diff --git a/.circleci/config.yml b/.circleci/config.yml index 5dbacab5cb..e97dc70a65 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -13,7 +13,7 @@ jobs: steps: - checkout - restore_cache: - key: v2-<< parameters.version >>-min-dependency-cache-{{ checksum "dev-requirements.txt" }} + key: v3-<< parameters.version >>-min-dependency-cache-{{ checksum "dev-requirements.txt" }} - run: name: install python dependencies command: | @@ -22,7 +22,7 @@ jobs: pip install --upgrade pip pip install -r dev-requirements.txt - save_cache: - key: v2-<< parameters.version >>-min-dependency-cache-{{ checksum "dev-requirements.txt" }} + key: v3-<< parameters.version >>-min-dependency-cache-{{ checksum "dev-requirements.txt" }} paths: - "venv" - run: @@ -45,7 +45,7 @@ jobs: steps: - checkout - restore_cache: - key: v2-3.9-dependency-cache-{{ checksum "dev-requirements.txt" }} + key: v3-3.9-dependency-cache-{{ checksum "dev-requirements.txt" }} - run: name: install python dependencies command: | @@ -54,7 +54,7 @@ jobs: pip install -r dev-requirements.txt pip install -e . - save_cache: - key: v2-3.9-dependency-cache-{{ checksum "dev-requirements.txt" }} + key: v3-3.9-dependency-cache-{{ checksum "dev-requirements.txt" }} paths: - "venv" - run: @@ -82,7 +82,7 @@ jobs: steps: - checkout - restore_cache: - key: v2-3.9-dependency-cache-{{ checksum "dev-requirements.txt" }} + key: v3-3.9-dependency-cache-{{ checksum "dev-requirements.txt" }} - run: name: install python dependencies command: | @@ -91,7 +91,7 @@ jobs: pip install -r dev-requirements.txt pip install -e . - save_cache: - key: v2-3.9-dependency-cache-{{ checksum "dev-requirements.txt" }} + key: v3-3.9-dependency-cache-{{ checksum "dev-requirements.txt" }} paths: - "venv" - run: diff --git a/benchmarks/cifar_exp/experiment_varying_task_sample.py b/benchmarks/cifar_exp/experiment_varying_task_sample.py index ffcc33be9d..ba9df30d78 100644 --- a/benchmarks/cifar_exp/experiment_varying_task_sample.py +++ b/benchmarks/cifar_exp/experiment_varying_task_sample.py @@ -1,474 +1,474 @@ -#%% -import random -import matplotlib.pyplot as plt -import tensorflow as tf -import keras -from keras import layers -from itertools import product -import pandas as pd - -import numpy as np -import pickle - -from sklearn.model_selection import StratifiedKFold -from math import log2, ceil - -import sys -from joblib import Parallel, delayed -from multiprocessing import Pool - -from proglearn import ProgressiveLearner -from proglearn import SimpleArgmaxAverage -from proglearn import NeuralClassificationTransformer, TreeClassificationTransformer -from proglearn import TreeClassificationVoter, KNNClassificationVoter - -import tensorflow as tf -from numbers import Number -from collections import Set, Mapping, deque - -import time - -#%% -def unpickle(file): - with open(file, "rb") as fo: - dict = pickle.load(fo, encoding="bytes") - return dict - - -try: # Python 2 - zero_depth_bases = (basestring, Number, xrange, bytearray) - iteritems = "iteritems" -except NameError: # Python 3 - zero_depth_bases = (str, bytes, Number, range, bytearray) - iteritems = "items" - - -def getsize(obj_0): - """Recursively iterate to sum size of object & members.""" - _seen_ids = set() - - def inner(obj): - obj_id = id(obj) - if obj_id in _seen_ids: - return 0 - _seen_ids.add(obj_id) - size = sys.getsizeof(obj) - if isinstance(obj, zero_depth_bases): - pass # bypass remaining control flow and return - elif isinstance(obj, (tuple, list, Set, deque)): - size += sum(inner(i) for i in obj) - elif isinstance(obj, Mapping) or hasattr(obj, iteritems): - size += sum(inner(k) + inner(v) for k, v in getattr(obj, iteritems)()) - # Check for custom object instances - may subclass above too - if hasattr(obj, "__dict__"): - size += inner(vars(obj)) - if hasattr(obj, "__slots__"): # can have __slots__ with __dict__ - size += sum( - inner(getattr(obj, s)) for s in obj.__slots__ if hasattr(obj, s) - ) - return size - - return inner(obj_0) - - -#%% -def LF_experiment( - train_x, - train_y, - test_x, - test_y, - ntrees, - shift, - slot, - model, - num_points_per_task, - acorn=None, -): - - df = pd.DataFrame() - single_task_accuracies = np.zeros(10, dtype=float) - shifts = [] - tasks = [] - base_tasks = [] - accuracies_across_tasks = [] - train_times_across_tasks = [] - single_task_inference_times_across_tasks = [] - multitask_inference_times_across_tasks = [] - model_size = [] - - if model == "dnn": - default_transformer_class = NeuralClassificationTransformer - - network = keras.Sequential() - network.add( - layers.Conv2D( - filters=16, - kernel_size=(3, 3), - activation="relu", - input_shape=np.shape(train_x)[1:], - ) - ) - network.add(layers.BatchNormalization()) - network.add( - layers.Conv2D( - filters=32, - kernel_size=(3, 3), - strides=2, - padding="same", - activation="relu", - ) - ) - network.add(layers.BatchNormalization()) - network.add( - layers.Conv2D( - filters=64, - kernel_size=(3, 3), - strides=2, - padding="same", - activation="relu", - ) - ) - network.add(layers.BatchNormalization()) - network.add( - layers.Conv2D( - filters=128, - kernel_size=(3, 3), - strides=2, - padding="same", - activation="relu", - ) - ) - network.add(layers.BatchNormalization()) - network.add( - layers.Conv2D( - filters=254, - kernel_size=(3, 3), - strides=2, - padding="same", - activation="relu", - ) - ) - - network.add(layers.Flatten()) - network.add(layers.BatchNormalization()) - network.add(layers.Dense(2000, activation="relu")) - network.add(layers.BatchNormalization()) - network.add(layers.Dense(2000, activation="relu")) - network.add(layers.BatchNormalization()) - network.add(layers.Dense(units=10, activation="softmax")) - - default_transformer_kwargs = { - "network": network, - "euclidean_layer_idx": -2, - "num_classes": 10, - "optimizer": keras.optimizers.Adam(3e-4), - } - - default_voter_class = KNNClassificationVoter - default_voter_kwargs = {"k": int(np.log2(num_points_per_task))} - - default_decider_class = SimpleArgmaxAverage - elif model == "uf": - default_transformer_class = TreeClassificationTransformer - default_transformer_kwargs = { - "kwargs": {"max_depth": None, "max_features": "auto"} - } - - default_voter_class = TreeClassificationVoter - default_voter_kwargs = {} - - default_decider_class = SimpleArgmaxAverage - - progressive_learner = ProgressiveLearner( - default_transformer_class=default_transformer_class, - default_transformer_kwargs=default_transformer_kwargs, - default_voter_class=default_voter_class, - default_voter_kwargs=default_voter_kwargs, - default_decider_class=default_decider_class, - ) - - for task_ii in range(10): - print("Starting Task {} For Fold {}".format(task_ii, shift)) - if acorn is not None: - np.random.seed(acorn) - - reduced_sample_no = int(num_points_per_task * (1.29**task_ii)) - - print(reduced_sample_no) - - train_start_time = time.time() - progressive_learner.add_task( - X=train_x[ - task_ii * 5000 - + slot * reduced_sample_no : task_ii * 5000 - + (slot + 1) * reduced_sample_no - ], - y=train_y[ - task_ii * 5000 - + slot * reduced_sample_no : task_ii * 5000 - + (slot + 1) * reduced_sample_no - ], - num_transformers=1 if model == "dnn" else ntrees, - transformer_voter_decider_split=[0.67, 0.33, 0], - decider_kwargs={ - "classes": np.unique( - train_y[ - task_ii * 5000 - + slot * reduced_sample_no : task_ii * 5000 - + (slot + 1) * reduced_sample_no - ] - ) - }, - ) - train_end_time = time.time() - - train_times_across_tasks.append(train_end_time - train_start_time) - model_size.append(getsize(progressive_learner)) - print(model_size) - - single_task_inference_start_time = time.time() - llf_task = progressive_learner.predict( - X=test_x[task_ii * 1000 : (task_ii + 1) * 1000, :], - transformer_ids=[task_ii], - task_id=task_ii, - ) - single_task_inference_end_time = time.time() - single_task_accuracies[task_ii] = np.mean( - llf_task == test_y[task_ii * 1000 : (task_ii + 1) * 1000] - ) - single_task_inference_times_across_tasks.append( - single_task_inference_end_time - single_task_inference_start_time - ) - - for task_jj in range(task_ii + 1): - multitask_inference_start_time = time.time() - llf_task = progressive_learner.predict( - X=test_x[task_jj * 1000 : (task_jj + 1) * 1000, :], task_id=task_jj - ) - multitask_inference_end_time = time.time() - - shifts.append(shift) - tasks.append(task_jj + 1) - base_tasks.append(task_ii + 1) - accuracies_across_tasks.append( - np.mean(llf_task == test_y[task_jj * 1000 : (task_jj + 1) * 1000]) - ) - multitask_inference_times_across_tasks.append( - multitask_inference_end_time - multitask_inference_start_time - ) - - df["data_fold"] = shifts - df["task"] = tasks - df["base_task"] = base_tasks - df["accuracy"] = accuracies_across_tasks - df["multitask_inference_times"] = multitask_inference_times_across_tasks - - df_single_task = pd.DataFrame() - df_single_task["task"] = range(1, 11) - df_single_task["data_fold"] = shift - df_single_task["accuracy"] = single_task_accuracies - df_single_task[ - "single_task_inference_times" - ] = single_task_inference_times_across_tasks - df_single_task["train_times"] = train_times_across_tasks - df_single_task["model_size"] = model_size - - summary = (df, df_single_task) - file_to_save = ( - "result/result/increased_sample_" - + model - + str(ntrees) - + "_" - + str(shift) - + "_" - + str(slot) - + ".pickle" - ) - with open(file_to_save, "wb") as f: - pickle.dump(summary, f) - - -#%% -def cross_val_data(data_x, data_y, num_points_per_task, total_task=10, shift=1): - x = data_x.copy() - y = data_y.copy() - idx = [np.where(data_y == u)[0] for u in np.unique(data_y)] - - batch_per_task = 5000 // num_points_per_task - sample_per_class = num_points_per_task // total_task - test_data_slot = 100 // batch_per_task - - for task in range(total_task): - for batch in range(batch_per_task): - for class_no in range(task * 10, (task + 1) * 10, 1): - indx = np.roll(idx[class_no], (shift - 1) * 100) - - if batch == 0 and class_no == 0 and task == 0: - train_x = x[ - indx[batch * sample_per_class : (batch + 1) * sample_per_class], - :, - ] - train_y = y[ - indx[batch * sample_per_class : (batch + 1) * sample_per_class] - ] - test_x = x[ - indx[ - batch * test_data_slot - + 500 : (batch + 1) * test_data_slot - + 500 - ], - :, - ] - test_y = y[ - indx[ - batch * test_data_slot - + 500 : (batch + 1) * test_data_slot - + 500 - ] - ] - else: - train_x = np.concatenate( - ( - train_x, - x[ - indx[ - batch - * sample_per_class : (batch + 1) - * sample_per_class - ], - :, - ], - ), - axis=0, - ) - train_y = np.concatenate( - ( - train_y, - y[ - indx[ - batch - * sample_per_class : (batch + 1) - * sample_per_class - ] - ], - ), - axis=0, - ) - test_x = np.concatenate( - ( - test_x, - x[ - indx[ - batch * test_data_slot - + 500 : (batch + 1) * test_data_slot - + 500 - ], - :, - ], - ), - axis=0, - ) - test_y = np.concatenate( - ( - test_y, - y[ - indx[ - batch * test_data_slot - + 500 : (batch + 1) * test_data_slot - + 500 - ] - ], - ), - axis=0, - ) - - return train_x, train_y, test_x, test_y - - -#%% -def run_parallel_exp( - data_x, data_y, n_trees, model, num_points_per_task, slot=0, shift=1 -): - train_x, train_y, test_x, test_y = cross_val_data(data_x, data_y, 500, shift=shift) - - if model == "dnn": - config = tf.compat.v1.ConfigProto() - config.gpu_options.allow_growth = True - sess = tf.compat.v1.Session(config=config) - with tf.device("/gpu:" + str(shift % 4)): - LF_experiment( - train_x, - train_y, - test_x, - test_y, - n_trees, - shift, - slot, - model, - num_points_per_task, - acorn=12345, - ) - else: - LF_experiment( - train_x, - train_y, - test_x, - test_y, - n_trees, - shift, - slot, - model, - num_points_per_task, - acorn=12345, - ) - - -#%% -### MAIN HYPERPARAMS ### -model = "dnn" -num_points_per_task = 500 -total_slots = 1 # 5000//num_points_per_task -########################### - -(X_train, y_train), (X_test, y_test) = keras.datasets.cifar100.load_data() -data_x = np.concatenate([X_train, X_test]) -if model == "uf": - data_x = data_x.reshape( - (data_x.shape[0], data_x.shape[1] * data_x.shape[2] * data_x.shape[3]) - ) -data_y = np.concatenate([y_train, y_test]) -data_y = data_y[:, 0] - - -#%% -if model == "uf": - slot_fold = range(total_slots) - shift_fold = range(1, 7, 1) - n_trees = [10] - iterable = product(n_trees, shift_fold, slot_fold) - Parallel(n_jobs=-2, verbose=1)( - delayed(run_parallel_exp)( - data_x, data_y, ntree, model, num_points_per_task, slot=slot, shift=shift - ) - for ntree, shift, slot in iterable - ) -elif model == "dnn": - slot_fold = range(total_slots) - - def perform_shift(shift_slot_tuple): - shift, slot = shift_slot_tuple - return run_parallel_exp( - data_x, data_y, 0, model, num_points_per_task, slot=slot, shift=shift - ) - - print("Performing Stage 1 Shifts") - stage_1_shifts = range(1, 5) - stage_1_iterable = product(stage_1_shifts, slot_fold) - with Pool(4) as p: - p.map(perform_shift, stage_1_iterable) - - print("Performing Stage 2 Shifts") - stage_2_shifts = range(5, 7) - stage_2_iterable = product(stage_2_shifts, slot_fold) - with Pool(4) as p: - p.map(perform_shift, stage_2_iterable) +#%% +import random +import matplotlib.pyplot as plt +import tensorflow as tf +import keras +from keras import layers +from itertools import product +import pandas as pd + +import numpy as np +import pickle + +from sklearn.model_selection import StratifiedKFold +from math import log2, ceil + +import sys +from joblib import Parallel, delayed +from multiprocessing import Pool + +from proglearn import ProgressiveLearner +from proglearn import SimpleArgmaxAverage +from proglearn import NeuralClassificationTransformer, TreeClassificationTransformer +from proglearn import TreeClassificationVoter, KNNClassificationVoter + +import tensorflow as tf +from numbers import Number +from collections import Set, Mapping, deque + +import time + +#%% +def unpickle(file): + with open(file, "rb") as fo: + dict = pickle.load(fo, encoding="bytes") + return dict + + +try: # Python 2 + zero_depth_bases = (basestring, Number, xrange, bytearray) + iteritems = "iteritems" +except NameError: # Python 3 + zero_depth_bases = (str, bytes, Number, range, bytearray) + iteritems = "items" + + +def getsize(obj_0): + """Recursively iterate to sum size of object & members.""" + _seen_ids = set() + + def inner(obj): + obj_id = id(obj) + if obj_id in _seen_ids: + return 0 + _seen_ids.add(obj_id) + size = sys.getsizeof(obj) + if isinstance(obj, zero_depth_bases): + pass # bypass remaining control flow and return + elif isinstance(obj, (tuple, list, Set, deque)): + size += sum(inner(i) for i in obj) + elif isinstance(obj, Mapping) or hasattr(obj, iteritems): + size += sum(inner(k) + inner(v) for k, v in getattr(obj, iteritems)()) + # Check for custom object instances - may subclass above too + if hasattr(obj, "__dict__"): + size += inner(vars(obj)) + if hasattr(obj, "__slots__"): # can have __slots__ with __dict__ + size += sum( + inner(getattr(obj, s)) for s in obj.__slots__ if hasattr(obj, s) + ) + return size + + return inner(obj_0) + + +#%% +def LF_experiment( + train_x, + train_y, + test_x, + test_y, + ntrees, + shift, + slot, + model, + num_points_per_task, + acorn=None, +): + + df = pd.DataFrame() + single_task_accuracies = np.zeros(10, dtype=float) + shifts = [] + tasks = [] + base_tasks = [] + accuracies_across_tasks = [] + train_times_across_tasks = [] + single_task_inference_times_across_tasks = [] + multitask_inference_times_across_tasks = [] + model_size = [] + + if model == "dnn": + default_transformer_class = NeuralClassificationTransformer + + network = keras.Sequential() + network.add( + layers.Conv2D( + filters=16, + kernel_size=(3, 3), + activation="relu", + input_shape=np.shape(train_x)[1:], + ) + ) + network.add(layers.BatchNormalization()) + network.add( + layers.Conv2D( + filters=32, + kernel_size=(3, 3), + strides=2, + padding="same", + activation="relu", + ) + ) + network.add(layers.BatchNormalization()) + network.add( + layers.Conv2D( + filters=64, + kernel_size=(3, 3), + strides=2, + padding="same", + activation="relu", + ) + ) + network.add(layers.BatchNormalization()) + network.add( + layers.Conv2D( + filters=128, + kernel_size=(3, 3), + strides=2, + padding="same", + activation="relu", + ) + ) + network.add(layers.BatchNormalization()) + network.add( + layers.Conv2D( + filters=254, + kernel_size=(3, 3), + strides=2, + padding="same", + activation="relu", + ) + ) + + network.add(layers.Flatten()) + network.add(layers.BatchNormalization()) + network.add(layers.Dense(2000, activation="relu")) + network.add(layers.BatchNormalization()) + network.add(layers.Dense(2000, activation="relu")) + network.add(layers.BatchNormalization()) + network.add(layers.Dense(units=10, activation="softmax")) + + default_transformer_kwargs = { + "network": network, + "euclidean_layer_idx": -2, + "num_classes": 10, + "optimizer": keras.optimizers.Adam(3e-4), + } + + default_voter_class = KNNClassificationVoter + default_voter_kwargs = {"k": int(np.log2(num_points_per_task))} + + default_decider_class = SimpleArgmaxAverage + elif model == "uf": + default_transformer_class = TreeClassificationTransformer + default_transformer_kwargs = { + "kwargs": {"max_depth": None, "max_features": "auto"} + } + + default_voter_class = TreeClassificationVoter + default_voter_kwargs = {} + + default_decider_class = SimpleArgmaxAverage + + progressive_learner = ProgressiveLearner( + default_transformer_class=default_transformer_class, + default_transformer_kwargs=default_transformer_kwargs, + default_voter_class=default_voter_class, + default_voter_kwargs=default_voter_kwargs, + default_decider_class=default_decider_class, + ) + + for task_ii in range(10): + print("Starting Task {} For Fold {}".format(task_ii, shift)) + if acorn is not None: + np.random.seed(acorn) + + reduced_sample_no = int(num_points_per_task * (1.29**task_ii)) + + print(reduced_sample_no) + + train_start_time = time.time() + progressive_learner.add_task( + X=train_x[ + task_ii * 5000 + + slot * reduced_sample_no : task_ii * 5000 + + (slot + 1) * reduced_sample_no + ], + y=train_y[ + task_ii * 5000 + + slot * reduced_sample_no : task_ii * 5000 + + (slot + 1) * reduced_sample_no + ], + num_transformers=1 if model == "dnn" else ntrees, + transformer_voter_decider_split=[0.67, 0.33, 0], + decider_kwargs={ + "classes": np.unique( + train_y[ + task_ii * 5000 + + slot * reduced_sample_no : task_ii * 5000 + + (slot + 1) * reduced_sample_no + ] + ) + }, + ) + train_end_time = time.time() + + train_times_across_tasks.append(train_end_time - train_start_time) + model_size.append(getsize(progressive_learner)) + print(model_size) + + single_task_inference_start_time = time.time() + llf_task = progressive_learner.predict( + X=test_x[task_ii * 1000 : (task_ii + 1) * 1000, :], + transformer_ids=[task_ii], + task_id=task_ii, + ) + single_task_inference_end_time = time.time() + single_task_accuracies[task_ii] = np.mean( + llf_task == test_y[task_ii * 1000 : (task_ii + 1) * 1000] + ) + single_task_inference_times_across_tasks.append( + single_task_inference_end_time - single_task_inference_start_time + ) + + for task_jj in range(task_ii + 1): + multitask_inference_start_time = time.time() + llf_task = progressive_learner.predict( + X=test_x[task_jj * 1000 : (task_jj + 1) * 1000, :], task_id=task_jj + ) + multitask_inference_end_time = time.time() + + shifts.append(shift) + tasks.append(task_jj + 1) + base_tasks.append(task_ii + 1) + accuracies_across_tasks.append( + np.mean(llf_task == test_y[task_jj * 1000 : (task_jj + 1) * 1000]) + ) + multitask_inference_times_across_tasks.append( + multitask_inference_end_time - multitask_inference_start_time + ) + + df["data_fold"] = shifts + df["task"] = tasks + df["base_task"] = base_tasks + df["accuracy"] = accuracies_across_tasks + df["multitask_inference_times"] = multitask_inference_times_across_tasks + + df_single_task = pd.DataFrame() + df_single_task["task"] = range(1, 11) + df_single_task["data_fold"] = shift + df_single_task["accuracy"] = single_task_accuracies + df_single_task[ + "single_task_inference_times" + ] = single_task_inference_times_across_tasks + df_single_task["train_times"] = train_times_across_tasks + df_single_task["model_size"] = model_size + + summary = (df, df_single_task) + file_to_save = ( + "result/result/increased_sample_" + + model + + str(ntrees) + + "_" + + str(shift) + + "_" + + str(slot) + + ".pickle" + ) + with open(file_to_save, "wb") as f: + pickle.dump(summary, f) + + +#%% +def cross_val_data(data_x, data_y, num_points_per_task, total_task=10, shift=1): + x = data_x.copy() + y = data_y.copy() + idx = [np.where(data_y == u)[0] for u in np.unique(data_y)] + + batch_per_task = 5000 // num_points_per_task + sample_per_class = num_points_per_task // total_task + test_data_slot = 100 // batch_per_task + + for task in range(total_task): + for batch in range(batch_per_task): + for class_no in range(task * 10, (task + 1) * 10, 1): + indx = np.roll(idx[class_no], (shift - 1) * 100) + + if batch == 0 and class_no == 0 and task == 0: + train_x = x[ + indx[batch * sample_per_class : (batch + 1) * sample_per_class], + :, + ] + train_y = y[ + indx[batch * sample_per_class : (batch + 1) * sample_per_class] + ] + test_x = x[ + indx[ + batch * test_data_slot + + 500 : (batch + 1) * test_data_slot + + 500 + ], + :, + ] + test_y = y[ + indx[ + batch * test_data_slot + + 500 : (batch + 1) * test_data_slot + + 500 + ] + ] + else: + train_x = np.concatenate( + ( + train_x, + x[ + indx[ + batch + * sample_per_class : (batch + 1) + * sample_per_class + ], + :, + ], + ), + axis=0, + ) + train_y = np.concatenate( + ( + train_y, + y[ + indx[ + batch + * sample_per_class : (batch + 1) + * sample_per_class + ] + ], + ), + axis=0, + ) + test_x = np.concatenate( + ( + test_x, + x[ + indx[ + batch * test_data_slot + + 500 : (batch + 1) * test_data_slot + + 500 + ], + :, + ], + ), + axis=0, + ) + test_y = np.concatenate( + ( + test_y, + y[ + indx[ + batch * test_data_slot + + 500 : (batch + 1) * test_data_slot + + 500 + ] + ], + ), + axis=0, + ) + + return train_x, train_y, test_x, test_y + + +#%% +def run_parallel_exp( + data_x, data_y, n_trees, model, num_points_per_task, slot=0, shift=1 +): + train_x, train_y, test_x, test_y = cross_val_data(data_x, data_y, 500, shift=shift) + + if model == "dnn": + config = tf.compat.v1.ConfigProto() + config.gpu_options.allow_growth = True + sess = tf.compat.v1.Session(config=config) + with tf.device("/gpu:" + str(shift % 4)): + LF_experiment( + train_x, + train_y, + test_x, + test_y, + n_trees, + shift, + slot, + model, + num_points_per_task, + acorn=12345, + ) + else: + LF_experiment( + train_x, + train_y, + test_x, + test_y, + n_trees, + shift, + slot, + model, + num_points_per_task, + acorn=12345, + ) + + +#%% +### MAIN HYPERPARAMS ### +model = "dnn" +num_points_per_task = 500 +total_slots = 1 # 5000//num_points_per_task +########################### + +(X_train, y_train), (X_test, y_test) = keras.datasets.cifar100.load_data() +data_x = np.concatenate([X_train, X_test]) +if model == "uf": + data_x = data_x.reshape( + (data_x.shape[0], data_x.shape[1] * data_x.shape[2] * data_x.shape[3]) + ) +data_y = np.concatenate([y_train, y_test]) +data_y = data_y[:, 0] + + +#%% +if model == "uf": + slot_fold = range(total_slots) + shift_fold = range(1, 7, 1) + n_trees = [10] + iterable = product(n_trees, shift_fold, slot_fold) + Parallel(n_jobs=-2, verbose=1)( + delayed(run_parallel_exp)( + data_x, data_y, ntree, model, num_points_per_task, slot=slot, shift=shift + ) + for ntree, shift, slot in iterable + ) +elif model == "dnn": + slot_fold = range(total_slots) + + def perform_shift(shift_slot_tuple): + shift, slot = shift_slot_tuple + return run_parallel_exp( + data_x, data_y, 0, model, num_points_per_task, slot=slot, shift=shift + ) + + print("Performing Stage 1 Shifts") + stage_1_shifts = range(1, 5) + stage_1_iterable = product(stage_1_shifts, slot_fold) + with Pool(4) as p: + p.map(perform_shift, stage_1_iterable) + + print("Performing Stage 2 Shifts") + stage_2_shifts = range(5, 7) + stage_2_iterable = product(stage_2_shifts, slot_fold) + with Pool(4) as p: + p.map(perform_shift, stage_2_iterable) diff --git a/docs/experiments.rst b/docs/experiments.rst index 94e619049d..69c80990ba 100644 --- a/docs/experiments.rst +++ b/docs/experiments.rst @@ -16,6 +16,7 @@ The following experiments illustrate specific tests using the ``ProgLearn`` pack experiments/recruitment_across_datasets experiments/spiral_exp experiments/spoken_digit_exp + experiments/streaming_forest_tutorial experiments/xor_rxor_exp experiments/xor_rxor_with_cpd experiments/xor_rxor_with_icp diff --git a/docs/experiments/functions/streaming_spirals_functions.py b/docs/experiments/functions/streaming_spirals_functions.py new file mode 100644 index 0000000000..59d945c1a3 --- /dev/null +++ b/docs/experiments/functions/streaming_spirals_functions.py @@ -0,0 +1,589 @@ +from proglearn.forest import LifelongClassificationForest +from sdtf import StreamDecisionForest +import matplotlib.pyplot as plt +from matplotlib.ticker import ScalarFormatter +import numpy as np +import seaborn as sns +from joblib import Parallel, delayed +from proglearn.sims import generate_spirals +from math import ceil, log2 + + +def plot_spirals(spiral1, y_spiral1, num_spirals1, spiral2, y_spiral2, num_spirals2): + """ + plots spiral 1 and spiral 2 + """ + colors = sns.color_palette("Dark2", n_colors=5) + + fig, ax = plt.subplots(1, 2, figsize=(16, 8)) + + clr = [colors[i] for i in y_spiral1] + ax[0].scatter(spiral1[:, 0], spiral1[:, 1], c=clr, s=50) + ax[0].set_xticks([]) + ax[0].set_yticks([]) + ax[0].set_title(str(num_spirals1) + " spirals", fontsize=30) + ax[0].axis("off") + + clr = [colors[i] for i in y_spiral2] + ax[1].scatter(spiral2[:, 0], spiral2[:, 1], c=clr, s=50) + ax[1].set_xticks([]) + ax[1].set_yticks([]) + ax[1].set_title(str(num_spirals2) + " spirals", fontsize=30) + ax[1].axis("off") + + +def run_spiral_experiments(mc_rep): + """ + A function to run the spirals experiment in streaming and batch settings + """ + # generate all results + stream_spiral_errors = run_experiment_stream(mc_rep) + batch_spiral_error, batch_spiral_le = run_batch_experiment(mc_rep) + # format for plotting + streaming_spiral_errors, streaming_spiral_efficiencies = get_learning_efficiencies( + stream_spiral_errors + ) + spiral_results = [ + streaming_spiral_errors, + streaming_spiral_efficiencies, + batch_spiral_error, + batch_spiral_le, + ] + + return spiral_results + + +def run_experiment_stream(mc_rep): + mean_errors = experiment_stream() + for i in range(mc_rep - 1): + mean_errors += experiment_stream() + mean_errors = mean_errors / mc_rep + return mean_errors + + +def get_learning_efficiencies(stream_errors): + stream_synf_FLE = stream_errors[2, :] / stream_errors[6, :] + sdf_FLE = stream_errors[5, :] / stream_errors[7, :] + stream_synf_BLE = stream_errors[0, :] / stream_errors[1, :] + sdf_BLE = stream_errors[3, :] / stream_errors[4, :] + errors = [stream_errors[1], stream_errors[6], stream_errors[4], stream_errors[7]] + learning_efficiencies = [stream_synf_FLE, sdf_FLE, stream_synf_BLE, sdf_BLE] + return errors, learning_efficiencies + + +def experiment_stream( + n_task1=750, + n_task2=750, + n_update=25, + n_test=1000, + n_trees=10, +): + """ + A function to do stream SynF and stream decision forest experiment + between two tasks where the data is generated using generate spirals. + """ + errors = np.zeros((8, ((n_task1 + n_task2) // n_update) - 1), dtype=float) + + # instantiate classifiers + synf_single_task_t1 = LifelongClassificationForest(default_n_estimators=n_trees) + synf_multi_task = LifelongClassificationForest(default_n_estimators=n_trees) + synf_single_task_t2 = LifelongClassificationForest(default_n_estimators=n_trees) + sdf_single_task_t1 = StreamDecisionForest(n_estimators=n_trees) + sdf_multi_task = StreamDecisionForest(n_estimators=n_trees) + sdf_single_task_t2 = StreamDecisionForest(n_estimators=n_trees) + + # generate initial data for add_task + x1, y1 = generate_spirals(n_update, 3, noise=0.8) + x2, y2 = generate_spirals(n_update, 5, noise=0.4) + x1_test, y1_test = generate_spirals(n_test, 3, noise=0.8) + x2_test, y2_test = generate_spirals(n_test, 5, noise=0.4) + + # add tasks to progressive learners/decision forests + synf_single_task_t1.add_task(x1, y1, task_id=0, classes=[0, 1, 2]) + synf_multi_task.add_task(x1, y1, task_id=0, classes=[0, 1, 2]) + sdf_single_task_t1.partial_fit(x1, y1, classes=[0, 1, 2, 3, 4]) + sdf_multi_task.partial_fit(x1, y1, classes=[0, 1, 2, 3, 4]) + + # updating task 1 + for i in range(n_task1 // n_update - 1): + x, y = generate_spirals(n_update, 3, noise=0.8) + synf_single_task_t1.update_task(x, y, task_id=0) + synf_multi_task.update_task(x, y, task_id=0) + sdf_single_task_t1.partial_fit(x, y) + sdf_multi_task.partial_fit(x, y) + synf_t1_y_hat = synf_single_task_t1.predict(x1_test, task_id=0) + synf_multi_y_hat = synf_multi_task.predict(x1_test, task_id=0) + sdf_t1_y_hat = sdf_single_task_t1.predict(x1_test) + sdf_multi_y_hat = sdf_multi_task.predict(x1_test) + errors[0, i] = 1 - np.mean(synf_t1_y_hat == y1_test) # synf single task, t1 + errors[1, i] = 1 - np.mean(synf_multi_y_hat == y1_test) # synf multi task t1 + errors[2, i] = 0.2 # synf single task, t2 + errors[3, i] = 1 - np.mean(sdf_t1_y_hat == y1_test) # sdf single task, t1 + errors[4, i] = 1 - np.mean(sdf_multi_y_hat == y1_test) # sdf multi task, t1 + errors[5, i] = 0.2 # sdf single task, t2 + errors[6, i] = 0.2 # synf multi task, t2 + errors[7, i] = 0.2 # sdf multi task, t2 + + idx = (n_task1 // n_update) - 1 + # updating task 2 + synf_multi_task.add_task(x2, y2, task_id=1, classes=[0, 1, 2, 3, 4]) + synf_single_task_t2.add_task(x2, y2, task_id=1, classes=[0, 1, 2, 3, 4]) + sdf_single_task_t2.partial_fit(x2, y2, classes=[0, 1, 2, 3, 4]) + sdf_multi_task.partial_fit(x2, y2, classes=[0, 1, 2, 3, 4]) + + synf_t1_y_hat = synf_single_task_t1.predict(x1_test, task_id=0) + synf_t2_y_hat = synf_single_task_t2.predict(x2_test, task_id=1) + synf_multi_y_hat_t1 = synf_multi_task.predict(x1_test, task_id=0) + synf_multi_y_hat_t2 = synf_multi_task.predict(x2_test, task_id=1) + sdf_t1_y_hat = sdf_single_task_t1.predict(x1_test) + sdf_t2_y_hat = sdf_single_task_t2.predict(x2_test) + sdf_multi_y_hat_t1 = sdf_multi_task.predict(x1_test) + sdf_multi_y_hat_t2 = sdf_multi_task.predict(x2_test) + + errors[0, idx] = 1 - np.mean(synf_t1_y_hat == y1_test) # synf single task, t1 + errors[1, idx] = 1 - np.mean(synf_multi_y_hat_t1 == y1_test) # synf multi task t1 + errors[2, idx] = 1 - np.mean(synf_t2_y_hat == y2_test) # synf single task, t2 + errors[3, idx] = 1 - np.mean(sdf_t1_y_hat == y1_test) # sdf single task, t1 + errors[4, idx] = 1 - np.mean(sdf_multi_y_hat_t1 == y1_test) # sdf multi task, t1 + errors[5, idx] = 1 - np.mean(sdf_t2_y_hat == y2_test) # sdf single task, t2 + errors[6, idx] = 1 - np.mean(synf_multi_y_hat_t2 == y2_test) # synf multi task, t2 + errors[7, idx] = 1 - np.mean(sdf_multi_y_hat_t2 == y2_test) # sdf multi task, t2 + for i in range(n_task2 // n_update - 1): + x, y = generate_spirals(n_update, 5, noise=0.4) + synf_multi_task.update_task(x, y, task_id=1) + synf_single_task_t2.update_task(x, y, task_id=1) + sdf_single_task_t2.partial_fit(x, y) + sdf_multi_task.partial_fit(x, y) + synf_t1_y_hat = synf_single_task_t1.predict(x1_test, task_id=0) + synf_t2_y_hat = synf_single_task_t2.predict(x2_test, task_id=1) + synf_multi_y_hat_t1 = synf_multi_task.predict(x1_test, task_id=0) + synf_multi_y_hat_t2 = synf_multi_task.predict(x2_test, task_id=1) + sdf_t1_y_hat = sdf_single_task_t1.predict(x1_test) + sdf_t2_y_hat = sdf_single_task_t2.predict(x2_test) + sdf_multi_y_hat_t1 = sdf_multi_task.predict(x1_test) + sdf_multi_y_hat_t2 = sdf_multi_task.predict(x2_test) + + errors[0, i + idx + 1] = 1 - np.mean( + synf_t1_y_hat == y1_test + ) # synf single task, t1 + errors[1, i + idx + 1] = 1 - np.mean( + synf_multi_y_hat_t1 == y1_test + ) # synf multi task t1 + errors[2, i + idx + 1] = 1 - np.mean( + synf_t2_y_hat == y2_test + ) # synf single task, t2 + errors[3, i + idx + 1] = 1 - np.mean( + sdf_t1_y_hat == y1_test + ) # sdf single task, t1 + errors[4, i + idx + 1] = 1 - np.mean( + sdf_multi_y_hat_t1 == y1_test + ) # sdf multi task, t1 + errors[5, i + idx + 1] = 1 - np.mean( + sdf_t2_y_hat == y2_test + ) # sdf single task, t2 + errors[6, i + idx + 1] = 1 - np.mean( + synf_multi_y_hat_t2 == y2_test + ) # synf multi task, t2 + errors[7, i + idx + 1] = 1 - np.mean( + sdf_multi_y_hat_t2 == y2_test + ) # sdf multi task, t2 + + return errors + + +def experiment_batch( + n_task1=750, + n_task2=750, + n_test=1000, + n_trees=10, + max_depth=None, + random_state=None, +): + + if n_task1 == 0 and n_task2 == 0: + raise ValueError("Wake up and provide samples to train!!!") + + if random_state != None: + np.random.seed(random_state) + + errors = np.zeros(6, dtype=float) + + progressive_learner = LifelongClassificationForest(default_n_estimators=n_trees) + uf1 = LifelongClassificationForest(default_n_estimators=n_trees) + naive_uf = LifelongClassificationForest(default_n_estimators=n_trees) + uf2 = LifelongClassificationForest(default_n_estimators=n_trees) + + # source data + X_task1, y_task1 = generate_spirals(n_task1, 3, noise=0.8) + test_task1, test_label_task1 = generate_spirals(n_test, 3, noise=0.8) + + # target data + X_task2, y_task2 = generate_spirals(n_task2, 5, noise=0.4) + test_task2, test_label_task2 = generate_spirals(n_test, 5, noise=0.4) + + if n_task1 == 0: + progressive_learner.add_task(X_task2, y_task2, n_estimators=n_trees) + uf2.add_task(X_task2, y_task2, n_estimators=n_trees) + + errors[0] = 0.5 + errors[1] = 0.5 + + uf_task2 = uf2.predict(test_task2, task_id=0) + l2f_task2 = progressive_learner.predict(test_task2, task_id=0) + + errors[2] = 1 - np.mean(uf_task2 == test_label_task2) + errors[3] = 1 - np.mean(l2f_task2 == test_label_task2) + + errors[4] = 0.5 + errors[5] = 1 - np.mean(uf_task2 == test_label_task2) + elif n_task2 == 0: + progressive_learner.add_task(X_task1, y_task1, n_estimators=n_trees) + uf1.add_task(X_task1, y_task1, n_estimators=n_trees) + + uf_task1 = uf1.predict(test_task1, task_id=0) + l2f_task1 = progressive_learner.predict(test_task1, task_id=0) + + errors[0] = 1 - np.mean(uf_task1 == test_label_task1) + errors[1] = 1 - np.mean(l2f_task1 == test_label_task1) + + errors[2] = 0.5 + errors[3] = 0.5 + + errors[4] = 1 - np.mean(uf_task1 == test_label_task1) + errors[5] = 0.5 + else: + progressive_learner.add_task(X_task1, y_task1, n_estimators=n_trees) + progressive_learner.add_task(X_task2, y_task2, n_estimators=n_trees) + + uf1.add_task(X_task1, y_task1, n_estimators=2 * n_trees) + uf2.add_task(X_task2, y_task2, n_estimators=2 * n_trees) + + naive_uf_train_x = np.concatenate((X_task1, X_task2), axis=0) + naive_uf_train_y = np.concatenate((y_task1, y_task2), axis=0) + naive_uf.add_task(naive_uf_train_x, naive_uf_train_y, n_estimators=n_trees) + + uf_task1 = uf1.predict(test_task1, task_id=0) + l2f_task1 = progressive_learner.predict(test_task1, task_id=0) + uf_task2 = uf2.predict(test_task2, task_id=0) + l2f_task2 = progressive_learner.predict(test_task2, task_id=1) + naive_uf_task1 = naive_uf.predict(test_task1, task_id=0) + naive_uf_task2 = naive_uf.predict(test_task2, task_id=0) + + errors[0] = 1 - np.mean(uf_task1 == test_label_task1) + errors[1] = 1 - np.mean(l2f_task1 == test_label_task1) + errors[2] = 1 - np.mean(uf_task2 == test_label_task2) + errors[3] = 1 - np.mean(l2f_task2 == test_label_task2) + errors[4] = 1 - np.mean(naive_uf_task1 == test_label_task1) + errors[5] = 1 - np.mean(naive_uf_task2 == test_label_task2) + + return errors + + +def run_batch_experiment(mc_rep): + n_test = 1000 + n_trees = 10 + n_xor = (100 * np.arange(0.25, 7.50, step=0.25)).astype(int) + n_xnor = (100 * np.arange(0.25, 7.75, step=0.25)).astype(int) + mean_error = np.zeros((6, len(n_xor) + len(n_xnor))) + std_error = np.zeros((6, len(n_xor) + len(n_xnor))) + mean_te = np.zeros((4, len(n_xor) + len(n_xnor))) + std_te = np.zeros((4, len(n_xor) + len(n_xnor))) + for i, n1 in enumerate(n_xor): + # run experiment in parallel + error = np.array( + Parallel(n_jobs=1, verbose=0)( + delayed(experiment_batch)(n1, 0, max_depth=ceil(log2(n1))) + for _ in range(mc_rep) + ) + ) + # extract relevant data and store in arrays + mean_error[:, i] = np.mean(error, axis=0) + std_error[:, i] = np.std(error, ddof=1, axis=0) + mean_te[0, i] = np.mean(error[:, 0]) / np.mean(error[:, 1]) + mean_te[1, i] = np.mean(error[:, 2]) / np.mean(error[:, 3]) + mean_te[2, i] = np.mean(error[:, 0]) / np.mean(error[:, 4]) + mean_te[3, i] = np.mean(error[:, 2]) / np.mean(error[:, 5]) + + # initialize learning on n-xor data + if n1 == n_xor[-1]: + for j, n2 in enumerate(n_xnor): + # run experiment in parallel + error = np.array( + Parallel(n_jobs=1, verbose=0)( + delayed(experiment_batch)(n1, n2, max_depth=ceil(log2(750))) + for _ in range(mc_rep) + ) + ) + # extract relevant data and store in arrays + mean_error[:, i + j + 1] = np.mean(error, axis=0) + std_error[:, i + j + 1] = np.std(error, ddof=1, axis=0) + mean_te[0, i + j + 1] = np.mean(error[:, 0]) / np.mean(error[:, 1]) + mean_te[1, i + j + 1] = np.mean(error[:, 2]) / np.mean(error[:, 3]) + mean_te[2, i + j + 1] = np.mean(error[:, 0]) / np.mean(error[:, 4]) + mean_te[3, i + j + 1] = np.mean(error[:, 2]) / np.mean(error[:, 5]) + + return mean_error, mean_te + + +def plot_error(results): + """Plot Generalization Errors for experiment type (RXOR or XNOR)""" + algorithms = [ + "Stream Synergistic Forest", + "Stream Decision Forest", + "Batch Synergistic Forest", + "Batch Decision Forest", + ] + fontsize = 30 + labelsize = 28 + ls = ["-", "--"] + colors = sns.color_palette("bright") + fig = plt.figure(figsize=(26, 14)) + gs = fig.add_gridspec(14, 26) + ax1 = fig.add_subplot(gs[7:, :5]) + # Stream Synergistic Forest XOR + ax1.plot( + (100 * np.arange(0.25, 15, step=0.25)).astype(int), + results[0][0], + label=algorithms[0], + c=colors[3], + ls=ls[1], + lw=3, + ) + # Stream Decision Forest XOR + ax1.plot( + (100 * np.arange(0.25, 15, step=0.25)).astype(int), + results[0][2], + label=algorithms[1], + c=colors[2], + ls=ls[1], + lw=3, + ) + # Batch Synergistic Forest XOR + ax1.plot( + (100 * np.arange(0.25, 15, step=0.25)).astype(int), + results[2][1], + label=algorithms[2], + c=colors[3], + ls=ls[0], + lw=3, + ) + # Batch Decision Forest XOR + ax1.plot( + (100 * np.arange(0.25, 15, step=0.25)).astype(int), + results[2][4], + label=algorithms[3], + c=colors[2], + ls=ls[0], + lw=3, + ) + + ax1.set_ylabel("Generalization Error (3 spirals)", fontsize=fontsize) + ax1.set_xlabel("Total Sample Size", fontsize=fontsize) + ax1.tick_params(labelsize=labelsize) + # ax1.set_yscale("log") + ax1.yaxis.set_major_formatter(ScalarFormatter()) + ax1.set_yticks([0.25, 0.45, 0.65, 0.85]) + ax1.set_xticks([0, 750, 1500]) + ax1.axvline(x=750, c="gray", linewidth=1.5, linestyle="dashed") + ax1.axvline(x=1500, c="gray", linewidth=1.5, linestyle="dashed") + + right_side = ax1.spines["right"] + right_side.set_visible(False) + top_side = ax1.spines["top"] + top_side.set_visible(False) + + ax1.text(75, np.mean(ax1.get_ylim()) + 0.35, "3 spirals", fontsize=26) + ax1.text(850, np.mean(ax1.get_ylim()) + 0.35, "5 spirals", fontsize=26) + + ######## RXOR + ax1 = fig.add_subplot(gs[7:, 7:12]) + rxor_range = (100 * np.arange(0.25, 15, step=0.25)).astype(int)[30:] + # Stream Synergistic Forest RXOR + ax1.plot( + rxor_range, + results[0][1][30:], + label=algorithms[0], + c=colors[3], + ls=ls[1], + lw=3, + ) + # Stream Decision Forest RXOR + ax1.plot( + rxor_range, + results[0][3][30:], + label=algorithms[1], + c=colors[2], + ls=ls[1], + lw=3, + ) + # Batch Synergistic Forest RXOR + ax1.plot( + rxor_range, + results[2][3][30:], + label=algorithms[2], + c=colors[3], + ls=ls[0], + lw=3, + ) + # Batch Decision Forest RXOR + ax1.plot( + rxor_range, + results[2][5][30:], + label=algorithms[3], + c=colors[2], + ls=ls[0], + lw=3, + ) + ax1.set_ylabel("Generalization Error (5 spirals)", fontsize=fontsize) + ax1.legend( + bbox_to_anchor=(1, -0.25), + loc="upper center", + fontsize=20, + ncol=4, + frameon=False, + ) + ax1.set_xlabel("Total Sample Size", fontsize=fontsize) + ax1.tick_params(labelsize=labelsize) + # ax1.set_yscale("log") + ax1.yaxis.set_major_formatter(ScalarFormatter()) + ax1.set_yticks([0.25, 0.45, 0.65, 0.85]) + ax1.set_xticks([0, 750, 1500]) + ax1.axvline(x=750, c="gray", linewidth=1.5, linestyle="dashed") + ax1.axvline(x=1500, c="gray", linewidth=1.5, linestyle="dashed") + right_side = ax1.spines["right"] + right_side.set_visible(False) + top_side = ax1.spines["top"] + top_side.set_visible(False) + + ax1.text(75, np.mean(ax1.get_ylim()) + 0.4, "3 spirals", fontsize=26) + ax1.text(850, np.mean(ax1.get_ylim()) + 0.4, "5 spirals", fontsize=26) + + #### Transfer Efficiency + ax1 = fig.add_subplot(gs[7:, 14:19]) + algorithms = [ + "Stream Synergistic Forest TE", + "Stream Decision Forest TE", + "Batch Synergistic Forest TE", + "Batch Decision Forest TE", + ] + rxor_range = (100 * np.arange(0.25, 15, step=0.25)).astype(int)[30:] + # Stream Synergistic Forest RXOR + ax1.plot( + rxor_range, + np.log(results[1][0][30:]), + label=algorithms[0], + c=colors[3], + ls=ls[1], + lw=3, + ) + # Stream Decision Forest RXOR + ax1.plot( + rxor_range, + np.log(results[1][1][30:]), + label=algorithms[1], + c=colors[2], + ls=ls[1], + lw=3, + ) + # Batch Synergistic Forest RXOR + ax1.plot( + rxor_range, + np.log(results[3][1][30:]), + label=algorithms[2], + c=colors[3], + ls=ls[0], + lw=3, + ) + # Batch Decision Forest RXOR + ax1.plot( + rxor_range, + np.log(results[3][3][30:]), + label=algorithms[3], + c=colors[2], + ls=ls[0], + lw=3, + ) + + ax1.set_ylabel("Log Forward Learning Efficiency", fontsize=fontsize) + ax1.set_xlabel("Total Sample Size", fontsize=fontsize) + ax1.tick_params(labelsize=labelsize) + # ax1.set_yscale("log") + ax1.yaxis.set_major_formatter(ScalarFormatter()) + ax1.set_yticks([-1, 0, 1]) + ax1.set_xlim(-1, 1) + ax1.set_xticks([0, 750, 1500]) + ax1.axvline(x=750, c="gray", linewidth=1.5, linestyle="dashed") + ax1.axvline(x=1500, c="gray", linewidth=1.5, linestyle="dashed") + right_side = ax1.spines["right"] + right_side.set_visible(False) + top_side = ax1.spines["top"] + top_side.set_visible(False) + ax1.axhline(y=0, c="gray", linewidth=1.5, linestyle="dashed") + + ax1.text(75, np.mean(ax1.get_ylim()) + 1.1, "3 Spirals", fontsize=26) + ax1.text(850, np.mean(ax1.get_ylim()) + 1.1, "5 spirals ", fontsize=26) + + #### BACKWARDS Transfer Efficiency + ax1 = fig.add_subplot(gs[7:, 21:]) + algorithms = [ + "Stream Synergistic Forest TE", + "Stream Decision Forest TE", + "Batch Synergistic Forest TE", + "Batch Decision Forest TE", + ] + rxor_range = (100 * np.arange(0.25, 15, step=0.25)).astype(int) + # Stream Synergistic Forest RXOR + ax1.plot( + rxor_range, + np.log(results[1][2]), + label=algorithms[0], + c=colors[3], + ls=ls[1], + lw=3, + ) + # Stream Decision Forest RXOR + ax1.plot( + rxor_range, + np.log(results[1][3]), + label=algorithms[1], + c=colors[2], + ls=ls[1], + lw=3, + ) + # Batch Synergistic Forest RXOR + ax1.plot( + rxor_range, + np.log(results[3][0]), + label=algorithms[2], + c=colors[3], + ls=ls[0], + lw=3, + ) + # Batch Decision Forest RXOR + ax1.plot( + rxor_range, + np.log(results[3][2]), + label=algorithms[3], + c=colors[2], + ls=ls[0], + lw=3, + ) + + ax1.set_ylabel("Log Backward Learning Efficiency", fontsize=fontsize) + ax1.set_xlabel("Total Sample Size", fontsize=fontsize) + ax1.tick_params(labelsize=labelsize) + # ax1.set_yscale("log") + ax1.yaxis.set_major_formatter(ScalarFormatter()) + ax1.set_yticks([-1, 0, 1]) + ax1.set_xlim(-1, 1) + ax1.set_xticks([25, 750, 1500]) + ax1.axvline(x=750, c="gray", linewidth=1.5, linestyle="dashed") + ax1.axvline(x=1500, c="gray", linewidth=1.5, linestyle="dashed") + right_side = ax1.spines["right"] + right_side.set_visible(False) + top_side = ax1.spines["top"] + top_side.set_visible(False) + ax1.axhline(y=0, c="gray", linewidth=1.5, linestyle="dashed") + + ax1.text(75, np.mean(ax1.get_ylim()) + 1.1, "3 Spirals", fontsize=26) + ax1.text(850, np.mean(ax1.get_ylim()) + 1.1, "5 spirals", fontsize=26) diff --git a/docs/experiments/functions/streaming_xor_functions.py b/docs/experiments/functions/streaming_xor_functions.py new file mode 100644 index 0000000000..de59d62add --- /dev/null +++ b/docs/experiments/functions/streaming_xor_functions.py @@ -0,0 +1,632 @@ +from proglearn.forest import LifelongClassificationForest +from sdtf import StreamDecisionForest +import matplotlib.pyplot as plt +from matplotlib.ticker import ScalarFormatter +import numpy as np +import seaborn as sns +from joblib import Parallel, delayed +from proglearn.sims import generate_gaussian_parity +from math import ceil, log2 + + +def run_gaussian_experiments(mc_rep): + """ + A function to run both Gaussian R-XOR and XNOR experiments in streaming and batch settings + """ + # generate all results + stream_rxor_errors = run_experiment_stream(mc_rep, task2_angle=np.pi / 4) + stream_xnor_errors = run_experiment_stream(mc_rep, task2_angle=np.pi / 2) + batch_xnor_error, batch_xnor_le = run_batch_experiment(mc_rep, t2_angle=np.pi / 2) + batch_rxor_error, batch_rxor_le = run_batch_experiment(mc_rep, t2_angle=np.pi / 4) + # format for plotting + streaming_rxor_errors, streaming_rxor_efficiencies = get_learning_efficiencies( + stream_rxor_errors + ) + streaming_xnor_errors, streaming_xnor_efficiencies = get_learning_efficiencies( + stream_xnor_errors + ) + rxor_results = [ + streaming_rxor_errors, + streaming_rxor_efficiencies, + batch_rxor_error, + batch_rxor_le, + ] + xnor_results = [ + streaming_xnor_errors, + streaming_xnor_efficiencies, + batch_xnor_error, + batch_xnor_le, + ] + return rxor_results, xnor_results + + +def run_experiment_stream(mc_rep, task2_angle): + mean_errors = experiment_stream(task2_angle=task2_angle) + for i in range(mc_rep - 1): + mean_errors += experiment_stream(task2_angle=task2_angle) + mean_errors = mean_errors / mc_rep + return mean_errors + + +def get_learning_efficiencies(stream_errors): + """ + Returns + ---------- + errors: SynF task 1, Synf task 2, SDF task 1, SDF task 2 + learning_efficiencies: SynF FLE, SDF FLE, SynF BLE, SDF BLE + """ + stream_synf_FLE = stream_errors[2, :] / stream_errors[6, :] + sdf_FLE = stream_errors[5, :] / stream_errors[7, :] + stream_synf_BLE = stream_errors[0, :] / stream_errors[1, :] + sdf_BLE = stream_errors[3, :] / stream_errors[4, :] + errors = [stream_errors[1], stream_errors[6], stream_errors[4], stream_errors[7]] + learning_efficiencies = [stream_synf_FLE, sdf_FLE, stream_synf_BLE, sdf_BLE] + return errors, learning_efficiencies + + +def experiment_stream( + n_task1=750, + n_task2=750, + n_update=25, + n_test=1000, + task2_angle=np.pi / 2, + n_trees=10, +): + """ + A function to do stream SynF and stream decision forest experiment + between two tasks where the data is generated using Gaussian parity. + """ + errors = np.zeros((8, ((n_task1 + n_task2) // n_update) - 1), dtype=float) + + # instantiate classifiers + synf_single_task_t1 = LifelongClassificationForest(default_n_estimators=n_trees) + synf_multi_task = LifelongClassificationForest(default_n_estimators=n_trees) + synf_single_task_t2 = LifelongClassificationForest(default_n_estimators=n_trees) + sdf_single_task_t1 = StreamDecisionForest(n_estimators=n_trees) + sdf_multi_task = StreamDecisionForest(n_estimators=n_trees) + sdf_single_task_t2 = StreamDecisionForest(n_estimators=n_trees) + + # generate initial data for add_task + x1, y1 = generate_gaussian_parity(n_update) + x2, y2 = generate_gaussian_parity(n_update, angle_params=task2_angle) + x1_test, y1_test = generate_gaussian_parity(1000) + x2_test, y2_test = generate_gaussian_parity(1000, angle_params=task2_angle) + + # add tasks to progressive learners/decision forests + synf_single_task_t1.add_task(x1, y1, task_id=0, classes=[0, 1]) + synf_multi_task.add_task(x1, y1, task_id=0, classes=[0, 1]) + sdf_single_task_t1.partial_fit(x1, y1, classes=[0, 1]) + sdf_multi_task.partial_fit(x1, y1, classes=[0, 1]) + + # updating task 1 + for i in range(n_task1 // n_update - 1): + x, y = generate_gaussian_parity(n_update) + synf_single_task_t1.update_task(x, y, task_id=0) + synf_multi_task.update_task(x, y, task_id=0) + sdf_single_task_t1.partial_fit(x, y) + sdf_multi_task.partial_fit(x, y) + synf_t1_y_hat = synf_single_task_t1.predict(x1_test, task_id=0) + synf_multi_y_hat = synf_multi_task.predict(x1_test, task_id=0) + sdf_t1_y_hat = sdf_single_task_t1.predict(x1_test) + sdf_multi_y_hat = sdf_multi_task.predict(x1_test) + errors[0, i] = 1 - np.mean(synf_t1_y_hat == y1_test) # synf single task, t1 + errors[1, i] = 1 - np.mean(synf_multi_y_hat == y1_test) # synf multi task t1 + errors[2, i] = 0.5 # synf single task, t2 + errors[3, i] = 1 - np.mean(sdf_t1_y_hat == y1_test) # sdf single task, t1 + errors[4, i] = 1 - np.mean(sdf_multi_y_hat == y1_test) # sdf multi task, t1 + errors[5, i] = 0.5 # sdf single task, t2 + errors[6, i] = 0.5 # synf multi task, t2 + errors[7, i] = 0.5 # sdf multi task, t2 + + idx = (n_task1 // n_update) - 1 + # updating task 2 + synf_multi_task.add_task(x2, y2, task_id=1, classes=[0, 1]) + synf_single_task_t2.add_task(x2, y2, task_id=1, classes=[0, 1]) + sdf_single_task_t2.partial_fit(x2, y2, classes=[0, 1]) + sdf_multi_task.partial_fit(x2, y2, classes=[0, 1]) + + synf_t1_y_hat = synf_single_task_t1.predict(x1_test, task_id=0) + synf_t2_y_hat = synf_single_task_t2.predict(x2_test, task_id=1) + synf_multi_y_hat_t1 = synf_multi_task.predict(x1_test, task_id=0) + synf_multi_y_hat_t2 = synf_multi_task.predict(x2_test, task_id=1) + sdf_t1_y_hat = sdf_single_task_t1.predict(x1_test) + sdf_t2_y_hat = sdf_single_task_t2.predict(x2_test) + sdf_multi_y_hat_t1 = sdf_multi_task.predict(x1_test) + sdf_multi_y_hat_t2 = sdf_multi_task.predict(x2_test) + + errors[0, idx] = 1 - np.mean(synf_t1_y_hat == y1_test) # synf single task, t1 + errors[1, idx] = 1 - np.mean(synf_multi_y_hat_t1 == y1_test) # synf multi task t1 + errors[2, idx] = 1 - np.mean(synf_t2_y_hat == y2_test) # synf single task, t2 + errors[3, idx] = 1 - np.mean(sdf_t1_y_hat == y1_test) # sdf single task, t1 + errors[4, idx] = 1 - np.mean(sdf_multi_y_hat_t1 == y1_test) # sdf multi task, t1 + errors[5, idx] = 1 - np.mean(sdf_t2_y_hat == y2_test) # sdf single task, t2 + errors[6, idx] = 1 - np.mean(synf_multi_y_hat_t2 == y2_test) # synf multi task, t2 + errors[7, idx] = 1 - np.mean(sdf_multi_y_hat_t2 == y2_test) # sdf multi task, t2 + for i in range(n_task2 // n_update - 1): + x, y = generate_gaussian_parity(n_update, angle_params=task2_angle) + synf_multi_task.update_task(x, y, task_id=1) + synf_single_task_t2.update_task(x, y, task_id=1) + sdf_single_task_t2.partial_fit(x, y) + sdf_multi_task.partial_fit(x, y) + synf_t1_y_hat = synf_single_task_t1.predict(x1_test, task_id=0) + synf_t2_y_hat = synf_single_task_t2.predict(x2_test, task_id=1) + synf_multi_y_hat_t1 = synf_multi_task.predict(x1_test, task_id=0) + synf_multi_y_hat_t2 = synf_multi_task.predict(x2_test, task_id=1) + sdf_t1_y_hat = sdf_single_task_t1.predict(x1_test) + sdf_t2_y_hat = sdf_single_task_t2.predict(x2_test) + sdf_multi_y_hat_t1 = sdf_multi_task.predict(x1_test) + sdf_multi_y_hat_t2 = sdf_multi_task.predict(x2_test) + + errors[0, i + idx + 1] = 1 - np.mean( + synf_t1_y_hat == y1_test + ) # synf single task, t1 + errors[1, i + idx + 1] = 1 - np.mean( + synf_multi_y_hat_t1 == y1_test + ) # synf multi task t1 + errors[2, i + idx + 1] = 1 - np.mean( + synf_t2_y_hat == y2_test + ) # synf single task, t2 + errors[3, i + idx + 1] = 1 - np.mean( + sdf_t1_y_hat == y1_test + ) # sdf single task, t1 + errors[4, i + idx + 1] = 1 - np.mean( + sdf_multi_y_hat_t1 == y1_test + ) # sdf multi task, t1 + errors[5, i + idx + 1] = 1 - np.mean( + sdf_t2_y_hat == y2_test + ) # sdf single task, t2 + errors[6, i + idx + 1] = 1 - np.mean( + synf_multi_y_hat_t2 == y2_test + ) # synf multi task, t2 + errors[7, i + idx + 1] = 1 - np.mean( + sdf_multi_y_hat_t2 == y2_test + ) # sdf multi task, t2 + + return errors + + +def experiment_batch( + n_task1=750, + n_task2=750, + n_test=1000, + task1_angle=0, + task2_angle=np.pi / 2, + n_trees=10, + max_depth=None, + random_state=None, +): + + """ + A function to do SynF experiment between two tasks + where the task data is generated using Gaussian parity. + Parameters + ---------- + n_task1 : int + Total number of train sample for task 1. + n_task2 : int + Total number of train dsample for task 2 + n_test : int, optional (default=1000) + Number of test sample for each task. + task1_angle : float, optional (default=0) + Angle in radian for task 1. + task2_angle : float, optional (default=numpy.pi/2) + Angle in radian for task 2. + n_trees : int, optional (default=10) + Number of total trees to train for each task. + max_depth : int, optional (default=None) + Maximum allowable depth for each tree. + random_state : int, RandomState instance, default=None + Determines random number generation for dataset creation. Pass an int + for reproducible output across multiple function calls. + Returns + ------- + errors : array of shape [6] + Elements of the array is organized as single task error task1, + multitask error task1, single task error task2, + multitask error task2, naive UF error task1, + naive UF task2. + """ + + if n_task1 == 0 and n_task2 == 0: + raise ValueError("Wake up and provide samples to train!!!") + + if random_state != None: + np.random.seed(random_state) + + errors = np.zeros(6, dtype=float) + + progressive_learner = LifelongClassificationForest(default_n_estimators=n_trees) + uf1 = LifelongClassificationForest(default_n_estimators=n_trees) + naive_uf = LifelongClassificationForest(default_n_estimators=n_trees) + uf2 = LifelongClassificationForest(default_n_estimators=n_trees) + + # source data + X_task1, y_task1 = generate_gaussian_parity(n_task1, angle_params=task1_angle) + test_task1, test_label_task1 = generate_gaussian_parity( + n_test, angle_params=task1_angle + ) + + # target data + X_task2, y_task2 = generate_gaussian_parity(n_task2, angle_params=task2_angle) + test_task2, test_label_task2 = generate_gaussian_parity( + n_test, angle_params=task2_angle + ) + + if n_task1 == 0: + progressive_learner.add_task(X_task2, y_task2, n_estimators=n_trees) + uf2.add_task(X_task2, y_task2, n_estimators=n_trees) + + errors[0] = 0.5 + errors[1] = 0.5 + + uf_task2 = uf2.predict(test_task2, task_id=0) + l2f_task2 = progressive_learner.predict(test_task2, task_id=0) + + errors[2] = 1 - np.mean(uf_task2 == test_label_task2) + errors[3] = 1 - np.mean(l2f_task2 == test_label_task2) + + errors[4] = 0.5 + errors[5] = 1 - np.mean(uf_task2 == test_label_task2) + elif n_task2 == 0: + progressive_learner.add_task(X_task1, y_task1, n_estimators=n_trees) + uf1.add_task(X_task1, y_task1, n_estimators=n_trees) + + uf_task1 = uf1.predict(test_task1, task_id=0) + l2f_task1 = progressive_learner.predict(test_task1, task_id=0) + + errors[0] = 1 - np.mean(uf_task1 == test_label_task1) + errors[1] = 1 - np.mean(l2f_task1 == test_label_task1) + + errors[2] = 0.5 + errors[3] = 0.5 + + errors[4] = 1 - np.mean(uf_task1 == test_label_task1) + errors[5] = 0.5 + else: + progressive_learner.add_task(X_task1, y_task1, n_estimators=n_trees) + progressive_learner.add_task(X_task2, y_task2, n_estimators=n_trees) + + uf1.add_task(X_task1, y_task1, n_estimators=2 * n_trees) + uf2.add_task(X_task2, y_task2, n_estimators=2 * n_trees) + + naive_uf_train_x = np.concatenate((X_task1, X_task2), axis=0) + naive_uf_train_y = np.concatenate((y_task1, y_task2), axis=0) + naive_uf.add_task(naive_uf_train_x, naive_uf_train_y, n_estimators=n_trees) + + uf_task1 = uf1.predict(test_task1, task_id=0) + l2f_task1 = progressive_learner.predict(test_task1, task_id=0) + uf_task2 = uf2.predict(test_task2, task_id=0) + l2f_task2 = progressive_learner.predict(test_task2, task_id=1) + naive_uf_task1 = naive_uf.predict(test_task1, task_id=0) + naive_uf_task2 = naive_uf.predict(test_task2, task_id=0) + + errors[0] = 1 - np.mean(uf_task1 == test_label_task1) + errors[1] = 1 - np.mean(l2f_task1 == test_label_task1) + errors[2] = 1 - np.mean(uf_task2 == test_label_task2) + errors[3] = 1 - np.mean(l2f_task2 == test_label_task2) + errors[4] = 1 - np.mean(naive_uf_task1 == test_label_task1) + errors[5] = 1 - np.mean(naive_uf_task2 == test_label_task2) + + return errors + + +def run_batch_experiment(mc_rep, t2_angle): + n_test = 1000 + n_trees = 10 + n_xor = (100 * np.arange(0.25, 7.50, step=0.25)).astype(int) + n_xnor = (100 * np.arange(0.25, 7.75, step=0.25)).astype(int) + mean_error = np.zeros((6, len(n_xor) + len(n_xnor))) + std_error = np.zeros((6, len(n_xor) + len(n_xnor))) + mean_te = np.zeros((4, len(n_xor) + len(n_xnor))) + std_te = np.zeros((4, len(n_xor) + len(n_xnor))) + for i, n1 in enumerate(n_xor): + # run experiment in parallel + error = np.array( + Parallel(n_jobs=1, verbose=0)( + delayed(experiment_batch)( + n1, 0, task2_angle=t2_angle, max_depth=ceil(log2(n1)) + ) + for _ in range(mc_rep) + ) + ) + # extract relevant data and store in arrays + mean_error[:, i] = np.mean(error, axis=0) + std_error[:, i] = np.std(error, ddof=1, axis=0) + mean_te[0, i] = np.mean(error[:, 0]) / np.mean(error[:, 1]) + mean_te[1, i] = np.mean(error[:, 2]) / np.mean(error[:, 3]) + mean_te[2, i] = np.mean(error[:, 0]) / np.mean(error[:, 4]) + mean_te[3, i] = np.mean(error[:, 2]) / np.mean(error[:, 5]) + + # initialize learning on n-xor data + if n1 == n_xor[-1]: + for j, n2 in enumerate(n_xnor): + # run experiment in parallel + error = np.array( + Parallel(n_jobs=1, verbose=0)( + delayed(experiment_batch)( + n1, n2, task2_angle=t2_angle, max_depth=ceil(log2(750)) + ) + for _ in range(mc_rep) + ) + ) + # extract relevant data and store in arrays + mean_error[:, i + j + 1] = np.mean(error, axis=0) + std_error[:, i + j + 1] = np.std(error, ddof=1, axis=0) + mean_te[0, i + j + 1] = np.mean(error[:, 0]) / np.mean(error[:, 1]) + mean_te[1, i + j + 1] = np.mean(error[:, 2]) / np.mean(error[:, 3]) + mean_te[2, i + j + 1] = np.mean(error[:, 0]) / np.mean(error[:, 4]) + mean_te[3, i + j + 1] = np.mean(error[:, 2]) / np.mean(error[:, 5]) + + return mean_error, mean_te + + +def plot_error(results, experiment): + """Plot Generalization Errors for experiment type (RXOR or XNOR)""" + algorithms = [ + "Stream Synergistic Forest", + "Stream Decision Forest", + "Batch Synergistic Forest", + "Batch Decision Forest", + ] + fontsize = 30 + labelsize = 28 + ls = ["-", "--"] + colors = sns.color_palette("bright") + fig = plt.figure(figsize=(26, 14)) + gs = fig.add_gridspec(14, 26) + ax1 = fig.add_subplot(gs[7:, :5]) + # Stream Synergistic Forest XOR + ax1.plot( + (100 * np.arange(0.25, 15, step=0.25)).astype(int), + results[0][0], + label=algorithms[0], + c=colors[3], + ls=ls[1], + lw=3, + ) + # Stream Decision Forest XOR + ax1.plot( + (100 * np.arange(0.25, 15, step=0.25)).astype(int), + results[0][2], + label=algorithms[1], + c=colors[2], + ls=ls[1], + lw=3, + ) + # Batch Synergistic Forest XOR + ax1.plot( + (100 * np.arange(0.25, 15, step=0.25)).astype(int), + results[2][1], + label=algorithms[2], + c=colors[3], + ls=ls[0], + lw=3, + ) + # Batch Decision Forest XOR + ax1.plot( + (100 * np.arange(0.25, 15, step=0.25)).astype(int), + results[2][4], + label=algorithms[3], + c=colors[2], + ls=ls[0], + lw=3, + ) + + ax1.set_ylabel("Generalization Error (XOR)", fontsize=fontsize) + ax1.set_xlabel("Total Sample Size", fontsize=fontsize) + ax1.tick_params(labelsize=labelsize) + ax1.set_yscale("log") + ax1.yaxis.set_major_formatter(ScalarFormatter()) + ax1.set_yticks([0.1, 0.3, 0.5, 0.9]) + ax1.set_xticks([0, 750, 1500]) + ax1.axvline(x=750, c="gray", linewidth=1.5, linestyle="dashed") + ax1.axvline(x=1500, c="gray", linewidth=1.5, linestyle="dashed") + + right_side = ax1.spines["right"] + right_side.set_visible(False) + top_side = ax1.spines["top"] + top_side.set_visible(False) + + ax1.text(200, np.mean(ax1.get_ylim()) + 0.5, "XOR", fontsize=26) + ax1.text(850, np.mean(ax1.get_ylim()) + 0.5, experiment, fontsize=26) + + ######## RXOR + ax1 = fig.add_subplot(gs[7:, 7:12]) + rxor_range = (100 * np.arange(0.25, 15, step=0.25)).astype(int)[30:] + # Stream Synergistic Forest RXOR + ax1.plot( + rxor_range, + results[0][1][30:], + label=algorithms[0], + c=colors[3], + ls=ls[1], + lw=3, + ) + # Stream Decision Forest RXOR + ax1.plot( + rxor_range, + results[0][3][30:], + label=algorithms[1], + c=colors[2], + ls=ls[1], + lw=3, + ) + # Batch Synergistic Forest RXOR + ax1.plot( + rxor_range, + results[2][3][30:], + label=algorithms[2], + c=colors[3], + ls=ls[0], + lw=3, + ) + # Batch Decision Forest RXOR + ax1.plot( + rxor_range, + results[2][5][30:], + label=algorithms[3], + c=colors[2], + ls=ls[0], + lw=3, + ) + ax1.set_ylabel("Generalization Error (%s)" % experiment, fontsize=fontsize) + ax1.legend( + bbox_to_anchor=(1, -0.25), + loc="upper center", + fontsize=20, + ncol=4, + frameon=False, + ) + ax1.set_xlabel("Total Sample Size", fontsize=fontsize) + ax1.tick_params(labelsize=labelsize) + ax1.set_yscale("log") + ax1.yaxis.set_major_formatter(ScalarFormatter()) + ax1.set_yticks([0.1, 0.3, 0.5, 0.9]) + ax1.set_xticks([0, 750, 1500]) + ax1.axvline(x=750, c="gray", linewidth=1.5, linestyle="dashed") + ax1.axvline(x=1500, c="gray", linewidth=1.5, linestyle="dashed") + right_side = ax1.spines["right"] + right_side.set_visible(False) + top_side = ax1.spines["top"] + top_side.set_visible(False) + + ax1.text(200, np.mean(ax1.get_ylim()) + 0.5, "XOR", fontsize=26) + ax1.text(850, np.mean(ax1.get_ylim()) + 0.5, experiment, fontsize=26) + + #### Transfer Efficiency + ax1 = fig.add_subplot(gs[7:, 14:19]) + algorithms = [ + "Stream Synergistic Forest TE", + "Stream Decision Forest TE", + "Batch Synergistic Forest TE", + "Batch Decision Forest TE", + ] + rxor_range = (100 * np.arange(0.25, 15, step=0.25)).astype(int)[30:] + # Stream Synergistic Forest RXOR + ax1.plot( + rxor_range, + np.log(results[1][0][30:]), + label=algorithms[0], + c=colors[3], + ls=ls[1], + lw=3, + ) + # Stream Decision Forest RXOR + ax1.plot( + rxor_range, + np.log(results[1][1][30:]), + label=algorithms[1], + c=colors[2], + ls=ls[1], + lw=3, + ) + # Batch Synergistic Forest RXOR + ax1.plot( + rxor_range, + np.log(results[3][1][30:]), + label=algorithms[2], + c=colors[3], + ls=ls[0], + lw=3, + ) + # Batch Decision Forest RXOR + ax1.plot( + rxor_range, + np.log(results[3][3][30:]), + label=algorithms[3], + c=colors[2], + ls=ls[0], + lw=3, + ) + + ax1.set_ylabel("Log Forward Learning Efficiency", fontsize=fontsize) + ax1.set_xlabel("Total Sample Size", fontsize=fontsize) + ax1.tick_params(labelsize=labelsize) + # ax1.set_yscale("log") + ax1.yaxis.set_major_formatter(ScalarFormatter()) + ax1.set_yticks([-1, 0, 1]) + ax1.set_xlim(-1, 1) + ax1.set_xticks([0, 750, 1500]) + ax1.axvline(x=750, c="gray", linewidth=1.5, linestyle="dashed") + ax1.axvline(x=1500, c="gray", linewidth=1.5, linestyle="dashed") + right_side = ax1.spines["right"] + right_side.set_visible(False) + top_side = ax1.spines["top"] + top_side.set_visible(False) + ax1.axhline(y=0, c="gray", linewidth=1.5, linestyle="dashed") + + if experiment == "XNOR": + ax1.text(200, np.mean(ax1.get_ylim()) + 2, "XOR", fontsize=26) + ax1.text(850, np.mean(ax1.get_ylim()) + 2, experiment, fontsize=26) + else: + ax1.text(200, np.mean(ax1.get_ylim()) + 1.25, "XOR", fontsize=26) + ax1.text(850, np.mean(ax1.get_ylim()) + 1.25, experiment, fontsize=26) + + #### BACKWARDS Transfer Efficiency + ax1 = fig.add_subplot(gs[7:, 21:]) + algorithms = [ + "Stream Synergistic Forest TE", + "Stream Decision Forest TE", + "Batch Synergistic Forest TE", + "Batch Decision Forest TE", + ] + rxor_range = (100 * np.arange(0.25, 15, step=0.25)).astype(int) + # Stream Synergistic Forest RXOR + ax1.plot( + rxor_range, + np.log(results[1][2]), + label=algorithms[0], + c=colors[3], + ls=ls[1], + lw=3, + ) + # Stream Decision Forest RXOR + ax1.plot( + rxor_range, + np.log(results[1][3]), + label=algorithms[1], + c=colors[2], + ls=ls[1], + lw=3, + ) + # Batch Synergistic Forest RXOR + ax1.plot( + rxor_range, + np.log(results[3][0]), + label=algorithms[2], + c=colors[3], + ls=ls[0], + lw=3, + ) + # Batch Decision Forest RXOR + ax1.plot( + rxor_range, + np.log(results[3][2]), + label=algorithms[3], + c=colors[2], + ls=ls[0], + lw=3, + ) + + ax1.set_ylabel("Log Backward Learning Efficiency", fontsize=fontsize) + ax1.set_xlabel("Total Sample Size", fontsize=fontsize) + ax1.tick_params(labelsize=labelsize) + # ax1.set_yscale("log") + ax1.yaxis.set_major_formatter(ScalarFormatter()) + ax1.set_yticks([-1, 0, 1]) + ax1.set_xlim(-1, 1) + ax1.set_xticks([25, 750, 1500]) + ax1.axvline(x=750, c="gray", linewidth=1.5, linestyle="dashed") + ax1.axvline(x=1500, c="gray", linewidth=1.5, linestyle="dashed") + right_side = ax1.spines["right"] + right_side.set_visible(False) + top_side = ax1.spines["top"] + top_side.set_visible(False) + ax1.axhline(y=0, c="gray", linewidth=1.5, linestyle="dashed") + + if experiment == "XNOR": + ax1.text(200, np.mean(ax1.get_ylim()) + 2.0, "XOR", fontsize=26) + ax1.text(850, np.mean(ax1.get_ylim()) + 2.0, experiment, fontsize=26) + else: + ax1.text(200, np.mean(ax1.get_ylim()) + 1.5, "XOR", fontsize=26) + ax1.text(850, np.mean(ax1.get_ylim()) + 1.5, experiment, fontsize=26) diff --git a/docs/experiments/streaming_forest_tutorial.ipynb b/docs/experiments/streaming_forest_tutorial.ipynb new file mode 100644 index 0000000000..8d9f51e3be --- /dev/null +++ b/docs/experiments/streaming_forest_tutorial.ipynb @@ -0,0 +1,234 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Streaming Synergistic Forest Tutorial\n", + "**Note:** This is an experimental feature and requires a modified fork of `scikit-learn` with added `partial_fit` functionality: [scikit-learn-stream fork](https://github.com/PSSF23/scikit-learn-stream). Additionally, this notebook uses external functions stored in `tutorials/functions/streaming_forest_functions.py`" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from functions import streaming_xor_functions as fn\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using the `update_task` function for streaming data\n", + "Current standard implementations of decision forests operate in batch mode. In many real world applications, we are not provided with all data at once and therefore need to incrementally update as data arrives. For incrementally updating decision trees we can use the [scikit-learn-stream fork](https://github.com/PSSF23/scikit-learn-stream) with an added `partial_fit` function for incremental learning. Furthermore, for synergistic learning we can use the function `update_task`. When new data, $x$, arrives with labels, $y$, we can update task $t$ as follows:\n", + "\n", + "`synf.update_task(x,y,task_id = t)`\n", + "\n", + "Note that when using `update_task`, the `classes` argument must be provided on the initial call to `add_task`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Synergistic Learning\n", + "\n", + "The goal of synergistic learning is to improve performance on the current task as well as past and future tasks. This can be accomplished through ensembling independent representations, as is done in both Synergistic Forest implementations. \n", + "\n", + "The metric of learning efficiency, as described in Vogelstein et al. 2020, can be used to quantify a classifier's learning abilities. \n", + "\n", + "The **learning efficiency** of an algorithm $f$ for a given task $t$ with sample size $n$ is defined as \n", + "$$\\text{LE}^t_n(f):=\\frac{\\mathbb{E}[R^t(f(\\mathbf{S}^t_n))]}{\\mathbb{E}[R^t(f(\\mathbf{S}_n))]}$$\n", + "If $\\text{LE}^t_n(f) > 1$, $f$ has learned task $t$ with data $\\mathbf{S}_n$\n", + "\n", + "The **forward learning efficiency** of an algorithm $f$ for a given task $t$ with sample size $n$ is defined as \n", + "$$\\text{FLE}^t_n(f):=\\frac{\\mathbb{E}[R^t(f(\\mathbf{S}^t_n))]}{\\mathbb{E}[R^t(f(\\mathbf{S}^{\\leq t}_n))]}$$\n", + "\n", + "If $\\text{FLE}^t_n(f) > 1$, $f$ has leveraged data from past tasks to improve performance on task $t$\n", + "\n", + "The **backward learning efficiency** of an algorithm $f$ for a given task $t$ with sample size $n$ is defined as \n", + "$$\\text{BLE}^t_n(f):=\\frac{\\mathbb{E}[R^t(f(\\mathbf{S}^{\\leq t}_n))]}{\\mathbb{E}[R^t(f(\\mathbf{S}_n))]}$$\n", + "If $\\text{BLE}^t_n(f) > 1$, $f$ has leveraged data from future tasks to improve performance on previous tasks\n", + "\n", + "An algorithm has **synergistically learned** if $\\log\\text{LE}^t_n(f) > 0$ for all $t \\in \\mathcal{T}$ \n", + "\n", + "Conversely, an algorithm has **catastrophically forgotten** if it has negatively learned for all tasks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gaussian XOR Experiments" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "mc_rep = 25\n", + "rxor_results, xnor_results = fn.run_gaussian_experiments(mc_rep)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gaussian R-XOR" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fn.plot_error(rxor_results, \"R-XOR\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gaussian XNOR" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABjEAAAJSCAYAAACC1ueCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3gU1frA8e+76QVC712kKCoqeq+9KyqCYr3qz957x9577wW7V7x2LKiooGBXsCEgTXqvIb3tvr8/ZpJsQrLZ3WyyJe/neebZ3ZkzM+9mTubszJlzjqgqxhhjjDHGGGOMMcYYY4wxscYT7QCMMcYYY4wxxhhjjDHGGGPqYpUYxhhjjDHGGGOMMcYYY4yJSVaJYYwxxhhjjDHGGGOMMcaYmGSVGMYYY4wxxhhjjDHGGGOMiUlWiWGMMcYYY4wxxhhjjDHGmJhklRjGGGOMMcYYY4wxxhhjjIlJVolhjDHGGGOMMcYYY4wxxpiYZJUYxhhjjDHGGGOMMcYYY4yJSVaJYYwxxhhjjDHGGGNihoicIyLZ0Y7DGGNMbBBVjXYMxhhjjDHGGGOMMcYAICI+oBB4E3hBVX+OckjGGGOiyCoxjDHGGGOMMcYYY0zMcCsx/G9YzQKeA8apam5UgjLGGBM11p2UMcYYY4wxxhhjjIklVwNzAHGnbYHHgRUi8qqI7BXN4IwxxjQva4lhjDHGGGOMMcYYY2KOiOwBnAMcDWS6sytvZM0DxgKvqeqGKIRnjDGmmVglhjHGGGOMMcYYY4yJWSLSGjgZOBPY0Z1deUOrHBiPM3bG5CiEZ4wxpolZJYYxxhhjjDHGGGOMiQsishNO64wTgNbu7MqbW4uA54FXVHVNFMIzxhjTBKwSwxhjjDHGGGOMMcbEFRHJwKnIOBv4t98iBSqACcBzqvpFFMIzxhgTQVaJYYwxxhhjjDHGGGPiktvV1F3AhVS3yBC/9/OBW1X1zSiEZ4wxJgKsEsMYY4wxxhhjjDHGxBUR2R04CziW6kG/BacVxt/Adn7JFfgAOEFVy5sxTGOMMRHgiXYAxhhjjDHGGGOMMcY0RETaichlIjIT+BY4FcjCqbxYDtwC9FbVHYABwCNAgbv8SODiaMRtjDGmcawlhjHGGGOMMcYYY4yJWSKyP87YF0cCqZWzAR8wEXgW+FRVfXWs2w34CqdSY6aqbt8cMRtjjIkcq8QwxhhjjDHGGGOMMTFFRLoApwNnAn0rZ7uvq4CXgLGquiyIbZ2DU9FRrKpZTRCuMcaYJpQc7QCMMcYYY4wxLY97Q+kNVS2IdizGGGNii4iMBw4Hkipn4YxrMQmnMuJDVfWGsMml7mt6xII0xhjTbKwlhjHGGGOMMabZiYgPKATeBF5Q1Z+jHJIxxpgY4ZYRldYBrwDPqerCMLe3N/Aa4FPVfo2P0BhjTHOySgxjjDHGGGNMs3NvUPlfjMwCngPGqWpuVIIyxhgTE9wy4hucVhfvqWp5lEMyxhgTRVaJYYwxxhhjjGl2InIlcAYw2J1VeWFSAryL0zrj22jEZowxJrpEZJCqzol2HMYYY2KDVWIYY4wxxhhjokZE9gDOAY4GMt3ZlRcp84CxwGuquiEK4RljjDHGGGOizCoxjDHGGGOMMVEnIq2Bk4EzgR3d2ZUXK+XAeJzWGZOjEJ4xxhhjjDEmSjzRDsAYY4wxxhhjVDVPVZ9W1Z2BYTgtMPIBAVKB44AvRGSBiIwRkc5RDNcYY0wTEpHeIvKPOx0e5DqHichCEZkvIl2aOkZjjDHNxyoxjDHGGGOMMTFFVX9T1fOArjgtM37CqcwQoB9wN7BURN4TkYOjF6kxxpgmciLQF8gGJga5zudABk45cXITxWWMMSYKrBLDGGOMMcYYE5NUtVhVXwaGA09VznZfU4Ajgc9EZI6InBCFEI0xxjSN/XHO9xNU1RvMCm66j3EqvA9swtiMMcY0M6vEMMYYY4wxxsQkEdldRF4CVgAX4NzQEsAL/EV164wBwDi3ZUZKtOI1xhgTMdu6r9NDXO+3WusbY4xJAFaJYYwxxhhjjIkZItJORC4TkZnAt8CpQBZOZcVy4Bagt6rugFN58QhQ4C4/Erg4GnEbY4yJqPbu69oQ11vvvnaIYCzGGGOizCoxjDHGGGOMMVEnIvuLyP9wWl08BAzGqZhQ4FNgJNBXVe9Q1VUAqrpAVa8EBgHz3PSnRSF8Y4wxkVXivmaFuF6m+xpUF1TGGGPiQ3K0AzDGGGOMMca0TCLSBTgdZ/DuvpWz3ddVwEvAWFVdFmg7qrpSRB4GngW2aqJwjTHGNJ81OIN67xDiepXp10U2HGOMMdFklRjGGGOMMcaYZici44HDgaTKWTitLibhVEZ8GOxgrq6l7mt6xII0xhgTLT8B/YHjReQGVS1paAURyQBOwClLfmni+IwxxjQj607KGGOMMcYYEw2jcB6qEpw+zB8AtlbVg1X1/RArMACKcCoylkQ2TGOMMVHwnvvaFXguyHWec9MDvBvxiIwxxkSNqGq0YzDGGGOMMca0MCLiA77BaXXxnqqWRzkkY4wxMUREfgWGuh+/BW5U1e/qSLcXcCewpzvrL1UdWjudMcaY+GWVGMYYY4wxxphmJyKDVHVOtOMwxhgTm0RkK5xuodr4zd4MzAEKcMbMGOi3XIANwL9V9Z9mC9QYY0yTs0oMY4wxxhhjjDHGGBNzRGQATtdQQ/xm+9/IEr/3M4BjVXV+c8RmjDGm+VglhjHGGGOMMcYYY4yJSSLiwRmw+0ScLqNa+y3eDHwHvA68o6q+5o/QGGNMU7NKDGOMMcYYY0yzE5HewFfux0tU9ZMg1jkMeBLwAnup6uomDNEYY0wMEpFsnIqMPFUtiHY8xhhjmp4n2gEYY4wxxhhjWqQTgb44fZpPDHKdz4EMoB9wchPFZYwxJoapaoGqrrQKjNgnIt1EJFdEVEQmBJH+ejetisjB9WzvehH5TkRWikipiKwVkWkicpfb/VhD+3jFbx/+U5mIrBGRr0TkMreyzNQhUse11rEoEpGuDWxnipu2wd+NllcSj1ViGGOMMcYYY6Jhf5x+zSeoqjeYFdx0H+P0gX5gE8ZmjDHGmEZS1ZXAde7Hw0Xk+PrSikh/4Cb34zhV/aLW8quAecBdwB5AVyAV6AgMA64HZorIAyKSFEa4KUAnYD/gEWCGiGwdxnYSXiSPq58M4NpIxGd5JTFZJYYxxhhjjDEmGrZ1X6eHuN5vtdY3xhhjTOx6FvjBff+YiLStJ91YIB3YAFzuv0BEngYeALKAFe7ybYEOwADgLGAWzs3lq4D3RSQliNha+U3dcB6Q+MZd1tfdjt07rVujj2sdzhGRbo0JyvJK4rI/rjHGGGOMMSYa2ruva0Ncb7372iGCsZgwWVchicm6CrG8EktEZJiI3CAi40TkU/e4NDRNjnbcxqHOYLxnA2VAZ5wbzDWIyBk4T7UDXKmq6/yWnQuc7378BthGVR9V1dmqukFV56vqi8BOwBtuupHAbUHEVuA3rVLVyW4cv7pJhgAHhfiVW4TGHtda1gCFOJUd19WTpkGWVxKbVWIYY4wxxhhjoqHEfc0Kcb1M9zWoLqhM07KuQhKTdRVieSUWiEgvEZkC/AzcDpwAHALs08C0rzuZGKGqs4H73Y9niMg+lctEpDPwoPtxsqq+6resHfCQ+3EFMFJV8+rZRxlwKtU3lceIyKAwYvX5xQOwZ6jbaCnCPa51yAWect+fLSI9Qo3F8kris0oMY4wxxhhjTDSscV93CHG9yvT1Pc1nmp91FZKYrKsQyytRIyJtgKnAXjjjIIUymdh0J07lowBjRSTNnf8Y0BYoBs6rtc45VD/scJOqbg60A1WtwPm/B+ee52VhxjrX732nMLfRUoRzXOvyAFAApBFeawzLKwnOCmBjjDHGGGNMNPyEc8F7vIikB7OCiGTgPImrwC9NGJsJgXUVkpisqxDLK1F2DdDbfb8IJy9uBaSrqieIKZwWOKYJqWopzo1mxalwvFFEDgcqW3rdrqoLaq022n0tBN4Kcj9TgIXux6PCDNe/MmxTmNtoEcI8rnVtZz3wpPvxLBHpGWIollcSnFViGGOMMcYYY6LhPfe1K/BckOs856YHeDfiEZmwWVchicm6CrG8EkUj3delwC6q+qKqLnKPrYlTqjoVeNn9OAZ43n0/g5r/a4hIJrCj+3G6qhaFsKvv3NdObpd3oRro9/7vMNZvUUI5rg14EMjH6R7w+mBXsrzSMlglhjHGGGOMMabZqeqHwO/ux5PdAX3rvEEoInuJyFTgJJwn/f5S1XeaKVQTPOsqJDFZVyHVLK80nz445/tnVHVjlGMxkXUVTuusFJwHE3zA2e7/rL8eQLL7PtSbw7P93vcJZUW327gr3Y8bAPu9EZxgj2u9VHUD8Lj78QwR6RXkqpZXWgCrxDDGGGOMMcZEy3E4T2iD0+/5VBHZKCI/iMgX7usGYArOE9ACbASOjkawJjDrKiQxWVchlleipLLFxcKAqUzcUdVNwOd+s95V1bq6iPQfhyc3xN34p29XXyIRyfabuorIAcDXwM5AEXB0iE/1t1ghHNeGPATk4bTGuCHIdSyvtADJDScxxhhjQiMinYBdge1x+rJtC2TgPKm3EViC07T0lwB9JxtjjElwqvqPiOyG0zXUEHd2G+Bffsn8byDOAI5V1X+aJ0ITKlWdKiIvA2fgdCmx3l3UFF2F9MPt/iGYm+i1WPcPIQjluDbgQeBCnMGzr6d6fIuALK+0SP/gjG1S701FE59EZBfgZL9Zh4pId1VdUTup33sNdTdBpsuvZ/504Mg6YjL1COG4BqSqm0TkMeAm4HQRuUdVFze0e/9NhLI/LK/EDWuJYYwxJiJEZCsRuUVEfgNWAR8CdwBn4Twxe5j7ejZOtwQfAatF5FcRuUlE+kYpdGOMMVGkqvOAoTgXvp/iPH0nftNm4BPgP8BOqjo/OpGaEFhXIYnJugqxvNKc3sIpA4ZHOxATOSKSjDNeggdnvJNinErNJ+pI7t+NWNs6lgeS4/c+nBZUw4Abw1ivRQrxuAbjYZzffykE1xrD8koLYJUYxhhjGkVEDhaRiTh9Jd8M7EDNm08NTUOBW4EFIvKZiBzUzF/BGGNMlKmqT1XfUNURqtoGaI1z07K1qrZV1SNU9S13kF0T46yrkMRkXYVYXmlmT+FUWI0SkUOjHYyJmCtxrhfBebjtNvf9USIyslba5UBlJemgEPcz2O/9ovoSqapUTjhj3hyDc10LcJ6InBPifluqUI5rg1Q1F3jU/XhaEA88Wl5pAawSwwQkIt1EJFdEVEQmBJH+ejetisjB9WzvehH5TkRWikipiKwVkWkicpeIDAhiH6/47cN/KhORNSLylYhcJiLZ4X7veBep41brb10kIl0b2M4UN+3EIGO0vBDHRGRPEfkO+Aw4iOpKiY3uvFtx+ko+GOfib2ucpxQOBk7A+WEzEedph8p1DwYmisi3IrJHc34fUz8rCxKPlROWT2Kdqhao6kpVLYh2LCZ0Uk+XEnUl9XvflN0/VE4rgUnA3jjdPwxQ1akh7rfFCuG4BuRWhjzmfjxdRPoEs3v/TYS4S8srcUhVi4EROAOrv+/+JshpYDUTw0SkH3CL+3Gcqn6BU6k5w533pP9vMrfS8A/34zBxupUL1p7u69pgu5BT1XWq+h6wL7DWnX2/iIT6ZH+LEupxDcEjOJXQyThdS9XL8koLoao22RRwwumnVN3p+ADp+uM0GVPg9TqWXwUU+G2rrqkMeABICrCfVxrYRuW0ENg62n+/eD5udfytH2tgn1PcdBMbSGd5Ic4nYBzgxelGwIfTZPQ+YPswt7c9cC/OWBmV2/TWdS6xKWrH3MqCBJusnLB8YpNNTTHh3Gz4w/3fWoLzBLsC79eRdoDf/+EzIe5njN+6B9VaFuz/fkj7bMlTKMe1nmMxp9b8Njg3pxR43m9+neWE5ZWWNwFfudOvVF8blAEz3XzyVQPT5Gh/B5u2OKZfuv9PG4COfvP/5R5fBR6ptc71fv+Hpwa5n7381nm2juVV//cBtvF/ftu4M9p/u1iewjmudRyLOfUsv9ldXg5sVV8ZYXmlZUxRD8Cm2J9wnlz53v2HXA20rSfdV26a9f4nLnfZ037/1MuBy4BtgPY4T2ef6f4YqUzzIZBSz35e8UuX7Td1BQ4Apvot/wvwRPtvGMfHzf9vrTg3sboF2Ge9BYrlhcSaqK5omATsH+Ft7+9u1wd4o/1dbao6LlYWJNhk5YTlE5tsaoqJmjeMD671eWSttJk4NyYU+DrE/fj/f/evb1mt+R1xxuea67fuOdH+m8XDFMpxredYbHGDCqfVbuXNqb7uvDrLCcsrLW+iuuLCf6prXl2TXUfE2ASc4ve/dEYdy590l1XgjH9VOb89UOguWwa0amA/ScAvbnovMKiONHX+39dK4wFmuelygZxo/w1jcQr3uNZxLOqrxGiN09ODumnrLCMsr7SMKeoB2BQfE87Ng1L3n/KFOpaf4XfiOrXWsnP9lk3F6du4rn2k4jzdXZn27nrSBTyJuCeQ6X7bOSTaf794PG61/tarqX4i9okA+6u3QLG8kFgTTiXDHk28jz2AL6P9XW2qcUysLEiwycoJyyexMuF0N3iDe1w/peEnbO0p2xicgH5UP6H/ujsvGfjTnbcUyK61zjR3WT6QGcK+FrjrraljWUP/+11xBqiuvOFQZyWuTeEf1zqORV2VGDk43Yoq8JI7r95ywvJKy5qofmgq3MkqMWJkAjoA6whQCYlzs3qFm2Y6fi1tgQv8fqt9TT03p3EGgX6NRv4+9Et3gt+2boj23zHWpsYe11rHos5KDDfNjVRXhCyur4ywvJL4U9QDsCl+JuAO9x/SB+zjN78z1TWjk2qt047qmxrLaaBGEufHcOXNhMbUhPqfQO6I9t8u3o5bHX/rOThdBSlQAvSoJ/2U+goUyws22ZQYk5UFiTdZOWH5JMr5r5ebL4J5staeso3xCesqJCGncI5rHcfCugqxyaYWOgH/9fuNODBAutF+/2uX1lo21m/ZMuASnAGZ27nnjtNxWtVWpgmqpW4DcXuA2W7atYRQedoSpggd14BlhJumlVv+qN8UqFW35ZUEnWxgbxOKO4F5ON1PjBWRNHf+Y0BbnC4kzqu1zjlAlvv+JlXdHGgHqlqB0w82OCeBy8KMda7f+05hbiNRhHPc6vIAzs2lNOC6MOKwvGBMYrCyIPFYOVHN8kkzEpE2OC1u9sLJf6FMJsaIyCnAge7Hq1V1XeUyVf0ZeMb9eLGI7OS36nM4T/kD3CkirRrYTxLOgKHgVGY9GmbI43BuOABcZAMG160RxzVYj+K0xmhw4FYsrxgTd0TkIOBk9+Ndqjq3vrSq+j7wkfvxDhHp4bfsHOBanHNAD5zfqbNxbm4vAF4ChuA8rf8wcLSqljcmdlX14fxOBqeLuXMas71EEqnjGgxVzaf6XB5MessrCcoqMUzQVLUU5x9RcQZWu1FEDgeOd5PcrqoLaq022n0tBN4Kcj9TcAbYBDgqzHD9L243hbmNhBDmcatrO+tx+jMEOEtEeoYYiuUFYxKAlQWJx8oJyydRdA3Q232/CDgb5wm5dFX1BDElRS1yU4OIdKD6BsMUVX2pjmTXAytx+qAe695gRlU3AFe7aXoAH9V3c1pEUoCXgV3cWfep6pxwYnZvONzhfswBLgpnO4msMcc1WKqah3MTCZwbYn0CpLW8YkwcEZEM4Fn34984rXYbchHOQzGtgCf8F6jqfTi/VW8CfsDp6q0cZ9y234B7gG1V9Ur3YZdIeJPqB16uFJHUCG03bkX6uAbpcZxKiKBYXklQ0W4KYlP8TcCLODc6ynB+sCpOf6jJtdL5D742JcR9vEp1066gBl+rleY/fuufGu2/WSxMwR63ev7Wc9zP7YE8d94zdaSfQh1N+ywv2BTksW6Pc4EZ9VhsCup4WVmQYJOVE5ZPopDnZuI8Hb0IaBfteCL4vdoAB+GM8fGB3/9TyPk7Xiasq5CEnCJ0XGuUE/Wsb12F2NRippZYRthkk002RWKylhgmHFfh1GKm4Ax05gPO1i1rL3vgNAsGp3Y2FLP93vcJZUUR8QBXuh83AO+EuO9EFexxq5c6Tz897n48Q0R6Bbmq5QVTLxFpLyL34QzSdVUDyU3ssLIg8Vg5YfmkufWhusJrY5RjiaTfgS9wuhUYhfP/lLCsq5DEZF2FbLFPyytRJiLdReQUEblHRJ4VkRejHVOYWlQZYYwxkdLoSgwR6SYiu4nIYSJytPv6bxGxE3GCUtVNwOd+s95V1V/qSNrW731uiLvxT9+uvkQiku03dRWRA4CvgZ1xftQerapF9a3fkoRw3BryEM5Ttqk4T48Ew/KC2YJbeXEvzhO4V1HdF76JA1YWJB4rJyyfREGZ+7owYKr4499F2RpgQrQCaWrWVUhisq5C6mV5JQpEpJOIvIFzzfAyTleE5wCn1ZH2aREpE5F/mjfKkLSYMsIYYyIpueEkNYlIH2AkcAiwK4EvFjcAv+BcEH+kqkvCC9PEEhHZheqncgAOFZHuqrqidlK/9xrqboJMl1/P/OnAkXXE1GKFcNwCUtVNIvIYzgXD6SJyj6oubmj3/psIZX9YXoh5IiLACThlwwAgHVgK/Ag85T6Z7Z8+CxiDMwhvFtXHuAJn4EQTB6wsSDxWTlg+iYJ/gJ0IcD0Rp57Eudk2TVWXAohIqPk6LqhqMU73PaGsswznRnd9y1fgPKF8Z31pgtjHadRxg7OetD5gULj7SkSRPK7BHgtVLQA6hLhPyysJTkS2BqYCnQmuvH8COA/oIyL7qjN2VqxpMWWEMcZEUlAtMUQkSUROEJFvcC42HgGG4/R7LAGmDsChwKPAPyIyVUSOD3WwLxM7RCQZeB4n7ywFiqn/aRv/bgHa1rE8kBy/95tCXBdgGHBjGOslpBCPWzAeBjbjdDkSzFO2lhcSlIh0An4GXgeOA4biXNwdDNyCc+7f3S/9QcA8nHyTjVNWFOP8mO+vqqc3Z/wmPFYWJB4rJyyfRMlbOOXA8GgHEkmq+qCqvld5c8oYY0zo3MHZJwBdcMqK/+I8TFvvwOqq+jfOeCgQo2WLlRHGGBOegJUYbuXF2ThNvMcBe1CzkmIx8BnwBs5F7l04N6LeACYCS/zSeoA93WX/iMhZVpkRl64EdnDfnw3c5r4/SkRG1kq7HOfJagj9iZXBfu8X1ZdIVaVyAjoBx+DcIAU4T0Ssr1JHKMetQaqai1M5CXCaiPRtYBXLC4nrXZwbgPVVZrcGPhWRDiJyGk6ZUXkhshm4G+itqpfYD/m4YmVB4rFywvJJNDyF01XNKBE5NNrBGGOMiSlnAlvjtNA8V1VPVdUvgYZaTk7Fudb4VxPHZ4wxphnVW4nhPi37F05fmD1xCoHVOBeko4DOqtpPVQ9X1ZNV9VJVvcm9EXWyqh6mqn1xblaNctdb7W6nF/AcMENEDmy6r2ciSUT64TxZDTBOVb/A6fd6hjvvSRHJrkzv9iv9h/txmIhkhrC7Pd3Xtaq6IJgVVHWdqr4H7AusdWffLyKhPtGZUEI9biF4BKcf8mScLkPqZXkhMYnI4TjHR3H6k38Q53w/HOeGaGUf561wnsp+BqfcKQBuBnqp6o2qur6ZQzeNYGVB4rFywvJJtLhd1ozA6WP+fRG5XkRyGljNGGNMyzDaff1KVZ8PYb1Z7uuACMdjjDEmigK1xPgc50k4L043IQcDPVX1ClX9WFXXBbMDVV3rpr8C6OFu53Wcp+0G47TYMPHhOSADp8uHywHcQdLOAXw4lV131FpnvPuaDRwbzE5EZC+q+2AdHyhtXVR1Fc4gweB0MXFlqNtIMOEctwap6macG1QA/yciDfWba3kh8RzvvpYDB6jqNe75/gtVfQSnn/OZbpqTgDSccTIGq+qdqlpf//QmtllZkHisnHBYPmlmIvIV8CJO92VpOPlsnYjMFJEpIvJVA9PkqH4BY4wxTWk7nIelPghxvcouKu3BBGOMSSCBKjG8OBcVA1T1FFWd5A5kFTZ1TFLVU3BqxV9y92NinIicAlS2mrnavxJLVX/GecIa4GIR2clv1edwntAGuFNE6h3Ez91PEs7Tn+DcOHk0zJDHAbPd9xe11Kf6GnHcgvUoTv/jDT5li+WFRLQzzoXF225+qkFV83C6pKnsWmotcLCqrmzWKE3EWFmQeKycACyfRNO+wD444ylVDmqajPOg017usvqmfd3JGGNMYmrnvq4Ocb3kSAdijDEm+gJVYmytqmer6uKm2LGqLlHVs7AmfjFPRDpQfZNgiqq+VEey64GVQBIwtnK8E1XdAFztpukBfFTfTQl34K6XgV3cWfep6pxwYnYr3CqfGs0hwOBfiaoxxy1Y7k3qh92PJwN9AqS1vJB4urqv3wRIM9V9VeAlVS1s2pBMU7GyIPFYOVG1X8sn0VV7LKW65tU1GWOMSWyb3ddQHy7o7b5uiGAsxhhjoqzeSoymqryoYz9LmmM/sWL48OGKczMvbqaTTz55HdAhLS2NOXPm7FtXGlXd/N5773Vzv+bOjz76aIXfsqfOPvvsyj/Bvj169Mh7/PHH9e+//9aNGzfqP//8oy+//LIOGTKkDPg/gJEjR1JWVnZdXfs69dRTT/X7k9Ybt9fr/d/gwc5Ynx07dryzqKgo6n/LQNMrr7yir7zySswcN/+/9cCBAwfWt5+8vLw72rVrB84Nrt4AhxxyyCH17M/yQvjHPha1dl8DjWnhf/EQ1g3GliSWywgrC2L+HNHsx9T/OFg5EfW8EZdU1dPIKaRKtXgkIueIyHQRmb7ttttGPc/ZFJtTU5UTNiXGFMflxCL3ddcQ1zsU57vPbChhvLMywqZgJisjbAo0xVMZEaglhmkC69fH1/i1X375Ja+//joAN9xwA849irqNHj2akSNHAnDTTTexfPnyqmVjx47l3nvvJTMzk+XLl3PppZeyzTbb0L59e/r3788ZZ5zBzJkzSU5O5oorruC9994jJSWlUbF7PB5uvPFGANatW8fYsWMbtb14EqnjFoxWrVpx5ZXBdyFueSGhVJYh9XY1qKr+BWJuk0aTAGK1jLCyIPFYOVGT5RMTq1R1rKoOU9VhGRkZ0Q7HGGOa05c4Le9OEJGOwawgIgfjdEcIzjivCc3KCGNMi6KqzToB2zb3PmNp2nnnnTVeFBUVab9+/RTQwYMHa2lpaYPrLF26VLOzsxXQI488covly5cv1zvuuEN333137dy5s6akpGiHDh10p5120uuuu07nzp3b4D5OPfXUqhrDhni9Xh04cKAC2qNHj6C+Q7T8888/+s8//zR6O5E8bpV/64EDBwZcPz8/X9u3b191XA455JAG92l5oVqQxz7q56/aE07lhRcYGYl0NsVmGWFlQfRFqnyoZOVE3eIxn/jljaifv2wKPFXmQ5yu2xKmjDCxIdLlhEks8VpOAD2BYvc64hsgx50/qvL6olb6A3BaiPtwxuNqHe3vEMJ3tTLCNBkrI0wg8VRGiGrztBoRkW2AW4GjVLVxj8vFsWHDhun06dOjHYYxJv7EXP/fIuLD+bF9lKp+1Nh0xsoIY0zYYq6MMDWJSOVF11RV3TecbVgZYYxphLgsJ0TkOuAunGuJ9cBLOK3Br3bn7QMMAY4CDsT5ngqcrXWP9RWTrIwwxkRZXJQRyU29AxEZDNwCHEOc/FGMiYbVq1cD0KVLlyhHYppbAhz7O0XksgilU1U9oPEhGZM4EuAcYZpIouUNEemO8yTtYKAtkKKqZ0Y3KmNiX6KdC0xkrV69Om7zhqreIyKdgEuBjsA1lYvc16l+ySvvN90eTxUYxjQ1KyNMIPFURgRdiSEiGcDewAAgHVgK/KKqi+pJPwC4nerKi8oCZXNjAjYmUU2cOBGA0047LbqBmGaXAMd+2waWV15kNJSu8skpY4yfBDhHmCaSKHnDvUH1KM51Q+Vg3ZVlwpm10j4NnAUsU9WtmjFMY2JWopwLTNOYOHFiXOcNVb1cRKYAtwHbB0g6C7hOVSc0S2DGxAkrI0wg8VRGBFWJISIX4xQYObUW+UTkbeAcVS1002YC9wHnuNuvrLxYCzwGPBWBuI0xxsQGa2FnjDEmbCKyNc6TtJ0Jrkx5AjgP6CMi+6rqlCYMzxhjTAxQ1Q+BD0Vke5yBu/vg3J8qAFbgdMNkfSkZY0wCa7ASQ0RuxukOCra8sEgCTgC6i8h+QC9gIk5rjcq0S4AHgRdVtSQSQRtjjIkJ+0U7AGOMMfFLRFKACUBlG/b/Aq8DWwNP1rWOqv4tIn/h9IE+HJjS9JEaY4yJBao6A5gR7TiMMcY0v4CVGCLSH7ix8iOwCvgJKMXpFmQ7d/5ewMnADTgVGADzcAZgekNVvRGP3BhjTFSp6tSGUxljjDH1OhOnwkKB81T1eahq2R3IVJzrkH81bXjhEZGhwNB6FncRkdNqzZuoqqubMiZjjDGxwcoIY4wJT0MtMc5w0yjwEE7/ghWVC0VkBPAWzhgZz7mvJcAY4ClV9TVF0MYYY4wxxpi4N9p9/aqyAiNIs9zXAQFTRc+RVLdkr20g8HKtefsBdoPKGGNahiOxMsIYY0LWUCXGnu7rr6p6de2FqjpBRO7BGcA7HagADlTVHyIbpjGJ74ADDoh2CCZK7NgbYwKxc4SpTwLkje1wHpb6IMT1NrqvbSMajTFxKgHOBaYJWf4wpmWzc4AJJJ7yR0OVGANwLizeDpDmLZxKDAXetwoMY8LTs2fPaIdgoiSRj72IeIB27seN1kLPmNAl8jnCNE4C5I3K8iHUJ0wbHNcvmlT1VuDWKIdhWpAEOBeYJhTr+UNEFrpvVVW3qmN+uGpsL1ZYGWGaW6yfA0x0xVP+aOgCoI37ujhAmkV+779pTDChEJEewMXAETgDile4sYwHnlDVTRHYRyfgIuBQnP5603Eusr4Hxlp/8CaSli1bBsTXCcRERiIde7cf8/8DDgJ2BzrXWr4G5xz6JfC6qhY1URxWRpiEkUjnCBNZCZA3NgPtgZwQ1+vtvm6IbDjGxKcEOBeYJrRs2bJYzxt93FetY77ijMMajtrbM6ZFsjLCBBIHZUQVTwPLU93XsvoS+I+RAaxsdERBEJHhwF/ANcBgIAvn4mcocBvwl4js3Mh9HI4zOPlNwDB3+2k4F00nAlNE5AkRCbdANaaGyZMnM3ny5GiHYaIgUY69iFwFLAWeBo4CuuBcdPhPXXD6QH8GWCoiVzZBHFZGmISSKOcIE3kJkDcqH4baNcT1DsW5OTUzsuEYE58S4FxgmlAc5I2lwBL3tfb8ymXhTLW3Z0yLZGWECSSe8kakm2I3eTchIrI98C7OTaki4D5gMs53GQVcAnQHJojIzqoacsWKiOwJvI9TiVMKPAl8gvO02ADgUuDfOE/g5gE3NO5bGWNM/BKR1sA7wIGVsxpaxX1tB9wvIgcBx6lqXgRisTLCGGPix5fALsAJInKTqq5raAURORjYC6cS4/Mmjs8YY0wTU9U+ocw3xhjTMsV0f7L1eBTn5pQXOFRV/buwmioivwH/xXna907gjFA27j41+xTOzSkvMEJVJ/kl+U1E3sW5STYKGCMi/1XVOWF+H2NMlJT5yinyFZMsSSRJEsnuKbHQV0S+t5B8byGF3kIAMjwZDMkaUGP93wtmMWXzz5T4SknzpJIqKaR6UkiVVNI9qaRKqvs5hU4p7RmavU2zf8emJiLJODf09/ebPRvnPPwjMBfIdee3wbnJvxtOl1Pb4lRoHAS8JyKH1mrdF45HsTLCJLAKreCMeWPYJnNrhmYPZoeswXRN7RTtsIwJ13PAlUArnHLgCFXdXF9iETkAeMP9mAe81PQhGmOMMcYYY6It2EqM/UWkTaTSqeprQe63Brf7j/3cj6/UujlVue3XReR0nBtqp4jItaq6NoTd7ARs775/s9bNqcp9VIjIBcDhOH/Dq4CzQtiHMQbnZtycooV41UuZlrHZW0BuRR6bK/LJ8xZQruV41YtXfYgIN/S8sMb684oXcc786ynXckq1nHJfOV58qPrw4sOnis/93Ca5Nb/u+HGN9b/J+4VT510VVKwDM/rx1Xbjasz7tWAmD654Pqj1D8jZndcGPhRU2jhzC875VnH6Jr9YVd+qJ+0ad/oWpwXGscATQCd3Gze7U1isjDAtwbzixUze/AOTN/9QNa9zSgd2yBrMbq135LC2+9IjrWv0AjQmBKq6TERuB+4C9gDmichL+HV567Z+G4LTTeGBOJXfClwZiRZ8xhhjjDHGmNgXbCXGxQ0srxwwqaF0lWnDqsTA6Ue90osB0r2Ec4MqCRgJvBDCPnbxe/9ZfYlUdaWI/AnsDBwpIudF4AliY+JWma+chSVLmVu8kPnFi1ldvo41ZRtYW76edeUb2VyRx/c7vEuX1I5V6xR4izhk1qlB72NMj3NJlurTlle9zC9ZHNS6Jb7SLealSPCN0Tx19JDULrlN0OsnIhHpAlyOc15fBeynqvODXV9V3xGR34Gvcbp4ukJEnlLVNWGGZGWESXgzCv/eYt6a8vV8kfstX+R+y21LH2eHrMEc1nZfhrfdm37pvfBIQ0OgGRM9qnqPiHTC6YqvI854RlB9fTHVL3llYXy7qlorDGOMMcYYY1qIYO7gxdKgpHu6r0XAtADpvq61Tig3qNr7vW/oRlrl8vbANsCMEPZjTA3Dhw+PdggBFXgLSZM0Ujw1Txtnzh/DopLl/FOyhAr1NrCNohqfkyQpxBiKaJPcuupzqqQGva7WMS/Dk07rpGy86sOrFVTgxadKdlIm2UlZtErKItOTgUeE3mk9tlh/m8z+XNT1FDKTMij3lVOqZZT6nKlMyynzlbnzytk+a1C9scX6sQ/geCAT5897aigVGJVUdYGInIbTL3oGcALwWJjxWBlhEpL/OWK/nN14eqvb+aPwb/4s/Ju/CudS5Cuukf5Pd9k9y58h05PBwIy+DMzox8DMfuzVehcGZ/Zv7q9gmkgclx81qOrlIjIFuI3q1m51mQVcp6oTmiUwY+JEopwLTNOI1/whIknAiTj3pKar6uwg1tkGGAb4VPX1Jg7RmLgQr+cA0zziKX80VInxarNEEbzKDuXnB3qi1X0CNg9o7bdOsAr83uc0kLZNrdjsBpUJW5cuXaIdQg2qyjd5v/D62g/5q3AOy8pW8cHg59ilVc17C38WzmFVWXC98RTWqsRIliQGZ/QnWZJIlmTaJLciJ6kVbZJb0zq5FamSUjVehQfPFi0neqR1YfKQ10n1pJImKaRICkniwSMePDivSXgQBGcog5p2bbUDf+/8ZYh/mWqDMrfiuszzw16/Uqwd+xBUlnY/qOrkcDeiqpNF5Htgd3eb4VZiWBlhEpL/OaJzagdGtT+IUe0PApwWaQuKlzCtYAYTN03lu7zplPtl/yJfMb8Xzub3wurr/t1a7ciZnY/j4LZ7hVyZbGJLHJcfW1DVD4EPRWR7nIG7++CcZwuAFcBUVZ0evQiNiV2JdC4wkRfH+WMEzj0pH1D/E2E1leK0uhYRWaeqnzdVcMbEizg+B5hmEE/5I2Alhqqe3lyBNERE0oAO7sflQayyHOemUc8Qd+XfT8M+wHv1xNMKGOo3q1eI+zGmhoULFwLQr1+/qMZR5ivno42TeHbVG/xdvKDGsjnF/2xRidE2OaeqEqNnalcGZvZjYEY/uqd2oXNqezqldKBzSnvaJueQ4UmvsW6GJ51J2/037FjTPKkMytwq7PVjRawc+zAMxGmF8WkEtvUJTn/oA8NZ2coIk8gCnSOSJMk572b24+ROR7K5Ip8vc7/j041T+KXgTzZVbDlG8o/5v/Nj/u/0TO3KaZ2P4dROo8lISt8inYl9cVx+1EtVZ2CVvsaEJBHPBSZyFi5cGK95Y6T7+oOqLgiY0qWq/4jId8DeOF3NWiWGafGsjDCBxFMZEXyH8NHXyu99Qb2ptkyTHeJ+vsUZnLY9cLqIPFFPFym34HSjUld8xoTsm2+cMYijdfJYUbqat9d/yrh1H9bZsiJZklhfvmmL+ff1GYMHYauM3rRKymqOUBNOtI99I3RyX5dEYFtL3deOAVPVz8oIk7BCOUfkJLfimA6HckyHQ1FV1ldsYk7RP8wtXsgv+X8ycdM3eHG6/ltWtoo7lj3Ba2vf5/6+17Jn62FN+j1M5MVx+WGMiSA7F5hAvvnmm3jNG7viPDD1VYjrfYVTifGviEdkTByyMsIEEk9lRDxVYmT4vS8LIn3lKL4ZAVPVoqrFInIH8CjOza1vRGQMzlPCecAAnIFsz3TjqOyUv979iMg5wDkAvXrZw7gmtvxaMJOHlr/AN3m/oLVGjsjwpPOfjkdwfIcRDMjoS6onZYv1d8retrlCNbGnMsNEYuykxm7DyghjahEROqa0o2NOO/bK2YWzuhzPyrK1vLbmfV5f90FVK40lpSs4fs7F/KfjEdzU82Jykq3OzRhjjDFR19t9DXXcvX/c1z6RC8UYY0y0eaIdQAj8R60MZjTftDrWC4qqPgY85X7sgtMP43qcG1IzcW5O5QE3+a2WH2B7Y1V1mKoO69gx3IeMjWkaFVrB1Lyfa1RgdExpx5ge5zJt6Afc0fsKhmQNqLMCw7R4lU12egdMFZzKbawLc30rI4wJQrfUTlzb8zymDf2Au3tfTU5SdYXF/9Z9zL5//YcXVr/FL/l/klcRTKMmY4wxxpgmUfl7vTRgqi1VPtCUGTCVMcaYuBJWSwwRycEZcG93oDtOtxrgdLGxAvge+FZV8yIRpMv/BlAw3X9UpgnrClxVLxKRicBVON+z8g5uCTAeuA7nb1Bpy352jIkDu2bvQJ+0HiwpXcHerXfl+I4jOKTtXqR70hpe2bR0c4G+OIPu3d3IbR2O07JjTpjrWxlhTAgyPOmc2nk0w9vuzY1LHubTTV8DsLZ8A7csfbQqXY/ULgzN3obLup3O4Mz+UYrWxDsRWei+VVXdqo754aqxPWOMMQllI073td1CXK8y/ZYDgxljjIlbIVViiEgf4FrgFKprxetTKiKvAvep6uKwovOjqqUish5n4NYeQaxSmWZZI/Y5AZggIuk4T9sCrFTVMgARudAv+axw92NMc9lUsZkCbxE907pWzRMRHul3I91TO9M9rUuAtY3ZwmfAcOBfInKQqn4ZzkZE5EBgN5xKjInhbMPKCGPC0zm1A89vfTefbpzCDUseZG35hhrLl5etZvnG1Uza9B23976CEzuORCQSPciZFqaP+6p1zFfC71Kw9vaMMcYkjgU4lRjDgcdDWO8Q93VRxCMyxhgTNaIa3G9/ETkJeAbIIvgLDQUKgfNVdVxYEdaMYSrOAE1FQI6qVtSTrhtOixCAV1X1tMbuu579/Aj8G/ABbYNpeTJs2DCdPn16U4Rj4tz69esB6NChQ8S3rap8tmkqNy99hHbJOXy0zfPW0iKGBHnsY+6uoYh0xulzNgNYBeyjqv8EXmuLbWwFTMV5YqoQ2EpVtxxZPrhtWRlhElJTlg/+civyeGf9p8wonMvfRQtYULKY8lr/RqPaHcR9fcfQKimrSWMxwfHLGzFXRvgTkcW4FQ6q2reu+eHy316iszLC1Ke5ygkTn9avXx/z5URdROQW4BaccmJfVf02iHX2Ab5217lHVW9s2ihjh5URpj5WRphA4qmMCKolhohcCjxc+dF9nQv86L7muvNzcAY13Q0Y5M7LBl4TkXaq+kQj4/0O5wZVJrCLu/+67FtrnYhzb7z92/34WYS7zjItUFMVKPOLF3PTkof5Nm8aAKvK1nLH0ie4q89VTbI/E7p4/TGhqmtE5BHgBqAr8L2IXKiq7wWzvoiMxhlbojPOhcYj4VZguKyMMAmpuc4RbZJbc3aXE6o+l/nK+atoLtcsuoc5xU6vPx9u/JI/C//m4X43sGv2DtYqI8ripfxQ1T6hzDfGhCZezgUmOuI4f4wFxuD0AjJeRI5X1cn1JXZbd7/pfiwDnmv6EI2JfXF8DjDNIJ7yR4OVGCJyMPBQ5Uecrj5uUdVpDay3C3ArcKi73sMiMldVv2hEvO8D17vvz6T+G1RnuK9e4KNG7C8Q//7fn6o3lTFBmjt3LgADBw6MyPZKfWXct/xZXlzzNhXqrZrfNjmHvXJ2icg+TGRE+tg3s9uAPXAqBjoCb4vIbOA1alZ0A7ShuqL7/4AhVFeMfw3c3shYrIwwCSla54hUTwo7Zw9hwjYvcvPSR3hjnfPvsrh0OaP/Pp8uKR05uO1eHNJmL3ZvvTOpnpQGtmgiLc7LD2NMhNi5wAQyd+7cuMwbqrpKRG4D7gHaAl+IyBSc3+9/44xtlw0MBkbiXI8IzsNRd6pq2N3GGpNIrIwwgcRTGRGwEkNEPMCjgAenILhCVR8NZsNuJcfhInIJ8AiQBDwiItupqi+cYFX1VxH5GtgPOE1EXq3dpNDt9uoA9+NrtZ/qdcf1qOwbcaqq7lt7PyLSGvCoam5dcYjIDcBx7sfxqvpZON/HGH8//ujcb43UyeO6xffz1vpPqj578HBKp6O4qsfZtE3Oicg+TGRE+tg3J1WtEJEjcSoQ9scpK7YB7g1i9coKjMnAMfV1/xRCLFZGmIQU7XNERlI6D/S9jt1b7cSYxfdT6CsCYHX5Ol5b+z6vrX2fnKRWXNrtdM7scizJEtKQa6YRop03jDGxwc4FJpAff/wxbvOGqt4nIj2AyrHm9qVmq2p/ldcWT6rqXU0cmjFxw8oIE0g8lRGeBpYfidMtlAJ3B1uB4U9VHwfudD8OAkaFuo1aLsPpNz0JmCgiN4nI7iKyt4g8BLzqplsDhNv/4QBgpYi8KiLHi8gwEfm3iJwuIt9Q/X1mAueE/1WMaRrT8v+sUYHxr1ZDmTjkFe7qc5VVYJiIc7tKOginFcRmnAuIYKZc4DrgYFXdHKFwLsPKCGOaxFEdDuGzbV/mmPaH0iapVY1lm7353L7scY6YdTYzC+dFKUJjjDHGJBpVvRg4AaeFd6BriznAsap6aZRCNcYY04QaelTuMPd1JY3r5uMunO47ugEjgPHhbkhVZ4jIMcD/cLomub2O2FYAo1R1Zbj7wRmo9hR3qsvnwCmqur4R+zAm4rzq5YYlD1V9Ht52b17of6/1W26alKoqcK+IPIFz3jwI2B3oVCvpWuAH4EuclhCFEY7DyghjmtBWGb14bKubqdAKfsmfweebvuGzTVNZUbYagBlFczhs1hmc1/VELu9+Bhme9ChHbGKZiCQBJ+LcfJquqrODWGcbYBjgU9XXmzhEY4wxMUBV3xaRd4CdgT2BHkBrIA9YDnyrqr9GMURjjDFNrKFKjN1wWmG8p6rl4e5EVctE5D3gEqoHOg2bqk4Uke3c7Y0AeuH0bb4Ip4LkcVXd1IhdzAUuwulyZDucQWeTgdU4fayPU9VPG7F9Y5rMf9d+wKyi+QCke9K4rddlVoFhmo1bKfGMOyEiyUA7d/HGxnYZFWQMVkYY08SSJZndW+/E7q134oaeF/LM6nE8tuJlSrUML16eWvVfxm/4gvO6nMiJHUeSkWSVGaZOI3BayPlwWmwHoxR4CRARWaeqnzdVcMYYY2KH+9DUdHcyxhjTwjRUidHZff0rAvuq3EbngKmCpKrLgWvcKZT1FlPdV2J9afJxBmK1wVhNXFFVvsytHgLg4q6n0iOtaxQjMi2dW2mxtsGEkd+vlRHGNJNUTwqXdjuNEW33Z8zie/kx/3cAVpat4ealj/DYylc4q8txnNrpaHKSWzWwNdPCjHRff1DVBcGsoKr/iMh3wN7AaJyWb8YYY4wxxpgEJk5ldj0LRUqAFOB4VX23UTsSORZ4CyhT1Rb7ON6wYcN0+nR7cMBsafNmZ0iAnJzGjVnhUx9vrpvAG+s+4t3BT5HuSYtEeKYJBXnsrTlNC2BlhKlLpMqH5lBZBt23/FnWV9Rs8NQqKYu7el/F0R2GRym6xOOXN+KyjBCRv4BtgDtU9dYQ1rsZuBWYoapDmyS4GGRlhKlPPJUTpvlt3rw5bssJEzwrI0x9rIwwgcRTGdFQS4wNQBe27NM8HB3d140R2FbcEZEjgCP69+8f7VBMjIpUgeIRDyd2Gsl/Oh5h3UjFCfsxYayMMIHE0zmisgw6qsPBvLVuAk+vGlc1Xka+t5BLFt7GrKJ5XN/zApKloZ+hpiHxlDfq0dt9nR/iev+4r30iF4ox8SsBzgWmCVn+MKZls3OACSSe8kdDV48rcCox9gKebuS+9nRflzdyO3FJVT8GPh42bNjZ0Y7FxKaZM2cCMGTIkIhszyow4kekj31zEZG9m2K7qvpNU2w3llkZYQKJx3NEhied0zofw0kdj2T8hs95bOXLLC5dAcBzq//HnKKFPN3/dtokt45ypPEtHvNGLZXNRUtDXK/Mfc2MYCzGxK0EOBeYJjRz5syYzhsistB9q6q6VR3zw1Vje8a0VFZGmEBivYzw11AlxtfAMOBwEemiqqvD2YmIdAGOwBkk/OtwtmFMoqts+hnOyUNVrdIijjXm2EfZFJzzeiQpDZdNxrQocXyOIMWTzHEdD+ewdvtyyT+383muU0c5Ne9nDp91Bi9tfT8DM/tFOcr4Fc95w7URp8V3txDXq0y/ObLhGBOfEuBcYJrQ9OnTYz1v9HFfa19X9HHnhXuhG+nrFGPikpURJpA4KCOqeBpYPt59zQKeE5GG0m/BXedZdxv+2zTGRMidy57kpLmX8eGGSZT4Qn2Y0ZhGkSaYjDEJJjspixe2vofLu51RNW9x6QpGzD6Lt9Z9QqAx2kxCqxzMO9SBUg5xXxdFMBZjjDHRsRRY4r7Wnl+5LJyp9vaMMcbEsYBPu6rqTyLyOc6FwgjgTRE5S1Xzgtm4iLQCngdG4tSCf6GqPzUyZmOMn3JfBe+s/4wNFZuYsvlnxg14hH3b/DvaYZmW4bkIbCMdOAanSxCrwDAmgXnEw1U9zmZwZn8uW3gHRb5iinzFXLHoTr7Z/DP39h1Dq6SshjdkEskkYA/gEBHZS1W/bWgFEdkHp9JDgS+aOD5jjDFNTFX7hDLfGGNMyxRMlx2XAD8BbYCjgd1F5GHgdVVdW9cKItIROBm4gurm3rnutowxETR58/dsqNgEQNfUTuyVs0uUIzIthaqeH+66biu9M4Gbqdmn+brGxmWMiW2Ht9uPfuk9OW/BjSwoWQLABxu/5LfCWTy11e3slL1tlCM0zWgsMAZnbIzxInK8qk6uL7GIHAi86X4sIzKV6cYYY4wxxpgY12D3UKo6HzgKKHJndQUeAFaJyAIR+URExrnTJyIyH1gNPIhTgSHuuke62zLGRNCb6yZUvT+2w2EkSVIUozGmYSJyHDAbp6vBynIiH7gFsMH3jGkBBmf257NtX+bEjiOr5i0tXclRf5/LEytfxaveKEZnmouqrgJuwykH2gJfiMhkEblURA4Wkd3d10tFZDLwOdAOpxXGnaq6LHrRG2OMiQQR+U1EfnVb2vnP7+VO6dGKzRhjTOyQYPsgFpHBwNuA/+Nx9a3s3yXILOA4Vf07rAgTzLBhw7RyUB1j/BUVOfWEmZmZDaSstrZsA8P+GIUX52bPd9u/Td/0nk0Sn2k6QR77uO9qSUSGA3cBQytnASXAU8A9qroxSqHFDCsjTF3CKR/iyUcbJjFm8X3keQuq5v271VAe63czPdK6RjGy2OeXN+K6jBCRJ4AL3Y+BLk4qv+cTqnpp00YVe6yMMPVJ9HLCNE5RUVFMlxMi4sM59x+lqh/Vmu8DRvvPN3WzMsLUx8oIE0islxH+gh6o262EGAqcAkzDKUzqG5TV56b5P2CoVWAY07DMzMyQC5X3N0ysqsD4V6uhVoERp8I59vHEfZJ2KvAJTjkigBdnzKStVfVqq8Awpn6Jfo4Y2f5AvhjyGjtnD6ma91P+Hxw08xQ+2GBDHgSSKHlDVS8GTgDmUv/1hQBzgGNbYgWGMYEkyrnANI04zxtxcWPNmFhmZYQJJJ7yRjBjYlRRVS/wOvC6iOQAuwE9cJp1A2wElgM/qurmSAZqTKL7448/ABg6dGhQ6VW1RldSx3c4vAmiMs0h1GMfL0Rke5yWF4dVzsJ5yuot4CZVXRCt2IyJJ4l6jvDXM60r7w9+hsdXvsojK17Ch488bwEX/nMLX276jtt6X0aHlHYNb6iFSaS8oapvi8g7wM7AnjjXGK2BPJzri29V9dcohmhMzEqkc4GJvD/++CPW80Yhzhh5HaIdiDGJyMoIE0gclBFVAlZiiEh3VV1R1zK3kmJiKDsTkVTgVlW9PpT1jGkJQi1Yfi+czfySxQBkejIY0W7/pgnMNLlE+1EhIlsBtwPHU/30LMBnwPWq+me0YjMmHiXaOaI+yZLMFd3PZO/Wu3LxwltZWroScAb9/nrzT1zf8wJO7DgSjwTdkDjhJVreUKef2+nuZIwJUqKdC0xkxcENqqXAIGAk8FKUYzEm4VgZYQKJgzKiSkMtMWaKyBWq+nJjdyQi/8YpkAYCVolhTCO95dcK44h2+5OVFD9NwExiEpGuwM3AGTjlS2XlxffAdar6XbRiM8bEj2GttuOLIa9x05KHeWf9pwBs9uYzZvF9vL3+E+7tM4ZtMvtHOUpjjDHGRMgkYDBwhIjMBP4ESv2WXyIiR4axXVXVMyMQnzHGmBjQUCVGDvCCiBwLnF1fq4xARCQduBu4GEgi8GB9xpggFPtK+GjjpKrPx3ccEcVoTEsnIm2Ba4GLgHSqKy/+BG5Q1U+jFZsxJj61Ssri0X43Mardgdyw5CGWlDo/QX8tmMnwmadxZpfjuLL7mWQnZUU5UmOMMcY00gM446m2wanMGOy3TID9GrFtq8QwxpgE0VB7/BKcQuMQnFYZp4eycRHZB/gLuBSnAgNgXKhBGmNqWlu2gW0y+5PpyaBPWnd2zd4h2iGZFkhEMkXkBmAhcBWQgVNmLABOVNUdrQLDGNMY+7XZjcnbvc6l3U4jRZxnb7x4Gbv6f+wz4wQ+3PAlTg9ExhhjjIlHqrocZ7zVCTgtMPy7o8Xvc6iTMcaYBNJQS4yhwCvAv6nZKuMct6Cpk4hk4dSmn0N1AbISOE9VJ9S3njEmOL3Tu/Pe4GfwqpcN5bmI2G80ExWLcAbgq8yAK3DGwnhJVb1Ri8oYk1AyPOlc0+Ncjmp/CNctfoAf838DYHX5ei7452ZeX/shd/e5iq0z+kQ3UFMvEVnovlVV3aqO+eGqsT1jjDHxSVXnAiNFJBnn+iId50EpBc4FvoxieMYYY2KANPT0mjh3R6/EuTGVjlOI5ANXqOoWgy6JyCHAc0BPqm9sveym3xy50OOLiBwBHNG/f/+z58+fH+1wTAwqLy8HICUlJcqRmOYW5LGPuZoqEfHhlAkCFALvAsWN3Kyq6oWNjS3eWBlhArHyoZqq8sGGL7h92ROsLd9QNT9VUris+xlc0OVkUjwNPaOTOPzyRsyVEf7c8gKcc3xSrfmV5Ug4amwv0Q0bNkynT7cxz82WrJwwgZSXl8d8OVEXvzLiKFX9KNrxxDorI0x9rIwwgcRTGdFgJUZVQpFBOJUR/3JnKfAFzlgZy0UkB3gUOKVyFWCpu9xqzV1WsBhjwhRzhYrfhUVEtaQbUrVZGWFMcPK9hTy0/AVeWvMOXqobfm2buTUP972BIVkDoxhdVMRcGeFPRBbjlheq2reu+eHy316iszLCGNMIMVtOiMj27ttFqprvN/9l9+1jqvpHswcWZ6yMMMY0QsyWEf4aGhOjiqrOAfbAGby1sp/Cg3HGyrgTmI1TgVH5xZ8FhlgFhjHBmTZtGtOmTYt2GCYK4vzYh9tHrfVda0yQ4vwc0SRaJWVxa+9LmTjkFXbM2qZq/qyi+Rw260zuXfYsZb7yKEbYPOIlb6hqH1XtW7vCwX9+uFO0vpMxsSRezgUmOuIgb/wB/M6WA3gvxum+tqiZ4zEmoVgZYQKJp7wRUnt7VfUB94vIxzitMnYFWgPXUX3zaSFwpqpOjWSgxiS6WbNmAbDLLrsETPdHwWw+3DiJHbIGMSx7O3qkdW2O8EwTCvbYx6DaFxrGmCYQx+eIJrdNZn8+2OY5Xlj9Fg8sH0uJluHFyxOrXmVR6TKe2eoOPBL0Mztxx/KGMQbsXGACmzVrVrzmjVtwWuv9AcyLbijGxC8rI0wg8VRGhNVpsKr+LSL3AG/X2sZaYC9VXRWJ4IwxW/om7xfGrv4fAKd0Gs09fa6OckSmpbLKamNMLEiWZM7rehIHtdmLqxbdzS8FfwIwYeNX9Eztyo29LopyhEZEfsO5EXWFf9khIr3ct2tVtSQqwRmTYHz5+ZRP/Y6yb38gqVsXMi9tcUONmfjjw3ko1jrsN8YYU6+QH00TkRwReRV4H6cCo7ILEAU6Aj+LyGERjdIYU2VG4Zyq9ztkDYpiJMYYY0zs2CqjF+8NfppTO42umvfM6nG8uub9KEZlXEPdKafW/MU4rbgPbt5wjElc5T/8TO4Rx1J0/yMUv/x6tMMxJhi57mufKMZgjDEmxoVUiSEiI4BZwMlUV1w8BOwPzHfn9QA+FpFXRKRNRKM1xvCnXyXG9lmDoxiJMcYYE1s84uGO3ldwUJs9q+bduOQhvtz0XRSjMg2w8ZCMiaCU3f8FHucyv2LGTHy5udENyJiGzcIpCy4UkV1EpHaLDI1CTMYYY2JMUJUYItJGRF4DPgS64hQwc4A9VPVqVZ0C7IBToVHZFPD/gNkiMrIpAjemJVpXvpGVZWsASPekMSCjT3QDMi2aiHSP8PZSReTuSG7TGNPyJEkST291Ozu4Ff0+fJz/z01M3DSV2UULWFa6ityKPHzqi3KkLUqh+9ohqlEY0wJ4WrUieccdnA+qlP/wc3QDMqZhb7qvvYGfgBIR8brzBPhARLxhTBVR+TbGGGOahKgGrtQWkSOAZ4EuOAWIF3gYuFlVS+tI/2+cQb8HurMU+B9wiapujFzo8WnYsGE6ffr0aIdh4tSk3O85dd5VAAzL3o4Ptxkb5YhMM4q5J1VFZBNO/+YvR2Bb/wZeAgaqalKjg4tTVkYYEznryjdyxKyzWFZW91Bt7ZLbcFX3szml01GIxNwpNlQx/QVEZBYwCPhYVY/0m+/DuVY4SlU/ilJ4ccPKCBOs/MvHUPToUwBkXnslre65LcoRmRgQs+WEiHiAj4BId0uuLem6wsoIY0wjxGwZ4S/gwN5u64uTKj8CfwOnq+ov9a2jqj+JyFDgDuByIAn4D3CgiFygqtYxsTFhqjkehnUlZaIuB3hBRI4FzlbVFaFuQETSgbuBi3HKC2suboyJiI4p7fjvwIcZNfscNnvzt1i+sSKX65c8wKTc73mo7/V0Sm0fhShbjEnAYOAIEZkJ/An4Pwx1iYgcGcZ2VVXPjEB8xiSUlL12B7cSo/yb76McjTGBqarPfXj2SJyKjJ5AGrAPzrXBbGB91AI0xhgTEwJWYuCMfQFO64uHcFpflDW0UbeFxjUi8i7wCs6TV52Ad0TkXVU9PvyQjUlMP/zwAwC77757vWn+LPy76v32Nqh3wgjm2MeoEiAdOASYKSIhtcoQkX2AF4B+VNf8j4t4lMbEuTg+R0Td1hl9+N/Ax3h81SusK99IgbeIPG8BuRV5FPtKAPhq8w8cMPNkHux7HYe03TvKEYcmjvLGAzhdzbbBqczwfxJDgP0asW2rxDAtXu1zQeqeu1UtK5/2K1pcjGRkRCU2E30//PBDzJcT6nQRMt6dgKrWegA3WGs9Y8IXR78XTRTEQxlRKZgxMWYBu6vqtcFUYPhzW2wMxblw8eJcpBwTapDGtATz5s1j3rx59S5XVWuJkaAaOvYxbChOv7VCdauMT0WkR6CVRCRLRJ4GJlNdgbESGKmqpzRtyMbEnzg+R8SEHbIH8+LW9/HRNs/z1XbjmD70Q2buNJGzO59QlWZjRS5nzB/DNYvupdhbEsVoQxMveUNVlwO7ARNwWmAINZutS5iTMYYtzwWeTp1IGjTA+VBeTvkv1sVMSxYP5YQxpunEy+9FEx3xlDcaqsS4F9hZVaeFuwNVLVPVMcDuON1RGWPCsLp8HWvLNwCQ5cmkX3rPKEdkWjpVnQfsAVyD0ypDqG6VcUZd64jIITiV4+filEGCM47Stqo6oTniNsaYdE8at/a+lP8NfIwuKR2r5o9b9yEjZp/JguLF0QsuQanqXFUdCbQGuuFUYoPTVcg5QN8wpn4YY+qUulf1U5Vl3/4QxUiMCdt+wP6A9YlmjDEmcCWGql4fauuLANuaBuwI3BeJ7RnT0vi3wtg+ayBJ0mLGKDMxTB0PAjsBP+NUSrQGnheRzypbZYhIjoi8DHyK08+tAEuBQ1T1TFXdHJ1vYIxpyfbO2ZVJ2/2XI9odUDVvTvFCDp11Bu+tnxjFyBKXqlao6mpVXew3e62qLglnitb3MCbWpey1R9V7GxfDxCNVnepOG6IdizHGmOgLpjupiHFbZVzfnPs0JlEMzdqGR/reyOmdjuHwdo3pOtqYyFPVOTitMq6luquQg3FaZdyJMyDfKVR3//EsMERVv4xCuMYYU6Vtcg7PbHUH9/e5lnRJBaDIV8wlC2/jyoV3VY2dYcInItu7U6tai14FXsOp1DbGRJB/S4zyH39BKyqiGI0xzUdEkkSktYi0jnYsxhhjIqdZKzGMMfVLSUkhJSWl3uWdUztwXMfDubPPlZze+dhmjMw0tYaOfbxQVZ+q3o/TKuMXqltlXAd0dT8vBPZX1QtUtSBqwRoTRxLlHBHLRISTOo3i421fpF96r6r5b66fwJnzrqXUF5GGyREXR3njD+B3thzAezGwCChq5niMSSh1nQs8vXvh6ekMU6YFBVT8MSMaoZkYEA/lhIj8JiK/isg+AdKc4k4Bx98DRgCbgI0RDdKYOBVHvxdNFMRT3hBVjXYMLcqwYcN0+nQbWM0YE7K4GsBUREYBbwPJlbOAtcCOqroqaoHFOCsjjIm+Am8h1y6+n/Ebvqiad0ibvXmu/12keJIDrBlVMV1GiIgPZ+yLo1T1o4bmm7pZGWFCtfmkMyh5420Ash++l6zLL4pyRCaK4rKcCDWNm24UMB6n59sW0wezlRHGmEaI6TKiUr0tMUTkMRHp3JQ7F5EuIvJYU+4jVojIESIydvNm6/bdGJO43LEvXgXex6nAEHdSoCPws4gcFsUQY5KVEcbEjuykLJ7odytXdDuzat7nud9w2cLb8ao3eoHFN5/7Gj+PehmTAFL8u5T65rsoRmKMMcYY0ziBupO6GFgoIg+LSNdI7lREuonIozjdirSIx0FU9WNVPScnJyfaoZgYNXXqVKZOnVrnsmJfCdZqKnEFOvbxRERGALOAk6muuHgI2B+Y787rAXwsIq+ISJsohRpzrIwwgSTKOSKeiAhXdD+T87qcWDXvg41fMmbxffjUF2DN5hVHeSPXfe0TxRiMSVh1nQuKX3uDsinfVn0u/ehTNg4/El9eXnOHZ6IsTsoJY0wTiaPfiyYK4ilvBKrE+B3IAC4FlojIZyJykohkhrMjEcl015+I0//txUC6ux9jWrxFixaxaNGiOpc9u2oc2/52CCfMuYRJud83c2SmqQU69vFARNqIyGvAh1SPfTEH2ENVr1bVKcAOOBUaPnf5/wGzRWRkdKI2Jn7E+zkiXokIN/a8iFM6ja6a9791HzNm8X0UeAujGFm1OMobs3DO/ReKyC4iUrtFhj2pYUwj1HUuKJ3wGaVvvVc9w+ej/PNJFD30eDNHZ6ItTsoJY0wTiaPfiyYK4ilvBKrEGAZcAKzB6RLkYOA1YK2IfC0i94nIaBHZVkS6ikgagIikuy0thojI0SJyv4hMwekL/TXgIHd7a4DzgF2a7NsZkyBWlK1hszefb/Omsbx0dbTDMaaKiByBc3PqJJwbVD7gAZyxL36uTKeqpap6NbAnMNdN2wUYLyKvi0i7Zg/eGGMaICLc1ftKju1Q3QveG+s+Yp8ZJzB+/efWSjJ4b7qvvYGfgBIRqeybS4APRMQbxlQRlW9jTBxI6t6tzvnFL/0X9VrXeMYYY4yJL/VWYqjjWWAr4BpgOc5FRiawN3AV8A4ww11WJCJlQCGwDPgTZ1DXK4G93PUEWApcAfRT1bFqV3/GNGhF6Zqq991Tm3SoGmOC5ra++ACnMkKAv3FaX4xR1dK61lHVn4ChwIOA113vPzitMkbXtY4xxkSTRzw82Pc6RrU7qGre6vL1XLTwVo6ZcwGzixZEMbq48RzwKdXjJFVOlWrPD2UyxtQh7cgRtHr0PtJP+U+N+b7lKyib+GWUojLGGGOMCU9yQwlUtRh4UEQeAUbgdAEyHKdSItjtFQITgf8CE1RjqDNhY+LAirLq1hfd07pEMRJjajjZffXidBV1s6qWNbSSW8FxjYi8C7wCDAI6Ae+IyLuqenwTxWuMMWFJlmSe2uo2DmizO3cue5K15RsA+Cn/Dw6ZeSr/1+lIrup+Du1SbFybuqiqz225dyRwGNATSAP2welKajawPmoBGpOAUvfZi9R99qL8l+mUvPa/GsuKx75M2uHDoxSZMcYYY0zoGqzEqKSqXpz+zj8UkVRgD+BfwBCcpuHtcC5GSoGNOONezAR+Bn4I5saWMS1ZZmbdw82oKivKrCVGIqvv2MeJWcAZqjot1BVV9RcRGQrcgdNCLwk4JrLhGRP/6jpHFHgLya3Io0da1yhE1DKJCEd3GM7BbffikRUv8uKat6lQLz58vLr2fT7cMImre5zNyZ2OJFmC/ondKPFUfritr8e7EwAiUvlg0w2q+lFUAjMmAQQ6FyTvuAOSlYUWVo/lU/rJRLwrVtbb5ZRJLPFUVhhjIs/OASaQeMofYr05Na9hw4bp9OnTox2GiSMby3PZ7vdDAcj2ZDJn50mIWO8JLVDMHXQRuRu4NRKV1CKyC26rDFVNauz24pWVEaYhC4oXM2r2OeR689k6vQ9Ttv9fwyuZJjG/eDE3L3mEb/J+qTF/UEY/7ulzDbu22qE5w4m5MiIYbiWGAkdZJUbDrIww4dp00BGUTfq6xrysO24i+8YxUYrIREFMlxPBlAfBlhkiMgqnwlxb0nWFlRHGmEaI6TKiUqCBvY0xMaBGK4y0LlaBYWKGql4fqVZ2bkuOHYH7IrE9YxJV+5S25HrzAVhettoGlo6irTP68MbAR3lp6/vonda9av6c4oUcO+dC3l//eRSjixv7AfsD30c7EGMSWdqow2t8Tj3sYNKOOCxK0RgTUDA/bOzHjzHGtEBWiWFMjJg0aRKTJk3aYn6N8TCsK6mEVN+xb2lUtUxVr492HMbEGv9zRJuk1mR5nCa/xb4SNlVsjmZoLZ6IcEjbvflqu3Fc2+M8Mj0ZAFSol4sX3srzq99s0v3He/mhqlPdaUO0YzEmnjV0Lsg47yxS9tmz6nP5L7/iade2OUIzMSDOyokPRMRb1+Qul0Bp3HTvRzF+Y2JOvP9eNE0rnvKGVWIYEyOWL1/O8uXLt5i/orS6JUY3q8RISPUde2OMgZrnCBGhR1qX6mV+Fd0metI9aVzc7VSmbPcGgzL6Vc2/delj3LPs6SZrMdNSyw8RSRKR1iLSOtqxGBMLGjoXSHIyOW++iqerU37o+g1sPu4UtMyGrWwJ4rCckHompboVRn1prNsCY2ppqb8XTXDiKW/EbSWGiPQQkftEZLaIFIhIroj8LiI3i0ijHisRkX1FRIOcXonQVzKmTjVaYqRZJYYxwbAywiSy7ql+lRilVokRS7qndeG9wc+wS/b2VfOeXPVfrlp0N+W+iihGFn0i8puI/Coi+wRIc4o79WhgcyOATcDGiAZpTAJL6tKZnLdehSRniIDyn34h/6rqBrBaVIR30WK0tDRaIRrTUCVEsBUVVpFhjDEJKC4rMURkOPAXcA0wGMgCcoChwG3AXyKyc9QCNCaCaoyJ4XfjyphoEpHHRKRJa9VEpIuIPBbGelZGmIRWsyXGqihGYurSJrk1/xv4GAe22aNq3pvrJ3D47DOYUTgnipFF3VB3ygmQ5hXgZWCnILZnT9waE6LUvfYg+747qj4XP/Es63oOZG3bHqzN6sT6fkNY174XRY89hfp8UYzUtDSq6mmCqcUM6m2MMS1B3FViiMj2wLtAG6AIuAXYE9gXeATwAt2BCSLSLQK7PAPYLsB0QwT2YUy9Hux7PZOHvM5rAx5i99bBXNMb0ywuBhaKyMMi0jWSGxaRbiLyKLAQuCjEda2MMAmvh7XEiHkZSem80P9eju1QPXDurKL5jJh1Fncte4piX0kUozPGtGSZV1xM6mGHVH32LV+B5uZWfdbCQvIvG0PuQUfgXbosChEaY4wxxmwpOdoBhOFRnKdqvcChqvqN37KpIvIb8F+gC3Anzg2mxlikqjMbuQ1jGtS6dd3dOrdKymJQ5lYMytyqmSMyzaW+Yx/jfgd2BC4FLhKRycDrwHhVLQp1YyKSCRwF/B+wP5CE84TtbyFu6lGsjDAJpvY5okdadb3hChsTI2aleJJ5pO+NDMrYigeWP0eJluHFy9OrXufTjVO4t8817JWzS6P2EaflhzEmwkI5F4gIrV98mvW9BkF5ec2FSUngdcZPLvtqKhu2+xetnnyI9JNPQCS8hk+qSuk771PyznjSjx5F+gnHhrUdEz4rK4xp2ewcYAKJp/whTTXQYFNwu/+Y7n58UVXPqifdZJybYF6gm6quDXE/+wJfux/3U9Up4cRbl2HDhun06dMbTmiMSUiqykMrXsCHj2t6nBvKqjHVZYY4V7LnAjfjVAhUFibFwDTgF+BnYC5On+UbVbVURNKBdu40EPgXsCswDMio3DywGrgVeF6DLKisjDAtxa8FMxk5+2wAhmQO4PMhr0Y5ItOQRSXLuHrRvfyYX7Ne9uA2e3FDzwvpn9G7sbuIqTKiLiLiwykrjlLVj8JN46YbBYwHtCV1F2JlhImkipmzybvoCsqnfrflQhHw+/mVesRhtH78AaRdW4qffRFEyLz4PCQ9PeA+fOvWkXf+ZZS+92HVvOyH7yXr8pAa2prIiPlywjSOlRHGmEaIizIi3lpijPZ7/2KAdC9R/STvSOCFpgzKGGOCUeYr56pFd/PehokA9Errxgkdj4hyVOFxKxaeFZFXgQtxupfqCWQCe7tTDSLixTkv16Wy0FwCPAY8q6qh9rdiZYRpEaw7qfjTN70n7wx6kjfWfcSdy54kz1sAwBe53/LV5h84pdNoLu92Bu1S2kQ3UGNMi5E8ZBvaTZlIxZy5FN73CCWvvwkVFc5CVaRVKzQ/H4Cyjz9l/aSvkIxMdONGZ960X8m88BxK336fit/+JGmrvqTutzcp++1NUt8+lH7wMXnnXoKuW19jvwVXXIt4hMxLL2zy76iqlE38kqKHHse3Zi2tX3iKlH81rgWcMcYYY6Ij3sbE2NN9LcJ50rc+X/u937PeVMbEkIkTJzJx4sQa8/IqClhRuoYKrYhSVCZScivyOHHuZVUVGACfbZqKqtZ57OOFqhar6oNAP5zuoN7HaY0hdUzJ9cwvAt4DjgS2UtVHw6jAACsjTIKqfY7omNKOVElBENI9aZT4SqMYnQmWiHBSp1F8vd0bNcbKqFAvL615hz1mHMvraz/Ap8EPphvP5YcxJnIacy5IHjSQnJefpcOCGaQetH/VfM3Px9PHr5VYcUlVBQZA2Tvjyd33UIqffp7yn36hZNxb5J11IRu22o713fqzefSJNSowPL16VL3Pv2wMRU8+G1a8VfH5fJRO/JLc409h0wGHU/LmO9XLVCn9ZCIb/70fuYeNpmzyFCpmzmbziWegZWWN2m+kNccA6lZOGNOytZTfixVz57H5zAsovPchtMTGnwtWPOWNeGuJsY37Ol+1/ru6qrpSRPKA1n7rhOsuEekOdMW5MbYM+AZ4TlX/auS2jamyevWWT9NO3DSVyxfdSRJJ/F+nI7mrz1VRiMw01rLSVfzf3CuYX7K4at5JHUdxV++rEJE6j328UVUv8CHwoYikAnvgdBU1BOiN031UGlCK073UYmAmTpdTP6hqJK4orYwwCan2OcIjHr7b/m06prQn1ZMSpahMuLqkduTRfjdxZufjuG3p41VdTOV5Cxiz+D4+2PAlD/S9lr7pPRvcViKUH8aYxovEuSCpdy/aTHiXvDPOp2TcWwD4Fi8h7bij8c6dR8Wfwf+s8a1e47fhJEhJwbd0OSQnV7X2yL/4Ksp/n0HmuWfg6dUTT+dOQY274Vu7luKXX6f4uZfwLlpcNT/tOKdBbvn038g7/zIqpm85rJp34SKKX3iFjPPPRjdsQNq0QZLrvyXi27DB+S4eD4ozCLpv/QZQp5JH8/LR/HzSTz6B5AFb11i35L0PQARPl854unRGCwvxLVmGd8lSvEuW4V24iIq/5+Jbs5aO65YE993z8/GtWIkWFqEFBWihMwxdyp674QnQp7mVFca0bC3hHFD+2x9sOngkusGpbC9+dRw5r44lZddhUY4s9sVT/gi5EkNEFrpvP1bVSyMcT6D9pgEd3I/Lg1hlOc7NqYavAAPb3e99KtAG2A64UEQeB65S1fK6VjSmsVaUORcAXrxkJmU0kNrEot8LZnHavKtZX7Gpat71PS7ggq4nhz1AYqxzKyS+pmaLhyZlZYRpabqndWk4kYlp22UN5J1BT/JF7rfcvvQJFpc6p64f83/jwL9O5soeZ3NOlxNIlnh75sgYE68kNZXWrz2Pp0tnih56nKRtB9P62UeRVq0ofnosBTfeUdXFVJXkZLIfvBstLaV8yreUf/sDWuB0mZd23GhK336/arDwqu6qXCUvvUbJS685H9LS6Lh8Lp4OHaqWl377Pd5Zs5HsVlT8+Rfl3/9E+fTfthyQ3OMh/agjKB73FnlnXgClfi0URZBOHdE1zhBo+ZdeQ/7VN0JREdK2LWmjR5J+3GhSD9gXSXJ6PVVVCq67haKHHt8i5rqk7PYvkgdsjZaWUnDr3ZRP+ZaK2XPQvLwG1wXwrVhJUo/uVZ+1qIi8Cy4n8/KLSNlhO+dv8clEco85Gep4uljatCHzqkvIvOR8PK1aBbVPY4wJlZaWOt0NNjAeUnMr++kXcocfhW7eXDXPO2ceG3c/gKwxl5N183VIWloUIzSREs5VUU+cbqhmRDiWhviXxgVBpK9Mkx3m/lbjDBj4LbAQKAe6AYcAZ+D0+34JkAOcFuY+jAloZVn1U0zdUztHMRITjv+t+4jrFz9ImXsPO1VSeLTfzYxqf2CUI0tIVkYYY+KOiHBI273ZO2dXHl3xEs+segMvXkq0jLuWPcUnG7/i6a3uoHd694Y3ZmKSiPTAGTfqCKAXUAEswilDnlDVTQFWN6bZicdDqwfvJql/P9IOH46nbVsAMi+5gLRjR1N038P48vIo+2wSvtWroaKCogcfQzIzafvFh3i6daXi9z8hNZXk7YewdvzHTqVDrcHCt9yxIO3bV30sfnUceaedGzjWtm1JP/l4knfcgcKHn6TovoerF6amQlkZqFZVYABOpYRbMaGbNlHy4quUfvAxHVc7z2qqKgVXXU/Rw0+E9HfzLltO7jEnU/FL6AMrFz32FNl334akOK0ri55+npJXx1Hy6jhIS0Oys9CNm+r9+2luLoU33k7RI0+Sdc3lZF54DpKVFXIcxhhTn4o5c9l04BFo7mbaTHiH1H23GAIzKsqmfkvuiGOrKs+lTRsoL0cLC8HrpfDuByl55wM8nTri27gR3bARX+5mUobtRM67r5PUteU9GFYxfwGerl3wZId7KyR6whkTo/KuanCPFUSO/2PowXQ7Uvn4RTiPr08DeqnqBar6P1X9WVV/U9UJqnoxsBPVT/qeKiKHB9qYiJwjItNFZPq6devCCMe0VCtKqysxulklRtwo85Vz7eL7uWrRPVUVGG2SWvPWoCesAqPpWBlhjIlbGZ50rut5AZ9u+yJDMgdUzf+j8G8OmXUqEzZ+FcXoIi7AXcyQ0sQ8ERkO/AVcAwwGsnAqt4cCtwF/icjOUQvQmAAyzzuLpJ49asxL6tqFVo/eT85Lz9J20keI+9S/b/kKvPPmU3DznUhKCim7DiNl6PaIx0P7WdPouGk5nSo202HpHNpM+pjsh+5Gcvy6P0pKwtOrR1Ur5fJpv5J37iX1xubp1ZOMC86hzQdvknXFxZS+/1GNCoykwQPJvue2wF8wNbXqbfrokUhyMurzkX/JVfVXYNRqRS3t25Fxyfn41q1nw057hFWBAVD04ONsGLQTxa+/ia+khKIHHq1eWFrqdI9SVwVGairSsbrlim7YSMGYm1jfbwhFjz0VVizGNEQrKvCuXIVWtrAyCU99PvLOvsjtzq6QvLMvbtLxhdTno/z3Pymb+i1aXFx3GlVKPpzApkNHV1dgdOxA2ymf0f6vn0nZp3roS+/8BZR//yPev+fiW7sOysoo/+EnNu0zHO/yFQ3G48vPZ/OZF7Cu77YU3HpXTIytVD5jJvnX3cLmk89k04EjWL/tMNa278W6XoPIO+8SSr+YXBWn+nyU/zKd/OtvZf22w9gwYCilH38a5W8QnnBaYszG6fu7T2RDaZB/zk2tN1W1yrZCdef4AFS1sIHlc0XkZGCKO+sS4JMA6ccCYwGGDRuWEBdlJvLa+z15VGlFWXXfdNZ1SHxYU7aecxZcz/SC6n6DB2dsxQtb30uf9B51rlPXsTchszLCJKy6zhFlvnKWlq5gWekqkiWZvXJ2iUJkJtKGZA1kwjYv8tzqN3hwxfOUawX53kLOXXADp3QazS29LiHdU90cPk7Ljw8a6E5RgkgT80Rke+BdnIqLIuA+YDLO9dconLKhOzBBRHZW1ZXRitXEv2icC5K33YacN14id+RxVTfYyz6fhC8vr8b4DMlb9696n9SzB0k9e5B2wH6k7rEbG/c40Olqyusl44RjAPCuWUPu6BNrdglVi2/pMoqfHkvx02O3WJZ6+HBy3ngJT+vWZJx5ChW//0n59N/xrt9AySuvV7XKyLz0AtJGj6T07fdJGz3SqcA47xKKn3+lemNZWaQecgBp++5Fyl57kDRkG4ruuJfC2+8FnEqDktf+R/GTz0HlAN1JSWRdfxW+3M2UffI53oWLqrcnQvKwnUg77GAkK4uiBx9zbqjhjNeR939nkfLUWLIfvZ/Sd8dTOmGi05qkPmVlZD94N+L1UnD7vfgWL3H+PmvXUfbTNDLdzr/jtKxoEeKttZ6qsvnE0yl9ZzzpJx5H69dfTNgukhNJY88BJa+9Qfl3P1Z99i74h+Jnnifz0gsDrufLzaX8ux8p/2MGqfvtTeoeu9Wb1rtiJWVffkXZF5Mp/fIrdP0GACQri9TDDiZ99EhSDzsE799zKXlnPCXvfoBvydKq9T3dutJ20sckDx4EQNuvPqX4yWfJv/YWqKcixDt/AZv2PoS2X31CUp/edaapWPAPuaOOxzt7DgCFt91D6Yef0PrVsaRsPyTg928KvnXrKLjxdqesqqNyWzdupPi5lyh+7iUkJ4eUvfeg4tff8a1cVSNd6QcTyPjPcUB8lRGigZp01rWCyGnAS8DvqtpsTw65/Z1XdgD5iaqOaCD9LJz+zleratcmimk2zlNVJUCWqvoaWmfYsGE6fXp4T2iYlkVV2frX/Sn2Odl+1k6f0ya5/gHbTPR9tnEKYxbfzwa/8S9GtjuQh/peH4kxTezXYQBWRpiW5oe83zh2jnPhsHP2ED7a5vkoR2Qi7feCWVzwz80sLa2+tz04oz/P9r+T/hlbXGjFfBkhIj6qW1jUF6//hUmg76TuclXVpAiEF3Ei8hWwH+AF9lfVb2otPxn4r/vxZVU9o6FtWhlhYlHJ2+9R9OyLpO6zJ5mXXxRwgOnaCu68j8Kb7nA+JCXR9utPKbj+1qqbZdKmDW1/mYKuXEXRk89ROv7j6vE16pB5zeVk331r1dgWW8T6zvtsPu4U50N6Oh0WzEBat6Js0tcUv/w6ZX5PpqadcAw5rz1f1cWTv+Jxb5F3xvlbVDB4Onci5+3XSN3beQJYVfHOm0/Z1O+QrCzSDtoPT6dOVem1sJCiJ5+j8L5H0E1+96pFyDjzVLxr11L20adVf5/s++8A8VA+9TvKpn6H5ubSYdlcknp0R8vKKH7ldQrvvB/fipW0nzWN5EED/cOL+XKipXFb6/0PZ0y9uqwARqnqr8FsrznKiLLvfmDTXgdXfW773ZcBb0yb+OfbsIH1g3aqqlSoJG3b0mHBn3jatasxv+zHnyl9+33Kpn5HxZ9/VVfwAhkXn0ere29HMjOr5nlXrabgmhspef3NhoOpp1tCT6+etP3qE5K36rdl/GvXUj79d6RVNp52bZF27Sj/4Sc2/+f0qvGVPD170HbyhBqV7gClE79k839OR3Nzt4wlJYWsW64ja8wVSHLd7QN8GzZQ9MSzeBcsdGJ3J8nOIv2k40nd/d91rqeq+FatrkorWVlO141PjaXwtntqjP0RlowM0o85kpzXalw/xkUZEU4lhgeYCuwBPKyqVzVFYPXsex3OwK1/qurQBtJuBloD01R11yaK5x3gGPdjJ1VtsB8Qu/gwwdpYvpntfh8OQJYnk7k7T7KnHGLU5op8blryMO9tmFg1z4OHG3pewLldTozUcbOD3wArI0xLsrR0Jbv9eTQAnVM68NuOH0c5ItMUNlfkc/Wie/hk09dV89ont+XnHd4nI6nGoIoxX0a4lRiRFpOVGG4XUZUn8xdV9ax60k0G9sep6OimqmvrSlfJygiTaNTrZdO+w6uf8E1JqR60W4Q2n75P2vCDqtJ7l6+gdPxHVCxYiG/JMryLl+BdtARSU2j1yH1knHxC4P35fGzcdR8qfv0dAE/vXs6NolqVEen/9x9av/xsvZUh4NzMzT3qP1U39lL22I2ct18jqVvoz8b48vIouu9hCh98vN6WF63GPkHm2adXfxevF+/fc0gesm3NuH6Zjm/lKtKPPKL2JmK+nGhJ3NZ6PxC4tV4Szjh8QbXWa44yIve4/6P0nfFVn9NGjaDNB0HcfDZxK++ci6paqHl69USSk6tamGVefhGtHr63Km3ho09RcPmYgNtLGjSAnP++QPIO21H0xLMU3no3mp+/RTrp2AFPmzZ45y+od1vSti3pR48i69brSereLaTvVfrJRHKPPqmq1Z+naxfSTzoeaZODp20bvMtXUnTvQ9WVJmlpZJx+MsWvjIOSkqrtJO+8I60euZfUvfaouf1JX5N36jlbtIDwl3HhOWTfe3uNsSnKvppC/tU3UvHbHzUT+5ePrtThB5F+/NHO+BZdOuPp0gnv3PmUjv+YkvEf12ipIu3bkXbEYaQdOYK0g/avUZFUmSTwXyw2hFyJASAibYHXgeE4P9CfxhncdIWq1t/us5FEZCqwN85JPkdVK+pJ1w2n1hrgVVU9rYnieRs41v1oN6hMo3z8sXMD6ogjnB+cMwvncsis0wAYkNGXr7d7I1qhmQCmbv6ZKxfdzaqy6vsOXVI68Gi/m4Pu3qX2sa9HXBQq0WRlhElUdZ0jyn0V9Ju+Dz6c+8ILh00lzRNMT2om3qgq/103nluXPEaplvFQ3+s5oaOTF/zyhpURMURE7gKudz/urqo/1pPuJJxrKoCzVfWFQNu1MsLUJ8jfkjHJu3gJG3bYDc2rOeRm9r23kzXmiojvr/TLr8g9eGS9yzPOOZ1WTz8asAKjknfRYgoffoKkfn3JvOjcOltthKJiwT/kX34tZRM+qzE/86pLafXAXUFto+yHn7Z4uvfjjz+2ciLGxGNrPe+y5azvu23N1lAitP/7V5IHDqh/RRN14ZYRZT/+zKbdD6j6nPPBm1BRweZjTnZmpKTQfvZ0kvtvReHdD1BwQ62xiDweknfcAcnKpPyb76vnJyWR1LtXze72gJR99iTtsENIPfgAkrcfgng8VMz+m5L3PqT0vQ+p+PMvpE0b0o46gvRjjyL1gH2R1PCvf0q//IrcUcfX291U1dfo0Z024/9HyrCdqJgzl7zTzqP852k10qQecRit7r2NpK36UXD9rfWPrVR727170fr5J0nq2pn8a26i7LMvGlwnacDWtHrkXtIOO6TeNKpKxR8zKP/1d5L79yNlz93rbTEST2VEyGNiiIh/+00BhuF0L1W5vKFNqKqGMxYHwHc4N6gygV2AOi8IgH1rrdNUKh97KAU2BEpoTEM2bKiZhVaUVQ/q3d0G9Y45C0uWcdeyJ5m4qcbvTUa3H84dvS8Pqeuv2sfehM3KCJOQ6jpHpHiS6ZzaoaoCdWXZGvqm92zu0EwzEBFO6TSanbO346MNkzi+Q3VveVZ+xKzK0SSLgGkB0n3t935PIGAlhjH1iedzQVKf3rR6+hHyTj6zal7acaPJvObyJtlfwT47MWeP7gz6vnowV+92A2l9xBGkjRpByq7Dgt5WUt8+tH7ioYjFltx/K9p+/A6ln35O/mVj8M5fQPopJ5J97+1Bb6Ou7kniOX8kIre13n7ux1dqV2AAqOrrInI6Tmu9U0Tk2oZa6zW1oqef37I7N1WKHn6C1s8Fd8M2EXjXrME7ew7eRUuc1mCLl4LXS9aN11SNxxBrAp0D1Oul/IefKP3kc7SoiJQdtiN55x1JHrg1+edfVpUu9YjDSB81AlUlZc/dnBZ05eUUjLmJ5MEDKbzrgaq0Kbv/m6wbriZlj3/jyclBVSl+8VUKLhuDFhaC11ujAiNp8EBaPfEgaQfsR23J2wwme5vBZN90Lb78fCQjo96b8aFKO2h/2n72Prkjjq0aHLy2lL12J+ed/5LU2bknlzxoIG2/+5KiBx+j4Ja7qlrPlX38KRs+mYinZ4+aLSA6tCf75muRnJyqVh0l735QVVntW7LUqViv3VVWaiqetm3QgkLnb4bTmiLr+qudSvMGKm9EhJQddyBlxx0a/DvEUxkRzpGvXUvRnLU171P9VNOZ1H+DqrKW2gt81BSBiMheOP2pA3wXTF/nxoRiRWl1JUY3q8SIGbkVeTy64mVeWfsu5X4P+rdLbsN9fcZwWLt9oxecsTLCtCg9UrtUVWIsL11tlRgJbtvMrdk2c+toh2GCU3n+n19fq0AAVV0pInk43RtuU186YxJdxknHU/7jzxQ/NdbplumlZxrVHauq1rn+zMK5nDn/WjbdnsMx470UZHn4bo9WrOmcyv45eezaahYXU7MSw6teHlrxAmd2Po72KW3DjikUaYcdQuqhB+Nbu7bqxllL5LZWCIcPyAc2AjOAKar6Z8QCa7zRfu9fDJDuJZxKjCRgJFGs6NbiYorHvlz1OfPyiyh65EkAil99g6zbb6yRV72Ll5D/3vtkjzxii3EGmjxWn4+ih5/AO38BWTdfF3I3Q4EU3vsQBTffuUW3PgDlP/5C+5m/1NVNT8zxFRRQ9tVUSj/8hNKPPqkx3kVVm4SkpOpKq4wMWj/uVFKICK0euoeN/9oXgNL3P8K/O57UA/alzYdvOeM4uESEzLNOI3X/fcg75RzKv3fHPcrOJuvW68m85PygWrJ5WrUK9yvXK3WfvWi/4E9KP/oU3bgJ36ZcNDcXzcsn5d+7kHHeWVtUGEhyMlnXXkn6CcdQcOPtlIx7y1ng89WowEg99GBav/QMSV1qnsfTTzmRkjfeJv+Sq9GNG52ZlRUYIqSfdjLZt99IUo/uziKfDy0sRLKyEI8n4n+DeBJOJcY31Bx0r9mo6q8i8jVOrfVpIvKqqn7rn8Ztll3Z3um12rXVItIHqKzym6qq+9Za3hYYqqr+T0ZRK81AYJzfrKfC+DrGBFSqpWR5Min0FdE9rUu0wzHArwUzOXXeVWyqqDmQ0tHth3NTr4vpmNKunjVNc7AywrQ0PdK6MK1gBgArylZHORpjDICIpOGMzwSwPIhVluNUYFgtpGnRWj/5MFk3jcHToUNQXTnVRVV5fNWrPL7iZUZ3GM4Dfa+rWvbu+s8Ys+heSrQMspN49f861lj3q80/8tXmHzm83f70cx8KUFWuXXw/b6z7iE82fs3/Bj1Ot9RONJWZhfM4/5+bKPOVUablePCwd+GunNjxCIZlb4+IUOgtYk35hqoYKy0sWUa31E6ke9KaLL4o2JcI3XsSkZ+B81R1RiS210hRaa2nXi8Vv/6OL3czWlCAFhahhYUkDxpA6r57B1y35I23q262evr0JvuBuyj77kcqpv0KpaUUPzWW7NtvAmDz1K/IHXEM6QVl5N90Gx0/ep/0A/dvTOghKX56LAVX3wA4FQvtfvo6IhULdXaX5Me7aDEFd9xHq3vqTxOIFhZS/tsfVMyeg/fvuVTMnkPFvAUk9e1NzusvNq4yRhXNy6fgtrspmzyF8p+m1VkRU4Nfq5vsm8aQ1Kd31eeUXYeRfuJxlLzxdo1VUg8fTpt3X0fSa4zbViW5X1/aTp1IyWtv4F26jIyzTw9rHKFIS+rcucaYQ0Gv18c5NplXXkLBtTdT9sVkZ0F6Oq0evIuMC86ps0JdRMg46XhSD9yX/IuupPTdDwBnjIvs++4gZfshNdN7PEgTVODEo5ArMWrf0ImCy6geAGmiiNxLzQGQLnXTrQFuDGP7OcBXIjIT+AD4FVgJlAPdgUNwnuKtPAu+qarj69iOMY1yfteTOa/LSeR5627WZprXmrL1nDX/2hoVGLtm78CtvS5lh+zBUYzM1HIZVkaYFqJ7anUF9/JSq8QwJkb4X2UG8yOuMk12wFQ4zf1feeWVGvO23XZbdtllF8rLyxk3btwW6wwdOpShQ4dSVFTE22+/vcXyYcOGMWTIEDZv3sz48VsWV7vtthsDBw5k/fr1TJgwYYvle++9N/369WP16tVMnDhxi+UHHHAAPXv2ZNmyZUyePHmL5cOHD6dLly4sXLiQb77ZokcVRowYQYcOHZg7dy4//rhlA8ujjjqKnJwcZs6cSV19wR933HFkZmbyxx9/8Mcff2yx/KSTTiIlJYVp06Yxa9asLZafdtppAPzwww/MmzevxrKUlBROOukkAKZOncqiRTX79s7MzOS4444DYNKkSSxfXrNOq3Xr1owe7TyQPXHiRFavrnkeb9++fVX/5R9//PEW3T106dKF4cOHA7B+/XoqKipq5I8ePXpw4IEHAvD2229TVFRUY/2+ffuyzz77ADBu3DjKa93QGjBgALvvvjvAFvkOYi/vKco/xUtZV7GRAxnKwH16AbBs2TImTZ7EzMJ5HOgbCkASHg485EB6de3FS7+/gffP6r/N67//l15p3RgxYgRL09fw/cyfGLF4VwDu/eYBtsnsT7onLay8pyiF3mLyvPnk7ufj/q2vq5H3CrxFbFPklO0T/vULAHN+mcUL69YxzpNGh+S2rCvfhC9Zue/s28lMymDq1KnMWPAXc4oWkpPciq0z+pCVmVUj79XOW3Gm8g6gElwvIPWl+zfws4gcqqpTIhRbuJq8tZ535SpKXh1H6aef0/brz8DjYdO+w50ugOqQ/ch9ZF12YX1xUPT4M1WfMy86F0lKIuvqS9l83CkAFD31PFljrqDk2+/YfNRxpJc4N8BTiyvYOOJo2o9/i7RDD66x3WWlq3h3/acc2GZPtssaGMrXq5d32XIKrru16nPFX7PIO/8yWr/yXFCtu3wFBUhq6hZP3hfe/0iNCoykQQNI2XlHkvr0wpeXT/ETzwJQ9OBjpJ94LCnb1bwJXRctLqb852mUfTWVsq++ccZYqNgyO/iWLGXTgSNoN3Uink7BVaJqSQnl036lbOp3lH/zPeU9u6A+L4WvvFVnek+XzqSNOhxPzx5U/PYH5b/+UdWiIOVfu5B55SVbrJN9962UvPdh1cDYaUePIueNlxvu5igpiYzT/y+o7xEvUnbcgbaff0jZ11Mp+/4n0o8bTfKAhltPJ3XuTJt3Xqd8+m+QlBRU108tXWQ6EmtGqjpDRI4B/ge0AW53J38rgFGqurIRuxriTvWGAjwJXNWIfRhTpUuXLVtbiAg5yVbjGm1lvnLOXXADa8udi8e2yTnc2+caDm+7X6Oauleq69ib8FgZYRJRfeeIHn6t9JZbS4wWycqPmJTh974siPSVvTBk1LVQRM4BzgHo3r174yIzCSs9PZ2ysmCyW2Io8BZR6K0eiLVCvcwrXshmv4e/eqRVP90rCAMy+vJX0VySJZmBGX3ZvfXOdGnVhXY9zubzBV+wsmwtJb7SGi0ZdsrelvO7ncT3i39AUUq1jJlF8xicGXz3OIXeIlaXrWezN4+8igIqcG7ufrZ+Olf3ObdGWk+A64piXynL3LK+wuvljmVPck+fq8mtyGN20QJ8KBsqckkpWc42GTUHWU5txMC30aSqHhFpDTwPHAvMB54BpgALgUKcB5f64bTaOB/YGngHOA9IAXYFLgIOBtKAt0Wkn6pG5UnB5mitpz4f7118MH+3K4RBkP7N9UirVhQP+gcG1XMTfNZDpH02v86b794lSyjedS3s2glSUsgaJcjyF9B/+yi+egC+TbkAJI89loq58+Hk9ltu/8MLSU85kqT+/ZDkFPK8+byx7mOKfMU8suIlRrU/iD5pPYL9inV/b5SSN9/Be0Im1c+TAUwi7eOLSNlpx7rXKyujYtZsKn7/E++yFUhaGkmDB5A8ZFuS+vZxKhrmT4aznL9dUr8+pP/nWCTZ6f5IVSnptDPeJcsA8Iw/n/JWR5GelE6apDpjTnz/AxVz5kFJKVpahpaW1hxfZDAwOFCvDrl4nhhFxiknIhnVPxd869dT9sNP6IaNaFk5lJWjZWWkbi7ikM820G21UzndfngdY01sty2phw8n/cgRJO+y8xbdFPnWr8e7bAXJgwfWWTGR5A5IXXjbPaSNPIzs+++M2FgV8Sp1v31I3W+fkNdLGbZTE0QTvHi6nhDVqPQM1Wgi0gO4BBgB9MLp23wRMB54XFU31bNeHwJ3FZKK09/gv3EGhu2BU8hkAHnAApyBYF9U1b9DjXvYsGFa15MaxpjYddOSh3lpzTsAePDwxsBH2Stnl+YOoznHHwqbiCx0336sqpcGTNy0cVgZYRLelNyfOGmeM/Dpbq124t3B1nNZCxYXZURLICIdgHXux7dU9YQG0v+Mc5OtQFUDPrliZYQxzg3DYX+MYkPFJnZvtTMHtNmd/64dz/ySxVVpjml/KA/2vZ4UT80barOK5tM7rRvZSVmE4uvcHzlrwXWU+Jw6xzZJrXl78JP1jlOkqkwrmMF/137AJxu/olTrrmB6eqvbGdX+oKrPpb4ylpWuIs2TSooks6JsDW+tm8CHG76kwFfdWqRVUhZ39r6SYzocCsBtSx9n7Or/VS2/pse5XNrttNq7i7tyQkQ8wCRgH5yxIy5U1Xr7wBGRFJxKjtOBqcCBlePSua2zr8F50OhqVX24icOvL8YmKyP69u2rt9xyCwAL1s1iXXoZC7usYnbvZSR5PRw6fctB6+d1X8G8HitIK0vhoN+3vMk/u9dSFnZdTVZxOvvN2H6L5TP6LGJp53XkFGSx16xtt1j++1b/sKLDBtrntWK3v7fsvWDagHmsaZtL501t2GXegC2W/zj4bza0zqf7+vbs+M9WWyz/dttZbM4upNeajmy/uO8Wy7/efgaFGSX0W9WFbZb22mL5lzv+TmlqOQOWd2fAii0fFPhs2HS8ST62WdKTfqu37PaossXU9gv70GtdzQqiCo+Xibv8CsCOC7ai+4aalTulKWV8udMfAOwydwCdc9vUWF6YXsLXOzi9n+02exDt81vXWL45q5BvhzituPaauS05hTXPa8WeTdwy5gOyC31MHn04hR07IG3b4GnbBmmTQ89+/VpUa73arKVozZaip512WlyUEXFbTaaqy3EKoWtCXG8xAQpwVS0D3nUnY0wL9976iVUVGADX9Tw/GhUY8aQn4MEZRC9qrIwwLYF/SwwbE8OYmJHv977BLqL80lj/ocYEYUbhHFaXO/eAp+b9zNS8n2ssH9PjXC7uemqdraXrq3RoyH5tduPNgY9xyryryPMWkOvN4/g5F/P2oCfZxq9Vhk99vLV+As+vfou5xQvr3FbnlA7s0XoYe7bemd1a1Xz6Ns2TSv+M6n7nu6R2ZOfsIdza61I+3vgVH2+cRHZSFjf2vLBGS5Obel7E2rL1fLDxSwB+zf8Lr3pJkvDGFokhZ+K0sPgTOFcbeAJXVcvd1mu74FR8nE71wNnXAUcB/YFDgahUYtBMrfUkIwPqqTwzLUNRVhJPPrUPd3tOJI0KyvxbfhgTpxrdEkNE+gNHAv8CuuL0A5uP00f4L8B4Vf2ncWEmDnuCytTn/fffB2D06NHkVuQxdfMvdE/tTM+0rnRO7dDA2qYpzCycy6i/z6166uqwtvsxtv9dEelCyp//sQ8gLmrGRWQ5Tllwgqq+01B6U5OVEaYu9Z0jir0l7DbjaHqkdqFvek+e2OrWKERnoskvb8RFGdFSiMg6nFZ6f6rq0AbSbsbp73yaqu4aKK2VEaY+Qf6WjCsby3O5eekjHNZ2Pw5rt2/V/B/yfuOOpU8wo2hOjfSpksIj/W7kyPYH01T+KJjNf+ZeWjVmYbvkNrw96Imq7qVUlWPmXMBP+X/UWG/7zEEc0+FQ9s7Zlf7pvSN+LQFO97enzLuSbqmduK/PtTVaobz//vtxWU6IyFScAa1DajkhIlcCDwDfquo+fvPvBK4HVqlqVPrna67Wep9v+oZpT9+Md7EzrkHqgfuSusfuaEU5qCIpqZRPm07pp18EHfvy7qn8OmprjutwGCnidKX0e8Es+OYntp62BgBP506k7LkbvmXLqZj1Nz9u62H+1umM+CSXtrn1Dv8RFsnOJuOM/0PatCHvw/Ek/emcE6RVKzIuOBtJT0M3bqJ47MtO902BttW6FZqXHzBNpaQB/cn4j/MU+7d505hW4Dy7l1ShHPPeBnLytqwsUAFxb71mnH8WnnZtITkZQdCKcgrvegDJysTTri3SoT2ejh2cqUMHSEmm4pdfKfvm+zrj8XTpjLTKRrt2oqJLe0o65/B6yaSq5W8OfJx1k52uro468sgtuo3S4mLweJC0NEzLFE9lRNgtMUSkPfA0cDT131w7GrhXRN4FLlLV9eHuz5hEl5eXV/X+76IFXPDPTQDslDWEj7d9PlphtVgfbpjE1YvuqarA6J/em0f63dAkFx3+xz4BzMapxOgT5TiMSRj1nSMyktL5Y8dPmjkaE0sSrPxIJLOBvYGtRSS5voFbRaQbTgVG5TrGhCXRzgUTNn7F9YsfZEPFJn7K/4N9cnYlK8np43731jvx2ZCXWVG6hi9yv+GLTd9R5Cvmhp4Xsmurph0UdWj2Nrwx8FH+M/dS8r2FbKzI5bg5F/POoCcZlLkVIsJNPS/m8NlnkunJ4Kj2B3NypyPZPmtQk8YFkOpJ4eUB95MuaVtcr8Rx/qj8wy0Ncb3K9LX/8JVdvQYafKCpNUtrvUPa7s3evc4l78azAUia8ivt571YlTd8mzez/qzb0Y0bg9peRRKc83Q/1pSvZ27xIl7Y+h5eXjqOr/N+ImUbH4f83IHDW+1FmytvJO/8yyh96zMATk0TTnytP5MOyOHKx1ax+2+ltFlXArUepl7ZI4PJe2fxzZ6tWDQgm8NmZbHHt7ls9+UiMjfXVwGxFh69jcL2mWRtqO4KydM9CR17ByQlkTZiOJ4+x1N094NbrC3t2pE+eiTpp59M2c/TKbzi2qD+FqlHDKPt1WdR7quoqsAA6LWslK0XlDD6o5q9Fi/tkcpbx7bj6kecVtMdH7kET3b1oa+YNZsNL1ztflocVAwASQO3ptUDd1Gybg3/+/Bmnj9jI1vNKuXxw1ew6rGBTN7ZOdZXfnMRZ3yxE55yL/lfTqX1M4/V2E7hvQ9RePu9kJHhtOAJcLsj8+LzyL7l+hrzCm6/h7KJk+pZo9b6l11A+nFH15iXd94lVMzYsrukumTfeROp++9bY17uMSf9P3v3HeZGdTVw+Hek7X3XvVeKqTaYXmy66b0kkGBKEgIJJSEkX0ghhASSEFoglAABAgQIvTeDbaqxAVONMbivu7f3ovP9MVqtdu1tWkmjkc6bR49GoynHkbh3NWfuuQTW9G5Eev7tN5G+684d1pVNnwFNXVap66Dwf//BP2J46HWgqoqKGSf2al+A4jdf7JAsalm6jKqzzu/VvpKfR/Erz3RY1zz/Q6ov6V3hCf+4MRQ+dO9W3/NSHxFREkNExgBvASPo+e5gwZmEaR8R2V9VV0VyTmNSSWnT+tByeLkQE3sNgUb+sPIWHtjwZGhdni+Hu7e5rs/1c1PUw8ChwBk4d0AZY4wxqeZtnCRGDk5Zky2LJTumd9rHmJS2qbmMK1f8nefL3gitW9u0gZfL53LywBkdth2ROYRzhpzKOUNOjWuMU/J25L/b3RxKZEinyyGT83bgXxOv5YDCPciP82+HbF9WXM8XB20jD7qYjbpLgzrt36Yh+OxanSVVbRSRTTij9Xozk3XbNn2+jpZ18vFU//RytLKS1m++pXnu22RMOwCAuutvDiUwfGNGk/uLS/CPGY1/7Gh8w4aijU387+XrmLqolVFHnMwzhV+zUO8D4NWKtzjuwX1YuJ1Trqw5w8fjP9+ZE7a7Gp8/l4zpB9D46BMA5AwZyV9bz+C0kqf5zR9GMa1gL24b/Rvy11YRWLmKwIaNpO2yE9Vjsnho8U/Y0LwZgAf3ruXBvdP56d//yOUtR9K6YiWNz7xA4+NPEyhd0+HfGZ7AQIRA6drQy0XvPMPGxWnsmZ0N9fXt/9+ccxYFd/4DSXdGlARK15BxxKEEStegdfVoUxPa1MRre6fz9Rg/R71WzdiVTRAIIBnOPum+NB7c7gb+tOqfLP7gRa7/7mf4Ax0/g9cPLeap87fltm8PIv/WQWh9A5KT02Gb1nXrISMDmnr+WkpxMel7TSXz2CPJ/sE5LGlZzbkf3cayK52vybphGXy6fTpX/PYr5v93G6oK0ygd4qN0kDBqdSuBisotjhlaV1/vjMrohtZt+X7LF4tofm/eVrbeUuD0LUcLtnzeh/03b5l0a/noE1qXLe/V/lq95Wib5nkLoKFhK1tvZf/OI3paW3sdOwCBTl+Q+vpe7y9FRVserrKq9//fVW752XtRn5MYwcmVnqW9MV2LMyLjVeBrnAxxHrANcATwY2A4Tp3050RkSk+1DI1JdeFJjBEZQ1yMJLUsbVjFj7/5DZ/XtU+MNDZzBHdO/BPbZI91LzBveQCnfu1+InK9ql7udkDGGGNMnD2JU7IEnD6xqyTGucHnVpzfV8akrLmVH3DRt7+nrKUitG5o+iD+Ou5XHFK0r3uBbcWUvB15eLubufjbP3D3NteyfU7HCYfDy1+ZfikFxgOn4Fxz6q22zNaaTuvbRmBs7mdc/RWX0XqSk0PWd0+l/va7Aai/+34yph1A6/r11N5wa2i7vD9fRfZ3T+uw72efvcrPd/oAdoJpy7/m37lX89nCAdy7u/N/XVsCA2Bq3s48tN2NoRv+Mg4/hNwrf0H6tAPImLY/gzIy+NHKbO5c91/mVM3jhZq3OWvCCTBhfOgYE4HHtr+Vc76+gmWN7fmaQ4r3Jy1/HGnjx5F50DT0xr/QPOctGl+Zxcb3Z6PzPyav1rkwXF6cRknOYLR0Dc1+eOCsQdx1/mAKqlt5/IwlFIZdf29+74MOo0GyTj2JrFPbL7CvbdrAFcuu441Kp/u+96wSThpwBJeNOJchWe25pzRJ43cjLmLtxTfiVyH9oAPIOv1ktK6etB0nsd+B23FcenG3Cc3MQw5icN1GAqVraFnyDa2LFtPy5Ve0fPkVrYsWoy2t+AYOcB4jh1P06AMAlDau57uLL2VtevuF/eLKAJsGpLHrZ3VcfuNafnfVKAA2DE6nuKIFXV++ZQAtLZCW5jxHQOt7lwAwJhoiGYnxPWBnQIEXgDNVtXM6qxJYACwQkZuBh4Bjg/udBfwn4oiNSQGlje3D4UZkWhIj1lY0lPKPtffzv00v0qLtNSyPLj6I68f9moK03oz0NQCqGhCR44AHgctE5ACcHx1vAaWq2n1BUmOMMcbjVPVDEXkTOAiYKSL3q+pb4duIyJnAIcGXD6jqhnjHaUyiWNFQyg+W/B81gfY7qs8YeAy/G30xhWndTgPgmt3ydmT2Lg+TJhFX6DY9ew24AJgmIr9Q1R5HeYvIL3Am9VbglU5vt9WRWYu74jZaL2vmWaEkRsNjT5B381+pveavUOf8t5a2y05knXHKFvs99O7NMCV4jK9XUXH6oVwosOqaUbx2aFFou8lLlAePv7ZDxYK08ePIu+b3HY73q5E/JteXQ12gnuNKDt1qrNtkj2XOLv/l45oveaPyXeZXf8ZueTt22EZESJ92AGv2Hs+xX7xHZfMOjF3RyEEbh/Lr42/Hv2odkpdH7fAiHl/6A5qpYPMAHzdcMow//HG18+85+0zy/3E9kpGxRQyqyhObX+Z3K26ksrX9MmeAAI9vfomny17l9IHH8MuRP2JAerGzT10dJTf+jfT99+1Qagi2Xl9ZVblm1a18d9DxTMge7fy7/H78o0fhHz0KDjloq///hCtvqeTMxZeytsn50yHHl80lw2dyzu6ncOPY23m/fBX1NHOAv5G3Wp1STSu2KyTzplu2OFbBbTeSf+sNaG1tjyMSJHvL+eXz/3I1gV/9rMeYAfxjx2y5/+03otW9q5aWtu3ELdYV/u8/Pc55Etp/px22WFf85otbjpDogn/4sA6vJT+f4nd6V0oLcEbchB9v3Nhe7y9+/xbr0qdO6f3+W/nsvCiSHretgNky4NSeLkipao2InAZ8AYwDTsOSGMZsYeTI9oz+2qaNoeVhGX0dPWt6a3nDam5ecx9PbHqZVtqTFxmSzu9G/5SZg0+JyRwYnYV/9l4nIuEzmQkwFbg37P2eDqGqar8GjQnTXRtR2riOt6rms7pxHaMzh3PaoKPjGJlxWzL1H0noUuBdIBd4WUSuA2bh/P46HrgkuN164DduBGiSh5fbghZt4SffXhVKYAxJH8jfx/2ag4r2cTmynnklgeHh78f1wNlAFs5cq9OBm4G5qhq62ioiWThJgUuAtrpjDcH9w83ASW7MjmXQvRC30Xodfnk1NVP35+upv7O9Ln7en6/aYqLnxkATz09toe3n8fHPOXfv+xT+cPVqqsYMYN42reyTO5n7zri+VyWXM3zp/Hxkz7X//eJnav7OTM3feavvP7XpFZ4vf4PlDaupaK0Gn1C/7Uh+cuK/yc4YCKPGAlAEXOf/NecsceYLeO6YYo4fdDgHjz+KzKNnbPXYqspVK2/m7vWPhtYJws452/FpnTNpeIu20qqtFKcVhrbx5eeTdfqWiaCu3Lv+f9yx7mEe2PAUFw8/m0k5ExmVMYyRmUPJ9GXwVd1SPqldRGnTOq4Y+aMt9q9vbWDm179gScNyANIljXu2uY4DC/cE4NnatynFuSn2mW3vYuHXl7G+qAKABzY8yQXDvrvFMUUEycuDvL7fvJk2qX9z/qTvvFP/9t99Sr/2z9h7z4j3lbQ0MvbdO/L9c3L6tb+vqKhf+7fxUh8RSa+7G07D/+/e3lEbrPt3L3ANoXyuMSbcoYe235FQ2do+sU5JWpEL0SS/L+qWcNKXF3S44wtgn/wp/G70xXGZgK9N+GefBDpnKWKfBTImyXXXRnxe9zU/X/ZnAA4q3NuSGCkmyfqPpKKqn4rIKcB/ca6nXB18hCsFjlfVziVPjOkTL7cFN5bey0e1nwOQJn7u3eYvTM7b8m5ZEzmvfj9UdamInI9TrtaHk4SYAQREZB1QhzOaYWjwfXB+e7QC56rqsrZjiciBOKWpAsBLcftHbEU8R+s1vTm3w+u6v7ffiZ++/z5kHHXEFvu8VvE25cHrEcMbc9nj0ybw+8k6/WRKLvsJ/9t9V1Y2rmFM5gh84tti/1h5u2oBly27huaw6lsZks6/trmOIRkDt9j+8OIDOK7kUJ4tc+5U//0Bqzhg5wNobq3lo5ovUJRphXuFtheRDvPKjMkcwQ3jrmTvgil8UP0Jf119J+9Vf8wjm55nU0s5d0y4hmx/3+ahqWyp5m+ldwFQF6jnutV3dHg/TfyhyhCCcOGwszokiVq0hXOWXMGCms9C624e/7tQAgMgy9d+t39BWh6/HPkjftN6AwDlGxv50dDvxOVGTeMdXuojIklitLUOX3e71ZaWBJ8HRHBOY1JKZUv70MVCf2IOofayFm3h8qV/7pDA2K9gdy4bfi77FOzmYmRJYS5OotsYEwcjMoaGlleHlSI0xgtE5I2et9qqAFANlAGfArNV9ZOoBRYlqvqyiOwMXAwcA4zGubi2DHgKuEVVt1Kg2pjU8GntV9yy5v7Q68tH/MASGKYDVf2viGwA7sRJQgD4gRE4vzk6X41dBvxAVTv0L6o6l8iuf8XKpcRhtF7T7Le6fC/v2j9s9WL2oxufDy2fPu50hq5+FPx+fGETC4/LGhVpSBGbV7WwQwID4C9jf7lFyalwfxxzGXMrP6CitYrSpnVM+/QMNjSXESDAbrk7dUhiAOwavJHx7MEnceWoi8j1O5Nw75m/K//b/jberlrAk5tfYbvscWT6tixH1ZPCtHwe3/6fXPjtb/m2YeUW74eXtlaUz2oXd7g+8WLZbN6qmh96fdXoSzh+wGEdjpHlywwtNwQaOW3g0Vy76g5qA3V807CCBTWfsUf+Ln2O3ZhEEEkjXotzN1FRH/dr276uu42MSVWPPfYYAKeddlqH+ouJWgfWy+5e91hoSGimZPCf7W5gv4LdXYsn/LP3OlWd7nYMxiSb7tqIkZlhSYymdaiq3V2VQpKg/5hOlBLfIjIPuEBVP43G8aJFVVcDVwQfxsSEV9uCHXImctmIc7mx9F72yp/MhcPOcjukpPTYY4957rsRTlVnicj2OBf3j8cpVzscJwFQizOB9wLgGeCZribKTiTxGK2nzc00v731SlVy1CFk7L/vFuvXNG1gduW80OvTBx2DLzMx7kP++cjzKUor4Pcrb0JRfjDkjB5HIA9ML+HqMZdx8dI/ALCueVPovc/qvqI+0NBh9MVe+ZN5ZtJdWy1nJSIcULgHBxTu0a9/x0652/Lyjvfx6Kbn+bLuG1Y1rmVV41pKm9bRrC0MzxjC5NwdmJK3A6MyO87BED4C48JhZ/GDoWdscfzwf09DoJFcfw6nfzaNVY1reW23hTy66XlLYpgOvNRHRJLEWA5MBo4C/tWH/Y4K298Y00ldcHItVbWRGDG0oqE0NIQT4GcjznM1gQHtn70xxmxNd21EoT+fPF8ONYE66gMNlLdUUpJeFL/gjKuSpP9oy7pt7Y7arelqu72BeSJypKrOjlJsxniCV9uCNEnjZyPO44CCPRieMQS/bDlxqek/r34/wgUTE08EH0kh1qP1mj/8GK1xJkyWIYPR9U5FqoDAQz+ZyOWdtn+/6mOuXvUPAjiTHO9fMHWLi+huO2/oaexbsBubmsvZv2Bqr/Y5acARvFD2Jq9UOKW1fPjYPmcCe+TtTH1rxyRGSXpRXP6OzvFnc86QUzusC2iAukB9l3OMqDojMwTh3CGn8uuRF251u84jMQAGBwawoXkzAM9unsUfRl8aGmVijJf6iEiSGK/izGtxnIicrKo9diIichJOxlyBVyI4pzEpo0EbadJmwKnxGN4Jmf5RVX65/C+hznyHnG340dAtJ7YyxhivEBFGZg7lq/qlgDMaw5IYxitU1SciBTg3Rp2KU372dpxJV5fi3GGbi1NCZDrwY2Ab4H/ABUA6sCfwE+BwIBN4TETGq2pNPP8txpjI2V3BJlXFcrRec1gpqa++ty+rPnqTQ9+o5K7zBzNvdPkWSYynNr/KJ7WLQq/PGHhMtEOKikk5E/u0vYhwx8RreLXiLfL9ueyWtxP5vZiMPN584ut2knQR4akd7qA50EK6r+tLuVtLYuT7c0PJmtpAHc+VzeKMQcdGKXJj4ieSJMZtOJniLOC/InI9cIOqbuq8oYgMwKn119YgNwT3N8Z0oTHQxF75k6lsqcIvfisLEkWPbXoxVEPSh4/rx/5ft38AGGOMF4zIaE9ilDauY5dgPV9jEp2I+ICngWnA3cBFqsE7OdpVAQuBhSJyG06S4xxgEHCoqj4PPB+sJ34Fzvx7PwRuiMe/wRhjjElEbZN6t/rgmmOq+OLU0aQ1B2hN97N9oJmABkITc7dqa2ikAkCRv4AZJdNciTsWMnzpHFNysNthREVP1y/Ckxj1wSQGwOD09rJgj2x83pIYxpP6fPVOVVeLyM9wfkD4gV8CPxeRT3Am+267Y2obnLJTaThDvhW4TFVLoxO6McmpKK2AJyfd7nYYSWdjcxlXr7w59PoHQ09n17xJLkaUGkRkInACsBcwDMjHmYx1DfAB8JSqfutagMYkgRFh82KUNq13MRJj+uw8nBEWnwA/UtVu58dQ1WYR+SGwB07i4xzgnuDb/wecCEwEjsSSGMYkpKZAM3evf5Qjig5kQvZot8MxJilpczNNwfkwHj+phC+yNwKQlpHFmzs/yPhOE3P78HHPNn/hxbI3Wd20jnMGn9KhzJLxjizZciQGwKD0EtLET4u2Mr/mU76pX87E7LEuRGhM5CK6BVlV7wzeHX4DkI0zlHv34CNc2y3k9TgJjLtIUSJyLHDsxIl9G/pmUse4cePcDiGpXbfqdiqCE6aPzhzO5SN+4HJE7ZLxsw+OxPsncDJd1zg/GbhORB4HfrK1EX2pwvoI052e2ogRGUNCy5bESC1J0H+chXOj0396SmC0UdWAiDwA/A34PsEkhqqqiPwP+DWwQ4ziNSYheakteLtqAX9adRt/WnUbhxTuywPb/d3tkJKel74fWyMiaTg3RR2B074X41QG6Ymq6oQYhpawmhd8BHV1bC5J458XDg+t/8nws7dIYIBTqmj3vJ3YPW+neIZpYqDjSIwGoL0NOKxof14qnwM4ozF+M/on8Q/QJBwv9RER11EJJjJeBi7BuetpzFY2W4Ez8dI/VHVFpOdKBqr6HPDc1KlTE+fKqUko06Ylz3DNRLO4bimPbXox9Pq6sVeQ4892MaKOku2zF5ExwFvACHqepFVw6qDvIyL7q+qqWMeXiKyPMN3pqY3okMRoXBfrcEwCSYL+o6322co+7te2fefaaW3FvEsijsgYD/JSW/BS+ezQ8sTsrV1CMNHmpe9HZyIyBXgEZ5Rdh7d6sXuvkuPJqPl9p4TyTT8dSnWu83/VuMxR/HjYmW6GZeIgfARN20iMtjagqdwfSmI8vvklfjnyAiuvbTzVR/Tr2xpMTPwM+JmIDKJjqZC1qrqx/yEaY0z/XLf6DgIEADiocG+mFe7lckTJK1jf/FlgZHDVWpwRGa/ilBysAfJwSg4egTNJ63BgFPCciEzp7d24xhjH8Mz2JMYaG4lhvCU/+Dy4j/sN6rR/m4bgc1PEERljYqZFW3i5vL3u/pHF012LxSQ+ERkBvA4U0Z60aAE2AY1d7GaAnEsvYuGMcbxQfU1o3Z/G/rzDXfomOR1UtDdFaQVk+TLZJ3/KFu8NSR/I+uZNbGwu443Kdzmi+ECXIjWm7/qcxBCRe4OLC1X1lrb1wYSFJS2MidBDDz0EwKTjJ/NRzecUpuWzU862TMqx8jL9Mb/6E16teAsAQfi/URe6HNGW2j77M89MijtjvgfsjHPn0wvAmapa3WmbSmABsEBEbgYeAo4N7ncW8J/4hWtM4uupjRiTOYKjiqczPGMI22Z7Zziw6b8k6D9KgfHAKTgJ7946Nfi8ptP6thEYm/sZlzGe4pW24IPqTylrqQBgSPpAK10TJw899FDCfze68Cuc0lEKzAN+A8xV1WZXo/KAFm3lty0Ph14fU3Kw3ciXIqYV7rXFZx3eR5w68ChuXfsA4JSUsiSG8VIfEclIjJk4ncgn0Q3FmNTW3Oz8LTa78n3+Xno3ABcPn2lJjH5QVf60qv2ayIkDDmfHnG1cjGjr2j77JHFy8HkZcKqqdnuXlKrWiMhpwBfAOOA0LIlhTAc9tRFDMwbxr22ujVM0JpEkQf/xGnABME1EfqGqf+tpBxH5Bc6k3gq80untnYPPa6MapTEJzittwYtlb4aWZxQfiE98LkaTOrzy/diKI3Da+i+Aaapqo+x6aXnjaspbKgHI8WXz+9GXuByRcVN4G3D6oGNCSYxZFe+yubmcAenFboVmEoCX+ohI/mpou7OpNJqBGGMclS3tN60X+jtXSTB98VrF28yv+RSAdEnjFyN/6HJEKWE3nB8b/+4pgdEmuN29OMPEp/SwuTHGmORxPVAfXL5ORF4QkcNFpMOErSKSFVz/AnBdcHVDcP9wM3D6oNkxjNkYE4GABkK12AGOKjnIxWiMR7SVp73bEhh9s032WObu8ijnDzmdK0b+kOEZfa3aaJLV+KxRTM1z7vlopZUXw+YpMibRRZLEWBZ8HhjNQIwxjsrW9iRGUZolMSLVqq1cu/r20OvvDz6J0ZnDXYwoZbT1DV/3cb8lwecBUYzFGGNMAlPVpcD5EJy4yklCvARUi8gqEVksIqtw5tt7Kfi+AK3Auara9rsEETkQpzRVILitMSaBLKxdxLpmp/p0cVohe+dPdjcg4wW1wWe7gTYC+f5c/jDmUn4w9Ay3QzEJ5riSQ0PLz2x+3cVIjOmbSJIYT+H8eDgqyrEYY7CRGNHy8MZn+breubaR58vhkuEz3Q0odbT92Cjq435t29dFLRJjjDEJT1X/i5OcWIbzG0MAPzACmBh89oe9tww4QlUf7XScuaqapqrpqvp2HP8JxpheCC8ldUTRAaRJJJWtTYr5Kvg8zNUojPGQ+dWfcNbiyzhl0YVct+qOrW5zTMnBCALA+9Ufs75pUzxDNCZikfzlcDvwY+BoETlJVZ+MckzGpKRtt90WgGdb54XWFaYVuBWOZzUFmvnr6ju5Y137RGYXDDszoes8tn32SWI5MBkn0f2vPuzXlhhfHt1wjPG+3rQRcys/4Nmy1yltXM9RJdP53uAT4xCZcVuy9B+qOktEtgeODz6mAsOBXJzk+BpgAfAM8IyqtrgVqzGJKNHbAlXlpbCSJUeWTHctllSU6N+PbvwH2A+nX7jV5ViM8YTylirerHwfgFx/DrBlGzAkYyD75O/Gu9UfoijPl73BeUNPi3usJjF4qY/ocxJDVStE5HicHxGPiMjNwK2quiLq0RmTQvbdd18AKj+7LbSuwJ/nVjie9E39ci769vd8XtdeyWhM5gh+mOBDaNs++yTxKs68FseJyMmq+kRPO4jISTg/TrY2SasxKa83bcS3DSv478bnABiVaTcspopk6j+CiYkngg9jTB8keluwqP5bljc6FYHyfDkcULCHyxGllkT/fnTjHuD7wMEicr6q3u12QMYkuixfZmi5IeBMUbm1NuC4AYfwbvWHADxb9rolMVKYl/qIPicxROSN4GIFzkRLPwN+JiKlOLUK67vYtY2q6iF9Pa8xqaKytSa0bHNi9I6q8uDGp7lq5c2hjhpgeuFe3Djut6E7EExc3AZcDGQB/xWR64EbVHWLMaoiMgC4FLgiuKohuL8xpo9GZAwNLa9pWu9iJMYYY0xH22eP5+lJd/JS+WwEIdOX4XZIxgNUtTV4A+0TwJ0isidwi6p+7nJoxiSsrSUxtubo4oO4cvnfaaWVBTWfUdq4jhGZQ7vc3phEEEk5qek4d8sS9iw49WpH9LCvhO1jjAlz3333AVC5U9icGFZOqkdlzRVcvuxaXqmYG1qXKRlcOeoizhlyCj6JZOqf+Gr77GfOnOlqHNGgqqtF5Gc4pQf9wC+Bn4vIJziTfdfilAfZBqfsVBrtfcNlqmoT9xnTSW/aiOEZQ0LLpZbESBnJ1H8YYyKX6G2BT3zskb8Le+Tv4nYoKem+++5L2O9Gd0RkaXCx7ffCecB5IlIHbAYCPRxCVXVCDEM0JuFsLYmxtT6iJL2IAwqnMrvSKWf+XNksLhh2ZtziNInDS31EpLNpSS/XGWP6QFHqAs5gJj9+8nw2gqA7cys/4NKlf2R9c/tN/ttlj+e2CX9gUs5EFyNLbap6p4gA3ABkA+nA7sFHuLZ+ox4ngXFX3II0Jsl0SGI0rkdVCf53aIwxxhjjRWPpeANt2x82ucFHT+wGWpNywpMY9YGGbrc9ruSwUBLjmc2vWxLDJLxI5sRI/NuajfGoFm0NLRek5dkFqC6oKtetvp1b1/6nw/pzBp/ClaMvItuX5VJkpk0wkfEycAlwIjBmK5utwBke/g+bV8mY/ilOKyDbl0V9oIHaQB2VrdUU2Wg+4xEikgacABwB7AAU45Ql7IndZWuMMclrJZaIMKZPOo7EaOp22xnFB/Kr5ek0aTOf1n3FsoZVjMsaFesQjYlYpCMxjDExcsqAI6lqrbEL8d3478bnOiQwBqQVc8P4Kzm0aD8XozKdBRMTbfMmDQKGAflANbBWVTe6GZ8xyUREGJExhG8anHxgadN6S2IYTxCRKcAjQOchlL25k8MubhmTwP617hFWNa7lkuEzGZBe7HY4xmNUdazbMRjjNVnSuzkxAArT8pleuDevVrwFwLNls7hk+MxYhmdMv0Qysfe9wcWFqnpLlOMxJqWlSxo3T/id22EktJrWWv5aemfo9bSCvbhp/G8ZnDHAxahMm676iGDCwpIWxsTQiIyhoSTGmsb17JizjcsRGdM9ERkBvA4U0Z60aAE2Ad3/8jbGJLTylkpuLL2XytZqHt34PI9P+ic7527ndljGGJPUsv3tN8P2lMQAOH7Aoe1JjM2vWRLDJLRIRmLMxLnr6ZPohmJMattxxx3dDsETblv7IBubywAYljGYe7a5rkNH7UVJ9tnPxPoIY6Kqt23EiEyb3DvVJEH/8Suc0lEKzAN+A8xV1WZXozLGYxKxLfjHmvupbK0GYFD6ALbPtspvbknE74cxJjY6j8RQ1W7bgMOK9ifLl0lDoJGv6peyuG4p2+WMj0eoJkF4qY+IJImxGSgBSqMcizEpbY899nA7hIRX2riOu9Y+HHr9q5EXeD6BAUn32VsfYUyU9baNCJ/ce40lMVJCEvQfR+AkML4Apqlq98WbjTFblWhtwerGtfx7/eOh178adQHpPqtk7ZZE+34YY2In3ZeGHz+twf81a0u3bUCuP4dDi/bj+bI3AHiubJYlMVKMl/qISP6SWIZzgWpglGMxJqU1Nzs3Haanp7scSeK6bvUdNASvb+ySsz0nDTjC5YiiI8k+e+sjjImy3rYR4UmM0sZ1MY3JJIYk6D9GBp/vtgSGMZFLtLbgr6vvoik4oGpK7o4cXXyQyxGltubm5oT5bhhjYu9v435FmqSR5cvEJ9JjH3FsySGhJMbL5XO4fOQP4harcZ+X+ohIkhhPAVOBo4A7ohuOManroYceorylkvLDAhT68zmwcA/2yN/V7bASxsc1X/Dk5ldCr38/+mJ84nMxouh56KGHAJg5c6a7gUSH9RHGRFlv24jd83bit6N+yojMIWybNS4OkRm3JUH/UQtkYqP3jOmXRGoLXiqb3eFv9itHXYiIdLOHibWHHnooIb4bXRGR0KSQqnr11tZHKvx4xqSK0wcd0+H1fQ/dB3TdRxxUuDeZkkGjNrGo/luWN6xmbNbIrW5rkk+i9xHhIkli3A78GDhaRE5S1SejHJMxKauqtYZ71j8PQJYv05IYQarKH1aG5ojmqOLp7F0wxb2ATHesjzDGJROzxzAxe4zbYRjTF18B+wLD3A7EGNM/zYEWrl39T+5c99/QukMK92Wfgt1cjMp4xFU4pQUBru5ifaQsiWFMD3L9ORxYuCevVbwNwMvlc7lg2HddjsqYLfX5NmZVrQCOx7lj6hER+ZuI2C9mY6KgRVtCy4Vp+S5GklheKH+T+TWfApAuafx61IUuR2S6Yn2EMcaYPvgPIDj9hjHGo9Y2beDUry7qkMAYkTGUa8b+3MWojMd0NVxH+vEwxvTSjOIDQ8uvlM91MRJjutbnkRgi8kZwsQKnju3PgJ+JSCnORav6Hg6hqnpIX89rTCpo1UBoucCf52IkiaMp0My1q/4Zej1z8CmMyxrlYkSmO9ZHGGOM6YN7gO8DB4vI+ap6t9sBGWP67tuGlSyo+Sz0+pDCfbl5wu8oTit0MSrjIV1NmmKTqRgTJ4cV7Y8PHwECzK/5lI3NZQxKL3E7LGM6iKSc1HTah/S1PQswIvjojtD/4YDOgURGAj8FjgVGAy04E8o+BfxDVcv7cewRwBHAHsAUYCjOJLVpQBnwKfA08ICq1kX+rzCmo/CRGEVpBS5Gkjge3PA0yxudUtlF/nwuGTHT3YBMT6ZjfYT1EcZ1qkqAAH7xux2KMV1S1VYROR54ArhTRPYEblHVz10OzRjTB/sXTOXnI87nhtJ7+OXIH3HhsLOSZu46E3uqOqcv640x3fvZ0mv4sOZzGgKN3D7xml7tMyC9mD3zd+H96oUoyqvlb3HmYBsoaxJLJEkM2PrQvLgN1xORGcB/gaJOb00OPn4oIser6ocRnuI7wN+6eG9Y8HEE8CsRObkf5zEmZPLkyby+en7odaHfyklVtdRw45p7Q69/OnxmUt7RNXnyZLdDiDbrI6yPMFHUlzbixtJ7eWbza5Q2redv437FCQMOj11gxnVe7z9EZGlwMQ2nnzgPOE9E6oDNQKCrfYNUVSfEMERjPCER2oJLhs/k0KL92Dl3O7dDMZ0kwvfDGBM/pU3r+aZhBQDVrTW9bgNmFE/j/eqFgDMvhiUxUoOX+og+JzFU1dVbKkRkF+BxIBeoA/4CzML5txwPXIxzt+/zIrK7qq6J4DQKLALmAgtxSqCsA7KBMcCZOBeoxgCvichOEZ7HmJDJkyezhDXQ5Ly2OTHgn2sfpKylAoCRGUOZOeRkdwOKES91Gj2xPsL6CBN9fWkjKlqqWNKwHIDSxvWxCcgkjCToP8bScfReW8I7N/joSVRG7xnjdYnQFvjEZwmMBJUI3w9jTPxk+TJDyw2BRqZN3qtX+80onsZVK28G4O2q+VS31pLv782fY8bLvNRHRDoSw0034fyoaQWOVNXwGWfmiMhHOJMEDgWuAc6N4Bw3q+rfu3n/PyJyKXAjUAxcjlP33ZiI1dXVUV9fD8HKHwUpPhJjTdMG/hU2OeAvR17QoTNOJnV1TsWhnJwclyNJCjdhfYRJMn1pI0ZkDgktr2myJEayS4L+YyWWiDCm35KgLTAxVFdXZ98NY1JI5yRGb/uIUZnD2DFnG76oW0KTNvNGxXscP+DQmMZq3OelPsJThSpFZHfaJ3e6r9PFKQBU9UGgbWLZ74vI4L6eRzVsYoKu3QrUBJcP6Os5jOns0cceZZ8F7XcvFaal9sTef1/9LxrUGZayc852nDDgMJcjip3HHnuMxx57zO0wokJE7g0+Lnbh3NZHmKTUlzZiRMbQ0HKpJTGSntf7D1Udq6rj+vNw+99gTCJwoy0oa67guC9/wA2l97Cw5su4ntv0jZf7iXAiMkJEDhOR00Tk+715uB2zMW7I9mWFlhsCjX3qI44snhZafqV8i5/TJgl5qY/w2kiMk8KW7+lmu3uBg3HuaT8OuDvagahqi4g0AHlAVk/bG9OTVm0NLef7c1N6MtZFdd/w2KYXQ69/M/onNjmgd8zEuav2ExfObX2ESXkjMtpHYlgSwxhjTKzMqZzHhzWf82HN58ypnMczO9zldkgmSYnITJyRzZP6uKsCD0Q9IGMSXPhIjPpAQ5/2nVE8jetLnZ/HsyreoTHQRKYvI6rxGROpbq8KikhB8NHvq6kiMkREjhOR4/pxmP2Dz3XA/G62e3Mr+0SViBwCDAy+/CoW5zCppSUsiZHKk3qrKn9ceSuB4FyeBxfuw/4FU12OyvTB5uBzqQvntj7CpLzhYUmMNY3rXIzEGGNMMnuz8v3Q8vTCvV2MxCQzEbkX5+akSTjzJvX1YUzKyZKO5aT6YvvsCYzJHAFATaCOd6o+jGpsxvRHTyMxKoAAzt2tz25tg2CnAnCLqi7s5lh7A08FjxfpCJAdgs9LuivnoaprRKQKKAjbp99EpAAYBZxKx/rmN0frHCZ1+cXPqIyhnDfkNPL83qhHFwtPbn6FOVXzABCEX4+60OWITB8tA0pov4AfT9ZHmJQ3ML2YDEmnSZupaK2mprWWPJuQzxhjTBQFNMCcynmh1wdZEsPEgIicgTPKu807OGVhS4G+XZk1JoV0HInRSFYfZhIQEWYUH8idwflJXy6fw8FF+0Q9RmMi0ZtkQk/Z65k4w/SeBhZG4Xhb30kkk/aLYqt7sctqnItToyI5X9h5rwd+3sXbLcAlqvp2f85hDEC6pDEycxgzx8x0OxTXbG4u5/crbwq9PmfIKUzKmeheQCYSTwFTgaOAO+J1UusjjHH4xMfwjMEsb3QGQ61p2sC22TZtgDHGmOj5om4Jm1rKAShJK2KX3O1djsgkqfODz03AGar6tIuxGOMZnSf2huw+7X9k8bRQEuOV8rlcM+bnZPjSoxmiMRHx0pwY4fV1arrcasttYjU78ss4F6e+jtHxTYqZOtVKJv1uxY2Ut1QCzuS0vxp5gcsRxUeSffa3Az8GjhaRk1T1yTid1/oIk7T62kYMzxjansRoXG9JjCTmlf5DRH7XtqyqV29tfaTCj2dMqop3W/Bm5Xuh5emFe9ncdQnOK33FVkzGuWH235bAMKb3Ok/sPXXqAX3af7e8nRicPoANzZvZ1FLO45te4ruD+zMzgElkXuojvJTECE8dNvVi+7bhhX1LOW7peuC+4HIuTi3Gs4EZwKMi8kNV7a72OiLyQ+CHAKNHj+5nOCZZ7bTTTm6H4KrXK97h6bLXQq//MvYKclOkrFYyffaqWiEixwPPAI+IyM3Araq6Isantj7CJK2+thEjModAtbNsk3snNw/1H1fhXIgCuLqL9ZGyJIZJefFuC96ssPkwvMRDfUVnbT8G57oahTEe03li7762AX7xc/6Q0/nz6n8CcMua+zh14FGk+7x0Cdn0lpf6CC99A+vDljN6sX3bf7X13W7VA1VdB4TPjDkPuE9ErgSuAeaKyPGq+mo3x7gLuAtg6tSp/f2hZpJUZaUzAqGwsNDlSOKvurWWXy3/a+j1SQNmcFAK1V1Mps9eRN4ILlYAI3HmhviZiJTi1K/tqU1WVT0kglNbH2GSVl/biBFhk3uXNtnk3snMY/2HsPWERX8mXrU20xji2xZUtlTzYc3nodfTCveM+TlN/1RWVnqln+hsDTAOm6DbmD45tGg/xmWNJMuXydCMQRH1ETOHnMzt6x6ivKWSVU1reXzzi3xnkI3GSEZe6iO8lMSoDlvuTfmPtm16U1akz1T1TyJyLLAX8C8RmdDdRLLG9OSOx/5FeUsV9YencdLAI5hWuJfbIcXNtav+ydqmDYBTV/cPoy9xOaL4euqppwCYOXOmu4FEx3TaLyq1PQswIvjoTlcXuHrD+giTtPraRpw28GgOKtyHEZlDGJw+IIaRGbd5qP84qI/rjTF9EM+24O2qBbTSCsCuuZMYmF4S83Oa/nnqqae80E9szSyceTEmAw+7G4ox3jEic4gzMjvovv/eB/Stj8j153DB0O9y7erbAbhlzf2cMsBGYyQjL/URnvn2qWqjiGzCmbh1ZC92adtmVeyi4lmcC1SjgT2Bd2N4LpPkalvrKG+p5PnNHzAlb8eUSWJ8WPM5D2x4KvT6j2MuoyS9yL2ATDRs7W6pmN5BZX2EMe3GZI1gTFZPOUNj4kdV5/RlvTEmcc2uDC8llRq/V4xrbgK+D5wrIn9R1c0ux2NMSpk55GRuX/sQFa1VrGxcwxObX+KMQce6HZZJYV6bgevL4PM2ItJlAkZEhgMFnfaJhY1hy2NieB6TAlq0NbRclJbfzZbJo0Vb+NXyv6LBm+8PLtyX40sOczkq0x+q6uvnw9+P01sfYYwxxhgTQ5/Xfh1aPsjmwzAxpKqLgB8DRcArIjLW1YCMSTF5/lwuGPbd0Otb1txPc8CKCxj3eGYkRtDbwIE4EzztAbzXxXbTO+0TK+G3OcakJIlJHa1hSYxCf2okMe5d/z++rFsCOJNP/Xns5YhYyVMTMesjjDHGGGNi6IUd7+GLuiXMqZzHlLwd3Q7HJDER+T4QAP4HnA58JSLPA+8Dm4LvdUtVH4hpkMYkONX+TR92zpBTuGPtw1S0VrGisZQnN7/M6YOOiVJ0xvSN15IYTwK/Di6fR9cXqM4NPrfilPOIOhHxASeHrfosFucxqSN8JEZBCozEKG1cz99W/yv0+mfDz2NU5jAXIzJJwPoIY8JUtdSwsrGUMVkjyffnuh2OMcaYJOATHzvnbsfOudu5HYpJfvfRca69DODE4KM3FLAkhkk5i+q+4ZRFF9IQaGRC9hi+y8ERHyvPn8uPhn2Hv6y+E4Bb1tzHyQNnkNZ14QNjYqa337qdRKSin9vs1MtzdUlVPxSRN3EmAZwpIver6lvh24jImcAhwZcPqOqGTu+PBZYFX85R1emd3s/BufD0kKpuNbMvIn7getr/TW+p6vJI/13GAHw7YT3rmzcBqTES46qVN1EXqAdgu+zx/HDod1yOyD377LOP2yEkBesjTLKKpI2Y+fUveK3CGWj0wLZ/55CifaMdlkkAydZ/iMgIYAegGMjqzT52l60xydcWmOjy+Pej8zB9G7ZvTA/SJI2K1moA6gON/W4DzhlyKneufZiK1mqWN5by1OZXOXXgUdEI1SQAL/URvU1i/LGb97QX20TTpTiTo+YCL4vIdcAsnH/L8cAlwe3WA7+J4PgZONn6a0TkcZyhiquBepwfVFOAmcDOwe2rgIsiOI8xHXwzeA3lLZVA8s+J8Vr527xYPjv0+tqxvyDdl7qZ/O228+adbCLSNq9ErWrYUKLIjjUEZxJsVLU/oyMuxfoIk2QiaSMGpheHllc2lkYzHJNAvNp/dCYiM4HLgUl93NXusjWG5GkLTGx4+PtxjtsBGONFWb7M0HJDoLHfbUC+P5fzh57B9aVOJY2Xy+dYEiOJeKmP6O1Vw4TJdqvqpyJyCvBfnAmerg4+wpUCx6vqmn6cajTwsx62+RL4nqpamRDTL6qKVAQoJJfKvFoKkngkRn1rA79dcUPo9RkDj2Gv/MnuBZQANm1yRuAMHDjQ5Uj6rAKnFu1JdFGWSUTuDS7eoqoLuznW3sBTweNFnNGyPsIko0jaiDGZ7VOyLG+wJEay8nD/ERLsJ85ue+lmLMZ4VTzagjvWPkya+DlxwOEMCEuUm8S3adMmT/YTqnq/2zEY40WdkxjR6COOKTk4lMR4v2ohAQ3gE1//AjUJwUt9RE8XiubSPtIiYajqyyKyM3AxcAzOxaRWnBIgT+FcLCuP8NgVIrIbTjmS6cAEYAjOxbAaYA3wUfA8z6pqc7/+McYANYE69v3Cuflw1j6fkuFLdzmi2Hlw49OsaloLQHFaIVeOspvUn3/+eQBmzpzpbiCR6emC00ycfuRpYGEUjtcj6yNMsomkjRgdlsRY2diffJ1JZB7vPxCRM3D6iTbvAG/gJJsb3YjJGC+KdVvQGGjiH2vup6K1ij+u+gcv7XgfO+RMjMm5TPQ9//zznuwnROTA4GKlqn7iajDGeEh2pyRGNPqIiVljGJhWzKaWcipaq/iqfqn1A0nCS31Et0mMzrXAE4mqrgauCD76st9yerhIpqofAx8DN3S3nTHRUtVSHVpO5vkwAhrgvvVPhF5fPuJ8StKL3AvIJC3rI0yqG9shiWEjMUzCOj/43AScoapPuxiLMaYLr1e8Q0VrFQBD0gexffZ4lyMyKWI2zs1QfwMsiWFML3UeiRENIsLeBVN4vuwNAN6r+siSGCbubOyPMQmgbdIlSO75MGZXzmN542oACvx5nDbwaJcjMsaY5DQ6a3hoeUXjGlQTbmCtMQCTcS5Q/dsSGMYkrv9tejG0fMrAGVZCxMRLXfDZEhjG9EGapJEmfgACBNAoFdjZJ3+30PJ71R9F5ZjG9IX99WFMAhiWPpiJWWMYmzmCHww9w+1wYubf6x8PLZ8+8Bhy/NkuRmOMMcmrOK0wNLKvPtDAxuYylyMyZqtygs9zXY3CGNOljc1lvFHxXui1TeZq4mht8NnvahTGeFCWtI/GCGggKsfctyAsiVH1cdSOa0xvWRLDmARQkl7IoPQShmUM5oxBx7odTkwsa1jFm5XODyBBOHvISS5HZIwxyW10ZvhojNUuRmJMl9ombLEJvY1JUE9tfoVWWgHYI28XxmWNcjkik0LmBJ9363YrY8wWwktKBYhOsmGbrLEMSCsGoKK1isX1S6NyXGN6q6eJvY1LWrSFutYG6gMNpImfAenFbodkYuzAAw/seSMPu3/9k6FhjAcV7mM/gMIk+2dvjOmfSNuIMVkj+KxuMeCUlNojf9dohmUSQBL0H7Nw5sWYDDzsbijGeFcs24L/bXoptGyjMLzJw33F7cDZwEwR+Yuqrnc7IGO8ItuXFVreaZ9dGZIxsN/HFBH2zp/MC+VvAs5ojEk2L4bneamPsJEYCeqJTa8w6aPD2G3hsVy98h9uh2PiYPz48Ywfn5yT5NW21vHopudDr88dcoqL0SSeZP7sjTH9F2kbMSZscu8VDTa5dzJKgv7jJpxJvc8VkQEux2KMZ8WqLfi89mu+rFsCQJZkcGzJIVE/h4k9r/YTqvoh8FugCJglIju5G5Ex3hE+EqNk9MCotQMdSkrZvBhJwUt9hI3ESFBp8xbCYGe5av57MMHVcEwcrFu3DoChQ4e6HEn0Pbn5FapaawAYlzmKaYV7uRxRYknmz94Y03+RthFjMkfgw8fwjMFk+NJjEZpxmdf7D1VdJCI/Bu4GXhGRU1R1ucthGeM5sWoLwif0nlE8jYK0vKge38THunXrPNlPiMj3ccoOvgQcCSwUkbeAt4BSoL6nY6jqAzEN0pgEde+2fwWcZEZgUxPrqqLTDnSc3NuZF8Mndn+8l3mpj7AkRoLKDrR/NA00uRiJiYe/rb6LNc98S5r4Oew7R3J48QFuhxQ1qsp9YRN6zxxysnVynbz88ssAzJw5091AjDEJKdI24uSBMzh14FGWwEhiXu8/gheoAsD/gNOBr0TkeeB9YFPwvW7ZBSpjYtMWtGorT29+NfT6tEFHR+3YJr5efvllr/YT90GwHrHz7AMODD56QwHrI0xKGh9Wvvu+V+8DotNHbJs9jpK0IspaKihvqeTr+mVsn2N3XXuZl/oIS2IkqOyM9rtc6n0tLkZi4mFl4xqaAg0AVLZWuxxNdL1X/TFfBSd8yvFlc9pA+wGUhHYSkYp+bmPDw42JsvBh5MYkqPvoeIEqAzgx+OgNu0BlTIwsbyilJlAHwKD0EvYvmOpyRCZFSQ+vjTFx5MyLMYUX2+bFqP7IkhgmbiyJkaBysvJDyw2+VhcjMfFQ0VJNTnC50J/f7bZec9va9msLpww80oahJ6c/dvOe9mIbY4wxqcsuUBmTgCZkj+aL3V5hQc1nbG6uwC9+t0MyqecctwMwxmxp34L2JMa7VR9zzpBTXY7IpApLYiSo7JzC0HK935IYya6ytYqcYBqjKK3A5Wii552qD5ldOQ8AHz7Os84tWdkFJ2OMMZGwC1TGJLAsX6aNwDCuUdX73Y7BGK9q0RbqA400BBqjPm9F+LwY71d/jKoiYpcETOxZEiNB5WQXhKapakjX7jc2nlfZUs2wYBIjWUZiqCrXrvpn6PVpA49iYvZY9wIysTCX9pEWxpgEVNq4jsX1y1jRuJq986cwKWei2yEZE2IXqIwxxhhjou8Xy67jsU0vAHBJyykMTh8QtWOHz4tR1lLB1/XL2C5nfNSOb0xXLImRoLJziy2JkUIqW6uZv20lQNKUW3qpfA4f134JQKZk8LMR57scUeI65JBD3A4hIqo63e0YjEkF/Wkjbl37Hx7Y8CQAvx99sSUxkoxX+482ItI2OWulqn7iajDGeJjX2wITW/b9MCb1hM+NV7DnIA4pOShqx/aJj73zJ/Ni+WzAmRfDkhje5aU+wpIYCSontwg2OcsNGa6GYuKgurWWhuJGAAr83k9itGgLf1l9R+j1zCEnMyJziIsRJbZRo0a5HYIxJoH1p40Ykzk8tLyioTQa4ZgEkgT9x2ycEX1/AyyJYUyEot0WvFQ2G4B9C3anMC05RomnsiToK4wxfRSexGCwn1HDotsO7JO/WyiJ8W7VR8wcckpUj2/ix0t9RL+TGCLiAyYAxUBWb/ZR1bn9PW+yy8krCS03ZFptuWSmqjQGmhhSXgR06mw86n+bXuSbhhUA5Ptz+cmws12OKLGtWrUK8FbnYYyJn/60EWMyR4SWVzauiVpMJjEkQf9RB2RjCQxj+iXabcHfS+9hUf03+PDxxKR/smf+rlE5rnHHqlWrvNxPbEFE8oECoMfZ5lV1ZewjMibxhF9Xql5bxaqW6LYD+xRMCS2/V/0x9YEGsn29uiRsEoyX+oiIZ3YRkeki8jxQA3wFvAe82YvHG/2MOSWkZ+fhb3HKSLWkCU3NDS5HZGKlWVtQlD2+3pY9v94Wv/T4t1hCqw80cP3qu0OvfzzsLErSC7vZw8yaNYtZs2a5HYYxJkH1p40YndWexFjeaCMxkk0S9B9rg8/e/uPHGJdFsy3Y2FzGovpvAPCLjx1ztonKcY17PN5PICJ+EfmeiLwqIhVABbASWNbDY6krARuTAMKTGPXzy6PeDmyXPZ4BacUAlLVUcPG3f6BVW6N6DhMfXuojIkpiiMjvgVnAkTijL6SPD9MDn89HVmP7XBh11WUuRmNiqUmbQsu+yPOKCeP+9U+wrnkjAIPSS/jBkNNdjsgYY1JXeDmp1Y1r7ceFSTRzgs+7uRqFMSbk7cr5oeXd83Yi15/jYjQm1YnIMOBd4D7gEJwRGHbtyZgeZEl7EiOggagf3yc+fh427+mL5bO5auXNqNqcviZ2+lxOSkSOAH4ftmolzg+QUqAxSnEZIKtJqc11lutqyikqGd79DsaTGgPtSQwRb/+dFdAA/1r3SOj1pcPPJcef7WJExhiT2vL8uQxMK2ZTSzlN2sy6po2MyBzqdljGtLkdOBuYKSJ/UdX1bgdkTKqbW9WexDigYE8XIzGpLli6/Flg9+CqZcA84Ayc+ZRmA5uBMcBkID24/jXaR/oZk5LCR2IEiH4SA+DsISexrGEV/1rvXAO6d/3/GJ4xmB8POysm5zMmkjkxfhJ8DgCXAzerpdpiIqu5/YJ2fW25i5GYWMrz5/LIdrew4NN33Q6l3z6v+5p1zc6M9MVphXx30HEuR2SMMWZ05gg2tTh/R6xoXGNJDJMwVPVDEfkt8Gdgloicoaqfux2XMalKVXkrPIlRuIeL0RjDd3ASGArcDFyuqgEROSP4/s2q+iyAiAwCfg38FNgZuFJVP3QhZmMSQockRgwv2f5u9E9Z17yR58qckkTXrLqNoemDOHHgETE7p0ldkSQx9sTpRB5V1ZuiG44Jl9XcXlqorr7KxUhMLGX6MjigcA++TfvC7VD6bVbFO6Hlgwr3JsOX7mI0xhhjAMZmjeCjWue68IrG1exrlXtMghCR7wNrgJdwytQuFJG3gLdwRnnX93QMVX0gpkEak0K+bVjB2qYNABT489g1d3uXIzIp7pTgcylwhWrXNXFUdSNwmYgsAu4AnhSRyapqd4OalJQdh5EY4JSVumn8b9nYvJn3qxcCcNmyaxiVOZyp+TvH7LwmNUWSxGibofflaAZitpTd6oNgY1NXV+FqLCb2ZsyY4XYI/Taron00yaFF+7kYibckw2dvjImd/rYRo8PmxVjeYJN7J5Mk6D/uw7k5iuCzDzgw+OgNBSyJYVJetNqCuWHzYexXsDtpEsnlApNoPNxXtI3CeFBVW7by/hYTSqrqXSLyXeAA4Mc4I/2MSTnhIzE2TKnj4rGxaweyfJncs81fOGnRj1lcv5RmbeH2dQ9yT/5fYnZOEz1e6iMimUV4XfC5qdutTL9ltfpDy/UN1S5GYuJh6NChDB3q3RIfm5rLWFi7CAA/fqYV7uVyRN7h9c/eGBNb/W0jxmSOCC2vbFwTjZBMgkiS/qPzBKx9mbDV25OJGRMl0WoL5lZ9EFrev8BKSSULD/cTA4PPyzqtb7utPKuL/Z7A6R9OiEFMxnhCeBKjpqgx5u1AUVoB/5xwdej13Mr5HeZ/NYnLS31EJLdWvIMzkdKOUY7FdJIdSAOaAUtipIKlS5cCMH78eJcjicwbFe+hwZspp+bvTFFagcsReYfXP3tjTGz1t42YmD2WKbk7MiZzOHsXTIlmaMZlSdB/nON2AMYkg2i0Bc2BFt6r+ij0+sBCm9Q7WSxdutSr/URborqs0/pqoAAY0sV+64PPY2MQkzGesE/+bny1++tkSSarlq+MSzuwXfZ4xmaOYHljKXWBeuZVL7S+xAO81EdEksT4B3A6cLaIXKuqPdaqNZHJ1nTaSgHXNdW6G4yJmXerPuK8Jb/kkPd2odCfz59+fJXbIUXk9bD5MA4p3NfFSLxn7ty5gKcvQhljYqi/bcRueTvy/I53RzMkkyC83n+o6v1ux2BMMohGW7Cw9gtqAnUAjMwYyrjMkVGJzbhv7ty5Xu0nNgAjcRIW4dYE1+3UxX5tX167q86krHRfGunBS77x+ntRRDikaD/uWf8Y4FwjsiRG4vNSH9HnclKq+j7wO2AUzmRJhT3sYiKURfukyPXNNS5GYmKpPtBAVWsNzdpCi7a6HU5EmgMtHYafH1JkSQxjjDHGGGO8YkLWWG4YdyUnDjic4wcchohVazOu+zL4PLHT+o9xRmkcJyLZ4W+I88X9XvDlOowxcRV+LSh8zlRjoqHPIzFE5EDgbeC/wHeAJSLyAPA+sAl6nvZeVef29bypKFvaa9jVN9e5GImJpaawOoE+j/5Y+KDmE6pbndFCIzKGsl22N7K4xhhjjDHGGChJL+T0Qcdw+qBj3A7FmDbvAEcAne+QewL4Ls6cGU+KyGXAUmAC8EdgV5wJwWfFL1RjDMDe+VPI8WVTF6hneeNqvq1fyYTs0W6HZZJEJOWkZkOw8L3zPBC4rA/7a4TnTTnZYRPx1LdY1a5k1ahhSYy+D45KCLPCSkkdWrSv3bllQkTEh/ODopiuJ9/rwBLdxhhjjDHGpLwXgKuBfUVksKpuCK5/GvgI2A04HPhiK/s2AH+NR5DGJKJWbWVF4xoaAo3UtNaR58+Jy3kzfRkcULAHr1Q4P+lnVb5jSQwTNZEmEzpfobQrljGQ7WsfGVnfakmMZNUYaA4ti0f/UwofJnhI0X4uRmIShYhMBy4HDgYyu924I0t0GxMDn9Z+xSvlc1nesJoDC/fi9EFHux2SMV0SkXycWub+nrZV1ZWxj6hvggn87YE9g489gF2AjOAmB6nqbHeiM8YYb1DVj0XkKiAbp5z5huB6FZHjgVeBSVvZtRY4U1UXxytWYxJNfaCBAz49DYDj6vZmr/xd43buQ4r2bU9iVLzLD4d+J27nNsktkgtFf4h6FGarstPCkhiBBhcjMbHUqI0AvLXjFxxbcrDL0fTd8obVfNOwAoAsXyb7FuzmckTec8wxyTVsX0R+jzN3EliS25h+i0YbsbD2S25a828A0n3plsRIEsnSf4iIH6c0yPdwLvrn93LXRE18fw+4z+0gTOrob1ugqjaSOol5ua9Q1au7WF8qIrvilDg/FBgC1AHzgXtVdX38ojQm8WSFVXaZu+NnXL3zr+N27oOL9gktz6teSE1rLXn+3Lid3/SNl/qIPv/Rr6qWxIiT7LT24V71YSWHTHJpDM6JUZlXS0Zxr6rtJJTwURj75e9Ots97/wa3DRw40O0QokZEjgB+H7ZqJTAHKAUaXQnKGI+LRhsxNnNkaHlZw6p+H88khmToP0RkGE5pkKltq9yLJmrC/w3NwOc4v7t2dicck+z62xY8sOEpbl37AJOyJ3DqoKM4tuSQKEVmEkEy9BVbo6otwH+CD2NMmDRJI038tGgrFXm1FAwojNu5h2UMZsecbfiibgnN2sLcyvkcVTI9buc3feOlPiIR71wyQdnpYUkMLImRrJqC5aRGrx9ERhMwxt14+spKSfXf4sXOSOftttvO5Uii4ifB5wBOOambVVW72d4Y04NotBHjs0aFlpc3rO53TCYxeL3/CJZdehbYPbhqGTAPOANnlMVsYDPOX0eTgfTg+teAtfGNtk++BC4BPgAWqmpDsCSKJTFMTPS3Lfiybglrmtazpmk9exdMiWZoJgEsXrzYs/2EMSZyWZJJjdYxev0gvvzqS6bsMDlu5z6kaD++qFsCOHOoWhIjcXmpj/DmLMIpIiczL7TcIM3dbGm8rG1i712Wj4MvvHWjem1rHe9VfxR6fWjRvi5G413vvfce7733ntthRMueOBeYHlXVmyyBYUz/RaONGJ4xhExxyvFvaimnurU2GqEZlyVB//EdnASGAjcB26jqd8Pev1lVT1PVvYCRwM3BbXcGblXVc+Icb6+o6geqeouqvq+qVhPWxFx/24JF9d+ElnfInhiNkEwC8Xg/kXRExCciO4jITBH5p4jMF5FGEdHgY7rbMZrkkO13qmTssnwc8+fNj+u5Dylsvzb0RuV7BDQQ1/Ob3vNSHxHVJIaIpIlIsYjYCI8oyM5oT2LUS4uLkZhYaisnBXiuFu0r5W/RpE6CbVL2BEZkDnU5IpMA2sapvuxqFMaYDnziY3Tm8NBrKyllEsQpwedS4ArVrn/hqupGVb0MuBAYBjwpIsVxiNGYpBbQAIvqvg29npRjSQyTeETELyJniMi9IvKeiHwlIt9uZbudRGRfEdnRjTh76XvAF8C/gR/jlFPMcDUik5SypH1ejHgnEabk7UBJWhEAG5o383nd13E9v0lO/UpiiEiGiJwrIs+LyEaceuebgEYR2RBcP1NErEGOQHZ2QWi5wW9JjGQVnsTweWxw1FObXw0tHzfgUBcjMQlkXfDZauAZk2DGhZWUWmYlpUxiaBuF8WCwtnlnW/xhpKp3AXNxRmb8OLbhGZP8VjauoS5QD8CAtGIGpw9wOSJjOgqOTFgKPAScjTPye1tg7FY2Px54C3hHRLLjE2GfdZ436WPgM5diMUksfHLvAPEtkOAXPwcV7h16Pavinbie3ySniK+YisiBwNfAv4AjgQE4jXHbY2Bw/T3AYhE5oN/RppicrPYkRr3fhl4lq58M/x6zdnqQXXK2Y2C6d24o3NxczpzKeaHXJww43MVoTAJp++skke9+MiYljcuyyb1NwmmbSXBZp/Vtf/hmdbHfEzi/N06IQUzGpJQv69pLSU3KmeC5keEmuYnIsTjzII3EafdbgcpudrkTpw/JB46OeYCRaZs3aR+gQFV3A550NySTjDokMVwo5xQ+Z2r4XKrGRCqiJIaIHAa8CoyiPWlRA3yCcwHrk+DrtvfGAK+JSMreqi0ix4rIXZWV3fW3HWXnFIaWG9IsiZGsBqaXsH3OBHL9OWRIutvh9NpzZW/QSisAU/N27lCmxKS0f+DcVXt2At/9lHAi6SOM6auxlsQwiaftamlZp/XVwechXey3Pvg8NtoBGZNqFoUlMXbI2cbFSIzpSEQGAg8CfqAKOA8oArqcD0lVN+GMxABIyOtPNm+SiZeOIzHif01xeuFe+PEDsLB2ERuaNsc9BpNc+jx3hYgUAA/TXrPvBeA64N3OE7iKyH7AL4Fjgtv/V0QmqGpVv6L2IFV9Dnhu6tSpP+jtPjm5RaHlhnSbGzfZnXjiiW6H0CdPh5WSOtFGYfSL1z777qjq+yLyO+AanHrlZ6iqXZnvQSR9hEkd0WojxmW2l5Na3mjlpJJBEvQfG3Duri3otH5NcN1OXezXlpHrvJ8xKak/bcGX9UtCy5OyJ0QjHJNgPNxX/BRnREUTcKiqfgi9mkfyfWA6MCWWwRmT6LJ9zoDWN3f5lBPHnxD38xem5bNn/q68V/0RivJyxRy+P/ikuMdhuuelPiKSCbgvxCkdpcDvVPVPXW2oqu8Ax4nIr3EuaJXg1K79SwTnTTk5ue2lheozQFVteG8SKyws7HmjBLGqcS3zaz4FwI+fY0sOcTkib/PSZ9+TYKnBt4H/At8BlojIAzg/JjZBz7eAqOrcmAZpjMdEq40Yb3NiJJ0k6D++xElIdJ5J+GNgEs7viItVtb7tDXH+GP5e8OU6kpyI/BD4IcDo0aNdjsYkqv60BeGTettIjOTk4b7iSJzrTo+2JTB6qS0zNz76IRnjHQVpeRT588kqyCSnINeVGI4qns571R8B8GLZbEtiJCAv9RGRJDHa6gq+010CI5yq/llEZgD7A8diSYxeyUnPCS03ZPmgvh5ycrrZw3hRfWsDIsI3Xzp/a+20U1c3HSaO8FEY0wr3ZICH5vJIRJ9//jngjc++F2ZDaNYwxal3flkf9lci65uMSVrRaiOGZQzmvCGnMTZzJOOyRtrNEUkgCfqPd4AjgH07rX8C+C5OH/KkiFyGM6nrBOCPwK44/cWsSE8sIllAfY8b9uwPqnpVFI6zVcGJzO8CmDp1qg3NNlsVaVtQ3VrLisZSANLEzzbZY6MdmkkAn3/+uVf7ibahQW/2cb+2yh82Ws+ktDsnOpdsP//8c1gFuHCt+siSafx25Q0AvFv1EWXNlZSke+eieSrwUh8RyZwY2+L8aHisj/u1bb9tBOdMSW1Dv8BJYmhtrYvRmFg5Z8kVTFgwnX+8+S9mvd/Xv8/iT1V5qkMpqSNcjCY5LFiwgAULFrgdRjRJ2KPz6948jDFhotVG+MTH1WMu49yhp3JQ0T6WwEgCSdB/vBB83ldEBoetfxr4CKdPOBz4Aifh8DnQNua9AfhrfMI0JrFF2hYsrV8ZWp6YNYZMX0Y3Wxuv8nA/0XbreHW3W22p7c5Pm2/CGNz9e3FYxmB2z3MukLfSyqsVVnQh0Xipj4jkbte2lFlfh2+3TcBn2fBeCp+EpyHbR6CmFt+gQS5GZGKhMdAUWvbCBaVF9d+yuH4p4CTajig+wOWITIL5g9sBGGOM8QZV/VhErgKygVE4c2SgqioixwOv4pSV6qwWOFNVF/fj9I1dHLuvNkXhGMa4Yte8SXy9+yy+ql9KXWs0BiYZE1WbgaHBR1+0te0boxuOMSYSRxcfzIc1zojBF8re5IxBx7ockfGqSJIY5cBgoK9FWdsm4KuI4JwpyS9+0puV5nTnwnZDTTl5jHU3KBN1TdqexPB54Cb08FJSRxQdQK7fSpyZdqpqSQxjjDG9pqpXd7G+VER2xZlf6VBgCFAHzAfuVdX1W9uvD+dV4Kv+HMOYZJDrzwndJWtMgvkCJ4FxCHBbb3YIzpt0Mk71kPmxCy0x2LxJxguOKpnO1atuAeCtqvlUtlRTmJbvclTGiyIpJ7UIZ2j3d3u7Q7AjOROnI/kygnOmrKzm9ovadXWVLkZiYqXjSIxI/pOMn4AGOpSSOmHA4S5GY4wxpj8CGnA7BGO6paotqvofVT1bVWeo6kmqem1/ExjGGGM84QWca0/HiMhuvdznMqBthvpnIz2xiGSJiEbhcVWkMfSGqt6lqlNVdeogq9phOlnduJa5lR9Q1lJJXcC96mqjMoexS872ADRrC69VvO1aLMbbIrli+lzweYqI/L2X+/wFaOt0nongnCkrOyyJUVtb7mIkJlYatTm0nOgjMeZVL2RNk3PdoDitkOmFe7sckTHGmL74tn4lZ3x1MXstPJGTFv3Y7XCMMcYYY7pyN06ZQT/wvIjs29WGIpItIn/EmStJgaXAo3GJ0pgE9eTmV/jO4ktYXL+UTc1lrsZydMlBoeUXy2a7F4jxtEjKSd0BXI4zrO9SEdkL+BvwuqqGZp4WkVycYX+XA/sFV68F7upXxCkmq8UPtABQX9/X+ayMF7SNxHhtysdcvuOl7gbTg3+ufTC0fEzJwaT7ImlCTGennXaa2yHEhYikAflAtaq2uB2PMV4RzTYiy5fBW1VOdQU378gy0ZEq/YcxpnuRtAXlLZV8VruYHXImMjC9JAZRmUTh1b5CVWtF5BycERVDgLdE5AMgdDVWRH4L7AgcjjN/q+DMeXSmar+GnNq8Scbz2ubZfW3Kx5w16HhXYzmq5CCuXX07ALMr36emtZY8f66rMRmHl/qIPl+BVNV6ETkZmAVkAfsATwIqIutwJtrLxUlytN1WLkA9cLKq2oxhfZAVaB8sU9dQ5WIkJlba5sRozGimIDdx6wIurPmSNyrfA0AQzh/inYYu0eXkJOe8IiKSAZwFnATsBZSEvbcZ+AB4HHhYNWxyGGNMB9FsI4ZlDCZLMmjQJspaKqwmrcclU/8hIn7gVJwLUZOAYiBdVSd02m4noACoVNUv4h5oL4nIzE6rJoctzxCRsWGv16nqy7GOySSvSNqC96s+5vxv/g+Ao4qn869tro1yVCZReLmvUNWXROQM4B6ctn/PtreCz1cFn9uuPVUAZ6jqB/08r82bZDyvLYnRmNFMQ0ZzD1vH1visUUzKnsii+m9o1CZmVbzH8QMOdTUm4/BSHxFRAX5VfR9ndEXb/BgSPNZwYGLw2Rf23hfAfqo6Lwoxp4Sqlhreq/oIX0v7zQP1DTYSIxm1jcTYdvUIvv1sicvRdO3GNfeGlo8rOZSJ2WPdCybJLFy4kIULF7odRlSJyIHA18C/gCOBAbT3CQIMDK6/B1gsIge4FKoxCS+abYRPfIzJGhl6vaxhVVSOa9yRLP2HiEzHKf3xEHA2zkWqbYGxW9n8eOAt4B0RyY5PhBH5d6dH+C2Qv+z03q/iHp1JKpG0BYvqvw0tj8gYGuWITCLxej+hqk8AOwG3AuV0/E3R9qgCbgd2VtVXuziUMSklS5wkxrarR6BLGl2OBo4umR5afqHsDfcCMR14qY+IeBZhVV0I7IzzB/n9OAmNCiAQfF4UXH8csEtwe9NLn9Qu4pSvLqKuKVShi/qwZZM8QkmM0hF89ekil6PZus9qF/N6xTuAMwrjkuEz3Q0oySTLRag2InIY8CowivYfFjXAJ8A7weeasPfGAK+JiN2KYcxWRLuNGJvZnsRY3rg6asc18ZcM/YeIHAu8BozE6RNagcpudrkT5/dGPnB0zAM0xgMiSmLUfRNa3iFnYpQjMonE6/0EgKquVtWLVXUgznWoY3FGfJ8A7AGUqOpFqlrqYpjGJJS2kRjblo4g/dv+VFeLjqNLDg4tv1H5HvWtVto2EXipj+hXQfvgELvnaJ/s20TJsIxBAPhUQ+vqmmrcCsfEiKrSGFZFRyQxJ/a+KWwUxtElB7FdzngXozGJTEQKgIeBjOCqF4DrgHeDfUb4tvvh3I16THD7/4rIBFW12nnGxNA4G4lhEoSIDAQexJm0tRL4Gc5ErIcBT21tH1XdJCJvAdOAQ3HKEiYcVU3MP+qMCfqyrn0EuCUxjJcESwl2WU5QRHYFdg1u+0C84jIm0bQlMQAC/ZoiJjq2zR7HxKwxfNOwgvpAA7Mr3+fIsNEZxvQk4pEYJraGBpMYEnbJr6G5zqVoTKw0aXtdQgn+L9F8UbeEl8vnhl5fOvwcF6MxHnAhTukoBX6rqseq6judExgAwfXHAb8JrioBfhy/UI1JTeOyRoWWlzbYSAzjqp/ijKhoAg5V1X+ram/+4H0fZ9TGlFgGZ0yy+qZ+BcsbnRvW/fjZJnucyxEZE1WnAPcB9/awnWtEZGb4gy3nTQp/f4Y7URqv65DEwP0kBjgTfLd5crNVfjN906+RGCZ28vy55PlyQNuHV9W32pzoySZD0vl691k0Bpp5/IvH3A5nq24q/Xdo+aji6UyyO7VM99pKe7yjqn/qzQ6q+ufgH+f74wwN/0usgjPGdExiLLckhnHXkThJ70dV9cM+7Nd2C7kNDTUmAn9e9c/Q8gGFU8n0ZXSztTGelXh3CLb7dzfv/bLT6znAyzGMxSSp7A4jMba4p9AVJ5Qcxi1r7gPglfK5rGnawPCMwe4GZTzDRmIksKEZgzp0u/UtlsRINiJCrj+HkvRCMiTd7XC28FXdt7xY/mbo9SU2CsP0bFucC1J9zcq1bb9tdMMxxnQWnsRY1mjlpIyrJgSf3+x2qy21lR0siGIsxqSEedULeaWifZT1r0baIFhjjElG2b6s0HKijMTYLmc8++TvBkArrfxnw1arhxqzVV2OxBCR37Utq+rVW1sfqfDjma4NzRjEKlkcel2vNulNMjvzzDPdDmEL/1z7YGj58KID2CnXri/HQiJ+9v1QGHxe18f91gef7YKUMZ1Eu40Ymj6QLMmgQZsob6mkoqWKojT7T8+LkqD/yA0+V/dxv5zgs/1xbAy9bwsCGuDqlbeEXp80YAY7524Xq7BMgkiCviLp2LxJJh7aykm9NHUB4zJH9bB1/Jw75FTeq/4IgIc2PMMlw2d2KH1l4stLfUR35aSuwrmbFuDqLtZHypIYvTA0fRArwyZ6rg+bANokn/T0xBqJUdZcyfNlb4ReXzz8bBejSW6J9tn3UzkwGBjdx/3aZhquiGo0xiSBaLcRPvExNmskX9UvBWBl4xpLYnhUEvQfm4GhwUdfTAo+b4xuOMZ4U2/bgufKZrGwdhEAmZLBL0f+MJZhmQSRBH2FMSYCuf4cJmaNIcuXyajMYW6HE3J48f4MzxjCmqb1bG4p5/myNzhl4JFuh5WyvNRH9FROqqvssPTjYXppaMYgWv3trxu00b1gTEw0BBr5pn4FqxrXMvv9OcyfP9/tkEIe3/wijcHE2S452zMlb0eXI0pe8+fPT6jPvp8W4bT13+3tDiIiwJk4CfIvYxSXMZ4Vizbi2rFX8NKO/2bRbq+xS+72UT22iZ8k6D++CD4f0tsdgn3GyTh9hqf/8cZES2/bgm/qV+ALXgI4f+jpjEygi1omdjzeTxhjIjQsYzBzdnmEa+p/wo8qTnY7nJA0SeP7g08Mvf73+v+5GI3xUh/R3UiMg/q43kTZsIzBtPrDRmJIi4vRmFhYXLeUo748F4DTP5zGLrnbs8cee7gcFagqD254OvT6rMEnuBZLKvjiC+caTiJ89lHwHDAdmCIif1fVn/din78Au+FckHomhrEZ40mxaCP2zN81ascy7kmC/uMF4FDgGBHZTVU/6sU+lwHb4PQZz8YyOGO8ordtwc9Hns/RJQdxy5r7+cmw78cjNJMAvvjiCy/3E8aYfkrEvxfPHHQ8N5beS6M2sbB2ER/VfMFuduOsK7zUR3SZxFDVOX1Zb6JvWMYgWtLCkxjNLkZjYqEprESYT3oaGBU/71d/zLcNKwHI8+VwwoDDXI7IeMgdwOU4pUEuFZG9gL8Br6tqbdtGIpKLc+ft5cB+wdVrgbviG64xxhgX3Q38HzAIeF5ETlHVd7e2oYhkA78Obq/AUuDReAVqTLLYPmcC/5xo1Z2NMca4pyS9iOMHHMZjm14A4N/rH7ckhulR4lw1NVsYmTmMATmDQ68b/K0uRmNioSEQlsRIoGpr4aMwThx4BLn+nK43NiaMqtbjlPlom2x1H+BJoFJEVovIYhFZDVQCT+EkMASoB04O7m+MMSYFBJPb5wABYAjwloi8B4QK9YvIb0XkEaAUJ4nhA5qAM1U1EP+ojTHGGGNMf50z5JTQ8nNlr7OxuczFaIwX9DmJISKjg4+sPu6X2bZvX8+ZqnbM2YZfjL8w9LrekhhJpzFsJIYkSE6xrLmCF8tnh16fNegE12Ix3qSq7+MkJ9rmxxCc/mY4MDH47At77wtgP1Wd50rAxqSwDU2b+d+mF1nbtMHtUEyKUtWXgDOAapw+YU9gBs5oC4CrgFOBouD7FcDxqvpBnEM1xpMCGqBV7XekMcakomc3v8765k2sbdpAfaCh5x3iaJfc7dk9bycAmrWlw820xmxNd3NidGU5zt1SJ9G3OrTTgZeC+0Zy3pSUk10YWm5Is5vNkk1ToL1EmE8SYyTGY5tepEmduKbk7sBOudu6HJHxIlVdKCI7A8fg9Bd7AsOAfJwLVWuBD4AngBdUVbs6ljEmNn674gbuDU6k96cxlzNzSOJM+GdSi6o+ISLzgCuA7wIlW9msCngI+LOqlsYzPmO8bE7lPK5Y/hdOHXgkpw88hjFZI9wOyZgtiMgbUTzcuCgeyxhP+93KG9mrYSIAlS3VZGf06X70mDt3yKl8WPM5AA9ueIoLh51Fpi/D5ahMooo0mdCfq62JcaXWI7KzCkLLDRmgzc1IerqLEZloagw0hpYrD4OZE2e6FwzOhN4PbWyfV9km9I6PmTNnuh1CTAQTE88FH8aYCMWqjRiXOSq0PKdyniUxPCiZ+g9VXQ1cDFwsIjsCY4FCoAanlNTHVj7KmK3rri14ZNPzrGlaz81r7qM+0MjvR18cv8BMQvBIXzGd9hF4xpgoyZJMnt/LGbz6f2HXnxLFUcUHMTj9FjY0b2Zd8ybuXPcwFw+f6XZYKcUjfQRgc2IkvBx/e5a0IcuH1tZ2s7XxmrYRDwAZPveTU+9Wf8TS4ITe+f5cjis51OWIjDHGxMr0or1Dy+9UfdhhdKAxblLVL1T1BVV9WFWfVdUPwxMYIrKriHxfRL7vZpzGJLqy5kpeLX8r9Pr0gUe7GI0xPZIoPowxQJYvM7TckIBJjAxfOj8Z1v7n3M2l/2Z5w2oXIzKJLJ5lnYqCz3VxPKfnLa5bFlp2khh1UFTkXkAmqsIn9s790se7695l3333dS2e8BqEJw+YQY4/27VYUsm7774L4Opnb4xJXLFqI8ZljmRM5ghWNJZSG6hjQc1n7FuwW1TPYWIrhfuPU4ArccrUPuByLMa4rqu24OnNr4ZumpqcO4ntcybEPTbjvnffdfc3Zi8d5HYAxiSjLF8muywdC0DDDomXxAA4e8hJ/G/Ti3xWt5gGbeI3K/7Of7a9AUmQkuvJziN9BBDfJMZJwedVcTyn571T/WFo2UZiJJ+msIm901crX2/62rXGo7a1jlfK54ZeWymp+Pn666+BlLwIZYzphVi1ESLCtMK9eGDDkwDMrnzfkhgeY/2H3W1rDHTdFjy66fnQ8umDjolrTCZxfP21e78xe0tV57gdgzHJKNuXxeCNzly7iTgSAyBN0rhu7BUc8+X5KMqble/zfPkbHFtyiNuhpQQv9BFtuk1iiMjxwPFdvH2xiJzQw/EFyAUmAxNwahy+1d0OpqPhGUNCyw2ZgtZYEiOZNIaNxHA7yzyr4l0ag0mVSdkTmZQz0dV4TGITkd+1Lavq1VtbH6nw4xljYuugwr07JDF+PepClyMyxhgTDZ/XLubzOie5kSUZHF9ymMsRGWOMibfwclL1gQYXI+ne5LwdOHvwSdy34QkAfr/iJqYX7k2+P9flyEwi6WkkxmRgJltOsCT0fbif4JSSuqGP+6W0kRlDQ8s2EiP5+MRHji+bxkATPpenqHmxfHZo+eiS6a7FYTzjKtr7hqu7WB8pS2IYEyf7FuxGmvhp0Va+qFvChqbNDM4Y4HZYxhhj+unRTS+Elo8smU5hWr6L0RhjjHGDk8RwRmAk6kiMNr8ceQEvls9mQ/Nm1jdv4m+r7+LqMZe5HZZJIL29arq1CZL6MqlSFfAUsJ+qLo5K5CliVOaw0HJTpo+W2hoXozHRduGws1gy9Q1W7vl2h8863uoDDcyqeDf0+sji6a7FYjylq+FDNgmfMR6R589lj7xdQ6/nVM1zMRpjjDHR0Bho4slNr4Renz7QSkkZY0wqSvSJvcMVpOVx1ehLQq//vf5xPqlZ5GJEJtH0NBLjJuC+sNcCLMW5y/ZHwGs97B8AalS1PML4Ut6wzMGkNwVoznDyTfW1FeS4HJOJjfT0dNfO/VblfOoC9QCMzxrNdtnjXYslFbn52fdDV6PxbFI+Y6Is1m3E9MK9eK/6IwBmV7zPqQOPiun5TPR4tP8wxkRZ57bg1Yq3qGitApyR/fsV7O5GWCZBWF9hTOrK8mVS5WsFoEETO4kBcFzJoTyy8XnmVn1AgADnLvklT+9wp6s3/SY7L/UR3SYxVLUSqAxfF6zbL8AGVV0Ru9AMwLD0QaQ3K80Zzuu6ugqsyENyOvPMM1079wtlb4aWjyqe7vr8HKnGzc8+Ul1NvmeT8hkTfbFuI6YX7s21q28HYE7VB7RqK37xx/ScJjq82H8YY6Kvc1vw2Mb2UlKnDTwan7hbtta4y/oKY1JXti+Tx/b4EID9A9NcjqZnIsKfx17O4Z+fTV2gnnXNGznjq5/y5KQ7GJIx0O3wkpKX+ohI/poZF3z0NArDREG2P4v0lvbXm+s2uheMSUpNgWZeq3g79Pqo4umuxWKMMSb+dszZhim5O3DmoOP569hfof2e1sYYY4xbVJX9CnZnfNZoAE4bdLTLERljjHHLdtkTOKhwb44snsbIDG+MZhiXNYp7t/kLGeKMEFjeWMp3F19CeUtlD3uaZNdTOakt2OiL+EsPtN8Vb0mM5PJl3TdUtlSR6ctk4/xSsnyZTJsW3+z4e9UfUdlaDTjDzXfJ3T6u5zcwZ44zeCHen30siMjo4OIGVW3ow36ZwBAAVV0Zi9iM8apYtxEiwvM73hOTY5vYSqb+wxgTufC2QES4YNiZ/Gjod/mq/lsrwWGYM2eO9RPGpKizh5zE2K+cei7Tttnf5Wh674DCPbhj4jX8YMmvaaWVr+qX8r3FP+OR7W8hz5/rdnhJxUt9hI0r9YCMQPvHVNaw2cVITLTdWHoPp3x1Ecd+eT6ff/sFy5Yti3sM4aWkjiy2UlJuWLZsmSuffYwsx5k76fA+7jc9bF9jTJgkayNMFNl3wxgDW28LRIRJORNdisgkEusnjEltXv178YjiA7lx/G9Crz+u/ZLzl/wfAQ24GFXy8dJ3o88jMToTET+wCzASKAB6LKKsqg/097ypJFPTAKemVHWjDZ9KJo2BptCyz4WcYqu28kr53NDro0qmxz0Gk5T6kwmzLJoxxiQhEXkjiocbF8VjGWOMMcaYBHTywBlUt9Zy5YrrAXiraj5vVy3gwMI9XY7MuCHiJEawZMjvgdOB7D7sqoAlMfqgwJdL2/zqOWS6G4yJqkZ1N4kxv/pTNrWUAzA4fQBT83aOewzGGGMSS6u20hBoJNef43YoJrlMB5twxRhjjDHG9N7MISfzZd0SHtr4DAAvl8+xJEaKiuiqqYjsBywEZgI5OHfO9uVh+mBw+oDQcpra/33JpCnQHFp2o4zTi+WzQ8tHFB+IT6zCnHFNUfC5zs0gjEllb1XO56zFl7HjR0dwY+m9bodjklNffzPY7wljjDHGmAiVt1Sypmk9KxvX8PfVd7sdTsSOH3BYaPmV8rdQtftiUlGfR2KISAHwJM4FpwDwH+Bd4A6cu6tuBRYDY4AjcEpNKfAw8Ho0gk412b6s0HJ9a72LkZhoCx+JkZWdRU5a/O56DWigQxLjqOLpcTu36Sgnx+52Bk4KPq9yNQpjElC82oi6QD1vVr4PwLzqT+JyTtM/Hus/DnI7AGOSlcfaAhNn9v0wJnXVtdbzdWA5AJ9tfJ+fjzzf3YAitFf+rhT586lorWZd80Y+rf2KXfMmuR1WUvBSHxFJOakLgEE4iYmzVPURABG5I/j+LFV9Nrj8SxE5HrgHOAN4XVXv72fMKSc7rb1aV32g0cVITLQ1hc2Jsd8J09gxZ5u4nfvj2i9Z27QBgCJ/Afvk7xa3c5uOTjvtNLdDiEiwfT++i7cvFpETejoEkAtMBibg9CtvRSs+Y5JFvNqI8JKCn9V9RX1rA9n+rG72MG7zUv+hqnPcjsGYZOWltsDEn30/jEldJWlFvLbbQgAyWzJQVVeqgPRXmqRxcNF+PLn5ZQBeqZhrSYwo8VIfEUkS48jg84dtCYzuqOozIrIOeBu4XUTmqepXEZw3ZWWH3Z1fr5bESCYNYUmMTMmI67mfL2ufX/OI4gNI90U8RY5JXZNxygp2Hssp9P2OW8EpJXVDv6MyxkRkQHoxE7PG8E3DCpq1hYW1X7JPgSW4jTHGGBM7IvK7WB1bVa+O1bGN8YJsfxZZvkwaAo00ahN1gXrPzns3o/jAUBLj1fK3uGLkj1yOyMRbJFctd8C5YPV0F+/7O69Q1Xki8hjwHZyRHJdGcN6UlZ2e6xTuAkqbN1LXWk+Ovy9zqZtEFV5O6rO5C1nuX8Khhx4a8/OqKi+UvRl6fUzJITE/p+na6687lfbi8dnHyNZu5ejL7R2VwBvA1aq6ODohGZM84tlG7JU/mW8aVgBOSSlLYiS2JOg/jDFRYG2B6c7rr7+e6N+Nq9jypqhosSSGSXn7fr0D1a21zN/uaza3VHg2iTG9cC8yJYNGbWJR/besaChlTNYIt8PyPA/0ESGRJDGKgs+d65Y3B4+X28V+s3CSGIdHcM6Ulp2RCw3OcpOvlbVNG5mQPdrdoExUhJeT2rRmA5WSHpfzflz7JaVN6wAo8uezf8HUuJzXbN3q1avdDiFSNwH3hb0WYCnOj5AfAa/1sH8AqFHV8lgEZ0yyiGcbsUf+Ljy08RkA5tfYvBiJzsP9hzEmiqwtMN3xyPejNzdAaQ/bdX7fZv41BhhUXkBOwLnWVNZcwejM4S5HFJlcfw77FUzljcp3Aaek1A+HfsflqLzPI30EEFkSoym4X0On9dVAMdBVGqxtRmpLk/VRTmZe6P/tVh+sa7YkRrIIH4kh+OJ23ufLZoWWjyg+kAxffJInJrmoaiXOKIqQYH1NATao6go34jLGRG6v/Mmh5QXVn9Gqrfhli0G2xhhjjDHR0lMZ2ouBE3FugHoV5wbZb4BanJtoJwKH4Nww6wOeAv4Rq2CN8Zp0ab/0W9ZS2c2Wie+I4gNCSYxXy9+yJEaKiSSJUQpsAwzotH4psDuwRxf7bdePc6a07Kz80GXC1jRhXdNGdwMyUTMmcwQ1rbU0BJrwxWlyJSslZWJsXPB5g6tRGGMiMipjGEPTB7KueRM1gToW1X3DTrnb9byjMcYYY0wEVHVOV++JyC3ACcBXwOmq+lkXm94gIjsBj+AkPFap6mXRjtUYLwpPYmxu8XYRhMOLDuBX/BVFmVf9CWXNlZSkF7odlomTSG79/jT43Hka+Pdx7r49SkTGhL8hIkU4c2EosCyCc6a0nOz2/yCb04R1jXZtMFm8stP9vLPr43w45Vl8cRqJsbD2S1YHS0kVWikpE2WquiL4qO95a2NMohER9sjfNfT6g+pPu9naGGOMMSY2ROQI4CfAZmB6NwkMAFT1c5wRGZuBi0XESpkbA6SFj8Ro9vZIjMEZA5iSuyMAAQK8XvG2yxGZeIrkqukcnGTF9E7rHww+ZwJzReTHInK4iPwY+BAYHHz/6QjOmdKy09on8W7M8rGpeo2L0ZhYKSgooKCgIObneb7sjdCylZJKDPH67I0x3hTvNmKvsCTGvJqFcTuv6TvrP4wxYG2B6Z6HvxttN8Leraq9upNTVdcDd+Ncs7oghrEZ4xkZeZnUZjk16staKtwNJgqOKD4gtPxqxVsuRpIcvNRHRFLa6Vmc+oI7iciOqvoFgKp+ICIPAmcBI4Fbt7LvKuDvkQabqrJ9WaHlhiwfZZXrXIzGxMpJJ50U83OoaockxjElB8f8nKZn8fjs3SIifmAXnH6hAOixuL6qPhDruIzxkni3EXvkOUmMLMmI2yhBE5lk7j+MMb1nbYHpjoe/H7sHnz/p435tw0it5IAxwKjDJ3Lb8ieBZEliHMi1q28HYHblPOoDDR2um5q+8VIf0eckhqquEpGDgCygqtPb5wGNwLk4me9wHwJnqKq3C7C5oEMSI1OorLAkhonMJ7WLOpSSOqCgqylsjOkfERkN/B44HcjuYfNwClgSwxgXTcqZwDOT7mKX3O1ttJ4xxhhj3DIo+NyX3xLgXKsK39+YlDYpeyJnDjqe4rRCds/bye1w+m1i1hjGZ41macNK6gMNvF25gMOK93c7LBMHEU2y3dXES6raDPxARK4BDgaGAHXAfFV9L+IoU1znkRibK9fQqq34pccbmk0Cq2mt5aXyOWRIBkVp+dS/5+T3ZsyYEbNzPlc2K7RspaQSx8svvwzE9rOPJxHZD3gOKGTLhLYxpo/i3Ub4xc/U/J3jci7TP8nWfxhjImNtgenOyy+/7NXvxmZgGHAocF8f9jssbH9jUt6md0o5mMlebQe2ICIcUXQAt697CIAXy2dbEqMfvNRHRJTE6ImqrgD+HYtjp6JsX2ZouSHLh6+6kjmVH3Bw0T4uRmX6a0NzGZcu/SMAYzNH8oN1R8f0fFZKKnGtW5c8o6tEpAB4EigCAsB/gHeBO3BGWdwKLAbGAEfglJpS4GHg9fhHbEziS6Y2wkSXfTeMMWBtgemeh78fb+GM6j5DRB5Q1Vd72kFEDgvuo4DN+GsMnm4DujSjeFooifHs5te4ctSFDEwvcTkqb/LS98MKHXtA55EY2Q0BPqn90sWITDQ0BhpDy1m+jJifz0pJmTi5AGfotgJnqepMVb0r7P1ZqvpPVf2lqk4GTgTKgTMAVPX+eAdsjDHGGGOMSTi34fymEOAZEfmNiBRtbUMRKRKRK4FncK5zKXBLvAI1xsTX7nk7sUvO9gA0aBP3rv+fyxGZeOhzEkNEfhd8XBycsLW3+23Xtm9fz5nqOiYxhH8MvYLLRpznYkQmGhoDTaHlDIl9EuPNyvaKbocV7W+lpEysHBl8/lBVH+lpY1V9BmgbhnS7iGwfs8iMMX2ysbmMF8re5PcrbmJzs01pZowxxpj4UdW3getwkhgZwB+AdSLynoj8R0TuDD6/B6wFrqZ9PozrVPVdVwI3xsSciHDh8LNCr+9f/wS1rXUuRmTiIZJyUlfhZLUBjhORU1S1ohf7bR+279URnDdldR6JMaA8s5utjVc0aXNoOTMOIzE+qP40tDytcK+Yn8+krB1w2vmnu3h/i+S3qs4TkceA7+CM5Lg0VsEZY3rv/CW/YkHNZwDsUzCFGcXTXI7IeFUsb2JSVftdYYwxSUpVrxSRCpxrSJk4yYw9g49wbfPwNQK/VdXr4xakMR6wsnENP/rmSsqaK7lz4p8oSS90O6R+O6p4OmMzR7C8sZSK1moe2vgMPxz6HbfDMjHUnzkxBDgIeF9EjlXVJVGKyXTSIYmR6SNQW+NiNCZaGsLKSWX40hkwYEDMztWiLXxY83no9V75u8bsXKbvYvnZu6Ao+Lyq0/pmnD4nt4v9ZuEkMQ6PTVjGeJdbbcSe+buGkhjzqj+xJEYC8lD/cRXtN0FFmyUxTMrzUFtgXOD174eq/k1EngAuBk4ARm9lsxXAU8Ctqro0juEZk/AGDBjAO2ULebFsHgCbWsqSIonhFz8/GvZd/m/53wC4a90jnDP4VNJ9MZn+OWl5qY/ozyf7LTAB2BYnkXGqqr7Rwz4mAum+NNICQotPaU0TmupqurwKaLyjw0gMyeTYY4+N2bm+qF1CbcAZWjc8YwgjMofG7Fym72L52bugCadvaei0vhooBkZ0sV998Lmr941JWW61EXvk7RJanl35Pr/nYlfiMF3zWP8hPW8Sqn3e2/djlRgxxlM81haYOEuG70cwMXEpcKmIDAKGA3lADbBGVTe6GJ4xCe3YY4/l7i+fc/5rAcqaKyDb1ZCi5tSBR/H31XezqaWctU0beLrsVU4deJTbYXmKl/qI/iQxLgemAlfiXJh6SUQuUdU7ohJZimstXUPjU8/SunQ5viGDydrfT42vBYD6+kpqGtfyyMbnqA808LvRdlHBi8LnxMiM8fwUH9R8Elq2URgmxkqBbYDO6fylwO5AVzPKbxd8ttsmjEkQ+xdMJUsyaNAmvq5fxjf1K5iYPcbtsIw3HdTD+xcDJwIB4FWc0XnfALU4I/gmAofgjNbz4dxt+49YBWuMMcZ9YaUIv1XVh9rWBxMWlrQwpg9K0opCy2Utle4FEmXZvizOHXoaf119JwC3r32IUwYciUhv7p0xXtPnib3DqKr+FjgL547bdOA2EblFRPpzXAO0rlpN9U8vp+7GW2l45HGyA+1l5NfXrmOfT07mpjX/5r71T1CeRA1QKmkKT2JIBs899xzPPfdcTM71QXV7EmNPS2IknFh+9i5om3xlUqf17+PcPXuUiHS4CioiRThzYSiwLNYBGuM1brUROf5sphftHXr9cvmcuMdguueV/kNV53T1AE7GKQ/yFbCbqh6tqjeo6rOqOiv4fIOqHg1MARbhJDxOCO5vTMrzSltg3OHh78ZVwO+xkdrG9Mtzzz3H8AV5odebW8pdjCb6zh58Ejk+Z2jJ4vqlzKp81+WIvMVLfUS/kw2q+jBwMLAe5wLVRcCLIlLQ32OnMv+49mt8rUuXk6Xtd+qntSo75zg3LTdqE09ueiXu8Zn+a9T2JEaGL4PNmzezefPmqJ9HVZkXnsTIsyRGoonVZ++SOTh9wfRO6x8MPmcCc0XkxyJyuIj8GPgQGBx8/+l4BGmMl7jZRhxZPD20/FL5bFdiMF3zev8hIkcAPwE2A9NV9bPutlfVz3FGZGwGLhYRm0fJGLzfFpjY8vB3oyL4bDc5GdMPmzdvJrO6veBBMo3EAChKK+DMQceHXv9z7YPdbG0681IfEZURE6r6PrAXzh24AhwGvCci46Jx/FTkGzwYcnIA0KoqsgPtDU59Ux3fGdxes+zhjc+gaiWBvaahQzmpjJidZ2nDqlCmvcifz7bZ9p+lialng887iciObStV9QOcRIYAI4FbgZeCz2ODm60C/h63SI0xPTq0aD/SxBkNurB2EaWN61yOyCSZtlF4d6vqht7soKrrgbtx+pMLYhibMcYYd60KPtsNssb0U9vf8xCcEyPJ/GDoGaF/47zqhbxQ9qbLEZlYiFrZJ1VdCewHPIfzo2J74AMROTBa50glIkLa+LGh11nN7fXc6ltqOXHAEWT7sgD4qn4pi+uXxjtE009DMwayX8HuTM3bmbGZI2N2ng9qFoaW98jfFZ9VezMxpKqrcGqfHwVUdXr7POCe4LJ0enwIHKKqyTW21RiPK0orYL/8qaHXL5fPdTEak4R2Dz5/0u1WW2orXTi1262MMcZ42fM4vxMOdjsQY7wuXcJHYlS4F0iMjMgcwikDjgy9/vmyP7GsYVU3exgviurVTFWtxalpez1OZzMAeFVEzovmeVKFb9zY0HJWY/v6+uZ68v25HFy4T2jdO1UfxjEyEw0ziqfx2Pa38swOd3HBsO/G7DzzbD4ME2fBOuevBBMa4eubVfUHwHichMavgUuB/VR1D1X9Nv7RGmN6cmTJtNCylZQyUTYo+Jzdx/2yOu1vjDEm+dyGU1LqNBHZz+VYjPG0tCRPYgD8dvRPGZ05HIDq1lp+9M2V1AcaXI7KRFPUb8lWxxXAuUATkAHcBfxftM+V7DqMxGhoDS3XB+oB2K+g/eYzS2J439ChQxk6dGjUjzvf5sNIeLH67BOVqq5Q1X+r6nWqeouqvud2TMYkMrfbiCOKDkRwRoR+VPMFVS01rsViOnL7uxEFbUV4D+3jfod12t+YlJYEbYGJIa9+N1R1DXAGUIsz7+pFItLXpLcxKW/o0KEMGDIw9LqsObnmxGhTlFbAnRP/RIY4cwp/UbeE36+4yd2gPMBLfURaz5tERlXvE5FvgSeAgcAesTpXsgqf3DurriW0XN/qZBL3K9g9tO696o9o1Vb8YXXujLfMmDEj6sdc37SJ5Y2lAGRJBrvkbh/1c5j+i8Vnb4xJHm63EYMzBnDRsLOYkDWGw4r3pyAtz9V4TDu3vxtR8BZwOnCGiDygqq/2tIOIHBbcR4G3YxyfMZ6QBG2BiSGvfj9E5N7g4mc4pctvAa4TkY+BUqC+h0OoqlpVEJPyZsyYwYqGUvj0VgA2J+lIDIBdcrfnqtGX8usVfwPgoY3PsFf+ZE4e6M12MB681EfELIkBoKpvicjeOPNkTIrluZKRf3z7BMyZVe31pOrVWZ6QNZoh6QNZ37yJqtYaPq/9rKlS4QAA5CNJREFUml3z7P9m025e9cLQ8pS8HcnwpbsXjEkJIvK74GIFcJuqtnazefh+2+FclEJVr45NdMaYSP3fqAvdDsEkp9uA03DK0D4jIn8CblXVis4bikgRcBFwJc5o8gDOBS1jjDHJaSZOwpqw51ychEZvWRLDGGBw+gB+NfICStKKGJw+wO1wYur7g09kXvVCnil7DYBfLv8LO+dux7bZ43rY0yS6SJIYBwWfP+/Nxqq6NJjI+CNQGMH5UpY/vJxURR2QCUA9zYAz+fd+Bbvz5OZXAHi3+kNLYnjIrIp3WVy/lAxJ54CCPfji5YUAnHTSSVE7xwc2H4YnPPnkk0B0P3sXXUX7j4zjROSUrV2M2ortw/a1JIYxYZKsjTBR5PXvhqq+LSLX4ZSdzQD+APwmeJftN0AdkANMBCYHt5Hg7tep6rtxD9qYBOT1tsDE1pNPPunl74b0ct3WaM+bGJP82vqIn550tsuRxIeI8Ndxv+TzusV827CS+kADly/7M89MuguR3jYfqcNLfUSfkxiqOieCfapxJm+NGhEZCfwUOBYYDbQAy4CngH+oank/jz8K2BOnDNaewFQgP/j2H1T1qv4cvzf8Y9vLSWVuriGUxGiqQRsbkczMDkmMBTWfxTokE0UvlL3Bo5teAODv435NQ1VV1M/xQU17EmOv/MlRP76JjqoYfPYJQHCS3u+LyLGquiSuJ0+BPsKkjiRtI0wUJMN3Q1WvFJEKnAR2Jk6iYs/gI1zbr85G4Leqen3cgjQmwSVDW2Bix8PfD7tt2pgo8HAbELE8fy53TfwzR35xDk3azIc1nzOnch7Ti/Z2O7SE46XvR0zLScWKiMwA/gsUdXprcvDxQxE5XlUjmu1aRMYAyyOPMDokN5fsC87DN2gghXutB5x/TkO60rLwU9L32oMDC/fi1yMvZL+C3dkpd1t3AzZ90hhoCi1nSAYNUT5+VUsNX9Z9A4APH7vl7RTlMxjTrW+BCcC2OImMU1X1jXicOFX6CGPcENAAH9Z8xtKG1Zw+6Gi3wzFJQlX/JiJPABcDJ+AknztbgZOIvlVVl8YxPGOMMS5Q1RVux2CM8a7tcybwnUHHcv8GZyTK9aV3M61wLxuN4WE+twPoKxHZBXgc5+JUHfB7YH9gOnAj0AqMAJ4XkeGRniZsWXGGs8+N8Fj9UnD7zeRd/Vvyp7TPi96QKTR/sACA4RmDuWj495ictwNp4smcVMpq0ubQcqYvI+rHX1DzGRocQbtjzjbk+3Ojfg5junE58KfgcjHwkohcEOuTplofYUw8lTVXsPvC4zhh0QVcueJ66lujnX43qUxVl6rqpao6FhgCTAEOCD4PUdVxqvozS2AYY4wxxpje+Mnws8kU53rbx7Vf8Gbl+y5HZPqjy6veInJg27Kqzt3a+kiFHy8CN+FM5tQKHNnpWHNE5CPgP8BQ4Brg3AjOUQ38BpgPzFfVchGZDrwZedj9k+3LCi03ZPlonrfAKZRiPKuhw0iM6E+4bfNhGJepqv5WRBYBdwNZwG0isgNwqaoGYnTem0jBPsKYeChJL6LQn8+G5s3UBxqYW/UBRxT3+89Ck8JE5HfBxW9V9aG29aq6EdjoTlTGGGOMMcnntjX/4YXyNylrruDK0RdxbMkhbocUc8MzBnPm4OO5d/3/ALi+9F8cVLi3jcbwqO5u3Z+Nc4epdtqubX2kOh+v10Rkd9onFr9va8kQVX1QRM4BDga+LyK/UtUNfQpQdTPtdxAnhC2SGB9EVAXFJJBGbQwtZ/oyGDlyZFSP/3bVgtCyJTESW7Q/+0Siqg+LyFKcEiBDgIuAbUXkNFWNavHFVO4jTHJLpDZiRvE0lqxdDsDL5XMtieGyRPpuROgqnN8G/+dyHMZ4WhK0BSaG7PthTGprawNmN33CJ7WLAFjftMnNkOLqomHf4+ENz9CgTXxSu4jXK97hsOL93Q4rYXipj+gpmdBVasqtlFX4dOn3dLPdvTgXqPzAcTh3AXta5yRG65JvCJSV4SspCa1f17SRd6s+4qiS6WT5Mt0I0/RBU6BjOakDDz00ascua65kYe2XgDMfxn4Fu0ft2Cb6Do3iZ5+IVPV9EdkLeBbYBTgMeE9EjlHVZVE8Vcr2ESa5JVIbMaP4QP6x9n4AXqt4mxZtsXKWLkqk70aEKoBCIJp9gTEpJwnaAhNDyfL9EBE/zm+JkUABzt/y3VLVB2IdlzGJrq0N+LS0fZqZspYKl6KJv6EZgzhz8Ancs/4xAG4ovYdDi/az0RhBXuojuvvV+Yc+ro+HtlRZHU4Zj66El/TYHw9foGpdvoKaX19Fa963cL6zriHL+Q+tef5HZB7hfNnO/vpyXq94B4AhGbfaRWsPCJ/Yu61GX7S8VfVBaD6MKXk7UJxWGNXjG9NXqrpSRPYDHgaOBbYHPhCRk/tZYjBcyvURxsTbLrnbMzR9IOuaN1HeUsmC6s/Yu2CK22EZ71qFk8QocDsQY4wxiUlERuPMc3c6kN2HXRWwJIYxQSVh14U2N1e4F4gLLhr2PR7a8DQN2sSndV/xWsXbHF58gNthmT7qMomhqltNVnS1Pk52CD4vUdWWrjZS1TUiUoXzg2iHrrbzBJ+Phv/+j7S98oBxgDMSA6B53vxQEmN4xpDQLu9ULbAkhgc0adicGL4MHnvMyQqfdtpp/T52+GRFBxXu3e/jmdiK5mefyFS1VkROAP6CM/H3AOBVEbkIiMZ41tTrI0xKSKQ2wic+Di8+kAc2PAk4JaUsieGeRPpuROh5YGec0XHdjaAzxnQjCdoCE0OPPfaYZ78bwZugnsNJeNtt08ZEoK2PKDmkvZJLWUulW+G4YkjGQL43+CT+tf4RAP5W+i92z9uJAenFLkfmPi/1ET63A+gtEckEBgZfru7FLm3bjIpNRPHhGzEc0tPJamyfA7c9idE+50F40uKdKpsvwwsaOo3EqKuro66urt/HDWiA2R2SGPv0+5gmtqL12XuBOq7AmVC7CcgA7qKf9dBTtY8wqSHR2ogZYfNgvFIxF9X+TJVm+iPRvhsRuA2npNRpwQtVxpgIJEFbYGLIq98NESkAngSKaB9VcUHwbQX+AfwE+Bvwadj6h4BzcH5vGJPy2vqIkvSi0LqylnL3AnLJRcO/Fyq9/2XdEvZceAK/WHYtX9V963Jk7vJSH+GZJAaQH7Zc04vt27bJi0EscSN+P/4xo8lqCEtiZAaTGB8sCF042Dd/t9D7C2u/pLbVO1/CVNWk4XNipEftuF/WLWFjcxkAJWlF7JK7fdSObUy0qOp9OHNjbMK5q2qPfh4yJfsIY9ywT/5u5PtzAVjZuIZF9an9h7+JnKquAc4AaoEXReQiEelLqRBjjDHJ6wJgEE5i4ixVnamqd4W9P0tV/6mqv1TVycCJQDlOv4Kq3h/vgI1JZCVpRaHlVBuJATAovYSfDjs79LpBm3h447Mc8vlZnPHVxXxTv9y94EyveGkmxvAfNE1dbtWucSv7uUJEfgj8EGD06NF93t8/bgxZS9pvLG7IdT423bSZ1mXLSRs/jpL0IiZlT2RR/Te0aCvzqj/h4CK7Az+RHVk8jbKWChoDTeQFLwZFQ3gpqWmFe+ITL+UqTSpR1bdEZG+cIeKT+nm4lO0jjIm3DF86BxfuyzNlrwHwSvlcdsiZ6HJUxotE5N7g4mfAfsAtwHUi8jFQCtT3cAhV1fNiGKIxxhj3HBl8/lBVH+lpY1V9RkTWAW8Dt4vIPFX9KqYRGuMhA8KSGKk2J0abS4bPZFzWSO5c918+qV0UWv9W1XwuX3YtT+9wp4vRmZ54KYkR/iOmN7MgZ25lP1cE7xa4C2Dq1Kl9rrngHz+WrM/eCr1uyM8MLbd8sIC08c5cGfsXTGVR/TcAvFbxtiUxEtzVYy6LyXHDS0lNt/kwTPwdFHz+vDcbq+rSYCLjjzi1biOVsn2ESV1aV4fk5Lhy7iOKD+yQxLhshFVsMBGZiXOHLWHPuTgJjd6yJIYxxiSnHXD6hqe7eN/feYWqzhORx4Dv4IzkuDRWwRnjNcVhE3uXt1QS0EDK3fQqIhw/4DCOKzmUBTWf8q91j/JC+ZsAfFjzOVUtNRSkWbGGRNVlEkNE3ojROVVVD4lgv+qw5d58o9q26U1ZkYTmHz+O/OrW0OuNBcqGQWkM3thC87wFZJ1xKgBHFB8QmqTm5fI5/GnMz1OuQfKycePG9fsYVS01LKj5LPR6WuFe/T6mib1ofPaJQlXnRLBPNf3/gZGyfYRJfuFtROuy5VSc9n1av12Gb/hQBn4+35WYDi7ahz3zduXQov04ovgAV2IwSdN/bG2i1t5O3mqJX2NImrbAxIiHvx9FwedVndY341zL6qqcwSycJMbhsQnLGG9pawMyfOnk+3Opbq0lQIDK1uoOiY1UIiLskb8re+TvyozPZ/JZ3WICBPig5hMOLUqtadq81Ed0NxJjOtH/YSCRHlNVG0VkE87ErSN7sUvbNp07PM/xjxtDfm2A3T+s4cPd82j1KU8eX8IFd2/oMLn3nvm7MiCtmM0t5Wxo3syHNZ+xR/6uLkZu+mLatGn9PsbbVQtoUSfhtUvO9gxKL+n3MU3sReOzT3Wp3EeY5BfeRkhRIS0LPgKgtaEBDQQQX/xvWMj35/LUDnfE/bymoyToP7zzq8mYBJYEbYGJIQ9/P5pwrlk1dFpfDRQDI7rYr22kdVfvG5NSwtuAAWlFVLfWAk5JqVRNYoTbp2A3PqtbDMB7VR+lXBLDS31ET796JcqP/voy+LyNiHQ3imQ4UNBpH8/yB8tFnfb45tC6J08oodkPzR8tRJudCaL94mdG8YGhbV4omx3XOI37OpSSKrJSUiblpGQfYVKLr7gYKQkmqOvrCaxd525AxvSDqq7o78Ptf4MxxpiYKQ0+D+i0fmnweY8u9tsu+Oyl8unGxMW1Y6/gke1u4dWdHmBU5jC3w0kI++RPCS2/V/2xi5GYnnSZxFBVX4weW9Qt7IO3g885dN1hgTOKpPM+nuUfPxaA6XOqGLi5BYBNg9KZPa0AGhtp+bS99PxRxdNDyy+Vz0bVRtknovrWBn69/G9cteJmbiy9B4CHHnqIhx56KOJjqmqHSb0PsvkwPKO/n70bROTAtkdX6yN99COslOwjTPLr3Eb4J4SVl/p26dZ2MSnCi/2HMSb6rC0w3fHwd+PT4POkTuvfx7lJ9igRGRP+hogU4cyFocCyWAdojBeE9xEHFu7JAYV7sGPONmT6ejOVZPLbK38yvuDl8c9qF1PVkloVp73UR3gtM/0k8Ovg8nnAe11s1za7ZCvwbKyDijVfcTFSWEh6ZSUnPrWZf50/BID/nTKAw96oovmDBaTv7mQO9y3YnYlZY9inYDeOKp6OokhUBsGYaKoJ1HH/hicBGJhWzGUjzqM5OKImUksalrOmaT0ABf48dsvbsd9xmvjo72fvktk4Pw6Ujn1J2/pIdT5eX6RkH2GSX+c2Im3ieFrmfwhA6zdL4cD93Qirg+UNq2nWFrbJHut2KCnFo/2HMSbKrC0w3fHw92MOcAodb0ACeBD4CZAJzBWR64BvgQnA5cBgup8Q3JiU4uE2IC4K0/LZKWdbPq37igAB5lUv5LBi939fxYuXvh+emvVZVT8E3gy+nCkiW8wkKSJnAm0Thz+gqhs6vT9WRDT4mB3TgKOo4M6bKXrxSc6/7GH8OINZFuyex7fjMjvMi5HhS2f2zv/lurFXcGDhnv/P3n3HN1W1ARz/nczuBWXvvYcgCiiCCLhxi4iIe09w7628LhTFDYoTxYWIqEwVUAHZe29KS/dKk5z3j5umDd2lbZr0+frpJ8m959w8IfGe5D5nyMLetVSuO9d731ZF2e/5KQXXa0+JOhFLybPpCFFVSpoq0C9TD9blNkLULbVpJMaytP8YuvZKBq65lKf3vOnXWIQQQggRVPI7G3VTSnl76Gmt/8FIZCiMde4mA3M8t608xfYCr9RYpEKIgNY/qvCUUiv9GIkoTSBe5bwbWAKEA794su7zMF7LSOAuT7nDwKOVfRKl1JlAo0KbOhW630spNa5wea31tMo+V3mEXH4JYLTQI7YO4udk4zrd1xfXo8Ps5T5llZKRF7Vdrrsg02lXVZPEKLwexumyHoaofk9VcHtNuZs62EaIusXcrq33vnObf5MYDWz12ZxtzNYwP3UJG7O20TmsnV9jEoFLKWUGemB85Y0CypyGVmv9SXXHJYQQouZprfcqpYYAIUDaMbuvA3IxRlgfewFkBTBKa51c/VEKEZhc2oXDnUeoOcTfodQK/SNP4N1DXwCwNE3WxaitAi6JobVeo5S6BPgCiAGe9vwVth8YqbU+cBxP9SBQ0hLtIz1/hU07jueqkKsbXuRNYsw+O4Y7pmwmLjUVU3R0TYUgjlOudnjvh1TBSIykvGSfbPFpsh6GqGZa62KTFSVtrynSRoi6wHckhn+ne24T0pwzYwcxJ3kRAG8dnM7ktv7OZYpAo5RqATwBXA6EVqCqBiSJIYQQQUprvaiE7XnADUqpZ4HTgYZAFvCv1rqkKWWFqPN+OjqfB3dNJMWZxsX1zmRS28f9HVKtkL8uhhs367K2kOpMJ9oS6e+wxDGOO4nhjx5TWutflFLdgTuBc4EWGHOb7wS+A94I5qz7wEhj3YttObvJDDfz84hobtywCVv/k4qUzXRlccCRIHNU1zIOd0ESI386qQ4dOlT6eN8n/YZTuwDoE9GNJrYGxxegqFHH896Loup6GyGCz7HniMIjMVzbdqC19usozNsbj/UmMX5I+p37mt5Iy5CmfounLgmG9kMpNRCYBURzHFMKClGXBcO5QFSfYP58aK13A1P9HYcQtVnhc4BNWUl2pgJw1HMrIMoSQffwjqzO3OhdF2N4bJHZqYNSILURlU5i+LvHlNZ6H3C/568i9XZRjh9IWuvBlQqsmmmHA3diElc3uJjH9rwKGFNKXbttu08SY1/uQR7f/TqLUpfROqQFv3ef7q+QRTEKj8TIn05qwIABlT7e14k/e+9fWv/sygcm/OJ43ntRvLraRojgdOw5wtSwASo8HJ2ZiU5NRR89iqpXz0/RQa+ILpwadSJ/pP2LGzdvH/yUl1o/4Ld46pJAbz+UUlHAtxgj59zAdIwpAd/B+M0wGdgMtARGYHSc0sDnwO81H7EQtVOgnwtE9ZLPhxB1W+FzQKylYAaXZGeKH6KpvfpH9mZ15kYAlqb/55PE+Dd9DYtS/2Z0g5FB12k4kNqISq367OkxtQoYB4RRQ4u2BjKl1HlKqfdSUyuX6XTt28+Rlp1JCK3P0X6ncUn9swhzGoNetrULYevBNT7lYyxRLExdRo52sDF7Gztz9h73axBVJ9dnJIb1uI61KWs7a7M2A0ZC5Py4M47reEKImne8bYSoW5RSBVNKmc249uzzb0DA7U3Geu/PSJzNYUeiH6MRAeRmIB4jMTFGaz1Oa/1eof3ztNZva60f0Fr3Ai4EkoFRAFrrj2s6YCGEEDVDKXWDUkoW2hKiCsVZYrz3kySJ4aN/1Ane+0vTCqZr/zd9DZdsupXXDnzE2M3jcWu3P8ITVCKJcUyPqfxRFTd7dmvgTeB24H/AmkLbPwOuwVh4qc7RWs/SWt8YXcl1K0wNG6CTjoLbjXv/AcL2HOGE7Mbe/dvTt/uUjzCHMyi6n/fxY7tfZV3mlsoFL6pc4SRG/kiMadOmMW3atAofq/AojOGxp8q8fQGosu+9CB7H20aI4FbcOSJq2rvU27qaBtmJWHv39E9ghQyM7EPv8C4AOHQe7x/60s8R1Q1B0H6c5bldobUu80Ojtf4BOMfzcIpSqlO1RSZEAAmCc4GoRgH82XgX2KyU2quUmq6UulYp1brMWkIIH4XbiHrWGO/2o3kpfomntuoX0ROT5zJ5/roYR/NSuGX7Y97p2zdmb+P3lL/8GWaVC6Q2ojLTSR3bY+pLAKXUO57987TWP3ruP6CUGgl8iNFj6nfpMVU5ymrFetopOH6eC4Djt/m07tacPzF6X+52HipS5+zYwfyW8icAC1KXsSB1GadE9eXmRqMZHH2yX+fPrut8ppM6joW9ndrJt0lzvY9lKilRU5RS86vp0FprPbSaji1E0KgNiYvClFLc3mQs1219EIBPEr7j9iZjibFE+TkyUct1wfhN8X0J+4ustae1/lspNQO4AuN3yd3VFZwQQgi/U0BTYLTnD6XUPmBB/p/Weo//whMisESZI7AoM07tIsOdRZYrmzBzRVYICF5Rlgh6hHdkVeZGNJpl6f8xPeE7DjoSfMpNPvgJw2JOkWuqflCZJEaFe0wppQ4Bf2L0mPpba72pEs9b59mGne6bxDhtEKQtBWCnvegUJOfXO4Mfj/7OgtRl3m1/pi3nz7TlnBV7Gm+1ffq4LqCLynO487z3j+c9WJz6Lwl5SQA0sNbjtEKjb4SoZoMxLjxVJVUNxxRC1JDhMafSIbQ1W7J3kunOYurhb7inaZ0cgCvKL8Zze+y8p3kYv1PCS6g3DyOJMbx6whJCCFELnI/xm2MI0JOCmUSaA1d5/lBK7aYgqbHQszaeEKIYJmWiua0JO3ONr167cvfTJUxmbcvXP/IEVnnWxXh418scyjvi3Zef/FmRsY5/MlZzUmQvP0VZd1VmTYxK9ZgCZgAhFEw9JSrIPmyI975j/mLa1O/sfby3vsadkuJTPsRk59OOr/FTlw84L26od1gUwJzkRdy07RGfi+mi5nQIbcUdja/mxkZXMCS6f6WPU3gqqQvrDceiKpOXFKLSKroekqyXJEQQMykTtzW+yvt4v6PoKFEhjpE/NDXnmO3pntumJdTLLmO/EEKIAKe1/klrPUFr3QeoB1wAvA6sxrgmlf8bohXGeq0fA7uVUluVUu8ppUb7IWwhar3WIc2892X9XF+F18UonMC4vfFVXFb/HO/jtw5Mr9G4hKEyVzxjPLfSY6qGmbt0xtSkMe4DB9HJyTTfke7dt6e5Ddf2nZj69C5Sr3dEV95p9yx7cg8waf9Uvkz8CYDfUv7kt5Q/OSduSJE6onp1C+9It/COx3WMVGc6c5MXex/LVFKiJmmtK5MEF0JUIZ2bi2vXbly792IfXjtmYRsZN4w1mZu4Mn4kHcPa+DscUfvtB9pjXJwqbAfQBzixhHr5X6Kk94YQQtQBWutU4EfPH0qpWOA0CkZqdKOgU1Rbz991wOc1HasQtV3rkOaQaszqsitHBi4V1i/SWBfDTcHi3SdF9uK+ZjeyO+cAXxyZhUYzL3UJG7O20VlGsdSoylyEkh5TfqKUwnZGQcKhwe9rMXn+vzrc0ErW9s2l1m9hb8LLrR/m9sZjAXi42a2SwKhFunbtSteuXctd/qej871ra3QL6yAnzwBW0fdeCFG3FHeO0G43CTFNSep0AikjRuLOyPBTdL6sJgtPt7yn2ATGP+mr0VpmjKtKQdB+rPHcdj5m+zKMi1FnK6VaFt6hlIrBGNmtgZ3VHaAQgSAIzgWiGgXjZ0Nrnay1/l5rfbfWuifQBmMtVicyPa0QPo5tI1rZC43EyJWRGIVFmsPpUajDcT1LLG+3fRqLstA2tAVnxZ7m3ff2wc/8EWKVC6Q2ojJJjP2e2+J6TIH0mKpWtmGnFzz4dSFNskIA0CbFzgPryqyvlOLBZjczs9Pb3NbkqjLLAyTmHWVT1vZKxSvK78QTT+TEE0v636eowlNJySiMwFbR914IUbcUd45QJhPmFs29j107dtVwVBUzL2UJF268mWkJ3/g7lKASBO3HIoxkxeBjtn/qubUDi5VStyilhiulbgFWAA08+7+viSCFqO2C4FwgqlEwfjaUUiFKqaFKqWeVUn8BW4BrMaY3zx+RIckMISjaRhSeTirVmV5clTrtivjzAbArG5PbPkkjW7x3362Nx3jv/5D0G/tyD9Z4fFUtkNqIyiQxpMeUH9mGDvbez1vyNy2dMd7HO1N3FK1QDKUUJ0cVnXZqX+5B1mdt9T7Odufw4t536LtqJEPXjeHlfe9XOm5Rtry8PPLyyrdGyb7cg/ybYfyvaFFmLqg3rDpDE9WsIu+9EKLuKekcYW7b2nvfta32djZIc2bw4K6JALxx4GPy3E4/RxQ8gqD9+NFz200p5e0GprX+ByORoYBmwGRgjue2lafYXuCVGotUiFosCM4FohoFw2dDKWVVSg1SSj2hlFoIJAO/Ag8B/QGrp+h64E3gIiC+uGMJUdcc20acGNmD37tNZ1ufBbzf/gU/RlY7XRk/kh+7vM/87p8xKLqfz77eEV0ZENkHABcu3j30hT9CrFKB1EZUZlTEIuASiu8xdTsFPaZeBLZjzEU4AaPHVGkLgotyMDduhKVbF5zrNkBeHi3TQvkrxti3y3mg0sfNdTu4adsjbMraznOtJtDY1oCHdv2P3bn7vWVeO/AR/SJ7FvmfWFTcV0dm83vKn9iUlQvrj+CMmIF89pkxFG3cuHFl1v8nfY33/oDIPtS3xlVXqKIGVOS9F0LUPSWdI8ztCqZscm2vvX1ENJo0Ty+vhLwk5qcuYUTsID9HFRwCvf3QWu9VSg0BQoC0Y3ZfB+Ri9KxVx+xbAYzSWidXf5RC1H6Bfi4Q1euzzz4LyM+GUmoAxnoXQzASFSH5uwoV2wQs8Pwt1Fon1miQQgSAY9uICHO4TEdeCqUUfSK6lbj/tsZjWJK+AoBPE75nS/ZOmtoa0sTWkBb2JpwZexpRloiaCve4BVIbUZkkxo8Yme1uSqmuWuv1YPSYUkp9CoyhoMfUsaTHVBWwDTsd1+EE7GcMoXVUE/IHt+y2pFT6mC/ue4dVmRsBGL/z+RLLLUv/T5IYVWB91hZ+Tl4IQK+ILhWuvzKjYOqwEyN7VFVYQlQ5pZQZ6IHRLkRhDPEuldb6k+qOS4hgYAmQkRjRlkjGNbyEyQeN/7U/S/hBkhjCS2u9qITtecANSqlngdOBhkAW8K/WemkNhiiEEMI//qRgSqj8xMVWfJMWh/0RmBCi7jot+iS6hrVnfdZWHDqPP9OW++z/8PAMvu/8LqHmkBKOICqrwkkM6THlfxHPPEbEy8+jTCbaJy2C7fMB2F3Phc7MRIWHV/iYV8afz6LUv9mc7TslVbQ5krubXsMXR2bxQLObOLPQIjai8hy6YLiWTdkqXH9FoSTGCeGBswiPqDuUUi2AJ4DLgdAKVNWAJDGEKAdzu7be+7V5JAbAFfHneZMYC1KXccCRQBNbgzJqCQFa693AVH/HIYQQwq+WAI9rref7OxAhRN2mlOKJFndx9ZYJZLtziuxfl7WFB3a9xKQ2j6PUsZfGxfGo1CLb0mPKvwonKVqHFSw/sreZDeeOnVi7lzzsqSTtQlvxU5cPeHDXRGYm/QLAhfWG80SLu4i3xnF9w8sxKd8lVLTWrM7cyMykX1iatpKTI3vzVMu7MasyO1rXebluh/d+iKliSYxsVw4bsgvWLukdIUkMUbsopQYCs4Boiia0hRBVpPCaGM5t5VsXy19ahTRjYFQf/kpbgRs3Xx2ZxT1Nr/N3WEIIIYSo3fJ/S/QHflNKHcIzCgNYoLWuvUNRhajF3NrNAcdhdubsI9YSTbfwDv4OKaAMjOrD2t5z2JW7jwOOBA44DrM2czOfHfkBgJlJv9A7ogvXNLzUz5EGl0olMcoiPaaKUkqdB5zXrl3VzjvX3N4EkxvcJjjUyErWti1EVyKJARBmDmVSm8e5ruFl2E02OoUV9PAsnMDQWjMj8WfeOvgJ23P2eLdvzN5Om5AWXNtI/ictS+Ekhk1ZSylZ1NqszTi1C4D2Ia2ItkRWaWxCHA+lVBTwLRADuIHpGD2n3sEYZTEZ2Ay0BEZgTDWlgc+B32s+4tqhutoIEdzMrVuBUqA17r370Lm5KLvd32GV6Mr4kfyVZswf+8WRn7izyTjp+FDHKaVuwLgItc3fsQghhKh1TsBYi3UIMAijg1Rj4ArPH0qp/RhJjfkY7cmeYo8khPAx7fBMHtvzKgCj48/nf60f8nNEgSfUHELnsHbe9UW01ri0iy8TfwLgyT2T6BrWgX6RPf0ZZlAxlV3El1LqI8/fndURULDSWs/SWt8YHR1dpce1m2w0zjIuWGiTYteBdWXUKJ1Sip4RnX0SGMWVGRF7KpHmotNWvbjvHfbnyrSUZXHogiSG3WS8f7169aJXr15l1i28HsYJMgojKJT3vQ8QNwPxGImJMVrrcVrr9wrtn6e1fltr/YDWuhdwIZAMjALQWn9c0wHXBtXVRojgUNI5QtntmJo3Mx643bh27a7ZwCrozNjTiDFHAbDfcYg/Uv/1c0SBLwjaj3eBzUqpvUqp6Uqpa5VSrcusJYTwEQTnAlGNAvWzobVepbV+XWs9EogDTgTuB+YAGRijNJphrMv6EbBTKbVdKfWBUupKpVQTf8UuRG1SXBvRKqSZ9/7OnH01HFFwUkrxXKsJ9AzvDIBTu7hp2yMcdiT6ObLSBVIbUeEkBjAOuBqZIsSvtMNB9ocfkzLqappvS/du35VS/R3Z/klfzfB1V7MqcyPhpjAurX82bUNaAJDpzuKR3S+jtS7jKHVb4ZEYds90UuX98bEiY733/gkRlRt1I2qXIPvheZbndoXW+suyCmutfwDO8TycopTqVG2RCRGgSjtHFJ5Sqravi2E32bik/lnex58d+dGP0QSHIGk/FNAUGA28D2xTSu1WSk1TSl3tWWNJCFGKIDkXiGoSDJ8NbVihtX5Za30uEAucDDyEMZo7C6M9aQ1cg7HGnozKEILyJDH21nBEwSvEZOf9ds8TZ4kBICEviZu2PUK2q+jaGbVFILURlUliJHlu91dlIKKCzGbS73uU3K9m+iQxdjqq/20xKzNnxw7mrbZPsbr3bF5v8xgvt37Yu/+3lD/5OXlhtccRyHJ10emksrKyyMrKKrWe1pqVGWu9j/tIEiMolOe9DyBdMEZhfF/C/iJzx2it/wZmACEYIzmEEIWUdo6wtG2Diq+P9eR+YK79UzNd2WCk9/6vKYs5knfUj9EEviBoP84HXgX+w2g7lOevOXAVBT1rdyilPlRKjVFKNSvxaELUUUFwLhDVKBg/G1prt9b6H631S1rrEUBv4EPA6SmS354IUecV10Y0tzXG7PlpfijvSK2+yB5omtob8XbbpzF5Lrn/m7GG8zbcwI5amiwKpDaiMkmM/G5+9asyEFExymzGNmwIAM33FVwQ32VJrvbn7hPRjSdb3sUF9YYTag4BoF9kT8bEX+At89juV0l1ppdwBFHcwt4zZsxgxowZpdY74EjgUJ4xFC3cFEaHUJlxIRiU570PIDGe22Nb6DzPbdF56AzzPLfDqzogIQJdaeeIyCmv0yBhF3FL52MfcUYNR1ZxHUJb0zeiO2GmUC6rfw4Od17ZlUSJAr390Fr/pLWeoLXuA9QDLgBeB1bjm9RohTEa/GNgt1Jqq1LqPaXUaD+ELUStE+jnAlG9gvGzoZRq4pky6gOl1HaMNfeupZgOU0LUdcW1EVaTheb2Rt7Hu3JlSqmqdGr0iTzS/Fbv443Z2zhr3Th+Ojrfj1EVL5DaiMokMb7D+DFxdhXHIirIfvYIAJrvzfVu2xObh87NLalKtXq4+a00sNYDQKHYk3vAL3EEgsIXbWzKVu56KzML1sPoFdFZFkQVtVF+hu7Yrhz5Wc2mJdTLLmO/EKIYymLxdwgV9mrrR/mv9yz+1/ohmtob+jscUUtorVO11j9qre/VWvfGWF/pIuANIH8Yan5Soy1wPTDdL8EKIYSoUUqpBkqpy5RSU5RSmzA6TH2CMXVUawraBwVsBN4GLvNXvEIEgtYhzb33d8m6GFXupkajeanVA9g91/wy3FnctO0RHt/9mnTkqqTK/PKdAtwCnKOUukhr/W0VxyTKyXam0eOy8EiMvc1suHbtxtKxQ43HE22J5NmW41matpIHmt9c7MLfwpCri66JUR4rC6+HES5TSYlaaT/QHqNHbWE7gD4YC/IVp6PnNvCuyAohKqRtaNElDpLykslx59K0UI8wUbdprZMxpib8HkAp1RJ4FGNtPjMyTYgQQgQ1pdRFwBDPX+fCu44puglYCCwAFmqtj9RIgEIEuFb2ghk6ZSRG1VNKMabBBfQM78xN2x5hd64x/f+Hh2ewOXsHH3d4mRCT3c9RBpYKXyzSWqcopUYCPwBfKqUmAZO11rurPDpRKnPDhlj69KbZmlUot0abFIcaWsnatoUoPyQxAM6JG8I5cUP88tyB5K4m40jMSyZXO2hgLf/MbCsKrYdxQkTX6ghNiOO1BiOJ0fmY7cuAvsDZSqmWhdsMpVQMxloYmoIpC4UQdcjrB6YyPeE7Rsefz11NrqGhTWYtreuUUiHAQAouYPWl4LdL/gUs7YfQhBBC1IxvKJhasLAt+CYtDtdwXEIEBd/FvSWJUV26h3dkTtep3LvzWX5JXgzAn2nLuW3747zb7jksSvpxlleF/6WUUvkTeKUAzYB7gXuVUvsxeuBml1A1n9ZaD63o84ri2c8ahnPFfzQ6lMfBJjbcZsXu/Wvpzrn+Ds3H/tzDxzVlRJ7bycbsbeS6HfQK74LVFNj/k4+sN6zCdXLdDtZlbvE+lkW9RS21CLgEGHzM9k+B2wE7sFgp9SKwHWNKkAlAA0pfEFwIUYK8v//FuWETru07CL3jZswNA2uKpv25h/k04XvytJOPE75lRuLPXN/wcm5tPIYoS4S/wxM1RCllBfpTkLQ4Ccgfrlo4abEe48LVAow2RwghRPBSwDYKkhYLtNaH/BqREEGi8HRSksSoXtGWSD5o9yKv7v+QVw98CMAvyYt5YOdLvNz6YZQyvuom5SXz8v4PWJCylGsaXspNja/wZ9i1TmWuBA+moNdT/q3CmMe8rLnMFdJjqkrZzh5B5rMTabE3l4NNjN95O5K30t3PcRX2waGveH7v23zU/iUGx5xc7npL01byW8qfrMxYz9rMTeR4pmBqYmvI9Q0vZ3SD84Nqyqq+ffuWun9D1lbvNFSt7E2pZ42tibBEDSjrvQ8wPwJvAt2UUl211usBtNb/KKU+BcZgJMAnF1N3L/BKjUUqRIAo6xyRfu9D5C1ZBoClT2/MF55fE2FVmQxXJj3CO7HcM9ow253Dmwc/ZnrCd9zR5GquiD+PaEukn6OsnQK9/VBKDaAgadEfCMnfVajYJgqSFgu11ok1GqQQASDQzwWiegXw5+MqjKSFLLYpxHEo6RxQeDqpnbl7ayqcOkspxb1NryPTncW7h74A4MvEn4ixRPFgs1uYlvANr+7/kDRXBgDP7p3MiNhTfUbMVIdAaiMq2529uDloZV5aP7D264uKi6P5Pgd/n2Rsq01z2X2e8CNP7HkdgGu3PlDuRMabBz7mxX3vFLvvgOMwT+99gxUZa3mv/fNVGa5fdetW+sgKn/UwZBRGUCnrvQ8kWuu9SqkhGBei0o7ZfR2QC1xL0TZjBTDKMwe6EKKQss4R1tNO8SYxcr//iZAAS2J0DGvD953fZUHqMl7YN4UNWVsBSHGl8czeN3lm75tEmyNpZm/E6PiRjGt4sZ8jrj2CoP34E99OUQBb8U1ayDQhQpQhCM4FohoF6udDa/2Zv2MQIhiUdA5obm/s/Y7dJqQFbu3GpEw1HF3dopTiseZ3kOJM46vE2QC8c+hzvkv6lcN5vv103Lh559DnvNjq/mqNKZDaiAp/OrXWpuP8M1fHC6mrlNmMfcRQWuwtWCh6l6X2XAM8NfpEmtmMRTpztYNrtt7PXM8ccCX5Iem3YhMYLexNqGcpGH0wruElVRusn6WmppKamlri/hUZ67z3ZT2M4FLWex9otNaLtNZztdZ7j9mep7W+AWiDkdB4GLgbGKi1PlFrvb3moxWi9ivrHBFyUUHSInfWHHReXk2EVaWUUpwe05+5Xacxuc2TtLA38dmf6kpnfdZW0j09k4QhyNqPJcAZWuuOWuubtdZfSQJDiPIJsnOBqGKB+tlQSp1ynPXfrKpYhAhkJbURNpOV9SfM5ddun/BOu2clgVFDlFJMbP0gZ8YO8m4rnMBoZI333p9xZDYJjqRqjSeQ2gj5hAYB29kjaL4v1/t4T1Qu2un0Y0QFmtsb803nt72JDIfO44atD/ND0m/Flt+avYt7djzrfdwvoidT209kVe/ZLO05k396fcfEVg9yftwZ9I/sXSOvoaq5tIsz141j5IYbuXzTHWhtdED87rvv+O6770qst7JQEqNPRG2aMEwcr7Le+2Cjtd6ttZ6qtX5Ra/2G1nqpv2MSojYr6xxh6dMbU3NjmLFOTsax6M+aCq3KmZSJC+uPYFH3L3m25b10Dm1HiLJ59ze3N/ZjdLVPkLQfyvPXH/hNKbVfKfWpUup6pVRbP8cmREAIknOBqCYB/Nn4USlVqS7CSqnJwK1VHI8QAam0NiJ/LQZRsyzKwlttn2ZgVB/vtkhzOI81v4OlPWfSO9zouJyrHXx4+KtqjSWQ2ojAXh1ZAGA/ezido58D3gdgb1Mr7r37MLdu5de48jW3N+bbzlO4bNMd7MrdhwsXt21/gmx3DqPiz/Mp2zakBTc2uoI3D35Mu5CWTO0wkRhLlHd/iMnOlQ1GcmWDkUWeZ13mFnK1gz4R3TiSd5Sfjs5jbvIfRJrDeb7VfcRb46r9tZaHw53H2qzNAIQoW7kajQRHEnsdB711Ooe2q9YYhagspdRHnrurtNZv+DUYIeoIpRT2C88j+40pAOR++wP2M4b4OarjYzNZuabhpVzT8FK01iQ6k9mbe5CWx4zQyO8IID/AAtYJGOvtDQEGAdFAY+AKzx9Kqf0YU0vNx5gbfY9fIhVCCFHTYoBflFIDtda7y1vJMwLjVmQ9ViFELRZisjO1/USmHPwMjWZcw0u81y1vb3IV1219EICPE77ltsZjibJE+DPcWkGSGEHAFBdH+3OuRP3zPtoEBxtZOfr8i0ScfjqWrl2wdGyPstv9GmNTeyO+7TyFUZvvZEv2TjSa8Tuf55vEX2hkq8/TLe4hzhqDSZl4sPnNtA1tQb+Inj4JjNJsy97F6M13k+3O4YSIrixJW4kbt3d/ijOdLztNwqzKP5tZjjuXPO0ssnj4QUcChxxH6BXepcSLJgmOJCIt4YSaQorsy1+cG8BmshXZX5z8xU4BeoR3xmqS/3VFrTUO4wfDaj/HIUSdEnLR+QVJjO9/Qk9+FWUKjgG3SinirXFFOiPkuZ08sOtFWoY0487GV7M9Zze/pvzJvJS/yHBlMTCqD2fFDqZPRDcZHl9Laa1XAauA15XxpeoEjITGYOBUIBJoBozx/KGU2kXBmhmy4KsQQgSvLIzE9q9KqVO01kfKqlAogQGwoTqDE0KI4xVuDmNCsxuKbB8ecyrtQlqyLWc36a5Mpid8x21NrvJDhLXLcf+iU0o1VUqNVUq9oJR6Ryn1YVUEFmyUUucppd6rrrnGQkx2GmVaAXCbFTt+nUHa6Gs52vNkjjRqS+7vC6rleSuioa0+33R6i65h7b3blqav5LukX7GarD5lL61/Ni1DmpbruFprbtv+BEnOZLLc2fyZttwngQGwJH0Fbx/8tNyx/p7yF6evvZJn9hSdRnP20QWcu+F6Ltp4C2syN/ns25Gzl+u3PkjvVef6TItVWK67IIlhL0cSw63dvHngY+/jEyN7lPdlCOEP+RM27vdrFELUMdZTBqDq1wPAffAQeX//6+eIqleWK5trt97PV4mzmbjvXQasuYTT1l7Bc3vfYln6KtZlbeHdQ19wwcabOHHVBWS7c6o8hnRXJpMPfMIze97kkKPM6yqiDNqwQmv9stb6XCAWOBl4CPgd42KWAloD1wCfADIqQwghgtdlgAtoB8xRSpXaDVkp9QZwG0ZbsQEYWu0RChHgUp3p/JD0G6/vn8pbB6b7OxzhYVImbm1ckLR4//CX5LhzS6lRN1Q6iaGUaqCU+hzYCUwF7gduxOiFe2zZt5VSDqVUnV20VWs9S2t9Y3R0dLU9R+uQ5t77L01owmej6rGhUyh56SlkPvtStT1vRdSzxvJ1p7foH3mCd1uIshFhCqv0MZVSTG77FI2s9X22nxTZi3NiC6bT+N++930Wxy7Orpx9XLPlfq7eMoHdufv5/MiPrMrw7cCxKtN4/E/Gas5efy337niWzVk7eHz3awxZewVzkhcBcF3DS4t9DocuWHDVpspOYsxInM2aLCNZEqJsXNXgwjLrCOFHOz239UstJXxUd6JbBD9lNmMfea73ce63P/oxmupnURaf9nRPbsmd8VuFNC12ZGRpUpxpJe5zaRdfHPmRU9dcxgv7pvDOoc85Y91V/Jr8R4WeQ5ROa+3WWv+jtX5Jaz0C6A18COQv/Ja/loYQQgiPF/e+w9K0lf4Oo0porX8Grvc87A38oFTxP6ALJTDASGCcrrVOqP4ohQhsiXnJ3Lr9cf63/z2mJcz0dziikAvrDaexrQEAR/KO8nXiz36OyP8qNSeNUqo9sAhoSPl+PLwJ3Ay0UkoN1lovrMzzitK1b9SDJUk7APj7pEj+PikSgOhUJ/dM3sh16emYIiP9GaIRjyWSrztNZkv2Tg46Ekh3Zx73XNbtQ1vxY5cPmHr4a+pb4zgvbihN7Q1xaicXbbyFFRnriLfG4tKuYuunOtOZdGAqHx3+mjxdsCh6lDmCA44EetHFuy3eWg+rspCnnWg0XyXO5qvE2T7HCzOF0i60lc+2PbkHuHLzPfQI6+jdVngkRv/+/YvElebM4IW9U7yPb2k8RhY1DULFvfcB7DugL3A28I6fYwkYWutZwKy+ffsWHUsq6rzyniNCLjqfnA+NkXu53/5IxMRng3atCJvJygftX+SijbewIWsrYLS9g6NP4oyYU4izRPNryh/MTf6Ds2IHl/u4Wms+PfI9z+6ZzPSOr9IvsqfP/llH5zH5wCesy9risz3Zmco1W+/nmgaX8GiL2wkxVd00nlmubJakr2Rf7kHGNbzEZ1+QtR8+lFJNMKaWyv9r5deAhKjFgvlcIMpv1tF5vHnwYyYf/IQ7m1zNhKY3YFKmgP58aK0/UUo1ACZiTDX4uVLqUp2/KBaglJoE3O55uBEYKgkMIQqUdg5obm+MCRNu3BxwHCbbnVPhzj+iethMVm5sNIqn9hhLjU45+BlXxJ+HRVXt9PKB1EaoQuf+8lVQygqsA/LnBJoOfOp5PBljNHiRhQeUUquBbsD/tNYPHk/Qgaxv3756+fLl1XLs5ePHcdOgtRxqXHzv/suzevP8oNeq9Id1INibe5CJ+97lqRZ3E2eNAYxelEfyjpLpyuaPtH95Zf8HHHWm+NS7Iv48Hmp2C/WssUWOuSNnL8/seZNfU4r2ujwpshePN7+DXhFdfLZ/kvAtD+36n8+2zqFt+b17ydNcPbPnTd459DkAjW0NWNz9S8LMoeV52SL4BMSVSKVUDLAGaApcqrX+1r8RBZbqbCNE8NO5uRyJb4VOT4eQEOpvWom5ZQt/h1WtMlyZ/Jg0j0a2eAZEnVDkO45Lu8jTTp/tLu3i1u2Pc07sEE6J6kusJRqlFEfzUpiw8wXmpiwGoJmtEb91m+5dRM+t3fRZdT4JeUneYzWyxgNwKK9gOqnOoe2Y1fX9cv8A/DNtOc/umcy2nN2s7T2HUHNBvef2vsWHh2aQqx2EKBvr+swt6bgB0UaUxnORajAFSYv2hXcfU3wDsBBjTYw6021Q2gghREn25R5k2LqxpLkyALggbhiT2z5VuDNDQLcTSqmJwASMtfc+0Frf5Nmen8BQGAmM07XWh/0WqB9JGyEqa8DqS9ida8wGPb/bZ3QMa+PniES+TFcW/VZdQIorHYDR8efzVIu7q+O6YEC0EZVJ31yH8aNCAzdrrd8HUEqVNR/QIqA7cFIlnlOUQ8+x45l95vlsjUhnVc8wVvUMZ3mfcBLrG+tNfBX2Hxs33Mx77Z+vU735m9sb82bbJ322pTjT6LPq/GLL94noxpMt7uaEiK4lHrNNSHOmdpjI4tR/eHLPJDZn76C1vTmPtriNETGDiu35+kdq0S8UUZaCkTGJiYkA1K9vzMKzPXsPHx6e4d3/aPPbJIERpI597wOZ1jpFKTUS+AH40vPDYrLWerefQxMiYJX3HKHsdiJeeBJTo4bYzxyGCg+vifD8KsIczugGxbfnAGZlxqx8+9ZMOfgZPx2dz09H5wNgVzYa2uqT7sok2VkwpVu4OYyjzhRvEuPfjDXeBEaIsnFL4zHc2ngMOW4HE3Y+701+nBLVt0iiYWfOXlrYm/jEkuHK5Lm9b/NJgpHrrWeJ9UlgAMRaosnVxlpaOdrB0rT/OD2moLdUoLcfSqmLKEhadC6865iim/AkLYCF5VncVYi6pPC54IAjgRlHZrMrdx/1LDE81uIOP0cnqptTO7l9+5PeBEZzW2NeaHW/9zdpYmJiwLYT+bTW93uS3WOB65VSiUAEkP8B30QdTmAIUZqyvi+2sjfzJjF25e6TJEYtEm4O49qGl/HqAWP56c+P/Miy9FW82eaJIh2nKyuQ2ojKJDEu8tzOz09glNN6z22HSjynKAdrz+402LqWyMnv0vF/k7hs5l6yQk08+1BTfhkRA8CarE2cuW4cH3V4iZMie/k1Xn8qLhnQzNaIh5vfxvlxQ8s9/cag6H783m06e3MP0szeqMiFksLebPsEY9JHsiBlGQtTl5HsTOXGRqO8+3/66ScAxo0bB8CTeyZ5p7Y6MaIHI+OGlffliQBz7HsfyJRS8z13U4BmwL3AvUqp/RiLfWeXcQittZZF+IQopCLniLDbbqrmaAJbjjuXz4/4rheSqx1F1tS4psElPNLiNp9kxO6c/bS0N6VPRHceaHYjzTwdQsLMoXzY/kWmH/mOmYm/8FDzW3yO5dIuzl5/LSYUp0SfyGlRJxFrieLJPZPY5zjkLRdazEjZIdEn89zet+gY2oYh0ScX6YQSBO3HNxgdo4794rUF36SFXJQSohSFzwUpzjT+t/89wLgwJUmM4Ddp/zT+zVgDgBkzk9s+5U3Ag/H5COB2orDrgHrAOUDh2T02IwkMIUpU1vfFViFNWeRZDm5nzt4aikqU1+1NxrIpewc/Jy8AYEfOHs7fcCP3NL2GO5pcfdzTSwVSG1GZV9od48fG9xWsd9RzW3RuHlFlTBERhD84ntDbbiT7zXfgpdd47vG99FiTxav3NMZpUaS40rhj+1Ms6zkTk6r02u4BLUTZaWStT4gphBhLJOfEnc61DS+t1FRbJmWiZUjTsp/TZOe06JM4Lfok4K5Sy85PWcr81CUAKBRPt7wnaOc1F0FnMEYbQaFbhTG9VFn/o6hCdYQQosqFmOz83PUjJu57l7/SVnDIcYQMd5Z3fz1LLK+2eYQzYgYWqXtZ/DlcFn9OscdVSjG2wUWMib+gyHerdZlbvL1jC48AKWx4zKk80/KeIts7hbbln57f09TesEKvM8AoYBsFSYsFWutDpdYQQpSolb3g69Y+x0Gc2lnl82eL2uPv9FW8fmCq9/G9Ta+jb2R3P0ZUfbTWLqXUpcA8IH9Y4mZgsCQwhKi89oXWc12ducl/gYhi2U023mv3HDMSf+ax3a+S6c7ChYuX93/AkrT/mNrhJSLMwT8CHyqXxIjz3Fb0x4V8c6pBpshIwh++D9u5Z3G076mM+iaJzpuyuWNSKzIizOx3HGJ91la6h3cs+2BBSCnFit6z/B1GiaYd/sZ7f1T8ufQI7+THaISosOIybpKFE6KK6KwsHH8swdS4EdYe3fwdTsCJsUTxfKv7vI8zXJkcciSS7sqgc1i741o7rLjOIUecR2lorc/hvMSisZijeLblvVxQb3ixnRWUUsGewLgKI2lxoMySQohyCTOHes85Tu1if+7hcnW4Ev6V7sok1GQvMeH0X8Z67tnxLFnuHHqGd+aEiC50DevA+J3P48YNQP/I3tzRZGxNhl0llFKDKljlf8BUwAw8BXRUShV7YUNrvfg4wxMi6J0Y0dN7f1n6f2itpRNtLaOU4vL4czg5shd37XjaO/puSfoKRm++m087vOYzAi9YVSaxkIoxhC+6gvVaem6TSi0lqpS1RzfC7r2drJdeo+e6LE79I405ZxmDYealLKF7eEfcCQm4E5Mwd+yAMpc8HZKoGW7tZnnGWu/jWxqN8WM0QlSM1rpuDu8SooZkvT+V9NvHg8NB6M3XYZ0yqdhyWmtyv/uR7A8+Jub7L1E2Ww1HGjgizOG0C62+3ktnxAxkRa8f2Zy9g0Wp/7A47W9WZWxkUHQ/nmpxNw1s9artuQPAH4BFKdVQetEKUXVahTTzJk535e6TJEYt913iXB7YNZEQk52XWz/E8NhTffYvT1/LlZvv9o4c3O845J1WJF+MOZJJbZ4odXrjWmwhlR+N/Vkp+zTSmVaIMnUOa0u0OZJUVzoJeUlsz9lDu9CWZVcUNa5lSFNmdn6b1/dP9a6TsSJjHaM238lnHV8j1lLRS/WBpTIXm3Z6bvtVsN5ZGI3Iuko8pzgOodeP894/ZUm69/6C1KUAOBb+QVLXEzkS3YSjpwwj7a77yP15LlrLrC7+sD1nD6ku432Ks8TQJqS5nyMSQghRW1jatQGHsdCz47cFJZZLOe9SUi++EsecX8l+f2qJ5UTNUErRKawtNzW+gs86vs76PnOZ0u6Zup7AANiF8dviUT/HIURQaVloSqldOfv9GIkoy6LUv7l75zNkurNIciZz7dYHmHRgmve3+L/pa3wSGCV5ufXDgT5yT1XTnxCiDGZlpl+k72gMUXuZlZnxza7nmRb3eretztzIpRtvJykv2Y+RVb/KZKV/A04ERimlHtNaHymrglJqOHAqRhJjbiWeUxwHS7u2mNu2wbV9Byf/nYHSCq00KzPWk+xMJSTdmKdZZ2aS99dS8v5aSvYbU7BfcgFR772JKVaWMakJgwYZo2j/KTQKo09ENxnGVwfkv/dCCFGcwucI64CTISwMsrJwbd+Ba+cuzK1bFaljG3wqjtm/AJDx1AuEjB2NKTKypkIWNSQI2o9cwAb84+9AhAhkx54LWoU0897flbuvpsMR5bQuczM3bH0Yp3Z5t2k0E/e9y4asrVwZP5Lrtz5EpieBkb9u0yHHEVZmrOO/zA0cyD3MzY1Hc1bc4BKfJwDaiqf8HYAQwaw854CTI3vzW8qfgJHEGNPggmqOShyvaxtdis1k5cFdE9FoNmZv45JNt/FR+5doXYHO0AHQRnhVJonxLjAeiARmKqXO01qnllRYKTUU+NzzMA34qBLPKY6TbcRQst/eQWyqix5Ho1hdLxU3bhan/sOImGhMjRvhPui7zEnuN9+T9M8Kor+Yim3AyX6KvO5o06YNAFN2fuXd1idC5jqvC/LfeyGEKE7hc4Sy27ENGojjl98AyP19AWE3XFOkTtjtN5H1xhTce/ehjySS9fIkIp6Szu7BJgjaj4MYU846/R2IEIHs2HNBK3uhJEaOJDFqo725B7lqy3hvgqKxrQGt7E1Z6ukB/dPR+fx0dL63fH1LLDM6TaZjmPFeV+QCY21vK7TWksQQohqV5xwwKLofF2YN5+TI3gyM6lMDUYmqMKbBBdhNNu7d8Rxu3GzJ3skZ667igWY3cV3Dy8o1xWBtbyMKq/B0UlrrvcDTGEPzBgJblFIvAAPyyyilTlFK3ayUmgv8irEYuAbGa63TqiRyUSG2EWd47w/8syDnNC9lCSEXX0D8gW3UP7CNmFlfE3LNVd797j17SR40gownn8Odno6oPocOHeLQoUM+62H0jejux4hETcl/74ORUqqpUmqsUuoFpdQ7SqkP/R2TEIHm2HOEbdjp3vuO3+YXVwUVEkLEM495H2e98iauQ7LkQLAJgvbjb8+t9NoQ4jgcey5oVWg6qd25Mp1UbZPsTGXM5ntIyDOWC40yR/BZh9f4ouMbXNPgkiLl461xfN35LW8Co6ICvJ0QQhyn8nxf7BLWjsltn2JMgwsq1Itf+N+l9c9mctunsHgSFjnuXJ7a8wYXbryZbdm7yqwfSG1EpRZg1Vq/AEzCSGTEA/cDEyhYjGkR8BZwBgXzED6ttZZRGH5iGzIIrFYABny7zbt9YerfuLUbAHPjRtjPPYvoj6YQPfMzVEyMUcjlIvOpF0jqfpKsk1GNfvnlF36aM5st2cayM2bM9Azv7OeoRE345Zdf+OWXX/wdRpVSSjVQSn2OMdf5VIx24kZgXDFl31ZKOZRS22s2SiECw7HnCNuwId77jnmL0C5XcdUIGTMKS/eugDFlZOZTz1dvoKLGBUH78QHGb4VxSqkIfwcjRKA69lxQeCHv3Tn7vL/3hP/luh1cu+UBtuXsBsCmrHzU/iU6hrXBarLwbKvxTGz1IFZlTJoRb43j605v0SG0daWfM8DbCSHEcQqC74uiDCPrncFPXT6kc2g777YVGesYvu5qHt71PxakLCXHnVts3UD6bFQqiQGgtb4HuBBYQ+kLKa0Hzpchgv5liozEOtCYEqrT5mzqOUMBSHImszZzc5HyIReNpN7qpVhP6e/dZh9+uqzPUM0yXJne+13C2hFmDvVjNEJUjlKqPbAKuBxj2sKyFtZ701OulVJqcDWHJ0TAs3TriqlhAwD00aM4/1tdbDllNhPx0jPex9nvT8O5ZWuNxChEeWit5wFvA42Bn5RSAb0qrRC1RYwlilhLNAA52sGhvEQ/RyQAtNY8svtl/skoaLdfb/M4/aNO8Cl3ZYOR/NrtE55rOZ5fu35C+9BWNRypEEKIQNM9vCM/d/2ICU2v9ybCc7WDjxO+ZcyWe+m28kzGbbmP6QnfsT83MEfoVzqJAaC1/kFr3QvoBdwBvILRo+p14D6gn9a6u9b6p+MLU1QFu2dKKZOGgZut3u3zU5cUW97cojmxC+YQ8eqLWHp0w37BeUXKOBYuxrVX5lmtKumFkhgylZQIREopK/AT0AgjcTEdGAHcXlIdrfVGIH8etTOrO0YhAp1SCtsZhUZjlDClFIDtzGFYh3gWa3O5yLj/MbRTlh8QtYNSahDwNTAHGARsVUpNVUpdq5QaoZQaVNaff1+BELVX4XUxdsu6GLXCxwkz+eLILO/jR5vfxsh6ZxRbtkNoa8Y1vIQGtno1FV6to5RqqZTa7vk7p5x1zlZK7VBKbVVKNaruGIUIRlprtmfvkZlYApDNZOWeptcxp+vUIjO7ZLtz+C3lTx7cNZGrttzrpwiPz3ElMfJprddord/SWt+ntb5Ra32v1voVrfXyqji+qBqF18Xo/8U67/35KctKrKMsFsLvuZ16q5dhO2u4zz7n1m2kXHAFSX1OwbFwcdUHXAcVHokhi3qLAHUd0B5jesGbtNZXa61/A8qakHkRRtLjpGqOT4igUHhdjNxSkhhKKSInPltQ9oefONr/dPlRImqLhcB8jAS2BiKAscD7wM/AgjL+Sv7wC1HHtSo0pdSuXEli1JQX9k7hjLVXMenANLJc2d7tS9JW8vju172PL6p3Jjc3utIPEQaU0UBrjLahvPOdzAVCgTbAmGqKS4igNWHn8/RedS6D1l7OXsdBf4cjKqlzWDtmdXmfLzu+wQ0NR9EmpIXP/qExA0qoWbtVSRJDBAZLz+5YBxrTQ538dwYml3EB47/M9RzNSymzfuGppLTbTeplY9GpqegjiSSfcR4ZT7+A++jRcsWSO/d3Usdch+OPvyr+QoJY4ZEYfSJlJIYISBd5budrrd+vQL31ntsOVRyPEEGp8EiMvL+WobOySixr7XsCIVcXXCixnzNCpocUtUnhaWiPfVyePyFEMQqPxNglIzFqxJrMTUw++Akbs7cxcd+7DFhzCdMOf8P27D3cuO1hXBhrWPUM78zE1g9IW1y20zES3D9prYtfAOwYnnKzMNqH4oe5CCFKdNCRwJE847re0rT//ByNOB5mZebU6BN5suVd/NHjK/7sMYOnW9zDaVEnMTzmFH+HVykWfwdQVyilzgPOa9euXZllqy0Gk4mYWTNIHTWO6F/n0X1dFqt7hqPRLNg2m4s7l78niDKZiJw0kdRLr8KdcMRY/PuJ58h84RVCRl1C2K03YD2xT7F1HX/8Rco5F4PLRe7sudTfsxFTZGRVvcyA1W5gJ97Y8RUADaz1aG5r7OeIRE0ZOnSov0OoSt0xfmx8X8F6+RnQ2CqNJkDUhjZC1F7FnSPMTZtg7tIJ14ZN4HDgWPwX9jOHlXiMqPfexNy2NTlTPyXs7tuqM1xRg4Kg/ZA184SoAsWdC1qFFEpi5JY1IFZUhV+SF/k8PpJ3lEd2v4IJE26MxdUbWOvxYfsXCTWF1FhcAdxWdPXcVnSGj5XH1BeiTqvIOeDkyN4sTP0bgGXp/3F5fLlmchMBoHVIc65r1JzrGl3msz2Q2ojjTmIopUxAW4wLT+VqibXWdW7uIa31LGBW3759b/BnHKbYWGJmzyTjgccYuORLVvcMB+CXWS9zYf3hmOLjy30s26BTiFv5F6kXX0ne3/8aG3NyyJn2KTnTPsXSvSvWIYOwnToA+wXnoSwWXAcPkXrZWHAZHSl0Sgo5U6cTduetVf5aA82u6EMcjk0BjKmkpGdO3dG8eXN/h1CV4jy3hypYr04n1WtLGyFqp5LOEfZhp5O1YRNgrItRWhJD2WxEPPYg4Q/fhzKbffZptxvXjp1Y2rWtuqBFjQj09kNrLUkMIapAceeClvZC00nJSIwa8WvyH9774aYwMt3GKMn8BIZNWXm/3Qs0tjWo0bgCuK3IXxAkoYL18leyr1+FsQgRsCpyDjg5srf3/tK0laWUFMEikNqISk8npZQarJT6CcgANgFLKXveWpm7thZQFguRr7zA8BF3erf91dvC8hcnlKu+djpxHTiI1hpz0ybELp5L1AdvYend06ecc+16st+YQtqt94DZjM7LM0ZuHDrsUy7rjXfQLt/RodrlInfOr+T+Nh/tdlfylRbl1m7y3LVzQdNVO9bSMDkGkPUw6pq9e/eyd+9ef4dRVVI9t9EVrNfSc5tUhbEIERRKOkcUXhejtMW9Czs2geHau4/kM87l6IChuA4fLqGWqK2CrP0QQlRSceeC1iG+00nJWkjVa0/uATZmbwfArmws6zmTx5vfSayl4Cvx860m0NcPUwYHcDuR47kNr2C9MM9tuaagEiLYVeT7Ys/wzt6RYnsdB9mfW9G+iSLQBFIbUakkhlLqCWAecBbG6AuZuzYA9bn8LuJdxveB1GgLF16+hbFLr2NlxvoiZbXWOJb+Tdrt93KkSTsSm7Yn9fKxaKcTZbMRet3VxK34k7hlCwgZOxrsdm9d2yn9UUqRcf+j5P21FICcEBMreoWRHmHCtX0H2R9MM54nL4/sqdNJ6tyHlLMvIvWi0eikqrmmmeBI4twN19NuxWC+TZxbJcesSs4V6Zy4xVgOoG+ErIdRl8ybN4958+b5O4yqstNz26+C9c7CmIZqXdWGI0TgK+kcYT3tFLBaAaPjgOtQxZIQ2u0m+awLyVuwGH0kkbRrb5WLXAEmyNoPIUQlFXcuqGeJJcJkXMvNcGdx1Jnih8iCy6qMDXx06GufdQzzzU0umGxiYFRf4qwx3NT4Cpb2nMlrrR9lRqfJXBF/fk2G6xXA7UT+F5uepZYqKr/8kSqMRYiAVZHvizaT1ed61NJ0WRcj2AVSG1Hh6TuUUiOAJwpt2gMsAvYDuVUUl6gBJmXillbX8fTeN7zb5pk3MG/D9QyI7MPYhhcyPGIAztffIWvKB7h37faW00Du19+R3rABUW++AhgLf1tPOpHok04k/KmHyf1hNs6VqzC3aU3m62+R9fpbABypb+Gmj7qwq6HGlutmyKI0zpv6CIPmzcf990rcewqygGET7iwyxZXWusJTLaU5M7hyyz1syNoKwGO7X2V47ClEmCvaqaN6HM1LJdtt/O9jVRa6h3fyc0RCVNpvwInAKKXUY1rrMn88KKWGA6dinFpqX4ZRiFrKFBGBtX8/8hb/BYDj9wWEjhlVbFnn9h3kzvwBS59e2Icai4Irk4nI114iZbhxUcXx81yyp7xP2K031swLEKIUSikLEAmka61r5zBaIWoxpRQtQ5qy3vP7Z2fOPupZ6+TSY1Xi95S/uGbL/bhxszB1GZ90fMVn/9xCU0mNiD3Vez/SHM5lMqd8ZS0D2gGXK6Ue0VrnlFVBKRUKjML4XfFPNccnRFA6ObI3f6QZU8YvS/+PS+qf5eeIhDBUZg7y2z23bmACMElLt72AdVPjK+iX3ZRXv72d+YMKLugvSV/BkvQVxGUoztmXQL9GGWw7pT4bOoeyvksYhxpaufCHo0x47T0s7dt617TQeXlkPjeR/758A0uukza7fPNaSXEWbvm4O7vqG79FHXYTc4fHMHd4DA0SNnNDXgYX7ykoHzLqEp/6OjubI/GtMLVqgbl1KyxtW2M9pT+2Yadjii5+9pocdy7XbL3Pm8AASHGl8fHhb7mtyVXH9e9XVVZmFnQ+7xbWgRCTvZTSQtRq7wLjMS48zVRKnae1Ti2psFJqKPC552Ea8FH1hyhE8LANO73UJIZz+w4yn/sfOZ987l2PKurzjwi9wljQzT7sdMLuuZ2s1yYDkD7+YWyDT8XSpXMNvgohQCllA8YAFwEnUbDGEkqpJIyLUd8An2utHX4JUogA08rezJvE2JW7zy9TGQWDNZmbuGXbY961LealLmFFxjrvFMDJzlT+SV/tLT8s5hS/xBmEZmK0C40xfmNcXY4673rKa4w2QwhRQf2jehvd1IGlaTISQ9QelZlOqh9Gg/CV1vp1SWAEvt5tBvGO+Ua+GbWFs+ckY3YVvKVHIzTTx8Rzx6TWTLqjMb+dEcOBJjbcZsXMi+pxw5Q2bHv+UXJ/moNz23a2nDOM222fMuqTNlzyVQcmvNiCPc1tACTHmLn5vY7sqF98Z7qEBlaee6gZC89tSsQLTxGfegBLxw4+ZVy7dqMzM3Gt34jjpzmkTn6b1Euv4ki9FhwdNJzMF14m75/l6Lw8AJzayW3bH2dZ+qoiz/fOoc/JcmVX0b/i8VmRUZDEOEHWwxABTGu9F3gaY+rAgcAWpdQLwID8MkqpU5RSNyul5gK/Ylyo0sB4rXWaH8IWImDZC6+LMedXst5+j+yp08n58mtSr72FpI69yZk63ZvAAEgbdzOOP/7yPo54/kks3bsaD3JySBk5iuyPP0NnZdXY6xB1m1JqELAFeB9jesF6+E5FW9+z/UNgs1Lq1BIOJYQopPC6GLtz9vsxksC1L/cgV2+ZQJbb93fjpP1TvffnpyzF5Vl+oXd4VxraZD3pqqC1/gHIv4I6Rim1UClVbIZIKXWqUmoRcCXG74q1WuuvayhUIYJKr/AuhCjjOt6u3H38V8yU80L4Q2WSGPnd3X+pykCEf4XdcTMdojrw7JP7+PHCzdz4/mEaHi67k9u6bmFcOa0N8567ifceHcH5D2Tx2xkx3v3zh0RzyVcdefm1vtw6vTfbmxsfOTNm3mn3LHN4kDGfHSHuaJ63zqtPd8Z0322YoqKKPJ9rlzFMw2WCJx9tysl/duN/9zQGl4u8P5aQ8fCTHD1pMAnRTTh6zkU8sHMivxSan/SO7xWNDxiv66gzhan/vF5kUfGaluHKZHHq397Hsh6GCHRa6xeASRgXnuKB+zFG7uVnSBcBbwFnULBO0tNaaxmFIUQFWfqegIqJAcCdcIT02+4l7dpbSL3imiLJCxUZadxxOEi54AqcW4zeuSokhOjPP/KuZ+Xatp20cTdxpEl70u4YT95aWapGVB+l1DCMhHZzCpIWGcBq4C/PbUahfS2B35RSZ/glYCECSKvCi3vn7vNjJIEp1ZnOVVvGk5BnrNEYaQ5Heb66zktdwrrMzYDvehiFp5ISVeIyIMVz/1RgkVLqqFJqiVLqV89tErAQOAWjnTgKXOyPYIUIBnaTjXPiCjpKTTn4mR+jEaKAquhACqXULowfGaO11l9VR1DBrG/fvnr58uX+DqNYjmX/kDxgKHg+Ey4TLB3WmDmPnsahWOgU1oae4Z3pFd6Ff9JX89SeSbg8Q2orwoSJN9o8zoX1RwBwdMBQEtcv58KvO5ASY8xwdmeTcTzQ7KZi67uTk3nuz4d5p+Eq77aZl22h9W7fqatmTziJxy4t6EV6o2swN5/2Dt+cG8nzDzYFoF5SHj9evJXw+CZYe/fE1LghpgbxuA8nEPHSM0WmqMqZMRNTs6ZYT+yDzszEnZiEOzEJnZ6BpXNHzM2alvvfIc/t5LMjP/Da/g9JdCZTL824uDTn1Ok0tTcs93FE4Dt06BAAjRo1Kq1YxRaCqQWUUiOBp4AepRRbDzyktf6pZqKq3WpzGyH8p6xzROr1t5Hz4ccl1redfhrhTzyEuUVzjp48BPfhBADM7doSt3QepvpGj9HsT78k7bpbweHbicHcoT311v6Nstmq4uWIKlTosxFwbQSAUioK2I4x8gJgNvAisOTY0d5KqYHAA8C5nk1JQNu6NIJP2ghRkpLaiSVpK7l0022AMULgp64f1HhsgcrhzmPMlnv4K20FYKxb+EXHSUxLmMlPR+cDcHbsYCa3fYruK88i02387lzQ/XM6hLb2V9jFOnToUMC2EwBKqQ4YU0MVnrKgcBtR+LWtAS7VWm+ljpE2QpSknNcbfGzM2sYZ667ipMhe3Np4DGfEDKyu8ISfBVIbUZkkxmcYCyU9p7V+vFqiCmK1vWFJu/lOst81OkNb+vQm5ptPMbdqWWzZJWkruWnzAxzVGT7bWxHPS50eJ8IUxjN73/SZykmheK3No1xa/2zvtpyvvyX1srF8f14sTz9q9Bay5mm+fTWCdvU6EXLl5VhPHYgymdBuN19PvYd7uvuu0XV1QlceSx6KY+7vOP5ahmvXbi77/WS2R2YCcFFuLx4Z8Q0qOxuHVTFyZgcONzQuxkx49QCjv0oq8vri/l6ItV9f72PtcnEkvhU6ObnEfz9TyxbYTumP9ZT+hN50XbELkLszMpi/ey5PZH7MLnzXPB4WcwrTOvyv2GNrpxOdU8ZaZm435OSA3V4kAePcth2ddLT0+vmvo3kzzE0a+9bfuAmdll6u+ua2rb0XxfLlrV5rxFae+p06FIk/b/lKnx7FpbH06IYKDfU+1i4XzuUry1UXjM++shQsGaRzcnCuXlu+yiYT1hP7+Gxyp6Xh2ri50BNYsPbpXe54PAKiUSmOUqoHRs+pVhij+TIwZtlcpLWuvSdEP6jtbYSondypqWRP/RT3nr3o7Gx0dg46KwsVEUHouCuxDSqYeSHv3xUcPe1MyDamxbAO7E/s77NQISEAuA4fJufjz8l+fxqubdvBZCL2r9+xndzPL69NlFtAthFKqQeB5zEuRj2utX6uHHUeBp711HlYa/1S9UZZe0gbISrqgCOBE1eNBCDOEsPaE+b4OaLaz6mdfJ/0G6/vn8rO3L3e7W+2eZKL6o9gQ9Y2hq0rWFfxsea388xeY12pVvam/Nnj62J/A9YCtTKo8lJKmTCuQ43GGHFReNqGVOBP4FPga611xXtaBgFpI0RV25q9i/ahrfwdhqgZAdFGVCaJcTJGA7Ef6KS1rh2LCgSI2t6w6JwcMie+hrLbCbvrVu9FjZLszz3EtavvZB17sbgVtzYczZ0tryfUZNTTWvNryh/8b9/7HHQc5smWd/skMMC4OJ/YtjvOvXu59r02rOlhLDB+8t/pvHXnLhRgatWS0KtHs3bP34wZd5icEN+Z0CIzNSsG/k64LQKAeTtmMzbxWQDC3TZ+PmsdkSnGSA0VE8NXF8fy4o1G2fiEPH68eDN2h+//C1GfvE/oVVd4H+f9u4Kj/U4r3z+kxULoNWOInPyqt+dq1qS3yHj0Gf5r4+b6d9rgNhecIxoednDtF2ZOWplDq7QsbEMHEz3dt6dU6rW3GFODlEPYg+OJfOEp3/pXXU/Op1+Wq37ES88Qfv89PtuSh56DY/6ictU/9t8OILHzCbg2bSlX/ZjfZ2EfOsRnW0JMU3RqietD+6i3YTmWzp28j3VWFgnhDcpVFyA+eR8mz/QsYCyMm9SutMEEhYSG0jDLNznl+OMvkgeN8D5WcXE0SCpYwX7Hjh0AtGnTprQjB0SjIo5PbW8jhH+U8xxRbjnfzyL1otHekZeWfn2Jnv4+lg7tvWW0203ewsW49u4n9OorfeprrdHp6cVO+yhqVqHPRkC2EUqpPzDWT/pTaz2oAvUWY1zEWqK1rjMr6EobIUpSUjvh1m7aLx9CjjZG2G044VeiLZE1Hl8gKCl5AXB/s5u4q8k47+NrttzPryl/AMYsA/kLft/Y6AqeaHFnjcVcXjt27AjYdqIkSqkIjERGmtbH9Kqso6SNECWp6t8SIrgEUhtR4TUxtNbLgMcxppT6VikVXUYVEUBUSAgRjz9E+AP3lpnAAGhqb8Ssvp/xaYdX+bP3TB5ofbs3gQGglGJE7CB+7z6ddSfMLZLAAFAWC1FTXsfStCkPTTyAybOw+LKTIpl3unGBxL1rN/smTeT2kfu9CYxWCYrm+421NNLDFV//WtAR70PHb97753990JvAMLVsQdy/i7jhveU0tBojBY40sDLzwjhjf5NGhN13FxGvvID1xBN84wwLJeS6qzG1aG48jozE3LoVlhP7YB3YH8LCCgo7nWS/P42Mh58s2Ga3k+XM5PHHm3kTGJFpLu588yDfXboFm707//U/EffBQ7hTi86MYIov/wJxshhrYFm8eDGLFy8uu6AQok6q6nNEyAXnEfHKC97Hzn+Wk9RrAFlT3ie/c4symbCdPrhIAgMg58uvORLdhISYpiR26s3RwWeSfN6lHD1tBEm9B5DYphtHGrclZeTl5P27osriFkUFQfvRAWNExYwK1ssv36FqwxEiMJV0LjApEy1CCqa73Z1bNxf3XpGxjhlHZpPndha7P8edy6hNd3LXjqd9EhjR5kgea34Hdza+2qd84YSGu9D0yiNiaud6GAHeThRLa52htT4gCQwhyhYE3xdFNQqkz4al7CK+lFKDMEZifAFcAWxVSn0CLAMSoexFErTWgfMvJMpkM1kZEtO/zHKlDau1nz2C+L2bqe9wMHbbRKZlzAbg+SfaMmNUBjlmN4caWkmMtwIQkWdm2uCPmfvNc7zQdCMA07N+ZazzCbY69rAozVgoW7k1V3xp9Io3d2xP7G+zMDdvhgW4pfGVPLlnEgAv39uE34dGc9F3Rzk34SANXnq2SLyWrl2I/uAtwBg9kj/dUK7bwdrMzeRkppB2yz249+5Faei4ORteeQPb0MHYzxqOqXEjXr+jMfuaGwunRqS7+HLMVhqnmiEyDkxmcBvTJamYaLLe+whLx/bYTjO+DJsaxENYWOnDk5WCEDvKszhrYea2rbEUmh6rNKbGRedKNHfqgCUjs3z168UV2Wbp0Q1Vzl67xfXutfbphbucz18kAWcylfu1A2A2+x7Pbi93fWUvOme8ioz0qW+Kkh5wQgj/Crv7NnC7yXjoCcjLg+xs0m+9h9wffybqw7eLTCmYz7X/AOm3jQdAp6biSk3Ftbn4aadzf5yNdcigIlPsCVFIfmeoQxWsd9hzK8OBhChDK3sztmTvBGBXzj56hHcqo0Zw+Td9NZdsug2ndrE6cyPPtZpQpMx3SXNZmv6f93GUOYIbG43i2oaXFTtypVdEFwZHn8TC1L+922It0fSN7F49L0IIIfzMqZ3MPrqQM2IGEG4OK7uCENWgwkkMYCEFiyhpoD5wT4mli9KVfF5RByibjQc63M3stUs5kneUlBAny3v6XpBWGiZ3eZH2EW2JO/dJXt14Kbl2E5tamfj7x7f4tnfBKITBi9JodiAPS68exM79HlODgimFxsRfwHuHvuSAw/gdvKpnOKt6hvNy6lrOnjWWYadcz6nRJxZ7glYWC07t5JvEObyy/0PvMXjIChhD9MIyXUx47SAXXH0j9df8zdLOmq8b1/Me4/5XDtD4cB6QR/TH72LLSge3m7j77ydtzHWkT/8CzGbilszD2q8v4ePvJHx85YcnRzz5CBFPPlLp+lFvvVbpugAxX31yXPVj582udF0VEkK9vxdWur65WdPjqm/t1eO46gcyz/y1bYFYoOzhXUiiW4iaoJQifPyd2M4YQtqY63Cu2wCA45ffSOrYm9A7bib83tt91jfSTifZU6cDGkwmYx2mUpgaxBN24zU+23Jn/0LOVzNRYaGo8HCsA0/Gfv45PusQiTolGWgAtKhgvWae25QqjUaIINQqpJn3/q7cfX6MpOa5tZsn9kzCqY2OYl8cmcX4ptcTZ43xKfdZwo/e+6Pqn8vjLe4sc9qtu5tc45PEOCNmIBYlbZkQIvj8kPQbL+57hz25B3iqxd1c3+hyf4ck6qjKtrLHdgUPiLmzRGCIskTwTMt7uXnbo8Xuf6zFnQyLNaY/rle/BecktODb5sYX8kmJn/H3YZt3orQrv0zE0vcEYn/70WeNA4BQcwjfdHqL5/a+xdyUxd4vt2nRFr6M3saX2x7E6lacaO7IgCan0sLehOb2xjS1NWJV5gYm7nuXbTm7S3wdWeFmnn60GQsXp3H/3dcw/ro0b3/DwX/ncnG9EeTyFQDpd90PzzwESpF+7S04V64yCrpcZL74CjHfflGJf0lfWmuy3/sInZpmrHdSzGgN4cudlobj13lYB5xcYq9kUTyl1GBgAnA6UJEPmyS6hahB1p7dift3MRmPPk3Wq2+C1uiMDLJeeJnsN98h9I6bsZ97JrkzfyDns69wH07w1rVfPJLwB+7FnZaGzszCFBWJiopCRUehE5NwJx1Fhfl2BHCuXkvO9EJt2qtvYmrVkrC7biX02qtknY26ZyPQEGOh1lfLU0EZQ1KvxGgvNlRfaEIEh1b2QkmMnLqVxPg2aS6rMzd6H+dqB18l/sQtjcd4t23M2sZ/mesBsCoLDze/tVzrhpwY2ZMBkX1Ykm5Mm3h27OAqjV0UpZRqCvTDSGRHAebSa4DW+unqjkuIYJfiTGdP7gEA3jv0JVc3uBirSX6yi5pXmU/dU2UXEeL4nBc3lHbdWrI39yBh5lBCTSGEmkKIt8YRb/WdqujaARP4du/dAPzRywwYyYjOG7M40d3GGIFxTAIjX8uQprzX/nkSHEl8dfB7pq/7gP3xBfvzTJolehNL9m8qNd7YZCdtd+QAYGrYgANtotjnMGZGWDwoij9OOYo2Gbm+mGQnL3V+kqixp5E0b5GxBsahwzi37YDsbPKW/eNz7Nzvf8K5dRuW9u3K809XoqzX3yLj3gcBcK5dX2ThcOEr77/VpFw0Gveu3aiICGKX/I61ezd/hxUQlFJPYKydBJLkFqLWUyEhRL78PPZzzyTt9vG41hsXfPKTGVkvvFxsvdyZP+DctIWYbz/3WRQcgLbFLxzoPnKk6LZdu8m45wEyn3iO0BvGETb+TszFTGsogtIsYDDQWyn1itZ6fDnqvAScgJHE+KEaYxMiKLQqtCbGrjq0Jka2K4cX9k4psv2ThO+4qdFoTMro9fb5kYJRGGfGnkY9a2y5n+P1No/y5J43aB/akmExpxx/0KJYSqm+GOf+wZWoLkkMIY7TZfFn88r+D0hyJrPfcYhvk37h8vhz/R2WqINU/gKOomb07dtXL1++3N9hBJ0zfz2TtTGpPtuefyePq1782WcKqbI4jySw6K0HmJ/+D3+dYGVr+9BSy0dkasZOP8zoL5MIy3Zj6dmduCXzyLGbeH7f23x0+OsidV7/swuX3vshADnffEfqpVcBkFLP+MIck5QMgKlFc9x7jIXlQm++jqgpk8r9Oo7lOniIpI690enp3m3RX31MyGUXV/qY1Um73bg2bcbcri3KVnSNieqWPf0L0m68A3JyvNvMbdsQ9+8iTLHl/2FTXomJiQDUr1/q4u0BkQxQSo0A5hTatAdYBOwHcstzDK11nU2WSxshilPOc0SV0G43uTO/J+OpF7zJjMJMjRpi6dkdx9zfvdtUZCRRH79LyIXnl3jcvJWryHp5EjlffwfO4hdW9QoJIezWG7BfeB5Zb72Hbehgwq4fV9mXFNQKfTYCoo04llIqFNgG5GetlgL/A37XWmcWKhcODMUY4TcQo008ALTXWmfXaNB+JG2EKElp7cTunP0MWHMJAI2s9VnRe1aNxuYvr+3/kJf3G5224q1x5LnzSHEZv4U+6fAKQ2MGkO3Ooc9/55Pq2f5Fx0kMiu7nt5irS2JiYiC3ExdirMdqpezfQ/qYMlprXeZojWAhbYQoSVX8lnht/0e8vP99ACLN4fzWbTrN7TJbRTAIpDZCkhg1TBqW6vHFrq+YkPC693H8UTdLu39NaNOKTrFs0A4Hjl/nsefHz1l4dAnbmygONbJyoLGNg42NxcXP+TmFaz4+QkyaZzHu2Fjili/G0qa19ziLkpZw94rxJMQYj89epnnvxoXehae11qScdymO2b/4PH/k5FewdOlE8unnGBtCQojfsxFTfMEwEe104k5KwtywYZmvJ3XsDb7Td3jirbf2b8xNm1To36YwrTWZjz1N7pzfCL//bkIuv6TSxyos7cbbyX5/GpZePYj7ZxHKaq2S4x5L5+bi2r4DLBYjWWKxkPnSq2RPfrfY8razhhMz62uU2S/fhQOjUVFqFnAO4Ma42DRJS0NTbtJGiNoiP5mR+fzLuLbtwH7+2YSMHY1t6GCUxUL21Omk3XqPT7I34sWnCX/g3iLHyvnuRyNh73IV+1wqJhrVsAHuYxYINzVqiPuQseZUzC/fYxs0EMxmvyS3K0u73eR8+Q3uQ4cJvf7q6pwuKyDaiOIopU4G5uG7bpLGWOw7EwjHSHLkv0YFZAOna63/pg6RNkJUhlM7abt8sHfq3K195hNmLr2jVqA75DjCKWsuI9tttFH/a/UQ23J28e4h4/fQ0OgBfNLxFWYm/sKdO4y+My3sTfirx9feERpBKODaCaVUQ4xEdzhGe/AKsAT4BaOdeAxYBbQERgDnYrzOT4BpAFrrRTUctt9IGyGqU4Yrk2HrxnqnleoT0Y1vO0+RtYCCR0C0EUHbQou65YLmI4l2Fky7f02L0ZVOYICxwLj93LNo/950rvvoPx5vdy8vf2Rl+rXb+f2sTfx+1ibuefMQMWkuVFwcIdddTdzfC3wSGACn1RvA7x0+4pr5Vsb+rnh5+HveBAYYC6tGvfUqhIWxq0NbdnVoS+SbLxN2201YBw/CckIvo2BODllvv++t59yxk6Tu/Uhs1JaM5yaW+locfy31SWCoesZ0XDo5mbRxN6HLWJi11GPP+ZXM5/6Hc+UqUkeNI/OVNyp9rHzOzVvI/uBj4/6qNTh+X1Cp4+StWkPq1TeS+dpkdFaWzz7tdpP1zgccadiGpK4nktSxN4mtu5LYvKNPAsPcpRMRLz/vfeyY8yuZTz5XqXhKs3nzZjZv3lzlx/WTfhg/Kr7SWr8uCQwhjp8/zhHKZCLk0ouo998S4tMOEv3ZR9hHnOFdgDv0mquIWzIPc+tW3joZDz5O5sTXfI6T+/sCUkeN80lgWE/uR9TUdzA1NEZK6pRUwh+4l5hZX2Pp0xsAU5tW3gQGQPo9D5D+5PMk2ONIiG3G0dPPJv2+R8j58mucW7eVqy1LHX0NqeNuIv3hJ8ma/A65s3/BnVowilPn5VX436k02u0m/Za7SLvyWjLGP0TyoBG4Dh6q0ucIhvZDa70MY3TFRowfUArjN0oToJ3n1lRo33pgYF1LYAhRmtLOBRZloZmtoLfs7iCcUsqpfUf4vbTvXW8Co3NoOy6PP4erGlzo3T8/dSl7cg/w+ZGCGemuiD8vaBMYAdxO3IaRwNDAeVrrJ7XWvxbav05r/bPWeorW+gKM3yF7gLHAgLqUwBCiNFXxfTHCHM7ktk9h9ixFsyJjHa/t/6gqwhN+FkhtRJW10kopu1KqkVKq8leOhaikUHMID7W7C4COIW24usM1VXZsU1QUYXfeSr3N/xHz4wxsZw7D3LkjIdddTczcH4g/tJ3oD94qcc2Keq068+yDi3nh4SVEd+pRZL+5ZQtivv+SteePYP11Ywi7/WbASHCE33eXt1zW5HfRWVk4128g+ZRhuDZtASDziedwbig65QeAdrlIv71gemn7xSOJ+e4LUEaS1fH7ArLeMOaKdaelkTtvAVnvfIBzx84y/1201mQ86jvFaMaEh0l/4DGO57p1/sKy+XK+/KZIGXdKCkcHDSexTTdy5xVNcji3biN5yNnkfPI5Gfc+SGL7nmS9PxXtdOLctJnk00aQfsvd6EIXr45lv+QC4pYtIHz8nYQV6lmc+exEcr77scR6lbF06VKWLl1apcf0I8/y9fxSaikhRLn5+xyhVPEdc6y9exK34g+sQwZ5t2U88BiZ/3sdAMfSv0m9YBQ4HACY27UlbuVfxC2dT+i4MYTdeYu3XtYrb2A750zi/l1M1Gcfoo8m+zyXa+NmnEuWAaBTUshbsJislyeResU1JHXoRUJYPIld+pAy8nLS730QnVswe13ur/NIOnEQOV9+Q87Hn5H1wsuk3zGBlHMv4UhccxL7nEJiz5NJCK3P0aHn4EpKOq52DIw2Mv32e8l+b6p3m3P1WpIHnoFz67YKHytv9Vpyvv62yD5/fzaqitZ6FdAdGAl8jJHQSMEY1ZfiefwxcD7Qw1NeCOFR1rmgdUjB4t7rs7aWWC7QpDjTOGvdNbT891R6/XcO566/nhu2PszXiT97yzzR4k7MykzrkOYMjj4JAI3m6T1vsCx9FQBmzFxeP3jndw/gdmIYRgJjvtZ6YVmFtdYrgeEYU9g+rZQ6sXrDEyIwVNX3xT4R3ZjQ7Hrv4zcOfMyytP+O+7jCvwKpjTiucT9Kqc7AXRgNRUvPZn3scZVSlwNtgUNa6zqZqlNKnQec167d8S3OLEp2VYMLOSd2CKFmYxHwqqbMZuznnY39vLOr/Nj2Yadj2b+n6PZLLsT04BO4d+9BJyYZvU6/molOOlpQyOUi/e4HiJn7Q5ELTdnvfYRz1RrjQWgoka+8gLllC8Luv4esl14FjJ6z2e9PxbVxszd5oKKjiV30C9ae3UuMOffbH3D+t7rI9qyJr+FOTCLq3Te8PXbLy3X4MNkff+77PN//hM7J8RnBkvX6W+T9sQSAlPMvJ/bXH7AN7A8YyZiUkZejU1K85d0HDpJ+4x1kvfgqrn37vRfUAEwN4lFRUUYPXIcDFRFB2G03EHrnrd5/z4jnnsD532ocv84DIG3sjZgXNsfq6TEsfBwCmgOOsgoKIQKfKTaW2J++IfncS8hbsBiAjPsfxX3gINnTPkNnGssamJo1Jfb3WZhbFvR1Cb3lejKffxmdmYlr/UYcc37FfvYIXJu2oFM8SWaz2TuKI++fFUYSvrgEQ24uro2bjbYMI2lvG9gf5/YdpF402htHEW43rpWrvA/z5i8isVFbGual+B7+9wWkXnmtcRyzGaVMBe2G3Y6pZXPMLVtgbtkcU8sWuPfsI3vKB0WezrVzF0k9+2Pp3BFLpw5YB5yEtf9JWHp0K7HNzPn0S9LG3oCKjMR+/jkou73YcoHOM3JvludPCFGFOoW2ZUGqkQh+dPcrtA9pRc+Izj5lnNrJwtS/CTHZOSWqrz/CLOJoXgqZ7uwS512fcvBT1mRtAuBI3lGO5B3lv8z13v3DYk7h1OiC69hXN7iYhanGIK45yQWd9M+IGUhDW/WvOyUqLP/iye8l7C8y57DWeqtSajpwA3Aj8G81xSZEnXRb46tYnPovS9NX4sbN7Tue5LdunxBriS67shDHqdIjMZRSjwNrMBqHVhQM8S6uu54deBZ4xzOvYZ2jtZ6ltb4xOlr+x65OcdaYaklg+IuyWAi/5zbv4+y33/cmMFREBJiM/4Udv80n98fZPnXdiYlkPFIwUiL8ofHei0cRTz+KpZdnVEhuLq4Nm3wuCunUVFLOvKDEERna5SLjsWe8j0Nvvwn7+ed4H+d89IlxsaeCPVmz33oPcn3XftZpaeQWWkBW5+X59GwlK4uUcy4h77/VaLebtKtu8F7Ewm7H1KjglOPasbMggWGxEP7wBOrv3kj9rauJ37WB+APbqL9lFWF33eaTEFJmM9FfTPVOm6IzMkgeei55/8ico8X4y3Pb1a9RBBil1HlKqfdSSxkdJERtpcLCiJ31NdbTTvFuy3r9LW8yWcXXJ/a3H30SGGAkQEJvGOd9nPm/13EdOkzmK296t0W99ybm/JGODgehN15L/d0biZoxHUvfkhPJubPmoF0u0q65udgEhqpfDxUTU2L9Y9svnZmJTjgCmVmQlm6M5MvKAqfTSMJs2IRjzq9kv/Mhmc9OJHtKwRSQIaMvw3r64IKDZWfjXLmKnM9nkH77eI72OYWE6CYkdupNQnxL8o7pIGAbfjoohU5Px/Hb/BJjFkKIklzT8FLircaUsumuTEZvvptNWdu9+7dm7+KCDTdx9ZYJXL7pDt4/9KW/QvXalr2bU9dcxoDVl/DVkdlF9ic7U5l6eGaJ9UOUjUeb3+6zbWjMAJraGhUpO7rB+ccfsKgO+RdPju3tl99ZKryEevm/R06r8oiEqOPMysybbZ8gxmys83bQkcAXR6T/iagZlUpiKKWeAp4AzBjDvJcCf5ZS5Ssgw1N+ZGWeU4i6KuTasUUutKi4OGLnzyb05uu82zLufQjtWWDVfeQIKSNHoZON6TjMbVoTft/dBfVtNqI/+xDCwgoOajZj6dUD5Vl01H3oMCnDR+IqNCd5vpwvvvYmClRkJBFPPET0zM8IGTfGWyZ3xrc45vxapK7WmuyPPiHz+f/hTksr2J6ZSdZbBRd9LD26FTxfoSmlcr+fhfuYOcV1airJI0aSfvOdPsmcqA/eov62NUQ8/ySqUALRcmIf4lb8ScRzT/qM8CiNKS6O6B++RMXGFjznsPNxLPunXPXrkDcxRuRdrZQK7lUjq5AkukWgU+HhxM6eiXXQQN/tUVHEzv0BS6eOxdYLu/s2Y7QFkLfwD1JHXW0kBwBLz+6EjBtD5KsveMtnvz8V98FD5H71Dc7lRYevh95+I+HPPo6lQzuyJr3tHbWH2Yy5bRtvOZ2Y5DNij7BQ71SLOJ045i/0Oa5jbkmdQItRKGliH3UJUR+/h7lhfOl1srJwbd6KTkzCnXDEZ5e5YUNs556FuW1rHPMWHtdaVv6klFqplFqhlJKLSkLUsKb2hnzZ8Q3vRacUVxqjNt/JtuxdvHPwc0asu5r/Mjd4yz+7dzL/pq/xV7gATD74CSmudNy4eWLPayQ4knz2Tz38DZluo73oENqav3t+y8xOb/N6m8d4tPltfNflXdqFtvSpY1Zmrmpwgc+2xrYGDIk+uVpfi6i0bM/tsQ1ffq+fkqYyzy9f/BAeIcRxaWxrwKttHsGubDzb8l5uaXSlv0MSdUSFkxhKqW7AI56Hq4AuWuuBwCsl1dFa5wK/eR4OruhzClGXmSIjfZIVpkYNiVs0B+uJfYh4+lHvRXXXjp1kvTYZ5/oNJPUbTJ5n7nCAyNdfKnKx3tKlM/X+XUTke28Su+gXGqQeoN5/S4iZNQM8ZV3bd5By5gVFFj7NfKJgceuwe27DVL8+ymIh6qMphFxd0IBlPPJUkYst2VPeJ+26W8l45CljbY+9+4ztU6ejjxqjTMytWxE19R1vHcesOd7FubPees+73T7qEm+CRx9JJPv9aQVxjb+T0DGjUOHhhD80gfrb1xDx6otETf+AuKXzsRZKkpSXtXs3YufPLlgcPS2NlOEjcfwVOHMIVjfPAq2PY0wp9a1SSq7KC1FHqPBwYmbPxHrqAGNDWBgxs7/B2rtniXXMLVsQcvnF3sd5iwr6xES8+DTKZMJ2zpnYRpxhbHS7OXrKMHJnFizGampQkCDI/nA69nPPwtq/HxkPP+ndHv7IfdRb/y/hTz8Kx0zHFHLtWOL3bfFpa7Mmvu69705PJ+eb74uN33r6acQunovt/HPA5DsY2X7phURP/wBlsWA7e4QRa/NmqIhjOo6G+uZ73UcSizxP6LgrcW3fSdbrb5E85Cx0dnaRMgGgl+evxHZBKbVDKbVdKXVGTQUlRF3RKawtn3d8nQiT0YnpSN5Rhq4bwzN73yRX+84C6tQubt72KEl5ycUdqtolOJL4Iek37+N0VybP7p3s8/jDQ195H9/Z+Gqa2RtzclRvLq1/Nrc0HkOP8E7FHvuK+POwqYJZiK6ofx5mZa6GVyGqQP4IjGN7AuQv7DKghHpFF6IUQlSpEbGDWNLzG65peGmRac1f3f8hW7N3+ScwEdRURad7UUq9DdwMJAGdtdaJnu0jge8wprQt8i1AKfUwxpRS67XWJU+0H+T69u2rly+XKWhEUfnTyBTXE1tnZpJ24x3ojEwiXn0BS6HepFmT3yH9jgnGg7AwlNmMTk83HitFxCsvEH7P7UWOWZqcH2eTetFo7zzklt49Cb32KmzDTsex6E/Sb7rTOHxsLPV3rsNUKGbXocMktukGngss0V99TMhlxgUq1/4DJHXuUxAfYGrciJgfZ5B62VhcO3cBEPnmy4TedhNJXfp4FzCPnvEJli6dSOrWz6hoNlN/90Zce/aSMux8n+lCbMOHEjN7ZoXX5CivvLXrSB56LtpzoUmFhxP53puEXFG0AQdj9IlOTMS5fSeuHbtwbd+Ba8cuwu66FWuvHqW+94UUv7JuLaOUyl/h9ybgCiAR+ARY5rlfZhdirfXiaguwlpM2QhSnnOeIWkM7HOTO+RVL965Y2rQus3zeqjUc7e17HcJ2+mnE/P6T95zq3LiJpO4nedulfGF330b4kw9z9OQh3vbC3LoVKi4W5wpjpIald0/ili1A2WzGsbbvIPPxZ3EdOEj4w/dhH3a6d3tSh17gSb7HrfwLa++eZDzxLJlPvwgYSQjbkEHkfOK7ftOxQq65ylgbympcKHOnpeE+nIClfTtc+w+QeulV5C3921ve1KolES8/i21Af0z163nrgTG6MrHrid42J2TsaKI/NhL6hT4btb6NUEq5MUbqXai1/rGyZeoyaSNESSrSTvyTvporNt9Fjtt3CtduYR24r9mN3LX9KVJcxnf1QVH9+LTjq8d9kT8pL5kt2TvpHt6RCHNJMwAVeGXfB7x64MMi27/r/A79Invy1oHpPL/vbQBa2ZuyqMeXWFT5v/c/vOt/fJzwLZHmcOZ3/5wmtgblfzEBKDU1NSDaiWN51rYYDbyvtb650PaXgPsAJ9BPa72q0L5WwGogAvhPa107FnipAdJGiJLU5G+JVRkbOGfDdViVhZsajebuJtcQag6eKd+DUSC1EZVJYmwEOgCvaq3vK7S9rCTGVcDHQKrWOva4og5g0rCIqqadTo72HoBz3Qaf7SoigujPP6r0QuTZ0z4l7Zqbi+4otKhqxAtPEf7g+CJF0h96gqwXjcFZ5g7tqbf+X5TFQspFV5D7XTHzJRZauFXFxRG/ZyMqPJyMJ58j8yljGhH7RedjatSQ7LeNKafsF48k5pvPAGPB1ZRzLgaHA3PbNsT9sxBTXFylXnd5OddvIHnoubgPJ3i3WYcMIuqtV7F07oTWmrwly8j+aDq53/7oO22JR9TUdwgtNAVXGQKjUSm4AOXddMzjsmitdfVknwKAtBGirkoefr7Peg9x/yzCemIfnzLpd99P1qS3vY8jXnmB8HvvAMC5aTNH+w32SZIDYLMRt3wx1u7lG32XcvlYcmd8C0DIFZcS8coLJLXv6U2UR017l5Cxo8l85kWfUYnepxs+lIhnHy8S+7G0w0HG/Y/6vB5CQ4n+YiohI88tKKc1qZeO8Y48MTVtQr11/2Aqup5HrW8jJIlx/KSNEFVlceo/XL1lAg6dh0WZubPxOO5sMg6rycK8lCWM3VLw/X580+u5t+l1pRytqDy3kxUZa1mY+jeLUv9mbdZmNJr2Ia34scv7RFkiSqyb63bQb9UFJDqNUSDNbI3Y5zCmku0c2o7vurzDwNWXkuTZ/3Lrh7givmJrWuS6HSxK/ZsOoa1pFdKsQnUDWK1vJ46llLoOeB/YprXuUGh7F4z1WRWQDrwLbAfaAtcDsRhtyUNa64k1Hbe/SBshaoPrtj7AL8kFfRKb2RrxbMvxDIs9pZRaohYIiDaiMmtiNPXcrqxgvSzPbdldL4Sog9atW8e6desqXE9ZLERO8v1uZmrRnNi/fq90AgMgdNwYIl57ybt4uJcngWFq2ICwO4pJcgDh993lXYPCtWUrOZ98Ts53P/okMCJeeKpgnYpCPWvDbr0eFW6cJgpPMZL786/kfPJFQbnbbvTet58xhLhlC4iY+Cyxf/1W7QkMAEvXLsQunIOpecEPn7wFi0nq2Z/Ua24mqfMJJJ8yjJyPPik2gQHGdF1Q+fe+FlOF/o59XJ4/IUQhQXiOKCL84QneNSlCrri02CRA+FOPYB18KqYmjYn+cpo3gQFg6dSRqI/fLVIn4ulHy53AAAi//x7v/ZyvZhqjID0JDEuPboSMGYVSiojHHyLq4/fAM7rDOrA/sQvnEDv3hzITGGCsTRX5+kSiv5zmbfPIzib14ivJ/nxGQQxffu0zdVbUh2/7JDDqwmdDCFG2ip4LBkX3Y1aXD5jQ9HrmdJ3G+GbXYzUZfUiGxgzgzibjvGVf3f8h81PKP3XqL8mL6Lf6Ai7edCtvHvyYNVmb0J7+LFtzdjF+53OU1pHyh6TfvAmMxrYGzOg0mVCT0Yt3Y/Y2Rm26w5vAaGJryMX1zip3bPnsJhvDY0+tMwmMAG4nfsAYxd1WKdU/f6PWegPGdOYKiAQmAFM8tzGeYmuBN2oyWCFqq5r8vji+6Q2cGFEwo9s+xyHGbb2PCzbcxPuHvmRv7sEaiUOUXyC1EZXp7Zo/ysJVaqmiYjy36aUVEqKuyu810a1bxddqsJ0+mNBbrid7ygdYTx1A9IzpmBs1PO6Ywu++Dfv5Z+P4eS6O3xbgWLDY28s14sWnCy68HMMUF0fYfXeR+ejTAGQ8+bx3eg6A0OvHEf7geOznnUXy2Rfj3rPX2GG3E3r7Td5yls6dsPTohnPNOsjJ8XbnN3fuiHXwIAqz9u5Z6rzr1cHSqSP11v1D5pPPk/XGFCMZk5dHzrRPi5RVERGY27Y2/toYt9YBxiKCx/Pe10JP+TsAIYJNkJ0jimUbPIiYWV/j3LqdsFuuL7aMKTqauAVzSjxGyIXnk/fQBLJeeBkA68n9CJtwV4XisPbpjW3oYBzzFoLbjeOngueLeOkZlLlgsHHo2NHYhg7GffQolm5di51OsCwhl1+CpUc3Us6/HNe27eBykTbmOnRmJvZzziT9toLe0KE3XoN9hO9SEXXhsyGEKFtlzgXdwjvQLbxDsfsmNL2e5elrWZK+Ao1m3Jb7uLnxaO5peq03oXCsdFcmT+x+ja8SZxfZZ8aMy3P54OfkhXx4eAbXN7q8SDmtNR8cLljr4poGl9AypCl3NRnHi/uM9fJWZW707r+t8RhsJmuR4whfy5cvD8h2QmudqJRqD9iAhGP2PaCUSgMepGhH2W+BG7XWOTUTqRC1W01+X+wS1o5vO09hRuJsnt37FslOYyqrfzPW8G/GGp7cM4muYe05K3Yw4xpeTKwlMKbLDWaB1EZUJolxGGgJlD3Jsa/8bmn7K/GcQogyRL39OhHPPYGKianUhZSSWNq0xnL7zYTdfjPa6cS5chXY7Vh7lr60Tdhdt5L9xhTcCUdwexbvBmMER8TEZ4xjd+1C3N8LSb18LHl/LiXi6UcxN/RNvoRcfjEZa3wzw2G33lClr/F4mKKiiHz1RULGjSH9lrt9FlRXkZGEjLqY0OuuxtKvb62JuTpprSWJIYSoFPs5Z2Ivu1ipIp55DFNkBK5duwl/6lGfpEN5hT1wr5HEKMR2+mkFi4sXYm7aBHPTJpUNFzAS9rGL55I87Dxc6zeC1qTfeAdZ7duhk43exsaaGc8f1/MIIUR5mZWZt9s9zZnrruZQXiIuXLx1cDpzkhfxSuuH6Rfp23Ho7/RV3LX9afY6CnrY1rPEcmbsIAZHn8zAqD5M3Pcu0xJmAvDs3sn0iehG74iuPsdZlv4f67OMNZtDTHZGNzCmibqx0RXMSPyZHTl7vGUbWOtxefy5iOCmtd5Zyr7nlFKvAP2BhhizfyzXWh+oqfiEEEWZlIlR8ecxPOZUnt/3Nl8dmY270NKY67O2si17N9c2vNSPUYpAVJkkxj9AK2Ak8FJ5KiilIoDLMeYl/LMSzymEKAdTbPUuN6MsFqz9yrc2mikigvBH7iP9rvt9tkdOmugTp7lRQ+IWzUXn5KBCivbssl9+MRmPFFwXV+HhhFx1RSVfQfWx9uhG7B+/kvP5DBy/L8B2+mmEXDyyxNEqQgghqp4ymwl/aMJxHcN2xhAsvXvi/G+1d1vExGerNRFtbtyIuEW/kDziAu+C5K6t27z7o6dOwRQZWW3PL4QQx4q3xvFt53cYv/N5lqYbM0nvyNnDhRtv5vToAbhxkerMINWVzs6cvd4powAuiBvGc60mEGOJ8m57vMWdrMxYz5qsTeRpJzdve5Rfuk3z6YVbeBTGpfXP9u6zm2w82/JeRm++27v/pkajSxwVIuoOz2iLBf6OQwhRVJw1hpdbP8z9TW/i15Q/mJu8mD/S/iVPOxkRO4hoi+9326+O/MSqzI20DmlGK3szmtsbE22JIsocTrgprE50ChWlq0wSYyZwGXCSUmqs1vqT0gor41P2HgWLK31RWnkhRPAIvek6Ml9+wzsSw3b2COyXXVxs2eISGACWtm2w9D0B53Ljx1PIVaMwRdfOIYfKZCJ0zChCx4zydyhCCCEqSSlF+MMTSL30KgBCrrwca5/e1f68pnr1iJ33EynnXkLenwXzz4fddSu2Y6ZQFEKImtAypCkzOr3J50d+5Jk9b5LhNpa5nJ+6pNjy0eZInm81gQvqDS+yz26y8W775xix7mrSXBnscxzizu1PM6Hp9dS3xpHtzmZu8h/e8tc1vMyn/mnRJzE6/nw+P/IjHUJbc1WDC6ruhQohhKg2DWz1GNPgAsY0uIB0VybzUv6ilb3omkS/pyzh5+Tic5ImTESZw2lsa0DrkOaMjj+fITH9fcq4tRuTqszSzyJQVCaJ8Q2wGugJfKCUagZMLq6gZ/Gl54FBGAmMeVrrP4orK4QIPspuJ+rdN0i58ArMzZsRNeX1SmXPwx+4h9RLr0JFRxM2/s5qiFRUN6WUHSOZbdNa7ymrvBBC+FPIJReip72La89ewiu4rsbxMEVHE/vL96RcehWOOb9iOaEXEc8/WWPPX0O6KaVSqqAMAFrrxccdkRCiRCZlYkyDCzg9ZgAP7nyJeSUkME6P7s9LrR+kia1BicdqYW/Cq60f4fptDwFGMqS4hMiQ6JNpH9qqyPaJrR7kmoaX0tzemHBzWOVekBBCCL+JNIcXm+gG2JW7r9jtAG7cpLjSSclOZ2P2dobGDChSZti6qzjkOEKEOZwwcyjhplBCTaGEmOyYlQmzMmHCjFmZGN/0ep92xq3dfHnkJ6OMMmHGjN1kI9wUSrg5lDBzGKGmEGzKglVZqW+NxawKpq3VWuPGjcr/T0aNVAultS671LGVlGoLLAPqYSQnHBgLLTX3PF4IdAHyv8EoYB9wotb68HFHHcD69u2r8xfVEaKwrCyjZ1NYWPB9IdcOByiFslZ+4T3X3n2oqMhaOwrjeJTzvQ+4VlAp1Rm4CxiOsZYSgNZaW44pdznQFjiktf6oZqOsXaSNEMUJ5vZBFE9rjWvLVswtW5Q4UhF8Phu1vo1QSrmBiv/wKF2RNiWYSRshSlJT7YTWmhUZ69iTe4BoSyRR5ghiLFHUs8QQZ40p93Ge3D2J9w9/WeL+zzq8xuCYk6sgYgHG5yMQ2omKUEpZgEuAYUATIBPYCHyltV5XWt1gJW2EKEmg/JZYkLKUzdk72ZW7j505eznkOEK6K5M0VwbZ7hyfsjM7vc3JUb4jpXusPJskZ3K5nmtO16n0CO/kfexw59F6eflHPq/uPZv61jjv4725Bzl59UVFypkwkicWZcGizFiUhShzBEt6fuNTblPWdq7cfDdh5jDCTCGEmkJQKNy4cWuNxo1VWYmyRNDIGs9LrR/wqb8iYx1fJ/5MnjsPh3aSp/PI03k43M4iMU1q8zhx1oLraoHURlTqS7/WertS6mRgBtAbsAPNKPhhMhjfC27/AhfX9QSGEKWp7Q3K8VA223Efw9y86HDDYBGM771S6nHgMcBE2QkYO/As4FRKzZa2QghfwXiOEKVTSmHp2KHMcgH62QiIH0lCBJKaOhcopegb2Z2+kd2P6ziPNL+NSHM4KzLWccR5lMS8oyTmJePGzdmxQxgU3a+KIhYQWG2FUqoBcA9wGhAN7AF+A972rH+R36n2B6DzMdUvBB5USk3SWh/fAllCBJFAOQcMielfZIqofHluJ6muNPbmHmRnzj46h7Xz2e/WbtJc6eV+rgiz79qlLlwVitWifC+nu7W72HJGEsJNni5IJmS5souUS3dlcCgvEfLKfu4mtoZFtu3K2cf0hO/Krgw4tMPncaB8PqCSSQzwJjL6AhcAVwGnYozMyJcBLAY+Br7RlRnyIUQdsmrVKgB69erl1zhEzQu2914p9RTwKMaFKhfwj+f2lBKqfIUxLWE4MBJjHSUhhEewnSNE1Qmwz8Ziqn4khhCCgDsXYDVZGN/sep9tLu0ix50r00RVg1WrVgXEZ0MpdQLwK8YUtPk6YYzqHqeUGgCYgXkYs4AUlxQ3A/copbK11o9Vc8hCBIRAayOKYzVZqG+Ko741jt4RXYvsNykT2/suJNWZToY7i0xXFlnuHLJc2WS7c7wjGly4cGkXja3xvvUxcUX8ebi0G5d24cZNjjuXTFc2me4sslzZZLlzyPOMcrAp31lG3LgxYy5XMqS4MpnFJDZKEm2OLLLNqio/MDlQ2gg4jiQGGOO3ge88fyilwjGy5Rla67TjD0+IuiMYGhZROcH03iulugGPeB6uAi7XWm9VSo2khCSG1jpXKfUbRlJ8MJLEEMJHMJ0jRNUKpM+G1nqwv2MQIlgF0rmgJGZllgRGNQmEC1RKqVCM9VfjSijSFWPkdjrQwrNtITAXSMLoUDuCgllBHlBKTdVa76i+qIUIDMHQRpSHWZmJs8YQR0yF69pNNl5u/XCln7t1SHP29PvT+1hrjTEJlBuXduPUTpza5b09Vv+oE/in5/dku7PJ9CReTMqEQnlvHW4Hqa50rKroNO09wjvxfMv7sCoLNpMVq7JiUxYsylJkfY4YS5TP40BoI/JV6RyyWutMjLkIhRBC1E23YkwhlQQM11onlrPeCowh4Mc3P4EQQgghhBAi0FwJtMIYsbcaeALYBNQHrgeuwVgDI89T5nat9ZRjjvGSUupWjBHeZk8dGY0hhKhxShkLfJswYVFgp/Qp1u0mG03tRaeJKq9WIc1oFRK8U7DnqzML4QkhhKgRQzB+WEyrQAIDYK/nNvhbXiGEEEIIIURhIz23h4DTtNb5k9tvBZYqpWwYiQ4N/FlMAgMArfXbSqnLMaY7L/8qvUIIIWo9k78DEEIIEVSaem5XVrBeluc2vNRSQgghhBBCiGDTAyNB8WmhBEZhbxe6/1MZx8rf37EqAhNCCFE7lDkSQxmTZ+VP75Gttd5aTJn55XiufVrrsRWMTwghRGAxe27LXtHKV4zntrgfLUIIIYQQQojgVd9zu7aE/YW37y7jWPn7Y44nICGEELVLeaaTuhL42HP/DozhfMcajJE1L5VSao7W+otyRydEHXLllVf6OwThJ0H23h8GWgKtK1ivj+d2f9WGI0TgC7JzhKhC8tkQQoCcC0TpAuTzEYpxTanYDk1a64xCi9PmlHGsXM9t0dVvhaiDAuQcIPwkkD4f5ZlO6lFAAcu01m+XUVaV8Vf5pd6FCHJWqxWrVb5n1UVB9t7/g3G+H1lWwXxKqQjgcjxz3FZTXEIErCA7R4gqJJ8NIQTIuUCULsA+G2V2jhVCVIy0EaI0gfTZKDWJoZTqA3TAaEgmluN4N2L0vj327yrP/i6eYwohjvHvv//y77//+jsM4QdB9t7P9NyepJQqcwpBz5SF7wGxnk0yWk+IYwTZOUJUIflsCCFAzgWidPLZEKJukzZClCaQPhtljcTI70l7SGv9QzmOl6C13l3M32fANk+ZcyodrRBBbP369axfv97fYQg/CLL3/htgNcZojA+UUg8rpaKKK6iU6g/Mp2AUxjyt9R81FqkQASLIzhGiCslnQwgBci4QpZPPhhB1m7QRojSB9Nkoa02MPhgXlhZWwXPNBW4D+lXBsYQQQtRCWmutlLoEWAbUA54BHgMS8ssopeYBXYAG+ZuAfRSM2hNCCCGEEELUPd2UUinHWaZb1YUjhBCitigridHZc7uiCp5rg+e2UxUcSwghRC2ltd6ulDoZmAH0BuxAMwrmuB2MkbjI9y9wsdb6cE3GKYQQQgghhKhVnillny5HGSGEEEGqrOmk4jy3CaWWAnehv5IkHXPMOkUpdZ5S6r3U1FR/hyKEENVOa70d6AtcDHwPHMVIXOT/ZQA/Y0wldbLWep9/Iq0dpI0QQgghhBDC5/fC8fwJIYQIMmWNxAjz3OaUVkhrXdZxoCBrHl6OskFHaz0LmNW3b98b/B2LEELUBK21Br7z/KGUCgeigQytdZo/Y6ttpI0QQgghhBB12GIKrhkJIYQQRSjjGlMJO5VKwJjT/Fat9bvH9URK3QRMARK11g3KKh+slFJHgN2lFKkPJNZQOKL2kfe/7irrvU/UWp9ZU8EI/1BKpQOb/R2HqJWkfRAlqQ9skjYi+EkbIcog7YQoTYjWWtaKCGIlXGuS84LIJ58FUZqAaCPKGkGRiJHEaF8Fz9XBc5tUaqkgp7WOL22/Umq51rpvTcUjahd5/+suee+Fx2b5HIjiyDlClMTz2ZAERt0gbYQokbQTojRKqeX+jkFUr+KuNcl5QeSTz4IoTaC0EWUlMVZhLMQ9tAqe63SM4YGrq+BYQgghhBBCiACmlHJVsqoG0jHWW1oDLACma62Tqyo2IYQQQgghRO1RVhJjITAK6KGUOkVr/WdlnkQpdSrQE+MHx/zKHEMIIUTto5RSQHfPw2yt9dZiypTnvL9Paz22SoMTQghR21V28VWFscZSNNAKOB94Til1n9b6nSqKTQghhBBCCFFLlJXE+BZ4FQgFJiulBmqtMyvyBJ6FXCd7HmYBMyscZd3ynr8DEH4l73/dFajv/ZXAx577dwBFkhjAYMqxUJ9Sao7W+ouqCy0gBernQFQ/+WyIkgTyZyN/IddI4IRC21OBnUAmEA60xkhY4Cn/H5CNMe1tB8DkKfeWUipca/1KjURf8wL5vRbVTz4fojTy+aib5H0X+eSzIEoTEJ+PUhf2BlBKvQLcg/GD4U/gCq31gXIdXKnGwBfAIE/917TWE44rYiGEELWGUmoTxgWkpVrrgSWUcWO0AWX1uF2vte5eRhkhhBBBRCnVHaPjVBvgE2CS1npVMeV6AXcDVwHbgYu01uuUUtHArcATgA3IAzpqrXfVQPhCCCGEEEKIGlCeJEY48DfQ2bMpDfgA+AxYo7V2H1PehDG1yJXA9Ri9phSwHjhJa51VlS9ACCGEfyil+gD/YiQoLtJa/1BCufwkxk3Ab8UUOQWY7inTT2u9onoiFkIIUZsopeKAlUBz4Dqt9bRy1LkW47fIbuCE/HUwlFIXYoz41sBErfVD1RW3EEIIIYQQomaVmcQAUEq1A34HWuA7JUgWsAdI8TyO8ZQJy6/qud0NDNVa7zjuiIUQQtQKSqmngUeBg1rrpqWUy09iXKi1/rGEMluAtsBTWuunqyNeIYQQtYtS6nHgSeBnrfW5/2/vPsMlqcq1j/9vokjOIiijCIIoQQQJIoOKgoogYkYY9CiKCfU1c3RMHPUocgyoKDgGBEQkKYgIDCAgKIIJScogQclDlDjP++FZPbump+Pu3rt7775/11VXd1etqlpdYT1VtapWdTHeL4BdgdkR8ZlK/3OAnYDfR8Q2fc6umZmZmZkNyBKdJIqIa8l2ak8nKyZq3fLAxsC2pdu49KsNBzgN2MoVGM1JWk/SFyRdIek+SfMlXSbpE5JWHXT+LEmaKym67GbVTWNGF+PO7TBf20iaI+k6SQ9KulXSOZL+S9KSE7EspiNJq0jaRdLHJZ0k6eZu1sUwr9vyv46XdIOkh8p/O03SqzudRhNbkZUTc3ucDsAZZNwYuYtOjgFTn+PD6HLs6NleZBxpWMHdwslkzHhVXf/Ty+dTeszX0HCMmB4cJ0abY4X1QtJWkg6W9MvKcr5f0t8l/VjSrh1Mo+/bkPWPY8Roc4zoQkR01QHbA8cBtwMLmnS3lzTbdTv9UevIu8juIk/gGnU3kpVAA8/rqHfkhdpm66lZt23dNGZ0Me7cDvL0MeCxFtO4AFh10MtuKnTkC0R7WRdDt27JCzyHt8nLScCy41xm/yh5fH+bdAtKule0SPOOku7aQW8Lk7zdOQZMg87xYXQ7x46el9/8kt9Xdznea0rMmF/X/7Wl/0OD3jb6tH05RkyTznFitDvHisGvg6naAed2uN5/Dqw8WduQu76vZ8eIEe4cIzpfVkvRpYi4ELgQQNImwBOB1cvgO4CbI+Jv3U53FEnaDPgp+fTKA8AXgLOApYA9gPcA6wI/l7RVdPhCdZsw+5PrqpW1yabXAK6OiN+2SHsweSdhM/e3mpGyTejPlZ/XA4cAlwFrke8e2J2sdDxR0gui7v01tpjqS6dvId/10HHTFnWGZd1+mqwcAPgzWcZcBaxPvhz1eWRZ8x1g35b/qLHVyuetbdLVmpNqtQ3eUTfNac8xYFpxfBhdjh29qT0VvkGX49XSq65/7T/dO+4cDQnHiGnHcWK0OVbYeNWa7L2FjAnnkestgOeQy3pD4GXAKZJ27mB/7WkbsgnhGDHaHCM6Negap1HugLPJ4PMo8PwGw/dhrIbqqEHn111H6/T9lXX2sQbDZ1SGz+phPqsAd5bp3Ais3SDNdyrz2nfQy2bYO+D/kc1SPLnSb7y13wNft+QFnodLmsuA5euGL0U2u1GbzmJlUAd5fZisod+7D8v/1Uyju2c7/M+OASPUOT5Mz86xo/vYUTe9y0rZfyWwdIfjLEOeBD0GXFY37D1lelcNetvow7blGDFinePE9O0cK3qLFaPckU9YvA5Yqsnw5cm7omvLep+J3IbcDXRbcIyYpp1jROcxoqN3Ylj/SdoK2Ln8nBMR59WniYgfkScwAPtKWmuy8mfjtl/5XAD8cALn8xag1g7yRyLilgZp3gfcXb5/cALzMi1ExJci4oSI+OeAs9KvdXsQsHT5/u6IWKTGPSIeBd7O2F2r49lG5pfP1Vsl6lDtCYy7W6aaJhwDRpLjwzTk2NHz9nNi+dwQOFbSCq0Sl+HHlvQAP6tLslX5vK7HfA2UY8TIcpyYphwrvA2NV0S8PCKOLcu00fD7yWVd43eRTF+OEdOUY0Tn25ArMQZnr8r3I1ukO6p8Lgm8YuKyY72StDmwWfl5dkTcMIGzq20/9wLHN0oQEfdVhj1T0tMmMD/WPz2vW0kC9iw/r46I3zSZzvWMXQDZpd3FowZuL58btkzVmY3K5x0tU00fjgEjxPHBJsFUih1VhwI3le97AtdIOqS8BHADSeuUz10kHQJcQz56ThnvK5X8Lw28lLyj68we8jQMHCNGjOOETZKpGiushYj4M2PnUN5XpyHHCJskQx8jXIkxOM8rnw+Q7Z01c06DcWw47Vf5/v2Jmkk5Sd+m/PxtRDzUIrm3nymkj+t2BrBe+X5um9nWprMs2a5qNy4n2298YZfjNfIC8sLTH/swranAMWC0OD7YhJmCsWOhciK0G3AbGU/WAj4M/BK4mnyU/ery+8NluMj2gncr49dsRcals4FTx5unIeEYMXocJ2xCTeVYYR2p3fX82EBzYRPFMcIm1FSJEa7EGJxnlM9rmj0aCBD5kr576saxISNpKeAN5ed9LN68QSPvlnSNpAcl3SPpSklHSmoXADYi25ADuKJN2isr3739TJ5Br9vq74ncRuaWz806+G9NSdoR2Lz8PLtV2mnEMWBEOD5YFwa93icrdiwiIv4CPAs4mrz4ohbdY8CPgM0i4q910/ltROxSuqt7ydMQcIwYIY4T1qVBr/tJixWSHhtn96ikuyT9XdKJkt4jadX2c5yaJG0JrFR+/q2DUca7DdkAOEZYlwa97ic0RrgSYwAkLQusUX7e2MEotTRPmpgcWR/sCqxdvh8fEQ90MM6zycc9lwVWBJ4OvBk4X9JxklZsMt56le/ttp/qY4befibPoNftZG0jPyPvEgX4uqTluxyfMs7Xy88HgBO6ncZU4xgwchwfrFODXu8D234i4raIeFOZ1n8B3wJOAc4qn98q/Z8UEftGxG29znNYOUaMJMcJ68ag1/1kbkOtKrVbdUsAKwNPIZva+wrwT0lvZ3o6uPL9uA7Sj3cbssFwjLBuDHrdT+g2tFT7JDYBqhvNfU1TLZ7G7UgOr+rjfXPapJ0PnETexX4NeeF2bWAm8DbyBcevAVaTtFuDO/C62X6qw739TLz5DMe6nZRtJCJul/Rt8uVOzwJOk/T6cmdoW5LWAY4p4wbw7YgYhXdiOAaMFscHa2c+w7HeB779lBcIHsXYux5GkWPE6HGcsE7MZzjW/WRuQ+eR5wgrkhfmau4GrgPuB5YnKytWLsMCuAz4D7A6eXfxEiXdNyQtHxFfHkdehpKk1zLWjv3vgRNbJJ9Pb9uQDYZjhHViPsOx7id0G3IlxmAsV/n+cAfpa22RLdcylQ2EpFWA3cvP64DzWyS/GVi3Se35GZK+Srb7vBnwIuAA4Bt16brZfqrt2Hn7mVjDtG4ncxv5BPASYBOyPcS/Svou2SzInyJiQTWxpCXISos3knfV1k44rijTGgWOASPC8cE6MEzr3dvPcHCMGCGOE9ahYVr3k7YNRcRMSc8in/4O4AfA/0XE5fVpJW0BHAS8iWxaaVZE/EXSysCBwCeBZYBDJJ0QEfO6zc+wkbQZcGT5+QDwpoiIJsn7sQ3ZJHOMsA4N07qf0G3IzUkNxn8q35fpIP2yDcaz4fE6xtbRD1ocOBARD7d6/C8i/gW8Cnik9HpPg2TdbD/LVr57+5lAQ7ZuJ20biYj7gT3JRwFFnjS8H7gUuFvSXyVdULq/kndO/QH4ALBKGed6YI8OH42dDhwDRofjg7U0ZOvd289wcIwYLY4T1taQrftJ24YkrQacCjwVeEtE7N+oAgMgIi6PiFnAW8mmVE6VtGpE3B0R/wO8viRdiryAN6VJmgGcRj5hsgDYLyKubJa+T9uQTT7HCGtryNb9hG5DrsQYjHsr3zt5ZKaWppNHym3y1R7vq90d0pOIuBb4dfm5UWlyp6qb7ac63NvPgE3iup3UbaT8r2cDp7Noe7TLAxsD25Zu49KvNhzy4HuriPjHeOY9RTkGjA7HB+vZdI0djUh6gaSvS/qdpBsl3V0+Lyn9d+7XvIaYY8RocZywvpimseJdwJOB0yNiTicjRMRR5DnJk8v4tf4nAueS5yAvHEdehkZZt2cC65ZeB0TET3udbgfbkE0+xwjri+kSI1yJMQAR8RBwe/m5Xqu0dWluaJnKJp2kDcmLswDn9/FC7F8r3+u3kRtbDKtXfTmOt5/hMBnrdtK3kYi4MyJeRjYpdTxwZxlU/6I9yrDjgR0i4uURcWf99KYzx4DR4PhgfTYtY0eNpI0kXUxelHkHWTH+RLJd3ScCW5X+v5Z0Udm/piXHiNHhOGETYLrFir3Ii7endDneyeR5x6vq+p9ePp8yjrwMBUlrkLHyaaXX+yLiu32cRattyCaRY4RNgCkfI/xOjMG5Ang+sKGkpZq9NEnSE8nmWWrj2HCpvmTp+32cbtPHBIGrgUfJ/fcZbaazceW7t5/hMBnrtvp7UreRiLgQuBBA0ibkxafVy+A7gJsj4m+9zmcacAyY/hwfrJ+mbewo7ZjPJSssVBl0N3lX1gqMvT8J4LnA7yTtFBF/7GXeQ8wxYjQ4Tli/TbdYMaN83tXlePPrxq+5vnyuxBRU3o/wK2DT0uu/I+KwPs+m1TZkk8sxwvptyscIP4kxOL8pn48Htm6RbmaDcWwISBL54jDIF2kd38fJb1r5fnN1QEQ8AlxSfm4rqVU7czMr3y/oT9asR5OxbucBN5XvO7XJT206DwG/b5O2KxHxt4g4KyJ+UrqzXIGxkGPANOb4YBNgWsYOScsCJ5EXlAT8kdx31oqIVSPiSRGxKrBW6X9ZGXUl4MQy/nTkGDHNOU7YBJlusaJ2vWqDLserpVdd/wXl816mGEkrkE+SbFl6fSEiPjsBs2q6DdnkcYywCTLlY4QrMQbnZ5Xvb2mR7s3l8zG6f4zSJtbOZFubACdGRF8OhiRtAOxSfv49Im5qkKy2/awIvKbJdFaoDPtLRFzTj/zZ+E3Wui0v/Dqx/NxI0vOaTGd94AXl55kR4bYsJ49jwPTm+GB9M81jx1vJfSWAI8h3JB0dEbdXE0XE7RFxNHlB/9ul9/rAf/Uw72HmGDH9OU5YX03TWPF3siJilqSlOxmhXHibRcaV+uZ3am3A3zGOvAyMpOXIF5zXmhb6WkR8ZALm08k2ZJPDMcL6arrECFdiDEhEXAqcU37OkrRjfRpJb2TspVM/iIhbJyt/1pHq431zOhlB0itLrXqz4esAJwC1g7RvNEl6JGOP1f6PpLUapDmUseYX/reT/Nn4DeG6PQx4pHz/qqTl6/KzFPBNYMk207EJ4Bgw7Tk+WEeGcL0fxuTGjj3K55+BAyNiQavEZfg7gT+VXnv2OP+h5BgxEhwnrGNDuO4PY3JiRe1C2IbAseXiWVNl+LElPSxaIQz5fiWA68aZn0lXKmVOYOyO5SOB945jOv3ahmxyOEZYx4Zw3R/GBMUIZSWJDYKkzci245cnHxH7PHAW2QbZHmRwWhK4BXh2RPhxviFRdsJ/k+003wis3+7Eu4xXuyPkZ+SjWjcAD5LNJOwMvA1YrSQ/D9glIh5uMq23ALWXeM0DDgEuB9YEDgBeUYadC7ygk/yNstIm9xZ1vb9XPq8i98+qX0bEvyvjD926lfQZ4ODy88/lP1xNvkDp/eRLuAF+GBH7NpqGTRzHgOnJ8WG0OHb0Fjsk3QysDXwoIr7cxXgfIE94bomIddqln4ocI6Yvx4nR41gxvlhRKiX+Rr5jD+BWcrmdQy6PB8hm955KLof9yWUict96Ru3u3vIkx83kcuoq5gySpJ8y9oLyi4C3M9YsVkMR8ZcG0+nbNmQTyzFi9DhGdBEjIsLdADtgV7KmK5p0N5KP1g88r+4WWW/7VtbRIV2M12w913fHAit1ML2Pk00INJvOBcBqg15eU6EDZnexfgKYOezrljyAP7xNfk4Clh308h/VzjFg+nWOD6PVOXb0vPweKvndu8vxXk1exHlw0NvABG9fjhHTsHOcGL3OsaKnZfdM8oLugpLndt0C4F/ApnXT2RY4s3QbDXqb6OL/d7PdBBA9TqejbcjdhK5zx4gR63CM6HhZLYUNVET8UtKzgPcALyfbvXuMfMTxROCrEXHXALNoje1X+f79LsbbHdgOeC7ZlvMaZA37vcD15B13cyLid51MLCI+J+lMsmmFnYAnlGn9FfgR8L2IeKyL/Nn4Dd26jYweB0o6kaw135asQb+TrE0/KiL6+ZIw65JjwLTk+GDdGLr1Psmx425gdfJpjG6sWT7v6VM+hpJjxLTlOGHdGrp1P1mxIiL+UsrBQ4HXQstrWI+SF+k+EBG31U3nt4y1Bz+K+roN2YRyjLBuDd26n6gY4eakzMzMzMxs0km6kDypOTcidu5ivLPJ9sF/GxHbT1D2zMxsiEhaG3gZ8ByyianlgfvJZqJ+D/wiIm4ZXA7NzGwi+UkMMzMzMzMbhNPJSoznSzooIg5rN4Kkd5EVGAH8YkJzZ2ZmQ6NUUBxVOjMzGzF+EsPMzMzMzCadpFWBvwMrl17HAV+MiMsbpN0M+CDwBrKd3fnABm5OyczMzMxs+nMlhpmZmZmZDYSkPYCfAktUet8OXEM2E7I8sCHZvi9kBcZjwF4RceokZtXMzMzMzAbElRhmZmZmZjYwkl5KNg+yVqV39SRFle+3AvtHxOmTkTczMxsOkl4A7EW+vHYdYEXyZbM3A5cAJ0TEOYPLoZmZTSRXYpiZmZmZ2UBJWgF4M/BKYGvg8ZXBDwC/A04A5kTEfZOfQzMzGwRJGwE/JF/ovbB35Xv1otYlwL4Rcc1k5M3MzCaPKzHMzMzMzGyoSFqJcpdtRNwz6PyYmdnkk7QFMJeMB9WKi7uB+4AVGHuvUs09wE4R8cdJyKKZmU0SV2KYmZmZmdmUIemVwO5ARMRbBp0fMzPrP0nLAlcBTy69/gh8CTgjIm6vpFsDeAnwfmDL0nsesElEPDRpGTYzswm1RPskZmZmZmZmQ+PZwKzSmZnZ9PRWsgIjgCOArSLi6GoFBkBE3B4RR5NNEX679F4f+K/JzKyZmU0sV2KYmZmZmZmZmdkw2aN8/hk4MCIWtEpchr8T+FPptefEZc3MzCabKzFsoCTNlhSlmzno/NiiJM2trZ9B56XfJM2sbHuzB50fM1ucY8Rwc4wws0FyjBhujhHWB5uST2H8sF0FRk1J90Py/RnPnMC82ZBzjBhujhE2HksNOgOjTtIM4Lo+TW7/iJgzznzMAmYARMTsPuVn0kl6HPBq8q6LLYE1geWA+4GbgGuAS4HzgAsi4pHB5NR6IUnAC4HXA9sA65Eve3sQuA24FrgcuBA4yy8EtanKMaK/HCNGg2OEjQrHiP5yjBgNjhFTyurl8/oux/tn+Vy1j3mZchwj+ssxYjQ4Rgw3V2JYzSxgp/J99uCyMX6Sngf8AHhKg8ErlW4T4BWl30+A105O7qxfJK0L/AiY2WDw8qWbAbyo9LsVWHsy8mY2jc3CMcKmAMcIs4GYhWOETQGOEVPO3WRFRrfrYM3y6YuLw2EWjhE2BThGDD9XYgzercArWwx/AfDu8v0c4Kst0v6hX5maaiQ9F/gVWRMOWRN+Atke5t3ACmRhsy1ZIC0LLDnZ+bTeSFoVOBfYoPS6H/gZcDG5Ly0DPBHYigwsq9NkPUfEXPIxY7Nh5hjRB44Ro8ExwkaQY0QfOEaMBseIKelaYA1gb+AbXYy3d2X8UeYY0QeOEaPBMWJqcCXGgEXEA8BJzYZLWqXy858R0TTtiPs2Y0FlDvCOiHiwUUJJK5AHNutNTtasjz7JWFD5A7B7RNzcKKGkJcng4jsgbMpyjOgbx4jR4BhhI8Uxom8cI0aDY8TUczp5Yfj5kg6KiMPajSDpXeSF5AB+MaG5G3KOEX3jGDEaHCOmAFdi2JQnaVNg8/LzBuBtrdofjIj7yOBjU88bKt/f2CyoAETEY8AZpTOzEeUYMVIcI8ysK44RI8UxYur5OvA+YGXgy5K2Ab4YEZfXJ5S0GfBBxtbz3cDhk5RPm6YcI0aKY8QUsMSgM2D9IelJkj4v6Q+S7pT0kKSbJJ0qaVapKWw03lxJwVgbhUiKBt3suvGWkvQSSV+W9BtJt0p6WNK9kq6WNEfS8yf2Xy+0ceX7Rf14gZKkjSV9UNIpkv4h6YGyTP8l6ZeSDiwvdmo1jZn1y0/SRpK+IemaMs2byzravsH4L5P0c0k3SHpQ0vWSDpf0hDbzrc1zbvm9pqRPS/qzpLsl3SPpUkkfkbRcq2l1Q9Iakj4u6XxJ/y7bw23l94ckrdjj9FdnrH3TWyPiyh6nt9j6qRveaD9o1c1tMa8VJB0k6cyyzh8q++nvyrpZs9m4Zv3gGLGQY4RjRKfTc4ywkeEYsZBjhGNEp9NzjJgEEXEXsD+woPR6LXCppFtK2XFG+bwFuIy8CCngMWC/Mr71yDFiIccIx4hOp+cYMVEiwt0Qd+RLkKJ0c5qkOQB4oJKuUfcnYEaDcee2Ga/Wza4b75wOx5sDLNPi/82upJ05zmX0mso0zu7DMt+3w/92LbBJi+nMrC4/4FVku3qNprUA2L+MtzRwVIv5/gt4Wov51tLNBbYEbmwxrWuAp7SY1sLto4Pt9J42y+vfwHY9rJe1KtN6CFiqx/W8yPppsRw77eY2mc9uwC1txr0HeEWv26670etwjOhkGTlGLDpfx4jOprfI+mmxHB0jBtABnyn7xWODzsswdzhGdLKMHCMWna9jRGfTW2T9tFiOjhF96ICXlm1gQaV7rNJV+/8b2G3QeZ4KHY4RnSwjx4hF5+sY0dn0Flk/LZajY0SXnZuTmuIkHQB8q9LrVLLtx/nARuSdC08BngX8RtKWEXFbJf3B5MuyPgtsWvo1evlTfU3kcsB9wFnApcA84EFgnTKdNwLLA/uVvBzU/b/r2N8r33co//GyHqb3eHJnvxQ4D7gKuAtYCVifvANkI7K9vNMlbRER89tM89nAR4CHgcOA35NPQu0KvJ68Y+Q7ks4H3kuutz8BPwKuB9YG3gY8E3gCGbCf12aeK5MvIlqXfBHVScCdwNOBtwBPBp4GnFX+wz1tpteQpPeW/wRZ4J8AnA/cAaxW/uMe5T/8WtLWEXHFOGZ1O/lY8MrkS5UOoLsXvHWr1UvQavYHXlG+z68fKOlVwHHkC58eA35O7jP/BlYEdia3pxWBEyXtEhFn95xzs8IxAnCMaMYxojeOEV2S9Nig82CLcowAHCOacYzojWNEH0XEaZKeBryZXLZbk/tazQPA78jtZ05kkz7WI8cIwDGiGceI3jhGjNega1Hcte5oUTsOzGCsVvxR4DUNxl+O3Jhr0zi+yXzm1tJ0mK8XAsu1GL46WbgEuUM1rIGlP7XjS5CBrzadu4HPkTXDS4xjeps2y29lfv+vMr9PNkk3k0VrQK8Fntwg3ccqaS4la8oPr887GfD+VEm7TZP51te8vrNBmhVY9A6Hr41nuwC2Ah4paa4ENmyS7mVkUA3g4h72hyMqeX6MDLAtt8UW06qun9njGP/FZb8L8o6FJ9UNf1LZFmt3BmzdZDpbk0EpyHY2lx7v8nE3eh2OEZ3kxTFi0XSOEZ1Nq7p+Zo9jfMeIxf9L7c7ZBX3oatPxkxitl/msynY8p27YDBwjwDGifnqOEZ1Nq7p+Zo9jfMeIHjvyou+6wEqDzstU7XCM6CQvjhGLpnOM6Gxa1fUzexzjO0Y0WzaDzoC7NiuodWA5tDLsCy2msRJwc0m3ANioQZqWBcg48/7USv4ObpJmdiXNzB7mtQONH3O8j6zhPpR8xG7VPv6/c2sBo8nwmXV52bZJumVZ9PG4P9Hk8TWync9auv9ukqY6z2Na5H/tSsH3ALBKt9sFcEoZ/iAtHjssaT9dydf241zma5IBun49P0K2g/od8g6dpgcGTdbP7C7zsUklGPyHBkEe+Gpl+ju2md6bK2nf0K9t1N3073CM6HRejhFjaRwjHCMG0tGfyovFKjMG/b+GucMxotN5OUaMpXGMcIyY8h15l/NRwJGDzsswdzhGdDovx4ixNI4RjhED7fxi76ltr/L5KPDlZokiH906vPwUsOfEZmvhfP9B1goCPHeC53UBsC0ZRKqWB3YE3gf8FPi3pGMlbdiH2V5YPjeQtEabtJdGxG8bDYiIh8hH/mq+HRGPNpnObyrfn9FBHlttF7eQjxBC3kWxawfTW0jSqmStN8DJEXFtm1F+VPn+4m7mVRP5eOpzge+TteM1SwFbAP8FHAn8Q/kSsBeOZz6tlJc+nUo+agjw5oi4pC6NyMdcAS6JiPPbTPY4cj+GcS4bswYcI8bm5RjRmGNEnzlGNBcRS0xA1/BlotYRx4ixeTlGNOYY0WeOEZPm2eQF+lmDzcaU5hgxNi/HiMYcI/rMMaI9vxNjipK0FtlmHsAfI+LWNqP8inwJIvSpkJe0ErnzvJRsB3ENsiBvZL1+zLOViPgTsJOkLcia8OcDz2HR9jKXIduF213SGyLi5GbTk/Qi4HXkI1hPJtuSa3ayvC7Zjl4zF7fJ/i2V75c0TbVoulXbTPNu8pHBVs4GDizftwaObZO+agdYWBH6oKQ926RfuvJ9ky7ms4iIuAOYJenjwKuBFwDbkdtfff5+LemQiPj4eOdXJWlpsh3GDUqvT0fEMQ2Sbkq20QhwZwfLBvJOjlXoYdmY1ThGLM4xYjGOEY4RNqIcIxbnGLEYxwjHCBtRjhGLc4xYjGOEY8RAuBJj6lqn8v3qDtJX06zTNFWHJO0M/Jh88U8nVup1np2KiMuBywEkLUnuqDuQdxPUah4fDxxTXjK0yPKTtDLwE7qrpWz3/+5oM/yhTtJGxENZ8QrA49pM8+8R+fxYC9Ua7Se2SVtvRuX7vqXrVLug2FZE3ES+5OkwAEnrk3dIvBR4DWPL52OSroyIH/Y6T+CbwE7l+/HkI6qNzKh835Xu7jzoedmY4RjRlGPEQo4RyTHCRpFjRBOOEQs5RiTHCBtFjhFNOEYs5BiRHCMmmSsxpq4VK9/v7yD9fU3G7Vp5PO4X5GNhAFcBpwPXAHeSbdbVHEG2LTeQx/0j4jHgL6X7tqSZwGlk3pcDPkQ+Flb1U+BF5fu95ONcl5Mv1HmAbOsRsub8teV7u/+3oM3w8aZt5YEO0lS3nRW6nP7K7ZM0tUwP4zYUEdcD1wPHSfoE8Etg4zL4k0BPgUXS/wPeUn7+HtivReAeqmVjI8kxogOOEW05RnTIMcKmGMeIDjhGtOUY0SHHCJtiHCM64BjRlmNEhxwjOudKjKnr3sr3Zo/VVVULjXubpurMRxkLKp8jX/rTcAeT9J0e59VXETFX0qeB/ym9FmnHTtLzGQsqfwR2KW3jLUbSDhOW0f54fPski2w79zVN1Vg1/ayI+H6X40+YiLhe0v7ARaXXBpLWL8Gna5JeDnyh/LwZ2CMi/tNilOqymR0RnxrPfM164BgxDo4Ri3GM6IBjhE1BjhHj4BixGMeIDjhG2BTkGDEOjhGLcYzogGNEd/xi76nrX5Xvnbw4qJrm5h7nXSt4bwU+0SKorMhYW23D5KzK9/rH2l5U+f7xZkGlWL/FsGGwgSrPAzbxtMr3breLmyrfN+1y3MlwMYsW8N0+wgiApGeRj7MuQd5x8IqIaLeshn3Z2PTnGDF+jhFjHCPacIywKcoxYvwcI8Y4RrThGGFTlGPE+DlGjHGMaMMxonuuxJiiysuVajV9W0has80o1Tb3Gr3MZ+FjZR0URmuXz+siotXjaC9iOLexhyvf62uE1658/3uzCUhaBpjZxzxNhJWBZ7dJs3Pl+++6nP55QO2gYg9JQ7WuywHPo5Ve3db+115qdir5WGwA+0ZEuxdYAVwG3FO+v1hSJ3ewmPWNY0RPHCPGOEa04BhhU5VjRE8cI8Y4RrTgGGFTlWNETxwjxjhGtOAYMT5DtSFY104on0sBBzVLVGqpDyw/AzixQbLqTtduJ6i1f/fUZkGovOToY22m0xeSVikFfadeUfl+Rd2watt+G7SYxjvI9heH3fubDSgHI/uUn/8h2/XrWDm4qY2zEWNt+E0ISUtIWqOL9DsCq5SfDwL/6HJ+ywInMXYXxCci4oTmY4wp7WMeXX6uzCTtC2Z1HCNwjGjDMSI5RtgocozAMaINx4jkGGGjyDECx4g2HCOSY8QkciXG1PY1skAA+JCkV9UnkPQ44EeMPd50QkRc02Ba11W+t6tRrdWirkmDgCZpaeA7wHPaTKdftgX+Lul97e4SkLQXi+7k9S/gqdYQf6IULvXT2B34/HgzO8neIOnt9T1Lbe0xjL0U6MiImD+O6R8MPFK+f03SPq0SS3qypP8ttc7dWgaYJ+nLkjZulVDSpkC13cQTI6KTl5JVfRfYrnz/cUR8tsvxDwHml+8flfT/Wt1BIGlNSQdL2qzL+Zg14xiRHCOac4xIjhE2ihwjkmNEc44RyTHCRpFjRHKMaM4xIjlGTCK/2HsKi4h5kt4HfItclz+VdDJwGrlBbwi8GXhqGeUm4J1NJncW8J7y/UhJXyEfIXys9Ls2Iq4t378G7FK+HyppJnAGcEeZ577l85zyuV4v/7ND6wGHAl+UdCH5kp1ryeWwLFnTvRsZhGrOA46sm86J5HJaF9gGuELSkWTN6irAS4HdyVr0nwF7Tci/6Y/LyTx/U9Ke5H+bz1hNdq3W9zrg4+OZQUT8QdI7yAOJZYEfSvoAcDK5/B8qedgY2IFcpgL+bzzzI+/ceD/wfkl/Ai4A/gLcXqa7LvB84GWMlW//Bj7UzUwkvZKxOwfuBE4ty7CV2yPiN7UfEXGjpNcBp5BB8X+Bt0k6AfgbuQ2tRO4j2wI7AksCc7vJq1kzjhGLcIxY3OU4RoBjhI0ox4hFOEYs7nIcI8AxwkaUY8QiHCMWdzmOEeAYMfkiwt0Qd8As8rG8AOY0SfN2spY8WnR/Bma0mM+SwPktxp9dl/6QNvP7DVl7Pq/8ntdkvrMr48wc5zJ6NvmioFb5qXYLgO8ByzeZ3rZkYdJs/LvIANMy72Q7hg2XX4O0cyppm66nkraWbm674cAWwI0t/su1wFNbzGtuLW2bPO1OFuCdLP/bgTXGsZ6XJoNIp+s5yMDztCbTa7p+WHS/67Rrtj62Jdu87GQa9wLPGkRZ425qdjhGdLKMHCOaDMcxwjHC3bTucIzoZBk5RjQZjmOEY8QkduQF7X52C4DHBv2/hrnDMaKTZeQY0WQ4jhGOEQPo/CTGNBAR35L0C7Lm+yXADODxZG31ZcDxwA8j205rNo3HJO0CvBfYg6zNXIkMOI3Sf0zSecC7gOeSj4rdTtb6HUMGwUfV9r1NvYusoV235GNnckfeiHyscXmyhnY+cCVZ0BwTEX9rMb3fStqcrFHdDXgSGbhvAH4BHB4R/5S0zYT9qT6JiMslbUne+bAnWSMu4Bpyu/i/iHig+RQ6ns+pkp5C3hnxUmBLYA1y+7mbDGC/B34F/CoiHm42rRbzeAR4pqQNybszdgA2Kf9pJfJg9R7yTobfk+14zo1Sug9K2Z6eDryWbCNza/Kg63GM5fcy4NfAL6L7RxHNWnKMcIxoxjHCMcLMMcIxohnHCMeISSbyQls/dvyBrrfpxDHCMaIZxwjHiEHQgJe5mfWZpNpOfW5EzBxkXszMbLg4RpiZWTOOETYokhZMwGQjIhpeKDez7jlG2KD5SQwzMzMzMzMzMxuIiGj6UlozMzMABwozMzMzMzMzMzMzMxtKrsQwMzMzMzMzMzMzM7Oh5EoMMzMzMzMzMzMzMzMbSq7EMDMzMzMzMzMzMzOzoaSIaJ/KzMzMzMzMzMzMzMxskvlJDDMzMzMzMzMzMzMzG0quxDAzMzMzMzMzMzMzs6HkSgwzMzMzMzMzMzMzMxtKrsQwMzMzMzMzMzMzM7Oh5EoMMzMzMzMzMzMzMzMbSq7EMDMzMzMzMzMzMzOzoeRKDDMzMzMzMzMzMzMzG0quxDAzMzMzMzMzMzMzs6HkSgwzMzMzMzMzMzMzMxtKrsQwMzMzMzMzMzMzM7Oh5EoMMzMzMzMzMzMzMzMbSq7EMDMzMzMzMzMzMzOzoeRKDDMzMzMzMzMzMzMzG0quxDAzMzMzMzMzMzMzs6HkSgwzMzMzMzMzMzMzMxtKrsQwMzMzMzMzMzMzM7Oh5EoMMzMzMzMzMzMzMzMbSq7EMDMzMzMzMzMzMzOzoeRKDDMzMzMzMzMzMzMzG0quxDAzMzMzMzMzMzMzs6HkSgwzMzMzMzMzMzMzMxtKrsQwMzMzMzMzMzMzM7Oh5EoMMzMzMzMzMzMzMzMbSq7EMDMzMzMzMzMzMzOzoeRKDDMzMzMzMzMzMzMzG0quxDAzMzMzMzMzMzMzs6HkSgwzMzMzMzMzMzMzMxtKrsQwMzMzMzMzMzMzM7Oh5EoMMzMzMzMzMzMzMzMbSq7EMDMzMzMzMzMzMzOzoeRKDDMzMzMzMzMzMzMzG0quxDAzMzMzMzMzMzMzs6HkSgwzMzMzMzMzMzMzMxtKrsQwMzMzMzMzMzMzM7Oh5EoMMzMzMzMzMzMzMzMbSq7EMDMzMzMzMzMzMzOzoeRKDDMzMzMzMzMzMzMzG0quxDAzMzMzMzMzMzMzs6HkSgwzMzMzMzMzMzMzMxtKrsQwMzMzMzMzMzMzM7Oh5EoMMzMzMzMzMzMzMzMbSq7EMDMzMzMzMzMzMzOzoeRKDDMzMzMzMzMzMzMzG0quxDCzkSFplqSQNGuCpj+nTH/GREzfzKxXkmaUcmrOOMefWcaf3d+cmdlE63X/t85Iml2W88wJmv5cSTER0zaz1kalHO31eG+iz7vNbDS5EsOGlqQlJb1V0rmS7pT0iKRbJf1J0nclvaIuvQNlhaRdJJ0o6WZJD0u6S9LVko6X9B5JGnQep5qJPiltM+9aBUmzbu5k56lXo3ISMJW5HB6/2kWmSvdoKYevlPQTSftLWmHQ+ZwOKifarboZg85nt3yhcvg12dYekjRP0vclbdLH+cztx7T6TdKrJf2yxIZHJN0h6QpJP5K036DzNxUN8qaYBrGrvpsz2XnqlSvfh9uol6Plf1b/e60c/bOkH5YydplB53M6qJynNO0GncfxKNvQvEHnw2wyLDXoDJg1ImlJ4OfArsB84BfAjcBqwAbAG4CNgVMGlMWhJuljwOeAR4FfAlcBSwNPAXYC9gYOL8NHyYnAb4F/TdD0Pwp8HrhpgqYPcDJweYP+8yZwnjaCXA73zffJ/VPASmQ5/CLg1cAhkt4SEadNYn5uAjYB7h7n+JeU8W/vW47653pgTpNh8ycvGzaCPlX5vjKwDbAv8CpJz4uIyweSqwkm6QjgrcB/yBhxHbA88FRgd2AmWQaOmq8DxwL/nKDp7ws8foKmXVOLXfUun+D52ugayXK04v/IY5UlyOPFpwOvBPYBrpH0poi4eBLz0+vx3kSfd/fij8BJg86EmXXPlRg2rF5PXjj7I7BTRCxysUXS44HnDiJjw07S+sCngXuA50XEn+uGLwHsAjw2gOwNVNmOxnvhrpPp/4uJP1A7KSLmTPA8zMDlcL/MiYi51R6SHgd8gCyrT5S0S0ScNxmZiYhHgCt7GP+BXsafYPMiYvagM2Gjp9F2J+lrwLuAg4BZk5ujiSdpB7IC40Zgu4i4sW740mQlxsiJiNuZwIreiJioypGqxWKX2UQaxXK0zmERMa/aQ9LKwGeAdwNnSNo2IiblGKzX472JPu/u0eU+XjSbmtyclA2r7cvnnPoLZ5BBNSLOqf0uj4Z+r/z8XqMmJFRpCkjSGyRdLOm+6qN3kh4v6aOSLpd0fxl+kaTX1+dB0jKS3iXpNEnXl8de75T0a0m7NfpTtUf9JK0g6SuSbpD0nzK/PUuapSR9TNI1kh6U9HdJ7+pi2T0XWBI4p74Coyy7BRFxRkREmd/GZbmc3WyC5XHWRyQ9ofxe+Fi2pC0k/ULSfEkPKJud2b7JdJaSdKCk30q6p6S/rCzHJerSLmxqSNJGko5TNlWwQKU5J6X3KpsteFDSTZK+LmnlRo9VqklTN5I2k3RMGechSbdJ+oOkw8pJOGVanyyjnNPosVO1ePxf0jblP9xU5vEvSb+S9Jpmy70Xkl6obN7hzrJsrpb0+XIwXJ+21nTAMpI+Iemqksc5lTTrlWX7jzLsDkmnSNq6wfRWlPTfkv5S1vO9ZTs+TtJWJc1s8o5NgP206D47ayKWiXXN5fD4y+GWIuLBiPgc8FlgGfLuu/p8dlxeVsZpW86oSTNuktaW9KWy/9+vLNOvKuXaUyvpmjbLIWlDST8o839Y2ZzhDyRt2CBtdVvYW9Il5T/eKelYSet2sUi7ImkdSd8o28HDyjL/Z7XyqS7twrghaddSXt6tRcv+rtaVpFdIOqusn4fKcjpX0oFl+Iwy/Z3K7ynddOAI+1X5XLPaU3mM8kFJZ0u6sbINniJp27q0syrb2k5128LsurRdHWeU7exYSbeXcu73kl7exf/boXyeUF+BAVlhGhFnVua3a8n3UU3ys2zJy+2Slq3+//K5c9n/7i372S/UpJkZdRdHqse025Tp3qlFY9eyZXjtGOg6SZ8t/RfbL9Wk+VFJO0o6taz3hyT9u5Qbn6ykCaDWDNd1lfU9r5JmbrUMqpvHi8s8bi3zuEHSyZJe1Ch9ryS9RtJ5pVz8j/Kc4aO1dViXthZ/V5J0aPn+SHVbVp6XzCn5fkjSLZJ+LOnpDabXNm4pY13tWOWTdfvQzIlYJtZX070cbSki7o6I9wA/IJ9O+XyDPHRc3lXGaVtOqMnxnqSnSjpC0rVln7+z7PffkrR6JV3D8+4ybCtJJ1Tmf72kwyWt0yDtwvNrSQeUeT1YyoYj1ODctl80/uPafpzjSNJ+ki4s2/aDZT2dIem1Jc3Msm2vD6xft23PmajlYjZIfhLDhtUd5XOjDtPPIR+/3IPFm9uZX5f2A+STCKeSB7UrA0haBTgb2BL4A3AUWdH3EuDHkjaNiIMr01mNvPB0IXAmcBuwDvn4/GmS3hoR322Q16VL+tVKXpch73g+QdKLgQPJiojTgYfIJke+Jum2iDiug2VRW3ZPlbRkRLR84iIirpR0DrCzpI0i4urqcGWFxDPJk9R/143+HOBDwEXAd4EnA68CzpK0RURcVZnO0uQyfwnZvNWPgQeBnYGvlf/8pgZZ3AC4GLgaOBpYjnzKBOAbwDuAm4EjgIeBV5CPHy8NPNLqv5d8bVamH2SzONeRj/A+jVwXB5fpHAbsSV5UavaIfbN5vBX4Jvn0yynANcBa5PI7EPhJp9PqcH4HlPndDxwP3EreDflhYHdJO0TE/AajngBsTW57J5XxkPRs8iRiNeAM4GfAGuTy+I2kV9aaw5Eksgmz7RnbLh4FnlTycD5wKTAXWAV4L4s/0nt5D3/f+sfl8PjL4U59CfggsEX5b3+F8ZWXvZQzyqdqLiDL2zPLvEWeFO0B/BT4R6s/oqzQ/DWwYpn/FWRzY28E9pD0woj4fYNRDyTL7VOAc8t/ey2weYkjD7Wab7ckPQX4DfBEcls7hiyfXg28TNKrIuLnDUbdm3wy6XTgW8CMMr2u1pWktwHfBv5dxrudXE+bAfuTTT3OJ5vVmEWug2oTG/N6+Ps2uWoXg+q3+03IJj/PI5tguos8fnoFsJuk3SPilyXt5eT6/ySLN5c2t/ZlHPv/+mRTIf8AfkiWha8FTpb0omoFdQvdxogzgL8Dr5X0vgaV468CVge+3GC/fzlZFtX2v2cALwW2lvSM8uQDMK44UrMd2Szob8o4awAPl+OaE4CXkcv162QMmQVs2uF/R9Ku5Pq+h1xHN5HLfRNyHdX280+Rx1ebM9a8DHTQJJ6kTwGfAO4jj6tuIMu67ckmaX7daX47IekQcpndTpZ99wG7AYcAL1E+ZVh/LL4MuX5WI48t76Hc1FKW0c/I5XsqcC2wHrAXWT7vHBF/KGk7jVsnlfnuR8aYuZW8zOt5IdhEm+7laKc+RTat9XJJK0XEPSXPq9BleddLOVEqGX5HniufRpaNjyObSn0TWT7e0Wz8Mo2Xl/FE7qfXA1uR5/R7lPPUeQ1G/WL5X6eSZcfO5NOATwNe0Gqe49HDcW2/znE+R5av15Hb3t3kOc7W5DHrcWQZ9inySSXI6xU1l4/vn5sNuYhw527oOrJwfxhYQB4U7AWs32acWeSF6FlNhs8uw+8HtmwwfE4Z/qG6/o8jL8ouALao9F8WWK/BdFYG/gLcCSxXN2xemcepwLKV/juW/neSBwarVIY9tSyLyzpcdstX5nMe8GbyJGvJFuPsXdJ/qcVy2aXSb2bpt9jyBg4o/Q9vsvy/Vs0L+dTIkWXYHpX+MyrzOKRBvmrL7Kq65bVM+d9BNi3SchsBvlw/78qwVYElGvyHmU2WY21Zzaj0ewZZCXInsGmDcRbbhtpM+6SSj/pulZJuffKi6z3AxnXTOLxM44i6/nNL/z8Ba9QNW4o8iXyQbFKoOuyJ5En4vyjbM/CsMq0TG/yHJYBVG6zjOZ0sA3eT2+FyeJXKsK7K4TJObb+a2Sbd+SXd/g2WU6flZcflTKP9jqz0CeArDcZdBlix8ntmSTu70k/A30r/N9aN/9rS/0oal6f3AM+qG+fHZdhrOlzWtTzNo3H5OLOS9oyS9uN109ierHC9A1ihwTa9ANi1xTbd6bq6lCyj12owrfrydy4Q3e677iavY+w4pbq9HVr26wVkObNi3Tgr16/r0n898qaMvzWZz9wmeRjP/h/AJ+vSvaT0P63D/74ueWE9yAs8bwA2BNRinP9X0r+rwbC5ZdhGlX61/e9R4IV16f+HxvFiTpP+zeLIzMoyOaBBvt7E2DH1MpX+q5Dl2mLrhgbHi+RFuwA2bzCP+n2/9h9mNFmOi5UNwIvLOP8A1m21HbRZr7X1MIcG5Wkl3XYl3T+BJ1T6L0Vu9wF8rG7a80r/XwPL1w1blbwQfTvwjLphm5IXXP9Q6ddT3HI3PB0jXI6WcWr7xYw26W4o6Xau9KuVFZ2Wdx2XE432G7JZqwDe22Dc5akcc9P4vHuFso8/BuxYN/6HS/pf1fWv/cd/Ak+u9F+KsXP+bTpc1rU8XU7j48UtSrpejmv7dY5zB9lc4+MbTKs+Zsyj7rqHO3fTtfOTGFPQLVphNmPN2rTznbXjvrfVjV97CV8nPrV23De7bvxTyTuiOh6nWxFxmaR9yDuQ9ikdku4kg9VREXHqOCd/RERcVu2hfPRxH+D3EfHFurw8KOnD5EHJGyi12pF3iTV6fP5u5aPyXyZryhu1c35QVO4yi4jzJV1H3sXw4ajcJR8R/5B0AbBjh09W3C/pFeTTAjuWDuA/kn5H1tofGYve5XYSecA3S9LHa8PKHQOvIe+ca3RXxgWx+PsZjiLvwtim1kPZnMa7yDtP31f9DxHxmKQPkHegvpG8K7rqFha9C7Vmv/L5ubrl9bCk2p103fhPfY+IuKvLaTTyDvIg6zNR7rKum8di21Abe5Su3hzyYsI+5Mnbl2PxNlM/Xoa/SdK7Y/E7Hf87KnczFi8j73L7UkScW5f3myV9kbzr44XkHTk1jZbnAvIEdcpb95LtZtNFOXzTNhctUg6ve8l2XZXDN21z0ey68duWw/XjdMvl8PjL4S7dVD7XhHGXl/0qZxrttw+TFTitbE/enXZRRBxdN/5xyqa4nle6+nXx1Vi86cPvkE/GbEN3T6qtT/P9cq6k9cgT+H+Sd/RV83mhpGPIbXAvsumGqpNj7K5OoKfY9igNnhRsUP5OSbdohRh0Hjq1dtynPk2q0XZ3BXBMRNxb7RkNmucr/W+U9FPg3ZKeHJ2/92A8+//1ZHN21XRnSPonleO3ViLiJkmvJPfX3UsHcK+kC4Efkf+/Wl5+j2zf/QDyWBEAZVNBO5FNoS7yRHBxbEScVdfvCOAjLHq82XUcqbg8Ir7dYN61482DS3lYm958SZ8p/7MbjcrZfuz77y6fH4iIm+oHjuN4c78m/WeXzzeXz89G5UntiHi0lH0vBf6LfCqj3gci4v66fvuSFUPviogrqgMi4q+SvgMcVJ68qQ4fb9waautest2UKUdv2uYil6Nj6boqR7t0E1lJUzteHE95169yotF+V79PN7IH+cTdMRFxft2wLwNvB3Zpsu4+Xe1Xyprvkdc6tiGfiunU5qWrN49cVr0c1/blHKd4hAbvMZ0ux4tm4+FKDBtaEfETSSeSjwo+j7wr+HnkI9Z7SvoBWbPf7UFeowC3NXnXZMN2vsnHmiEfXV1I0qZkUyDPJx/ve1zdeI3a9J4fEX9v0P9m8uLZpQ2G3VTy9wTGLng1FRF/AraU9Bxy+W0FbFvy+XzgbeWR7LtK+kclfZd8tPRV5F2wkHefLUcG40bLebFHKCPiEUm3kHdU1WxEHrBcAxycT+Yv5j/ULd/ijw0utkNuD9C4suK35EWiThxHNml0Ujno/TVZOdNoHY1HrV3W0/s0vf0bVBxVPbt8LvaOk4i4S9Jl5DawMdmMU1WjfWO78rl+k32j1iboJmQlxhXkwdfrlS+ZP5lcR7+vnvzb1OByeBFdlcNdqBWItWU4nvKy13LmXPI/faQ0H3ca2UzH5R1W2DQtdyr9a9tP/cleo0fxbyifqzYY1sq5ETGzxfBa3Dg/Fm/iBDKf+5R09ZUYjbbZ8ayro8kT9b9KOo5c9hdExG0t8m1DLiIWrnxJy5N3jn8eOLo0EfHxanrlS7HfS8bYtcibD6rWJSvbOjGe/b/Zvn0DY3G/rYg4R9JG5PsxdiL3nR3IizEvId959fLacVxE3CHpJ8C+kraPiAvLpGoV/d9qMqtOy4lxxZGi2QWwLck7ZC9sMKybG2aOJitILy77/jnkvt9t5UIz25Jx5JftEnZo52j9Yu9Wx5tXS7oReIqkVWLRJkwfJJ/8rVfb7jZvsu5qzZZtQh5r9hq3bMiMajnahfrjxfGUd72WE6eQFZPfkPQS8unWC4ArOjwXaFVuPCrpPPJJly1ZfN3183jx+xExq8XwXo5r+3WOczRZ6fRXSceTZd5FzSrwzEaFKzFsqJWLDL8qHZKWJC+yH0XesXMii7al34n69zpAXoSADDCLvai4YoXaF+VLw84m96OzyKB+D+VRQPJOg8Veake2Z9jIo9D0zpLaBfmlGwxrKrKdxoUBX9I25BMam5N3uxxUSX4E8DHy7rhaJcbbyDuZvtdkFvOb9H+UDNQ1teW7Ia3vXl+hQb9G6wtK+5LkkxqLKHfAtmyPs5L2Ekk7kk8p7E1pu1zSVcCnIuKYTqbTwirls58XPVupLZd/NRle679Kg2Gt9o1Xt5nvCrBw2b+ArBDbG/hCGX6vpO8DH42I+9pMy4aIy+FFh9FlOdyBJ5bP2kXs8ZSXq5TPcZUzEXFPWZafItuTfkkZdLukw8k7bVu9Y6iXcmd+g361Zb1kg2G9mKjyseN1FRGHSrqdbF/7PWQcDknnAh+Mxu0r2xRS7ka9RNJe5JNiH5L0rYi4AaA8vfBT8mLumeTTrveT5dZMsjKgUbnVzCrls5v9f36T/o+STT92LPIpy/NLV3s31i7k8eaLyDucD6uMcjgZOw4ALlS+AHo/8j1cJ3Wa33LBCxofb3YcRypaHW/eGRGNbo5Z7Bi0mYj4WWkL/gPkUwwHAEi6lDw2OrPV+B1YBbgrIha7Q3qCdFKePrmkm1/pf2uTi521ddfuKdXa8WavccuG2KiVox1qdrzYTXm3Cj2UExFxfbmeMJt8T9heZdANkr4UEV9tM4lRP17sZl29j9yu30w+dfgR4FFJp5FP0lzbYjpm05YrMaag0lTT7B7GfxtjdzyNZ/zd26eaGOVuh59Iehb5wuUX0P3Fs0YHzrULVl+JiPd3OJ2DyacUFrtTqTRn1KjJn4EqF+zfRT5t8IK6YTdJOhV4paRNyDsangkc14c7RGvL98SI2KtlygbZbtL/nvK5NnUvnC0XWVenwwPRiLiIfFHasuRTK7uSdz78WPki315ehDi/fK5Ltp050WrL+gnAYo9Dk3eqV9Mt1OSkspZuj4g4pZMMlCd83ge8T9LTyBOJA8hmV1ah8Qvcp5TSVNPsHsbvqRy+aZuLXA6nKVcOV0lakSxzAC4un+MpL+eXz3GXM+Vu4LeUC5DPINfrO8kKySWA/24xerXcaaRpuTPJeslnq222q9gWET8AfqBssnF74JXkSeoZkjaJiFs7ndYw6mMTTVNaZHNDV5F3dD6bsTtGP0PeIPKciPhbdRxJ3yZjZjfml8/JOs5oqRxL/ErSwcB3ybLksMrwiyX9AXiNpIPIF0GvDnyhD09sjieOLMxak/73AKtJWqpBRcbaXc0g4hfAL8pd5s8lm4V8B/BzSVtGXTNKXZoPrC5puUmqyKiWp42ebGxWnjZbzrV0m5cnytvqMW4NtT420TSljWo5Wq+cT61HXrSvPS08nvJuPj2WE2V5v1bSUuSNkS8iz5v/T9L9EXFki9FH/Xix43VVzrf+j1yua5FPfryOvLFw0/J0UqPWKsymtYmoITabDLV2MasHeLXHOcdTE38JeefGju0SVjyNvDNrboNh3R44TaZGy67m8PJZvcDaqH3gbl1JHjRtK6lfdzHX2pp8XoNh2zKOStqIeCgiLoyIT5B3yMKiF0HHs439tnzu1m1+xqm2XGbWDygXzLYg71r6W/3wJmr572bfWCgiri0HszuRL2XsdXna8HA53LsPkpUwl1VOwsdTXvatnIn014j4Gnk3NWTzYa00LXfq+v+hp8z1bmHcKCff9XYun53ms6fYFhHzI+K0iHgr+V6j1Vh0+38MFlbM29RUa+Kies71NLLpjfoLb0vQ+JgGsmxsth1M9nFGp1odb36TbPpvX/J4M8h3a/RqPHGkncvI9bd9g2HN1ldLEXF/RJxdLmYdQjaDU11/4z3eFHkjzmRodbxZu+B6XV1TUq2M+3izg7jl482pbZTL0ZpPlM9TY+z9IOMp7/pWTkTEoxFxaUR8gXyPGfRwvFiOy2rrbliOF2c2GV7r32k+e4pNEXFrRPwsIl5DPoG+AXmzac1juHyzEeFKDBtKkl4vaZdyIFI/7AmMPWpcbYOw1nzQk7udX7nr8WjgOZL+u9HFDUkbSHpKpdc88s6szerSvYWxR5onnaRtJM2StFyDYUsDHy4/G73o9izgavKx/tcAV0fEOb3mqdy59jXyroWvNsnbOpKe0cVka+2Vf1xS7ZFPJC1D45cINiRpx+r4FbW76x6o9BvPNvZN8q6Z/270/5Qvmu2nH5EvAXt3OYms+gywEvCjLu7cOJm8w+6dkl7aKIGk7SQ9vnx/ivIdBfVWJR/rrt71cxd54aLrfdYmnsvhiSPpcZI+RjZj9zBjlabjLS97KmckPVPSjAaDGpWDjVwAXEVWDuxdN+29yfeVXE137cf3Xblr90yyveWDqsMkPZd8oeJdZBNpnUyv63UladcmFShrlc9eY44NCUl7ku/YeYRF36cwD9hQ0hMraUU2SdbsOOgO4ElNhk32cUZturtK2qtRBZ6kFRjbxxodb/6YvDP1Q2SF85nRh3eRjTOOtFM73vxsOcasTWdlurjTX9ILG5UR9O9482vl88uSFnsXVKN+PTqqfB4sac3KfJYEvkReZ2h1R3a975GVwp9UNlezCElLSJpZ+d1N3HJZOkVN93K0HUkrSfoq+RT7fLJJIWDc5V1P5US5ztDoCbROjxdPAu4k3524bd2wg4CnAr+Ozl/IPlH6elzb7bqStGyJGapLszR5wwssXsat2STGmE0rbk7KhtVzyRd1/VvSb4DrSv+nAC8j71w9mWwLs+YisjA/SNJqjLVT+7Xo7AVI7yLbtf408KYy31vI9ic3IdsvfH0lL4eRF8l+o3xJ4d3Ac8g7CH5Kvg9gEJ5Ingh8vfyHK8g779ch77p4AnAt+T8XEREh6VvAoaVXP57CqPkM+cjp24HdJZ1NNve0FrncdyAv6HX0KH1EnCvpCPIOvr9KOoE8wN2dXBc3k3c8tPMB4MWS5pLNUt1HvkhuN/Ji1hGVtOeUaf6PpGeW4UTEZ1vk8wpJB5Ivq7xM0snkS2BXJ7eXexm7+7dnETFP2TzDN4A/lG3zNvIiwXbkncMfbj6Fxab3iLI92jPIJhAuJF/c/QB5IrA1ecC5Tum3OXCiso3nv5DrYU3yCYylGXtHBhFxn6SLgR0lHU0eDD4GnNJpUwI2oVwO98esyoWXFci7p55PnoT8C3hzRNSfBHVVXvahnHkRcGjZv68k26Zfj9xvFwD/2+oPltixH1lBcFyZ/5XA08m78u4F9o1sO3/Q3k6enP6vpBeT7416Evl4/gJg/8pdjp3oNrYdCzxYtu155B2RO5Lb9qVkc481Z5V8/UzZBvJ/gOsj4odd/mebYFr0RZ3LkxfRanf0fiwiqu9O+Apj+2rt2GWHMs6p5HFMvbOA1ymb/byUvNh2XkScN9nHGRUbl/9yl6TzyzwfJcuOl5HNR14MfL1+xIh4QPmerFoFbj+PN7uNI+38gGzCY1fgL5JOIY9nXkWWH0+ns+PNLwMzyvHmPLICeyuyCaTrybKh5izySb3vSPopeWw6PyIWW5Y1EfErSZ8hK1b+JukksumdtcmY+FtgVid/uBMRcaGkL5IVUX8p+byf3O6fSV7caxk76qZ3R7k4eCLwW0lnkc2iLiArH7Yjt+nHlVG6iVtXkeXy6yQ9TL4wOIAfRsT14/j7NgFGtBytOkjSfPK4YCWybHk+uSyuBvaJiKvrxumqvOtDOfEG8sa2c8nrCXeRx7W7Aw+x6PuPFlPO/d4MHA+cq3xh9T/JsvDF5PskDmg1jckwQce13ayr5cjjwXnlXPl6suzbpaQ9pe4ppLPK+L9Uvhz9IeCPEXHqOP6+2XCLCHfuhq4jLyi8kzyQvYpsj/Zh8oLPacA+wBINxtuVvIh2H3lwGsCMMmx2+T2zxXyXIQPMheTFsIfIwHoWeXfA6nXpX04G+3vJuyN+RR5szCrzmlWXfh4wr8m851KaEm4wbE71v7RZdiuSAfB7wJ+A28mDtDvL//oIsGKL8VclLyQ/WP9/K2lmlvzMbjK84f8kD8reVJbnnWWd3kSe6HwMeFIl7Ywyjzkt8roE+e6FK8u6upm8eL9yWSeX16VfbL2QB0zfIy8w3U2egF0FfBVYv8E89yEv4v+nto11sp7Ik68TyJOsh0tefwns3eE+UZv2rA7Tv7hsj3eVZXMt8EVglW62vUqatYDPkxUTD5D72DXkheJ9gKVKuvXIJ2EuIA9EHyJfyHc6sFuD6T6NPNm4gzzp7Pg/upvYDpfD9cOa7t+tplXpHi35uxI4ruRv+Rbjd1xeVsZpW87QoGwlT4gOJS/I3VaW+byyf29fN4+ZNCn/yZO7H5Zt5JHy+SPg6Q3SNt0WGuWxzbKu5Wluh+nXJe+6vL4sp9vJuwO3bpC24XY03nVFVnacSFaaP1DSX0ZeCFyxbrpLkuXpP8ry7Pg/upucrm4fr+7r/yIreXdpMt4s8lji/rL9nQg8q9l+QcbgH5MXPB5rtA+Od/+vm8Zc2hwPVNKuQb7L5RjyGOqusp3eRt70cSCwTIvxNy95uZlyDNFkOTXd/5rtE3QRR2hzTFvSPI688HQdY+Xj58iyJICT6tIvth7JJ5yPIY+d7iNj6l/KdNZsMM/3k01/PlSmNa+T9QS8tKz3O8u4N5Tt6wUdrte5jbbBFulfR5Z195LnDn8lK24f1yDtPJrE37pt9OtlOT1YltOVZGzZs5Ku47hV0m9d1v/djB1vdvQf3U1sxwiXoyX9vLr//kjZf/9ctvu9aV2WdnXcXMZpW07QoGwkb3D6JvDHMu5/yHPM7wHPbLB+GpbfZX88sey7tYrFbwJPbJB2Ds3PrxfLY5tlXctTw3XXIH1fjmu7XVdkRfmHyPPnf5Jl4W3k+c7b67cHsqLrm+Q596Pd/Ed37qZap4jAzKym3DF8Dtnk0JR8AbOkDck7Vo6NiNe3S29mZmZmk0fSLPLC12cjYkq+gFnSLmTF+ecj4qODzo+ZmZnZdOZ3YphZvQ+Vz6aPrA8LSU9QXXv9ynczHFZ+njjpmTIzMzOzpkp74O8n7xjtZ1NSE6La7n6l3+rkE6rg400zMzOzCed3YpgZkp5FNsmyFdn26M8j4uLB5qojB5EvBptLPt75BOCFZJNGp5PtbZqZmZnZgEl6HvmOrplksy9fj4gbB5qpzhwqaXOyCZDbyOPM3ch3G307Ii4ZZObMzMzMRoErMcwMsvLiELLd2ePJdoyngjPJNpVfTJ5IPko2I/VV4LBwe3lmZmZmw+JFwCfJttS/w9jTv8PuZ+SLb3cnX1hee/fDUcB3B5ctMzMzs9Hhd2KYmZmZmZmZmZmZmdlQ8jsxzMzMzMzMzMzMzMxsKLkSw8zMzMzMzMzMzMzMhpIrMczMzMzMzMzMzMzMbCi5EsPMzMzMzMzMzMzMzIaSKzHMzMzMzMzMzMzMzGwouRLDzMzMzMzMzMzMzMyGkisxzMzMzMzMzMzMzMxsKLkSw8zMzMzMzMzMzMzMhpIrMczMzMzMzMzMzMzMbCi5EsPMzMzMzMzMzMzMzIaSKzHMzMzMzMzMzMzMzGwouRLDzMzMzMzMzMzMzMyGkisxzMzMzMzMzMzMzMxsKLkSw8zMzMzMzMzMzMzMhtL/B2qEpGRRiEFnAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fn.plot_error(xnor_results, \"XNOR\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Spiral Experiments" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from proglearn.sims import generate_spirals\n", + "from functions import streaming_spirals_functions as spirals" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "spiral3, y_3 = generate_spirals(750, 3, noise=0.8)\n", + "spiral5, y_5 = generate_spirals(750, 5, noise=0.4)\n", + "spirals.plot_spirals(spiral3, y_3, 3, spiral5, y_5, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mc_rep = 10\n", + "spiral_results = spirals.run_spiral_experiments(mc_rep)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "spirals.plot_error(spiral_results)" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "021eb6924868a04ff0ec55ee3d6a2838e9123a6946b2ca5369814d359127e19d" + }, + "kernelspec": { + "display_name": "Python 3.8.12 ('add_task')", + "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.8.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/proglearn/forest.py b/proglearn/forest.py index 1d642ffbca..0f26e800e2 100644 --- a/proglearn/forest.py +++ b/proglearn/forest.py @@ -15,26 +15,21 @@ class LifelongClassificationForest(ClassificationProgressiveLearner): """ A class used to represent a lifelong classification forest. - Parameters ---------- default_n_estimators : int, default=100 The number of trees used in the Lifelong Classification Forest used if 'n_estimators' is not fed to add_{task, transformer}. - default_tree_construction_proportion : int, default=0.67 The proportions of the input data set aside to train each decision tree. The remainder of the data is used to fill in voting posteriors. This is used if 'tree_construction_proportion' is not fed to add_task. - default_kappa : float, default=np.inf The coefficient for finite sample correction. This is used if 'kappa' is not fed to add_task. - default_max_depth : int, default=30 The maximum depth of a tree in the Lifelong Classification Forest. This is used if 'max_depth' is not fed to add_task. - Attributes ---------- task_id_to_X : dict @@ -42,98 +37,80 @@ class LifelongClassificationForest(ClassificationProgressiveLearner): and values of type ndarray corresponding to the input data matrix X. This dictionary thus maps input data matrix to the task where posteriors are to be estimated. - task_id_to_y : dict A dictionary with keys of type obj corresponding to task ids and values of type ndarray corresponding to output data matrix y. This dictionary thus maps output data matrix to the task where posteriors are to be estimated. - transformer_id_to_X : dict A dictionary with keys of type obj corresponding to transformer ids and values of type ndarray corresponding to the output data matrix X. This dictionary thus maps input data matrix to a particular transformer. - transformer_id_to_y : dict A dictionary with keys of type obj corresponding to transformer ids and values of type ndarray corresponding to the output data matrix y. This dictionary thus maps output data matrix to a particular transformer. - transformer_id_to_transformers : dict A dictionary with keys of type obj corresponding to transformer ids and values of type obj corresponding to a transformer. This dictionary thus maps transformer ids to the corresponding transformers. - task_id_to_trasnformer_id_to_voters : dict A nested dictionary with outer key of type obj, corresponding to task ids inner key of type obj, corresponding to transformer ids, and values of type obj, corresponding to a voter. This dictionary thus maps voters to a corresponding transformer assigned to a particular task. - task_id_to_decider : dict A dictionary with keys of type obj, corresponding to task ids, and values of type obj corresponding to a decider. This dictionary thus maps deciders to a particular task. - task_id_to_decider_class : dict A dictionary with keys of type obj corresponding to task ids and values of type obj corresponding to a decider class. This dictionary thus maps decider classes to a particular task id. - task_id_to_voter_class : dict A dictionary with keys of type obj corresponding to task ids and values of type obj corresponding to a voter class. This dictionary thus maps voter classes to a particular task id. - task_id_to_voter_kwargs : dict A dictionary with keys of type obj corresponding to task ids and values of type obj corresponding to a voter kwargs. This dictionary thus maps voter kwargs to a particular task id. - task_id_to_decider_kwargs : dict A dictionary with keys of type obj corresponding to task ids and values of type obj corresponding to a decider kwargs. This dictionary thus maps decider kwargs to a particular task id. - task_id_to_bag_id_to_voter_data_idx : dict A nested dictionary with outer keys of type obj corresponding to task ids inner keys of type obj corresponding to bag ids and values of type obj corresponding to voter data indices. This dictionary thus maps voter data indices to particular bags for particular tasks. - task_id_to_decider_idx : dict A dictionary with keys of type obj corresponding to task ids and values of type obj corresponding to decider indices. This dictionary thus maps decider indices to particular tasks. - default_transformer_class : TreeClassificationTransformer The class of transformer to which the forest defaults if None is provided in any of the functions which add or set transformers. - default_transformer_kwargs : dict A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines to which type of transformer the forest defaults if None is provided in any of the functions which add or set transformers. - default_voter_class : TreeClassificationVoter The class of voter to which the forest defaults if None is provided in any of the functions which add or set voters. - default_voter_kwargs : dict A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines to which type of voter the forest defaults if None is provided in any of the functions which add or set voters. - default_decider_class : SimpleArgmaxAverage The class of decider to which the forest defaults if None is provided in any of the functions which add or set deciders. - default_decider_kwargs : dict A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines to which type of decider the @@ -171,6 +148,7 @@ def add_task( tree_construction_proportion="default", kappa="default", max_depth="default", + classes=None, ): """ adds a task with id task_id, max tree depth max_depth, given input data matrix X @@ -178,34 +156,26 @@ def add_task( data for training and voting based on tree_construction_proportion and uses the value of kappa to determine whether the learner will have finite sample correction. - Parameters ---------- X : ndarray The input data matrix. - y : ndarray The output (response) data matrix. - task_id : obj, default=None The id corresponding to the task being added. - n_estimators : int or str, default='default' The number of trees used for the given task. - tree_construction_proportion : int or str, default='default' The proportions of the input data set aside to train each decision tree. The remainder of the data is used to fill in voting posteriors. The default is used if 'default' is provided. - kappa : float or str, default='default' The coefficient for finite sample correction. The default is used if 'default' is provided. - max_depth : int or str, default='default' The maximum depth of a tree in the Lifelong Classification Forest. The default is used if 'default' is provided. - Returns ------- self : LifelongClassificationForest @@ -237,6 +207,7 @@ def add_task( "kappa": kappa, }, decider_kwargs={"classes": np.unique(y)}, + classes=classes, ) def add_transformer( @@ -246,31 +217,26 @@ def add_transformer( transformer_id=None, n_estimators="default", max_depth="default", + classes=None, ): """ adds a transformer with id transformer_id and max tree depth max_depth, trained on given input data matrix, X, and output data matrix, y, to the Lifelong Classification Forest. Also trains the voters and deciders from new transformer to previous tasks, and will train voters and deciders from this transformer to all new tasks. - Parameters ---------- X : ndarray The input data matrix. - y : ndarray The output (response) data matrix. - transformer_id : obj, default=None The id corresponding to the transformer being added. - n_estimators : int or str, default='default' The number of trees used for the given task. - max_depth : int or str, default='default' The maximum depth of a tree in the Lifelong Classification Forest. The default is used if 'default' is provided. - Returns ------- self : LifelongClassificationForest @@ -288,20 +254,115 @@ def add_transformer( transformer_kwargs={"kwargs": {"max_depth": max_depth}}, transformer_id=transformer_id, num_transformers=n_estimators, + classes=classes, + ) + + def update_task( + self, + X, + y, + task_id=None, + n_estimators="default", + tree_construction_proportion="default", + kappa="default", + max_depth="default", + classes=None, + ): + """ + updates a task with id task_id, max tree depth max_depth, given input data matrix X + and output data matrix y, to the Lifelong Classification Forest. Also splits + data for training and voting based on tree_construction_proportion and uses the + value of kappa to determine whether the learner will have + finite sample correction. + Parameters + ---------- + X : ndarray + The input data matrix. + y : ndarray + The output (response) data matrix. + task_id : obj, default=None + The id corresponding to the task being added. + n_estimators : int or str, default='default' + The number of trees used for the given task. + tree_construction_proportion : int or str, default='default' + The proportions of the input data set aside to train each decision + tree. The remainder of the data is used to fill in voting posteriors. + The default is used if 'default' is provided. + kappa : float or str, default='default' + The coefficient for finite sample correction. + The default is used if 'default' is provided. + max_depth : int or str, default='default' + The maximum depth of a tree in the Lifelong Classification Forest. + The default is used if 'default' is provided. + Returns + ------- + self : LifelongClassificationForest + The object itself. + """ + if n_estimators == "default": + n_estimators = self.default_n_estimators + if tree_construction_proportion == "default": + tree_construction_proportion = self.default_tree_construction_proportion + if kappa == "default": + kappa = self.default_kappa + if max_depth == "default": + max_depth = self.default_max_depth + + X, y = check_X_y(X, y) + + return super().update_task( + X, + y, + classes=classes, + task_id=task_id, + transformer_voter_decider_split=[ + tree_construction_proportion, + 1 - tree_construction_proportion, + 0, + ], + num_transformers=n_estimators, + transformer_kwargs={"kwargs": {"max_depth": max_depth}}, + voter_kwargs={ + "classes": np.unique(y), + "kappa": kappa, + }, + decider_kwargs={"classes": np.unique(y)}, + ) + + def update_transformer( + self, + X, + y, + classes=None, + transformer_id=None, + n_estimators="default", + max_depth="default", + ): + + if n_estimators == "default": + n_estimators = self.default_n_estimators + if max_depth == "default": + max_depth = self.default_max_depth + + X, y = check_X_y(X, y) + return super().update_transformer( + X, + y, + classes=classes, + transformer_kwargs={"kwargs": {"max_depth": max_depth}}, + transformer_id=transformer_id, + num_transformers=n_estimators, ) def predict_proba(self, X, task_id): """ estimates class posteriors under task_id for each example in input data X. - Parameters ---------- X : ndarray The input data matrix. - task_id: The id corresponding to the task being mapped to. - Returns ------- y_proba_hat : ndarray of shape [n_samples, n_classes] @@ -312,15 +373,12 @@ def predict_proba(self, X, task_id): def predict(self, X, task_id): """ predicts class labels under task_id for each example in input data X. - Parameters ---------- X : ndarray The input data matrix. - task_id : obj The id corresponding to the task being mapped to. - Returns ------- y_hat : ndarray of shape [n_samples] @@ -332,52 +390,42 @@ def predict(self, X, task_id): class UncertaintyForest(LifelongClassificationForest): """ A class used to represent an uncertainty forest. - Parameters ---------- n_estimators : int, default=100 The number of trees in the UncertaintyForest - kappa : float, default=np.inf The coefficient for finite sample correction. If set to the default value, finite sample correction is not performed. - max_depth : int, default=30 The maximum depth of a tree in the UncertaintyForest - tree_construction_proportion : float, default = 0.67 The proportions of the input data set aside to train each decision tree. The remainder of the data is used to fill in voting posteriors. - Attributes ---------- default_transformer_class : TreeClassificationTransformer The class of transformer to which the forest defaults if None is provided in any of the functions which add or set transformers. - default_transformer_kwargs : dict A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines to which type of transformer the forest defaults if None is provided in any of the functions which add or set transformers. - default_voter_class : TreeClassificationVoter The class of voter to which the forest defaults if None is provided in any of the functions which add or set voters. - default_voter_kwargs : dict A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines to which type of voter the forest defaults if None is provided in any of the functions which add or set voters. - default_decider_class : SimpleArgmaxAverage The class of decider to which the forest defaults if None is provided in any of the functions which add or set deciders. - default_decider_kwargs : dict A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines to which type of decider the @@ -402,15 +450,12 @@ def __init__( def fit(self, X, y): """ fits forest to data X with labels y - Parameters ---------- X : array of shape [n_samples, n_features] The data that will be trained on - y : array of shape [n_samples] The label for cluster membership of the given data - Returns ------- self : UncertaintyForest @@ -422,12 +467,10 @@ def fit(self, X, y): def predict_proba(self, X): """ estimates class posteriors for each example in input data X. - Parameters ---------- X : array of shape [n_samples, n_features] The data whose posteriors we are estimating. - Returns ------- y_proba_hat : ndarray of shape [n_samples, n_classes] @@ -438,12 +481,10 @@ def predict_proba(self, X): def predict(self, X): """ predicts class labels for each example in input data X. - Parameters ---------- X : array of shape [n_samples, n_features] The data on which we are performing inference. - Returns ------- y_hat : ndarray of shape [n_samples] diff --git a/proglearn/progressive_learner.py b/proglearn/progressive_learner.py index e4d5cd4aab..8bfa5e0819 100755 --- a/proglearn/progressive_learner.py +++ b/proglearn/progressive_learner.py @@ -13,42 +13,35 @@ class ProgressiveLearner(BaseProgressiveLearner): A (mostly) internal class for progressive learning. Most users who desire to utilize ProgLearn should use the classes defined in {network, forest}.py instead of this class. - Parameters ---------- default_transformer_class : BaseTransformer, default=None The class of transformer to which the progressive learner defaults if None is provided in any of the functions which add or set transformers. - default_transformer_kwargs : dict, default=None A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines to which type of transformer the progressive learner defaults if None is provided in any of the functions which add or set transformers. - default_voter_class : BaseVoter, default=None The class of voter to which the progressive learner defaults if None is provided in any of the functions which add or set voters. - default_voter_kwargs : dict, default=None A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines to which type of voter the progressive learner defaults if None is provided in any of the functions which add or set voters. - default_decider_class : BaseDecider, default=None The class of decider to which the progressive learner defaults if None is provided in any of the functions which add or set deciders. - default_decider_kwargs : dict, default=None A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines to which type of decider the progressive learner defaults if None is provided in any of the functions which add or set deciders. - Attributes ---------- task_id_to_X : dict @@ -56,66 +49,54 @@ class ProgressiveLearner(BaseProgressiveLearner): and values of type ndarray corresponding to the input data matrix X. This dictionary thus maps input data matrix to the task where posteriors are to be estimated. - task_id_to_y : dict A dictionary with keys of type obj corresponding to task ids and values of type ndarray corresponding to output data matrix y. This dictionary thus maps output data matrix to the task where posteriors are to be estimated. - transformer_id_to_X : dict A dictionary with keys of type obj corresponding to transformer ids and values of type ndarray corresponding to the output data matrix X. This dictionary thus maps input data matrix to a particular transformer. - transformer_id_to_y : dict A dictionary with keys of type obj corresponding to transformer ids and values of type ndarray corresponding to the output data matrix y. This dictionary thus maps output data matrix to a particular transformer. - transformer_id_to_transformers : dict A dictionary with keys of type obj corresponding to transformer ids and values of type obj corresponding to a transformer. This dictionary thus maps transformer ids to the corresponding transformers. - - task_id_to_trasnformer_id_to_voters : dict + task_id_to_transformer_id_to_voters : dict A nested dictionary with outer key of type obj, corresponding to task ids inner key of type obj, corresponding to transformer ids, and values of type obj, corresponding to a voter. This dictionary thus maps voters to a corresponding transformer assigned to a particular task. - task_id_to_decider : dict A dictionary with keys of type obj, corresponding to task ids, and values of type obj corresponding to a decider. This dictionary thus maps deciders to a particular task. - task_id_to_decider_class : dict A dictionary with keys of type obj corresponding to task ids and values of type obj corresponding to a decider class. This dictionary thus maps decider classes to a particular task id. - task_id_to_voter_class : dict A dictionary with keys of type obj corresponding to task ids and values of type obj corresponding to a voter class. This dictionary thus maps voter classes to a particular task id. - task_id_to_voter_kwargs : dict A dictionary with keys of type obj corresponding to task ids and values of type obj corresponding to a voter kwargs. This dictionary thus maps voter kwargs to a particular task id. - task_id_to_decider_kwargs : dict A dictionary with keys of type obj corresponding to task ids and values of type obj corresponding to a decider kwargs. This dictionary thus maps decider kwargs to a particular task id. - task_id_to_bag_id_to_voter_data_idx : dict A nested dictionary with outer keys of type obj corresponding to task ids inner keys of type obj corresponding to bag ids and values of type obj corresponding to voter data indices. This dictionary thus maps voter data indices to particular bags for particular tasks. - task_id_to_decider_idx : dict A dictionary with keys of type obj corresponding to task ids and values of type obj corresponding to decider indices. This dictionary @@ -173,6 +154,9 @@ def _append_transformer(self, transformer_id, transformer): else: self.transformer_id_to_transformers[transformer_id] = [transformer] + def _replace_transformer(self, transformer_id, transformer): + self.transformer_id_to_transformers[transformer_id] = [transformer] + def _append_voter(self, transformer_id, task_id, voter): if task_id in list(self.task_id_to_transformer_id_to_voters.keys()): if transformer_id in list( @@ -192,10 +176,21 @@ def _append_voter(self, transformer_id, task_id, voter): def _append_voter_data_idx(self, task_id, bag_id, voter_data_idx): if task_id in list(self.task_id_to_bag_id_to_voter_data_idx.keys()): + self.task_id_to_bag_id_to_voter_data_idx[task_id][bag_id] = voter_data_idx else: self.task_id_to_bag_id_to_voter_data_idx[task_id] = {bag_id: voter_data_idx} + def _update_voter_data_idx(self, task_id, bag_id, voter_data_idx): + if task_id in list(self.task_id_to_bag_id_to_voter_data_idx.keys()): + prev = self.task_id_to_bag_id_to_voter_data_idx[task_id][bag_id] + new = voter_data_idx + self.task_id_to_bag_id_to_voter_data_idx[task_id][bag_id] = np.append( + prev, new + ) + else: + self.task_id_to_bag_id_to_voter_data_idx[task_id] = {bag_id: voter_data_idx} + def _append_decider_idx(self, task_id, decider_idx): self.task_id_to_decider_idx[task_id] = decider_idx @@ -218,6 +213,90 @@ def _bifurcate_decider_idxs(self, ra, transformer_voter_decider_split): ) return first_idx, second_idx + def _update_transformer( + self, + X, + y, + transformer_data_proportion, + transformer_voter_data_idx, + transformer_id, + num_transformers, + transformer_class, + transformer_kwargs, + backward_task_ids, + classes=None, + decider_kwargs=None, + ): + + if transformer_id not in list(self.task_id_to_X.keys()): + self.transformer_id_to_X[transformer_id] = X + if transformer_id not in list(self.task_id_to_y.keys()): + self.transformer_id_to_y[transformer_id] = y + + backward_task_ids = ( + backward_task_ids if backward_task_ids is not None else self.get_task_ids() + ) + + # for all transformers referring to specified task + counter = 0 + for transformer in self.transformer_id_to_transformers[transformer_id]: + + # Check data and assign data for training + + if X is not None: + n = len(X) + elif y is not None: + n = len(y) + else: + n = None + if n is not None: + transformer_data_idx = np.random.choice( + transformer_voter_data_idx, + int(transformer_data_proportion * n), + replace=False, + ) + else: + transformer_data_idx = None + + X2 = ( + self.transformer_id_to_X[transformer_id] + if transformer_id in list(self.transformer_id_to_X.keys()) + else self.task_id_to_X[transformer_id] + ) + y2 = ( + self.transformer_id_to_y[transformer_id] + if transformer_id in list(self.transformer_id_to_y.keys()) + else self.task_id_to_y[transformer_id] + ) + + if transformer_data_idx is not None: + X2, y2 = X2[transformer_data_idx], y2[transformer_data_idx] + + transformer.transformer_.partial_fit(X2, y2, classes) + + voter_data_idx = np.delete( + transformer_voter_data_idx, + np.isin(transformer_voter_data_idx, transformer_data_idx), + ) + + self._update_voter_data_idx( + task_id=transformer_id, + bag_id=counter, + voter_data_idx=voter_data_idx, + ) + counter = counter + 1 + + for existing_task_id in np.intersect1d(backward_task_ids, self.get_task_ids()): + self.set_voter(transformer_id=transformer_id, task_id=existing_task_id) + self.set_decider( + task_id=existing_task_id, + transformer_ids=list( + self.task_id_to_transformer_id_to_voters[existing_task_id].keys() + ), + ) + + return self + def _add_transformer( self, X, @@ -229,13 +308,16 @@ def _add_transformer( transformer_class, transformer_kwargs, backward_task_ids, + classes, ): + if transformer_id is None: transformer_id = len(self.get_transformer_ids()) backward_task_ids = ( backward_task_ids if backward_task_ids is not None else self.get_task_ids() ) + transformer_voter_data_idx = ( range(len(X)) if transformer_voter_data_idx is None @@ -261,6 +343,27 @@ def _add_transformer( int(transformer_data_proportion * n), replace=False, ) + if classes is not None: + # raise ValueError to avoid infinite loop + if int(transformer_data_proportion * n) < len(classes): + raise ValueError( + "length of X times transformer_data_proportion must exceed number of classes" + ) + ensure_all_classes = False + while ensure_all_classes is False: + transformer_data_idx = np.random.choice( + transformer_voter_data_idx, + int(transformer_data_proportion * n), + replace=False, + ) + y = ( + self.transformer_id_to_y[transformer_id] + if transformer_id in list(self.transformer_id_to_y.keys()) + else self.task_id_to_y[transformer_id] + ) + if len(np.unique(y[transformer_data_idx])) == len(classes): + ensure_all_classes = True + else: transformer_data_idx = None self.set_transformer( @@ -297,7 +400,6 @@ def set_transformer( transformer_class=None, transformer_kwargs=None, ): - if transformer_id is None: transformer_id = len(self.get_transformer_ids()) @@ -362,10 +464,6 @@ def set_voter( bag_id=None, ): - # Type check X - - # Type check y - if task_id is None: task_id = len(self.get_task_ids()) @@ -462,6 +560,7 @@ def set_decider( self.task_id_to_decider[task_id] = decider_class(**decider_kwargs) decider_idx = self.task_id_to_decider_idx[task_id] + self.task_id_to_decider[task_id].fit( X[decider_idx], y[decider_idx], @@ -483,26 +582,23 @@ def add_transformer( transformer_class=None, transformer_kwargs=None, backward_task_ids=None, + classes=None, ): """ Adds a transformer to the progressive learner and trains the voters and deciders from this new transformer to the specified backward_task_ids. - Parameters ---------- X : ndarray Input data matrix. - y : ndarray Output (response) data matrix. - transformer_data_proportion : float, default=1.0 The proportion of the data set aside to train the transformer. The remainder of the data is used to train voters. This is used in the case that you are using a bagging algorithm and want the various components in that bagging ensemble to train on disjoint subsets of the data. This parameter is mostly for internal use. - transformer_voter_data_idx : ndarray, default=None A 1d array of type int used to specify the aggregate indices of the input data used to train the transformers and voters. This is used in the @@ -510,25 +606,19 @@ def add_transformer( transformers or voters (e.g. X and/or y contains decider training data disjoint from the transformer/voter data). This parameter is mostly for internal use. - transformer_id : obj, default=None The id corresponding to the transformer being added. - num_transformers : int, default=1 The number of transformers to add corresponding to the given inputs. - transformer_class : BaseTransformer, default=None The class of the transformer(s) being added. - transformer_kwargs : dict, default=None A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines the kwargs of the transformer(s) being added. - backward_task_ids : ndarray, default=None A 1d array of type obj used to specify to which existing task voters and deciders will be trained from the transformer(s) being added. - Returns ------- self : ProgressiveLearner @@ -544,6 +634,7 @@ def add_transformer( transformer_class=transformer_class, transformer_kwargs=transformer_kwargs, backward_task_ids=backward_task_ids, + classes=classes, ) def add_task( @@ -561,7 +652,9 @@ def add_task( decider_kwargs=None, backward_task_ids=None, forward_transformer_ids=None, + classes=None, ): + """ Adds a task to the progressive learner. Optionally trains one or more transformer from the input data (if num_transformers > 0), adds voters @@ -570,18 +663,14 @@ def add_task( specified in forward_transformer_ids (and from the newly added transformer(s) corresponding to the input task_id if num_transformers > 0) to the new task_id. - Parameters ---------- X : ndarray Input data matrix. - y : ndarray Output (response) data matrix. - task_id : obj, default=None The id corresponding to the task being added. - transformer_voter_decider_split : ndarray, default=[0.67, 0.33, 0] A 1d array of length 3. The 0th index indicates the proportions of the input data used to train the (optional) newly added transformer(s) corresponding to @@ -596,43 +685,33 @@ def add_task( proportion of the data set aside to train the decider - these indices are saved internally and will be used to train all further deciders corresponding to this task for all function calls. - num_transformers : int, default=1 The number of transformers to add corresponding to the given inputs. - transformer_class : BaseTransformer, default=None The class of the transformer(s) being added. - transformer_kwargs : dict, default=None A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines the kwargs of the transformer(s) being added. - voter_class : BaseVoter, default=None The class of the voter(s) being added. - voter_kwargs : dict, default=None A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines the kwargs of the voter(s) being added. - decider_class : BaseDecider, default=None The class of the decider(s) being added. - decider_kwargs : dict, default=None A dictionary with keys of type string and values of type obj corresponding to the given string kwarg. This determines the kwargs of the decider(s) being added. - backward_task_ids : ndarray, default=None A 1d array of type obj used to specify to which existing task voters and deciders will be trained from the transformer(s) being added. - foward_transformer_ids : ndarray, default=None A 1d array of type obj used to specify from which existing transformer(s) voters and deciders will be trained to the new task. If num_transformers > 0, the input task_id corresponding to the task being added is automatically appended to this 1d array. - Returns ------- self : ProgressiveLearner @@ -650,11 +729,13 @@ def add_task( transformer_voter_data_idx, decider_idx = self._bifurcate_decider_idxs( range(len(X)), transformer_voter_decider_split ) + self._append_decider_idx(task_id, decider_idx) # add new transformer and train voters and decider # from new transformer to previous tasks if num_transformers > 0: + self._add_transformer( X, y, @@ -667,6 +748,7 @@ def add_task( transformer_class=transformer_class, transformer_kwargs=transformer_kwargs, backward_task_ids=backward_task_ids, + classes=classes, ) # train voters and decider from previous (and current) transformers to new task @@ -690,6 +772,7 @@ def add_task( transformer_ids = np.concatenate([forward_transformer_ids, task_id]) else: transformer_ids = self.get_transformer_ids() + self.set_decider( task_id=task_id, transformer_ids=transformer_ids, @@ -699,33 +782,166 @@ def add_task( return self + def update_task( + self, + X, + y, + classes=None, + task_id=None, + transformer_voter_decider_split=[0.67, 0.33, 0], + num_transformers=1, + transformer_class=None, + transformer_kwargs=None, + voter_class=None, + voter_kwargs=None, + decider_class=None, + decider_kwargs=None, + backward_task_ids=None, + forward_transformer_ids=None, + ): + + """ + Updates a task for the progressive learner. Concatenates new data to existing + data for specified task and partial fits transformers. Updates voters and decider + from updated transformers. + Parameters + ---------- + X : ndarray + Input data matrix. + y : ndarray + Output (response) data matrix. + task_id : obj, default=None + The id corresponding to the task being added. + transformer_voter_decider_split : ndarray, default=[0.67, 0.33, 0] + A 1d array of length 3. The 0th index indicates the proportions of the input + data used to train the (optional) newly added transformer(s) corresponding to + the task_id provided in this function call. The 1st index indicates the proportion of + the data set aside to train the voter(s) from these (optional) newly added + transformer(s) to the task_id provided in this function call. For all other tasks, + the aggregate transformer and voter data pairs from those tasks are used to train + the voter(s) from these (optional) newly added transformer(s) to those tasks; + for all other transformers, the aggregate transformer and voter data provided in + this function call is used to train the voter(s) from those transformers to + the task_id provided in this function call. The 2nd index indicates the + proportion of the data set aside to train the decider - these indices are saved + internally and will be used to train all further deciders corresponding to this + task for all function calls. + num_transformers : int, default=1 + The number of transformers to add corresponding to the given inputs. + transformer_class : BaseTransformer, default=None + The class of the transformer(s) being added. + transformer_kwargs : dict, default=None + A dictionary with keys of type string and values of type obj corresponding + to the given string kwarg. This determines the kwargs of the transformer(s) + being added. + voter_class : BaseVoter, default=None + The class of the voter(s) being added. + voter_kwargs : dict, default=None + A dictionary with keys of type string and values of type obj corresponding + to the given string kwarg. This determines the kwargs of the voter(s) + being added. + decider_class : BaseDecider, default=None + The class of the decider(s) being added. + decider_kwargs : dict, default=None + A dictionary with keys of type string and values of type obj corresponding + to the given string kwarg. This determines the kwargs of the decider(s) + being added. + backward_task_ids : ndarray, default=None + A 1d array of type obj used to specify to which existing task voters and deciders + will be trained from the transformer(s) being added. + foward_transformer_ids : ndarray, default=None + A 1d array of type obj used to specify from which existing transformer(s) voters and + deciders will be trained to the new task. If num_transformers > 0, the input task_id + corresponding to the task being added is automatically appended to this 1d array. + Returns + ------- + self : ProgressiveLearner + The object itself. + """ + + if task_id is None: + print("Error: No Task ID inputted") + return self + # come up with something that has fewer collision + self.task_id_to_transformer_id_to_voters[task_id] = {} + + self.task_id_to_X[task_id] = np.concatenate( + (self.task_id_to_X[task_id], X), axis=0 + ) + self.task_id_to_y[task_id] = np.concatenate( + (self.task_id_to_y[task_id], y), axis=0 + ) + + # split into transformer/voter and decider data + + transformer_voter_data_idx, decider_idx = self._bifurcate_decider_idxs( + range(len(X)), transformer_voter_decider_split + ) + transformer_voter_data_idx += len(self.task_id_to_X[task_id]) - len(X) + decider_idx += len(self.task_id_to_X[task_id]) - len(X) + + self._append_decider_idx(task_id, decider_idx) + + # updates transformer and train voters and decider + # from updated transformer to previous tasks + if num_transformers > 0: + self._update_transformer( + X, + y, + classes=classes, + transformer_data_proportion=transformer_voter_decider_split[0] + if transformer_voter_decider_split + else 1, + transformer_voter_data_idx=transformer_voter_data_idx, + transformer_id=task_id, + num_transformers=num_transformers, + transformer_class=transformer_class, + transformer_kwargs=transformer_kwargs, + backward_task_ids=backward_task_ids, + decider_kwargs=decider_kwargs, + ) + + # train voters and decider + for transformer_id in self.get_transformer_ids(): + self.set_voter( + transformer_id=transformer_id, + task_id=task_id, + voter_class=voter_class, + voter_kwargs=voter_kwargs, + ) + self.set_decider( + task_id=task_id, + transformer_ids=self.get_transformer_ids(), + decider_class=decider_class, + decider_kwargs=decider_kwargs, + ) + return self + def predict(self, X, task_id, transformer_ids=None): """ predicts labels under task_id for each example in input data X using the given transformer_ids. - Parameters ---------- X : ndarray The input data matrix. - task_id : obj The id corresponding to the task being mapped to. - transformer_ids : list, default=None The list of transformer_ids through which a user would like to send X (which will be pipelined with their corresponding voters) to make an inference prediction. - Returns ------- y_hat : ndarray of shape [n_samples] predicted class label per example """ + if self.task_id_to_decider == {}: raise NotFittedError decider = self.task_id_to_decider[task_id] + return decider.predict(X, transformer_ids=transformer_ids) @@ -742,20 +958,16 @@ def predict_proba(self, X, task_id, transformer_ids=None): """ predicts posteriors under task_id for each example in input data X using the given transformer_ids. - Parameters ---------- X : ndarray The input data matrix. - task_id : obj The id corresponding to the task being mapped to. - transformer_ids : list, default=None The list of transformer_ids through which a user would like to send X (which will be pipelined with their corresponding voters) to estimate posteriors. - Returns ------- y_proba_hat : ndarray of shape [n_samples, n_classes] diff --git a/proglearn/sims/spiral_sim.py b/proglearn/sims/spiral_sim.py index cf5c4a1851..42ed74a612 100644 --- a/proglearn/sims/spiral_sim.py +++ b/proglearn/sims/spiral_sim.py @@ -1,90 +1,90 @@ -import numpy as np - - -def generate_spirals( - n_samples, - n_class=2, - noise=0.3, - random_state=None, -): - """ - Generate 2-dimensional Gaussian XOR distribution. - (Classic XOR problem but each point is the - center of a Gaussian blob distribution) - - Parameters - ---------- - - n_samples : int - Total number of points divided among the four - clusters with equal probability. - - n_class : array of shape [n_centers], optional (default=2) - Number of class for the spiral simulation. - - noise : float, optional (default=0.3) - Parameter controlling the spread of each class. - - random_state : int, RandomState instance, default=None - Determines random number generation for dataset creation. Pass an int - for reproducible output across multiple function calls. - - - Returns - ------- - - X : array of shape [n_samples, 2] - The generated samples. - y : array of shape [n_samples] - The integer labels for cluster membership of each sample. - """ - - if random_state != None: - np.random.seed(random_state) - - X = [] - y = [] - - if n_class == 2: - turns = 2 - elif n_class == 3: - turns = 2.5 - elif n_class == 5: - turns = 3.5 - elif n_class == 7: - turns = 4.5 - else: - raise ValueError("sorry, can't currently surpport %s classes " % n_class) - - mvt = np.random.multinomial(n_samples, 1 / n_class * np.ones(n_class)) - - if n_class == 2: - r = np.random.uniform(0, 1, size=int(n_samples / n_class)) - r = np.sort(r) - t = np.linspace( - 0, np.pi * 4 * turns / n_class, int(n_samples / n_class) - ) + np.random.normal(0, noise, int(n_samples / n_class)) - dx = r * np.cos(t) - dy = r * np.sin(t) - - X.append(np.vstack([dx, dy]).T) - X.append(np.vstack([-dx, -dy]).T) - y += [0] * int(n_samples / n_class) - y += [1] * int(n_samples / n_class) - else: - for j in range(1, n_class + 1): - r = np.linspace(0.01, 1, int(mvt[j - 1])) - t = np.linspace( - (j - 1) * np.pi * 4 * turns / n_class, - j * np.pi * 4 * turns / n_class, - int(mvt[j - 1]), - ) + np.random.normal(0, noise, int(mvt[j - 1])) - - dx = r * np.cos(t) - dy = r * np.sin(t) - - dd = np.vstack([dx, dy]).T - X.append(dd) - y += [j - 1] * int(mvt[j - 1]) - - return np.vstack(X), np.array(y).astype(int) +import numpy as np + + +def generate_spirals( + n_samples, + n_class=2, + noise=0.3, + random_state=None, +): + """ + Generate 2-dimensional Gaussian XOR distribution. + (Classic XOR problem but each point is the + center of a Gaussian blob distribution) + + Parameters + ---------- + + n_samples : int + Total number of points divided among the four + clusters with equal probability. + + n_class : array of shape [n_centers], optional (default=2) + Number of class for the spiral simulation. + + noise : float, optional (default=0.3) + Parameter controlling the spread of each class. + + random_state : int, RandomState instance, default=None + Determines random number generation for dataset creation. Pass an int + for reproducible output across multiple function calls. + + + Returns + ------- + + X : array of shape [n_samples, 2] + The generated samples. + y : array of shape [n_samples] + The integer labels for cluster membership of each sample. + """ + + if random_state != None: + np.random.seed(random_state) + + X = [] + y = [] + + if n_class == 2: + turns = 2 + elif n_class == 3: + turns = 2.5 + elif n_class == 5: + turns = 3.5 + elif n_class == 7: + turns = 4.5 + else: + raise ValueError("sorry, can't currently surpport %s classes " % n_class) + + mvt = np.random.multinomial(n_samples, 1 / n_class * np.ones(n_class)) + + if n_class == 2: + r = np.random.uniform(0, 1, size=int(n_samples / n_class)) + r = np.sort(r) + t = np.linspace( + 0, np.pi * 4 * turns / n_class, int(n_samples / n_class) + ) + np.random.normal(0, noise, int(n_samples / n_class)) + dx = r * np.cos(t) + dy = r * np.sin(t) + + X.append(np.vstack([dx, dy]).T) + X.append(np.vstack([-dx, -dy]).T) + y += [0] * int(n_samples / n_class) + y += [1] * int(n_samples / n_class) + else: + for j in range(1, n_class + 1): + r = np.linspace(0.01, 1, int(mvt[j - 1])) + t = np.linspace( + (j - 1) * np.pi * 4 * turns / n_class, + j * np.pi * 4 * turns / n_class, + int(mvt[j - 1]), + ) + np.random.normal(0, noise, int(mvt[j - 1])) + + dx = r * np.cos(t) + dy = r * np.sin(t) + + dd = np.vstack([dx, dy]).T + X.append(dd) + y += [j - 1] * int(mvt[j - 1]) + + return np.vstack(X), np.array(y).astype(int) diff --git a/proglearn/tests/test_forest.py b/proglearn/tests/test_forest.py index 11927409b9..d895861eb4 100644 --- a/proglearn/tests/test_forest.py +++ b/proglearn/tests/test_forest.py @@ -99,6 +99,29 @@ def test_predict_proba(self): u2 = l2f.predict_proba(np.array([0]).reshape(1, -1), task_id=0) assert np.array_equiv(u1, u2) + # def test_update_task(self): + # np.random.seed(1) + + # l2f = LifelongClassificationForest() + + # X = np.concatenate((np.zeros(100), np.ones(100))).reshape(-1, 1) + # y = np.concatenate((np.zeros(100), np.ones(100))) + + # l2f.add_task(X, y) + # u1 = l2f.predict_proba(np.array([0]).reshape(1, -1), task_id=0) + # u2 = l2f.predict_proba(np.array([1]).reshape(1, -1), task_id=0) + + # X2 = np.concatenate((np.zeros(100), np.ones(100))).reshape(-1, 1) + # y2 = np.concatenate((np.zeros(100), np.ones(100))) + + # X3 = np.concatenate((X, X2)) + # y3 = np.concatenate((y, y2)) + + # l2f.update_task(X2, y2, task_id=0) + + # assert np.array_equiv(l2f.task_id_to_X[0], X3) + # assert np.array_equiv(l2f.task_id_to_y[0], y3) + class TestUncertaintyForest: def test_initialize(self): diff --git a/proglearn/tests/test_system.py b/proglearn/tests/test_system.py index bfa88c7061..ba8349df5c 100644 --- a/proglearn/tests/test_system.py +++ b/proglearn/tests/test_system.py @@ -1,136 +1,136 @@ -import pytest -import numpy as np - -from proglearn.progressive_learner import ProgressiveLearner -from proglearn.deciders import SimpleArgmaxAverage -from proglearn.transformers import ( - TreeClassificationTransformer, - NeuralClassificationTransformer, -) -from proglearn.voters import TreeClassificationVoter, KNNClassificationVoter - - -def generate_2d_rotation(theta=0, acorn=None): - if acorn is not None: - np.random.seed(acorn) - - R = np.array([[np.cos(theta), np.sin(theta)], [-np.sin(theta), np.cos(theta)]]) - - return R - - -def generate_gaussian_parity( - n, mean=np.array([-1, -1]), cov_scale=1, angle_params=None, k=1, acorn=None -): - if acorn is not None: - np.random.seed(acorn) - - d = len(mean) - - if mean[0] == -1 and mean[1] == -1: - mean = mean + 1 / 2**k - - mnt = np.random.multinomial(n, 1 / (4**k) * np.ones(4**k)) - cumsum = np.cumsum(mnt) - cumsum = np.concatenate(([0], cumsum)) - - Y = np.zeros(n) - X = np.zeros((n, d)) - - for i in range(2**k): - for j in range(2**k): - temp = np.random.multivariate_normal( - mean, cov_scale * np.eye(d), size=mnt[i * (2**k) + j] - ) - temp[:, 0] += i * (1 / 2 ** (k - 1)) - temp[:, 1] += j * (1 / 2 ** (k - 1)) - - X[cumsum[i * (2**k) + j] : cumsum[i * (2**k) + j + 1]] = temp - - if i % 2 == j % 2: - Y[cumsum[i * (2**k) + j] : cumsum[i * (2**k) + j + 1]] = 0 - else: - Y[cumsum[i * (2**k) + j] : cumsum[i * (2**k) + j + 1]] = 1 - - if d == 2: - if angle_params is None: - angle_params = np.random.uniform(0, 2 * np.pi) - - R = generate_2d_rotation(angle_params) - X = X @ R - - else: - raise ValueError("d=%i not implemented!" % (d)) - - return X, Y.astype(int) - - -class TestSystem: - def test_nxor(self): - # tests proglearn on xor nxor simulation data - np.random.seed(12345) - - reps = 10 - errors = np.zeros((4, reps), dtype=float) - - for ii in range(reps): - default_transformer_class = TreeClassificationTransformer - default_transformer_kwargs = {"kwargs": {"max_depth": 30}} - - default_voter_class = TreeClassificationVoter - default_voter_kwargs = {} - - default_decider_class = SimpleArgmaxAverage - default_decider_kwargs = {"classes": np.arange(2)} - progressive_learner = ProgressiveLearner( - default_transformer_class=default_transformer_class, - default_transformer_kwargs=default_transformer_kwargs, - default_voter_class=default_voter_class, - default_voter_kwargs=default_voter_kwargs, - default_decider_class=default_decider_class, - default_decider_kwargs=default_decider_kwargs, - ) - - xor, label_xor = generate_gaussian_parity( - 750, cov_scale=0.1, angle_params=0 - ) - test_xor, test_label_xor = generate_gaussian_parity( - 1000, cov_scale=0.1, angle_params=0 - ) - - nxor, label_nxor = generate_gaussian_parity( - 750, cov_scale=0.1, angle_params=np.pi / 2 - ) - test_nxor, test_label_nxor = generate_gaussian_parity( - 1000, cov_scale=0.1, angle_params=np.pi / 2 - ) - - progressive_learner.add_task(xor, label_xor, num_transformers=10) - progressive_learner.add_task(nxor, label_nxor, num_transformers=10) - - uf_task1 = progressive_learner.predict( - test_xor, transformer_ids=[0], task_id=0 - ) - l2f_task1 = progressive_learner.predict(test_xor, task_id=0) - uf_task2 = progressive_learner.predict( - test_nxor, transformer_ids=[1], task_id=1 - ) - l2f_task2 = progressive_learner.predict(test_nxor, task_id=1) - - errors[0, ii] = 1 - np.mean(uf_task1 == test_label_xor) - errors[1, ii] = 1 - np.mean(l2f_task1 == test_label_xor) - errors[2, ii] = 1 - np.mean(uf_task2 == test_label_nxor) - errors[3, ii] = 1 - np.mean(l2f_task2 == test_label_nxor) - - bte = np.mean(errors[0,]) / np.mean( - errors[ - 1, - ] - ) - fte = np.mean(errors[2,]) / np.mean( - errors[ - 3, - ] - ) - - assert bte > 1 and fte > 1 +import pytest +import numpy as np + +from proglearn.progressive_learner import ProgressiveLearner +from proglearn.deciders import SimpleArgmaxAverage +from proglearn.transformers import ( + TreeClassificationTransformer, + NeuralClassificationTransformer, +) +from proglearn.voters import TreeClassificationVoter, KNNClassificationVoter + + +def generate_2d_rotation(theta=0, acorn=None): + if acorn is not None: + np.random.seed(acorn) + + R = np.array([[np.cos(theta), np.sin(theta)], [-np.sin(theta), np.cos(theta)]]) + + return R + + +def generate_gaussian_parity( + n, mean=np.array([-1, -1]), cov_scale=1, angle_params=None, k=1, acorn=None +): + if acorn is not None: + np.random.seed(acorn) + + d = len(mean) + + if mean[0] == -1 and mean[1] == -1: + mean = mean + 1 / 2**k + + mnt = np.random.multinomial(n, 1 / (4**k) * np.ones(4**k)) + cumsum = np.cumsum(mnt) + cumsum = np.concatenate(([0], cumsum)) + + Y = np.zeros(n) + X = np.zeros((n, d)) + + for i in range(2**k): + for j in range(2**k): + temp = np.random.multivariate_normal( + mean, cov_scale * np.eye(d), size=mnt[i * (2**k) + j] + ) + temp[:, 0] += i * (1 / 2 ** (k - 1)) + temp[:, 1] += j * (1 / 2 ** (k - 1)) + + X[cumsum[i * (2**k) + j] : cumsum[i * (2**k) + j + 1]] = temp + + if i % 2 == j % 2: + Y[cumsum[i * (2**k) + j] : cumsum[i * (2**k) + j + 1]] = 0 + else: + Y[cumsum[i * (2**k) + j] : cumsum[i * (2**k) + j + 1]] = 1 + + if d == 2: + if angle_params is None: + angle_params = np.random.uniform(0, 2 * np.pi) + + R = generate_2d_rotation(angle_params) + X = X @ R + + else: + raise ValueError("d=%i not implemented!" % (d)) + + return X, Y.astype(int) + + +class TestSystem: + def test_nxor(self): + # tests proglearn on xor nxor simulation data + np.random.seed(12345) + + reps = 10 + errors = np.zeros((4, reps), dtype=float) + + for ii in range(reps): + default_transformer_class = TreeClassificationTransformer + default_transformer_kwargs = {"kwargs": {"max_depth": 30}} + + default_voter_class = TreeClassificationVoter + default_voter_kwargs = {} + + default_decider_class = SimpleArgmaxAverage + default_decider_kwargs = {"classes": np.arange(2)} + progressive_learner = ProgressiveLearner( + default_transformer_class=default_transformer_class, + default_transformer_kwargs=default_transformer_kwargs, + default_voter_class=default_voter_class, + default_voter_kwargs=default_voter_kwargs, + default_decider_class=default_decider_class, + default_decider_kwargs=default_decider_kwargs, + ) + + xor, label_xor = generate_gaussian_parity( + 750, cov_scale=0.1, angle_params=0 + ) + test_xor, test_label_xor = generate_gaussian_parity( + 1000, cov_scale=0.1, angle_params=0 + ) + + nxor, label_nxor = generate_gaussian_parity( + 750, cov_scale=0.1, angle_params=np.pi / 2 + ) + test_nxor, test_label_nxor = generate_gaussian_parity( + 1000, cov_scale=0.1, angle_params=np.pi / 2 + ) + + progressive_learner.add_task(xor, label_xor, num_transformers=10) + progressive_learner.add_task(nxor, label_nxor, num_transformers=10) + + uf_task1 = progressive_learner.predict( + test_xor, transformer_ids=[0], task_id=0 + ) + l2f_task1 = progressive_learner.predict(test_xor, task_id=0) + uf_task2 = progressive_learner.predict( + test_nxor, transformer_ids=[1], task_id=1 + ) + l2f_task2 = progressive_learner.predict(test_nxor, task_id=1) + + errors[0, ii] = 1 - np.mean(uf_task1 == test_label_xor) + errors[1, ii] = 1 - np.mean(l2f_task1 == test_label_xor) + errors[2, ii] = 1 - np.mean(uf_task2 == test_label_nxor) + errors[3, ii] = 1 - np.mean(l2f_task2 == test_label_nxor) + + bte = np.mean(errors[0,]) / np.mean( + errors[ + 1, + ] + ) + fte = np.mean(errors[2,]) / np.mean( + errors[ + 3, + ] + ) + + assert bte > 1 and fte > 1