diff --git a/automind/__init__.py b/automind/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/automind/sim/b2_inputs.py b/automind/sim/b2_inputs.py new file mode 100644 index 0000000..ccd2639 --- /dev/null +++ b/automind/sim/b2_inputs.py @@ -0,0 +1,494 @@ +#Brian2 functions related to additional inputs +import brian2 as b2 +import numpy as np +import matplotlib.pyplot as plt +from sklearn.svm import SVC +from sklearn.metrics import accuracy_score +from sklearn.model_selection import train_test_split, cross_val_score, GroupKFold +from sklearn.preprocessing import StandardScaler +from sklearn.svm import SVC +from sklearn.linear_model import LogisticRegression +from sklearn.discriminant_analysis import LinearDiscriminantAnalysis +from sklearn.metrics import ( + classification_report, + confusion_matrix, + roc_curve, + auc +) + +def DM_simple(all_param_dict, mu = 10**-9, sigma = 2.5*10**-11, buffer_period = 10, stim_time = 5): + """ + Inputs: + params_dict: dt and sim_time + + Optional: + mu: mean of stimulus + sigma: standard deviation of stimulus + buffer period (in seconds): How long before the stimulus is applied + stim_time (in seconds): How long the stimulus is applied + + Returns: + A Gaussian stimulus lower bounded at 0 + """ + param_dict_settings = all_param_dict["params_settings"] + + #Set random seeds + b2.seed(param_dict_settings["random_seed"]) + dt = param_dict_settings["dt"] + + #Setting stimulation and simulation length + stim_steps = int(stim_time * b2.second / dt) + one_second = int(b2.second / dt) + buffer_period = buffer_period * one_second + total_steps = int(param_dict_settings['sim_time'] / dt) + if stim_steps > total_steps: + raise ValueError("Stimulus steps exceed total simulation steps.") + stim = np.zeros(total_steps) + stim[buffer_period:buffer_period+stim_steps] = np.random.normal(mu, sigma, stim_steps) + stim = np.maximum(stim,0) #Lower bound signal at 0 - not necessary (?) + return stim + +#Optional stimuli, buffer period, +def test_stim(all_param_dict, buffer_period=10, vals=None, pulse_length=1): + ''' + Outputs a stimulus flickering between zero and provided input strengths. + + Inputs: + all_param_dict: Parameter dictionary containing simulation settings + + Optional: + buffer_period: Initial buffer period in seconds before stimulation starts (default: 10s) + vals: Array of stimulation amplitudes to use (default: np.linspace(10**-10, 2.5*10**-9, 25)) + pulse_length: Length of each pulse in seconds (default: 1s) + Default setting should give an input of around 60 seconds (including buffer) + Returns: + -------- + stim : numpy.ndarray + Array containing the full stimulus time series + ''' + + param_dict_settings = all_param_dict["params_settings"] + + # Set random seeds + b2.seed(param_dict_settings["random_seed"]) + dt = param_dict_settings["dt"] + + # Convert time values to steps + one_second = int(b2.second / dt) + pulse_length_steps = int(pulse_length * one_second) + buffer_period_steps = int(buffer_period * one_second) + total_steps = int(param_dict_settings['sim_time'] / dt) + + # Set default values if not provided + if vals is None: + vals = np.linspace(10**-10, 2.5*10**-9, 25) + + # Initialise stimulus array + stim = np.zeros(total_steps) + + # Calculate how many full cycles we can fit after the buffer period + available_steps = total_steps - buffer_period_steps + cycle_length = 2 * pulse_length_steps # ON then OFF + + if len(vals) > available_steps // cycle_length: + usable_vals = available_steps // cycle_length + print(f"Warning: Not all stimulus values can fit in the simulation time. " + f"Using {usable_vals} out of {len(vals)} values.") + + # Check if all values can fit within the simulation time + for i in range(min(len(vals), available_steps // cycle_length)): + start_idx = buffer_period_steps + i * cycle_length + end_idx = start_idx + pulse_length_steps + if end_idx <= total_steps: # Safety check + stim[start_idx:end_idx] = vals[i] + else: + break + return stim + +def cluster_specific_stim(all_param_dict, n_clusters, means=np.linspace(10**-10,10**-9,25), std = 2.5*10**-11 ): + """Generate cluster-specific stimuli and weights to be used in input_configs. + + Parameters + ---------- + all_param_dict: Network parameters + n_clusters: Number of clusters + + Returns + ------- + stim_list: List of stimulus arrays, one per cluster + weight_list: List of weight arrays, one per cluster + """ + + #Setting param dicts + param_dict_settings = all_param_dict["params_settings"] + param_dict_net = all_param_dict["params_net"] + N_exc = int(param_dict_net["N_pop"] * param_dict_net["exc_prop"]) + dt = param_dict_settings["dt"] + + #Stimulation length + stim_steps = int(5 * b2.second / dt) + one_second = int(b2.second / dt) + buffer_period = 10 * one_second #Allow network to stabilise first + total_steps = int(param_dict_settings['sim_time'] / dt) + if stim_steps > total_steps: + raise ValueError("Stimulus steps exceed total simulation steps.") + + #List of stimuli and weights + stim_list = [] + weight_list = [] + np.random.seed(88) + mean_random = np.random.permutation(means) + for i in range(n_clusters): + stim = np.zeros(total_steps) + stim[buffer_period:buffer_period+stim_steps] = np.random.normal(mean_random[i],std, stim_steps) + stim = np.maximum(stim,0) + weights = np.ones(N_exc) #Will be masked in get_input_configs(), just need array of ones + + stim_list.append(stim) + weight_list.append(weights) + + return stim_list, weight_list + +def get_input_configs(cluster_list,stim_list,weight_list): + ''' + Setting up stimuli and weights for each cluster. + ''' + if cluster_list is None: #Potentially not required as this function will not be called when there are no clusters + return [{ + 'clusters': None, # Indicates no clusters + 'stim': [stim_list[0]], + 'weights': np.ones(len(weight_list[0])) + }] + + #Returns dictionary of the variables to be used in the network operation + if not (len(cluster_list) == len(stim_list) == len(weight_list)): + raise ValueError("Must provide equal number of cluster list, stimuli, and weights") + + # Create configurations + input_configs = [] + for clusters, stim, weights in zip(cluster_list, stim_list, weight_list): + config = { + 'clusters': clusters, + 'stim': stim, + 'weights': weights + } + input_configs.append(config) + + return input_configs + +def create_input_operation(E_pop, input_configs, membership=None): + """ + Creates a network operation to handle inputs with flexible clustering. Not usable on outside of simulation. + + Parameters + ---------- + E_pop : brian2.NeuronGroup + The neuron population + input_configs : list of dict + Input configurations + membership : list of lists, optional + Cluster membership (if applicable) + """ + N_exc = len(E_pop) + if membership is not None and len(membership) != N_exc: + raise ValueError(f"Membership array length {len(membership)} doesn't match number of neurons {N_exc}") + # Pre-compute masks for each input + input_data = [] + # Validate input configurations + for config in input_configs: + if len(config['weights']) < N_exc: #Each set of weights should have the same length as N_exc + raise ValueError(f"Weight array length {len(config['weights'])} is smaller than number of neurons {N_exc}") + elif config['clusters'] is None: + mask = np.ones(N_exc) + else: + # If membership provided, use cluster-based masking + if membership is not None: # Not necessarry as this function will not be called if there are no clusters. But useful if you want to refactor the single input case + mask = np.zeros(N_exc) + #Provide stimulus to neuron if it is part of the cluster the input is directed to + for neuron_idx in range(N_exc): + if any(cluster in config['clusters'] for cluster in membership[neuron_idx]): #Each neuron has 2 clusters + mask[neuron_idx] = 1 + else: + # If no membership, all neurons in the neurongroup are activated (no mask) + mask = np.zeros(N_exc) + mask[config['clusters']] = 1 + + input_data.append({ + 'stimulus': np.array(config['stim']), + 'weights': np.array(config['weights'][:N_exc]), #Kind of redundant but potentially useful if you want to set random weights + 'mask': mask + }) + + #Input operation based on above parameters + @b2.network_operation(dt=b2.defaultclock.dt) + def input_operation(t): + idx = int(t / b2.defaultclock.dt) + total_input = np.zeros(N_exc) + #Adding the values of the input step by step, looping through the cluster specific stimuli + for input_set in input_data: + if idx < len(input_set['stimulus']): + total_input += (input_set['stimulus'][idx] * + input_set['weights'] * + input_set['mask']) + + E_pop.I_ext_ = total_input * b2.amp + + return input_operation + +class NeuralDecoder: + def __init__(self, method='logistic'): + """ + Initializes the neural decoder for population firing rates. + + Args: + method (str): Decoding method, either 'logistic' for logistic regression + or 'svm' for support vector machine. + """ + self.method = method + self.model = None + self.scaler = None + self.cv_accuracy = None + + def train(self, firing_rates, input_strengths, n_splits=5): + """ + Trains the decoder on multi-neuron firing rates. + + Args: + firing_rates (np.ndarray): Shape (n_trials, n_neurons, n_timepoints) or + (n_trials, n_neurons), population firing rates. + input_strengths (np.ndarray): Shape (n_trials,), the input strengths for each trial. + n_splits (int): Number of folds for cross-validation. + """ + + + # Check if firing_rates is 3D (including time dimension) or 2D (already averaged) + if firing_rates.ndim == 3: + # Already in format (n_trials, n_neurons, n_timepoints) + # Average across time to get (n_trials, n_neurons) + X = np.mean(firing_rates, axis=2) # Shape (n_trials, n_neurons) + elif firing_rates.ndim == 2: + # Already in format (n_trials, n_neurons) + X = firing_rates + else: + raise ValueError("firing_rates must be either 2D (n_trials, n_neurons) or 3D (n_trials, n_neurons, n_timepoints).") + + if len(input_strengths) != X.shape[0]: + raise ValueError("input_strengths must have length n_trials.") + + # Create labels + half_max = 0.5 * input_strengths.max() + y = (input_strengths > half_max).astype(int) + + # Cross-validated training + gkf = GroupKFold(n_splits=n_splits) + accuracies = [] + + for train_idx, test_idx in gkf.split(X, y, groups=np.arange(len(y))): + X_train, X_test = X[train_idx], X[test_idx] + y_train, y_test = y[train_idx], y[test_idx] + self.scaler = StandardScaler() + X_train_scaled = self.scaler.fit_transform(X_train) + X_test_scaled = self.scaler.transform(X_test) + if self.method == 'logistic': + self.model = LogisticRegression(penalty='l2', C=1.0, solver='liblinear') + elif self.method == 'svm': + self.model = SVC(kernel='rbf', C=1.0, probability=True) + else: + raise ValueError("Method must be either 'logistic' or 'svm'.") + + self.model.fit(X_train_scaled, y_train) + + # Evaluate on test set + y_pred = self.model.predict(X_test_scaled) + accuracies.append(accuracy_score(y_test, y_pred)) + + self.cv_accuracy = np.mean(accuracies) + print(f"Cross-validated accuracy using {self.method}: {self.cv_accuracy:.2f}") + + def predict(self, data, use_sliding_window=False, window_size=10): + """ + Applies the trained model to new data. + + Args: + data (np.ndarray): Shape (n_neurons, n_timepoints) for a single trial time series, + (n_trials, n_neurons) for pre-averaged data, or + (n_trials, n_neurons, n_timepoints) for multiple full trials. + use_sliding_window (bool): If True, uses a sliding window for prediction. + window_size (int): Size of the sliding window in timepoints. + + Returns: + predictions: Binary predictions. + confidence: Confidence scores (probability of class 1). + """ + import numpy as np + + if self.model is None or self.scaler is None: + raise ValueError("Model not trained. Call `train` first.") + + if use_sliding_window: + # Check if data is single trial time series + if data.ndim == 2 and data.shape[0] < data.shape[1]: # Likely (n_neurons, n_timepoints) + # For a single trial with sliding window + n_neurons, n_timepoints = data.shape + + if n_timepoints < window_size: + raise ValueError("Time series is shorter than the window size.") + + predictions = [] + confidence = [] + + for i in range(0, n_timepoints - window_size + 1): + window = data[:, i:i + window_size] + # Average across time points in the window for each neuron + features = np.mean(window, axis=1) # Shape (n_neurons,) + features_scaled = self.scaler.transform([features]) + pred = self.model.predict(features_scaled)[0] + + if self.method == 'logistic': + conf = self.model.predict_proba(features_scaled)[0][1] + else: # SVM + conf = self.model.predict_proba(features_scaled)[0][1] + + predictions.append(pred) + confidence.append(conf) + + return np.array(predictions), np.array(confidence) + else: + raise ValueError("For sliding window, data should be 2D with shape (n_neurons, n_timepoints).") + else: + # Handle different input shapes for non-sliding window predictions + if data.ndim == 3: # Shape (n_trials, n_neurons, n_timepoints) + # Average across time to get (n_trials, n_neurons) + X = np.mean(data, axis=2) + elif data.ndim == 2: + if data.shape[0] < data.shape[1]: # Likely (n_neurons, n_timepoints) for a single trial + # Average across time, reshape to (1, n_neurons) + X = np.mean(data, axis=1).reshape(1, -1) + else: # Shape (n_trials, n_neurons) + X = data + else: + raise ValueError("Unsupported data shape. Expected (n_neurons, n_timepoints), (n_trials, n_neurons), or (n_trials, n_neurons, n_timepoints).") + + # Predict + X_scaled = self.scaler.transform(X) + predictions = self.model.predict(X_scaled) + + if self.method == 'logistic': + confidence = self.model.predict_proba(X_scaled)[:, 1] + else: # SVM + confidence = self.model.predict_proba(X_scaled)[:, 1] + + return predictions, confidence + +def plot_multiple_decoders(decoder_class, data_sets, input_strengths, test_data, nrows=10, ncols=5, + method='logistic', window_size=10, figsize=(20, 20)): + + + import numpy as np + import matplotlib.pyplot as plt + + fig, axes = plt.subplots(nrows, ncols, figsize=figsize) + fig.suptitle(f"Neural Decoder Predictions for {len(data_sets)} Sets", fontsize=16) + + + axes = axes.ravel() + + for i in range(len(data_sets)): + # Initialize and train the decoder on single input + decoder = decoder_class(method=method) + decoder.train(data_sets[i], input_strengths) + + # Test on continuous pulse + predictions, confidence = decoder.predict(test_data[i], use_sliding_window=True, window_size=window_size) + + ax = axes[i] + ax.plot(confidence, label='Confidence', color='blue', alpha=0.7) + ax.plot(predictions, label='Prediction', color='red', linestyle='--', alpha=0.7) + if i == 0: + ax.legend() + ax.set_xlabel('Time (sliding window position)') + ax.set_ylabel('Prediction') + else: + ax.set_xticks([]) + ax.set_yticks([]) + + ax.set_title(f"Set {i+1}") + for i in range(len(data_sets), nrows * ncols): + axes[i].set_visible(False) + + plt.tight_layout(rect=[0, 0, 1, 0.96]) + plt.show() + +''' +#Not used anymore but you might find useful +def DM_cluster(all_param_dict, mu = 5*10**-9, sigma=2.5*10**-11): + """ + DM task mimicking Wang 2002 https://www.cell.com/neuron/fulltext/S0896-6273(02)01092-9 + + Returns: + - stimulus_A: Stimulus for population A + - stimulus_B: Stimulus for population B + """ + + #Dicts + param_dict_settings = all_param_dict["params_settings"] + param_dict_net = all_param_dict["params_net"] + + #Set random seeds + b2.seed(param_dict_settings["random_seed"]) + b2.defaultclock.dt = param_dict_settings["dt"] + + #Setting stimulation and simulation length + stim_steps = int(5 * b2.second / b2.defaultclock.dt) #Potentially change stim length to user added input + one_second = int(b2.second / b2.defaultclock.dt) + buffer_period = 20 * one_second #Allow network to stabilise first + total_steps = int(param_dict_settings['sim_time']/b2.defaultclock.dt) + if stim_steps > total_steps: + raise ValueError("Stimulus steps exceed total simulation steps.") + + #Check number of clusters in the network + if ( + ("n_clusters" not in param_dict_net.keys()) + or (param_dict_net["n_clusters"] < 2) + ): + stim_list = np.random.normal(mu,sigma,stim_steps) #One stimulus for everything + else: + stim_list = [] + means = np.linspace(10**-10,2.5*10**-9,25) #Meaningful input probably lies within 10^-10 to 10^-9 + mean_to_be_used = np.random.choice(means,size=int(param_dict_net["n_clusters"]),replace=False) + for i in range(int(param_dict_net["n_clusters"])): + stim = np.zeros(total_steps) + stim[buffer_period:buffer_period+stim_steps] = np.random.normal(mean_to_be_used[i],0.01 * mean_to_be_used[i], stim_steps) + stim = np.maximum(stim,0) + stim_list.append(stim) + + return stim_list + +def input_scaling(all_param_dict,scaling): + param_dict_settings = all_param_dict["params_settings"] + param_dict_net = all_param_dict["params_net"] + #Set random seeds + b2.seed(param_dict_settings["random_seed"]) + b2.defaultclock.dt = param_dict_settings["dt"] + + #N_neurons + n_neurons, exc_prop = param_dict_net["N_pop"], param_dict_net["exc_prop"] + N_exc = int(n_neurons * exc_prop) + + #Type of scaling + if scaling == 'all': + input_scaling = np.ones(n_neurons).astype(int) + elif scaling == 'rand': + input_scaling = np.random.rand(n_neurons) + elif scaling == 'subset': + input_scaling = np.random.randint(0,2,n_neurons) + elif scaling == 'e_only': + input_scaling = np.zeros(n_neurons).astype(int) + input_scaling[:N_exc] = 1 + elif scaling == 'i_only': + input_scaling = np.zeros(n_neurons).astype(int) + input_scaling[N_exc:] = 1 + else: + raise ValueError(f"Invalid input for 'scaling': {scaling}. Choose from 'all', 'rand', 'subset', 'e_only' or 'i_only'.") + return input_scaling +''' \ No newline at end of file diff --git a/automind/sim/b2_models.py b/automind/sim/b2_models.py index 8c34a77..eab3eb4 100644 --- a/automind/sim/b2_models.py +++ b/automind/sim/b2_models.py @@ -1,6 +1,7 @@ ### Brian2 models for network construction. import brian2 as b2 import numpy as np +from automind.sim import b2_inputs def adaptive_exp_net(all_param_dict): @@ -64,14 +65,14 @@ def adaptive_exp_net(all_param_dict): ) ### TO DO: also randomly initialize w to either randint(?)*b or randn*(v-v_rest)*a - - poisson_input_E = b2.PoissonInput( + ''' poisson_input_E = b2.PoissonInput( target=E_pop, target_var="ge", N=param_dict_neuron_E["N_poisson"], rate=param_dict_neuron_E["poisson_rate"], weight=param_dict_neuron_E["Q_poisson"], - ) + )''' + if has_inh: # make adlif if delta_t is 0, otherwise adex @@ -268,12 +269,21 @@ def make_clustered_network( return membership, shared_membership, conn_in, conn_out -def adaptive_exp_net_clustered(all_param_dict): - """Adaptive exponential integrate-and-fire network with clustered connections.""" +#Modified function incorporating inputs to specific clusters +def adaptive_exp_net_clustered_cog(all_param_dict, mode='default', custom_input=None, stim_cluster=None, custom_cluster_input=None): + ''' + Adaptive exponential integrate-and-fire network with clustered connections. + + 3 modes + - Default mode - no input + - Single mode - Single input -> User can define any input sequence. DM_simple is used when no inputs are provided + - Cluster mode - Each cluster gets different input, can be defined by user. DM_simple with different mean is used for each cluster when no inputs are provided. + - Can also select number of clusters to stimulate + ''' + # separate parameter dictionaries param_dict_net = all_param_dict["params_net"] param_dict_settings = all_param_dict["params_settings"] - # set random seeds b2.seed(param_dict_settings["random_seed"]) np.random.seed(param_dict_settings["random_seed"]) @@ -287,11 +297,16 @@ def adaptive_exp_net_clustered(all_param_dict): #### NETWORK CONSTRUCTION ############ ###################################### + + ### get cell counts + N_pop, exc_prop = param_dict_net["N_pop"], param_dict_net["exc_prop"] + N_exc = int(N_pop * exc_prop) + N_inh = N_pop - N_exc + ### define neuron equation adex_coba_eq = """dv/dt = (-g_L * (v - v_rest) + g_L * delta_T * exp((v - v_thresh)/delta_T) - w + I)/C : volt (unless refractory)""" - adlif_coba_eq = ( - """dv/dt = (-g_L * (v - v_rest) - w + I)/C : volt (unless refractory)""" - ) + + adlif_coba_eq = """dv/dt = (-g_L * (v - v_rest) - w + I)/C : volt (unless refractory)""" network_eqs = """ dw/dt = (-w + a * (v - v_rest))/tau_w : amp @@ -299,13 +314,10 @@ def adaptive_exp_net_clustered(all_param_dict): dgi/dt = -gi / tau_gi : siemens Ie = ge * (E_ge - v): amp Ii = gi * (E_gi - v): amp - I = I_bias + Ie + Ii : amp + I_ext: amp + I = I_bias + Ie + Ii + I_ext: amp """ - ### get cell counts - N_pop, exc_prop = param_dict_net["N_pop"], param_dict_net["exc_prop"] - N_exc, N_inh = int(N_pop * exc_prop), int(N_pop * (1 - exc_prop)) - ### make neuron populations, set initial values and connect poisson inputs ### # make adlif if delta_t is 0, otherwise adex neuron_eq = ( @@ -422,6 +434,7 @@ def adaptive_exp_net_clustered(all_param_dict): p_out, param_dict_net["order_clusters"], ) + param_dict_net["membership"] = membership # scale synaptic weight Q_ge_out = param_dict_neuron_E["Q_ge"] @@ -491,6 +504,93 @@ def adaptive_exp_net_clustered(all_param_dict): ) syn_i2i.connect("i!=j", p=param_dict_net["p_i2i"]) + ### Handle different input modes ### + if mode == 'default': #No input + stim_time_values = b2_inputs.DM_simple(all_param_dict,0,0) #Just change this to an input (pass in an stim array) + dt = param_dict_settings["dt"] + stim_timed_array = b2.TimedArray(stim_time_values * b2.amp, dt=dt) + + # Define network operation to update I_ext + @b2.network_operation(dt=dt) + def update_test_input(t): + E_pop.I_ext = stim_timed_array(t) + + elif mode == 'single': + # Check if custom input is provided in the parameter dictionary + custom_input = all_param_dict.get("custom_input", None) + if custom_input is not None: + stim_time_values = custom_input + else: + # Use default DM_simple if no custom input is provided + stim_time_values = b2_inputs.DM_simple(all_param_dict) + + dt = param_dict_settings["dt"] + stim_timed_array = b2.TimedArray(stim_time_values * b2.amp, dt=dt) + + # Define network operation to update I_ext + @b2.network_operation(dt=dt) + def update_test_input(t): + E_pop.I_ext = stim_timed_array(t) + + elif mode == 'cluster': + # Determine if network has clusters + has_clusters = ( + "n_clusters" in param_dict_net.keys() + and param_dict_net["n_clusters"] >= 2 + and param_dict_net["R_pe2e"] != 1 + ) + + if has_clusters: + n_clusters_original = int(param_dict_net["n_clusters"]) + stimulated_clusters_count = n_clusters_original + + #Check if user defined number of clusters to stimulate + if stim_cluster is not None: + stimulated_clusters_count = stim_cluster + if stim_cluster > n_clusters_original: + stimulated_clusters_count = n_clusters_original + print(f"No. of clusters picked ({stim_cluster}) exceeds actual no. of clusters. Stimulating all {n_clusters_original} clusters instead.") + #Select number of clusters + selected_clusters = np.random.choice( + n_clusters_original, + stimulated_clusters_count, + replace=False + ) + cluster_lists = [[c] for c in selected_clusters] + + # Generate cluster-specific inputs for selected clusters - see b2_inputs + if custom_cluster_input is not None: + stim_list = custom_cluster_input + _, weight_list = b2_inputs.cluster_specific_stim( + all_param_dict, + n_clusters=stimulated_clusters_count, + ) + else: + stim_list, weight_list = b2_inputs.cluster_specific_stim( + all_param_dict, + n_clusters=stimulated_clusters_count, + ) + + # Create input configurations + input_configs = b2_inputs.get_input_configs( + cluster_lists, + stim_list, + weight_list, + ) + input_op = b2_inputs.create_input_operation(E_pop, input_configs, membership) + param_dict_net['input'] = stim_list + else: + # Fallback to test mode if network doesn't have clusters initially + print("Network does not have clusters. All neurons will receive the same DM_simple input ") + stim_time_values = b2_inputs.test_stim(all_param_dict) + dt = param_dict_settings["dt"] + stim_timed_array = b2.TimedArray(stim_time_values * b2.amp, dt=dt) + + @b2.network_operation(dt=dt) + def update_cluster_fallback_input(t): + E_pop.I_ext = stim_timed_array(t) + param_dict_net['input'] = stim_timed_array + ### define monitors ### rate_monitors, spike_monitors, trace_monitors = [], [], [] rec_defs = param_dict_settings["record_defs"] @@ -510,12 +610,12 @@ def adaptive_exp_net_clustered(all_param_dict): # and later drop randomly before saving, otherwise # recording only from first n neurons, which heavily overlap # with those stimulated, and the first few clusters - rec_idx = np.arange(N_exc) + rec_idx = np.arange(N_exc) else: rec_idx = ( - np.arange(rec_defs[pop_name]["spikes"]) + np.arange(rec_defs[pop_name]["spikes"]) if type(rec_defs[pop_name]["spikes"]) is int - else rec_defs[pop_name]["spikes"] + else rec_defs[pop_name]["spikes"] #Change param_settings.record_Defs to 2000 ) spike_monitors.append( b2.SpikeMonitor(pop[rec_idx], name=pop_name + "_spikes") diff --git a/automind/utils/data_utils.py b/automind/utils/data_utils.py index 12d1b4c..0876b25 100644 --- a/automind/utils/data_utils.py +++ b/automind/utils/data_utils.py @@ -17,6 +17,7 @@ def _filter_spikes_random(spike_trains, n_to_save): """Filter a subset of spike trains randomly for saving.""" + np.random.seed(42) record_subset = np.sort( np.random.choice(len(spike_trains), n_to_save, replace=False) ) @@ -33,13 +34,14 @@ def collect_spikes(net_collect, params_dict): sm.name.split("_")[0] ]["spikes"] n_to_save = pop_save_def if type(pop_save_def) == int else len(pop_save_def) + #n_to_save = len(spike_trains) if n_to_save == len(spike_trains): # recorded and to-be saved is the same length, go on a per usual spike_dict[sm.name] = b2_interface._deunitize_spiketimes(spike_trains) else: # recorded more than necessary, subselect for saving spike_dict[sm.name] = b2_interface._deunitize_spiketimes( - _filter_spikes_random(spike_trains, n_to_save) + _filter_spikes_random(spike_trains, n_to_save) # THIS IS WHERE THE NEURONS ARE RANDOMLY DROPPED BEFORE SAVING (AND PLOTTING??) ) return spike_dict @@ -674,3 +676,31 @@ def load_df_posteriors(path_dict): path_dict["root_path"] + path_dict["params_dict_analysis_updated"] ) return df_posterior_sims, posterior, params_dict_default + +def sort_neurons(membership, sorting_method="cluster_identity"): + """ + Sort neurons based on the specified method. + + Parameters: + membership (list/array of 2D arrays): Membership arrays for each simulation. + sorting_method (str): "cluster_identity" or "n_clusters". + + Returns: + sorted_indices (list of arrays): Sorted indices for each simulation. + """ + sorted_indices = [] + #Sort by whether neurons are in one cluster or two clusters + + if sorting_method == "cluster_identity": + # Sort by the first cluster identity + sorted_idx = np.argsort(membership[:, 0]) + sorted_indices.append(sorted_idx) + elif sorting_method == "n_clusters": + #Neurons in one cluster have the same values in both columns + single = np.where(membership[:,0] == membership[:,1]) + double = np.where(membership[:,0] != membership[:,1]) + sorted_indices.append(single) + sorted_indices.append(double) + else: + raise ValueError("Invalid sorting_method. Use 'cluster_identity' or 'n_clusters'.") + return sorted_indices \ No newline at end of file diff --git a/automind/utils/plot_utils.py b/automind/utils/plot_utils.py index 565c18c..ebfdaaa 100644 --- a/automind/utils/plot_utils.py +++ b/automind/utils/plot_utils.py @@ -327,7 +327,6 @@ def _plot_raster_pretty( ax.set_ylabel("Raster", fontsize=fontsize) return ax - def _plot_rates_pretty( rates, XL, @@ -584,3 +583,126 @@ def plot_corr_pv(pvals, ax, alpha_level=0.05, fmt="w*", ms=0.5): for j in range(pvals.shape[0]): if pvals[i, j] < alpha_level: ax.plot(j, i, fmt, ms=ms, alpha=1) + + +#Just use the default plotting function with the sorted spikes +''' +def plot_raster( + spikes, + membership, + XL, + plotting_method="cluster_identity", + every_other=1, + ax=None, + fontsize=14, + plot_inh=False, + E_colors=None, + I_color="gray", + single_cluster_style="|", + double_cluster_style="x", + mew=0.5, + ms=1, + **plot_kwargs, +): + """ + Plot raster plot with neurons sorted by cluster identity or number of clusters. + + Parameters: + spikes (dict): Dictionary containing 'exc_spikes' and 'inh_spikes'. + membership: Array/list of 2D membership arrays (from params_net['membership']). + XL (list): X-axis limits. + plotting_method (str): "cluster_identity" or "n_clusters". + every_other (int): Plot every nth spike. + ax (matplotlib axis): Axis to plot on. + fontsize (int): Font size for labels. + plot_inh (bool): Whether to plot inhibitory spikes. + E_colors (list): Colors for excitatory clusters. + I_color (str): Color for inhibitory spikes. + single_cluster_style (str): Marker style for single-cluster neurons. + double_cluster_style (str): Marker style for two-cluster neurons. + mew (float): Marker edge width. + ms (float): Marker size. + """ + if ax is None: + ax = plt.axes() + + exc_spikes = spikes["exc_spikes"] + inh_spikes = spikes.get("inh_spikes", {}) + + if plotting_method == "cluster_identity": + # Sort by cluster identity + sorted_indices = data_utils.sort_neurons(membership, sorting_method='cluster_identity') + sorted_indices_list = sorted_indices[0].tolist() # Convert to list of Python integers + sorted_exc_spikes = {i: exc_spikes[idx] for i, idx in enumerate(sorted_indices_list)} + #exc_spikes_to_plot = sorted_exc_spikes.values() + elif plotting_method == "n_clusters": + # Sort by number of clusters + sorted_indices = data_utils.sort_neurons(membership, sorting_method='n_clusters') + sorted_exc_spikes_single = {i: exc_spikes[idx] for i, idx in enumerate(sorted_indices[0][0])} + sorted_exc_spikes_double = {i: exc_spikes[idx] for i, idx in enumerate(sorted_indices[1][0])} + #exc_spikes_to_plot.append(sorted_exc_spikes_single) + #exc_spikes_to_plot.append(sorted_exc_spikes_double) + else: + raise ValueError("Invalid plotting_method. Use 'cluster_identity' or 'n_clusters'.") + + # Plot excitatory spikes, single cluster in blue and double cluster in red respectively + [ + ( + ax.plot( + v[::every_other], + i_v * np.ones_like(v[::every_other]), + single_cluster_style, + color='blue', + alpha=1, + ms=ms, + mew=mew, + ) + if len(v) > 0 + else None + ) + for i_v, (t,v) in enumerate(sorted_exc_spikes_single.items()) + ] + [ + ( + ax.plot( + v[::every_other], + (i_v+ len(sorted_indices[0][0])) * np.ones_like(v[::every_other]), + single_cluster_style, + color='red', + alpha=1, + ms=ms, + mew=mew, + ) + if len(v) > 0 + else None + ) + for i_v, (t,v) in enumerate(sorted_exc_spikes_double.items()) + ] + + # Plot inhibitory spikes + if plot_inh: + [ + ( + ax.plot( + v[::every_other], + (i_v + len(sorted_indices[0][0]) + len(sorted_indices[1][0])) * np.ones_like(v[::every_other]), + "|", + color=I_color, + alpha=1, + ms=ms, + mew=mew, + ) + if len(v) > 0 + else None + ) + for i_v, v in enumerate(inh_spikes.values()) + ] + + ax.set_xticks([]) + ax.set_yticks([]) + ax.spines.left.set_visible(False) + ax.spines.bottom.set_visible(False) + ax.set_xlim(XL) + ax.set_ylabel("Raster", fontsize=fontsize) + return ax +''' diff --git a/datasets/README.md b/datasets/README.md deleted file mode 100644 index 8610983..0000000 --- a/datasets/README.md +++ /dev/null @@ -1,40 +0,0 @@ -# Data Download -### Summary data and trained DGMs - -All files can be downloaded as a single file [from figshare](https://figshare.com/s/3f1467f8fb0f328aed16). Place the `.zip` file in this directory (`./datasets/`) and unzip in place preserves the correct relative paths for code demos, model training and inference, etc. - -Alternatively, files can be individually downloaded and manually organized in the directory structure as follows: - ---- -`./training_prior_samples/` -- `training.zip`: 1-million parameter configurations and summary features from model simulations used to train deep generative models. -- `heldout.zip`: additional network simulations not used for DGM training, a subset of which was used as synthetic observations. - ---- -`./discovered_posterior_samples/` -- `organoids.zip`: discovered model configurations consistent with human brain organoid network burst across development. See ./organoid_predictives.png. -- `mouse-vis.zip`: discovered model configurations consistent with population firing rate PSD of Neuropixels recordings from mouse visual areas. See ./allen_predicitves_all.png. -- `mouse-hc.zip`: discovered model configurations consistent with population firing rate PSD of Neuropixels recordings from mouse hippocampal areas. See ./allen_predicitves_all.png. -- `synthetic.zip`: discovered model configurations consistent with population firing rate PSD of synthetic observations, i.e., held-out network simulations. See ./synthetic.png. -- NOTE: all `.zip` files also contain the prior distribution, posterior density estimator, and config files necessary for running the simulations and analyses. - ---- -`./dgms/` -- `burst_posterior.pickle`: trained conditional density estimator that approximates the posterior distribution conditioned on network burst summary features. -- `psd_posterior.pickle`: trained conditional density estimator that approximates the posterior distribution. conditioned on network firing rate power spectral densities. - ---- -`./observations/` -- `allenvc_summary.csv`: population firing rate PSD of Neuropixels recordings. -- `synthetic_summary.csv`: various summary features of synthetic observations (i.e., held-out network simulations). -- `organoid_summary.csv`: population firing burst statistics of organoid multi-electrode array recordings. -- `example_raw_data.npz`: raw spike train data from an example organoid recording. - ---- - -Example discovered model configurations and simulations, overlaid with target observation data (first row of each subplot in organoid panels, black lines in mouse and synthetic PSD panels): -![](../assets/img/predictives.png) - ---- -### Raw simulation data -Coming soon. \ No newline at end of file diff --git a/notebooks/IO_test.ipynb b/notebooks/IO_test.ipynb new file mode 100644 index 0000000..5da3450 --- /dev/null +++ b/notebooks/IO_test.ipynb @@ -0,0 +1,841 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Examining input-ouput relationship of invariant networks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "mpl_rc = \"../assets/matplotlibrc\"\n", + "plt.style.use(mpl_rc)\n", + "\n", + "import numpy as np\n", + "import os\n", + "import pickle\n", + "import pandas as pd\n", + "import brian2 as b2\n", + "from torch import Tensor\n", + "\n", + "from automind.sim import b2_interface, runners, b2_models, b2_inputs\n", + "\n", + "from automind.inference import inferer\n", + "from automind.utils import data_utils, analysis_utils, dist_utils, plot_utils\n", + "from brian2 import *\n", + "import json" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[WinError 3] The system cannot find the path specified: '../datasets/discovered_posterior_samples/synthetic/'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[2], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m data_dirs \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m../datasets/discovered_posterior_samples/synthetic/\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m----> 2\u001b[0m path_dict \u001b[38;5;241m=\u001b[39m data_utils\u001b[38;5;241m.\u001b[39mextract_data_files(\n\u001b[0;32m 3\u001b[0m data_dirs,\n\u001b[0;32m 4\u001b[0m [\n\u001b[0;32m 5\u001b[0m \n\u001b[0;32m 6\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mposterior.pickle\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 7\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mparams_dict_analysis_updated.pickle\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 8\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msummary_data_merged.csv\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m 9\u001b[0m ],\n\u001b[0;32m 10\u001b[0m )\n\u001b[0;32m 11\u001b[0m df_xos, posterior, params_dict \u001b[38;5;241m=\u001b[39m data_utils\u001b[38;5;241m.\u001b[39mload_df_posteriors(path_dict)\n\u001b[0;32m 12\u001b[0m _, _, _, _, cols_psd \u001b[38;5;241m=\u001b[39m data_utils\u001b[38;5;241m.\u001b[39mseparate_feature_columns(df_xos)\n", + "File \u001b[1;32mc:\\users\\brian.laptop-8bs4kr2p\\automind\\automind\\utils\\data_utils.py:455\u001b[0m, in \u001b[0;36mextract_data_files\u001b[1;34m(data_folder, file_type_list, verbose)\u001b[0m\n\u001b[0;32m 453\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mextract_data_files\u001b[39m(data_folder, file_type_list, verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[0;32m 454\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Extract data files from a folder based on file types.\"\"\"\u001b[39;00m\n\u001b[1;32m--> 455\u001b[0m run_files \u001b[38;5;241m=\u001b[39m listdir(data_folder)\n\u001b[0;32m 456\u001b[0m data_file_dict \u001b[38;5;241m=\u001b[39m {}\n\u001b[0;32m 458\u001b[0m data_file_dict[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mroot_path\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m data_folder\n", + "\u001b[1;31mFileNotFoundError\u001b[0m: [WinError 3] The system cannot find the path specified: '../datasets/discovered_posterior_samples/synthetic/'" + ] + } + ], + "source": [ + "data_dirs = \"../datasets/discovered_posterior_samples/synthetic/\"\n", + "path_dict = data_utils.extract_data_files(\n", + " data_dirs,\n", + " [\n", + " \n", + " \"posterior.pickle\",\n", + " \"params_dict_analysis_updated.pickle\",\n", + " \"summary_data_merged.csv\",\n", + " ],\n", + ")\n", + "df_xos, posterior, params_dict = data_utils.load_df_posteriors(path_dict)\n", + "_, _, _, _, cols_psd = data_utils.separate_feature_columns(df_xos)\n", + "print(posterior)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'posterior' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[3], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m f_bounds \u001b[38;5;241m=\u001b[39m posterior\u001b[38;5;241m.\u001b[39mx_bounds_and_transforms[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfreq_bounds\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDensity estimator was trained on PSD between \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mf_bounds\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m Hz.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 4\u001b[0m \u001b[38;5;66;03m# Extract the frequency bounds and trim correspondingly\u001b[39;00m\n", + "\u001b[1;31mNameError\u001b[0m: name 'posterior' is not defined" + ] + } + ], + "source": [ + "f_bounds = posterior.x_bounds_and_transforms[\"freq_bounds\"]\n", + "print(f\"Density estimator was trained on PSD between {f_bounds} Hz.\")\n", + "\n", + "# Extract the frequency bounds and trim correspondingly\n", + "freqs = data_utils.decode_df_float_axis(cols_psd)\n", + "f_idx = (freqs >= f_bounds[0]) & (freqs <= f_bounds[1])\n", + "freqs, cols_features = freqs[f_idx], np.array(cols_psd)[f_idx]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 sims dropped due to early stopping.\n", + "0 sims dropped due to manual criteria.\n", + "0 sims dropped due to power threshold discard.\n", + "0 samples discarded in total.\n", + "Target observation has shape torch.Size([1, 990])\n" + ] + } + ], + "source": [ + "idx_xo = 10030 #Replace with any from the list of observation indices\n", + "df_xos_preproc, _, _, _ = dist_utils.preproc_dataframe_psd(\n", + " df_xos.loc[[idx_xo]],\n", + " posterior.x_bounds_and_transforms,\n", + " drop_nans=False,\n", + " replace_infs=True,\n", + ")\n", + "xo = df_xos_preproc.loc[idx_xo][cols_features].values\n", + "xo_tensor = posterior.x_standardizing_func(Tensor(xo[None, :]))\n", + "print(f\"Target observation has shape {xo_tensor.shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Selecting existing network parameters " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "observation_indices = df_xos[df_xos['inference.type']=='gt_resim'].index.tolist()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABdwAAAXcCAYAAAA4NUxkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAuIwAALiMBeKU/dgABAABJREFUeJzs3Xd4jff7B/D3OVkkESOSoMSsXTTUiBWj1lfVlipKjNrVqlFalNaqqq+oUqtq16iqomqP2HurGQRJCFnIOOf3h1/ON884M+ec55yc9+u6el2ez7NubXPynPu5P/dHpdVqtSCbiouLQ2BgoGAsNjYWAQEBCkVERI6OnxtERLbBz1ciModKpZId5+cGERnC5w0i16ZWOgAiIiIiIiIiIiIiotyACXciIiIiIiIiGcnJybh9+7bSYRAREZETYcKdiIiIiIiIiIiIiMgK3JUOgIiIiIiIiMgR+fr6Kh0CERERORlWuBMRERERERERERERWQET7kREREREREQy2MOdiIiIzMWWMkREREREREQyfHx8kJqaqnQYRERE5ERY4U5ERERELiElJQUpKSlKh0FEToSfG0RERGQuVriTU4mJiUFkZCQSEhLQu3dv1K1bV+mQiIiIyEnoW/zwk08+Qf78+eHp6QkvLy/kyZNH92dj//j4+CBfvnzw8/NDvnz5kDdvXqhUKjv/zYjIVrhoKhEREZmLCXdyKl9//TVOnToFALh69So2bdqEQoUKKRwVERERObNLly7Bw8PDKtdyc3NDvnz5dP9kJeKz/lygQAEEBgaicOHCCAgIQEBAAPLkyWOVexMRERERkfKYcCenERsbq0u2A68XMNq3bx86duyoYFRERETkLB4/foz4+HhUqVLFZvfIzMzEs2fP8OzZM5PP8fX1FSThAwMDERwcjJIlS6JUqVLw8/OzWbxEZFhycjLi4uJQunRppUMhIiIiJ8GEu42x55/1nDhxQjLGhDsRERGZKigoSOkQZCUnJyM5ORm3bt2S3V+oUCGUKlVK90/p0qVRpUoVJuKJ7ICLphIREZG5mHC3Mfb8s55jx45Jxk6cOIHU1FR4e3srEBERERHlBiNGjEDevHnx6tUrg/+kpaXh5cuXgj9nJcu1Wq3N4nv69CmePn2K06dPC8ZLlSqFatWq4a233kK1atVQunRpqNVqm8VBRERERETGMeFOTkGr1eL48eOS8fT0dERFRaF58+YKREVERETORF9LmbZt2yIgIMDi62o0GqSkpCApKQlJSUlITEyU/fPz58/x9OlTxMXFIS4uLsdVs3fu3MGdO3ewZcsWAK8rcUNCQlC/fn3Ur18fRYsWzdH1iUj/jOWEhIQcfW4QERFR7sWEu42x55913L59G/Hx8bL79u/fz4Q7ERERGWWrljJqtVq3MKo5UlNTdcn32NhYxMfHIy4uDg8ePMDdu3dx//59ZGZmmny9lJQUHDx4EAcPHgQAlClTBg0aNECDBg1Qo0YNVr8TWUDfjOUffvgB8+fPh0qlsnNERERE5OiYcLcx9vyzDrnq9iyHDh1CRkYG3N35vzMRERE5D29vb5QsWRIlS5aU3Z+RkYEHDx7oKtnv3r2L27dv49q1a0hLSzN6/Vu3buHWrVv49ddfERgYiHbt2uH9999n5TuRFURFRWHr1q147733lA6FiIiIHAwzlOQUDCXck5KScObMGbzzzjt2jIiIiIicjbPNPHR3d9cl5Bs3bqwbT09Px7///otz587hwoULOH/+PB49emTwWrGxsVi8eDGWLFmCOnXqoEOHDmjcuDELFoiMMPS5MWvWLNSqVYsvsYiIiEiAT9jk8DIyMnDy5EnBmFqthkaj0W3v37+fCXciIiJyCR4eHqhcuTIqV66MDz74AAAQFxeHkydPIioqCocPH0ZiYqLsuVqtFkePHsXRo0dRrFgx9OvXD//5z3/g5uZmz78CkdMwNGM5JSUFX3/9NebPn8+WTURERKTDpwJyeJcvX5Y85Hbu3FmwvX//fmi1WnuGRURERE7G19fXaarbzRUQEIDWrVtjypQp2LVrF5YuXYq+ffuifPnyes+JiYnB5MmT0blzZ2zbtk1QzEBEpjl58iTWrVundBhE5ED0LbZMRK6DCXdyeMeOHRNslytXDh06dBCMPXz4EI8fP7ZnWEREREQOSa1Wo1q1ahg0aBBWr16NVatWoWvXrnoXf7x37x4mTJiA8PBwyaxCIjIuMjISd+7cUToMInIQufkFPxGZhgl3cnji/u21a9dGuXLlJFOfnz17ZseoiIiIyNkkJyfj9u3bSodhdxUqVMDo0aOxY8cOTJ48GVWrVpU97tatWxg4cCAmT56M58+f2zlKIueVlpaGCRMmICMjQ+lQiIiIyAEw4Y7XVT0dO3ZEgQIF4O/vjwEDBujte0n2lZaWhvPnzwvG6tSpA5VKhXz58gnGk5KS7BkaERERORkfHx/4+PgoHYZi8uTJgzZt2mDZsmWYO3cuKleuLHvcli1b0KlTJ2zfvp0t+4j06Nixo2D78uXLWLZsmULREJEjcdUX/ET0Py6fcNdqtXjvvfeQlpaGw4cPY/v27Thy5AgGDRqkdGgEID4+HpmZmYKxt956CwAk06KZcCciIiJD2FP1NZVKhdDQUCxfvhyzZ8+W7fP+7NkzfPXVVxg/frzeBSOJXFnfvn1RqlQpwdjixYtx5coVZQIiIofh6i/4iYgJd8TFxaFixYpYuHAhqlSpgtq1a6N///7Yu3ev0qERpEl0tVqtq2wXV7gnJyfbLS4iIiJyPuypKqRSqdCoUSOsXLkSo0ePhre3t+SYnTt3omfPnrh586YCERIpT9+LOi8vL0yePBlq9f++UmdmZmLChAl49eqVPUMkIiIiB+PyCffAwECsXbsWb7zxBgDgxo0bWLFiBZo2bapwZARIE+6+vr5QqVQAmHAnIiIisga1Wo2uXbtiw4YNaNKkiWT/3bt30atXL2zbtk2B6IiUZehFXeXKldG3b1/B2O3btzF//nx7hEZEREQOyuUT7tk1bdoUb775JuLj4zFjxgylwyFIE+7Zk+xsKUNERETmYE9VwwIDA/Hdd99h5syZksKGV69eYcKECViyZAn7uhNl07dvX1SsWFEwtnr1apw+fVqhiIiIiEhpuT7hfuPGDahUKtl/wsLCBMfOnj0bhw8fRokSJdC8eXOkpaUpEzTpiJPofn5+uj9z0VQiIiIyB3uqmqZp06ZYtWqVJIkIAD/99BN++OEHaDQaBSIjsj9jL+rc3d0xefJkeHp66sa0Wi0mTZrENSOIiIhcVK5PuJcsWRJXrlyR/efXX38VHFujRg2EhoZi/fr1uH79OrZv365Q1JTFUIU7E+5ERERkDi6aarpixYph6dKl6NSpk2Tf6tWrMWXKFMnC9kS5kSkv6sqUKYMhQ4YIxmJiYjB79mxbhkZEREQOyl3pAGzNw8NDtjonS2xsLPbu3Ytu3brpxoKCguDv74+4uDh7hEgGyPVwz8KEOxEREZlD3I6ODPP09MQXX3yBsmXLYubMmYJ9f/75J9LS0jBlyhTBopFEruqDDz7A/v37Ba1k/vjjDzRu3BiNGjVSMDIiIiKyN5d/Or537x7Cw8Nx7tw53didO3cQFxeHqlWrKhgZAea1lOGiqURERETW17VrV9nE+t9//41Zs2axpzsRXi8+PGnSJHh7ewvGv/nmGzx79kyZoIiIiEgRLp9wDwkJQaNGjdCvXz+cPn0ax44dQ9euXdGqVSvUrVtX6fBcHhdNJfqfx48fKx0CEZFT46KplmvdujW+//57QZ9qAPjtt9+waNEihaIicizFihXDyJEjBWNPnz7F1KlT+WKKyIWwhR0RSRLuO3bsQPPmzZE/f34UKFAA9erVw/r16+0eWHh4OIoXL27wmGXLliEkJAS+vr4IDAxEjx49cPfuXbPuo1KpsHHjRlSsWBEtWrRAq1atULVqVaxduzYn4ZOVsIc70f9MnjyZizkTEeUAF03NmYYNG2L27Nlwdxd2pfz555/x22+/KRQVkWNp164dGjZsKBjbs2cPduzYoVBERGRvvr6+KF26tNJhEJGCBAn3uXPnonXr1rhw4QJ69uyJ7t274+bNm+jatSu+//57uwU1depUrFu3zuAxY8eORUREBF69eoUhQ4agWbNmWLt2LWrVqmV25VLhwoWxYsUKxMfHIyEhAUuXLkX+/Plz8lfQ4ZvNnDHUw11c4c6WMpTbXbt2DXPmzFE6DCIicmF169bF5MmToVKpBOOzZs3C+fPnFYqKyHGoVCp8+eWXku+TM2fORGxsrEJRERERkT3pEu6XLl3C559/jsqVK+PChQuYN28e5s+fj4sXLyIoKAjjxo2zeQXxy5cvMXDgQIwfP97gcWfPnsWMGTPQoEEDnDlzBjNmzMCaNWuwYcMGxMfH45NPPrFpnObgm82cSUxMFGwb6uGekpICjUZjl7iIlPLbb7/h77//VjoMIiJyYS1atMDYsWMFYxqNBmPHjmWvaiIA/v7+GDdunGAsKSkJX3/9NVvLELkAtrAjIl3Cfe7cuUhPT8fChQsRGBioOyAwMBBTp05F7969DfYPXrVqFU6dOiUZv3//PiIjI40G8ueff6JSpUpYuHAh2rRpY/DYH3/8EQAwceJEQR/J9u3bIywsDFu3bsWDBw+M3pMcn7hq3VBLGa1Wy9kE5BK++eYbPsAREZGiOnXqhIiICMFYbGwsJkyYwAIIIgDNmjVD69atBWPHjh3Dhg0bFIqIiOyFLeyISJdw37p1K4oVK4YGDRpIDoqIiMDChQtRrlw52YtER0cjIiICzZs3FyTd7927h7CwMAwfPhyHDh0yGMiSJUuQlJSE+fPnY+vWrQaPPXjwINzd3dGoUSPJvmbNmkGr1WLv3r0Gr2EvfLOZM+b0cJc7nig3evHiBUaPHo3U1FSlQyEicips9WddAwcORK1atQRjUVFRWL58uUIRETmWUaNGCYrZAGDOnDmIjo5WKCIiIiKyBzUAxMfHIyYmBlWqVMHDhw/Rr18/FClSBHnz5kXt2rWxefNmgxcJDg7G8uXLkZSUpEu6ZyXbb968iWnTpskm8rMbMWIEbt++jUGDBkl6QmaXmZmJ69evo0SJEoLq9ixly5YFAFy9etXY390u+GbTchkZGXjx4oVgLHvf9rx580KtFq77yz7u5Cpu376NadOmcVoyEZEZ2OrPutRqNb799lv4+/sLxhcuXIhbt24pFBWR4/Dz88OECRMEY69evcKkSZOQmZmpUFRERERka2oAuvYriYmJCAkJwd69e9GlSxd06dIFV65cQYcOHYy2hQkPD8fKlSt1SfdGjRrh1q1bmDZtmqTHo5ywsDDZimWxxMREaLVaFCpUSHZ/gQIFAID9I3MBuWr17D3cVSqVZOFUVrhTbpb1QjHL9u3bsWnTJoWiISIiet2reurUqYIiiIyMDHzzzTdsLUOE1wsNd+nSRTB2/vx5/PrrrwpFRERERLamBv5XFXzs2DFUrlwZ58+fR2RkJH799VecOHECfn5+GDlyJO7evWvwYuHh4Zg1axaePXuGO3fuYPDgwSYl282RFauXl5fs/qzxly9fWvW+ZH9yyXPxSxnxNhPulJtNmDBBMmNm1qxZuHz5skIRERE5F7b6s42aNWuiZ8+egrHz58/zpTDR/xs+fDhKlCghGFu0aBESExMVioiIiIhsSQ0Abm5uuoHIyEhBQqdixYoYPnw40tPTsX79eoMXi46Oxty5c19fWK3GqlWrcOzYMasGnCdPHgBAWlqa7P5Xr14BgKTymZyPuD2Mh4eHpI0QE+7kSt544w1MmjRJMJaeno4xY8bwCxsRkQnY6s92BgwYgOLFiwvG5s6di9jYWIUiInIcefPmxddffy2YCZKWloYdO3YoGBURERHZihoA8ufPD+D1l5BKlSpJDqpZsyYA4ObNm3ovdPfuXYSFheH27duYPn061q5di5SUFLRo0QJHjx61WsD58+eHWq3W2zImazzr70TOS27BVHF/fybcydU0adIEPXr0EIw9fPgQEydO5NR9IiJSjJeXF8aNGycYS01NxX//+1+FIiJyLNWqVUOzZs0EY3/88YdC0RAREZEtqYHXfYHd3d2RkZEhuwBfeno6AMDb21v2IjExMbpk+4wZMzBmzBh06dIFq1evRmpqKlq2bIlTp05ZJWBPT0+ULVsW0dHRuriyy3opULlyZavcj5QjrtiV6/EvHuOiqeQKhg4diurVqwvGDh48yF6gRESkqNq1a6Ndu3aCsb///htXrlxRKCKinEtJSUFKSopVrvX+++8Ltq9du4Zr165Z5dpERETkONTA6yR2vXr18OrVKxw4cEByUFZbGHGCJ0vhwoVRvXp1zJw5E6NHj9aNZyXdq1atKlnsLycaN26MtLQ0HD58WLJv165dUKlUqF+/vtXuR8qQq3AXE7cOYsKdXIG7uzumTZuGggULCsbnz59vtZebRERElvjkk08kz2eRkZGyRT1EzsDX1xelS5e2yrVq166NoKAgwRir3ImIiHIfXRO5wYMHAwA+++wzPH/+XHfA+fPn8dNPP8Hf3x8dOnSQvYinpyd+//13jBo1SrKvS5cuOHToEAoUKGC1oCMiIgAA48aNw4sXL3Tjmzdvxv79+9GuXTtJD0lyPuLkuSkJd7aUIVcRGBiIb7/9VtBmSaPR4IsvvkB8fLyCkRERkSvLnz8/+vTpIxg7fvy41dd1InJGarUa7733nmBsx44detcnIyLnZM2ZMUTknHQJ9/DwcPTp0wdnzpxBlSpV8Mknn6BPnz6oV68e0tPTsXjxYtmEZxZxb21T91miXr16GDJkCI4cOYLq1atj9OjR6N69Ozp37oygoCDMnj3bqvcjZVjSUoYJd3IltWvXxsCBAwVjT58+xbhx45CZmalQVERE5OrCw8MRGBgoGJs7dy7XGiECJG2XEhMTsW/fPmWCISKbsObMGCJyTursG0uWLMHSpUtRrFgxLF68GJs3b0bjxo2xb98+tG/fXqEQ5UVGRiIyMhJeXl6YO3cu9u/fj/DwcERFRaFMmTJKh0dWYEpLGSbcydX16dMHoaGhgrHTp09j/vz5CkVEROS4WHFmH15eXpIXwtevX5dtXUnkaooVK4Z33nlHMLZlyxaFoiEiIiJbECTcVSoV+vTpg+PHjyMlJQUJCQnYtm2bJJljD1qtFvfv39e7X6VSYejQobhw4QJevnyJBw8eYOXKlUy25yJMuBMZp1arMWXKFEk/0OXLlzOxQUQkwooz+2nbtq3kuXzFihUKRUNkucePH+PSpUtWvaa4yv3YsWN4+PChVe9BRMpJTk7G7du3lQ6DiBSkNn4IkTLEPdz9/Pwkx4gT7lw0lVxR/vz5MXPmTLi7uwvGJ06ciAcPHigUFRERuTK1Wo3evXsLxs6dO4fz588rExCRhYKCglClShWrXrNp06aCtai0Wi22bt1q1XsQkXJ8fHzg4+OjdBhEpCAm3MlhiXu4ixdIlRtjhTu5qipVquCzzz4TjCUlJWHMmDFciIuI6P+x4sy+WrRoIZmBtXLlSoWiIXIcXl5eaNWqlWDszz//5DoHREREuQQT7uSwLGkpk5yczAdVclldunRBixYtBGNXr17FrFmzFIqIiMixsOLMvtzd3dG9e3fB2N69exEdHa1QRETms9WLOnFbmZiYGJw6dcrq9yEiIiL7Y8KdHJYlCXetVosXL17YNC4iR6VSqfDll1+iVKlSgvFNmzZh27ZtygRFREQurX379oKXHFqtFmvXrlUwIiLHUKlSJZQrV04w9scffygUDREREVkTE+7kkLRarSThbkoPd4BtZci1eXt7Y+bMmciTJ49gfOrUqbh586ZCURERkavy8fFBp06dBGPbtm3Dy5cvFYqIyDy2WmxZpVJJqtz37NkjaatJREREzocJd3JIaWlpSE9PF4zJ9XDPmzcvVCqVYIwJd3J1ZcqUwfjx4wVjL1++xKhRo/D06VOFoiIiIlfVpUsXwfNacnIy9uzZo2BERI6hTZs2gkXv09LSsHPnTgUjIiIiImtgwp0cklzSXK6aXa1Wc+FUIhmtW7eWVBRGR0dj0KBBePbsmTJBERGRSypatCjq1q0rGNu8ebMywZBDun//Ps6ePeuQC73bcrHlAgUKoHHjxoKxLVu22OReREREZD9MuJNDMjXhLjeenJxsk5iInM3IkSNRqVIlwdjNmzcxePBgTlcmIiK7at++vWD79OnTuHv3rjLBkEPZtm0bOnbsiH79+mHgwIEutx7T+++/L9i+fPky/v33X4WiISIiImtgwp0ckjjhnjdvXsF0y+xY4U4kz9PTE99//z3eeOMNwfj169cxZMgQ/qwQEZHdNGrUCAUKFBCMcYFI0mq1mDdvHjQaDQDg/PnzDrfQu616uGepW7cuAgMDBWOsciciInJuTLiTQxInAvVVt8vtYxKR6H8CAwOxYMECFClSRDB+5coVDB8+HCkpKQpFRkRErsTDwwNt27YVjG3dulWXaCXX9PjxY8TGxgrG9u7dq1A0ylCr1ZKfjW3btjlkex0iIiIyDRPuNpaSksKElgXESXO5BVOzMOFOZFjRokWxcOFCSfXUhQsX8MknnyA1NVWhyIiIyJWIW2c8ffoUZ86cUSgacgRyrVMeP36sQCT62bKHe5b33ntPsP38+XMcPHjQpvckIiIi22HC3cZsPQUxtxL3l/bz89N7LBPuRMa98cYbWLBgAQoXLiwYP3v2LD799FO8fPlSociIiMhVlC5dGuXLlxeM7d69W6FoyBE8efJEMvb48WNotVoFopHn4+MDHx8fm96jRIkSCAkJEYyx5RKR82LhJREx4U4OSbzwqTktZbhoKpG84OBg/PTTTyhUqJBg/NSpU/jss884dZmIiGyuefPmgu3du3ezrYwLe/bsmWQsNTXVoQpo7JU4E88AOXLkiMNV+xORaVh4SURMuNuYPaYg5kbm9HAXt5thwp1Iv9KlS+Onn35C/vz5BePHjx/H559/zqQ7ERHZlDjh/uTJE5w7d06haEhpcgl3AIiLi7NvIAbYK3HWtGlTeHt767a1Wi3++usvm9+XiIiIrI8JdxuzxxTE3IiLphLZTtmyZfHTTz9JWjVFRUVh7NixSE9PVygyIiLK7YKDg1GuXDnBGNvKuK7nz5/LjutLxOdmefPmRatWrQRjf/zxB2eAEDkhFl4SERPu5JDEPdzNqXBnwp3IuPLly+PHH3+U/PwcOHAA48ePR0ZGhkKRERFRbtesWTPB9p49e5hUdFH6EuuOlHC3Z+KsXbt2gu0HDx5wYWEiJ8TCSyJiwp0cUk56uDPhTmSaSpUqYd68eYLpy8DrxMeECROQmZmpUGRERJSbiRPusbGxuHr1qkLRkJL09UbXV/muBHsmzqpUqYIyZcoIxrh4KhERkfNhwp0ckjktZcTJwhcvXtgkJqLcqGrVqpg7dy7y5s0rGN+5cye+/vprVhwSEZHVlSlTBsHBwYKxI0eOKBQNKenly5ey445U4W5PKpVKUuW+e/durlFFRETkZJhwJ4eUk4R7amqqTWIiyq1q1KiBOXPmwMvLSzC+bds2TJo0iUl3Iso1UlJS9FbUkn3Vr19fsB0VFaVQJKQkfYUyrppwB4A2bdrAzc1Nt/3q1Svs3LlTwYiIiIjIXEy4k0Myp4e7OOH+8uVLJgiJzFSzZk388MMP8PT0FIwz6U5EuYmvry9Kly6tdBgEoF69eoLtCxcuSJ7/KPfTV+HuSC1l7P2irlChQmjUqJFgjG1liIiInAsT7uRwtFqtWT3c8+TJIxnT9/BORPrVrl0bs2bNgoeHh2CcSXciIrK2mjVrCl7yajQanDhxQsGISAnOUOGuxIs6cVuZS5cu4ebNm3aNgYiIiCzHhDs5nBcvXkgSe+ZUuGddg4jMFxoaqjfpPnHiRCbdicipPX78GJcuXVI6DALg5eWFmjVrCsbYVsb1OEOFuxJCQ0Ph7+8vGNuyZYtC0RAREZG5mHAnhyM3ndjchDv7uBNZrn79+vj+++8l7WW2b9+OCRMmIDMzU6HIiIhyJigoCFWqVFE6DPp/4rYyR44cgVarVSgasjeNRuMUi6YmJyfj9u3bdr2nm5sb2rZtKxjbtm0b0tPT7RoHERERWYYJd3I44gVTVSoVfHx89B7v4eEBtVr4vzIr3IlyJqvSXZx037FjB5PuRERkFaGhoYLt2NhYuyc2STmvXr3Su8+RKtx9fHwMfhexlffff1+wnZCQwLZLREREToIJd3I44oS7j4+PJKGenUqlQt68eQVjTLgT5VxoaKhspfvff/+Nr776ikl3InI6bCnjWEqWLIkiRYoIxs6ePatMMGR3htZcSk5Odvk2dsHBwXjrrbcEY2y7RERE5ByYcCeHI14w1c/Pz+g54rYybClDZB316tXD7NmzJUn3nTt3MulORE6HLWUci0qlQo0aNQRjTLi7DkMFMlqtls/zABo2bCjYZsKdiIjIOTDhTg5H3MPd19fX6DmscCeynbp16+KHH35g0p2IiKyuevXqgm0m3F2HoQp3QH5dJ1cjXucgOjoaDx48UCgaIiIiMhUT7uRwxC1lDC2YmoUJdyLbqlOnDubMmSObdB8zZgzS0tIUioyIyHRKLH5IhokT7jExMYiPj1coGrInYwl38axXV1ShQgUULFhQMHbkyBGFoiEiIiJTMeFODseShDtbyhDZXu3atWWT7vv27cPQoUP5xZiIiMxWrlw5yYKU586dUygasidjL+sdpcI9JSUFKSkpitxbrVZLqtzZVoaIiMjxMeEO4N69e+jYsSMKFCgAf39/DBgwwGEe8FyR+N+9KT3cWeFOZB9ZSXcvLy/B+OnTpzFgwAA8efJEociIiIzz9fVF6dKllQ6DslGr1ZKFIZlwdw3p6ekG94uLcJSi9OeGOOF+4sQJziwkcnBKvqgjIsfg8gl3rVaL9957D2lpaTh8+DC2b9+OI0eOYNCgQUqH5rIsSbizwp3IfmrXro3IyEhJReL169cRERGB+/fvKxQZERE5I/Zxd03OknBXWt26daFSqXTbL1684EspIgen9Is6IlKeyyfc4+LiULFiRSxcuBBVqlRB7dq10b9/f+zdu1fp0FwWK9yJHF9ISAgWLVqEQoUKCcYfPHiAiIgIXL9+XaHIiIj0Yw93xyROuF+7ds1of29yfhkZGQb3O0rCXenPjYIFC6JSpUqCMfZxJyIicmwun3APDAzE2rVr8cYbbwAAbty4gRUrVqBp06YKR+a6xAn3/PnzGz2HCXci+ytfvjyWLVum+/zM8vTpU/Tv3x+nT59WKDIiInImVatWhVr9v68lmZmZuHr1qoIRkT04S4W7j4+PZFafvYWGhgq22cedyLEp/aKOiJTn8gn37Jo2bYo333wT8fHxmDFjhtLhuCxxwp2LphI5rjfeeANLly5F+fLlBeMpKSkYOnQo9u/fr1BkRERSnOLtmLy9vVGmTBnB2LVr1xSKhuzFWRZNdQTihPuNGzcQGxurUDREZIwjvKgjImXl+oT7jRs3oFKpZP8JCwsTHDt79mwcPnwYJUqUQPPmzbkYjUJY4U7kXPz9/fHzzz8jJCREMJ6WloZRo0bhwIEDCkVGRETOokKFCoJtJtxzP2MV7snJyXaKxPFVqVJFUoR09OhRk8/XaDRM0BMREdlRrk+4lyxZEleuXJH959dffxUcW6NGDYSGhmL9+vW4fv06tm/frlDUrkur1VpU4c6EO5GyfH19MW/ePMmLTI1Gg3HjxjFxQkQOgVO8HRcT7q7HWA93Vrj/j5ubG+rUqSMYO3z4sEnnPn78GO3atUObNm3w0UcfITo62hYhEhERUTa5PuHu4eGBihUryv4THByM2NhYrFu3TnBOUFAQ/P39ERcXp1DUruvFixeSh29TKtzZUoZIeZ6enpgxYwbef/99wfjLly/x6aef8jOViBTHKd6OS5xwv3nzptEKaHJuztLD3VGI28ocO3YMmZmZRs/7/vvv8ejRIwDApUuX8NFHH+HYsWM2iZGIiIhey/UJd2Pu3buH8PBwnDt3Tjd2584dxMXFoWrVqgpG5prkHqzZw53Iebi5ueHLL79E27ZtBeOxsbEYOXIkXr58qVBkRETkyMRrgWRkZHA2Qi7HhLt56tWrJ9hOTk7GxYsXDZ6TkJAgWU8nKSkJw4YNw5o1a6DVaq0eJxERETHhjpCQEDRq1Aj9+vXD6dOncezYMXTt2hWtWrVC3bp1lQ7P5Tx//lywrVKp4Ovra/S8PHnyCLaZ1CNSjkqlwrhx4/D2228Lxi9fvoyJEydCo9EoFBkRubqUlBSkpKQoHQbJyJcvH4oVKyYYY1uZ3E2ccHd3dxdss6WMUEBAAN58803BWFRUlMFztm/fLlsFr9Fo8P3332PKlClct4yIiMgGDCbc9+7dC7VajR49etgrHp3w8HAUL17c4DHLli1DSEgIfH19ERgYiB49euDu3btm3UelUmHjxo2oWLEiWrRogVatWqFq1apYu3ZtTsInC4krWfLlywe12vh7IVa4EzkWT09PfPfdd3jjjTcE47t378aCBQsUioqIXJ2vry9Kly6tdBikh7itzPXr1xWKhOxBnHAvUKCAYJvP81LiKvcjR44YPH7r1q0G92/ZsgUDBw7E06dPcxwbERER/Y/eTGZiYiL69OmjyDSzqVOnSvqqi40dOxYRERF49eoVhgwZgmbNmmHt2rWoVauW2dNPCxcujBUrViA+Ph4JCQlYunSpSX3DTcFKKvOIK9z9/PxMOo8JdyLHU6BAAcyZM0cyS2Xp0qXYtm2bQlEREZGjEreVYYV77iZet0ku4c5ZcULiPu6XL1/Wmyy/du2a5KVVs2bNJMedP38ePXr0wK1bt6wXKBERkYvTm3AfMWKE2dXiOfXy5UsMHDgQ48ePN3jc2bNnMWPGDDRo0ABnzpzBjBkzsGbNGmzYsAHx8fH45JNP7BSxcaykMo+4wt3UhLu4pUxaWhof0IkcQOnSpTFjxgzJTJUpU6bg5MmTCkVFRK4qOTmZfcEdmLjC/dq1a3yey8WMVbgDwIsXL+wUjXOoXr068ubNKxjTtwDqn3/+KdguUqQIpk2bhpkzZ0q+O8XGxuLzzz+XvAQhIiIiy8gm3P/8808sW7YM7dq1M/lCq1atwqlTpyTj9+/fR2RkpNHz//zzT1SqVAkLFy5EmzZtDB77448/AgAmTpwIT09P3Xj79u0RFhaGrVu34sGDBybHTo7DWhXuAB/QiRxFnTp1MGbMGMFYeno6Bg0ahKlTp+LZs2fKBEZELsfHxwc+Pj5Kh0F6VKxYUbCdkpKCx48fKxQN2Zo44S43w5gzhYU8PDzwzjvvCMbk2sqkp6dj+/btgrG2bdtCrVajadOmWLp0KYoUKSLYHx0dLUnSExERkWUkCff4+Hj0798fDRs2NLlSPDo6GhEREWjevLkg6X7v3j2EhYVh+PDhOHTokMFrLFmyBElJSZg/f77RXnMHDx6Eu7s7GjVqJNnXrFkzaLVa7N2716TYbY2VVOaxtMJdLuHOtjJEjqNTp0744IMPBGNarRabNm1Cx44d8dtvv8ku6kVERK4jICBA8kxnrRm3Go0G27Ztw9ixYzFq1CisXr2axRkKMyXhzud5qfr16wu2jxw5IpkJcvDgQUkhU9u2bXV/Ll++PFasWCFZhHXx4sVcRJWIiMgKJAn3QYMGITk5GcuWLTNpsUoACA4OxvLly5GUlKRLumcl22/evIlp06ahQYMGBq8xYsQI3L59G4MGDYJKpdJ7XGZmJq5fv44SJUoIqtuzlC1bFgBw9epVk2K3NVZSmcfSCnfx1EqAFe5EjubTTz+VfVGamJiImTNnokePHjh9+rQCkRERkSNQqVQoWbKkYCw6OjrH101NTcWIESMwYcIE7Nq1C3v37sXs2bPRrVs33L9/P8fXJ8uIE+558+aVfL9jwl1KvHBqQkKC5LuvuFI9JCQExYsXF4wVLFgQn376qWDs8ePH2Lx5s/WCJSIiclGCjPqqVauwYcMGzJgxQ5e4NlV4eDhWrlypS7o3atQIt27dwrRp0zB27Fij54eFhSFfvnxGj0tMTIRWq0WhQoVk92f1/mOLAudkaYW7h4cH3NzcBGNMuBM5FrVajZkzZ2Lw4MGS3qEA8O+//+Ljjz+WTIEmIrIWLmbv+MQJ9zt37uToelqtFl9++SWioqIk+2JiYvDJJ59Inj/JPsQJdw8PD8kMB/68ShUrVkzyc5K9rcyTJ09w+PBhwf7s1e3ZvfPOOwgJCRGMLVmyBC9fvrRStERERK5Jl3B/8OABhg0bhiZNmmDw4MEWXSw8PByzZs3Cs2fPcOfOHQwePNikZLs5kpOTAQBeXl6y+7PG+ZDgnCytcAekbWVYEUPkeNzd3REREYFNmzahRYsWkv1arRbTp0/HkydPFIiOiHI7Lmbv+MSJxJy2lFm/fj0OHDigd//du3exYMGCHN2DLGNKwt0Rnucd8UVdaGioYDv7C6Vt27YJWszkzZsXzZs3l72OSqXCoEGDBGNPnjzBhg0brBgtERGR69El3Pv27YuMjAwsXbrUYEsXQ6KjozF37tzXF1arsWrVKr2rplsqqypSX2+5V69eAXj9hYqcj6UV7oC0rQwr3IkcV2BgIKZOnYqff/4Z5cqVE+xLSUnR/S4hIiLXYs2E+/Pnz/Hjjz8aPW7Tpk149OiRxfchy8gl3MWtOB0h0e2IL+rEbWUuXLigmwkubifTrFkz2fWusrz99tuoW7euYOyXX35xiJcdREREzkoNAAsWLMDff/+NWbNmoVSpUhZd6O7duwgLC8Pt27cxffp0rF27FikpKWjRogWOHj1qtYDz588PtVqtt2VM1rjcojvk+HJS4S5OuPMhkcjxhYSEYNWqVZJq97/++gvnzp1TKCoiyq24mL3jE38XefTokcUzV5cvXy5J2EZGRmLLli3w8PDQjaWnp2PVqlUW3YMsJ064u7u7O2SFuyOqWbOmoN+9RqPBiRMncOXKFdy6dUtwbLt27YxeT1zl/uzZM6xdu9Y6wRIREbkgNQDdL9OPP/4YKpVK90+TJk0AvO7trlKp0Lt3b9mLxMTE6JLtM2bMwJgxY9ClSxesXr0aqampaNmyJU6dOmWVgD09PVG2bFlER0dLHtIA4ObNmwCAypUrW+V+ZF85qXAXP6Czwp3IObi5uWHkyJGSqrYZM2YIpkQTEeUUF7N3fCVKlJCM3bt3z+zrpKSkYN26dYKxli1bol69eihWrBg6duwo2PfXX3/pnUFLtpGZmSnYdnd3d8gK98ePH+PSpUtKhyHg5eWFWrVqCcaioqKwZcsWwVixYsVQo0YNo9erUqWKZGH7FStWcH0DIiIiC6kBoHfv3pg4caLkn48++ggA8NZbb2HixIlo37697EUKFy6M6tWrY+bMmRg9erRuPCvpXrVqVbMXYTWkcePGSEtLkywGAwC7du2CSqVC/fr1rXY/sg+NRsOWMkQuyt/fHx9//LFg7Pr16+whSkTkYvLmzYvAwEDBmCVtZXbv3q1rNQm8bnc5cOBA3fYHH3wgOD4xMRH79u0z+z5kOfFLdbVa7ZCLpgYFBaFKlSpKhyEhbitz+PBh/P3334Kx9957D2q1GqbI/vMBvC6EWr16dc6CJHJRjrj2AxHZlzsAvZXr+/btw/Lly1GtWjVMmjRJ70U8PT3x+++/y/Z+79KlCzp37mxxX3g5ERERWLx4McaNG4fdu3frEq2bN2/G/v378f7776N48eJWux/ZR9aCuNlx0VQi19GtWzf88ccfuplKAPDTTz/h3XffRcGCBRWMjIiI7KlUqVKIjY3VbVuScN+2bZtgu2HDhoLq+eLFi6NmzZqCWbi7d++WXdCbrOv06dOYM2cOLl++LBh3c3OTPM9b2k7IFYSGhuL777/XbcfHx0uO+c9//mPy9cqXL49mzZph9+7durFVq1YhPDyc7VqJzMQ1BYnItNfdJjCUULdmsh14/TZ/yJAhOHLkCKpXr47Ro0eje/fu6Ny5M4KCgjB79myr3o/sQ9y/HWCFO5ErcXNzw5gxYwRjSUlJiIyMVCgiIiJSQk4XTo2NjZW0s2zTpo3kOPHYkSNH2FbGxtLS0vDFF19Iku3A6+cALy8vwZgjJNwdsaUMAAQHB6NYsWJ697/zzjsG98vJajGbJTU1FevXr7c4RiIiIldltYS7vUVGRiIyMhJeXl6YO3cu9u/fj/DwcERFRaFMmTJKh0cWELeT8fDwkDx0G8KEO5HzCwkJQatWrQRjW7ZsQbt27dCrVy8MHz4cM2bMEFTBExFR7iJOuN+5c8es8w8ePAitVqvb9vX1RcOGDSXHNWzYUJJcPH36tHnBkllu3LiBJ0+eyO5zc3NDnjx5BGPZ2wIpxVFbyqhUKklbmezee+89s69ZpkwZtGzZUjB25swZs69D5Oq4SDsRuRvaGRYWJnhYtSdj91WpVBg6dCiGDh1qp4jI1sQV7n5+fmbNjmBLGaLc4ZNPPsGBAwcEP8MxMTGIiYnRbe/atQvr1q1DoUKFlAiRiIhsSJxwv3//vlnni9d5atiwITw9PSXHFSpUCFWrVsWFCxd0Y1FRUahbt65Z9yPTPXr0SO8+tVotKbZxhIS7IwsNDcXGjRsl497e3mjSpIlF1wwLC8OOHTt020waEpnPx8eH+QgiF+e0Fe6U++RkwVRAWuHOX3BEzikgIAADBgwweExCQoLsF0wiIkO4iJlzELfBSExMNHnmYlpaGk6cOCEYCw0N1Xu8eB8r3G1Lrs94FrmWMo6QcHfUljLA67Yx7u7SGrp3331X8t3IVKVKlRJsx8bG8nsVERGRmZhwJ4chV+FuDvFDpSP0fCQiy4SHh6Np06YGj9mwYQPS09PtFBER5Qa+vr4oXbq00mGQEUFBQZIxQ5XR2Z09e1aQnFepVAYr1mvWrCnYvn79OpKTk02MlMxl6IWXoybcHbWlDPC6kr1GjRqS8Xbt2ll8zeDgYKjVwjSBuW2diIiIXB0T7uQwclrhzpYyRLmHu7s7Zs6ciT///BOLFy/GrFmz8OmnnwqOefLkCfbs2aNQhEREZCt58uRBgQIFBGOmJtzF1e2VKlVCwYIF9R5ftWpVQbsZjUaDs2fPmhwrmcfQ87lcD3cW0BgnnqURHByMatWqWXw9T09PySwTJtyJiIjMw4Q7OQxrV7gz4U7k/IoWLYoaNWogLCwMH374Id5++23B/rVr1yoUGRE5Iy5i5jyKFCki2DY14Z69HzsA1K5d2+Dxnp6eqFq1qmDs4sWLJt2LzGeowl2uh7sjJNwd/XOjffv28Pf3120PHTrUrHWw5IhnAjHhTkREZB4m3MlhWLuHuyM8oBORdXXr1k2wfeHCBVy+fFmhaIjI2fj4+MDHx0fpMMgE4oT7w4cPjZ6j0WgkvxNMqfStXLmyYPv69esmREiWMJRwd3d3d8iWMo7Oz88Pa9aswYQJE/Drr78abclnCnEfdybciYiIzMOEOzmMnFa4s6UMUe4XFhaGwMBAwVhWlbtWq8Xjx4/x5MkTJUIjIiIrKlq0qGDblAr3W7duSZ7/xNXrcsqXLy/YZsLddgw9n8tVuDtCwt0Z1n4oVKgQ2rVrJ3l5ZCnx39eRK/yJiIgcERPu5DDYw52IjHF3d0fnzp0FY//88w8OHjyIjz/+GP/5z3/QunVr/P777wpFSERE1mBJSxlxO5lixYqhUKFCRs8TJ9wfPXqExMREE6Ikcxnr4e6ICXdXJK5wv3fvHjIyMpQJhoiIyAkx4U4OI6cV7uJFll68eJHjmIjI8XTo0EGwwF16ejo+/fRTnD59GsDrlgKzZ8/mZwARkROzRsLdlOp24HVy0cPDQzD277//mnQumSctLU3vPrlFUx0h4e7oPdxtQZxwz8jIwIMHD5QJhoiIyAkx4U4Ow9oV7unp6azEIMqFChYsiFatWhk85sWLFzh06JCdIiIiImsTJ9wfP34MjUZj8Jxr164Jtk1NuLu7u0taaNy8edOkc8k8hhLujrpoqiuu/eDn5yeZHcI+7kRERKZjwp0chrV7uAOscifKrcSLp8r5559/7BAJERHZgjjhnpmZifj4eL3HazQa3L17VzAmbhVjiDjhHh0dbfK5ZLr09HS9++Raymg0GsULaFJSUgwu9ppbiavcXa3Kn4iIKCeYcCeHkJaWJpkymtOWMgAT7kS5VYUKFVCzZk3BmFot/JV26NAhruVAROSkChYsKGgfBhhuKxMbGyuphi5ZsqTJ9xMfK07ek3UYaykjTrgDyreVcYZFU21BnHBnhTsREZHpmHAnhyC3MJW5Cfe8efNKxphwJ8q9Jk+ejNq1a6NEiRLo1asXNm7cCDc3N93+tLQ0tpUhInJSarUaQUFBgjFDCXdxMtDb2xuFCxc2+X5MuNuHuT3cAeUT7q6KFe5ERESWc1c6ACJAPuGeL18+s67h4eEBDw8PwVRVVrcS5V5BQUGYP3++YKxOnTqIiorSbf/zzz9o0aIFTp48idOnT6NBgwaoXLmyvUMlIiILFClSBPfu3dNtm5NwL1WqFFQqlcn3EifcHz58iLS0NEmVPeWMoZYycj3cAeX7uCcnJyMuLs7lqtzFf987d+5Aq9Wa9XNFRETkqljhDuDevXvo2LEjChQoAH9/fwwYMEA2AUy2I/737e3tDXd3898HiavcWeFO5FqaN28u2D58+DAWLVqEgQMH4ueff8ZHH32EK1euKBQdERGZQ9zH3VDCXVyRLq7ONSY4OFiwrdVqBcl+sg5LKtyVTri74qKpgPRnKCUlxeA6CkRERPQ/Lp9w12q1eO+995CWlobDhw9j+/btOHLkCAYNGqR0aC5FnHA3t51MFnHCnRXuRK4lLCxM8LIuLS0NCxcu1G1rtVqsX79eidCIiMhMgYGBgm1DyT65CndzeHt7IyAgQDDGhLv1GVs0Va1WS4pu2FJGGUFBQZIXIOzjTkREZBqXT7jHxcWhYsWKWLhwIapUqYLatWujf//+2Lt3r9KhuRRrJdy9vb0F26xwJ3Itfn5+qFOnjsFjjhw5Aq1Wa6eIiIjIUv7+/oJtWybcAaB48eKC7QcPHph9DTLMWIU7AElbGSbclaFWqyWtltjHnYiIyDQun3APDAzE2rVr8cYbbwAAbty4gRUrVqBp06YKR+ZabFXhzoQ7ket59913De6Pi4vDv//+a6doiIjIUuJFT588eSJ7XGpqKuLi4gRjliTcs74PZGHC3bo0Gg0yMjL07lerX381dbSEe0pKClJSUhSNQSlyfdz10Wq1OHv2LI4ePYrMzEwbR0ZEROTYuGhqNk2bNsXevXtRqlQpbN68WelwXIqtEu6u+nBM5MoaN24Md3d3g1/qo6KiUL58eTtGRURE5hJXuOtLuMslxsXV6qYQJ9zv379v0nkajQbr16/H6dOnERQUhL59+yJ//vxm3z+3M/R7GYCulYy4jYnSCXdfX19F768k8YsrfQn3ly9f4ssvv8S+ffsAAPXr18fs2bN1sxaIiIhcTa6vcL9x4wZUKpXsP2FhYYJjZ8+ejcOHD6NEiRJo3ry5wSmPZF3WSrjny5fP4HWJKPfLly8fGjVqJBgTf1mOiooC8Hpq9IULF9hihojIAYkT7i9fvpRdn+fhw4eC7cKFC8PT09Ps+4kT7jExMSadN2fOHHz33XfYvXs3Vq9ejWHDhkGj0Zh9/9zO2HcrfRXuSi+a6spMqXBPSEjAwIEDdcl24PWi9cuXL7dxdERERI4r11e4lyxZEleuXJHdJ+73XaNGDQDA+vXrUaxYMWzfvh3vv/++rUMkWC/hXrBgQcH2s2fPLA2JiJzYp59+itjYWNy6dQvt2rVDrVq18Pnnn+v2nz17FpGRkbovgy1atMDUqVOVCpeIiGQUKlRIMvbkyRPJM7w4MV6sWDGL7ieXcNdoNLpEsJyrV69i9erVgrHLly/j77//RuvWrS2KI7cyNeEuflliaKFVe0hOTkZcXJwk+ewKxBXusbGxSElJgY+PD4DXs0CGDRsmu8DwwoULERoaiooVK9ojVCIiIoeS6xPuHh4eBn/Jx8bGYu/evejWrZtuLCgoCP7+/pJekGQ74oS7pdNwxQn3hIQEi2MiIudVtGhR/PLLL7rtFy9ewMPDQ/elXaPRCCqvdu7cid69e7PNDFEu58q9mJ2Rt7c38ubNK1iT58mTJyhRooTgOHGFe9GiRS26nzjhnpaWhvj4eAQGBuo9Z/369bLjCxYsQIsWLdhSIxtjifOsljKO1sPdx8dHdmaFKyhRogTUarVgxsbdu3dRuXJlXL16FcOGDdP7fSszMxNfffUVVq5cKflvSkRElNvl+pYyxty7dw/h4eE4d+6cbuzOnTuIi4tD1apVFYzMtYgT7uLWMKYqUKCAYJsJdyICXq/vEBISYvCY48eP2ykaIlKKr6+vS1apOjNT+riLE+6WVrj7+/vDw8NDMPb48WO9x6empuKff/6R3ffgwQMcO3bMojhyK1Mr3MX/DZSucHdlnp6ekhdRt2/fRmpqKj777DPJdy3x7ITbt2/jxx9/tHmcREREjsblE+4hISFo1KgR+vXrh9OnT+PYsWPo2rUrWrVqhbp16yodnsuwVoU7E+5EpE/9+vUN7j9x4oSdIiEiIlOZknAXt5SxtMJdpVIhICBAMBYbG6v3+F27dhmsfN69e7dFceRWxhZNzZoN4GgV7q5Oro/70qVLJT8b5cuXx6ZNmySzy1evXs1nLCIicjmChPuzZ88wevRoVKhQAXnz5kXJkiUxfPhwRVqrhIeHo3jx4gaPWbZsGUJCQuDr64vAwED06NEDd+/eNes+KpUKGzduRMWKFdGiRQu0atUKVatWxdq1a3MSPpnJWhXu7OFORPoYS7ifOXPGaDKAiJzb48ePcenSJaXDIDNYknC3tMIdeN1aMjtDFe7GEuqcOfU/qampOH36tMFjshLu4gp3Y5XxZFviPu6HDx/GqlWrBGPVqlXD4sWLUaRIEUyePFlS6b548WJbh0nkUNjCjoh0CfekpCQ0bNgQ3333HYoXL45hw4ahevXqiIyMxNtvv40HDx7YLaipU6di3bp1Bo8ZO3YsIiIi8OrVKwwZMgTNmjXD2rVrUatWLdy+fdus+xUuXBgrVqxAfHw8EhISsHTpUosrrMX4QWucVqu1WQ/3Z8+eCXoOEpHrCg4ONpiESU1NxeXLl6HVavnlniiXCgoKQpUqVZQOg8xgLOGekpIieY7MScJd3K9dX4W7VqvFxYsXBWO9e/cWbD98+BDPnz+3OJbc4vLly2jVqhWmTZtm8Dh9Fe78nawsccL9+vXrgjY/bm5umDBhgm4x4zJlymDo0KGCcy5cuMCiBnIpbGFHRLqE+5QpU3Dx4kVMmjQJu3fvxsyZM7FlyxZERkbiwYMHmDBhgs2DefnyJQYOHIjx48cbPO7s2bOYMWMGGjRogDNnzmDGjBlYs2YNNmzYgPj4eHzyySc2j9VU/KA1LjU1VZIUt1aFu0ajQXJyssWxEVHuoVKp8J///MfgMXPmzEHTpk3RpEkTrF692k6RERGRPsYS7uL+7QBQpEgRi+8nrnDXl3C/f/++JJnevn17SWXvlStXLI4lt/j1119NWnRUXw93pRPurl5AJU64i3Xv3l1yjPh5Ky0tDXfu3LFuYERERA5Ml3C/desWgoKCMGrUKMEBPXv2BPB66pghq1atwqlTpyTj9+/fR2RkpNFA/vzzT1SqVAkLFy5EmzZtDB6btfDKxIkTBQ+17du3R1hYGLZu3WrXinzKGbnKH2v1cAfYx52I/qd379748MMPERISgi+++ALh4eGC/efPn0dSUhJevXqF//73v3j06JFCkRKRLSQnJ5s9E5KUZSzhLm4nU7hwYUnS2xymVrhfvnxZsF2oUCG88cYbKF++vGD86tWrFseSW+zatcuk4xy1wt3VC6gMJdwLFy6Mfv36Scbz588vefHFnwVyJXzeICJdwn3Dhg149OiRbipYlqyqDEOLD0VHRyMiIgLNmzcXJN3v3buHsLAwDB8+HIcOHTIYyJIlS5CUlIT58+dj69atBo89ePAg3N3d0ahRI8m+Zs2aQavVYu/evQavYS/8oDVOPB3X09NT8v+hqby8vJA3b17BGBPuRJTFy8sLn376KX7++Wd06tQJtWvX1ntsZmYmoqKi7BgdERGJGUu4i1+MWrpgahZTE+43btwQbFeqVAkqlQqVKlUSjLPC3XRZFe7iFyZKJ9xdnZ+fHwoVKiS7b/jw4fDx8ZHdJ1489dq1a1aPjchR+fj46P3ZICLXoNa3IyEhARs3bkS3bt3g7u6OL7/8Uu9FgoODsXz5ciQlJemS7lnJ9ps3b2LatGlo0KCBwUBGjBiB27dvY9CgQVCpVHqPy8zMxPXr11GiRAnZ6pWyZcsCcJw36PygNW7fvn2C7Vq1ahn8f8AYLpxKRKZ6++23dV/w5Rw7dsyO0RCRrbl6paozKly4sGD7yZMn0Gq1uu34+HjBfnHC3FxyLWXk1gO6efOmYLtcuXIApElGV0+4W7KWkqMl3FlABdnPzerVq6N169Z6zxH/LDjK93MiIiJ7kM0yLFiwAIUKFULnzp3x4MEDrFixAs2aNTN4ofDwcKxcuVKXdG/UqBFu3bqFadOmYezYsUYDCQsLM6lvd2JiIrRard637FktRZhkdQ7p6emSdkVhYWE5uqa4rQwr3IlIn3z58qFChQp69584cYILLxMRKUj8zJ+RkYGkpCTdtjjhLq6IN5f4/IyMDNn1gMQJ96yiH3GFe0xMjEn9y3Orly9fmn2OoyXcWUAlbSujUqkwevRog0VSchXufKYiIiJXIZtwDwgIwJgxY9CrVy94e3ujR48emD17ttGLhYeHY9asWXj27Bnu3LmDwYMHm5RsN0fWA6+4t1+WrHFLHu7I/k6dOiVZhEiuVZA5mHAnInMYaiuTmJiIs2fP4vr163jx4oUdoyIiW2ClqvORK7LJ3lZGnHAXV8Rb+37A6+8Z4vWishLupUqVkiQh7927l6OYnJklLxscLeFOQGhoqGC7U6dOBgsWAEj2p6am4v79+1aPjYiIyBHJJtw7deqE6dOnY/ny5bh48SICAwMxcuRInD592uDFoqOjMXfu3NcXVquxatUqq0/Hz5MnDwD9D16vXr0C8HrKMDm+/fv3C7arVq2a4y9KbClDROZo2bKlwbYyAwYMQPfu3dGuXTuXTpoQESnB09MTfn5+grHsSXZxMjynz5Genp6S7xHi4g25pGHJkiV154vb0kRHR+coJmfGhHvu0KhRIwwYMADlypVD586d8dlnnxk9p3DhwpIXWGwrQ0RErkJ/huH/BQcH66rUN2/erPe4u3fvIiwsDLdv38b06dOxdu1apKSkoEWLFjh69KjVAs6fPz/UarXeJGrWeP78+a12T7INrVYrSbjntJ0MwIQ7EZmnfPnymDp1KkJDQ9GrVy907NhR9riEhAQsXLjQztERkTWxh7tzEs9eTExM1P1ZnHDPaUsZQFrlLr6H+OVrYGCgrigIeP39KTtXTrhbMjuMCXfHo1KpMGDAAKxduxZjx46VXUtN7hz2cSciIlelBl5Xhf/zzz/YsWOH7EFlypQB8HrRIDkxMTG6ZPuMGTMwZswYdOnSBatXr0ZqaipatmyJU6dOWSVgT09PlC1bFtHR0UhPT5fsz+qnWLlyZavcj2znypUrkv+nGjdunOPrihPubClDRMY0b94cc+fOxfDhw9GwYUO9xx04cEA3k4qIiOxDXEjz/PlzAK8X5Hz69Klgny0S7uJnSXHCvXjx4oJtccLdldtoMOHu2uT6uBMREbkCNQBkZmaiTZs26Natm2wiIauVTLly5WQvUrhwYVSvXh0zZ87E6NGjdeNZSfeqVavq+hpaQ+PGjZGWliZZbBMAdu3aBZVKhfr161vtfmQb4ur24OBgyYI8lmAPdyLKiZo1a+rdl5qaiiNHjtgxGiKyJvZwd07iljJZFe7Pnj2TLMKY05YygPEKd3ECXZxwL1asmGD78ePHOY7JWbGljGuTq3DXarUKRUNERGQ/agDw9vZGx44dkZiYiK+++kpwwJkzZ/Ddd9/Bx8cH3bt3l72Ip6cnfv/9d4waNUqyr0uXLjh06JAkCZoTERERAIBx48YJqiY2b96M/fv3o127dpIHX3I8+/btE2yHhYUZXOneVKxwJ6Kc8Pb2RkhIiN79u3btsmM0REQkrnDPSriLF0xVqVSS50BLiBPu4ip6ccK9RIkSgu0iRYoIth89epTjmJzVy5cvzT6HCffcQ5xwf/78uUu/gCIiItfhnvWHH374AcePH8d3332HqKgo1KtXD3fv3sXmzZuhUqmwZs0aSbVGdoYSpdZIomZXr149DBkyBD/++COqV6+O9u3b4/79+/jtt98QFBSE2bNnW/V+ZH0PHjzQtf/JYo12MoB8hbtWq7X6/4dElHt1795d70LhO3bsQFxcHGrWrIm+ffvCzc3NztGRLcTExODhw4eoVq0aPDw8lA6HbES8GCY5B3GFe1ZLGXHlecGCBa3ymWws4S5OGBYtWlSwLZdwd9Vn0YyMDLPPYcI99yhatCjy5cuHpKQk3djVq1clPyNERES5jS7hXqxYMZw4cQKTJ0/GH3/8gWPHjqFgwYJo3749xo0bhxo1aigYplRkZCQqVqyIhQsXYu7cufD390d4eDgmT56s6zlPjkvcTqZgwYJ46623rHJtcWVTWloaXr58ibx581rl+kSU+4WFhWHx4sW4cuUKKlasiAEDBgimQJ86dQqnTp2CWq1Gv379FIyUckqj0aBv3764cOGCbiwqKsqkBeGIyD70tZQRJ9yt0U4GkPaBFyfc4+LiBNuBgYGC7aCgIMF2WloaEhISJIl8ANBqtTh//jxSU1NRu3btXPcSV27NLWO8vLwE21w7xXllLZx64sQJ3di1a9cQFhamXFBERER24J59o3Dhwpg7dy7mzp2rVDw6xnq7qVQqDB06FEOHDrVTRGRN4nYyjRo1glqttsq15doXJSQkMOFORGapUaOG7mXz22+/LVvxvnr1anz44Yf8fHFihw8fFiTbAWDs2LGcLZdLJScnIy4uDqVLl1Y6FDKDvkVTxS1lrLFgKiAt3nj27Jnuz6mpqZK+5AEBAYLtwoULQ61WC/rLx8bGShLuGo0G48aN07Uqq127NubMmZOrXvhZknAXzzKy5BrkOCpUqCBIuF+9elXBaIiIiOzDOhlOIjM8f/4cZ8+eFYxZq50M8Hq6uLu74F2S4IsSEZG5WrZsKTuemJiIrVu32jkasqZFixZJxg4cOKBAJGQPPj4+8PHxUToMMlO+fPkE2/oq3K2VcNeX4AdeJ87FxBXubm5ukuS6+OUAAGzYsEGwLsjx48exfv16i2J2VKxwJ7mFU4mIiHI7JtzJ7i5fviyo+PHy8kKdOnWsdn2VSiXbx52IyFLvv/8+6tevL7tv9erVgs80cg6vXr3CvHnzcPnyZaVDISIj9C2aaquEu7iFTVJSku5zXpxw9/PzkySIAWl7G3GsGo0GK1eulJyX217iWqvC3djsZ3Jc4oR7XFycpE0TERFRbsOEO9ndv//+K9guX7687BeVnDA0FZiIyFzu7u7473//iz179mD+/PmCfffu3cO6desUiowstWzZMvzyyy9Kh0F2lpKSgpSUFKXDIDPpWzRVXDVurR7u4vtptVokJycDkPZv13dP8bg41osXLyImJkZy3r///itJzjuj48ePY8iQIRa15xJ/L9BoNMjMzLRWaGRnwcHBktZ72duLZmZm8nOZiIhyHSbcye5u3Lgh2H7zzTetfg9WuBORLfj5+eGdd95B+fLlBePff/99rmsDkNstXrxY6RBIAb6+vuzf7oTEFe6vXr3SLUSana0q3IH/VdWLE+fi/u1ZTEm463Pp0iWT4nRUiYmJGDlyJI4dO2bR+XI97NPS0nIaFilErVajbt26grE///wTAHD+/Hm0bNkSYWFhGDp0KK5cuaJEiERERFbHhDvZnTjhXq5cOavfQ1zhzoQ7EVmLSqVC//79JeMzZszAvHnz2F6GiMjK9CXAs/dWB6SJeUvlyZNH0tYkK+EuboWhL8lvLOEufh7OztkT7vv27cOLFy8sPt/REu6cGZNz7733nmD7woULuH79OsaPH49nz55Bq9Xi6NGj6NmzJ7744gu2nCEiIqfHhDvZVUZGBm7duiUYs0XCnRXuRGRLTZo0wccffywZ/+WXXyyaPk+Ohy9Ocqfk5GTcvn1b6TDITOJFU4HXbWWykuBZ5BLzllCpVJJrZd1L/EwpXhxV37j4PHGLxeycPeEut7CsORwt4c6ZMTlXv359ycup0aNH4+HDh5Jj//nnH4wcOZJ9+4mIyKkx4U52dffuXWRkZAjG7FHhzh7uRGRt/fv3x8CBAyXja9euxf379xWIiExlypf4iRMn2iESsjcfHx/4+PgoHQaZyc3NDb6+voKxx48fS54prVXhLnctfRXu+hLu4uKP7NX4mZmZuHnzpt57X7161ZxQHY74RYi5HC3hTjnn5uaG//znP4IxQ89KFy5c4MtRIiJyaky4k12Jp88GBQVZrRopO3HCPSYmhostEZHV9evXD+PHj4ebm5tgfNu2bQpFRKbYs2eP0WO2b9/OBA+RAxE/L967d8/oMda8X1bCXFypLn7mzCJOuGcv/rh3757Bz5dnz57pFml1RklJSTk6X9zOB1A24f748WOnn3XgCNq1a2dwv/hFy+7du20ZDhERkU0x4U52JZ4+a4vqdkD65efGjRv49NNPnfrLCxE5pg4dOqBTp06CsZ9//hlLly5FTEyMQlGRPmlpaRgzZoxJx7JnL5HjEFecixPuarXaqrMXTG0poy/hLo73+fPnutk1d+7ckRyrVgu/ljnzTKmc9G8HXv+3FCfdlUy4BwUFoUqVKordP7coVaoUqlWrJruvZs2a6Nixo2DMlJfjREREjooJd7IrccL9zTfftMl9qlSpAnd3d8FYVFQUvvrqK/YDJCKra9u2rWRs/vz56NWrV46n1pN1GVqoUMwWCfe0tDTcv38f6enpVr82GcfFD52XuI+7OOHu5+cHlUpltfvpS5ib2lJGfL5Go9EVfoj7VpcqVQpBQUGCMVdOuAPSKnfOOMod9FW5Dxw4EE2bNhWM/fvvv7IzWYiIiJwBE+5kV+JEh60q3IsUKYLJkydLHtYPHjxoVrKFiMgUlSpVkl1Q7dmzZ9ixY4cCEZE+a9asMflYayfFb926hU6dOqF9+/bo3bu3oKcz2QcXP3Rexircrd2iUJzgf/78OZKTkyV9401tKQP8r62MOOFetGhRFC1aVDCW04VHlfTy5cscX8PLy0uwzZYyucO7776LPHnyCMbq1KmDt99+GzVq1JC8wGKVOxEROSsm3MluEhMT8fjxY8GYrSrcAaBFixZYuHCh5AvTmTNnzL7W2bNnsXDhQvzzzz949eqVtUIkolxCpVJJFgPLMm/ePKxZswbx8fF2jorEUlNTsX37dpOPt2bCXavVonfv3rpE27Vr17Br1y6rXZ8otxMn1MUV4NZcMFXufsnJyZJ2MoD+hHuePHkkPamzXrI9evRIMF60aFEEBAQIxpz5d4YlFe5TpkwRbNuiwt3SWa5sKWM9Pj4+aN++vW7bzc0NQ4YMAfC6lVBYWJjgeCbciYjIWTHhTnYjrix3d3dHyZIlbXrPatWqoXHjxoIxcxPuZ86cQb9+/bBo0SJ88cUXaN26NQ4ePGjNMIkoF+jSpQuKFy8uGU9NTcX333+Prl275nghOcqZy5cvm3W8uJI1J5YuXYrU1FTB2N69e612fTJNcnIybt++rXQYZAG5Fi3ZWbvCXdwPPiUlRTIrxcvLS1Ktm524yj3r/Li4OMF4UFCQJOEuPsaZmFPh/t577+HLL79Eq1atBOPiCndrFLyI/58hZQwfPhx9+vRBWFgYvv/+e1SuXFm3T9xW5tKlS5KCLSIiImfAhDvZjTjhXrp0aUmfdVsICQkRbJ8+fdqsChdx+4HExERMmTLFqokYInJ+Pj4+WLduHb766ivZ/YmJidi5c6edo6Lsrl69atbx1vyc/+mnnyRjR48eRe3atTFjxgyuL2InPj4+Vl1Yk+zHWELd2hXuvr6+gu3k5GTJS1NjMcldA4AkcV+oUCGjCfcXL15g4sSJ6NatG3755ReHTh6bWuHeqFEjTJw4Ee3bt5f03xdXuFtjxpGl/87YUsa6PD09MWTIEMyaNQsNGjQQ7KtVq5bk54pV7kRE5IyYcCe7ESfcbdlOJrsaNWoItp88eWLyQlQZGRk4evSoZPzp06eS/ptERF5eXnj//fdRqlQp2f3Hjx9HTEyMfYMiAMCxY8cwZ84cs86xx4tVjUaD9evX49y5cza/F5EzM5bctkeFu3gRbHHbQjF9CfesXu5Z8ufPbzThPn/+fPz111+4efMm5s2bh9WrVxv9OyjF1IS7m5ub3n3WrnDXarUYN26cReeypYz9uLu7o1GjRoIxS9qBEhERKY0Jd7Kbf//9V7BtqwVTxUqUKAF/f3/BmKkPbmfPnpW0AMjy4MGDHMdGRLlT7dq1Zcd3796Ndu3a4bvvvrNzRJTVI9Yc1urhbkr1urkvA4hcjbEKdmsn3MXJcrmEuyUV7pmZmZLrFChQAIULFxaMZU+4azQabNu2TbB/6dKlDjszxtSEu7iqPTtx//ucfh6fPn2abbycRM2aNQXbV65cUSgSsrfMzExs27YNy5cvd+qFo4mIACbcyU40Gg1u3rwpGLNXwl2lUuHtt98WjJ0+fdqkcw8dOqR3H6tUiUgffQn3LOvWrUN0dLSdoiFjxJWUWaxR4f78+XMMGDDA6HHmtrshcjXGEu7O0lJGnGwHXifcxRXuqampuqKP6OhoSRuaxMREh1t4+ebNmzhw4IDJ1eiGKtzFCfecVrhv3brV4nO59oN9VapUSbD98OFD2QWLKXfRarXo2bMnJkyYgMjISLRp08as9SCIiBwNE+5kFw8fPpRUiturpQwg7eNuaoX74cOH9e4ztS0NEbmeBg0aoGzZsgaPuXDhgp2iIWOVkYcPH5attMxpRaVGo0GfPn1M+p3DdUGIDBMvQCpm65YyaWlpePLkiWDMkpYy4nYywOvYxRXuwP+q3K9duyZ7/d9//93g/e1p69at6NatGz777DOTz1Gr9X8VFSfc09LSLI4N4HO7MyldurTkRTir3HO/9evX4/r164IxcY9/IiJnwoQ72YW4nYy+Lxa2Iu7j/uDBA6PT1E6dOmWwmoUV7kSkj7u7O5YuXYoJEyboPWbXrl2cLmsnWX2TDZFLuOc0CX7kyBGzZjLoa2FGRMYT7raucAeAR48eCbYtqXAXV6r7+PjAw8MDefPmhbe3t2BfVnJeX8L91q1bBu9vL1qtFtOnTzf7PHsm3MWLsJrD19cXpUuXztH9yXRubm6oUKGCYIyzwHK/mTNnyo6b8gxHROSImHAnu5BbMNVQ30ZrK1eunKQK6eLFi3qP12q1+O9//2vwmuzhTkSG+Pj4oF27dqhTp47s/oMHD+L999/Hnj177ByZ60lJSdG7b+jQoQCATz/9VLIvpxXu5rYg2LhxY47uR8alpKQY/P+BHJefn5/BZ0dj1ebmEle4A9JiC2tUuGd/USC+XlYLG3HVZ5b4+PgcJ6KtITEx0aLWD/ZMuBtqX0OOR9xW5vLlywpFQvZgaD2Ke/fu2TESIiLrYcKd7EJc4W7PdjLA6wf6ihUrCsbu3Lmj9/i9e/dKHuyaNGki2GbCnYhMYagqMz09HUuWLLFfMC7KUHXUBx98AABo27atZF9OK9zNXdCQC/rZHitVnZdarTZYUW7tCncvLy9Jkvbhw4eCbWtUuGf/HSFOuCcmJkKr1eqtcAekVfdKsHS2lqEkuLiliLGEu1arxY0bN2xS9c8e7vZXuXJlwTZbyuRuZ8+e1bvv+PHj9guEiMiKmHAnuxAn3O21YGp2pUqVEmzfuXMHBw8exKpVqyRfFP744w/BdnBwMAYPHiwYS0xM5BQ3IjKqcePGBvdfu3YNmZmZdorGNelLlHTv3l2X1MmXL5/kC35OK9zNdf78edy9e9eu9yRyJoZeYFq7h7tKpZJUuYtnR1iScBdXuGf/O4mvl5ycjCdPnhhcMNIRFpPM6jVvLkMzFsQtYIwl3IcNG4bw8HB07doV3bt3l+zXaDQWxQi8nu0gN+OBbEdc4f748WM8ffpUoWjIljZv3oz+/fvr3R8ZGcl1j4jIKTHhTjb38uVLyUJF9q5wB6QJ923btuHTTz/FDz/8gPDwcN20Xa1WK/mlHhERgeLFi0u+GOjr4/78+XPcvHmTSTQiQlhYGIoXL27wmIkTJ3LKrI0cPnwYX331lUnH5s2bV7Bt7wp3AFi+fHmO7kmGsVLVuRmqYrd2SxlAvo+7Ofc0N+EuV+FurHrcERLuSle437t3D0ePHtVtX79+XVL5b8nnMSmnVKlSyJMnj2CMfdxzn9jYWHzzzTdGj9u+fbsdoiEisi4m3Mnmbt26JagqUalUKFOmjN3jECfcs0tMTNT1Ub537x4SExMF+2vVqgUPDw8EBgYKxsUvEoDXU+Lef/99dOvWDf3797d7hSQRORZPT0+sXr3a4BeKHTt2oEePHpLPHsq5pUuX6t0nrnh0d3cXbOc04Z49AWSqLVu25OieZBgrVZ2bvgp3X19fm/ToNpZwN/b/kjVayogT9GLZq36PHTuGiIgIjBgxQtL+xpYsTbgb6uFuToW7XMsdcfFMTircufaD/anVasnCqezjnrucP38ebdq0MelYttwjImfEhDvZnHjB1OLFi0uqCO3BUMId+F+SQ7yYqr+/P4KCggAAb7zxhmCfXIX7kiVLdK1mzp8/j8OHD1saMhHlEt7e3mjVqpXBY1JSUrB//347ReQaMjMzce7cOYP7sxMneHLywvTy5cvsO0pkZfoS7v7+/ja5ny0S7uKK9OxV+3ItZYwl3LOud/v2bQwbNgznz5/HoUOHMHDgQIsWMrWEsRj1MZRwF1e4v3r1Su+xclX+4gR5ThLuXPtBGeI2b6dPn0ZSUhJOnTqFf/75xyFmd5BlHj58iIiICJOPVyJ3kFN8UUdETLiTzYmrTpRoJwMAAQEBkqmJ2WVVRokT7lWrVtW1khEn3MULp2q1Whw5ckQwJu4HT0Suq0OHDgb3s4LHuoy1Z3nrrbcE256enoLtnKzTsXjxYovPJSJ5+hLu4ucza/H29s7RfnHCXavVSqrBs1e1i483p8L9r7/+EiSVHzx4YPMZM6mpqYiPj0dqaqpF5xtKuIs/jw1VuMv1kI+Pjxdss6WM8xH3cT9+/DiaNGmCjz/+GF988QU6duxocLFNckxpaWlmJduB14tDO9vPMF/UERET7mRTaWlp2Llzp2BMqYS7Wq1GyZIl9e6Pjo4GIJ9wz1KsWDHBPnHCXe6BX9yigIhcV4cOHSRJhOwOHDiACRMmWJy8IKH58+fr3efl5YV69eoJxgICAgTbOameO3nypMXnEpE8fQl38fOZtRhLqJtb4Q68XvxR3zXEFe5JSUkmV7jLtds4dOiQwXNzYv78+WjUqBFatWqFrVu3WnQNWybcxQts5qTCnWs/KKNKlSoG9yclJWHo0KGcTeZk9u3bZ3Ch5aZNm+Ldd98VjKWlpeHx48c5+jkmIrI3JtzJpuSm+zVp0kShaAy3lYmPj0d8fDyuX78uGM+ecDdW4S5unwNIWxQQkeuqXLky1qxZg4YNG+o9Ztu2bfjll1/sF5SLWrJkCQoWLCgYE7cwyElLGb40IbI+eyfcjbUxMLfCHZC2X8mecBf3cDcn4S63rpDcc6k1xMXF4ddff83xdQz13RfPSjXUHkf8PA5IP4Nzkqjj2g/KKFmyJEJDQw0e8/LlS4wYMYILzzuRS5cu6d1XuXJlTJo0Cd9++61kX9u2bdGpUyfcunXLluFZDV/UERET7mQzWq0Wa9euFYzVqlUL5cqVUygi433ct23bJlgkT6VSCfoHihPuDx8+FDzAy32xEVfYEJFrK1myJIYOHWrwGCbcc07cnz27d955BxUrVpSMW2vRVPaVJbINfQn3okWL2uR+hhLqarVa8pJO7hhz2tKYsmiq+Fn06dOn0Gg0ksp54PViprZ4+XfhwoUcLyoNQNeyUY61E+6GfieQ45o9eza++OILVKtWTe8xaWlpWL16tR2jIku9evUKq1atkt2nVqvx66+/wtvbW+/sl3v37mHJkiW2DNFq+KKOiJhwx+sP7o4dO6JAgQLw9/fHgAEDkJiYqHRYTu/ChQu4cuWKYKxbt24KRfOasYS7uP1N6dKlBb8oxV9y0tLSBD0i//33X8k1nzx5YkGkRJSblShRwmDlpEajYXIgh+Sqo7IMGzZMdlyccLe0wt3c3qREZBpHqnD38fExmDDOYmzh1ez7TWkpU6ZMGcF2QkIC7t+/r/d3RlbLRGuydJFUMWtUuO/cuVP2ZYN4DY6cVLhz8UPluLu7o1OnTli6dCl27NiB1atXY9++fWjatKnguGPHjikUIZlj48aNevdNnz7dpGv8/fff1gqHiMimXD7hrtVq8d577yEtLQ2HDx/G9u3bceTIEQwaNEjp0JzeunXrBNtFixZFo0aNFIrmNUM93AHg6tWrgm3xFzh/f39JT8mYmBjdn+Uq3JlwJyIxT09P9O/f3+AxP/30k1UqCF2VvsUCQ0NDBTOXshO3ALPk3396errRqe3169c3OE2eL1uI5DlSwt1Y5XoWYwl3QxXuKSkpkudI8SJ8z549ky34yHL37l0Ar4tEjh49KmmdaImkpKQcXwMw3MNdPHvg1atXkmM0Gg3GjRsne372BHlqaqrkGd8cXPzQMRQuXBjly5eHr68v+vTpI9gXHR2Nhw8fKhQZmUKr1WL27Nmy+yIjIyUvUQYPHmyPsIiIbMblE+5xcXGoWLEiFi5ciCpVqqB27dro378/9u7dq3RoTi0uLg67du0SjHXp0sVgJYs9BAcHm3V8oUKFBNsqlUpvH/fMzEzcuXNHco3ExESDCz0RkWvq1auX3qQw8LqtzNy5c+0YUe5hqL/nnDlz9O6zRsJd/LtPTvfu3TF37lwUKVJEdj97fhLJ05dw1zeeU4aS6qa2CjCWcM9+HblripOI4gp3jUZjMIl+9+5dZGRk4KOPPsLQoUPRvXt3g5+DprDWTOCcLppqqKgle0sZpQt+yPoqVKggmRHCxVMdV0JCAt555x3Zff369ZMsYg8AYWFheq/HxVOJyBm4fMI9MDAQa9eu1SVRb9y4gRUrVkjesJJ5Nm3aJKjQ8/LyQvv27ZUL6P+Jp6caI15QD5BWUWUl3B88eKC3/QD7uBORnGLFiqF79+5692/YsIEv7CwwduxYvfsMJXis0VLG2EKCJUqU0H3p1Pd7kf/NieTpS16b0trFEtaocDe28Gr2JLvcNcWfB3LtEQ0tjnr//n0cPHhQUAW/cuXKHFW6O0qF+/79+/Wen1XhfvLkSQuj+x8ufuh41Go1ateuLRhjWxnH9PTpU7z77rt693fu3Fl2vHDhwnrPMbSmAxGRo3D5hHt2TZs2xZtvvon4+HjMmDFD6XCcVlpamqQ/W5s2bSRVCEpp06aNycfKJdz1VbgbehBnwp2I9OnatSsCAwNl96WlpeHSpUt2jsi5JScnG6xwN0Rc4X7hwgWzr2GotUP+/PmxZMkSXZJJ3+8jWyUPiZydXIJW/HNrTdZIuBuqhFepVIJ7mFI1HxAQIKn+NtSn/fnz57LJ9aNHjxq9V3anT59Gq1at8Nlnn0nWaLKUoZmv4oS73ItI8dpL2WX1cH/06JGF0f0PFz90THXq1BFsnzhxgpXPDujPP//Uu69Hjx56E+viFlvZcU0FInIGuT7hfuPGDahUKtl/xNOUZs+ejcOHD6NEiRJo3rw5K8wstGvXLkmCWenFUrMbMGAAKlSoAA8PD3Tu3FnyQJ+duKUMIE24Z/VwN5Rwz76wam60fv16dOnSBZ999lmu/7sSWVvx4sWxYcMGvQtt9u/fnz9XZpCrgsyir4oqi7h3+suXL6HVaq0SF/D692P23ytMrBPlnKmJb2tf29QErLGkffbPATc3N4PPpcDrF3fiSv/s6wmJJSUl4dq1a5Jxc15M/vvvvxgwYADi4+Nx4MABqyXcDX0Gil8qZGRkmJVMffHiBTQajWzxDOUO4oR7QkKCwdkeZF8bNmxArVq1EBkZqfeYoUOH6t1n6PMhe8soIiJH5W78EOdWsmRJvQ+F4ofoGjVqAHidPCxWrBi2b9+O999/39Yh5jpr164VbNesWRPlypVTKBqp4sWLY9WqVbrtM2fO4ObNm7LHWqvCPTcvnHrnzh3djJDbt2+jcOHCehewIiJ53t7e6Nu3L/766y88fvxYsn/w4MFYuXKlJAFBUoZeln/00UcGzz137pxkLCkpyeQZWoams5crV07y5TF//vyyx967dw+VKlUy6Z5ErkatVgsSr7bsz23rCne5fT4+PnpfHObJkwd58uSBr6+voLjF0IvGxMRE3L9/XzKetbjz06dPsX37duTPnx8tW7aEh4cHYmJiMHPmTCQkJOCjjz4y2irLUuZUuAOv/57Z/5sYWmdDq9Xi5cuXFrUGI+dQrFgxFC9eXPD/d1RUFMqXL69gVAQAly5dwvTp0w0es23bNkkrP7GWLVvi77//loyzwp2InEGur3D38PBAxYoVZf8JDg5GbGws1q1bJzgnKCgI/v7+iIuLUyhq53Xx4kVcvnxZMOZI1e1y9C1aB5jWwz0uLg5paWlmVbjfu3cPq1atwpkzZ8yM1vEsXrxYsL1p0yarXHfPnj1o164dunbtivPnzwMArl+/jsuXLxusOL116xaWLl2KqKgoq8RBZC9eXl5Ys2YNQkNDJftu3bqF5cuXKxCV89GXcP/uu+9QtGhRg+fKLdBlap/Q9PR0DBkyRO/+zz//XDKmL2E3b948k+5J5IpGjBih+7NarUa/fv1sdi9bV7jLXcPQPbNe/hlbiDW76Oho2daG9+7dQ3JyMvr06YMffvgBkyZN0i3U3a5dOxw6dAiXLl3C6NGjcfHiRZPvZw5zergD0s93uRfU2SUnJ3PGci5Xt25dwbahNkNkP//973/17qtbty5OnDiht51idmPHjkXJkiUl46xwJyJnkOsT7sbcu3cP4eHhgqq2O3fuIC4uDlWrVlUwMuck7t1epEgRNG7cWKFoTGMo4S7XUkacsNFqtXj06BHu3Lmj9zrPnj3T/TkmJgbdunXDDz/8gAEDBuDAgQNmx+xIbFFh8OrVK0yaNAkxMTG4desWpk+fjkWLFqF79+7o1auX3oqJK1euoGvXrpg/fz6GDx+OHTt2WD02sYSEBEyYMAGDBw82ux8qkZifnx+++eYb2STMihUruEiUCfQlV0xpK1C/fn3J2IsXL4yet2bNGtSrV8/gMSEhIbLjY8aMkYwZag9B5OrCw8Mxbtw4dO7cGYsXL5bMPLQmW1e4y13D0HWz9pnTT1xfG5anT59i69atupmawOvneLmZPrZiKOEuN6MreyV/Zmam0eKo1NRUVrjncs2aNRNsX79+3eB3MrK9xMREnD59Wu/+Zs2amdxSL1++fNi4caOk4I0V7kTkDFw+4R4SEoJGjRqhX79+OH36NI4dO4auXbuiVatWkjfmZNjLly+xe/duwVjnzp0NThd1BIYS7gUKFJCM5cuXT7KIy7lz5wy+ac+ecP/vf/+rSwhptVps3brVvIAdjLGpgJY4fPiw4N/n9evXsXDhQt32xo0bZdv09OzZU7D95Zdf4tKlS2jbti3q1KmDn3/+2eqxzpo1C9u2bcPx48cxdOhQjBkzBt99953uv3lsbKzV70m5m5+fHyZOnCgZT01NNfgFhl6bOnWq7Lgpn1VyyTVjyZrk5GR8//33Bo85cOCA3sSSuActERmmVqvRsWNHjB07FtWqVbPpvayRcDe3wt1Q9XrW8eZUuBsiLkxIS0vD/PnzrXJtU+Skwj0+Pt5oT/eUlBSD7XZMlZKSwgSfg6pZsyb8/f0FY6xyV05GRgaaNm1q8BhLXpKKW/s9f/7c7GsQEdmb4CknOTkZ48aNQ8WKFZEnTx74+fmhcePG2Lx5s90DCw8PR/HixQ0es2zZMoSEhMDX1xeBgYHo0aMH7t69a9Z9VCoVNm7ciIoVK6JFixZo1aoVqlatKulDTsYdOHBAkCRVq9X4z3/+o2BEptGXcPfx8dHbL1n8lt1Ya5jsCXfxS4k9e/aYEKV1vXz5EosWLcKsWbNyXElpixcqplTxmrrY148//ohHjx4hMzMTP//8s96/b0xMDHr27InatWtj0qRJBvuCZifuK7h7926sW7cOX3zxBXbs2MF1IMgiTZs2xcmTJ1G9enXBuLVaNuVWiYmJuHDhguw+UxLuKpUKHh4egjFjCXdjn+GzZ882mJgLDg42GhdZDxNnZA5rtJQxdJxc4tyUe5pT4W6IXKuYU6dOWeXapjCUcBd/FgPCCvdHjx4J9nl6ekpmMqWkpFilwt3X1xelS5fO8XXI+tRqNd59913B2M8//2zyczxZj1arRffu3Q0eExAQgJo1a5p9bfHPdkJCgtnXICKyN91TTlJSEurXr49p06bBx8cHgwcPRpcuXXDu3Dl06NAB06ZNs1tQU6dOlfRVFxs7diwiIiLw6tUrDBkyBM2aNcPatWtRq1Ytg7205RQuXBgrVqxAfHw8EhISsHTpUr0LmZnLlb7Ybd++XbD9zjvvICAgQKFoTKcv4S7XTiaLOOFubPrt7du3kZ6ebrQSx16+/fZbLFy4EGvXrkVERESOHkptUeFuSr9NQ1/Ssjt+/LhgO+tlmlarxYsXL5CZmQkAWL16Na5cuQKNRoOtW7dKzpNj6MXAiRMn8OWXX3IqM+WIuE3Jvn37+ELYgN9++03vPlM/q8THGft8NPZ5JdemhpTDxBmZw9YV7vZoKePIDBVtqFQqSeFL9oR79mIW4PX3OfG/l9WrV+PIkSM5D5QcWsuWLSVjoaGh2Lhxo8F1n8i6Lly4oLcgqmPHjhg4cCDWrl1rUbEWE+5E5Ix0GauZM2fi/PnzGDhwIE6ePInZs2djyZIluHTpEooWLYqvvvoKN27csGkwL1++xMCBAzF+/HiDx509exYzZsxAgwYNcObMGcyYMQNr1qzBhg0bEB8fj08++cSmcZrDVb7YJSQkSBapbN26tULRmEffInqG+v2KE+7GZlbExsaia9euOHjwoGRf1hS52NhYzJs3D0uXLrV5n+bsL0fi4+NzVGUvV4GUU6YkqU3t/Sd248YNZGZmYvz48WjYsCE6deqEW7duSZKYU6dORVJSElatWoUtW7ZIXpZoNBpERERYFAORqeT6gs+aNQv37t1TIBrHtnr1aixYsEDvfksT7vo+j9LT03H8+HGjvWIdva0aEenn5uamd7ajNSrc5faZ0vPdWi1llGbsWU7cVib7C86kpCTBvnz58kn+3R06dAiHDh3KYZSvZ4GbW9BF9lO1alXJ9zmNRoNp06bhk08+QWJiokKRuZbr16/r3Tdu3Dj069fP4qJG8ffylStXWnQdIiJ70iXcf/vtN6hUKkybNk3w8PPGG29g0KBByMzMxLZt2/ReaNWqVbJTEO/fv4/IyEijgfz555+oVKkSFi5ciDZt2hg89scffwQATJw4UfAQ3L59e4SFhUkWACLb++eff3SVwsDrB+QmTZooGJHpAgICZKulzalwN2X/vXv38MUXX0jG8+TJg4yMDAwcOBC//PIL5s+fL9u/2ZbMbcWUnalJrAcPHmD27NlYunSp0YpQUxLupla4ix0/fhzHjh3T9Xe8f/8+Fi9eLDlOo9GgX79++OGHHzB58mTMmDFDsP/w4cMGHyyJrKFSpUooU6aMZLxDhw52WRTYWWRmZmL27NkGjzH1s0r8ElGuwj0zMxN9+/bF4MGDDc44qF27tkn3JPt5/PgxLl26pHQY5ET0VaibWuFublsaa7SUMfQM60iMvZAUv+zI/vyYnJws2Ofr62uzyn8fH59cM6sgN1KpVPjwww9l90VFRWHs2LGsdLeD6dOny45v2LAhx9eW+/mzxvoMRES2pPv2+cknn+DZs2eyi0RmVReIKwmyREdHIyIiAt7e3ti1a5euL9e9e/fQpEkT3Lx5E2+//TYaNGigN5AlS5YgKSkJ8+fPx8CBAw0m0w4ePAh3d3c0atRIsq9Zs2bYt28f9u7dix49eui9hr0kJycjLi4u11e5i9vJNG7c2GkeTN3c3BAQEIDHjx8Lxs2pcBd78803ZXuFyyWaU1JScODAAURHR+vGdu/eDa1WK1v5ExcXh8uXL6NSpUoIDAw0GIec7C9Gspw7dw5Tp07Fvn37ULx4cfTr1w/lypVD4cKFjSa25ZJYmZmZcHNzQ2pqKlJSUqDRaNC9e3dde6X79+9jwoQJste7c+eOSQ9mlla4A8C8efME23KLK8XGxgoWPN24cSO8vLxw6tQp1KtXjxXGZBdqtRpz5sxBu3btJPu+/PJLxMfH44MPPnD5KmpTFs+yZkuZVatW4fLly0avZYsZQJQzQUFBSodATsbHx0f2M8ZWCfecVrh7enrC398fT58+NSk+JRl7xhRXuGefASpX4S73jEuuoVu3bihYsCDWrl0rWcvl+PHj2LNnD5o1a6ZQdLmfoWLHUqVK5fj6cj/bd+/eRfny5XN8bSIiW9F9qxw8eLDsAVqtVrdIW7Vq1WSPCQ4OxvLly9GjRw80b94cu3btQmBgIMLCwnDr1i1MmzbNYLIdAEaMGIEVK1YgX758Bo/LzMzE9evXUapUKdkpnmXLlgUAXL161eB17MXHx0ewkGhudO/ePcmDjbFZCo6mSJEiVk24ly9fHvv37zfp3i9evJC048kaF39Ji46ORu/evZGYmAgfHx8sWbIE5cqVM+k+WeSqAY4ePar789OnTzF8+HAAr6sz58yZI/lZi4qKwtWrV9GkSRPZJFZaWhqioqIwfvx42WSVvn83169fR58+fUyqWBAn3Pft22f0nJxavXo1AODatWs2vxdRlmLFiuHDDz/EqlWrJPvmzJkDjUaDXr16KRCZ49BXEJCdqclvUxLuc+fONelapr549vT0NGntCiKyP33JbVN/vk3pyW7qdbP2GUq4+/r6Gv0+5SiMJdwNVbjLJdy5bo7rUqlUaNmyJVq2bImoqCiMGjVK8H3iv//9Lxo2bKi3RRRZ7uTJkxg4cKDsvkmTJlnlHjVr1sSSJUsEY+J1HIiIHI3Rngw//fQTjh07hjJlyqBVq1Z6jwsPD8fKlSuRlJSE5s2bo1GjRrpk+9ixY40GEhYWZtLDYWJiIrRard6pklkV+vwAth9xdXuBAgVQt25dhaKxjNzCqYam4+rr+56ldOnSJlecajQa2entcovtrly5UteHMCUlRbYVijHmJHWOHz+OvXv3CsZ27tyJ4cOHY/78+fjwww8FVeBZ0tPTMX/+fL2LDeqrRo2MjDR5emD2L2kHDhzAqFGjTDoPyFl1PJES3n77bb37li1bZsdIHNOuXbuMHmOrRVMNMbUCtnr16hbfg8zDljJkLn3JbUdtKePj46NbH8jRmVvhrlRLGXIuoaGhkkRvTEyMroiQrCur3a9Y7dq18e6771rlHiEhIZIxU4otiIiUZPAp57fffsPw4cPh7u6O5cuXG60OCw8Px6xZs/Ds2TPcuXMHgwcPNinZbo6shyvxA1iWrHFbLzpJr2m1WknCvUWLFiYnNhyFXMLdUIW7t7e3wYR8YGCgWYvC/Pvvv5KxBw8eSPoNih8UTUkyiZlbRTl79mwcP35c1z4hey/ztLQ07N69W3JORkaGyX3hNRqNbprgkSNHTI4r60vakydP8Nlnn5nVm5EJd3I2NWvW1PtSOikpyeaLmju6n376yegxliZiclJ5XrlyZZOOyy0LIDqDoKAgVKlSRekwyInYssJd7to5bSnjTBXuxopTxN/3shdliL/r5c2blwl30mnevLmkWOHvv/9WKJrcKz09XTLTHXidD5g/f77enI253N3dUaJECcFYbu8iQETOT2/C/aeffsIHH3wAAPj111+NtoQBXre7yJpmrVarsWrVKhw7dsxKob6WJ08eAPq/AGc9iPHLq31cunRJ0sva2drJAPIV64YS7gBQtWpVvfsCAwNzVBUJAP369cPnn39u9X6U5i4w8+TJEwwePBi9evXC8uXLTeqVbGrFwdWrV9GgQQPUqVMHtWrVMisuAFiwYAFatmxp9nni9kFEji5fvnyYPHmy3v0ffPABFws3oFq1aia/CM6+ngbwet0YSxQqVAht27Y16Vj2eidyXDmtcPfy8tJbyS13jazvOnJMrXB3loS7sQIIcfsPQwl3Ly8vJtxJR6VSoU+fPoKxCxcuIC4uTqGIcqcrV67Ijpv6/GOOgIAAwTYT7kTk6CRPfxqNBiNHjsTgwYPh6emJ9evX6xLvhty9exdhYWG4ffs2pk+fjrVr1yIlJQUtWrQQ9IfOqfz580OtVuttGZM1bk51MVlOXN1eokQJp6wcE/8CBwy3lAGgWxxYTuHChSVTXS2xf/9+s19aPX78GLNnz8bChQuRmpqKK1eu4Pz587oK8JxUa0ZGRpp0nL5V6rPTarX4+eefLY7n6dOnFrXUAYCEhASLziNSUsOGDfW2dtNqtXj//fddMul+69Ytg/uDg4Px+eefW3z97LNn0tPTsWDBAqPnREREYOXKlSb3ijXWVoGsJzk5Gbdv31Y6DHIicgl3T09Pk1/iqVQq5M2bV3afXIJY37GA6RXuztJSxliFu6Ee7uICkjx58hgtliHX8s4770h+xuyx5pMriYmJkYzly5fPokIqY8T/LZlwJyJHJ3hSTEtLwwcffIBNmzahUKFC+OOPP0yqbI+JiUFYWBju3LmDGTNmYPTo0bp93bt3R8uWLbFnzx6DCUpTeXp6omzZsrh79y7S09MlVWE3b94EYPo0brJcRkYGdu7cKRhr3bq1U7bryOr9n52xlzZyveSyruXp6QmNRmON0DBnzhyEhoaadKxGo8GAAQN0SbdFixbp9nXs2BHjxo0zu8LdEidOnDB6jEajwYEDByy+hzVf5BE5C2MvAocNG4YNGza4TAI3MzMTQ4cO1bv/+PHjZv+7CAgIEFTAZf9C16VLF9y/f9/oNfQtRK+PM/7eJHIVcklxcyupvb29ZdfmsTThnlsq3I19Pour/bM/w4qfZ728vJzm70324eHhgUaNGgkKxPbu3YsuXbooGFXucfPmTXz99deS8S+++MImi9OKZwQx4U5Ejk73lKPRaNClSxds2rQJpUuXRlRUlEnJduB1NW/16tUxc+ZMQbK9S5cuWL16NapWrYqyZctaLejGjRsjLS0Nhw8fluzbtWsXVCoV6tevb7X7kbxjx45JKoVbt26tUDQ5U6lSJUEi64033oC/v7/BcypUqCD7hSerH7y1qmyMJe4fPnyo+/PRo0f1Vrhu2rQJ8fHxOapwt6actsq5fv26lSIhch7GWnZFR0frXjy7gnPnzsku3JzFkhcP4ll9We3B4uPjTUq2W4IJd/vx9fVF6dKllQ6DnIhcNbmp7WSMHW9uwt2UljLO1MPd2Ge0ORXuXl5eVusXTblHkyZNBNsnT57kdwgruHv3Lnr06IH09HTBeOvWrdGiRQub3FP8OSr3EpOIyJHonnKmTZuGLVu2IDg4GAcPHkSFChVMvoinpyd+//13jBo1SrKvS5cuOHTokGwFsaUiIiIAAOPGjcOLFy9045s3b8b+/fvRrl07FC9e3Gr3I3nbtm0TbL/11luSxUychaenJyZPnoyyZcuifPny+Prrr41+CVCr1ZLFeADoWj4MGzbMKrEZS7hPmjRJ9+c7d+4YPPbkyZMOk3DPaY/706dPWykSIudRsWJFfPTRRwaPcaX+pFevXtW7z1DluyHihE16ejpevHgh+Ky1NleZkUDkjMxd2FSOvoS73LgpCXe1Wm0wie8sLWXMTbgb6+HOhDuJ1atXT/D/hUajweeff871nHJo48aNkmQ7AISHh9vsnuLPvOx5IFt4+vQp/vrrL76gISKLuQOv+xlPmzYNAPD2228L2lBk16hRIzRt2lR2n6HqLGtXbtWrVw9DhgzBjz/+iOrVq6N9+/a4f/8+fvvtNwQFBWH27NlWvR9JpaamSnrgOWt1e5a6deti3bp1Zp3Trl07HDp0SLcdERGBDz/8EMDr1dlPnDgh6XNvrqxK8Ox9hLM7deoUAGDPnj1G/9//8ssv0bFjxxzFYy05TbgTuaphw4YhPj4ef/31l+z+4cOHY+fOnUbbz+QG8fHxsuONGjVCp06dLLqmuFXdpUuX0LBhQ4uuZSom3O0nOTkZcXFxrHInk8kl3AsXLmzWNeSS42q1WnaBVEOLpmaPxcfHR7algqEe7j4+Pnj58mWOZxlai7HPPnEC3VBLmTx58tikjQU5t7x586Jr165YsWKFbiwmJgbdunXDpEmTEBYWplxwTmzt2rWSscDAQJu29bVnhfvTp0/RuXNnJCYmQq1Wm9XilYgoizvwut9y1gfWH3/8gT/++EP24PHjx+tNuNtbZGQkKlasiIULF2Lu3Lnw9/dHeHg4Jk+ejDJlyigdXq63d+9ewYOum5sb3n33XQUjUkaTJk0wY8YMnD59GvXr1xf8Is6TJw+mTJmC8PBwoxWphmRVuBt6i3/y5EmMHTvWpOtt2rTJ4lisyVE+S4icUYcOHfQm3AHgl19+wWeffWbHiJShb3Hq77//3uKX/eKEu7iK0hbatm2LLVu22Pw+pD9JSaSPXDV7+fLlzbqGXMLdx8dH9nPKlB7uWefLzWgy1FLGz88Pnp6eDrN4vLFFU8UJ9+yzNFnhTqYaNGgQzpw5g4sXL+rGkpOTMWbMGKxcuRJvvvmmgtE5n6SkJNkZ2EWKFLFpizx79HBfuHAhlixZIvj7aTQazJs3jwl3IjKbGnhdiavVao3+880339gtMK1Wa7BXqkqlwtChQ3HhwgW8fPkSDx48wMqVK5lsz0aj0eD8+fM4efKk1auJxe1kQkNDrdaz3JmoVCo0a9YMo0aN0vtL2NwvZWJZVUj6EksAMHDgQKst0kpEjq9GjRr48ccf9e5fvXq1HaOxP61Wi8uXL+PMmTOy+3PyhU+ccDeXJe3E5NqTkW2kpKSw7yuZRa7C3RoJd30tYfQljb29vQUV4fra2vj6+iJ//vyy+/Lly+dQ/d2NfVYbaikjV+HOhDvJ8fT0xMyZMxEUFCQYz8zMxJQpU/gdykybN2+WHTc0O8caxJ951k64P3jwAIsWLZL9/4FtZYjIEpzDnEtdvXoVffv2RUREBAYOHIiuXbti//79etuSmCMuLg4nTpwQjDl7OxlbymnyJuuXflJSkjXCIaJcok6dOgarssTJiNxkxowZ6NWrF27fvm31a+fkM7tTp07o2rWr2edx0VT74aKpZC65NiXmVsTKJcf1Jcz1tZoRJ/71ne/j42Owwt2REu7GGKpw56KpZI7AwECsXLlSUiB1+fJlvQlkkvff//5XdrxGjRo2va+tK9zNbS1LRGQME+65TGJiIqZNm4aePXviwoULuvHo6GiMHDkSAwcONLjInCl27twpePPr7e2NRo0a5eiauV3VqlUtPjc+Ph6rVq1iwp2IJAy1q6pfvz7mzp3rMAslW0tCQgI2bNhgs+tbknD/9NNPcfLkSXzxxRcG20EQkfMpVaqUIJHr7++PkiVLmnUNuc8FQwuvmnK8XOV91riHh4dsBb2fn5/TLKgK6K9w12g0ktm7Xl5eNuvhzpkxuUPBggUxa9Ysyc/vn3/+qVBEzsfQ7MrmzZvb9N62TrhzfTEisjYm3HMJjUaD33//HR06dMDGjRsNLrDZs2dPTJo0CbGxsRbdS9xOpmnTpjafQubsBg8enKPzf/jhB0RGRlopGiLKLVq1amXwy8+vv/6KZcuW2TEi2zNW1d6hQ4ccXd+ShHvWYtk5kdO4yTTJyck2mRlBuZe3tzdGjhwJDw8P+Pn5YcyYMWYvdGxOhTuQs4R71nFybWWcvcI9K+Eut7aGl5eXzb6PcGZM7uHp6YkRI0YIxi5cuGDx92JXcuvWLb3PlCtWrLB5a19xwj0mJsaq12drISKyNibcc4HLly+jd+/e+Pbbb/H8+XOjx2u1WmzduhUdO3bEwoULzXo7fOvWLVy7dk0w1qZNG7NjdjXvvPMO+vTpg4IFC6JWrVoWJeDPnTtng8iIyNnVqVMHAwcO1Lt/0aJFdozG9hITEw3u7927d46u7+7unqPzLTVgwADUrVtXkXu7Eh8fH4OJTiI5HTt2xOHDh7Fz506LFn2XS6Dr6+EOyPdCNrWlTNZxcpXsBQsWdOqEe9aMLbmWaXny5LFZhTvlLnXr1pX8PO3fv1+haJzDkydP9LbM++2331CpUiWbxyD3mRkdHW2165uSRyEiMgcT7k7s+fPnmDp1Kj766CNcvnxZst/LywuDBw/GlClTUKRIEcn+ly9fYtGiRejYsSO2bNli0lvd7du3C7YLFy6MWrVqWf6XcBEqlQpDhgzBP//8gwULFqBKlSpKh0REuUi/fv0MVmbHx8fbMRrbefz4MT7//HO9+48fP4433ngjR/dwc3PL0fmWCggIwLx583Ds2DH2ESVyQGq12uIXcnLJcX0V6oBpFe6GergD8hXuAQEBsuMlSpTQG4uSxAn0rIS7vgp3WyXcHz9+jEuXLtnk2mR/Hh4eaNiwoWBsz549CkXj+A4ePIiWLVvq3W+v2R9yn3mGngnN8ezZM/zzzz9WuRYRURYm3J2QRqPBxo0b0aFDB2zatEm2fUzTpk2xceNGREREoHXr1ti4cSOGDBki+2Y4Pj4ekydPRt++fZGQkGDwvuKEe6tWrcyeVkuvv/AQEVmTobYmCxcutMqi2UpbuXKlwf254feRm5sbypYtq3QYuRZ7MZMSbNHD3VjCXa7CPTAwEMWLF5eMm7sIrL2IK9yzEu1yFe5eXl42+x0QFBTEYplcpkmTJoLtEydOoEWLFtiwYQNbi2Szfv16fPrpp3r39+nTx24Lv/v7+0vGbt26lePrnjt3zub954nINTn/N1MXc/HiRXz00UeYNm2a7LT6kiVL4scff8TMmTMFVe1eXl7o06cPNm/ejI4dO8o+kF64cAFffPEFMjMzZe999uxZPHr0SDDGdjKWYcKdiKztww8/1JuA+f33340mq53BmjVrlA6BnBx7MZMS5D6bDbWUkUu4m9JSxs/PT/eML1fJHhgYKFvNXqpUKYd8Yamvwl28GHhOZh+Qa6pXr57kZ+rp06eYPn061q5dq1BUjmHv3r1o2rQpatWqhRkzZhg8dsiQIXaKyvCsIEtt2rQJffv2tfp1iYgAJtwdXkJCAvbs2YNZs2ahe/fu6N27N65cuSI5Lm/evBg2bBjWrl2LOnXq6L1eoUKFMG7cOKxZswb16tWT7D958iTmz58ve664ur1MmTIOWxHj6Hx9fSVVO0REOVGwYEHs27cP5cuXl92/cuXKXFHlTkTkbOQS6IUKFTLreHGySS75VKBAAd2f5ap0AwMDUbJkSdnzHLG3u/hZOavw5+nTpwaPsza2lMl98ubNi+HDh8vuW7ZsmewsCleQkZGht7BPbPfu3XaISKh79+5Wu1ZcXBymTp1qtesREYkx4e5g4uPjsXPnTkyfPh1du3bFu+++i9GjR2Pt2rW4fv267DnvvvsuNm7ciI8++shgD9/sypYti8jISMydOxeFCxcW7Fu+fLmkj11aWhp27dolGGvTpo3dppDlNiqVSvLvnYgop1QqFRYtWoRhw4ZJ9j158gSHDh3CixcvFIjMeThilSdZT3JyMm7fvq10GORigoODBdvu7u4ICwvTe7zcoqniinZjCfe33npLsr9QoUIoVKiQpGDm7bfflr2nJQvEWpPcmhpXrlzB0KFDBWO2XiyVLWVypw4dOsj+HCYkJGDr1q32D8gB3Lt3T/JCSywgIABTpkyRnUVja3Jrx1nSJi4xMRGtW7e2RkhERHrxW6XCHj16hG3btuGbb75Bx44d0apVK4wbNw4bNmww2pOsdOnSmD9/PqZNm4bAwECL7h8aGoqZM2dKpmFOmjQJd+/e1W0fPnwYSUlJgmNatWpl0T3pNVt/OSAi1+Tj44OPPvoIv/zyi2Tfp59+im7duiE2Ntb+gdnYwIEDrXIdc5Mq77zzjlXuS/bh4+NjsHc2kS0EBQWhV69eAF5X1k6ePBlBQUF6j5ercBdXoMv9f5w94R4aGip41vz44491LxS//vprFCxYEGq1Gp07d0alSpVki2gGDBiAypUrA3g9s7Vnz54G/pbWl/3vk+Xnn3+WjPGZmiyhUqnw7bffokePHpJ9rtrC7t69e3r3RURE4OTJk9i+fbtiyeqCBQtKxs6dO2f2dZYvX270mL1795p9XSKi7NjsTiEzZ87EtWvXEBMTY/a5+fLlQ0REBMLDw02uaDekWrVqGDlypKBHW2pqKkaNGoVffvkF3t7eknYyISEhgh7xZL6KFSuaVGW3bds2LFiwAFu2bBGM9+zZEytWrLBVeETk5KpWrYq6devi6NGjgvGYmBj8/vvv+PjjjxWKzDKG2uH0798fH330kVXuY87vVU9PT4OLiRERZRk+fDh69eoFDw8Poy995GZBiotr5K6R/dm8cOHCWLp0KbZt24aSJUvi/fff1+0rX748du7ciaSkJN3iqnIJ9+DgYPzyyy949uwZChQogH379hmM29rkEu4HDx6UjFnj+5AhycnJiIuL4/oPuZCXlxdGjBiB0NBQDB48WDd+584d3Lt3T3bNg9wsOjpa777+/fvbMRJ5FStWlIyZ2y5Ro9EYTbh/8803yJcvHzw8PJCenm7W9YmIsrDCXSE7d+40OdmeN29e1KlTB4MHD8bixYvx999/o2fPnlZ9uOzcubNkAdRbt25hypQpSExMlDzccrHUnMs+Q8Dd3R3z5s2TPS4wMBBjxoyRjLOah4iM0bemx6JFi2T7+zqyY8eO6d338ccfW/V3YlYCKrtWrVph8ODB+P333/Hbb7/hyy+/xJo1a/T2zCciEitQoIBJMyz8/f0lY+JCF7nriKvmK1asiM8++wydOnWSzGZVqVSCzzq5QhpPT0+o1WoUKlQIarUaDRs2FPSez2kC2ljfeFM/1/lMTDlVq1YtyboKUVFRCkVjf9HR0fj8888xZ84c2f179uyx+YstU8jFYG5CXN937iz58uXTtdP65ptvzLo2EVF2rHB3QD4+PqhRowZq1qyJkJAQVKxYUfKQbG0qlQrjxo3Dv//+i3///Vc3/s8//yA2Nlbwi8zDwwPNmjWzaTyuoH79+pg/fz7Onj2LunXrolq1anqPlVsMilU2RGRMp06dsHz5cjx79kyyb9GiRU5V5T5z5kzZcVtMa/7yyy8xevRowdjEiRMFX/TKlClj9fuS7aWkpFjU75XInuSS3+JkelBQEIKCgvD48WMAr5/lmzRpYvE9K1WqhDNnzui2ixYtKjnGw8MDCxcuxIoVK+Dr64t27dohPDzcovsFBwfLVqtmZ2oi3dYJd7l++ZS7qNVqhIaGCnq3Hz58GN26dVMwKvtYt24dvvvuO73727RpI1uIoJQyZcoIWu+mpaWZdf7mzZv17itatCj+/PNP3XZOPlOJiJhwdwB+fn54++23dQn28uXLK7JoW548efDdd9+hZ8+egn7t4r5oDRs2NFqRQqapXbs2ateurdseNWqU4IEn+9TG9u3b6x4Q/Pz8FF/Iiogcn7e3N7p27Srb83bRokUICwtDhQoVFIjMfPqmOTds2NDq92rQoAGaNGmi69+5fv16h6jsopxj4oycQUhICAIDA3XrbYSEhEj6uqvVasyYMQNz5sxBWloaevXqJVmc1RwtWrTA2rVrodFooFarZWdXAq8LPiZMmADAssUKu3btirS0NPTr10+2jU12rHAnexIn3E+ePIkXL17IrqngTDQaDVatWoUrV66gVq1aaNeuna6Yb8mSJfjpp5/0nhscHIxRo0bZK1STiH/ezUm4Hz9+HImJiXr3z549W7CtRE6GiHIPJtwV0qhRIzRs2BAhISEoU6aMw3yYFy9eHFOmTMGIESP0HsN2MrbTpk0b7NmzB6dOnULVqlXRvn173b5Ro0ahaNGiePLkCcLDw2W/XISGhmL69Ono06cPbt68afb9ixYtiocPH+bkr0BEDqZDhw6yCXcA+PDDD9GvXz+rLThqCzdv3tQ7/ffLL79E8+bNrX5PT09PzJw5E+np6XB3d3eY39FE5Brc3d0xd+5cLF26FHny5NH7GV21alUsXrzYKvesWrUqfvnlF5w+fRohISG6xVIN8fb2Nvs+4tlDhpj62Wtqwt3SWV3s4e4a6tatC7VarWu5l5aWhvHjx2P69OlO/VJn5cqVmDt3LoDXbW2Tk5PRtWtXDBgwAJcvXzZ47po1a2RnWivJ3IR7ZmYm9u/fDzc3N4wcOVLvcZUqVUK5cuWsEiMREcCEu2ImTJiAgIAApcOQ1aBBA/Tv3x+LFi2S7PPz80NoaKgCUbmGfPnyYcGCBUhLS4OHh4fgi4aXlxf69u0rOL5jx47YtGmTbrtfv37w9va2uBJj1apVOHToEAoUKIC6desKqu+JyDkFBATghx9+0Lu45+LFi9G8eXOH/JJx8eJF9O7dW+/+7C8lrU2lUjn1F2ySx8QZOYty5cph6tSpdr1n5cqVTUq0Z1GpVGjVqhV27NgB4HXv+SdPnug9Xq5NjTVkr4SPiIjA0qVLZY9zhEUfyXFlfc89dOiQbuzAgQN47733sHLlSof97m7Iq1evdMn2LHPnzpWMyVm1apXDJdsB6cwXubaJ2X3xxRfYs2eP0evOnj3b6KwbIiJzsGSLZPXv3182sd68eXMmIGxMpVLBy8vLpKqevn376hb5iYiIwFtvvQVAvue7KfLly4c2bdogNDSUFZ1EuUjDhg0NJtT//vtvO0ZjuuHDhysdAuUyPj4+Ji1aSUSmmTBhAj799FMMGDAAa9asweDBg6FSqeDh4YFevXoJkmOWtKbo2rWr0WPc3Nx0fx40aBD+85//SI6ZNGmS2ffO4uvry5d0LmLAgAGSsSdPnmDBggUKRJMzWq0WY8eOtejc7777zmFbDj59+lSwPX/+fMkxjx49wqRJk9CzZ0+Tku0dO3Z0yhcqROTYmFEjWWq1Gt988w2KFSsmGH/vvfcUiojkBAUFYcGCBdi5c6fuCw7wuh+/JfhWnyj3+vzzz/XuW7ZsGV69emXHaExjqM+mI1bkExG5Gk9PT3z44YcYMGCArgBk586d+PvvvzF8+HCsWLECw4YNw08//YRGjRqZff3OnTsbPSYjI0P3Z5VKha+//hq7d+9GaGgofHx80LZtW5sssE25T+XKldG4cWPJ+Pbt2/H8+XMFIrLcrVu3cPDgQYvOdeTFQm/fvm30mCFDhmDr1q24cuWK0WPz5MljsJ2u3P8PRESmYMKd9PLz80NkZCSqVasGf39/DB8+XFdBTY5NLuG+YsUKwWJaISEhggR7pUqVJOe8/fbbtgnQgDlz5uTo/Fq1alknEKJcplatWvjmm2/07t+9e7cdozHu5MmTBvfXrVvXTpEQEZE5ChYsCD8/PwCvX45+9NFHeOeddyy6VtZ1DJHr4Zw/f37MnTsX+/fvx6RJkwRV8OZKTk42KclHucPEiRNRo0YNwVhaWho2bNigTEBmunHjBs6dO4ejR49adL4jJ9v1admyJT777DP8+OOPqFWrFu7evWvyuStWrDC4HgUXWyciSzHhTgaVLFkSS5cuxd9//41evXopHQ6ZSO5LhY+PDxYvXoy+ffti+PDhmDdvHgYMGACVSoX8+fNj2LBhknMGDRqEggUL2iNkndDQUAwePBiBgYEWnTt+/HgbREWUO7Rq1Qp16tSR3TdhwgRcu3bNzhHJu3r1qtGFXE2peiQiIudmacLdmtiKyrX4+flh8eLFklkRv/76q9F+4UqbPHkywsPD0bdvX/zwww9mn1+5cmUMHTrUBpHZ1pMnT3DgwAEsW7bMrPN+/vlno+2i+LNPRJZiwp0oF5J7MChQoAAKFSqEQYMGoVevXvD09ET//v0RFRWFnTt3yi6QGhISgr/++gsHDhwQVMebqnnz5mafo1arERERgZUrV5p1nq+vL+bOnYsSJUpYXEVF5Apmzpypd9+IESOQmppqt1g0Gg1OnjyJ69evIzU1FT/++CO++uorDB482Oi5xYsXt0OERESkJE9PT6PV6ffv37dpDCkpKUhJSbHpPcjx9OjRQ7CdkpKCefPmITMzU6GIDLty5Qq2bNli9LjZs2ejRYsWgrGRI0fi5MmT+PXXX1GyZElbhWgV1mqB6uPjg5CQEKPHGap+JyIyhAl3olxIPA2yUaNGeiuEPDw8DH6R8fT0hLe3t1mL5ebNmxft2rUz2vPO0ANTThZtlavWJ6LXfHx8sGnTJtl9cXFxOH78uN1iGTFiBAYOHIju3bujUaNGWLZsGbZv326wdzsA2QXxiIgod/Ly8jK4v1SpUja9PxdNdU0VKlRAq1atBGObN29GgwYNcOLECYWi0m/fvn0G97u7u+OPP/5Ao0aN8O2332Lnzp3YuXMnjh07hg8++MA+QVrBlClTrHKddevWmXQcK9yJyFJMuBPlQq1bt0b//v1RtWpVREREYOrUqTm+prEvO1kGDBiAgwcPYsKECUYrAgwl+s1NuGd/IVC5cmUEBQWZdT6RKwkODkbNmjVl933++edmT8m1xOXLlxEVFWXRuZ06dbJyNOQqWKlK5HyMPYMaa0FGZKmPP/5YMpaeno6xY8caLQ6wpYyMDMyePRu1atVCrVq18N5772HJkiV6jw8ODsaRI0fwxhtvAHhd9FSoUCEUKlQoR+sbKEFcnW+Jbdu2oUiRIiYdy5dtRGQpJtyJciG1Wo2PP/4Yv/zyCwYPHiy7iKq5zKlwz+Lh4WFwv6EHPHMf/sT3cnd3N+t8IlczYMAAvft+/PFHXLhwwab3nzRpksXnVqtWzXqBkEthpSqR89H3DOrt7Y0PPvjA5q0EuWiq6ypRooTsIu3Pnz/Hl19+iVevXikQFbBy5UqsXr1at/3w4UO9xwYFBWH27NlWa8WitJzMggaAP/74w6y1who2bGjR2mJEREy4E5FJLOlfZyxJb80KdzF91btE9FqhQoUM7h85ciQWLFiAmzdv2uT+t27dsui8EiVKWDkSIiJyZHIV7h988AEOHDiAkSNH2jyRyEVTXVvHjh1lx6Oiogyui2NLq1atMnpM8+bNERUVhb/++svmbZechUql0lX5m8rNzQ2LFy+2UURElJsx4U5EJpFLzn344YcGzzGWcDc0RTin0xv79+9v0nH2aJ1B5IjeeOMNvWs7AMDTp0+xePFidOvWDXfv3rVjZIYZe1FAZAgrVYmcj9zzZMGCBRWIhFxRWFiY3jYmf/75J6Kjo216/8zMTFy7dg1Pnz4FAMTGxiIhIcHgOZGRkZg+fbpFM5SdQfv27S06LzIy0qLzihUrZtF5ROTamHAnIpPIVYxHREQYPMdYW5eJEycKtrt3727yucYULVoUI0eONHrcW2+9laP7jBs3LkfnEynF09MT48aNQ/78+Y0e26lTJ8WmTYuxypBygpWqRM5HLmlojXaJpuLaD65NrVZj6tSp+Ouvv/DDDz8IZlRoNBr8+uuvNrt3eno6+vbtiw8//BAtWrRAkyZNsHLlSoPneHh4oE6dOjaLyRGY8v1rx44diIqKQo8ePVCtWjV88sknqF27th2iIyJ6jQl3IjJJy5YtBQuRdu/e3WiizlBVRbdu3VC3bl106NABnp6eeOuttwQV82q1Gs2bNzc5Pq1WKxmrVKmSyedbqkmTJja/B5GtNG/eHLt378aJEycwdOhQg8du27bN4H6NRmPyfbVarcVto/r162fReURE5JzkZkTas3KXaz8Q8LoXesOGDdGzZ0/B+JYtW2xW5X7gwAFcvHhRt52UlCTo3S6nXr16OW7N6ej0/f38/f1RrVo1bN++HYULF4anpydGjBiBpUuXomfPnrn+3wsRORZ+4hCRSTw8PPDrr79i0KBBGD9+PEaMGCF7XI0aNXR/lqtSHzBgAObOnYvPP/8c7u7uGD9+PKKiorBs2TJBQh8AJk+ejHfffVdyja+//tqkmO0x/S+nrW+IHIFKpULv3r3RtGlTvcd8++23suMZGRkYN24cateujVq1amHMmDFISkoC8LoqcP369di5c6cgIZ+ammpygj4iIkLXRqZt27Y5npVCRETORS7hbqgtIZEtde/eXfDCR6PR4Oeff7bKtVNSUrBp0ybs27cPGo3GaDU7AEHVdmBgIL766iurxOLoPv74Y8nY33//jaVLlyIgIECBiIiIhHLWs4GIXIq/vz/69u0rGBs+fDjmzp0LAKhSpQreeecd3T65ZHTjxo1RoUIFk+7n6emJfv364Z9//hGM16tXz6TzAwMD0bRpU+zZs8fgcR999BGWL19u0jXlfPnll/jmm28sPp/IUZQsWdLg/kuXLqFKlSq67cePH+OPP/7Azp07dWO7d+9G0aJF0a9fP3Tv3h0xMTEAgIsXL+Kzzz5DamoqNm3aZFI8np6e+OCDD9CvXz+8fPnSYM95IiLKneSq2e2ZcE9OTkZcXByr3AkAULhwYXzwwQeC7w47duzAnTt3kJSUhDZt2sgmg/XRarXYvHkzFi1ahNjYWLPjGTp0KCpXrmz2ec6uV69eWLhwoW57yJAhCkZDRCTFhDsR5UivXr3w1ltvISEhAQ0aNBD0NZRLuGdmZpp1/TJlyiA4OFg3VbNChQpmLZo4bdo07NmzB25ubti8eTOioqIkx4SHh+Pw4cO4ceMG3nzzTQQHB2P37t2S4/z9/fHkyRPBmFqtRvv27Zlwp1zB19fX4P59+/ahbNmy+OeffzBz5ky8ePFC9rhTp04hICBAl2wHgNWrV+PcuXO4dOmSSbEEBQVh1KhRuoXxcuvCX0REZJjSLWV8fHyQmppqt/uR4+vVqxdWrVqFjIwM3djVq1cBAIsWLcKzZ8/w/vvvo2LFikavtX37dr2zCI2pWLGiSffIjby8vHD8+HFcuXIFRYsWNev7IRGRPTDhTkQ59vbbb8uOyyXczenzDLxudTFnzhwsWLAAbm5uGDx4sOxxpUqV0htDVluaP/74Q/aYgIAArFixAgkJCShYsCDWrVsnSbgXKVIEPXr0wKxZswTjWb0Af/nlF0RERJj99yNyJNWqVTO4f9WqVVi2bJnR61y5cgVXrlyRjJuSbK9Zs6agYomIiFyb0hXuRGL58+dHaGgoDhw4ILt//fr1WL9+Pbp06YLRo0cLCpKyaDQaxMbGYsGCBRbFUKZMGcyfP9+l+5Kr1WrBzEsiIkfiup/ORGRzAQEBCAwM1G3ny5fP5HYy2QUHB2Pq1KmYMmUKihYtCgAYNmyY4Bh9PeVN5eHhgcDAQHh4eKBjx47IkyePbl/FihWxdu1a3b2zy3qArlq1KhYvXoyBAwfmKA4iJVWvXl3vyysASEtLs3kM4rZVRETk2tjDnRxRu3btjB6zfv16NGjQAM+ePQPwOsl+8eJF9O/fH7Vr10bbtm0FswENKVGiBJYuXYouXbpg/PjxWLduHVvtERE5MFa4E5HNqNVqjBo1ClOmTEFGRgZGjRoFDw8Pq1z7ww8/xKtXr3Dt2jW0adMG5cuXN3qOVqs16dre3t5YunQp1qxZg4CAAPTt21fvF7vsFSvVqlVDtWrVkJ6ejiVLlpj2FyFyIGq1GkuXLsW2bdtQoEABlC1bFh988IFd7p0nTx58//33gsW/iIiIbt++LRljwp2U1rhxY/Ts2RO///47kpOT9R736tUrdO7cGYMHD8bMmTMFbWgM8fLywqtXrwC8rqj/9ttvUblyZaOzEYmIyDEw4U5ENtWkSRM0adLE6td1d3fHgAEDrH7dLOXLl8fEiRONHic3jbNbt27Yu3cvbt26haCgIFuER2Qzfn5+CA8PBwC79awdOnQoevfubZd7ERGRc0lKSpKMZZ+JSKQElUqFTz75RDfrdvr06XoXhX/27BmmTp1q0nWbNm2KCRMmwNfXF1qtFvfv30dgYCBfMhERORkm3ImIrKxQoUJYsWIFHjx4wIQ7OTVvb2/4+fkhMTHRpvfp2LGjTa9PRETOK2vx7Ozy589vt/unpKQgJSXFbvcj55JVfNO7d29s3rzZ4vWcBg8ejIiICMGYSqVCiRIlchwjERHZHxPuREQ24OXlhTJlyigdBlGOBQYG6k24BwcHo2LFikhOTkaJEiWwbt06i+7BHqRERKRPlSpVcOLECcGYPRPuvr6+drsXOa9i/8fefcc3Uf9/AH8lbdPSFlqglI1sFRUUAQGRDSLKEFkiQxHZS5lfUKayQYZMGTJkC4iACgooQ5ZsobIKZZWyShedye+P/hp7I8klueTS9PV8PHzIfXK5e5Mr17t33vf+FCuGwYMHY9asWYrWL168OLp27YqIiAhUqlQJrVu3dm2ARETkVky4ExEpVL16dcFygQIFVOtJT+SpLE2UOmDAAHTr1k0w5uPjg7Vr19q1/VKlSjkcGxEReb+sPtbZ8fqLPFGnTp3QuHFjJCcno0SJEqhZs6ZsxfvChQtRrVo1wVxQRETkXaTNh4mIvFS1atWcen9gYCCGDh0KHx8fBAYGYuTIkbxQJq/Xvn17yVjdunUlyXYA6N69O4oXL25ebtmyJU6cOIETJ07g999/x+7du/H2228L3jNkyBD1gyYiIq/x0ksvabr/hIQE2YlbieSEh4ejVKlS0Ov1GDNmjOT1YcOGoXr16ryHICLycqxwJ6Jco23btlizZg0ePXoEABgxYoTd2+jYsSPee+896HQ6+PryFErer2nTppg7d66g0t3ShMKhoaFYs2YN9uzZg7CwMLzxxhvm17Ie/+/Xrx/u3LmDf//9F++88w5q1arl2r8AERHlaA0aNEDRokVx9+5dAJm9rt0pKCjIbZOIk3dp2LAh5s+fj/v37wPIvKZq166dxlEREZE76Ewmk0nrILzd/fv3ER4eLhiLiYlBoUKFNIqIKPd6+PAhfvvtN5QsWRK1a9fWOhyLeN4gT3Lnzh3s27cPxYoVQ4MGDbQOh8gpPL8S5TxPnjzBr7/+ikKFCqF+/fpurw7meYMc9ejRI/zyyy8oUqQIGjRowMr2XITnDaLcjQl3N+CJlojsxfMGEZFr8PxKRPbieYOI7MXzBlHuxh7uRERERJQrJCYmIjExUeswiIiIiIjIi7EBMRERERHlCsHBwVqHQEREREREXo4V7kREREREREREREREKmDCnYiIiIhyhXv37uGff/7ROgwiIiIiIvJibClDRERERLlC4cKFtQ6BiIiIiIi8HBPubmA0GiVjDx480CASItJSwYIFodcre7CI5w0iAuw7b5DjeH4lyl3sPbfyuoyIAOXnjsTERMTHx0vGed4gyj10JpPJpHUQ3u7ixYuoVKmS1mEQkcZiYmJQqFAhRevyvEFEgH3nDbItMTERERERqFatmtahEJGG7D238rqMiADl5w6dTueGaIjIk7FkioiIiIhyhaCgIAQGBmodBhEREREReTEm3N3g0aNHWodARDkMzxtERK7B8ysR2YvnDSKyR0JCAvbs2aN1GESkISbciYiIiIiIiIiIVBAUFIQ8efJoHQYRaYiTprpB2bJlJWPnz59HeHi4S/ebmJiIMmXKAAAiIyMRFBTk8m0oXd/WepZet2c8+9iJEyck/VovXLiAsLAwBZ+Cczz1ODh6DCy9pmTs6dOnkv6X7jgOWhwDufcULFhQ8f5y8nnDke248mfW0fNGbvuZVeP87chrnnr+9pR/C/acN0iZnHx+5b9r53jKv2tel2n/b8Hec2tuOm8ofQ/v51y7DS3O3zxv2H5PTrifAzz3Z5a/61y7DebjpDQ9DiZyuZiYGBMAwX8xMTEu329CQoJ5fwkJCW7ZhtL1ba1n6XV7xrOPRUZGanIMrMXsym0oWd/RY2DpNSVjuenfgrP7zcmflSPbceXPrKPnjdz2M6vG+duR1zz1/O3J/xbIOfx3bd96/Hft/HZ4XWbf39UV23B2n7nps1L6Ht7PuXYbWpy/ed5Qd79afVYmk+f+zPJ3nWu3ocZ5w9rrPH/bdxx0JpPJBHKp+/fvS77FVDq7NamDx8Az8Dgox8/KM/A4aI/HgNTGnynt8Rh4Bh4H5fhZaY/HwDPwOCjHz8oz8DhoL7ceA/ZwJyIiIiIiIiIiIiJSARPuREREREREREREREQqYMKdiIiIiIiIiIiIiEgF7OFORERERERERERERKQCVrgTEREREREREREREamACXciIiIiIiIiIiIiIhUw4U5EREREREREREREpAIm3ImIiIiIiIiIiIiIVMCEOxERERERERERERGRCphwJyIiIiIiIiIiIiJSARPuREREREREREREREQqYMKdiIiIiIiIiIiIiEgFTLgTEREREREREREREamACXciIiIiIiIiIiIiIhUw4U5EREREREREREREpAIm3ImIiIiIiIiIiIiIVMCEOxERERERERERERGRCphw9zDp6en47LPPEB4ejpCQEPTq1QtJSUlah5WrmUwmNGvWDLNnz9Y6lFzl3r176NKlCwoXLoywsDC0a9cOt2/f1josj8Vzh2fheUM7PHeQmnhu9Tw8v2qD51bleN7wPDxvaIfnDuV47vAsPG9ox1vOG0y4e5jPP/8c27Ztw5YtW7Br1y7s27cPn376qdZh5Vrp6eno1asXfv31V61DyXXatm2LGzduYNeuXdi7dy+ePHmCFi1aID09XevQPBLPHZ6D5w1t8dxBauK51bPw/KodnluV43nDs/C8oS2eO5TjucNz8LyhLa85b5jIYzx9+tQUFBRk2rx5s3ls7969Jl9fX9PDhw81jCx3+ueff0zVq1c3lS5d2hQaGmr6+uuvtQ4p14iIiDABMEVERJjHbt26ZQJgOnHihIaReSaeOzwHzxva4rmD1MRzq2fh+VU7PLcqx/OGZ+F5Q1s8dyjHc4fn4HlDW9503mCFuwc5ffo0EhMTUa9ePfNYnTp1YDKZcPToUQ0jy53+/PNP1KpVC6dOnUJISIjW4eQqhQsXxo4dO1ChQgXJa0+fPtUgIs/Gc4fn4HlDWzx3kJp4bvUsPL9qh+dW5Xje8Cw8b2iL5w7leO7wHDxvaMubzhu+WgdA/7l9+zb8/f0RFhZmHvPz80PBggVx69YtDSPLnXr37q11CLlWaGgo3n77bcHYzJkzERwcjJdfflmboDwYzx2eg+cNbfHcQWriudWz8PyqHZ5bleN5w7PwvKEtnjuU47nDc/C8oS1vOm8w4e5BkpKS4O/vLxn39/dHSkqKBhEReYbVq1dj9uzZmDNnDoKDg7UOx+Pw3EEkj+cOcgbPrUTyeG61jOcNIst47rCM5w4ieTn5vMGWMh4kT548sifTlJQUBAYGahARkfYWLlyIDz/8EJ999hkGDBigdTgeiecOIimeO8hZPLcSSfHcah3PG0TyeO6wjucOIqmcft5gwt2DlChRAikpKXj8+LF5LC0tDQ8fPkTx4sU1jIxIGxMmTEDfvn0xatQozJgxQ+twPBbPHURCPHeQGnhuJRLiudU2njeIpHjusI3nDiIhbzhvMOHuQapUqYKgoCD88ccf5rGDBw9Cr9ejevXqGkZG5H6zZs3C2LFjMX36dEycOFHrcDwazx1E/+G5g9TCcyvRf3huVYbnDSIhnjuU4bmD6D/ect5gD3cPkidPHvTs2RMDBw5ESEgI/P390atXL3z00UcoUKCA1uERuc2lS5cwcuRI9OzZE507d0Z0dLT5tfz588v2t8vNeO4gysRzB6mJ51aiTDy3KsfzBtF/eO5QjucOokzedN5ghbtKOnbsiBIlSlh8fcWKFahatSqCg4MRHh6Ozp0748aNG5L1pkyZgpYtW6JNmzZ45513UL9+fcyZM8eVoXsdtY4FOUaNz3/z5s1IS0vDkiVLULRoUcF/P//8s6v/Cm7Fc4dn4HlDezx3kJp4bvUcPL9qi+dW5Xje8Bw8b2iP5w7leO7wDDxvaI/nDRETOe2rr74yATAVL15c9vURI0aYAJgqVapkGj58uKljx44mHx8fU1hYmOnatWtujta78Vhoi5+/ffh5eQYeB+3xGJCa+PPkOXgstMXPXzl+Vp6Dx0J7PAbK8bPyDDwO2uMxkGLC3QlPnz419erVywTA4g/WqVOnTABMderUMaWkpJjHt27dagJgatGihTtD9lo8Ftri528ffl6egcdBezwGpCb+PHkOHgtt8fNXjp+V5+Cx0B6PgXL8rDwDj4P2eAwsY8LdQdu3bzeVLl3aBMDUvHlziz9YPXr0MAEw7dmzR/Ja/fr1TTqdznTr1i13hOy1eCy0xc/fPvy8PAOPg/Z4DEhN/HnyHDwW2uLnrxw/K8/BY6E9HgPl+Fl5Bh4H7fEYWMce7g5atmwZ4uPjsWDBAuzYscPiegcOHICvry/q1q0rea1Ro0YwmUzYt2+fK0P1ejwW2uLnbx9+Xp6Bx0F7PAakJv48eQ4eC23x81eOn5Xn4LHQHo+BcvysPAOPg/Z4DKzz1TqAnGrw4MFYvXo18ubNa3GdjIwMXLp0CaVLl4bBYJC8Xq5cOQBARESEy+LMDXgstMXP3z78vDwDj4P2eAxITfx58hw8Ftri568cPyvPwWOhPR4D5fhZeQYeB+3xGFjHhLuD6tevb3OduLg4mEwmFChQQPb10NBQAEBsbKx6geVCPBba4udvH35enoHHQXs8BqQm/jx5Dh4LbfHzV46flefgsdAej4Fy/Kw8A4+D9ngMrGNLGRdKSEgAAPj7+8u+njWenJzstphyKx4LbfHztw8/L8/A46A9HgNSE3+ePAePhbb4+SvHz8pz8Fhoj8dAOX5WnoHHQXu5+Rgw4e5CAQEBAIDU1FTZ11NSUgAAwcHBbospt+Kx0BY/f/vw8/IMPA7a4zEgNfHnyXPwWGiLn79y/Kw8B4+F9ngMlONn5Rl4HLSXm48BE+4uFBISAr1eb/HRiKzxkJAQ9wWVS/FYaIufv334eXkGHgft8RiQmvjz5Dl4LLTFz185flaeg8dCezwGyvGz8gw8DtrLzceACXcXMhgMKFeuHKKiopCWliZ5/erVqwCASpUquTu0XIfHQlv8/O3Dz8sz8Dhoj8eA1MSfJ8/BY6Etfv7K8bPyHDwW2uMxUI6flWfgcdBebj4GTLi7WL169ZCamopDhw5JXvvtt9+g0+nw+uuvaxBZ7sNjoS1+/vbh5+UZeBy0x2NAauLPk+fgsdAWP3/l+Fl5Dh4L7fEYKMfPyjPwOGgv1x4DE6kCgKl48eKS8cOHD5sAmGrVqmVKSkoyj2/dutUEwNSqVSs3Rpk78Fhoi5+/ffh5eQYeB+3xGJCa+PPkOXgstMXPXzl+Vp6Dx0J7PAbK8bPyDDwO2uMxEGLCXSWWfrBMJpOpX79+JgCmChUqmIYNG2Z6//33TT4+PqbChQubrl696uZIvR+Phbb4+duHn5dn4HHQHo8BqYk/T56Dx0Jb/PyV42flOXgstMdjoBw/K8/A46A9HgMhJtxVYu0Hy2g0mubNm2d68cUXTf7+/qZixYqZPvjgA6/9odIaj4W2+Pnbh5+XZ+Bx0B6PAamJP0+eg8dCW/z8leNn5Tl4LLTHY6AcPyvPwOOgPR4DIZ3JZDIpbT9DRERERERERERERETyOGkqEREREREREREREZEKmHAnIiIiIiIiIiIiIlKBr9YB5AZGoxEPHz4UjBUsWBB6Pb/vICJ5PG8QEbkGz69EZC+eN4jIXjxvEOVuTLi7wcOHDxEeHi4Yi4mJQaFChTSKiIg8Hc8bRESuwfMrEdmL5w0ishfPG0S5G79aIyIiIiIiIpKRmJiIxMRErcMgIiKiHIQV7kREREREREQygoODtQ6BiIiIchhWuBMRERERERERERERqYAJdyIiIiIiIiIZCQkJiIyM1DoMIiIiykHYUoaIiIiIiIhIRlBQEJKSkrQOg4iIiHIQVrgTEREREREREREREamACXciIiIiIiIiGYmJiUhMTNQ6DCIiIspB2FKGiIiIiIiISEZwcLDWIRAREVEOwwp3IiIiIiIiIiIiIiIVMOFOSEtLw8WLF5Gamqp1KEREbnXv3j3cuXMHJpNJ61CIiCgbk8mES5cuISYmRutQKJdLSEhAZGSk1mGQBQkJCbh06RKSk5O1DoWIiHKImzdv4ubNmy7dBxPuudzZs2fRqlUrdOnSBa1atcK9e/e0DomIyC22bduGVq1aoWXLlpg2bRqT7kREHsJkMmHIkCHo1KkTWrZsid27d2sdEuViQUFBCAoK0joMknH9+nW0bdsWnTp1QqdOnfDo0SOtQyIiIg/37bff4t1338W7776LpUuXumw/TLjnYn/++Sf69Oljrhy6f/8+5s6dq3FURETusWTJEqSnpwMANm3ahFOnTmkcERERAcCxY8fw559/AgDS09OxYsUKjSMiIk+0YsUKPHjwAAAQFRWFXbt2aRwRERF5sqdPn2Lx4sXm5UWLFiEpKckl+2LCPZf68ccfMXToUKSkpAjGf//9d1YGEJHXS05OlrQpmDlzpkbREBFRdtlvhADg8uXLGkVCRJ5s586dguXZs2drEwgREeUI0dHRkrE7d+64ZF9MuOcyJpMJy5Ytw8SJE2E0GiWvp6enY+vWrRpERkTkPk+ePJGM/fvvv7h//74G0RARUXYRERGSsYyMDA0iIQISExORmJiodRikgF7P9AYREVnm4+MjGXPVNSZ/I+UiRqMR06ZNw8KFC62u98MPP/Cmhoi8mlzCHQC/cCQi0lhsbCxSU1Ml4/Hx8RpEQwQEBwejTJkyWodBCuTJk0frEIiIyIP5+vpKxphwJ6ekpqZi5MiR2LRpk+S1Zs2aCZZjYmLwxx9/uCs0IiK3i42NlR3/4YcfkJaW5t5giIjI7Pjx47LjcXFxbo6EiDyZ3GT3TLgTEZE1ck9CZc3rpvq+XLJV8ijx8fHo378/9u7dKxjX6XQYPnw4vvzyS7z44ouC1zZu3OjOEImI3MpSwv3hw4fYt2+fe4MhIiKzY8eOyY6zwp20kpCQgMjISK3DIJGnT59KxphwJyIia3Q6nWRM7gtcNTDh7uXu37+PTz75BCdPnhSM+/n5YdKkSWjfvj0AmP+f5cSJE7h27Zrb4iQicidLLWUAYPfu3W6MhIiIsjt69KjsOCvcSStBQUEICgrSOgwSefTokWSMCXciIrJGbi5LV2HC3YvduHEDH330Ea5cuSIYDwwMxLx589CkSRPzWOPGjREaGipYb/Pmze4Ik4jI7awl3GNiYtwYCRERZXn8+DHu3Lkj+xor3IkoO7mEOxERkTWuqmaXw4S7l7p06RJ69OiB6OhowXjBggWxdOlSVKtWTTBuMBjw7rvvCsZ27NiBpKQkl8dKRORu1hLuiYmJboyEiIiy3L171+JrrHAnouweP34sGZNrM0NERJRFLuEu12ZGDUy4e6Fz586hV69ekouQUqVKYcWKFahYsaLs+9577z3BBAJJSUnYuXOnS2MlItKCpR7uAPhFIxGRRsSFItkx4U5E2clVuDPhTkRE1rClDDns77//Rt++fSWP3VaqVAnLli1DsWLFLL63SJEieOONNwRjGzdudOsjF0RE7sAKdyIiz2Otwp0tZUgriYmJvDbwQKxwJyIie7GlDDnk0KFDGDBggORCo2rVqli0aBHy589vcxviyVMjIyPx999/qxonEZHWrFW4P336lF80EhFpgC1lyBMFBwejTJkyWodBIpYq3HkNR0REljDhTnbbu3cvhgwZgtTUVMF47dq1MXfuXAQGBiraTvXq1fHMM88IxjZu3KhanEREnsBawt1kMrFCiohIA6xwJyKl5BLuRqMRaWlpGkRDREQ5ARPuZJedO3di5MiRSE9PF4w3bNgQM2bMQEBAgOJt6fV6tGvXTjC2f/9+xMTEqBIrEZEnsNZSBmAfdyIiLbDCnTxRQkICIiMjtQ6DRORaygBAcnKymyMhIqKcgj3cSbHNmzdj7Nixkh+a5s2bY/LkyTAYDHZv85133kGePHnMy0ajEVu2bHE6ViIiT5Cenm6zFysT7kRE7sdJU8kTBQUFISgoSOswSESuwh1gH3ciIrJMrsLdVVXvTLjnYKtXr8aUKVMk4++99x7GjRsHHx8fh7YbHByMt956SzC2ZcsWPp5HRF7BVnU7wIlTiYjcLSkpyWpSnS1liCg7SxXuTLgTEZElcsl1V1W9M+GeA5lMJixZsgRz5syRvNalSxeMHDkSer1zh1Y8eeqjR4+wd+9ep7ZJROQJ5BLu4nkuWOFORORe1qrbAVa4E9F/jEajxfl4mHAnIiJL5JLrrHAnAJk/CLNnz8aSJUskr/Xq1QsDBw6ETqdzej/ly5dH1apVBWOcPJWIvIH4Bi04OBj58uUTjLHCnYjIvaz1bwcyz8vu7LtJRJ7ryZMnFs8HTLgTEZE9mHAnGI1GTJ48Gd9//73ktcGDB+OTTz5RJdmeRTx56pkzZ3Dt2jXVtk9EpAVxhXtISAgr3ImINCaucC9UqJBkHbaVISLAcjsZgJOmEhGRZaxwJ1lTpkyRTF6q0+kwatQodO7cWfX9NWjQAGFhYYKxY8eOqb4fIiJ3Ele4h4SESCZDY8KdiMi9xBXuFStWlKzDtjJEBFieMBVghTsREVnGHu4kcf78eUmyXa/XY/z48WjTpo1L9unr64vatWsLxs6ePeuSfRERuYu4wj00NFRS4c6WMkRE7iVOuJcuXRp+fn6CMVa4kxYSExN5XeBhmHAnIiJHuKqaXQ4T7jnEhg0bBMu+vr6YOnUqmjdv7tL9Vq5cWbDMhDsR5XRyCXdWuBMRaUuccC9atCjy5s0rGGOFO2khODgYZcqU0ToMysbShKkAE+5ERGSZXDU7K9xzsYcPH2LPnj2CsZ49e6JBgwYu37c44R4dHY2YmBiX75eIyFXkWsqwwp2ISFviHu5FixaVTGjNhDsRAaxwJyIix8hVuLOHey72ww8/ID093bxsMBhc1kZGrHTp0ggODhaMscqdiHIyJS1lWOFOROQ+8fHxkoIOuYQ7W8qQFhISEhAZGal1GJSNtYQ7J00lIiJLmHAns7S0NPzwww+CsWbNmiE0NNQt+9fr9WwrQ0RehZOmEhF5loiICMGyn58fypQpw5Yy5BGCgoIk1wmkLWtJdVa4ExGRJUy4u9m9e/fQpUsXFC5cGGFhYWjXrh1u376tdVgAgN9//x0PHz4UjHXs2NGtMTDhTkTehC1liIg8y8WLFwXL5cuXh5+fHyvciUhWSkqKxdeYcCciIjlPnz7FnDlzJOPs4e5Cbdu2xY0bN7Br1y7s3bsXT548QYsWLQRtXLQiniz1lVdeQcWKFd0agzjhHhERYfUih4jIk3HSVCIizyKucH/++ecBgBXuRCQrNTXV4mtMuBMRkZzp06fLFhC7qsLd1yVbzUH+/fdfHDx4EBEREXj22WcBACtWrECJEiVw5swZvPrqq5rFduHCBZw7d04w1qFDB7fH8cILL0Cv15u/9UlPT8fFixfx8ssvuz0WIiJnGI1GSYUkK9yJco/ExET++/ZA4gr3rIS7eB4hfhlKRAAr3ImIyH7bt2+XHTeZTIiLi0NGRgby58+v2v5yfYV74cKFsWPHDlSoUEHymta/rNevXy9YDg8PR/369d0eR1BQEMqXLy8YY1sZIsqJEhISJI+McdJUotwjODgYZcqU0ToMyiY+Ph43b94UjGUl3AMCAgTjnAyRiIDMec4s4XmCiIjssXPnTjRr1gxNmjTBokWLVNturk+4h4aG4u2334Ze/99HMXPmTAQHB2tawf3o0SPs2bNHMNa2bVv4+mrzUAL7uBORNxD3bwc4aSoRkZbkJkwtV64cACBPnjyC17QuhiEiz8AKdyIiUsvevXvNrcqWLl2KR48eqbJdr0+4X7lyBTqdTvY/uWrx1atXY/bs2Zg0aZLkMVZ32rJli+Cbe4PBgHfffVezeOQS7q7qc0RE5CrihHtAQAD8/f3ZUoYol0hISEBkZKTWYVA2liZMBZhwJyJ57OFORESucuLECVW24/U93J955hnJhXwWcYJl4cKF6N+/Pz777DMMGDDAHeHJSk9Pxw8//CAYe/PNN1XtJWQvccL90aNHuHPnDooXL65RRERE9hNPmBoSEgIAkgr3lJQUZGRkwMfHx22xEZHrBQUF8QkWD2NpwlSACXcikseEOxEReTqvT7j7+fnhueees7nehAkTMHbsWHz++eeYOHGiGyKzbO/evbh//75gTIvJUrMrXrw4ChQoIHi04syZM0y4E1GOIq5wDw0NBSD9AhbIbCuTN29eN0RFRJR7WZowFWDCnTwDJ1v2PGwpQ0REns7rW8ooMWvWLIwdOxbTp0/XPNkOSCdLrVKliqIvDVxJp9PhpZdeEoyxjzsR5TSWKtwtJdyJiMh1UlJScOvWLcHYs88+a/6zeNJUJtJIC5xs2fNYq3DnpKlEROQMtdpn5/qE+6VLlzBy5Ej07NkTnTt3RnR0tPk/a9+cu0pERIQkka11dXuWKlWqCJaZcCeinEaccM+qcBe3lAHYx53IG7FS1bPcuHFDclOTPbHJCnciksMKdyIi8nSChHtsbCyGDx+OZ599Fnny5MEzzzyDgQMHStqbuEPHjh1RokQJq+usWLECVatWRXBwMMLDw9G5c2fcuHHDrv1s3rwZaWlpWLJkCYoWLSr47+eff3bmr+CQDRs2CJYLFSqEhg0buj0OOeI+7leuXGEFKBHlKJZayvj4+MBgMAhe4/mNyPuwUtWziCewLVq0qCDJLk64Jycnw2g0uiU2oiycbNnzpKWlWX0tIyPDjdEQERFJmRPu8fHxeOONNzB9+nSUKFECAwYMQJUqVTBv3jy88soruH37ttuCmjRpkiTxLDZy5Eh0794dKSkp6NevHxo1aoT169ejWrVqdl0QjRo1CiaTSfa/1q1bO/k3sc/jx4/x66+/Csbatm0LX1/PaLX//PPPC2IxGo04f/68hhEREdnHUksZQFrlzoQ7EZFrXbt2TbAs/jJEnHAHrFe2ErlCUFCQ7JNwpA2j0Wg14Q6wrQwRETlO9ZYyEydOxPnz5zFu3Dj8/vvvmDZtGrZv34558+bh9u3bGDNmjCo7tCY5ORm9e/fG6NGjra53+vRpTJ06FXXq1MGpU6cwdepUrFu3Dps3b8aDBw8waNAgl8eqlD2PLm/dulXQj87Pzw/vvvuuq0Kzm7+/v6CvJsC2MkSUs8THxwuWs0+KKu7jzrYTRN6HlaqeRXwslCTc2S6CKHezlWwHeJ4gIiLtmRPu165dQ+HChTFs2DDBCl26dAEAHDp0yOqGvv/+e/z999+S8Vu3bmHevHk2A/npp5/w/PPPY/HixWjevLnVdefPnw8AGDt2rKAFQOvWrVG/fn3s2LHDrRX51ih9dDk9PR2bN28WjDVp0gQFChRwVWgOYR93IsrJEhISBMvBwcHmP7PCncj7sVLVs1y/fl2wLL5mFk+aCrBylSi3U/KUCxPuRESkNXPCffPmzYiOjpZU+F28eBFAZk9FS6KiotC9e3c0btxYkHS/efMm6tevj4EDB+LgwYNWA1m2bBni4+OxYMEC7Nixw+q6Bw4cgK+vL+rWrSt5rVGjRjCZTNi3b5/VbXia/fv3IyYmRjDWsWNHjaKxTNzH/dy5c+ylSUQ5hrhqPXvCnRXuRETuk5GRgaioKMGYkoQ7E2lEuVv2J8It4XmCiIgcpXpLGbHHjx/jhx9+QIcOHeDr64vPP//c4kZKlSqFlStXIj4+3px0z0q2X716FZMnT0adOnWsBjJ48GBERkaiT58+0Ol0FtfLyMjApUuXULJkSckEdwBQrlw5AEBERITV/bmL0keXxT3rX3rpJVSqVMlVYTlMnHCPj4+XVCcREXkqaxXu4oQ7K9yJiFzn1q1bSE9PF4yJE+56vV6SdGcijSh3k0u46/XCtAafhCEiIkeplXCXnY1z0aJF6NOnDwDAx8cHa9asQaNGjaxuKKsau3PnzmjcuDFCQ0Nx/fp1TJ48GSNHjrQZSP369RUFHBcXB5PJZLHVSmhoKAAgNjZW0fZcLSgoyGbS5tKlSzh16pRgrEOHDq4My2Hh4eEoXLgw7t27Zx47e/YsypYtq2FURETKsKUMUe5mz9w65FriCVMLFCiAfPnySdbLkyePIHnGhDtR7ibXUiY0NBSPHj0yL/M8QUREWpOtcC9UqBBGjBiBrl27IjAwEJ07d8asWbNsbqxjx46YMWMGYmNjcf36dfTt21dRst0eWckSf39/2dezxnPSt9rr168XLBcsWNDmFxxaYh93IsqJ0tLSJFVR2ZPsbClD5P2Uzq1DrmdrwtQs4olTmUgjyt3E13I+Pj6SazieJ4iISGuyCff33nsPU6ZMwcqVK3H+/HmEh4djyJAhOHnypNWNRUVFYe7cuZkb1uvx/fff4+jRo6oGnPVYqaXebVnfeGevWvRksbGx+OWXXwRj7733Hvz8/DSKyDZxWxkm3IkoJ5BLoLPCnYhIG7YmTM0ibimTk4pqiEh94jyAv78/v5gjIiKPY7GHe5ZSpUqZq9S3bdtmcb0bN26gfv36iIyMxJQpU7B+/XokJiaiadOmOHLkiGoBh4SEQK/XW2wZkzUeEhKi2j5dadu2bYKLBl9fX7z33nsaRmSbOOF+/fp1PHnyRKNoiIiUEbeTAVjhTpTbKJ1bh1zP0Qp3fhlKlLuJE+4Gg4EJdyIi8jh6ILMqfM+ePZJK6yxZ/bljYmJkX79z54452T516lSMGDEC7dq1w9q1a5GUlIQ333wTf//9tyoBGwwGlCtXDlFRUUhLS5O8fvXqVQDwyAlHxTIyMrBp0ybBWJMmTVCwYEGNIlKmYsWKkpY+586d0ygaIiJlxAl0Hx8fwbmMk6YSeb+goCDJ0yzkfkajUXGFuzsTaWlpaYI+0ETkecQ93A0GAwwGg2BMLk9ARESkhFqTpuqBzMRv8+bN0aFDB9lJSLJayZQvX152I2FhYahSpQqmTZuG4cOHm8ezku4vvvgiypUrp0rAAFCvXj2kpqbi0KFDktd+++036HQ6vP7666rtz1X++OMPweSjgOdOlpqdr68vXnjhBcEY28oQkacTV7gHBQVBp9MJlrNjwp2IyDWuX78uSZxbuldwV8J9+/btaNasGZo2bYqhQ4ciIyPDJfshIufItZQRt2Nlwp2IiLSmBzKr+tq0aYO4uDh88cUXghVOnTqF6dOnIygoCJ06dZLdiMFgwNatWzFs2DDJa+3atcPBgwcRGhqqWtDdu3cHAIwaNUpw0b1t2zb88ccfaNmyJUqUKKHa/lxFPFnqCy+8gBdffFGjaOwjbiuzfft2REVFaRQNkXdJTExkOxMXEH+m4rk+2FKGiMg9/vnnH8Fy4cKFLT7hKU64u6KH+48//ogJEyaYWyTu379ftadzKefjdZlnkWspI064W5rvjYiIyF3MPdy//vprlC5dGtOnT0edOnUwbNgwtG/fHq+99hpSU1OxatUqFCtWzOKGslcJ2vOaI2rVqoV+/frhr7/+QpUqVTB8+HB06tQJbdu2ReHChTFr1ixV9+cK165dk0xCmxOq27NUrVpVsPzgwQP06NED165d0ygiIu8RHBxs8dF6cpy4wl2ccGeFOxGRe4gT7uInJ7MTT5qqdoV7XFwc5syZIxkXt7yh3IvXZZ5F/ES+XIV7enq6y/b/559/olu3bvj0009x+/Ztl+2HiIi0oWpLGQAoVqwYjh8/jgEDBuDmzZuYPXs29u/fj9atW+Po0aNo06aNKjtUy7x58zBv3jz4+/tj7ty5+OOPP9CxY0ccPnzY3HPek4knoC1QoAAaN26sTTAOqFmzpqTK/dGjR+jZsycuXbqkUVRERJbZSrizwp2IyD0uXLggWLaWcHd1S5kNGzYgLi5OMh4bG6vqfohIHeLqdT8/P7e1lImLi8Pw4cPxzz//4MCBA5g6dapL9kNERNpRPeEOZPZinzt3Lm7cuIG0tDTExMRg48aNePnll1XZmT1MJhNu3bpl8XWdTof+/fvj3LlzSE5Oxu3bt7FmzZockWwHgN9//12w/N5770kme/Fker0es2fPlkxOGxsbi169ekkql4hIuYSEBERGRmodhteR6+GeHSdNJfJ+bA2hvdTUVElxhhYJ96SkJAwfPhyLFy+WfZ0Jd8rC6zLPoqSHu6tayhw4cEBQPX/48GHO90BElAOolUS3h972KuQK2R+F8/Hx8bgnCJTIly8fFixYIKl0j4+PR58+fXD69GltAiPK4YKCgiTJYHKerR7u4s88PT2dPUCJvAxbQ2jv0qVLgoSVTqfD888/b3F9VyXcp0yZgr1791p8nQl3ysLrMs+ipIe7qyrcxe1sALCtDBFRDmBPwt0lFe6kjcaNG6NQoUJah+GQ4OBgfPPNN6hWrZpgPCkpCf3798fly5c1ioyISMjeCneAVe5ERGoTPwVZpkwZq8lMV0ya+vfff2PXrl1W12HCncgziZPecgl3V/Vw9/X1lYxxvgciIpLDhLsHyEmTpcoJDAzEnDlzULt2bcF4cnIyxowZwwpRIvII9la4A0y4E3kbtobQnjjhLm5PKOaKCndbyXaACXciTyXXUkbcmtVV95/i4g2ACXciopyALWVyoeeffx4vvfSS1mE4zd/fHzNmzEC9evUE45cvX8a3336rUVRERP+xVeEeEBAAnU4nGGOvZyLvwtYQ2hMn3K31bwdck3A/c+aMzXWYcCfyTFq2lGHCnYgoZzIajW7fJxPuGuvYsaMkwZNTGQwGTJ48GeXLlxeMr1y5EmfPntUoKiKiTLYq3PV6PQICAgRjarQuICKiTPHx8bhx44ZgzN6Eu7NPHj158kSSIGvYsCFGjBghGIuNjdWkGoqIrBO3lPH395e0enFVwl2uEIMJdyIiz8cK91wmf/78aNKkidZhqMpgMGDChAmCix6j0YgxY8awNQORQomJiaysdgFbFe4AmHAnInKhU6dOCZb9/PxQoUIFq+9Ru4f7uXPnBMv+/v6YNGkSatasKRhPTU3l7wAiDySucPfz85O0lHFnwj06Otol+yIiopyNCXcNvfvuu5KLA29QsWJF9O7dWzB269YtzJ07V6OIiHKW4OBglClTRuswvI6tCneACXciIlc6duyYYLlKlSqSVhBi4vOysy1lxEn/F154Ab6+vggNDZWsy7YyRJ5HrsLdXS1l5BLuvFYkIvJ89lS4q1UNz4S7RvR6Pdq2bat1GC7TtWtXVK5cWTC2efNmHD58WKOIiCi3E1e4M+FORORe4oR7jRo1bL5HrsLd0Ruh1NRUrFq1SjD28ssvA8j8naDXC2+NHj9+7NB+iMh1xMl0rXu481qRiMjzsaVMLlK3bl2Eh4drHYbL6PV6jB8/XpK8GjhwIJo3b46ePXtiwoQJ+OWXX5CRkaFRlESeKSEhAZGRkVqH4VVMJhMT7kREGnrw4AGuXbsmGHMk4W4ymSQVrkpcv34dtWvXltxw1alTBwCg0+kQFhYmeO3o0aN274eIXEv879+dCXe5CvfU1FTO90BE5OHsmTSVFe45XOvWrbUOweVKliyJwYMHS8ZjYmJw8uRJbN++HZ9//jlmz57t9tiIPFlQUJBsf3FyXHJysuSXLHu4E+U+nCNDO+Lq9uDgYDz//PM23ydOuAOOtZWZN2+eZCx//vx48cUXzcviPu7btm1jIo3Iw4h7uLuzpYxchbsr90dERO7HhHsO98ILL2gdglu89957qFWrltV1tmzZYte3TURE9pK7QWKFO1HuwzkytCNOuL/66qvw8fGx+T41Eu4pKSk4cuSIZPyNN94QtJERF8Tcvn0bd+/etbl9k8mEI0eOYNWqVbhx44ZdsRGRfcQJd7kKd/E6arH0hS2vF4mIPBtbyuQiOp1O6xDcQqfTYcKECahevbrFdVJSUhTdzBAROUruBklJhbuzk/MREVHmTY444f7aa68peq/4vAzYn9w6fvy4bBua999/X7D80ksvSfZ3//59q9s+duwY2rZti/79+2Pu3Llo3749fv31VwBAUlISvv76a4waNQpnz541v+fMmTPYuHEj7ty5Y9ffg4g8b9JUwHUJfiIiUocWCXdft++Rcp38+fNj4cKFSEpKwq1bt3Dr1i2MHz9ecMFy48YNFC9eXMMoicibiSvc/f394esr/RUoNzkfEXmPhIQE3L9/n1XubhYVFYWYmBjBmJL+7UDmvEAGg0GQ0LL3y9ADBw5IxtauXYsKFSoIxnQ6HQoWLIjbt2+bxx4+fCh5b3p6Oi5cuICLFy9i+vTpgtcyMjIwdepUNG3aFFOnTsXOnTsBAIcOHcLWrVtx5swZDBs2DAAwf/58bNq0yavndSJSmzi57efnJ0m4p6enq75fo9FoMeHuyLwSRETkPvYk3NVKzjPhTm4TGBiIihUromLFili1ahXOnz9vfi1rIisiIlcQ3yBZ6pHPljJE3i0oKAhJSUlah5HrHDx4ULAcHh6OZ555RvH78+TJ41TC/fTp04LlgQMHomLFirLrihPuDx48AABs3LgRP/zwA4oXL47Tp08jLi7O4v7i4uKQmJhoTrYDmb+Hvv/+e/z000+CsQ0bNmDAgAF2/X2IcjMlFe6uqDhPTk62mIRhwp2IyLOxpQzlGqVLlxYss98lEbmSuMJdrn87wIQ7EZHaTCaTIMkMZE5Oak97RfGXpPHx8YrfazQacfPmTcHYSy+9ZHH9sLAwwfLDhw9x9uxZTJs2DVevXsWff/5pNdmeJTY2VjK2e/duPHr0SDD2yy+/2NwWEf1H3C7GYDDAYDBYXUcNliZMBZhwJyLydEy4U64hrmq6fv26NoEQUa4grnBnwp2IyD0iIiJw5coVwdhbb71l1zby588vWH78+LHi90ZHR0uqXa1V14sT7v/88w+6d++ueH9Z5Pqz37t3TzLm7+9v97aJcjNxcttgMEjaBLoi4W6pnYxcTERE5FmYcKdcQ3yjwwp3ov8kJiZavagn+7HCnYhIG+Lq9mLFiuHVV1+1axvOJNzF15jBwcGS7WVXsGBBwfKRI0cU7yu7QYMGScaMRqNkTG5SWCKyTPwFmrsmTWWFO6nBnie0iEg9TLhTriFuKfPgwQMmGIn+X3BwMCf0U5n4Jok93ImIXC81NVXSMuWdd96BXm/fLUiBAgUEy0oT7klJSZg4caJg7JlnnrHazkaccHeU0oQfK9w9HwshPIfJZJIk3C21lFE7uWJt7ggm3EmpTZs2aR0CUa7EhDvlGiVKlJDcbLHKnYhchRXuRETu98cff0j6nb/zzjt2b0dckS7ugy4nIyMD/fr1Q0xMjGDc1mStaiXclRInCsnzsBDCc2RkZEieFJGrcM9aV03WJmJlwp2U2rp1q11PaRGR+6mVnGfCnTRhMBhQrFgxwRgT7kSZEhISEBkZqXUYXkVcmcYKdyIi19u6datguVq1apLrPyXECXe5CUnFfvrpJ5w7d04ybivhLu7hrkTTpk1Rr149u98HuKb1BZG3kkt6y/Vwt7Su2vvOwoQ7KfX06VOsWrVK6zCIch17kuhMuFOOx4lTieQFBQVZTAiTY1jhTkTkXhERETh27JhgrGXLlg5tS9xSxlaFe2pqKpYsWSL7WqlSpay+95lnnlHc8qZ69eqYOnUqxo0bh5CQEEXvEUtISMCRI0ewd+9epKen4/z581i2bBlOnTrl0PZIfSyE8BxyiW25ljIAkJ6e7vJ9Z1E7uU/ebePGjXjw4IHWYRDlKnLz6KixzT179uDHH3+U/R0h/SqYyE2eeeYZHDp0yLzMCncichVWuBMRudd3330nWM6fPz8aNmzo0LbsbSlz+vRpSSsZANDr9XjhhResvjcwMBDPP/88/vnnH8lrAQEBSE5OhsFgQM+ePdGtWzdzP3hrE7Fac+3aNfTv3x9A5pfBSUlJ5pvCUqVKYfbs2Ta/JCDXCgoKQlJSktZhECxXuMu1j1H76RFrSXVeL5I9UlJSsGLFCgwbNkzrUIhyDVdUuM+YMQMbN24EAPz4449Yvny54HVWuJNmxBOnMuFORK7CCnciAjj5obtERUXh999/F4y9//77knOsUnItZaxVKsk9Nenj44PevXsramlTtWpVyVhYWBh+++03bN68Gb/99hs+/PBDweSrb7zxhs3t2pKQkCD4e0VFRaFHjx6sniX6f5YS7nI93NX+d2Otwp0tZcheW7Zswb1797QOg4ickJVsB4CzZ8/iwoULgteZcCfNiFvKREVFueQxDyIiVrgTEcDJD91l5cqVguqgwMBAtGvXzuHtiVvKGI1GxMfHW1z/1q1bguWmTZvi0KFD6N69u6L9Va9eXTJWoUIFBAQEoHTp0ggMDJS8/vLLL+OLL75QtH17PHr0CLVr18a+fftU3zZRTiOXRPfz85NNuLuzwp1fipG90tLSsGzZMq3DIMo11OrLbo244IMJd9KMuMI9JSWF3/ISkUs4WuGemprKLwKJiOwQExODnTt3Csbat2+PvHnzOrzN0NBQydjjx48tri9OuJcoUUJ2UkVLatasibp16wrGxMtyWrVqhYkTJyrejz3GjRvHpB7leuJKcoPBAJ1OJ/vvW+0e7pw0ldT2448/4vbt21qHQZQrcNJUylUKFCggqTLlxKlE5AriCnelCXeAVe5E3oSTH7rezz//LEh0GQwGdOrUyaltGgwGyTWjtT7ucgl3e+j1esyYMQPDhw9H7dq10bdvX7Rp00bRewsXLmzXvpRKTEzE6dOnXbJtopxCnPT29/cHANmkuztbyvBakZTKPsFvRkYGli5dqmE0RLmHOyrcxZhwJ83odDpJWxn2cScitRmNRslkZ5YS7nny5JGM8SaKyHsEBQVZbClF6jh06JBg+a233pK0hHGEeBuxsbGy6xmNRqcT7kBm0r19+/aYO3cuunfvDh8fH0XvCwsLk4x99tlndu9fDp+4otxOnETPnrzM/meALWXIM7Vq1UqwvHPnTuZAiNxA7YS7ku0x4U6a4sSpRFKc1E9dcp+l0h7uABPuRERKJSQkSKqw69evr8q2xROnWqpwf/DggST55UjC3VElS5YUXN/WqlULnTp1QtOmTZ3etl6vx4MHDzBz5kxMmjQJd+7ccXqbRDmJXEuZLOIKd7UT7pw0ldTQoUMHQYGP0WjEkiVLNIyIKHfQIuGuvJkhkQuwwp1IylL1NTlG3L8dsPwZZz2anB0T7kREyhw9elRQhe3n54dq1aqpsm2lCXdxdbvBYJCtOncVnU6HxYsX4/vvv4e/vz86duwIABg/fjzKly+PiIgI1KxZE5MmTbJ727Nnz0ZAQADOnj0LIPPz3rp1K/R61lBR7uCpFe5MuJNSoaGh6NixI1asWGEe2717N7p3745y5cppGBmRd3NHSxnxPphwJ02JK9zZw52I1CaucNfpdLKtY4DM6kGDwSC4qWLCnYhIGXE7mapVq1o839pLaUsZuXYy7k5IFyxYEAMHDhSM+fn5oXv37ubl4OBgjBo1yq7tXrp0SbB8+/ZtbN68Ge3bt3c8WKIcxFIPdyDz31h2TLiTp+rSpQs2btxovkcxmUxYvHgxpk2bpnFkRN6Lk6ZSriOucI+JiZH0WibKbTipn7rEFe6BgYFWky/itjJMuBMR2WYymXD48GHB2Ouvv67a9pVWuEdFRQmW3dlOxh6NGzdWZTvTpk3DTz/9pMq2iDydtQp3Vyfc2VKG1JIvXz588MEHgrG9e/ciIiJCo4iIvB97uFOuU7JkSeh0OsGY+EaJKLfhpH7qEle42/psmXAnIrLf5cuX8eDBA8GYKxPujx8/ll1PXAVepkwZ1WJQk16vR+XKlVXZ1ty5c1XZDpGns9bDnRXulJN06tQJ+fLlE4wtWrRIo2iIKDtryfS0tDTExcUx4U6ez9/fH0WLFhWMsY87EalJXOFuq0c+E+5ERPYTt5MpVqwYSpUqpdr2xS1lLFW4ixPuzz77rGoxqK1///6Sv5cjHj9+7JbepERa07KlDCvcSU3BwcHo2rWrYOzgwYM4d+6cRhERebfscww56uLFi2jZsiUaNmyI0aNH21yfPdxJc8888wzu3LljXr5x4wZMJhNSUlJgMBg4ERQROUVc4W4r4S7uN8yEOxGRbeJ2MnXq1JE8xegM8cSnt2/fRnp6Onx9/7udefTokaTK3pMT7lWrVsXOnTuRkZGBO3fuQK/X45lnnsH+/ftx6dIlHDp0CBcuXFC0rZ9//hm//fYbSpcujT59+kiSj0TeQMuWMta2x4Q7OaJ9+/b4/vvvBU9sLVy4EAsWLNAwKiLvYTKZsHLlSuzatUuV7X333Xe4f/8+AOD333+3uT4zmaQ58cSp27ZtQ/PmzVGnTh106tQJ0dHR2gRGRF7B2Qr3p0+fqh4TEZE3efToEc6cOSMYq127tqr7qFChgmA5NTUV165dA5DZjnD58uVYtmyZYJ2AgACULFlS1TjU5ufnh4CAAJQtWxalS5eGTqdDgwYN0KtXL7zwwguKtzNmzBj8+eefWLVqFWrVqmW1/QVRTmVPSxm1/w2wwp3UFhgYiI8++kgwduzYMZw8eVKjiIi8y/Hjx/HNN9/g2rVr5mtGJSw9NagkyZ4dE+6kObmJU7O+Nbpy5QpWrFihRVhE5CXECXf2cCciUteqVasEj+oaDAZUq1ZN1X3ky5cPxYoVE4xdvHgRMTEx6NSpExYsWIANGzYIXq9QoUKOflIyJCTE4fd+99136gVC5CHsqXBPT0936b6VvkZkzXvvvYdChQoJxhYuXMg2YUQq+PHHHzXdf869AiWvIU64ix0/ftxNkRCRN2IPdyIi13n48CE2bdokGHvzzTcl51I1PP/884Llixcv4qeffrJ4nq5YsaLqMbhTYGCgw+9dsmSJipEQeQZxJbm1Hu5qJ8GtbY/XiuQof39/dO/eXTB26tQpHDt2TKOIiLxHRESEpvtnwp0099xzz1m9KYuKikJsbKz7AiIir8IKdyIi11m5cqUgCabX6/Hxxx+7ZF9yCXdrj94/99xzLonDXZz9/XP27FkAmZOqXr9+nRWTlOOJ+6hnr3DP/me5dZ3FljLkKq1atUKRIkUEY6xyJ3Keo1+8qvVvjwl30lzevHkxevRoFCpUCAULFkSjRo0E1QoAcP78eY2iI6KcLvtERAAQGhpqdX0m3IlICaPRiKdPn+bqG+IHDx5g8+bNgrEWLVqgRIkSLtlfpUqVBMsRERE4ffq07LqFChXCm2++6ZI43MXZz7F79+7YuXMnmjRpgrZt22LQoEGC1j9EOY21Hu7ZJ1AG1E+4W0vcZGRkICMjQ9X9Ue5hMBjQo0cPwdj58+dx8OBBjSIi8g5an5d9ba9C5HpvvfUW3nrrLfNyz549BRVLZ8+eRZ06dbQIjYhyuEePHgmWCxQoYHV9JtyJvFdiYiISExMl4xs2bICfnx+Sk5Px9OlT83/JycmCsex/zkq+5MmTB6VLl0aZMmXM/y9TpgxKlCghSQB5E5PJhEWLFgmSUD4+Pi6rbgekFeuWklxFihTBnDlznGrJ4gkaNGiA4OBg85NaBoPB/HNaqVIlnDt3zuY2xo4da/7z4cOHcfLkSdX76xO5izjpba2ljDsr3LNeV3rOiY+Px4EDB1CmTBnJkzuUO73zzjv47rvvcOvWLfPYokWLUKdOHeh0Og0jI8q5nG0tZjKZcO/ePeTNm9fmU/KANMHvvXcBlKO99NJLgoQ7K9yJyFH2Jtzz5MkjWGbCnch7WJrD4dtvv5Uka5R6+vQpLl68iIsXLwrGfX19UbJkSUkivmzZspLWB54oNTUVRqNRtu3f48ePMX78eEn1XcuWLSUTm6opa+LUO3fuWFxn4MCBaN26NfLly+eyONwlT548WLp0KdatW4eCBQviww8/hI+PD3x8fJCcnIz69evbvc3Nmzcz4U45lviazJ0tZWwlbpQm3JOSktC2bVs8fPgQer0eX375JZo2bapWmJRD+fr6omfPnhgzZox57N9//8W+ffvQsGFDDSMjyplMJhPi4+Mdfn9GRgaGDh2KAwcOIDQ0FLNmzbL5ngkTJiBv3rxo0KABACbcyUO99NJLguXz58/DaDRCr2cXJPJ+liowyX4mk8npCvenT5+qHhcReb/09HRERkYiMjJSMB4QEICWLVuic+fOLk1OO8poNGLmzJnYvHkzMjIyEBgYiAIFCiB//vzw8/ODTqdDZGSk5Nzq6+srmfjNFSpXrmwx4f7OO++ga9euLo/BncqXL48vvvhCMq6k0koOKyUpJxNfk2VPcLuywt1oNCI9Pd3qOkorKX/99Vc8fPjQvN0pU6agVq1ayJs3r9NxUs7WrFkzLF++HNevXzePLVq0CPXr12cehMhOycnJDreUMZlMOHr0KA4cOAAAiI2NVZRwB4Dp06ejfv360Ol07OFOnkmccE9KSsK1a9fMy7m5Xyp5v+DgYJQpU0brMLxCfHy85BctW8oQ5V4JCQmSBLi7JScnY+PGjWjdujVGjx6NS5cuaRqP2JYtW7BhwwbzuTMpKQm3bt3CuXPncPLkSfz999+SZDsADBkyBEWLFnV5fFlVQ3Jefvlll+/fUziaOGfCnXIyccI9+1OJruzhriSZrnTi1IiICMFyXFycOalDuZter0evXr0EY9euXcOePXs0iogo53Kmuh0A1qxZI1hW2nUjJibG3AqQFe7kkQoWLCh5ZPjs2bNIT0/HyJEj8eTJE/Tq1QsdO3bUMEoi8nRySSEm3Ilyr6CgICQlJUnGa9Sogfz58yNPnjzm/wICAmT/n/11X19fREdHmyvZs/6TO/eIGY1G/Prrr/j1119Rs2ZNdOvWDdWqVdM0IXr37l3MnTvXrvcUKFAA48ePR61atVwUldDrr7+OgIAA2dYSdevWdUsMOdnu3bvRs2dPlC5dWutQiOwmPn9nr3B3ZUsZJQl3pdeL2Xt0Z7HWJotyl0aNGqFChQq4fPmyeWzx4sVo3LgxfHx8NIyMKGeJjY11+L0mk8mpeZiynohiwp081ksvvSS4+Dhx4gSWLFmCBw8eAABmzJgBHx8ftGvXTqsQiVwiISEB9+/fZ5W7CsRJr6CgIJu9k5lwJ8p9Jk2ahEKFCjn03lKlSqFGjRqCsbi4OFy/fh3Xrl0zJ+GvX7+Ou3fvyj6ld+TIERw5cgSVKlVC165d0bBhQ7c/Pm4ymTBp0iTZLyQsqVWrFsaPH2/zi0w1BQQE4PXXX8fvv/8uGG/durVb4/AEpUqVQlRUlN3vGzFiBPz9/XH37l107twZ3bp1c0F0ROqzlnB3ZUsZJdXrSlvKyD1lpeRLWsod9Ho9evfujSFDhpjHoqKisGvXLrRo0ULDyIhylsePHzv8XmcT7llPiTLhTh7rpZdewq+//mpe3r17t2Sd6dOno0SJEm6rqiJyB0sVmGQ/8Q1MwYIFbb6HCXcicla+fPlQuXJlVK5cWTAeHR2NtWvXYuvWrbLzQ1y4cAEjR45EiRIl8OGHH6JFixZuq2jbsWMH/vrrL8FY8+bN8e677+LRo0d48uQJMjIyYDQaYTQa8cILL+DFF1/UpK9s48aNBQl3Hx8fr+vdrkT58uUFCfe6deuiRIkSWLt2rdX3Xb161fznefPmoUGDBihVqpTL4iRSi/iaLPs1mzjhrjQBroTctsRP2ihJyicnJyMmJkYy7kxiiLxP3bp1UalSJVy4cME89u2336JZs2YOT/BOlNs4W+HuzPV3VnENe7iTxxLfpMoxGo0YOXKk4MaBiCiLOOGeP39+m+9hwp2IXKVIkSL47LPPsHPnTvTp08fiOenWrVv48ssv0a5dO+zevRtGo9GlcT148EAyGVShQoUwfPhwvPLKK2jUqBHatGmDdu3aoUOHDnj//fdRuXJlzSZxq1evHipWrGhe7t69O4oUKaJJLFrq2rWruar/9ddfx6RJk9C7d2+7t7Nu3Tq1QyNyCXsq3G1NcmoPuWS6eJJTJQl3Sz2FWeFO2el0Osm5/M6dO/jpp580iogo5zlz5oxm+2bCnTxehQoVbLZ+AIDExESMHTuWE6kSkYQjFe7ZJ+ACmHAnIvXly5cPH3/8MXbs2IGRI0eiePHisutFRUVh1KhR6Ny5Mw4ePOiSax2TyYQpU6ZIEkH/+9//EBwcrPr+1GAwGLBkyRKMHTsWc+fORc+ePbUOSRMvvvgitm3bhl27duHrr79GQECAIAGpFAtXKCdIS0uTJNHd1VJGXOHu5+cnuV5UknCXe7IJYIU7SdWqVUtSgLh06VJVn9wg8mbOXNs4e71tMpkQGxvLhDt5Lj8/Pzz//PMWX8suIiICN2/edEdYRJSDqFHhbunmiIjIWf7+/mjbti22bt2KyZMn47nnnpNd79KlSxg8eDB69OiBkydPCl5LT09HTEwMLly4gOPHj9tdKXngwAHs379fMNasWTOPn4A0ODgYLVq0QO3atTWdaFZrgYGBCA8Pd+ppA/HPFJEnkrsey570dmdLGYPBICkMU9pSRg4r3ElMp9Ohb9++grGYmBhs2bJFo4iIcpa///7b4fc6m3DPyMhAnz592MOdPFvlypVlHwWZPXs2hg8fjsTERPNYdHQ0+08SkYAaPdxTUlJgNBo1a51ARN5Pr9ejSZMmaNy4MY4ePYoFCxYIerdmOXPmDHr27IlKlSohLS0NDx48QGxsrODGIDAwENOmTUPNmjVt7jc1NVXSSiZ//vwYOnSo838pylHef/99VKhQATVr1kT9+vUdqpQnciV7E+6unDTVYDDA39/f6jpyLBVxZM2R4a45OyhnqFatGqpVq4YTJ06Yx5YvX45WrVpJnrAgIvU4m3AfOHAgrl+/zgp3ALh37x66dOmCwoULIywsDO3atcPt27e1DouQOXGqWI0aNfDaa6+haNGignG5CWiIKHcTJ9yzet1aI064A+pWSRERWaLT6VCzZk2sXLkS06dPR9myZWXXu3DhAi5fvozHjx9LbgqSkpIwbNgw/PPPPzb3t379ety6dUsw9umnnyI0NNThvwPlTJcvX8auXbswZswYtG7dmu3UyOOI+7cD1hPuavZwFyfK8+TJo2rC3WQyWezvTrlbnz59BMuPHj3C5MmT2U6XyIqMjAyn3u/sv6/r168DYA93AEDbtm1x48YN7Nq1C3v37sWTJ0/QokULVX9Jk2PkEu6ffPIJACA8PFwwzoQ7EYmplXBn4oGI3Emn06FBgwZYv349xo8fj2LFitn1/qdPn2LgwIG4ceOGxXUePnyIpUuXCsYqV66Mt956y6GYyXN88cUXTr3/0aNH2LRpk0rREKlDnKw2GAyCinBXtpQRXwcGBASomnCX2wcRAFSpUgW1a9cWjO3atQtbt27VKCIizxcXF+fU+9X6QivXJ9z//fdfHDx4EN9++y1effVVVK5cGStWrMCpU6c0ndWWMhUqVAitW7c2L7du3RqvvPIKACbcicg2JtyJKCfT6/V4++238cMPP2DEiBFW22KJ+5g/efIE/fr1s3h9NH/+fEnF6NChQ3N1P3Rv0apVK6e3sWHDBhUiIVKP+Hwlbnsk7qmuZksZuX0z4U7uMnToUMnP+/Tp02VbzxERsHv3bqfer1bCPdf3cC9cuDB27NiBChUqSF7jRHmeYfTo0WjatCl8fX3x8ssvm8eZcCcia5KTkyU3SEy4E1FO5Ofnh3bt2qFFixY4cOAA7t69i/z58yMsLMz8X1BQED777DMcOXLE/L7o6GgMGDAAS5cuRd68ec3jFy5cwPbt2wX7aNGiBSpVquS2vxO51ksvvYRz586ZlwMDA2VbclgSHR2NRYsWoWHDhqhYsaIrQiSyi1xbl+x8fYWpDXcn3JVU1Fu7nmTugSwpVaoUxo0bh+HDh5vH0tLSMHz4cHz//fcICQnRMDoizzNz5kyn3n/48GFFc7/Zkusr3ENDQ/H2228LJsObOXMmgoODBcld0o5Op0ONGjVQtWpVwXESJ9zv3bvn7tCIyIOJq9sBZQl3Hx8fyWPJTLgTkScICAhAkyZN0LVrV7Ro0QK1atVChQoVkD9/fhgMBkybNk2SNL969So+/fRT3Lt3D3fu3MH169cxY8YMwTqBgYHo16+fO/8q5GJ9+/Y1J2G6dOkiW1xky9KlS9GpUycMGjSI/YJJc7YS7q6scFfSw13JtSIr3MlRDRs2ROfOnQVj0dHR+OKLL2A0GjWKisgzOftv4uzZs9i3b5/TcXh9wv3KlSvQ6XSy/9WvX1+y/urVqzF79mxMmjQJwcHB7g+YFBMn3O/fv69RJETkicQJdz8/PwQFBSl6r7jKnTdBRJQTBAYGYs6cOShVqpRg/PTp03j77bfRsmVLtG3bFmfPnhW8/vHHHyMsLMydoZKLVa9eHb/88gv+/PNPpxPmhw4dElTLE2nBVksZcbFETmspwwp3sqV///7m9rpZDh8+jGXLlmkUEZFnevHFFyVja9euxQsvvIB8+fKhZcuWbonD6xPuzzzzDC5evCj736pVqwTrLly4EB9++CE+++wzDBgwQKOISanChQsLlh89eqTq5DhElLPJ9W9X2ptYnHDnTRAR5RT58+fHN998oziBXqJECbz//vsujoq04OfnJ0lKOuqHH35QZTtEjhJfi7kz4a6kwp093MnVfH19MXnyZMkTu0uWLMFff/2lUVRE6jOZTFi3bh369euHb7/9FhkZGXa9v0SJEoLlKlWqoGLFili5ciX27t2Lpk2bqhmuRV6fcPfz88Nzzz0n+1/26p8JEyagb9++GDVqlOQxW/JM4gp3AHjw4IEGkRCRJ3JkwtQsrHAnopysWLFimDdvnqKnNT/99FNJKwbyPqVLl3bq/f/++y9WrVqFv//+W52AiOwkTlaLr9XcXeEuPm8qKfxiwp2cFRYWhilTpgha7ZpMJowePRp3797VMDIi9Rw6dAgzZ87E0aNHsXjxYuzYscOu94vPp7Vr1xYsi+f8cBWvT7grMWvWLIwdOxbTp0/HxIkTtQ6HFAoODpZcaLGPO3mDxMREJCYmah1GjseEOxHlZhUqVMDcuXNlCxT0ej3CwsIwcOBA1KtXT4PoyN0++ugjwXK3bt3sev+VK1cwd+5c9OrVC3/++aeaoREpYm9LGaPRqFpva7l9O3KtaG0dXmuSUlWrVpV0ZIiLi8OIESP4xD95hXHjxgmW7c3Tis/Z4ieSfHx8HIrLXu5J63uwS5cuYeTIkejZsyc6d+6M6Oho82v58+eXHBjyHDqdDuHh4YiKijKPsY87eQPOH6EOJtyJKLerXLkyduzYgdjYWPj6+sLPzw8Gg8FtNxrkOUqWLImZM2di69atKF26ND755BMEBQVhwYIFdm9r/vz5qFu3rgui9EwshPAM9ibcgcwqdzXu58XXgXny5BFUGANsKUPu1blzZ8nEjhcuXMCsWbMwcuRIDSMjcl5sbKxT7xfnBcV5AE0q3BMSEjBq1Cg899xzCAgIQL58+VCvXj1s27bNLcFk17FjR0nfHbEVK1agatWqCA4ORnh4ODp37owbN27YtZ/NmzcjLS0NS5YsQdGiRQX//fzzz878FcgNxH3cWeFORFmYcCciyqxmL1CgAPLly4c8efIw2Z6L1atXD7Nnz8bgwYMREBDg8A3n1atXVY7MswUHB6NMmTJah5HrySW9s5NLuKtV7StO9ufJk0fSUoaTppI76XQ6jB07FiVLlhSMb968Gbt27dIoKiLP8PjxY8GyeF4jtyfc4+Pj8frrr2Py5MkICgpC37590a5dO5w5cwbvvvsuJk+e7JaAAGDSpEnYsGGD1XVGjhyJ7t27IyUlBf369UOjRo2wfv16VKtWDZGRkYr3NWrUKJhMJtn/Wrdu7eTfhFytUKFCguWYmBiNIiFST0JCgl3nMZLnTMJdfBPHyjYiIvI2JpPJ4ffyi2hyN7mkd3aWKtxdse/AwEBJ5byS5L54O9nx3xTZKzg4GNOmTZP8LH711Ve4cuWKRlERactoNEoq5ENDQwXLbk+4T5s2DWfPnkXv3r1x4sQJzJo1C8uWLcM///yDokWL4osvvnD5P9rk5GT07t0bo0ePtrre6dOnMXXqVNSpUwenTp3C1KlTsW7dOmzevBkPHjzAoEGDXBqnPfgIomuJK9yZcCdvEBQUhKCgIK3DyPGcSbiHhIQIlp19rI2IPAOvy4j+40zC/a+//lIxEs/GQgjP4EhLmfT0dFX2La4+z5Mnj0NPQ1r7/cOEOzmiQoUKkvxZSkoKhg8fjoSEBI2iItKOXN5a84T7xo0bodPpMHnyZOh0OvMKxYsXR58+fZCRkWH10ZTvv/9edtb6W7duYd68eTYD+emnn/D8889j8eLFaN68udV158+fDwAYO3as4FGu1q1bo379+tixYwdu375tc5/uwEcQXUs8ERgT7kSUxZmEe/78+QXL4sfSiChn4nUZ0X+cmVDyt99+UzESz8ZCCM8gl/TOTtziBXBdSxm5CnclCfP4+HiLr7GlDDmqefPmeO+99wRjUVFRGD9+vFNfrBLlRIsWLZKMiRPucl/QuoI54T5o0CB8+eWXkkCA/2Z0tfQLIioqCt27d0fjxo0FSfebN2+ifv36GDhwIA4ePGg1kGXLliE+Ph4LFizAjh07rK574MAB+Pr6yk7W06hRI5hMJsHkEeS9xAl39nAnIgDIyMjAkydPBGNMuBMREf2nWbNmgmVxq0Zrfv31V9SuXRuLFi1yKnFPpJQ4IS2ucJerWFSrpYySCnclPdytVRyzwp2cMWTIEFSqVEkwtm/fPqxZs0ajiIi0ceLECcmY+AtZuS9oXcGccO/bty9GjRolWcFkMmHLli0AgMqVK8tupFSpUli5ciXi4+PNSfesZPvVq1cxefJk1KlTx2oggwcPRmRkJPr06SOosBfLyMjApUuXULJkSdkPqVy5cgCAiIgIq/tzFz6C6FrihPuDBw9y5UX/zZs3MXjwYPTs2RMnT57UOhwizcXGxkoqOpxJuLOlDJF34HUZ0X+KFSuGTp06AchMXv7vf//DkiVLFL8/NTUVS5cuxaRJkzB9+nTs3buX1ZTkMrZ6uOv1euj1esGYGgl3k8kkm+wXV7jbSribTCarCXdWuJMzDAYDpk6dinz58gnG582bhz///FOjqIjcz8fHx+Y6bm8pY8nChQtx9OhRlC1bVlIFkV3Hjh2xZs0ac9K9bt26uHbtGiZPnoyRI0faDKR+/frImzevzfXi4uJgMpksJk6yKvQ9JTnCRxBdS9zD3Wg04uHDhxpFo50JEybg4MGDOHnyJIYOHapaNQdRTiVuJ6PT6WSf4LKEFe5E3onXZURCn332Gfbs2YOff/4ZdevWRdWqVVGjRg27trFt2zZs2LABw4cPx4EDB1wUqXY494NnsNVSBpBWLarRUiYlJUXyRZIjCfenT59aLQxjhTs5q2jRovjyyy8FBaxGoxHDhw9nBwjyegkJCZgwYYKkM4v4yQ9Agwp3ORs3bsTAgQPh6+uLlStX2uxz07FjR8yYMQOxsbG4fv06+vbtqyjZbo+sb4XFv+CyZI3zF1buEBoaKvl2StzHPTk5GZs3b8b333+PuLg4d4bnFiaTCadOnTIvx8XF5aqJrIjkiBPuoaGhir7tziKXcGfVHhEReaP8+fMLvoiaPXs2RowY4dC2Pv/8c7XC8hic+8Ez2Jo0FYBDbV7s3S+QmewX5yPS0tKsJtRtTWDJ/AWpoXbt2vjkk08EY+np6Rg5ciR+//13jaIict7YsWMtntNTUlLQqVMnbN++XfKaRybcFy5ciPfffx8AsGrVKpstYYDMXu5z587N3LBej++//x5Hjx5VKdRMWb9ELX1bnXUAgoODVd0veSa9Xi/pN5m9j7vJZMLo0aMxZcoUfP311/jkk0+87mJGrppdjYtLopxMnHAXJ9BtEa+fnp5u80aJiIjIGxgMBrRr1w79+vWz+71JSUlo2LAhevToISmCIXKUXFsXuQp3ccJdjfs+uVYvgYGBkn0B1u/BbF1HWmspc/bsWfz222+8xyNFevTogZYtWwrGMjIy8L///Q+7d+/WKCoi5+zcuRN79+6VfW379u24c+eO7GtyLcs1ayljNBoxZMgQ9O3bFwaDAZs2bTIn3q25ceMG6tevj8jISEyZMgXr169HYmIimjZtiiNHjqgWcEhICPR6vcWWMVnjISEhqu2TPJu4j/v9+/fNf/7rr7/wxx9/mJevXr2KBQsWuC02d5C7kLSnkpfIG4kT7gULFrTr/XIJeraVISKi3KR9+/YOvS8uLg6nT5/GjBkzVI5IG5z7QXty1ePuSriLK9x1Oh0MBoPsE/fW9udohfuGDRvQvXt3jBw5Eh9++CHS09MVRE25mV6vx+eff453331XMG40GvH5559j165dGkVG5JwvvvhCdvzQoUMW3yP3RaV4vg9XEewlNTUV7dq1w6xZs1CgQAHs2bNH8o9Uzp07d8zJ9qlTp2LEiBFo164d1q5di6SkJLz55pv4+++/VQnYYDCgXLlyiIqKkq3svXr1KgD5xwbIO4n7uGdVuBuNRnzzzTeS9detWydowZLTyT3t4a5v7Ig8lbMV7gEBAZKbNk+ZG4SIiMgdgoKCUL9+fYffb6kSLafh3A/ak2vroqSljBoTkcpV1ut0OtmEuzMV7pYS7ps2bTL/+fLly/j555+tbocIyEwo/u9//0Pbtm0F40ajEWPHjsVPP/2kUWRE7tWmTRvN9m1OuBuNRrRr1w5btmxBmTJlcPjwYUVtZAAgLCwMVapUwbRp0zB8+HDzeFbS/cUXX0S5cuVUC7pevXpITU2V/Rbjt99+g06nw+uvv67a/siziVvKZD2+umfPHly6dEmyvslkwoQJE7xmYlG5hDsr3Cm3c7bCHZAm6cXbJCIi8nbTpk3DzJkzUblyZYfe36JFC6xfv17lqCi3kUuca1XhnpXoV7uljKVYr1+/LlheuXKl1e0QZdHr9RgxYgQ6duwoGM/Kh2zbtk2bwIjc6MUXX9Rs3+aE++TJk7F9+3aUKlUKBw4cwLPPPqt4IwaDAVu3bsWwYcMkr7Vr1w4HDx5EaGioKgEDQPfu3QEAo0aNEvzy3bZtG/744w+0bNkSJUqUUG1/5NnEFe4xMTFIT0+32jrm5s2bqs8voBW2lCGSevjwoWDZ3gp3ufewpQwREeU2er0e9erVw9KlS1GjRg2733/37l3MmDEDN2/edEF0lFvIJdzlEt7uSLhnJfp9fX0lbQnsSbiLn0iWi1VuElZxAp7IGp1OhyFDhqBz586CcZPJhC+//BKbN2/WKDIi9cj1aQeA/v37uzkSIV8gM4kwefJkAMArr7yCb7/9VnblunXromHDhrKvWfoL2nrNEbVq1UK/fv0wf/58VKlSBa1bt8atW7ewceNGFC5cGLNmzVJ1f+TZxD3co6Ojcfr0ady+fdvq+y5cuKD4KQ5PJlfhLndxRpSb3Lp1S7AcFhZm9zaYcCciIsqk1+vxzTffOJR0B4ClS5di/PjxKkflHomJiUhMTNQ6jFxNnPQOCAiQ7cErrnpXI+EuPvbBwcGCOLLHZk8P90KFCuHu3bvm5dTUVBiNRsHfy1JV/KNHj1CgQAFlfwHK9XQ6HQYNGgRfX1989913gtemTJmCjIwMdOjQQZvgiFzIYDBoun9fADh+/Lj5F8mPP/6IH3/8UXbl0aNHW0y4u9u8efPw3HPPYfHixZg7dy4KFiyIjh07YsKECShbtqzW4ZEbFS1aVLAcHR2NK1euCMbKli2L1157DevWrTOPXb582S3xuZpcJUVGRoYGkRB5hoSEBERFRQnGKlSoYPd2xAl39nAnIqLczJlJxnLyl9bZE6ykDUttXcRcUeEuTnpn7+fv7+8viM1ahXt8fLxgWZxwBzLjzf53s5RwnzdvHsaOHWs7eKL/p9Pp0K9fP/j6+mLp0qWC16ZPnw4ATLqT1/Hz89N0/74A0LRpU5hMJk0DEbMVj06nQ//+/TV/RIC0V7JkScGy0WjEiRMnBGPlypVDxYoVBWNy/d1zIrkLO85eT7lZRESEYNnPz8+heURY4U5ERKQONSavpNxLnDiX698OuGbSVGsV7uKJU+1pKSP39OXTp08FCXdxkj5LZGSk5YCJLNDpdOjduzd8fHywePFiwWszZ85EqVKlUKtWLY2iI1Kf1hXujpcpEHmIfPnyIV++fIKx48ePC5aLFy8uSbjfvn0bgwcPRqdOnbB161aXx+kqci1lWOFOudmFCxcEyxUqVHDoly0nTSUiIlKH3PVqTpGQkMAEp8Ys9VEXc0WFuzjhLq5wV7o/JQl38fstVbiLPw8ie3zyySfo16+fYMxoNGLUqFGcb4O8itxcH+7EhDt5BfEkueILo+LFi6NMmTKSyUQPHjyIS5cuYfLkyfj3339dHqcrsKUMkdDFixcFy88//7xD22GFOxERkTr++eefHPt0aVBQkCDJSu7nyS1lsrOnpYylCndr77G0HpG9PvroI/Tq1UswFh8fjyFDhvALHfIa1lrCtWnTxuX7Z8KdvII44S5WvHhxGAwGlClTRvZ1o9GIn376yRWhuRwT7kRC4gr3SpUqObQd9nAnIiIS6tq1q8PvHTdunMe1MaWcQZxgtlThrsWkqdnZ01ImODjY5hcEcXFxsttiQpTU0KNHDzRq1Egwdu3aNYwZMwZGo1GjqIjUYy3h/r///c/l+2fCnbyCuI+7WPHixQFA0lYmuz///FPVmNxF7sIuNTUVycnJvKmhXCcuLg63b98WjKlZ4c5/U0RElJt169YNDRs2tFnsIufSpUsWK3aJrBEn3LWscLeWcLenpUxwcLDNLwiePHkiuy1WuJMadDodxo4di/LlywvG9+/fj2XLlmkUFZF6rCXcdTqdS/fdr18/JtzJO1i76Nfr9ShcuDCAzF7Olty5cydH9miW64n55Zdfok6dOujXrx8rIHKgxMRESTUNKSNuJ2MwGFC2bFmHtiVOuKelpfHfExER5WohISGYNm0atm3bht27dyM0NNSu93/99dc4c+aMa4Ijr5VTerg7W+EuTqRbameYmprKJ5pJFYGBgZg5c6ZkTrzFixfn2IJEoizWEu6u9tFHHzHhTt7BWoV7kSJF4OvrC8B6hTsAHDlyRDKWmprq0Uk2axd2x44dw4oVKxAVFeXGiMhZwcHBFtsfkXXidjLPPvus+d+/veSSCDnxSzkiIiJXKFCgANauXWux2ljOTz/9hI8//hjHjx93YWTqYiGE9pS2lLGVwHaEq3q4582bV/L3EMdrrZ0hq9xJLcWLF8eUKVOg1wvTg59//jknjCa7mUwm7Ny5E7NmzcK5c+c0jUXLhDvAljLkJaxVuGe1kwGsV7gDwF9//SVY3rhxI+rXr4+33noLu3btcipGk8mE77//Hu3bt8eoUaNU6wdt7cIOAFasWIE2bdpg3rx5ADIvzqKjo232Zbt//z7Gjh2LQYMGsRKJcgy1JkwFMm/mxDdSnDiViIjoP+Hh4di4caPd7+SmDK0AAQAASURBVOvTpw/S0tJcEJH6WAihPS0nTbWnwt3S/oxGo+TvEBwcLEkGiZP71q47PbkgjHKeGjVqYNCgQYKxpKQkDBkyhK3AyC7btm3D2LFjsXbtWnz88ceaFn/aUxCgpgEDBgBgwp28RMGCBSUXWFmyJ9wLFChgdTtHjhwxJ6Lv3buHGTNmIDU1FYmJiZg9ezbS09MdjvHixYv4+uuvce3aNezevRvfffedw9vKTq6ljJyVK1fi+PHjaNOmDd555x307t3barJ+ypQp2LlzJw4dOoR+/fqxisKNEhISWE3gILUmTAUy+7px4lQiIiLrihQpguHDh9vdXqZJkyauCYi8jqMV7q6eNFVphXtSUpJkHiC5hLs4sckKd3KnTp06oXnz5oKxqKgojB49mpOokmJfffWV+c9GoxFt2rTBgwcPNInFVp/21157zSX77datGwAm3MlL6HQ6i21lsifcAUh+iWT3+PFjXL16FUDmN3PZf7E8evQI9+7dczjGhQsXCpbXrFnj8Lays1Xhnt2IESNw//59AMDJkyexf/9+bNiwAdOnT8fly5fN6xmNRvzxxx/m5eTkZBw+fFiVeMm2oKAgQfUMKfPo0SNER0cLxpxJuAPyE6cSERGRUPv27bF792673pOQkJAjfq+yEEJ7WiXcTSaT1Qp38f4s3ZeJK9eBzJYyefPmtboeK9zJnXQ6HUaPHi15Qvjw4cOcRJWc8v7777v9nPX222/bXKdnz56q77d06dLmPzPhTl7DUlsZccK9T58+qFy5MgIDA/HBBx+gaNGigtevXLkCIHN2brHbt287HJ8zyXpr7LmQjIuLEyyPHj0a06dPx4YNG/Dhhx/iyZMnAGBOymdnT2KfSAsRERGC5YCAAMEvPEcw4U5ERKSMuP+vEjmhbSELIbSnVUuZp0+fSip7s1elK92fuHJdp9MhMDDQaoW7yWRCTEyMxdiYcCdX8Pf3x4wZMyT3QEuXLhUU6BHZ4/Hjx9i+fbtb96nk93blypXRoUMHVfd7/fp185+ZcCevobTCvWjRoli+fDn279+PTz/9FOXKlRO8HhkZiatXr8r+QnEm4S5+jFAtajwqCWQm1FeuXAlA/u+p9YQTRLaI28k899xzDt38Zyd+PJ6TphIREVlWpUoVu9YfOnQoTp065aJoyFs4WuGemprqVCsMuclyrbWUsXRfJq5cDwwMhF6vl1S4Z0+4P3r0yGrrUHGBlMlkQkpKCjIyMiy+h0iJwoULY9q0aYL7qIyMDIwfP96pFruUux07dsxl25bLtYm/NJKj0+kwbNgwTJw40RVhMeFO3kNphXuWrF8g4grY69ev45dffpF9jycm3NXs3/f3338DkH/sUWmveCKtqNm/PYt43get+s8RERHlBG3btrX7PXPnznVBJORN5BLWcuTm9HKmOEnunij7vsWJf6UJ96ykvbWWMrbuO7M/PZ2RkYERI0bg9ddfR/v27TWdpJC8wyuvvIIPP/xQMBYREYHVq1drExDleL6+vm7dX8GCBRWv6+fnp9p+K1asaP4zE+7kNeQS7oGBgQgJCbH6vjJlygiWIyMjcf78edl179y543iALqJWhTvwX1VFWlqa5LXcknA3mUw4duwY9u7dq8o3+H/99ZcKUZESFy9eFCyL+w86QvyF3bVr15zeJhERkbdq0qSJ3V94nzt3TvAINpGYuKWfpcpFtRPu4gp3f39/QdLI0ZYyWYl2ay1l7t69azW27An3AwcOYO/evQCAGzdusN82qaJHjx4oW7asYGzJkiWc04Ic4u6Eu/gLTWvUTLi3b9/e/Gcm3MlryLWUKV68uM2ZicUJ96ioKIv91m/duuVwfHIV7nKJbXupWeGe1eNdLi5He7gnJCRgyJAhqFu3LoYPHy77aKYnWbhwIfr27Yvhw4dj4MCBTm9v+vTpKkRFtty/f1/yaK0aFe7ly5cXLF+/fp2PUhIREVng6+uL5cuXY/ny5ahVq5bi93322Wd8ioxkJSUlSe53xE8gZpFrNaNmwl3cE1iccLd0X+ZIhfvDhw+txpb9fnXt2rWC13bu3Gn1vURKGAwGjBkzRtBaJi0tDRMmTHCqVRPlTs62erV325Z+T8hRM+HesGFD85+ZcCevUbhwYcm3ZpbayWQnbimTkZFh8TE8Zyrc5RLuakx2o2bCPWtbala479q1C3/88QeSkpKwd+9ei+16PMXy5cvNfz527JikatpefKTTPcTHKTAw0OK8DvYQz/GQnp6OGzduOL1dIiIib+Xr64vKlSvj008/VfyeqKgoNGvWDOvWrXNhZI5JTEz0+IIRbyY3f46lVgHinuqAui1lxBXp4gS/vQl38fayryfXzia77NXwcus6WixFlN2LL76IDz74QDB27tw5jzxXk2dz5fwScl0tsrd2sUXNhHv2L2KZcCevodfrJQl2JQn3fPnyKf72KzY2VtULbke2debMGSxatAgnTpwAoG7CPeubQTUT7tOmTRMsT5482aHtOOr27ds4duyYwxfbly5dMv85KioKBw4cUOWLElKXXDsZNb5Fz5cvH8LDwwVjV65ccXq7RERE3q5s2bKoU6eOXe+ZOXOmx11nBQcHS56IJfcRJ9z9/f0tTpqq1+thMBgEY66scHc04a6kpYx43+KntrP/O5HraW/piW0ie/Xu3RulSpUSjM2fP5+FZeQxxF8wFihQwK6WMuLfG45q3LixYFtMuJNXqVChgmBZXJ1qibjK3RpHJ06V+0bP3mT5yZMn8cknn2Dp0qXo06ePU4lkOdYS7jlxgpS//voL7dq1Q9++fdGlSxeHvpzIejLhr7/+QocOHfDpp5+iY8eOrHTyMK6YMDWLuK0ME+5ERETK1K9f3+73/PDDD+oHQjmWuLVKwYIFrbYMVdpXXQlLvdezqD1p6tOnT82tC8X3GoUKFRIsZ0+4i+OU2yeRo/z9/TFmzBjBv7vU1FR8+eWXbC1Ditlq9eyM3bt3C5Y7duxo1/stfYlrr4kTJwqWmXAnr9KlSxfzhUv58uXRpEkTRe+zp2rF0bYycsleJUnbjIwM/Pjjj9iwYQP69Olj/qVmMpmwb98+VRPuPj4+AOQT7nKPc3q6r776ylyZHxkZiR9//BFA5me3e/durF27FrGxsYq2NX36dPPncufOHWzYsMElMZP9TCaTSyZMzcKEOxERkWOaN2+OfPny2fUeT/s9m5CQwEkCNSS+B7H1ZLKWCfenT5/KthFV2lIG+O/+UHyfGBYWJtlXFvE8RnL7JHLGyy+/LJgMEsgsBty8ebNGERFlksuz2Xvel5tw217Dhg2TtKZhwp28ygsvvICtW7dizZo1WL16teJvquxJuDs6capccl3JI7MTJkzAxIkTMX36dEmV/KFDh9zWUgaQ70PvyaKjowXLP/30E4DM2dVHjRqFWbNmoXPnzuZKErleh1nfxIofmctK3stJTExUnMgn58XExEhuxljhTkREpD2DwYAffvhBMImYLTt37sSuXbtcGJV9goKCJK1EyH3kKtytcWfCXbwvo9Eoex+ltMI9+z6VVrgnJycjLi7O5j6JnNW/f38UK1ZMMDZv3jxBC1YiS1z1NITcBNM3b960axtqVLiHhoZKxphwJ68TGhqK5557zq6JD+xJuP/444929zPPyMiQTebaSrhnZGRYnWW+ZMmSFpPjjrCVcJdL7p85cwbbtm2TPdF5mqwvDL799lvzWHR0tPkRpPHjx8u+R66a3dLPwN69e/Hmm2+icePGmDdvnhphkw3idjJ58+ZVNH+DUuKE+927d9lSiIiISKH8+fPjiy++sOs9X375pcf1cidtiIsqbCXclbZ5UcLehLul/Vnq4e7v7w9fX1/ZfdpKuGdV08fExMjGzoQ7qS1Pnjz4/PPPBWNPnz7FoEGDOGcA2ZRV5OgscRGo3LVCVucGpdSocJebS4MJdyLY18M9MjJSkLBVwlJyztaNhK0LJTWr24H/ToKWEu5169bF/Pnzzcu7d+/Gxx9/jC+//BIdO3aUra7wJJYq9CMiIgBIe38BmZOmTp8+XTJuaZbtr776ynyhvXLlSkdDJTvItZNRs0dc6dKlJROwXr16VbXtExERebu8efPi2WefVbx+amoqvvvuO9cFRDmGuKjHk1vKAPL3Z+LtZFW463Q6SVuZrPs/Wwl3o9GI1NRUi9ekTLiTK9SoUQPvvfeeYOz+/fsYNGgQf+bIKrUKRcU5nQcPHkjWqVq1ql3bVKPCXS5pz4Q7EYDw8HDZb6QAoEmTJpJ+0CtWrJBNzlriaMLd1gStarctSUtLw5kzZ7BixQqL66xYscLcXiX7N9yPHz/G2rVrVY1HbZcvX7b7PRs3bpQdFyd0jUYjkpKS8OTJE4diI8e5csJUIPNx+GeeeUYwxrYyRERE9pk8eTJq1qypeP3ly5e7MBrKKTwp4S5OjitNuFtqKQNIk/hKK9yBzHvJI0eOyIWOWbNmcUJLcokhQ4bglVdeEYxduXIFI0aMUK2KmbyPWj8b4u38/PPPknWaN29u1zbFTxo5Qu4JeybciZCZPLVU5V6oUCGMGTNG8ljK2LFjFT86ZSmxbq0txePHj9G1a1er2338+LGi/Sv19OlTfPzxxzbXW79+PQBpH64//vhD8b6MRiPu378vexFsMpkwZ84c1KhRA++++65DiXJL7t69q9q2ssTFxaFnz56oW7eu6tsm60wmk8sT7gD7uBMRETmrVKlS+Oabb+x6z5gxY7B79+4cN48QqcfeljLihLszTwSLE+7iCYB9fX0liRolLWWsJdwtVbiLJ00FMv9ullrKANbnnCJylMFgwMyZMyUFSUePHsWkSZN4viZZaiXcxZ0G5J7yUaNFjL3E8xsATLgTmVlKuBcoUAAVKlTAoEGDBONpaWmKJ3RypMJ927ZtNrcrvgh0l5s3b2L48OGScaW/XFNTUzFgwAC89dZbqFOnjuRpgWvXrmH16tUwGo24efOm3S18rBk7dqxkzNmLgu3bt+P06dNObYMcc/fuXUkrI/ETKWooV66cYPnGjRuq74OIiIiEdu3ahVGjRpmLPSj3ESfcPamlDCCtchcn+NPT0yVj2RPuci1lTCaTJElfsGBByRO2J06csNrSc8uWLRZfI3JGvnz5MHfuXMm/x+3bt2PZsmUaRUWeTK2WMtkT90lJSZJJe5977jlV9mOPpUuXyo4z4U70/6wl3AHg/fffR/369QWvRUdHK9q2Iwl3T36M9q+//sLevXsl40oT1wcPHsTRo0fNy6NGjcKsWbPMy+IT1t69e526WM7u5MmTqmwnu9mzZ6u+TVJGXN0eGhqKIkWKqL6fokWLCpblesURERGRa8ycOVPrEEgDycnJkvsld06aammy0+xsVdTL3QdaS7jHx8cjJSVF8iRxcHCw5H714MGDVguwIiIikJSUhN27d2PevHmSxBSRM4oXL47Zs2fD399fML5o0SL89NNPGkVFnsoVFe579uyRvN6nTx+HtmvvF0VBQUH45JNPsHLlSrz88suy6zDhTvT/ypQpIzuedVGn0+kkbSWUtnRxJOGu5qSP7vLgwQOMHTsWn332Gc6fP29xvYULF0rG1q5da/485foNjhkzRr1AyWvItZNxxb8dcd/M+/fvq74PIiKi3EBJ+0I5/N2b+4ir2wH7W8o4mnDPyMiQ3KuJk+OA7QS/3ESSthLucveOQUFBaNy4sWDsn3/+sTpRpclkwsqVKzFq1CisXLkSXbp0wZ07dyyuT2SvSpUqYdKkSZL7r4kTJ9o15x15P1ck3OUqy+VauyhRpUoVu9avWbMmevXqhRdeeMHiOky4E/0/Swn3/Pnzm/8sfmRK7iJQjqXE+k8//YQxY8bgt99+A5DZSmXOnDk59vG/J0+eYOfOnfjzzz8xYMAAixOI+vn5yY5n9cWWq5Tfu3cvNm3aZJ6wVU058csNynTx4kXBsivayQDSvplxcXFITU11yb6IiIi8Wbt27ey+sQWAt956S5OWbomJiVbnXSLXET9RaDAYEBgYaPU9aiXc5SrHHalwFyfE9Xq9IEkvTrhb+nkLDAxEkyZNBGP37t2z2sMdEFZtZmRkWGx9QOSoevXqYejQoYIxo9GIzz//XPapeMqdXJFwF0+qDTiecLeX3KTZYky4E/2/EiVKSCZGBYRVFNmT74DyhLulxDOQ2Zty5MiR2LdvH7p06YLVq1dj0qRJVqvfc4L4+Hg0atRI9jVLs0Bnff6WWtNMnToV77//PvtnE4DMCzlxwt0VE6YC8hNVsa0MERGR/cLCwrBs2TKcOHECkyZNsuu933//vYuisiw4ONhiYQ65ltyEqbYKZdSaNFUu4S6eNBWw3cNdvJ3g4GDB30Guh7s4Se/n5weDwYDSpUtDr3cuhfPrr7869X4iOR06dEDXrl0FY0ajEf/73//w559/ahQVeRK1Eu7ZtyPXr13c4shVxD/vcphwJ/p/vr6+KFWqlGTcWoW70pYysbGxNtcZNmwYUlJSFG0vpxO3AcmSlYi31gs+JSUFc+fOdUlclLPcunVLckPiqgr3vHnzwmAwCMaYcCciInJO06ZN7ZrgbMuWLardtJPns3fCVMB1Fe5ZSW8xe1vKiBPschXu4sKroKAgAJnV8bZa6thKyKekpGDs2LE4duyY1fWI7DVgwAB07NhRMJaRkYHhw4fj8OHDGkVFnsIVFe5ib775pir7sKVfv34oW7aszfWYcCfKRjwRjTjJJq5wj4+PN8+2/O+//2Lw4MEYNmwYIiMjBespSbhTZsI9NjYW+/fvt7reH3/8IWnnkZyczBuwXEZc3V6wYEFJr3W16HQ6Vfu4379/Hxs2bMCff/4pO2cBERFRbiFuRWCLuI+1qyUkJEiu7ck9xO0CbCWbAfUS7nITpspV19vbUsZWwj0hIUHSUiYr4Q5Y/wzy5s2LokWLWnw9y86dO9G3b1/s2rXL5rpESul0OgwZMgTvvfeeYDw9PR1Dhw7FiRMnNIqM3MXafW1W3sxZ2XNF4jxbgwYNnNp2nTp1FK330UcfKVqPCXeibMSPi4oT7HIXOI8fP8adO3fQs2dPHDx4EPv27cPIkSMFVdqelnB31zd/9vLx8VF8E9W3b1+kpqbi3r17GDduHOrUqYOWLVvin3/+sXu/1irqLXH04p3U464JU7OI28o4WuEeFxeHHj16YPr06fjss8+wcuVKNcIjIiLKkapUqYL//e9/itdPSEjApUuXXBiRUFBQkCDhSe7jSIW7rYpzpeRawSjZn62Eu7gPvPhny5mE+5tvvmmzx31248aNU7ReXFwczp8/b3WCViIgM+k+YsQItGzZUjCempqKL774wuEWT5QzWKs+V1ocaasYbc6cOeacj7jjRGhoqKJ9WGKtFbQjmHAnykbcjkKu4l38mN6DBw8wduxYwYXR1atX8e+//5qXtUi4N23a1OJrli4YtXb8+HHF654+fRq1a9fG22+/jR07dgAAYmJi0K1bN+zevVu276I19ibdExMTcfnyZbveQ+py14SpWdSqcF+7di1u375tXl6xYgUvPonchJMfEnkenU6H9957D1u3blX8HlZK5g5aVriL7yXkJkwFpAl3cTsYW4l7JT3cs69j7TMIDw9XNJFfFqPRiPj4eFy8eBGxsbFIS0vD999/jxkzZuDatWsAgJs3b6JDhw748MMP0aFDB9y9e1fx9il30uv1+Pzzz9G8eXPB+P3797F69WqNoiJ3sJYsV5pwV1IJP2PGDFy/fl1yflXyO8Kac+fO2VxnypQpirfHhDtRNnXr1kW1atUAZE6K8+GHHwpe1+v1kqr33377DadOnZJs6+DBg+Y/a5FwDwoKwpw5cyTjer3ergsxd4qKilJlO6NGjZJ8q26Nvcn5LAsXLnTofeQ8uQlT3Z1wd6TCPSEhQVLRnpSUhL179zoVGxEpw8kPiTxXyZIlMXLkSEXrzpo1S9JekLyPlgn3uLg4wbKlhLu4olJccWmrpYy4wv3Ro0fYs2ePYCx71bq1OQ9CQ0PtqnAHMlswdOnSBc2bN0erVq3w9ddfY/369ejWrRsSEhKwbt06c5HJvXv3sGLFCru2T7mTXq/HuHHjUL16dcH4qlWrnGrLSZ7NWoW70pYyStY7d+4cpk6dKhl/5plnFO3DElt92cuXL4+GDRsq3h4T7kTZ+Pj4YOHChdiyZQu2b9+OypUrS9YRP8r4xx9/yG7r0KFD5j9rkXA3Go3mSUizCwgIkJ3wx9vYk0TfsWOHQ320OeO6diIjIyVV4S+88IJL9yluKePIxeK6detkLyJ+/PFHh+MiIiLyFm3btsWqVasUrVu7dm0XR0NaU2PSVEefIhQn+0NCQmTXE8dkK+EuTtzLPXksLubKvu933nnHQsSZ6zn6JHNqaipiYmLMy0+fPsW6deuwceNGwXpbtmxxaPuU++j1egwZMkTQISA5OZlFa15MjZYyShLuer1etjuCrUmjbZk0aZLF1woUKIB169bZtQ8m3IlEdDodSpUqZfFiRVzhfuPGDdn1zp8/j9jYWBiNRkmFhL3q1q1r93uMRiN8fHwk4waDQTYR7wmcPUE6o3///g69L+uJCHIvca/+YsWKKboJc4azLWXu379vsV/7yZMnJTdoRKQ+Tn5I5PkqVaqEPn36KFqXX1h7N3HSW8m1nrjCOzEx0aH5mu7duydYLlKkiOx64pjEXxLY21JGTvYqemsV7KGhoZJ7VWcsXrxYtW1R7lS+fHm0atVKMPbTTz+5dR4Och9bLWWUnIuVJNwdKZZUonz58hg+fLhkvEGDBti1a5fd88Ux4U5kJ6VJPZPJhGvXriEuLs6hi7wsYWFhDiWDLSXc/f39PbbC3ZUTXtpiT/940t758+cFy66ubgecnzR1yZIlVh9rvnnzpkNxEZFynPyQKGd49913Fa03ceJETZ4kJddLSUmR9ENX0lImX758guX09HSHqtyjo6MFy5YS7uIEtzjhbm9LGTnitjWdO3eWXS8kJERS4U+ktd69ewu+KDKZTPj666+dypGQcnfu3MGdO3fcsi9rFe5KXgeUt55xlfbt2+PEiRM4fvw4du3ahb/++gvTp093qGiVCXciO9lTRRsbG+v0TUChQoUcmm05JybcN23apHUIHoGT+tkmrnCvVKmSy/cpTrjHxcUp7h9rMpkk/TjFsk+kSkRElJvZkzTcvHmzCyMhrYir2wFl92FyvdYdma9JacJdHFNcXJygdYKthHtAQACKFi1qNRbxvWD37t1l1wsJCdH0HmLHjh1o3rw5OnTogAsXLmgWB3mWggULSubGO378uGDOO3KN5cuXo2XLlmjZsiWWLl2K1NRUnDx50mX3nbYS6krayjiacJ84caJD77NEp9MhPDwcfn5+Dm+DCXciO9nzmN6TJ09USbiLKzXE5BLoPj4+st/C+fv7O3XSINfjpH7WpaSk4PLly4Ixd1S4i1vKAMqr3B8/fiy54SpWrJhg2V2VB0RERJ7OnokfFy1axEpJLyROeAcEBChqvxIcHCx5atbe9p6pqamSazylCXdA2MfdVg93nU6H4cOHW73fE99/Wlo3JCQExYsXt7gdtXTv3h3nzp0TjCUkJOCrr75CTEwMrl69iunTpyventFoxIkTJyRtRjIyMvDzzz9j165divs/k2f64IMPULhwYcHY7NmzeVxdKDk5GQsWLDAvL1q0CO+//z569uyJtm3bumQ+OlutXpQUqzmacH/rrbccep8rMeFOZCcljzJm2bdvHyZMmODU/sLCwmQT5+3bt0e9evVQo0YNLFy4EHXq1BG8/sEHH1js4c6EO+Vk//77r+CXuV6vx3PPPefy/QYHB8Pf318wpjThLk6m+/j4oEaNGoIxVrgTuR6fICLKOfbt26d4XUstNijnEl87FStWTFH7Sb1eL0nM21vhLjdPjzhZmCUkJEQyD5W1hLvclwZvvPEGfv/9d7Ru3Vp2H0qfdjYYDHj77bddPi/W2bNnMWTIEBiNRkRHR+PChQvYs2ePIFEmTshb89lnn6F3797o1KkT1q5di127dmH16tUYOHAgvvjiC4wZMwYjR450xV+F3MTf3x/9+vUTjN24cQPbt2/XKCLvJ1fMlTX/YFpamtN5Kjm2KtyttVfNonVLGTV55syJRB7Mngr3w4cPO72/rKraN954AwcOHAAA+Pr6olevXoIZ63v37o2rV6/i7t276NSpEypUqIArV65ItufJLWUoU0JCAu7fv88qdwvE/dvLli1rVyWco3Q6HcLCwgSJcaUTp4oveIoUKYKSJUtaXYeI1KekOpKIPINcaxBL/v33X+zevRtNmzZ1YUTkTuLrIlttV7LLmzevIMlub4W7uLo+MDDQ4s+jXq9HaGiooHd7REQEzp8/jwoVKihKuAOZ15mVKlXCtm3bJK/Z0140LCwMs2fPxvr161G4cGHUr18f+fPnR2xsLAYOHKh4O7Y8evQITZs2tfo0d7t27fDxxx+jWbNmFte5ePGioLXIrFmzZNfbv38/Xn/9dSxZssQtT7aS+po1a4b169cL2g0tXboU77zzDvMTLmDrC0pXzH+iVcJd/OS4p2CFO5Gd7OnhroasvtFDhw5F7dq18eyzz+Krr74SJNsB4LnnnsP27dtx7NgxfPbZZwDACvccipP6WSfu3+7Oi25xWxmlCXdx9Xrx4sXZUoaIiMiGTz/9VPG6o0aNku37TTmTOOltT0JF3HLF3oT7vXv3BMtFihSxmrwSF2RNmDABkyZNwkcffSRpoWDti6QKFSrIjsu1sxk2bJhgOfuTk7Vr18bcuXMxevRovP7666hUqRJq1qyJcuXKWdy3I2wl7CIjIzFmzBjJRLLZnTx5UvH+UlJS0K1bN/z1118WW1ckJyfbfbzJPfR6PQYMGCAYi4mJ4TwcLmKrvYsW+/zll19sbsORhPvgwYPtfo87MOFOZCdrFe62Kud8fHzwwQcfOLS/4sWLY+7cufj+++/RqFEj2XV1Op3gEUK5hLuvry8T7pSjeVLC3dGWMsWKFZP02IyOjlY0czsROS4hIQGRkZFah0FECrVt29au9Tdu3Kh6DGxFpQ1nKtzFCXd7W8oonTA1iz0tR63dL5YvX152XG4S4XfffRdVq1Y1v26rrZJer8fXX3+N1q1bo3bt2njllVcUx+wMo9GIpk2bOjRxrSUDBgxAr169JNWyf/31F9566y00bNjQYqW8PU6cOIF9+/axz7iKqlevjurVqwvGVqxYgaSkJI0i8l4pKSlu36ete9klS5bYPNaOJNxLlSpl93vcgS1liOxkLeFepkwZq/3qRowYgbfffhs3b95UPEmFPY8QillKuPORLcqpnjx5glu3bgnGXnzxRbftP+uJkywxMTGSdUwmEw4cOICbN2+iSZMmCA8Pl1S4FytWTFKpZTQace/ePY99JI7IGwQFBfGmjigH8ff3t6tVTPbe2WphKyptyBUrKCWuIne2pYythHupUqVw7NgxRdu29vOUJ08eRdsAMp9anj9/Pq5du4aCBQtKrlHlFCtWDJ9//jmAzMkL582bh3Xr1inepzPmzp2Lpk2bYtOmTShatCgCAwOxf/9+ScsdpU6dOoXdu3ejZcuW5rHp06ebE/tr165F27ZtLSbiDh8+jG3btqF06dLo0aMHDAYDYmNjMXnyZMTFxSExMdHc+qR69epYuHChQ3GSVJ8+fXD8+HHz8uPHj7F+/Xp0795dw6i8jycm3IHM9lDNmze3+LojCXdrk05riQl3IjvlyZMHefLkwdOnTyWvWUq458uXD7NmzcLLL78MILM3XVpaGt58802bF4BqJ9x9fHxY4U45lri63d/fH2XLlnXb/sUTZl2/fl2yzoYNGzBjxgwAwPLly/Hjjz/i7t27gnWKFy+OkJAQBAYGCpJ/t2/fZsKdiIgomwIFCmD//v2oX7++zXVZieodMjIyJG1d7Lk+ErfedHWFu6XKdDE/Pz+bhU8dO3bE+vXrBcvWtvfss88q2reYwWDAkCFDEBkZiSNHjji0DXts3boVW7duVXWbEyZMwPbt29G/f3/MmTMHUVFRgtfbtGmDBQsWCNrtAJnX29n72Z84cQIzZsyw+MVe9uQwOa9y5cqoU6eOoHf/6tWr0a5dO7vm7iDrxO2s5GRkZMjmjBylJOEuPreLOfJ73JmcmSuxpQyRAyxVuZcuXVp2/PPPPzcn27P4+fkpmuhR7YR7SEiIbMK9TZs2+OOPPxzeF5E7iBPuzz33HHx93ffdccWKFQXLV65ckVwUzJ492/znJ0+e4I8//pAk3IsVKwadTidpK3P16lV1AyYiIvICwcHB2LFjh831Ll26pPq+2YrK/e7fvy9J3Ng7aWp2zla4iwsuxCz1XrcVl5yOHTua53IKDg5GmzZtFG3bUX369MnRxVinT59Gjx49LD5l3rdvX8yYMQPbt2+HyWQCACxbtkywztmzZznhspv16dNHsBwfH481a9ZoFI13UlLhrmQSU3soSbjbetJUyRcFYp7awYEJdyIHWJo41VLCvUSJErLj4os5Oc48HiOXcA8LC5M9IRUpUoQTdZLH07J/O5CZ4M8uNTUV165dMy/HxMRIEvAbN26UjGVVaYm3d/bsWTXDJSIi8hq2qowBICIiAqdPn1Z1v5zM3v3E7WT8/f3tKkJyZtJUk8lkd4W70slIlbQnKlGiBLZt24ZZs2Zh06ZNLn+S84UXXsCaNWswatQofP311y7dl1bWr1+PCRMmYNOmTQCAGzduaBwRPfvss5J56datW2d1gl2yj5KEu1zXBlfv09oE1ADsnjNF6ReeWmDCncgBaiXclSTTs0+Cai+5yt+wsDDZKgZrvemJPIHJZJIk3N3Zvx3I/DcrfqQ5IiLC/Oe///5b8h7xxKr+/v7mc8hLL70keO38+fNqhUpEMjj5IZH3mzZtmtYhkJPECe+sJwOVEleS29NSJj4+XlKBaSvhHhwcrKjljdLJVfPnz4+6deuiUKFCitZ3Vrly5dCmTRu88cYbbtmfVqZNm4Zq1arhzJkzWodCAHr37i3IdSQlJeHzzz+H0WjUMCrvoUXCXUl1uq38lnjC48qVK1tdf/jw4bYD0wgT7kQOkEu4h4SEWEzEW2od06BBA1XjEpO7MC1YsKBswj0r+d+hQweXxkTkqLt370omQ3N3hTsgrUrPnnA/efKkZH1xn7qiRYua/22KE+537tzBw4cP1QqViESCg4NRpkwZrcMgIgd17drV5jquaCtD7iWucLennQzgXIW7+LpNp9MpSny/+uqrNtdRmnDXUvbe5kSuVKZMGbz11luCsWPHjmHx4sUaReRdlCS/1W4p42yFe2pqqmQbefLkwccff2zxPa+88oryAN2MCXciB8gl1gsUKCD7uKm1/tJdunRBmTJloNPpXNI3LigoSFK5/sorr8i2lMmKvVu3bqhWrZrHzvRMuZe4uj0kJESTCUatJdzlKtzFst+0lStXTvKFHNvKEBERyXv//fcVrbdlyxYXR0KuJE6423u950zCXVxdX7BgQUX9gevUqWNznZyQcG/evDlKlSqldRiUSwwaNEjyhdayZcsEE6qSY5Qk0z2tpYx44mMAKF68OHr37o3+/ftLXpsxY4Z9AboZE+5EDpBrv5I/f37Zk4e1yXFKly6N9evX4+DBg5g0aZKqMQKZj+v069cPPj4+0Ov1GDhwIPLly2eeMCa7rIR7eHg4Fi1ahL1796Ju3bqqx0TkKLn+7fY8XqwWccL90qVLMBqNePDggexFglj2L+z0er2kLc7FixfVCZSIJDj5IVHOVqhQIRw8eBBffPGF1fUmTZrEXsA5mNxk8/aQmzRV7v5Hjr3927PUrFnT5uSjYWFhiralpbCwMKxduxbr1q3D+vXrtQ6HvFyBAgUwZcoUydxzY8aMkXzxRvZRUuGuJEFuD2e3J27FCgCdO3eGTqfDhx9+iE2bNqFUqVKoVq0avvvuO9SvX9+p/bkaE+5EDrBU4S7H1mz0Pj4+8Pf3BwC0aNFC8Joaj8e0bt0av//+O3bv3m1+DFeuuuKZZ56RjPXt29djZ3ym3Edc+e3u/u1ZxAn35ORkXL9+XfEkbeJ/f+L2FnIXGkSkDk5+SJTzBQQEoFWrVjbX27Ztm+uDIZdQu6VMRkaG4kpOccK9cOHCit4XFBSEvn37Wl0nJ1S4A5n/xipUqIDy5ctj69atWodDXq5KlSoYPHiwYCwuLg79+/fH9evXNYnJGyhJfmdkZKi6TyVJfmv7HDFihGQs+xM3ZcqUwZYtW7Bo0SLNcgH2YMKdyAFyFe5ZCffXX39dMN6jRw/F2+3SpYu5vYTBYMCnn37qRJT/CQ4ORmhoqHk5ICAAH330kXm5W7dusi1kypcvjzVr1qgSA5EzLly4IEm4a9G/Hcj8tx4eHi4Yi4iIUFTdnvV+a8viPvVERERkPyU3/uR5jEaj7Pw39pAreFI6caqjFe5A5r3c9u3bsX79erRs2VLyek6ocBcrWbKk7N+FSE0dO3ZEkyZNBGNRUVHo2rUr9u/fr01QOZwWCXdxGxu5ok5L+4yJiUFiYqJgTHzPndMw4U7kAEuTpgLABx98gICAAABAxYoVJb84rClbtizWrVuHCRMmYN26dahUqZI6Acvo168f1q9fj3Xr1mHAgAFWY3rzzTddFgeREkuXLhUsFyhQANWqVdMoGvm2MuLHny0Rnz/EX+DxEXgiIiLbGjZsqHUI5AIPHjxAenq6YMzeljLBwcGStoNK+7iLr+fsSbgDmbGWL19e9jrV0hPRnq5Lly7mPtvlypXTOBryRjqdDl988QVKly4tGE9KSsLQoUOxaNEixW2hKJOz1eaOEH9hKb5nBiA5v2e5evWqZEyL9rFqYsKdyAFyF0tZJ4MaNWpgy5YtWL58OVatWmWzl59Y8eLF0bx5c9lvA9VWvnx5VKhQweZ6er3lU8Xo0aPVDIlI4tKlS/jzzz8FY507dza3YtJC+fLlBctRUVGKE+7ix4lZ4U5ERGS/Pn36WH1dyYRx5HnE7WQMBoPs08XW6PV6BAcHC8aUVrjfvHlTsFy8eHG79p2lRo0agmWdTmd38t5TlClTBps3b8bGjRuxevVqLFiwQOuQyAsFBgZi/vz5ePbZZyWvLV26FKtWrdIgqpwrLS3N5jpqJ9xv374tWC5ZsiTeffddwVhMTIzkfUlJSbJFoO+9956q8bkbE+5EDsiqZrckPDwclStXhq+vr5sici1r3yzK/UIkUtPy5csFy/ny5UPbtm01iiZTiRIlBMu3bt1yuMKdCXciIiL7lSlTxmrrxjVr1uCLL75Q3LubPIM44V6sWDGHqhzF7TKVVLjHxcVJrsMcLYIKCwsTJIuaN28uaPGZ0wQFBaFs2bIwGAyoVq1ajm/1QJ6pcOHCWL58OZo3by55bf78+Th27JgGUeVMWiTcxXORFS5cWNIibPfu3ZL3bdy4UXZ77du3Vy84DTDhTuQAHx8fc9uYLHXq1NEoGtezdpHrLV8qkGeKjIzE77//Lhjr1KmTea4DrZQsWVKwbE/CXVzhLr75evr0KZMDRC6SmJgo6Q9JRDlX5cqVrb7+888/y97ck+e6deuWYNnedjJZHEm4i+fj0ev1Du8fAEaOHImFCxdi/vz5GDt2rMPb8TR6vR7jxo1D2bJlUbZsWQwZMoT3hKQaf39/jB8/HkOHDhXkIYxGI0aNGiVpW0LyLLVuyU7thPvDhw8FywULFsThw4cl6xmNRsHyd999J1nn+eeflzyplNMw4U7koEGDBpn/XKtWLTz//PMaRuNa1lrK+Pj4uDESym2WL18u6NcXFBSEDh06aBhRJnHCPTU1VfHkbLYq3AFWuRO5SnBwMMqUKaN1GESkktdee83mOhMnTnRDJKSGjIwM7Ny5UzAmfqpQKfHEqUpayogT7iVKlLC7PWh2Op0O1atXx2uvvWb1fionqlGjBjZu3IiNGzfi/fffx9q1azF48GAsX74cJ06cQNeuXbUOkXIwnU6Hjh07SlqHxcbGYvjw4ZwUWwF3V7ibTCbJXGQFCxaUbWH85MkTwXJCQoJkHW+4Xveusz6RG7Vr1w7r16/H4sWLMWfOnBw/oYOjvO3ikTzHzZs38euvvwrGOnbsKLmB0kLBggUlT7kokS9fPkkFUFBQkORmTmnCPS4uDhcuXFA0Cz0REZG3YeGHd/n9998lPYAbNGjg0LYcqXC/fv26YLlUqVIO7Ts3Klu2LDp37mx+6mTgwIE4ceIETpw4gcmTJ0vW//LLL9G9e3d3h0k5zIcffoi6desKxi5cuID58+drFFHOoaTCXck6SsXHx0uS/AUKFJCdbyX706Y//PCD7PY6d+6sWmxaYaaMyAnly5fHq6++mquTzrzRIVdZsWKF4HGzPHnyoFOnThpG9B+dTiepcs+uaNGisjdp4nYyWdsSTwamJOH+77//omXLlujatSu6du2qeDIw+k96errkkUY1JSQk4MKFCzw2HiQhIQGRkZFah0FEKvrmm29srlOtWjV89tlnboiGHGUymbBy5UrBWKVKlVCtWjWHtidOuIsrL7PExMTg5MmTSE9Pl1S4O9q/nYQaNWqEfv36oVq1aujbty+OHTuGZs2a4YMPPkCDBg1QuHBhyfGypH79+vjoo49cHDF5Cr1ej/Hjx0uedFm7di3OnDmjUVQ5g7sr3MXtZIDMe9833nhDMr527VoAmU+Jy30hN3DgQFSsWFG12LTCRltE5BRXJtxLlSolufCl3CEiIkLySHG7du1sTljsTiVLlsTly5dlXytatCgKFy4s+fmVax8DAPnz5xfM2G7ppjC7xYsXmx+/u3r1Kvbu3YtWrVopDT9Xy8jIwPjx47Fr1y4888wzmDlzJkqXLq3qPu7cuYOePXsiOjoa4eHhWLJkicOPxZN6goKCkJSUpHUYRKSimjVrolKlSrhw4YLV9f788083RUSOOH78OP7991/BWLdu3Rx+irh48eKC5b///luyzl9//YUhQ4YgNTUV5cuXl7SpYMJdHXq9Hh999JEkUR4SEoLp06cDyPzC5fjx47h+/Trq1q2L4cOHm/9NN27cGFOmTDG/Ly0tDStWrHDfX4A0lTdvXkyfPh3dunUz/xs1mUwYP3481q1bB39/f40j9ExKEu5qFh6J71+Dg4NhMBhk1924cSPq1atnMcZ33nlHtbi0lHvLcolIsew9tMWUVPdbS2T5+vpi+PDhsq95SjUzuVdMTAw+/fRTwTfu/v7+HvdYmbXkaZEiRVCpUiXJuFyFOyBNxNuqcM/IyJAkDnbt2mX1PfSfkydPmj+vGzduyE7UYw+TyYSzZ88KEgUrVqwwT+oUExOD5cuXO7UPIiKyrG/fvlqHQE4S/y4uWbKkw+1kAGl//6ioKMGErElJSRg3bpw5gXflyhVWuGtIp9OhRo0aaN++PYoUKYKlS5di9OjRGDNmDL788kvBun5+foLr7IIFC+KXX35RNR4fHx/8/vvv2LVrFxo2bKjqtsl+FSpUQO/evQVjUVFRWLBggUYReT6tK9wt3fdm6devHwYPHiz7mqUitZyGCXcisslawt1WhXtoaChWrlxpsf2Gn58f2rdvL/ua0kcLyXskJydjyJAhuH//vmC8Q4cOHveL11bC/YUXXpCMW+r7Lm4pY6vCXVwBBgCBgYFW35NTHDt2DKNGjcK3336r6ELREfPmzRMs79ixw6ntTZw4Ed27d8cHH3yApUuXAgC2bt0qWGf79u1O7YOIiCyrWbMmvvrqK63DIAdFRUXh2LFjgrEuXbo41bazYsWKkmvHw4cPm/+8dOlS2RYIWfz8/LyipUFOZTAY8O6776Jly5aS+Y+AzB7wderUQfXq1TFjxgyEhYXh4MGD6NixI1599VWMGzfO4X0XK1YMX3zxBUJCQhAeHo5p06Y58TchtXTu3BkvvviiYGzt2rU4fvy4RhF5Nnf3cH/w4IFg2VbC3RJv6s/PljJE5BRrCXeDwYAff/wRQUFBqFq1Km7evClZx9pJPjk5WZUYKWcwGo0YM2YMLl68KBivWrWq7GQrWrPVw/3ZZ5+VjIsvRLLYW+Eu91j0gQMHEB8f7xGTyjrqzp076Nevn/lLPqPRiI8++ggREREoUaKEal+6qDXvRnp6OubMmSNIpi9atAhPnjxRZftERKTcm2++idGjR2sdBjlAXJ0cGhrqdEsBvV6PWrVqCVoUHj58GO3bt0dcXBzWr19v9f3169fP0ddU3q5UqVKYPXu2YCwgIABDhw41LxuNRnz55ZcwGo0oX748rly5ItlOy5Yt8eDBA5w4cQI1a9bExIkTERQU5OrwyQF6vR7jxo1Dp06dBK1lhg0bhuXLl6Ns2bLmsSNHjuD27duoXr16rn1SRUkyXc0Kd/GE1+Hh4Q5tR/x0Uk7GhDsROcVS4qp8+fLo27ev+YJFrjIBsP6ok1xLDvJeixYtwt69ewVjJUqUwPTp0+Hn56dRVJbZSrj7+/sjT548ePr0qXm8WbNmsutbSrhHRkbi1KlTyJMnD5o0aWL+d3T9+nXZ7fTv3x/fffedw/1OtbZs2TLBEzXffvstdu/ejRs3bsBgMGDKlCmoW7eu0/uxdD569OgRlixZgtTUVHz88ccoXrw4Tp06hdGjR+PJkyfo16+foNXVokWLsG7dOsl25MYAoGfPnnj11Vfx8ccfy8YQFRWFbdu2oUiRIhaf/CEiIvdKTExEYmKi1mF4LZPJJEm4v/nmmxZ7/9qjdu3agoT7wYMHceHCBURGRkr6tYtxXpycr2XLlnjppZfw+PFjvPzyy6hRo4ZknUGDBnnUHFFkXenSpdG7d2/MnTvXPJaQkIBBgwZh2bJlAIAJEybgyJEj5tdfffVVdO3aFa+//rrb49WSu1vKHDx4ULBcqlQpu7dhqdVwTsWEOxE5xcfHB127dsWqVavMY7/88gvCwsIE61lKmIp7sWVXvnx55MuXD3FxceoESx5r586dkh7XwcHBmD17tsdeBIeHh8NgMMjesBUtWhQAMGLECPMjrQUKFJCdpR3IrOTKLivxu2TJEvPY/v37MXXqVACQtNzJ8s8//+DmzZs2L3AeP36Mb775Bnfv3kXHjh1VSWIr8eDBAxw7dgyhoaG4c+cOKlSogCpVqphfv3btmuQ9N27cAJA5i/0333wjiXXZsmVYs2YNihYtii+//NJc3ZLl2LFj2LFjB8qXL4/3338fPj4+FhPuI0eOxMmTJwFkPkWwbds2zJ492zyh7axZsxAWFobXX38da9assbv3+8mTJ3Hy5EmUKFECb7/9tuC1pKQkdO7c2TyhJxPuRET2a9OmDbZs2aLqNoODg1XdHgldvHhR0jvdUoGCvV577TXodDrBl/m9evVCnjx5rL6vZMmSsslZynnKlCmDMmXKAMicfDM+Pt782saNGz32PoMs69y5M86dO4d9+/aZx+7evYvmzZvDx8dHkkT++++/8ffff2P69OlOzQuR07hz0tTbt29LKtyzF6f17dtXUb99cQ4pp2PCnYhsstXDvU+fPggICMCtW7fQtm1b2ROlpQTXu+++a3XfX3/9NT7++GP7AqYcIykpCd988w02btwoGNfr9Zg2bZrVCXe1ptfrUbx4cURGRgrGCxYsiOLFiwPInGG9WLFiuHHjBt544w2LjyaLK9yvXr2KS5cuCcb27t2LuLg45MuXz5wAlhMdHW014Z6eno4+ffqYH6s9ceIEdu3a5fILnJiYGHTs2FHwBZpOp8O0adPMF7+2KvPFCfkbN25g4cKFAID4+HgsWrRI0GczKipKMJHe3Llz8cILLyAlJUWy7d69e5uT7QDMj6GKjRo1ymqMSowdO9accDeZTIiIiMC2bdvMyXZyHVaqEnm3nj17qp5wJ3Wlp6dj+fLliIyMxFtvvYUTJ04IXi9RooSkT7OjQkND0bRpU/z666/msadPnwqePhTLnz8/pk2bplr7OfIcw4YNw4QJE5Ceno4WLVpIijQoZ9Dr9Zg4cSJ69+6N8+fPC16zVrG9cOFC1KtXL9f82xYn3PPnzy9pW6pWD/c9e/ZIxrK38unQoQOuXbtmc3LjmjVrqhKPp2DCnYicotfr4efnh549e1pdTy7hPnbsWJuTaeSWX4g5zZ07d3D58mWEhISgcuXKDh2nkydPYty4cbhz547ktREjRuSIyqKmTZti8eLF5uXChQtj4sSJgp/3qlWromrVqla3I064y138mEwmREdH20y42+r/fuDAAUEPS6PRiDNnzqBRo0ay669duxbff/89ihcvjnHjxqFYsWJWt2/JsmXLJE+rmEwmTJ48GQ0aNIDRaMTZs2ft2ubKlSsFy3v37kVqaqr5MXS5SXf++ecf2W2Jb/jdISUlJdc93qo1VqoSebewsDAMHDhQ0G7AWQkJCbh//765SpacM3PmTGzatAlAZpJGfI/QrFkzVVvjjRgxAvfv3xd8qZ6dj48Phg4disOHD+PZZ59Fp06dkC9fPtX2T56jefPmqFatGpKSknJtX29vERAQgFmzZuHDDz+UvZeUc+3aNRw8eNBtT/ZqTXw/OX78eOzYsQO7d+82j6nVUkbuGDz33HPmPwcFBeHLL79EkSJFBE8IBwUFmQthevfujcDAQFXi8RRMuBORU6xNmpqdXMKdj/DlHAkJCThx4gSOHj2KI0eOCCbALVy4MNq0aYNWrVopqpJ++vQp5s+fb3Gyqk6dOuG9995TLXZX6tatG4KCgnDz5k28/PLLaNSokcWnOazJnz+/ovWio6PxzDPPWG2ztH//fuzZswd+fn7o06cPSpUqhePHj+O7775DgQIFEBAQIHmPuLL64MGD+Pfff1GqVCnMmjULAHDv3j188803mDRpkh1/s//88MMPsuOPHj0CAJw+fdrubcp9MVG7dm106dIFgwYNwqlTp+zepjuJJ/siIiLndezYUdWEe1BQEJ9AUklUVJTkekD8u1ytdjJZ8uXLh2+++QY9evTAhQsXJK9Xr14d7dq1Q7t27VTdL3kmRydyJM9ToEABLFiwAOPGjcPZs2cF7VHefPNNfPbZZ+jTp4/gCdmVK1fmmoS7uMLd19dXkrtRK+Eu7t/eokUL2YK8fv36oXr16khMTETdunXh4+ODy5cvI2/evOaWrN6ECXcisslaUt2ZhLsjiUlyj/T0dJw/fx5Hjx7F0aNHcf78eYs93u7du4eFCxdiyZIlqFevHtq2bYtq1aoJfsnGx8fjzJkzOHnyJH777TfZb8H9/f0xYMAAdOjQwWV/L7UZDAbBJJqOUppwj4mJsdi/PUv2R/ru3buHOXPm4NNPP0VycrLF92R/tHrXrl0YM2aM7Hq7d+92KOF+7Ngxm+tYSsjLiY6Oxvbt27Fr1y7Z11evXo1jx46Zk/meqFWrVpJeh+R6rFQl8n5Kr03J/ZYuXWq1Z/Bzzz3nknaCBoMBX3zxBT744APB/vV6Pbp06aL6/ojIPUqUKIGlS5ciNTUVt27dwq1bt1C4cGE8++yzADKLo8aOHWte/8yZMzh9+jRefvlljSJ2H/GXma5KuMfFxUmevrb0+ep0Orz22muCsYoVKzodg6ditouIbLLWLkRpKxEm3D1HamoqHj58iIcPH+LBgweyf7527Zrd1VwZGRnYu3cv9u7di5IlS6JFixaIjY3F33//jUuXLlmdC+Dll1/G2LFjBZOr5CYBAQHIkyeP1Z6iQGbC3Vo7GbGzZ89i69atVpPtgDDhvnr1aqvrxsXFYfny5fjxxx+RmpqK119/HUOHDkV4eDhu376Nq1evokqVKuYnWB49eoSBAwfajNXf31/B3wioVq2aovX+/fdfRetphcl2bbBSlcj7sR2hZ7p+/brN/r1qV7dnV6FCBQwePNj85F7ZsmUxatSoXJF4I/J2BoMBZcuWlfTlf/PNN7FgwQLcu3fPPLZ27dpc8e9eXOHu5+fnkoS73Hn9/9i77/Aoqvdt4PdueiEVEnoJvQoIAUIVlC9NkIBIUQREQXoNvYUqvQsovQhSDUjvvaMgiAhBOgSSQEghdd8/eJNfZmdrMruz5f5cl5fMmdmZJzubk51nzjzH0MFkto7ZLiLSS9dIIUNrLDo5OYnamHA3reTkZFy6dAlnzpxBZGRkVjL97du3kuxfV4L40aNHBs1E7uzsjH79+qFjx452f4Hs6+urN+H+4sULvHr1yqj9qj/ip0n24/777786t50xY4ag9t/Ro0ehUCjQqVMn9O3bF8nJyciXLx82bNgAf39/bN++Xe+EPOfPn8elS5f0xklERKSPQqHAkCFDshKrZBlWrFghGF3u7u6OwMDArMnn/f39syYUN5XOnTujTp06iIuLQ6VKlfg0BJGNc3R0RJcuXQR/D86cOYN3795pLLNpS9Svv0yVcM9+XZipcOHCud6vLWC2i4j0kiIxrqkz9/HxyfV+pdSvXz8sXrxY7jBy5dWrVzh16hROnTqFCxcuIDk5WbJ9Ozk5oWrVqqhduzZq1aqFMmXK4Pbt29i+fTv2799v9LGqVKmCiRMnomjRopLFaM38/Pz0Tvrz4sULnD9/3qj9apskLLvMEb+6nkLIpOlL1ZEjR/D8+fOsz8DLly+xceNGDBgwQFDvX5t+/frp3YaIiMhQbdq0YcLdQqSmpuLChQuCknfA+1r73bp1w549e/Ds2TN8+umnZhkVyZJiRPalZcuWmD9/ftYNv+TkZFy4cAENGzaUOTLTUalUGke4q+d1cptw37dvn8Z5uNjPvseEOxHpJcXoD021lAMDA3O9XykZWtLCkqhUKty5cwcnT57EqVOnNE4GlRulS5dGrVq1UKtWLVSrVk00EqBChQqoUKECBg0ahH379mHbtm2CiWmyc3JyQuXKlVGtWjUEBwejWrVqdj+qPTs/Pz9Rm7u7u6D8xeXLl01y7MySM7l5+uHmzZuC5c2bN+Pjjz/WWmediIjIVKzxO52tOXv2LDZs2IA///xTNCjDw8MDX375Jdzd3dGhQweZIiQie+Dt7Y2qVasKBiGdOHHCphPumhLpjo6Oomvv3CTc4+PjMW7cOFH7tGnTDK6CYOuYcCcivaRIimpKuHt4eOR6v1IyZHSvJcgsFXPy5EmcPn3aqJre2Tk7O8Pf31/wX968ebP+q1SpksYksCZ58uRBhw4d8Pnnn+PPP//Ejh07cPfuXXh7e6N69er48MMPUalSJTg7O+coVnug6YmPjh07YtWqVTpf17ZtW+zcuTNXx84sKZPTz5ImKSkp6Nq1q2T7IyIiMpSjoyOaNWumt2Y4SS89PR1LlizBunXrtG7TpUsXeHl5mTEqIrJnjRo1EiTcT506hYyMDJsd/KU+uh2QvqRMRESEqM3Lywsff/xxjvdpa5hwJyK9pBjhrj6BiRS+/vprrF27VrL9WVqJG3V79+7Fn3/+iYsXL+qdBDOTUqnEBx98gDp16qBQoULImzdvVnLd09NT8rvPCoUCVatWtYuJaKSmaTRetWrV9L6uVKlS8PLyQlxcXI6PnZCQgGfPnuktaUNERGQtJk+ezIS7mcXGxmLMmDG4ePGi1m0CAgLQqVMnM0ZFRPauYcOGgjJjsbGxuH79us1es2oq9ero6CjK6+ibZ0ubX375RWPZtp49e9rsTYycYMKdiPSSIuHeunVrLF++POtu63fffZer/QUGBqJLly6SJtw//vhjjB8/XrL9SW3u3LkaJ59V5+HhgZCQENSvXx9169aFt7e3GaKj3MpeOiZTtWrV4O3tjTdv3mh9Xb58+VCsWDHcuHEjx8c+efIkTp48mePXExERWRo+0p5z586dw/Hjx1GmTBm0bNnSoMkF7927h4EDB+L58+ca15cuXRo1atRAp06dkCdPHqlDJiLSqlChQihZsiTu3buX1XbixAmbTbirD6JSKpXw8fER1XDPPpG1oe7evYs5c+aI2j/88EN07NjR6P3ZMibciUgvKRLufn5+WL16NSIiIlCkSBF8/vnnBr1O08XSmDFj0KRJE6MfRfX390d0dLTGdUqlEs7Ozpg1axaGDx9u1H4tQaFChdCgQQPUr18f1apVMygxT5ZF0+Sxrq6uaNiwocZH9jIFBASgaNGiooR7gwYNmEQnIiIioxw9ehRhYWFZy8uWLcOXX36Jzz//HO7u7hpf8+7dOwwePFiUbHd0dMSAAQPQqlUrlpAhIlk1bNhQkHDft28fvv/+e5ssefro0SPBcoECBeDs7CxJSZkTJ05obJ89ezZHt6vhu0FEeknVcZYrVw5hYWHo1KmT6O6qMUJCQrR+aVcqlWjWrBkCAgIE7Xny5EGrVq207nPixIkA3k8Cag2USiWqVq2KAQMGYOvWrdi1axeGDh2K4OBgJtut1Keffir4XQsNDQUAfPTRRzpfFxAQgGLFionay5Yti9atWwva2rZtiz59+kgQLRERkeXL/FtqCTIyMvDo0SOcOHECBw4cwLlz53Dr1i08fvwYcXFxORppKLVHjx5h0qRJgrbY2FgsWrQIrVq1wk8//aSxhN3atWtFIyrz5s2LFStWoHPnzky2E5HsmjRpIlh+9eoVfvvtN5miMa2HDx8KljMHduU24Z6YmIgff/xR1D5+/Hg+uaQBR7gTkV65SY7nVqlSpQTLCoUC/v7+Wrf38PDAlClTALy/aJg9ezYSExPx/fff459//tH6utq1a2ft31K5u7ujUaNGqF+/PkJCQiy+5jwZJyAgAPPnz8fmzZtRqFAhfP/99wCAWrVqwdnZGSkpKRpf5+/vj0aNGuHHH3/MmvjXwcEBrVq1gkqlwqFDh5CUlAR3d3d0794dBQsWhKurq8a6e0S2LiEhAQkJCXKHQURmMmrUKOzYscPsx42NjcXdu3ez/vv3338RGRmpcw4epVKJPHnywNvbG97e3vDy8sr6f8GCBdG0aVPkzZvXZDGnpKRgxIgRWvvIuLg4LF++HFu2bMGsWbOy5pl58uSJqMRjuXLlsGDBAp3f2YmIzKls2bKoUaMGLl++nNW2Zs0afPbZZzY3YO327duCZW0J9/j4eL37unfvHvbt2wd/f3+NpWQAiAZ50XtMuBORXlKUlMkpV1dXDB8+HHPmzIGDgwNGjhyp8wZA9oR5kSJFsGDBgqzlcuXKYdGiRVoTl5Zu+/btKFiwoNxhkAmFhIQgJCRE0Obs7IwqVaoIvhxm5+DggKCgICxZsgSHDh2Cm5sb2rVrh0KFCgF4P4P8H3/8gWrVqmXdpClbtqxJfw4iS+Xp6Sl3CERkRqYeSJGcnIzIyEhBcv3u3btaSxjqkpGRgTdv3midt2XZsmUYOXIkmjdvbpKfa86cObhz547e7V6/fo1+/fph1qxZCAkJwZw5cwTfrZVKJSZOnMhkOxFZnG+//VZwTfXixQts27bNpiZyjomJEZV9ybz2K1y4sKD94sWLOHbsGOrWrSsorZORkYGDBw9i7Nixeo+3Z88eCaK2TUy4E5FecibcAeCLL75Aq1atoFAotNaONIS7uzsWL16MgQMHIikpSeM2lvA4rza2duedDFeuXDmNCfdGjRpl/Ts4OBjBwcGibXx9fUVlaSpXrgxfX1/ExsZKHisREZE96N69O6Kiosz23TExMRHjx4/HqVOnMGrUKEnLtBw4cADbt28XtJUoUQKjR4/Gxo0bcfz4ccG65ORkDB48GO3btxfNF/PFF1+InlAlIrIE1atXR7Vq1XDt2rWstnnz5sHLywstW7Y0aB8ZGRlYunQpfv/9dyQnJ6NgwYJo1qwZ2rRpYxFlVVavXi1qK1euHACgZs2aUCgUWU9FA8Dw4cNRrVo1LFu2LCvvs2PHDsyYMcOg4+XPn1+CqG0Ta7gTkV6aJnOUWuYfAW08PDwMSrbrqzdfvXp1HDt2THCRUqhQIfj6+gLQn3D39vbG1q1b9cYBAKtWrdKYACUyVp06dURtpUuXRr9+/XK0P2dnZ6xatSq3YRFZnfj4eNy/f1/uMIjIjIYPH26S/T569ChHyXZfX18EBQUhb968ORpMcejQIXTs2BEXL140+rWaPHjwAFOnThW0ubq64ocffkC1atUwe/ZsbN68GbVq1RJsk56eji1btgja/Pz80KtXL0niIiKSmkKhwLfffitoy8jIwMSJE0U3D7XZtm0b1qxZg5cvXyIuLg63b9/G/Pnz8dlnn2HTpk1ITEw0RegGO3/+vKitZMmSAAAfHx+UL19etP7atWuYMWMGLly4gNDQUIOT7QMGDMhdsDaOI9yJSK969eqhYMGCosmQxo0bJ9kxRo8eja5du2Yt57TzNuQRW0dHR4wdOxazZs2Co6MjRo8enfU6TRdOa9aswfXr1/Hq1Su0b98eBQsWxOTJk/Hrr7/iwYMHGiePAoAqVapg6dKlOfo5iLKrWbMmypQpk/Wod9OmTTFt2rRc7bNIkSIYOXKkwV+ozKVFixbYu3ev3GGQjfLw8JD9QoiIzKtdu3Z4/vw51q9fb9bjOjs7o2TJkihVqhRKlSqF0qVLo1SpUvDz88vaRqVSITk5OauUTFxcnODfcXFx+O+//0SJoKioKPTp0wedO3dGv379BKUANFGpVIiPj0dqaioyMjKQnp6O9PR0pKamYsSIEaJ+ceTIkQgKCspaLlWqFBYsWIDw8HCdf6MHDBjA0l1EZNGCg4PRuXNnbNq0KatNpVJhxowZqFmzJtzc3LS+NioqSuv1/Zs3bzB37lxs2rQJCxcuFPSh5vLq1SvRwJKRI0cKKhZUr14dt27dEr12586d2Llzp8HHKlWqFL766qucB2sHmHAnIr2USiVWr16NrVu3wtnZGYUKFULhwoVRsWJFyY5Rvnx5hIeHY//+/ShXrlyO66gZWtOycePGaNy4sahdU8LdyckJnTt3FrQ1b94czZs3R2pqKmbMmGGzM5yTZVAqlVi6dCl27NgBd3d3hIaGSrLfli1b4uDBg7h69aok+5OCq6ur3m2GDBmCp0+fYvPmzWaIiIiIrJmjoyMGDhxosoS7QqFAoUKFBEn1UqVKoUiRInqfvFQoFHB1dYWrqysCAwO1bnfkyBFMnTpVNMhj06ZNuHDhAqZMmYLSpUsL1sXHx+PixYs4c+YMzp07h6ioKIN+ntatW6NVq1aidkdHR0ycOBGenp749ddfReurVKmCFi1aGHQMIiI5DR48GA4ODoK/C1FRUVi7di169+4t2DY+Ph7h4eE4f/68QYM2nj9/jpEjR2LDhg16b4ZKRaVSYe/evZgwYYKg3cPDA23bthW0SVG9wNPTk9dhBmDCnYgM4u/vL/rjIyWFQoEWLVrI/kU9ez2zTLqS+E5OThg3bhwT7mRyPj4+6NGjh6T7dHNzw/Lly9G7d29cuXLF6Nc7OztLPgmxvjkjMkelLF++XNLjSqVp06aYOHGiaPJbIiKyLUOGDEGNGjUQFBSkc0SkFJo0aYLKlStj0qRJuHDhgmDdvXv30LVrV/Tr1w/BwcE4e/Yszpw5gz///BPp6elGHadkyZIICwvTul6pVGL48OHIkycPVq5cmdWuUCgwYsQIvTcYiIgsgUKhwIABA/DPP/8IynOtW7cOrVq1gqenJzw8PLJuNKrPY5HJ1dUVtWvXFq2PjIzErFmzBE/Sm9L69euxcOFCUfuHH34ourZSnzjVWC1atMDEiRNztQ97wYQ7EdmU3P5B03RhwosHsmUKhQLe3t5Gvy5zktbFixdLGo+2SeAqVaqEoKCgrLr1lvp76enpabbRLEREZLgGDRpIur8WLVogX758ku5Tl4CAACxatAhbtmzBokWLBDe8U1NTMW/evFzt393dHTNnztT7pJlCocD333+PfPnyYenSpXj37h3CwsJQtmzZXB2fiMicFAoFhg4dik6dOmU95Z6SkoLPPvsMwPtBQLpuWvr7+2P9+vUICAjAtWvXMGzYMLx58yZr/c6dO+Hq6oohQ4aYNOmuUqk0PnUEALVr1xa1ffDBB/Dx8cHr16/17tvBwQH79u2Dn58f3r17Z9CTyPR/LPNqlYgoh3KbhNP0+K85Jo0lsnSOjv93j16pVGLgwIGSj+hTKBRZX3LVrVmzBuPHj8+qfavrJkGRIkUkjQsAihcvbtB2me/Txx9/LHkMRESUc4MGDZI7hFxTKpXo1KkT1q9fLyohkxsFCxbE7NmzUaxYMYNf0759e+zfvx+nT5/W+rebiMiSlSxZEu3bt9e4TleyvWrVqli1ahUCAgIAANWqVcPy5ctFE2H/8ssvJn8q9/Hjx3j+/LnGdc2bNxe1ubi4YN68eQgJCUHTpk21DhQaMmQIzp8/n3XtxWS78TjCnYhsSm7vHjs5OWHUqFH44YcfoFAoMHz4cINGq/bo0QOrVq3KWuaM3WRNDPm96dChA+rXr48///wTISEhKFu2LP744w+dr1mxYgUcHR1Rvnx5hIaG4tmzZ4L1+fLlQ/369bFjxw54eXmhZ8+eKFCggEExt2zZEjNnzhS1N2jQADNmzJC8pMuECRPQvXt3vdvlyZMHwPs+IC4uDlFRUejatSvKlSsnmguCiIjMx5YGUJQsWRJr167Fjz/+iA0bNmgsiQi8/15bvXp11K1bF7Vr14aPjw8cHR3h4OAApVIJBweHrP9ygk90EZG169evHy5duiSabFSTJk2aoE2bNqhdu7ZokF6pUqUwdepUjBw5UjAv3M8//4z//vsPI0eOhI+Pj9Thi8qMZerevXvWdYm6ypUrZ5Wg6d27Ny5fvixYv2XLFpQsWVLaQO0QE+5EZNVat26NiIiIrOUhQ4bkep9t27ZFs2bNoFKp4O7ubtBrOnTogHPnzuHvv//GBx98wJE+ZFU0JdzVbyJ9+umnKF26NGrWrJnVFh0drfF1aWlp6NixY9aoDwBYtGiRaARJYGAgRo8ejdGjRxsds4eHB4YOHYo5c+ZktdWqVSvrJpm7u7vGiY0UCgVcXFwQHByMkydPCtaNHTsWjRs3xnfffYe7d+9mtTs4OKBSpUqoW7cuzpw5k9VeqFAhFC9ePKtNqVTiiy++APB+tODSpUuN/rmIiIgM4ezsjIEDByIkJAQTJ07EixcvALz/+xMSEoKQkBDUrFnT5PXliYismbu7O2bPno2vvvpK56So3333Hb777jud+2rcuDHCw8Mxbtw4wY3Qw4cP47///sPatWvh4uJiUFzHjx/HmjVr4Ofnh2HDhqFgwYIat8tegz5TgwYN0LNnT4OOo2m/+fPnN+i1pBsT7kRk1bp164Y//vgDDx8+RIMGDSSrz2nsxUnevHmxZs0aJCUlwd3d3WLrSxNpoinh3q1bN7x79w6RkZFo2bKlxkfXS5UqJWrr06ePxmNoGlmobUSeoTp16oTPP/8ciYmJ8PT01Pt7d/ny5azHQ9PT0zFlyhTs3bsXALB58+asn2fEiBHo168fkpOT4e/vjw0bNkChUGDgwIG4dOkSUlJSoFQqMWbMGAQGBiIhIQGvXr3CN998k/XYJRERkTnUrFkTO3fuxF9//QV/f38ULVrULJP0ERHZimLFimHOnDkYM2YM3r59i6pVq8LX1xdPnjxBhQoV8Omnn6JChQoG7atZs2Z49eoV5s+fL2i/e/cudu7cifbt2+Pq1asAgBo1ami8frl06RKGDx+eda1048YNVKlSBSdOnECJEiWgVCpRuXJl1K5dG0ePHhW8NiwsDB06dDD4Z69Ro4ZgAGP16tXh4eFh8OtJO4Uqt1e7pNfLly8Fo/wAICoqyqyT7BDZsvT0dCQnJ8PNzc1mLjDYb5A57dy5E1OnThW0qT9aqMm7d+/QsmXLrAmCunXrljWpqSY1atQQLFesWBFr164Vbde4cWPExcUJXrds2TK98WTXoEED0SgVQ36mTI8ePUJkZCSqVKkCX1/frPbIyEhcvHgRFStWROXKlY2KSf3n18WYWMk47F+JyFjsN4jIWOw3rI9KpUJqamquy2VlZGSgX79+Gkef58mTB2/fvgUAtGrVChMnTsxad+DAAUyZMgVJSUk5Oq5SqcS+ffvg7+9v8GsyJ90+ceIEPvjgAwwbNowDiCTCEe5EZPUcHBwMLv1CRGItW7bETz/9hKioKACGl2ZydXXFhg0bsHv3bgQEBKB169ZGHVfbPf/OnTsLEuw5megut+MJihQponHy1aCgIAQFBeVq37oMGjQI5cuXN9n+iYiIiIhITKFQSDI3hVKpxNy5czFmzBicOHFCsC4z2Q4Ae/bsQWhoKKpUqYKNGzdi3rx5uTpuo0aNjEq2A+/n+ggLC0NYWFiujk1iTLgTERHZOWdnZ2zatAmHDh1CwYIFUbduXYNfW6BAAb31DLVxdNT8NaRr165ISUnBnTt30LJlS5QrV87ofVviA3zjxo3D5MmTAQDFixfH559/jlmzZmWtb9KkCb788ku5wiMiIiIiIgm4urpizpw56Nu3r9aJTYH3k6pOmTIFS5YsyfUxBwwYkOt9kHSYcCciIiL4+Pjg888/N+sxs5dqyc7Z2VlrLXhDWWLCvU2bNihZsiSePXuWdVPjwIEDuH79OvLnz49evXrJHCEREREREUll5MiR6NixI5KTkzWuP3v2LGbPno2UlJRcHeenn35C4cKFc7UPkhZn9SMiIiJZlCxZ0mT7tsSEOwBUqlQJn3zyCdzd3eHu7o6ffvoJe/bswdatW01aqobeS0hIQEJCgtxhEBEREZEdKFKkCCZMmJD1ZO+HH34o2mbv3r2iNm3J8/Hjx2Pv3r1Zk626u7tj0qRJqFatmoRRkxQ4wp2IiIjMokmTJjhy5AiA96PYO3bsaLJjBQUF4fbt2ybbv1QcHByQP39+ucOwG56ennKHQERERER2pGnTpqhbty7i4+MRGBiIiIgIhIeHa93+u+++Q48ePXDmzBkMHToUAFC+fHmsXLkyq8b8+fPn8fz5c7i6unKSUwvFhDsRERGZRVhYGBwcHPDy5Ut07drVpF8Ohw8fjm+++SZrediwYSY7FhERERERkTYeHh7w8PAAALRq1QqHDx/G2bNnRds5OTmhXbt2cHR0RMOGDbF79248fvwYVatWhZOTU9Z2SqUSBQsWNFv8ZDwm3ImILAxLHpCt8vf3x7Rp08xyrCpVqmDixIk4fPgwKlSogPbt25vluGTZ4uPj8fLlS5QoUULuUIiIiIjIDimVSkybNg2ffvop3r59K1gXGhoKf3//rOUCBQqgQIEC5g6RJMCEOxGRhWHJA6LcUygUaNWqFVq1aiV3KGRBPDw8kJiYKHcYRERERGTHPD090a5dO6xZsyarLSAgAD179pQvKJIUJ00lIiIiIiIiIiIiMpNvv/0WtWrVgkKhwAcffIDly5fD19dX7rBIIhzhTkRkYVjygIiIiIiIiMh2ubi4YMmSJXj37h1cXV3lDockxoQ7EZGFYckDIiIiIiIiItvHZLttYkkZIiIiIiIiIiIiIiIJMOFORERERERERERERCQBJtyJiIiIiIiIiIiIiCTAhDsRERERERGRBgkJCUhISJA7DCIiIrIinDTVDDIyMkRtr169kiESIpKTv78/lEr99zkTEhLw9u1bUTv7DSL7Y2i/QYbj9zIiMqZv9fT01NjOfoPI/hjTd/D7BpF9U6hUKpXcQdi6v//+GxUqVJA7DCKSWVRUFPLly6d3O4VCYYZoiMgaGNpvkOH4vYyIjOlb+b2MiDIZ03fw+waRfeOQKSIiIiIiIiIN4uPjcfnyZbnDICIiIivChLsZxMTEyB0CEVmR+Ph4HDp0SO4wiIhsEr+XEZExPDw88O7dO7nDICIrw+8bRPaNCXciIgvj4eEBNzc3ucMgIiIiIiIiIiIjcdJUMwgKChK1/fXXXwgICDDpcRMSElCiRAkAwP379+Hh4WHyfRi6vb7ttK03pj172+XLl1GjRg3BMW7duoW8efMa8C7kjqWeh5yeA23rDGlLSkoS1bEzx3mQ4xxoeo2/v7/Bx7PmfiMn+zHlZzan/Ya9fWal6L9zss5S+29L+V0wpt8gw1hz/8rf69yxlN9rfi+T/3fB2L7VnvoNQ1/D6znT7kOO/pv9hv7XWMP1HGC5n1n+rTPtPpiPE5P1PKjI5KKiolQABP9FRUWZ/Ljx8fFZx4uPjzfLPgzdXt922tYb05697f79+7KcA10xm3Ifhmyf03OgbZ0hbfb0u5Db41rze5WT/ZjyM5vTfsPePrNS9N85WWep/bcl/y5Q7vD32rjt+Hud+/3we5lxP6sp9pHbY9rTe2Xoa3g9Z9p9yNF/s9+Q9rhyvVcqleV+Zvm3zrT7kKLf0LWe/bdx50GhUqlUIJN6+fKl6C6mMbNbU+7xHFgGngfD8b2yDDwP8uM5IKnxMyU/ngPLwPNgOL5X8uM5sAw8D4bje2UZeB7kZ6/ngDXciYiIiIiIiIiIiIgkwIQ7EREREREREREREZEEmHAnIiIiIiIiIiIiIpIAa7gTEREREREREREREUmAI9yJiIiIiIiIiIiIiCTAhDsRERERERERERERkQSYcCciIiIiIiIiIiIikgAT7kREREREREREREREEmDCnYiIiIiIiIiIiIhIAky4ExERERERERERERFJgAl3IiIiIiIiIiIiIiIJMOFORERERERERERERCQBJtyJiIiIiIiIiIiIiCTAhDsRERERERERERERkQSYcCciIiIiIiIiIiIikgAT7kREREREREREREREEmDCnYiIiIiIiIiIiIhIAky4ExERERERERERERFJgAl3C5OWloYhQ4YgICAA3t7e6NWrFxITE+UOy66pVCo0a9YM8+fPlzsUu/LixQt89dVXCAwMRN68efH555/jyZMncodlsdh3WBb2G/Jh30FSYt9qedi/yoN9q+HYb1ge9hvyYd9hOPYdloX9hnxspd9gwt3CjB07Frt27cKOHTuwd+9eHDt2DIMHD5Y7LLuVlpaGXr164cCBA3KHYnfat2+PBw8eYO/evTh69CjevHmDTz/9FGlpaXKHZpHYd1gO9hvyYt9BUmLfalnYv8qHfavh2G9YFvYb8mLfYTj2HZaD/Ya8bKbfUJHFSEpKUnl4eKi2bduW1Xb06FGVo6OjKjo6WsbI7NPNmzdVNWvWVBUvXlzl4+Ojmjdvntwh2Y3bt2+rAKhu376d1fb48WMVANXly5dljMwyse+wHOw35MW+g6TEvtWysH+VD/tWw7HfsCzsN+TFvsNw7DssB/sNedlSv8ER7hbkjz/+QEJCAho2bJjVVq9ePahUKly4cEHGyOzTyZMnUadOHVy7dg3e3t5yh2NXAgMDsWfPHpQuXVq0LikpSYaILBv7DsvBfkNe7DtISuxbLQv7V/mwbzUc+w3Lwn5DXuw7DMe+w3Kw35CXLfUbjnIHQP/nyZMncHFxQd68ebPanJyc4O/vj8ePH8sYmX3q3bu33CHYLR8fH7Rs2VLQNmfOHHh6eqJq1aryBGXB2HdYDvYb8mLfQVJi32pZ2L/Kh32r4dhvWBb2G/Ji32E49h2Wg/2GvGyp32DC3YIkJibCxcVF1O7i4oLk5GQZIiKyDOvXr8f8+fOxYMECeHp6yh2OxWHfQaQZ+w7KDfatRJqxb9WO/QaRduw7tGPfQaSZNfcbLCljQdzc3DR2psnJyXB3d5chIiL5/fjjj+jWrRuGDBmC/v37yx2ORWLfQSTGvoNyi30rkRj7Vt3YbxBpxr5DN/YdRGLW3m8w4W5BChcujOTkZMTGxma1paamIjo6GoUKFZIxMiJ5hIeHo0+fPhg9ejRmz54tdzgWi30HkRD7DpIC+1YiIfat+rHfIBJj36Ef+w4iIVvoN5hwtyAffPABPDw8cOLEiay206dPQ6lUombNmjJGRmR+c+fOxYQJEzBr1ixMnjxZ7nAsGvsOov/DvoOkwr6V6P+wbzUM+w0iIfYdhmHfQfR/bKXfYA13C+Lm5obvvvsOAwYMgLe3N1xcXNCrVy90794dfn5+codHZDZ37tzByJEj8d133+HLL7/E8+fPs9b5+vpqrG9nz9h3EL3HvoOkxL6V6D32rYZjv0H0f9h3GI59B9F7ttRvcIS7RDp27IjChQtrXb969WpUr14dnp6eCAgIwJdffokHDx6ItpsxYwZat26N0NBQtGrVCo0aNcKCBQtMGbrNkepcUM5I8f5v27YNqampWLFiBQoUKCD4b9++fab+EcyKfYdlYL8hP/YdJCX2rZaD/au82Lcajv2G5WC/IT/2HYZj32EZ2G/Ij/2GGhXl2tSpU1UAVIUKFdK4fsSIESoAqgoVKqjCwsJUHTt2VDk4OKjy5s2rioyMNHO0to3nQl58/43D98sy8DzIj+eApMTPk+XguZAX33/D8b2yHDwX8uM5MBzfK8vA8yA/ngMxJtxzISkpSdWrVy8VAK0frGvXrqkAqOrVq6dKTk7Oat+5c6cKgOrTTz81Z8g2i+dCXnz/jcP3yzLwPMiP54CkxM+T5eC5kBfff8PxvbIcPBfy4zkwHN8ry8DzID+eA+2YcM+hiIgIVfHixVUAVC1atND6werZs6cKgOrQoUOidY0aNVIpFArV48ePzRGyzeK5kBfff+Pw/bIMPA/y4zkgKfHzZDl4LuTF999wfK8sB8+F/HgODMf3yjLwPMiP50A31nDPoZUrV+Lt27dYunQp9uzZo3W7U6dOwdHREQ0aNBCta9KkCVQqFY4dO2bKUG0ez4W8+P4bh++XZeB5kB/PAUmJnyfLwXMhL77/huN7ZTl4LuTHc2A4vleWgedBfjwHujnKHYC1GjRoENavX488efJo3SY9PR137txB8eLF4ezsLFpfsmRJAMDt27dNFqc94LmQF99/4/D9sgw8D/LjOSAp8fNkOXgu5MX333B8rywHz4X8eA4Mx/fKMvA8yI/nQDcm3HOoUaNGereJi4uDSqWCn5+fxvU+Pj4AgNevX0sXmB3iuZAX33/j8P2yDDwP8uM5ICnx82Q5eC7kxfffcHyvLAfPhfx4DgzH98oy8DzIj+dAN5aUMaH4+HgAgIuLi8b1me3v3r0zW0z2iudCXnz/jcP3yzLwPMiP54CkxM+T5eC5kBfff8PxvbIcPBfy4zkwHN8ry8DzID97PgdMuJuQq6srACAlJUXj+uTkZACAp6en2WKyVzwX8uL7bxy+X5aB50F+PAckJX6eLAfPhbz4/huO75Xl4LmQH8+B4fheWQaeB/nZ8zlgwt2EvL29oVQqtT4akdnu7e1tvqDsFM+FvPj+G4fvl2XgeZAfzwFJiZ8ny8FzIS++/4bje2U5eC7kx3NgOL5XloHnQX72fA6YcDchZ2dnlCxZEg8fPkRqaqpo/b179wAAFSpUMHdodofnQl58/43D98sy8DzIj+eApMTPk+XguZAX33/D8b2yHDwX8uM5MBzfK8vA8yA/ez4HTLibWMOGDZGSkoIzZ86I1h0+fBgKhQJ169aVITL7w3MhL77/xuH7ZRl4HuTHc0BS4ufJcvBcyIvvv+H4XlkOngv58RwYju+VZeB5kJ/dngMVSQKAqlChQqL2s2fPqgCo6tSpo0pMTMxq37lzpwqAqk2bNmaM0j7wXMiL779x+H5ZBp4H+fEckJT4ebIcPBfy4vtvOL5XloPnQn48B4bje2UZeB7kx3MgxIS7RLR9sFQqlapv374qAKrSpUurhg8frurUqZPKwcFBFRgYqLp3756ZI7V9PBfy4vtvHL5floHnQX48ByQlfp4sB8+FvPj+G47vleXguZAfz4Hh+F5ZBp4H+fEcCDHhLhFdH6yMjAzVokWLVJUqVVK5uLioChYsqOrSpYvNfqjkxnMhL77/xuH7ZRl4HuTHc0BS4ufJcvBcyIvvv+H4XlkOngv58RwYju+VZeB5kB/PgZBCpVKpDC0/Q0REREREREREREREmnHSVCIiIiIiIiIiIiIiCTjKHYA9yMjIQHR0tKDN398fSiXvdxCRZuw3iIhMg/0rERmL/QYRGYv9BpF9Y8LdDKKjoxEQECBoi4qKQr58+WSKiIgsHfsNIiLTYP9KRMZiv0FExmK/QWTfeGuNiIiIiIiIiIiIiEgCTLgTEVmYhIQEJCQkyB0GEREREREREREZiSVlTIyJMyIylqenp9whEBERERERERFRDjDhbmJMnBERERERERERERHZB5aUISKyMPHx8bh//77cYRARERHZPT6xTERERMbiCHcTi4+Px8uXL1GiRAm5QyEiK+Hh4YHExES5wyAiIiKye3ximYiIiIzFhLuJMXFGREREREREREREZB9YUoaIiIiIiIhIA5b6IyIiImNxhDsRERERERGRBnximYiIiIzFEe5ERERERERERERERBLgCHciMohKpcLRo0dx7tw5BAcHo2nTpnKHRGoyMjLw+vVrREVFCf578eIFkpOT4evrC19fX/j7+2f938/PD35+fnB3d4dCoZD7RyAiIjuTmJiIrVu34uXLl2jfvj2KFy8ud0hERERERLnChDsRGeTChQsYMWIEAGDXrl1wdXVFgwYNZI7KvkRFReHZs2d4+fIlXrx4IUqsR0VFIS0tLUf7dnZ2zkq+ZybiixUrhqCgIAQFBSF//vxQKvlQFBFZt4SEBCQkJMgdBmUze/ZsREREAACOHz+OHTt2wNnZWeaoiIiIiIhyjgl3IjLI6NGjBcu//PILE+5m1rlzZzg5OZlk3ykpKXj+/DmeP3+ucb2LiwtKlCiBoKAglChRIuvfhQoVgoODQ46OmZ6ejn/++QeXL1/GlStX8O+//yJPnjz44IMPUL16dVSrVg2BgYG5+bGIiAQ8PT3lDoGyiYuLy0q2A8Dz589x6dIl1K1bV8aoiIR4o46IiIiMxYQ7ERkkLi5OsHzp0iWZIiE5JCcn4/bt27h9+7agXalUIm/evMifP7/gv8DAQOTLlw9paWmIj49HfHx81gXr27dvcfv2bVy7dk00CVlUVBTu3buHHTt2AAAKFCiAhg0bomfPnvDx8THXj0tERGZw4cIFUdvt27eZcCeLwht1REREZCwm3IkoR7y9veUOgbTITIIHBAQgICAAgYGBcHNzQ2xsLKKjowX/T0pKytWxMjIyssrZXL9+XaKf4P88e/YMmzdvxuHDhzFp0iTUqlVL8mMQkf2Ij4/Hy5cvUaJECblDIQBnzpwRtT158kSGSIiIiIiIpMOEOxHliIuLi9wh2CVnZ+esRLr6f5mjyv39/Q0u85KUlISYmBjRf8+ePcP9+/dx//590dMNcnj16hX69u2Lzp07o1+/fhrr+yYlJeHJkydwd3dHgQIFOAksEYl4eHiInqwheWRkZODs2bOi9vv378sQDZF2vFFHRERExmLCnYhyhMlM89u+fTtKliwp6Xvv5uaGQoUKoVChQhrXq1QqxMbGIjIyEpGRkbh//37W/2NiYiSJoXjx4vjwww9RtWpVvHz5En/88Qf++OMPjYn+TZs24cKFC6hYsSLS0tKQlpaG169f47///kNUVFTWdoGBgQgODkbNmjVRqlQpFC5cGO7u7pLES0REuffPP/9o/DsSGRkJlUrF7xlkMXijjoiIiIzFhDsR5UhOJ8qknPP29jZ7AkKhUMDPzw9+fn6oUaOGYF1cXByePXuWNdnqixcvsv79/PlzvHr1Cq6urvD09ISHhwc8PDyy/u3v74+qVaviww8/hL+/v2C/Xbt2RUZGBu7du4dFixaJRkDeu3cP9+7d0xn3ixcvsHv3buzevTurLW/evKhduzZCQ0NRuXJlJnOI7BAnP7QcmsrJAO/P0cuXLxEQEGDmiIiIiIiIpMGEOxHplZ6eLmpTKpUyREKWxMvLC15eXihbtqzk+1YqlShdujQWLFiAX3/9FQsWLEBKSkqu9vnq1Svs2bMHe/bsQalSpRASEoIyZcqgcuXKWkf4E5Ft4eSHlkNbwh14X1aGCXciIiIislZMuBORXpoSnUy4kzkoFAp88cUXqFGjBsaMGYO7d+9Kst+7d+8K9vXpp59i1KhRWbXhVSoVLl68iJs3b6JYsWKoWrWqYCR+WloaHBwcDBol/+rVKzx58gQVKlSAk5OTJPETEVmzjIwM3Lx5U+v6yMhITpJNRERERFaLCXci0is1NVXUxoQ7mVPJkiWxbt06HD16FDdu3ICDgwMcHR3h6OgINzc3FClSBMWKFUPhwoXx7NkzXLx4ERcvXsQ///yDFy9e6N3/7t278fTpU8yZMwfu7u6YM2cOtmzZItimWrVq+Oabb7B582acPn0ajo6OCAgIQPPmzdGjRw/RRMIqlQq//PILFi1ahNTUVJQqVQqLFi1Cvnz5NMaQkZHB3ysiE+Pkh5bhzZs3yMjI0LqeE6cSERERkTVjwp2I9OIId7IEzs7OaNasGZo1a6Zzu6CgIAQFBaFjx44AgOTkZDx+/BinT5/Gjh078OTJE42vu3LlCjp16gQfHx/8/fffovXXrl1Dv379spbT0tLw9OlTrFy5EpcuXcKMGTPw9OlTnD59Gs7Ozjh79iz++uuvrO3v3r2L5s2bo0mTJqhduzYCAgKQnJyMu3fv4tChQ3jw4AHq1q2LcePGwc/PLydvERHpwckPLUNsbKzO9frm6SAiIiIismRMuBORXky4kzVzcXFByZIlUbJkSXz11Ve4fPkyLl++jDt37uDy5ct49+5d1rbPnj3Ds2fPjD7G9evX0aJFC4O2PXLkCI4cOaJx3alTp9CzZ08sXrwYBQsWFK3nKHgisgWvX7/Wuf7+/ftQqVSc3JqIiIiIrBIT7kSkFxPuZCuUSiWCg4MRHBwMAPjnn3/Qv39/xMTEyBzZ/3n48CG6d++Ob775BhUrVoSvry9OnTqFHTt2IDIyEr6+vpg0aRLq1Kkjd6hEVichIQEJCQlyh2H31Ee4Ozg4CCZoj4uLQ0xMjGDuDCIiIiIia8GMGRHppSnhrlKpZIiESFply5bF6tWrUbp0adE6Ly8vrFixAmfPnkXXrl0FIy1r1qyJsLAw5M2b1yRxRUdHY+bMmfj666/RunVrzJo1C/fu3YNKpUJMTAzCwsLw+PFj3L17F3v37sWLFy/w8uXLrNH6GRkZuH//PuLj400SH5G18vT0ZP12C6CecK9QoULWpNWZHj58aM6QiIiIiIgkwxHuRKSXpoR7WlqaDJEQSa9QoULYuHEjrl27hsjISDx69AhOTk5o3749ChQoAAAYMGAAWrRogdOnT6N8+fIIDg6GQqFA48aNMXfuXBw9elT0O6FUKtGkSRMMHToUbm5uOH/+PKKionDp0iX8888/UCgUcHJygo+PD/Lnz49Dhw4ZHHNSUhI+++wzUbujoyOGDBmCPXv24NatW/D29sYPP/yAGjVq5Oo9IiKSknrC3c/PD/nz5xck2aOioswdFhERERGRJJhwJyK9mHAnW6dUKvHhhx/iww8/1LpNqVKlUKpUKUFb3rx5MW3aNLx9+xaXLl0CANSrVw9OTk5ITU0VjNhs0qQJAKBTp04a9z9q1CgMGzYMV69ezfHPkZaWhpkzZ2Ytv3nzBsOGDcPatWtRrFixHO+XyFbEx8fj5cuXHOUuM/WEu6+vL5KSkgQJ9xcvXpg7LCIiIiIiSbCkDBHplZqaKmrLXmuVyN7lyZMHjRs3RuPGjeHs7AyFQiEqj6CPl5cXli1bhpkzZ6JBgwYoUqRI1jpPT09UqVIlR7HFx8ejf//+ePr0aY5eT2RLPDw84OHhIXcYdk9Twj0gIEDQxoQ7EREREVkrjnAnIr04wp3IPJRKZVbiHgBev36N1NRU5M2bFwqFAtu3b8f06dON3u/Tp0/RunVrdOzYEbVr10a9evWkDp2IyGCaEu7qk7Ez4U6WgpMtExERkbE4wp2I9GLCnUgePj4+yJcvX9aErW3atMlVsnzz5s0YNGgQTp8+jdjYWKxbtw7z58/H9evXpQqZiEgv9YS7j48PAgMDBW2s4U6WgpMtExERkbE4wp2I9GLCncgyODo6Yt68eXjw4AHy5csHDw8PJCQkICYmBomJiejSpYtB+xk0aJBgedOmTVi/fj2KFi0KNzc3E0RORPR/NI1wz8jIELQ9f/7cnCEREREREUmGCXci0ktTDXcm3InkoVAoULx48azl7DWpDxw4gDlz5uDVq1f46quvcPfuXSxZskTvPjMyMgTJ+oEDB6JDhw5wcXGRPH4iObE0hPwyMjLw+vVrQZuvry8cHYWXJTExMUhJSTF6PgwiIiIiIl0SEhKgUCjg7u5usmMw4U5EeiUnJ4vamHAnsjz+/v6YNm1a1nLNmjWxc+dOoydMXbBgARYsWICAgAA4OjrC19cXffv2Rc2aNbPK2xBZI09PT7lDsHvx8fGi0ey+vr4an6559eoVChYsaK7QiIiIiMjGbd++HbNmzQIAhIWFITQ01CTHYQ13ItKLI9yJrJOrqysWLlyIypUr5+j1UVFRePr0KW7evIk+ffrg119/lThCIrI36uVkgPcJ9zx58oiS7iwrQ5bgxYsXuHnzptxhEBERUS6lpKRgxowZSEtLQ1paGmbPnq0x3yUFJtyJSC9NNdwzMjKgUqlkiIaIjFG8eHGsXr0aZ8+eRenSpXO1r59//pk328iqxcfH4/79+3KHYdfUE+7u7u5wdnaGQqEQTZz64sULc4ZGpFFgYCAqVqwoak9MTJQhGiKyZm/fvpU7BCK79t9//wnyWCkpKUY/DW4oJtyJSC9NCXcASE9PN3MkRJRTzs7OWLBgAfz8/HK8j9jYWPzxxx/SBUVkZtnnPCB5qCfcfXx8sv4dEBAgWBcVFWWOkIhyZM6cORx8QkRGGT9+vNZrayIyPU2Dx9TnEZIKE+5EpJe2LwUc6UpkXQICAnDw4EEsXLgQFSpUyGqvUKECGjRogO+++07vPnr37o2dO3fizZs3gva3b99i2bJlCAkJwWeffYZDhw5JHj8RWT/1hLuvr2/Wv/Pnzy9YxxHuZAm0lZQ5ceIE1q9fL0NERGStbty4gXHjxonmMiEi89CUw1q+fDkSEhIkPxYnTSUivWJiYjS2M+FOZJ1CQkIQEhIClUolmgS1Z8+euHTpEsLDw7Umu6ZOnYrVq1ejX79++OOPP1CsWDEsX74ccXFxAIDHjx9j8uTJqF27NvLkyWPyn4eIrMfr168Fy9kT7iwpQ5ZI/XOZ3eLFi1GuXDkEBwebMSIismZHjhzBvHnzMGTIENH3cCIyLU05rL179yI+Ph5z586V9FhMuBORXk+ePNHYzpIyRNZN05d8pVKJWrVqYffu3Xjz5g2OHz+OqVOnirZ7+vQpRo8erXXfiYmJuHPnDj788ENJYyYi66ZrhLt6SRkm3MnSZWRkYNSoUdiwYQMKFCggdzhEZCV++eUXBAYG4ssvv5Q7FCK7om3Q6MmTJ5GRkQGlUrpCMCwpY2IJCQkmeTSByJy0Jdw5wp3IdimVSvj6+qJJkyY5HqV+7NgxxMXF8bFZshj8XiY/XQl3c49wj4iIQFhYGH777TfW4iattJWUyfTmzRsMHz4cycnJZoyKiKzd/PnzcfDgQbnDILIrunJYUk+GzoS7iXl6eqJEiRJyh0GUY6mpqVoveJlwJ7J9Xl5emDZtWo5eu3nzZjRu3BjBwcEYPnw4J4ki2fF7mfx0TZqqnnCPjY01Wb9x9OhRhIeH4+jRo5g8eTJOnTplkuOQ9QsMDETFihV1bnP79m1Mnz6dN26IyCgTJkzA5cuX5Q6DiKB97sKcYsKdiHR69uyZ1osHlpQhsg916tTB8ePHUb169Rzv49ixY2jcuDFSU1MljIyIrI0xI9wBICoqyiRxjBw5UrB8+PBhkxyHbFfhwoUFy3v27MG2bdtkioaIrEHPnj0Fy6mpqRg6dCju3r0rU0RElEnqp7KZcDex+Ph43L9/X+4wiHIscxJETeLj480YCRHJydPTEytWrMhVrcl3796hTp06CA8P56P3JAt+L5OfrklTPT094e7uLlhvirIyT58+FV1U7d27V/LjkG3Q1m9MmjRJ9HmdPXs2/vzzT3OFRkRW5osvvkCHDh0EbQkJCRgwYADnLSGSGRPuVsbDwwMeHh5yh0GUY7qSYp07d9aZkCci29OqVSuNk60aIyIiAvXr15coIiLD8XuZvFQqlc4R7oB56rgfOXJE1MYJL0kbbf1GsWLFMHHiREFbeno6wsLC8PLlSzNFR0TWRKFQYNiwYfjoo48E7VFRUejfvz/evn0rU2RE9kFXUl3qsnBMuBORTvpGoR47dsxMkRCRJShVqhR+/PFHfP7555gyZQouX76Mixcv4vTp0xg7dqzB+8nIyMA///xjwkiJyNIkJiaKykrJkXDXNFo5JiaG9bdJI12TLTdu3BjdunUTtEVHR2PEiBEsoUZEGimVSkyZMgVVqlQRtEdGRmLo0KGc84jIhHR91+MIdyIyK30J9xUrVpgpEiKyFDVq1MCIESPQrFkzAO8vHFxdXREcHAyl0vCvFkePHjVViERkgdRHtwPCSVMBccLdFDXcNY0+Tk5O5lN7pJG+yZb79OmD2rVrC9quX7+OuXPnmjo0IrJSLi4umDdvHooVKyZov3r1KiZOnCh54o+I3tOVcOcIdyIyK30Jd29vbzNFQkSWrmDBgvj+++8N3v7QoUO8oCCyI+oJdxcXF7i5uQnazDHCXVu5D9bPpZxQKpWYOnUqChYsKGjfunUrdu/eLVNURGTpvL29sWjRIvj7+wvaDx48iIULF8oUFZFt4wh3IrIYb9680blefWQaEdm37t2748KFC1iyZAkmTJiAVatWiZIQmR4+fIh+/fqxjAORndBUv119Tgj1hPvz588lj4MJdzKGIZMte3t7Y9asWXB2dha0T58+HX///bcpwyMiK1awYEEsXLhQNAHzhg0bsGnTJpmiIrJdupLqTLgTkdmoVCrMmjVL5zZMuBOROgcHB9SqVQuffvopqlSpgoiICFy+fBk//PCDaNuLFy/i1q1bMkRJROb2+vVrwbJ6/XbA9CVlUlJStA4mMEX5GrJ+hk62XLZsWdFcJikpKRg+fLjGckpERMD7vmPmzJlwcHAQtM+bNw+HDx+WKSoi28QR7kRkEQwZkaN+N56ISJuSJUtqbN+wYYOZIyEiOWga4a4uICBAsPz69Wu95e2M8erVK63r9I1iJvuka9JUdS1atEDHjh0Fbc+fP8fo0aORnp5uivCIyAbUrl0b48ePF7SpVCqMGzcOV69elSkqIvvChDsRmc3du3f1bpOammqGSOyLMRd2RNakaNGiGtsPHTqEa9euYd26dTh58iTrupPJsH+Vl3rCXdNTcvnz5xe1STnyXFfCPSIighOnkoi+SVPVDRo0CNWqVRO0Xbp0CUuWLJE6NCKyIS1btkSfPn0EbampqRg6dCgiIyNliorItui6zuSkqURkNi4uLnq3YcJdesZe2BFZC6VSiQULFmhc9+2332LhwoUYMmQIgoOD0bRpU6xfvx6rVq3CX3/9ZeZIyVaxf5WXISPc3d3dReU7pKytrivhnpiYiD179kh2LLJPjo6OmDFjBvLlyydoX7duHQ4dOiRTVERkDbp374527doJ2t6+fYv+/fuz7BmRBFhShogsgiGjAKV8zJuIbF/dunVRq1YtvdvFxMRgwYIFWLp0Kbp164b69etj1qxZOH78uOmDJCKTMCThDojruEuZcNc2YWomPrpP6gyZNFWdv78/Zs6cCUdHR0F7eHg47t27J2V4RGRDFAoFRowYgQYNGgjaX7x4gYEDByI+Pl6myIhsg66EO0e4E5HZGPJYNUe4Sy8nF3ZE1sTf39/o1yQlJWHLli0YNmwYTp48aYKoyB6wf5WXIZOmAuKyMuZMuN+4cUPyCy6yboZOmqqucuXKCAsLE7QlJSVh2LBhePv2rVThEZGNUSqVmDZtGipXrixo//fffzF8+HCkpaXJFBmR9eMIdyKyCOoXA3ny5BFtwxHu0svphR2RtShWrFiuXr99+3aJIiF7w/5VXoaOcFefOFXKhLv6I/n16tUTLEdHR+PZs2eSHY/sW9u2bdGmTRtB26NHjzB+/HjOV0JEWrm6umLevHmi+Y8uXbqEVatWyRQVkfVjwp2ILEJSUpJg+ZNPPsHAgQMFbRzhTkTGat26NZTKnH8FOXPmDEegElmhmJgYwbKmSVMB05aUef78uWC5Ro0aojj++OMPyY5H9i2zPESFChUE7adOncLPP/8sU1REZA18fHywaNEi+Pn5CdpXrlyJv//+W6aoiKwbJ00lIovw7t07wbKrqyu8vb0FbXykjYiMlS9fPsybN0/r6FZDZI6UffPmDU6ePImnT59KFR4RmUBSUpLoqThDa7irJ8lzQ31fBQoUQJUqVQRte/fulex4RM7Ozpg1a5bo875ixQqcOnVKpqiIyBoUKlQIc+fOFQxUSU9Px4QJE5CSkiJjZES2Jz09XdL9MeFORFqpj3B3dXUVTf7EhLv0EhISDJqwlsia1a1bFwcOHMhxeZmmTZvi5cuX+PzzzzFkyBC0bt0aN27ckDhKIpKKejkZQHvCvUCBAoLle/fuSVLmJSMjQ1RSJjAwEE2aNBG0XbhwgTfxKIsU38sCAwMxY8YM0dNd48aNw8OHD3O1byKybZUqVcI333wjaIuMjMTSpUtliojIenGEOxFZhEOHDgmWmXA3D09PT5QoUULuMIhMTqlUYvHixQgNDUXTpk3Rs2dPo14/fPhwQYmK7t27Sx0iEUlEfcJUR0dHrfX0q1SpAk9Pz6xllUqF3bt35zqGmJgY0feW/Pnzo0mTJqLjnTt3LtfHI9sg1feyDz/8EIMGDRK0xcfHY9iwYUhMTMz1/onIdn3zzTcoV66coG3jxo24evWqTBERWSfWcCci2Wka2eXm5saEOxFJqkCBAhg9ejSmTZuG3r17Y9asWQa/9q+//hK1qY9eJSLLoGnCVIVCoXFbFxcXNGvWTNAWERGR6wsh9XIyjo6O8PPzg6urq2jy1Js3bxq83+TkZPz4448YOHAg5s+fr3E0PxEAdOrUCU2bNhW0RUZGIjw8nHOTEJFWjo6OCA8Ph7Ozc1abSqXCxIkTecOOyAi6/tZyhDsRmcXp06dFbY6Ojky4m0F8fDzu378vdxhEsihatKjG9jJlyhj0+uPHj0sYDRFJRVPCXZfPPvtMsPz8+XNcuHAhVzGoT74aEBCQVeJDfVLLW7duGbzf5cuXY+XKlThz5gw2bNiA0aNH5ypOsixSfi9TKBQYN24cSpcuLWg/fPgw1q9fL8kxiMg2BQUF4fvvvxe0PX36FPPnz5cnICIrxBHuRCQ7V1dXUVtCQoIo4S71xBIEeHh4aH3MnsjW5cmTR9RWq1YtbNq0yaDXz5w5EzVq1MCrV6+kDo2IckE94e7j46Nz+3LlyqFs2bKCtl27duUqBvUR7vnz58/6d8WKFQXrIiMjRXPZaKJSqRARESFou3TpkmjiebJeUn8vc3Nzw6xZs0R/7xYvXoyLFy9Kdhwisj1dunRBtWrVBG07duzA2bNnZYqIyLow4U5Essv+uFqm+Ph4jnAnIpPy9vYWtTVo0MDo/Wzbtk2KcIhIIsaOcAeANm3aCJZPnDiRq3It6iPcsyfcy5YtK5jQMiMjA//++6/efT58+FBUnx4A2rZti0ePHuU4VrJthQsXxtSpUwVllTIyMjBq1ChJJggmItukVCoxceJEuLm5CdonT56MuLg4maIish6cNJWIZKdpVNcnn3zChDsRmZSLi4uorXz58gDEI1B1+fnnn5GYmCj5SAWybgkJCUhISJA7DLuknpQ2JOHerFkzwQCAtLQ07N27N8cxqD/5EhAQkPVvV1dXUUmrhw8f6t3njz/+qLH95cuXWLhwYQ6iJHsREhKC3r17C9revHmD4cOHIzk5WaaoiMjSFSpUCIMHDxa0vXz5EjNnzpQpIiLbwIQ7EZmFpoR7mTJl4ODgIGhjwp2IpNalS5esf1eqVAmVK1cGAPTt29eo/TRo0ADdu3dHTEyMpPGR9fL09ESJEiXkDsMu5WSEu5eXF5o0aSJo27VrV44viN68eSNYVi9rU7hwYcHykydPdO7v4sWLOHz4sNb1Z86c4USYpFP37t3RsGFDQdvt27cxffp0fnaISKu2bdsiJCRE0LZ//34cOXJEpoiIrANHuBOR7NQT7g0aNIBCoeAIdzPgCEyyd4MGDcKsWbMwfvx4LF++POuR+5o1a4pKTOhz8+ZN7N692xRhEpERcpJwB8STp96/fx937tzJUQzqj9t7eXkJltUT7o8fP9a5v507d+pcn5KSorM8iEqlwqpVqxAaGopRo0axHIAdUiqVmDRpkujpij179rA0GhFppVAoMHbsWNFcENOmTUN0dLRMURFZPl1JdSbcicgs1BPu7u7uAMBJU82AIzDJ3ikUCnz00Udo3bq1oMSMQqHAuHHjspLubm5uaN++vd79LVq0yGSxknWJj4/H/fv35Q7DLhk7aWqm6tWrC2qtAzCotrom6iPc1eeMMDbh/uDBA73HvHv3rtZ1165dw9KlS/Hw4UMcOnQIa9eu1bs/sj2enp6YPXt21nftTLNnz8aff/4pU1REZOkCAgIwYsQIQdubN28wdepUPiFDpIU5fzeYcCcijdQT7pkTs2ga4c4/6ERkTuPGjcPhw4dx4sQJhIWFoVy5cnpfw5uDBAAeHh7w8PCQOwy7lNMR7gqFAqVLlxa0GVJbXRP1hHtuR7g/f/5c7zF1xTpjxgzBMhPu9isoKAgTJ04UtKWnpyMsLEw09wARUab//e9/otJrJ0+e5NOdRFpwhDsRyS41NVWwnDlpmXrCHQCuX79ulpjsBUdgEunn4+MDpVIJpVKJlStXYvz48Tq3r1WrFlasWGGm6Igou5SUFCQmJgraDE24A0CRIkUEy/oS4ZqkpaWJyrWpj3AvVKiQYDk2NlZribekpCSDSsBom0MiOTkZkZGRel9P9qNx48bo1q2boC06OhphYWGi7+VERMD7m9KjRo2Cn5+foH327Nk6S5oR2Ssm3IlIduq12TMT7eqTpgLAvHnzzBKTveAITCLjuLi4oHXr1qLJo9StWLECf/31l5miIqJMr1+/FrXlJuGekxHub9++FbVpSrgrlcLLo8uXL2vcn6ZExubNm0V/v9UT7hkZGVi+fDnq1q2rN+aMjAzs378fu3btwrt37/RuT9avT58+qFWrlqDt+vXrmDt3rkwREZGl8/HxwdixYwVtiYmJmDRpks4JIonsESdNJSLZaUu4axrhzgQWEVmCadOm6d0mPDwc169f5wUIkRmpl5NRKpWiid50UZ9Q8uHDh0ZfFGkaja4eg7OzM6pVqyZoO378uMb9ff/994JlLy8vlCpVSjRCWT3hvnPnTvz0008GxTxlyhSMHTsWU6ZMQf/+/VnCzw4olUpMmzYNBQsWFLRv3boVERERMkVFRJauQYMGaN26taDt8uXL+PXXX2WKiMj6MOFORGahLeGeWVqGiMjSeHp6YtOmTTq3iYyMRI8ePfDNN9+wrjuRmWiaMFV9JLku6iPcExMTRfvUR71+u5ubm8bvNI0aNRIsnz59WnQB9vbtW0RHRwvaAgMDAQD+/v6CdvWE+4kTJ7TGmD2e9PR07NmzJ2v52rVruHHjhtbXku3w9vbGrFmzRJ/PyZMnY9myZfzbRUQaDRkyRDTJ+MKFCxEREcGBJkT/nzl/F5hwJyKNtCXcMydPJSKyRGXKlMGqVav0bnfjxg0cOnTIDBERkaaEuzHy588PJycnQdujR4+M2oe+CVMzqZd6iY2NFZXE0VTSpmbNmgAgqqOrnnC/c+eO1hgVCoUgXvWLwlmzZml9LdmWsmXLikpEqFQq/Pzzz+jduzeioqJkioyILJWnpycmTJggaEtJSUF4eDi6d++OmzdvyhQZkeVgDXcikp22hLurq6sc4RARGaxKlSoGbbd69WoTR0JEgDjhbkz9duB9mQ31CU2NTbirl5RRr9+eqXDhwqLkvnqCXdOx+/XrB0Bzwj174tzd3V1rjMnJyVnbaiqB8/fff2stcUOmk5CQoHXyXFNq0aIFOnfuLGq/du0aOnXqhFOnTpk9JiKybDVr1sQXX3whar958ya+/vprhIeHa53Mm8geMOFORLLTlnDPPvqKiMhShYeH693mv//+M30gRIQXL14IlvPmzWv0PjTVcTeG+gh3bQl3pVIpKmHz4MEDnccOCQnJKv8REBAgWJeWlobnz59nLetL3CYnJ2uMN9ORI0cAvL8oPHz4MJYuXapz1DzlnqenJ0qUKCHLsQcNGoSBAwfCwcFB0P7mzRsMHjwYc+fORWpqqiyxEZFlGjhwIP73v/9pXBcREYG2bdti06ZNout9InvAhDsRyU5bwp1MT66RVES2pEWLFti/fz+6d++udZv09HRcu3bNjFER2adnz54JltUnhDRE4cKFBcuPHz826vWGlpQBxDXj1RPs6sfOHpu/v79o39kT4vHx8TrjTEpK0hhvpn379gF4nzQZOXIkVq1ahc6dO2P58uU690vWSalU4quvvsLKlSs1/t5s2rQJ33zzjdG/D0Rku5ydnTF16lQsXLhQdLMaeH+tOXfuXHTu3BkXL16UIUIi+TDhTkSyY8JdPnKOpCKyJXnz5sX333+vc5tvv/3WTNEQ2a+nT58KlgsUKGD0PnI7wt3QkjIAUKxYMZ3HUr+BkD3hrlAoUKZMGcH6zIR7ampq1gh2bd69e6cxXnWTJ08WLP/000+4f/++ztdQzrx48UL22seVKlXCxo0b0bhxY9G6W7duoUuXLjh48KAMkRGRpQoJCcGWLVswcOBAjeXMIiMj0adPH4SFhRk9ETmRtZI6qa4LE+5EpBET7kRkC5RK/V91tI0kJSJpqCeoc5JwVx91rp7E18eYEe7qyX310cPqyXD1mvQlS5bU+Hp9o9sBYNmyZcjIyNDZL6lPppnJkAmjyXiBgYGoWLGi3GEgT548+OGHHzBy5MisEkaZEhISMHr0aEybNo0lZogoi5OTE7766ivs2LEDLVq00LjN0aNH0bdvX/YdZBc4wp2IZKcr4d60aVPBusDAQLPEZC/i4+M5So1IQgMGDNC5vkmTJggNDcWaNWvMExCRHUlMTBQlj3NSUkb9u0ZcXFxW+RVDREdHC5Z9fHy0bqteY149fvXEuaenp2A5f/78guWXL18CEE8eC4gno9+7dy8mTpwoije7/fv3a2w3diJZsj4KhQLt27fHmjVrNJaK2LFjB2bNmiVDZERkyfLmzYvw8HCsWrUK5cqVE62/c+cO1q9fL0NkRJaDCXciMgv1O9zZE+7NmzcXrFOfyIlyx8PDAx4eHnKHQWQzvvrqK73bPHz4EIsXL8b169fNEBGR/cg+YWgm9YS0ITTd3I+KijL49caUtcmTJ49g+e3bt4Jl9YS7+vbqE6c+f/4cERER6NChg6Ddyckpq4RMdnv37sW6deu0xqfNX3/9hYcPH+Lrr79Go0aNsGTJEsTFxSElJcXofZFlK1OmDDZs2ICWLVuK1u3YsQPHjx83f1BEZPGqVKmCdevWYfTo0aLSaj///DNv3JLN4wh3IpLdv//+K1jOnnBXLy/DGc6JyJIpFAqcP39elOzSZMaMGWaIiMh+qCe6/fz84OLiYvR+3NzcRGVgXrx4YdBr09LSRNvqGmWvnkBPTExERkYGACAjI0M0sbn6CPd8+fIJlh89eoTw8HDRcWrWrInq1avr/wGMEBoaips3byI+Ph6rV69G48aNUb9+fdy+fVvS45D83N3dMWnSJEyaNEn0OzV58uSsJyuIiLJTKpUIDQ3F4sWLBaUXU1JSMH36dLPWuCYyNybciUhWiYmJojZdCXfWeyMiS+fo6IiwsDBcvnxZ53Z37tzB9u3bzRQVke1TT7jnpJxMJk0jxw3x/PnzrIR5pkKFCmndXj2BDvzfqHb1ZLum7dXj1KZ79+747LPPDNo2N9LT07Pqu1+8eBEHDhzgBHlGsIRJU3Vp2bIlRowYIWh78+YNJk2aJPrcExFlKl++PDp27Chou3jxIvbt2ydTRESmx0lTiUhWhw8fFrVlT7I7OTkJ1nGEOxFZkzJlyuhcP336dJw7d85M0RDZNvWkeE4mTM2kXlbG0JIy6kl/T09PnZOm6kq4q5eXAfSXlNGkcOHCqFq1Kj755BO920rh6NGjWL16Nfr06YMxY8agS5cuBj8hYO8sZdJUXT799FM0btxY0Hb+/Hls3rxZpoiIyBr07t1b9Ld17ty5OifuJrJmTLgTkawePHggasveMXGEOxFZs1q1aundpn///maIhMwtISFB4whlMh1jaqfro54UMDRh/PjxY8GyvlH2bm5ugsfsgf9LtKvXb1coFHBzcxO0OTs76026N23aFAqFAk5OTmjWrJnObaWyZcuWrH9HRUWhZcuWaNeuHf777z+zHJ9MR6FQYOzYsaLP3aJFi0RlIomIMrm7u4uekHn9+jUWLFggU0REpsWSMkQkK00Tdr5+/Trr3+p1IpOTk1nrjYisRqdOnQzajhMN2h5PT0+UKFFC7jDsyrNnzwTLuSkpoz7ZqqEJd/Wkf+HChXVur1AotE6cqp5w9/T0FCXnASAoKEjr/n18fPDFF19kLXfu3FlnPFJ59eqVqO3BgwdYs2aNWY5vreLj43H//n25w9DLy8sLEydOFLSlpqZi7NixSE5OlicoIrJ4DRo0ED0hExERgatXr8oUEZHpMOFORLJSKBSiNj8/v6x/u7q6CtapVCqOciciq2FofWUm3IlyTz3hnpsR7jmt4Z6TOvLGJNw10ZVw3759O/z9/bOWK1SogJIlS+qNyVT27NmDkydPcvCEDQgODsZXX30laLt37x4WLVokU0REZA2GDRsGd3d3QdvUqVP5XZhsDhPuRCQrTY/b165dO+vf6o9OA0BSUpJJY7InLHlAZHrTp0/Xuw0vMmyPtYxUtRXv3r1DTEyMoE2OkjKmTLirb5dJ25MUoaGh8Pb2FrVrasv0ySef6Cw7U6RIEa3rDDVkyBAsW7Ys1/uxRdb2ZMz3338vmqtk8+bNOHv2rEwREZGlCwgIQL9+/QRtDx48wNq1a2WKiMg0mHAnIlmpX0zWrl1bULddfYQ78P6imqRhbRd2RNbIkIkKmZywPR4eHhrLppFpaBqBLmXC3dAb1OpJf0OeclEfua5t0lRtI9y1jVjXVs5GU8K9T58+GDp0KCZNmoSuXbtqTcpLkXAHgJUrVwIA4uLi8Ouvv+Lo0aMc9W6FnJ2dMXXqVDg7OwvaJ06ciNjYWJmiIiJL1759e9EE0atWrdI4vxsR6ceEOxGJxMXFCZbVR8loSrhzhDsRWZtJkyZprL2caeLEibh+/boZIyKyLeojy318fDQ+JWcoTYlyQ0a5Z5+HJjMOfdRHrmcm3NWfkMheci+74sWLa2wvV66cxvauXbsKltu0aYMePXqgU6dOcHZ2RpkyZbB7926Nr61atarG9pxITExE165dMXPmTISFhWHFihWS7dtaWeOTMSVKlMDgwYMFbTExMZg4cSK/sxORRkqlEmPGjBF8N05NTcW0adNE+QEia8UR7kQkq6ioKMFy3rx5BcuOjo6CEe8AR7hLyRov7IisUcuWLbF582YsXbpUdGMxU48ePXDy5EkzR0ZkG9RHuOdmdDvw/oa/+ihvfQn3lJQUJCYmCtoMSbirj1zfsmULnj59im3btgnay5cvr/H1Xl5eGm8Q1KxZU+P2lSpVQo8ePeDr64vq1aujZ8+eom3U6+tmCg0N1dieE506dcLjx4+zln/66SfJ9k3m1b59e9SrV0/QdubMGYSGhmLPnj3IyMiQKTIislRlypRBly5dBG1XrlxB48aN0aRJE/To0QOTJk3CmjVrcPr0ac7jRlaHCXcikpUhF8jqI9Q4WkY6LHlAZD5BQUEIDg7G6tWrtW4zZMgQM0ZEZDvUR7jnNuEOiMvK6Js49c2bN6K2nIxwf/PmDdq1ayfaTv3x++zat2+f9W8vLy+cPXtW48T0wPsJ6/v06YNDhw5hxYoVRr1XPj4+GDhwoMHb6/LkyRNRm72XlbHWUn8KhQLjx48XPYXx8uVLTJw4EV27dsXVq1dlio6ILNV3332n8W/QmzdvcP36dezevRuLFy/GoEGD0KNHDw68I6vChDsRyUalUolGuKtf3ALikV8XL140aVxERKbk4uIidwhENicnk5Xqo14DXd8TYerlZBQKBby8vPQep1SpUqI2TSP5tI1wB4Du3btj4cKFGDt2LCIiIkQ1tXOiTZs2guXMkfCff/651nI1uaU+tw9ZDz8/P0yZMkXjZ+/27dv47rvvMHz4cDx69EiG6IjIErm5uWHkyJEGbfv3339jy5YtJo6ISDpMuBORbFJSUkSPmGqapOvZs2eCZT5yTES2TH3SRSJTspURxVKXlAHEk5HevXtX5/bqCXcvLy+dczdkMmRi5caNG+t8Ik2hUCAkJASfffaZ1slVjdWhQ4esGwZFihTBl19+CeB9uZ3169dj586dWLBgAXbs2IE6depIcsxt27Zh4cKFuHTpkiT7szbWXuovODgYGzZsQO3atTWuP3bsGD7//HPs3bvXzJERkaWqW7cuxo8fj5IlS8LBwUHntmvXrhVNKE5ETLgTkRpNj4Rx5CcR2YMGDRpoXbdjxw4zRkL26unTp+jWrRvq1q2LMWPGIDY2Vu6QciV7LXBAmoS7+shzYxPuhpSTAd4nsPVNGBoeHm7QvqRUtmxZ7Ny5E2vWrMGvv/4qSOQrFAoUKVIEdevWRdGiRfHNN98IXhsaGoqPP/7Y6GMuWbIE69atw/fff2+Xc1rYQqm/oKAgLF68GAsXLkRQUJBofVpaGsLDw3Hnzh0ZoiMiS9S6dWts2bIFZ8+exY4dOzBv3jwMHjxY9KRVXFwcNmzYIFOURMbRNX8JR7gTkUlpSri7urrKEAkRkXmNGTNG67q1a9eaMRKyR+/evcOQIUPw119/ISUlBQcOHMAXX3yBc+fOyR1ajsTFxYmeDClWrFiu91u6dGnBckxMjM4nUHKacAfe12d3cnLSuG7RokWyfT/y9vZGpUqVtMaWqWrVqpg5cyZq1KiBzz77DH379kXjxo1zdewhQ4agRo0aqFGjBoYOHaq3hj5ZlpCQEPzyyy8YOXKk6HchLS0NY8eORXJysjzBEZFFcnBwQNGiRVG/fn106dIF48aNQ5MmTQTbbNq0iU+DklVgSRkiko2mL9maLiizTwRGRGQL/P39sX//fo3rkpKSsGzZMkyaNAm3b982c2Rk61QqFaZPny4arR0TE4P+/ftj7ty5SElJkSm6nFEvweHo6Ciqv54ThQsXFj15p2uUe24S7i4uLmjevLmofeDAgZKVazG1xo0bY9myZRg7diy8vb0RHBws2b5PnDiBOXPmSLY/S5WQkICEhAS5w5CMg4MD2rdvj127dqFVq1aCdZGRkVi4cKFMkRGRtejdu7egPFtSUhJWr14tY0REhmHCnYhkoz7CXalUwtHRUbTdRx99JFjOmzevSeMiIjKHvHnzIiwsTOO6n3/+Gbt370aPHj04iSBJateuXfj999+1rt+0aRO6deuGyMhIM0aVO+oJ96JFi+qtA2sIpVIpKomhK+H+5s0bwbIxCXcAGDx4MKpXr561/M033+Crr74yah+WxMfHB4sWLZJsf8eOHZNsX5bK09MTJUqUkDsMyXl6emLMmDEoW7asoD2zhAQRkTYlSpRAy5YtBW3btm3jU09k1ZhwJyKTUk+4a3tcWj0Jn5aWZrKYiIjMqUOHDggNDdW6PiUlBdu3bzdjRGTLbt++jVmzZgnaFAqFaLs7d+7gyy+/xNatW61iUlX1hHvx4sUl27d6WRlTjXAHgDx58mD58uX46aefsGnTJvTq1cuo11siKUe5k3VzcnLClClT4OzsLGifNGmS1c8hQUSm9e233wpyAqmpqfjpp59kjIhIP3N+h2bCnYgEmHAnIno/eaUuT548MVMkZMvi4uIQFhYmKhczY8YMhIWFiZJgKSkp+OGHHzB06FBRItnSqCfcpRwhbMzEqervk7e3t9HHUygUqFatGsqUKSN4hN5aaXrSoH79+jneX2pqKmJiYnRORGbN4uPjRZ9nW1KiRAkMHjxY0BYdHY0pU6ZYxc09sg8qlQrr1q1Dr1698NNPPyE9PV3ukOxewYIF0a5dO0Hb7t278eDBA5kiItKPJWWISDaGJtzVL9aYcCciW9K6dWu5QyAbl5GRgYkTJ4pu7nTu3BlNmjRBhw4dsH79epQsWVL02pMnT2Lo0KEWnXD477//BMumTLj/888/Wss85XaEu60qWLCgYHnYsGG4fPlyjvZVp04dNG3aFB9//DF+/fVXzJ07F1evXpUiTIvg4eEBDw8PucMwqfbt26Nu3bqCthMnTmDXrl3yBESk5tixY1i4cCGuXLmC5cuXY8+ePXKHRAB69OghyBdkZGRg2bJlMkZEpBsT7kQkG/VJUw0d4W7JF/3WxtYm5yKyRuqJB3XHjx83TyBks9atW4eTJ08K2qpUqYIBAwZkLZcsWRLr169Hx44dRa//888/ce7cOZPHmRPv3r3Ds2fPBG1SJtwrV64sGP2fnp6OCxcuaNyWCXfN+vXrl/UedurUCYUKFcr1PuPi4jBz5kxs2rQJvXv3xp07d3K9TzIPhUKBCRMmwNfXV9A+Z84cHDlyhCPdSXbqN38mT54sTyAk4O/vj06dOgnaDh06hA0bNuDEiRO4efMmXrx4YbNPQJH1YcKdiGSjPsLdxcVF43YsKWM6tjo5F5E10Tea0ZbLJ5DpXblyBUuXLhW0+fr6YsaMGaK/r87Ozhg2bBgWLlwoSob99ttvJo81Jx48eCC4aFEoFChWrJhk+3dzc8OHH34oaDtz5oxou/j4eERFRQna/P39JYvDmjVt2hR79+7F77//jqFDh2a1S/X9IyMjAwsXLpRkX2Qefn5+GDdunKDt3bt3GDFiBPr06YN79+7JFBkROJGvBfvqq6+QJ08eQdv8+fMxdOhQfP3112jZsiWaN2+u9cY4kaVgwp2ITCqnNdxVKhWTT0RkV1jHnXLi1atXGDVqlOBvpkKhwNSpUxEQEKD1dSEhIejdu7eg7eTJk4iJiTFZrDmlXu+6QIECWr9P5JT6UyinT58WfQ+5fv26oM3JyUk04ao98/HxQWBgoKBt4MCBku3//Pnzku2LzKNBgwYaJw2/dOkSOnXqhFmzZiEuLk6GyMjeaZp7giyDl5cXunbtqnOb6OhojBo1iv0HyY6TphKRbN6+fStYNnSEO8BR7lKx9cm5iGwFH7EnY6WlpWHUqFGiJHnv3r0RHBys9/X/+9//BH+X09PTLbKOrfrfsOLFi0t+DPWEe0xMDK5cuSJoU68jXqlSJdFEtCRUr149SZ9GsAX2VupvyJAhGifRzcjIwJYtW9ChQwfRHA1Epsa+27J17NhRb2myuLg4LF++3EwREWmma5Copmu7xMTEHN8oYsKdiLK8fftW9Ii7oSPcASbcpWIPk3MREdmjpUuX4tq1a4K2kJAQdO/e3aDXe3p64uOPPxa07dq1y+Ju/qgn3E1RJq1IkSIoWrSooG3GjBlISUnJWlZPuFerVk3yOGzRhAkTsr6HFCtWDMeOHcvxvgYMGIB//vlHqtBkYW+l/lxdXTF37lzMmDFD9AQE8P4pnZEjRwp+14hMzcnJSe4QSAc3NzesWLEC3bp1Q8OGDVGxYkUEBgaKcgZbt25FZGSkTFES6R4wpV6e8MCBA/j444/x8ccfY+XKlUYfiwl3Isqi6YJKW8Jd02N9TLgTkS1ZtmyZzvUsl0DGOH78ONatWydoy58/PyZPngyl0vCv5J999plg+eHDh/jzzz+lCFEy6qNfTZWs7NChg2D5wYMH2Lx5M4D3k8DfunVLsL569eomicPWVKlSBdu2bcPPP/+MjRs3Ik+ePGjbtm2O9nX27FlRCSWyfAqFAh9//DG2bduGnj17ikYX3717F4sXL5YpOrJHmhLulnaz2d4FBgaiX79+mDNnDtauXYvff/8dO3bsEPQfGRkZmDNnDs8dWaTsc0WoVCosXLgQKSkpyMjIwIoVKxATE4Pnz58jIiICt2/f1rs/JtyJKMv8+fNFbSwpQ0T2qkaNGjrrGc+cORPnzp1jIon0SkxMxOTJkwVtTk5OmDlzJry9vY3aV9WqVUUju3ft2pXbECWTnp6Ohw8fCtpMmXCvWLGioO348eMAgH///VfwvUShUKBKlSomicMW5cuXD1WrVs0aeNGjRw94enrmaF8PHz606lHu9lzqz83NDb1798a2bdtQsmRJwbpNmzbxxjOZjaaEe3JysgyRkDEKFiyIr776StB24cIFnDp1SqaIyN4ZerMnNTUVL168yFpOT0/Hzp070blzZ4SHh6Nr1656J3Nmwp2Ismi6kGJJGSKyZ1999RV+/PFHKBQKjev79++Pb7/91sxRkbU5cuQI3rx5I2gbOnQoKlSoYPS+FAqFaJT74cOHER8fn5sQJfP48WPR9wFTJdyVSiW++eYbQdt///0HlUqFv//+W9BevHhxuLu7myQOe1CgQAFs2bIlx6//4YcfEBsbK2FE5sNSf++TZtOnTxeNdJ8wYQJev34tT1BkVzQNbrCnuRWsWbdu3USTws+dO5dlqUgWhibc3717J2rbvn17Vj33jIwMjB8/Xuc+mHAnoiyaEu7aRrhrao+KipI8JiIiudWsWRO//fab1vV//vkn7ty5Y8aIyNr8/vvvguVatWqhXbt2Od5fy5YtBWVo3r17h4MHD+Z4f1JSHwns5+cHLy8vkx1PfdRtXFwcYmNjRY/6li9f3mQx2AtN9bwN9ddff+GLL77gd0UrFhQUJHrqKzo6GpMnT2Z5CDKpHTt2aOw7EhMTZYiGjOXm5ob+/fsL2h4/fow5c+Zgz5492LVrFw4cOCCaUJ7IFHT9vapRo0bWvzUNJlXvh/TdcGbCnYiyaEq4axu17uzsjOLFiwva7t69a4qwiIhkV7BgQZ3rM8tYEKl79uwZLl++LGgLDQ3V+tSEIfz9/dGgQQNBm6WUlVGfDE39u4LUChQoIBp1+99//4kS7uXKlTNpHPbC2BJI2cXExGDNmjXSBUNm16FDB4SEhAjaTpw4kaunH4h0uXDhAqZNm6ZxXWpqqpmjoZxq1qyZqKzb9u3bMXHiREyZMgVjxoxB586d8ezZM5kiJHuhK+GeL1++rH9L0b8w4U5EWfz8/ERtmh6lyZS9QwI4yoCI7NfGjRvlDoEs1L59+wTLefLkQf369XO93zZt2giWb926hX///TfX+80t9VrdpUuXNunxlEqlqKb9v//+i3v37gnamHCXxogRI3L1+l9//VWiSEgOCoUCEyZMgK+vr6B99uzZmDZtGmtqk+SmT5+udR3LmVoPhUKBYcOG6dzm1atXWLJkiZkiIhLLXrpKiv6FCXciypL98fRMwcHBWrdXLyvDL9lEZK9YR5Q0UalU2LNnj6CtadOmohHZORESEiK68a2r9JG5qJdXKlOmjMmPqV4j/siRI6ILJXPEYQ+aNm2KZcuWYdiwYejXr5/G745k2/z9/TXWrd2xYwe6du0qesqFKKcuXbqEx48fa13PhLt1qVChAlq3bq1zmwMHDljE4AGyXbpGuGdfxxHuViAhIYEX4WQ1NCXM69Wrp3V79QlVmXAnIiL6P3/99RcePnwoaGvZsqUk+3ZwcMCnn34qaNu7d6+sk5AlJiaKkiPmSHSrl625evWqYLlIkSIay+ZRztSoUQMdO3ZEt27dsGXLFq3lHrQ5ceKEiSIjc6lfvz6+/vprUfu9e/fw1VdfWcycEmS9zpw5g++//17nNiwpY31GjhyJL774AqVLl0bp0qVRvnx5wSA+lUqFH3/8UcYIydapP4mZXfaEO0e4WwFPT0/RqBsiS6V+kT5gwABRUj07jnAnInuib8JAXviROvXJUosWLYrKlStLtn/1kWJxcXGyzidw9+5dwcWKUqkUTWpqCvrqxFeqVMnkMdirEiVKoGnTpka9ZujQoTh9+rSJIiJz6devHyZMmKBxAM7YsWNx8eJFmSIjW7B06VK923CEu/VxdnbG8OHD8csvv+CXX37B+vXr0b17d8E2J0+exI0bN2SKkGyd+pOY2WUvKcMR7kQkKfWEua5kO8CEOxHZl1mzZulcX6dOHU4eTVlSUlJEozxbtmyZq8lS1RUuXBg1a9YUtMk5ear6qKHixYtLUj5HH30JdylvcpA0Bg0ahBo1aqB169aYOXOmrE9mUM4oFAp8+umn2LBhg2iuhoyMDIwYMQIPHjyQKTqydrpGoWbiQAfb0LlzZ/j4+AjaOMqd5MAR7lYmPj4e9+/flzsMIoOoX+yoJ9TVqSfkdU2wSkRk7SpUqKB3mxUrVpghErIGp0+fRlxcnKCtefPmkh9HffLUixcv4unTp5IfxxDqdVfLli1rluMWK1ZMZy1xjnC3XE+fPsWvv/4q65MZlDvFixfHmjVrRH3R27dvMXjwYFE/SCQVJtxtg7u7O3r06CFou3jxIs6fPy9TRGSvWMPdynh4eMDDw0PuMIgMop5w1zcqjSPciYiEjh49KngckeyX+mSpH374IQoWLCj5cRo3bgwvLy9Bm1yj3NVHJJprolJXV1cUKVJE4zpnZ2fR6FuSXocOHXL1+tGjR0sUCcnBxcUFY8aMQePGjQXtDx8+xIgRI1j6g0yCCXfb0b59ewQEBAja+vXrh9DQUISHh4vmZiEyhezXcBzhTkSSSkxMFCwbm3BXfz3lDCdbJrJcvXv31rsNR+RQbGwszpw5I2iTarJUdc7OzmjWrJmgbceOHWa/CZ6eni4a4W6uhLuuY5UrVw5OTk5mi8NeDR48GP369dM71wXZLqVSiUmTJqFcuXKC9kuXLiEsLAxJSUkyRUa2ijdybIezszO+/fZbUfvDhw8RERGB3r1749y5czJERvaEJWWIyCTevHmDx48fC9ry5cun8zXqd6EfPnwoeVz2iJMtE1muTz/9VO82AwYMwPjx4xEZGWmGiMgSHThwAOnp6VnLLi4uaNKkicmO1759e8Hy69evsXfvXpMdT5OHDx+KnpQz58hybQn3qlWrmi0Ge+bk5IRu3bph586d8PT0lDsckombmxvmzp2LvHnzCtpPnjyJXr16ITo6WqbIyBYx4W5bPv30U61zsmRkZGD69OksYUsmxYQ7EZmE+lwDzs7OKF++vM7XqCeFHz16xEf7iMimBQYG4syZM5gwYYLO7fbu3YtevXoJkq5kP37//XfBcuPGjU1aYjAoKAi1a9cWtP3yyy+CCwdTUx/dni9fPvj5+Znt+NoS7vXq1TNbDPT+++OKFSvQtGlTFC5c2KjXzpkzxyITsnzy0DgBAQGYO3eu6EnYW7du4euvv+bNaJIMrztti6OjI+bOnYsGDRqI5ooD3s/5sWrVKhkiI3uRvaQMa7gTkWTUy8H4+PjofQRbPeGekZGBR48eSR6bveFky0SWzcXFxaCR7rGxsThx4oQZIiJLEhkZib///lvQZqpyMtl17txZFIc5yxup1283d910bcf74IMPzBoHvb/5MW3aNISFhRn1ul9++QV9+/Y1640iQ/DJQ+NVqFABixYtEs0v8fz5c3Tv3h0XL16UKTKyJRzhbnuKFi2KuXPn4vjx41i3bh2qVKkiWL9u3TpeJ1OulCpVSus6jnAnIpNQfzxL011ldZ6enqJHRv/77z8pw7JLnGyZyDp89NFHercxNuFEpmWOkarqk6Xmy5cPwcHBJj0mANSpUwdBQUGCto0bN5r8uJnu3LkjWC5btqzZjg1oLoMXFBQEBwcHs8ZB/6dChQpGv+bu3bu4e/euCaIhc6tevTpWr16NQoUKCdoTEhLQv39/REREyBQZ2QqOcLddjo6OqFChAsaOHSv4O56WloYZM2YIRiITGUPXZyd7wp0j3IlIMjlJuAPiUe5MuBORvZgxY4ZB27HepOUw9UjVjIwM7Nu3T9DWvHlzKJWm/8qtUCjQqVMnQdv58+dx7949kx8bECfczTlhKvD+52/cuLGgrU+fPmaNgYR8fHzQo0cPo18XGxtrgmhIDsWKFcOaNWtQuXJlQXt6ejrCw8OxYsUKmSIjS5cnTx6926jPG0K2JygoCF9++aWg7cqVKwgNDcXq1av594KMpqvcZ/ZkPEe4WwHW/CNrkZSUJFh2c3Mz6HXqE6fGx8dLFhMRkSUzdORsTEyMiSMhS3Hx4kW8fPlS0GaOcjKZWrRoAR8fH0Hbpk2bTH7c6OhoUe1tcyfcAaBv374oVqwYHBwc0KZNGzRs2NDsMZBQnz59EBERYdQkvocOHTJhRGRuvr6+WLZsmcaJo1esWIHDhw/LEBVZurdv3+rdhiPc7UPPnj1RoEABQdvjx4+xZMkSdOzYUXTDn0gXjnC3Iaz5R9YipyPcHR0dBcuspUdE9mT16tV6t+Fjr5bD1HNkqE+WWq5cOZQsWdJkx1Pn4uKC9u3bC9r27dtn8ps+Z86cESy7ubmhSJEiJj2mJsWKFcO2bdtw7NgxjBs3DgqFwuwxkFjBggVFAzR02blzpwmjMd6LFy9w8+ZNucOwai4uLpg+fTq6du0qWjdjxgzemCaBV69eGbRdcnKyiSMhS+Dm5oYRI0ZofFowOjoaI0eOFM1HR6SNrhHurOFORCahPsKdCXciIv0MqVPNftFymHKOjMTERBw9elTQ1qpVK5McS5fPP/9cMOl5SkoKtm3bZtJjHj9+XLBcp04ds5TR0UShUMDd3V2WY5NugwcPNnjbgQMHYs2aNRZxwzIwMBAVK1aUOwyrp1QqMWDAAAwfPlzQ/vr1a/zwww8yRUWWKCoqyqDtWFLGftSrVw/z58/XOIjh4cOHmD17tgxRkTXS9b0i+zpdiXlDMeFuYqYeSUUkFfUR7oaWlFEvqcDEEhHZE2dnZ/Ts2VPnNu3bt8f58+fNFBHpYspSf4cPHxaMtnNwcEDTpk1Ncixd/P390axZM0Hbtm3bTJaYSExMFH2+GzVqZJJjkXXr0qULVq1aZdC2Z86cweLFi0WTEJP169Chg2i+hSNHjuDgwYMyRUSWJvtNY12YcLcvISEh2Lx5M1atWiUa8BIREcE+hAxiaEkZKW74M+FuYqYcSUUkJY5wJyLKmd69e+vdpl+/fgbVIyXTMmWpP/VyMnXr1oWfn59JjqWP+uSpMTEx2L9/v0mOde7cOUHSw8HBAfXq1TPJscj6ValSxajtw8PDTRSJ4VhSRloKhQIjR46Et7e3oH3s2LEIDw/H48ePZYqMLIX69aU2LCljfxQKBapUqYIffvhB9DTb5MmTcfr0aZkiI2thaEkZJtyJSDJMuBMR5dwnn3yidxtD6r2TdXr69CmuXLkiaJOjnEymMmXKIDg4WNC2adMmwYWEVI4dOyZY/vDDD+Hl5SX5cch2qH82LR1LykjPz88PI0aMELRlZGQgIiIC7dq1w4EDB2SKjCyBofNvcIS7/SpcuDBGjhwpaEtKSsKQIUNM9n2HbIOuz0b2JDsT7kQkGfXJaQwdlceEOxGRYbWJb9++bYZISBdTlfrbt2+fYNnLy0v2Ud6dO3cWLN+9exe7d++W9Bipqami0WQfffSRpMcg29OiRQu5QyAL8Mknn2gsu5Weno6JEyfi6dOnMkRFlsDQRBdHuNu3Fi1aoGXLloK2jIwMzJ07FwsWLGDSnTQydIS7FJ8fJtyJCADw/PlzwXJgYKBBr2PCnYgICAgI0LtNamqqGSIhXUxR6k+lUonKyTRt2hTOzs6SHsdYISEhKFasmKBt1qxZePjwoWTHuHLlCuLj4wVtDRs2lGz/ZJuMffpD/YaWuXFOLtNQKBQIDw9Ht27dRE/WpqamYtGiRTJFRnIzNOHOEe40ZswY0bw1ALBhwwYsW7ZMhojI0hmacOekqUQkmcjISMEyE+5ERNJi/2ibbty4IUpiq4+4koNSqcTAgQMFbUlJSRg7dqxkn0X1cjIVK1Y06OYTUeXKlQ3edty4cYiOjjZhNCQXR0dH9OvXDxEREWjSpIlg3aFDh3D9+nWZIiM5MeFOhnJ2dsbkyZPx/fffi9atXLmS5RxJ5N27d1rXZe97OMKdiCRx9OhRUVv+/PkNei0T7kRE7+mrS8z+0Tapj24vWrQoKlWqJFM0Qg0aNEBoaKig7datW1i+fHmu952UlCRKuLOcDBlK/WaQPr/++quJItHPlJMt03t+fn4YM2aMaP6HiRMnYsqUKdi0aRMSEhJkio7MzdCRpSwpQ8D7p2W++eYbhIeHi+r/L1myBHv37pUpMrI06enpOq/HOGkqEUlu7ty5ojZDR6ipJ9zPnj0rSUxERNambdu2Otf//fffZoqEtElISJA0aZOSkoKDBw8K2lq1amXwhG/mMHjwYFFpmTVr1uDq1au52u+8efMQExMjaGPCnQxVpUoV9OjRA/ny5TNoe/afts/LywvffvutoO3hw4fYtWsX5s6di3HjxskUGZkba7hTTrRo0QKjR48WtU+ePBl//PGH+QMii6PvqRjWcCciyanXbwdgcO1Z9YQ7AEnrwxIRWYuPPvoIFStW1LnNsGHDJBkxQTkj9UjVU6dO4e3bt4K25s2bS7Z/Kbi5uWHq1KmCv9cqlQpjx45FXFxcjvZ54sQJ7NixQ9BWvXp1UWKfSBulUok+ffoYXJ/97NmzktRTzQnWcDef9u3bo2jRohrXnTx5kjde7ARHuFNOtW3bFkOHDhW0paamYsiQIdi6dSvLENk5fU8bZ79GYw13KyD1SCoiS6Mp4b5hwwYZIiEikpejoyNWrlyJ8PBwrdscP34cf/31lxmjIlNSLyfz4YcfokCBAjJFo125cuXQp08fQVtUVBSmTp1q9AieV69eiT7jbm5uHH1KJlerVi28fPlS7jDIhJycnBAWFgalUnOaYtu2bWaOiORg6N8lJk9Jk06dOqFjx46Ctri4OPzwww/4/PPPOTjQjulLuHOEu5VhzT+yRiEhIQZvqynhHh8fL2U4RERWw9HRES1atMDFixe1brN48WIzRkTZSTlSNSYmBmfOnBG0tWrVSpJ9m8KXX36JmjVrCtqOHDmCuXPnGnxRERsbi1GjRuHNmzeC9mHDhqFIkSKSxUr2pU6dOgZv27x5c0kugo3B6znzql27NlasWIGuXbuK1u3fvx///vsvjh8/Lnq6iGyHoSNL5XrqhSzfkCFDULduXVH7kydPMGzYMM6rZKeMSbizhjsRScLJyUmw3Lt3b4Nfq6n0jKura65jIiKyZtpG5wEckSUnDw8PeHh4SLKvAwcOCC72XVxc0KRJE0n2bQpKpRKTJk0STUr4yy+/YNGiRYKLjMTERFy5cgUXLlzAq1evoFKpcPHiRXTq1AnXrl0TvL5x48Zo3bq1WX4Gsk3ffvst/Pz8DN7+m2++MXvSncyratWqGDBgAPbv3w8HB4es9uTkZHTq1AnDhg1Du3btEB0dLWOUZCqGJrqYcCdtlEolpk+fjvr164vWRUZGYtOmTTJERXKKjo7G5MmTdW6Tve9hwt0KsOYfWbrU1FSkpqYK2oxJRvj6+oramHAnIgI6dOigsZ3fC2yDejmZxo0bw93dXaZoDBMQEIDw8HDRDaF169bhp59+Qnx8PH766Se0bNkSvXr1Qt++fdGsWTM0adIEffv2xatXrwSvy5cvH8aMGWNRk8SS9alSpQp+//13HDx40KDP0vXr13H06FEzRPYer+fkkzdvXjRq1EjjupiYGKxbt868AZFZMOFOUnB3d8e8efOwYsUK0RwzCxcuxNSpU3H9+nXewLUTXbt2xdmzZ3Vuw5IyVkbKkVREppCUlCRqMyZhoOkRcjc3t1zFRERkC7SN+uXcLtbv3r17uH37tqDNksvJZFevXj1MnjxZlNhcsWIFmjdvjuXLl4tKNcTFxYkuPPz8/DB79mx4e3ubPGayfU5OTvDz88OhQ4cM2n7EiBEmjuj/8HpOXu3bt9e6bt++fXj+/DnOnj3Lv602xNBEOsuCkCGqV6+O8PBw0feenTt3okePHti+fbtMkZG5REVF4cWLF3q3i4yMzPq3of2QrsQ8E+5Edi4xMVHUZkzCvWDBgqI2XpQQEWkuuUXykmoy+7179wqW8+XLJ6qPbsn+97//Yfz48aJ2TTfhNalTpw42b96MihUrSh0a2TkfHx+5QyALU6NGDdHo1EwxMTFo1aoVBgwYgM8++0z0FA5ZJ0NHlnKEOxmqYsWKWm/eLVmyRGNOhGzHhg0bjH6Nof0QE+5EpJWmPy7GjlBXn5CEow2IiHQn3NVHR5N5SDH5YUZGBvbt2ydoa968uc66/Zbo008/xejRo3Vuo14iztHREUOGDMGCBQuMqrlNZM2kulFHOaNQKBAeHg4fHx+dJYdiY2Pxyy+/mDEyMhVDa/Mz4U7G6NOnj8an89++fYsdO3bIEBGZy+PHj41+jaGlrXQl3B2NPioR2ZTY2FjBsoeHh9FJA/UJ2DghYO7wwo7INuhKuH/55ZdYunQpgoODzRgRSeHq1auIiooStLVo0UKmaHInNDQUycnJmDNnjqC9SZMm6NmzJ0qWLInnz5/j7t27iI6ORnBwMAoVKiRTtETy8PT0lDsEu1exYkUcOHAACQkJOHDgAH744QeN2128eNHMkZEprFixwqDtmHAnY+TJkwdr167FoUOHMH36dMG6+fPno0iRIqhVqxbno7NBhQsXNnjbjIwMKJVKg0e4Z2RkCCb3zs66huIQkeTUH73Mmzev0ftwcnISLJ88eTJXMdk7KUZgEpH81G9GquvTpw+TA2YmxeSH6uVkSpcujVKlSuVqn3Lq1KkT5syZg5CQELRr1w6bN2/GDz/8gNKlS0OpVKJgwYJo0KAB2rZty2Q7mYWh5bj+++8/0wZCFsXBwQFeXl5o2rSp1uTG33//jYcPH+LJkydmjo6k9OzZM4O2Y8KdjOXl5YV27dph9erVonVDhw5F27Zt8fLlSxkiI1NSH2SqS2a1BtZwJ6JckyLh7ugofFgmMjISjx49ylVcRETWztXVFXny5NG5zYwZM8wUDQG5n/wwOTkZR44cEbRZ6+j27Bo2bIiFCxdi1KhRVn3zgGzDlClTdJYOyaRrMk0pSXGjjqTj7e2Nhg0bal0fGhqKNm3aYObMmWaMiuSQkZFhcNkHouwqV66M6tWri9pfvnyJn376SYaIyJTi4uIM3jYz4c4a7kSUa6ZIuAPQeNeYDMMLOyLbsXDhQp3rHz58aKZISAonT54UlPxSKBT43//+J2NERLancePGWLt2LQYOHKj3MfDff//d4IvinMrtjTqSXq9eveDi4qJzm19//RWRkZFmiojkwoQ75dR3332n8ebu3r17ERkZyRKvNsSYc5nZpxjat+jajgl3Ijv39u1bwbK3t7fR+9D0hyoiIiLHMdk7XtgR2Q5DRmmS9VCfLLVmzZoICAiQKRoi21WhQgV89dVXmDt3rs7tJkyYgDFjxpgpKrIUJUuWxO7duzF37lx07txZ63ZXr141Y1QkB5aVoZyqUaMGpk6diqCgIEH7u3fv0KFDB3zyyScslWsjTJlw5wh3ItJKfYJTfaNFNNGWUDL1iCMiIiJziY2NxZkzZwRttlBOhsjaHTx4UO4QSAZ+fn5o0KABmjVrpnWbq1evIjIyMqtEANkeJtwpN5o2bYpff/0Vn3zyiWhdSkoKpk6dys+YDcjJ0wpMuBNRrqWmpgqW1SdAzQ31ZD4Rkb3hjUfbcejQIcFFl4uLCz766CMZIyKyffrmwcjEshL2q1y5clo/JwcPHkSHDh3w2WefITo62syRkTnwZgpJoWPHjhrbo6OjceHCBTNHQ1KLj483eFuOcLciCQkJrP1EFk09Ke7s7CzZvjlxKhERWZLcfC9TLyfTsGFDlv8iMrF8+fIZtJ0pk268nrNsSqVS5ySqAPD8+XOsW7fOTBGRKVSuXFljO0cfkxSqVKmi9TO2fft20SBFsh4qlSpHJWUMHTTFGu4y8vT0RIkSJeQOg0gr9T8eOUm4aysps3Tp0hzFRERkKzRNKk3yyen3socPH+LGjRuCtpYtW0oVFhHpsHv3br3brFixwmTH5/Wc5evXrx+Cg4Ph4+OjdZt9+/bh4cOHfALXSq1YsQLTp08XtTPhTlJQKBSYOnUq6tatK1p34sQJ1KlTB3v37pUhMsqtpKQkrf1EhQoVtL5OiifnmHAnsmORkZE4e/asoE3KhDsnGSEie1e2bFm9IzTfvXtnpmgop/bv3y9Y9vX1Ra1atWSKhsi+FChQQO82a9aswb1798wQDVmivHnzYunSpTh8+DCCg4M1bhMTE4PQ0FC0aNECd+/eNXOEZKg3b95obHdyckJISIionQl3kkrBggWxYMECHDp0CA4ODqL106ZNw9u3b2WIjHJDVzkZTeXIOMLdisTHx+P+/ftyh0Gk0bJly0RtUpaUISKyd0qlEtOmTdO5DUfMmE9OvpepVCrROWratCmfXiAyo6JFi+rd5osvvjDJY/+8nrMulSpV0rn+9evXWL58uZmiIWNpSl75+/sDgMYkqKkT7k+fPkWvXr1MegyyLL6+vhpHur979w59+/bFsWPHOHeAFYmLi9O6TlN9/sw+yNC+hQl3GXl4eLC+J1mso0ePitqknDSViIiAatWqYevWrVrX60vIk3Ry8r3sxo0bePz4saCN5WSIzKtfv34GbTdr1izJj83rOetStWpVvdscO3YMGzduxK1bt0wfEBlFU5Jr5cqVADQn3BMTE00az7Jly3DlyhWTHoMsT69eveDm5iZqv3XrFoYPH44FCxbIEBXlhK6Eu1KpPSVu6Ah3XZhwJ7JT2joQjnAnIpKevvq/Dx8+NFMkZCz1yVKLFi2K8uXLyxQNkX366KOPdF4YZ9qxY4cZoiFLVrNmTRQrVkzvdvPmzUPXrl1x+fJlM0RFhtKUcPfz8wOgOeH+77//mjQePoVon8qWLYtdu3ahU6dOGtdv2bIF0dHRZo6KckJXSZnChQuL2jJHrBtaw50j3IlIJCkpSWO7JSXck5KSMGPGDHTt2hXr1q2TZOIKIiJLNHnyZLlDIA1SU1Nx8OBBQVuLFi20zl1CRKahUCiwbds2ucMgK+Dk5IRly5ahT58+OifEy7R582YzREWG0lSqIzPRrummm4uLi8ljIvvk7++PwYMHIyAgQLQuIyMDhw4dkiEqMpauubI0lYfMHJhqaO5J10h4JtyJ7JS2O7JSJtxz+wVo9erV2LZtG27duoWFCxfi6tWrEkVGRGR+TZo00bru2rVrZoyEDHXu3DnRBG7NmzeXKRoi+1a0aFGsWbNG73Z//PGHyWMhy5YvXz706NED48aN07vt8ePHcezYMU5gbiE0lY/KPrJdvcwHJ00lU1IqlejQoYPGdbNnz8a6deskKT1C0srIyMCdO3cQFRWF5ORkrdv17NlT1MaEOxHlWmxsrMb2nNRw1zS7M/B/E9zokpaWhlOnTuHmzZuC9vv372PVqlWCtunTpxsdGxGRpfj+++/lDoGMpP4o+QcffIBChQrJFA0RVapUCV9//bXObXr27MmnIgkAULJkSXh6eurdbvjw4ejQoYPOxAyZx6NHj0Rt2Ue2q0+gnJKSYvKYyL517doVnTt31rhu4cKFWL16tZkjIl1UKhUGDx6Mzp0747PPPsP+/fs1blenTh3Ur19f1G5sSRkm3IlIRMoR7u3bt9f4iF9qaqrO16lUKvTu3RuDBw/G119/jV9++SVr3fr160Xbv3z50ujYiIgsRfHixTF+/Hi5wyADxcfH4+TJk4K2Fi1ayBQNEWXq37+/3m327NljhkjI0imVSvTu3dugbZ8+fSqas4MsQ/brTPUnqHmThExNqVRiyJAhOH/+PLy9vUXrly5diqNHj/Lmj4W4fv06zpw5A+D9DbkLFy4I1leqVAm7du3CwoULNc4LkZlAN/TJBdZwJyKRmJgYje05Sbj7+vpiypQponZ9X4AuX74seOx3zpw5Wf+OiIgQbW/IZFlERJbMkIncyHQSEhKQkJBg0LZHjhwRXDw5Ojrik08+MVVoRGSEFStW6Fw/e/ZsM0VClq5jx47Yvn07ZsyYoXfbKVOmYPr06YiKijJDZJQT5ky4x8XFmWzfZH0cHR21lpcJCwtDr169mHS3AAcOHNC53t/fH4ULF4ZCodCYXzK2pMzdu3e1rmP2ishOaRvhntO6602bNsXKlSsFbXFxcTrvDF66dMmoYzDhTkTWrnLlylrXnTp1yoyR2CdPT0+UKFHCoG3Vy8nUq1cPXl5epgiLiIxUvXp1nesTExPNFAlZg2LFiqFJkyYaJz9Ut337dkybNs0MUZG6H374Qe825ky4s64/qevZsydGjx6tcd2NGzf4lIwFcHV11bk+ex+iUChE641NuJ87d07rOmaviOzMgwcPMHfuXI0jg3x9fVG8ePEc71tTQjx7bfbo6GjMnz8fS5cuRUJCgsZZ6I3dPxGRNdHVj02ePNnofpFM4/nz57hy5YqgjeVkiCxL27Ztda7n6FTKTqFQYMCAAXB0dNS77enTpzXWEifTiYyMxNatW/Vup/40tilHFGtKxpF9c3BwQGhoKJYsWaJx/eTJk3H8+HHzBkUC+hLu2a/FNP2OG1vDXeexcr0HIrIaSUlJ6NatGzZt2qRx/ZIlSzTWsTKUpppmN27cAPD+TmGvXr2wYcMGrFq1CqNGjdLYiemcdIIJdyKyYTExMbh165bcYdi0+Ph43L9/X+926hMs5cmTB/Xq1TNVWESUA5omO8tu165d5gmErEazZs2wd+9eDB8+XO+2bdu2xYgRIwyu40u5Y+jvq3oyzZSj0PXNR0b2Kzg4GHXr1tW4btiwYdixY4eZI6JM+io2PHnyJOvfuka4S9H3M3tFZEeuXLmCt2/falw3e/ZslClTJlf7L1KkiKgtc3TR33//jf/++y+r/ezZsxq/IOn6YsOEOxHZOtZ+NC0PDw94eHjo3EalUonKyXz88cc5muOEiExH302whQsXmikSsiZ+fn745JNPDLquOHLkCMu9mYmho8nV/xbfu3fPFOEAAH7++WeT7Zusm0KhwKxZs7TOFzJt2jRMmzbN4HmDSDr6Rrg/ffo069+a+p309HQAHOFOREZ6/Pix1nUffPBBrvevUCjQoEEDQVtmXb3Xr1+LtteUWGrZsiVq1Kihcf9MuBORLfjuu++0rst+Y5Lk8e+//yIyMlLQ1rx5c5miISJtDPleuHPnTjNEQtbGz88PnTt3Nmhb9SeeyDQMvc5TH7165swZkw1WiIiIMMl+yTY4OzujUaNGWLBggcb1O3bswJAhQ/iUjJnpq9jQpk0bneszKzQYmnCvVKmS1nXMXskkPj5e7hDIDmmrWeju7g4fHx9JjpE3b17BcmbCXdfjOtnFxsZq3Tfr6BGRLfj888+1rpsxY4ZJJwAj/X7//XfBcoECBVC1alV5giEinfQlTadOnZrrUWoJCQkcpWiDBg0ahC1btui9oXrw4EFs2rRJktGOpN3Vq1cN2k5TuQjeFCE51a1bF6tXr9a47sqVK1rXkWlkjlDXpnDhwjrXZz4dZ2ifr6msciYm3E1M2xe0du3aoU+fPvjll18EjzTYk4yMDL2/DCQtbTd6EhMTJUtmqz/mt2XLFnzyySdYvHixaFtjv7jy7jAR2QJfX18sX75c6/rffvvNjNFQdhkZGaIL9+bNm/MJKyIL1a9fP73b3LlzJ1fH8PT0RIkSJXK1D7JMJUuWxPfff6+3ZNjcuXP5tISJ3bx506DtNCXcdT3FnVO57TfIvlSuXBm7d++Gl5eXaN3SpUvxww8/yBCVfUpLS9O5Xl9/nznwydBcla6cJq8eTEzbF7T09HRcvHgRc+bMQevWrfHFF19g6dKluHHjhl3cPd+wYQPq1q2LkJAQdOzYEePGjcO6detw+/ZtuUOzadrqt2uqvZ5TL1++FLXFxsbin3/+EbUbm0C3h98NIrIPJUuW1Lru+PHj5guEBC5duoTo6GhBG8vJEFkuQ+ZW+PLLL1nPnbQqWLAg1q5di44dO+rcTv3pJzKPHj16CJY1/c7/9ttvOp+SNtbr16/RrVs3yfZH9qFAgQL4+eefERAQIFq3detWXLx4UYao7E9uE+6ZA1ENzVXpylEx4W4h7t27h1WrVqF79+5o1qwZJk+ejJMnT+Zq1u20tDQ8efIEz549s6iRwU+fPsXChQuRmpqK9PR03L17F/v27cPChQvx5ZdfYtq0aUysmoi2Ee5NmzaV7BjXr183eFv1Sen0efXqlUV9lomIckrXhD76viiS6agnVMqXL8+RrUQ2YN26dSwLQ1qVLl0aw4YNE81Fld3169c5z4oMQkNDBcua6jNHR0ejQ4cOkv2Ob9iwgZPYU44EBQVhz549KF++vGhdnz598Oeff8oQlX3JbcI986lWQ3OSurbTXNCZJBMfH4+XL18adbEWExOD3377Db/99hucnZ1Ru3Zt1K9fH/Xr1xfUx1apVHjz5g2ePHmi8b/nz59nnXxfX19UqVIFH3zwAapUqYIKFSoYNCLEFM6fP6/zQ7ljxw68e/cOEydO5CPcEkpLS8P27dtF7Z6ennpHdBgjNTVVsn1p8u+//6JMmTImPQYRkanp+hvMm87ySEpKwrFjxwRtHN1OZPlq1aqFCxcu6N1u165d6NKlixkiIms1atQoFChQAFu2bNG4vn379pgxYwY+/vhjM0dmv/RNgJgpNjYWGzdu1DkxvaHu3buX632Q/VIqlViwYAH69u2Lf//9V7Aus6x00aJFZYrO9ukrWy11wl3X8ZhwNzEPDw8kJiaK2idNmoTr16/j1KlTOh9/SklJwcmTJ3Hy5EkAQMWKFREQEIAnT57g8ePHGvetSWxsLE6cOIETJ04AeD95Zvny5QVJePXJLk3FkEdp9u7dC5VKhYkTJxr8R5Z027p1q6jtm2++wffffy/pcWrXrm3SiWt+//13JtyJyOrpuqHMhLs8Tpw4gaSkpKxlpVKJ//3vfzJGRESG6Nevn0EJd0NrRJP9ypcvH4YPH44PPvgAo0eP1rjN4sWL0aRJE8nmv6L3JVy0Uc8F6Epu7d27V5KEO88t5Zafnx82bNiATp06ITIyMqs9OTkZnTt3xqpVq5jTMBGpSsoYej324MEDres4fFgmdevWxfjx43HgwAGsWrUKX3/9tUGj4G/evIljx47hzp07BifbNUlLS8ONGzewceNGhIWFoVmzZujUqRNWrVplkklHMmVkZODy5cuCthYtWiA0NBROTk6C9n379mHcuHGcWFUic+bMEbXly5dP8uOYut7dxo0bBX+0iIhsDf/uyUO9zFnt2rXh7+8vUzREZKjy5ctj165derc7ePCg6YMhm/DJJ59oTbg/fvwYP/30E/9WSygiIkLrOvUBCtpKpALSTJ6qUqmyBjsS5YaDgwMWL16MggULCtrfvXuHnj17mjTvZs9ym3DPvMlnaCnjZcuW4cWLFxrXMeEuM6VSiSpVqqB///7YunUrduzYgcGDB6N69epmL6fy77//YunSpfjss8/QtWtXrF+/Hs+fP5f0GHfv3hXdwe7duzdGjx6NOXPmiD78Bw8exKJFiySNwR5puzmjq4ZwTgUFBUm+T3UbNmww+TGIiOTCUZjmFxsbi/PnzwvaWE6GyHoULlwYX3/9tUn2HR8fj/v375tk32SZFAoFQkNDMWvWLI3rV6xYgSVLlpg5Ktula1Jj9RHuhQsX1rmvR48e5SqWnTt35ur1RNkFBARg8+bNooGOiYmJGDJkCKKiomSKzHbpS7jrm5+hVKlSAIx74njlypUa25lwtzBFixZFly5dsGLFChw+fBiTJ0/GJ598And3d62vUSqVKFSoEIKDgxEaGor+/ftjxowZWL9+PY4ePYqIiAhMnjwZ7du3R5kyZQxK5N+6dQsLFixAq1at0KNHD2zZsgVv377N9c+nPrq9UKFCWXf8QkJCMHfuXFHSfcOGDVmlcChnXr16pbHdzc1N8mOZ40aR+qR2REREhkhISNA4qdqxY8cEX6zd3NzQqFEjM0ZGRLnVv39/uUMgG9OwYUOtfws2bdqEmJgY8wZkg/QltdQT7vpKvd26dStX8UybNi1XrydS5+7ujiVLlsDb21vQHhkZiUGDBvFpGYnpS7jrK1ldu3ZtAMYl3I8fP66xnTXcLZiXlxeaN2+O5s2bIzU1FVevXsWVK1eQkZGBQoUKoVChQihcuDACAwN1fmi8vLxQsGDBrJFaCQkJ+Ouvv/Dnn3/i+vXruH79us7yNJnbrFy5EiNHjkTjxo1z/DOp12+vWbOmYLl27dqYN28eBg0aJJh8c8KECdi4cSMKFSqU42Pbs3fv3mlsN0XC3Rx8fX3lDoGIiKyQp6enxvYjR44Ilj/66COr/RtJZM9OnjyJBg0aSLpPbf0G2T6lUonZs2fj999/x4QJEwTr0tLSsHLlSgwfPlym6GzDzz//rHO9+mAud3d3uLm5CeZcyS43gwR1lashyo2goCDs2rULHTt2FJQfuXPnDiZMmIBJkyZx7kKJ6Eu4V6xYUbDcsGFDwQDfzFIyxiTctd185Qh3K+Hk5IRatWqhT58+6NevH9q2bYvg4GAULFjQ6F9MDw8P1KpVC9999x0WL16M48ePY8WKFWjfvr3ORGZMTAzCwsIwYsSIHN3NT0tLw9WrVwVt6gl3AKhVqxaGDRsmaIuPj8fIkSP1Pv5Bmmn7QmKKkjIAUKVKFZPsN5OPj49J909ERPbln3/+ESy3aNFCpkiIKDfc3d05QpUk17x5c9SqVUvUvmXLFmzcuFGGiGzHihUrdK7X9PR00aJFtW6vqx68Pvv378/xa4n0yZMnD5YuXSqaH2j//v0YPHiw1pyNtVOpVDh//jyOHj2qNxkuBX3HUO9T1POpmYl2YxLu2rZnwp2gVCpRvXp1jBw5Evv378fSpUvRpk0beHl5adz+yJEj+Pzzz7F//36DJxIAgL///ls0kl5Twh0AQkNDRY+L/f3331iwYIHBx6P/Y84a7gAwduxYk+w30927dzkCgYisXp06deQOwe4YUovZ399f6/cTIrJ89evXl3R/L1684Nwadk6pVGLRokUYMmSIaN28efNw6NAhGaKyD46O4qIM2Z+EV5ebJ1J07ZdICsWKFcOUKVNE7WfPnkXv3r1tLseRmJiImjVrol+/fggLC8OAAQNMfkxdCfeQkBBRm0KhECxnJs6NyXVqOy4T7iTg4OCA4OBgjBs3DgcOHMD8+fNRt25d0XZv3rzB2LFjMXToUIMnerh06ZJgOSgoCH5+fhq3VSgUGDNmDIoXLy5o37p1q+QTudq6hIQEvHz5UuM6Uz0uHxQUhGbNmplk35lmzpxp0v0TEZna6NGj5Q7B7nh4eMDDw0PnNs2aNeNjvURWTOoBJYGBgaJH0Mn+KJVKdO7cWePkvKNGjcLw4cOZsJVYixYtNI5w15VQUy9hawz+7SdzqFmzJnr06CFqv3nzJqZNm2Z0oteSbdu2TbB88eJF3Lt3z6TH1NU/NGnSRNSmbYS7sbX1NfX/TLiTVk5OTqhXrx7mz5+PqVOniiZ5AN7XSezQoQOuXLmid3/qCffg4GCd27u7u+OHH36Ai4tLVltGRgZ+++03A38CioiIwMcff4zw8HCN601Zn7Zv374m2zcA7N2716T7JyIytQIFCmD9+vVyh0FqWE6GyLqpj1YjklL//v01TtB77NgxLF++XIaIbFOXLl1EdfMz6Sszq2t+OiJL0KdPHyxcuFBUVeLgwYM2Vdpo4cKFora7d++a9Ji6Eu6a8l/q3xkyb3gYe+Nj5cqV2L59uyBRz4Q76aVQKPC///0PW7duxccffyxaHx8fj2HDhuHhw4da95GcnIw///xT0GbI49olS5ZEq1atBG27du3Sebfp+fPnuHjxotZR3fYiIyMDixYt0jnSwpQJ9wIFCuC7774z+nUfffQRL5SIyG6UL18eX3zxhdxh0P8XFBSEMmXKyB0GEeXS0qVLJduXIaWoyL58/fXXovKnALBmzRqMGDHC6Nq/9kpb/qBIkSIYPHiw1hHncXFxOvf77t27HMVja+U8yLKFhIRg1apVoqT7lClTcPbsWZmiMj1TP0miK+GuqUSV+lM0mblGY/vxdevWYfr06YJ5ZJhwJ4P5+flhxowZmDlzpqgUzNu3bzF48GCts4Jfv35dcCc6s268Idq1aydYfvnyJU6fPq1x2yNHjqBdu3bo06cPmjdvjh49emDHjh12+aUnMjISsbGxOrcxZcIdgManInTp3LkzZs2aheXLl+PLL7/UWzbmwoULuQmPiMgiMMFrOVq0aMGbvkQ2QN+TtMYwpBQV2Z/hw4drLHdy5MgR7Ny5U4aIrM/s2bM1tv/66686X6epLER2OR1BK+WNOiJDFC9eHGPGjBG0JScnY+TIkTY7gFRTvyklXYNzixUrJmpTjyenI9wzZa/IwYQ7Ga1x48bYunWrqLb7gwcPMHr0aI0fcPVyMuXKlUOePHkMOl6ZMmVEdRO3b98u2u6PP/7AuHHjkJycnNV2/fp1TJs2DT/++KNBx7IVa9euRceOHfVu5+TkZNI4NHVoumTGU716dQwaNAiNGzfWuX3fvn3xzz//5Dg+IiJL0KhRI7lDoP/P1POPEJH1SUhIQEJCgtxhkIXx8fHBiRMnNK6bPn06Nm3aZOaIrI+mUbyHDx/We43apUsXnetnzJiRq7iIzKlJkyZo3bq1oC0xMRHffvstoqOjTXbcGzduYNq0adi0aZMgh2Zqpp7rQtcI95IlS4ra1BPumYN1czNoNzNZz4Q75Yi3tzdmzJghGpV37tw5LFiwQLS9sfXb1amPcj937hw2bdqEPn36oGPHjhgxYgSGDh2qtZ7bjh07sj70ycnJ2LlzJ+bMmYPbt28bFYc1SEpKwooVK/RuV6NGDZOP4qtWrZpR2+dkkqs5c+YY/Rr6f+zdd1xT1/sH8E/CkqE4ENwLtY466qyjSsXRuhcW0TqoExWttWrRaqWOuhDBPevGVRGtu1pn3TirUifuhYqAiEB+f/gjX5LcJDeQ5Cbweb9evNqce+69j7l4TJ577nOIyJIY+jQQmUatWrVQpEgRqcMgIgvj4uKCsmXLSh0GWSBHR0f0799fcFtISAh27Nhh5oish7bv4erlNYSUL19ecNHJDLpK3RJZop9++kljQuuDBw/QqlUrk+Ssnjx5gmHDhuGPP/5ASEgIli9fbvRzaPPu3TuTHl9Xwl2Iek7MGAn3jBiYcKcsc3R0REhIiEZ5mfXr1yMqKkr5OjExEVevXlXpI6Z+e2YtWrRQeZRToVAgJCQEp0+fxs2bN/HXX3/hzZs3Wvd/8+YN7ty5g0uXLsHPzw9TpkzBhg0b0K9fP5PeNZTCrVu3RN2hnDBhgsljcXBwEJX8z5CVu53qawMQERFlRZs2baQOgYiIrMy3336rteTQpEmT8Mcff5g5Iutw7tw5wXax5SYCAgKwatUqeHh4GDMsIknY2dlh/PjxyJ8/v8a2nj17YuPGjVkucSJk06ZNKmsWbN++3ajHzyD091nfosfZZWjC3RQz3D98+IA//viDCXfKniJFimDWrFkaj31NnToVv//+O8LDwzF27FiVX1Y7OzvUqFHDoPM4Ojoa9EW4cePGGv/4Llq0CP369cO9e/eUbcnJydi3b59BsVg6MR9S+vTpg2LFipkhGhh0rePi4gw+vin+YSAiotzF3t5ebxkzIrIuP/30k1GOw0VTSRcnJyfs379f6/apU6dyxrWao0ePYs6cOdk+TtWqVbF27VojREQkvcKFC2Px4sWCSfeZM2di5MiRRiv9snPnTpXXL1++xOPHj41ybH0MTYgbytAJmaZIuCcmJiI0NJQJd8q+6tWrIygoSKUtNTUV8+bNw6pVq/DPP/+obKtWrVqWSod07txZVL9PPvkEU6dORe3atVXaDx48KPiXJqd9gE5KStLbR8yjesZiY2ODChUqiOorVDt35MiRxg6JiIhIxeeffy56bRkisg5dunQxyudILppK+tjb2+OLL77Qur1nz56Ij483Y0SWKz4+Ht9//73gtlq1ahl8vAIFCgi261o4UV1SUhK/c5JF8PT0REhIiOC2o0ePolGjRjorO4iRnp4umDO6detWto4rdB6h/JspE+7a1tXQRWjR1JiYmGzNxB83bhySkpKYcCfjaNeund7FSzJ8/vnnWTpH+fLl0bBhQ5W2ypUr44cffsA333yDhg0bolu3bli4cCGcnJxE/4N9+/btLMVjqcQs6mTOhDsADBs2TFQiQ+ia6XuygTPciYgou1q0aCF1CERkAn5+ftk+BhdNJTF0JWyTkpLQrFkzvHr1yowRWaa9e/dq3RYeHm6087x9+1Z033379uHIkSNGOzdRdlSvXh3jx4/Xut3b2xsrV6406KZSZg8ePEBycrJG+/3797N0PG20lQs2ZcL9hx9+0Lqtd+/egu3qCffExET069cvW3GcP3/+47GzdRTSKzd9QBs+fLhGQlxdyZIl0a1btyyfY9KkSfDz80Pbtm0REhKC1atXo3v37vjxxx8RFhaG0aNHK5PJhiTcc1LS1hIT7g0bNsSff/6ps8/WrVsFy+G4urpqXYwIYMKdiIiyr06dOlKHQEQmkt2SE1w0lcQoWbIkZs2apbPP3LlzzRSN5Zo+fbpge+vWreHg4GC08xiyNtjChQuNdl4iY2jbti0qV66sdfv8+fMxe/bsLB374cOHgu3GTrhrmyEuNuEeFxeHRYsWYf369Vla60/dd999J9iunoPatWuXqKoRYjDhbmK56QOaXC7Hb7/9hnbt2qF48eKoUqUKvL298e2332L06NGYN28eNm/eDBcXlyyfo0CBAhg5ciR++eUXNGnSRGNF4cxKliypsaCrkPj4eJ2zDRQKBXbs2IGgoCCVxWAtlSUm3IGP9Q179eql0V65cmXs2bMHpUuX1rqvvhJEpli5m4iIcg/1tWiIKOeoVKmS1CFQLlGnTh2d5Yd27tyJly9fmjEiy7Ju3Tqt24YNG5bl4wqVLxWawatNbr4mZJlsbW2xbNky+Pr6au2zadMm1KlTx+CFmbXVajf234PszHBPT09Hu3btsGzZMoSEhKBBgwaiaqoL5Qdbt26NEydOwMnJSXAfsQs1ZwUT7mRUTk5OmDhxIrZv347Vq1dj+vTpGD58OLp164bPP/8ctra2ZotFJpMZpazM0aNHMWnSJOzbtw/BwcHYtWuXsUJUERsba3B5m/DwcDRp0gS9evVS3ql88OCB3v2kSLgDH+sXZiaXyzF//ny4ubnp3M/R0VHn9m+//dYqboYQERERkflt3bo1y/ty0VQSy8XFResM7gzffPONQcngnCI+Pl7rQql58uRB4cKFs3xsoYSZ2PfYWDNZiYzNwcEBo0aNwowZM3T2mzp1qkELnj569Eiw3diVObKTcD958qTGArHnzp3Tu1+5cuU02lq2bAl7e3ut++iaxJtdTLibGD+gSUso4V6lShV88sknKm26Et3qKzj/9ttvRq87tXbtWnTp0gXdunXDzJkzRe1z/vx5rFq1CklJSfj333+xePFiTJ06VefMgQxSLQxXsGBBHDlyBN27d8eXX36JJUuWiEr+N23aVOd2hUKBRYsWGStMIiIiIspBSpcujVKlSmVpXy6aSob4/PPPMWrUKK3bX79+jeDgYDNGZBnWr1+vdZuhM3TVCc18FZtwnzx5crbOTWRqzZo1Q9euXXX2WbRokeibR7GxsYLtxr75lJ2Eu9Ak0m3btundT2iCr42Njc59OMPdivEDmrQ+++wzjbYWLVpo3PnSdlNEoVDg4MGDKm1JSUk6Z7k/ffoUAwcORMuWLbFgwQK9NcbT0tIQGhqq7Ldx40ZRC+qor169a9cu0R9WChUqJKqfKTg5OeGHH37AzJkzUbNmTVH7eHh4oHXr1jr7PHv2zAjRWYbctPYDERERkTkEBgZKHQLlEh07dhQsc5Jh37592LFjhxkjkt6JEycE28PCwuDu7p6tYwsl8MQk3KOiorBv375snZvIHMaOHYv27dtr3f7nn3+iZcuWuHfvnt5j3bx5U7Dd2PmH7NRwF5p1LubPJlQiUt/ispzhTpRFnp6eKF68uPJ1njx50Lp1a426+rdu3YJCocDly5fx77//Ktu1lWdZtWqV1kT60qVLce7cOcTFxWHFihW4fPmyzhhfv36t0Xbt2jWd+wDZq1uu65EaS6VrpkhOk5vWfiAiMife0CTKvfRNgiEyljx58mDx4sU6+0yaNClX/XsklGRbsGABGjZsmO1jCyXUdH2fVigUWLFiRa580oCs1/jx4+Hv7691e3JyMrp06aJzpnpycrLWHFdCQkK2Y8xMW2JdTMJdaFb6jRs3cPfuXZ37Cc1w13e+K1eu6I0nq5hwpxxNLpfjl19+gaenJ0qWLIlJkyahUKFCGjPcb926hYkTJ6Jv377o1asX5s2bBwC4cOGC4HHv3buHW7duYcqUKfj+++8RHR2t3BYZGanS9/fff9cZo9Bsdn2Lt2m7W5iTmfJRHyIiqZUvX17qEHIF3tAkyr30rQlEZEz58uXTWxZzxIgR5gnGAggtWGiszz5CCbWwsDCsWrVKsP/u3buxYMECo5ybyFzkcjkCAgL0rhMxfPhwrTeYb968qXXxUUua4a4t/tWrV+vcTyiPpu9858+f1xtPVjGDRTneZ599hoiICGzbtg3e3t4ANBdTePPmjUqZmLVr1yIxMVFrwh0ABgwYgG3btuHo0aP44YcftA5Q+hawiIuL02hTXyBCXXZmtxtjFoEUclPCnWs/EOU+o0ePljoEIqIcrW7dulnaj0/GUFZNmzZN5/bo6Gg8ffrUTNFIJz09XfB7dcGCBY1yfG1lSsPDw/Hu3TuVtvj4eEyYMMEo5yWSgre3t86Z7tHR0ahbt65K5YYMuvJISUlJRn0STFsNd23tmQnNVAc+loEydD9956tfv77eeLIq92SwKFdTr8tUvHhxnbPIU1NTcePGDVy8eFFrn/j4eJX/P3funODdM301o4QS7vo+1OuKSxcHBwcMHTo0S/tKLTcl3Ln2A1HuU6tWLWzZskXqMHI83tAkyr30LZymDZ+Moayyt7fH999/r7PPuXPnzBSNdDZt2qTRpu9mhCEyJtUJyfw0uUKhwMCBAw0+vtDsfCIpBQQEwMfHR2efESNGaCTQdSXcFQqFxg2q7MjOoqkODg5ZOqfQxNXq1avr3KdVq1ZZOpcYuSeDRZSJjY2N3g/OZ86c0VsjKrO7d+8KJs9NkXDXttCFkHz58mHOnDmYNm0aNm/ejIoVK4re15KYMuEeGxuL2bNnY/Xq1aL+ARDj9evXGDVqlM7FTYiIMitTpozUIeR4vKFJRETm1L59e503eyZMmIBTp06ZMSLzOXXqFGbMmIFZs2ZpbKtXr57RzvPFF19o3ZY5AXflyhX8999/Bh3bz88PEydOzHJsRKYyZswY+Pn5ad0eFxeHBg0a4NGjR8o29fLH6oz5NFd2Eu5iZsGrUygUguVhMq/pKMSU3wuYcKdcq1OnTjq379+/36DjPXr0CC9fvtRo11dvXaiGu74FK54/fy46rtWrV+OLL75AixYtUKxYMdH7WRpTJdyTk5PRq1cvbNiwAWFhYZg7d65Rjrtu3Tr8/fffKv/AEREREZF14ZMxlB158+bFoUOHkCdPHq19hgwZgpMnT5oxKtPbsGEDhgwZIji7HQBcXV2Ndi65XI4ffvhBcFtGwv3p06fo27evQcedMGECRowYoTOhTySlkSNHYvbs2Vq3p6amon379khPT9db/xwwbsI9OzXcs5Jwv3z5skZb165d9e5nyomdTLhTruXj44OZM2fis88+E9xuyOx24OMsaaGE+8uXL3XWwhKa4a5rZWkAePHihei4jFUbT2piBkJ99fKFREZGqtzg2LBhg/L/37x5g/379xv0REGGlStXGrxPBtYKJSIiIrIMfDKGssvJyQlBQUE6+wwdOlTrYobWSFcS0BQLxWsrQXHp0iU8ffoUbdq0Meh4ixcvRvv27SGXy2Fvb2+MEIlMomnTpoiKikKlSpW09hk6dCh+//13vceylBnuWak6sHDhQo02oVybOibciUzkyy+/xNKlS7F79+5sL55y+vRprFixQqM9JSVFpd773r17MXz4cMyfPx/v378XnOGub6ATm3AvVKgQHB0dRfW1dGIGwh07dhh83Hv37gm2v3nzBr6+vvjpp5/Qo0cPHD9+3OBjZxVrhRIRERER5RytW7fWW2oyJCTETNGYlr5kWWBgoNHPWatWLcH2GTNm4OjRowYd6+uvv0bt2rWNERaRWRQrVgxr167F1KlTBbefPn1aJSeVQX1ypjUn3IWqQGhbfDUzJtyJTKxw4cJo0aKFxuKqmZUsWVLvcS5duiTY/uzZMwDAjRs3MG7cOBw/fhwrV67E2rVrDa7hHhcXJzhYChk8eLDOP1NOoz5YpqamIjg4GPXq1UOPHj0MKu+ydu1a5aCdlpaGX3/9VaPP/fv34evri3r16qF3796IiorC06dPs/eHICIiIiKiHEdfSZOIiAidT0ZbC6HSDpnZ2dkZ/Zy6ZqEfOXLEoGPVrVs3u+EQSaJFixbo1auXqL4TJkzQeHpLX2ljQ2grKSOmXExWSsoIVTsQs/hqVhdUF4MJd6L/5+joqHPBuuzc5c5I3KrXsFu4cKFgGRpdA92YMWNEnXPv3r3o2LGj+CCtgL7ZEOqD5ZkzZxAVFYX09HTcuHEDa9euFXUehUKBrVu3qrS9ePECv/32m8pAvmbNGty8eRPp6em4evUqgoOD4evri9OnT4v8EwljrVAiIiIiopylZMmSeusoL1myxEzRmI6+8qjlypUz+jl1zWR9+/atQcfy8vLKZjRE0pDJZAgMDBRVr/2rr77SSLhPnjzZoPUCdTHnoqmJiYkqCyRnEFMOjjPcicxEV92rGjVqZPm4GTPco6OjNbY9efJEo+358+dYsmQJ5syZg5MnT+LgwYNISkpCenq64DGEFCpUKMvxWip9C9a8efNG5f0cNmyYyvZNmzbhyJEjaNGiBZo1a4Z9+/YJziKpW7eu4FMEW7ZsQbt27XDo0CEAwB9//KHR5+3btwgICBD159GGtUKJiIiIiHKeKlWq4JtvvtG6fenSpYIlR63Jw4cPtW5r27atSb6n6kq465txn9n333+PfPnyGSMkIslUqVJF55Mdbm5usLe318g5xMfH46effjLKkzbakuZiqjUYmnBXnyyZoV27dnr3ZcKdyEx0JdxLlSqV5eNmlBkRSqIKDWaXL1/GkiVLsG7dOgwdOhSjR49G586dcevWLY2+Tk5OGm05ZaFUdWXKlNE5I2Lt2rVo164dli1bhr/++kuwz8iRI/Hq1SvEx8cjKCgIW7ZsMTiOMWPG4MKFCwbvR0REREREuduoUaNQuXJlrdvFPpVrqWbMmKHR1qFDByxZsgQTJ040yTmNUaYmJCQEPXr0MEI0RNJzcnJCaGio4LbPP/8cgHB+6sKFC7hx40a2z68taR4bG6t3XQVts+A9PDwE27XlZj755BOd5wFYUobIbHTNYi9atGiWj3v37l0AEHzMRawXL15gxIgRGu2zZs3SmGnt6+ub5fNYMplMhvDwcJ19FAoFFi1aJLr0Tlakp6ejX79+Jjs+ERERERHlTDKZDHPnztW6fdWqVXjx4oUZIzKeEydOaLS5uLjg559/Rq1atUy2vpgxEu5NmjQxQiRElqNx48bw9/dXaZPL5fDx8QHw8e+mkPPnz2f73NpquAPAnDlzdO6rLVmvbea9UJ6tc+fOOs+RgTPcicykSpUqgo+Q2dnZwc3NDd26dVNp79Kli6hHzm7dugWFQiFYPsYQ6gtyVqpUCfXq1UOpUqWwcOFCtG3bFiNGjEDv3r2zdR5Lpu2uJhERERERkTUoWLCgzjrLO3fuNGM0xhETEyO45pbYxFd2ZDfh/u233xopEiLLEhAQgNWrV6NTp07w9vbGrFmzULVqVQDC1RIAGGU9OV212mNjY3WWjdG277Nnz3Dw4EGNdqFKELoS/pllZYb7ggULRPXTXuiKKBeSy+WoV68eDhw4oNJetGhRyOVydO/eHUePHsXjx4/xySefYPjw4QgMDETTpk11HvfevXt49eqV3gVkDJX5UcS6detyRfUcIjExEYmJiVKHQUREREREJpJRZ9nLywvp6ekq2+bNm4d27dpZ1bpcfn5+gu3du3c3+bmzM0vV3t7eLDESSaVKlSqoUqWKRru2deNu376d7XPqS3g/f/4cxYoVE9ymKxk/evRoLF++HDVq1MDbt2+xe/duwSeCtI1H6sSOHQcPHsTz589RqlQp0Tf4OMOdSE1GPavMihQpAuDjyvJbtmzB9u3bsWbNGjg5OcHZ2RktW7bUecy0tDScOnXK6LF26NDB6Mck6bm4uKBs2bJSh0FERERERCbk5OSEkydPCm7buHGjmaPJOl01nwsXLmzy82e1VE3Dhg1x4sQJuLu7GzkiIsunK+Ge3YVT9SXcda2Jl1GSWZuVK1ciPT0dvXv3FlwzAgAqVqyoL0QA4hPu+fLlg6enp0FP0zDhTqSmQYMGGm2vX79W/r+DgwOKFy+u8hczIyGvy/Hjx40SXwZPT098+umnRj0mERFJa+DAgVKHQERERGYkl8uxdOlSjfbIyEjEx8dLEJFh0tPT8eeffwpuW7lypZmjEWflypVYtmyZ1kUliXIDR0dHwfa3b99mex2JhIQEndvnzZundVt0dLTOfY8dO4Zz584hNjY2S7FlJibh3rp1a402MaWyWFKGSI1QjXAvLy+d+4hJuO/Zs0fltbOzMzw8PLL8uM4XX3yRpf3I8iUkJOD58+ec5U6UC/Xr1w9lypSROgwiIiIyo5o1a0Iul6uUlomLi0OzZs2wc+dOUd83pfD06VMMHjxYMPG1aNEiVKtWTYKodPvxxx8tMi4ic3v+/LnWbQ8ePMjW0yn6bhY+e/Ysy8fOnz8/xo8fn+X9MxOTcB8xYoRGm4ODg/5jZyUgopxO/S9U8+bNdfYX+gBUsmRJnfu0adMGmzZtwsqVK/Hzzz9rXSFaG2OsxE6WydnZWevjXUSUs8lkMrRo0ULqMIiI6P9xbR0yB5lMhmPHjglua9u2LR4/fmzmiMRZv369YLLd398fderUMWss5cqVE9Xvq6++MnEkRNahZs2aWrf1798/W2sQmvLpnNevX+Ply5datxtyg1Lfoqn9+/dHwYIFRR8vMybciQR0794do0aNQvv27TFv3jy9/3i7ublptA0ePFjnPhmla6pVq4YOHTrgk08+MSjG+vXrG9SfiIiIiIgMw7V1yFzs7e2xYcMGwW3t2rWzyPIy69atE2yvUKGCmSP5OGlOzKQle3t7M0RDZPnq168vmMvKkJ1Z5JnLMpvbuHHjRPfVN8NdX0Je57GzvCdRDmZjYwNfX19MmDBBcBFVdRUqVFAZqMqVK4cWLVqgVq1agv3t7OxQu3ZtlTahUjbayGQyVK9eXXR/IiIiIiIismwVKlRAcHCw4LZmzZrhyZMnZo5IO101nj09Pc0YyUcNGzbEnj17ULlyZa197OzstNatJsptHBwcsHbtWowcOVJw4eAjR46gcePGWarnLuYGodDCrNldrBUQXpdRG30JdVtb4Ursmct/acOEu4nxEcTcwc7ODjNmzEDt2rXRoEEDTJkyBTKZDAMHDhRcMb1WrVpwcnJSaTPkMZXNmzeLXk2ZiIiIiIiy5unTp7h69arUYVAu0rp1a7Rv315wW9u2bZGSkmLmiDRdv35dZ2kWqZ4KcXR0xLx581C1alVlW5MmTeDk5ISqVati/fr1ksRFZKnc3Nzg5+entUJDcnIyBg8ejH379uHgwYN4//693mMmJyeLmuGelpam0Zbd8W3GjBkG9c/qDHcxNwa4aKqJGVqXm6xX9erVsXjxYpW22rVrY9asWdi4cSNOnz4NAHB1dcWQIUM09i9evLhGW+/evbFq1SqNdqG7j0REREREZFyGPIVKZCwTJkzAnj17BJNPJ06cgJeXl/mDymTq1Klat61fv15w0pm5uLq6Cn6HJiLtPv/8czg4OAgm1O/cuYOgoCAAH28IansKJ8O2bdtEnfPDhw8aM8iF1oQQa9GiRQavHZHVhHvmm3paj21QJERksKZNm2LBggU4ffo0/vjjD0RFRaFKlSoa/dRLzNSvXx9Dhw4VPCYfgyMiIiIiIsq5Jk6cKNg+atQo5Sz4kydPmiWW9PR0rFmzBl26dEGdOnXw77//CvYLDAxExYoVzRITERlP4cKF9SbSAWDXrl24fPmyzj4hISGizvnhwweV12/evEH37t1F7avu7NmzWVqoOaslZVq2bKn32Ey4m1hCQgLu3LkjdRhkAeRyOUqVKqV1IZdy5cph1KhRKFGiBBo1aqQsS9OkSROVfh4eHpLOGCDTYykqIiIiIqLcrXnz5lq3PXv2DI8ePcKUKVNE1RLOrmPHjmHu3Lm4d++ezn69evUyeSxEZBre3t7Yt2+f3gmeffv2xd27d7VuL126tKjzHTx4UKU0y+zZs0Xtp27EiBFZ2g+A3tyatoS7nZ0d9u3bh3z58mndlwl3E3N2dha1UjYRAPj6+iIyMhJz585F/vz5AXycwZC5NJHUjw+S6bm4uEhW95CIiIiIiKRnY2Ojd6bo48ePRdVKzq7Jkyfr7SN2VisRWa6CBQti69ataNiwoc5+Xbt21Tq5uFq1aqLONXnyZJWa67t27RIfaCZZnRUPZH2GO/DxvTp48KDW7Uy4E1m4YsWKYf78+ejUqRP69+8vWP+diIiIiIiMj4umkpQaN26st4+pyso8e/YMkyZNQlBQEOLi4vT2V38ym4isk7u7O8LCwvSuSenj44M///wTiYmJePXqlbJdvQ68v78/Ro8eLXiMzZs3a5SWMUSNGjX0Js110VfDXUxs2ha5ZsKdyApUrVoV48aNw8CBA+Hk5CR1OGRiLEVFREREZBk8PDxELY5GZApyuVzvzPEJEyaY5NxjxozBjh07sG/fPpMcn4gs28yZM/UmsydOnIimTZuiRYsWaN26NdLT0/Hu3TuVPnny5EHXrl21HiNzsl6Ivb291m0Zi7lmlb4/3/379/Ueo1+/foLtTLgTEVkYlqIiIiIiIiIAeks7AMD27duRkJBgtHO+e/dO78KImXl4eBjt3ERkGerWrYs//vgDoaGhmDp1qt7+z549Q7169XD06FGV9jx58uicSf7kyROVWu7qVq9ejU8//VSlzd7eHnPnzoWnp6feuHTRN8NdzITXYsWKYefOnejRo4dKu/ZiNEREuZCdnV22HmkiIiIiopwjISEBz58/5/o6JBlbW1ts2bJF5wzRX3/9FYsXL8bq1avh5uaW7XMmJSUZ1F9XbERkvYoXL47ixYsjPj4+y8fIkyePzu3+/v46t5cvXx6///470tPTkZ6errOuuqH0JdzT0tJEHadIkSL4/vvvsW7duv8dO1uRERFJIG/evCY79q5du3Dw4EH89ttvJjsHERERERGRWGXKlNHb59mzZ/Dz89Oon5wV+hLuTk5O+OGHH1CzZk34+fnBz88v2+ckIsuVL18+1K5dO0v76ku46+Lj46P8f7lcbtRkO6C/pIzYhLsQJtyJyOpMmjQJMpkMAODo6Gi04wYEBKBAgQLIly8fmjdvbrTjEhEREZF1cnFx4ex2sgjz58/X2ycuLg7dunXL9rnUazCrW7RoEbp3745ly5Zh5MiRcHBwyPY5iciyzZ8/H7169TJ4XZOMhHtGDscQgwYNMngfQ+ib4Z6enp71Y2d5TyIiiTRp0gRLly7FqFGjsG7dOkyaNCnLx2rZsiW8vb0REBCA3r17GzFKIiIiIiIi46hXrx5GjBihN0H08OFDLFy4MEvnePPmDY4dO6Z3ocAqVapk6fhEZL1sbW0RGBiIVatW4cyZMxg/fryo/TIS7osXLzbofLt374arq6vBcRpC3wz3Tp06ZfnYrOFORFapZs2aqFmzJgCgcOHCmDhxYpaOM3nyZL0fWomIiIgod2INd7IUMpkMPXv2RM+ePVGnTh2dfZcvX47BgwcbdPyHDx+iQ4cOevs1adLEoOMSUc4jk8nQsWNHtG7dWu/CzhlVCWrVqoV9+/ahZcuWeo9fsWJFFC5c2Cix6qJv1n3JkiWzfGxmmYjI6jk6OuLIkSNZ2ldXsv2nn35SbldfFZuIiIiIiEgKBQoU0NunQ4cOeP36tehjLliwQFQ/Y5SsIaKcwd7eXu+iyZlruBcsWBBffvml3uP+9NNP2Y5NDF0J96wsQD1ixAjl/zPhTkQ5gpOTE0JDQ416zC5dumDbtm2IiIjAypUrjXpsXRITE5GYmGi28xERERGRMNZwJ0sUGBiot8/Dhw/RvHlzlRrE6enpiIqKQlhYGG7evAngYxmZoKAg7N27V+8xBw8ejM8//zzrgRNRjvPdd9+hbt26sLe319hma2uLYsWKqbRlXghVSJcuXVCtWjWjxpgVwcHBBu/To0cPTJgwAb169WJJGSLKORo3bozDhw+jRYsWSElJ0du/QYMGevsUL17cGKEZxMXFxeznJCIiIiIi69CuXTu4uLjgxx9/1Nv33LlzqFu3LgBg3bp1mDt3LgBg9erVqFKlCu7evYukpCS9x8mXLx+6d++evcCJKMcpXLiwct2ItLQ0jB8/Hvv374dcLsfAgQM16rBnrEehPmGyXr16GDRokEUk24GP8RhKJpOhffv2ADjDnYhyGGdnZ8ybNw+NGjXS2c/d3d3guoamXiGbiIiIiCxLQkIC7ty5I3UYRBq+/PJLzJgxQ2+/wYMHo2/fvrh8+bIy2Z7h33//FZVs9/Pzw/r16+Hk5JTleIko57OxscG0adNw4sQJHDx4EH379hXsV7VqVY220NBQVK9eXW9ddXPQt06GGEy4E1GOU6tWLcydOxdjxozR2icyMhJVqlQx6LjfffcdfvnlF8FtJ0+eNNoK2vxiR0RkGizZRUSGcnZ2hrOzs9RhEAlq1qwZzp49i6FDh+rsd/nyZa2JL306deqEkSNHokiRIlnan4hyH3t7e51P7levXh3u7u7K1y1atBAsSSMVXbkksZhwJ6IcS9tdSUdHxywN5jKZDG3bthXcZmtri2nTpqFy5cqoXr26wcfOjF/siIhMg7WYiYgoJ+rduzd+/vlnox+3UKFCKosAEhEZg42NDZYtWwZfX1/0798f48aNkzokJVdXV6N8X2ANdyLKscqWLYuWLVti3759yjY7Ozuts9Szq169elizZg2AjzPoJ0+ebJLzEBEREZF58MkYsgYymQwdOnRAgQIFMGXKFLx8+TLLx6pTpw569OiB5ORk1K9fnxOBiMgkihUrhlGjRkkdhgZjzbRnwp2IcrQpU6agV69ecHJyQmJiIvLnz4+iRYua/LwdO3ZEs2bNkJ6ebvJzERGROAkJCXj+/DlnuRORaFzMnqxJkyZN0KRJkyzXH27dujWCg4ONHBURkfUwVg15lpQhohxNJpOhUqVKKFWqFCpXrmyWZHuGfPnyIX/+/GY7HxER6caSXURElBtktf5w69atjRwJEZF1sbFRXJcJAAEAAElEQVSxMcpxmHAnIsqmatWqSR0CEREREZkAF7Mna+Tj44MpU6bA1dXVoP1q1aplooiIiKyDXG6cVDkT7kRE2VSjRg2pQyAiIhFYi5mIDMUnY8hatWrVCn/99ZfgtkqVKmm0eXl5Ga12MRGRtapcubJRjsOEOxGRgfz9/ZX/b2tri969e0sYDRERieXi4sL67URElKuMHj1a5XVERATWrl2LsLAwlfagoCBzhkVEZBFGjBih/H+ZTIYhQ4YY5bhcNJWIyEADBgyAk5MT7t+/jy5duqBAgQJSh0RERERERKSha9euAIBr166hZcuWKF++PACgYcOGOHv2rJShERFJzs/PD3K5HDdv3kSbNm1QsmRJoxyXCXciIgPZ2tqiT58+UodBREQGSkhIwPPnzznLnYiIcg25XI5u3bpJHQYRkUWSy+Xw8/Mz+nGZcCcisjCsMUxEZBrOzs5ISkqSOgwisiL8XEZERESGYsKdiMjCuLi4SB0CEREREYGfy4iIiMhwXDSViIiIiHIFzlQlIiIiIiJTY8KdiMjCJCQk4M6dO1KHQUSU47i4uLB+OxEZhJ/LiIiIyFAsKUNEZGFYY5iIiIjIMvBzGRERERmKCXczSE9P12h78eKFBJEQkZQKFSoEuVzcg0UcN4gIMGzcIP0SEhLw9OlTeHp6qrRzfCXKXQwdW/m5jIgAfp8jIvGYcDeDuLg4jbYqVapIEAkRSenZs2coXLiwqL4cN4gIMGzcIP2cnZ3x/v17jXaOr0S5i6FjKz+XERHA73NEJB6nTBERERERERERERERGQET7mYgdGeTiEgXjhtERKbB8ZWIDMVxg4gMxXGDKHdjwp2IiIiIiIiIiIiIyAhYw90MypUrp9F25coVuLu7m/S8iYmJKFu2LADgzp07cHZ2NvkxxPbX10/bdkPaM7edPXsWderUUTnHv//+Czc3NxHvQvZY6nXI6jXQtk1M27t37zTq1pnjOkhxDYT2KVSokOjzWfO4kZXjmPJ3NqvjRm77nTXG+J2VbZY6flvK3wVDxg0Sx5rHV/69zh5L+XvNz2XS/10wdGzNTeOG2H34fc60x5Bi/Oa4oX8fa/g+B1ju7yz/rTPtMZiP0yTpdVCQyT179kwBQOXn2bNnJj9vQkKC8nwJCQlmOYbY/vr6adtuSHvmtjt37khyDXTFbMpjiOmf1WugbZuYttz0dyG757Xm9yorxzHl72xWx43c9jtrjPE7K9ssdfy25L8LlD38e21YP/69zv5x+LnMsD+rKY6R3XPmpvdK7D78PmfaY0gxfnPcMO55pXqvFArL/Z3lv3WmPYYxxg1d2zl+G3YdZAqFQgEyqefPn2vcxTRkdWvKPl4Dy8DrIB7fK8vA6yA9XgMyNv5OSY/XwDLwOojH90p6vAaWgddBPL5XloHXQXq59RqwhjsRERERERERERERkREw4U5EREREREREREREZARMuBMRERERERERERERGQFruBMRERERERERERERGQFnuBMRERERERERERERGQET7kRERERERERERERERsCEOxERERERERERERGRETDhTkRERERERERERERkBEy4ExEREREREREREREZARPuRERERERERERERERGwIQ7EREREREREREREZERMOFORERERERERERERGQETLgTERERERERERERERkBE+5EREREREREREREREbAhDsRERERERERERERkREw4U5EREREREREREREZARMuBMRERERERERERERGQET7hYmNTUVI0eOhLu7O1xdXTFw4EAkJSVJHVauplAo8NVXXyE0NFTqUHKVp0+f4ttvv4WHhwfc3Nzg4+ODhw8fSh2WxeLYYVk4bkiHYwcZE8dWy8PxVRocW8XjuGF5OG5Ih2OHeBw7LAvHDenklHGDCXcLM378eERGRuKPP/7Arl27cOjQIXz//fdSh5VrpaamYuDAgdi7d6/UoeQ6Xbt2xb1797Br1y4cPHgQb968Qbt27ZCamip1aBaJY4fl4LghLY4dZEwcWy0Lx1fpcGwVj+OGZeG4IS2OHeJx7LAcHDeklWPGDQVZjHfv3imcnZ0VW7ZsUbYdPHhQYWtrq3j58qWEkeVOV69eVdStW1dRpkwZRf78+RVz5syROqRc4/r16woAiuvXryvbHjx4oACgOHv2rISRWSaOHZaD44a0OHaQMXFstSwcX6XDsVU8jhuWheOGtDh2iMexw3Jw3JBWTho3OMPdgly4cAGJiYlo2rSpsq1x48ZQKBQ4deqUhJHlTkeOHEGDBg0QHR0NV1dXqcPJVTw8PLBz505UqFBBY9u7d+8kiMiyceywHBw3pMWxg4yJY6tl4fgqHY6t4nHcsCwcN6TFsUM8jh2Wg+OGtHLSuGErdQD0Pw8fPoSDgwPc3NyUbXZ2dihUqBAePHggYWS506BBg6QOIdfKnz8/2rRpo9I2e/ZsuLi4oGbNmtIEZcE4dlgOjhvS4thBxsSx1bJwfJUOx1bxOG5YFo4b0uLYIR7HDsvBcUNaOWncYMLdgiQlJcHBwUGj3cHBAe/fv5cgIiLLsGbNGoSGhmLu3LlwcXGROhyLw7GDSBjHDsoOjq1Ewji2asdxg0g7jh3acewgEmbN4wZLylgQR0dHwcH0/fv3cHJykiAiIuktXLgQffr0wciRIzFs2DCpw7FIHDuINHHsoOzi2EqkiWOrbhw3iIRx7NCNYweRJmsfN5hwtyAlSpTA+/fv8erVK2Xbhw8f8PLlSxQvXlzCyIikERwcjICAAAQFBWHWrFlSh2OxOHYQqeLYQcbAsZVIFcdW/ThuEGni2KEfxw4iVTlh3GDC3YLUqFEDzs7OOHz4sLLt2LFjkMvlqFu3roSREZlfSEgIJk6ciJkzZ+LXX3+VOhyLxrGD6H84dpCxcGwl+h+OreJw3CBSxbFDHI4dRP+TU8YN1nC3II6OjhgwYAACAwPh6uoKBwcHDBw4EH379kXBggWlDo/IbGJiYjB27FgMGDAAPXv2xJMnT5TbChQoIFjfLjfj2EH0EccOMiaOrUQfcWwVj+MG0f9w7BCPYwfRRzlp3OAMdyPx9fVFiRIltG5fuXIlatWqBRcXF7i7u6Nnz564d++eRr/ffvsN7du3R+fOndG2bVt4eXlh7ty5pgw9xzHWtaCsMcb7v2XLFnz48AFLlixB0aJFVX52795t6j+CWXHssAwcN6THsYOMiWOr5eD4Ki2OreJx3LAcHDekx7FDPI4dloHjhvQ4bqhRULZNmTJFAUBRvHhxwe1jxoxRAFBUqVJFMXr0aIWvr6/CxsZG4ebmprh9+7aZo83ZeC2kxfffMHy/LAOvg/R4DciY+PtkOXgtpMX3Xzy+V5aD10J6vAbi8b2yDLwO0uM10MSEeza8e/dOMXDgQAUArb9Y0dHRCgCKxo0bK96/f69s37ZtmwKAol27duYMOcfitZAW33/D8P2yDLwO0uM1IGPi75Pl4LWQFt9/8fheWQ5eC+nxGojH98oy8DpIj9dAOybcsygqKkpRpkwZBQBF69attf5i9evXTwFAsX//fo1tXl5eCplMpnjw4IE5Qs6xeC2kxfffMHy/LAOvg/R4DciY+PtkOXgtpMX3Xzy+V5aD10J6vAbi8b2yDLwO0uM10I013LNo+fLlePv2LRYsWICdO3dq7Xf06FHY2tqiSZMmGtu8vb2hUChw6NAhU4aa4/FaSIvvv2H4flkGXgfp8RqQMfH3yXLwWkiL7794fK8sB6+F9HgNxON7ZRl4HaTHa6CbrdQBWKsRI0ZgzZo1yJs3r9Y+aWlpiImJQZkyZWBvb6+x3dPTEwBw/fp1k8WZG/BaSIvvv2H4flkGXgfp8RqQMfH3yXLwWkiL7794fK8sB6+F9HgNxON7ZRl4HaTHa6AbE+5Z5OXlpbdPfHw8FAoFChYsKLg9f/78AIDXr18bL7BciNdCWnz/DcP3yzLwOkiP14CMib9PloPXQlp8/8Xje2U5eC2kx2sgHt8ry8DrID1eA91YUsaEEhISAAAODg6C2zPak5OTzRZTbsVrIS2+/4bh+2UZeB2kx2tAxsTfJ8vBayEtvv/i8b2yHLwW0uM1EI/vlWXgdZBebr4GTLibUJ48eQAAKSkpgtvfv38PAHBxcTFbTLkVr4W0+P4bhu+XZeB1kB6vARkTf58sB6+FtPj+i8f3ynLwWkiP10A8vleWgddBern5GjDhbkKurq6Qy+VaH43IaHd1dTVfULkUr4W0+P4bhu+XZeB1kB6vARkTf58sB6+FtPj+i8f3ynLwWkiP10A8vleWgddBern5GjDhbkL29vbw9PREbGwsPnz4oLH91q1bAIAqVaqYO7Rch9dCWnz/DcP3yzLwOkiP14CMib9PloPXQlp8/8Xje2U5eC2kx2sgHt8ry8DrIL3cfA2YcDexpk2bIiUlBcePH9fYduDAAchkMjRq1EiCyHIfXgtp8f03DN8vy8DrID1eAzIm/j5ZDl4LafH9F4/vleXgtZAer4F4fK8sA6+D9HLtNVCQUQBQFC9eXKP9xIkTCgCKBg0aKJKSkpTt27ZtUwBQdOjQwYxR5g68FtLi+28Yvl+WgddBerwGZEz8fbIcvBbS4vsvHt8ry8FrIT1eA/H4XlkGXgfp8RqoYsLdSLT9YikUCsWQIUMUABQVKlRQ/Pjjj4ru3bsrbGxsFB4eHopbt26ZOdKcj9dCWnz/DcP3yzLwOkiP14CMib9PloPXQlp8/8Xje2U5eC2kx2sgHt8ry8DrID1eA1VMuBuJrl+s9PR0RXh4uOLTTz9VODg4KIoVK6bo0aNHjv2lkhqvhbT4/huG75dl4HWQHq8BGRN/nywHr4W0+P6Lx/fKcvBaSI/XQDy+V5aB10F6vAaqZAqFQiG2/AwREREREREREREREQnjoqlEREREREREREREREbAhDsRERERERERERERkREw4U5EREREREREREREZARMuBMRERERERERERERGYGt1AFYgqdPn2LUqFHYt28f0tLS8OWXXyI0NBTFixc3yvHT09Px8uVLlbZChQpBLuf9DiISxnGDiMg0OL4SkaE4bhCRoThuEOVuMoVCoZA6CKl98cUXkMlkmDNnDuzs7DBq1Ci8ePECp0+fhq1t9u9JPH/+HO7u7iptz549Q+HChbN9bCLKmThuEBGZBsdXIjIUxw0iMhTHDaLcLdfPcL9x4waOHTuG69ev45NPPgEArFy5EiVKlMDFixdRu3ZtiSMkIiIiIiIiIiIiImuQ659l8fDwwM6dO1GhQgWNbe/evZMgIiIiIiIiIiIiIiKyRrl+hnv+/PnRpk0blbbZs2fDxcUFNWvWlCYoIiIiIiIiIiIiIrI6OX6G+82bNyGTyQR/vLy8NPqvWbMGoaGhmDp1KlxcXMwfMBERERERERERERFZpRw/w7106dK4du2a4DYnJyeV1wsXLsTQoUMxcuRIDBs2zBzhEREREREREREREVEOkeMT7nZ2dqhUqZLefsHBwZg4cSLGjx+PX3/91QyREREREREREREREVFOkuMT7mKEhIRg4sSJmDlzJkaNGiV1OERERERERERERERkhXJ9wj0mJgZjx47FgAED0LNnTzx58kS5rUCBAnBwcJAwOiLKjRITE5GYmCh1GEREREREREREZCCNRVP37NmD5s2bw9XVFfnz50eDBg2wefNmswfm6+uLEiVK6OyzcuVK1KpVCy4uLnB3d0fPnj1x7949g86zZcsWfPjwAUuWLEHRokVVfnbv3p2dPwIRUZa4uLigbNmyUodBREREREREREQGUkm4h4WF4euvv8bly5fx7bffws/PD7du3UK3bt0we/ZsswU1depUbNy4UWefsWPHwt/fH+/fv8eQIUPg7e2NiIgI1KlTB3fu3BF9rqCgICgUCsGfjh07ZvNPQkRERERERERElLOlpaVBoVBIHQaRRVAm3K9evYpRo0ahSpUquHz5MubNm4cFCxbgypUr8PDwQFBQEN6+fWvSYJKTkzFo0CCMGzdOZ78LFy5g+vTpaNy4MaKjozF9+nRs2LABW7ZswYsXLzB8+HCTxmkIloYgU1EoFJgzZw4aNWoEPz8/xMbGSh0SGUlCQoJBNw6JsiIuLg4DBw5Ew4YN8fPPP+Pdu3dSh0REREREFubff/9Fx44d0ahRI6xYsULqcMgCPX78GFOmTIGXlxdatGiB0NBQPHr0SOqwiCSlTLiHhYXhw4cPWLx4Mdzd3ZUd3N3dMXXqVPTp0wdPnz7VeqB169bh3LlzGu0PHjxAeHi43kB27NiBypUrY/HixWjdurXOvvPnzwcATJw4Efb29sr2jh07wsvLCzt37sTDhw/1ntMcWBqCTOXKlStYt24d3r9/j5iYGCxbtkzqkMhInJ2d4ezsLHUYlMNFRETg3LlzSElJwe7duxEaGip1SERERERkYWbPno0HDx7g/fv3WLBgAe7evSt1SGQhnjx5gqlTp6JTp07Ytm0b3r17h9evX2Pt2rXo2LEjxowZg0uXLnHWO+VKyoT7zp07UaxYMTRu3Fijk7+/PxYvXozy5csLHiQ2Nhb+/v5o3ry5StL9/v378PLyQmBgII4dO6YzkOXLl+Pt27dYsGABdu7cqbPv0aNHYWtriyZNmmhs8/b2hkKhwKFDh3Qeg8jaLVmyROX1rl27JIqEiKzRjRs3VF5v3boVKSkpEkVDJC0mD4iIiDTFxcXh4sWLKm2TJk2SKBrrkdMrHTx58gTTpk1Dx44d8ccffyA1NVWjT3p6Ov766y/4+/ujb9++Gr9HRDmdHABevHiBR48eoWrVqnj8+DH69euHIkWKwNHREfXq1UNkZKTOg5QqVQqrVq3C27dvlUn3jGT7rVu3MG3aNMFEfmYjRozAnTt3MHjwYMhkMq390tLSEBMTg5IlS6rMbs/g6ekJALh+/bq+P7tZsDQEmUp8fLzUIRCRFRP6t8nUpeOILNXKlSulDoGIiMjiCFUxuHz5sgSRWJecXOlg9+7d6Ny5M7Zu3SqYaBdy5coVfPfdd5g2bRq/b1CuYQtAWX4lPj4etWrVgpOTE3x8fPDmzRts27YNnTp1QlhYGIYNG6b1QL6+vgCAnj17onnz5sifPz/u3r2LadOmYezYsXoD8fLyEhVwfHw8FAoFChYsKLg9f/78AIDXr1+LOp6pOTs7IykpSeowKAdKS0uTOgQismI2NjYabZzhTrnV8ePHcfnyZVSrVk3qUIiIiCzG7du3BdvT09Mhl8sFt1HOtXHjRsycOVNwm729PTp37gyFQoGoqCjB9aG2bt2Kv//+W7nu4sWLF3HhwgW8fv0azZs3x4gRI2BnZ2fSPwORudgCH2dhA8CpU6fQrFkzREVFKesHX79+HfXr18cPP/yA9u3bo3Tp0loP5uvriydPnuD777/H69evERAQICrZboiMWB0cHAS3Z7QnJycb9bxElkbs3WQiIiFCyfUPHz5IEAmRZQgPD8fixYt1PmlJRESUW5w6dQpLly4V3BYfH6+c7EiaEhIS8Pz58xwzy12hUGDp0qUaZW2B/yXae/fujcKFCwMABg0ahO3btyMiIgJPnjxR6f/y5UtMmDBB4zgbN27E06dP8dtvv8HW1tY0fxAiM5IDqrPcwsPDVRbrq1SpEgIDA/Hhwwds3rxZ58FiY2MRFhb28cByOdatW4dTp04ZNeA8efIA0D4L7/379wA+PsJDlJMJJdw5652IxGLCnUjV+fPn8c8//0gdBhERkUWYPXu21m1v3rwxYyTWx9nZWSWvZs3S09Mxe/ZswWR7+/btERkZiVGjRimT7QCQN29e9OzZE9u3b8fIkSOVeTx9/v77b4wfP555DcoR5ADg6uoK4OOgULlyZY1OtWvXBgDcunVL64Hu3bsHLy8v3LlzB7/99hsiIiKQmJiIli1b4uTJk0YL2NXVFXK5XGvJmIz2jD8TUU4l9I8QyxcRkVhCCzmxpAzldvPmzUN6errUYRAREUlOWzkZgN87c4vU1FT88ssviIiI0NgWEBCAn3/+Ge7u7lr3t7GxgZ+fHzZv3oxGjRqJOueBAwcwceJEfh4jqycHPi40amtri9TUVCgUCo1OGTPenJycBA/y6NEjZbJ9+vTpGDNmDHx8fLB+/XokJSWhVatWgottZIW9vT08PT0RGxsrOBMv46ZAlSpVjHI+IkslNMOdH3yISIzU1FTOcCcSEBMTg/3790sdBhERkUXjZ8ac7/379xg9ejR27dql0i6TyTB27Fj4+/uLLsNXtGhRhIaGYtq0acoEff78+dG0aVP069dPYwb8nj17MG3aNMH8JPBx1v39+/eZlCeLZgt8TGI3aNAAR48exZEjRzQWMM0oC1OjRg3Bg7i5uaFGjRoICAjAjz/+qGz38fEBAISGhsLT09NoQTdt2hTLli3D8ePHNWI9cOAAZDKZ6LtnRNZKKOEuNGOVrE9iYiKvJZmUtptznOFOBCxYsADNmjXjol1ERERaMOGe88TFxeHq1au4cuUKrl69iqtXr+Lt27cqfWxsbPDrr7+iZcuWBh9fJpOhRYsW8Pb2xps3b5A/f35lwr527doYPny4yneRbdu2oVq1amjfvr3KcQ4ePIhZs2bh2bNnKF68OKZMmYJPP/00C39iItNSrkQQEBCAo0ePYuTIkTh06JCyJMulS5ewcOFCFCpUCJ06dRI8iL29PbZt2yZ4d8vHxwddu3Y16gJU/v7+WLZsGYKCgvDXX3/B0dERABAZGYnDhw+jQ4cOKFGihNHOR2SJhBKyQiuBk/XhGhRkahkLkKtjwp0IePjwISIjI5UTR4iIiEgVPzNav8TERPz555+4cOECrly5gkePHuns7+DggBkzZmR7cqtcLkeBAgVU2urWrYuQkBB8//33KjdzZsyYgWrVqqFs2bJ4/vw5ZsyYgUOHDim3P3z4EIMHD8asWbNQv379bMVFZGzKhLuvry/27duHlStXomrVqujSpQvi4+OxadMmfPjwAevWrUPevHm1HkhXQt2YyXYAaNCgAYYMGYL58+ejRo0a6NixIx48eIBNmzbBw8MDISEhRj0fkaVJT08XnKHKWdFEJIa2sYKzlSi3qlq1KmJiYpSvly5dijZt2mgtp0hERJSb8TOj9UpPT8euXbsQFhaGuLg4Ufu4uLggNDQUNWvWNFlcn3/+OYKDg/HTTz8p25KTkzF27Fi0bNkSv//+u+AEw3fv3mH48OGYMmUKvL29TRYfkaHkmV8sX74cK1asQLFixbBs2TJERkaiadOm+Pvvv9GxY0eJQhQWHh6O8PBwODg4ICwsDIcPH4avry9OnDiBcuXKSR0ekUkJlZMBWMM9p0hISMCdO3ekDoNyMJaUIVL13XffqbyOi4sTXCCMiIiImHC3Vv/++y/8/f3xyy+/iE62V6lSBUuWLDFpsj1DixYt0KVLF5W2W7duYeHChTqf5k9NTcX48eNx7949U4dIJJpt5hcymQx9+/ZF3759pYpHSdviCBlkMhmGDh2KoUOHmikiIsuh7QMOE+45g7OzM68lmVRycrJgO788UW5VvXp1NGzYECdOnFC2rVq1Cl26dFGWWSQiIsot9OVjOEnDusTFxWHevHmIiorS2c/R0RGVK1fGp59+qvwpXLiw0atW6DJy5EhcunQJ//33n9Y+BQoUQMWKFZXrTQIfv8esXbsW48aNM0eYRHrJ9XchIkuj7QMOk7REJIa2xDq/PFFupj6JIzExEStXrpQoGiIiIunom4Tx77//mikSyo7U1FSsX78enTp10ppsb9iwIcaPH4+IiAgcPnwYS5YsQWBgIJo1awZ3d3ezJtuBj7Xip02bhjx58mhsk8lkaN++PbZs2YLw8HC0adNGZfuff/6JV69emStUIp2YcCeyQpzhTkTZoS2xzoQ75WYVK1bEV199pdK2adMmPHnyRKKIiIiIpKHvM+GGDRv0zoInaZ0+fRrdu3dHSEiI4PpNpUqVwty5cxEWFoaOHTuifPnykMstI0VYpkwZBAUFqbTVq1cP69atw4QJE+Dq6gq5XI5hw4bB1vZ/hTtSUlKwdetWc4dLJMhWfxcisjTaEu43b940cyREZI20rQPBkjKU2w0ePBj79+9HWloagI9f3JYsWYIJEyZIHBkREZH5iJmE8fTpUxQpUsQM0ZAh/vvvPyxatAiHDx8W3O7k5IR+/fqhe/fusLOzM3N04rVu3RqFCxfGuXPnUKtWLdStW1djtr2bmxtatWqFP//8U9m2aNEi2Nvb4/r16/j333/x5MkT1KpVCz///DOKFi2qsr9CocDDhw/h4eFh0e8FWSfLuH1FRAbR9gFo165dOmudEREBLClDpE3x4sU1FuvauXMnbt++LVFE4v33339YsmQJjh8/LnUoRERk5R48eKC3j6XMhqaPbt68idGjR6N79+5ak+2tW7fG1q1b0atXL6tIMNetWxeDBg1CvXr1tJa26dGjh0ZbWFgY9u3bhwcPHiA1NRWnT59G7969cenSJWWf5ORk9OvXDx07dsRXX32FO3fumOzPQbkTR0giK6RrFirrzRKRPtoS65zhTgT069cPjo6Oytfp6elYuHChWc6tUCiwa9cuhISE4OrVq6L3u3//Pnr27IklS5Zg+PDh2LdvnwmjJCKinK5fv356+2SeVUzSuX37NsaOHQtfX18cPHhQsM8nn3yC5cuXIzg4GIULFzZzhKZVsWJF1K1bV2+/uLg4DBw4UHkzYu3atbh48SIA4M2bN/jtt99MGiflPky4E1khXUkxfskmIn04w51Iu4IFC8LPz0+l7dChQ7h8+bLJz71582ZMmDAB69evR//+/UXNMAQ+zsLPKIMDQOvCaERkuMTERMH6x0Q51R9//IH09HS9/ebPn2+GaEib27dvIygoCN988w0OHDgg2MfV1RVBQUFYs2YNatSoYeYIzUdolruQDx8+4KeffsLx48exZMkSlW3nzp1jiV4yKibcTYwf0MgUmBQjouxgwp1It2+//Raurq4qbeHh4SZdIC4lJQVLly5Veb1jxw5R+167dk3l9a1bt4waG1Fu5uLigrJly0odBpHZrF69WuoQSIe7d+9i3Lhx+Oabb7Bv3z7BzyZ58+bFoEGDsH37dnTu3DnHl/9p1KgRWrZsqXxdtGhRtG/fHkFBQWjQoIFK35SUFAwfPlzwptKmTZtMHivlHlw01cRcXFykDoFyIJZ9IKLs0DaGcGwh+sjFxQX+/v6YM2eOsu38+fP4559/0LBhQ5Occ9++fXj16pVKW3R0tN79FAoFrl+/rtL2/PlzxMfHI1++fEaNkYiIcj6xT1eRecXGxmLp0qXYu3ev1icQXFxc0KNHD3Tv3j1X5aJkMhmmTp2KgQMHwt7eHkWKFFHWfO/QoQOmTJki6um/Xbt2YejQofz8REbBhDuRFWJSjIiygzPcifTz8fHB+vXr8fTpU2XbvHnz8Pnnnxt9pphCocCGDRs02q9cuYKUlBTY29tr3ffFixeIi4vTaL916xY+++wzjfY3b95g8eLFuHv3Lrp27YpmzZplL3iiHC4hIQHPnz/nLHciMqn09HS8fv0az549U/l5/vw5Hj9+jPPnz2tNtDs7O8PPzw9+fn7ImzevmSO3HKVLl9Zos7Gxwbhx45CQkKC1xn2G5ORk/Pbbb5DL5ShYsCD69evH5DtlGRPuJsYPaGQKTIrlbCxFRabGGe5E+tnb22PgwIEIDg5WtsXExGD//v1o1aqVUc914cIF3LhxQ6M9JSUF165d01l3VX12ewZtCfdFixZh8+bNAD7OoI+IiBD8gkpEHzk7OyMpKUnqMIgklS9fPsTHx0sdhtXQ9n3u6tWr+PDhA54/f46nT5+q/PfZs2dITU016DxOTk7o3r07evTowcSwDjY2Npg8eTLGjx+vN+meeU282NhYhIaGmjg6yqmYcDcxfkAjU2BSLGfLTY//kTQ4w51InLZt22Lt2rW4ffu2sm3BggVo1qwZ7OzsjHYeodntGaKjo3Um3NXrt2fQVsf9r7/+Uv7/hw8fsGfPHgwcOFBkpERElBtNmTIFw4YNkzoMq6Ht+9zw4cON8vnByckJvr6+6NmzJxPtItnb22P69Om4cOEC/vjjD5w5cwZFihRBt27dMGHCBMF9jh07hujoaDx//hwxMTFo2LAhatWqZebIyVox4U5khZhwJ6LsYMKdSBy5XI6AgACMGjVK2fbw4UNERkbCx8fHKOd4/Pgx/v77b63bo6Oj0adPH63btc1wv3nzpkZbXFycRvmZY8eOMeFOREQ6FS1aVOoQCICjo6My0a6+uDvpJ5PJ8Nlnn6k8AahQKLB27VrExMQI7tO/f3/l/69evRqhoaEmW8+HchYm3Ims0D///KN1m42NjRkjIVNgKSoyNW2Jdd7MI9LUtGlTVKtWDZcvX1a2LV26FG3btoWjo2O2j79582atNVkB4OLFi0hPT9daN15XSRmFQqFcNAwQTsJfu3YNL168gJubm4GRExFRbpEnTx6pQ7Aq2fk+J5fL4ebmhsKFC8PDw0P53yJFiuDzzz/njHYjk8lk8PX1VSkhqE16ejomT56MLVu2wMnJyQzRkTVjwp3IyqxevRp79uzRuj0tLQ1paWlMvFsxlqIiU9NWH5Iz3Ik0yWQyDBs2DAMGDFC2xcXFYcOGDfD398/Wsd+9e4fIyEiVtmbNmqnUF01ISMDNmzdRsWJFjf3j4uLw7NkzwWPHx8fjxYsXKFy4sLJNKOEOAMePH0eHDh2Ur//77z/s2LEDJUqUQOfOnWFry68MRES5weHDhwXbHRwczByJddP2fc7e3h7FixeHu7u71p9ChQrxu7yZtWrVCnPnzsWbN2/09n327BlCQkLQqlUrlC1blhMWSCt+eiayMmFhYXr7vHv3jnXAiUgrznAnMkytWrXQsGFDnDhxQtm2atUqdOnSJVuPdO/evVtjEbqhQ4fixo0bePjwobItOjpaMOGubXZ7hlu3bolKuB87dkyZcH/27BkGDRqk/NL55MkTBAYGivsDERGR1UpPT8dvv/0muI0Jd+P4888/4e7uLnUYpMbBwQFjxozB+PHjdT51mCEyMhKRkZHIkycP5s6di9q1a5shSrI2ws+mEpFV4+xoItKFNdyJDDd06FCV14mJiVi5cmWWj6dQKBAREaHS1qhRI5QqVUqltijwMeEuREzCPTNtCfdTp04p//5v2bJFZYbXxo0bkZiYqPM8RERk/d68eYPnz58LbmPC3Tgyl3kjy9KyZUvs2bMHmzZtwj///INevXqhevXq6N69O+bMmSO42G1ycjImTpyId+/eSRAxWTom3IlyIH4xJiJdmHAnMlzFihXx1VdfqbRt2rQJT58+zdLxzpw5g9u3b6u0+fr6Avg4oz6z6OhoKBQKjWMYknBPT0/XmnBPSkrChQsXkJqaiu3bt6tse//+Pfbu3avzPEREZP10JQ21lTgR+reJyFoVLFgQ5cqVg52dHQIDA7FixQr88MMP+OKLL9C8eXPBfZ48eYIePXpofMZKSUlBQkKCOcImC8WEO5EVEfuBRkztMSLKvbQl3FlShki3QYMGqSQdUlJSsHjx4iwda8OGDSqvy5Qpg88//xwAULNmTZVtL1++xP379zWOoZ5wVy87k/nL34MHD3TeVDt27BiOHDmCly9famyLiopS/n9kZCS+/vprdO/eHTExMVqPR0RE1iU5OVnn9vz582u0/ffffyaKhsiydO3aVeu22NhY9OnTBwcOHIBCocD27dvxxRdfoGXLlti8ebMZoyRLwoQ7kRXRttChuhcvXpg4EiKyZpzhTpQ1JUqUQJcuXVTadu7caXDi+f79+zh27JhKm6+vr/JR85IlS6JgwYIq2y9cuKDyOj4+Ho8ePVJpa9Omjcrr27dvK2uR6kuKHDt2DFu3bhXcduXKFdy+fRvnz5/H5MmT8fz5c/z3338YOnQoXr9+rfO4RERkHfQl3L///nuNtj///NNU4RBZlOrVq6NChQpatycnJ2Ps2LFo3rw5fv31V6SlpSElJQWhoaF4+/atGSMlS8GEO4CnT5/i22+/hYeHB9zc3ODj46OyUBWRpRCbDGPCnYh04Qx3oqz77rvvkCdPHuXr9PR0fPfdd9i0aZOohbaAj3XRMz+15uLigtatWytfy2QyvXXc1We329vbazzunJycrEzKqz/qXKhQIZXXsbGxOHXqlNaYIyMjMXv2bJW2uLg4TJ06VeMJvGfPniEyMhJXrlzRejwiIrIs+upQe3h4aLQxkUi5hUwmQ1BQEJycnJRtmT8PZlCvNvD+/Xt+HsqlmHDHx0dD7t27h127duHgwYN48+YN2rVrJ3o2MZG5iE24Cz0OTkSUgTPcibKuUKFC6NGjh0rbu3fvMGPGDAwaNAgPHjzQuX9iYqJKiRYA6Nixo8oXOEC4jntm6gn3ChUqwN3dHa6urirtGXXc1RPurVq10ki66xIREYEbN25otB88eBC7d+9Wvr558ya6d++OyZMnw9/fH3v27BF9DiIiko62hHvPnj0BQLAedYECBUwaE5ElqVatGvbt24ft27fjzJkz2LdvH5o0aaJ3v0WLFvF7Vi6U6xPuN27cwLFjx7B06VLUrl0b1atXx8qVKxEdHY2LFy9KHR6RCs5wJyJj4Ax3ouzp3bu34GPF58+fh6+vLzZs2KB1tvuOHTuQlJSkfC2Xy9GtWzeNfuoz3B88eIDnz58rX6sn3CtVqgSZTAZPT0+V9oyEu3pJmQoVKqBRo0aCMQJA48aNVV7rmr0/ffp0PHnyBCkpKRg3bpxydld6ejqmT5+OV69ead2XiIgsw/v37wXbGzRoAEB4Nruzs7NJYyKyNHny5EHx4sUhk8ng5OSEGTNmYOjQoXBwcNC6z9WrVxEYGMjvWrlMrk+4e3h4YOfOnYJfmvQ9UkVkbkIfgmQyGVq2bKnSxoQ7Eemi7eYdPwQSiePk5IRly5ahc+fOGtuSk5Mxe/Zs9O/fH7GxsSrb0tPTsXHjRpW2pk2bolixYhrHKV++vEYiI/Msd6GEe8Z+md28eRNJSUka5RIrVKigkVTPbPjw4ahRo4bW7ZklJiZiwIABGD9+vDLBn+Ht27cIDQ3Ftm3bMHLkSCxfvlzUU6R//fUXevfujZEjR6rUqk9OTha9iDwREYmXlpYm2J6xvkj9+vW1biPKrWxtbdGnTx/s2rULVatW1drv7NmziIiIMGNkJDVbqQOQWv78+TUWmJo9ezZcXFxQs2ZNaYIi0kIoSbZ+/Xpcv34d+/btU7Yx4U5EumhLrKenpyMtLQ02NjZmjojI+jg7OyMoKEi5ONbjx49Vtl+8eBG+vr4ICAiAn58f5HI5jh8/jvv376v08/X1FTy+XC5HjRo1cOLECWXbhQsX0LJlSyQmJmok8zMS7kIz3G/fvq2SpJbL5ShbtixKlSoFW1tbjQR4rVq1ULZsWXTo0EHwic+GDRuiQIECKovlPXr0SGMR1wx//vmnsu+RI0fw4MEDTJgwATKZDElJSYiKisL58+fx33//wcbGBl988QXWrVunnFWfmpqKkJAQhIaGYuvWrShQoABCQ0NRsWJFxMXF4eXLl/D09IRcLm4uUWxsLKKjo1GjRg2UKVNG1D5ERDmdtpuhGWOru7u76H2IchtXV1esWLECly5dwosXL/DTTz9p9Fm6dCnq16+PAwcO4O7duyhfvjxatmyJR48eoUqVKsifP7/5AyeTyfEJ95s3b2pdSbhp06b4+++/VdrWrFmD0NBQzJ07Fy4uLmaIkEg89YS7vb09KlSooJFgZ8KdiHTR9eUoJSUFjo6OZoyGyLrVq1cPGzduRHh4ODZv3qyyLSUlBaGhofjrr78wYcIEbNiwQWV7hQoVNGq1Z/bZZ5+pJNwzZrir11K3tbVVJtrVE+53797FtWvXVNpKlSqlfPS5Vq1aOH36tMr2jJn7zZs3x8yZM1We+pTL5RgxYgTc3d0RHR2tNcmuy44dO1C0aFG4uLhg5cqVGiVn7t69q/L6xIkTGDZsGM6cOQPg46Ks48ePx8iRIzFq1CgkJyejevXqmDVrFgoWLKjz3DExMejVq5dyHJw4cSK8vb2VNfQTExORnJxsUH17IqKcQNsM98w3M1u0aIH9+/fr3YcoN7KxsVGWBIyIiNCYtJCUlAQ/Pz/l64MHD2LJkiUAAEdHR0yePBlNmzY1X8BkUjm+pEzp0qVx7do1wZ/Vq1er9F24cCH69OmDkSNHYtiwYRJFTKSdesI948uym5ubSvurV68424CItNK1HgTLyhAZzsnJCWPGjMHixYtRvHhxje2XL1+Gn5+fRmK7e/fuOh/HV0/G37x5E/Hx8RrlZDw9PWFvb6/8/8zS0tJw8OBBlbbMZWfUy8q4urqiWbNmyj9Xq1atVLZ36dIF5cqVg4uLCxYtWqS17Iy+J0WXLFmCkJAQ0fXdM5LtGW7fvo2hQ4ciOTkZAHDp0iUMHDgQu3fvxvr16/Hs2TPEx8dj2bJlWL58OV6/fg3g48JlmT8jTZo0CT4+Pnj8+DGOHz+Or7/+Gq1atYKfn59G3XsiopxMTMLd1lZ1zia/cxIJmzJlCtq2bSu6/7t37zB27FiNJxjJeuX4hLudnR0qVaok+FOqVCllv+DgYAQEBCAoKAizZs2SMGIi7YRmuAOaCXcAiIuLM0tMRGR9dCXVxS7OTESaateujYiICMFEuvrfu/z58+Orr77SebzKlSsr/60HAIVCgYsXL2qt3w4AefPm1Xjs/+zZsyqvMz/92bZtW5XZ3AMHDlQ559ChQ1GxYkUAQJ06dTB06FDltmLFimHp0qX46aeflDPEAaBJkyZYtGiRRj15U7tz5w5+/vlnhISEoEOHDmjWrBkWLVqEhQsX4ocffkB6ejqOHDmisd/Tp08xYcIEDB8+XLmgbUxMDLp3764xQYeIKKcSk3BXLzv4+++/mzIkIqtVpEgR/PLLLxg3bpzofT58+IDIyEiVtidPnmDWrFkIDQ1VTh4g65DjS8qIERISgokTJ2LmzJkYNWqU1OEQaaW+aGrGF2JXV1fY2NiofEh68eKFYJ09snyJiYlITEyUOgzKwZhwJzIdR0dH/PDDD/D29kZwcLDWmUqdO3dWSWwLsbe3x6efforz588r26KjozVKxFSuXFnldfny5fHs2TPla/VFRjMnwvPly4dVq1bhr7/+QunSpdGoUSOVvvnz58e6deuQlJSksYgr8DER06VLFzRt2hR79+6Fs7Mz2rZtC1tbW8yZMweTJ0/G8+fP8fXXX+PVq1dYv3694J+1YcOGKuVzskt9nLt48SJOnjyptX/mBWkzW7RoEXr27KlMOL169Qrz58/HpUuXUKlSJYwaNQr58uUDAFy7dg3//PMPatasqbNUEBGRJdK3aCogPKkrNTVVY+Y7EX2k/rlKn2PHjiEwMBDAx/W1hg8frlyQ/urVq1i6dKnRYyTTyPWjYkxMDMaOHYsBAwagZ8+eePLkiXJbgQIFlCU7iCyB+pfHjC/qcrkchQoVUvlyzTru1ovrR5ApKRQKnQl3lpQhMo6aNWti/fr1WLRoEdavX69cABT4OEOwa9euoo+TOeH+zz//aNQ4zzzDHfhYVkZX8lp9faMiRYqgR48eWvvLZDLBZHtmbm5uGscoWrQo5s+fr3ydlpaGJ0+eKEvcODs7o0GDBujevTtq1KiBlJQUBAYGaszIN5aML7CGSElJQUREBCIiIjTq1d++fRu7du3C/PnzUaBAAfTp00eZsOrXrx8GDRpklLiJiMxB36KpAJSJv8xSUlKYcCfSwt3dHfXr18epU6eUbWPGjMGsWbMEb3Ldvn0bjx49QrFixXDlyhWVv3PR0dF4/fo1F1e1EjpHxUOHDsHb2xt+fn5Yu3atuWICAPj6+uLYsWN48OCB1j4rV65EeHg4YmJi4OTkhJYtW2LKlCkoXbq06PNs2bIFHz58wJIlS5SLFWTYtm0bOnbsmNU/ApHRqc9wz3xDyM3NjQl3ItIrPT1dY7ZrZpzhTmQ8efLkwYgRI+Dt7Y1JkyYpE+Xfffed6KfQMhbfyqBeV1wul2sk0NXruGfm5OSEIkWKiDq3sdnY2GD69On4999/AQCffPKJSpLG3t4eCxYswIEDB6BQKAx6DNuUQkJCdG4fMmSIRtuyZcvg7u6uXICWiMjSiZnhLtQn8w1lItL0888/Y968eXjz5g369OmD2rVrw9nZGb///jvc3Nw01vhp3749ChYsKPhEyYMHD5hwtxJaa7jHx8ejb9++Or+Um8rUqVOxceNGnX3Gjh0Lf39/vH//HkOGDIG3tzciIiJQp04d3LlzR/S5goKCoFAoBH+YbCdLo54Is7OzU/6/eh13JtytV0JCgkHjGJEh9CXUOcOdyPiqVauGiIgILFy4EGvWrEH//v1F71ujRg2V2YXqypYtq/FEpq6Eu6enp87jmZpMJkPVqlVRtWpVwRmRcrkcLVu2RKtWrdCiRQuVbW5ubla11tLUqVOlDoGISDQxNdyFMOFOpFuRIkUwefJkhIeHo3bt2gCA1q1bY9OmTViwYAGaNGmisY+2NfkePnxo0ljJeLSOnCNGjMC9e/fMGQuSk5MxaNAgvbNZLly4gOnTp6Nx48aIjo7G9OnTsWHDBmzZsgUvXrzA8OHDzRSxfqzFTMaknihTn+GeGRPu1svZ2Vnvo/tEWaUvoc4Z7kSmYWtri7p166Jy5coaC6rq4uTkhE8++UTrdvX67cDHJLy2c6jPhrdk6pNfhgwZAi8vL/zyyy8qkw6qVaumsW9YWBjCwsIwYMAAlQVdLUFSUhKSk5Px8OFDnD9/HnFxcTh//jxevXoldWhElIuJSbh7eHhobNdWioaIxKlSpYrovrqqgJBlESwps2PHDqxcuRLt27dHVFSUqAOtW7cOlSpVUt6tyfDgwQNs27YNw4YN07n/jh07EBgYiLt376J169bYtWuX1r4ZtSAnTpyosthUx44d4eXlhZ07d+Lhw4coXry4qNhNibWYyZjUE2GZf/+ZcCciMfR9KWLCncjyfPbZZxoLpWZQr98OfCxlU6JECdy/f19jW+YFUy1d/fr1MWXKFBw+fBh16tRBu3btAABt27ZFlSpVsH37dmXZljFjxijr1jdq1AgNGjSATCZDw4YN0b17d5w9exZLlizRKMljaq1atUKjRo3g6emJBg0aoFu3blr7urq6YunSpShXrpwZIyQi+khMDffBgwdj6NChKts5w50oewxJuF+/fh2PHj1CkSJFJH1ikfTTuDovXrxA//798cUXX4ieKR4bGwt/f380b94c586dU7bfv38fXl5eCAwMxLFjx3QeY/ny5Xj79i0WLFiAnTt36ux79OhR2NraCj524e3tDYVCgUOHDomKnciaqNdwZ8KdiAzFkjJE1qdmzZpatwkl3AHtZWWsKeEOfExYT506VaMWerly5fD999+jR48ecHR0xNSpUzF27Fj89NNPmDJlisoM/7x58+LLL7/EqlWrMGDAALPG//LlS0RFRWHOnDk6k+0A8ObNG8F1sx49eoQJEyZg5syZeP36tYkiJaLcTswMd6EniphwJ8qeKlWqiE6eHzp0CO3bt0dgYCAnSlk4jSs6ePBgJCQkYOXKlaIveKlSpbBq1Sq8fftWmXTPSLbfunUL06ZNQ+PGjXUeY8SIEbhz5w4GDx6s8zHbtLQ0xMTEoGTJkirJxgwZXy6uX78uKnZTYy1mMiZDZrhrq/lFRLkbS8oQWR/1hVMzyGQyVKxYUXCbtsS6tSXcxXJxcUHXrl3RpUsXrU+Y2tvbmz3hbqioqChcunQJM2bMwPjx43Hw4EG0b98eu3btwsaNG9G8eXNMmTIFL1++lDpUIsphtM1wz5yfEcoRsaQMUfbkz58f3bt3N2ifkydPomHDhvD391cuRk+WRaWkzLp167BlyxbMmzcPnp6ego+hauPr6wsA6NmzJ5o3b478+fPj7t27mDZtGsaOHat3fy8vL1HniY+Ph0KhQMGCBQW3Z6zWaymzP5ydnZGUlCR1GJRD6Eq4q3+55NoBRCREX8KdM9yJLE+BAgVQpkwZ3L17V6W9dOnSWuuTC81wd3d3R758+UwRIhmRv7+/8v/37NmjsX3btm24dOkSIiIiDFoPgIhIFzEz3G1sbDS2M+FOlH2BgYFwdHTE5s2bkZqaihIlSuDt27dITEzEmzdvtO536dIlBAQEIDIyUpkPJcugHDkfPnyIYcOG4csvv0RAQECWDubr64tZs2bh9evXuHv3LgICAkQl2w2RkJAAQHWxyMwy2pOTk416XiJLoGvRVPUv3ElJSVAoFGaJi4isB2e4E1knoVnu2srJAMIJ95w6u91UChYsiH/++QeRkZFSh6Lh1q1buHnzptRhEFEOoi3hnvnGnlDCfd++fSaLiSi3sLGxwaBBg3DgwAEcPnwY69atQ1RUFHbs2KF334SEBDRv3hw///wzKx1YEGXC/bvvvkNqaipWrFiR5ZkSsbGxCAsL+3hguRzr1q3DqVOnjBPp/8uTJw8A7QmBjBrXXKyUciJdM9zVE+5paWmcqUpEGphwJ7JOhibcS5UqBVtblYdZUaFCBaPHZY3UF/zr168fevXqpdJWqFAhTJs2DXZ2dihRogRWrlxpzhBFiY6OVnmdnp7OyRZElCVxcXGIiIgQ3JZ51qxQSZlFixaZKiyiXEc9H+vk5CR4o0vI7t27sXTpUlOERVkgBz4OkHv37sWsWbNQpkyZLB3o3r178PLywp07d/Dbb78hIiICiYmJaNmyJU6ePGm0gF1dXSGXy7WWjMlod3V1Ndo5iSyFrkVThR4pZzkjIlLHRVOJrJPQwqmVK1fW2t/W1lZjlvsnn3xi7LCsUrt27VCuXDkAH29MdO7cGf3790evXr3QtGlThIWFYe/evahdu7Zyn2rVqmHSpEkax9qwYQO6du2q9Vy//PKL0ePPMGPGDIwYMQJ9+/ZFnTp1UK9ePXTq1Am3bt0y2TmJKGeaOnWq1m2ZS5GxjBWR+X366aei+27evBn79u3jYsYWQA5AeSdz4MCBkMlkyp8vv/wSwMfa7jKZDH369BE8yKNHj5TJ9unTp2PMmDHw8fHB+vXrkZSUhFatWuHcuXNGCdje3h6enp6IjY0VTApkfMCsUqWKUc5HZEnUf+eZcCciQ+mrs8kZ7kSWqWjRoiqfbwsWLIiqVavq3KdHjx7K/y9RooToNZNyukKFCmHt2rWIiopCREQE3N3d4ejoiMDAQMyePRsNGzYU3E9ohpmLiwtq1aol2P+bb75B27Zt8c8//xg1/syOHTuGy5cvK18/ePAAgYGBJjsfEeVMf//9t2B7UFCQeQPJIRITE7mmGhlNmzZtlP/v4OCAoUOH6pxEERQUhHr16iEqKopPvknIFgD69Okj+AH87t27WLVqFapVq4bOnTsLzqwBADc3N9SoUQMBAQH48ccfle0+Pj4AgNDQUME6klnVtGlTLFu2DMePH9eI+8CBA5DJZGjUqJHRzkdkKdRnuGeu4Z5RbikzJtyJSB0XTSWyTjKZDJMnT8a8efOQnJyM/v37C/7bn1nr1q1RtmxZPHz4EA0bNlS5UZ/b2dvbo1ixYgbtIzSz08XFRbDEAvC/J27t7OxQp04dnD171vBAs+Dp06eIjY3F69evMWjQIDg4OGDDhg0oUqSIWc5PRDmDt7c3OnfuLHUYVokljsmYOnXqhPz58+P27dto3rw5ypQpg86dO6NZs2Y69wsODoarqyuaNm1qpkgpM2XCXcjff/+NVatWoXr16jofh7S3t8e2bdsEP4T6+Piga9euRn30yN/fH8uWLUNQUBD++usvODo6AgAiIyNx+PBhdOjQASVKlDDa+YgshfrMUzs7O+X/y+VyODo64t27d8o2JtyJSJ2+Geyc4U5kuUqVKoUZM2YYtE/lypV1lp4h8YoWLarR5uzsrDXhntmAAQNw6dIl5RhrY2OjdYFCY8icJEtJSUHbtm1x/PhxlckaRES6VK9eXeoQiAgfb/g3a9ZMJcGeL18+tG/fHlFRUTr3/eOPP5hwl4j+T4ci6UqoG7vOV4MGDTBkyBD8888/qFGjBkaPHg0/Pz907doVHh4eCAkJMer5iCyFeiJM/UuTelmZzMl3IiKAi6YSEWVVtWrVULZsWeXrZs2aQS6Xa72hkfkJhFq1amHLli0ICwvDoUOH0KpVK5PHq2779u1mPycRWa43b94gKioKc+fOFdyeeXKXPqwXrSohIQF37tyROgzK4UaNGqW1DF6G48ePmykaUme0hLu5hYeHIzw8HA4ODggLC8Phw4fh6+uLEydOKBdBIspp1BNh6o+GqyfcWTeOiNTpq+HOkjJERMJkMhkWL14Mf39/DBkyBMHBwQA+znxv3bq1Sl+5XK7RVqxYMTRs2BB58+ZFr169VLYVL15co7+xXb16FY8ePUKvXr3QsGFDTJs2TZkkS05Oxt27d5GcnGzSGIjIMiQnJ8PPzw/BwcFYs2aNYJ8XL16IPt6bN2+MFVqO4OzsDGdnZ6nDoBzOyckJYWFh8Pf319lPoVDg9u3bePjwoZkiI+D/S8po4+XlJVmBfX3nlclkGDp0KIYOHWqmiIikp17DXV/CnTPciUgdS8oQEWVdwYIFERAQoNE+adIkfPLJJ5gzZw6cnJwwaNAguLm5aT1O+fLlMWjQIERERKBEiRIIDg5GkSJFUKlSJZM9rfvnn3/i9OnTeP78OQBg69ataN68OUqVKoVBgwbh/v37KFmyJBYtWgQPDw+TxEBElmH37t14+vSpzj62tsLpIqE1KThhg0g6gwYNQr58+RAaGiq4vW7dugA+TgYYNWoUunXrZsboci+rneFOlBtxhjsRZRcXTSUiMj6ZTIYePXrg7NmzOHLkCPz8/PTu069fPxw4cAC///47SpUqBXt7e/j5+Rm8mKshMpLtGQIDA9GmTRvcv38fAHD//n2ts12JKOc4deqU3j5fffWVYPuECRM02vQ9QUlEpiOXy9GzZ0+9E5LT09OxYMECk64hQ//DhDuRFdGXcC9YsKDK69u3b5s8JiKyLqzhTkRk2UaPHm22cwn9mxAREYHTp0+bLQYiMr/Ma0xoU6pUKcF2d3d3jTZO2CCSno+PD7788kudfRISEvDHH39g3bp1XGfAxJhwJ7Ii+hZNrVq1qsrry5cvmzwmIrIuTLgTEVm2Ro0aYdy4cWjWrBk+++wzSWIwVVkbIrIM6t8j1WWsUSHExsZGo40JdyLpOTs7Y+bMmTh27JjOftOnT8ecOXPwzTff4NatW2aKLvdhwp3Iiuib4f7pp5+qvObgSUTqWFKGiMiyyWQydOrUCTNmzICvr68kMdy8eVOS8xKReehLuHt7e2vdJpPJYGdnp9LGz49EliNPnjxo3ry53n7p6emIjIzE0aNHERUVhaSkJDNEl3sw4U5kRfQtmlqoUCGV16mpqaynZ4USExNZf59MhoumUm7G8ZWsjaenp2TnTk9Pl+zcRGRa+krKaFswNYN6wp3fOYksS6VKlUT127BhA77//nsEBwejSZMmGgsiU9Yx4U5kJRQKhcbMAfWEu9BMBSbPrI+LiwvKli0rdRiUQ+n7QsQZSpSTcXwla1OmTBk0bNhQo71ly5YoUaKESc+dlpaGly9f4t69e1AoFCY9FxGZl76Eu1yuO1WkPhP23bt32Y6JiIynVatWWdpv0KBBiImJMXI0uRMT7gCePn2Kb7/9Fh4eHnBzc4OPjw8ePnwodVhEKtLS0jRmGqkn2NUT8ACQnJxs0riIyLqoJ9RlMpnO7UREJK05c+ZgxowZ6N27N77++msEBAQgODgYW7ZswaFDh1C7dm2TnHfBggVo1aoVunTpgvHjx5vkHEQkDScnJ53b1T8f6hMaGpqNaIjI2IoWLYp+/fplad/p06cbOZrciQl3AF27dsW9e/ewa9cuHDx4EG/evEG7du34WBRZFKGZ6uoJdqGZCuplaMjyJSQkcMVwMhn1sUT9CxefiqGcjOMrWSMbGxs0a9YMw4YNw6+//gp/f3/Y2trC1tYWefPmxXfffWeS865Zs0b5/3v37sW///5rkvMQkfnpKhlVunRpg48XExPDUhREFmbgwIGIjIzE5s2bMWTIENH7Xbx4EUuWLGFN92zK9Qn3Gzdu4NixY1i6dClq166N6tWrY+XKlYiOjsbFixelDo9ISShxzpIyOZOzszOcnZ2lDoNyKPUZ7Oq/a5zhTjkZx1fKierWrQsPDw+Tn+fAgQN4//49Tp48iXv37pn8fERkOmlpaVq3LVy4UO/+Qt87p02blq2YiMi4ZDIZSpQogbJly8LHx8egsopLlizBL7/8YrrgcoFcn3D38PDAzp07UaFCBY1trENGlkQoCaaecLexsdGot8cZ7kSUmfpYwhnuRETWTSaTITQ0FPXr10e9evW09vvxxx+zdZ53796hV69eGDp0KL755hv8/fff2ToeEUlH2wz34OBguLu7691faDzhjTgiy+Xi4oJly5Zh+vTpmD17Nlq0aKF3n8OHD3MB9WzI9Qn3/Pnzo02bNipJytmzZ8PFxQU1a9aULjAiNWJmuAOaZWVYw52IMmPCnYgo56lQoQLmz5+PBQsWoEuXLoJ9unTpgi+//DLL5/jzzz9x69YtAB8X4J44cWKWj0VE0tI2w13fYqoZ8ubNa8xwiMgMXF1d4e3tjaZNm6JMmTJ6+6elpSEyMtLkceVUOT7hfvPmTchkMsEfLy8vjf5r1qxBaGgopk6dChcXF/MHTKSFUBLMzs5Oo0398T7OcCeizFhShogoZxszZgx++eUXFC5cGAAgl8sxevRo2NraYtKkSfjuu+/g6+ur8VSkPuq1XBMTE40WMxGZl7ZZq7a2tqL217foKhFZttatW4u6wTZ16lTExMSYIaKcR9xoasVKly6Na9euCW5T/0di4cKFGDp0KEaOHIlhw4aZIzwi0dQT7vb29oKrx6vPeudsVSLKTF/CnWMGEZF1k8vlaNu2Ldq2bYuXL19CJpOhYMGCAD5+/xk8eDCAj9+Tpk+fLmWoRCQRbQl3sYl0oSetich6lCxZEhs3bsSZM2dQtGhRnYuqTpkyBatWrTJjdDlDjk+429nZoVKlSnr7BQcHY+LEiRg/fjx+/fVXM0RGZJi3b9+qvBZaqEaonTPciSgzfSVlOMOdiCjnKFSokNZtbdq0yXbCvU6dOujXrx8GDBhg8Ix5IpJOamqqYPsnn3wian+xM+GJyHIVL14cxYsX19vv6tWrOHToEJo2bYq0tDTBtQNJE98hACEhIZg4cSJmzpzJZDtZrLt376q8LlasmGA/1nAnIl3UZ7Crl09LSUmBQqEwZ0hERCQBJycnzJs3L9vHWbZsGQICAowQERGZi9AM95YtW4quzS5U2hTQLD1FRNZBqHpCZj/++CPq1auHBg0aoHHjxlixYoWZIrNeuT7hHhMTg7Fjx2LAgAHo2bMnnjx5ovzhzGCyJOoJ97Jlywr2Y0kZItJF3wx3QPusJyIiylk+//xzoxzn7Nmz2LFjh1GORUSmJ5Rw//nnn0Xvr22Ge0JCQpZjIiLp/Pjjj6L7pqSkYMGCBbh06ZIJI7J+Kgn3169fY/To0fjkk0/g6OiI0qVLIzAwEM+fPzd7YL6+vihRooTOPitXrkStWrXg4uICd3d39OzZE/fu3TPoPFu2bMGHDx+wZMkSFC1aVOVn9+7d2fkjEBnVnTt3VF5rS7izpAwR6aKeTBdKuLOsDBERGWrSpEm4deuW1GEQkQhpaWkqr9u1awdHR0fR+7OkDFHO0qFDB3Tr1s2gffz9/fH48WMTRWT9lAn3t2/f4osvvsDMmTNRokQJDBs2DDVq1EB4eDg+++wzPHz40GxBTZ06FRs3btTZZ+zYsfD398f79+8xZMgQeHt7IyIiAnXq1NFITOoSFBQEhUIh+NOxY8ds/kmIjCc2NlblNRPuRJQV+krKCPUhyikSExORmJgodRhEFuWzzz4z2rG++eYbox2LjCM9PR1//fUXFixYgH///VfqcMhCqM9wN7Qes7aEu7bFWInIsjk4OGD06NEG79ezZ0+8e/fOBBFZP+Wo+uuvv+LKlSv45Zdf8Ndff2HGjBmIiopCeHg4Hj58iAkTJpg8mOTkZAwaNAjjxo3T2e/ChQuYPn06GjdujOjoaEyfPh0bNmzAli1b8OLFCwwfPtzksYrFL3ZkLOqP52lbBIsJdyLSRUxJGSbcKadycXHResOaKLcaNmwY8ufPD+DjWkCtW7fO1vEy1gE5e/Yspk+fjqioKK4NIpGrV6+iT58+GDNmDFasWIG+ffvi5MmTUodFFkB9hruNjY1B+zPhTpQzffvttwb1f/PmDUvKaaEcJW/fvg0PDw+Nuj3ffvsthg0bhuPHj+s80Lp161CpUiXUrl1bpf3BgwfYtm0bhg0bpnP/HTt2IDAwEHfv3kXr1q2xa9curX3nz58PAJg4caJKveqOHTvCy8sLO3fuxMOHD0WttmtqQjMHiQylUCg07hpqe+RPPeHORVOJKDP1hLuzs7PePkRElHNVr14d27dvR3x8PDw8PCCXy/Hw4UNcvHgxS8erW7culi1bhkGDBinbFAoFOnToYKyQSY+4uDjMmzcPUVFRKu1paWkICgrC2rVrUaxYMYmiI0tgqhnuxvTu3TvExsaiWLFiohdzJaLsGTx4MPLkyYPY2Fg8ePAAV69e1bvPhg0bDC5HkxsoR9UtW7bgyZMnGjPdrl27BgAoWrSo1oPExsbC398fzZs3x7lz55Tt9+/fh5eXFwIDA3Hs2DGdgSxfvhxv377FggULsHPnTp19jx49CltbWzRp0kRjm7e3NxQKBQ4dOqTzGETWJDU1VeNDUZ48eQT7qv8d5uM9RJSZmIQ7Z7hTTpWQkGBQ6UGi3MLZ2RlFixZVJt2y+3Rzv379VF7/+uuv2ToeiZOWloaIiAh07txZI9meIT4+HqNGjeKknFwuuwl3Ozs7UcfNqhcvXqBHjx7o0aMHunXrhrt37xrluESkm729PQYOHIgpU6Zg4cKFop56u3//Ph49emSG6KyL1lH11atX2Lp1K7755hvY2tpi/PjxWg9SqlQprFq1Cm/fvlUm3TOS7bdu3cK0adPQuHFjnYGMGDECd+7cweDBgyGTybT2S0tLQ0xMDEqWLKkyuz2Dp6cnAOD69es6z2cu/GJHxiCUNBebcE9KSjJJTERkndQT7g4ODhpfsjjDnXIqZ2dnwZtMRKSqdOnSWLJkCfLmzWvQQooknXPnzsHPzw+zZs3SKEWpLiYmBlOmTGGpn1zM0kvKbNiwQbmG2fPnz7F48WKjHJeIxHNyckJwcDD+/vtvFClSRGffyMhI8wRlRQQT7osWLULBggXRtWtXPHz4EGvWrIG3t7fOA/n6+mLt2rXKpHuTJk1w+/ZtTJs2DWPHjtUbiJeXl6jHhOLj46FQKFCwYEHB7Rn1B1+/fq33WObAL3ZkDEIzULR9+WHCnYh0UZ+9bmdnp3EDmzPciYioVq1aOHToEI4ePYqaNWtKHQ5pkZ6ejilTpmDgwIG4deuWxnYnJycMHToUZcqUUWnfvXs3IiIizBQlWYqMagDbt29XaTdWSRlj3cRZtWqVyuv9+/cb5bhEZDgXFxds3boVI0aM0NpnxYoVGD9+PNdxyERwVC1cuDDGjBmDXr16wcnJCT179kRISIjeg/n6+mLWrFl4/fo17t69i4CAAFHJdkNk3K1Xr1OdIaOdj8hRTiI0w11bwl29nQl3IsosNTVV5TUT7kREpM+8efOyfYwffvgBb9++NUI0lNm8efOwbds2wW2tW7fG1q1b0adPH8yePVtjYs6cOXNw/vx5c4RJFmLz5s0a6/YBxpvhzr/jRDmTg4MDvLy8dPbZs2cPoqOjzROQFRBMuHfp0gW//fYbVq1ahStXrsDd3R0//PCD3n+MY2NjERYW9vHAcjnWrVuHU6dOGTXgjDIa2pIB79+/B8DFSilnUb+BZGNjo/VDjvoTFUy4E1GG9PR0jVkHdnZ2GnU4WVKGiIgyy5MnD2bNmpWtYxw+fBg9evQwUkQEAPv27cPq1as12itWrIilS5ciODgYhQsXBvCxTNDkyZNV+qWnp2Ps2LF49uyZWeIl6c2YMUOw3Vgz3GfOnGlwTERkHcRU75gyZYoZIrEOekfVUqVKKWep66rJc+/ePXh5eeHOnTv47bffEBERgcTERLRs2RInT540WsCurq6Qy+VaS8ZktLu6uhrtnERSU5/hrquWJme4E5E2QjerOcOdiIjE+OKLL/Ddd9+hYsWK8PHxydIxHj16hPj4eCNHljvFxMRg0qRJKm22trYYPXo01qxZg88++0xjnyZNmmgsaBsXF4cff/yR//bnctoqCGijbd29q1evGiMcIrJAYiY2x8bG4vjx42aIxvLJgY+zwvfv3489e/YIdipXrhwAaL3z/ejRI2Wyffr06RgzZgx8fHywfv16JCUloVWrVjh37pxRAra3t4enpydiY2MFZ+Bl1K2rUqWKUc5HZAkMSbirPyp68+ZNJt2JCID2hDtnuBMRkT42NjYYPHgw1q9fjzFjxmT5OKzFnH1v3rzBqFGjlE93Zxg9ejS6deumszzIgAED0KhRI5W2q1evYsSIEXj69KlJ4iXLZ2jCnYhyHzs7O3z55Zd6+w0fPpzlyvD/Cfe0tDS0bt0a33zzjcY/2gCUb1T58uUFD+Lm5oYaNWpgxowZGD16tLI9I+n+6aefwtPT02hBN23aFCkpKYJ3TQ4cOACZTKbxIYLImqmXlMkorSREPeEOQOfiFkSUewitb5InTx7OcCciIoMNGTIkS/upryVChklLS8NPP/2ER48eqbR36tQJnTt31ru/XC7H5MmTUbJkSZX206dPo1u3bti+fbvRFr4ky5KWlqZ1GxPuRCTGpEmT8O2336J+/fo6+w0YMAD169cXXMw7t5ADHxN0nTt3Rnx8PH7++WeVDtHR0Zg5cyacnZ3h5+cneBB7e3ts27ZNcPENHx8fHDt2DPnz5zda0P7+/gCAoKAglZm/kZGROHz4MNq3b48SJUoY7XxEUsvODHfg400zzlghIqGEu6OjIxPuRERkMB8fHxQtWhTAx1Im7du3F7WfMcuN5kbz5s3D6dOnVdqqV68u+F1cm7x582LWrFka3ykSExPx66+/Yvjw4fzukAPpKudkKQn306dPY/bs2YLb1NcgICLzc3JywvDhwzF//nzMnz9fZ9+0tDRMnz7dTJFZHmUN9zlz5qBMmTKYOXMmGjdujB9//BHdunVD/fr1kZKSgtWrV6NYsWJaD6Sthpe+bVnRoEEDDBkyBP/88w9q1KiB0aNHw8/PD127doWHhwdCQkKMej4iqWV3hjvw8dFTIsrd1McSuVwOW1tblpQhIiKDubi4YMOGDZg1axbWr1+PCRMmoECBAnr3O3r0KLZu3YonT56YIcqcZe/evVizZo1Km5ubG2bMmKFx81wfT09PzJ07V7moamYnTpxAt27dEBUVla14ybKoT+LKzBIS7leuXEFAQAA2bNgguD0yMhL37t0zc1REpE39+vWxadMmnX3Onz+fa/8tUSbcixUrhjNnzmDYsGG4f/8+QkND8ffff6Njx444deqUqMfTzCk8PBzh4eFwcHBAWFgYDh8+DF9fX5w4cUJZc54opzAk4a5t5WihclFElLsIjSUymYwz3ImIKEtcXFzg5eWl/P61ceNGUftNmzYN3bt3x/Pnz00ZXo4SExOD4OBglTZbW1vMmDEDbm5uWTpmrVq1sGnTJrRr105jW2JiIoKDg7Fu3bosHZssj9CTjhksIeE+Z84cvX2OHTtmhkiISKxy5crpfcItODgYQUFBGDJkSK5Kvsszv3Bzc0NYWBju3buHDx8+4NmzZ9i0aRNq1qxp9sAUCgUePHigdbtMJsPQoUNx+fJlJCcn4+HDh1i7di2T7ZQjGVJSRtsH7sTERKPGRETWR9vNO85wJyIiYyhYsCCmTp0qqu/bt2+xcuVKE0eUM7x+/VpwkdQxY8agevXq2Tp23rx5MXHiRISGhgrOdp87dy5OnDiRrXOQZdA1ASsrCfemTZtmJxwNFy9e1NvH2NUTiCj7goKC9PbZt28fTp06heDgYI2yaDmVXH8XIpKaIQl3uVz4rzUT7kSknnDPGEs4w51yi8TERP57SGRiLVu2FN1306ZNSE9PN2E01k/bIqldunRBp06djHaexo0bY+PGjWjbtq1Ke3p6OoKCgljKIwcwdsJd28LJplx0V9fCr0QkDVtbW0RFRWlM4tJmx44dJo7IMjDhTmQFDCkpA0DwkR4mGIhI21jChDvlFi4uLihbtqzUYRDleBUrVhTdt3///iaMxPIkJSXhv//+Q0xMjPLnxo0buH79Oq5fv45r167h33//Vf7Mnj0bZ86cUTlGjRo1MGrUKKPHli9fPvzyyy8YPHiwSntCQgK+//57vH371ujnJPPRVVJG2zpgumirLtC/f3+DF90V+1312bNnBh03s71798LPzw8jR47M1nGISFOxYsXwzz//iOp769YtE0djGWylDoCI9FP/QJA3b16d/Xv37q1RGyshIcHocRGRdVF/WkZbSZnU1FSzxURERDlPkSJFEBMTI6rvxYsXkZSUlKWEnzVJSUnB/PnzsXnz5mzd2C5cuDBmzJgheiZhVvj7++O///7DgQMHlG2xsbEYN24cQkNDtT5RS5ZN1wz3IkWKGO08Fy5cwIoVK/DTTz+J3mfXrl2i+m3YsAHt27dHhQoVDIrpxYsXGD9+PBQKBWJiYuDo6IgpU6YYdAwiMo6YmBjcvHkT5cuXlzoUk+K/lERW4ObNmyqv9c3OK126ND799FOVNibciYgz3Cm3S0hIwJ07d6QOg4jUNGnSxKRlKKR279499OnTB+vWrcvWv7F2dnaYOXMmChUqZMToNMlkMkycOBGffPKJSvuJEycQHh5u0nOT6ehKuBcoUMCo59q6datB/V+9eiW67/z58w0NB2vXrlUZY/bu3WvwMYhIP7E3ZFetWmXiSKTHhDuRhXv//r3GAsKenp569ytTpozKa5aUsR6sMUymInbRVCbcKadydnaGs7Oz1GEQkYCzZ89KHYLRKRQKREVFoUePHqJn/OsyduxYjUk1puLo6IjZs2ejYMGCKu1r1qzBoUOHzBIDGZe261alShXJFyPVtUaZumPHjhl8fJZDIjKPX375RVS/3bt3mzYQC8CEO5GFu3PnjsZiUtrq5WXm4uKi8poz3K0HawyTqYhdNPXDhw9mi4mIiAgAoqOjpQ7BqBISEjBu3DgEBwcL1s6Wy+XKHxsbG9ja2sLOzg729vawt7eHg4MD8uTJgzx58sDd3R0jR45Ehw4dzPpnKFKkCGbMmAFbW9VKtOHh4Vy80sqkp6dj//79gtt+/vlnM0fzP/fv38eAAQMwd+5ck55H6hsKRLmFt7e36L4rVqwwYSTSYw13IgunXk6mePHiomYAqK80zxmrRMSSMmSNFAoFvv76a3z11VcYMWKE1OEQkQhZKQ+zZMkSpKamYuDAgbCxsTFBVOZz6dIljB8/Ho8ePdLYVq5cOUyZMsXgGtRSqVmzJkaPHo2pU6cq22JjY7Fz506z3wCgrHvx4oXWbfnz5zdfIGrmzJmD8+fPS3Z+IjIuBwcHnDlzBvv27cO4ceN09l2wYAH69OmTY9cFyZl/KqIcRH0FZ7ELSzCBZr1YY5hMRduiqeoz1zjDnSxFRvKNtVaJrEu3bt2ytN+KFStw4sQJI0djPunp6VixYgX69esnmGzv3LkzVq9ebTXJ9gydOnVClSpVVNqWLFnC7xdW5PXr11q3mXIBXn2OHDmSpf1SUlIMurGXk9eIILI0MpkMrVq1QtWqVfX21XUz0Nox4U5k4dQT7mLqtwOaH5zOnDnDDxpWgjWGyVQ4w52syb///ouGDRti//79ks6+IyLD1a9fH02aNFG+rlSpkuh9v//+e1OEZHLPnj3D4MGDsWDBAo1ykHnz5sWMGTMQFBSk/LfXmshkMgQEBKi0PX36FH/88YdEEZGhdC1KKmXCPasaNmyIH374QetCsP/99x9WrFiBkydPmjkyIsowb948vX1at26N2NhYM0Rjfky4E1k49ZIyWZ3hHh8fjylTphgtLiKyPky4kzU5cuQIGjRogOjoaLi6ukodDhEZQC6XY/bs2YiKisKhQ4ewdu1ag2ayWtskkSNHjsDX1xfnzp3T2PbZZ59hw4YNaNasmQSRGU/9+vVRq1YtlbYVK1ZoPD1Hluny5ctat5k74X7p0iX8888/GjemDHXkyBHBceXevXvo1asXFixYgKFDh2L06NFWN6YQ5QR58+ZFp06d9PZbs2aNGaIxPybciSxYSkoKnj17ptImdjFN9QQaAERGRmocj4hyj7dv36q8zlhcWf2LFkvKkCUYNGgQ5s6dy9ntRFZKJpOhWLFiyJs3LwDAyclJ9L67d+82VVhG9f79e8yYMQMjR45EfHy8yja5XI4BAwZg0aJFKFKkiEQRGo/QLPe4uDhs3LhRoohILIVCgUWLFmndrl5a0JSWL18Of39/DBs2DH379s328TKvLZAhLCxM5bPswYMHERUVle1zEZHh+vXrp7fPtm3bzBCJ+THhTmTB1JNjAFCoUCFR+2r74KQ+Y56Icg/1MSVfvnwAOMOdzO/mzZuQyWSCP15eXlKHR0QSmzBhgtQh6HX37l307t0bmzZt0tjm4eGBJUuWYMCAAVa/AGxmNWvWRMOGDVXaVq1aJfidhSzH8+fPtW7r1auXWRcsXLhwofL/r169mu3jyWQyjbajR4+K2vfMmTMAgKSkJOzevRtnz57NdjxEpMrDwwNnzpxB7dq1pQ7F7JhwJ7Jg6jNlgP8lyPQRmuEOfPxAQUS505s3b1ReZ4wn5pzhvm3bNnTu3BkBAQF4+PChyc5Dlq106dK4du2a4M/q1aulDo+ITCQoKEh0X6FFRy1JQECA4ESWZs2aYcOGDahZs6b5gzID9Vnub9++xdq1ayWKhsS4ffu2YPuiRYswbNiwbB27a9eu2do/u+Lj4zW+M4stVTNs2DC8fv0aTZo0wc8//4xBgwZh/fr1pgiTKFeTyWSYP3++zj4DBgzQ+K5q7ZhwJ7Jg6h8enJycRD/yx4Q7EalTH1MyEu4ODg4q7doWoMqux48fY8qUKYiNjcXp06cxd+5ck5yHLJ+dnR0qVaok+FOqVCmpwyMiE2nbti38/PxE9Y2IiDBxNOIkJiYiMTFRo139aTAHBwcEBQVh+vTpoifIWKNKlSpp1KPfsGGD4EQhsgwPHjzQaKtbty7q1KkjOEPcECNHjhTdNzU1NVvn0qZNmzYGrRGRITU1Fc2bN1dpCwkJUXmdkpKi0UZEhrO1tUX//v21bj9//jxWrFhhxohMjwl3Igum/sE1owamGNoWv+HCRkS5U3p6OhISElTazF1SZt++fSqvDx48yEWsiIhyEXt7e4wcORJRUVF6k9KWksB1cXHRu4ZS+fLlsWbNGnTu3DnbCUxrMGjQIJUyJElJSTm2Bm9OILSGV58+fYxybHt7e1SqVElwm/pnvJMnTxrlnOrevXuHadOmmeTYf/75J2e9ExmJj4+Pzu3r1q3DnTt3zBSN6THhTmTB1Oshurq6it5X2wx39YQbEeUOCQkJGl98zD3DXei4r1+/Nsm5iIjIchUrVgwHDx5EjRo1tPbZuXMnkpOTzRhV1nTr1g2rV69GuXLlpA7FbMqVKwdvb2+VtoiICC66bqGEEu5169Y12vG1PYG9dOlSldczZsww2jnV6apTb6jt27crv4dPmTLFaMclyu0KFiyII0eOoHLlylr7+Pj4YMGCBWaMynSYcCeyYOo1rIwxwz2n1cUiInF0rQmRJ08elXZTJTiEZjMy4S7Onj170Lx5c7i6uiJ//vxo0KABNm/ebPY4fH19UaJECZ19Vq5ciVq1asHFxQXu7u7o2bMn7t27Z6YIiciazJo1S+f2qKgoM0WiXUJCguCMu3z58iEkJASjR4/WOtElJ+vZs6fK6+fPn2P//v0SRUO6qCfcAwMDjbpQqraFgZcsWaLyWmxt9axKSUlBXFxcto/z66+/4ssvv8SAAQOMEBURZebk5ITFixfr7LNixQrUqVPH6td1YsKdyIKZYoY7k1tEuZN6wt3e3l45s91cM9yFStWYqp5nThIWFoavv/4aly9fxrfffgs/Pz/cunUL3bp1w+zZs80Wx9SpU7Fx40adfcaOHQt/f3+8f/8eQ4YMgbe3NyIiIlCnTp1sPSJ69+5djBgxIsv7Z9BWi5mIpFGgQAGd22fMmIG5c+dix44dSEtLM1NUqpydneHs7KzRvnjxYjRp0kSCiCxD1apVNRaGXbt2LUvFWaDTp0+rvC5SpIhRjy+mjJJCoTD53+FVq1bB19fXaMc7f/680Y5FRP/j5OQkql9YWBju379v4mhMhwl3IguWnRnuTLgTUWZCa0JkfEFST7inpaWZ5EuR0Mx5Jtx1u3r1KkaNGoUqVarg8uXLmDdvHhYsWIArV67Aw8MDQUFBGjdnjS05ORmDBg3CuHHjdPa7cOECpk+fjsaNGyM6OhrTp0/Hhg0bsGXLFrx48QLDhw83aZxiiKnFTESWZc2aNZg0aRJ++eUXqUNRUbhwYalDkFyPHj1UXsfExODcuXMSRUNCDh48qNFm7IS7PvHx8QgICDBq2RchixcvNsoMdyIyvZYtW4rqZ82z3JlwB/D06VN8++238PDwgJubG3x8fPDw4UOpwyLK1gx3lpQhosySkpJUXmeeraeecAdMM8tdaNFmJtx1CwsLw4cPH7B48WK4u7sr293d3TF16lT06dMHT58+1br/unXrBJMfDx48QHh4uN7z79ixA5UrV8bixYvRunVrnX3nz58PAJg4caLKTd+OHTvCy8sLO3fu5OcrIsqy3bt3m+wJLMqapk2bapQZW7t2rUTRkJA5c+ZotJkz4a5QKLB7926cOXPGbOckIsvXtWtXUf1MPbHIlJhwx8cLfe/ePezatQsHDx7Emzdv0K5dOyYBSHJCM1LF0jbDnQl3otxJfXZ55rrtQgl3U9RxZ8LdcDt37kSxYsXQuHFjjW3+/v5YvHgxypcvL7hvbGws/P390bx5c5Wk+/379+Hl5YXAwEAcO3ZM5/mXL1+Ot2/fYsGCBdi5c6fOvkePHoWtra1giQVvb28oFAocOnRI5zFMTVstZiKyDky4Wxa5XA4/Pz+VtmPHjnGctSCPHz/WaHNzczPqOXSVlElNTcXMmTONej5rwBJ2RLrVrFkTnTt31tvvwIEDZojGNHJ9wv3GjRs4duwYli5ditq1a6N69epYuXIloqOjcfHiRanDo1zuxYsXKq/11bnMjDPciSgz9frpmZPs6oumAuZLuEtVk9cavHjxAo8ePULVqlXx+PFj9OvXD0WKFIGjoyPq1auHyMhInfuXKlUKq1atwtu3b5VJ94xk+61btzBt2jTBRH5mI0aMwJ07dzB48GCdX6jT0tIQExODkiVLCt7w9fT0BABcv35d/x/chLTVYiYi68D64JanXbt2Gouib9iwQaJoSAxjLpiqT279XWAJOyLd5HI5goKCsHnzZr19+/bta5V5rFyfcPfw8MDOnTtRoUIFjW1CiQEic1JfUT5zOQF9tM1wf/v2LRNcRLmQ+qzAzGMES8pYpozyK/Hx8ahVqxYOHToEHx8f+Pj44Nq1a+jUqZPesjC+vr5Yu3atMunepEkT3L59G9OmTcPYsWP1xuDl5SXq6ar4+HgoFAoULFhQcHv+/PkBcB0RItLUqVMnqUOgbHB0dESXLl1U2nbu3IlXr15JFBGZm64b8mFhYWaMhIisjZgbU5cvX4a3t7fVPeWW6xPu+fPnR5s2bVTu8s6ePRsuLi4aq64TmVNKSorGoi+G1NvTlnAHNEvVEFHOp/4BJXOS3cbGBjY2Njr7GwMXTTVMQkICAODUqVOoUqUKLl26hPDwcKxevRpnzpxBvnz58MMPP+DevXs6j+Pr64tZs2bh9evXuHv3LgICAkQl27MSq9DNm8ztpnhygoisW9++faUOgbKpW7dusLW1Vb5OSUkRNWuRTEvoO596CSBj4JMnmljCjki8TZs2iepnbf+u5PiE+82bNyGTyQR/vLy8NPqvWbMGoaGhmDp1KlxcXMwfMNH/Uy8nAxg2w12oREQGa3wch4iyR1cNd0AzUcoZ7tLLfBMkPDxcpRRKpUqVEBgYiA8fPuj98BkbG6ucYSaXy7Fu3TqcOnXKqLFm/D6ply7KkPH7xM9WRKSuWLFiOHToEMLCwvDVV1/p7MvEnmUqXLiwxrXbvHmz1n8TyPRevnyJ7t27a7TXqlXL6OfKuOlO/8MSdkTilStXTlSuKzQ01PTBGFGOT7iXLl0a165dE/xZvXq1St+FCxeiT58+GDlyJIYNGyZRxEQfPXnyROW1k5OTQf9o65rhzoQ7Ue6j/qVXfYxQT8Az4S49V1dXAB+/tFWuXFlje+3atQEAt27d0nqMe/fuwcvLC3fu3MFvv/2GiIgIJCYmomXLljh58qRRY5XL5VpLxmS0Z/yZiIgyy5s3Lxo2bIjJkyfr7Jeenm6miMhQ6jOnX716hV27dkkUDR08eBBPnz7VaNf1HTGr+N2SiLKrcOHCovr16dMH48ePx40bN0wcUfbl+IS7nZ0dKlWqJPhTqlQpZb/g4GAEBAQgKCgIs2bNkjBioo+E6rfrqo9nCNbQJcp9dJWUEXptrkVTmXDXztPTE7a2tkhNTRWc1fnhwwcAH2/ICnn06JEy2T59+nSMGTMGPj4+WL9+PZKSktCqVSucO3fOKLHa29vD09MTsbGxyrgyy7gpUKVKFaOcj4hyp5YtW5p91nRiYiISExPNek5rVLFiRdSrV0+lbd26dbxJIpHHjx8Ltmcu/WMsTLgTUXY1a9ZMVL8rV65gz549GDhwoMWXqszxCXcxQkJCMHHiRMycORO//vqr1OEQAQCeP3+u8tqQcjL68EMRUe5jaMKdNdylZ29vjwYNGuD9+/c4cuSIxvaMsjA1atQQ3N/NzQ01atTAjBkzMHr0aGV7RtL9008/haenp9Hibdq0KVJSUnD8+HGNbQcOHIBMJkOjRo2Mdj4iyplmz56tc/v+/fvNFMlHLi4uohZ1I6Bnz54qr+/cuWPUp6ko+0wxw71YsWJGPyYR5S5du3Y1qH9CQgJ27NhhomiMI9cn3GNiYjB27FgMGDAAPXv2xJMnT5Q/1rYCLuUs6rXwjPkYPme4E+U+lpBwF5r5fOnSJaOfJycJCAgAAIwcOVLlZumlS5ewcOFCFCpUCJ06dRLc197eHtu2bcOPP/6osc3HxwfHjh1D/vz5jRarv78/ACAoKEjlaYbIyEgcPnwY7du3R4kSJYx2PiLKmZo2bapz+8SJE3H58mUzRUOGaNCgAcqVK6fStnbtWomiyd20PVlgioT70KFDjX5MIspdnJ2d8ddff6FVq1ai94mNjTVhRNmnknBPSEhAUFAQKlWqhDx58iBfvnxo2rQpIiMjzR6Yr6+v3i9lK1euRK1ateDi4gJ3d3f07NkT9+7dM+g8W7ZswYcPH7BkyRIULVpU5Wf37t3Z+SMQZUtSUpLKa20lA3QJCgoSbM/ODPe7d+8iMDAQAwYMwMWLF7N8HCIyL0tIuAvNZv/jjz+Mfp6cxNfXF3379kV0dDSqVq2K4cOHo2/fvmjQoAE+fPiAZcuWIW/evFr311WKzFhlyjI0aNAAQ4YMwT///IMaNWpg9OjR8PPzQ9euXeHh4YGQkBCjno+Icq++ffua7VwJCQm4c+eO2c5nzWQyGXr06KHSdvr0aQQGBmLIkCEYN24crl27JlF0uYu2Jwjt7OyMfq4vvvgC7du3N8qxihUrpnUigTVhKSoiw7m6umLKlCk4e/asqP6WPklamXB/+/YtGjVqhGnTpsHZ2RkBAQHw8fHBxYsX0alTJ0ybNs1sQU2dOhUbN27U2Wfs2LHw9/fH+/fvMWTIEHh7eyMiIgJ16tQx6ANRUFAQFAqF4E/Hjh2z+Schyjr1f6Czssp569at8eWXX2q0r1mzRqNGvFgTJ07EiRMncP78eYwaNQppaWlZOg4RmZe+hLs5Fk3V9uWPZWV0W758OVasWIFixYph2bJliIyMRNOmTfH3339b3GeV8PBwhIeHw8HBAWFhYTh8+DB8fX1x4sQJjVmPRETZIbS2hSk4Oztn6XN4bvX111+jYMGCKm0nTpzAqVOnsHfvXgwcOBAPHjyQKLrcQaFQYOvWrYLbTJFwl8vlGDx4cLaPU6xYMURFRWHcuHFGiEpaLEVFlD0LFizQ2+fEiRNmiCTrlAn3GTNm4NKlSxg0aBDOnj2LkJAQLF++HFevXkXRokXx888/4+bNmyYNJjk5GYMGDdI7wF64cAHTp09H48aNER0djenTp2PDhg3YsmULXrx4geHDh5s0TkPwziZllTFmuOfJkwczZ86En5+fSnt6ejq++eYbxMXFGXS81NRUXL16Vfn61atXou8+EpG0DE24m2IRGm2JdXMvgGdtZDIZ+vbti9OnTyMxMRGvXr3Crl270LBhQ7PHolAodCZKZDIZhg4disuXLyM5ORkPHz7E2rVrmWwnIoOIWTxt3bp1ZoiEDGVvbw8fHx+t25OSkhAcHMzFVE3o6NGjgmX8ANOUlAEAGxubbB9j7NixRoiEiHKCevXq6R2vnjx5gocPH5opIsMpE+6bNm2CTCbDtGnTVB4xLl68OAYPHoy0tDTs2rVL64HWrVuHc+fOabQ/ePAA4eHhegPZsWMHKleujMWLF6N169Y6+86fPx/Ax5m2mS9Ax44d4eXlhZ07d1rMm847m5RVxki4Z1BPrAEfn2oxtJSD0Ac3S3+Mh4g+soSSMtq+/DHhTkREmYl5eic0NNTkcVDWfPPNNyhevLjW7efPn8eWLVvMGFHu8vPPP2vdZqqEu1ye9eUBK1eujE2bNqlMJDDmou5SYCkqouw7cOCA3j4Z+WFLpBwVhw8fjsmTJwsunpXxJfzt27eCB4mNjYW/vz+aN2+uknS/f/8+vLy8EBgYiGPHjukMZPny5Xj79i0WLFiAnTt36ux79OhR2NraokmTJhrbvL29oVAocOjQIZ3HILJ0xigpk0HbB6vt27cbdByh2anGrgFMRKYhdcI9PT1d6+P/TLgTEVFmn3/+uah+T58+NXEklBX58uXD8uXLMWbMGAwaNAjDhg1D0aJFVfqEh4fj0aNHEkWYs2l7wr5UqVIoVKiQSc6ZnYT7mjVrNJ6EG/F/7N13WBTX+zbwe5ciAjZE7KioxBY1Ro0VsWEvIRKxRtHYe+9dsWKLvTc0xlhQsfcSu8Yo+sWGqKjYFVAQ2PcPX/bH7M5WdncWuD/XlSvOmfawsxx2nznznEGD0nUpJ5aiIko7R0dHlClTRus2hw8fRq9evRAeHm6hqPSn7BX79OkjOsGiQqFQjoItX7686EHc3d2xYcMGfPr0SZl0T0m2P3jwAIGBgahVq5bWQAYNGoRHjx6hd+/eWhN4SUlJCA8PR+HChUWTiCl3Qu/evav1fJbCO5tkLNUR7lmzZjX6WGIj3AHDa/iJjU5lwp0ofVBNoKv+DTV3wl1bnXZNI9+JiChzksvlCAgI0LndnDlzLBANGcPV1RV+fn7o3r07fvvtN7VR158/f8aUKVMsVoufoFbNwJSMTbjnypVLtL169erYv38/QkNDsWfPHlStWjUt4RFROqXPDfgrV65g3LhxVvf3RGevuGzZMly8eBEeHh5o3Lixxu38/f2xefNmZdLdy8sLDx8+RGBgoF61uLy9vZEtWzad2338+BEKhUJtIpYUKSP0379/r/NYlsA7m2SM5ORk3Lt3T9BmjhHutra2Bh2HI9yJ0i/VBLpqzXYpE+4c4U5ERKr0GYl78uRJ8wdCJlG1alX4+voK2q5cuYJLly5JFFHGpCnh1KdPH3z33XdmO6+xCfekpCSN65ydneHm5oaCBQti6dKluHLlitlK4hCRddKU+1X18OFDvH792szRGEZrr7h9+3YMGDAAtra22LBhg87RsP7+/pg7dy7ev3+PiIgI9OnTx+QTX8TExADQPGI3pd0ck70RWcrcuXPV2tJSw13TBxNDJ7fhCHei9EvqSVOZcCciInOwxsfISdzAgQORN29eQdupU6ckiiZj+vDhg2i7oQOtDGVswl3b50Mxqu8fIsrYWrRoofeNNmv7TqmxV1y2bBnatWsHANi4caPOkjDAt1ruixYt+nZguRxbtmzBxYsXTRTqNykJAU0vZEpCwdnZ2aTnJbIUhUKB7du3q7WbY4S7pvp+mrDsA1H6JXVJmQsXLmhcZ20fjoiISHrVq1fXa7v27dvj7du3Zo6GTMHJyQlt2rQRtJ09e1bjqOyXL19iyZIlWLVqFa+xnl68eCHabmgpUUNpGhCpS6lSpQzaPjk52ajzEFH65OTkpMwz62Jt+Sq1hHtycjKGDh2KPn36wN7eHn/99Zcy8a7N48eP4e3tjUePHmHmzJnYtm0bYmNj4ePjo/VLtqFy5MgBuVyusWRMSnuOHDlMdk4iS0p5ikOVOUa4GzqC1do6MCLSn2pS29KTpk6ZMkXjOvYtZCmxsbEG32wmImm4u7vj559/1mvb9evXmzcYMpmaNWsKlqOiohAZGam2XUJCAvr27Yt169ZhxYoVaNu2rUnzChlVdHS0aLu5R7gb+9TzoEGDDNre2mo0a8LPG0SmU7lyZSxZskTndqrzIEpNkHBPSEiAn58fgoKC4OLigiNHjuj1IScqKkqZbJ81axZGjhwJPz8/BAcHIy4uDo0aNcLVq1dNErC9vT2KFy+OyMhI0S/oDx48AACdM9kSWStNjwGmJeGuacSBoQk1sd+5lMcAFQoFLly4gFOnTmmtxUdE0lB9ZFf1i5e5E+7abvCZ+lxEmjg7O6NYsWJSh0FEeho7diz+/vtvndsFBwdbIBoyhZIlSyJPnjyCtnPnzqltt2/fPkRERCiX3717h/79+/Na66Bp8Ja5R7gDhn9frVevnsF5m/Qywp2fN4hMq3Llyjq36dy5M3r27GmBaPSjTLgnJyfDz88PO3fuRLFixXD+/Hm9ysgA32Ygr1ChAmbPno0RI0Yo21OS7uXKlUPx4sVNFnSdOnWQkJAg+of56NGjkMlkanfOidILTU9vmKOkjL5lHJKTk7F161bRzislibdw4UL069cPQ4cOxfDhw42OlYhMLykpSe0LiqVLymjDEe5ERKRJkSJF9PpsKTZK2hQ4UtW0ZDKZWrmglO/1ycnJSEpKQlJSkuhTCwqFAgsWLMD9+/ctEWq69PnzZ9F2c49wB7Q/zShmyJAhBp8jvSTcici0bGxsMG/ePJ3bXb16FZUrVzbbZwJDKBPugYGBCAkJgbu7O86cOWPQDNb29vbYtWuX6AchPz8/nD17Fjlz5jRJwAAQEBAAABgzZozgD8ru3btx6tQptGzZEoUKFTLZ+YgsSdMI96xZsxp9TE0j3L9+/arXY3nnzp3DvHnzRD/AJSYmIjk5GZs3b1a2nT592io6OCL6RuzmmupIJ3NPmqoNa7iTpcTExODRo0dSh0FEBmrZsqXObXx9fc1ybo5UNT3VgX3Xrl3Dxo0bUbt2bTRs2BBt2rRBVFSU6L7Jyck4ePCgJcJMlzSVVLBEwt3b2xseHh56b58vXz6Dz2HoJKtS4ecNItOrWbMmypUrp9e248ePN3M0utkC3x7PCgwMBAD88MMPWLVqlejGXl5eqFevnug6bTW7jK3npUn16tXRt29fLFmyBBUqVEDr1q3x9OlTbN++HXnz5kVQUJBJz0dkSZoS7sbO/A5oHuEOfEu665r1efbs2RrXJSUlaSzv5O7urn+QRGQ2Yr+jqgl31Rtzpk64y+VyjaOSmHAnS3FycrK6+o5EpFvWrFmxZs0adOvWTepQyASqVq0KGxsbZRnKr1+/KifFi4+Px8ePH7Xuf/z4cfTt29fkeYaMQMoR7gCwevVqzJ07Fw8fPsTdu3c1bjdhwgSjjv/bb79h/vz5xoZnMfy8QWR6tra2WLVqFZYvX44NGzZo3fb27duIj483ekJnU5ADwOXLl5WPye3ZsweTJ08W/e/48eOSBapq8eLFWLx4MbJkyYJFixbh1KlT8Pf3x/nz5w26q0pkbcRKyjRs2DBNx9SWUH/48KHO/Z8/f65x3fz580VHGqTlBgERmZY+CXfVEe6avrAZy83NTeM6JtyJiEiXChUqYM2aNVq3CQsLM/l5OVLV9JydnVGhQgW9t095wj1FZGQkr4kGmsofmbLErzbZs2fHlClTBE8/q5LL5ahWrZpRx/f29kb27NmVy61atTLqOESUPtnZ2aFv3756bSv1d0xbAPDx8bG62Z51xSOTydCvXz/069fPQhERmUdycjJ27dqFly9f4ueffxZNuKf1cRhtCfeOHTvi4sWLsLGxMerYb9++FZ1PgSNOiKyHWMJdtV/InTu3YPndu3dISEjQ+QRMWmJIIfWHISIiSh90JWk7d+6MnTt3mvQpS45UNY+aNWvi2rVrOrfz8PBAr169sG/fPkRHRyvbT548yYF2IsQGTAwaNMiqyiKtXLlS60AMbQoWLIgtW7bg+vXrKF26NIoVK4YTJ06oPRXh7++Pbdu2CdqcnZ0RFxfHOvBE6Zy+gzvj4+ORLVs2M0ejGYegEknsjz/+QGBgINauXYvOnTvjxYsXgvVt2rQxeMZ3Vc7OzlrXnzx5Mk3HHzNmjFobE+5E1kOfGu558+ZV2yb1F9u00pZw56SpRESkL10DUX755RcLRUJpUaNGDdF21URsv379IJfL4e3tLWg/ceKEuUJL11RvDv3222/o2LGjJLGITaLauXNnVKxYMU3HzZ8/P5o2bar1JoJYUn3jxo24cOFCms5NRNZhxIgROrcZMGCApIPLmXAnktjGjRuV/3737h1CQ0MF600x4bCrqyvKlCmjcf2zZ8/SfA5VTLgTWQ+xsk+qtTydnZ3Vbu6p3gA0dQwp4uPjTXYeIiLK2HR9xrS2J7dJXIkSJdSS61WrVkVISAjmz5+Pzp07Y/HixfDy8gIAtYT7nTt3TPo5JaNQTbhnzZpVokiAunXrCp6gtLGxQZcuXSxyboVCgZEjRyr7i2bNmsHd3R1yuVzvSRdTaLo5RETS8fPzw4wZM7RuEx4ejps3b1ooInVMuBNZuRw5cpjkOH/88Qd69+4tui5lwqKPHz8iODgYoaGhaX7UbuHChQgPD8epU6d0TnyUWnJyMjZt2oTu3btj0aJFypG5iYmJ+PDhAx8BJDKC6gh3W1tbtUfxZDIZ8uXLJ2gz5RdZjnAnIiJTqFu3rtQhkAnIZDL06tVLuezp6YmZM2fC1tYWtWvXxoABA1C9enXl+kqVKglqdwPA2rVrLRZveqH6mUrKCQOzZs2KQ4cOITQ0FEuXLsXJkyfVrqG5JCcnw8/PD3///Te2bNmCSZMmKddVqlRJ7+MULFgQffr0MUOERJQWMpkMPj4+Orfbv3+/BaIRZ5mpqonIaC4uLiY5Tvbs2dGtWzcsW7ZMbV1SUhKmTp2KPXv2KNvu3r2LIUOG4Pr160ad79GjR2jfvr1yOTg4GJ6enjr3++eff7Bw4UIAwI0bN5A/f37UqlULAwcOxMOHD1GxYkXMnz9f0lpcROmN6pcv1XIyKfLkySOYSPndu3cmOb9CoWANdyIiMgl+Bsw4WrZsibJlyyI6Oho//vij1nljbG1t4e3tjZCQEGXbzp07UatWLeUoeNL/M58lubm5GV2zXR9iT724uroCgOh8Dp07d8aOHTuUTwMMHToUnz9/RmxsLHLnzo0LFy6gYMGC6Nq1q1njJiLzU32q26LnluzMRKS1xEIK1YkMzeHy5cu4evWqoC04OBhDhgwRfKhNi/bt2+uVdJ88ebJgedasWYiMjFQmAW/cuIF9+/ahXbt2JonLVE6dOoXz58/jxx9/1OtOK5El6fvlS/WJGkOeTtEm5SkaTZhwJyIiQ9jb22v92/HmzRuLfIamtCtevDiKFy+u17YBAQE4cuSIYGLQqVOnYvv27ciVK5e5Qkw3rl69iitXrgjatN3EyMjatm2rcV3OnDmxdetWHD58GEWLFlV7aib1oDEism4BAQFan3aysbGxYDRCLClDJCGxWeRVpdydNyfVZHtqDx48MNl5lixZAgAICwvDggULsHPnTrVE3Nu3b9X227p1q2B53rx5JovJWHFxcdixYweOHDmCy5cvY+jQofj7778xZswYnDp1SurwiASMTbh/+PDBLOdXxYQ7EREZYtasWVrXb9682UKRkCUVKlQIQ4cOFbS9e/fOZAOE0rO4uDgMGjRIrV3K0Z1S0lW6JmUEu7lKVMXGxiI2NtYsxyai/6NrUmjVMqqWlDl7XyIroU/C3dSjc2Qymd6TSSUnJyMsLMxk5z537hyePHmCzp07K9tmzJiBv/76S+ss81L78OEDtmzZArlcjo4dO8LJyQldu3bVeDNi7Nix2Lt3L8LCwlC8eHG1uthElqaa0NY02kn1y4mpRrjrSrizhjtpo1Ao0KRJEzRu3Fg0mUBEmU/t2rW1rt+0aRMGDhxooWjIklq1aoUTJ07g3LlzyrY7d+5IGJF1OHDggOh3S2soKWNuuiZSloKzs7PUIRBlCrpurnGEO1Em9eXLF53bSPnHumrVqiY/5uLFi9XarH0UUv/+/bF27VqsXr0aw4cPx8WLF7WO/P/y5Qv8/f0xcOBANG/e3IKREomTuqSMrhHsHOFOmiQmJqJnz544dOiQ1KEQUTqzc+dOqUMgM5DJZKhTp46g7fHjxxJFYx2ioqIQGBgoui6zlpQhosyjcOHCGtdt3LhRr1LO5sCEO5GEUiZq0cbUd+ylfqxQrHxN6slajREZGYlp06ZhwYIFiImJSdOxxI6depT/5cuX1Wojinnz5o1J4yBKC30T7qojBExVUkrXI7VMuJOYsLAw1KhRA0eOHEHOnDmlDoeIrEy1atW0rp8xY4bOOUQofSpSpIhg+fHjx0hOTpYoGuktXbpU47rMMMLdGsXExODRo0dSh0GUKYwaNSpN682FCXciCelTUsbUpP7QpemLz/nz53Hv3j2jjte9e3fs3r0bmzdvVpt0NbXY2FgcO3YMd+/e1fv479+/V2vT58kEImtibEmZN2/emOTmka6EO0vKkJjTp0+jevXquH79utrTF0REqqOcxURHR1sgErK0okWLCpYTEhLw4sULaYKxAgcPHtS4TurvfpZgjSVlnJyc4OTkJHUYRJnCTz/9BF9fX43rT548KckodybciSQkRcI9S5YsFj9napo6ugEDBhg1I/y5c+cEE62eOHFCdLv4+Hh06NABI0eORMeOHVG5cmVUrlwZ69ev13p8fevdE1kzfUe4i03SfObMmTSfX9eTJxzhTmJ69eqFhQsXcnQ7EYlq2bKlzm1atGiRqUc+Z1QuLi5qyczMXlZGk8yQcOf3NSIaPHiw1vUDBgywUCT/hwl3IgnpSrinnlzUVKSu46ft0V5jPiyJjUCfMmUKfH19ERQUpEw07t27F0+fPlXb9o8//sD169eVx1Idvc4PcJQR6JtwL1WqlFrbu3fv0nx+JtxJ1f379yGTyUT/8/b2ljo8IkoHsmTJonVkb4qtW7em6TyxsbE6n9Qiy5LJZGqj3CMiIiSJxdpJ/d3PElg6ioiyZs2KYsWKaVx/6dIl3Lx504IRMeFOJCnVhHvu3LlRsGBBAICbm5vWx2KMJfUId1N/IBKrSR8SEoLIyEgEBwcrR7yfPHlS4zF+//13TJgwAQ0aNECLFi3w77//KtfpU2efyNqpJtw1ffmSy+VqkyXHx8en+fwfPnzQup4J98ynSJEiuHPnjuh/GzdulDo8IkonxJ7MUjV//vw0ncPZ2Vnrl3iShlgdd1In9fxdlsCEOxEBwJIlS7Sut3Qt94zf+xJZMdWEu7u7OxYtWoQnT56gYMGCZqn7JvVjhaZ6rPfr16+wtbVVjk7XZMyYMRgzZozO44WGhgL4Npo3KCgIGzZswI0bN0QfPWJykNIb1festn4gT548gmVTJNzv37+vdT1ruGc+dnZ2ok9UEBER6UN1hDsT7uKk/u5nCSwbRUTAt0GrFSpUEAygTC06OhoKhcJi8z5whDuRhFQT7lmzZkXWrFnh6elptklW0vpYobu7u1VMXle9enXUrFkTu3btMvmxb9++DQBYsGCB6PqdO3ea/JxE5qQ6d4K2L1+qT8GYIuH+/PlzwbKHh4dgmTexiIjInKKioozeNyYmBo8ePTJhNGQKLCnzja5kc2YoKcMnUIgoxdChQ7Wu79+/v8Vu0jHhTmRhCoUCb9++xdevX0UT7ubWqVMno/ctUKAAdu7ciWPHjpkwIuOZO0l369Ytsx6fyFIMGeHu4OAgWFad18AYqiPYVSfBZMKdiIjMKS113J2cnMw2EIaMp1pS5tWrV5myFKSuz1CZYYT7sGHDBMsjRoyQKBIiklqZMmW0rr9w4QIGDRpkkbn6mHAnsqDExEQMHDgQPj4+8PX1VY6kTmGJhHu9evVQsWJFo/YNDAxM07nlcnY5RFLQt4Y7oD7C3RwJd9XEBUvKGObEiROQy+Xo2LGjxc/t7++PQoUKad1m3bp1qFSpEpydneHm5oaOHTvyUX8iMpvx48fr3Obvv/+2QCRkSYULF1YrC5AZ/9Yw4Q5UqFABU6ZMgZeXF3r37o1ffvlF6pCISEI7duzQuv78+fM6SxObArNfRBZ08OBBnD9/HsC3Egsp/05hiYS7ra0tVq5ciaZNmxq8b65cuZT//vXXXw3e3xI/n6lER0dLHQKRyagmtLVNoKU6wt0UJWVUz+/o6ChY5gh3/X38+BFdu3a1yKgMVTNmzMCff/6pdZtRo0YhICAA8fHx6Nu3L+rXr49t27ahcuXKaSrJEBERgUGDBhm9PxFlXI0aNULr1q21bpOQkCBJv0nmY29vjwIFCgjaMmPCXdfntMxQUgYAmjZtiqCgIHTr1g02NjZSh0NEEipatCg2b96sdZsePXqYPQ4m3IksaN68eVrXWyohLZfLUbZsWYP3S10GYujQoRgxYoRBoybS0wh3Y25IEFmrDx8+CJa1PRpvjhruqjXkVc/PhLv+Bg0aZPGEwpcvX9CrVy+MHTtW63Y3btzArFmzUKtWLVy/fh2zZs3C1q1bsWPHDrx+/RoDBw60UMSaxcbGIjY2VuowiMiEHBwcMG7cOFy5ckXrdlWqVLFQRGQpqmVlMmOtfV2foVQ/15Fl8PMGkbS+++47ndvcvHkT165dw9u3b80SQ/rJfhGlcwqFAp8+fdK6jSVHgBvz4St1fDY2Nvj111/Rt29fvffX9fMTkXmoPrHh5uamcVtzJNx1jXBXnc+CxO3duxfr1q1Dy5Yt9d5ny5YtuHr1qlr706dPsXjxYr3OWbp0aaxYsULnjcglS5YAACZOnCgYUde6dWt4e3tj3759ePbsmd6xm4OzszMnVyPKwAYPHix1CGRBqpOw379/X6JIpHPz5k2t6zPLCHdrw88bRNJSLTkmJiAgAD169ECbNm1w7949k8fAhDuRhTx8+FDnNqpJKHMyJuEu1mlpK01BRNbh5cuXguW8efNq3NYSI9zF+roXL16k+TwZ2evXr/H777+jdu3aeo8Uj4yMREBAABo0aCBIuj958gTe3t4YMGAAzp49q/UYa9aswadPn7B06VLs27dP67ZnzpyBra0tvLy81NbVr18fCoUCJ06c0Ct2IiJjdOjQQeoQyIJKliwpWDZHwsSaKRQKnXMYpKcnjImIpPDx40csX77c5Mdl70tkIbdu3dK5jSVHuJuqth1r5JkeH0EkU0pOTsarV68EbdpGuKvWcDfHpKliCfeNGzem+TwZWe/evRETE4N169bp/eXZ3d0dGzZswKdPn5RJ95Rk+4MHDxAYGIhatWppPcagQYPw6NEj9O7dW+tIkaSkJISHh6Nw4cKio+mKFy8OALh7965esZtLTExMpiw5QESUEakm3KOiotC1a1d07twZZ86ckSgqy1H9fEfWg583iKRnSJngU6dOmfz8TLgTWcj79+91buPs7Gz+QP6/mJgYtTZjRr1zhLvp8RFEMqX379+rJbwtXVJGnxHuYmVP6JstW7Zgx44dmDVrljJxrS9/f39s3rxZmXT38vLCw4cPERgYiFGjRunc39vbG9myZdO53cePH6FQKODi4iK6PmUOEH3+FpqTk5OT1jkMiCj98/b2ljoEspCiRYuq3YT+77//EBYWhhEjRuDp06cSRWZ+X758YULXivHzBpH0SpUqZdD2ukp0GYoJdyIzOXv2LBYuXIjr168DEE9wq7Jkwl11FCtgXMKdI9yJrJtq/Xa5XA5XV1eN25sj4f78+XPBMr+A6O/Zs2fo378/6tatiz59+hh1DH9/f8ydOxfv379HREQE+vTpo1ey3RApf+M0/R1JaTfFExNERNqUKVNG6hDIQuzt7VG0aFHRdV+/fsXKlSstG5CFREZGws/Pz6C5tIiIMhtD5r0CvtV0Dw4ONtn5mXAnMoNz585h0KBB2LRpE3r16oXw8HC9Eu6WTELVqVNH8Nh/tWrVlCMQDcER7qbHRxDJlCIjIwXLbm5uWkuSqN6Mi4uLS9P5X79+rdYmNsJdn1HUmVG3bt2QmJiItWvX6jX5j5jIyEgsWrQIwLcbLlu2bMHFixdNGabyfZOQkCC6PuXGjSVvLBMRUcanWlYmtYMHDyIqKsqC0VjG9u3b1QYzEBGRkLOzM1avXm3QPkFBQSY7PxPuRGawZcsW5b+TkpKwadMmfPr0Sed+lkxEODk5Yfbs2ShXrhxq1qyJUaNGYdCgQQYfR2ykPKUNH0EkU4qIiBAsaxoJliJ37tyC5bi4OHz8+NHo8+/atUutLUeOHGpthQsXNvocGdXy5ctx6NAhzJ07V+d10+Tx48fw9vbGo0ePMHPmTGzbtg2xsbHw8fHBhQsXTBZrjhw5IJfLNZaMSWkXu/ZERKZUokQJqUMgC9KWcE9OTsb69estF4yFbNu2TeoQiIjShYoVK0p2bibciUxMoVDg0qVLgrYDBw5Y3Qh3AKhVqxbWr1+PhQsXolChQqhRowbatGljUELEmDI0RGQ5qgl3XfMD5M+fX20EfFpqoD579kytTS6Xo23btoI2fW5KZjYpX6h79uwJmUym/K9u3boAvt3clclk6NKli+j+UVFRymT7rFmzMHLkSPj5+SE4OBhxcXFo1KiRyWrn29vbo3jx4oiMjFSbMwAAHjx4AIClHojI/HRNBk0Zi7aEOwCcOHHCQpEQEZE18vX1leS8rAVBZGJPnjwRbdenRIjUj9rb2tpi1KhRGDVqFCpXrqzXPnZ2dmaOiojSQrXv0TVS2tbWFvny5RM8gv306VOjE6ViZac+ffoEDw8PQVt4eLjex/z8+TP27NkDOzs7tGzZMsP2Q126dBGd/C8iIgIbNmzA999/D19fX40jN1xdXVGhQgX06dMHw4cPV7b7+fkBABYsWGDwJKza1KlTB6tXr8a5c+fU4j569ChkMhlq1qxpsvMREYmRy+U4fvw46tWrJ3UoZAG6Eu7v3r1DXFycaDm79OTy5csICQnROXCCiIiE/P39sXPnTouflwl3IhO7deuWaLvYKE9V1vRBcPTo0QgMDFQujxw5UnQ71nAnsl6vX7/G/fv3BW36fFErWLCgIOH+4sULk8ZVsmRJtVHQUVFR2L17N1q3bq1z/wEDBignpL58+TJmzpxp0vishaaR6ydPnsSGDRtQvnx5TJo0SeP+9vb22LVrl2jtdz8/P7Rp08bouvBiAgICsHr1aowZMwbHjh1D1qxZAQC7d+/GqVOn0KpVKxQqVMhk5yMi0iR79uxo3769SSc/I+uUJ08endu8fPkyXSeqo6Ki0KdPHygUCoP269atm5kiIiJKPzw8PDB+/HhMnz4dycnJOrfv2bMnGjZsiF9++SVN35VYUobISImJifjrr7+wcuVKvHr1Stn+33//GXU8R0dHrRMZWlqTJk3QsGFDZM+eHQ0aNECzZs1Et9OWcDd0ggoiMq3Tp08Lvpw5OjqiXLlyOvfLlSuXYDkt5V4+f/6s1ubq6io6SfMff/yh80PQ06dPlcl24NvI6bRO7JqRafuQaMpkOwBUr14dffv2xT///IMKFSpgxIgRaN++Pdq0aYO8efOadBIiIiJdOMI9c5DJZKhevbrWbUw9cMDSli9frleyvXbt2ujWrRsKFiyI+vXro0OHDhaIjojI+rVq1Uqt9LMmV69excyZM3Hjxo00nZNDU4mMNGfOHPz9998AgJCQEOzatQt2dnZGJ9ylLiejytHRUTDCXRNtCXdr+5nSi9jYWMTGxkodBmUAd+7cESzXqlUL9vb2OvfLnj27YPnDhw9GxxAfHy9Y7tWrFwCIxvH+/Xu8fPkS+fPn13i8t2/fqrV9+PDBqp4QyswWL16MUqVKYcWKFVi0aBFy584Nf39/TJkyRa2MEBGROZnqpiI/l1m/33//HVevXkVCQgI8PT2RmJiIhw8fKte/fPlSwujS7u7du3ptlz17dvTu3Ru9e/c2c0REROmTp6en3qVMf//9d1y5csXoczHhTmSE5ORkZbId+DZq4p9//kHVqlUNqkOcWnpNTouNUk1h6UlgM4r0+l4g66OaKC9SpIhe+6km3NMywl014Z4y0bKmxH9UVJTWhLvYfpktEeLt7W3wY+Wmouu8MpkM/fr1Q79+/SwUERGROE9PT5Mch5/LrF/58uVx8OBBREREoGzZshgxYoQg4Z7eR7gnJCTotV2OHDnMHAkRUfqm+iS3LmfOnEHt2rWNOpf11K8gSkfERkncvHkTd+7c0asmlJj0mpwuUKAAvv/+e9F1+oykJSLzUU24qybSNTHnCPeUhLumiU5Vt1eVmJio1hYTE2NkdERElFFlzZoVPXv2lDoMspDs2bOjfPnysLGxQd68eQXr0vsIdybciYhMw9C82+DBg40+FxPuREZ49OiRWltMTIzR5WSA9JtwB4AFCxbAz89P0Fa5cmXY2Njo3LdAgQLmCivdiomJEX2PERnq48ePgmV9v4ipJtxVj2OIL1++CJYdHBwAaL4hJ5ZQT03sS2dSUpKR0RERUUb2+++/Y+nSpWk6Bj+XpT/58uUTLHOEOxERATDqRvzu3buNOhcT7plccnIydu7ciaFDh2LZsmWIjo6WOqR0IfUjiikePXqEW7duGX3M9Py4ao4cOTBy5EgEBQXhu+++Q9WqVTF69Gi9Eu4LFiwwf4DpjJOTU7q+AUPWQzVRru8Id9UvbGlJuP/vf/8TLOsa4a4r4X7u3Dm1tjdv3hgZHRERZXTayh/qg5/L0h9NCfeEhAQEBwdj6dKl6ep7LxPu6Q/nfiCyTsWLF1d+H9XXtGnTjDoXa7hnYgqFAkFBQdi2bRsA4NSpU9iwYQOaNGmCTp06cXIzLcRGuTx69AhyufH3sDLCB3kvLy94eXkpl3V9OKxYsSLfZ0RmZKqEe1RUFIKDg9GkSROD6t7Fx8erjT7XVcNdV8J9w4YNam1LliyBj4+P3nERERFRxqWacH/58iUUCgVmzZqFPXv2AAD279+PPXv2wNbW+lMiTLinP+l5MB1RRnfgwAE0adJEZynT1CIjI+Hu7m7QeTjCPRPbvHmzMtmeIjExEXv37sWvv/6KQYMG4dq1a5JNzGbNxBLub9++xevXr40+Zkb8o6ythnudOnU4up3IjBISEvD582dBm75fxFRrnwJAUFAQOnTooPeXPgC4evWqWlvKF1tjEu6a/h49e/ZM75iIiChz4eCOzEf1c0xCQgLevn2rTLYD35Lwly5dsnRoRtE1GCEFE+5ERLplz54dmzZtQvv27dG5c2e99vH19cX79+8NOg8T7pnUwYMHsXDhQq3bnD17Fj169ECXLl1w/PhxoycDTe+ioqIEjxwqFArRkjKqnJ2dIZPJ9D5PqVKljIovverdu3eGvMlAZC0+ffqk1qbvCPe8efOKloSKjo7GqVOn9I7h3bt3am0pXxo1jSjT9qWSj+YSEZGhbG1t4ejoKHUYZEGurq5qTx5fu3ZNbbv79+9bKiSLYMLdenDuByLr5uHhgSFDhsDf31/vfQydE4YJ90zo0qVLmDRpklq7ptGGt2/fxogRIzBgwACDHrlI72JjYzFmzBi0bNkSTZs2xebNmwEAr1+/RkxMjM79y5cvrzG5VbFiRXTv3h0FCxaEi4sLfvnlFzRo0MCk8Vu79PD4JlF69uHDB7U2fRPucrlc7XHsFGfPntU7hqxZs6q1VaxYUXkOMVOmTEFkZKTouqioKI3nUq0VT0RElKJx48ZSh0AWZGNjgzx58gjaLly4oLad6sTu6R0T7taDcz8QpQ/6PkEEADt37sTevXv13p4Jd4n8+eefaZqEzljh4eEYNmyY2ptqwIAB2LdvH7p3764xIXPhwgUEBgZm+BIzUVFRmD9/Plq3bo3Dhw8r21euXImEhAQ8fvxYr+OUK1dO44eeihUrolevXtizZw8OHz6M0aNHa5xAML0bMmSIaHvqiSpat26ttj71DSBNxyAizVT/xjg5Oek1kXGKAgUKiLYb8jfg69evam2pJ68rXry46H6rVq0Sbdc2qiA4OFjvuCh9USgUaNy4McuQEZHRmjdvLnUIZGGqAwfEEu4pk6lmFA4ODlKHQESUrhg6ger06dP1rv7BhLtEVq1ahaZNm2LmzJmIiIiwyDmfP3+OAQMGIC4uTtDu7++PTp06wcXFBb169cL+/fsxfPhw5M+fX+0Y+/btw/bt2y0SrxRevXqFDh06YMuWLWqlEOLi4vD8+XO8efNGr2N9//33GhPuLVu2THOs6UW7du1QrVo1tfbUr027du3U1h84cABjxozBH3/8gfbt26cphkKFCqVpf6L06Pnz54JlQyY7BTQn3A2Zq0L1qagyZcoIlgcOHCi634EDB0TbtY2u379/v95xUfqRmJiInj174tChQ1KHQkTp2Pfff8/JtTMZ1TruL1++VNtG25Nz1sKQuXMMKWdKRERA7ty5UaJECb23T0xM1PvpKCbcJfTlyxfs2LEDbdq0wYABA3DhwgWzjR7/+PEj+vfvr5YoqV+/PoYMGSL445w1a1a0bdsWu3fvxvTp09VqHs6bN0+0Bl5G8Oeff4rWPU7x9OlTvH37VudxZDIZypYtK5pwr1SpksGzG6dnMpkMVatWVWtPXWqiePHi+OGHH5TL7du3R44cOeDr66tM1o8bN070+G5ubjpjGD16tKFhm4wx1zo2Npa1qinNVOeaKFq0qEH7a7phqM8HDIVCgZ07d2LKlCmCdtXSZTVq1ED16tUNiosyj7CwMNSoUQNHjhwRPBlBRGQomUyG6dOnSx0GWZCmp+hSUx2cYI30KWVKRETG0/R0dVox4W4lzp8/j379+uHXX3/Fzp07TVpPLj4+HoMHD1YbSf/DDz9g6tSpGuvo2tjYoFGjRpg8ebKgPTk5GSNHjsxwj+B9/foVISEhWrfRN+H+yy+/IHv27KJ12zJbrXYAqFevnmA5V65caiMwlixZgqlTpyIoKAiDBw9WO4ZY2RkAWLNmDU6fPo1Lly7hypUrorNM//TTT/jll1+M/wHSwJibaM7OzihWrJgZoqHM5MGDB4JlDw8Pg/bPli2baLs+I63++ecfzJgxQ61dbK4QTfOHEJ0+fRrVq1fH9evXWZeWiNKMo38zlxYtWuicLPfFixd6lwaQir6DcPr06WPmSIiIMqZs2bJpHOApJikpSa/tmHCXiKYk96NHjzBjxgw0bdoUf/zxB6Kjo9N0nuTkZIwbNw7//vuvoN3DwwPz5s3TK9FRt25ddOvWTdD27t07DBs2LENNonrq1CmdyXSxhHvDhg0FNQIbN26srDn+5MkTtWPUqVPHBNGmL4UKFVImzLNkyYJRo0apbWNvb48mTZrAy8vLoC9Ecrkcjo6Oyt8pTQnu7t27i5a2MTdTPrXy5MmTDPU7R+alOsJdn5FeqdWvX1+0Xawuu6qJEyeKtov9zeEEyqRJr169sHDhQo5uJyIig7m5uWHo0KFat0lKSsKrV68sFJFxdI1w79q1KyZMmIAuXbpYJiAiogyoRYsWem+r7+BjfsuVyObNm3HixAns3LlTdPLUjx8/Yv369di4cSMaNGiAdu3a4fvvvzfoHAkJCZg/fz5OnDghaHdzc8PixYs1To4qpmfPnvjf//4nqJ979+5dTJ8+HZMnT84QI0Z27twpWK5YsSIqV66M1atXK9uePn2q9rMWL14cgwcPxtmzZ1G0aFH88MMPym3q1q2LsLAwwfaq9QQzi3HjxqFbt25wcHAwuJa0Nvq+9/LkyYM//vgDPXv2xNWrVwXrKleujCtXrpgsptRy585t8D4xMTF49eqV2ij3rl27ws7ODrly5UK+fPmQL18+5M+fX/nvlP/EniAQk5ycjPfv3+Ply5d49eqV4P9fvnxBgwYN0KBBgwzx+53Z/O9//8PTp08FbYaOcHd3d0efPn3UJirVJ+GuOgdGCibcKcX9+/dRsmRJ0XV16tTByZMnLRsQERFlOC1btsSxY8dw/vx5jds8f/7cqr+faRvh7uzsjL59+1owGiKijMnGxgYFChTQa26P9evX61Wmjt9yJeLm5oZ+/fqhe/fuCA0NxdatW/Ho0SO17ZKTk3H48GEcPnwYZcuWRfv27fHTTz/h7du3ePPmDV6/fo3Xr18r/526TawWuZOTExYtWmTwhwq5XI6pU6fit99+Q2RkpLI9NDQUpUuXFp30MoVCocD169dx9+5dVK1a1aAJCYBvr0FKMrRKlSpmSf69e/cOly5dErT5+vqqPWL49OlTtTIxLi4ucHNzg6+vr9pxvby8sGzZMuVxJkyYYOLI0xexiXhNzc/PD5s2bVIuV6hQQec+3bt3T3PCfdCgQViwYIFau66RNWKcnJzUJjdO7d27d3j37h3u3Lkjut7e3l4tCe/o6Ijo6GhBYv3Vq1dITEzUeJ5jx47h3LlzGDVqFBwcHAz+OUg6+/btEyznyZMHnp6eBh8nICAAnp6eGDRokLJNn4S7JmIJd03vrWvXrqFSpUoGHX/cuHEYO3asYI4Isk5FihTR2IfpKgFARESkD5lMhnHjxqFp06Yat4mKikLFihUtF5SBtCXcs2TJYsFIiIgytmHDhimrVWhz6NAhJtzTAwcHB/j6+uLnn3/GxYsXERwcrPEO/O3btzF27Fijz2VnZ4d58+YZnPBOkS1bNsydOxddunQRJAPnz5+PV69ewc/PTy2hGh4ejvnz5+Py5csAvn3oadWqFfr166f3I+JTpkxRJo9q166NWbNmaS2F8/r1axw7dgyXLl3CvXv3ULBgQYwdOxaFChXSuI/ql34HBwc0aNBAbXT6s2fP1EYsaxutXbx4caxcuRLHjx9H2bJl4ePjo3Fb0s3d3V1wwwcAXF1dBcsFChRAQEAA1q5di9y5c6N///6C9fXr1xeMcLe1tdWadNZH+fLl4e/vj/DwcISGhgL4diOmR48eKF26dJqObYyEhARERkaqvVbG2LdvH+7cuYPZs2ejSJEiJoiOzOnjx49YtWoVtm7dKmhv0qQJbGxsjDqman+rTw13fY8FQHSuCwCYOXMmtm/fbtDxDx48iCpVqqBVq1ZGxUeWY2dnh1KlSkkdBhERZXBubm6YNGkSJk2aJLre2idO1VZSJi2DIIiISKhatWpo0KABjh49apLjMeFuJWQyGapVq4Zq1aohIiICf/75J/bu3WvSyVMnT56MypUrp+kYHh4emDJlCoYNG6ZsS05OxsaNG7F582bUrl0bbdu2RbFixbBs2TLs3btXUMNaoVBg9+7dOH78OPr06QNfX1+N9eyBbyPKU4/UPHPmDIYPH445c+aIJm5u3ryJvn374vPnz8q2qKgozJ8/H1OnTsWff/6JJ0+eoFWrVoKRz3fv3hUcx9PTE/b29mpJ+oSEBLUPZS4uLhrjB76VprHmURPpiZ2dnVqb2PunT58+6NGjB+Ryudr6li1bYuvWrXjy5AnkcjmmTZumddKLSpUq4dq1a2rt27Ztw7Vr15CQkABfX1/Y2tpiypQpmDJlihE/mXV78OABOnXqhHHjxvGmkZWbM2cODhw4oNbu7u5u9DFVS76k5cud2O+wpoS7ag16fSc1mzp1KhPuREREpNS8eXMkJCRg//79anOb6VM+QEqpv9eqEitNS0RExrG3t0dgYCBGjx6tcT4zQzDhboWKFi2KkSNHonfv3ti9eze2b9+ud1F+Mbly5cKAAQNMlijz9vZG9+7dBbXNgW/JkFOnTuHUqVOQyWRaJ4v8+PEjZs6cid27d2PGjBkak0Gq9ecB4Ny5cxgxYgRmz56tlnRfu3at6IeSK1euYPXq1di4cSMA4Pjx49i2bZtyslPVhHvKqOTcuXPDwcFB640PXQl3Mh1Dyglpqgvt4OCALVu24OLFiyhYsCA8PT3x33//qW23du1axMTEoGrVqmqTrXp5eaFEiRJGPy1irJCQECQlJeHFixei/718+VLvGbNTk8vlcHV1Rd68eZEnTx7kypULBw4cEDzJEhcXhzFjxuDGjRsYNGiQXhMuk2UpFArRZDvw7QklY6le648fP8Lf3x9v377F77//Dj8/P72PJfbos6aEu6q0PolCREREmZevry98fX2xfv16/PHHH8p2a0+4x8fHSx0CEVGmIZPJkCNHDpMciwl3K5Y9e3Z07twZHTp0wMmTJ7F161bcuHFDsN7V1RW5c+cW/F+1LVu2bCave96jRw98/PhR4+P+2pLtqd29exd9+vTBpk2bREuziCXcAeDs2bOYOnUqpk6dqmxLTk4WvD6pxcbGCmKNiYnB+vXrMWrUKGUcqaU85i6TyVCwYEE8ePBA48/AhLvlmOp97OjoiLp16yqXy5Urh0KFCiknmaxRowbKly9vknOZkqOjI/LkyaNx8svk5GS8fv1amYB//vy58v/x8fFwdXWFm5ub2n+5c+dWexKgQ4cOGDFiBO7fvy9o3759O27duoVZs2ZZpCY/6U/TRKWAaRPuAJTvizlz5qB27drKm5e6GDLCXdXatWv12i4jev/+PWbMmIE9e/YgMjISbm5uaNWqFcaPH488efJYNBZ/f3+cPXtWbVLe1NatW4fFixcjPDwcjo6O8PHxwfTp01mWioiIJKf6BPOTJ08kikQ/TLgTEVmfr1+/in63TY0J93TAxsYG9evXR/369fHhwwfExsbC1dVV0hGmcrkcI0aMgJ+fH/766y/s27dP4ySPWbNmRdeuXdGwYUMsW7YMhw8fFqx/8eIFRo8ejT/++EMwKvnNmzeiI49THDhwAJ07d0bJkiUBABEREVpr3KmOUt+xYwdGjhyJjx8/qo1sSF1XtlChQhoT7vb29pzczYIKFiyIe/fumfy4MpkMK1euxPr16+Hg4ICuXbua/ByWIJfLlUn0tN4wcHd3x/r16zF79myEhIQI1oWFhaFDhw6YOnUqatasmabzkOk8e/ZM47q0JNw1PS0CfLvJs2vXLvTu3VvQpomxI9zj4uLUnqrSx927d7Fy5Uo4OjpiwIABcHNzM/gYUvv06RNq166NW7duoV69emjVqhXu3r2LxYsXY+fOncqndSxhxowZ+PPPP7Web9SoUZg1axbKlCmDvn37IjIyEtu2bcOhQ4dw6dIlFCtWzKhzR0REGBm1UGxsrNYJ6IiIKGNTTbi/fPkSCQkJVvv0pilLzBIRkX7q1auH48ePa1xfvXp1zJw5Ew0aNNC4jebi2WSVcuTIgQIFCljNB4JixYphxIgROHDgAEaMGCH4Ip0yQequXbsQEBCAwoULY8aMGVi+fLnaKLcrV65g4cKFgrZTp04JRspnzZpVLbmdeoJZ1Xp8+ggPD8f//vc/QZu9vb1gBPF3332ncf9cuXKZ/OkB0kx1AtSAgACTHdvNzQ0jRozAgAED0pSczEgcHBwwYcIETJgwQbSsyMCBA7FkyRKOvLES2kYcm3qEe2qpJ+d99eqVxknJAPER7s7Ozhq3TymRpO3mq5gXL16gU6dO6NixI06fPo2DBw9i/PjxBh3DWkydOhW3bt3CpEmTcOzYMeVNsMWLF+PZs2eYMGGC2WP48uULevXqpXPi9hs3bmDWrFmoVasWrl+/jlmzZmHr1q3YsWMHXr9+jYEDB5o9Vl2cnZ2NTvoTEVH6p5pwVygUVjtx6t69ezP1E35ERFIZOXKkzm1GjRoFLy8vhIWFia5nwp1MwsnJCb/++iu2b9+OlStXYuTIkdi+fTvGjx8PV1dXwbaVK1fGypUr1UYabt26VTBBqmo5mdq1a6Np06aCtosXLyr/bWhCBgAOHTqkVk6mZMmSsLGxUS63bt1aY0KI5WQsq0iRIpg9ezZq1KiBTp06oVu3blKHlCm0bNkS69evR+HChdXWrVu3Dk2bNsXSpUvx6tUrCaKjFOZKuOt6VC71hF0TJ05EaGioxm0NHeG+ZcsWKBQKrZNri9m8eTPu3LkjaLt69apBx7AWDx8+RN68eTF8+HBBe6dOnQB8m9dEmy1btoj+7E+fPsXixYt1nn/v3r0oXbo0VqxYofY3WNWSJUsAfHsfpL5R07p1a3h7e2Pfvn1an8QgIiIyN2dnZ+TMmVPQpu0zlFRCQ0MxefJkrdvo+oxGRETG0ff7c1xcHHr27Ck6lyQT7mRSMpkMlSpVgp+fn9YRZLlz58bcuXPVRk7OmDED//33Hz59+oRLly4J1nl7e6tNXnn9+nXlY3aqI9y1jZpMcfjwYbW7UanLyQDfRj5rGtUnVneezKtevXpYtGgRBg4cKJq8swRzlxGyxpIHnp6e2Lx5s+hs3R8+fMDatWvRvHlzjB8/XuMdXjIvbTVI9ekPNdH1Ze7r16/K86v22/ocS9vv06JFi/DXX38JboKm0JaE37Ztm2j76NGj8ffff+s9z4g12LFjB168eKH2OqXcUNA2l0JkZCQCAgLQoEEDQdL9yZMn8Pb2xoABA3D27Fmt51+zZg0+ffqEpUuXCm6Kizlz5gxsbW3h5eWltq5+/fpQKBQa52axlJiYGDx69EjSGIiISFrpoY77ypUrdW6jzwhMIiIynCGVLD5//oy9e/eqtbOGO0mmTJkyGD16tODOfUJCAvr27YuGDRsqSwkA35I0NWvWVI50TKkR/PXrV1y/fh1lypTB48ePBcdv0aIFtm7dqjWGlMklUytdurTadg0bNsTx48dx5MgRQbu22saUcbRs2VJQx7xHjx5mPV9akqPm5OTkhJkzZ+LPP//E/PnzBb+jwLfyHwcOHMCBAwdQoUIF+Pv7I1euXIiKilL+9+zZM+Vju6VKlULZsmVRtmxZlClTBtmzZ5fix8owtNWYE0tY60vfEe76zK8gVp5GVw332bNni7YXK1ZM64TWYo4cOYIjR44gMDAQP/74I4YOHQpPT0+DjqGLQqHA4cOHER0djWbNmok+CfX8+XMEBgYiOjoav/32G5o0aaL38d+9e4fjx49jyJAhsLW1xbhx4zRu6+7ujg0bNqBjx45o0KABjh49Cjc3N3h7e+Phw4cIDAxErVq1tJ5v0KBB2LRpk85RHklJSQgPD0fRokVFr3Px4sUBqE9SbmlOTk4a55whIhJjjQMhKG0KFSqEW7duKZdNNcI9PDwc0dHRqFq1appKwCoUCo0xeXp6omTJkihXrhxatWpl9DmIiEgzQ78/v3z5Uq2N2UKSVIsWLfC///1PMBoxLi4Oe/bsEWz3008/KZMy5cqVw82bN5XrLly4oJb4y5IlCxo2bKgz4S5GLOEOAP369VNLuBctWtTg41P606tXL7x+/RpPnjxBu3bt4O7uLnVIkpHJZPD390f58uWxfPlywTwKqf37778651WIjo7G6dOnlcuFCxdGw4YN0aVLF05GbACFQoFhw4aZbVItXV8YP3z4AEC/Sb3EjmXsDSa5XI7GjRvj4MGDRu1/9epVTJw4EcHBwWmeiyM5ORlfv36Fvb09VqxYoZzgddu2bdizZw9sbW0RGRmJiIgIVKxYEfPnz1f+7kycOBE//fSTXiXKli9frpyg1sbGRuNTJ6n5+/sDgDLpnjNnTkRERCAwMBCjRo3SeU5vb2+d2wDfbrwoFAqNP0fK4/vv37/X63hERNbCWgdCkPFUR7ibIuEeEhKCqVOnQqFQoFSpUti4caPBJfFSaJsfqWHDhujatauxYZKF8EYdUfpm6PfDDRs2qM05yJIyJLlBgwbhp59+0rpN3bp1lf9WLStz8eJFQQIeAMqWLascTWcIJycnlCxZUnRdwYIFlTVzNcVCGZObmxsWLVqEXbt24ddffzX7+dJDyYMyZcpg0aJF2L59O3x9fU1S3ufJkydYu3Yt+vfvz4lY9XTu3Dn89ttvOHXqlNnOoWuE+4cPH6BQKPS6ZmJPBRl7c6VKlSppfpT63r17ak85xcbG4u3bt3ofIzIyEn5+fqhZsyZGjRqlTLYD30Y6HDlyBFevXoW/vz+GDBmCtm3bCp5GSE5ORnBwsF7nypMnD0aOHInOnTvD0dERHTt2RFBQkM79/P39MXfuXLx//x4RERHo06ePXsl2Q8TExAAQr9Ofut1cN4aIiIj0pSvh/vLlS4waNQqNGzfGtGnTkJCQoPOYc+fOVZasu3v3Lq5cuWJ0fNoStQ4ODkYflyyHk7QTpW8ymUzn/FWqHj58KFhmwp0kZ2tri/nz52t8pF4ulwvqwaomue/fv49jx44J2sqXLw8nJyfkzp3boFgqVqyodSRCv3790LlzZ1SsWBFDhw5FlSpVDDo+kT6cnJx0ltmwFh4eHhgzZgxCQ0PRr18/tcmQjfHvv/9i7NixytJRJO7QoUMYOHCgzpr5FSpUSNN5dI3OSkhIwJcvX/T6Mvr69Wu1NmNLc7Vq1SpNk8GmaNGiBcaNG4f4+Hjs3bsXderUgY+Pj8ZSNqrWr1+vLGmm+rcIAG7cuIE5c+YoXx+xyYX/+usvXLlyBQMGDMCvv/6KdevWiZ7rl19+wcyZM7FhwwbcunULbm5uGDp0KK5du6Y1xsjISCxatAjAt+u5ZcsWwaTjppCSAND0Pki5IcORokSU3qSHgRBkmMKFCwuWnz59iqioKADAlStX4O/vj6NHj+L169fYvXu3zqfpkpKS1MqVaSv1p0vKTWwxaSlVQ0RE+pswYYJBA7xCQ0MBfHsC/cWLF0y4k3Wwt7fHlClT0LNnT7V1FStWFExOWrZsWbVkpGr99vLlywMAihQponY8R0dHjR9UfvzxR61x2tjYYMCAAVi9ejXatWuX5jIERBlFjhw50KVLF4SEhGDGjBkoX748bGxskDVrVhQvXhxeXl7KEb7z5s3DtGnT0K5dO5QvX1709/HkyZOYNWtWuprc0tLEJmYR06xZMzNH8m2Uuz711EuUKGGyc6Y8xTR48OA0H+vgwYOoWbOmYE6RlKc3Pn36pHXf1PM7iPn7779x//59rdvExsaiV69eOH/+PB4+fIglS5bojNnd3V05Sn337t0at3v8+DG8vb3x6NEjzJw5E9u2bUNsbCx8fHxw4cIFnefRV44cOSCXyzWWjElpz5Ejh8nOSURkCelpIATpp2jRooIBBYmJiRg1ahSuXr2KAQMGqP3tT13vXYzq03IA0jQoQNsIdz4plj7wRh1R+mdraws/Pz+sX79er+3Xr18PhUKB8ePHo3nz5qzhTtZDJpPh999/R5EiRTBp0iQkJCRALperJeFtbGxQpUoVnDx5UuOxUifcVUf+fffdd7Czs8OlS5fU9vvhhx/S/oMQZWK2trbw8fGBj48PkpOTIZPJNN6Yaty4MYBvX3Ju3LiBYcOGCUb0/P3333Bzc0O3bt0sEru1i4mJwd69e+Ho6IhmzZohIiJCbRtbW1scPHgQ7969w+HDh1GyZEnUq1fP7LE9fPgQO3fu1LldpUqVRNvz58+vnExXH7169VL+O1++fHrvZ6jIyEjs3bsX7du3V7YlJCRg8eLF2Lp1q85yaGkVHx+P06dPIykpSfn7kpqHhweAb/MhiImKioK3tzciIiIwa9YsjBgxQrmuffv2aNSoEY4fP67zZrM+7O3tUbx4cTx+/Bhfv35VK0WUckOmTJkyaT4XERFRWuTIkQPNmjUTDF4ICwsTHfwFfJuwXJsnT56otRn7pGZycjLWrFmjcb220e9kPThJO1HGoWmeRzFdunTB7du3AbCkDFkhHx8fhISEYPz48QgODhZNBGhLchQrVkw5OZvYCPeiRYuiatWqau0ODg4G/SIRkXZyuVyvp0BsbW1RuXJlBAUFqSXpli1bpjaJsjmcO3cOI0eOxOrVq5GYmGj28xkqOTkZvXv3xrx58zB16lSMGzdObTSVl5cXDh06hJw5c6JYsWLo2bOnyZLtqUd+i9FntH29evU0zvY+fPhwg2qSpu7DDZ1B3lBBQUGCL0zbtm1TTsht6rIsqpKSktC0aVO0bdtWtEZ+yg1lTU8OuLq6okKFCpg9e7Yg2e7n54fg4GCUK1fOqPlONKlTpw4SEhJw7tw5tXVHjx6FTCZDzZo1TXY+IiIiYw0bNkyttIwmb9680bpebNLVlEnlNTl9+jTWrFmj9qT2qVOntM7NY4ryjUREpD8bGxu9y1WnJNsBJtzJSrm6uqJVq1YakwiaJiu1sbFB7969lctiCfdixYqJJtzz5ctndC1hIkq7SpUqYdq0aWpJ+unTpyM4ONhsNd137tyJgQMH4tixY1i+fDkmTJhgVaVs7ty5gzp16uDOnTvKtqNHj6ptN336dLOV62jSpAnatm2rcf2RI0d0HiPlySMxXl5eOkuzpFa0aFHlv82dcAe+xbdy5UqcPn1aWQvdEhwdHeHr64uPHz9i/PjxgnXXr1/HnDlz4OTkJBiBn5q9vT127dqF4cOHq63z8/PD2bNnlTeoTSEgIAAAMGbMGHz+/FnZvnv3bpw6dQotW7ZUm6iOiIhICk5OThrnEFNlzAh3TSXWgG/l6IYMGYJly5ahU6dOykEUT548Ef2bncLBwQGNGjXSK2YiIjKdBg0aGLwPE+6ULhUqVEitNIG3tze2bdsmGNGpaYR7qVKl1NpTT8xKRNKoX78+hg0bJmhLTk5GUFAQunfvbrJaiDExMYiLi8ORI0cQGBgoWHf48GHs2rXLJOdJq6SkJIwdO1aQvBTj5uaGrFmzmi0OuVyO4cOH46+//kKLFi0M3t/BwQE///yz1m1cXFz0Pl727NkNjiGtVq5ciSFDhlj8vPPnz0fRokUxZ84c1KpVC8OHD8evv/6Kn376CQkJCdi4cSMKFCigcX9tT5mYeh6S6tWro2/fvvjnn39QoUIFjBgxAu3bt0ebNm2QN29eBAUFmfR8REREaaFvmbPUI9wTEhLUBmY8e/ZMbR9tI9xTT8IaFxeHP/74A8eOHdP6Walp06ZYtWoVHB0d9YqZiIhMx5hBXhzOS+mSTCbD9OnTsWnTJiQmJqJx48aioycLFiwIZ2dnZa07uVyOEiVKQC6Xo127dsqyAHZ2dmjVqpVFfwYiEte2bVu8evVKbXKSmzdvon379ujRowd++eUXQdL1+fPnOHToEC5cuABHR0f07NkT3333ndqxX716hYEDByI8PFxrDHPnzkW5cuXg6elpkp/JWI8fP0ZkZKTO7cRuLppDsWLFMHHiRHz48AGnT5/Wa5+mTZuiXbt2JptwbuHChYJlsce4M5ICBQrg8uXLmDJlCvbs2YOLFy8iV65caN26NcaMGYOKFStKHaLA4sWLUapUKaxYsQKLFi1C7ty54e/vjylTpihrzhMREVkDfRPucXFxiI+Px4YNG7B27Vo4Oztj1qxZytKnYsl1bSPcVecSO3jwIC5fvqxx+zp16mDKlCl6xUpERKbn7Oxs8D5MuFO6lSdPHp2jDW1sbNCrVy8EBQUhOTkZ/v7+yrp3vXv3hlwux8OHD+Hr62uxhBUR6da3b18kJydj48aNgvavX79iyZIlWLJkCfLmzQtPT0/ExMTg+vXrgu0uXLiA8ePHqz0qPG3aNJ3JduDb6KXx48dj69atkMulexjs4cOHem1n6f6revXqeifcTfkFsV27dqhRo4agLVeuXCY7vrVydXXFokWLLFrORhNd5ZZkMhn69euHfv36WSgiIiIi47i4uCBv3rx4+fKlzm2vXLmClStXAviWTF+4cKHyc2psbKza9toS7mK01YmX4sk+IiL6P35+fsq/Afpiwp0yPH9/f9SpUwdfv36Fu7u7st3R0RGDBw+WMDIi0kQmk2HAgAGoVasWpk6dKlob8+XLlxq/IKUkzO/du4d+/fpBLpcjLCxMdDLHFIUKFRKMln7w4AHCwsJQrly5tP9AGiQnJ+Off/5BZGQk6tevrzYRlr4ldCw9Ev+XX37BrFmzLHpOAOjevbtaGZQ6depYPA4iIiLKGMqWLatXwn3evHmC5bCwMCgUCshkMsHk6inevXuH58+fI3/+/Mq2T58+qQ0S0Ue2bNkM3oeIiEzHmEFerOFOmUL+/PkFyXYiSh8qVaqErVu3olOnTkaNNN+4cSMGDx6Mz58/Y82aNRq38/X1xfbt29VqYf/3338Gn1NfMTExGDZsGAYOHIh58+ahY8eOaiOkrDXhLpfL4ePjY9FzAuJfOM1Zu56IiIgyNn0HVoiV+Ev53CY2wh0ARo0apfz3hw8f0KFDB6Pmg8mRI4fB+xARkWkZ+rQxE+5ERFYmNjZW4wf3zMjBwQEDBw7EunXrUKVKFdjaij+clS1bNlSpUkWt/dy5cwgICMCpU6cE7d27d8f27dsRGhqKMWPGwN7eHpUrVxZsY0zC/e3bt0hMTMTjx4+xcOFCbN68WXTS0zFjxgjKsrx9+xbnz58XbKNvSZkSJUoYHGda5c6d2+Ln1HTTZezYsRaOhIiIiDKCxo0bq03c7uLiIjoXkKq3b98C0Jxwv337trIU29atWxEVFWVUjBzhTkQkverVq2PkyJF6b8+SMkREVsaYCTkyg7Jly2LZsmXKZHZ4eDju3buHpKQk/PDDD6hRowbs7e2xa9cuzJo1C4mJicp97927JzhW9uzZ0blzZzg6Ogray5cvj5CQEOWyWMJdoVDgzJkz2Lx5M+7evYtatWph0qRJ+Pz5M8aNG4d//vkHMplMUOv62bNngj/OcXFxasl14NukrimSkpL0njDVwcFB53amJkXCXZOff/4Z06dPlzoMIiIiSmfc3Nywfv16TJo0CdeuXYONjQ369euHo0eP6tz37du3KFiwIBISEjRu8+XLF2TJkgWrV682OkbWcCcikp5MJoOfn5/epVWZcCcionTF1tYWxYsXR/HixdUmRQW+JV89PDwwePBgfPz4UfQYHTt2VEu2A8D3338vWH7+/Dlev34NV1dXAN++NA0aNAhXrlxRbnP48GHkz58fZ86cUY5IV51Ycs+ePRg8eDDs7e0BQGOt0NQTbIWFhal9gZs9ezZGjBghaKtWrZroscytaNGikpxXk1y5cuHdu3dSh0FERETpTIECBbBy5UpERkbC0dERrq6uuHbtms793r59q/Op1JiYGOVIeGOlfH4kIiLpTZs2DePGjdO5HUvKEBFZmZiYGL1rd5O4ChUqYPXq1cpEeWrZsmXDr7/+KrpfsWLF4OTkJGhLPcp9//79gmR7ig0bNmgt/5KQkIAbN24ol6Ojo0W3S50wVh0B7+HhgXr16uHSpUsICAhAvnz5ULt2bXTr1k3jec2pTJkyOrdp3769QcdMyxfKfv36Gb0vERERkbu7u/Kzo2qZGTH6Jtz1mZRVGxsbmzTtT0REptO4cWNMnTpV53ZMuBMRWRknJye1pC8ZzsPDA2vWrFGbCLVdu3Yay/bI5XKULVtW0JY64X7hwgWj40m9r6YvXqkT7ufOnROsq1GjhjLGPn36YN++fZg/f75eXwjNwc3NTRmTmIIFC6Jjx44GHbN3795Gx1O9enWj9yUiIiJKLVeuXDq3efv2LeLi4rRuExsbi9evX6cplkKFCqVpfyIiMi2xJ+1VsaQMERFlWAULFsTq1asxa9YsXLlyBXXq1EFAQIDWfcqXL49Lly4pl1MS7snJyXo9XqzJ/v37kTVrVrx79w4fPnwQ3SYl4f7p0yfcuXNHsE5bclsq8+bNU0t0Fy1aFNOmTYO7u7to2R5tfH198d9//+H48eNq61q2bKl1X6luPBAREVHGkzNnTp3b6DvCPS0J9zx58qB48eJG709ERNJgwp2IiDI0Nzc3zJs3DwqFAjKZTOf2qnXcr1+/jho1aiB37twaE+Wpubu74+vXr3j+/Lmg/c2bN1ixYoXWfd+9e4fIyEg8f/5cUAdeLpejYsWKOs9taXZ2dmptnp6eKFWqlFHHc3JywuzZs1G5cmW1dT169NC6r62tLdq1a4etW7cq2xwcHLB3715ER0cjT548AL598fX19TUqPiIiIsoccuTIoXObHTt2oE6dOlq3SWvCfc2aNUbvS0RE0mHC3cxiY2N13vUmIiLz0yfZDqgn3IFvNdhVE+iadO3aFY0bN8bXr1/RuHFjnY8apxYZGSmaDM6bN6/VTpjl6emJ8PBw5fJvv/1m8nMULlwY+fLl07ndkCFDUKlSJaxZswaenp7w9/dHrly5BI+FayonRERERJRCnxHuwLen/bQRKynTrl07NG7cWK/PTPqUtiEiIsvr3bs3li1bpnE9a7ibmbOzM4oVKyZ1GEREpKfs2bOjSJEiRu9ftWpV2NnZwdHREbVq1TJJTKp16K1Jr169kCVLFgDAL7/8gu+++87k50g92l8bmUyGunXrYvPmzZgwYQI8PT3VtuHEY0RERKSLvgn3iIgIrevFRri7ubmhbNmy+Pnnn3Ue38HBQa84iIjIsn799Vf4+PhoXM+EOxERkQp96qWLjUTPmTMn8ubNq1zu378/ypUrl+Z4ChYsmOZjmIuXlxcOHz6M0NBQjB492iznMLQWvDZyOT/6EBERkXb6Jtx1EUu4u7q6AtBvsnh9n9AkIiLLypYtG2bMmKFxPb91mllMTAwePXokdRhERGSArl27okqVKnByctK4Tbt27dTaSpQoIVjOnz8/1q1bh+DgYHTt2tXoePLnz2/0vpbg5OQENzc3kx1P9bUdPHiwyY6tzxfX9evXm+x8RERElP44Ozub5Cb9qlWr8PDhQ0FbyrwypkrqExGR9WHC3cycnJy0JmyIiMj6uLi4YNmyZTh16hROnDihtj5XrlwoWrSo2kj4Dh06qG0rk8ng6emJvn37onTp0kbFY80j3M2hU6dO+PHHH5E9e3a0b98eP/74o0XPL1aKxtRq1qxp9nMQERGRceRyObJnz67Wboo5dVJGuPOpOyKi9K9hw4ai7ezhiYiItMiWLRv69+8vaPP29oZMJsPAgQORL18+yGQyNGvWTGfN9iZNmhgVg7WPcDc1Nzc3rFixAsePH8eQIUMs+oW0RYsWsLe3xw8//GDW8yxcuBDHjx836zmIiIjIeGIj0CtUqJDm+WBSEu5ERJT+qeYKAKBLly5MuBMREenSoUMHNG3aFHZ2dihXrhx69uwJAChevDhCQkJw7NgxTJ48WWe5Ej8/P1StWtXg82e2Ee5S8ff3x/jx4wFAr4nM0ip79uyio+eIiIhIejly5FBrK1asmGh7iu+//17rMbNkycIn4ImIMpACBQpg7969KFWqFORyOZo2bYrOnTsz4U5ERKSLra0tpkyZgrNnz2LdunWCkUmaHjkWY2dnh6CgIOVjZ/okXLNnz86RUCZWsWJFtbamTZti6NChytH0TZs2TVPZlyJFimDfvn3Ili2b1u0OHTpk9DmIiIjIfMRGuBcrVkxj7XUPDw+0atVK6zHz5MnDiVCJiDKY/PnzY/Pmzbh06RKmTJmC7NmzM+FORESkLxsbmzR/SXJwcEBgYCAOHz6M0NBQrSOp5XI5evfuzRqfJqZapmb9+vWiTyi0bdvW6HNs3rwZ+fLlw4kTJ7RePzs7O7i7uxt9HiIiIjIPsUER2hLu9erV0zlIwsHBQbBsa2trdHxERGS92LsTERFJwMXFBQDQsmVLbNiwQbBOLpdj165dsLW1Rd68eaUIL0MrU6YMLl26pHO7ypUrI1u2bPj06RMAwN3dHZUqVcLp06fh4uKC58+fIzY2VnS/rFmzKpcVCoXW8+haT0RERJb3+fNntTZtCXd3d3fl5ztNChcuLFiePHkyxo4dK7ptZpvDh4goI+GQOSIiIgkVKVIEzZs3F7TVrVsXBQsWZLJdYvb29pg8eTLc3d3h6emJyZMnY9y4cTh8+DC2bduG0NBQbNu2DcePH0elSpUAfLuRMmDAAMFxfv/9d8GyaqmaYcOGmfcHSecUCgUaN26MBQsWSB0KERFlIh8/flRrc3Fx0VjDvVChQjoT7t99951guWHDhhg2bBi8vb3VPveNGTPGwIiJiMhacIQ7EZGViY2NFR01SxlXnz59cO3aNURFRcHe3h7t2rWTOiT6/7y8vODl5SW6zsnJCSVKlAAALF++HFFRUciZMyecnZ0F2/n5+eHw4cOIiIiAi4sL+vXrJ1hftWpV/Pjjj7h69SoAYMmSJWb4SdKnxMRE9OnTB4cOHULjxo2lDoeIMiF+Lsu8fv75Z8ETcUWLFoVMJtM4wr1QoUJqnwFSK168uFopQblcDn9/f/j7+yM2NhazZ8/G7du30bBhQ/z0008m+TnI8thvEBET7kREVkbbB3XKmNzc3LBp0ybcunULJUqU4Mj2dEgul6NQoUKi63LlyoXNmzcjIiIC+fPnVxsZZ2dnh+XLl+PTp09wcHCAvb29JUK2emFhYejSpQtevXqlMblBRGRu/FyWedWuXRvu7u6IjIyEjY2N8gk2sb9Jjo6OyJUrF2QyGZycnNSSrS1atMDYsWO11mx3cnLC5MmTTfozkDTYbxARE+5ERERWIEeOHGqlRijjcHBwQKlSpTSul8lkopOzZWanT59G9erVMXnyZFSsWFHqcIiIKJNxcHDA5s2bcePGDRQqVEg5yblYSZlChQopJ193cXFRS7iXKlWKE6QSEWUi7PHNjI8SEZGhYmJi8OrVKxQrVkzqUIiIJNOrVy+pQyAi4ueyTM7R0RE1atQQtJUpU0ZtO29vb+W/5XL1qfJcXV1NHhtZL/YbRMRJU83M2dmZnSwRGcTJyQlOTk5Sh0FEZDb379+HTCYT/S910oKISGr8XEaqPDw80LNnTzg5OaFAgQLo06cPunXrplyfnJystk/K5OqUObDfICKOcCciIiIiiypSpAju3Lkjus7R0dHC0RARERnm999/x++//y66rm7duti4caNy2cfHB7ly5bJUaEREZAWYcDczPkpEREREJGRnZ6e1pj0REVF69csvvyAkJATv37+Hq6sr+vfvL3VIRERkYUy4m5mTkxPi4uKkDoOIiIiIiIiIzKxgwYLYs2cP7t69i5IlS3JSdCKiTIgJdyIiIiIiIiIiE3FycsKPP/4odRhERCQRTppKREREZMViYmIwZswYlCpVCg4ODsiePTvq1KmD3bt3WzwWf39/FCpUSOs269atQ6VKleDs7Aw3Nzd07NgRjx8/tlCERERERERE0mLCnYiIiMhKffr0CTVr1kRgYCCcnJzQp08f+Pn54d9//8XPP/+MwMBAi8UyY8YM/Pnnn1q3GTVqFAICAhAfH4++ffuifv362LZtGypXroxHjx4Zfe6IiAgMGjTI6P1TxMbGIjY2Ns3HISIiIiIi0oQlZYiIiIis1OzZs3Hz5k306tULS5cuhUwmAwBMmTIFVapUwfjx4+Hn54cSJUqYLYYvX75g0KBBWLFihdbtbty4gVmzZqFWrVo4duwY7O3tAQBt27bFzz//jIEDByIkJMRscerD2dlZ0vMTEREREVHGxxHuRERERFZq+/btkMlkCAwMVCbbgW8TsvXu3RtJSUkIDQ3VuP+WLVtw9epVtfanT59i8eLFOs+/d+9elC5dGitWrEDTpk21brtkyRIAwMSJE5XJdgBo3bo1vL29sW/fPjx79kznOYmIiIiIiNIzjnC3gOTkZLW2169fSxAJEUkpd+7ckMv1u8/JfoOIAGDAgAH48OEDcubMqbYuS5YsAL6VnRETGRmJgIAAODo64ujRo8rJ2548eYK6deviwYMH+OGHH1CrVi2N51+zZg0+ffqEpUuXolevXlr7sDNnzsDW1hZeXl5q6+rXr4+TJ0/ixIkT6Nixo7Yf2axiYmLw8uVLFC9eXNDO/pUoczHkMxnAz2VE9A2/zxGRvphwt4C3b9+qtZUpU0aCSIhIStHR0ciTJ49e27LfICJAc7+hUCiwc+dOAED58uVF93V3d8eGDRvQsWNHNGjQAEePHoWbmxu8vb3x8OFDBAYGak22A8CgQYOwadMmZMuWTet2SUlJCA8PR9GiRQWj21OkJLjv3r2r9Tjm5uTkhPj4eLV29q9EmYshn8kAfi4jom/4fY6I9MWEOxEREVE6s2zZMly8eBEeHh5o3Lixxu38/f0BQJl0z5kzJyIiIhAYGIhRo0bpPI+3t7de8Xz8+BEKhQIuLi6i61NG6L9//16v4xEREREREaVXTLhbgNidTSIibdhvEJEm27dvx4ABA2Bra4sNGzbAzs5O6/b+/v548eIFBg8ejPfv36NPnz56JdsNERMTA+D/ytyoSmn/8uWLSc9rDPavRGQo9htEZCj2G0SZGydNJSIiIkonli1bhnbt2gEANm7cqLMkDPCtlvuiRYsAAHK5HFu2bMHFixdNGpeDgwMAICEhQXR9ShkXZ2dnk56XiIiIiIjI2nCEuwV4eHiotd26dQtubm5mPW9sbCyKFSsGAHj06BGcnJzMfgx9t9e1nab1hrSnbrty5QoqV64sOEdYWBhcXV31eBXSxlqvg7HXQNM6fdo+f/6sVrfOEtdBimsgtk/u3Ln1Pl967jeMOY4537PG9huZ7T1riv7bmHXW2n9by+9CSr+RnJyM4cOHIygoCA4ODggODsbPP/+s8/yPHz9G3bp18ejRI8ycORMeHh5o3749fHx8cOjQIVSrVs2on0tVjhw5IJfLNZaMSWnPkSOHSc6XFum5f+XvddpYy+81P5dJ/7tgyGcyIHP1G/ruw+9z5j2GFP03+w3d+6SH73OA9b5n+bfOvMdgPk6dpNdBQWYXHR2tACD4Lzo62uznjYmJUZ4vJibGIsfQd3td22lab0h76rZHjx5Jcg20xWzOY+izvbHXQNM6fdoy0+9CWs+bnl8rY45jzvessf1GZnvPmqL/Nmadtfbf1vS7EB8fr/D19VUAULi4uCjOnDmj17mfPXumKFq0qAKAYtasWcr27du3K2xtbRXZs2dXXLlyxaCfB4CiYMGCoutKliypsLe3VyQkJKitmzp1qgKAYtu2bQadzxz4e23Ydvy9Tvtx+LnMsJ/VHMdI6zkz02ul7z78PmfeY0jRf7PfMO15pXqtFArrfc/yb515j2GKfkPbevbfhl0HjnDPwJycnKBQKCx6DH2317WdpvWGtKdue/Xqlc6YzMVar4Ox10DTOn3a4uLidIVuFlJcA1Od19JMFbM1vWeN7TeAzPWeNUX/bcw6a+2/reV3ITk5GX5+fggJCUGxYsVw4MABfPfdd3ody9XVFRUqVECfPn0wfPhwZbufnx8AYMGCBShevLjeselSp04drF69GufOnVObbPXo0aOQyWSoWbOmyc6X3vD3mr/XadmGn8vSdoz0+JkMsO7PsPw+Z95jSNF/s98wz3mlYK3vWf6tM+8xmI9TJ+V1YA13IiIiIisVGBiIkJAQuLu748yZM3on2wHA3t4eu3btEiTbU/j5+eHs2bPImTOnyWINCAgAAIwZMwafP39Wtu/evRunTp1Cy5YtUahQIZOdj4iIiIiIyBpxhDsRERGRFXr37h0CAwMBAD/88ANWrVolup2Xlxfq1asnuk4mk2k8vrZ1xqhevTr69u2LJUuWoEKFCmjdujWePn2K7du3I2/evAgKCjLp+YiIiIiIiKwRE+5EREREVujy5cuIjY0FAOzZswd79uwR3W7s2LEaE+6WtnjxYpQqVQorVqzAokWLkDt3bvj7+2PKlCmik4cRERERERFlNDJFeixIRURERERERERERERkZVjDnYiIiIiIiIiIiIjIBJhwJyIiIiIiIiIiIiIyASbciYiIiIiIiIiIiIhMgAl3IiIiIiIiIiIiIiITYMKdiIiIiIiIiIiIiMgEmHAnIiIiIiIiIiIiIjIBJtyJiIiIiIiIiIiIiEyACXciIiIiIiIiIiIiIhNgwp2IiIiIiIiIiIiIyASYcCciIiIiIiIiIiIiMgEm3ImIiIiIiIiIiIiITIAJdyIiIiIiIiIiIiIiE2DCnYiIiIiIiIiIiIjIBJhwJyIiIiIiIiIiIiIyASbcrUxiYiKGDBkCNzc35MiRAz179kRcXJzUYWVqCoUCjRs3xoIFC6QOJVN5+fIlOnXqhLx588LV1RV+fn549uyZ1GFZLfYd1oX9hnTYd5ApsW+1PuxfpcG+VX/sN6wP+w3psO/QH/sO68J+QzoZpd9gwt3KjBs3Drt378bOnTsRGhqKEydOYPDgwVKHlWklJiaiZ8+eOHTokNShZDpt2rTB48ePERoaiuPHj+PDhw9o0aIFEhMTpQ7NKrHvsB7sN6TFvoNMiX2rdWH/Kh32rfpjv2Fd2G9Ii32H/th3WA/2G9LKMP2GgqzG58+fFU5OToodO3Yo244fP66wtbVVvHnzRsLIMqfbt28rqlSpoihatKgiZ86civnz50sdUqZx9+5dBQDF3bt3lW1Pnz5VAFBcuXJFwsisE/sO68F+Q1rsO8iU2LdaF/av0mHfqj/2G9aF/Ya02Hfoj32H9WC/Ia2M1G9whLsVuXHjBmJjY1GnTh1lW61ataBQKHDx4kUJI8ucTp8+jerVq+P69evIkSOH1OFkKnnz5sW+fftQsmRJtXWfP3+WICLrxr7DerDfkBb7DjIl9q3Whf2rdNi36o/9hnVhvyEt9h36Y99hPdhvSCsj9Ru2UgdA/+fZs2fIkiULXF1dlW12dnbInTs3nj59KmFkmVOvXr2kDiHTypkzJ5o1ayZomzdvHpydnVGxYkVpgrJi7DusB/sNabHvIFNi32pd2L9Kh32r/thvWBf2G9Ji36E/9h3Wg/2GtDJSv8GEuxWJi4tDlixZ1NqzZMmC+Ph4CSIisg6bNm3CggULsHDhQjg7O0sdjtVh30Ekjn0HpQX7ViJx7Fs1Y79BpBn7Ds3YdxCJS8/9BkvKWJGsWbOKdqbx8fFwdHSUICIi6S1btgxdunTBkCFD0L9/f6nDsUrsO4jUse+gtGLfSqSOfat27DeIxLHv0I59B5G69N5vMOFuRQoVKoT4+Hi8e/dO2fb161e8efMGBQsWlDAyImlMmTIFffr0wZgxYzB37lypw7Fa7DuIhNh3kCmwbyUSYt+qG/sNInXsO3Rj30EklBH6DSbcrUiFChXg5OSEU6dOKdvOnj0LuVyOKlWqSBgZkeUFBQVh4sSJmDNnDqZOnSp1OFaNfQfR/2HfQabCvpXo/7Bv1Q/7DSIh9h36Yd9B9H8ySr/BGu5WJGvWrOjRowcGDBiAHDlyIEuWLOjZsye6du0KFxcXqcMjspjw8HCMGjUKPXr0QMeOHfHixQvluly5conWt8vM2HcQfcO+g0yJfSvRN+xb9cd+g+j/sO/QH/sOom8yUr/BEe4m4u/vj0KFCmlcv27dOlSqVAnOzs5wc3NDx44d8fjxY7XtZs6ciZYtW8LX1xfNmzeHt7c3Fi5caM7QMxxTXQsyjile/x07duDr169YuXIl8ufPL/jvwIED5v4RLIp9h3VgvyE99h1kSuxbrQf7V2mxb9Uf+w3rwX5Deuw79Me+wzqw35Ae+w0VCkqz6dOnKwAoChYsKLp+5MiRCgCKMmXKKEaMGKHw9/dX2NjYKFxdXRUPHz60cLQZG6+FtPj6G4avl3XgdZAerwGZEt9P1oPXQlp8/fXH18p68FpIj9dAf3ytrAOvg/R4DdQx4Z4Gnz9/VvTs2VMBQOMb6/r16woAilq1aini4+OV7bt27VIAULRo0cKSIWdYvBbS4utvGL5e1oHXQXq8BmRKfD9ZD14LafH11x9fK+vBayE9XgP98bWyDrwO0uM10IwJdyOFhIQoihYtqgCgaNq0qcY3Vvfu3RUAFEeOHFFb5+3trZDJZIqnT59aIuQMi9dCWnz9DcPXyzrwOkiP14BMie8n68FrIS2+/vrja2U9eC2kx2ugP75W1oHXQXq8BtqxhruR1qxZg0+fPmHp0qXYt2+fxu3OnDkDW1tbeHl5qa2rX78+FAoFTpw4Yc5QMzxeC2nx9TcMXy/rwOsgPV4DMiW+n6wHr4W0+Prrj6+V9eC1kB6vgf74WlkHXgfp8RpoZyt1AOnVoEGDsGnTJmTLlk3jNklJSQgPD0fRokVhb2+vtr548eIAgLt375otzsyA10JafP0Nw9fLOvA6SI/XgEyJ7yfrwWshLb7++uNrZT14LaTHa6A/vlbWgddBerwG2jHhbiRvb2+d23z8+BEKhQIuLi6i63PmzAkAeP/+vekCy4R4LaTF198wfL2sA6+D9HgNyJT4frIevBbS4uuvP75W1oPXQnq8Bvrja2UdeB2kx2ugHUvKmFFMTAwAIEuWLKLrU9q/fPlisZgyK14LafH1NwxfL+vA6yA9XgMyJb6frAevhbT4+uuPr5X14LWQHq+B/vhaWQdeB+ll5mvAhLsZOTg4AAASEhJE18fHxwMAnJ2dLRZTZsVrIS2+/obh62UdeB2kx2tApsT3k/XgtZAWX3/98bWyHrwW0uM10B9fK+vA6yC9zHwNmHA3oxw5ckAul2t8NCKlPUeOHJYLKpPitZAWX3/D8PWyDrwO0uM1IFPi+8l68FpIi6+//vhaWQ9eC+nxGuiPr5V14HWQXma+Bky4m5G9vT2KFy+OyMhIfP36VW39gwcPAABlypSxdGiZDq+FtPj6G4avl3XgdZAerwGZEt9P1oPXQlp8/fXH18p68FpIj9dAf3ytrAOvg/Qy8zVgwt3M6tSpg4SEBJw7d05t3dGjRyGTyVCzZk0JIst8eC2kxdffMHy9rAOvg/R4DciU+H6yHrwW0uLrrz++VtaD10J6vAb642tlHXgdpJdpr4GCTAKAomDBgmrt58+fVwBQVK9eXREXF6ds37VrlwKAolWrVhaMMnPgtZAWX3/D8PWyDrwO0uM1IFPi+8l68FpIi6+//vhaWQ9eC+nxGuiPr5V14HWQHq+BEBPuJqLpjaVQKBR9+/ZVAFCULFlSMXz4cEW7du0UNjY2irx58yoePHhg4UgzPl4LafH1NwxfL+vA6yA9XgMyJb6frAevhbT4+uuPr5X14LWQHq+B/vhaWQdeB+nxGggx4W4i2t5YycnJisWLFyvKlSunyJIli6JAgQKKDh06ZNg3ldR4LaTF198wfL2sA6+D9HgNyJT4frIevBbS4uuvP75W1oPXQnq8Bvrja2UdeB2kx2sgJFMoFAp9y88QEREREREREREREZE4TppKRERERERERERERGQCtlIHkBkkJyfjzZs3grbcuXNDLuf9DiISx36DiMg82L8SkaHYbxCRodhvEGVuTLhbwJs3b+Dm5iZoi46ORp48eSSKiIisHfsNIiLzYP9KRIZiv0FEhmK/QZS58dYaEREREREREREREZEJMOFORERERERERERERGQCTLgTEVmZ2NhYxMbGSh0GEREREREREREZiDXciYisjLOzs9QhEBERERERERGRETjCnYiIiIiIiIiIiIjIBJhwJyKyMjExMXj06JHUYRARERERERERkYFYUoaIyMo4OTkhLi5O6jCIiDIczpFBRERERETmxoQ7EREREWUKnCODiIiIiIjMjSVliIisDEdgEhERERERERGlTxzhTkRkZTgCk4jIPGJiYvDq1SsUK1ZM6lCIKJ3gQAgiIiIyFBPuREQaJCcn48yZM0hKSoK3tzfkcj4URESUnnGODP18+PABZ8+eRaFChVC+fHnIZDKpQyKSDAdCEJGheKOOiJhwJyLSYMaMGdi9ezcAoF69epg9e7ZFzssRmEREJJWjR49i+vTp+PTpEwBgzJgx8PX1lTgqIiKi9IM36oiICXciIhGfP39WJtsB4Pjx44iOjoabm5vZz80RmEREZC4JCQnYuXMnIiMjUaJECVSsWBHFihXD58+fMXfuXISEhAi2X7ZsGVq2bAlbW35toMyJAyGIiIjIUPzkTEQkIiYmRq3t+fPnFkm4ExERmcP79+8xdOhQ/Pvvv4L2HDlyIEuWLIiOjlbb5927d/jnn39Qu3ZtS4VJZFU4EIKIDPXy5Uu8fv0aZcuWlToUIpIICxITEemJNWyJiCi9ioyMRNeuXdWS7cC3mu1iyfYUoaGh5gyNKF26c+eO1CEQkZXKmzcvk+1EmRwT7kREIhQKhdQhEBERmcS///6Lrl274smTJ0btf+rUKWVNdyL6ZuLEiVpvVBEREVHmxYQ7EZGV4az2RERkKocPH0bv3r3x4cMHQbuLi4tombRy5cph48aNgprtCQkJOHr0qNljJUpP3r59iyFDhuDLly9Sh0JEVubly5e4ffu21GEQkYRYw52IyMpwVnsiIkqLmJgYHDp0CHv27EFYWJjaek9PTyxYsAB58uTBixcvcP36ddy/fx9FihRBs2bNYGtri9q1a+PEiRPKfUJDQ/Hzzz9b8scAANy6dQvnz5/Hjz/+iB9//NHi5yfS5u7du5g8eTJmzJjB0oNEpJQ3b16pQyAiiTHhTkRERESUzikUCly/fh27d+/GsWPHEB8fL7pdzZo1ERgYCEdHRwBA/vz5kT9/frXtmjVrJki4X79+HVFRUShQoIB5fgARd+7cQUBAAJKTkwEAf/zxB6pVq2ax8xPp48iRIyhevDi6d+8udShEZOWuXbuGRo0aSR0GEVkAS8oQEYkQq+FuqZFLMTExePTokUXORURE6V98fDx69uyJHj16IDQ0VGOyvU2bNggKClIm27WpWbMmsmfPLmiz9OSpBw4cUCbbAWDnzp0WPT+RvpYvX47jx49LHQYRWQlN3+fmzZuHuLg4CSIiIktjwp2IyMo4OTnByclJ6jCIiDKcjDpHxt9//41r165pXJ8nTx6MGTMGI0eOhI2NjV7HtLOzUxuFt3//fotOKh4RESFYvnXrlsXOTaSLXC78Kj1hwgSEh4dLFA0RpQcvX77E4sWLpQ6DiCyACXciIhFSjnAnIiLzcHZ2RrFixaQOw+T27t2r1mZjY4N69ephwYIF2LdvH3x9fQ3+O9a0aVPB8pMnT3D9+vU0xWqIJ0+eCJajo6MRHR1tsfMTadOzZ0/B8pcvXzB48GC8fftWooiIyFpo+7zx119/4erVqxaOiIgsjQl3IiIiIqJ0Kjw8HPfu3RO0de/eHQcOHMDs2bNRq1YtvUe1qypXrhzc3d0FbVOnTkVMTIzR8aZ48OAB1qxZg+XLl4sm0RMTE/Hs2TO19v/++y/N5xajUCg0luJJ7cWLF7h586ZFR/qTdfL19UXLli0FbS9fvsSwYcOQkJAgUVRElB5MmTIFnz9/ljoMIjIjJtyJiPTEEe5EROlbRpwjY9++fYLlvHnzokePHnBxcUnzsWUyGVq3bi1oe/LkCaZMmWJ0wvnMmTPo1KkT2rZti2XLlmH16tXo168fvn79KtguKipKUL89ReqEu6ExJCYmYtmyZQgICMDGjRuV7dHR0fjtt9/g5eWFMWPGiJ43ISEB48aNQ/PmzREQEICBAwcy6Z7JyWQyjBo1ChUqVBC037x5EzNnzuT7gygT0/V549mzZ1i6dKkFIyIiS2PCnYhIBL8kERFlPBltjoykpCQcPHhQ0NasWTO12tJp4e/vj7Jlywrajh8/ji1bthh0nNevX2PkyJEYPHgw7ty5I1j38OFDXLp0SdAWGRkpepybN28CALZv3w4fHx/4+/vjwYMHesWwb98+rFmzBjdv3sSiRYtw5MgRAMD69esRFhaGpKQkHD58WLREz7Zt2wSv9fnz5xEWFqbXeSnjsre3x5w5c5AvXz5Be0hICIKDgyWKioikps/njW3btuHff/+1UEREZGlMuBMR6Ykj3ImIyJr8888/avWimzVrZtJz2NvbY+bMmciePbugfdGiRVonak0tIiIC7du3x7FjxzRuo7pOU8L97t27uHv3LubMmYN3797h/v37GDFihOiodABITk5GVFQUoqKiEBISIlg3adIkAN+S96lNnTpV7Tg3btxQa1Od1JUyJl2TLbu4uCAoKAgODg6C9oULF+L8+fPmDo+IrJCmfsPe3l75b4VCgcmTJ+tVzoyI0h8m3ImIRHCEOxERWbv9+/cLlsuVK4ciRYqY/Dz58+fHtGnTBDeek5OTMXz4cDx+/Fjrvq9evUK/fv10TiR58uRJJCYmKpc1JdwTEhIwd+5cwd/px48fY82aNRg2bBiGDRumfIz/zJkzaNGiBVq2bImWLVsqR8eniI+Px8ePH0XPo9ouVk+eE7hmDvpMtuzp6al2oyY5ORmjR4/OcGWsiEg3Tf1Gly5dBMuRkZFYtmyZhaIiIktiwp2IiIiIKJ359OkTTp06JWgz9ej21GrUqIHu3bsL2j58+ID+/fvjzZs3ovvExsZi4MCBePHihaA9R44c6Nmzp6Dt48ePuHbtGs6ePYsWLVpgx44dGmMRG22+YsUKnDx5EidPnkT37t0RGRmJSZMm4eXLl1p/LtUa+ClSys0A327CiyXcX716pfXYYr5+/YojR47gwoULvLmfwdStWxe9e/cWtMXGxmLIkCEab+wQUebSpk0blCtXTtAWHBxstgnBiUg6TLgTEREREaUzR44cQUJCgnLZ1tYWjRo1Mus5f//9d9SsWVPQFhUVhYEDByIuLk5t+/nz5yM8PFzQVqZMGezYsQO///47SpcuLVi3a9cujBkzBs+fP09TnB8+fICvry8+fPigc1vVpwRS7NixQ5kQf/v2Lb58+aK2TeoR7m/fvhUta5OYmKhsVygU6Nu3L0aPHo1+/fpxVGM6YchkywEBAfDx8RG0PXnyBKNGjRI8wUFEGZumfkMul2PixImC0jLJycmYPHmy4G86EaV/TLgTEYngqDMiIrJmqoliLy8vtTrrpiaXyxEYGKiWKL97966yHnqKuLg4hIaGCtoKFy6MBQsWIFeuXACAevXqCdYfOXJENHFvTv/73/9E2+/du6e8WfD06VPRbaKjo5GcnIyhQ4fCx8cHtWvXRnBwMN6+fYuIiAgEBASgevXq6NixI6KiohAeHi6oe7927Vp+3kgHDJlsWSaTYcKECWq/I5cuXUJQUJA5wiMiK6St3yhWrBh69OghaIuIiMDKlSstERoRWQgT7kREIsS+AHPSVCIisgZPnjzBv//+K2gzZzmZ1BwdHbFw4UIULFhQ0H78+HHBI/Hnzp0TjNazsbHBokWL4OLiomyrX7+++QNOg5Tk+NWrV0XXv3r1CgcPHlSW9omPj0dQUBCaN28Of39/3Lx5EwqFAuHh4Vi5ciVu376tdoyYmBjz/QAkCQcHB8ybNw+urq6C9u3bt2Pnzp0SRUVElqRrsuVOnTqhTJkygraNGzciLCzM3KERkYUw4U5ERERElI6ojhzPmTMnatSoYbHzu7i4YPHixWoj6levXq389/HjxwXrqlatisKFCwva3N3d1RIOYvLkyQNHR8c0RGycGzduICYmRmM9+Tdv3mDNmjVq7QkJCWrlQ/bt2yd6437Xrl24ffs21qxZo0zwX7hwAdOnT8eSJUtw//59fPjwAWvWrEFwcDBLDqQTbm5umDdvnqBsBADMmjVL4w0cIso4dE22bGNjg4kTJ8LW1lbZlpycjEmTJrGfJ8ogbHVvQkSU+fARbyIiskbJyclq5WQaNWoEOzs7i8bh7u6Obt26Yf78+cq2c+fO4c6dO/Dw8MDZs2cF26uWj0kxduxY/P7771pLyfj7++Off/7BlStXBO1eXl5wdHTEwYMH0/CTaHbt2jUsXrxYUKs9teTkZDx+/Fjv402fPl2tbdGiRYLlpk2bCm6orFu3TrD+v//+Q2BgoN7nJOmULVsW48ePx/jx45VtSUlJGD58ODZt2qT2lAgRZS7FixdH9+7dsXz5cmXbw4cPsWbNGrUJmIko/eEIdyIiPek7YVZa6XoEkYiIMq8bN24gKipK0Na8eXNJYvH19UXOnDkFbWvWrME///yDz58/K9vkcjm8vb1Fj/Hdd99h9uzZsLGxEbQvX74ckydPxpIlS/Dbb7/h+++/V9u3WbNm6Ny5s9ooYmMVL15csPzu3Tv8/fffJjm2vlSfXlB15MgR0clZyTo1adIEXbt2FbR9/PgRgwcP5mc9ogxM38mWu3TpAk9PT0HbunXrNM4vQkTpBxPuREQixEa4r1q1yiLn1vQIIr9gExGR6uh2Dw8PlCpVSpJYsmbNio4dOwraTp48iQULFgjaKlWqpJwoVUy1atUwe/ZsuLq6IkuWLBg8eDAqV66MZs2a4aeffgIAlC9fXrCPs7MzateuDU9PTyxatAg///wzhg8frpa411epUqWwbds25MuXz6j9LWnz5s38TJCO9O7dG15eXoK2hw8fYvLkyRJFRETmpu9ky7a2tpg0aZLgb1dycjImT56Mr1+/mjNEIjIzJtyJiPSUlJQk6fn/+usvSc9PRETS+vLlC44cOSJoa9asmaSTev/6669qtdyfPn0qWNZUTia1OnXqYN++fThz5gw6dOigtr5mzZqCGwt9+/ZVjmyvXLkyxo4di7Zt24r+rV66dCm8vLxQqFAhdOzYEfnz51fbplKlSpDJZGjQoIHGGB0cHNQSp1JYtGgRqlatqvY6k3WSy+WYNm2a2hMUx48fx927dyWKioishaenJwICAgRt4eHhWL9+vTQBEZFJMOFORKQnudwyXebLly9x+/Zttfa1a9fi5s2bFomBiPRz48YNTJs2DcHBwRxxSmZ36tQpQa1zmUyGJk2aSBgR4OjoiPbt22vdpm7dunody9bWVuPfWrlcjrVr12L27NnYsGED2rRpI7pd7dq11dqqVKmCoKAg7N69G4MGDRLdr2nTpgAAHx8fjfEVKVIEhQoVEl3n7u6u83UwtdatW8PLywsdOnTA6tWr8fXrVyQnJ3MeGivk6OiI+fPnq92c+vPPPyWKiIisSUBAAEqUKCFoW716Ne7duydRRESUVky4ExGJEPuyauxj6obKmzcvypYtq9aelJSEMWPG4OPHjxaJg4i0i4qKQo8ePbB7924EBQVh8+bNUodEGdy+ffsEy1WrVoWbm5tE0fyftm3bwsXFRXRd+fLlkSdPHpOcx97eHvXq1UPZsmU1jupv3bq1YLlv375q26rWk3dzc1OOni9Tpowy+a5KLpeLlnwDgB9//FGSSTDj4uLwv//9D8uXL8fYsWOVZXjWrl1r8VhIuwIFCqjdlDl06BDevXsnUUREZC6GzsllZ2eHiRMnCm46JyUlYfLkyUhMTDRHiERkZky4ExGJkDLhrs2LFy8wZcoUjl4jsgKrV68WjGpftGiRhNGQPtLzpNRv3rzBxYsXBW3NmjWTKBqhbNmyYenSpahfv75gBK9cLkf37t0tGouXlxd69eqFEiVK4Ndff0Xnzp3VtmnRooXy3zY2NpgyZYpg/eTJk7Fx40a1/erWrYv69evD2dlZbV3p0qXVJr6ztOPHj+PVq1dITk7G0qVLERwcjJiYGEljIiFfX1/Y2dkplxMSErB7927pAiIis9A0J5c2pUuXRpcuXQRtd+/eFf17RETWjwl3IiIRYgltS5WU0eXkyZPYvn271GEQZXohISFSh0AGMuYLsLU4dOiQ4AZP1qxZ9S7VYgklSpTArFmzcPToUQQHB2PGjBnYtm0batSoYdE4ZDIZunfvjm3btmHEiBGiN8s9PT0RHByMPn36YNWqVahcubLaMcqUKYPAwEBlm729PZo3b47s2bOLJvHLlCmDihUromrVqoJ2Dw8PE/1khgsKCoKvry/evn0rWQwk5OLigoYNGwraduzYIfk8QURkHbp37672d2PVqlV4+PChRBERkbGsI3tERGRlrDnhDgALFizAnTt3pA6DiIgs5ODBg4LlunXrImvWrBJFo5lcLoenpyd8fHwkTTbrkjJJXfny5TVu07BhQ/zxxx/o06cPtm7dqizf065dO0Epn8KFC6NEiRKQyWRYunQpJk2ahNKlS6Nq1aqYNm0aqlSpYvafR5O3b99i8ODBAL6VJ7h9+zYWL16Mw4cP82k5ifj7+wuWX758iVOnTkkUDRGZQ0xMDB49emTwfvb29mqlZb5+/YrJkyfzxhxROmMrdQBEROmFpRLuMTExePXqldZRmF+/fsXo0aOxZcsWODk5WSQuIqL0Tp/+1RpFRkYiLCxM0Cb1ZKmZRbVq1VCtWjVBW9asWbF8+XIsXrwYSUlJ6NWrF2xt/+9rVfPmzdG8eXPlctGiRXH58mXBMX766Se1EkHmcvv2bbVR/ADw+fNntGrVCgkJCQgLC0P+/PmRN29ei8SUmZUpUwblypXDrVu3lG3btm1DvXr1JIyKiEzJyclJMMm5IcqWLYuOHTsKSsncvn0bW7ZsEX3Cioisk/UM1yQisiJio740TdBmKW3bthUsP336FNOnT+cINSIJqCY/KX1wcnJKlzcpDxw4IFh2cXFRK11CluXu7o45c+YgKChIZ+12Pz8/tX3Hjx8Pe3t7ZVutWrXMEqc2U6dOxZIlS+Dn54fu3bvjl19+waFDh7B3715BMphMT/Uz3bVr13Dv3j2JoiEia9OzZ08UKVJE0LZ8+XJERERIExARGYwJdyIiEVIm3DXVGO7atSu+//57Qdvhw4c52RaRhS1ZsoQjjMhiFAoFQkNDBW0+Pj5WMZE36cfDwwPt27cH8K1cQN++fZEvXz4sXrwYPj4+CAgIwJgxYySJbd26dXj27BkA4MuXLxg7diwmT56Mrl274ujRo5LElBk0aNAALi4ugjbOz0NEKbJkyYKJEycKvn8mJCRgypQpgvlciMh6MeFORCTCGkeN29raYsaMGciWLZugfc6cObh//75EURFlLvHx8Vi3bp3UYVAmcuvWLWVCNAXLyaQ/Q4YMwcGDB3H48GHUr18fAPDjjz9ixowZ6NOnD1xdXSWOUEihUGDChAlSh5Fh2dnZ4ZdffhG0hYaG4uPHjxJFRETWpnz58mjXrp2g7ebNmzhx4oREERGRIZhwJyISIeUId22T7OTPnx8TJ04UtCUkJGDUqFH4/PmzJcIjytQ+fPggdQiUyaiWk3F3d0eZMmUkiobSwtXVFc7OzqLr5HI5fvrpJwtHpF1CQoLUIWRovr6+gidV4uPjsWfPHgkjIiJr06dPHxQuXFjQpvrUGxFZJybciYj0ZKlJU3Xx9vaGv7+/oC0iIgKzZ8+WKCKizIOP8ZIlJSYm4siRI4K2xo0bSz6nCJnH5MmT0aJFC9StW1fqUMgC8uTJo3zaIcVff/3FvzNEpOTg4ICAgABB27lz5/g0DFE6YB3ZIyIiK2ONNdxTGzBgAEqVKiVo27t3L/bv32/O0IgyPSZCyJIuXryId+/eCdpYTibjcnV1xcSJEzFnzhw0aNBAbf2QIUP4dIMEYmNjERsba5Zjqw6giIqKwtmzZ81yLiKyHFP2G3Xr1hVMsp2YmIjjx4+b5NhEZD5MuBMRiRBLuKvOFC8le3t7BAYGwtHRUdA+c+ZMzl5PZEZMuJMlqZaTKVu2rNqj5ZQxBQQEIG/evACAQoUKISQkBO3bt8fGjRsREhKC3r17Y8aMGahVq5bEkWZ8+gyEMNb333+vNoBi27ZtZjkXEVmOKfsNZ2dntb7+4MGDJjk2EZkPE+5ERCLEEu4VK1a0yLm11XBPrXDhwhg3bpyg7fPnzxg9ejTi4+PNFR5RppaYmCh1CJRJxMXF4eTJk4K2pk2bShMMWZynpyd27dqF48ePY9euXShQoIByXYECBdCtWzf4+Pjgy5cvEkZJaSWTydC2bVtB26VLl/T6HEhEmUfjxo0Fy1evXkV0dLRE0RCRPphwJyISIZZwB749Hrh06VIEBQXh9evXFo5KnY+PD37++WdB27179xAUFCRRREQZ29evX6UOgTKJU6dOCZKpcrkcDRs2lDAisjR7e3tkz55da0m7Nm3amDWGsLAwsx4/PdB3IISxGjVqhJw5cwratm/fbrbzEZH5mbrfqFWrFpycnJTLCoVCbY4XIrIuTLgTEelJoVBgzJgxWLt2LYKDg9GzZ0+Nifm0MPQRxKFDh6J48eKCtr///htHjx41dWhEmR4T7mQpquVkqlWrBhcXF4miIWtVr149ZakBc0zu3rlzZ6xcudLkx01PnJycBIkuU7O3t1cbPLFv3z7ExMSY7ZxEZF6m7jfs7e3VJllmWRki68aEOxGRCLFE+tevX3Hu3Dnl8uPHj61i5JeDgwMCAwPh4OAgaJ86dSqePXsmUVREGRNLypAlvH37FhcuXBC0qT5OTgR8S7LPmTMH69evx44dO/Ddd9+Z/BwrV67k/BVm1qZNG8ENk8+fP2Pv3r0SRkRE1qZRo0aC5Tt37iAyMlKiaIhIFybciYhEiCXck5KS1Nrevn1r8nMb8wiih4cHRo4cKWiLjY3F6NGjOSKXyISYcCdLOHLkiCDB6eDgAG9vb+kCIqtmZ2eHcuXKwd3dHfb29mrrK1WqlOZzXLlyBbdu3cLz58/TfCxSlzdvXrXf8e3bt/NGBxEpVa5cWe1JN45yJ7JeTLgTEYkwR6kYfRn7CGLz5s3VJtQLCwvD4sWLTRUaUabHG1hkCarlZLy9veHo6ChRNJSeFC5cWK1t+fLl2Lp1Kw4dOoTTp0+jbNmyBh+3T58+6NKlC1q0aKE2mS+Zhr+/v2D5yZMnak+6EFHmZWNjAx8fH0HbwYMHJf3eSkSaMeFORCRC3w8u1vQBRyaTYdSoUXB3dxe0BwcH4/Tp0xJFRZSxMOFO5vbkyRPcunVL0NakSROJoqH0pkePHrCzs1MuV6tWDXK5HCVLlkTu3Lnh6OiIoUOHIlu2bEafY9iwYaYIlVT88MMPKFGihKBt27ZtEkVDRNZItbxcZGQk7t69K1E0RKQNE+5ERHqyVHI9NjYWsbGxRu3r6OiImTNnqj1SPmnSJLx48cIU4RFlWgkJCWqJUCJTUx3dnjNnTvz0008SRUPpTaFChTBjxgyUKVMGNWvWxLhx49S2KV++PP766680nScwMDBN+5M6mUyGtm3bCtrOnz/PGs1EpFS2bFkULFhQ0MayMkTWiQl3IiIRYjUzLZVwd3Z2RrFixYze39PTE0OHDhW0ffz4EaNHj8bnz5/TGh5RpvTx40d07twZq1evljoUysAUCoXaF2cfHx/Y2tpKFBGlR3Xr1sXGjRuxcOFC5MuXT3QbV1dXtdIEhvj7778RHR1t9P4krkmTJsiePbugLa03R4go45DJZGqTpx4+fJjzPRBZISbciYhEiCXXral8jC6+vr5o0KCBoO2///7DwIEDERcXJ1FUROnXvn37cP/+fanDoAzuzp07aqNZWU6GzKV79+5p2v/27dsmioRSODg4oFWrVoK2PXv28LMbESmplpV59eoVrl+/LlE0RKQJE+5ERCLEkuuWGvUeExODR48epekYMpkM48aNQ4ECBQTt165dw4ABA/jFjchAq1at0mu79HRjjqzPvn37BMuFChVCuXLlJIqGMjoPDw8sXrwYzZs3F51sVZfhw4ejadOm2Llzpxmiy7z8/Pwgk8mUy3FxcWp9AxFlXh4eHvD09BS0sawMkfVhwp2ISE/37t1TazNHcs3JyQlOTk5pPo6zszOCgoKQI0cOQfuNGzfQv39/Jt2JDKBvSQ8+0kvGev/+PUJCQgRtjRs3FiTeiEytevXqmDRpEsaOHWvU/tHR0ZgxYwbOnTtn4sgyrwIFCqB27dqCtu3bt/OGLhEpqY5yP3bsGBISEiSKhsh63bx5EytXrsSVK1csfm4m3ImIRIh9qQkNDZUgkrQpUaIEli9fjpw5cwra//33X/Tr18/oyVmJMhs7Ozu9tmPCnYy1bds2fPnyRblsY2OjVlqCyFx+/PFHFC9e3Oj9Bw4ciI8fP5owoszN399fsBwREYFLly5JFA0RWRvVOTg+fvyICxcuSBQNkXW6ffs2unfvjpUrV6J3794W/zvKhDsRkQh9RxGlh9FGJUuWFE2637x5E/369UNMTIw0gRGlAwqFAn/++afekwOmhz6BrE9cXBz+/PNPQVvjxo2RP39+iSKizEYmk2HVqlXo378/Ro0aZVTipl69ejh27JgZost8qlSpAg8PD0Gbah9BRJlXvnz58MMPPwjaWFaGSGjWrFnKwVAKhQIzZsyw6PmZcCciEpHRkmYlSpTAihUrkCtXLkH7f//9x6Q7kRb//fcf5syZo/f2HOFu3WJjY63yyZ6///4bnz59ErT99ttvEkVDmVX27Nnx22+/oU2bNrC1tUWtWrUMPsbIkSNRuXJlzJkzh58t0kAmk+HXX38VtJ05cwbPnz+XKCIisjaNGjUSLJ86dYolQ4lSCQsLEyw/ffrUoudnwp2ISERGS7gDQPHixbFixQq4uLgI2m/duoW+ffuqJXuICNi4caNB2zPhbt2cnZ1RrFgxqcMQSEhIwJYtWwRt3t7eaqNbiSxtyJAhqFSpklH7/vnnn5g9e7aJI8pcmjZtCmdnZ+WyQqHAyZMnpQuIiKxKgwYNYGNjo1yOj49nH0FkRZhwJyJKA3Mk5s05AtPDwwPLly9XS7rfvn2bSXciES9fvjRoeybcyVD79+/H69evBW1du3aVKBqi/+Pu7o6VK1eiR48eRu0fGhqKqKgoE0eVeTg6OqJevXqCtjNnzkgUDRFZm5w5c6JatWqCtkOHDkkUDRGpYsKdiEiElCPczT0C08PDAytXrkTu3LkF7WFhYejbty8nPSNKRSaTGbQ9E+7WLSYmBo8ePZI6DKXk5GS1pyiqVKmCsmXLShQRkTo/Pz+j9125cqUJI8l8ateuLVi+du2aVZbFIiJpNG7cWLD8zz//4N27dxJFQ0SpMeFORCQiI5aUSa1o0aJYuXIlXF1dBe1hYWHo06cPk+5E/5+hCfeM3nekd05OTnBycpI6DKWjR4/iyZMngrYuXbpIEwyRBrly5cKBAweM2nffvn1ITEw0cUSZx08//QQ7OzvlcmJiIi5evChhRESkD0vNGVOnTh1kyZJFuZycnMzJq4msBBPuREQi9E2amSO5ZqkRmEWKFMHKlSuRJ08eQfvdu3fRu3dvJt2JYHjCPSkpyUyRUEajUCiwfv16QVvp0qVRtWpVaQIi0iJPnjwICQnBd999Z/C+U6ZMYWkZIzk6OuLHH38U3tMlSAAAifxJREFUtJ0+fVqiaIhIX5aaM8bR0RF16tQRtB08eNDs5yUi3ZhwJyISIeUoVUuOwHR3d8eKFSvg5uYmaP/f//6HXr16saY7ZXpyuWEflTjCnfT1zz//IDw8XNDWtWtXg2/yEFlKgQIFsGXLFhw7dgzly5fXe7/Q0FC0bNkSixcvNmN0GZdqWZlz586xfBkRKamWlblx4waeP38uUTRElIIJdyKiTE5T0j08PBwjRozA169fJYqMKP1hEoT0tW7dOsFykSJF4O3tLU0wRAbIkSMHxo8fb/B+GzZsYG1hI6gm3N+9e4fbt29LFA0RWZvq1asje/bsgrbDhw9LFA0RpWDCnYhIhJQlZaRQuHBhrFy5Ennz5hW0X758GVOnTs0wPyeRufF3hfTx77//4vr164K23377zeAnKoikYmyphLCwMBNHkvEVKFAAHh4egrYzZ85IFA0RWRs7OzvUr19f0Hbo0CGJoiGiFPxUT0QkIrMl3AGgUKFCWLFiBVxcXATtoaGhWLFihURREUnn4cOHuHnzpkH7sIY76UN1dLubmxuaNGkiUTRExjl//rzB+/CmknFUR7mfPXtWokiISB+WmpMrhWpZmfDwcDx8+NBi5ycidfzEQ0QkIjMm3IFvSfcFCxbAwcFB0L569WqEhIRIFBWR5SUlJaF3794G75fR+gQyvXv37qklyzp16gQ7OzuJIiIyjr29Pf755x+D9rGxsTFTNBmbasI9PDwcL1++lCgaIrI2P/zwg1p5UE6eSiQtJtyJiERk5qRZmTJlEBgYqDYKbdq0aQZ/sSZKr86ePYs3b94YvB9ruJMu69evFyznyJEDrVu3liQWorSys7NDjx499N4+MjLSjNFkXN9//71ajWaWlSGyXs7OzkaX3jKGXC5Hw4YNBW0HDx7M1N9piaTGhDsREampXbs2Ro4cKWhLTk7GyJEjER4eLlFURJZj7MhBJtxJm6dPn+LIkSOCtnbt2iFr1qwSRUSUdj///LPe286cORNv3741YzQZk42NDWrWrCloY8KdiFJTLSsTFRWFW7duSRQNkXW6du2axc7FhDsRpXvR0dHo2rUrfvrpJ4wdOxYJCQlpPiZHAwC//PILfvvtN0FbXFwcBg4cyMeYKcP7+vWrUfsx4U7abNy4UfAecXR0xK+//iphRERplydPHkyaNEnv7X18fLB8+XK1iYNJO9WyMpcvX8bnz58lioaItHn58iVu375t0XOWKlUK7u7ugjaWlSES6tmzJ+7fv2+RczHhTkTp3p9//on//vsPSUlJOHToEM6dO5fmY2bWGu6q+vbtCx8fH0Hbq1evMGDAAMTExEgUFZH5GXvjjgl30uT169fYu3evoM3X11etTARRetS8eXNcuXJF7+1Xr16N33//nckgA1SvXl1Q7i8hIQGXL1+WMCIi0iRv3rwoW7asRc8pk8nURrkfOXIESUlJFo2DyJopFAosWbLEIudiwp2I0r0NGzYIlidOnJjmY2b0RLq+5HI5Jk2ahEqVKgnaHzx4gBEjRhg9Cpgoo2LfQZoEBwcL+kw7Ozt06NBBwoiIpDdu3DipQ0g3smXLhh9++EHQpjoBMxFlbqoJ97dv36J///7YvXs33r17J1FURNbl4sWLFjkPE+5ElOGYIuFl7Aj3c+fOoWfPnpgwYUKG+VBjb2+PuXPnomjRooL2S5cuYdq0aUwwUoZkY2Nj1H4cRURiXrx4gR07dgjamjdvjjx58kgUERGlR6plZc6cOcPPYURWKCYmBo8ePbL4ed3d3VG6dGlBW8p3tkaNGqFXr17Yvn07Xr16pfU4Hz9+xH///YcTJ05wsmsiI9lKHQARUUbx/v17DB48WFBSYsqUKRJGZDrZs2fHokWL0KVLF8FkZ/v370fu3LnRv39/yGQyCSMkIrJOycnJmDx5MuLi4pRtcrkcnTt3ljAqIkqPateujQULFiiXX716hf/9738oVaqUdEERkRonJyfB331LatmyJe7cuaPWnpycjCtXruDKlSuYPXs2ypcvj3r16qFo0aKIjIxERESE8r/U3/fkcjnmzp0LLy8vS/4YRGaTJUsWi5yHI9yJiEQYM8J969atgmR7aGioyeOSUoECBbBgwQI4ODgI2jdu3IiFCxdyhBVlGMnJyQgJCTF6X6LUtm/frlZnuXnz5ihcuLBEERGZj+pk62Ra7u7uan3HmTNnJIqGiDSJjY1FbGysJOf29fVFmzZtYGdnp3W7mzdvYsGCBRg0aBCCgoKwc+dOXLt2TZBsB759tp05cyZLiVKGoZrPMBcm3ImIRBiTcH///r3a+s+fPxt8bik/oOlSpkwZzJgxQzBpFwBs3rwZQUFBTLpThvDHH38gIiLCqH35O0CpRUREYNGiRYK2vHnzYvDgwRJFRGReXbt2NXgf1eQOaSaTyUTLyhCRdXF2dkaxYsUkObeNjQ1GjRqFo0ePYvr06ahXr16aE4zR0dGc5JoyDF03o0yFCXciIhHGJM3ESqoYUzJAyg9o+vDy8sKECRPUft6tW7di9uzZHOFL6d7GjRuN3pcJd0qRlJSECRMmICEhQdA+ceJEZMuWTaKoiMzL2dnZ4PIma9asMVM0GZNqwj0sLAxv3ryRKBoislZOTk5o1KgRZs+ejaNHj2LOnDlo0qQJnJycjDrepk2b+D2PyACs4U5EGY4lJ01NTSzhLsVkOZbQvHlzyOVyTJo0SfDB66+//kJSUhJGjRqlNgqeKDPgFxFKsW7dOoSFhQna2rZti6pVq0oUEZFljBo1CpMnT9b7M5BqySXSrmLFinBychI8DXnu3Dm0bNlSwqiIKLWYmBi8evXKagZROTg4oG7duqhbty4SEhJw+fJlHDt2DBcvXsSXL19QpEgRFClSBEWLFkXRokVRpEgRREREYNiwYcpjPHz4EOfOnVO76UdE4phwJyISwVGqujVt2hS2trYYN26cIMm4c+dOJCYmYty4cUy6U7qTlJSUpv3ZdxAA3LlzB6tWrRK0ubu7o3///hJFRGQ55cqVw19//YWwsDC9nvR7+PAh7ty5g9KlS1sguvTPzs4O1atXx9GjR5Vtp0+fZsKdyIpIOWmqLvb29qhZsyZq1qypdTt3d3d4eHjg4cOHyraNGzcy4U6kJ2ZCiIhEGFPDXWyEe0bn4+ODGTNmwMbGRtAeEhKCyZMnc7QvpTtp/XLEhDvFx8djwoQJgps3crkcU6dOtdgkTUTWwJAEeqdOnRAcHGzGaDIW1YTXxYsX1cpXEZF0rHlOLn3J5XK1m6bXr1/HzZs3JYqIKH1hwp2ISISUSbOXL1/i9u3bkp3fUA0aNMDMmTPVku779+9XSzoRWbu0fjliwp2WLl2qVkojICAAZcuWlSgiImnIZDKDbjIFBQWZMZqMpUaNGoKBHp8/f8bVq1cljIiIUrP2Obn01ahRI7i5uQnaNm3aJFE0ROkLE+5ERCKMGeFuKnnz5k13iZm6detizpw5sLUVVio7ePAgR7pTupLWhDvf65nbtWvX1EbplipVCt26dZMoIiJpTZo0SeoQMqRcuXLh+++/F7SdOXNGomiIKKOys7ND+/btBW0nT57E48ePJYqIKP1gwp2IiEzCy8sLc+fOhZ2dnaA9NDQU06ZNYyKSrF5CQgK2b9+epmNwhHvmFRsbi0mTJgneA/b29pgyZYpav0iUWTRo0AAzZszQe/vw8HAzRpOxqJaVOXv2LP8GEVmJmJgYvSeOtna+vr5wdnZWLisUCo5yJ9IDE+5ElOGY4suGMccwVQ339FZSJrVatWohKCgI9vb2gvaQkBDMnDmTXwTJqg0aNAh///13mo7B93jmFRQUhKioKEFbnz594OHhIVFERNbBx8cHV65cURslKaZ9+/Y4d+6cBaLSn7XWYlZNuEdFRQkmNyQi6Tg5OcHJyUnqMEzC0dERfn5+grb9+/fj9evXEkVElD4w4U5EJELfpNmkSZPQuHFj3Lx502QJ9/RYUia16tWri450/3/t3XV4FGfXBvB7N5BAEgIESGhwbfGixb1Ag7s7xR2KW4O7BXdocU0huGvR4lIcigQnAkkg+/3Bl7yZnVlLZndmd+/fdb3Xyz4zO3O6kzzZPXvmPFu3bsXUqVOZkCRVCgkJwdmzZxN9HN7J4ZyOHTuGHTt2CMaKFCliVoKRyFmUKVPGrP0mT55s5Ugso9ZezDly5ED69OkFY2wrQ0TW0KxZM8Fnu+joaKxfv17BiIjUjwl3IiIJliSFX79+jblz51oxGvtTunRpTJkyRdTTfePGjZg5cyaT7qQ6L168kOU4/Nl2Pu/evcO4ceMEY+7u7hgzZgy0Wr7VJopl7iLq+neKkDSNRiOqcmfCnYisIU2aNKhVq5ZgbPPmzaq8+4dIaXv27EHVqlWZcCcikmJp0uzSpUuyVbg7Ss+/cuXKYeLEiaKE09q1azF37lwmJklVvnz5Istx+HPtXHQ6HSZOnIi3b98KxgcMGAA/Pz+FoiJSJ3MT7oC65lI1vy/TT7hfvXoV79+/VyYYIoqj1lZUidGqVSvB592wsDBs27ZNwYiI1CcqKgoTJkzA+/fvmXAnIsejpg9pzq5SpUoYP368KOm+evVqLFq0SKGoiP5Hp9Nhx44d6N+/vyzHY0sZ57Jnzx4cOnRIMFauXDnUqVNHoYiI1Ou7774ze98nT55YMRLLqLkXc7FixZAsWbK4xzExMTh16pSCERERoN5WVImRJUsWVKxYUTC2du1aREdHKxMQUQLJVSgp5cqVK4iIiADAljJERJKUXDTV0d6g/fzzz/j9999Fr8/SpUuxdOlShaIi+mbfvn0YO3YswsLCZDkev/BzHiEhIaJe0ylTpsSIESOs+kaeyF7lzJnT7H379etnxUgch6urK3766SfB2LFjxxSKhogcXZs2bQSPQ0JCcPjwYYWiIVKf+IWGTLgTEUlg0kxev/zyC0aNGiUaX7hwIVatWqVAROTsgoOD0blzZwwfPlzW43LucA46nQ6///676Iua4cOHI02aNApFRaR+R44cMWu/R48eqaZqUu2tIfTbypw4cQKfPn1SKBoiAtTdiioxChQogB9//FEwtn37dkViIVI7JtyJyOFERUUl+hhKJs0c9Q1a7dq1JZObc+fOxdq1axWIiJzVvXv3MGrUKFy8eFH2YzPh7hz++usv/P3334Ixf39/VK5cWaGIiOyDp6cnNm/ebNa+FSpUUEXiWO13HlasWFFQUff582cunkqkMDW3okqshg0bCh6fPXuWi12TXbHV5zUm3ImIJCiZNHPkN2j169fH4MGDReMzZszAxo0bFYiInNGCBQusdmz2cHd8Hz58wOzZswVjPj4++O233xSKiMi+ZM2aFbt27TK5X1RUFHbv3m2DiOxbqlSpRG1l9u7dq1A0ROToKleuDE9PT8FYUFCQQtEQqUv8PBIT7kSkqKioKKxbtw5z5szBo0ePlA4nUeTq2av2W5cTq3HjxpILVE6ZMgVbt25VICJyJrdv3za7pUFCsMLd8QUGBuLDhw+CseHDhyNFihQKRURkf3x9fVGmTBmT+02YMMEG0RhnD3ceVqtWTfD41KlTCA0NVSgaInJkbm5u8Pf3F4wFBQWx6ITshjXXWmLC3U7Frjp/7do1pUMhks38+fMxffp0rF69Gu3atYtb0VlpXDTVulq0aIHevXuLxidMmMAKCbKamJgY9O3b16rnYMLdsV25cgXbtm0TjFWuXNmsxCERCU2bNk3pEMxiD3ceVqxYEUmTJo17HB0djaNHjyoYERE5srp16woeh4SE4MyZMwpFQ6ROTLjbiU+fPqFz587o3bs32rVrhzlz5igdElGi6XQ6/PHHH3GPQ0NDcf78eQUj+h8mzayvTZs26N69u2h87NixCA4OViAicnTXr1/Hq1evrHoOVvc4rq9fv2LSpEmCseTJk2PAgAEKRURk3+IniI3hvGpaihQpUKpUKcHYvn37FIqGiBzd999/jx9++EEwxsVTiVjhbnd0Oh1+//13/PPPP3Fjq1evxo4dO5QLikgGUm1Tnj59qkAkYtevX7f4OXJVuNvDrcty6dChA3799VfBmE6nw5gxY/hBkWT3+fNnpUMgO7ZhwwbcuXNHMNalSxf4+voqFBGR/dPvPS7lwoULNojE/lWvXl3w+MyZM3j//r0ywRCRw9Ovcj927Bjevn2rUDRE6sCEu51Zvnw5Dhw4IBqfNGkS28uQXZOqWHJ1dVUgErG//vpLsXPbw63LcurcuTPat28vGIuJicGIESNw6NAhhaIiR+Ti4mL1c7AS0zGFhIRg4cKFgrGcOXOiWbNmCkVE5BgGDhxocp/NmzfbIBL7V65cObi5ucU9jomJ4fsoIoU4+ppcAFCjRg3BZ/cvX77wLmWieJhwV7kjR45gwYIFktuio6Px22+/4c2bNzaOikgejta2xZqLbzgyjUaD7t27o1WrVoLxmJgYDB06FMeOHVMoMnI0tphzmHB3TNOnTxetMTJ06FAkSZJEoYiIHEO2bNmQN29eo/scPHhQ0bnVXhJn7u7uKFeunGCMdwsSKcMZ1uRKkSIFqlatKhjbsWOHw33GJ0ooJtxV7O7duxg1apTRfV69eoXBgwcjOjraRlERyUfqjzH/QNvPBzs5aTQa9OnTB02bNhWMf/36FYMHD+YiPCSLyMhIpUMgO3Tq1CkcPHhQMFa3bl0UKlRIoYiIHEvbtm1N7rNlyxYbRCLNnhJn1apVEzy+cOECXr9+rVA0ROTo6tWrJ3j84MEDXL16VZlgiFSALWXswPv379G/f39RNVXv3r1RvHhxwdg///yDGTNm2DI8IlmwElSaPX2wk5NGo8HAgQPRsGFDwXh0dDQGDRok6p1MZClb9HDnvOZYIiMjMWXKFMGYl5cXevXqpVBERI6nSpUqKFasmNF9Jk+ebKNo7FuZMmXg7u4e91in04m+MCQi63OWNbkKFy6MTJkyCca4eCo5MybcVe7Lly8YPHgwnj17JhivVasWWrdujQkTJiB9+vSCbZs2bUJQUJAtwyQiPWwpk3gajQaDBw9GnTp1BOMRERHo27cvQkJCFIqMHIEtKtx5l45jWblypWgx7z59+iBVqlTKBETkoKZNm2ZynxcvXtggEjF7Spy5ubmhYsWKgrG9e/cqEwyRE3OWNbk0Go1o8dT9+/eLCkeJbE2pIqj452XjSRWaMWMGLly4IBgrUKAAhg0bBo1Gg9SpU2PatGno0KEDoqKi4vaZOHEicuTIgXz58tk6ZKIEcbSWMnIl3MPCwvDq1SunrHIHAK1WixEjRuDz58+C3qMhISHo06cPli5d6hRvYEl+8f9mmlKwYEGkSZMGhw8ftugc9jyHkdDjx4+xcuVKwVjBggVRu3ZtZQIicmCenp44d+6c6E7e+GrVqoWzZ89Cq7VtzZiHh4ddJY+qVasmWLjwypUreP78Ob777jsFoyIiR1WrVi3Mnz8/LtH46dMn9OvXD+nSpYNWq4VGoxH8v1arhZeXF6pVq4bcuXMrHD05qq9fvypy3vgJd1a4q8zWrVuxceNGwZiPjw+mTp0qWAH6hx9+wIgRIwT7xS6i+vbtW5vESpRYcnzr6IiLBjtLRYQxWq0WY8aMwY8//igY//fffzFkyBB8+fJFmcDIrpmbMClatCiWL1+OjBkzWnwOtpRxDDqdDpMmTRKskaPVajF06FCbJ/uInIU5hQvr16+3QST27aeffoKXl5dgbP/+/QpFQ0SOLm3atChbtqxg7MKFC9izZw+Cg4Oxa9cu/PXXXwgKCsL27duxdetWrFy5Ep06dcKTJ08Uipoc3adPnxQ5LxPuKnXx4kVRf0JXV1dMmzYNadOmFe3v7++PFi1aCMZCQkIwePBgJqPILshRCZrYxUX//fdfdOrUCa1ateLCnCrj6uqK6dOnI3PmzILx06dPY9KkSawkJouZM1/Mnj0bCxcuBJCwOYo/l45h//79OHv2rGCsRYsWyJUrl0IREREArltlhqRJk6Jy5cqCMSbcicia9BdPNUdERATWrVsnfzBEgNH1S6zZCpg93FXo+fPnGDRokOi2h1GjRiFv3rwGn9e7d28ULVpUMHbp0iW+GSUy09ixY/HPP//g1q1bGDp0qKCa0VLs4S6/lClTYs6cOaJ+ydu3b8e8efOUCYrslqkK9xEjRqBMmTKJ+l1mwt3+hYWFYfr06YIxHx8fdO7cWaGIiCg+FhaZVq1aNcHjmzdv4vHjxwpFQ0SOrkyZMqI7k82xd+/eRH3+JjJEqQr3+J8F2cNdBT59+oT+/fvj/fv3gvG2bduiRo0aRp+bJEkSTJo0Ca1atcLLly/jxjdu3Ig8efKwzyipmlTrBUt7bSU0Mfb161c8evQIN27ciBsLDQ3FmTNnUK5cuQQdkwl368iYMSNmzpyJLl26CHpwr1y5Ep6enmjXrp1ywZFdMdXD3d3dXfA4Ia1DmHBXt/DwcJN3OixcuFDUrmzgwIGinw8iUkZkZCSSJLHdx1hz5g21KVq0KLy9vQWtRvfv34+OHTsqGBUROSoXFxfMmjULhw4dwvPnzxETEwOdToeYmJi4f3/9+hXR0dHYtGlT3PM+fPiAU6dOoUKFCgpGTyQfLpqqIjExMRg9ejT+/fdfwXjZsmXRo0cPs44Ru4hqx44dJRdRNVYhT6QkqcRUYGAgmjdvbvYxEpLkjoqKQvfu3fHPP/+ItqnhG3Z7/GBnbQUKFMD48eMxePBgwR+xwMBApEiRAg0bNlQwOrIXpn6/9ROqLi4uFp+DPdzVzdPT0+j2W7duidbSKV26NCpVqmTNsIjIApGRkTZd68bUvKFGLi4uqFq1qmA+27dvHxPuRGQ1np6eqFOnjsn97ty5g8uXL8c93rVrFxPuJDv9O+SVwJYyClu2bBkOHTokGMuaNSvGjRtnUWVdnjx5RIuoRkVFYeDAgVxElVRLKuEeGRlp0TEMJdyNVZkeOHBAMtmeWHJVtnp6eiJbtmyyHMuRVKpUSTTPAcCkSZOwZ88eBSIie2Mq4Z48eXLB4xQpUlh8jpCQEIufQ+oQExODiRMnCr40cXV1xeDBg3kHE5GN5MiRw+Q+bCljHv22Mvfu3cO9e/cUioaI6JuaNWsKHh8/fhwfP35UKBpyVFLrYNoCF01ViUOHDmHRokWCsRQpUmDGjBkJqqTw9/dHs2bNBGMhISEYMmQI35iSKsmRoE5Iwv2PP/4wedyEtJJgZav11alTBwMGDBCM6XQ6jBw5En/88QfbeZBRpv4WJk2aVPC4bt26FrctWLNmjcVxke2EhYXhwYMHktu2bduG69evC8Y6duyIDBky2CI0IgIwZMgQk/vYuhe5sXlDzQoWLAgfHx/B2L59+xSKhojom6pVq8LV1TXucXR0NBd2JtkplQPloqkqcP/+fYwePVowptVqMXHiRGTOnDnBx+3bty+KFCkiGLt48SLmzJmT4GMSWYtSyVFTbSJi+80pxV4/2NlK8+bNRYsX6nQ6zJo1C+PGjVNFWyBSJ1M/G/qJ1ZQpUyIgIMCic3z+/NniuMh2PDw8JFtRvHv3DoGBgYKxLFmyoHXr1rYKjYgAFC5cGDNmzDC6T9euXUVFS9ZkaN5QO61Wi59//lkwtm/fPhYnEJGivLy8RGum7dq1S6FoyFFZujagXJhwV4GRI0eKVs3t27cvSpYsmajjxi6i6uvrKxhfv349nj9/nqhjE8nNmkltYx8m4i8wLEXpSnV7/WBnS7/++itatGghGt+xYwd69OiBDx8+KBAVqZ2pSoc0adKIxqpVq4Zhw4ZZKyRSiUWLFiE0NFQwNmTIEEEFFhHZRvny5VG0aFGj+yxZskT0O0ti1atXFzx+8uQJbt68qVA0RETf6LeVuXLlis3vXiLHZizhbs0vnplwVwH9hF+dOnUsWijSGG9vb0ydOlXwITEmJga7d++W5fhEamIoOW5sEjW2rkHsCuoJwYoh29FoNOjXr5/k4tIXL15E165d2QuQRIxVuHft2tXgtvr164tuyyfHcuDAAcHjGjVqoHjx4gpFQ0TmtPOSWteFhPLkySO6eyswMJDvWYlIUaVLlxYtahkcHKxMMOSQjBVRWnNtJvZwV5mCBQtiyJAhsl70vHnzolatWoKx4OBgvrkiVZHj59HQRJqYKnWueWAfNBoN2rdvjylTpiBZsmSCbf/++y969OiBsLAwhaIjNZJKuHt7e6NChQpo0qSJwedpNBrs3LkTGTNmtGZ4ZAPh4eEIDw83uo+Hhwf69etno4iISEr9+vVN7nPy5EkbRGLfNBqN6DPh2bNn2cudiBSVJEkS1KhRQzAWHBys+J3m5DiUSrizwl1FfHx8RNXocvH39xc8fvjwIW8hJFVR4x/UwYMHi9ZXIHWrXLkyli5dKqpAvnnzJnr37o2IiAiFIiO10U+4Dxo0CPv27cP06dPh5eVl9LlarRYFChQweY4yZcokKkayLk9PT2TLls3oPj169JBsL0REtlO+fHmlQ3AYLVu2FLUbnTFjBosSiEhR+m1lnj17hn/++UeZYMjhMOHu5FxdXTF9+nSrfagrVKgQ/Pz8BGNsK0NqYs0K98Qc+/Dhwwl6Hu8gUc4PP/wgmXS/cuUK+vXrh6ioKIUiIzXRv3sladKkFj3f1ILLANh6xs7lyZMHjRo1UjoMIqfn6uqKyZMnKx2GQ3B3d8dvv/0mGHvz5g0WLFigUERERN8+v2XPnl0wpt/ijyihlCruZEsZlRg9ejTy5MljteNrNBpRlfvevXsVW62XyBoMTaRXr161cST8Qktpfn5+WLhwoehLzAsXLmDy5Mn8QoREFe6WJtzN+fvJv7HqFhYWhgcPHkhu02g0GDp0KLRavj0mUgO1VLmb04pK7SpUqICyZcsKxjZt2oRbt24pFBEROTuNRiNqK3Po0CFV3gVP9kepnyNWuKtA8+bNRavGW4N+wv3t27c4c+aM1c9LZA5rToJnz5612rENef36tc3PSUKZM2fGggULRIvw7NixA5s2bVImKFIN/TsdzFmULz5z+gXLkXDnBw3r8fDwgIeHh+S2Ro0aIW/evDaOiIgMsfRLUWsxpxWV2mk0GgwaNAhubm5xYzExMZgwYQL/5hBZgSN8UWcLlStXFjx+/fo1rl27plA05EiMfSZjSxkH1759e5ucJ3PmzMiXL59gbNeuXTY5N5EphiqODVUfSjH0IYFVps4re/bsmDdvnmgh1enTp+PChQsKRUVq8OrVK8Fjd3d3i57/8eNHk/vIkbiQWtyVrCt16tTo3r270mEQkYWUKLCwV35+fujYsaNg7MaNG9i2bZtCERE5Lkf4os4WsmbNKmorc/DgQYWiIUei1N3tTLirgC1vV9ZfjOLIkSP8tpVUwdAk2KJFC7M/QBlKbrFax7l9//33GDNmjGDs69evGDx4MJ4/f65MUKSo+/fvixLmyZMnl/08rHC3T127dkWKFCmUDoOI9AwfPtzo9mnTplk9BmOtqOxNq1atkCVLFsFYYGAg3r59q1BEROTs9KvcDx06xFaglGhKFWCyh7uT+fnnnwULvUVFReHQoUMKRkT0jaE/pNHR0QgICEjUsVnhTlWrVkWHDh0EY+/fv8eAAQPw6dMnhaIipaxbt040xoQ7xdL/sEdE6lCvXj2MHTvW4Pb79+9bPQZjrajsjaurK4YMGSIYCw0NxezZsxWKiMgxvXz5EtevX1c6DLug/x7s+fPnXF+CEs3Y5ylrtpSJjwl3J5A6dWqULl1aMBYcHKxQNET/Y+yb6xcvXph1DEMTaUREBGbMmIEOHTpg9erVTGA5qa5du6JcuXKCsTt37mDs2LGsnHAyUrfM67cdkkNiE+7h4eHo06ePTNGQPkM9VW31xpuILKPRaPDLL78Y3efJkyc2isYxFC9eXLRQ4a5du3Ds2DGjz4uMjMSNGzfMaq9G5Ox8fX1FrX1JWq5cuZAxY0bBGAtEKbGM5X+smQdghbsT0l889fz58wgJCVEoGqJv5JjoDE2k27dvx9q1a3HlyhXMmTMHf//9d6LPRfZHq9Vi7Nixotun9+3bh1WrVikUFamFq6ur7MdMbMJ97969+Oeff+QJhkTYU5XI8XTp0kXpEOxOv3794OnpKRjr378/unfvjnPnzgneo7969Qrz5s3DL7/8gjZt2qBq1aro3Lkz/vzzT37ZQUSJptFoRFXuBw8eZHEUJYpSCXf2cHdC5cuXF9wKqdPpsHv3brOeGxMTg7CwMGuFRk7Mln9Ef//9d5udi9TF09MTM2bMEH2wDAwMxMqVK/lmzom5ublZtL85668kNuE+YcKERD2fiMgRNW3a1OA2FhFZLk2aNJILRZ89exbdunVDhw4dEBwcjFGjRqF27dpYsWJFXGV7TEwMLl68iJkzZ6J+/fpo3rw5zp07Z+v/BCJVY0sZy1SpUkXw+PHjx3HrL924cQNRUVEKRUb2ythnMibcSVZubm6oWrWqYGzXrl0mf9CuXLmC6tWro1KlShg3bhzbcpCsrFnhru/169eJPpetGGp5QAmXJUsWjB8/XtQ2IjAwEGPHjkV0dLRCkZGSLE249+zZ0+Q+XD9C3Rxp8UMiZ9K2bVuj29nmxHKNGjUStR2NdfXqVYwaNQrBwcH48uWL0eP8+++/6NmzJ1tAEMXDljKWyZs3L3x9fQVjffr0QdWqVdGmTRv4+/tj27ZtzEeR2YzlmphwJ9nVrFlT8Pj+/fv4999/De4fFhaGwYMH4927d9DpdNi+fTt27txp7TDJicjxB9MR/+iy5YF1lClTBr169RKNBwUFoUuXLnj27JkCUZEtGKp+tLSlTNasWU3u44hzkiNxpMUPiZyJj4+P0e2dOnWyUSSOQ6vVYvr06ejXrx/Spk2bqGN9/foVQ4YMwZ49e2SKjoiciVRbmRcvXsS9r37//j3Gjx+Ptm3b4tq1a0qESHbGWBGUNT+vsYe7k/rxxx+RPn16wdiuXbsM7h8YGIhXr14JxubNm4eIiAirxEfOh608yNZat26Nvn37iirdr1y5gubNm2Pfvn0KRUbW8OXLF2zcuFG0jkksSyvc379/b3IfVrgTEVmHoWps4FshEVkuadKkaNmyJYKCgjB06FD4+flJ7ufq6ooGDRpg7dq1mDFjBurVqwdvb2/BPjExMRg5ciSCgoJsETqRqvGOOsvpJ9yl3Lx5Ex06dMCZM2dsEBHZM6VyTaxwd1JarRa//PKLYGzPnj2SyYHLly9j8+bNovE3b95gxYoVVouRyFKOWE3Knn/Wo9Fo0KpVK0ydOhXJkiUTbAsPD8ewYcMwdepUJk0dxLx58zBlyhSD211cXCw6XtKkSU3uY+rWeyIiSpgOHTooHYLDcnV1RcOGDbF161b8/vvvcXdapkmTBt26dUNwcDCGDRuG3Llzo3z58hgxYgT27NmDRo0aCY6j0+kQEBCAbdu2KfGfQUR2rFChQga/9IsvJiYGq1evtkFEZM+UqnBnwt2J6Vf5vXnzRrTITVRUFMaOHWvwGH/++SdbL5As2FJGGnv+WV/FihWxZMkSyTd1GzZsQM+ePfHhwwcFIiM5rVmzRtbjmZOgd8Q5iYhIDTJnzqzIeZ1pbZ0kSZKgZs2a2LhxI/bt24fdu3ejY8eOSJUqlWhfrVaLwYMHo0WLFqJtEydOZNsHcmpsEWo5rVaLcePGIVeuXPDz80OtWrUwbdo0zJ49W9TW8cKFCwgNDVUmULILxj6TWav6/dSpU9iwYUPcYybcnUy2bNmQJ08ewVhwcLDg8YoVK/Dw4UODx4iKisLs2bOtER45GVaCkpLy5MmDdevWSbYbOXfuHHr06MGfUTtmjdt4c+TIYXKfhN4dodPpWBFIRGSEpW3A5OKMiTONRgNvb29otcbTBRqNBv369UO7du0E4zExMRg+fLjTfFFBRPIoWLAg1q1bh6CgIIwZMwYVK1ZEmTJlsHr1asHaS1+/fsWpU6cUjJTUztYJ940bN6J3796C4mQm3J2QfluZQ4cOxfVlv3//vqhlTN68edGkSRPB2MGDB3Hx4kXrBkoOb/v27Yk+RkKqSfX7d6sNW8rYjoeHBwICAjB69GhRu5Bbt25h06ZNCkVGiXXnzh3Zj5kjRw4ULVrU6D4JSbi/f/8eq1evxvjx4xMaGhGRw0uePLnR7bt377ZRJBSfRqNBjx490KZNG8H4f//9h8mTJysUFZGy2MNdXu7u7ihevLhg7OjRowpFQ/bA1gl3qTamTLg7oRo1agiqFT5//owjR44gJiYGY8eOFVR0arVajBgxAl27doWXl5fgONOnT+et85Qoe/bsSfQxHDHhzpYytle7dm0sWbIEadOmFYwvXrzYrIUySX2sdavg3LlzMXLkSIPbLU2479u3D/7+/pg7d25iQyMzOFNrCCJHo9Vq4enpaXC7sbk5MZg4My026V6wYEHBeHBwML8IISJZVKhQQfD45MmTiI6OVigaUjtji6nbKo/JhLsT8vb2RsmSJQVju3btwubNm3H16lXBeNu2bZE7d254eXmha9eugm23b9/Gzp07rR4vEZEt5M+fX1SJFRoaisWLFysUESWGqXZAli6YGsvV1RV169Y1uP3evXsWJd1HjhyJqKioBMVClnPG1hBEjkS/Faa+ly9fyn5ODw8PeHh4yH5cR+Pi4oJx48aJXquJEyfiv//+UygqImXw/Yb8ypUrJ3gcHh7Orgtk0KFDhwxus1Zhlj4m3J1UzZo1BY/PnTuHwMBAwVimTJnQqVOnuMcNGzZE9uzZBfsEBgayUowU5Yh3WbCljHIKFSqEatWqCcY2b96MCxcuKBQRJZSppHeXLl0SdXz9n5P4zp8/b/ZxEtrznYjIGbm7uxvdvnz5chtFQlL8/PwwfPhwwVhERARGjRrlkO/Zich20qVLJ7oLnG1lKCGYcCerqlChguANa0xMTFwf91jDhw8XLE7k4uKC/v37C/Z5+/atqOc7kbny5s2b6GM44pt3tpRRVu/evQWL8sTExKBfv36iO4BI3UwlshNbdTR69Gh0794dPj4+om3sWatebA1B5Ni2bNmidAhOr1q1aqhVq5Zg7PLly1i3bp1CERHZHt9vWId+W5mjR4/aLHlKjoMJd7KqZMmSoXLlyga316tXD8WKFRONlyxZUnQrz59//snbBClBpBJVlrp8+bIMkRD9T/r06dGuXTvBWEREBHr16oWDBw8qExRZzFotZWK5ubmhQ4cOor+JAERfYJN6sDUEkeMzNf+T9Q0aNAgZMmQQjM2bNw8PHz5UJiAiG+P7DevQT7i/fPkSp0+fVigaUquzZ88a3c4e7mR1/v7+kuPe3t7o3bu3wef17dtXkKiIjo7GokWLZI+PbO/z58+YM2cOhg0bhitXrlj9fHJMdMuWLbP4OWpfNJUVEcrr2LGj6EvJsLAwDB48GMOGDUNoaKhCkZG5rJ1wjyU1n7DShojIesqXL290O3v6Ks/d3R2jR48WjEVFRWHMmDFspUZECZY9e3bRl3m9e/dG9+7dcePGDYWiIrXZsWOH0iEAYMLdqRUrVkyywnjw4MHw8vIy+LwsWbKgadOmgrFjx445ZGsPZzN79mysXr0a+/btQ5cuXfDx40erno8/M6RWLi4uGD9+PMqUKSPatm/fPrRs2ZJ99lXO1Ad6uRLuWq34rZS51ZWcA4mILNezZ08kT57c4PawsDAbRkOGFClSBM2bNxeMXbt2DWvWrFEoIiLbCQ8P51p3VqDRaERV7sC3iuaOHTvixIkTCkRFarN3716j21nhTlan1WpFi6dWqFDBaKuZWK1atRI8DgsLw927d2WNj2xv06ZNcf+Ojo7Gn3/+iY8fP2LlypXYvHmz7BUppia6Hj164Pjx47Ke0x5wVXt1SJo0KaZMmYKqVauKtj179gwdO3bE2rVrWc2sUqbmK7nudJFKuJszV0ZFRaFfv36yxEBE5EyyZ88ueM+qb+TIkTaMhozp0aMHMmfOLBibP38+goKCFIqIyDb4ec56WrZsKVk4Gh0djYEDB+LYsWMKREX2hD3cySbat2+PH3/8EQBQoEABjBgxwqwkhI+PDzJlyiQYu3DhgjVCJAU9fPgQHTp0QGBgICZNmoSJEyfKenxTCfe///4b/fv3x+vXr2U9r9pbypB6uLm5YeLEiRg7dqzozp8vX75gxowZGDRoEKKjoxWKkAy5dOmSTc4jdReEqYS7TqdD165dcfLkSWuFRUTk0NKmTWtwW2RkJHv6qkSyZMkwZswYwZfTMTExCAgIwPr16xWMjIjsla+vLzZs2IAePXrA29tbsO3Lly/47bffcOrUKYWiI6W9ffvW5D5MuJNNuLu7Y+nSpTh27BhWrFiB1KlTm/3cwoULCx7bKrlBtnPq1CnB4kbbt2+X9fjm3Mqj0+mwatUqWc9racLd19dX1vObwh7u6qLRaPDLL79g3bp1KFSokGj74cOHsXjxYgUiI0MiIyNNJrPleqOVJ08e0ZipljLXrl2zyToZRESOSuruovh69eplo0jIlIIFC6JDhw6i8WnTpmH58uUKRERkffw8Z10pUqRA+/btsXPnTtSuXVuw7evXrxg7diyioqIUio6UZOwOuFhMuJNNubu7W/ycokWLCh5fvHiRrRUczKdPn6x6fHNb1Mhd4W6p6tWrK3p+UgdfX18sXrwY7du3F21bs2YNHj16pEBUJOXvv/82uY+rq6ss57K0h3tYWJjkzxAREcnr/v37SodA/69Lly5o166daHz+/Pk4f/687QMisjIPDw94eHgoHYbDc3V1xciRI1GvXj3B+KtXr7Bt2zZlgiJFLVmyxOQ+7OFOqqdf4f7+/Xt+i+sE5JyczP2CRq4WMPXq1UNwcLDFz/P19UXx4sVlicEc7PmnXi4uLujRowfmzp2LJEmSxI1/+fIFkydP5peOKmHOgnnJkiWT5VxSi68a+znYvXu3LOelhOEiZkSOwZz3hvv27bNBJGQOjUaDnj17omfPnqJtgYGBfP9ERAmm1WoxbNgwUUHoihUrEBkZqVBUpGascCfV++6770StNthWxvGZapVgCXMr3I1NiDVq1DD7fE+fPsXvv/9ucb9td3d3LFiwAEeOHOE35QQAKFWqFFq2bCkYO3v2rFMu8qtG5ryJypAhgyznkkq4GzN58mRZzksJwy80iRyDRqOJW4fKELmKRPhFnXzatWsnSrpfu3aN75+IKFG0Wi26du0qGHv9+jW2bt2qUESkZky4k+ppNBrRt4hcONXxyZlwv3z5cqKPYWzRLCnmJvnji70d0NPTU7RYsDWw55996NixI3x8fARjCxcutNktamSYqWvQsGFDpEyZUpZzmeojHF/8NTGIiChxAgICjG6Xa+0hflEnr1atWiFjxoyCsXnz5vH9EzkUflFne4ULF0aJEiUEYytXrkRERIRCEZFaMeFOdkFq4VTeEujYLK0ON8SS/vDGbhu2xZtzT09Pq58jPvb8sw/u7u6iKq07d+7g4MGDCkVEsaS+GCxUqBAWL16MRYsWYciQIbKdy5IKdy4Opzx+oUnkOPz8/Ix+6fn27VsbRkPmSpIkiagS9d69e2wBRA6FX9Qpo0uXLoLHb968wZgxY5ijIgH2cCe7oF/h/urVKzx9+lShaCgxzP0jJFeF+4kTJ2Q5ji0mSy8vL6ufg+xTjRo1kD17dsHY/PnzWUmhMKl+jTqdDkWKFEHRokVlWxcCsKzCPSFrSJC8+IUmkWOR6gkuN35RJ79q1aohZ86cgrGFCxfKeictETmfQoUKoWTJkoKxQ4cOYfXq1QpFRGowfPhwRc7LhDslSqZMmeDt7S0YYx93+2Ruwl2uCne5juOICXfegmg/pPoFPnnyBBMmTGAlhYKkEu7WmivMTd7zSxgiIvmZ6uMuB35RJz+tVovu3bsLxp4+fcp+y+Qw+EWdcoYNGyb6/B4YGIhJkybhw4cPCkVFSipQoIDgMSvcyS5oNBoUKVJEMMY+7vbJ3IoSuSpPUqVKJctxHDHhzlsQ7UulSpVEf8T37NmDxYsXM+muEFsm3E358uULQkND8ffffytyfiIiR2bq/SQrptWrXLlyovdPixYtQlhYmEIREcmHX9Qpx8/PD+PHjxcUxeh0OmzevBmNGjXC48ePFYyOlCB1R7ItPqcz4U6Jpp9wZ4W7fTL3A4lclemW9D02xhZJNHd3d6ufg+yXRqPBuHHjRL3+lyxZgpIlS2LQoEG4efOmQtE5p8+fP4vGLGn9IpfHjx+jSZMmqFSpEn777Tebn5+IyNFlzpzZ6Hb2cVcvjUaD3r17C8Y+fPiAFStWKBQRETmKUqVKie6iAYB3795h9OjRCkREtpI3b17B48yZM0vekcyEO9kF/YT7s2fP8OLFC4WioYSydYX7169fZTmOLRLutk7U8RZE+5MhQwbJN29fv37FoUOH0KZNG8yaNUuxKmtnExUVJRpTIuG+cuVKVtEQEVnZhAkTDG5jhbu6FS5cGJUqVRKMrVu3Ds+fP1coIiJyFO3atUPv3r3h5uYmGL969Spu376tUFRkbfqftzt06CDr+l2WYMKdEi179uyilhsXL15UKBpKKFtXuFuSeDQ2QTpiApO3INqnSpUqYfDgwQa/Qf/jjz/wxx9/KBCZ85Gaz5R4oxUUFGTzcxIRORs/Pz+D21auXGm7QChBevXqJbjzNSoqCv369cPp06fZmo+IEkyj0aBNmzbYsmUL0qVLJ9i2ZcsWhaIia7t165bgsaurq2ThlU0KN61+BnJ4Wq0WhQsXFoyxrYz9mTlzpln7yVUpJNcE54gJd7JfjRs3xuTJk5EmTRrJ7YGBgfjnn39sG5QTkpoXSpcurUAkRERkbfny5TO4jYtwql/mzJnRuHFjwdjdu3fRq1cvdO3aFXfu3FEoMiJyBOnTp0f9+vUFY3v27EFERIRCEZG1hIeHi8aSJk3KljJk37hwqn3T6XTYvXu3Wfsq0VLG2Srcyb5VrlwZO3fuxPLly9GmTRvBtpiYGEydOpUVW1YmNb80bdrUpjHcv3/fpucjInJWGo0GVatWNbj99evXNoyGEqJTp05ImTKlaPzChQto2bIlJkyYIJlIkdN///2H+fPnY/Xq1Vy4lcjB1KtXT1DlHBERgT179igYEVnD33//LTnOhDvZNf2E++PHj/HmzRuFoiFLWZL8drYKd6X6fZF9S5o0KQoWLIjevXujc+fOgm23b99G165dUb16dbRt2xY3btxQKErHpT+nVatWTbSorbXNnTvXpucjInJm2bNnN7jt2rVrNoyEEiJVqlRYsGABsmTJItqm0+mwdetWqy4+/unTJ/Tq1QvLly/HnDlzMGXKFKudi5xDeHi41b8kIvP5+PigXLlygrE//vhDtna5pA5SuaGoqCjJljJMuJPdyJ07N9zd3QVj7ONuPyxJuMv1R8leFk319/e36vHJ8XXq1AmZMmUSjF24cAFv3rzB9evX0alTJxw7dkyh6ByT/ryQPn16q55P/1Z4ADh+/LhVz0lERP9j7H3liRMnbBgJJVTu3LmxceNGjBo1SvLv9tmzZ61299i+ffsEi5yz3QQllqenJ7Jly6Z0GBRPw4YNBY8fP36MdevWKRQNWYMliXX2cCe74eLigh9//FEwxj7u9oMV7oY1a9ZMNNagQQOrnpMVEY5Fq9WidevWBrdHRUVh9OjRvOYy0p/T4i/GRs6N8yuRYzL2fnD79u1sQWgnXFxcUKdOHWzZsgXdunWDm5ubYHtwcLBVzrt9+3bB45iYGFy/ft0q5yIiZZQsWRL58+cXjC1dupRtx+zcmzdvsHjxYqxbt04yrxUTE8MKd7J/7ONuvyxJostV4W7JBx8le7inTZtWNNa3b1+rnpMVEY6nZs2a8Pb2Nrg9NDQUhw4dsmFEjk1/XpB6kyUnXjv7wfmVyDGZKh45f/68jSIhObi5uaFjx46iO8iCg4Nlf+///PlzXL16VTQuNUZkrrCwMDx48EDpMCgerVYrak0VERGBmTNnKhQRJVZMTAzat2+PxYsXY/r06Rg/frxon2LFirGHO9k//YT7vXv30L9/f3Ts2BENGzZE48aNsWTJEi4WqEJKVLjbS0sZqcpYd3d3jB492qrnJcfi5uaGgIAApEqVyuA+5i5cTKbZusKdFfRERMoy9X5w0qRJNoqE5FSzZk3B45CQENmLugy19bty5Yqs5yHn4uHhAQ8PD6XDID358uVDnTp1BGN79+5l8YydunjxIp49exb3WGrBax8fHybcyf7lyZNHdNvfsWPHcPnyZTx69AgPHjzAokWLmFRSISV6uNtLSxlDibTatWujadOmVjknKyIcU8mSJREcHIwVK1Zg8uTJGDhwoGD72bNnsXfvXoWicyy2rnDX79FP6sX5lcgxmXo/+PnzZxtFQnLKlSsXcufOLRiTu63MvXv3JMevXr3KQjEiB9SzZ0+kSJFCMDZ+/Hi8fftWoYgooV6+fGnWflIJd/ZwJ7uSNGlSFCxY0OR+f/zxB9+8qAwXTTXMWOWqtapaWRHhuFxdXVGgQAFUqVIF9evXFy02PXLkSJw+fVqh6ByHrRPurVq1surxST6cX4kck1x3YJL6+Pv7Cx4fPHhQ1i9QHj58KDn+4cMHLmpP5IC8vb1FrWU+fPiAfv36cbFkO5M8eXKz9rP2Z0GD51XkrOSw9N8QSblz5w7++ecf6wdDZlN7Sxkle7gbm5zZRoISw83NDY0aNRKMxcTEYOzYsQgNDVUoKsdg65YyadKkserxiYjIOP0qaH0hISE2ioTkVqNGDcH78YiICBw9elRy36ioKGzYsAGLFy/Gf//9Z9bxDSXcAWDy5MlMwBE5oF9++QWVK1cWjF2/fh09e/bE06dPFYqKLJUkSRKz9mOFOzmEWrVqISAgAHXq1EGTJk3QuXNnDBo0CH5+foL9Nm7cqFCEJMWSJLpcCffFixfLchxrVzQZm8SZcKfE6tq1K6pVqyYYCwkJwZIlSxSKyDHYusKdiIiU5e/vb3RxcoBV8PYqbdq0+OmnnwRjhlrwBQQEYOrUqVi8eDGaNm2K9evXG62GDw0NNdpGIiQkBJs3b05Y4ESkWhqNBkOHDoWvr69g/MqVK2jYsCFWr16tUGRkDUy4k0PQaDTw9/fHqFGjMGjQIHTu3BlNmjRBs2bNBPsdOnSIlSYqokSF+7t372Q5Tnh4uCzHMcTV1dXgNmMJ9169elkjHHIwrq6uGD9+vOiD5I4dO1hRlQi2rnA3dhdOQuTMmVPW4xEROTpXV1f8+eefRve5c+eOjaIhuVWvXl3w+NSpU/j48aNg7N9//8WePXviHn/+/BnTpk1DpUqVEBAQgKioKNFxHz16JHis1WpRpEgRwdiff/4p+Vwism+pU6fGvHnzkCpVKsH4169fMWfOHNy/f1+ZwMhspnJT+fPnByBdfCVnm2tDx2LCnWyiVq1aSJYsWdzjr1+/Ytu2bQpGRPEp0cNdLp8+fbLasTNkyGB0u/4iwfHVr19f7nDIQWk0GgwbNkyQtA0PD+cC04mgP6dZu8Jd7uP37dtX1uMRETmDdOnSYe3atQa3R0ZG2jAaklPFihUFRTBfvnzB4cOHBfusWbNG8rnR0dEICgqS3K7fTiZjxoyiv8Fv3rzBggULEhY4Eala1qxZMWfOHKROnVq0Te4Fmkl+phLuJUqUACD9WU3OCndD+TQm3MkmvLy8RP3dt2zZorrkrbNSosLdEsYmQ2tWuC9dutTo9vhfIuljuxmyRIYMGVC2bFnB2Lx58/Ds2TOFIrJvtm4pI3eFe548eWQ9HhGRszDWy/3ff/9N0DHDw8OtfkclGefp6YkyZcoIxuK3lQkJCTHYZibWpk2bRJ9j9Cvcs2bNirx588YlaWKtWbMGBw8eTEjoRKRyefPmxebNm/Hdd98Jxvfu3WuTtiOUcKZyU7Gf0Uwl3N+/f4+AgAD07dvXrPUmY2JisGfPHqxduxbv3783GAcT7mQzjRs3Fjx++/YtDh06pFA0FJ8SFe7u7u5m76sfX0xMDG7duoVnz55ZrcL92LFjSJcundF9jCXctVotdu3aJXdY5MCaNGkiePzx40eMHDlS1tvdnIX+nGHugjoJJWfCvUqVKkiZMqVsxyMiom+mTJmSoOd5enoiW7ZsMkdDltJvK3P27Fn07t0bx48fx8yZM0V/+/XbQr5+/RrHjh0TjOlXuGfNmhUA0KNHD1HxzPz585l8I3JQKVOmxPTp0wVjz58/x9WrVxWKiMxhKuHu4eEBwHTCfdKkSQgKCsKJEyfQo0cPk61dAwMDMWLECMyYMQMdOnQwuFYIE+5kM7ly5RL1xNuwYYNC0VB8SiyamtCEu06nw2+//YZWrVqhfv36ov6NcjEnPlMV7vqLsBAZU7JkSVSqVEkwdvnyZRw9elShiOyXrSvcs2fPnqjn79u3DwEBAQgICMCECRNkioqIyDktXrxY6RDICsqWLSt6f37q1Cn069cP+/fvF4w3btwYp06dEt3xoL8Aqv5dD7EJ93z58mHo0KGCbY8ePRK1sSEix5ErVy7Rl6um7pwhZZnKTdWrVw+A6YT7gQMH4v4dGRmJoKAgo8eNv17I48eP8ddff0nux4Q72ZR+BeeVK1dw69YthaKhWEpUuFuSuI9/zgcPHsQlIC2J2xqMJdxjq2rq1q1rq3DIzmk0Gvz+++/w8/MTjA8cOBB169ZFu3btEBAQwEXfzGDrhHtiWkitWrUK3t7e8Pf3h7+/P9tRERElUuHChWU9XlhYGB48eCDrMclyyZIlQ+XKlU3ulzx5crRp0wYA0KpVK8G2s2fPxi2EGBoaiqdPnwq2f//993H/rlu3rihhP2/ePC6gSuSgNBqN6E6aAwcO8M4WFTOVU/Ly8gIg/VnQWC7p7du3Ro8bEhIieHzz5k3J/ZhwJ5uqWLGiqE0Hq9yVp0QPd0vOGf+N7d9//y3L+eVgLOEeq2XLljaIhByFu7s7evToIRr/77//cO3aNQQFBaFNmzaiW6JJSH9+UXMS21i/YSIispzc62p4eHjE3ZZOyurevTty5MhhcLuLiwumTJkS14u5atWqSJUqlWCfP/74AwBEBQxJkiQR3LGm0WjQrl07wT6PHz+Oez4ROZ5q1aoJHr99+5YFoipmbm5KKuFurG2rpS1d2cOdVCFJkiRo2LChYOzAgQOsFFCYPVW4q+kDjzkJ98S2miDn8/PPP+PHH380uP3Lly8YM2aMwV5xZPsK98RQc2xERERq4uPjg3Xr1mHt2rUYMGAAMmfOHLct9k7BUqVKxY25urqiUaNGgmMEBwfj1atXoiRazpw5kTRpUsFY1apVkT9/fsHY9u3bZfqvISK1yZw5s2BeAYATJ04oFA2ZkpiEu7EcGBPuZLfq168vqDz59OkTLl++rGBElNiE+9u3bzFjxgzMnDkT7969M+s4CU24q4k5CXciS2m1WkyYMAHe3t4G9/n48SP27dtnw6jsiz1VuDPhTkREZD6tVovcuXOjefPm2Lx5M6ZNm4Zu3bph7dq1qFGjhmj/Jk2aCBZQ/fLlCzZu3ChKuP/www+S5+rdu7dg7NmzZ6J2AkTkOMqWLSt4zIS7epmbU9JoNKK734wl1S1tI2Qon8ZPeWRzadKkQZ48eQRjp06dUigaAixLfn/48EE01q9fP6xduxZ//vkn+vXrZ9ZxEtpSRu7bhKV07drVrP1Spkxp5UjIWfn4+GDNmjVo0KAB6tevjwEDBiBJkiSCfbZu3apQdOpnTxXutpjTiIiIHJFWq0XFihXRsWNH5MqVS3Ifb29v1K5dWzB26NAhUcI9fv/2+H788UekSJFCMHbp0iXJfUNDQ7F8+XIsXLjQ7CIkIlKXcuXKCR7fuHEDK1euVHz9OBIzVpi5evVqwWP9z1zGrqeln89Y4U6qUrp0acHjkydPKhQJAZYlv/UXkHjy5AmuX78e9/jatWsmF5mIiYmx6FtDcyvc8+XLZ/YxjSlatKhZ+6VOnVpy3M3NLVHnDw8PR3h4eKKOQfbP19cXw4YNw/Dhw9G8eXNMnjxZsP3atWtcQNUAe0q4ExGR/PQrFMm51a1bV/D40aNHooVwpSrcgW/vIQoVKiQYM5RwHzFiBObPn4+lS5eiW7duFrclIMfBz3P268cff4S7u7tgLDAwEL/++iuvqcoYKxzNmzev4LH+Hc+x87PUPB0/4X727FlMmjQJQUFBBud0JtxJVfQT7vfv38fLly8VioYSk3B/9eqVaB9TFfOWLrxqbsJdf1JNqLRp05q1X/LkySXHE1t57OnpiWzZsiXqGOR4ypYtCx8fH8FYixYt8OTJE4UiUi/9OUbNLWXItvgBmMg5MOFO8f3www9G70x1cXExWCEPAIULFxY8vnjxomifFy9eCIrI7t69i0ePHiUgWnIE/Dxnv5ImTSpYCyLWlStX0KtXL64/qCKG8kpS872hCnepJHpssdbt27fRvXt3bN68GQEBAdi1a5fk+dhShlQlf/788PLyEoyxrYxyLEm4698eKZW4MHULjqUJd3P/qHl5eYkSkgnx3XffmbWfof9OX1/fRMdApM/FxQX16tUTjdevXx9XrlyxfUAq9uzZM8FjJtwpFj8AEzkH3tlE8Wm1Wvz0008GtxcqVMjo2kxFihQRPL5//77ovcbff/8tep7+PkRkHzp16iRZXHflyhVs2rRJgYhIiqG80uDBg0Vj+p8HY++IlsqFxeZ5pk+fLhgfM2aMZIKeCXdSFa1Wi5IlSwrGmHBXjqWLpsavOJdKuJtqF2Np/zNzK9zl6qmu3yvbGP2FK2fOnClLDERSGjRoIPmBcMKECRYv7uKozp49Kxpj4oWIyLlwfQzSp//ZMz79u6/15cuXD6lSpRKMHTt2TPD4zJkzoudJ3QmcUFFRUXj79i3b1NiJly9fCtqukn3JlSsXduzYgV69eonaxe7YsYO/hyphKOEudYeC/vsCYwn32M+Oly9fFm2TuvZsKUOqo//G5u+//zY7sUrysrTiPCIiQvLfsUwl/qzVUsbLywshISEWHTuxvL29ce7cOZw8eRJnzpwRLbJCJKe0adNi0KBBovG7d+/i4MGDCkSkPgsXLhSNscKdYoWFhYn69hKR48mTJ4/SIZDKJCbhrtVqRe/x9RPu165dEz1Prpap586dQ/Xq1VGtWjW0bdsWT58+leW4ZD2+vr6yrS9GyvD29kbbtm0xceJEwfj9+/dx/PhxrFu3TrK9FNmOobySVIGaoQp3qdyVsS/tpRL0TLiT6ui/sYmIiGBbBIVYWnEev6pd6hs+uRPuoaGhZu2n36YoIfQr1s2h0Wjg5uZmUWW8MayIIGPq1KmDoUOHisaHDh2K+vXrY+jQoU7do1rq74haKtzbtWundAhOz8PDAx4eHkqHQURW9sMPP6BEiRJKh0Eq4uPjI+rFDgBp0qQx2r89Vvny5QWPL1y4EPcZ5cuXL5LJdbkS7gsWLIg7140bN7B8+XJZjktEppUtW1bUMrZ///6YPn06unTpgh07digUGRkqzJTKy+h/HjSnpYwUc1vKtGjRggl3Uo63t7doNXi2lVFGYircpZhK4Fua4AekW9fok6OljLe3d6KPkVisiCBTGjZsiJEjR4rGnzx5gv3792PChAkKRKUOUv0WbVHh7u7ubnR77dq10axZM8EbuIYNG1o7LCIipzVnzhylQyCVGT58ONKkSSMYK1eunFktiEqWLAlXV9e4x1+/fo377PrixQvJgiP9hLtOp0vQHd36xQRBQUEWH4Nsi3fUOQ6tVotffvlFcptOp8PUqVN514lCDOWxpOZ0SxLuxoq1pPa/f/++aKxz585MuJOy9KvcmXBXhqVv/Ewl3BNS4W5qoVFz/oilSJECWbNmNbkfkSOoUKGCwTcDe/fuRc2aNbFw4UKLv1Czd8ZWmremMWPGGN3ev39/pE2bFrNmzULJkiXRoEED9OjRw+pxERE5K7nuPCTHkTVrVqxYsQKFChUCAGTOnBndu3c367nJkycX3TVx9OhRAIYXR42fcD9+/DgaNGiAUqVKoWXLlmYvqMo1eoiU5+/vb/CLuc+fP2Pq1Kk2jogAywpHDSXcLW0pY86c7OfnB09PTybcSVn6Cfd///3X5j24yfIK97CwsLh/y9VSRqpaN77IyEiTcaVMmRIDBgwwuZ8hw4cPT/Bz5cSWMmSOVKlSoWzZsga3v3z5EkuXLsXs2bNtGJXyPn/+LBqzRcK9cuXKRrfHtjEpU6YMAgMDMWzYMFnaYBERkWH6C10S+fn5YdmyZdi3bx+2bNli0d2t+m1lzp8/DwD477//JPf/77//EBkZicjISAQEBODJkycAgNu3b2PFihVmndPQXb5S73dIPTw9PZEtWzalwyCZZM+e3eiXc6dOnTJZlEjykyPhLnUMS3u464v9QpUJd1JUgQIFkCJFCsGY1ArvZF1RUVEW7R//j4lUct1Uwl1qkvrpp5+MPsecN5UpUqRAyZIl0atXr7ixn3/+2ehzpk2bhtKlS2Pq1KmoX7++yXPYAlvKkLmGDBmC8uXLG31TsGnTJrOrqOzdP//8Izmu9KKpSZIkUU0feSIiZyK1kDYR8K2NpDmtZOIrUqSI4PHbt28RHh5u8H1WVFQUTp48ifv37+Pdu3eCbeYW13z8+FFynEVqRLbVvn17zJkzR3LNB51Oh4cPH0oWI5L1WKvC3djnNkuuMT/9kaJcXFxEidbjx48rFI3zSkxLGTkq3JMkSWLyDa85Fe6urq7QaDRo27Ytzp8/j/Pnz2Pw4MEoV66cwQqnihUrYs6cOahUqZLJ4xOpjY+PD2bMmIFdu3ahTZs2kvt8+fIF69evt3FkthcTE4NOnTpJblM62b1r1y5Fz09E5Kxy5sypdAjkQPz8/ESfWZ48eWKwwh0ADhw4gBcvXojGpcakGEq4GzsnKY93LDum0qVLY926dTh37hwyZ84s2NazZ09UrVoVffr0MWv9OUo8qYS71OLYgLgAK7YI1NiiqVI5KnMq3GM/ezLhTorTbytz+PBhrFy5UplgEiEiIsJuv9G0NOEe/w+I1IRjahKSSribsmjRIosr8YFvtxLPnDkTBw4cwLJly+LGkyVLFtd3UW24yA5ZysfHBz179jT4xdKOHTsc/jbHW7duGdymdIW7/gJtREREZH9cXV2RPn16wdiTJ0+M3kl4/fp1yeT6x48fMWzYMISGhho9p6HtTOaqG+9YdmwajUbUMujjx4/48OEDTp48ifnz5ysUmXO5fPmyaKxly5aS+1qyaGpie7jHndPsPYmspEyZMoIV3wEgMDAQ8+bNs4sEtk6nw7hx41ChQgXUrFkTd+7cUToki1naw91USxlT1+3Tp0+Cx/rXX8qtW7cwbtw4MyOUVqhQIZw+fRoHDhzAsWPH4noqEzkCrVaLjh07Sm4LDw9H+fLlcePGDRtHZTsfPnwwuE3phDsRERE5hkyZMgkem6pw/++//wwW0uzbtw9Lliwxej5DFe6O/J6OyB5kz57d4LYNGzZwwWMrCwkJEeWVOnfujIoVK0rub0mFu7G7o825rrH7MOFOikuTJg169uwpGl+xYgWmTp2q+onq5MmT2L59O3Q6HUJCQky+aVKjxFS4S10fUxXub968ETyOrf4sU6aM0ecFBwcbPLa5Cx4lTZoUqVKlUrzFhDFcZIcSqnnz5li1ahVmzJghunsIANq0aeOwH9CM/U6r+fediIiI7Id+wv3OnTui/uz6Tp06ZXDb2rVrjT7XUIW7sUIDUh7vWHZ8pj6v371710aROKfYRavjy5Ili8H9DSXcpfJZrHAnh9KiRQsMGDBANL5x40asW7dOgYjMN2rUKMHjw4cPKxRJwiWmh3tCFk19/fq14HFswr1Dhw4mz71lyxbJ8ZEjR5p8LpEzyJcvH8qXL2+wp/uoUaMs/p23B8YWVlaywt3SBdmIiIhIvfQT7mfPnhXto992xlS/9rJly6JJkyaSbWIMtQTUr+wkdfHw8ODd1A7OVML90KFDWL9+PZYuXYr379/bJignMmXKFNGYsc4JlrSUMdaxgQl3skvNmzfHqFGjRL8IixYtwtu3bxWKyrivX78avM3PnliafIv/ByMhFe4vX74UPE6bNi2Aby1fFi9ejI4dO8Ld3V3yuTdv3pQcL1u2rNFz2hNWRJAcihYtihIlSojGHz58iO3bt9s+ICszdju3khXu5qxRQURERPZBP+Gu/1nQ29vb4t7dnz9/xv379zFp0iTRNkMJd0dfm8fehYeHc+FMB5c1a1aj25cuXYpp06Zh4cKF6N69u120S7YXkZGRCAsLE427ubkZfI4lLWWMJdWZcCe7VadOHYwfP15QERgREYF58+YpGJVhV65cUToEWViacH/+/Hncv6UmqBUrVmDs2LEGb5/Ub2kRm3AHgCJFiqBbt26oUqWK2fGsWLHCoapIWRFBctBoNBgxYgT8/PxE2yZPnoy5c+fi9u3bCkQmv5iYGMyYMcPgdmPV79bG/vFERMrSvxuVKDFMJdkyZMgg+d7LHDdv3ox7z3L58mXUq1cPixYtktyXCXd1Y4tQx5c8eXLRF3CG3LlzB/fv37dyRM7DUNeDhCTcja1JKJVjYsKd7NrPP/+MWrVqCcaCgoJUmRg6efKkaEyr1drdt5eWLpoaP+Eu9d96+vRp7NixA71795bsF63/xyZ//vyifYz139JXoEABs/e1B6yIILn4+flh48aNGDRokGjbqlWr0Lp1a6N9Re3Bp0+fJG8pjC9jxow2ikYsb968ip2biIiA2rVrKx0COZCMGTMiadKkBrf7+fkhVapUCT7+kydPoNPpMHbsWDx9+tTgfky42078z75E8bVu3drsfU21liLz7Nixw2ChlbEiTEtayhhLqpvq5iA4p9l7EtlQ9+7dkTx58rjHOp0O06ZNU10i+9mzZ6KxmJgYu+uPfObMGaPb9Seut2/fIjIyEoDpCWfWrFmCx6GhoaJbL3Pnzi16nq+vr9HjxpozZ45Z+9kTVkSQnJIlS4bGjRsje/bsom0xMTFYv369AlHJ48uXL2jbti02b95scJ+8efMiWbJkNomnUaNGorFevXrZ5NxERCTNke6CJOW5uLgYLQzKnDmz0YS7qZ/HJ0+e4NGjR3j48KHR/T5//mxRpSUlXELWlGOLUOfQoEEDBAQEGGyHG9+rV69sEJHjmz59usFt3t7eBrfpJ9yNtZRhD3dyaOnSpUP79u0FY5cuXcLBgwcVikiaoSpke6pOjoqKMlkhsWfPHtFY7Df9piacixcvCh4/efJE8Fir1eK7774TPc/Hx8focWOlTJnSrP2InJlGo8H48eMl34ScOnUKS5YsUe1aGcacOnXK5O2ZnTp1slE0374srl69OoBvH8hnzpzpcHfgEBHZIybdSU5SRQyxcubMaTTh3rZtWwwcONDg9kePHpl996FUD2NHFh4ejhs3bth8DbW1a9da/By2CHUe/v7+2LdvH5YvX45cuXIZ3C8kJMSGUTkuY7krY1+G6q+rZU7CXSrxzoQ7OYRWrVqJErEzZszAhw8fFIpIzFBi3Z5u8bt+/brR7d7e3kiTJo0osR17i6M5t9SEhobi2rVrCAsLw5EjRwTb/Pz8JG/LTJcuncnjAsD3339v1n72hBURZA25cuXC5s2bJauwFy1ahOHDh6vuLiJTTpw4YXIfWy5a6uXlhfHjx+P8+fP4+++/Ua5cOZudm4iIDFNy8WxyPDly5DC4zVTCPX369Ebv5H3+/LnZCfdu3bo5RZW7TqfD0aNHUaFCBbRp0wZNmzbF48ePrXKujx8/YsCAAahatSrGjRuHqKioBB2HLUKdS7JkyVCwYEGjCXdWuFtfQlrKSM2hsWNMuJPDcnV1RZ8+fQRjISEhGDVqlGreWDhCwt1Uwjx2cQn9bwtjq0rNSdA1bdoU7dq1Q9OmTbFmzRrBNkPVn+ZWuNsymWYrrIgga/Hy8sLgwYPh6ekp2nbu3Dk8evRIgagSzsvLy+Q+xvqsEhGRc+AC1iQnQwl3V1dXZMqUyWjC3dfX12jCPSQkRHSHsCG3b9/G3LlzzdrXno0bNw4DBgyIe/zq1SssX7487vGpU6fQrVs3jB49Gu/evUvUubZu3YqjR4/i/fv32L59u6hYzFxsEeqcjF1zVrgnnrHcU+nSpY0+15KWMuzhTk6hSpUqKFGihGDs5MmToqStUgwl3J89e4Y7d+5YvBipEkx9ax/bSz9nzpyC8bt37wIwb8KJ/ePy8uVLUX/7n376SfI5yZIlM9nHffz48SbPTURCGo0GxYsXl9zWqFEjjBo1Cnv27En0BxZbMCeZ7ohfyhEREZFyihUrJvkeJEeOHNBqtSYT7lLtNGP9+++/FlVVr1mzRrJg4uHDh7hy5YpqCtUSKiQkBDt27BCN79y5EzqdDtOnT0fv3r1x7tw57Nq1Cz///DMCAgJw48aNBJ0vMDBQ8HjYsGEJOg45p0yZMhnc9urVK9y9exeXL1+2+99LpRjLrxlr9QVY1lImllSC35I7wplwJ1XTaDQICAgQ9R2eN28eLl26pFBU/2Mo4T5gwAC0aNECv/76a4JvQ7OVz58/G93et29fAOKE+7179wBYdkuNlCJFihjctmHDBoPbUqVKhWrVqiXq3GrFWxDJ2jp37mzw9vrg4GCMGDECzZo1S/CHFVsxp0UAK9yJiIg93ElOnp6eKFmypGi8cOHCAIAUKVIYfI+SPn16own5ly9fWhyP/memjRs3olGjRujQoQMGDRpk8fHkEhYWhunTp6N///44e/Zsgo5x69Ytg9uuX78uuaBpUFAQunTpYrCiOCoqCtu2bcOuXbssqla1BFuEOqd8+fIZ3Hbnzh00a9YMHTt2xMCBA632s+fI9Is342vQoIHR5+rPradPnwZgvKWMFHOu2+bNmwEw4U52IG3atBg3bpzgjXJMTAyGDBkSt3CnEnQ6ncmk6NWrV+N+kdVKP+Hu5uYWdytUtWrVUKZMGQDiWycfPHiAmJiYRCfc06RJY3CbVNuLWDt27HDYD0+8BZGsLVeuXJg2bZrRfd68eYO+ffvi2bNnNorKcua0CGCFOxEREcnt559/FjxOlSoVWrVqBeBbQYBU27vkyZMjRYoUsn+G2bhxI6ZOnQrgWzJo3rx5cduOHDmiWOJ33rx5WLduHY4dO4aePXvizZs3Fh8jWbJkBrfNmTPH4LZPnz5h165dktv69u2L8ePHY/To0fj9998tjskcbBHqnL777jvJ9bL0HTt2DH/88YcNIrI/z58/x/Lly3HgwAFRNfn+/fsNPi9z5sxGjxtbMBor9ktAqar5xPZwz5o1KwAm3MlOlChRAp07dxaMvXnzBn369LH5KuWxoqOjzWoZY+gPvVroJ9y///57bNiwAadPn8aECRPiElr6t+hERUVhwIABeP/+fYLP7enpCTc3N6P71KhRQzS2fPlyvoEhSqTy5cvj7NmzKFq0qMF93r59i/79+9swKvmxwp2IiNKmTat0CORgatSogYoVKwIA0qVLh5kzZwrWoJKqYvf19bVawdCGDRvw9OlT3L59W1QUdufOHaucU5/+Z+NNmzbF/TsmJsaiz8Vfv36FTqeDq6urwX1ev35t9BhPnjwRjT19+lRQbR8cHIzIyEhERETgxYsXZsdHZMiQIUOwadMmrF271uh+ixcvxocPH2wUlX0IDQ1F8+bNMX/+fAwZMkRwB4tOp8PYsWNlP6dUAn358uWoXbt2ghLu8VtiM+FOdqNjx46ift/379/HwIEDFWnb8vDhQ7P2U3tiWD/hnixZMmi1WlGSKnXq1KLWPsePH8e+ffsSfO6wsDCT+7Rs2VLwuGrVqihYsGCCz2kPeAsi2YpWq8Xs2bPRrl07g/vcvXsXixcvtl1QFjDnS09WuFN8bNlF5JxGjBihdAjkYLRaLaZNm4Z9+/YhKCgIBQoUEGyPn3yPlT59+rh/165d2+Jzli9fXnSe+B48eIBz586Jxj99+mTxuSzx+vVrtGjRAqVKlcKIESPw9etXyaSUqQR5rD179qBatWqoWLEi9uzZY3A/U3c66rd+iIqKwl9//SXa7+zZs6hbty5q1aplVnxEpmTLlg25cuWKWw9PSmRkJPbu3WvDqNTvzz//FOSIFi5cGPfvZcuWWeWchnKJhrppHD9+3OjxYlsyA0y4kx3RarWYOHGiqNL64sWLaN26NYKCghAZGWn1OEJDQzFo0CC0aNHCrP2NfSuvBvoJd2N/FPT7uCeWoQVT4/vhhx8wbNgwFCxYEPXr13eKD0y8BZFsKVmyZOjZsycqV65scJ9t27bZMCLzGevjF0vqAy85L7bsInJOxYoVQ7du3ZQOgxyQt7e35N10Uguj+vr6xv27Y8eOZq1FA3y7Wy937tzo168fli1bhk6dOknut2nTJgQFBYnGb9++bfIcX758sWgxwPimTJmCO3fuQKfTYc+ePTh58qTkOmH67WGio6MxZcoU1KpVCxcvXgQAfPz4ESNGjMCHDx8QHh4e1wtZiql4d+3ahfr162P58uV4/PgxqlWrJpm0W7RoEd69e2fOf6rZ+AU/aTQaQbWzlClTpmD8+PGKdW1Qm0OHDgkeR0REAPiWs4qffE+I2JZf+kytaahvzZo1Bre5ubkhd+7ccY+ZcCe74uXlhTlz5ohuC7137x4CAgJQp04dXLhwwWrnf/fuHdq3by+aCIwJDQ21WjxykKpwN6RQoUKynrtjx44m99FoNGjQoAGWL1+O4cOHG+3rTkQJN3DgQBQsWFDyd+zVq1f4448/VLe4j6m7m1q1amX0S0QiInIOGo3GrPedRHLx8/MTjcVPuGfMmBF//PEHOnToYPQ47dq1w+nTp7F27VpkypQJWq3WYBHUqVOn8OjRI9G4sTXFPnz4gE6dOqFkyZLo3r17XIIr1uHDhzFu3DgEBwcbTHDrfzbu37+/ZOWu/l2H7du3x8aNG/HixQt07twZxYoVM1oAos+cO86fPHmC+fPno0GDBgbvrja2MGtC8Qt+AoDGjRub3Gfbtm1WW0vA3hiaY86cOZPoY+fNm1fwOEWKFAAga9HusWPHBI+ZcCe7kz59esyZMwfu7u6ibW/evEHv3r1x/vx5q5x71apVZreSiaX2vlyWJNzN+YNhriRJkqBIkSKyHY+IEsfHxwfLly/HoUOHcOTIEdH2WbNmYf78+bYPzAhDFe7JkyfHnDlz0KdPHxtHRGrHll1ERGQLUhXu8VvKAEDu3LnRvXt3lC5d2uBxpBZflRoz5unTpwgJCZHctmXLFvzzzz8AgHPnzgkqys+fP4/ffvsN27dvx6hRo7Bx40YAwI0bN3D+/HmjvYzHjx8vGoufcNfpdFZJdBOpSYkSJQQdGrRarWQrpKNHj1qcZ3JEUmtcvHv3DsOGDTP6vAYNGpg8tv58FVsYK1dB2bJly0TXlgl3sku5c+fGvHnzJFcijoyMRN++feNuS5OT/srG5rDF7UEJvf0PEFfgG2tl4u3tbXYrHVO6d+8uy3GISF5ardbgnSSrVq3Cs2fPbByRYYYS7v7+/ihdurTVFiYj+8WWXUREZAumWsrEZ2y9mdgqzPgSsgiwv78/hg4dirdv3wrGFyxYIHg8Z86cuH/PmzdPsG3q1KkYNWoU2rRpg65du2Lo0KEWreel0Wig0+kQERFhcRsHe8Mv+An49rlqypQpKFSoEDJlyoQxY8Zg2bJlku2ktm7dqkCE6iJ1Z3LNmjWN3tWcJUsWg+1i4ou/WHKsmJgYs9YEM4dUNwgm3MluFShQAJs3b8asWbNQuHBhwbbPnz+jT58+sq/I/urVK4ufY80K98ePH6NJkyYoXrw4xo4da3LFZClv3rwRPNZfGFVf165dLT6HFCY8DGPPP1KDfPnySY7XqVNHNR8gDL35UvvaGUREROTYpJLrqVOnltzX2GKiKVOmFI1lyJAhQTHt379f1AfZWOHW1atXRWPBwcFx/z548KDJytP41q5di+LFi6N8+fIoV66c2c+zR/yCn2JlzZoVy5Ytw7Zt2+Dv74/8+fNj9uzZov2s1aXBnqRLl040ZizZXqRIEWzatEmyEFeffrss4FtL1cDAQMuClFClShXJcSbcya5ptVqULVsWCxcuFP2Qf/r0CQMHDpS1wtzcldXjs2aF+4oVK3D//n0AwI4dOxI0Sev/N6VJk8bo/u7u7vD397f4PPqYEDOMPf9IDQy9cQC+tZdq0KCB4tXuhircpRYvIyIiIrKV9OnTI2vWrHGPv/vuO+TIkUNy31q1ahk8jlSFu5ubW4Lj2rp1Ky5duoQpU6Zg586dkvsk5u5pY+RemJTIXpUqVQqLFy8WjN25cwcrV6402P7JGVh658u4cePMXnxaqlODfs/1hOrbt6/kOBPu5BBcXFwwfvx40SIrz549w7BhwxJU+a0vKioK79+/t/h5YWFhVlto8K+//hI8Tsi3c/q3FZpKuANAQEBAohciNFQ9S0Tq0Lx5c/Tr10+0wEysx48fo06dOihWrBjWrl1r4+i+MZRwT8wHUSIiIqLE0mq1mDBhAkqVKoUSJUpg8uTJkr2bAaBq1aoGq6EN9WsvX758gmP79ddfsXHjRowZM0Zy++jRo/Hs2TMWMBBZkVSBXWBgINq1ayfK0TgLSxLu9erVg4+Pj9n7G1psWg5SLcQAJtzJgSRJkgTjxo1DgQIFBONnzpxB//79E1SdHp9+6xVL6PdJtxZLq+nfvn0r+u8yJ+EOfPs2sEaNGga3u7u7Y8aMGahevTrq1KmDTJkyxW0rWbKkYPEQEmLPP1KDpEmTomXLlli9erXJtRtmzJiBx48f2yiy/2GFOxEREalV7ty5MXfuXMyfP99gAQPwraXnunXrJLdJVbgDQKdOnWSJUUpwcDDq1Klj8H0WESVe6tSpkSpVKtF4SEgIZs2aZfN41MCShLuxtS+kWKsgq2nTpga3MeFODsXV1RVTpkwRJY1PnDiBJk2aJOqWkcQk7G2xcCpgvL+VlCNHjghuGUyePLng1kdjNBoNxo0bh/Pnz+P8+fOi3u4rV65E+fLlMX78eIwaNQpbtmzB1KlTMW7cOMycOdOiOJ0Ne/6R2tSrV8/kPhs3brR+IHoMzXmscCciIiJ74ufnJyocA6R7uANA3rx5MX/+fGuHRURWZKgIcc+ePTYr2lQTSxLuln7eM3SHUWLpd9mIjwl3cjjp0qXDlClTRN94ffz4EQMGDMCqVasS1JcuIQumxrLmwqnxWdrzau/evYLH5cqVS3Ciqk2bNujQoQPKly+PyZMni/54aLVaVKpUCTVq1GD1KZGdyZgxo8FbmmOtX78eL1++tFFE30itNg+wwp2IiOTDxezJVkqXLi14XLBgQaNFOOnTp7d2SERkRYYS7jExMTh37pyNo1GeJfksd3d3K0Zivk+fPhncxoQ7OaRChQph1qxZ8Pb2FozrdDrMnTsX48ePtzjprrYKd6m+9JZUuN+5cwcXLlwQjFWtWjXB8bi6uqJ79+6YMWOG0cUWicj+uLq6ok+fPibXbqhZsyZ2794N4FvLqgcPHlhl4a27d++iWLFiBrdzUWYiIpILF7MnW2natCmqV6+OjBkzolq1apg2bZrR/aXaUZA68Is6MoexBZMHDRqEUqVKYfLkyTh8+LDVFjOW08ePH3Hz5s0Er2FobsJdo9GYdQe2LRibh5lwJ4dVsmRJbNy4UTL5u337dmzZskU0HhUVZXAiU1uFu9RkZCzh/uTJEyxduhRTpkzBmTNnsGrVKsH2ZMmSiaoqiIhi1a1bF7t378apU6dQrVo1g/uNHDkSzZs3R61atdC4cWMMHjxY1jeIMTEx6N27t9F9mHAnIiIie+Pl5YXx48dj+/btmDBhgqh4TJ+np6eNIiNL8Ys6Mkf+/PkRGBiIJk2aSG6Pjo7Gpk2b8Ntvv+HkyZNmH/fMmTNo0KABGjRogFOnTskVrlE3b95EvXr10Lp1azRv3txo5bch5ibcf/31V/j6+lp8/HLlyln8HFPy5ctncBsT7uTQUqVKhUmTJqF3797QaDSCbTNnzhQs8rd27VpUrVoV5cqVw8GDB0XHSkyFuzUS7lLfmEtVvQPA0qVLUb9+fSxcuBAbN25Ez549Re1kfv75ZyRLlkz2OInIcXh6esLV1RWNGjUyut+///4b9wXgoUOHcP78edliePToEUJCQozuw4Q7ERHJhYvZk1pptYbTOcWLF7dhJESUUCVLlsSgQYPQo0cPo/sFBQWZdbzHjx+jf//+ePz4MR4/fozRo0dbvNZfQmzYsCGus8P9+/ctXt9Lp9OZlXB3d3dH586dExSjNRLu+nnG+JhwJ4en0WjQpk0bTJw4UTAeGRmJESNG4MuXL1ixYgVmzJiBiIgIfP78GSNHjhT1IjZV4V6mTBlkyZIFOXPmFFUjPH/+XJ7/mHgiIiIkx798+SJ4/O7dOyxcuNDk8Vq3bi1LXETk+IoUKYItW7agevXqZu3frVs3TJ8+XTAWExODq1ev4tmzZxad25wvP5lwJyIiuXAxe7I3M2fORKVKlZQOw6nxizqyVK5cuYxuP3TokODx8+fPsWDBAmzdulVQeLl9+3ZBgv3du3e4fv26vMFK2Llzp+Dx3LlzLXq+uQWuHTt2tOi48dn6riAm3MlpVK1aFY0bNxaM3bhxA926dcO8efME41FRUVi8eLFgzFTCvUSJEtiyZQvWr1+P+vXrC7atXbsWw4cPl3WlaUM94fS/KDhy5IjJY2XOnBlZs2aVISoichZZsmTBqFGjzF5oed26dTh9+jSAb8n2Ll26oH379mjYsCEOHz5s1jH++usvdOvWzeR+TLgTERGRM9JoNChXrhzSpk2rdChOjV/UkaVKlCgBPz8/o/ssXLgQbdq0Qa1atVC7dm0sW7YMEyZMQGBgYNw+Ul/0XL58WfZ45RATE4M1a9agf//++OWXX0zu7+XlhQYNGiT4fKbWI5MbE+7kVPr06YPMmTMLxi5duiS5719//YUdO3agV69eGDRoEO7du2f02BUqVJD8d6y9e/di9erVCYhamqEK93bt2gm+4TTnm/XOnTsbvSWRiEiKm5sbZs2aZfb+vXr1wty5c3H69Om4uTc6OtqsCoioqChRlbwh7GlKRERy4eKHZE8yZswIAEy4E9kZV1dXrFq1CoMHDza4z9KlS3Hjxg28ePFCMB6bZ7pz5w6OHz8uet79+/flDdZMhloex9q4cSNmz56NY8eOGd2vSJEiWLx4MXbt2oUUKVIkOB4XF5cEP1dK06ZNjW5nho2cSrJkyTBu3DizftFiYmIwduxYnD59WnT7DgD06NED7u7uAIAmTZrEvbkBgDx58iB9+vSi51iy0IUphhLu7969w4kTJ+Iev3//3uSxKleuLFdYRORkihcvbtGtfatXrxbdQRR/PQ3g25vFNm3aoEGDBjhw4AC+fPmChw8fIiwszKxzeHl5mR0PERGRMVz8kNSsT58+gsf9+vUDAMnPokSkbqlTp0bjxo2xe/dugwupGtK/f3+0a9dOctvbt29liM44qQJO/S8GYn3+/BkzZ87EtGnTTB7Xx8cHI0aMQJEiRRJdoS53wr1v375GtyeR9WxEdiBv3rz49ddfJfua586dG3fu3DF5DK1WiyZNmqBRo0aIiopCmjRpBNs1Gg0qV66MtWvXCsbv3r2Lz58/y7I4qbFKm71796J8+fIATCfcPTw82H6BiBKlW7duaNGiBT5//oxevXoZraLQ6XSSfQQ3bNiAypUrY8WKFYJFdoYMGQIvL6+4RXjMwaouIiIicgYNGzbEkydPcOXKFVSsWBFlypQB8C1J9f333+P27dsKR0hElkqXLh0GDRqET58+4a+//jLrOcaqxG2RcHdzc8OnT58EY48fPxa1yblz5w5at26Nr1+/mjzmunXr4OfnJ1t7ptSpU8tyHAD4/fffkTRpUqP7sMKdnFL79u1RoEABwViHDh2wZMkSUcsZKTVq1ICHhwdSpEghSrbHatOmjaitQUxMDNauXWv2ghDGGOsH//Dhw7h/x/ZMNiRdunSJjoWIKGXKlPD19cWiRYswYsQI0VoWpkydOhW//PKL5Ir2liTbAcTdfURERJRYXPyQ1Mzd3R3Dhg3D+vXr0bVrV0EF58iRI+PeExUrVgwajUapMIkoAfr37y/LceTIPxkTExMjSrYD4ruYt2zZghYtWpiVbAe+LSQr51oIuXLlQvbs2Y3uU6ZMGRQrVkxy2+HDh7Fnzx6cPXsWNWvWNHk+JtzJKbm4uGDGjBmoUqUKcubMiUGDBqFbt27w8PDAokWLkCNHDsnnJU+eHL169cKoUaNMniNt2rTYvXu3aHz+/PmoWbMmzp07l6j/BmMJqPfv32PdunUoX748dDqd0eOUKlUqUXEQEcWXOnVq1KtXD8OHDzfZj88a2rRpY/NzEhGR4+Lih2SvfvjhB+zfvx+bN2/GggUL2GaGyM6kSJEC69evT3RHgrdv35rsp54YUsl2ALh27Vrcv9+9e4eJEyeafUxT/dETQqPRIDAwEE2aNEGLFi3w/fffi/bx8vLCwoULUaRIEdG2FClSIG3atGavf8iWMuS0UqdOjcmTJ4vG06VLhyVLliAwMBC3bt1CjRo1UK9ePdy+fRu5c+e26A138uTJUbduXezYsUMw/vXrV0ydOhUbNmxIcKXBhw8fDG57+fKlWYsLJk2aFC1btkzQ+YmITLFFpXmlSpWQPn16nDx5Erly5UKrVq2sfk4iIiIie+Dm5oasWbMCgNHPsUWLFkWXLl2wY8cOZMuWDblz58b69euRNm1aBAUF2Sha81SqVAmHDx9WOgwim8iZMycCAwOxf/9+fP/99xg3blyCjlOiRAkAQKFChdC2bdu4FsRyMNTuODg4GB07dsShQ4ewdetWi47ZpUsXOUIT8fHxwaBBgwAA9+7dEyX2M2XKJNu5mHAnkuDl5YVhw4YJxgoXLpygYxUpUkSUcAe+rRR9+vRplC5d2ujzv379Krm4g7GEuzny58+PLl26sNJBhcLDw4326Cei/8mcOTN69eqFAQMGKB0KERERkWoZu/M5f/78KFKkiKCqM/ZzqqmEu7+/P65du4bKlSujSpUq+PXXX/H582ez49q7dy+qV68uGs+WLRsKFy6MVq1aoW/fvnj8+DG8vb3RrVs3REZG4tSpU2afg8iexf/dTGjCPdbly5fRv39/FC5cGMWLF0eFChUkK70BICQkBPfu3UPRokUFVfYXLlzAnTt3ULFiRXz9+hVXr141eL6GDRtaHGOtWrXg5eVl8fMslSNHDlSrVg379u0DALi6uqJZs2YAIEsLLibciaysWrVqWLVqleQiguPHj8eaNWvg7e0t2vbmzRuMGDEC58+fxw8//IDJkyfD19cXy5cvx+nTp3HlypVExbVy5cpEPZ+sR7/3PxEZVrduXaVDICIiB8ZCCHIUxhLuiUluBQQECB6vW7cOV69ehaurK4YMGWLweR4eHpg7d67BNdE2bdoU9+8///wTDx8+RIYMGeDl5YVBgwahXr16gv2l7izX9+OPPyImJibRn6WJ7N2lS5dw6dIlLF68GPXr10exYsVw9+5dVK9eHdHR0dizZw/+/PNPAICfnx82btyIZMmSYd++fXHFqeZ0VUgIW7YIHTNmDLJkyYLnz5+jadOmcXOhqdbM5mAPdyIrS5o0KQIDAyX7wr98+RKBgYGi8c2bN6N69eo4d+4cdDodbt68iYEDB2LTpk1YtGhRot8g9O7dO1HPJyIy16+//mrV45uz0DUREVFCeXp6Ilu2bEqHQWRVSZMmNbitUKFCBrc1atRINJYpUyb4+/sjb968Bp83f/58HD16FAULFpTc7u/vL3icPHly5MmTJy4ZljFjRtFzTN05Dnz77yxatKjJ/YjUqmvXroLHderUQffu3QVjTZo0seiY27Ztw/Dhw7FixQo0a9YMrVu3jku2A8CzZ8+wb98+PHjwQNQJQm5Hjx41ubCpnFxdXdGlSxeMGTMGefLkkfXYTLgT2YCPjw/Wrl2LpUuXws/PT7Bt165dePHiBYBvqztv2rQJkyZNEh3jzp07mDZtWqJjyZ8/P+rUqZPo45D1vHz5EtevX1c6DCJZNGrUSPY3L0REREQkHzc3N4PbypQpY3CbfqIvvrRp00qOjxo1CsWLFxeM6RdQlC1b1uBxY8Wvns+RIwcqVapk8jlJkiSRpVUEkVLq1KmD1KlTA/i2Xlbjxo3Rvn17TJkyBS1atMCwYcMwYMAAdOrUSdbzBgQEoHHjxrIeM768efNiyZIlDrVIOVvKENmIi4sLfvzxRyxfvhx16tRBVFQUgG892qdNm4YyZcpg7ty5+Pjxo6znrV27NsqXL48KFSogPDwcHh4eZq+qTMrw9fVVOgQi2aRJkwarVq3CuXPn0KNHD6XDISIiskhYWBhevXrFKndyaMYq3Bs2bIibN2+KFirt3r270VY08Xs+x2rbtq1k8VfLli0xadIk6HQ65MmTBxUqVDAZc6NGjZA7d26EhISgbNmyZn3G/emnn8z+vN2qVSvs2LEDoaGhZu1PZAs+Pj7YvHkzrl27hly5csHHxwcAULlyZVSuXDluvwYNGiAoKAghISFKhWq2+vXrY/jw4UqHITsm3IlsLG3atKhXrx42btwYN3bkyBEcOXJE9nMVLFgQo0ePjnucIkUK2c9BRGSKVqtFgQIFZD9u+fLlZT8mERFRfB4eHoiIiFA6DCKrkkqOx0qZMiWmTp2KyZMnx/VVd3V1NattRZkyZXDy5Mm4x7Vr15bcr2HDhihUqBBCQ0ORN29eoxX38em3pClQoIDBBRzTpEmDhg0b4vjx4yaPmz17dvTt2xd9+/bF69evzYqFyFZSpkxp9M4T4H+J+TNnzuDEiRM4duwY3r9/b5sALWTO3Sm21rp1a1y8eDHusaH2V8Yw4U6kgObNmwsS7tZSq1Ytq5+D5Pfy5Uu8fv0a+fLlUzoUItm4u7ujYMGCsi5SxYp5IiIiIvP06dMHffr0kdxmLOEeq2/fvkiZMiWeP3+OZs2awdPT0+RzevTogSdPnuDFixdo1aoVsmbNanDfnDlzmjyeKf369UOvXr0QHh4OPz8/bN++HWfPnsXTp09RpUoVJE+eHFWqVJF8btmyZXHixAl4enpi4MCBceOGWuMQqZ27u7ug8r1ixYoICwtTOCqgXbt2KFWqFE6ePIlixYqZtf6CrZUuXRrlypXD8ePHkSpVKvTt29fiYzDhTqSATJkyoWTJkjhz5ozBfXr06AFfX1+MGjXK5PGWLl2KFClSoHXr1nGtaipVqoS6devKFjPZDlvKkKOaNWsWfvnlF0RGRib6WM2aNZNcjJqIiIiIxH766SeUL18ex44dE20z1lImlpubm2jBRlNy586NrVu3WvScxChYsCB2796NsLAwpEuXDhqNBiVLlhTs4+Ligh9++AG3bt0SjM+cORNPnz5FypQpjbbKIbJXlStXRlBQkM3P2aRJE/Ts2ROZMmXCtGnTkCVLFgBQ9QLGLi4umDFjBl6+fIkUKVIkqLc8E+5ECunduzcuXrwYlyCPVaJECQQGBkKr1UKn02H16tW4e/eu0WMVKFAALi4uOHXqFHQ6HSIiIhxqsQkicgxeXl5YsmQJ1q9fj++++w7Lli0z63nLli1DTEwMunbtiq9fvyJNmjRo0KCBlaMlIiIichxJkiTB9OnT8e+//6JFixaCbY7UNsnd3R3u7u5G9/H29haNaTQaZMqUyVphESmuadOmVk24N2nSBGXKlMHChQvx9OlT9O7dG7Vq1ULSpEmNFpuqlUajQfr06RP8fCbciRSSO3du7Ny5E9euXUN4eDhCQ0ORJUsWFCtWLG7BF41Gg7Fjx2LatGm4cOGC5HFy5MgBFxeXuMcajYbJdjvHljLkyPLmzYuAgAAAECXcCxQogFevXuHFixdxY5s2bYpbqO7EiRO4e/cuMmbMyDUpiIiIiCyk0WgkW7eYs+CoI5FKuMspPDwc4eHhVj0HkaW+//57zJ49G7/99puo8DOh1q1bh7/++gsZM2ZEo0aNoNVqTfaXdxZMuBMpyNvb2+Sif7ly5cKiRYvQp08fwYIzwLdee927d7dmiKQAtpQhZ9G5c2csXrw47nGXLl3g5eWFhQsXInny5OjTpw/8/PzitidNmhR58uRRIlQiInJSTJyRo9FqtShRogTOnj0L4NtnSmdLkP3666/YuXNn3GN/f39Zj29Of3siJZQpUwanTp0CAHz48AHjxo3DzZs38csvv+Dly5cIDg6O2zdVqlRGF1pt0qQJcuXKhf79+1s7bLvEhDuRnRgwYAB0Oh3evn2LFi1aIF++fPD29maVJxHZrebNm+Pp06e4ceMGqlatihIlSkCr1WLOnDlKh0ZERASAiTNyTEOGDMH06dPx4cMH/PrrryZbsDiaDBkyYPjw4Vi7di38/PzQs2dPpUMisrmUKVNi6tSpcY+jo6ORI0cOhISEoFGjRnF3Gd+4cQNfv35Fzpw5MXXqVJw/fx5ly5ZF7969lQrdLmh0Op1O6SAc3atXr+Dj4yMYCwkJQbp06RSKiIjULDw8HK9evYr7AxeL8wYRUeLxfRkRWUKj0UiOc94gIkNCQkIkW4Ry3iByHqxwJyIiIiIiIpIQFhYmWQhBRGQIW4QSERPuREQqw1uXiYiIiNTBw8MDERERSodBREREdsS5lqImIiIiIiIiIiKykpcvX+L69etKh0FECmKFOxGRyvDWZSIiIiIiIvvEljJExAp3IiIiIiIiIiIiIiIZsMLdBmJiYkRjr1+/ViASIlJSmjRpoNWa/p7TUA93zhtEzsfceYPMx/dlRGTp3Mp5g4gA8+eOsLAwvHz5Ejly5BCMc94gch5MuNvA27dvRWN58+ZVIBIiUlJISAjSpUuX4Odz3iByPomdN0iM78uIyNK5lfMGEQGWzR3v3r0TjXHeIHIeTLgTEalMWFgYbt26hWLFiikdChEREREREVnA0B3LROQ8eI+yDUhVRBARGeLh4YHPnz8rHQYRkUPi+zIishTnDSIiIrIEE+5EREREREREREQyCAsLw/79+5UOg4gUxJYyNpA9e3bR2LVr1+Dj42PV84aHhyNbtmwAgAcPHsDDw8PqxzB3f1P7GdpuyXj8sfPnz4vac9y4cQNp06Y141VIHLVeh4ReA0PbzBn79OmTqG+dLa6DEtdA6jlp0qQx+3z2PG8k5DjW/JlN6LzhbD+zcszfCdmm1vlbLb8LlswbZB57nl/5e504avm95vsy5X8XLJ1bnWneMPc5/Dxn3WMoMX9z3jD9HHPnDg8PD+TLl080bot5A1Dvzyz/1ln3GMzHiSl6HXRkdSEhIToAgv+FhIRY/bxhYWFx5wsLC7PJMczd39R+hrZbMh5/7MGDB4pcA2MxW/MY5uyf0GtgaJs5Y870u5DY89rza5WQ41jzZzah84az/czKMX8nZJta5281/y5Q4vD32rL9+Hud+OPwfZll/63WOEZiz+lMr5W5z+HnOeseQ4n5m/OGvOdV6rXS6dT7M8u/ddY9hhzzhrHtnL8tuw4anU6nA1nVq1evRN9iWrK6NSUer4E68DqYj6+VOvA6KI/XgOTGnynl8RqoA6+D+fhaKY/XQB14HczH10odeB2U56zXgD3ciYiIiIiIiIiIiIhkwIQ7EREREREREREREZEMmHAnIiIiIiIiIiIiIpIBe7gTEREREREREREREcmAFe5ERERERERERERERDJgwp2IiIiIiIiIiIiISAZMuBMRERERERERERERyYAJdyIiIiIiIiIiIiIiGTDhTkREREREREREREQkAybciYiIiIiIiIiIiIhkwIQ7EREREREREREREZEMmHAnIiIiIiIiIiIiIpIBE+5ERERERERERERERDJgwp2IiIiIiIiIiIiISAZMuBMRERERERERERERyYAJdyIiIiIiIiIiIiIiGTDhTkREREREREREREQkAybcVebLly/o378/fHx8kDJlSnTp0gURERFKh+XUdDodatSogVmzZikdilN5+fIlWrduDV9fX6RNmxaNGzfGf//9p3RYqsW5Q104byiHcwfJiXOr+nB+VQbnVvNx3lAfzhvK4dxhPs4d6sJ5QzmOMm8w4a4yI0aMwPbt27F161YEBwfj8OHD6Nevn9JhOa0vX76gS5cu2Lt3r9KhOJ1GjRrh0aNHCA4OxqFDh/DhwwfUrl0bX758UTo0VeLcoR6cN5TFuYPkxLlVXTi/Kodzq/k4b6gL5w1lce4wH+cO9eC8oSyHmTd0pBqfPn3SeXh46DZv3hw3dujQIV2SJEl0b968UTAy53T9+nVd8eLFdVmzZtWlSpVKN3PmTKVDchq3bt3SAdDdunUrbuzp06c6ALrz588rGJk6ce5QD84byuLcQXLi3KounF+Vw7nVfJw31IXzhrI4d5iPc4d6cN5QliPNG6xwV5F//vkH4eHhqFChQtxY2bJlodPp8PfffysYmXM6duwYSpUqhUuXLiFlypRKh+NUfH19sXPnTuTKlUu07dOnTwpEpG6cO9SD84ayOHeQnDi3qgvnV+VwbjUf5w114byhLM4d5uPcoR6cN5TlSPNGEqUDoP/577//4ObmhrRp08aNJU2aFGnSpMHTp08VjMw5de3aVekQnFaqVKlQs2ZNwdj06dPh6emJH3/8UZmgVIxzh3pw3lAW5w6SE+dWdeH8qhzOrebjvKEunDeUxbnDfJw71IPzhrIcad5gwl1FIiIi4ObmJhp3c3NDZGSkAhERqcOaNWswa9YszJ49G56enkqHozqcO4ikce6gxODcSiSNc6thnDeIDOPcYRjnDiJp9jxvsKWMiiRPnlxyMo2MjIS7u7sCEREpb8GCBWjXrh369++PXr16KR2OKnHuIBLj3EGJxbmVSIxzq3GcN4ikce4wjnMHkZi9zxtMuKtIxowZERkZiXfv3sWNRUdH482bN8iQIYOCkREpIyAgAN27d8ewYcMwbdo0pcNRLc4dREKcO0gOnFuJhDi3msZ5g0iMc4dpnDuIhBxh3mDCXUUKFSoEDw8PHD16NG7sxIkT0Gq1KF68uIKREdnejBkzMHr0aEydOhVjx45VOhxV49xB9D+cO0gunFuJ/odzq3k4bxAJce4wD+cOov9xlHmDPdxVJHny5OjcuTN69+6NlClTws3NDV26dEH79u3h7e2tdHhENnPnzh0MGTIEnTt3RqtWrfDixYu4balTp5bsb+fMOHcQfcO5g+TEuZXoG86t5uO8QfQ/nDvMx7mD6BtHmjdY4S6TZs2aIWPGjAa3r1ixAkWKFIGnpyd8fHzQqlUrPHr0SLTfpEmTUKdOHTRo0AC1atVCxYoVMXv2bGuG7nDkuhaUMHK8/ps3b0Z0dDQWL16M7777TvC/3bt3W/s/waY4d6gD5w3lce4gOXFuVQ/Or8ri3Go+zhvqwXlDeZw7zMe5Qx04byiP84YeHSXa+PHjdQB0GTJkkNw+ePBgHQBd3rx5dYMGDdI1a9ZM5+LiokubNq3u/v37No7WsfFaKIuvv2X4eqkDr4PyeA1ITvx5Ug9eC2Xx9TcfXyv14LVQHq+B+fhaqQOvg/J4DcSYcE+ET58+6bp06aIDYPAH69KlSzoAurJly+oiIyPjxrdt26YDoKtdu7YtQ3ZYvBbK4utvGb5e6sDroDxeA5ITf57Ug9dCWXz9zcfXSj14LZTHa2A+vlbqwOugPF4Dw5hwT6CgoCBd1qxZdQB0/v7+Bn+wOnXqpAOg279/v2hbxYoVdRqNRvf06VNbhOyweC2UxdffMny91IHXQXm8BiQn/jypB6+Fsvj6m4+vlXrwWiiP18B8fK3UgddBebwGxrGHewItW7YMoaGhmD9/Pnbu3Glwv+PHjyNJkiQoX768aFuVKlWg0+lw+PBha4bq8HgtlMXX3zJ8vdSB10F5vAYkJ/48qQevhbL4+puPr5V68Fooj9fAfHyt1IHXQXm8BsYlUToAe9W3b1+sWbMGKVKkMLjP169fcefOHWTNmhWurq6i7Tly5AAA3Lp1y2pxOgNeC2Xx9bcMXy914HVQHq8ByYk/T+rBa6Esvv7m42ulHrwWyuM1MB9fK3XgdVAer4FxTLgnUMWKFU3u8/HjR+h0Onh7e0tuT5UqFQDg/fv38gXmhHgtlMXX3zJ8vdSB10F5vAYkJ/48qQevhbL4+puPr5V68Fooj9fAfHyt1IHXQXm8BsaxpYwVhYWFAQDc3Nwkt8eOf/782WYxOSteC2Xx9bcMXy914HVQHq8ByYk/T+rBa6Esvv7m42ulHrwWyuM1MB9fK3XgdVCeM18DJtytKFmyZACAqKgoye2RkZEAAE9PT5vF5Kx4LZTF198yfL3UgddBebwGJCf+PKkHr4Wy+Pqbj6+VevBaKI/XwHx8rdSB10F5znwNmHC3opQpU0Kr1Rq8NSJ2PGXKlLYLyknxWiiLr79l+HqpA6+D8ngNSE78eVIPXgtl8fU3H18r9eC1UB6vgfn4WqkDr4PynPkaMOFuRa6ursiRIwceP36M6Oho0fZ79+4BAPLmzWvr0JwOr4Wy+Ppbhq+XOvA6KI/XgOTEnyf14LVQFl9/8/G1Ug9eC+XxGpiPr5U68Dooz5mvARPuVlahQgVERUXh5MmTom0HDhyARqNBmTJlFIjM+fBaKIuvv2X4eqkDr4PyeA1ITvx5Ug9eC2Xx9TcfXyv14LVQHq+B+fhaqQOvg/Kc9hroSBYAdBkyZBCNnzp1SgdAV6pUKV1ERETc+LZt23QAdHXr1rVhlM6B10JZfP0tw9dLHXgdlMdrQHLiz5N68Fooi6+/+fhaqQevhfJ4DczH10odeB2Ux2sgxIS7TAz9YOl0Ol2PHj10AHS5cuXS/fbbb7rmzZvrXFxcdL6+vrp79+7ZOFLHx2uhLL7+luHrpQ68DsrjNSA58edJPXgtlMXX33x8rdSD10J5vAbm42ulDrwOyuM1EGLCXSbGfrBiYmJ0c+fO1eXPn1/n5uam8/Pz07Vs2dJhf6iUxmuhLL7+luHrpQ68DsrjNSA58edJPXgtlMXX33x8rdSD10J5vAbm42ulDrwOyuM1ENLodDqdue1niIiIiIiIiIiIiIhIGhdNJSIiIiIiIiIiIiKSARPuREREREREREREREQyYMKdiIiIiIiIiIiIiEgGTLgTEREREREREREREcmACXciIiIiIiIiIiIiIhn8H6ZhnqYnrI0HAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#LFP profile / observations \n", + "fig, ax = plt.subplots(5,5, figsize=(5,5))\n", + "ax = ax.flatten()\n", + "for i in range(len(observation_indices)):\n", + " xo_raw = df_xos.loc[observation_indices[i]][cols_features].values\n", + " ax[i].loglog(freqs, xo_raw, \"k\", alpha=0.8)\n", + " ax[i].set_yticks([])\n", + " ax[i].set_xlim([1, 400])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING c:\\users\\brian.laptop-8bs4kr2p\\automind\\automind\\utils\\dist_utils.py:428: RuntimeWarning: divide by zero encountered in log10\n", + " samples = np.log10(samples)\n", + " [py.warnings]\n", + "WARNING c:\\users\\brian.laptop-8bs4kr2p\\automind\\automind\\utils\\dist_utils.py:463: RuntimeWarning: invalid value encountered in multiply\n", + " dist = (dists * weights).mean(1)\n", + " [py.warnings]\n" + ] + } + ], + "source": [ + "id = 10030 #Select from observations \n", + "n_samples = 3 #How many networks you want to simulate\n", + "xo = df_xos.iloc[id][cols_features].values \n", + "samples = df_xos.iloc[id:][cols_features].values\n", + "log_samples = True\n", + "stdz_func = posterior.x_standardizing_func\n", + "standardised_samples = dist_utils.log_n_stdz(samples,stdz_func)\n", + "include_mapnmean = True\n", + "sort_samples=True\n", + "sort_weights=((freqs>=50) & (freqs<=400)) #Filter unwanted frequencies \n", + "\n", + "samples_sorted, dists, idx_sorted = dist_utils.sort_closest_to_xo(\n", + " standardised_samples[0,:], standardised_samples, \"mse\",top_n=None, weights=sort_weights\n", + " )\n", + "\n", + "params_dict['params_settings']['sim_time'] = 30.1 * b2.second #Changing simulation time to 30 seconds \n", + "df_samples = df_xos.iloc[id+idx_sorted[0:n_samples+1]] #Top x samples closest to the \"true\" oscillation\n", + "df_samples = df_samples.iloc[:,3:33] #Only network information (or else unwanted info will be passed to fill_params_dict)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING C:\\Users\\brian.LAPTOP-8BS4KR2P\\AppData\\Local\\Temp\\ipykernel_21232\\1886566056.py:12: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + " [py.warnings]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#LFP profiles of the selected networks \n", + "fig, ax = plt.subplots(2,5,figsize=(5,3))\n", + "ax = ax.flatten()\n", + "for i in range(len(ax)):\n", + " idx_xo = 10030 + idx_sorted[i]\n", + " xo_raw = df_xos.loc[idx_xo][cols_features].values\n", + " ax[i].loglog(freqs, xo_raw, \"k\", alpha=0.8)\n", + " plt.xlabel(\"Frequency (Hz)\")\n", + " plt.ylabel(\"log PSD (V^2/Hz)\")\n", + " plt.yticks([])\n", + " plt.xlim([1, 400])\n", + " plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# NOTE: This sets the correct early-stopping condition, i.e., to assess the simulation from 0.1 to 10.1 seconds.\n", + "params_dict['params_analysis']['analysis_window'] = [0.1, None] \n", + "params_dict_run = data_utils.fill_params_dict(\n", + " params_dict, df_samples, posterior.as_dict, n_samples\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from automind.sim.default_configs import MKI_pretty_param_names\n", + "\n", + "_, theta_minmax = dist_utils.standardize_theta(posterior.prior.sample((1,)), posterior)\n", + "fig, axs = plt.subplots(10, 3, figsize=(3.5, 1))\n", + "plot_utils.plot_params_1D(\n", + " df_samples[posterior.names].values,\n", + " theta_minmax,\n", + " MKI_pretty_param_names,\n", + " (fig, axs),\n", + " color=\"k\",\n", + " draw_canvas=True,\n", + " draw_kde=False,\n", + " draw_samples=True,\n", + " labelpad=12,\n", + " draw_median=False,\n", + " sample_ms=3,\n", + " sample_alpha=0.5,\n", + ");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#wrapper \n", + "def adex_simulator(params_dict):\n", + " \"\"\"\n", + " Simulator wrapper for AdEx net, run simulations and collect data.\n", + " \"\"\"\n", + "\n", + " print(\n", + " f\"{params_dict['params_settings']['batch_seed']}-{params_dict['params_settings']['random_seed']}\",\n", + " end=\"|\",\n", + " )\n", + "\n", + " try:\n", + " # set up and run model with early stopping\n", + " network_type = params_dict[\"params_settings\"][\"network_type\"]\n", + " if (not network_type) or (network_type == \"adex\"):\n", + " net_collect = b2_models.adaptive_exp_net(params_dict)\n", + " elif network_type == \"adex_clustered\": #Change function params here to switch between different modes, inputs etc\n", + " net_collect = b2_models.adaptive_exp_net_clustered_cog(params_dict, mode='cluster',stim_cluster=2,custom_cluster_input=[b2_inputs.DM_simple(params_dict,0.5*10**-9),b2_inputs.DM_simple(params_dict,0.7*10**-9)])\n", + " \n", + " # run the model\n", + " params_dict, net_collect = runners.run_net_early_stop(net_collect, params_dict)\n", + "\n", + " # return pickleable outputs for pool\n", + " spikes, timeseries = data_utils.collect_raw_data(net_collect, params_dict)\n", + "\n", + " return params_dict, spikes, timeseries\n", + "\n", + " except Exception as e:\n", + " print(\"-----\")\n", + " print(e)\n", + " print(\n", + " f\"{params_dict['params_settings']['batch_seed']}-{params_dict['params_settings']['random_seed']}: FAILED\"\n", + " )\n", + " print(\"-----\")\n", + " return params_dict, {}, {}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [], + "source": [ + "from time import time" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cache non-existent.\n", + "7149324-42|Simulation 1/3 took 33.60 seconds.\n", + "7149324-42|Simulation 2/3 took 34.29 seconds.\n", + "7149324-42|Simulation 3/3 took 34.39 seconds.\n", + "cache non-existent.\n" + ] + } + ], + "source": [ + "#Simulation \n", + "cache_path = \"./.cache/\"\n", + "b2_interface.clear_b2_cache(cache_path)\n", + "b2_interface.set_b2_cache(cache_path, True)\n", + "\n", + "\n", + "sim_parallel = False\n", + "if sim_parallel:\n", + " from multiprocessing import Pool\n", + "\n", + " start_time = time()\n", + " with Pool(n_samples) as pool:\n", + " sim_collector = pool.map(adex_simulator, params_dict_run)\n", + " print(f\"Simulations took {time()-start_time:.2f} seconds.\")\n", + "else:\n", + " sim_collector = []\n", + " for i_sim in range(n_samples):\n", + " start_time = time()\n", + " sim_collector.append(adex_simulator(params_dict_run[i_sim]))\n", + " print(f\"Simulation {i_sim+1}/{n_samples} took {time()-start_time:.2f} seconds.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 128, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(sim_collector[0][0]['params_net']['input'][0])\n", + "plt.plot(sim_collector[0][0]['params_net']['input'][1])" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [], + "source": [ + "results_collector = [\n", + " analysis_utils.compute_summary_features(sims[1], sims[0]) for sims in sim_collector\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Added plots for inputs at the bottom \n", + "from matplotlib import gridspec\n", + "\n", + "xlims = [0, 30]\n", + "xlims_zoom = [10, 20]\n", + "every_other = 5\n", + "\n", + "for i_sim, results in enumerate(results_collector):\n", + " # left: full view, middle: zoomed view, right: PSD spanning all rows.\n", + " fig = plt.figure(figsize=(4,1.5), constrained_layout=True)\n", + " gs = gridspec.GridSpec(3, 3, figure=fig,\n", + " width_ratios=[3, 3, 2],\n", + " height_ratios=[2, 2, 1])\n", + " \n", + " #Left column - Full view\n", + " ax_full_raster = fig.add_subplot(gs[0, 0])\n", + " ax_full_rate = fig.add_subplot(gs[1, 0])\n", + " ax_full_input = fig.add_subplot(gs[2, 0])\n", + " \n", + " #Middle column - Zoomed view \n", + " ax_zoom_raster = fig.add_subplot(gs[0, 1])\n", + " ax_zoom_rate = fig.add_subplot(gs[1, 1])\n", + " ax_zoom_input = fig.add_subplot(gs[2, 1])\n", + " \n", + " #Right column - PSD \n", + " ax_psd = fig.add_subplot(gs[:, 2])\n", + " \n", + " #Full view\n", + " #Plot full raster\n", + " plot_utils._plot_raster_pretty(\n", + " sim_collector[i_sim][1], XL=xlims, every_other=every_other, fontsize=5, ax=ax_full_raster\n", + " )\n", + " ax_full_raster.set_title(\"Full\")\n", + " \n", + " #Plot full rate\n", + " plot_utils._plot_rates_pretty(\n", + " results_collector[i_sim][\"pop_rates\"],\n", + " XL=xlims,\n", + " pops_to_plot=[\"avgpop_rate\"],\n", + " ylim_past=10 * 1000,\n", + " fontsize=5,\n", + " ax=ax_full_rate,\n", + " color=\"k\",\n", + " )\n", + " ax_full_rate.set_ylabel(\"Rate\")\n", + " ax_full_rate.set_ylim([0, 40])\n", + " ax_full_rate.set_yticks([0, 40])\n", + " \n", + " #Plot full input signal\n", + " params_net = sim_collector[0][0]['params_net']\n", + "\n", + " # Try to get the input from one key and fall back to the other\n", + " inputs = params_net.get('input')\n", + " if inputs is not None and not isinstance(inputs, list):\n", + " inputs = [inputs]\n", + " if inputs is not None:\n", + " sim_time = sim_collector[0][0]['params_settings']['sim_time']\n", + " dt = sim_collector[0][0]['params_settings']['dt']\n", + " time_vector = np.linspace(0, sim_time, int(sim_time/dt))\n", + " \n", + " ax_full_input.set_xlabel(\"Time (s)\")\n", + " ax_full_input.set_ylabel(\"Amps\")\n", + " for inp in inputs:\n", + " ax_full_input.plot(time_vector, inp)\n", + " else:\n", + " print(\"No input found in the simulation parameters.\")\n", + " \n", + " #Zoomed view\n", + " #Plot zoomed raster\n", + " plot_utils._plot_raster_pretty(\n", + " sim_collector[i_sim][1], XL=xlims_zoom, every_other=every_other, fontsize=5, ax=ax_zoom_raster\n", + " )\n", + " ax_zoom_raster.set_title(\"Zoom\")\n", + " #Plot zoomed rate\n", + " plot_utils._plot_rates_pretty(\n", + " results_collector[i_sim][\"pop_rates\"],\n", + " XL=xlims_zoom,\n", + " pops_to_plot=[\"avgpop_rate\"],\n", + " ylim_past=10 * 1000,\n", + " fontsize=5,\n", + " ax=ax_zoom_rate,\n", + " color=\"k\",\n", + " )\n", + " ax_zoom_rate.set_ylabel(\"Rate\")\n", + " ax_zoom_rate.set_ylim([0, 40])\n", + " ax_zoom_rate.set_yticks([0, 40])\n", + " \n", + " #Plot zoomed input signal\n", + " ax_zoom_input.set_xlabel(\"Time (s)\")\n", + " ax_zoom_input.set_ylabel(\"Amps\")\n", + " if inputs is not None:\n", + " for inp in inputs:\n", + " ax_zoom_input.plot(time_vector, inp, linewidth=0.6)\n", + " ax_zoom_input.set_xlim(xlims_zoom)\n", + " \n", + " #PSD\n", + " plot_utils._plot_psd_pretty(\n", + " results_collector[i_sim][\"summary_psd\"], [\"avgpop_rate\"], ax=ax_psd, fontsize=5\n", + " )\n", + " ax_psd.set_title(\"PSD\")\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multiple inputs " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#wrapper function for multiple inputs - \n", + "def adex_simulator_multiple(params_dict,input):\n", + " \"\"\"\n", + " Simulator wrapper for AdEx net, run simulations and collect data.\n", + " \"\"\"\n", + "\n", + " print(\n", + " f\"{params_dict['params_settings']['batch_seed']}-{params_dict['params_settings']['random_seed']}\",\n", + " end=\"|\",\n", + " )\n", + " try:\n", + " # set up and run model with early stopping\n", + " network_type = params_dict[\"params_settings\"][\"network_type\"]\n", + " if (not network_type) or (network_type == \"adex\"):\n", + " net_collect = b2_models.adaptive_exp_net(params_dict)\n", + " elif network_type == \"adex_clustered\": #Change function params here to switch between different modes, inputs etc\n", + " net_collect = b2_models.adaptive_exp_net_clustered_cog(params_dict, mode = 'single', custom_input = input)\n", + " \n", + " # run the model\n", + " params_dict, net_collect = runners.run_net_early_stop(net_collect, params_dict)\n", + "\n", + " # return pickleable outputs for pool\n", + " spikes, timeseries = data_utils.collect_raw_data(net_collect, params_dict)\n", + "\n", + " return params_dict, spikes, timeseries\n", + "\n", + " except Exception as e:\n", + " print(\"-----\")\n", + " print(e)\n", + " print(\n", + " f\"{params_dict['params_settings']['batch_seed']}-{params_dict['params_settings']['random_seed']}: FAILED\"\n", + " )\n", + " print(\"-----\")\n", + " return params_dict, {}, {}\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Simulation \n", + "cache_path = \"./.cache/\"\n", + "b2_interface.clear_b2_cache(cache_path)\n", + "b2_interface.set_b2_cache(cache_path, True)\n", + "\n", + "inputs = np.arange(0,2.5*10^-9,10**-10) #Replace this with the list of inputs you want to test on\n", + "for input in inputs: \n", + " sim_parallel = False\n", + " if sim_parallel:\n", + " from multiprocessing import Pool\n", + "\n", + " start_time = time()\n", + " with Pool(n_samples) as pool:\n", + " sim_collector = pool.map(adex_simulator, params_dict_run) #I haven't personally run this so I am not sure how to change it \n", + " print(f\"Simulations took {time()-start_time:.2f} seconds.\")\n", + " else:\n", + " sim_collector = []\n", + " for i_sim in range(n_samples+1): #n_samples taken from the distribution plus gt_resim\n", + " start_time = time()\n", + " sim_collector.append(adex_simulator_multiple(params_dict_run[i_sim],input)) #It should work here \n", + " print(f\"Simulation {i_sim+1}/{n_samples} took {time()-start_time:.2f} seconds.\")\n", + "\n", + "b2_interface.clear_b2_cache(cache_path)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "results_collector = [\n", + " analysis_utils.compute_summary_features(sims[1], sims[0]) for sims in sim_collector\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cluster analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [], + "source": [ + "n_sims = len(sim_collector)\n", + "membership = [sim_collector[i][0]['params_net'].get('membership', np.array([])) for i in range(n_sims)]\n", + "num_clusters = [int(sim_collector[i][0]['params_net']['n_clusters']) for i in range(n_sims)]\n", + "\n", + "#2 sorted indices, one based on the first membership and the other on the second \n", + "#sort_idx_special = [np.argsort(np.sum(membership[0],axis=1)) if membership[i].size > 0 else [] for i in range(n_sims)]\n", + "sorted_index_0 = [np.argsort(membership[i][:,0]) if membership[i].size > 0 else [] for i in range(n_sims)] #First membership\n", + "sorted_index_1 = [np.argsort(membership[i][:,1]) if membership[i].size > 0 else [] for i in range(n_sims)] #Second membership\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": {}, + "outputs": [], + "source": [ + "#Sorting the spikes by clusters\n", + "all_sorted_spikes_by_cluster = []\n", + "for i in range(n_sims):\n", + " spike_dict = sim_collector[i][1]\n", + " sorted_spikes_by_cluster = {\n", + " 'exc_spikes': {}, \n", + " 'inh_spikes': spike_dict.get('inh_spikes', {}) \n", + " }\n", + " exc_spike_dict = spike_dict['exc_spikes'] #Spikes from each simulation \n", + " if membership[i].size > 0: #i.e. having clusters \n", + " for new_idx, old_idx in enumerate(sorted_index_0[i]): \n", + " if old_idx in exc_spike_dict: #Not all spikes are saved but membership saves all neurons \n", + " sorted_spikes_by_cluster['exc_spikes'][new_idx] = exc_spike_dict[old_idx]\n", + " \n", + " all_sorted_spikes_by_cluster.append(sorted_spikes_by_cluster)\n", + " else: #If no clusters\n", + " all_sorted_spikes_by_cluster.append({\n", + " 'exc_spikes': exc_spike_dict, \n", + " 'inh_spikes': spike_dict.get('inh_spikes')\n", + " })\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING C:\\Users\\brian.LAPTOP-8BS4KR2P\\AppData\\Local\\Temp\\ipykernel_21232\\30307010.py:33: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + " [py.warnings]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Comparison between plotting with and without clusters. Note some clusters could be underrepresented as we subsampled neurons.\n", + "\n", + "#IMPORTANT: You can see from the top the neurons that only fire during the input disappear in the bottom plot. I will try to figure out why \n", + "#first so please don't use this part yet, sorry!\n", + "\n", + "xlims_full = [0, 30]\n", + "every_other = 1\n", + "\n", + "for i_sim in range(n_sims):\n", + " # left: full view, middle: zoomed view, right: PSD spanning all rows.\n", + " fig, (ax_unsort, ax_sort) = plt.subplots(2, 1, figsize=(4,1.5), sharex=True)\n", + " #Unsorted raster\n", + " plot_utils._plot_raster_pretty(\n", + " sim_collector[i_sim][1],\n", + " XL=xlims_full,\n", + " every_other=every_other,\n", + " fontsize=5,\n", + " ax=ax_unsort\n", + " )\n", + " ax_unsort.set_title(\"Unsorted Raster\")\n", + "\n", + " #Sorted raster \n", + " plot_utils._plot_raster_pretty(\n", + " all_sorted_spikes_by_cluster[i_sim], \n", + " XL=xlims, \n", + " every_other=every_other, \n", + " fontsize=5, \n", + " ax=ax_sort\n", + " )\n", + "\n", + " ax_sort.set_title(f\"Sorted Raster {num_clusters[i_sim]}\")\n", + " ax_sort.set_xlabel(\"Time (s)\")\n", + "\n", + " # Adjust the layout to minimize white space\n", + " plt.tight_layout()\n", + " plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "automind", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/decode_test.ipynb b/notebooks/decode_test.ipynb new file mode 100644 index 0000000..c7095f0 --- /dev/null +++ b/notebooks/decode_test.ipynb @@ -0,0 +1,778 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "# Imports\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "mpl_rc = \"../assets/matplotlibrc\"\n", + "plt.style.use(mpl_rc)\n", + "import numpy as np\n", + "import pickle\n", + "import brian2 as b2\n", + "from automind.sim import b2_inputs\n", + "from automind.utils import data_utils, dist_utils, plot_utils\n", + "from brian2 import *\n", + "from statsmodels.stats.multitest import multipletests\n", + "from sklearn.metrics import accuracy_score\n", + "from scipy.stats import kendalltau\n", + "from scipy.stats import linregress\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "posterior.pickle ['7149324_posterior.pickle']\n", + "params_dict_analysis_updated.pickle ['7149324_MK1_params_dict_analysis_updated.pickle']\n", + "summary_data_merged.csv ['7149324_MK1_summary_data_merged.csv']\n", + "1003 samples per xo.\n", + "Posterior conditional density p(Īø|x) of type DirectPosterior. It samples the posterior network and rejects samples that\n", + " lie outside of the prior bounds.\n" + ] + } + ], + "source": [ + "data_dirs = \"../datasets/discovered_posterior_samples/synthetic/\"\n", + "path_dict = data_utils.extract_data_files(\n", + " data_dirs,\n", + " [\n", + " \"posterior.pickle\",\n", + " \"params_dict_analysis_updated.pickle\",\n", + " \"summary_data_merged.csv\",\n", + " ],\n", + ")\n", + "df_xos, posterior, params_dict = data_utils.load_df_posteriors(path_dict)\n", + "_, _, _, _, cols_psd = data_utils.separate_feature_columns(df_xos)\n", + "print(posterior)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Density estimator was trained on PSD between (0.5, 495) Hz.\n" + ] + } + ], + "source": [ + "f_bounds = posterior.x_bounds_and_transforms[\"freq_bounds\"]\n", + "print(f\"Density estimator was trained on PSD between {f_bounds} Hz.\")\n", + "\n", + "# Extract the frequency bounds and trim correspondingly\n", + "freqs = data_utils.decode_df_float_axis(cols_psd)\n", + "f_idx = (freqs >= f_bounds[0]) & (freqs <= f_bounds[1])\n", + "freqs, cols_features = freqs[f_idx], np.array(cols_psd)[f_idx]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Picking the observation and samples" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "observation_indices = df_xos[df_xos['inference.type']=='gt_resim'].index.tolist()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING c:\\users\\brian.laptop-8bs4kr2p\\automind\\automind\\utils\\dist_utils.py:428: RuntimeWarning: divide by zero encountered in log10\n", + " samples = np.log10(samples)\n", + " [py.warnings]\n", + "WARNING c:\\users\\brian.laptop-8bs4kr2p\\automind\\automind\\utils\\dist_utils.py:463: RuntimeWarning: invalid value encountered in multiply\n", + " dist = (dists * weights).mean(1)\n", + " [py.warnings]\n" + ] + } + ], + "source": [ + "#Run this instead if you manually selected the samples instead of resampling \n", + "id = 10030 #Gamma \n", + "n_samples = 50\n", + "xo = df_xos.iloc[id][cols_features].values \n", + "samples = df_xos.iloc[id:][cols_features].values\n", + "log_samples = True\n", + "stdz_func = posterior.x_standardizing_func\n", + "standardised_samples = dist_utils.log_n_stdz(samples,stdz_func)\n", + "include_mapnmean = True\n", + "sort_samples=True\n", + "sort_weights=((freqs>=50) & (freqs<=400)) #Filter unwanted frequencies \n", + "\n", + "samples_sorted, dists, idx_sorted = dist_utils.sort_closest_to_xo(\n", + " standardised_samples[0,:], standardised_samples, \"mse\",top_n=None, weights=sort_weights\n", + " )\n", + "\n", + "params_dict['params_settings']['sim_time'] = 60.1 * b2.second #Changing simulation time to 60 seconds \n", + "df_samples = df_xos.iloc[id+idx_sorted[0:n_samples+1]] #Top x samples closest to the \"true\" oscillation\n", + "df_samples = df_samples.iloc[:,3:33] #Only network information (or else unwanted info will be passed to fill_params_dict)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from automind.sim.default_configs import MKI_pretty_param_names\n", + "\n", + "_, theta_minmax = dist_utils.standardize_theta(posterior.prior.sample((1,)), posterior)\n", + "fig, axs = plt.subplots(10, 3, figsize=(3.5, 1))\n", + "plot_utils.plot_params_1D(\n", + " np.array([df_samples[posterior.names].values]),\n", + " theta_minmax,\n", + " MKI_pretty_param_names,\n", + " (fig, axs),\n", + " color=\"k\",\n", + " draw_canvas=True,\n", + " draw_kde=False,\n", + " draw_samples=True,\n", + " labelpad=12,\n", + " draw_median=False,\n", + " sample_ms=3,\n", + " sample_alpha=0.5,\n", + ");" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "#Data paths \n", + "single_exc_path = \"../results/single_exc_rates.pkl\"\n", + "single_inh_path = \"../results/single_inh_rates.pkl\"\n", + "cont_exc_path = \"../results/cont_exc_rates.pkl\"\n", + "cont_inh_path = \"../results/cont_inh_rates.pkl\"\n", + "sum_features_path = \"../results/summary_features.pkl\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Loading data \n", + "with open(single_exc_path, 'rb') as f:\n", + " single_exc = pickle.load(f)\n", + "with open(single_inh_path, 'rb') as f:\n", + " single_inh = pickle.load(f)\n", + "with open(cont_exc_path, 'rb') as f:\n", + " cont_exc = pickle.load(f)\n", + "with open(cont_inh_path, 'rb') as f:\n", + " cont_inh = pickle.load(f)\n", + "with open(sum_features_path, 'rb') as f:\n", + " sum_features = pickle.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(50, 25, 200, 2000)\n" + ] + } + ], + "source": [ + "#Removing the last timepoint - only run once\n", + "\n", + "print(np.shape(single_exc))\n", + "single_exc = single_exc[:,:,:,:-1] \n", + "single_inh = single_inh[:,:,:,:-1] \n", + "print(np.shape(single_exc)) # (n_networks,n_inputs,n_neurons,n_timepoints) -> timepoints have already been downsampled " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'time (s)')" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Inputs \n", + "strengths = np.linspace(0.1,2.5,25)\n", + "for strength in strengths: \n", + " plt.plot(np.linspace(0,20,100166),b2_inputs.DM_simple(params_dict,strength*10**-9,0)[:100166],c='black') #Standard deviation set to 0 for visualisation \n", + "plt.ylabel(\"Input amplitude (Amps)\")\n", + "plt.xlabel(\"time (s)\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Taking meaningful periods \n", + "\n", + "input_period_exc_FR = single_exc[:,:,:,1000:1500]\n", + "input_period_inh_FR = single_inh[:,:,:,1000:1500]\n", + "\n", + "refractory_period_exc_FR = single_exc[:,:,:,1500:]\n", + "refractory_period_inh_FR = single_inh[:,:,:,1500:]\n", + "\n", + "input_period_1s_exc = single_exc[:,:,:,1200:1300]\n", + "input_period_1s_inh = single_inh[:,:,:,1200:1300]\n", + "\n", + "input_period_first_exc = single_exc[:,:,:,1000:1100]\n", + "input_period_first_inh = single_inh[:,:,:,1000:1100]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "#Average across neurons \n", + "pop_input = np.mean(input_period_exc_FR,axis=2)\n", + "pop_refrac = np.mean(refractory_period_exc_FR,axis=2)\n", + "\n", + "#Maximum responses in different conditions \n", + "max_input_all = np.zeros((50,25))\n", + "avg_refrac_all = np.zeros((50,25))\n", + "avg_input_all = np.zeros((50,25))\n", + "for i in range(50):\n", + " for j in range(25):\n", + " max_input_all[i,j] = np.max(pop_input[i,j])\n", + " avg_input_all[i,j] = np.mean(pop_input[i,j])\n", + " avg_refrac_all[i,j] = np.mean(pop_refrac[i,j])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING C:\\Users\\brian.LAPTOP-8BS4KR2P\\AppData\\Local\\Temp\\ipykernel_28148\\35586188.py:20: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + " [py.warnings]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Range of maximum firing rates excluding exploded networks \n", + "\n", + "input_strengths = np.linspace(0.1, 2.5, 25)\n", + "# Apply filtering: Exclude values > 200 \n", + "filtered_data = [max_input_all[max_input_all[:, i] < 150, i] for i in range(25)]\n", + "\n", + "# Create boxplots\n", + "plt.figure(figsize=(4,3))\n", + "plt.boxplot(filtered_data, positions=input_strengths, widths=0.05) # Set positions to match input strengths\n", + "\n", + "# Set labels\n", + "plt.xlabel(\"Input Strength (nA)\", fontsize=5)\n", + "plt.ylabel(\"Max Firing Rate (spikes/s)\", fontsize=5)\n", + "plt.title(\"Max Firing Rate Distribution Across 50 Networks\", fontsize=6)\n", + "\n", + "# Format x-ticks to round to 1 decimal place\n", + "plt.xticks(input_strengths, [f\"{x:.1f}\" for x in input_strengths], rotation=45)\n", + "plt.xlim(min(input_strengths) - 0.1, max(input_strengths) + 0.1)\n", + "plt.grid(axis=\"y\", linestyle=\"--\", alpha=0.7)\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Input output relation of all 50 networks \n", + "fig, ax = plt.subplots(5,10,figsize=(4,3))\n", + "ax = ax.flatten()\n", + "for i in range(len(ax)):\n", + " ax[i].plot(avg_input_all[i])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING C:\\Users\\brian.LAPTOP-8BS4KR2P\\AppData\\Local\\Temp\\ipykernel_28148\\2994431667.py:30: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + " [py.warnings]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(3, figsize=(2,3))\n", + "#Histogram of responses to 1nA input \n", + "\n", + "avg_refrac = avg_refrac_all[:,9]\n", + "avg_input = avg_input_all[:,9]\n", + "max_input = max_input_all[:,9]\n", + "\n", + "# Plot avg_refrac histogram\n", + "axes[0].hist(avg_refrac, bins=np.linspace(0, 5, 41))\n", + "axes[0].axvline(np.mean(avg_refrac), c='red', label=\"Mean\")\n", + "axes[0].set_xlabel(\"Avg adaptation firing rate (spikes/s)\")\n", + "axes[0].set_ylabel(\"Count\")\n", + "axes[0].legend()\n", + "\n", + "# Plot avg_input histogram\n", + "axes[1].hist(avg_input, bins=np.linspace(0, 50, 41))\n", + "axes[1].axvline(np.mean(avg_input), c='red', label=\"Mean\")\n", + "axes[1].set_xlabel(\"Avg firing rate during input (spikes/s)\")\n", + "axes[1].set_ylabel(\"Count\")\n", + "axes[1].legend()\n", + "\n", + "# Plot max_input histogram\n", + "axes[2].hist(max_input, bins=np.linspace(0, 100, 41))\n", + "axes[2].axvline(np.mean(max_input), c='red', label=\"Mean\")\n", + "axes[2].set_xlabel(\"Max firing rate during input (spikes/s)\")\n", + "axes[2].set_ylabel(\"Count\")\n", + "axes[2].legend()\n", + "\n", + "# Adjust layout for clarity\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Input strength (Amps)')" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Train stimuli and initial (1 second) response \n", + "fig, ax = plt.subplots(1,2,figsize=(3,1))\n", + "sim_time = params_dict['params_settings']['sim_time']\n", + "for i in range(25):\n", + " ax[0].plot(np.linspace(0,sim_time, len(b2_inputs.DM_simple(params_dict,strengths[i]))), b2_inputs.DM_simple(params_dict,strengths[i]), c='blue' if i<13 else 'black')\n", + " ax[1].plot(np.linspace(0,1,100),np.mean(input_period_first_exc[1],axis=1)[i,:], color=\"blue\" if i<13 else \"black\")\n", + "ax[1].set_xlabel(\"time (s)\")\n", + "ax[1].set_ylabel(\"Firing rate\")\n", + "ax[0].set_xlabel(\"time (s)\")\n", + "ax[0].set_ylabel(\"Input strength (Amps)\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "#Downsampling input for analysis \n", + "test_input = b2_inputs.test_stim(params_dict)\n", + "\n", + "def downsample_signal(stim, target_length):\n", + " downsample_factor = len(stim) // target_length\n", + " \n", + " downsampled_stim = stim[::downsample_factor]\n", + " \n", + " return downsampled_stim\n", + "\n", + "stim_downsampled = downsample_signal(test_input[:300000], 6000)\n", + "mask = [1 if i>0.5*np.max(stim_downsampled) else 0 for i in stim_downsampled]\n", + "stim_loc = np.where(stim_downsampled>0)[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Find input periods for sliding window \n", + "window_size = 50 \n", + "input_period = np.array([1 if i>0 else 0 for i in stim_downsampled])\n", + "prediction_mask = np.zeros(5951) \n", + "\n", + "for i in range(0, len(input_period) - window_size + 1):\n", + " window = input_period[i:i + window_size]\n", + " features = np.mean(window)\n", + " if features==1:\n", + " prediction_mask[i] = 1\n", + "stim_loc_slide = np.where(prediction_mask==1)[0] #Locations where sliding window is fully within the stim-on period \n", + "single_pulse_length_slide = len(stim_loc_slide)/25 #Length of an input pulse \n", + "ground_truth = np.zeros(len(stim_loc_slide))\n", + "ground_truth[int(single_pulse_length_slide*12):] = 1 #Starting from the 13th input the input should be above half of the maximum\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.84\n", + "Cross-validated accuracy using logistic: 0.40\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.92\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 0.92\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.92\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.40\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.92\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 0.92\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 0.40\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 0.92\n", + "Cross-validated accuracy using logistic: 0.92\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 0.96\n", + "Cross-validated accuracy using logistic: 1.00\n", + "Cross-validated accuracy using logistic: 0.92\n" + ] + } + ], + "source": [ + "#Calculating decoding accuracy \n", + "decode_probabilities = []\n", + "accuracies = np.zeros(n_samples)\n", + "for i in range(n_samples):\n", + " decoder = b2_inputs.NeuralDecoder(method='logistic')\n", + " decoder.train(input_period_first_exc[i],np.linspace(10**-10, 2.5*10**-9, 25))\n", + " prediction, probability = decoder.predict(cont_exc[i], use_sliding_window=True, window_size=50)\n", + " accuracies[i] = accuracy_score(ground_truth,prediction[stim_loc_slide])\n", + " decode_probabilities.append(probability[stim_loc_slide])\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "#Average decoding probability across different sliding windows throughout the input period \n", + "average_probabilities = np.zeros((50,25))\n", + "for i in range(50):\n", + " for j in range(25):\n", + " average_probabilities[i,j] = np.mean(decode_probabilities[i][int(j*single_pulse_length_slide):int((j+1)*single_pulse_length_slide)])" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "#Kendall's tau of each network's decoding probability across different input strengths\n", + "tau = np.array([kendalltau(average_probabilities[i].reshape(-1,1),strengths) for i in range(50)])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(-0.01, 0.5, 'Decoding probability')" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Decoding probability against input strength for the 50 networks \n", + "import matplotlib.ticker as ticker\n", + "def format_func(value, tick_number):\n", + " return f\"{value:.3g}\" # Formats to 3 significant figures\n", + "\n", + "fig, ax = plt.subplots(5, 10, figsize=(6, 4))\n", + "ax = ax.flatten()\n", + "\n", + "for i in range(50):\n", + " ax[i].scatter(strengths, average_probabilities[i], s=1)\n", + " ax[i].set_title(f'tau={np.round(tau[i,0],3)}' if tau[i,1] < 0.05 else 'insignificant')\n", + " ax[i].yaxis.set_major_formatter(ticker.ScalarFormatter(useMathText=True))\n", + " ax[i].yaxis.get_major_formatter().set_powerlimits((-3, 3))\n", + " ax[i].yaxis.get_major_formatter().set_useOffset(False)\n", + " ax[i].yaxis.set_major_formatter(ticker.FuncFormatter(format_func))\n", + " \n", + "fig.text(0.5, -0.02, \"Input strength (nA)\", ha='center', fontsize=6)\n", + "fig.text(-0.01, 0.5, \"Decoding probability\", va='center', rotation='vertical', fontsize=6)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING C:\\Users\\brian.LAPTOP-8BS4KR2P\\AppData\\Local\\Temp\\ipykernel_28148\\318072433.py:40: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n", + " [py.warnings]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(4, 7, figsize=(10, 6)) \n", + "ax = ax.flatten()\n", + "\n", + "regression_pvals = []\n", + "r2_scores = []\n", + "\n", + "#perform linear regressions and collect p-values\n", + "for i, param in enumerate(df_samples.columns[2:]):\n", + " mask = np.logical_and(tau[:, 1] < 0.05, tau[:, 0] > 0)\n", + " x = df_samples[param][:-1][mask].values\n", + " y = tau[:, 0][mask]\n", + "\n", + " if len(x) > 1:\n", + " slope, intercept, r_value, p_value, std_err = linregress(x, y)\n", + " regression_pvals.append(p_value)\n", + " r2_scores.append(r_value**2)\n", + " else:\n", + " regression_pvals.append(1.0) # Add non-significant p if insufficient data\n", + " r2_scores.append(np.nan)\n", + "\n", + "# Apply FDR correction\n", + "_, pvals_fdr, _, _ = multipletests(regression_pvals, alpha=0.05, method='fdr_bh')\n", + "\n", + "#plot with FDR-corrected p-values\n", + "for i, param in enumerate(df_samples.columns[2:]):\n", + " mask = np.logical_and(tau[:, 1] < 0.05, tau[:, 0] > 0)\n", + " x = df_samples[param][:-1][mask].values\n", + " y = tau[:, 0][mask]\n", + "\n", + " if len(x) > 1:\n", + " ax[i].scatter(x, y, s=5)\n", + " slope, intercept, _, _, _ = linregress(x, y)\n", + " x_fit = np.linspace(np.min(x), np.max(x), 100)\n", + " y_fit = slope * x_fit + intercept\n", + " ax[i].plot(x_fit, y_fit, color='red', linewidth=1)\n", + " ax[i].set_title(f\"{param}\\nR²={r2_scores[i]:.2f}, q={pvals_fdr[i]:.3f}\", fontsize=6)\n", + " else:\n", + " ax[i].set_title(f\"{param}\\nInsufficient data\", fontsize=6)\n", + "\n", + "plt.tight_layout()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "automind", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}