From ac29c41b6bbc10fc7ab73cebd1ed3a82b13c7a09 Mon Sep 17 00:00:00 2001 From: Emilie Baillo Date: Fri, 31 Oct 2025 14:23:14 -0700 Subject: [PATCH 1/6] Added eta optimization methods into the PCE class --- src/pytuq/surrogates/pce.py | 220 +++++++++++++++++++++++++++++++++++- 1 file changed, 216 insertions(+), 4 deletions(-) diff --git a/src/pytuq/surrogates/pce.py b/src/pytuq/surrogates/pce.py index b1af6c1..51c3f66 100644 --- a/src/pytuq/surrogates/pce.py +++ b/src/pytuq/surrogates/pce.py @@ -1,6 +1,6 @@ #!/usr/bin/env python -"""This module provides a KLPC (Karhunen-Loeve and Polynomial Chaos) wrapper class to facilitate +"""This module provides a Polynomial Chais Expansion (PCE) wrapper class to facilitate the universal coupling of FASTMath UQ tools and libraries. This class focuses on the use case of surrogate models built with PCE and linear regression, keeping in mind flexibility to implement additional UQ functionalities in the future. @@ -16,6 +16,9 @@ """ import numpy as np +import math +import copy +from matplotlib import pyplot as plt from pytuq.rv.pcrv import PCRV from pytuq.utils.mindex import get_mi @@ -25,7 +28,7 @@ class PCE: - r"""A wrapper class to access KLPC functionalities for PCE surrogate models. + r"""A wrapper class to access PyTUQ functionalities for PCE surrogate models. Attributes: pcrv (PCRV object): Polynomial Chaos random variable object, encapsulates details for polynomial chaos expansion. @@ -34,7 +37,7 @@ class PCE: pctype (list[str]): Type of PC polynomial used. outdim (int): Physical dimensionality, i.e. # of output variables. lreg (lreg object): Linear regression object used for fitting the model. - mindex (int np.ndarray): Multiindex array carrying the powers to which the basis functions will be raised to within the PC terms. + mindex (int np.ndarray): Multiindex array carrying the powers to which the basis functions will be raised to within the PC terms. Reset when build() is called again. regression_method (str): Method used for linear regression. ex] anl, opt, lsq _x_train (np.ndarray): Input training data _y_train (np.ndarray): Output training data, corresponding to x_train @@ -110,6 +113,208 @@ def set_training_data(self, x_train, y_train): self._x_train = x_train self._y_train = y_train + + def get_pc_terms(self): + """Returns a list where each element represents the number of PC terms + in the corresponding dimension of the PCE. + + Returns: + list[int] + """ + + return [mi.shape[0] for mi in self.pcrv.mindices] + + + def kfold_split(self, nsamples, nfolds, seed=13): + """Return dictionary of training and testing pairs using k-fold cross-validation. + + Args: + nsamples (int): Total number of training samples. + nfolds (int): Number of folds to use for k-fold cross-validation. + seed (int, optional): Random seed for reproducibility. Defaults to 13. + + Returns: + dict: A dictionary where each key is the fold number (0 to nfolds-1) + and each value is a dictionary with: + - "train index" (np.ndarray): Indices of training samples. + - "val index" (np.ndarray): Indices of validation samples. + """ + # Returns split data where each data is one fold left out + KK = nfolds + rn = np.random.RandomState(seed) + + # Creating a random permutation of the samples indices list + indp=rn.permutation(nsamples) + + # Split the permuted indices into KK (or # folds) equal-sized chunks + split_index=np.array_split(indp,KK) + + # Dictionary to hold the indices of the training and validation samples + cvindices = {} + + # create testing and training folds + for j in range(KK): + # Iterating through the number of folds + fold = j + # Iterate through # folds, if i != fold number, + newindex = [split_index[i] for i in range(len(split_index)) if i != (fold)] + train_ind = np.array([],dtype='int64') + for i in range(len(newindex)): train_ind = np.concatenate((train_ind,newindex[i])) + test_ind = split_index[fold] + cvindices[j] = {'train index': train_ind, 'val index': test_ind} + + return cvindices + + + def kfold_cv(self, x, y, nfolds=3,seed=13): + """Splits data into training/testing pairs for kfold cross-val + x is a data matrix of size n x d1, d1 is dim of input + y is a data matrix of size n x d2, d2 is dim of output + + Args: + x (np.ndarray): Input matrix with shape (n, d1) or 1D array with shape (n,). Each row is a sample; columns are input features. + y (np.ndarray): Target array with shape (n,) for single-output, or (n, d2) for multi-output. If 1D, it is internally reshaped to (n, 1) before slicing; outputs are `np.squeeze`d per fold. + nfolds (int, optional): Number of folds for cross-validation. Defaults to 3. + seed (int, optional): Random seed for reproducible shuffling in `kfold_split`. Defaults to 13. + """ + + if len(x.shape)>1: + n,d1 = x.shape + else: + n=x.shape + ynew = np.atleast_2d(y) + if len(ynew) == 1: ynew = ynew.T # change to shape (n,1) + _,d2 = ynew.shape + cv_idx = self.kfold_split(n,nfolds,seed) + + kfold_data = {} + for k in cv_idx.keys(): + kfold_data[k] = { + 'xtrain': x[cv_idx[k]['train index']], + 'xval': x[cv_idx[k]['val index']], + 'ytrain': np.squeeze(ynew[cv_idx[k]['train index']]), + 'yval': np.squeeze(ynew[cv_idx[k]['val index']]) + } # use squeeze to return 1d array + + # set train and test to the same if 1 fold + if nfolds == 1: + kfold_data[k]['xtrain'] = kfold_data[k]['xval'] + kfold_data[k]['ytrain'] = kfold_data[k]['yval'] + + return kfold_data + + + def optimize_eta(self, etas, verbose, nfolds=3, plot=False): + """Choose the optimum eta for Bayesian compressive sensing. Calculates the RMSE for each eta for a specified number of folds. + Selects the eta with the lowest RMSE after averaging the RMSEs over the folds. + + Arg: + y: 1D numpy array (vector) with function, evaluated at the sample points [#samples,] + x: N-dimensional NumPy array with sample points [#samples, #dimensions] + etas: NumPy array or list with the threshold for stopping the algorithm. Smaller values retain more nonzero coefficients. + plot: Flag for whether to generate a plot for eta optimization + + Returns: + eta_opt: Optimum eta + + """ + # Split data in k folds -> Get dictionary of data split in training + testing folds + kfold_data = self.kfold_cv(self._x_train, self._y_train, nfolds) + + # Each value has data for 1 fold. Each value is a list of the RMSEs for each possible eta in the fold. + RMSE_list_per_fold_tr = [] + + # Same but for testing data + RMSE_list_per_fold_test = [] + + # Make a copy of the PCE object to run the cross-validation algorithm on + pce_copy = PCE(self.sdim, self.order, self.pctype, verbose=0) + + pce_copy.pcrv = copy.deepcopy(self.pcrv) # copying over self attributes + + # Loop through each fold + for i in range(nfolds): + + # Get the training and validation data + x_tr = kfold_data[i]['xtrain'] + y_tr = kfold_data[i]['ytrain'] + x_test = kfold_data[i]['xval'] + y_test = kfold_data[i]['yval'] + + # As we conduct BCS for this fold with each separate eta, the RMSEs will be added to these lists + RMSE_per_eta_tr = [] + RMSE_per_eta_test = [] + + # Set the x and y training data for the copied PCE object + pce_copy.set_training_data(x_tr, y_tr) + + # Loop through each eta + for eta in etas: + + # Conduct the BCS fitting. The object is automatically updated with new multiindex and coefficients received from the fitting. + cfs = pce_copy.build(regression = 'bcs', eta=eta) + + # Evaluate the PCE object at the training and validation points + y_tr_eval = (pce_copy.evaluate(x_tr))['Y_eval'] + y_test_eval = (pce_copy.evaluate(x_test))['Y_eval'] + + # Print statement for verbose flag + if verbose > 1: + print("Fold " + str(i + 1) + ", eta " + str(eta) + ", " + str(len(cfs)) + " terms retained out of a full basis of size " + str(len(pce_copy.pcrv.mindices[0]))) + + # Calculate the RMSEs for the training and validation points. + # Append the values into the list of etas per fold. + MSE = np.square(np.subtract(y_tr, y_tr_eval)).mean() + RMSE = math.sqrt(MSE) + RMSE_per_eta_tr.append(RMSE) + + MSE = np.square(np.subtract(y_test, y_test_eval)).mean() + RMSE = math.sqrt(MSE) + RMSE_per_eta_test.append(RMSE) + + # Now, append the fold's list of RMSEs for each eta into the list carrying the lists for all folds + RMSE_list_per_fold_tr.append(RMSE_per_eta_tr) + RMSE_list_per_fold_test.append(RMSE_per_eta_test) + + # After compiling the RMSE data for each eta from all the folds, we find the eta with the lowest validation RMSE to be our optimal eta. + # Compute the average and standard deviation of the training and testing RMSEs over the folds + avg_RMSE_tr = np.array(RMSE_list_per_fold_tr).mean(axis=0) + avg_RMSE_test = np.array(RMSE_list_per_fold_test).mean(axis=0) + + std_RMSE_tr = np.std(np.array(RMSE_list_per_fold_tr), axis=0) + std_RMSE_test = np.std(np.array(RMSE_list_per_fold_test), axis=0) + + # Choose the eta with lowest RMSE across all folds' testing data + eta_opt = etas[np.argmin(avg_RMSE_test)] + + # Plot RMSE vs. eta for training and testing RMSE + if plot: + + fig, ax = plt.subplots(figsize=(10,10)) + + plt.errorbar(etas, avg_RMSE_tr, xerr=None, yerr=std_RMSE_tr, linewidth=2, markersize=8, capsize=8, label=('Training')) + plt.errorbar(etas, avg_RMSE_test, xerr=None, yerr=std_RMSE_test, linewidth=2, markersize=8, capsize=8, label=('Validation')) + + plt.plot(eta_opt, np.min(avg_RMSE_test), marker="o", markersize=15, color='black', label=("Optimum")) + + plt.xlabel("Eta",fontsize=20) + plt.ylabel("RMSE",fontsize=20) + + # Change size of tick labels + plt.tick_params(axis='both', labelsize=16) + + plt.xscale('log') + plt.yscale('log') + + # Create legend + plt.legend(loc='upper left') + + # Save + plt.savefig('eta_opt.pdf', format='pdf', dpi=1200) + + return eta_opt + + def build(self, **kwargs): """Builds and initializes the linear regression model for the pcrv object with training data. Returns coefficients for evaluated Polynomial Chaos Expansion. @@ -155,7 +360,14 @@ def build(self, **kwargs): else: self.lreg = anl(datavar=kwargs.get('datavar'), prior_var=kwargs.get('prior_var'), cov_nugget=kwargs.get('cov_nugget', 0.0)) elif regression == 'bcs': - self.lreg = bcs(eta=kwargs.get('eta', 1.e-8), datavar_init=kwargs.get('datavar_init')) + eta = kwargs.get('eta', 1.e-8) + if isinstance(eta, (list, np.ndarray)): + opt_eta = self.optimize_eta(eta, nfolds=kwargs.get('nfolds', 3), verbose=kwargs.get('eta_verbose', False), plot=kwargs.get('eta_plot', False)) + self.lreg = bcs(eta=opt_eta, datavar_init=kwargs.get('datavar_init')) + elif isinstance(eta, float): + self.lreg = bcs(eta=eta, datavar_init=kwargs.get('datavar_init')) + else: + raise ValueError("You may provide either a float (defaulting to 1.e-8) or list/numpy array for the value of eta. If a list/numpy array is provided, the most optimal eta from the array will be chosen.") else: raise ValueError(f"Regression method '{regression}' is not recognized and/or supported yet.") From bce33de5216c465576912dd4da38bd5c25936f15 Mon Sep 17 00:00:00 2001 From: Emilie Baillo Date: Fri, 31 Oct 2025 14:27:36 -0700 Subject: [PATCH 2/6] Updated Genz surrogate example --- examples/surrogates/ex_genz_bcs.ipynb | 572 +++++++++++++++++--------- 1 file changed, 375 insertions(+), 197 deletions(-) diff --git a/examples/surrogates/ex_genz_bcs.ipynb b/examples/surrogates/ex_genz_bcs.ipynb index 01bc04b..af77ee7 100644 --- a/examples/surrogates/ex_genz_bcs.ipynb +++ b/examples/surrogates/ex_genz_bcs.ipynb @@ -4,16 +4,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Genz Function Approximation with PCE fitted via BCS" + "## Function Approximation with Sparse Regression" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "In this example, we approximate the Genz Oscillatory function by constructing a Polynomial Chaos (PC) surrogate with Bayesian compressive sensing (BCS). The first build process uses a given eta of 1e-10, while the second build process selects the most optimal eta for BCS through cross-validation. Both models are then evaluated on testing and training data, returning parity plots and a Root Mean Square Error for each evaluation. \n", + "In this tutorial, we demonstrate how to approximate a function with sparse regression by constructing a Polynomial Chaos (PC) surrogate with Bayesian compressive sensing (BCS). The function we will approximate here is the Genz Oscillatory function, defined as:\n", "\n", - "To follow along with the cross-validation algorithm used to select the optimal eta, see section \"Functions for cross-validation algorithm\" at the end of the notebook." + "\\begin{align}f(x) = \\cos\\left(2 \\pi s + \\sum_{i=1}^d w_i x_i\\right)\\end{align}\n", + "\n", + "Where:\n", + "\n", + "- $s$: The shift parameter (``self.shift`` in the class).\n", + "- $w_i$: The weights for each dimension (``self.weights`` in the class).\n", + "- $x_i$: The input variables.\n", + "- $d$: The dimensionality of the input $x$ (number of components in $x$).\n", + "\n", + "Through three different build processes, we will construct three PC surrogates to highlight the advantages of BCS and explore the effects of the `eta` hyperparameter on model results. First, we'll build with least squares regression to demonstrate the limitations of non-sparse methods and the need for BCS. Then we'll build with BCS using a given eta of $1 \\times 10^{-10}$ and identify aspects for model improvement. Last, we'll build with the most optimal eta, as found through cross-validation algorithms exposed here. All three surrogates will be evaluated on testing and training data, with parity plots and Root Mean Square Error (RMSE) values used to compare their performance. \n", + "\n", + "To follow along with the cross-validation algorithm used to select the optimal eta, see section \"Functions for cross-validation algorithm\" in the second half of the notebook." ] }, { @@ -32,9 +43,8 @@ "from matplotlib import pyplot as plt\n", "from sklearn.metrics import root_mean_squared_error\n", "\n", - "\n", "from pytuq.surrogates.pce import PCE\n", - "from pytuq.utils.maps import scale01ToDom\n", + "from pytuq.utils.maps import scaleDomTo01\n", "from pytuq.func.genz import GenzOscillatory" ] }, @@ -42,69 +52,70 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Setting a random number generator seed:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Random number generator\n", - "from scipy.stats import qmc\n", - "rng_seed = 43" + "# Constructing PC surrogate and generating data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Constructing PC surrogate and generating data" + "To start, we begin with defining our true model and input parameters for our PC surrogate.\n", + "\n", + "After importing GenzOscillatory from ``pytuq.func.genz``, we generate the Genz function below, along with training data and testing data with output noise. This data and the corresponding Genz function will be used to create the same PC surrogate fitted in all three examples: first with linear regression, next using BCS with a given eta, and third using BCS with the most optimal eta. " ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 2, "metadata": {}, + "outputs": [], "source": [ - "We generate the Genz function, as well as training data and testing data with output noise. This data and the corresponding Genz function will be used to create the same PC surrogate fitted in both examples: (1) The first surrogate will be fitted using BCS with a given eta, and (2) the second surrogate will be fitted using BCS with the most optimal eta." + "# Random number generator\n", + "from scipy.stats import qmc\n", + "rng_seed = 43" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Use Genz Oscillatory function in multiple dimensions for the true model\n", + "# Define our true model as the Genz Oscillatory function in multiple dimensions\n", "func_dim = 4\n", - "func_weights = [1.0/(i+1)**2 for i in range(func_dim)]\n", + "func_weights = [1.0/(i+1)**2 for i in range(func_dim)] \n", "func = GenzOscillatory(shift=0.25, weights=func_weights)\n", - "noise_std = 0.1\n", + "noise_std = 0.025\n", + "\n", "rng = qmc.LatinHypercube(d=func_dim, seed=rng_seed)\n", + "np.random.seed(42)\n", + "\n", + "# As we choose to use Legendre polynomials later in the surrogate construction, we define the domain of ξ on [-1, 1]^d\n", + "ksi_domain = np.array([[-1.0, 1.0]] * func_dim) \n", "\n", "# Training data\n", - "np.random.seed(42)\n", "n_trn = 70\n", - "x_trn = rng.random(n=n_trn) # random numbers in [0,1]^d\n", - "y_trn = func(x_trn) + np.random.normal(0, noise_std, size = (n_trn,1))\n", + "value_ksi_trn = 2*rng.random(n=n_trn) - 1 # Randomly generating 70 data points within the domain of ξ \n", + "x_trn = scaleDomTo01(value_ksi_trn, ksi_domain) # We scale our training data to [0, 1]^d, the domain of the Genz function\n", + "y_trn = func(x_trn) + np.random.normal(0, noise_std, size = (n_trn, 1))\n", "\n", "# Testing data\n", "n_tst = 10000\n", - "x_tst = rng.random(n=n_tst) # random numbers in [0,1]^d\n", - "y_tst = func(x_tst) + np.random.normal(0, noise_std, size = (n_tst,1))" + "value_ksi_tst = 2*rng.random(n=n_tst) - 1 \n", + "x_tst = scaleDomTo01(value_ksi_tst, ksi_domain)\n", + "y_tst = func(x_tst)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "With a stochastic dimensionality of 4 (defined above) and a polynomial order of 4, we construct the PC surrogate that will be used in both builds. You have the option of printing the PC surrogate's full basis, before BCS selects and retains the most significant PC coefficients to reduce the basis." + "With a stochastic dimensionality of 4 (defined above) and a chosen polynomial order of 4, we construct the PC surrogate that will be used in both builds. By calling the `printInfo()` method from the PCRV variable, you can print the PC surrogate's full basis and current coefficients, before BCS selects and retains the most significant PC terms to reduce the basis." ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -187,7 +198,7 @@ " [0 0 0 4]] [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - "Number of Basis Terms: 70\n" + "Number of Basis Terms: [70]\n" ] } ], @@ -199,124 +210,60 @@ "# Optional verbosity output:\n", "print(\"Full Basis and Current Coefficients:\")\n", "pce_surr.pcrv.printInfo()\n", - "print(\"Number of Basis Terms:\", len(pce_surr.pcrv.mindices[0]))\n", + "print(\"Number of Basis Terms:\", pce_surr.get_pc_terms())\n", "\n", "# (1.5) Set training data\n", - "pce_surr.set_training_data(x_trn, y_trn[:,0])" + "pce_surr.set_training_data(value_ksi_trn[:80], y_trn[:80,0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# BCS with default settings (default eta)" + "From the input parameters of our PC surrogate, we have 70 basis terms in our PCE. With 70 training points and no noise, having 70 basis terms would mean that we have a fully determined system, as the number of training points is the same as the number of basis terms. However, with the addition of noise in our training data, it becomes harder for the model to accurately fit all basis terms, leading to potential overfitting. This demonstrates the helpful role BCS might play as a choice for our regression build. As a sparse regression approach, BCS uses regularization to select only the most relevant basis terms, making it particularly effective in situations like this, where we do not have enough clear information to fit all basis terms without overfitting.\n", + "\n", + "In the next sections, we will explore the effects of overfitting in more detail.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Here, we call the PCE class method of `build()` to build the linear regression model used to fit the surrogate. With the flag `regression='bcs'`, we choose the BCS method for the fitting. A user-defined eta of 1e-10 is also passed in." + "# Least Squares Regression\n", + "\n", + "To start, we call the PCE class method of `build()` with no arguments to use the default regression option of least squares. Then, through `evaluate()`, we can generate model predictions for our training and testing data." ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Regression method: bcs\n", - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n", - "Retained Basis and Coefficients:\n", - "[[2 0 0 0]\n", - " [1 0 3 0]\n", - " [0 2 0 2]\n", - " [0 0 1 2]\n", - " [4 0 0 0]\n", - " [3 1 0 0]\n", - " [1 1 0 1]\n", - " [2 0 0 2]\n", - " [2 0 1 1]\n", - " [0 0 0 4]\n", - " [1 0 0 3]\n", - " [0 0 0 1]\n", - " [1 1 0 0]\n", - " [1 0 0 1]\n", - " [0 3 1 0]\n", - " [0 1 0 2]\n", - " [0 1 1 2]\n", - " [2 0 2 0]\n", - " [0 1 0 1]\n", - " [0 0 0 0]] [ 0.11844696 -0.1286659 -0.23890894 0.20561299 -0.65563148 1.41773821\n", - " -0.20218904 -0.30625401 0.40503892 -0.27250245 0.99544673 -0.90463019\n", - " -2.75925351 -0.66386396 0.13068211 -0.96868699 -0.65718534 -0.27253516\n", - " 3.07988105 0.12550357]\n", - "Number of retained basis terms: 20\n" + "Regression method: lsq\n" ] } ], "source": [ "# (2) Build the linear regression object for fitting\n", - "pce_surr.build(regression='bcs', eta=1.e-10)\n", + "pce_surr.build()\n", "\n", - "# Optional verbosity output:\n", - "print(\"Retained Basis and Coefficients:\")\n", - "pce_surr.pcrv.printInfo()\n", - "print(\"Number of retained basis terms:\", len(pce_surr.pcrv.mindices[0]))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "After fitting, we evaluate the PCE using our training and testing data. To analyze the model's goodness of fit, we calculate the root mean square error between the surrogate results and the training and testing data." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The training RMSE error in the PCE BCS approximation is 1.72e-01\n", - "The testing RMSE error in the PCE BCS approximation is 2.73e-01\n" - ] - } - ], - "source": [ "# (3) Evaluate the PC model\n", - "y_trn_approx = pce_surr.evaluate(x_trn)\n", - "y_tst_approx = pce_surr.evaluate(x_tst)\n", - "\n", - "# Evaluate goodness of fit with RMSE\n", - "rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx[\"Y_eval\"])\n", - "print(\"The training RMSE error in the PCE BCS approximation is %.2e\"%rmse_trn)\n", - "\n", - "rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx[\"Y_eval\"])\n", - "print(\"The testing RMSE error in the PCE BCS approximation is %.2e\"%rmse_tst)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Notice above how the training RMSE error is almost half that of the testing RMSE error. This shows that our current model is overfitting, learning the training data with noise too well. To address this issue, we can explore selecting a better eta for the BCS fitting." + "y_trn_approx = pce_surr.evaluate(value_ksi_trn)\n", + "y_tst_approx = pce_surr.evaluate(value_ksi_tst)\n" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -327,14 +274,11 @@ ], "source": [ "# Plot the surrogate model's output vs. the training data output\n", - "\n", "y_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()]\n", "\n", - "\n", "fig1 = plt.figure(figsize=(8,6))\n", "ax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75])\n", "\n", - "\n", "ax1.plot(y_trn[:,0],y_trn_approx[\"Y_eval\"],\".\")\n", "ax1.plot(y_trn_mM,y_trn_mM) # Diagonal line\n", "\n", @@ -344,12 +288,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAssAAAIHCAYAAABpIhEUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAADz0ElEQVR4nOy9e3xU1bn//9kTCSQBQkK4JCEhMQJBCBDuNyNgqwT4IkJbkPZoUdEKak97Wgj+Dl5ajwR7zmmrolWwVE8L0gqiLRdtRYWAAnK/RQQSEiBAIiFIEghm9u+PnTXZl7X2ZWZPZpI879erlczs2Xvt21qf9aznIsmyLIMgCIIgCIIgCAOeUDeAIAiCIAiCIMIVEssEQRAEQRAEIYDEMkEQBEEQBEEIILFMEARBEARBEAJILBMEQRAEQRCEABLLBEEQBEEQBCGAxDJBEARBEARBCCCxTBAEQRAEQRACbgp1A8IBr9eLc+fOoUOHDpAkKdTNIQiCIAiCIIKMLMv45ptvkJSUBI9HbD8msQzg3LlzSElJCXUzCIIgCIIgiCamtLQUPXr0EH5PYhlAhw4dACgXq2PHjiFuDUEQBEEQBBFsrly5gpSUFJ8OFEFiGfC5XnTs2JHEMkEQBEEQRCvCygWXAvwIgiAIgiAIQgCJZYIgCIIgCIIQQGKZIAiCIAiCIASQWCYIgiAIgiAIASSWCYIgCIIgCEIAiWWCIAiCIAiCEEBimSAIgiAIgiAEkFgmCIIgCIIgCAEklgmCIAiCIAhCAIllgiAIgiAIghBAYpkgCIIgCIIgBJBYJgiCIAiCIAgBJJYJgiAIgiAIQgCJZYIgCIIgCIIQQGKZaBGUVdVix8kKlFXVhropBEEQBEG0IG4KdQMIIlDW7C7BonWH4JUBjwQsmZ6FmcNSQ90sgiAIgiBaAGRZJpo1ZVW1PqEMAF4ZeHLdYbIwEwRBEAThCiSWiWZNUUW1Tygz6mUZxRU1oWkQQRAEQRAtChLLRLMmPSEGHkn7WYQkIS0hOjQNIgiCIAiiRUFimWjWJMZGYcn0LERIimKOkCQ8P70/EmOjQtwygiAIgiBaAhTgRzR7Zg5LRU7vLiiuqEFaQjQJZYIgCIIgXIPEMtEiSIyNIpFMEARBEITrkBsGQRAEQRAEQQggsUwQBEEQBEEQAkgsEwRBEARBEIQAEssEQRAEQRAEIYDEMkEQBEEQBEEIILFMEARBEARBEAJILBMEQRAEQRCEABLLBEEQBEEQBCGAxDJBEARBEARBCCCxTBAEQRAEQRACSCwTBEEQBEEQhAASywRBEARBEAQhgMQyQRAEQRAEQQggsUwQBEEQBEEQAkgsEwRBEARBEIQAEssEQRAEQRAEIYDEMkEQBEEQBEEIILFMEARBEARBEAJILBMEQRAEQRCEABLLBEEQBEEQBCGAxDJBEARBEARBCCCxTBAEQRAEQRACSCwTBEEQBEEQhAASywRBEARBEAQhgMQyQRAEQRAEQQggsUwQBEEQBEEQAkgsEwRBEARBEIQAEssEQRAEQRAEIYDEMkEQBEEQBEEIILFMEARBEARBEAJILBMEQRAEQRCEABLLBEEQBEEQBCGAxDJBEARBEARBCCCxTBAEQRAEQRACSCwTBEEQBEEQhIAWIZbPnj2LH/3oR+jcuTOioqKQlZWFL774ItTNIgiCIAiCIJo5N4W6AYFSWVmJMWPGYPz48di0aRO6dOmCr776CnFxcaFuGkEQBEEQBNHMafZieenSpUhJScHKlSt9n6Wnp4ewRQRBEARBEERLodm7Ybz//vsYOnQovv/976Nr167Izs7G8uXLQ90sgiAIgiAIogXQ7MXyqVOn8Oqrr6JXr1744IMP8Oijj+KJJ57Am2++KfzN9evXceXKFc3/CIIgCIIgCEKPJMuyHOpGBEJkZCSGDh2KHTt2+D574oknsHv3bnz22Wfc3zzzzDN49tlnDZ9XVVWhY8eOQWsrQRAEQRAEER5cuXIFsbGxlvqv2VuWExMTceutt2o+69u3L0pKSoS/WbRoEaqqqnz/Ky0tDXYzCYIgCIIgiGZIsw/wGzNmDL788kvNZ8ePH0fPnj2Fv2nbti3atm0b7KYRBEEQBEEQzZxmb1n+2c9+hs8//xzPP/88Tpw4gVWrVuH111/H/PnzQ900giAIgiAIopnT7MXysGHD8O6772L16tXo378/fv3rX+N3v/sdfvjDH4a6aQRBEARBEEQzp9kH+LmBXQdvgiAIgiAIomXQagL8CIIgCIIgCCJYkFgmCIIgCIIgCAEklgmCIAiCIAhCAIllgiAIgiAIghBAYpkgCIIgCIIgBJBYJgiCIIgwpKyqFjtOVqCsqjbUTSGIVk2zr+BHEARBEC2NNbtLsGjdIXhlwCMBS6ZnYeaw1FA3iyBaJWRZJgiCIIgwoqyq1ieUAcArA0+uO0wWZoIIESSWCYIgCCKMKKqo9gllRr0so7iiJjQNIohWDollgiAIgggj0hNi4JG0n0VIEtISokPTIIJo5ZBYJgiCIIgwIjE2CkumZyFCUhRzhCTh+en9kRgbFeKWEUTrhAL8iBZJWVUtiiqqkZ4QQwMMQRAB09R9ysxhqcjp3QXFFTVIS4imfowgQgiJZaLFQVHkBEG4Saj6lMTYKBLJBBEGkBsG0aKgKHKCINyE+hSCIEgsEy0KiiInCMJNqE8hCILEMtGioChygiDchPoUgiBILBMtCooiJwjCTahPIQhCkmVZtt6sZXPlyhXExsaiqqoKHTt2DHVzCBcoq6qlKHKCIFyD+hSCaHnY1X+UDYNokVAUOUEQbkJ9CkG0XsgNgyAIgiAIgiAEkFgmCIIgCIIgCAEklgmCIAiCIAhCAIllgiAIgiAIghBAYpkgCIIgCIIgBJBYJgiCIIgwpqyqFjtOVlCJbYIIEZQ6jiAIgiDClDW7S7Bo3SF4ZcAjAUumZ2HmsNRQN4sgWhVkWSYIgiCIMKSsqtYnlAHAKwNPrjtMFmaCaGJILBMEQRBEGFJUUe0Tyox6WUZxRU1oGkQQrRQSywRBEAQRhqQnxMAjaT+LkCSkJUSHpkEE0UohsUwQBEEQYUhibBSWTM9ChKQo5ghJwvPT+1PZbYJoYijAjyAIgiDClJnDUpHTuwuKK2qQlhBNQpkgQgCJZYIgCIIIYxJjo0gkE0QIITcMgiAIgiAIghBAYpkgCIIgwgwqREIQ4QO5YRAEQRBEGEGFSAgivCDLMhHWkHWFIIiWiKhvo0IkBBF+kGWZCFvIukIQREvErG8zK0RCQX4EERrIskyEJWRdIYjwh1Z+nGPVt1EhEoIIP0gsE2EJlXkliPBmze4SjMnfgtnLd2JM/has2V0S6iY1C6z6NipEQhDhB7lhEGEJs66oBxWyrhBEaCirqkVRRTXSE2KQGBsltI7m9O5Cos4CO30bFSIhiPCCLMtEWELWFYIID3gWZFr58R+7fVtibBRGZXSmPo8gwgCyLBNhC1lXCCK0iCzI6+aNopWfAKC+jSCaF2RZJsKacLSuUFAT0VoQWZBr6ry08hMg4di3EQTBhyzLBOEASmdHtCbM/GtHZXQm6yhBEK0CsiwThE0onR3R2rDyryXrKEEQrQGyLBOETZwWC9BnECCI5gj51xIE0dohsUwQNnGSzo7cNYiWRGJsFIlkgiBaLeSGQRA2sZvyidw1CIIgCKLlQJZlgnCAnSVpp+4aBBEo5PJDEAQRPEgsE4RDrJakqfog0ZSQyw9BEERwITcMIiS05FzFVH2QaCrI5YcgCCL4kGWZaFLKqmrxx4IivFFQ1KItYZRBgGgKyOWHIAgi+JBYJpqMNbtLsHDtIc1nzBKW07tLixvcKYMAEWzI5YcgCCL4kBsG0SSUVdUiTyeUGcwSRhCEM8jlhyAIIviQZZloEr4ovgRZ8B1ZwgjCf8jlhyAIIriQWCaaBKnB8mX4HCBLGEEECLn8EARBBI8W54aRn58PSZLw7//+76FuCqFiSM846OWyBGD9/NEtLriPIAiCIIiWQ4sSy7t378Zrr72GAQMGhLophI7E2Cjkz8iCp0ExeyQgf0YWBqbEhbZhBEEQBEEQJrQYN4yrV6/ihz/8IZYvX47nnnsu1M0hOJBvJUEQoYQqHRIE4Q8tRizPnz8fkydPxne+8x1LsXz9+nVcv37d9/eVK1eC3TyiAfKtJAgiFFClQ4Ig/KVFuGG8/fbb2Lt3L5YsWWJr+yVLliA2Ntb3v5SUlCC3kCAIgggVVOmQIIhAaPZiubS0FD/96U/xl7/8Be3atbP1m0WLFqGqqsr3v9LS0iC3kiAIgggVZpUOCYIgrGj2bhh79uzBxYsXMXjwYN9n9fX12Lp1K15++WVcv34dERERmt+0bdsWbdu2beqmEmGImQ8j+TcSRPPB7H2lSocEQQRCsxfLd9xxBw4d0laGmzNnDjIzM7Fw4UKDUCYIhpkPI/k3EkTzwep9ZZUOn1x3GPWy3GwrHdIEniBCQ7MXyx06dED//v01n8XExKBz586GzwmCIfJhzOndBQC432V274DqunrEREaguq6eBiyCCAPM3mX1+9ncs/HQBJ4gQkezF8sE4Q9mPowyZO5305bt0JTspgGLaC60ZIuk2busP9fmmo3H7oSAIIjg0CLF8ieffBLqJhBhjpUPo/47AND9SQMW0Sxo6RbJpvZHDsXEw8mEgCAI92n22TAIwh+YD2OEpJQUVPsw6r/z6Ot0q6CIeiKcaQ0p08zeZbdZs7sEY/K3YPbynRiTvwVrdpe4fgwebEKghgIUCaLpaJGWZYKwg5kPo/q76EgP7nllh8GyA9CARYQ3rcUi2RT+yKF0hWgpAYoE0VwhsUy0eMyWTc18GNXfqQcqBg1YRLjTmlKmBdsfOdQTj+YeoEgQzRkSy0SLxi1/Tb2luabOSwMWEfaQRdI9wmHi0VwDFAmiuSPJssxZXG5dXLlyBbGxsaiqqkLHjh1D3RzCJcqqajEmf4thcCvIG08DDtGqKKuqDblFsiVk5Fizu8Qw8WhJwZIE0dqwq//Isky0WEK9bEoQ4UKoLZItJSMHuUIQROuExDLRYgnGsimzjlFhEoKwR0vLERzqiQdBEE0PiWWixeK2v6baOsZw20rWEpaqCUINrfAQBNHcIbFMNClNLQbdWjbVW8cYblrJWspSNRE+k55waEc4BMYRBEEEAollIijwBmk7YjAYg7sby6Y86xjDDStZS1uqbs2Ey6QnXNpBGTkIgmjukFgmXIc3SOf07mIpBsNlcOfBs44x3LCSWS1Vh4OFkLAmXCY94dIORksJjKP3kCBaJ1TumnAV0SC953SlUAya/S5cyvLqS+oy3LKSxURGcD+PjvSErMRusCirqsWOkxVhc2/dxGzS0xrboSYxNgqjMjqHrci0ei5b2ntIEIR9yLJMuIpokEaDtVjkt9gcgoCCWZikuq6e+/mZyvCyEAZKOK8euEG4+OfaaQdZSRuxei7DzVJPEETTQpZlwlXYIK0mQpIwJC1OY5nVW2R5v/NIimU1FIisTMw6NjAlzlUrmei6eWU57CyEgH/W4WCuHoSLtVq/AhEq/1yrdpCVtBE7z2U4WupFhMu7QBAtCbIsE65iFsxj5reo/x2gDFr3vLKjya2PobB+iq7b0LT4sLBUqvH3+gRr9SDcrNXh4p8ragdZSbXYeS7DZcXAinB7FwiipUBimXAdK1EsGpBnDktFZvcOmLZsB9iY1NQDebCFhNnSt+i6hVMmgUCuT7CKxISj8AunwhUytEqwObg8uY3Ze2fnuWSTWbUQDbeMHuH6LhBES4DEMhEU/BUL1XX1uqHd3kDulv9lMIWEHasP77qFi6USCOz6BCOFWGsUfnYRPW/NxUrqFlbvnZPnsmHRy/ffcILeBYIIHiSWibDCn4FcPxgunJiJrB6xfgnnYAmJQK0+4WKpDPT6uC38W5vws4vV8xZOqxXB5EBpJfLWHfKJW9F7Z/VcsuvJHjMZ4We1pXeBIIIHBfgRYYXTACmeKFiyqdDvwKVgBWg1pwAhM9y4Pm6mEAuXgLpww+p5mzksFQV547F67kgU5I1vkX6ta3aXKC5dNt87s+eyOby/9C4QRPAgyzIRdjixPppV1vPHZ6+sqhYp8dFYN2+Uq6nhWpLVJ5zcQsKxPeGAXT/clnqt9JZgNf68d83l/aV3gSCCA1mWibDErvWRl3JNTb0sY+/pSlvHVKfTuueVHSi5VO1qye2WZPUJtwIT4daeUNPSnjeniCbR/gbm6a+nB8CDY9MCb2gQ0L8LlEqOIAJHkuVwDFVoWq5cuYLY2FhUVVWhY8eOoW4O4ZA1u0s0Kef0SADyZ5inUCqrqsWY/C0Gy1FB3nhXBUZZVS1ZfRoIdlGM5lh0w+02t9bnjfc+ewC8O380BqbEBbTflQXFWFFwqlmkZ6NUcgRhjl39R24YRLOCJybUS48Hz17G0k2FmkHSTjBOU0WSt+SlbycEexBvjiIhGG1urc+bKIgxEKHMYEIZCO/0bLx4jkVrDyGm7U0Y0jMu7NpLEOEMiWWiyQjUamYmJpgoGJXRGUmx7fD46v2a31oJ3+bik9gSCGY+2LKqWnxRfKnZ5ZulHLnuEwz/3eaUno3XVi+Ax1btazYTSIIIF8hnmWgSAi2v66RUMqt6p8ZK+DZnH89w8Um0245gZRZgz9jjq/eHfeYCPc0h20IwCdYz7LYvu6gsfbhMqtXX0Syew81S8wTRGvDLsuz1euHxkM4m7MFdDlx3CNGRERiaFm9rIHNi0fE3j2xzjCQPF3cDJ+1oikp+esJJ0PBozSsb4fIM2yGcc1TzruM92clYu/csd/twtYgTRDjil1ju2bMnfvKTn2Du3Lno2rWr220imgl23Sq4y4Ey8Pjq/ZrBMdCStGr8Fb7NycczXJbunbajqSr5McJJ0IgIZxEWTMLlGXZCIJPqYAWdigwSZuH7rWUyRhBu4JdYPnv2LJ566in8+te/xve//33Mnz8fI0eOdLttRBgTqCWRwQbHyzU3sHRzoSsladW/CacB1+2BMlz8J/1pR1NU8vMAeGl2NgY3k2Cm5riyESjh8gw7xZ++JZgWdJFBQkRrmYwRhFv45Uuxc+dO/OhHP4IkSfjLX/6CMWPGYNiwYXjzzTdx/fp1t9tIhBlO/IcBoz+wnnpZRr4qg4Vof8256ligPts8wsV/0t92uOVPyiYhCydmanzOl8zIwuQBSc1KECTGRiEtIRpFFdWtwp80XJ7hYOO0z3QK7zp6JCVtpuYzAMtmZze7/pMgQo1fYpkJ4zNnzuD5559HSkoK9uzZgwceeAA9evTAokWLUFISuBggwhN/gpGY0F02O9vYgUswVNrypyRtuAS66XFzoFSfY7gEJYayHepJyNLNhViQ26dZTqYYwZhUhTPh8gyLcKtPEfWZGw6WudJf8a7jkulZyJ+R1ewnkAQRDrhSlESWZfz973/HsmXL8K9//QuyLCMiIgJTpkzBY489hjvuuMONtgYNKkrijEALeKiLiERIEhbk9jHkRnZaECScg4R2nKzA7OU7DZ+vnjsSozI6296P6BzDpfBEU7ejqQrJNBUt7XycEC7PsBo3+xTevWW42V/xrmM4XluCCBfs6j9XUlpIkoSpU6figw8+QGFhIR5++GHU19fj/fffx5133ol+/frhjTfegNfrdeNwRIgJ1Bqkd6d4JCcDCydm+h5Gp/sL9hJnoLix1Gx2juGydN/UJadbWrq1lnY+Tgi3cuVu9ylmrmiifftj1eZdx3C7tgTRHHG1KMnp06exYsUKrF27FoBice7evTuOHTuGhx9+GC+//DL+/ve/o0ePHm4elggBgQYjqQNk1uwuUYL7AEgSsCC3jyMry8qCorAOEnIj04GZkNp6vDxsrerBpKWlW2tp59OcCUbgIeszNxwsw3MbjpnuO5xXygiiNeKKZfnDDz/E1KlTccstt+A3v/kNqqur8cADD2D//v04d+4cPvzwQ4wcORIHDhzAz372MzcOSYQBblgs9BYcWQZe2PSlbWtKWVUtlm8rMnzukRBWIiPQ4ESRdTo60hPWVvVgEu7+rk5paefT1PjrX8z7XbACDxNjozB5QKLpvsN9pYwgWiN+W5avXLmClStX4tVXX8VXX30FWZaRnJyMRx99FI888gg6d270xfzOd76DCRMmYNCgQdiyZYsrDSdaBoFacIoqqg3BgQDw0Nibw05kWKWbMkstx7NOL5jYB7uKL4W1VT3YhHO6NX9SBYbz+YQzekvswtxMZCXHWl57kQU3mHmvrfbdXNPpEURLxi+x/Oijj+Ivf/kLqqurIcsyRo0ahSeeeALf+973EBERwf2Nx+PB0KFDceTIkYAaTLQsAl16FuXXnTM2zdV2Bhuz4D0muNRC6uDZy4agSEZrW7oPt3zaQGDL6KE8n2AVzXALXvt4ltglGwsBmF97q4IowZy4mO3bbp8Y7veKIFoSfonl1157DZGRkZg9ezZ++tOfYujQobZ+l5OTAxeSbxAtiEAtOC2h8plo0DYr1PLDFZ8LhXJzO/+WRnOsSgeEv5+sqH1m1RvNrr0dC24wJy6ifdvp08L9XoULNKEg3MIvsfzUU0/h0UcfRbdu3Rz97sc//jF+/OMf+3NIogVjx4Jj1uk196Vr0aCdv6nQ52KiHvRF4mDx5L6YNCCx2Z1/S6M5LqOHu8A3a59ZhVBAfO3DOaDSrE8L93sVLtCEgnATvwL8nnnmGcdCmWieNFWhD7NgQTuFGppzeiRR9S1RoRZR8BEJ5UZCWaCmOValC/e0dVYTkIW5mYZrzhBd+3APqBT1acEucNISoCBJwm1cyYZBtEzCoZpYa+j0eIM2b/Bng364D/KhJtTPbXO8P+Eu8M3at2Z3ic9/XwKQ27+77WsfaJaaUMC7FgDw3IZjraLqox3CffJHND9czbNMtBzCZakvnJa0RcFFbvjE8ZZdO0W1EfotNnfXk2ARLs+t/v4ASiXHpvadtPt8hrvvv6h9ALSpJwF8eOQC1s0bhZo6r613IxwDRM3QXws15JKhEM4uNkTzhMQywcVKpDZV4ES4dHo8/zcAAfnE6a+hftC2EsTNbZBvCsJpcsXuT6h8J50e140JWDD7BV77dpys4N7vmjqvo1LyzQ0nBU6aE249P+E++SOaHySWCR/qjspMpDbl4B8OnR7PWrlo3SHIMrgBeHbaZvcakiB2RrhMrhihsnT7e9xAnrem6Bf07XPzfje3zAmswMnzG4+FzfMeCG4/P7T6RrgJ+SwTAIx+nluPl3P9LgE48iF2I9Aq1H6FPGulVxYH4FnRGvywQ0W4+QuHyneyqY8bqmfarfsdaj/3QHhobLpvIA/18+4vwXp+mnPgNxFekGWZEHZUBXnjUZA33tayJ2/Zz01LQTAtrFYWJavUVAy7Fp1wchVoiYSTRenQ2SrDZ01h+WtqC3uonumyqlqkxEc78lHm7SMc/Nydou9fHx57M+aMTQvrNougPpEId0gst2KYSPz66nVhR6WflTupLmVwXVh7CHXfetEpug2GpsWHRSeoHnAkAHNvS8ecsematiXGRuHBselYvq3I8Ht2LZxYdAIVMmbivrktJbsJzwc81O1ZuqnQ8PmCiX2C3ramdl8KhfsLbzLuj5+yXaEWTu8Wr399o6Co2VUuZYSb+xRB6CGx3EKx6tj1A40ErVuBVW5Sq0GY67oAYPF7SrlzCUD+DK2l2clg5MbApR9wZACvbyvCioIigxX8gbHpWLGtyHCN/LFoBSJkzKz1oUzCH2ohEY4FCETFYwb06NQkxw+2hV1/z5tSnLtpDbYj1Ow+X031HrQ0S2w4xKYQhBm2xPKvfvUrvw8gSRIWL17s9+8J5/A6dlb5LT0hBoDR71iSAI+sCFo7uUmtBmEr1wUZiqWZDW5WbVYfwy1hJBIzvIE3MTYK+TOMnfnAlDjh/t2uOmgmEAC+L3lTLCVb3Y9gC4hwXUYPh+CzYFnYRffczjPtxvPgpli0Emp2n6+mnLC1REtsOLlPEYQeW2L5mWeegSRJkHU5HSVJUDKpAVmWSSw3MbyOPW/tIUgNHatHAh4cm24YaGQZeHl2NuJj2rqSmzQxNgr3ZCdj7d6zwm28gC/gyNDmhmwTgNYK/dGx81i49lDjPvwURmVVtbhUXWewqDN4A6+Tzlw/cD44Nh0PcNw7nLTZTCDIkENiaTpQWqm5V/r74baA4AmtcLWyuWUtCxerObv2MZERpuLRyXvh77m4LRbN3m07z5fI7SxYEzazZyvUqzyBEA7uU3qa8/Uk3MOWWH766acNnxUVFeGtt95Cu3btcOeddyI9PR0AUFxcjA8//BDXrl3D/fffj7S0NFcbTJjD69hlQCNm3igo4rpdDO4Z51pnUFZVi3f3iYUyoKRiSUuI5rdZ9bcMRfB/erwcGw+dN+zHqTDS+ynzMHNDsToOT0Au31aEFduKDK4nTrASCKHwGc1be8g0K4ibFl+R0ApVEJ0d7EywrHzQA72Gbgz2+ndGdM/N9u/mCkAwlu1F77YdYS5yO1tZUIwnJ/f1u01m8J6tcJlYtRToehIMv8RyaWkpBg8ejGnTpuHVV19Ft27dNN9fvHgRP/nJT7BhwwZ88cUX7rWWsMRO5gavDMwekYI1u84EzT9M5OLAkAAsmZHlO6ZVm2WAK5QB58Fxej9ljwTMGpaKt3eXOArW44kQkYBkxwpELFoJhFD4jPLOk90PNy2+IqGV2b1DyILo7GI2wbIajAO9hm4M9rx3Ro9HAqIjzTORur0C0FTL9naEeXpCDHcSsaLgVFAzVKifrXB1R2qu0PUk1PgV4Ld48WK0adMGq1atQrt27Qzfd+3aFatWrcLNN9+MxYsX48033wy4oYQ99B27Bw2WZd12b+8qxbxxGegUHYlhaXEa31s3LFHMN1rPc9P6oVNUJIakNVqx9W0WuUbwkABf/mc75YRFOZP/38AkPH7HLbYHXr0ImTUsBX2TOuLp946Ytj1Q9wAzgdCUPn+iyZAkAQty+wgnQXYmNk5cLXYXV4YsiC7Q98RsAlBdV29ZHMjf/Tsd7EX3Wt0urwzc88oOUzFudS7+XM+mWra3U01z7m3peF2XMccro0nS5xVVVONSdZ2rk9PW7noQru5dRGjwSyx/+OGHyMnJ4QplRrt27XDbbbfhn//8p9+NI/xD37FvPV6ORWsPwavaxisDL398EoDW4uTWstPFK9e4n8sAUuKjUFRRDQC+Tkfd5uhID6Yt22FLML/wvSx4ZWBM/hZbbTYbsO0OvDwRsmpXqY3WuuMeYNbOphIPohUMWQaWbipEp6g2mDks1bG1W/T8ie7bsLS4kAQ6ufGeiAZj9uyz/fq7YuDWYM+79h4Ay+8bgofe3GO7iqWZhbY5LHdbvVtzxqZjRUFRk7tCqd1j7GY1srvPcL0XTUFLDKIk/MevCn6XLl1Cba11ZZ1r166hsrLSn0MQAZIY21i5aOawVLw4O1u4LRvkDpRWcss6Hyh1fg93FV/ifr54/RHcvWwHt1IWa3Ph+W80v5EAPHxbOnd/0ZE3CSs/8aoHsgE7kIpfVi4mephfdEtKh6S/jmrU98BJ9UWzKl6i+zYwJc72/XSjmqRVO53ABmM9PPHpTwVL3v79GezZtVfvSgaw89Qlx1Usec9Dc6poqX+G1H+70bc4bQvPPYbdc3+O35zuRbBp6vtJhDd+WZZTU1Px8ccf48KFCwZ/Zcb58+fx8ccfIyUlJaAGEu4wpKfRAqdGtKTtlYFpy3Y4DkwbnhZvuQ3PEsXzhZUBtInwcGf5XpmfBWJlQTFWFJziWkcCdVdwUtHv+en9W2w6JHYdNxwsw3Mbjmm+U1sw7Vq7rSyhovtm5366aS1zy2JrcJniPFOi4kD+7D+QwT6ndxdIUmPgrQxgxbYivyxv+ufByfUMpXuA/hm6JzsZ7+47a3imQukKJQN4aVY2Ore3l9XIzj7DyfWgqe8/pbMjGH5ZlmfPno2rV6/ijjvu4LpZ/Otf/8J3v/tdVFdXY/bs2QE30owlS5Zg2LBh6NChA7p27Ypp06bhyy+/DOoxwx07FlU96iVtPSwwTb0/KyvdwJQ4DE7tZNlWvSVKZLV99ZOTWJibaZjlD02LN7TZA/iEMsC3jqgt705h15J3rQDFkrxsdrbPchbIsfzBLQuqXbrHtjNkFfHHgmnHEiq6lmbX2G1rmVsWW0BraX133mjX9svbvxOrtB5RtoeHxt4csOXN7vVcs7sEY/K3cFelgg3vGVq796xwFaQp3nfRdRuSFuf38d18tt0mVPe/qftvIjzxSyzn5eVhxIgROHr0KCZOnIhu3bphxIgRGDFiBLp164a77roLR44cwfDhw5GXl+d2mzV8+umnmD9/Pj7//HP885//xI0bN3DnnXeiuro6qMcNV8w6lJnDUrEgtw/0elm/pM0TgWpR+9rWkxht0WmVVdVif+lly/bqO+L0hBhD+wBlYB6Q3Mkw8POWyh66zZhH2mp52Ckzh6Vie94EPJyjdQ+RJCUn9OQBSSHpXJtyQGHHemzVPgCBu5vo76VHAh5woXyvmbXMH9xenmWDsROXEn/2H8h+eCLKA2DygO6adzKndxfHEzU71zPU7gF2XK/c7mOsCIabQLi6HrB0nOQeQoQKSdZXGrFJbW0tnnrqKbz++uv45hutj2n79u3x8MMP41e/+hWio5t2RlpeXo6uXbvi008/RU5Ojq3fXLlyBbGxsaiqqkLHjh2D3MLgUVZV6wt0Y0RIEgryxiMxNor7vUcC3p03Gl07tvMtb128cs0QYMf28/7+c1iiS9WlPgZjx8kKzF6+07S9rCNm1i62xLb9RAWWNQQf+toJ4MXZ2RgiyAVdVlXrWyoDYHod3KasqhZ7iishSXA1V7Wd46qXJK3uv9vH1h9LAvCru/vhO7d2C+h4ZVW1WLm9CMu3FmkC3fy1igbruqifOTevr5P9qp8BAL6iISybhpvt+o+/7jcUGRIFB0sA8nIz8cjtGbb3b3beov5k9dyRGJXR2a/zcQLvGdITzD7GjGA8h8F6tv3BLB1nU93/YEFZR0KPXf3nl88yAERFReE3v/kNfv3rX2Pv3r04c+YMACA5ORlDhgwxzZQRTKqqlAIF8fFin9nr16/j+vXrvr+vXLkS9HY1BVb+ZqK0aRsOlWHFtiKN7x2vtDMA5HNy2qotKuzF50bQS8CLs7KREh+FmjqvpiPW+wNO6t8dmw+fhxeNEd6PrdonFE56P8imzDmcGBuFKQPdG6TsdJ48H9yU+Ogm8zf8ovgS11/yqfeOoOZGPR7JyQhoIFixrch2lgUr3PTd1e83GM+U3f3yiuuob4mbmQxERYbU6e70wWZLNhUCEvBIjj3BbHbeoc5MwHuGpmUnaXyWgx3Mx3uXgiW2miqrjhV28rk3VyjrSPPCb7HMaNeuHUaPHu1GWwLG6/Xi3//93zFmzBj0799fuN2SJUvw7LPPNmHLmgarAUUkYJkFD2gc/AryxqMgb7zGurDjZIUwndv/fVaMzUfOa158nkCZMjDJ8FveEusHRy7g3fmjUXqpFk+8vc9xrthwCswIRADzOk/RkvS6eaOaRFCwdvKQASzZWIj9JZfxge55EJ1LU5SvDqfnwQ3sFAoJdJKhxswNwSzf9dJNhZg6MHCXpGBNeJzAS8m5rsHS7t/6rD1e+/Qk8jcVGlZZmqvYciLwzXJ8B3L/Q23RpYInzY+AxTIAnDhxAuXl5ejcuTN69+7txi79Yv78+Th8+DAKCgpMt1u0aBF+/vOf+/6+cuVKi8jaIRpQAODvB85CkiQsnJiJFzZ/6fv+gbFpWK5LpC+KwDfLArHxcGN1PTPBzUMkjmrqvIhvH+m3cAoH60igApjXeZpdr2ALCn07RWziPA/6c3GaUzmQ4hVAeDwPbmE3faFbKwtm7z4LDuYVE/LK7hXlCIcJD3uG9BZPFgTttth5betJjdubyJLvRGyFU0YRXn+obp8ox/e780ZrCmm53YZgE+5ZRwgjfovl+vp6LFmyBC+//DLKy8sBAPfffz/++Mc/AgD+8pe/YNmyZVi+fDn69evnTmtNeOyxx/CPf/wDW7duRY8ePUy3bdu2Ldq2bRv0NoUCnvVj9JItvk5dApA3KRMDkjv5xMcbNhPpJ8ZGYeHETIPPMo96WcaGg2WYPCDR0qfMShzxrOHRkR7sOFkh9M8M9oBgZ/9uCGBe52l2vUZldA6qoHCaY5qhPxera+Nv8Qo37nuorU52cJK+0I2VBf09Ue+fBQfn5Rr7BrdXNoI54QnU4um22CmrqhW6vfEs+XaOH0qhaKc/5LWP1xf4K5TDxaIbarciwjl+ieX6+npMmTIFH374IW666Sb07dsXR48e1WwzZswY/Nu//RvWrVsXVLEsyzIef/xxvPvuu/jkk0+Qns4vXtGaYC/9ntOVWLhWu1wuQ1ka3Z43wbedE2tkVo9Y2+14bsMxPL/xmGWHbLXEumR6FvLWHfItdbLczyL/zGAOCGVVtVhZUITl26yDz9wSwHqsrlcwBQWvnTyLop4ISfJNcNITYvzKqWw10Llx38PB6mQHkXhV47Yfrb7Kpj7u4JHbMwBJ6V+8cvhkUrCDGxZPt8VOUUU1173DA3ArV3okmB4/1ELR6p0Xtc/uCqUbbWgqwsGtiHCGX2L5D3/4Az744ANMmDABb731FpKSkuDxaLPQpaWlISMjAx9++CEWL17sSmN5zJ8/H6tWrcJ7772HDh064Px5Zfk3NjYWUVEt78HjRb/rLSHqjp+HfmlUPwhW19X78oXqEVm0cvt39/mo6o+1aO2hgHyMc3p3Magx3nJvoMuTanhWJt51Ndu/PwJYPWCbdZ6hWpIWdfKXa274/Cr1eCRgWnYS7nllh+/cFuZmOna1sEoBF+h9D7WYcIr6GTh45rIiUqFMXubmpGPOmHTX2201EXskJwNTByaZPpe8extKa77ovmd27+Bbtdp6vNyWxdPNtov62oW5mb40g2ojgiwDW4+XCyd3oRaKVv2hWfvcynMcThbdcHArIuzjl1h+8803ER8fj7/97W+IixMvh/Tt2xcHDhzwu3F2ePXVVwEA48aN03y+cuVK/PjHPw7qsZsaUfS72hJix6eUZ4FIjI3iDgi8rBP6qmMLczPRKaqNxk9VjRfAyoJiPDm5r+n5iQbioopqS8slENjypBqelSmndxfhdRXt3x/rgXrgs4Ns68q4i6iTT+rUDo+v3m/Y/tmp/fD0+0c0YuSFTV8a/OetXC3MBjo3hECoxYQ/sHdmVEZnTB1kLlKbuk08ePcWQJNZ851MwtjqlT7TSDAsnjy2Hi/X9APMhY5lF9EbEaz8pkMtFK36w6ZoX7hZdFtSHEVLxy+xXFhYiLFjx5oKZUCx7l68eNGvhtnFzzTRzQ6z6He1BczKp1RqGIz0L6gTqxoTS3tPV8Iry0iNj8Y9r+wwbf+KglOYMzbNr47BiX8mb3nSSYfLuw6L1h3Cs1P7CY9vtn+71gOzgCHAuILgdNm4KSyMrJqi/trHxfCDNAf06GQQG/76MgNG33anA22oxYQZdvIpN/XA6/T54r5baw8Bqmvu5kqQHieTMACad1GPlcWTlwPdzrVi28VERhhSpkkApqqyCfGMCGaTu3AQimb9YVO1r7ladJtDLEVLxm+fZTsBcmVlZS02kK6psRLBrJMUpYd7dmo/xMdECotmiKwrLEhPv1x66EwVlm4u9Fm5raYsgUTF6ztRqeGA6mPqqxD62+GKclEvfu8I9zw9gC/jCPPH5VmY/Q0YWrm9yJADO7N7B4MPt51AmWD73ooGuyE9xRMY/bXxx5fZ7NhOnjezfYRLBoFg51O2gxO/fTWiktn6l8qNlSDexNHuJCzQwEl9e+7JTtbkYxZdK819loyrS15o+1B/JndWQrEpnnOz/jCndxf8/t5BgAwMSQtegafmZtFtLrEULRm/xHLPnj1x8OBB021u3LiBw4cPo1evXn41jNBy6GyV6fcewNf58QZ8qxdLZF1RB+kB4Loi2LHtewB8XX3dV57UaYes96surawFZHALnARiObCyYrPvPBLw0NibMWdsGrYeL/dV9/K3I7ObA1stktXYCZRpCt9b0bW3K2TtCADRQOeGxYi3j1AMVHoLI29FicEstDFtbzKtcOmGCHLqt69GlAYMDgWfGrvPupNJWHSkx+dfz5CgCFirwEVee9RVD0XtM6wccm407z3Qv1cLcvugqKLa9z0P0fsTakEW6uO7hdsTjuYWS9FS8UssT5w4Eb///e/x+uuv4+GHH+Zu89JLL6G8vBw/+clPAmogobwsSy3StT2Uk+4TSinx0Vg3b5RBRJrBOl6eGOMtl/LwCUkAY3sloOCrCkMFPpGvtR30ftWS1FBSl1MhzF/LAbsOoknBS7Oy0bl9W9tuA06Pqx74eDmwRV5HdgNlmqJz5V17u0I2UAuxGxYj9T5CMVDpLcl2JqNeiCtcuiVCzOIh7DxfonsLwNWVIF5b7FphZcjo2rEdt512nl87qRV57bPzuwUT+5i+V74gTz/us8j9LDoyAkPT4oPebzh5z8LZHSEYgj/U/Tmh4JdY/uUvf4k//elPmDdvHo4ePYof/OAHAIDq6mrs3bsXf/3rX/G///u/SEhIwGOPPeZqg1sjln7IAOaMSee+qFY5jtXwsk4weMuleqYOTMJ3+nbzLZ+VVdViT3GlpgKfehd2hYfQyiYr1eIgN6StcomZw1KR2b2DIT1dhCQZlgbd7Mj0ghIw5sDmoc+c0ZS+t04GLrtC1k2fQrv5sEXbBHug4vm2WlmSzdC/U26KfbN+iD1fVtdbdG+t7re6D1D7adt91n2T4LWH4EWj+5SZ2xIveM/qmtmJr+C1z87vBvToxP2ctemHKz73+z6L3M8eX70/aPnMrY7Pe8/C2focrIl1OMdStCb8EsuJiYlYv349pk+fjhdffBEvvfQSJEnCO++8g3feeQeyLKNTp05Yu3YtEhIS3G5zq8OqI83LzQTAT52lTn9k9cJ+UXxJODjzfCX1rN9/Du/tP4f8GUoHlhgbhfj29nyt7QTliKxsSzcVYuqgwEvqqhmYEof8GdYWTrc7Mr2gtPKl5FWzaqpAmWAOXG5YiO20T/985eVmaiZewRyoeO1LiY/mvi+sDTx/fT3qd8pNsS/qh5jwtJNNRySyzO43z/XDIwELJ2Yiq0esMKsKF9aJSI0fmeX3dWJsYOehf2fH3JKA7ScqTF049L/TY/XMie7znuJKTBlofZ/Nxhi16APgl7+6P8fXn3O4uyMEa2LdVP05YY7fFfxycnJw5MgR/Pa3v8XGjRtx6tQpeL1epKSkIDc3F7/85S+RnJzsZltbLaKOlKVteyQnA89vOMp9UZl1VD248IQzG5BEsPGFjTUeNFibOdupO7D0hBjTpWTJJJG+XSubPvDFCWYWEjsWTjc6MjttWLm9CMu3al0yzKpZidoeiEVIn5HBzsAVqiVTOwMr7/lasqkQkOBz7QnWQCVq37p5o7iiQe1WBaDRd/9SrWblhm3PtuO9fxLMi1eI4AlB5rcPwOe3rz6fQINORa4fXhm+aoGsH2RVSe36EptlEApE5Ojf2W1fVUAC8LBF7muNS8XZy3hhk/UEQG1x54ndJ97eh+q6by2vs5VYr5dlrCwoxoqCU375q1th5z0Ld3cEN981Pc01g0dLwm+xDADdunVDfn4+8vPz3WoPIcCselZZVa3Bt5XBXlz94KIeqMx8EdUvPxPdL83KRkp8lCEIhuGoAzMxkdktrczLGx1IKik1diycgXRkdgXEim1FmkvlkYB180aZln3Vtz0QS7D+tw+NTbccuEK5ZGpnYBU9X0s3FWLqwMaVCn/vrz/uHTV1Xlvlfdn+BqbEobruW2diXhJ/ZYXoWuw4WWF6vf21CtrpA7yykre7IG+8I19idQYhvchxY/VA/c7KAN7YVow5Y9J93/OeD/bOjsrobFnchZt1Y+9ZjRHDiZhl9/ajYxfwn+uPGL5fvu2UaRq9QAWc1XvWLN0RAnjX9Lix2kb4j19ieevWrejevTt69+5tut1XX32FsrIy5OTk+NU4QkHdqfKWBe0W7WDoO1DRgPTTO27B7z86Yfht5/ZtUXj+G9vBZmZtkyG2CvMygERIEnJ6J+DjL8s1bVJXrgoklZQTtxU1/nRkgUTye2Wgpo5n2w/sWHZ/u2JbkWUFvlAumdoZWEWrHl7Z+Eya3V+rao+8Z9CsfaMyOjsS52Yig/f+yZzzcwLvWgRSnc2sHXZzrFvty6x9W4+Xa7aVEHiZcKvzDXSiznu/1u87h2fv7ofF72mFrhMxmxgbhZu7tOd+J7oFbgpW9URW/Tf7dzi7IwTjXSPCB4/1JkbGjRuHpUuXWm73wgsvYPz48f4cgmhgze4SjMnfgtnLd2JM/has2V1i2IYN+k6ol2XsPV2JHScrfEt4aiIkCRMyu3I/j470GBLmq7/nBZuJEHW0ogwgPxqZqhHKjEXrDqGsqlYo0ljKOoZoMLt72Q7Ta+0mVuWbGbxr6HSAsnssu7/1QlmCj5AkX3vU993O8cqqarHjZIXh3rgBG1jZdeOVD0+MjfL5+6vxSEDF1Wu22sV7P+08g6x9ouvHrIt2B1nR9m48O3aPf0+21u1uWnaSaT9gpx2++2hxfKt9ia43AOStNfZlzD/XX8zO124fZYbo/YqLjuT2twfPXA6o7R6JbyTVB0oGitV4N3NYKgryxmP13JEoyBsfNsF9QNO9a0Ro8EssA62ncl4oMetUAxUakqSkmpq9fCfueWUH7slONgwkrMCH/vPqunqupWfx5L6GDkw/SEmqTtfMMiCydr/52Wnu+TBroF1RGBMZAclExDsZwNT3QnRfeJ/zJjlmkfwiYWWHQDpy0W/njE0TDlxWx7MzCXQDq/Lhj9yegUWTMn1tZcUgHl+937Jdovfzi+JLtp5B9cC/bt4opMRHc583O8+XCDeeHVFb9J+/u++s5rP1+875tjNrh9U5zRyWinfnjxa+r3b3xRNae05XGq2BAPaerrS+GCbwznfBRCUHsuj52HCwzPZ9FQnalPgoLORMAF/Y/GVAz8yS6VnIn9H4mUcCZg9PxfZFE1wTrHYnEU4nkk2F2+8aEV4E5LNsRWVlJdq1axfMQ7RohFXdVIEWHgl4cGy6qavD4sl98a0s+wJG9MuRbAmPBRFFR3pQXVePA6WVvpzNZypr4ZVlDE2LB8AvLTxJVekPaFyezundBevmjcLu4koMS1N8Lz8qvIiE9pHI7N6BW/nO7vIrwyMB0ZEelFyqsVx+Z0ugVvM90fKletldk/e54Xvm282WVkVLrk6WfwMN8DAEZ4Gft9XOb3lWUCe/aQoXDbPy4fpjPJKTgakDk7D3dCUeW7VP4+dv1i7R++mRJOEzqHfZSIyNMs0iIarex7ZjAWpmbkNuBQeZuQ7YcbMIpODLwJQ45OsLcEzsgwE9Ojnal961QWT0ccMWpA/YU+dA5rn/qAtA+ROQ55WBe17ZgYfGphu2d+pXLHpmLtfcQH7Deby9uwQDU2JdE8vhHsBnBwrEa7nYFsslJVoLy9WrVw2fMb799lscOXIEH374ITIy3Mt/29oQVbxSRyR7ZSUXryjjhFrEsoCR9w+cxepdpZrtWHBRyaVqQ7Afb5AWFRdgwlctANg+ZIjTv+kHN6vobDUSlOAWFnAoodFCqBd2ZsGMhv1yAgfNSg+rd6n2gRb5RutdWSTJfPk30ACPmcNScbm2cbBburkQnaLbuCq41GJQ9Bu3B0Wez7DTYyTGRiEuxuhzaPYbkR/s4J78kus8UZzTu4tw4gBoM47on6+8dYd8aeTs5MIN5NmxmuA4yXcsehetJidmz6CoqEZm9w6mQbBD0+K5GQyGpIl/4wTWRn0OZEkCPLIxo5DTgDx9PnivDCzfVmQol+2PO4D+mSmrqsXSzYW2J5NOcTuAL1SZeCgQr2ViWyynpaVBUq2DrV27FmvXrjX9jSzL+NGPfuR/61o5POvcg2PT8Lou84VXVtISvbGtWCMsRRbAt3VCGVBEOPNF1osMnggsyBuvSdqvLvmsF5Hqf4s0Kq/jFRUH0fPC97Kw4B2tFdEjAy/PzsbgntZFRETMH5dhOiBb7aZelrG7uJIr2nif8wLL3IT5gcuqQdtKcKmxGgRElj2nwWBOEB3Tn2M4/Q3z01WXM2Z+urwCM7zUar+bNVAo6mXIps+qWgx5ZaXKZmb3DujasZ3ruXCtJh9Wqw9uTGiAxmeQuVuw/YmCYKct2+HL+y7aX/6MLJ/fsgQgf0aWq+8gr21yQ/+06XAZ/nHwvOY7JxPH6rp6rhsJZKPBAAB3FS+Q83DT8utmAF+gmXhCXSUw1McnjNgWy6mpqT6xXFJSgujoaGHBkcjISPTo0QMzZszAo48+6k5LWym8QXeFrqpbhCRhzhglhycvtZwaUeGRURnxWL/vnC0hyZLdx7eP9OXcVQfJ+LuCyet4eYOBmgl9umiEMsMLID6mrW2hdle/bth4uHHQGp/ZBb+4S+v750Ros/0OS4vjpqUalhbnl2AMpBMVDdqMQCxFVuVy2fFZu82qqTk5pvq5Y+Kftd+fgfehselYsa0IXlj7HIr8dH9xVx+fqGO/FaVW47lsAEpA1tRBSY5ckbxQxCHgX6VMM+xMJNjklrlbMYuumxMa0f5yenfhXisZ9s6dCUuzOAZ/EZ1nj7gog1AGGl3K7BATGSH+Ugaem9YPd/TtpjFmOMlxrX5nmyJ1mxtuDFYrFlZ9aKirBIb6+AQf22K5uLjY92+Px4Pvf//7+OMf/xiMNhE69BY9O8nbRR2BJBgNtp+8hO0nL9lqjwT4CiF4JCCjS3u/BbIaf8rAbuFkxtDvS9858q7fzGGp+M3mQiz75CQA4NMvy7Fmd4mmk9r+VYWj81kwsQ8Kz3+j+Yz5JQ9MiRNaJUUE2ona8QNXB6I5EeVm5XLVkwVmufP9wcx5KuxOCLjBWbISnDV5gNG6a/faShLwcEOxDbPfiAK19p6uRFyMtv1mLhsLczOVsu0qXtj8JaYOStJMKuwgurWBWgDtTD5EItZMuDid0HAnZWsPYfuiCVgyPYub2cLs3N1OIclDdJ4ll/iZaJjvsZ0KiNV19cLjygAWrz+C6rp6n7+0+hzNJhCivsaf++V0ch+oG4OZBdyqymSgKTYDtQaHOuUmIcavAL+VK1filltucbsthE1EIsCOmBrS02jptEJq+D9ZVqyAMqB5mb+6eDXgc+JZF1nns3BiJpZuLjQVeaJ9ia6J/vqVVdXi1U9P+vbBs0a88slJ7vF4+agBoEdcFB5fvU9zrZlfcllVLdbtFVsl9fjbiZpNFDwN91Rv9T549rLPx9KuKDer1Cjr/p239hAkCdxz0Q9mZlUnK2vquG1RW8vtDLx6C7UsA8sLTvkq0/G2/2NBEVYUFBm+Y1lm2Bxg7m3pmDM2He8f0K7aSFLjM1rxzXXDftjgPnNYKmLa3oTHVu0zbPNwTjpWbC2yJaTdsAA69Rl+ct1h/P7eQaZL904tiaI0hisLijFnbJowHkJ07iJhpa586oZlj3ee/zh4Trg97/12YlFnyIBGKKvPUT+BUFcDFPU1otUDHqGykIompno3Q9419tfVxK1zDcTVhVw3gotfYvn+++93ux2EQ3jBF3bK+xZVVCNvUia3A9Xzy7t6o+1NEYiNugmllbXo0r4t4mIiuQO3XSQAuVndsenQeY21ceGkTE3n8tqnJ5G/qbCxVHduJr6+et0nDkQDhARg+f1DcEff7txlevU1sfJlrpdlrN5Zgl7dlCT9ooF4QmZXvLTlhKFz9spGn1Pml7yl8IIjC5g/naidicLW4+Uad4gFE/s4tkI5RYYx2wCzyOqfYVHVyTW7S/AUp8oYAJx1mE7RykKtZs3uEq71EmiYVKomHzKA17c1+g5rDwBER0bgQGkl3uCIbg8aBd6QnnyXnTlj0tHG4/GthohwMxeuaPIhej4h8zPnqMWrE0uiaFK2ouAUsnp05P7mobE3C/cvWm3h9RmAs9UWPfrztDJc2KmAWJA33jIQ2isbA6tFGYJEY4JdyywjlBZSkSWfl/JU34f642ri5rm66ZpErhvu4lee5c8++wwPPPAAduzYIdxm+/bteOCBB7Br1y6/G0fYxyq/sDqv7dJNhVg4MRPLZmeb7vM3HxzHcxuO4ZfvHMKLH53A4veO4J09ZwJqpyTBUIVQhlKuluXT/O8PCrFkkzbq+oVNX2LOmHRsXzQBq+eOxLvzRnOT78sA5r61B2t2l+CPBUaRIirEISqe8uKWE3h89X480eBOoGdi/+4YmKIspbPfs845NT7a8BupwR/RSiDZaZ8HwNfV14W5eUU5SxNjtXlK5Yb9yhLw9dXrps+RCKdVJPXXRTS5YKjbr08Lp0f9LNnBbvowq+M+PiHD0rKu/uzx1fsxbRm/ZPxDOemawFxRQQ31agiPYOTC5eUxFuXVHpLGfzcCcQcZ28sYK6OIBIn7johWCNj+1NeW1wfUyzJWbi9yPS84Cy4UFW2yWwFRnT/6jfuHCPspUf5fOxmCzCyzvHctkCJIbsDLqW0n17zoXTN7Xt08V3+O70aRG8IavyzLr7/+OlavXo0XXnhBuE3v3r3xl7/8BTfddBOGDx/udwMJe4jSzLHcrnoLa/7mQuzIm4ClM/h+fiI+EfgI28UrK350eljn8v7+c3j5Y6MAYN+rRZ7IosL8GHnL03pBql66MrPQiK7PB4cv4LVPT/rcRCQo1lkA/CweMlBaWWspkPTorSXMUvTYqn1cS4IdSzTP/eB1G2WsedY1J3mxJQB5uZl4YfOXGsvP0LR4032wwg3dOra15XctcmfRt99u+jCzAM8IScIdfbvh5Y9P2nYXAsSrFXPGpGs+U68IsDzoPJ9pPf9voLkfvBP0ft15uZl4JEdJDSqy5m09Xu5bqWDvRiDCvayqFgWc2AGPpLg9OQnQZOivLUtBqd738q1FXGtzoNdWk4v5zGXDO2HX4qm2WudNMvrAf3jkgi+PPvsNy4xhFbjsxDLLCIc0cHpLvl0feaeuQW6fqxuuSc0tP3VzwC+xvGPHDgwaNEiYDQMAunTpguzsbGzbts3vxrU2AvE5Yh2BPivF1uPliGl7k3CZmb2Ye4orcbm2DrIMPPXeEVPx7NTn2Q7McpHPKXHNKPiqXGOVzundBb+/dxCOn/8GL27R+gyL/DhnjUjh+gAy/1JWPOW5Dcdstbteln3uIoByXZaYnIPc8H+GiY1KIImeA/W9YgGWAH/wttOB89wPAGBYWjx2FjUGe7LAQ7OlPv1AZEWn6Daa1IPqCZBZQNtzG44JizqIzpNhltouf4Y2O8eShvRh6nshmhCwUtpshSF/Y6Hj94Ptl7WL9/4nxhoLmNi5DsEIPJJlKIJMVqogAvzMPep0eTKUwMWRN8dzg+fstFO0gjH2lgSfyPXYDNBUoxZW+kwtD45Nx3Jduk63U6ax1Z6pg5K4IslJMGRWcqzhM5ZHf1RGZ8N7sHBipvA5Wjy5ry9Pf1lVraU7h932Onkm3XQxsCtE1c+DVVv9CVS1wqlrUrCzlBB+iuWzZ88iO9t8CR8Aevbsic2bN/tziFaHGx1CTu8umtFThpK+6/8NTORuf6m6zmddmDIwCYBibbAa6OePz8Crn5zyWThZ8F+EJGFadhLW7T3reEmeWS7Mfrfsk5PoGN0Gj+RkGK6XXW5NVPwaeTmTX9+mBG0tnJjJFUUSoAlMA8S+0yLY0rSoc7V6DhJjoxDf3tqSYKcDF7kf7FIJZQB4d+9ZTMrqbumXxwaiDQfLTCcbMhr9LfUuOWYBbQxm2WRFHfTPIG+gOlBaaVhdWbT2EGLa3oQhPeNsV5fTV0F8KEdJ2ci2X6qaOLFXUWr4h+gxkWBdlhvgL7eKroNHAh4Ym4a/fH4ayz456fvMzMfUTBCIrI9LNxVi6qAkzXPH/i1KlzftlR2G9tjt/3jCQAJQcKJCc13eKCjSuF84njD4bh6Q0KFt0MQIr3CMqH12hF5ZVS0uVdcZRC0LcuStMr6w+UvMG5+BZboVPX1VVicVR83aa7ZCwTsft32fnQhRu89lKCv3BUOsE0b8Essejwd1dfxIdDU3btzAt99+688hWhVudQgvbfnKMNh6ZeC9/WXc7Z9+/4ihE4iJjDC1Vs0YnIxf3JWJH47sib2nK+GVZaTGR/vKZN/zinkBER7qynVW4nPppkKMTI83XC+7LF5/BG0iPEiJj+b+zisrx5g3PsMnMgBtyjNNyd3cPraCJdm5sU6Mda7sGg5Ni7f9HNi1JFh14OeqrnHbqT8VL4CH3txjKyAxMTYKkwck4vmNx/x2leAFtBnaKCtFHeJj2vrOW3Sea3aXII/ja+yF0Y1F5MepDqjiWcR5fp8SgF9P64fYqDZIjY82XbFQr0yIUpeZFbdQX4eV24uwfGuRwRoqep6sBEFZVS2+vnqd2y94IS6kIwye011TUZVLUf+nd7XgFWpSP1/683twbDoeGMt3eeLd9xc2fYmFE41uQ4FY6YsqqrH9qwq88slJR1k3zIQer7ooQ5YVsXvi4lXuezz2li7oGNVGU5J75vAUfFF8yZcn3WnFUV579ZNW3gqFGisXg2BmgHA6LtsR4cFqL5XZDj5+ieW0tDR89tln+Pbbb3HTTfxdfPvtt/jss8/Qs2fPgBrYGnDqc8R74V779CRW7TRW5jND3wlcrrmhKWfKGJ0Rjzsyu2GoKlUQLypaJEDttGPDwTJMHpDIXfLUb8urfmcXZm1nAYJcwQzFip03MRM94qIgy4r/KrvW+k6pU1QbU79vvQWSob+GD45Nt/Uc8CwJC3L7oKii2ve9elveM3SgtNLg12gG79wk2PP/5oksq8p4eguuDOPyr746o5n4MbPY8gZBs3cyLSEasu6MRCnNFr93xGdF5a1Y8K6NyPpqlqtZLdpX8LJv6M7BalLAroVVlgQn91F0rn/bU2rrudeLXuZqAfALNTFLqv78lm8rwoptRdzKfqL7HuGRND6//ooR0fU0E2JmAkuU7k1/nWUoKymyXkU3kJYQrbiBDEzCyu1FeH1rEVbtLMGqnSU+FzVem524oogmrYBxhYJhZhgIdgYIUR51f91v9Bme3G6vE4s54Ry/smHcdddduHjxIp555hnhNs8++ywuXryIiRMn+tu2VoOdKF2GOqsFi8ouq6o19fXVI4r4zhdYSHeeqsSkAYk+oSwaYGMiIxy5RKh5bsMxjMnfgoQObU23U1e/8xevDGw4VIaFEzOF28gNy5ODe8Zhii5IivkXqt0PXvheFnc/z03rh+2LJuDJSbca/DP11/CNgiJulgh1cB3LRKCO9mbp3uxG6q/ZXeKr9BYQqsbqn0sAKMgbj5fvzeZWRVswkZ9PmqE+v+2LJiB/hrMIcYbdqov66HXRO3nw7GVuVgRRNhW1FfWFzV9iYW6m5jzyVJkiRL9TZzExi5Qvq6rFPw5aV+E8eOay799mkwKrLAl27sPMYalYkNtHqZAn2ObPnxsn+fr+T/S+XLxyDSt1Qlmdw1p0/5kF305WD0Dpn+55ZQdKLikTUn1GEFGWEDVW15OXQYHX3/O+u1uQVUWNF+ZuPowVOmOFDBgs94AzVxSrSStbodAjeuYBBDUDxJrdJfjp2/sNn/vrfvMbToYnyljRvPDLsvyzn/0Mb7zxBpYsWYIjR45g7ty5yMxUhEdhYSGWL1+O999/Hx06dMDPf/5zVxvcErHrcyQSqb+bNdC260OEJOHRcTdrXAwAc/cH/WxaNMDW1HltBXnl9ErA9hNfc7NYLN1UiPnjMri5Y9l1GZgSZ+s4ZqzYWoRn7+5nuk1jWW/zZTNm4eDRJsJj2wfUKyuFJt7YVuzIl5kVEGH7MFsqtEp/5gRZbhzgRC4L8e0juc9Vjzhroau2lPCyQbCBxmxZ08qtiCFKIaWx3lvkoNZbw/VBimw/egtlp+g2lr+zKuJhZQFWw6oDJsaalzDec1q8giMBeP2+wbijb3fTY5VV1Sp+3A4eOLUgMsvYoC4eommb3OgeYJalhfd+s/sosv7mrTvk8z9n7yEAWxZOq4kbL1OPyOqvPqZdeCs0jGVbTuD7Q3twM16IWJBrPuFVYyfjhkiE8p55kT+8G0GXokkNy0PPW8Ez47WtJw3+4G62l2ga/BLLSUlJ+Nvf/oYZM2bgvffew/vvv6/5XpZldOjQAX/729/Qo0cPVxra0rHyORJZjZRKbJKtQLPnpvVD9fV6xdVCNzguyO0jjOL3SEDF1Ws+65YoTV10pAc5vbvg6al98fR7R4VL9/9xZ28s/V47biCYVwZXKHskYN28UT7rtigzhF28AMo5ldP0sAp8Il/OPacrTV0wRMJVJFLmjFHcNfTVBUWDplMXHruWVh6iSHizNojEymOr9uHq9W9tL0Oy5eZDZ6s0qcgACO8PE5B2hDJvcsqyrUBW3HCsrrVVCjKgMZvHkulZvuBGq99ZFfGwkydX1GbRRH3r8XIsXMufAALKNX/ozT1cVwY1Tp83ln1h6/FyXyYNkQsLa4cetR+1mfiVAF/foX9+ROJe/blXhs9aqrcY8t75Q2erTM99YW6m5jdmz5sMcU5yoDHYev2+c5r7ern2Btf96s87S/DnnSXI7d9dWQWwcc8GJHey3qgBs0mL3ZUiteuTvxkg7GZc4bXz3hGpvhShdt0ozFZ9zfLqE+GHX2IZAO644w4cPnwY//M//4MPPvgAp0+fBgCkpqZi4sSJ+PnPf46UlBTXGtoaEPkcWVmNzlTW2rK0svzG6i08UERo147tuJ2oBKVDenz1fk0HoT+eF/At7Zv1szKAe17ZgSXTs2wFgjGYr3LXju00gR2s6IHdIDv1ed3RV6m8Z9VedvxF6w7Z9uVkiISr1WqC3UEzJjLCMLiZDRpmZanNuH9kT7Rt4xHmsOWlwqu4eg1pCdFcscKWwe0EsYqutfpPvUgRBdyxbCZsgjgguZMwKFCTXis3E0mx7RxVoxuU0gl7Sy4bzocnqNS/s+uPzhAN7hKAF76XhQXvHOJOchi8lG+jl2wx7lCHDMXSanYPnTxvLPsCYFypWLq5ELn9umPD4fO29sM7v5XbixorgDa0ST8BZcGGdt8PkcWaV0p6qYmr3KSs7oYAN65RQmoUWKLrqk739ou7+hgNMA0reLz0jJsOn8eglFjsLzUX9k7TEoriLETvnxrRqtqjt2f4AiTtCO5AMq54AKzeVWJ7BY9RVFEtnHjoJ0dEeOO3WAaAHj164Le//a1bbSE42LEavbD5S02U/sGzl/HCpi8Nwllkhamp82LP6UruvkWCZOawVGR27+ALRBLtn4d6md4qoE/NcxuO4fmNx3BPdrImPZ0/4g8S0LVjO01+XTvtXrm9CHPGpNu25Kmr7KlFfkxkBFLio02DhtTb8kTawbOXDUvcwUob9Nbnp30WXH0OW0MgV4N4V0+wfj9rEB5fvV+zT6tlyLKqWvzr6AUsfo9f1lqPen/czBEA7h2egv83INl0gOal12ITSSa4zdLUAUoAJU8oq9vKglr1v9cXqlBnKOAN8OkJMVxroAygR1wM8mfYSyvFLHdOqjGyfO36suCMxNgo5OVmmuYeB7TXkrfE7pVhSygDwF39uhkmF4mxUXhy0q2+VZuvq68b0hPWy7Lj4GFPw3XX/+Tg2csYldHZ9w5fqq4z3e8Hhy/gQGmlJgMKe6/yVL6+LKvFzGGp3OuqT/fGM8A8cnsGpg5KwrItJ/Dnncb4Bp5Q1k802eqDkwA7fzI2iFbVPj1ejo2HGp+Hu/p3Mz22k8wWPGFvlXFFhMiiPn98Bjf7BxG+BCSWieBjZxlTX92ORTVb5bsFGouB7Dh5xVZ71B1EdV29I19E/X72nq7EAw7EMqB0Omv3ntV85k8TmL9tTu8umDooCev3n7P1uxVbizCgRydTX06W65aJeJae7J7sZLy776zBUqRekmforSD3ZCdrllT1/rNA4yqBOhBTb/VxWpaaoRaO+hy2QONAuPd0JR5btc+wLP36fYO5kxomKvSs2V3iqLIkoLUoigapt3eW4vEJvUwHOFGxFjS03yMr6dp6xEX5fKf1+9tVfIm/AxVs8scTGWx/dvzRfYJ0o1E4sSwHZiKFZ0V3MgG9VN2YRpT3zD1yewYggevm5QHw0uxsTUYPJ9UgeWw8fB4bD58X5ilnk1beBJQFD9s5ts+1oeaGQbS+sOlLxYK72d6KlygDSk7vLpoboV6RYdeV9QNOJsqJsVH4/tAeXLHMY25DNp89xZWABKTERWnchexaWp1mbBCtqqmFMgBsPHQeB0orfX2f3f2wmAv9M8tbbRFlXDHDEMvQ8H6J8koT4QuJ5TDHzsDBe2kTY6MwLI3fcajJ6Z3AL8tsgiKuK2wHT4mYv2ofZgxODkpFQCs8ElBwohz3Ljf6RzN47fIC2HHia+62L92bjSFpcXh//zlN5DPAF/nsc/0gw7OCvLvvLJ6Zeis6x7TF4J58/1m2SlBWVYs/FhThjYbO3Sr9mFPMXEviYoxivF6W8dBbxjzNgCIqpuqyjfgThMhzY+GtWpjlBWZCr7LGPIe8F8CB0io8vprv7woAwxty01rBu/8HSiuxq/gS2t7kse2P/khOhmZ5XX09rFKP8fIK5+VmaipTmvH0+0cQeZOSWElkaXwkJ0NJS1ZQjBUFpzTibvKAJM3+zPyMncBzzVFfB54blD54WPSuqF0ddpw0lt/WV/a0gz4DSk7vLvii+BL3ffrX0QvI6NoeUwcmYepAftU/KwamxGHG4GRNvzSpf3dsPnLeMKGfMyZdY0nmrWSYrZY4QX2feG5mIr4oFotlUb/31mfF+KDhfNXPLO+d4QX82gn2a6ocyMHMOU3YFMsPPPAAJEnC888/j27duuGBBx6wfQBJkvDGG2/43UBCScK/3CR3qigNV3VdveW+P/6y3HIbPeqysoGKXJ6AbAqGpcVzI5TV8Pw9PQBW7eJbY4Y0TE6Wbrafxg8wCiB9KixA6eSfeu+or0PP6d3FIOYlSUkLNnv556b+vAs5VkgnNK5GKBMm9dKxVSEKq3MHnAWFeSTgxVnZmjzYjAcaileod8WbWJZV1WJlQZHvHbPKSugBfIIP4AvegSlxGJzK91nWw1ZZJg+Iwn/8db/pO+GRlMkqD7a8LqpCKEHJlztHVZBDZHEb0KMT8ibZe06cBLqNy+yCyQO6W+Yr9rl5OZzI62HPl8hlgCdi1D7Or281rnrpXR14gs6NCSmbWPBgrkki9we7wukXd/XBoJROqPjmOib07YqBKXFYs7vEMIkAtH7kovfZbLXETtucZHXRk5YQ7cuewpvI8/q9TSrXHvbMXq69wXV90rhHnbV2j9IfP5gCNtg5pwmbYvlPf/oTJEnCwoUL0a1bN/zpT3+yfQASy/5jt+PoERfF7SQOnTEP0hAxJSsRGw6VCQcptUjgcdstnbGNY30NJ3YWWS+TL1x7CNMHa90fZg7rgVW7jHlhZcBWlLoItY8jL6cpg3Xo6+aNMn4pQ2jNUovSr21kAdHDhLlHUvwD9RkbRMGfvFRoanji1cz6/f0hyVi3Vxvhz0q160mMjbL01+W9Y2rBzD72nT+AWcNTDM8Ar9jH/tLLJmeu5bFV+3D03BWuUFZPirxyY4AsbzBUuxn84+A5bbU0NJZ0typ0Eh3pMQ1I02MV6MYbzHnuN2oGpsRp7p/ompjBzsUsBZs6ywITcrV132I5Ryirq3ACqowruuvnpLInD/2ETIQ6MJFNWu34EvNWn5LiojAwhV/6nedHDghW30xcMsxEndOsLmqykjti7lt7TM85KznWcj++FQHVs7Jo3SFER0YgOjICpyqqcXNCjCGFpDr4OxD8sQ4HoyQ4YcSWWF65ciUAIDExUfM3ETzsdhwS4PMRVVsd95yudFSoRL2/DYfFQtkO4S6Uc3olYOtXxqVTPV4ZWL/vHF6/bzCKKmowLC0OpZW1XLEsAaipu4Gaunqu0NP7Heth7gh/LBALZQYLRNLvxeyesUDDA6WVpmJchFqs6f0F2efq4E+rFGqA2MfSF9jE8Vn+256zyO3fHfeNSrO1pCmyHpZV1eKL4kvCd0wG8PK92ejcXikj/f6Bc76iPbz7rxf9TlOmyQBe4aRMBIA5Y9Kwcnsx12rLjpWeEOP7tzq9Hg/9YMpbXv6o8GLAgW7smhwordQEqYlcj3gigVmYdxdXIj0hGtdueCHLQEp8lMHqLAGYNy4Df/j0lGZyxMsdXC/LSnaMbY1ikRdTwLt2DF4frY4b6BTVRhg8PG1QItbvLxNey4fGptt+T+tlGXcLigzxrjUvHkAv+PSWUJHhhU0s9ZdMlBHETNQFktby8LkrWoG79hAyu3fQuGXYcUHzwPi9V4YhOFmPV1aCv5+cdKt/JwD/rcNO04cS/mFLLN9///2mfxPuY7fj0Hd4eWsP+aKW/eFejtWspeCRgOX3DcHct/bY/k29LOOhN/f4JiMLJ/KDn2QAD76p7Fe9jC+hMTgGAMb16YKvLl7Fix+dMBxn7+lKvGFDLHsAbiCSyNqmDjS0cjFQ88SEW/DyxydsP0v6/L3MwjnmlgRs001OJCjuQ/4sFW46fB4/uf1m02wWegGpFmF2Vmw8aCxxbqewht4Vyh/fcNGmSnltLepleuZiYbYPPfr80EyQXq6ps+1ry1YN1Ev1vHzNvEmPldWZPReG4MOJmcjqIbAQSsCPRvXEj0b1NOQp56VgW761SDMBsesSxiy5uzjlkFncAKBy51DdJxbgNXVgEt4/UMafqMlA5/ZtA3blYKivtW/iwtlOL/jU2XjMXMt4+9Ln5gesRZ2/8RRcgQtg2is7kK96lhJjo7Bwojgziy9w2mZQpp7lW4swOStR6Ddthl3rMG9S6W/OacIZFOAXpvjbcciwFwzB465+3TBzWApW7ypt8oC7puDRcRk45Yf1Qj2gLt1UiHtHpGD1TvE10li7JCCjS3ttcAz4BT6+rr7ObVtOL0Vssq9kAIXnv8E92drgHGblYf/2AJg1IgVv7ypt9DW0ec4RkoRe3do7sy4COFH+Db6uvo4hPRsDHXnI0FaSU2MnwE8UzKP30WXH8kjAg2PTMWVAoq0VGxmNKbrsTFwH9Oik+VtvsbVDhCThrv7dNJb7GYOT8d1bu+OZ948aLJjqZXqn76uExny9/viJeiTg3XmjDb7H+gwCY/K3cNumztNrt0qdV4bveeJOWGX4sgIBwBfFlyBJEob0jDNYzx8Ym+YoC48aM0suu65qUfPk5L6YMzbNsLqhTwvnOw80lkbnpQB1CrvWdjLMrNhaZCuYzwwJ/Nz8VqLOF9hpM5UnoLwHC3MzuQJX5qzAJAsqh6oDNtUVNZ0gwyjQ7WLHOiyaVIqCVcmq7C4klsMUfwbbQPngyAV8cORCkxzLHwLNmmEV0GcHL4BVO0vhkYBJ/RXfbtPtG5YEoRok9OcgAZiWnYRn3j9q+L1HUioeFpyo0OSz1vtJMpgwfKkh6K2oohqrdtpbKWDXl3W2Q9PiHU3YvGgsfGMH0VKhHXE6lJPpRS+89Ksuy7cV2RZIMhoHWquJq8iKo8+XbGWxnZadhP/5wSAcKK3EF8WVSEuIRlSk0kXbyfvqlK3Hy5HZvYPjFH2AIkQ+P3XJYOXV+0yLrhmzxJuVLTbz/zcT4HpRKAHIn5GFdfNGYXdxJYalxaFrx3Y+f11XkYA/f35aKZbBETVq2PPx9q4S/J6z0jQguRMK8sbbSgEqwiMBD4xNw8Ur12xlmPEC2FNcaSuYT4T+vVu09pDQ5Ucv6kTW+HnjlAIk+tWBd+eNVlxeovkuL3p3G5GhQh2wydrw0bEL+E8H/RmgXCvm4zw0LZ5rCOC5G1lNJKwsz02VcaM1Y0ss/+pXv/L7AJIkYfHixX7/vjXDXoBAOsuWBK/PlgDMHpGqqa7kBNYRv+xQSHtlYNPhMlsC3gvzjWRAU2RFf5wNB43LtVZ+lZ3bt0VibBTeP2DMH81rswfAu/ONlkI3UniJkCR+uVcrcTpjcDLXquyvz6MHwGN33MJ1jWGWSpEVUB/wpYeJx7SEaORvLjR9DtbvO4f7RvVEdV09vvXKvoAllsVCXcDmfZt5wX2+uHvPaoSEDHDPxy4yGq28Zq4TIr6uVoJMrUSCpY+ppC2UAcAg/mVo3dNYe/XCTV0e2l9kWTsp14savVhKjI3CrOGpeGnLCe41SIyNwuQBifivjcf8uldskqjPCiPCA2gm9qbb2tzOC2BlQTGenNzXlqhLjI3iWuNT4qMNvvUsz3lO7y545u5b8fR7R7XZi3TuNmz1Tf/c8OImbu7SXnhOMwYnY3h6PFeg86zqgLlPMm8i8ZNxN+MfB89heFq80O9+T3El4ttrnyciONgSy8888wwkSYKsj0iWzD0gZVkmsewn6k7VSVloIPC0RaL9ub1fN5ABTBmQhB8M7aGpJmgXrwycqazx69heGXg4J91XQlcEK61r1jSz75ZvK3K0FKpe4uZlNJg1XHG1UcN8LXkZCtTHvSOzCz4qdJ5ukEvDfsuqapVCILLss8boB45Hx92MuOhIDG2wCvKyvzhxXdIPljm9u+BlnWBR+13qi0Mw7L4PZmVvGfWyzE2VJkPJYrG8oAj507MQHemxHbz74qxsTBmYhPGZXQ0V69xasFJbDwHYmly9vrUII9LjcaqiGo+Oy8AfPjnFtTaa+ZhKMLqC7DhZwX2XZMCQ4eD3swZh3bxROFNZC2/Ds9e7ewdNNgTeMZ1eNqv0dVYW163HywO+V3Z/LgM4W2n08ebx6LgMnK2stVXQaUXBKV/VT7uiTu3rDOhWalSp29TuVhK0FTZ57jYylJU3FrwraouoP/nxqJ545m5lYqavYqvGyqVI75OsPr//+6xYM+ma1L87N0blibeNud4p33JwsCWWn376acNnRUVFeOutt9CuXTvceeedSE9XApiKi4vx4Ycf4tq1a7j//vuRlpbmaoNbA7wZqJ1E+YxHx2UgLjpSaI2OkCTkz+iPDYfK8MmX5lkhIiRJkw3i81OXLEvXNiUSlLyzgVQTFEWl26Fz+7amI6gE4J7BSnluf5EBTBa4fOhTs1mVDQaALh3acpciefmH9Uu3rgnlhuOvLCjG8m2nNEvmeZMykZUc63vu0hvcEVhaLHWeb/0AofbzFAW9RUgSt8y4Wcnuh8amCwXHonXGyHs9doW86YRKNlpNrWC5v89ernXwK+cw6+G4zC62JxAsIBZQxMC/6TKclFXVwsNPKQ0AuHdEiuGa//mz0/ba23Bv9X7t+oweevzpYiQomXL8WUZn76AViyZlIiYywtJtwGrSLcPoLx0hSbirXzds1JUbZ64mdvDKjcWA7Io5M0usurKlfhVBkoHnpvXDHX27AYDB3SZCkrh52XnMGmYMeP+/z0vwyLgMJMYqqfbyTVbfzFyKeG5oibFRuHjlmuFabzx8HvPHN04qmQFG/zxdrrnh89+mfMvu4pdYLi0txeDBgzFt2jS8+uqr6Natm+b7ixcv4ic/+Qk2bNiAL774wr3WtgJEvkkFeeNRkDfel45LFGACAH/45BTWzRslTGE2LTvJUGxDRN/EDpr8lQ+OTff/5IKADCXv7MKJmSGxfFvlUv3V3f3w9PtHTK/1pKzuSO8cg2WC1GEeKBbsjZzc1+P6dMHcnAxER3o04q+sqhZfX73OvSYvfnRC47vHq0Zl5XPqFmqhjIb2iAph6MUvsxCWXKrBqw3+jB4JuKtfd2w+fN5nacrplYCCryo0mRt4wtasZLeZr7NXBqYt24H8GeKBya0YBKe/fP/AOUwdmOQoZ7K/sQErCk5h8gC+BcxqfxsPn8cjqgwndlw5Hp/QS/P3gdJKg8iwQr17O8+6PxkTZGgnBgx1MRqAX7jCrmvRyPR4/OOg+aSfGUl++Y65+GYCWW11lyTJcG2dPMaeBpcrngDO6d3FIJ554yCblPJcEjTtAvCf64+g5OsaTB6QiAfHpvsEs93gN7PnTy9yZw5LRXRkBDe9HDtv9m+Ru5GaXcX8GgDx0ZE+DfB19XXDSpG+aiTPek34j18BfosXL0abNm2watUqtGvXzvB9165dsWrVKtx8881YvHgx3nzzzYAb2lowi4odldEZibFKlS8z6mVZKSqi28/DOemYnJXoqCrW4XNXfP+2Eg1OmTYoydYSnhVe2ViMQ5KA+0f1xJ922LM0qZEAzB+fgR+O7Ik9xZV4fPU+4fWyGsiOnb9iuc2mw+dx7/AU4ff3NPjozhuXYRDUW74sR3bPTkhPaI8hPeN8qbj0AU76JjBL2kuzsnG2wV2DDWB28s1a8cb9Q3wp98xwcgjetl7Z6COqrsolA9h+4muuPzaDlZcenhaPgSlx3JLdds7DKncwE+PLPv4Kf/68adIzLt1UiOROUcJ7qX82zB3rzFFcmmoNRWkebQjOsrqGLMOJnRzziyZlGu6jSGQEAlvWVwutmcNSfZUSV24/hQ+PXvR7/4+t2oer17/VTLLUz43dFYktxy5app1cMLEPkuPspRN7bsMxo3sD/LSsN4hiwOiKkLfuECA3HiMvNxOP3J6BPacruXEady/bgfnjMmxdk9e3FWmCYKdkdcfcnJstU7tZPX88kSsKhl6Ym8lduTIT7cPT4rnHHdpgDTdLh2jHek1uGv7hl1j+8MMPkZOTwxXKjHbt2uG2227DP//5T78b1xrhdY5q38mLV67ZygfKK9PauX1bxV3BzQb7SYQk4Y6+XV0RywAnw4SspGzzd1+vfHISKfHRmDksFdV13/qVMQAA3m7InGFqCZGVDBuiwejdfWcxrk8X4ZL0/3z4FYBGF4b8jdqJg5XQ11ejCrQEuQSg4mqdpvqaVSW/YFIvy0J/bH156RmDk/GLu/r4ZR0V5Q5mImDqoCQUVVRjfJ+uTSaWvTJw/Pw3wuV3p5MChuh+PrZqH/JnZGFBbh9fEZdXPz2J6YOtJ2Asw4kda2qPTvZFRiCw+6Z3j2D//dcxvlCeMzoNK3cUW+5fhjZ7gj7F5Nzb0rFwYiZe2NzoWsS7NAkd2lpeswE9OiEtIdq26LXTh+iZPz4DPxrZE3tPV+JSdR3iYyIxuGESz3MLUz+TMpSg0QNnLnMLHzGWfXISk7K644PDF3wuU0xwm/GPQ+ex8fB5S9cEs+dPL3LVwlM/SVyYm4lHcjJ8vzULblTvZ2BKHGYMTjb0S0zk81zORFUj9cKeymL7j19i+dKlS6ittfaBu3btGiorK/05RKtFv1yr953M7d/d730v3VSId+eN5naW/loN/GXKwO5IjY8OmuuEF8Di96zT/qgtR5rfy41BS6yTe+mjE1i9q8TRdfICeHjszbZK1wJ864Dev1KEDHG5axE7TvH9mvX8dMItKK++bppfWt0OvesQy+Cg93cX+RWb4fRZZZPNA6WVvpLArECDfmKwdu9Z3Deqp8Flws7x2MD00bHzhjLTSzYVarJHDE7thL0llx2chYI/1+vFLScCsgzquaNvFzwxoZcwGJGlSlQH1K3fdw7vzhuN3cWV3FiKnF4JPjHAismYsf3E1xjcMw7/OnoBF7+5hu/07YauHcXGG39J7iQOSPuCU5SE8acdxbavt/r91gvU17cV+QqZDEjuJHTBO191zVZ6w8TYKMy9zX51QDN45/fKJyfxo5E9MXmAsQS9XSu5mVBmbD58XhPcefRcFdfVRQ/r12Pa3uRbidPDq1bokZRgWXWhIn258CXTs1CQNx57iisBCRjS02jB5j1LPAH7Pz8YhPtG9cQXxZUYmhbnW3FZWaCkv2SW+HuHp2DMLQm+CUmnqDYawf7g2DTfcagsdmBIsj7FhQ169+6N8+fP46uvvjL4KzPOnz+P3r17o3v37jh+/HjADQ0mV65cQWxsLKqqqtCxY8dQNweA8mDvPV2J+Tq/pEAHvP+c3Bf1Xtm2qEqJi0JpZXCCgyQo4n9Tg39psPFIwMT+ij8rW1ZdMLEPkjq1w1cXvsGLW4w+w7OHp+L56VmaalaiAZ9HhCShIG88/vDJSbxpI/jo13f3w1Pvmfs4u4ndVFFs0uYkK8ey2dmIi4nULPe9tvWkxuVj7C32So/bJUKScGe/bvjg8Hl4G9qttzqxAelMZQ1e4tzzn064BT+7sw8OlFaauiw9nJOON7YVayxJxy98Y8syHyFJ+LeRqXjzs9Om97pX1/Y4WX7V4OO5sqAYr287xf2NSJB4APzHXb1x4sJVvBvAio4E4KXZ2QafSStWzx2JtIRojMnfYlg52543QRP89cHh86bvC68ftFvG3gk865tetDQFrB8pqqjG7OU7je0EsHASv4iJJEFTKKOsqhajl/CLxbjBstnZXLEMKMLQbqC6FavnjsSojM5+FdUBxPeWd20eG5+BX9yV6TsH3kqj3rprx3JbVlVreB/YvVYLWLNz1B9HeT61eaqXTM9CSnw099lh17G1Ylf/+WVZnj17Nn71q1/hjjvuwG9/+1t897vf1Xz/r3/9Cz/72c9QXV2N2bNn+3OIVk9ibBRkGK3yMoB+iR1wpOwbv/b73IZj8EjKcn1yw9KYWXnrQISylbCXAcuAnCfuuAVXam/gzR3mosIOXhnYdKgx8Ouuft18gTqiLIirdpXgcm2dT2B7JGDqwCRbkxYJ8OV+tSOUAeD8lWsa9wWnOB2AvACmDbT2HfcVRJHtTdgkCb4gOXVn/khOBkamx2P51lP4x6HzQnHDSpNHR7ZBTd0NU/9nNukZ0KNTY0opNLST8yMWLPTz7/bm7u/0pRqUVdXiX8cumB5zzph0dG7f1udukL/ZvCS2mnpZthTKAHCy/Cq3Ut6Tk/ti8oDuBiuj1HDdPv7yosHVwwvgNx8EbriQG/7P6bN2prIaMmRNgQn1srZahEgAspI64pAqZsLQBh1bv6pwfYVMb33zR5i50aZ6WcYLmwuFrmVeAAOSO2HdvFGGZ0KW4UtfBsA167LovHjvAJsEZXbvgN/fOwiQlUwtZlU+zfBIShYkO/7tIlg/oLas/rGAPwFa1uCWl9O7i7C4iy/AzoHlVhSjtKe4ElMG8oMdeeehP456JZN9zwv6p7LY9vFLLOfl5eGDDz7Azp07MXHiRCQkJPhSxBUXF6OiogKyLGPEiBHIy8tzs72tiksNifv1PDruFqzdewYff+lfGi+vrLhkLL9viCHfrpu4MWjpC0VYwYLzln3MDyhSL42rhbqZyFEvC3plOPKzZpHedln28UksmpSJgrzx3JUFMyQ0BtLY9bGOkCSkdnbWWbL9jkiLw25OII7UsBH7WL30ebay1lYmAa8M7Cy6hDlj0vGPg+eE5/LAmDTMzbnZZ5UUpZTi7f9cFX8iuH7/Oct7zCZBS1WDo9PsAHYGeK8MbDhUhjlj0jXPUVFFNf7OKTgjy7AVWBkIHgBRkR4MS4vDziLjhF4ELwvDT26/2Zf6T++6cvjcFfzme1mW2RvUjEiPx66iS676xzNfdMA8h7RIPE7KSsSmw0phITs510W8u0/8TEpQxGPJJX7OeLX4AoA5Y9Oxwo8KhsxXXZROTkJjukIGb4LBJtCP3J4BSI1xE3aLw7AMNHNvS+eegxMXmJXbi/DkpFtRVlUrDJJkpbN/N2ugZfyJGlGVUobINeWJt/ehuk4J/LTjw68+jkiA19R5qSx2APglltu1a4ctW7bgqaeewuuvv47y8nKUlzcKt/bt2+Phhx/Gr371K9MgQELMmt0l3PLHrDMakhaHfx27gPIr1zEwJdaX3k29nZVYEPl4SRIwJLUTvjh9OZBTaFIkKHlXH5/QC1uPu5cLOBBkKIPUkLQ4R9alpZsKMXVgEiYPSMKB0suOLUAzh6Uipu1NlsvkrLMs+dq/oiw7iyvx2HglQ4d6kBif2QVbdPmYvYDjZfvXtzaWqRVx+uvGgchpBb+3d5biXk6BFis8aJwE+WPREgXjiHh9a5GvCpkdn+VguwZ4Ie47nLLsk5PoGN0GSbHtuP7PUW1uwtIZWVi41p5g/rzoEiRJiRPo3CHS55Ygmpyo30sWiMmbzG0/UY7D59oI75cHwLzx/EqgLD/6lAHdMfe2m/F50SVuQY1AkKGIx7sHJXK/ZytnooA0u/xqWj90iopEZW0dnubEhOiz+ugnQQy1NfSRnAxMHagNorxvVE/LIlMyGgo2wXj9eIHOIlZsLfJNRs3eR+U5khz15VaW24tXriG3f3ds0Plpq6+PHV9v9XHMqmKOyuhMZbH9xC+xDABRUVH4zW9+g1//+tfYu3cvzpw5AwBITk7GkCFDSCQHgNmyy9zb0vH+/nOGxOP6GeOPGvwh/eF7g5Pxzp7AMiI0Nevnj9aknQq2YLDL5do6JMZGId/BgO+VGxP4O7EAyVBSMeX07sINLlGzbHY2BjdsM2rJFlvt4hEhSYaRQy+UA8EyZVbhRZRV1SIxNoo7SJiJES8Un2mnYtkL5f44qRgIALM5wTh2l5Bl3X9bEks3FeL+0Wnc7yTJ/uSPIcvA8oJT2JE3wSfCoiM9vmI2DHUu4UvVdYAExEVH4tFxGZp0hAC4IliNF0BKfDQW5YorDv7j4Hn846AuVzGUNHgDkjuh4KtyYa51O8jgF1iSJKBHXBSe33DU52fNxo07+3XTpFq04mjZFby9q1T4zK7aVYq3d5f63K5e2vKV8JlVW+zVqcwOlFbir1+U2lqpMdvkvlE9bY2Bdt/nCEnC4J5xli4szPrukYCfjLtZk79ejT4Tjx51ytgl07O4pbXZ8dQWYquKkFQW2z/8FsuMdu3aYfTo0W60hWhANMOVAMNLypa4X5ydrUkif7nmht/H/1szE8oAsOHgeXTt2K5JCmk44eI3133lkp0Iq+jIxjxx6qT6VsgysPd0pU8Ii2CC7e8HArvXCR3aBizgJAB3+5lzW0bjxIINEurUW2wbHh4JaNfGpESc6HcAvq6+jrSEaM3x1EgAXvheFqLa3ITPTn2N1btKsGpXKVbvKsWkrO54OOdm02IGoYYthweab9sOylJ4Mfe7Mw2VB4f0jOOm1Jyc1R0ll2pw4IzWt1mWgY+OXcCPRqYJ89wumNgH1XX1OHruSkAilbFw7SHcPZAf2GbG0o2F2L5oAmQkuNIONRKA6dnJhomCV4btybsaO9lwmC9wXb0Xq3aKJ6IRkoSDZy77XKc8EjAoxb8sMXrsrtqwdjArq5m1fVp2kqUBI0KS8JPbb/b55C/7+CSWfXzSEITHy8QjahegTBh5pbU9klLyXZ872ixNHeEfAYtlADhx4gTKy8vRuXNn9O7ND5oh7COa4YrefbbE7daSXnNk+bZThmpw4cCLH53Ay1tO4MGxfN86EYfOVmHDwTJNmiB1JTozZBmWftJMYAYyqZoxOBnfubUbnn7/iPDcxvVOwCfHxUF8D429GZ3bRyI/gBLqB89c1kRz+3yILX4ny8BTNtMLsv2xJdjHVu3zDYDb8yZg5fYirNhapFiUoGTG+P5QxRf3ibf3afyoNxw6jw2HzgtzOocSDxqW2qMjMaRnnLIcbrOI0fg+XfyOoxDxwqYvMXWgIlIW5mZq3Be8MvD3g2Kr6OL1R9AmwuMTKGoB4QsEdfm6v8fxI7fCn5WK/kkdcbTMuuDRL+7qjf/+4Lgr/aIT9wOvrFx/ER4JBlckrwzHQlnUJif3lYlgoPEZ2VNcqXlvASX94X2jeqK6rh7zxvFdbv5tVCpe+dQYL8OMWpndO2BgSpxlAR2ePzErra23GOvzLzMLPVmQ3cWv1HEAUF9fjyVLluDll1/2+Svff//9+OMf/wgA+Mtf/oJly5Zh+fLl6Nevn3stDgLhmDpuze4S5K075ChoqClwO9q8teBpSLmmvnZOr6UHwPL7h6CoosY0dd1780eja8d2hpREahZNUhLm//3AWduWTUkCVtw3BMUVNb7cn4C90sQ8npvWD7FRbfDE6v22MouItmGplgCYnrMTftNgFZYk+Kz0vAFUnebpta0nfdHwVumaGL++ux9q6up9GTzUWKXp80jArOGpWLWzJIAzVe0PSrVIZk1m5wBAuATMuHtQIvJy++LX/ziqCYjtGR+F05cCSz3J0l06KTHN4KXh4qXr4tGUfd17DW5ka3aX+GXxFeH2OThJHSliRHocnpzUF7uKL+G/Nvg/SQaUfgwyDK4vvP5WhAfAu/O11tkdJytM31t/rwNL45fZvQM3XzYgthYzyqpqDRZjf4qNUCU/Bbv6z/kaJBShPGXKFDz99NOorKxE3759odfcY8aMweeff45169b5c4hWT07vLmGpSsOwSc0CrwzMzUlXfHyhDOJzb0t3tg8AD721x1fJS8Q9r+zA1uPlPqHDI39jIcqqajE0LZ67Lw/vQxk4d/kaunZsC0AZUMqqajFzWCq2503AwznptsslS5JieXrchlAGgF/d3U+4b+bb52/AHY+Faw+huu5bTB7QaHUqu1LLjTIvrlBSzS3VpY1atO4QYiIj+NeygcXvHVFSz3G+G9fguiPi3Xmj8fiEWwzbeCTnZatHpMfj2Wn9NG4X6iCj7Ysm4OHbbtbsd0R642D+3v4yjF6yBZt0gUqBCmVASXe5xE8rsNovFlCWv1/e8pXtfS2bna2UV3Z+aEfU1DU+AU7vndn2rgplAHcPTAz4WuwqrsTdy3YELJQBpZJjVo9YPDY+w3cdPADmjcvApCx7Bby8UMpov/bpSZRV1eLvB87iZPlV03fP3wmD3NAvdO3YDjMGJ/PbIwO7iytRJsjWkxgbhbSEaBRVVKOsqpZbbGTRukPC35dV1eL5DUcxeskWzF6+E2Pyt2DNbncm3C0Zv9ww/vCHP+CDDz7AhAkT8NZbbyEpKQkeXS3etLQ0ZGRk4MMPP8TixYtdaWxroqiiusUL0/iYNrhU7b8bQHNC8a9MRFZyLDwNgSIXr1xzXNhAlpWl6XnjMoT+jUzkvH7fYPF+AKwsKMaTk/siLzfTV6SGZQRI6tTOYHGWYayKKAHIn6FYMZ6cdCuuXq+3Zel0MthYuRcFI1eoWii+v/+csIgP81/+uvq6QYCxtG8LJ4qDvgDxeX38ZTnuH9UT//fZaa6YLq2sRdeO7XBPtrY07j3ZyRieHu8o08HOokvYWWRcGmZiMy0hGsfOX9G0VZ82zt/+irkeeCSl7VZpw5zCqjf+z4fHHRUtkQEcKK1SctYieJZmSQLSEqL9Dk5uqnFCBj+A0PF+XGwwS62p1rVeWAdk8lBX2WRY3XN/ngmWru5/fjAIk7K6c1M9PrfhGJ7feIxrIdZbkR/iuPipU+IxWNXBFQVFmntgJx804acbxvDhw3Hq1Cl89dVXiItTrAsejwc//vGPfW4YADB16lQcOHAAp0/7l5WhqQhHNwy7S4VqwslFIlzaEi7tABrbwkSBW8FTd2R2xUeFFw2f/2hEKv5sIlw9ErBwojFVFiuva9enUwKwY9EEAO65QdhFveTo9hI2AMwekWIapGSFBOCxCRncSoF2f3/vCLGrBW+5mbkeXLxyzba/sRmTshqqbAb5vrKJV07vLthwsMx2lUzGkNRO2ONCcBjDqrqlPzEiov7ojfuHICryJtOlfyK88EjAf3y3N37zofNCPx4A2xdN8BW6EU1sWcaW6rp6Xxl4QwVMADLHLUR/DKvc+/pKfq3FTSOobhiFhYUYPny4TyiLiI2NxcWLxkGcsCYxNgoT+1kvI6ln1OEiCoHGYKim5pYuMb7jhpNQBrRFOtbudS/LwJbCi9wlQ+byIcIrw1d9jvf5o7fbW36WofjzuukGYQcPlGp1KfHROFBaiUXrAhPKvKsViFAGlGvjr1Bmv397V4nwXfJy/DLrZRkbDpahtLLWled/46HgC2VAOY8n1x3GxSvX0K1jW9NlcB5uCmUAGJYeZ16AAsAjtztzpRLt7sE392D5tlMh6TMJ//DKwH9/eNyve8aCOsuqapESH41180bhPyf3NWxXL8uY9soOn7vEHzlZOLwAJvU35tdWH8NqxUK/OrdmdwnG5JObhhq/fZbbtm1ruV1ZWZmt7dxg2bJlSEtLQ7t27TBixAjs2rWrSY7rNsxn6qdv7zMtBS0BmD08VVimORwIhVA9Ud7ovuLm8YenmU8MQ4kMYECPWMPnb35+GuMzuxh/oPst93MZSvqjhr+tHrOPCi+gtu7bJhvsJSjn/NCbezB7+U5M06XGCmS/4Ybe390Oz2045rgITDjAxMHjq/eHPEPILovqhJIE/OHTIkf7NLuDHxeWh9XknrBGhn/jjAdKFh8mSO95ZQfqvTJ3gqiOg3ijoMjwDEVIEjdehAlgKyOGPk8zzwf6yXWHhT7QrQW/xHLPnj1x8OBB021u3LiBw4cPo1evXn41zAlr1qzBz3/+czz99NPYu3cvBg4ciLvuuqvZWbXX7C7B6CVb8Pjq/XjPJOesR1KKcEwZmBjyAaW1sOf0ZcwRFE4IB/aXVnE//ziAAiGy4N883t13Dg+6VGbZjiSUAew/U9U4MXLhwP4OfMFGguLvXpA3Hi/fmx2Wgt5NwiUDkFUzwqWdRPNj6qAkTdCqVwZe2Pyl5WqyV1ZyizPhpk4flz8jSxNAzgQwS0moxyMBD992M7YvmqDxixaVy1YHyrZG/BLLEydORHFxMV5//XXhNi+99BLKy8sxefJkvxtnl//93//F3LlzMWfOHNx66634wx/+gOjoaI3/dLgjKguqR4LiozkwJU74EhDuUy/LOHe5dc+sg40E4OV7s7F+/mi/n+tgZy0YfXO8b0CSVFkn1P/2QKnWZ3YK6u2tkKFkOHn/wDnIkIV9BHUF4Q/p69aH/r2UAG4BpnpZtlVN8R+HzgMNQrcgb7xP6Ob07oLfzRqIZbOzNZ+zYius3/IAeDgnHdvzJuDJyX0N/sg8XRGMIOrmhl/ZMH75y1/iT3/6E+bNm4ejR4/iBz/4AQCguroae/fuxV//+lf87//+LxISEvDYY4+52mA9dXV12LNnDxYtWuT7zOPx4Dvf+Q4+++wz7m+uX7+O69ev+/6+cuUKd7umxG72i/WqfJDMr9nMXYNwjw+OXnD8G48EDEmNw+7T5ku6BHDviBTIkLHtqwqM79MFHzm0irN8qTV1Xpwo/8a0KIK/fHbqEmYNT8HYWxLQIy4KpZW1gAwMaXDTUec/bRPhEZbb/Y/v9sZ/OwgM8srAko3mqbZYnAAJMufMGJyMtjd5sMph6XOiZRNowaAZg5XMNOqaCWaTXd53vM+ZS8acsWkArPMsO6noZ1Uuu7Xil1hOTEzE+vXrMX36dLz44ot46aWXIEkS3nnnHbzzzjuQZRmdOnXC2rVrkZCQ4HabNVRUVKC+vh7dunXTfN6tWzcUFvIHlyVLluDZZ58Naruckp4QYytNTdeO7Xx/v7b1ZMBCWZKUyltbAliuJ8R4ZZBQtoEEJZgukIC6hbmZvolkWkJ0UMSyDGB1Q9lqdXaThbmZyEqO9UWOr9ldgrcEQhkA0jrbr9bmtH2Ec9bvO4d/G2lexIFoHbD0mV9XX8frW535pOthVf/svJgT+nbBR8f44/ATd9yCFz86oflM7RrB8zHWp4JzUtEvJOWyvV7gRkPl2bYdgn88h/hd7jonJwdHjhzBb3/7W2zcuBGnTp2C1+tFSkoKcnNz8ctf/hLJyfyk26Fm0aJF+PnPf+77+8qVK0hJSQlhi5QH+aHb0rF8m/jlZFkHpgyMQllVbUAlgn37lBXLJ4llIpQEKvLmj8/AI7dn+P6+eOVagHu0Rp3dhFl9JQD3Dk/B27tLTc8pJT5KSdsnKEhCNC31sow/mUxuiNbD+oYKqKOXbAl4X/WyjN3Flbb6t4+OlXMNZjKA3l07cCfXB89ehgxZ6GMciMi1Ja5lGairBuquAte/afyf8O+rwPUruu+vNm4DGRg2F5j83363O1j4JZZLSkogSRJSUlKQn5+P/Px8t9tlm4SEBERERODCBe0S+YULF9C9O99Zvm3btk2WpcMJD4xNxwqLIhWPr96Hs1W1vvyqbuBPnshwgJacCcayj0/ibGUNvnNrdwzpGcfNO90UyICtpfxpDaVu6fkliPBBkpTV2y+KL7n2bsZG3WR7FYm3SYQkYUhaHLe40dKNhXi2obqpPte60MdYloEbNSqRqhet33CELEfYsv/KLk/366rd3Z9L+CWW09LSMGrUKGzfvt3t9jgmMjISQ4YMwUcffYRp06YBALxeLz766KOg+0u7TWJsFPJnNPoKiWaZVr6LrYnbeiVgm4OqXETLZf3+MqzfXwYJwNRBxryjjEn9Q+/nTyKZIMIPWVbiDiSbaRq/PzgZf1NVz+Sx4J1DyO3fHR8cueDzAV4wsQ96xEXhy/Pf4MUtJ0x/f1e/bkjs2A4p7WUkoArtpRrE4Bo6SLWIQS2++HsBfhhRi/a4hhipFh1wDbentUXi5tUcq26D8HVb4EoexXUisoPy37btG/5uD7TtqPu7g+Czhv/d1M76eCHAL7HcsWNHpKc7S8YeTH7+85/j/vvvx9ChQzF8+HD87ne/Q3V1NebMmRPqpjlCnaC8ps6LtIRo/OvYhaD4XrYEZICEMmFABvD3A/yyvG/cPwQHzlQBh5u2TU2NRwIm9u+OjYco+Jcg7MIssjV1N2xtby6UZbTFDbRHLY4cOY+nhnbG0MRIJLa7gfib9gLXryD7RjluuukY2uMa2qO2QezWIkZif19Dh69qUP/sNUyCF5Ps6sgzdjaSBKKVCVzOZ6K/20QhrIs+uIBfYvnWW29FaWn4RA3PnDkT5eXleOqpp3D+/HkMGjQImzdvNgT9hTO8aNZRGZ0RFx0Z6qYRRLPDKyvpkZZvLfJliZg+OBkPuZQLOtx5cVY2pgxMwmufnkT+psJWcc4EESjTBiXid5sO4l/7TyJVuqYIV9Q2WHGvoX2DNbe9VCsUuMp3yvZtpPrGnR9q+J+KJABPOFBhXlnCVbTDVUShWo7CVUThqtzwN6IwpHcq0pO6mVh1VX+3iW7xAtdNJFl27vm6cuVKzJ07F5999hmGDRsWjHY1KXZrgweLsqpaQ733CElCQd54AMDoJVtosCMIh3y2aAIAZVm1pu5GqxHKgGJBvzUpFl8UX8Le05exckdxqJtEEH7B5JzZuxvZYMH1CdcGYdteLWwb/u7VScaVqsu+7durxTBqtQLXBbyyhOoGgdsmqgMSOif4LLI1UhT+drhKEbxytCKE5ShUox2+QTSqG4Tw1QZhXItIyCbZ5F++V5kkE/axq//8sizPmTMH+/btw5133olf/vKXmDFjBtLS0sIyaK45YFYxp+RSeDq7E0S488eCIkwZkIi/Hzjb6vLnPvjmnlA3gSBMaYNv0R41iqsBdBZbSWfR9f3baNVtj1pEOhG4VwFE2NiMWWzldvhGbcn1CVomYhv//qZh+6uIwjdyNKrRDjVo6xO4nuvA9kcn+LJMRAO41v0kfuNCZisJjfneRZRV1aKootqX4tLfbVojfonliIjGJ23x4sVYvHixcFtJkvDtt9/6c5hWA6uYo7csR0d6sGiddVU/giCMLN9WZJqKkSAIZ7TBtw2CtUGsNojY9j43hBq+2PUJ3Bqfu0JbyX1dUC231VhifZbZhs+q0Q7fyFGoQTQGZiRj84kan9htdG1oh2q0M7Xg+osXMKR0y+oRa/qbCEnCtOwkvLvvrGlGjfwZWabi1qpwid1tWit+iWUnnht+eHm0OkQVc6rr6rkvBxPWlDqNIAiCMOMmfKvJntBeLXYFbguav1mgGWrRVrIX+OaEGp/A1fniqkSsT8w2iF2eVbca7eB1IHClr4zpV2cPT8HRsivYX1oV8HmN79MFn3xZbpnSLSZSbOZ++d5sDEmLQ2JsFMb16YLHV+83bPPTCbdg1ohUU6FcVlVrWbjEzjatGb/EstdLafTdhlcxp6whn7Le4syyZVRcvcZ9eQiCIIjmSwTqFcssL3DMptsCE8LtgiBwa+VIjcD1+dv6rLnRqsCzdj6XBLX4rW6w4Nbb8YlwGQ/4eY9XNVTmtPqtDGtD1afHy5UCRbtK4QWEZaOr6/guJA/npGv8j4emxXP1gJVQBsxdPdlv7WzTmvG7gh/hPuqKOcxvaOHETLyw+cvG/Iy5fVBdV4/0hBhER7q/TEQQrRVaqSECwQOvzhJbw82QoLfg+twYVOI3SqpzvX2KwFX52+qsud8I3Ba01t12qEZUSASuW3gkKNUzNxdyBbOoD3hv/mhfStetx8s1VlgeXlkR3x4JeHjszZgzNo0rOg+dMVqxPRIwZ4w2Pa9oBdqOkBW5eqqt3Ha2ac04EssnTpzAunXrUFxcjLZt22LQoEH4wQ9+gKgomnW4id5vaGFuJgYkd8LBM5eV8rgyLGe/BBEOPDAmDf88eh6llcEvPx0oJJRbHx54DZZYnsBVBK1K/OKarjjENURL111v3zW5jVa46vxxRYFn36iE7jeIQg3a4VuyjQEAfnV3P7SJ8DiqgLsoNxMDUxqD52YOS0V0ZIStlV2vDLxRUIQ5Y9MMwXMHSiuRzwnuW5ibyRXBvBVowDooz47QDkSMtwZsp4773e9+hwULFqC+XrtkkJycjI0bN6J///5BaWBTEOrUcWp4aeQ8AJbfP6RVpb4iCILgIWkEruKSwHNDELktqP13Y4IgcK/LbYQZEq42uCjoLbj6fLlM7JLADQ5OV5F4wW68sdqMh3PSsWJbkc8Idk92MtbtO8sV7Q/npOPJSbdqjqUWw+q/1VZujwQ8ODYdD4xN54rcsqpag9D2Z5uWhF39Z0ssFxQU4Pbbb4csy4iJiUGfPn1w5coVnDp1Cl6vF7169cKxY8fg8TRPt4BwEss7TlZg9vKdIW0DQRCEmzCBy81/q0oBZi/wzP1Vijo5QmXB1acA0wWUafLfNvjnqsTxjSYWuOQ+5A56FwQ9rPaBWkCu2V3is8RKAO4b1RPD0+Px2Kp9mntitW9DWwC8O380quvqcehMlc9lhIlslhlDlINagpIdQy/uKSWcEVfzLL/88suQZRn3338/Xn75ZcTExAAADh48iBkzZuDEiRPYvHkzJk2a5E7rWzHpCTHU+REEEXIkeBGN6w2W2BphhgSD0DUEnimWXLe5oRK4QjcEm24LdWjjevuaChor3GFc7y7Y8mW58HtesNvMYam4XHPDVyXz/z4/jVuTOiIvN1NxmYQismcOT8GqnSW22+IFMO2VHQars1cG1qpKbIvuvQxtJgtKCRc4tsTyZ599hh49euC1115DZGRj+eUBAwbg97//PaZMmYLPP/+cxLILJMZGYe5t6Xid8sMSBOEYuUHg6nPcWgtc/fYxuAaP5K4UYwLXLAWY3cCz62gDit4g3MJMKAP8YLeyqlos3dxYTt4rA3lrD0GSFMErAXh03M3o072DI7EMGNPaOYWJewCmKeHI4mwPW2L5woULmDRpkkYoM8aOHQsAuHjxorsta8XMGZuOFQVFjpZtCIJorsiIwnVhCjC1762mkpnObYEJ3AiXBe63skeQIUEp0auU5uWkDGuw4KrFLglcItRIgGODlAfA89OVuKwdJyt8wpKXbk1Go9CVAbz88UmMz+zC369D9wweEqCIc91+mLg3Swmn93cmi7MYW2K5rq4OnTp14n7HfDzq6txPddNa0UelklsGQYQbMtqhjpMVoVYlaI1WXVHgmdsCt16WTFOANQrcKJVfbjtdvlxF6JLAJcIVf8ZGSQImD0i0bZDK6ZWApd8bgK3Hy30Bfcw/ueaGvSqEHxcardaLcjMxdVASVm4vwoqtRfBCEayPjsvAq5+c5LaNVfNbv++cJmNFTu8umv2oM1lcvML38a+pu0FFSBxAobZhysxhqcjs3gG7iyuRnhCNuW/tIUszQQSEjLa4oRGsXLGrCzxTpxPz5c/FNdwkuVucyesTuPwUYLyyvSK3hWuIBAncls+PRqbiz587W95vKkbfHI8dpy4F9Rj+DIleGaip8+Ke7GSN/+/g1E7YV3LZsM/tJ77GxSvXNMJSBvDmZ6f9bTYAoEecYpmeMyYdc8akazJQpMZHa1K4LcjtgwHJnXzf/+KuPoaMFU9OutW3n+hID6rr6lFWVSsselJUUcO1OO89XYnJA0gs67Etlk+cOIG33nrLr+/vu+8+5y1r5egd8u/JTsa6vWfJwky0MhoFrlnlMjOBq/bBbSPxBw5/UQSurkwvJwWY3qrLSxlWi7YggUvYxSMBsVHhG5jo8YTns+yRgOhID97dd1bz+b6Sy9zt62UZHx276Lqxav6qfb726NO9ifIpM9QFzPSf610rFuZmcouNDEuL47qBPLZqH65e/5bcMXTYSh3n8XggSf49+JIk4dtv7S1VhIpwSB2ndrIHwM21LEuBO/0TRFMQ6RO44hRgZr63ap/dYAjcap/A1eW/9VlsVS4JPrcFdcqwqAaBGwkZzTNlJkG0RhZNykRWcqyjFK2Sg7F3RHocdhZVOm4XL92bGrNcy+riJHrtECFJWDCxj6YS8PPT+2PmsFSNUU4NL01eS8XV1HGpqal+i2XCGr0V+cGx6YaH1wuQ4zIRVNrgW1+VMpEFVy1iRW4L7VGLSJcFLgCVq4E4BZg+s4K2IISyfQ3aksAliFbILV1ikBTbDjGREY6C6+wKZQnA0LR47Cqq9A3XEoCHbkvHcouAQn26N6BRIB86W+Wr3qvPtawOzBMF8w3o0QkFeeMNlmpRJUJemrzWji2xXFxcHORmtF7KqmoNTvZvFBQZAhdEyceJ1k0bfNsgWLUpwBoDymr4YtcncBtL+LaV3F8BqpbbGnLdCn1vdeJXvU012pHAJYgAmDMmDSu3F3O/G9enCz49Xh4WK5cSgOHpcRrBaYYT0XuivBqPr94PCUBKfBRKLjnL//3DEalYtbPENL/xso9Paj6TAEwZkIgV24osz0ctUkVWX32uZXVgXnpCDNflgglknvgdmhYv/A3RCAX4hQg2Y7xUXcd9GR7OSfdFtjICqQhEhA834VtTNwRx5TJjvty20g3X21fjE7g6X1ydiLXKl1uNdvCSwCUIAylxUSitdL9QixmnLl7lfv69wcmYPqQHPrHIMxwsmGFIAnDviBQ8PqEXEmOj8H+fFWPxe0dMfxshSXh6al889d5RR8eUAcdCGQBSO0drXDKmZCXi9j4JWPDOIaEQ9gL46NhF28K/4uo1HCit5AplEUxkj8rorMmkxYIDiyqqAUDo56z/DcukQTmYGyGxHALUM0YJxvQ3EZKEzjFtIau+0L8z88ZloENUGyzZWNgkbW7tRKBescxapAAzc1tgQrhdEARurRypEbjaFGC6/Ldoh28a8uPyLLj1iHC9fQRBNHL2cuBC2WnatE+/qsD4zC6GNGbv7juH3KzuAbcnUGQAb+8qxcAenTBzWCo6RVsHLy6Y2AffvbU7nnn/aJMYj/Tj7abD53FX/26W9+HFLScs981EOLN8OzkdtSVYHRx48MxljfuGKI8yL6CQqv5pIbHcxOjdLtiMmlmKlTyLN/vKZ4pY9slJzLs9owla3HzxwKuzxNZwMySYB54p4jdKcj+PuCJwnVcu01p326EaUSRwCaIZEYiwkwD84q7e+O8Pjjv+bVZyrEEs18syDpyp8r9BAaK+FF5ZqTYXHRmBazes4x5Y+rVHb2/ITRy8ZnKpl2V4JCmgWggeCbh3uNa9w2pfvbq2x1eqlYJp2Ukayy/79w9XfG47j7LaTYPnHtraczCTWG5iRBV/7h2WitW7SuCVlYo/VsiyIphbGh54DZZYnsDVBpfx8uVeQ7R03fX2XZPbCFOAmQWeqVOIfYMo1KAdvqXXjyDChnAt/jR7eArW7D6jWSKPjozwq60lX9cY42Ek4MWPrC2fekTXy0nmCB7eBuuqHVj6tVDhkYAzOncaCUBebiYiPBKe23DMch9eGVi9i+8HzbvGEoCT5VqXmvX7zuEXd/XRCFmzyn1WgjeQ37ZUaLRuYngO+B4Ab+8WBw2EO5JG4Da4JGhEbK2p24Ja/MYEQeBel9uYZEhoSBmms+CK8uWSwCWIwBmRHg8A2FkU3KIVjpAAj4wmt05aMTojAY/f0cu3RL71eDl++vZ+v/a1fv85zd8SYDlDuOvWbvjg6AXD5y/dm42DZy8bYmsgh+fEQyQ8n7jjFlyuvoE3P3deZGRYWjyWbi40TD6mDkoCADy/8ZitVQTeNh4Az07rh8Kyb3yGtAhJwoNj0wylunlC9tBZ42qB3cA9s0DB1gqN/E1MYmyUoXLQmF4J2PZVRZO2Q4IX0biurWbGSQFmL/CMX04zEOrkCJUFVytwDQFlmvy3Df65KnF8gx5zohlye68EfNrE/UJT4ZZIHpbWCbuLL7uyL1kGXp6dDUApzBAuYi8q0uNbItcvjweMDSvwh0cvcIXTkLQ4TBmYhMlZiZj2yg7ffmQoQu/eESlYtbPUpYYGRv+kjjh87ormMw+Ugh1TByVhTP4Wv/a7q/iS4fp5ZXCD7ZxMINi2i9cfUQqLTMzEgB6dfGJVX6pbL2TLqmqxdJMxnmnBxD62LMNmQX+tFVIRTUxZVa2hclCBzQGRCVzFElsjzJBgELqGwDPFkus2N1QCV+iGYNNtoQ7hW5mKaBokAEN6dsIXpy+Huil+MzsAwWAmlP+/SZn4LwruxU9uz8Ce03tcEY8eAIN7xiExNgpXr3+LvLXiDAc8FuVmYglHoATKQ2/uQf6MLOT07oLn/uFuIJsddwkZwNyxN+ONgiKucCq5VGMUjADaR7YJm6xNeqEMKG3M31SIg2cu+91G3vXjBdu9tOUr2/2Ap2ECw3btlYGlmwvx+1mDfMF3VkJ2pU5MMwb06GT73KyqCLY2SCw3MUUV1egsV2KQ56SlwE1rX49r1Vc0vroeyd2ehwlcsxRgdgPPrqMNqFwv4RYy0KyFMgCs3uW+ZW1S/+6Ym5OBwvPfaFaomjsSgGFpcdhVbK/62aSs7rijb3dM7NcdGw+f13w3e3gqeiZEI3+jeaC0mlkjUnzW2+jICEe+BPPHBy/YWgawcO0hv3/vxIeYd8oRkoQ5Y9MweUB37C6uxLC0OHTt2A47Tlb4imXo8QBYUXDKkQgNheuGDGDDofOW21nB2i6ywK4WCOUfjUzFnz8v0XzGu2bMj1udlUIkZA+UVhrcNABFhDt1oxDlZm6NkFhuYtITYjA44gRea/Nb641rAV6a2m9ljyBDglKiVynNy0kZxsmXSwKXIIKDhOCUp7+9TxfuCpUE4NfT+mHx+iNBEx0T+nTBliDl45UBn1AenNoJGV1i8M6es8Jz2XjoPGb+YQd2csT16l0lvn3aZfTNCcJCEFa8+snJsLCg6pEArJ83Gh8du2iZvswjAe/OG40Pj17AKx+f1Ii/rcfLNelOAfG1lQDkZnW3LUIlKNkg2D1rlkjAy7OyMSQtziAuiyqqudfKIwHfH9IDq3aWaJ4ds+vrlYG8dYd8WSkMlf7OVCFfsLrx0NibAQA7TlZQ3mQ/ILHcxCTGRuF7tw/F3oJeuCorab/69EzCtzfF4MMTNfim4bMpw3phZN90vH/sG7y286LGqksCl2iN8Kww4QxLC+m2hnpy3WH8btZAbladaze8jo7HG5g9EjC0J9/COzcnA7cmdcSyBjEVLPaWXMbekstYlJuJ6us38OIWfuYfnlAGnF9zCYpv8BNv++cPHI5CGVCuQ+mlWtw7ItVSLHtlYMOhMl+lOQmKj2tO7y4Yk79Fk+7U6phOrbWrXQxwD0W1W1kGOrdvaxCgZVW1+Prqda47ysLcTAxMicOS6VkGl5/pg5Oxft851HNm27IM7D1dickDlGPZmeB5AHTuEOm7j5Q32TkklkPAd++cgrIRd6C4ogaDVEsoHapqNcsqr209iSWfFwJID22DCSIMGN+ni8EK0xxQ51B3o+0stysv6GpYWpyj48hQrLgHSqs0Fb9ES+vRkR688kngQtluG5duLsS780YLxbIIp4JJBvDQW3tCXu55TEZn7Dj5tatCT2q4GFYTN48ELN/aWJJZBvDC5i+RHBcV1HdO9v2ffTwSMHVgItbvL9N8LgFYP380Cs9/4/PpdQIvENBue/QuDq99etJXL0FCozuMYklPwdSBSsaMnN5dNK4yMpRUcOvmjcJHxy5wn/0vz3+DwT2VuCNLodwQIMiKkwCUN9kfqBZtiEiMjcKojM6GROKjMjoDAP5x8BxV5yNcZUCPjvA04wWJaze8WDI9CxGSvZOYNigRiyZlBtTJeSTF//W5af2431s1RQbw4qxsrJ47Eu/OG+3KelCEJGFwzzjNtfAAeHBsGrp2bIeFuZmO9re35DJev28wVs8diYK88chKjuUOvg/lpKO6rj5g4cSsWktnWN9Lr6xYRp0yIbOrkuu2Yf8RkoT54zJMr3+ohTKguC+8eO8gTGsQUk7hnd+l6jqs2nnaVI8qKcnSDdvUN0SaBbPfYELS7rYj0uIgy8D6/WW+CriA0sb8GVkYmBKHmcNSUZA3HstmZxuuiVl/YEco69sqNTzP6rH8ta0nsURVWEwGIMnAD0ekQpKAVbtKMSZ/C9bsLhHmNK6p8+LeET259/TFLScwJn8L/igI5GN4oLjWZPUwvtMs3RxhD7Ishxn++swRhBWHz1zBu/NHo6bOi7SEaFy8cg3v7T+HP24vbtJ2sJRNkIzlY8348vw3uHdEKhbk9lEsNhbvyPr9ZXj/QBkW5maiR1yU43RgOb0SsPR7A5AYG4UdJ/mZKR4ff4vp8jZLscXKxwYKE8VAY7T6yoJirCg4hde3FWH5tiLMGp7ieL8HSqvw8zv7NB5HnwteAuaMSed+Z9ZWGToXDyiD98CUOADwBSl9cLgMf/pMkOfWD6H2UeFFbCm8iPnjM9ApOhLD0uIwMCUOqZ2jfRZHD9zPqRyI240E+PzNPZJz/3D1qgDzLZYBLH7viOnvFk/ui0kDEvH+gXOG7yQAQ9LisDBXa5l0k4n9u2PzYbHbxuzhqYiPaYNln5yELGtdb2Qoz9Svp/VDbFQbDE2L932XGBuFwT2BubelY8U2JRd0hCRhwcQ+yN9s3X+oYYVG1Onb9hRX4nJtneG4ZVW1XL9hL4BVu0p8x2XW3XXzRglzGifGRiF/RhYWrT1keFa9MvBGQZHwmWP+5gNT4lBWVUt5kwNEkuVwmE+HlitXriA2NhZVVVXo2LFjyNpRVlWr8Q0jCDN+870sREfehH8evYD3Dpyz1fmvnjvSt3rBUE/QghWRftetXTFv/C0+oc6yDoxesiVgH1s1YzI6Y/vJrzWfeQA8dscttquUfadvV9w7PAV39O3u+4zXVgnAivuH4ME39wj3NX9cBsb0SkBMZATueWVHQO/2lKxEbDxc5rtPc29Lx+QBiQHvF1D2lz+j0Ydxze4SQ2oq3ndcQSwp1vQhaXHYerxcuB+GlYFgfJ8u+DjAoEKPBDw4Nh0PjFUEf3FFDaIjPYZrZzYRkABMHtAd92Qn48MjF7DmizOGbX55V2/0jI/B46vNJ2aSBEzPTsa7+84KXXQkCZh3e4ap2wt7X9nzMKfh/PYUV+Lxt/dZ9gkRkoSCvPEAwH0XmUhcurlRgN87PAWrXMjy4pGAeeOU8zN7fpnl2XSbBjcGtS+u+rnySMCsYakYfUtnDOkZhz9/fhrLbFTK9UjAs1P7YUCPWFTX1WsC4zT9pqRcp0dyMrDjZAVmL99p+zqsnjsSJZeqTd+TsqpabDhYxq0I+HBOOt7YVqxxoxqQ3MmQJUN/PchnWcGu/iPLchjBW44hCBH7Si9j9c5S22LTA3HqILW/3PjMLvi40N2MB8PSO6Nrx3aaznvP6UrHwly0/cj0eOwsvmQQyoBi0XFSzvdfxxSrJBNXZj59+0svm+7rlU9OYtknJy0nIbd0icHJ8mqf8AGMAnTDoTLNsi6zJLvRZcjQ+jCapaZSf/d19XU8pis5zMRDUUU1cnp3QUHeeGGuVjtFNgIVyqxNy7cVYcW2Is2kQJ+vduawHlwh+NMJt2DWiFTfCgFPKAPA9RteTBmYhOo6izzNMvCLu/rgF3f1QXFFDU6Uf4PF67UWYFkGbk3qiPXzlWwWL318QiN+JdVDxZ6HFQVFWDI9Cynx0bYmz1MGJAIQZ2yQAU3uaBnA27tKA5pUqydTRRXVeNlCtMqwdpFRW2sXrTuEhPaRmufKKytW3VW7SuCRgIfGWscBSVCeDwC+SRWbdE0ZkKjZvyw3rJLJSvU+u9eHWXdHZXQ2zWmcGBuFYWlx3H1MzkrEnDHptvIhy7L2v4R9SCyHEbwSk3YIRX5KIvQ4LXbxUI4yQLDUQYAiWPWD+seF5Rjfpws+PV7uGyAW5mYCMvwuuvDchmN4fuMxjdUnz0bu2H8bkYr/22ntvvC5y2WT9eIqJT7a8I7JAF6yCDyTdf8VcaK8GoDWUqh+r0V9gtP3Xmr4P95gqS+Za5ZjlX13oLSS+z1zebGyYAVqIHCSQxiwnhTsOV3JFcu9u3fQVNATcUffrgAaJxSrd5Zw3XRksIwGSUiMjULFVX4V1H8evYD39p/jBonxzttsaZ/HewfO4f0D55A3KdP2OBKI6wp7HqY0+GT/+u9HA9gbf+zzyjBd7fHKwIptRdbXRwIu19zwWdXZb5c3TFJ5LN1UiJE3x3O/0+ORoMnJrH/fWDo4Zs2urqvn7qemzmuZD5k9t+r+yN8AP327WgsU4BdGsMo8dgOYGDKUiHai9eDUjdMjAVevfYvRS7Zg9vKdGL1kC0Yv2SL04/34y3L8/Lu9sWx2NrbnTUCnqDZYutm+UOYFBLGB/EBppabjFhEhSfje0B6GfUmC/QcDNqjU1n3r6HcOX2HN8dh/3Z4AR0gS5t6WLhSXHgBfV19HWZX9gDrRAK4W+U+uOyzcZ3pCjF/XSgKwbHY21s8b7fhZ4AU2yQ0tHtIzzvBuSZJS2Q8wF/czBif7fLEBpT9n4pnHY6v2+fzYh6bFc9/p9Q1CWWmj8n9WopYFhy2ZnmXr2spQRF5ebmbQE5K+OCvbN3E6UFppKCYDAINSYrm/5d1nSfIviaoXSt5hNtby9iPLSoU/J5M5L4DdxfZWzNi1KKuqxY6TFZp3ZM3uEozJV/pqFgjIjGlq7Podi4IInQb48drVWiCxHGaoo3idsLfkcnAaRIQl88dn2BYJzAq1alepIzH23x8ex2Or9uH9A+ccBZ0+nJOO7XkT8J+T+xq+q5dlfHTsIndfs0ekaLIXsOAU9QQyQpKQPyNLuH+GRwJ+fXc/29do9vAU4bb1sowDpVWW+5gyoNHHmYkaNRGShMcc3DcevJ9GSBKmDeJnT/jRyFS8cf8QX6aLOWPThceXoQg43iDIG9ABcAdwPWaDcmJsFPIssndM6t8dS2dk+QYrDxT/6skDkgzPhwfKcyTKXgJoBYZ+8N96vBz5M7J85+SRgHxVpgPR+b5x/xD8zw8GGT4XTSaAxolYWVWtL5DLCruTqINnLmPmsFTsyJuAZbOz8fK92UpmGMG98spKKeT180fjHsGzFCgSgMqaOvz9wFmUVdViVzF/NSinVxeuKHz2buM99crA3BzxM232bE4e0B0FeeOxeu5I7MibgJc4Y67TCasH8KVvNIMF/vLEp941iU04ARj6Ql61QB5OhTbvfRe1y8nkujlDbhhhSGJsFOJiqkPdDMIFguUiExUZgYfGpmvKmpody982yIAw80S/pI44wkm1NDkrEYmxUZg8IBHPbzxmEMYvbTlhaGuEJOHxCb3w+IReBt87kf+saP/qpf/Imzw+n1TRkr1HAh6/oxcGpnTiTgqkhjab4ZGADQcbrWQyFGuVR4YvCp8F7fxwZE8sfOcgtn7Fz7AhPAaAZ+/uh2Nl3+Dt3SU+F5nnp/dHTu8uvuV6NX/+vASrdpZgyfQsX2Cn2k+XBT6t3lVisAazJVqzwCC2GmYW8BchSYiO9Agrhz2SkwHIinXT23CeA1Jisb9hgrL5yHnc3qcLti+aYOlDzb4TZS8BgJ+Mu1njUqEe/BetO4TteROwPc94LLb8vHBipi9/LuPExWrcmqRdnjYrSMFQu77k9O7iWn+Rv7kQUwclNbyHjddqZHo87l62w7C9R1IEttrlwG1kNGbmkADcP6ond7s7+nZFclyUIeAts3sHwzscIUmYMyYdk7MSMW3ZDsNzt27eKOwuruQGxundF4b0DDwXurrQiLr907KTfEVG2PkA4IrP3987SGgFNoslMEP/npoJbdH7bmadbg3uGCSWw5CyqlqcvHg11M1AdGQEakwsIwQfCUBu/+7YdOR80AIpfvPBcQBKZ3bv8FSMurkzUuKjDAMGEPjg6/OR1H3OE8qAMggBjR30Qp1vMtsPG5j0HTev4+X55PGE2kM56ZgzJl0otAH4Uq3pj+1Lxba9CCu2FvmEG8+ap/b9jZAkPDA2zeDHKMvAy7OzER/T1jCwFZwwijn9PtUDLLv+i987orkX7PlilkleIQa9+J05LBWZ3Ttgd3ElhqXF4R8Hywznp7YG8wZ0ta+j/hrrM2BMy07SBEixwVft+/jI7RmYOigJKwuKsXzbKZ9QVh+zIG+8IZMLQ/98pCfECIVnfHQkAP7StFcGXtryFZ6/Z4BGJP+xoAhvNOS05VkNl2wq9AlojwSMuSUB209UWAovtXVPFGSnxq6Y1ld5YwxMicOiXK3YlxpiEvI3FpruW/Qu+IMMcFMFMleWgSlxhmfqnld2GIQye3f1z796Zaprx3aGSTXPqsr6EyeraOqCQwsbsmEA/AncfaN6+t65rh3b4R8Hz3HFJ8trLWovr8y1Hf9hO0JbZD3O6d2FG1PVmtLPkVgOM/zNs5wY2w4Xqq65mje0OQvlWxM74GjZN67uc1L/7vjgyAVbVaE2B1Eoq/HKSnT6YxNuEQ62ToOg9LAKUC9s/tLWuR88c9knahLaRwq3G9AjFlMGJPly4PqDnQFAL6SenNwXc8amaQS02ur55KRbfdHlvGwPAPDSvUo0v3ofb+gKBLDiIczKyI4h8nvV7zMxNgq/uKsPXtrylSaYU/1TtpSf07uL71rwUkypLUD6VIE8WOYUu9Yk9TVW3xN9ejY2+F6uveHL28sEdEL7SLy+7RS3PU4tWImxUZg/PoObaWFoQ1YBUUD1qp2l6Nk5Bo/kZPgCUdWbWAVbemVgm41VAw+0AV5WAd4SlPRkdt9D3iZrdpdg6eZGUTx7RAoen9ALfyzgZ1VZPLkvhqbF+VI+bj1ebp7lw08kKGkY1ekaAcWX/OKVa4Yx0QNg3bxRvhzCZplXEmOjcE92MtbuPev7/bTsJO6zxCaSeqMDN7UflJzh6nSYatTvBO+d411Dj6TktbZjBfYnFZxVIKDZ+z4qo7Nt63RLhMRyGGEnjZL4t0o09ZSsRMzNScdrW09h4yFxoveWTJ9u7bHxpzkoq6rF0k2FWL/fmGzfHz44cgHr5o1C6aVaPPH2PtNB0444lQAMT4/HzgAzObDOTDTzX5DbBy9s+lKz7M6W8S3bqOqEpw5KEub6VPPC5i8xdVAS/vuDLzUDlJ79pVXYX1pl2tHbsZxYDQBmvxENOOx7UTJ/VmhEfVz9QLJgYh8UVVTj/QPnNMJwYW6m7X0CwGqLrCdqIZkYG8UVUswCVFZVqxE7okfgoZxG67w/1iTWlh0njdbVelnWuPZ4ZRhWH0TtZ1g9F2VVtRh9SwIOn7uCT1Sp59RBeImxUZg1jJ8zeOmmQoxMj7cViOovs0akaJ55/UqJHhmKX3FB3njsPV2J+ZxJHEOCIrrU8MaXNbvOYObQFLxRoF0VARRBOmlAoub66kszu4UMIDqyTWO7LHK/e6GsYNkRjGVVtXh3n7YfWr/vHH5xVx/uszMwJU5jpRbmeJbgS4epngyzv9nzCWhXZ8wunSwDW4+XC40AbL8xkRGWKz7+YGU99tcNpCVAYjmMcCPP8j8OlWHj4TIsmZ6FkTfH46n3AkvN0xw5fuGqL2jmd7Oy0Texo8HH0B9YlDnLoyoa1MxQL9uxjv2jY+dNUx1Z7hNAdKRH6Jc2c1gqpg5M0nRwA1Nihe33APjVtH6Ii470WUaBxlyfdqLxPzp2wVQoqxF19MFOos/1WV17CJndO2gElV1rinogOXj2MrfimVcGXtj0pcZSb7ZPO0vz6sGsrKoW+ZyqiAsmKsLgvzYctdyfRwKykmN975DZ+VuJVt7g64Fzv1C1JdDqudB//9j4DMRFR2KobgVjze4SvL2bPxHxykpWg2DmvX97Zyken9CL63/NKyqiruo2eUAUDpRe1sQsqJk+ONlwP0RWQ9F5zhqhVIJUi0CzMSoQf1/9M2xHXL679wz+uqcx37WoH7G7OqJ+ltl92Hu6kruyBCjCtriiBluPl2uet3t0xWYeGptu+7qoV4r0E2d9ERR91+2G/7Cd/s4f40RLgMRyGBETGeHKflin8fp9g4NiBQh3ZEDTaXSKbmN6Hez6AaqLeqiF0d8PnLVd0erFWdno3L7Rh7WsqhZRkTdh9ogU07zJZgORF0rS/IW5mchKjsXr9w1GUUWNxr1B38FphN2Zyz7hxkpR/2hkmuE4rLO2c63+/LnRH9EMfUdv5jsXSEetHhC5PqsApr2yA/kqAebEmsK+++GKz02DupiF0KxYB7MgiZaAZRj9vb8ovsS9P8mdlGeNZ0EEGp8v9p48vnq/Rojyzv+1T09q/HR5kxne4HtXv27clGFmvLvvLMb16YLU+GjT54L33Lz6ySkU5I03CCOzVbwISfJlNeBde0DbZ5gtrYvwAkLBNiQtDvkWomXO2HSs0Ln+MHiWU5HVUDQBXrWz1Ff0iFWomzowiTv5meVHVT9Wblx/bnaNRmqhzOD1I7wgS/1KhX6CtXBiJrJ6xMIry8J7KkExUuifN7WRwCvbzOmsO4e9pysRF6MNFtUXQdGjn3D4mwu5NVuPzSCxHEaYpRlySr0s46G39rQ6ocxQ54u1cm1hqausrM+zhqdwZ9hpCdFYvavUMHjy9nWp5rpvuV2/1Cj6DYvqrqnzIjrSg5o6L2rqbmjur1duqCClwsoay9o/KqMzIDXmFF26uRCdotsYyq06cREqPO88QDU6sjGTZTAirw0DIscdAlAGIr0wd2JNsRrs1RZC3j717bwnO9kX6McmM1MHJXEHM0mQWHfHyQrEt4/ktuvhhqBIZkVjm+iFqPo4r209qSlQYzaZ4fkwO8XbIOB574j6ubD73JjdI33aQv0KjP5nHgDvzh+Nrh3baYJDrbASbEumZwknVGVVtfii+BJmDU/hVvEU+ZXzrIZdO7YTtpHtV12hTh0Ex96jpQ6LFan7NP25+Vuci+1XnRZQ07+qgmf1qyN6wcuebY9kYkyRgJJLNZbt9AJ4eOzNeKOgyBesywJ5PQ3/1YwdkrGoT0p8NPc4vAmHGytyrdV6bAaJ5TDCLcsyI1RC2a30R4Hw2Kp9kCTg7oGJlp3ZgB6dMCqjM6YOSsKe4kps+6qcW862b2JHbvqrxFglVyxLfRUhSXhwbBp3ifSp947i6feOIm9SpmaZXkZjsQ29BYQN3Gp2nKywvL9W1li19XKpzod00bpDiI6MwNC0eOvlVwRW1YvBsmgAwKEzVYbvA4m85g2IzB2C3Tc1gQhzs8FeX7XLTjvX7zvHFRa8fbCiGvpDv72rFDOHpRitghJ82UPiYowuH6Ll6nyOODK7Zmzw5WUAcIJoMsmeC7sR+yL3kJdmZ2tcj0QBX2qY/2xibGNw6J7iSkNcg/q+qH3aGTyL+bp5o6C3beqDDnnTI9G7IkqzZ/eWLN1UiIWTMjVlkyu+ue7onor6NIZe1HugBGXuKq60tV+uJRZKGsdfT+uH2Kg2GJrWWGXPrG9TB+TpUcSuZCnsIyQJc8amGYKKedlj9OJZ/Rzwnmt9v2C1Itdaq++5AYnlMMJNy7JbOBG+ZiIxFMgysH5/meV2LHtDYmwUpgyMwpC0OPz1izOG8376/SMaa0pWcizSE2Kw9Xi5kp8UilVgQW4fTB2YJFwilWG0ArPPX2pw02AWZNEymF3ri0jAWAbQyNql+JzeXbhC68VZ2UiJj9JkPOBhtUytX0LkVQtckMsPyGGYDQQii+OAHp3w7vzRmMZJS+WvMN96vFw4kbGa4IjaWVPnFaZNU5MYG4WHbks3pLFjgs7MH9Gu0CyqqObnqwZMr5lVifPnpvXD9RvKM7/zVKUvvR8Ps7SDdnzMDYJMAh4cm64RyozqunrTPlB/jRJjoxDf3ngf1X/2Tezgy2nMjs2770ykq99DfTYKXtvu7NdN+K7orYZOLLleaFfgZChZYPR9iGjcWDy5ryFokMfMYam4XHsD+RuVfnX36UrTsejXd/fDgB6xqK6r9/UDPBer/1zfmOc5f4ZicbU6f9ExPZJS2dFOTmXeBFc9IWMTmIqr1/D46v2a46grMvJS47HzBcxX5PS+1W7HgLR0SCyHEW5blt0gt393bD5y3rIj/emEWzBrhPLiLd/GT0MUrizd1JjAH2jMWbto7SFFADdsp1mm29i4TKe2BMgNFsupA5NMI9tFnK2qxZC0OFsZIOzsnyd27AbQANoct7zOespApdoXW4plAkaUhN8XYQ5ocgrb8VkckNxJ2E6rpUczIZgYG2XpH2oXdm1F11SGubXfjVymUwYkGsQy28eojM5Cf0Q7QtOs0MbC3ExLi7nZZOmOvo0C746+3TFnbJrBNYRtK1rCB+z7XDKr8esNmYOWb1NyKdt5dtRt4T0rVgLssCpHuVfmC07AaGH8/b2DbPWtmw6fx39/UIhf3KW4mJlNJO32JQA/ONMrK648b2wr1mSC0Rc4iZAkW0KZtVed95nlehcJ5vNV17TGjIl8FyuGDCCvIZi3uq7eNDUmz1UCaHzeec/bL+7q48jnl01gRNl3RO+uPuhv/rgM7u95vtVuxIC0JiRZbq1erY1cuXIFsbGxqKqqQseOHUPSBn/zKwcbD4Dl9w/BQ2/uMU9Yr7J8jF6ypVmJZQB4+Lab8aSqfHJZVS32nK70+UeIIqJFrJ47EmkJ0dhzuhJ7T1fij9uLbf1OahgN1NYks9l/WVWtIUiPoc6GoWbHyQrMXr7TsC+zwWX13JEYldHZdzz1IKC3UuflZuKR2zO426o/AyD0xxyTv8XQ4euDtJxuv2Z3CTdTiP5aBhLUIrq2etj15GHVTjN4/YjTfYiugyFXrMrvcmFD8JdIkJldF6v2BXI9zODlUGbtsXp2FkzsgwE9Opk+K+rf2EEtOEXv4i/u7I3//vC43VPEotxMdIpuY8uiWFZVqxSFKTglXAG5f2RPvLXztGEVpiBvPAAYhJyd+6Z2B6uuq0d6Qgz2CLJQzBnTEyu3WwcP61NmWq2Qsmd4QHInHDx72fc70UR/3rgM/HKieZl2f+Fdt5zeXQzvFq/fAxQD14cN9QDY71Pio7nvn1k/1Fqwq//IshwGOAmeyumV4LhMrogISUL+jP745TvipVEvgGs3vHjotnSsMLEYe2Ul7dYzd98aVKFs1ulJUEqo8ipDWbGi4BTmjE3jBkhYWSn0REgSDp697MuIwKv4JUI9CDHfYbPZvzpIjwV91dTdMGTDUCOyXq6bNwpnKmu5ljxe9SiAb6VmeZZ5QSL6z0T+rU6S39sN6rKyOLoR1GJnSduDxgBU3vH8jUbn9SPq4g287b8ovgRJkjBElyJQf0zefZZkYFmDj+/W4+W+gduuZZ+xYGIfQ0U/J/fNH8ws3aJnR1310E4RHfab9/afs5wss7LNrBhOdKTH4CctAfgfB0IZUFwm1HmCWT+d07sLABiu9woToQwAb31+2lCsY0FuH+6+rHIFMxc2wzMrATOHpXCPn9GlvW33swHJjRlnTlz8xldqmweLYWBVIlmqzehIj0/AL8jt48sP/uqnJ5HaOToobgy8ipi8d0u0Arf58Hmsnz/a4MvcmqvvuQGJ5TDASX7l797azVQs2/UdA5RBKjnO+mUxS36vxgvg6SbI62zWWQ5Ji+OKZbXPrMhHV1Te94XNX2JhbqbP2mDYt6QIBxbct2BiH03wHlsiYxZjJ3hlYOX2Ijw56VbLbRNjo2z5pYnEKCsze/X6t64LVac4EUhOXBeCHeXNu7a8stWPrdpnauXzp50iP0114CSDFyTGfDjt7lsGcODMZQzuGWe5xMuuC88o8MLmLwFA48Orvy5OroedICarbBj6Z8efDANmq4WDUzvhQGmV8B1byamo548RQobRT94LYOE7B1HQUI7bKuOCWRu8MpC/sdDnMqG/Nvr7ZqeSnVcG1nDyX0sA7ujbDW0iPJbGJX3GmbSEaDz13hHL/PDq4j7qvlTf1mC7MajdMszKT/NSosoA/vrFGfzXPVma/YmKJrHv7dJagwRJLIcBTgIszGbHgNjnjUdyp6iA0vTYOT5bDouQJMvKb2oezlEs2bwB+qVZ2Th/5Zphf0pnbYxOVqd24pXgZe00K++rtlKoXR7Uy2RM2HGFRYMVLj6mrWaZT+92wfONW7G1yJexwAwnuYnNxGiwhKpT7AokvRCzyjhhF38HBZ4V8hd39TFkSHB7wLV7L/RV/ADlmTNbxRD1Eyu2FiErOda2ZT86MoIbwGQ3DZ0VdkWt6Hx4z47d98qsapsaCYrldNkPB5u6NNnBKnDW0/Cd/nu1wYWdDy/jgm8/NgPgzO6d01gJ/SoqK7RilaFEVEgjf4a2j9D3tU4LozgxCjjpS6xywbPjpiVE415BBcq/7CxBanw0Hrk9w/eZqGgSy6H9SE6GYT96gl0oKpwhsRwG8CKzm8J3+fHV+5A/I8uvQDQ7eKTGJeCyqlo8//+3d+fhUVTp/sC/HZaYBJIQ1gAJq4TFJIDwQ1YJOsoyF1G8oqgjDKIOOs696tUwV6545zosMqMzooLooDOOig7gMgyLCgghDKLsDoKJgSAJOyQYQgL0+f0RqumuOlVd1V3VS/r7eR6fRzrd1ae7qk6/deo97/nHXlOfK84FjMlOx5jsdE2HqCwLDECzvQYuF/p2aIZb+7TzKQx/q2qJW0C7NLF352o0EUyd8qAu5VVeUY1TVbWa0Wulbcrrr+uU5gmmlCC+Y4tE/KmgRFrJwEynbNSxKn/37qyNglGrgaodk+OC5V3OKljB/CjovVZWIcGOUXiF2X2htyqgcndFLzVmyhB5lQ3ZBareBVO/jmma58ru9ATyvVi5WNT0uahb4lt2UbpYUtVG3T71PjdatU3gyqRZ73xRq7XMXS7gw2mD8M+SU9LqOnEAZo3Pxt93lWOjn9Q9WcWFOFfd8uDxjeKQ2z4VTy011za9fWflDqoL0LTZe6EV9ZLUyqBMTjv9PHJZeoPeuWKmrXEu39rwevT6A1kALUsB1NwtdtVVcDJa+AjQTlwH5IsmedfQ9g6u1ZxaKCpaMFiOELIT2ai0l9rEAFZQEqjLX9s0fYR01DRYblG3ZGyr5KsMb8PKXnfrK4WYdVu2pkP07tBkgQFQt9qXN9lqVnqjp2YDDlkwqbfIiHobRoHYz4doc8PNjtTqjSwWfHccExcVm540aFW4V3xS558qwUignXgwPwpGr01q3EBz29TuvEEz+6JTiyRpnxLnMi79pndsyspn6V0wyYJUWXfgrwydjNWUIDPfVXlFteYCAfD9rmT73N+qbVYXSpF5eHgXVNVewtjctoCAp154XbDeGZOHdAQAw3J93p/nxI/nMaxbSzw5MsuzQNEHX9f1pW/jEK5pm4x/lVX6ramuPqaNVqN0AT451YB8KWdA+515Lw0OF3zy7vV4B8PDurXUXfRF786D93nj/Tul9KfqAFivPzhz7oIm7WhYt5aa585ZJVkoS0BTaURGb5BF7ziTBdf+XmfnxX6kY7AcQbwDMO+OfM/hM3hOMnKgUCbZvLf1kOURaeWEUuoMK6OmK3aVW0qb0PN/K/bit//Y6+kMZo7tiQ+3Hca2QxXG7RJXRl/0OjS9AvtmT2i90dNAgj9pEXxXXcqIsmKf7HnqQEy5XegdTEy5/KPnjyzQv/ma1nh5fbHnOU6NBvgbiXYyz81fJ271vYP5UdB77eJNJXWBpipQdmIU3t++UI4xn5zlyz/YZl4nC4r9nTPe+8D7uSeraqRVD+4f5j/tSC2QlCB/35XeKPyQri08r/v64Glprrj3qm1qZhdK0dOjdRO8sr4Y89cVe4KtTdNHaL5/swuOuMWVFRIB+QWMUu7O5QJG9dIvKfrkyCsDE0arUapT2BIbx+GH09W6c2RkF3NWawebvWOUnpKAp0Z1l47YqwNmpT+VtUWWB35JCJ9a1co2/nBXb+1xJPl+BczdPdM79vVynf3dwXQy5S4aMFiOELIf9PSUBMxbvc8npUDN+/b+rNuu1AY2ywVtB5SekqBbb3L5tEGGHZqMWwBPLd1teWU/JUBRAnkZ9Y+dXSe02TQEhXRylQCaN4n3O3qkN2KyuOAAXi/4Hq9tLMHrkvqvMuqlhcdJlhYO9WhAMCkNZgJdo30eyHsHcwxJV4ZzAYs2+I7IGlWpCAXvUTmXC9LFOIxep1enWbYNvX2gXMjorSpold0pQUpNaVm/VVB0AuUV1diw/7h05Fa9aptsnoPf1BAXcGf/TLy3tVTTZ+w9emU5ebe4codQXQbM6pwUM08TAlj9zVHMHNsT/yOZ0J3TPhVAYKtR/n2X/iJS9w/prMkRV29/+uXayXrVX6zcMcpul6L97JJ2XRICXx84rbsCo+z4lv0GQGj/JsutjgMASf/00PDOeHVdsWb5a7X0lLoVZ9UXAmYuLCMl5S4cGCxHAL0fk52HThsGygAwro/qtsnlnt1sYDp1aGfNwa4UhFd7amR35GY0C3ilQauJHcqtQb0SWzLhOqGDWWZXr5PyXsHMyoiwErToLYkdyC3uQAWT0mBlFEgvJSeQ9w7mGJK99udDOuquqBdO6Sl1K1YG8jq9lAX1LeivDpzyeyfFzvPV6l0hvYsxfxPt3ALYdvC0tPycepKg9x077xrjn+w8rCnbJ2t/bkYK8pftNhxNdANYXHDAp1a88t6BDKL4c0kINE+KN+zLrK5GWV5RjTcKtCkvQN3v2WTVHTa96i/jXinEbElfYfWOkd6S6LJAVf2Y92fVVKEY5VstSdnGtR3l6UwATD02oX8m7rmug6lj/8FhXXxSd8yed+FOuQsnBsthJr06XlZ3dfzlgVN+X6/k4wKQpgEYjSjIOiCg7rai7GXtm9WdGHZW0PjViK54aV2R/HaT8F1y2exopN0ntJnRTSu5zmYnYQWbH6a3n4xWWrNboJ/DapCt3ucA8PddZQF/h8EcQ7K2vKGaJGb37ctwlnOqW8yixLNyp3K7ffn2w9LzWu9Oil3nq9m7QkYTr/zNrag7r4T0OX+8s49nZUtZu/yV7VO3f1i3lqZGGpRa8YDvZN4J/TORFN9Qmu5i9W6ftx9OV2vyz71TxvT6n10/nJEGy3q5tMr3o06p0tu+0OkrrN4xMroIVz92bYdmllbeS01oZCmdyexjVu6IPnh9F+lEdX+s3nWtL6I6WD5w4AB+85vfYO3atThy5Ajatm2Le+65B//93/+Nxo0bh7t5pujdvh/3ciGm5fkv5aL88AhoO24zkwM37D+umZxwqqpG+lxlZEPdiQQqzgXcOSATbZsl+Nx6vOv/ZeKdLaWma1rqpbDYcUJbuY1vZZldM5Owgk0nkd3WfcpkiSC7BPo5AgmyvYMRvWDHyncYzDGkfq2TdzvCWc5J9l27BfymjslSv6x+H/4uEIz+bnQxZmai3f1DOksre3hX65G1A4Bu2b7Exg3Qr2Oa9MLZTC/rFsBLa7/Du1sOaSbzyoI55b39LXT16IiuqDx/AW8WHvR5fO6qfZ45JXopY9OGd8H8dcU+r5uz8ltc1zlNkyqhF/xOy+uCCf0zpfnPej8/sr7CaKDC6oI4ssfUVZi87/qqj2+r6UxmH7MqVgPfQER1sPztt9/C7XZj4cKF6Nq1K/bs2YOpU6eiqqoK8+bNC3fzTNG9Ogbw6rpi5GW1xLp9x3Vf7/3DI+u4nxyZ5cmVU/9dQH9ygpoLdQt+KJ3KsG4tsWzaQIx7pVDTYY2+pg1WfnPE87gLdTUyl2077NPpKxOK1B1HyYkq/HVLqc829QIlJwOFQFIIzHY+/p5n1+3pcN82C/RzBBpkG40KhjPHzqn9EM5yTlZLnQHW94FsKWT1BZHsvPf3d6OLMX93zuJw5Y7cnf8v40pwCt/JbbJ2TBnSSbdsn95dNLN38lwA3tlypSKS+ljQq0ZUUKQfKE8fXXdxXVh8QhMsK99XYuM4LNr4vc/gxvRlu3Hm3AWfycWedkGeKpGekoCnRnb3qbkNAAvWf4+berbWHOdWL8gA7ZyOqtpLWLih2JMWYXZBHPVj5RXVpqowGW2DIltUB8sjR47EyJEjPf/u3Lkz9u3bh1dffTVqgmWjTswNYP3+45g0qIOmowKuLDWqXBHLgpIJ/TM9t1pO/HheuiCAbHKCz2IZqKvXqQ6o7x/SSXpl37dDMzx4fWf8cLoaQsBTDaJbm6Y+Kz2pvwfvjsPs4gpOBgrhLpVjV4AV7k45kM8RaJCtNyo4Y0wPjM5JD+v34MR+COcxarXUGQA8NLyzqYtZdWqHQrk7ol4h0/u8N9MvyMrneddT9z72XABweaKVchwqE/u8X+9GXUkvuOomhyU1bqBph15OrmcbkrampyRoRi2HXd0Cg69u4VncSK8En/exoLcojFsAY7LbYMXuI5rX57RL9Xxfsj551w9nMFtS3swtoAl6vXmnSgBX0kay26dIP8PWA9qKI3r89RXpKQnSZbaVdgfyGxLu3wpyXlQHyzIVFRVIS0szfE5NTQ1qaq6kGlRWVjrdLENGKxIJAfx580E8PLwLFnzxvU8B/eZJ8Zor4td+1hfrvj2OvO4tcUOPNgB8l86UdXinq2uleV/KinNKkKqsTw8Y1xL9vxV7NVfo5RXVmCMpl2NmwQAn83qNREKpnHAHusHyvr0py1M0EkiQrbfPwh0oOyWcx2ggcxdeXV+Me67rYLgvjNJo3AKayVGA73lvpl/YsN/3bp0L8OSjFhaf8NTgVWr4ZjRL8FRwAOr6Qr0RYqXKgCwFzi3qauK/++Uh3dQKdVtlo5abik5izu05GJvb1rAEnwvAyaoazyRpvdSRB4Z1xj92H9Gt7y7rk5WJaoFm4l0SwpO+ofyG3dk/Q1oRon9HeRqJtzgAL10uo2p0fPm7IxLIb0gk/FYEIlaXrg5EvQqWi4qK8NJLL/kdVZ41axaeffbZELXKHGVFItmsZbcAXllfjPzR3T0rFAHa4PUprxJGb28pxfi+7fC7O3r7bOv+y6twKSPG4/q0xTM6S2j/cKYaY3LqJqrI6he7AUzsn4klWw9pcpfVwbATCwY43UHZlQoRq+xIkbF6sRBr+8yJz2v2B1SWE69X6kzhFsa1XM2kdsjmYsThympq/voF9SI2QN2dtDPnLnj6VPUkReX4HdilubQvlNF7yjtfHsL00d3RLiUBZ6prMePDbwwXITLqO5WymrKBEKUNj7yz3ef8kx0vshXx1MeRehn3qtpLlu8seIuDtuKPsrCW9/4VAvhnySlMGdLJM1G2gcuFcX3aamo2K79XRvzdEQnkN2TD/uOaiwaz9fHDJZaXrg6ESwgblmqzWX5+PubMmWP4nL1796J79+6efx8+fBjXX389hg8fjtdff93wtbKR5YyMDFRUVCA5OTm4xgdp56HT0jxg4PJqbPl5SE+pKws2cdEWv9v76OFByM1oJh2tUTIh9A4A7/crr6j2Cc4Vym3RBi6XdBGTd6deh4Fdmktf7739QC3ZWipNPbFTeUV1TJbKCYZT+9vK+0fiPnNqJMeuz2tlaV699/Y+J9X8HQNm+jX1XAyFd3sff3+HT9qC98CB3nv4mwyttB2AtC+0Is4FbMofgfSUBJ+cWVkfZvZc8v7eZfV51f257HgxOo40SzGr0mFklO9UFtxOGdIRr0lWRzTiAjDVa1nyQI57vd8yQP/79zeRVG97kRqEhrt/jiSVlZVISUnxG/9F5Mjy448/jkmTJhk+p3Pnzp7/LysrQ15eHgYNGoTXXnvN7/bj4+MRHx8fbDMdkZvRDLN1cpi9R2LN3gL96vJy07Lt+evrvd/Pk1utGvl2C2Duyn3S4uv+buPZMeIXigls0Z4KEQ7hzuGLxH3m5EiOd6pVYfGJgIJxK0vzGk2A8j4nNxUdxyvri30CQVmw7a8cmMI7mLmuc5rPwILS3u5tmhpOttJbOMZfX+o9mjvrtmxNzrKM3naVEfYN+497Ak4X6iYIqo8J9ailC8DPJaOW3t+73vwU7/7caD/I/qY+Nuau3IenRnb3XLR4z3PxtNUFTL289HZ6SgKeuDnLJ7XldVVJRX8EgDc2HvAsWhPIeS5NKRmZhZz2qZrfEDPnrNFIdSgn3FoR7v45GkVksNyyZUu0bNnS1HMPHz6MvLw8XHvttVi8eDHi4uIcbp3z9HKY41xXbjXKJqHIztd+HZsFNBEH0N6O0qvXqVd8XXYbz4nANhIDo1gXrTl8/gQ6MhyKqhXBBuN6P6CypXnNLOySnlK3GMfdBgslyNo867ZszSIc43q3xU96tvbJR62qvaS5A6c3GUx24a/Ov1UmH+vxPn71JssBVwJko+0qfbm6Nv7cVfswtveVkmOylBEBYNHGErwhWdXT3/wUvfNv4RfFnv3sAnDXgAwM7NzcU8pO79jIaZ+Kgvw8z/49VnlecwHzRkGJp3qIepK4UT1uPXYEdWZ+i8yes/4u8CIxCK2v/bOTIjJYNuvw4cMYPnw4OnTogHnz5uH48SuTNtq0aRPGlgVPnUMG1B3Yt75S6Okg1Se8emns8X3bITejmW4+G1DXMbpcV/IA1bO+1Se41eLrimAmelF0UucYRnvucDDBqNMjOXYE42ZHXM0uKuN9USEbqdRb3W/ZtIGaK/8Pd5Thox1lPot36P3gyyaDxcF3opts4RjZqqXega/6+NWbLKdezjk1oZHvIiSXjx1Zzq/6uw101NLKnbyFG4p9KlcI1JWge2fLIc+CIMO6tdTt9733b8mJKukFzIET5wBoV9T8cHsZlk8bhBW7yzVLwuuxK6jzN8hi9pxVf9dOtddOsTa3ww5RHSx/+umnKCoqQlFREdq3b+/ztwhMxbZMNsKs7iC9T/gnbs5C78xUHK+swQ09WnmKvuudzMoJov7RMLra9neSyTogTiSILd772wXgAa8cw2gVbDDq9EiOHcG4UcUDK+3W5LaO7I7s9inSGslqysiwrPcWMLdUdm5GM+ldN/VEN+++qrD4hPQ9/3hnHzRvEi/tD43e35sSmH994DRcLnhGx82M/gYzaml29HS2UYk3ANOX7sbyhweZuvg1Os6Nlr/+9eieGJOdrr2bCuB61VoD3ot9OMnKOev9Xe86fManSlWkBqH+jo9QVcqIloocUR0sT5o0yW9uc7Srqr2k6cRlHaT6B6pdswSfTltdjN175AOA5krZiJV0inAumkChp97f6hzDaBVsMOr0SI5dwbjs3NZbmldGdr4ro5ZmJoXpjQwrzC6V7R2gPvre9oBupSur8RntI7N9YXpKAn6aay7YBuCTd240aukCdPexmSBENhKspiwiIkxc/Po7zo2OUfXd1DgAvxjeBa9+4buwib/FPuxi9ZxVLr5KT135TiN9zE5vdD1UA1zRNJAW1cFyNDN7NWXmR9BsQGpnbq/ZbXEiQWypr/tbL0VBmUNghpOTUe0MxtXntpV2+0sb8Bcoe48My0af46ANDvX6ovSUBKQ1CexWupXvL5h+Vf3dbth/3Kd83ZQhnfDzIZ1QkJ+HbQdP42F1LWWXfLtmgxCzE8U9wR/8X/zqHS9mvuMJ/TNxpvoCZl8+Tl5ZX2xqsMgpVs/ZnYdO+6TcqO+GRANZPDF96W4kxTfEtX5qWAf7PpH8XTFYDgMrV1PqDiYO2vqNdgQoTt0K4USC2FJf97dshE89h8Dsdpz6IXA6GA803cSb7HHZYhLKZ1m8qcQnl1WgbpKY2e870FvpobwtrXy3suBh0cYSvL6xBLPHZ6Po2I+a1wqhrVttJQiR1Qf2Jps4bua3Re94MfMdey90ImtapC4MtWRrad3EVNXj0TZYIIsn3NCmMTnxPpH8XUV/6Ygoo9eRlVdU675mQv9MFOTn4YGhnQEX8NrGEgyevRZLtpYCuPKD4M1Kh7JkaykGz16LiYu2+GzXDkqQ0cDl8rQrUnO4KHj1eX9P6J+JZdMG+gzmmTl/Qyk9JcGzUEW43t97//vTwOXCrPHZGJOjzUNNT0nA5MGd4L0pZaTO7Pdt9XjU+/6c7CMVeqPySt7w65KlsmUj7UZBiDdZpY041NXmf3liH8y/qw8+fHhQUL8tMkbHqJnKTU+Ocj4FQ6GUYvR3vHm+S522/2XzAfsb5xBZPKGws78LNm4JNY4sh5i/qymj0Qv1akfeowWB3kLUC967t2mKqtpLtoyihKIWMkWO+ry/zc4hiGXqyU5zV+6T5tvGuYBl0wZqJsR5s2P0KdjjMVS3i41G5d2AdJj1/mHa3GGzo+l6I4g/nK72WQkvlFUTzKSF5LRLdeS91czeAS6vqMbfd5UZtvkfe45g56HThsd6pEx085cnb1d/5/Q8DrsxWA4xo47M6OT096MR6A+C3naVWcl23XZx8vYzRZ76ur/ra5qJ3ZT9P7BLc4zNbYsVu8o1K3y6BXCu1q2zhTp2fd/BHI+hul2sBA96udqQ5MzLcofNBiFJjRtI2/HIO9vxY81FT58fyotff4FaqM41sxdIRpVd1L46oB8s2z3RLdjAW2+CLGDvPoimgRWmYYSY3m1BQFuD0vt2h5lbFoHcgtW75aKcG5F2m5konOpzmolT0lMSMCYnPaBbrpHwfev1kbt+OGP7e03on4lN+SPwwLBOnh9nJVVF/T3Mui1b93tQUvfenXodlk0biIy0RE0fXlV7SfpaWapLKNN7vNs+fXT3sOx7M6ks6oDan34d5YFyIKmZRuxKGUpPScBPc9s6fv6FO3XMLI4sh4Hsaqqw+ITh6IVTtyw0EwgDXISAKFZE02hIpAim/wr3952ekoCnRnXHLNWiJerV9tQCHd1LT0nAr0f3xOTBnTSf2cr3kJ6SoFkxz3vEcvfhCt3XXhICK3aVY0xOeliOb/WdiVDve2n1G/jmh+vlV88Y0wNfHTyNlXuOeB4b37cdWiVfJV2K3s47F06kDIX7/IsUDJbDRH1bsFOLJM3MY5fL9+R06qBV12C+9ZVCzcm76/AZrrxHdFl9TTNxUjD9V7i/7+x2KZrHjAIaO26ryz6zle/BKHAC6sr4Gfm/FXvx23/sjYjat8LU2n72US7u1GXgvCux6KUIjc5Jx5ShnbHz0Gl8deA0+nVshm+PnPUpCej9ndqZ2uVUylC4z79IwDSMCHGs8ry2O5D0D07dslC2m5vRDE+N7K75+9yV+5iKQURBsdJ/+atEYLZSgR2szNy3+7Z6oIwCJzNVJ4Dwp+GFogqJnmHdWhpWYvGXIpSb0QxThnZGq+SrDI8HO1ONoqXCRCjPXbtwZDkCKPUZ1QS0NTRDIbu9tVEUIjIWKTPdo4W/kdlQr/zlL43Ee//qBamhTmvwN2IpW2Tnkbyu+OPaIp/t2N33mzkXyiuq8fVB3wU+7KxCYnZ1Q3+jtOq7slW1l1BeUW05zcKuu8aytMpQltozI5pW7fPGYDmMZB2Ct3BdEXLGP5F9ovXHIVz85V06kZdpJnjSC2jU+/epkd2lcz8CSWsI5iLLKMBfsrXUpyawC3WrBd7QoxXmrytyrO83cy4YVZiwI3APZnVD2XfhLzfcynbsCGon9M/EmXNXVkGcs/JbpCY0iog+J9pW7fPGNIwwUW4vPfLOdmmgHAeEbZZ9JMxAJ6oPIuWWfDTxV4nAyqIbZm71WrnVr04jke3fuav24alRV6o4eLOy/+1IQfCuLFGQn4cJ/TM1SzIDdXcxF20swa2vFOLWPu0c6fvNnAv+KkwEG7hbOR/N/g7622aof0/LK6oxZ9W3jle0CiSVwuy5G4k4shwG/jqEOBewfNogwwLmTuMMWKLgRduSrpHA30icmZE6KwtKBDPSpbd/c9qloiA/T1pf2sz+t3MEznvEUm9JZoVbAB9uL8OyaQNx6FQ14AKu7WDP75CZc8Eol9qOINPq+WjmdzCUaRZmhKLPCeRuWXlFNU7+WBO1d60ZLIeBmQ4hnIGygjNgiYLDlCbr/OUHG/3daq5rsIGF0f5V6kv/9h97Le9/JwIef0sye7/Pil1HPCvGWgmGjFJGzJwL0pJtLuCPd/bBtR2bBf17FMj56O93MNRpFv443ecEciHnHVy7UFfpS4joumvNYDkMnO4QiCgyOFUfvb7zNxIn+3sgua7BBhbBBPYKWZCZ1LiBppRosAGP2QoYcYAnUAasB0N6wbWZ70LvOT/Nbat+y4A4cT5G2jnudHusXsipg2sBIE4A8yf2Qd8O0RPvuITwd51Z/1VWViIlJQUVFRVITk4OyXsu2VqqOZgjIQGfiOxXXlHNlCYHlVdUe+rYyjRwuVCQn6dbEznYvtjf/tX7uyzIBKAJ+u34jfD3HSnvM2VIR7y2sUTzt3enXiettS/brtH3beZccPp8cWL7kXaOO9Ueq/u7sPgEJi7aonlc73gKNbPxH0eWw4Q5wUSxgylNzgom19WOvtjf/pX9XXY7e/rS3YDkruOyaQN1U/PMVsxQRhz1Rt9njOmB0Tnp+HhHmeZvRqPaeiON2w6expgcbXvMnAtOny9ObD/SznGn2mN15Lq+pKIxWA6jSDu5iChwrKUcPsGmtnn3xaHaj7Ig0w1oFqNyC+BcrVu6DasTrSb0z0T3Nk0x7uVCTYrH6Jx0AMCcVdqV/Yxq9cq+ewB45J3t+LHmIu+Y1kNWLjAjLU0lUAyWiYiCFMu1lCPhIsGuXFcr+zHYzy0N8AHNyLKVlQKnL92NpPiGuNYgFzQ3oxlmj5cHL4XFJ6Sjzu1TrY9YC0RPDV2yzspgX324k86cZYQnZzkYkfDjRER1rObw1SeRdpEQTJ6mlf1o9XPr9dmyfGkApnKo9XJBAfNtUn9XennNLgCzxxtv75Odh/HLd3doHo+U3FSqY3f8EO3xCHOW66lI+3EiinWxWks5ElfjCia1zex+tPq5ZX32sG4tUXKiCsO6tURBfp4maDUzCqeX/mCmTYD8uwpmlLhfxzRNBQ+XC1GXm1qf2R0/xFI8whX8oghXAyOKPErQ4i0aJ7BYFc2rccmY3Y9WPresz85futtnZb4N+4/7rAoIaFcKlFECW9lKgUZt8mdC/0z84c7e9mwv5u9bRw6744dYi0cYLEeR+vbjRFQfqIOWaJ3AYlWkXCR4L7sbyBK8CrP70crnlvXZAtANMKy2X1nOev5dfWzdF/06plneXsmJKk1sLAD+PkUIu+OHWItHmIYRRepLCRai+qY+TGCxKhJmuatXBgMuL3oQ4C1h7/2Y2DgOVbWXUF5RbWrhDFk1DaNUCYUSYGzYfzygW9rpKQn4aW4Cqmov+t0XVsvMWdm3/H0Kr2BWUAwk7zjW9jcn+CG6JvhxMRMiiiThWowhmIVI/DHKxVQCi6TGDXCu1u3zufUWGVH67DjUBfPqsm3Lpg3Era8UBj1J1GhfBJJfanXfhvv3KZInmznZNrP7Vm9CaaB5x+He33YwG/8xWEZ0BctA5K0UREQUakbVIBSBVGIwqophNPpr9DoAnj57w/7jmgAjIy3R0VXOQlmxxervk11BZCRPNnOybcGsoAhA89o4F7B82iDdRXCMtheN8QirYdRjXMyEiMIpEkbw/KU4BHpL2GhFOqMqGEY5nN6T9WQpO+UV1Y7e0naiYoveMWDl98muEnyRWJklVG2zum+994+srrZbAONeLvRbKhCIjH4gVBgsExGRaZEygqfOq3VdrlsmYG2SpfoHXy8X0y2EYVBiNodTFmA4nf9td36pHceAHSX4lPeM5PKNTrctmH2rd8GpVyrQ+9gNNMc+WjFYJiIiUyJtBE89SgvAco6t7AdfFrgqFSL0gpL0lAQ8Nao75qz8Fm4hD9iNAj4rk0StjujZGYzbdQxYCSL9vWckTzZzum3B7Fu9utqAdl+oj10hruTeh7sfCAUGy0REZEokjuCpb/ubbYdRAKYXuBoFJUu2lnoCZReAJ0dm+Yy0mQkyzaQwBDqqa1fFFruOgU4tkrSLmEC+iIm/94yEyix6QtG2YPbthP6Z6N6mKca9XKiZeKrsC9mxqxbufsBpDJaJiMiUSB7Bs8pMAKb+4dcLStTBhAAwd9U+jO3d1vMcf3VpzYwUBzuqa8d8F7uOgWOV57UPytdXMfWekVy+MRRtC2bf5mY0w+zx+gG97NhVi9Z+wCwGy0REZEokj+BZFWjQJwtKzIy26r3frsNncPfr/zQ1UhwJI/t2HANLtpYif+lu7SImAtLPYvY9I3nyeyS3DTAO6GXHrssFuATgRmwsxMRgmYiITIvkETwr7Az8zQTesvd7cmSWJ3UD8D9SHCkj+8EcA8rouGyg0uiz1Jfjzi5OVKLQC+j1zpVY2h8MlomIyJJIHyUzy64AzGzgrX6/QMp+RcrIfqDHgN4t/TgX/H6W+nLcBSscFWn0zhW9/VHfysoxWCYiophlVwBmNvBWv5/VkeJoH2GVjY7HwdpCGLHMiYo0VpZBD6bKTDSLC3cDiIiI6oP0lASfBUjMPH/Wbdlo4Kqb2WZ2pNjq+0SC8opqFBafAADNZ541PtvSinGFxSdQXlHtWFsjmb+JolYt2VqKwbPXYuKiLRg8ey2WbC0Nqn16wXy07y+OLBMRUcxTRteSGjdAVe2lkN0+jvaRYjNkI40F+XmWP7Ndi6FEc3qAnXnrToxSR8IkVCcwWCYiopjmHYQpQnn72GoqSDQFfHoBWUF+HgZ2aR70dqwEdvUhPcDOvHUnAttImYRqNwbLREQUs9RBmMKpVcmCDXSjLeCzKyALdjtOrz4ZygsYu+5GOBHYRtIkVDsxWCYiophltOCC3bePgw10I225cTPsCsiC3Y6T6QHhuICxY2KqU4FtfUwt4gQ/IiKKWUoQJmPn7WM7Jj7ZPbkrFAKdxGj3dmT72Y79G+0T2ib0z0RBfh7enXodCvLzbAvyo3ESqhGOLBMRUcxSj64p7L59bMfIZrTmg9o10hjMdpwaRa0PE9pYv9o/BstERBTTvIOwxMZxOFfrtv32sR2BbjTng9oVkAWzHSfSA6L1AoascQkhdLK1YkdlZSVSUlJQUVGB5OTkcDeHiIjqoSVbSzWBrtFtb71JY+UV1fUqHzTaWd2vFDnMxn8MlsFgmYiIQsNsoBttVS9iHS9gopPZ+I9pGERERCFiJo0gmKoX0VSDuT5h3m/9xmCZiIgoggQ6aczfaLRTgTQDdKrvGCwTERFFkEAmjfkbjXYqrYPpIhQLWGeZiIgoggRSU9hoNNqpWsDRXmOYyCyOLBMREUUYq2XOjEajnaoFXB9qDBOZwZFlIiKiCGRlFTSj0WinVq9zarsUOcorqlFYfCLm7xZwZJmIiKge0BuNdmoxk2heJIX8Yz76FayzDNZZJiKi+s+pWsCsMVz/lFdUY/DstZq0noL8vHq1j1lnmYiIiDycqgXMGsP1D/PRfTFnmYiIKIowj5Scxnx0X/UmWK6pqUHv3r3hcrmwY8eOcDeHiIjIdku2lmLw7LWYuGgLBs9eiyVbS8PdJKqHAilfWJ/VmzSMJ598Em3btsXOnTvD3RQiIiLbBbMMdqTgan/Rw2r5wvqsXgTLK1euxJo1a7B06VKsXLky3M0hIiKyXbTnkbK6QvRhPnqdqE/DOHr0KKZOnYq//OUvSEyMzVwaIiKq/6I5j5Sr/VE0i+pgWQiBSZMm4aGHHkK/fv1Mv66mpgaVlZU+/xEREUWyaM4jNRoVJ4p0EZmGkZ+fjzlz5hg+Z+/evVizZg3Onj2L6dOnW9r+rFmz8OyzzwbTRCIiopCL1jxSo+W4iSJdRC5Kcvz4cZw8edLwOZ07d8Ydd9yBTz75BC7XlftSly5dQoMGDXD33Xfjrbfekr62pqYGNTU1nn9XVlYiIyODi5IQERE5ZMnWUs1qf8xZDh4nTQbO7KIkERksm1VaWuqTQlFWVoabb74Zf/vb3zBgwAC0b9/e1Ha4gh8REZHzuNqfvThpMjgxsYJfZqbvAdGkSRMAQJcuXUwHykRERBQa/qorcJTUvPpQSjBaRHWwTERERPUDR0mtifZSgtGkXgXLHTt2RBRnlRAREcUkjpJax0mToRPVpeOIiIgo+rG0nHVOlRIsr6hGYfEJ1sD2Uq9GlomIiCj6cJQ0MHaXEmQqjBxHlomIiCisonnBlXBLT0nAwC7NbRlR5iqLchxZJiIiorCL1gVX6gtOGNTHYJmIiIgigr/ScuQcpsLoYxoGERERUYxjKow+jiwTEREREVNhdDBYJiIiiiFcJY+MMBVGi8EyERFRjGBpMCLrmLNMREQUA1gajCgwDJaJiIhiAFfJIwoMg2UiIqIYoJQG88bSYET+MVgmIiKKASwNRhQYTvAjIiKKESwNRmQdg2UiIqIYwtJgRNYwDYOIiIiISAeDZSIiIiIiHQyWiYiIiIh0MFgmIiIiItLBYJmIiIiISAeDZSIiIiIiHQyWiYiIiIh0MFgmIiIiItLBYJmIiIiISAdX8CMiIiKisCmvqMbXB09DCIF+HdMiboVJBstEREREFBZLtpYif+luiMv/dgGYPT4bE/pnhrNZPpiGQUREREQhV15RjenLrgTKACAATF+6G+UV1eFqlgaDZSIiIiIKuZITVXAL7eNuAAdOnAt5e/QwWCYiIiKikOvUIglxLu3jcQA6tkgMeXv0MFgmIiIiopBLT0nArNuy4fIKmF0AZo3PjqhJfpzgR0RERERhMaF/JoZ1a4ltB09DCODajs0iKlAGGCwTERERURilpyRgTE5kBcjemIZBRERERKSDwTIRERERkQ4Gy0REREREOhgsExERERHpYLBMRERERKSDwTIRERERkQ4Gy0REREREOhgsExERERHpYLBMRERERKSDwTIRERERkQ4Gy0REREREOhgsExERERHpYLBMRERERKSDwTIRERERkQ4Gy0REREREOhqGuwGRQAgBAKisrAxzS4iIiIgoFJS4T4kD9TBYBnD27FkAQEZGRphbQkREREShdPbsWaSkpOj+3SX8hdMxwO12o6ysDE2bNoXL5QpoG5WVlcjIyMChQ4eQnJxscwspEnGfxybu99jDfR57uM9jgxACZ8+eRdu2bREXp5+ZzJFlAHFxcWjfvr0t20pOTuaJFWO4z2MT93vs4T6PPdzn9Z/RiLKCE/yIiIiIiHQwWCYiIiIi0sFg2Sbx8fF45plnEB8fH+6mUIhwn8cm7vfYw30ee7jPyRsn+BERERER6eDIMhERERGRDgbLREREREQ6GCwTEREREelgsExEREREpIPBchCee+45DBo0CImJiUhNTTX1GiEE/ud//gfp6elISEjAjTfeiO+++87ZhpJtTp06hbvvvhvJyclITU3FlClT8OOPPxq+5siRI7j33nvRpk0bJCUloW/fvli6dGmIWkzBCmSfA8DmzZsxYsQIJCUlITk5GcOGDUN1dXUIWkx2CHS/A3X9/KhRo+ByufDhhx8621CyjdV9furUKfzyl79EVlYWEhISkJmZiUcffRQVFRUhbDWFAoPlINTW1uLf//3f8Ytf/ML0a+bOnYs//vGPWLBgAbZs2YKkpCTcfPPNOH/+vIMtJbvcfffd+Oabb/Dpp5/i73//OzZs2IAHHnjA8DU/+9nPsG/fPnz88cfYvXs3brvtNtxxxx3Yvn17iFpNwQhkn2/evBkjR47ETTfdhC+//BJbt27FI488YricKkWWQPa74sUXX4TL5XK4hWQ3q/u8rKwMZWVlmDdvHvbs2YM333wTq1atwpQpU0LYagoJQUFbvHixSElJ8fs8t9st2rRpI55//nnPY2fOnBHx8fHi3XffdbCFZId//etfAoDYunWr57GVK1cKl8slDh8+rPu6pKQk8ec//9nnsbS0NLFo0SLH2kr2CHSfDxgwQDz99NOhaCI5IND9LoQQ27dvF+3atRPl5eUCgFi+fLnDrSU7BLPPvb3//vuicePG4sKFC040k8KEwxwhVFJSgiNHjuDGG2/0PJaSkoIBAwZg8+bNYWwZmbF582akpqaiX79+nsduvPFGxMXFYcuWLbqvGzRoEJYsWYJTp07B7Xbjvffew/nz5zF8+PAQtJqCEcg+P3bsGLZs2YJWrVph0KBBaN26Na6//noUFBSEqtkUpEDP9XPnzmHixIl4+eWX0aZNm1A0lWwS6D5Xq6ioQHJyMho2bOhEMylMGCyH0JEjRwAArVu39nm8devWnr9R5Dpy5AhatWrl81jDhg2RlpZmuP/ef/99XLhwAc2bN0d8fDwefPBBLF++HF27dnW6yRSkQPb5999/DwCYOXMmpk6dilWrVqFv37644YYbOD8hSgR6rv/nf/4nBg0ahFtuucXpJpLNAt3n3k6cOIHf/OY3ptN1KHowWFbJz8+Hy+Uy/O/bb78NdzPJRk7v8xkzZuDMmTP47LPP8NVXX+Gxxx7DHXfcgd27d9v4KcgKJ/e52+0GADz44IOYPHky+vTpgxdeeAFZWVn405/+ZOfHIIuc3O8ff/wx1q5dixdffNHeRlNQQvWbXllZiTFjxqBnz56YOXNm8A2niML7BCqPP/44Jk2aZPiczp07B7Rt5bbc0aNHkZ6e7nn86NGj6N27d0DbpOCZ3edt2rTBsWPHfB6/ePEiTp06pXvLtbi4GPPnz8eePXvQq1cvAEBubi42btyIl19+GQsWLLDlM5A1Tu5z5dzu2bOnz+M9evRAaWlp4I2moDm539euXYvi4mJNZaTx48dj6NChWL9+fRAtp0A5uc8VZ8+exciRI9G0aVMsX74cjRo1CrbZFGEYLKu0bNkSLVu2dGTbnTp1Qps2bfD55597guPKykps2bLFUkUNspfZfT5w4ECcOXMGX3/9Na699loAdT+QbrcbAwYMkL7m3LlzAKCpgtCgQQPPCCSFnpP7vGPHjmjbti327dvn8/j+/fsxatSo4BtPAXNyv+fn5+P+++/3eSw7OxsvvPAC/u3f/i34xlNAnNznQN1v+M0334z4+Hh8/PHHuOqqq2xrO0WQcM8wjGYHDx4U27dvF88++6xo0qSJ2L59u9i+fbs4e/as5zlZWVli2bJlnn/Pnj1bpKamio8++kjs2rVL3HLLLaJTp06iuro6HB+BLBo5cqTo06eP2LJliygoKBBXX321uOuuuzx//+GHH0RWVpbYsmWLEEKI2tpa0bVrVzF06FCxZcsWUVRUJObNmydcLpdYsWJFuD4GWWB1nwshxAsvvCCSk5PFBx98IL777jvx9NNPi6uuukoUFRWF4yNQAALZ72pgNYyoYnWfV1RUiAEDBojs7GxRVFQkysvLPf9dvHgxXB+DHMBgOQj33XefAKD5b926dZ7nABCLFy/2/NvtdosZM2aI1q1bi/j4eHHDDTeIffv2hb7xFJCTJ0+Ku+66SzRp0kQkJyeLyZMn+1wclZSUaI6B/fv3i9tuu020atVKJCYmipycHE0pOYpcgexzIYSYNWuWaN++vUhMTBQDBw4UGzduDHHLKRiB7ndvDJaji9V9vm7dOmkMAECUlJSE50OQI1xCCBHq0WwiIiIiomjAahhERERERDoYLBMRERER6WCwTERERESkg8EyEREREZEOBstERERERDoYLBMRERER6WCwTERERESkg8EyEREAl8tl+b/hw4eHu9mGhg8frmlzUlIS0tPTMXjwYPzyl7/E2rVrwXL7RET6Goa7AUREkeC+++7TPHbkyBGsXr1a9+/du3d3tE2TJk3CW2+9hcWLF2PSpEkBbyc3Nxe9e/cGANTW1uLkyZPYuXMnCgsLMX/+fOTk5ODNN99Enz597Gk46i4+ADAQJ6Kox2CZiAjAm2++qXls/fr1nmBZ9vdoMW7cOMycOVPz+MaNG/HEE0/gyy+/xJAhQ/DFF1+gX79+oW8gEVEEYxoGEVGMGjp0KDZu3IghQ4bg3LlzmDhxIi5duhTuZhERRRQGy0REAaqursbvfvc7XHfddUhNTcVVV12FrKwsPPnkkzh58qT0NR988AFuvPFGNG/eHI0aNULz5s3Rs2dPTJ06Fbt27QIAHDhwAC6XC2+99RYAYPLkyT55x7JR4kA1btwYCxYsAAB89913+PDDD33+fvDgQcyZMwcjRoxAZmYm4uPjkZqaiiFDhmDhwoVwu90+z585c6YnBQPQ5oIfOHAAAHDhwgW8/fbbuPvuu9G9e3ckJycjISEBWVlZePTRR1FWVmbpc1x//fVwuVx49913dZ8zd+5cuFwu3HHHHZa2TUSxjWkYREQBKCsrw8iRI7F7926kpaWhf//+aNq0KbZt24bnn38eH3zwAdavX48OHTp4XvO///u/eOaZZ9CwYUMMGjQI7dq1Q0VFBUpLS/HGG2+gV69eyMnJQZMmTXDfffehoKAAxcXFGDx4MLp27erZjpJ/bJdevXqhT58+2L59Oz799FOMHz/e87e//OUvmDFjBjp16oRu3bph8ODBKC8vx+bNm7Fp0yasWbMGf/vb3zwBcu/evXHfffd5An11rneTJk0AAEePHsW9996LlJQU9OjRAzk5OaiqqsKOHTvw0ksv4b333kNhYaHP5zbyq1/9Chs2bMD8+fNx1113af7udrvx6quvAgAeeeQR618SEcUuQUREUuvWrRMAhLqrdLvdYvDgwQKAmDJliqisrPT87cKFC+Lxxx8XAEReXp7n8fPnz4uEhATRpEkT8e2332re68CBA2Lv3r0+j913330CgFi8eHFA7b/++usFAPHMM8/4fe79998vAIghQ4b4PP7ll1+K3bt3a55/+PBhkZubKwCI999/X/N32ffmrbKyUnz00UeipqbG5/Ha2loxffp0AUCMHj3ab7sVFy9eFB06dBAAxLZt2zR//+STTwQAkZOTY3qbRERCCME0DCIii1avXo1Nmzahd+/eWLBgAZo2ber5W8OGDTF37lxcc801WLduHfbs2QMAqKysRHV1NTp37oysrCzNNjt06OB4dQ0jLVq0AABN+kj//v1xzTXXaJ7ftm1bzJ07F0BdaolVTZs2xdixY9G4cWOfxxs1aoTf/va3aNu2LVatWoWzZ8+a2l6DBg3w8MMPAwBefvllzd/nz58PAJ7nEBGZxTQMIiKLVqxYAQAYP348GjbUdqNxcXEYNmwY9uzZg8LCQlxzzTVo2bIlOnbsiF27duHxxx/HlClT0LNnz1A3XZeSe+ydb6yoqanBmjVrsHXrVhw7dgw1NTUQQngC2X379gX8vjt37sTnn3+OkpISVFVVedpx8eJFuN1uFBUVmS5pd//992PmzJl455138Pzzz6NZs2YAgKKiIqxZswapqam45557Am4rEcUmBstERBZ9//33AIAZM2ZgxowZhs89fvy45////Oc/4/bbb8fvf/97/P73v0daWhoGDBiAn/zkJ7j33ns9o7vhcOLECQBAWlqaz+P//Oc/MWHCBJSWluq+trKy0vL7VVVV4d5778Xy5csNn2dl282aNcO9996LhQsX4o033sATTzwBAHjllVcghMDkyZORmJhoua1EFNsYLBMRWaSMfg4ZMgRdunQxfG6vXr08/z906FAcOHAAK1aswBdffIHCwkKsXr0aK1euxDPPPIPly5fjhhtucLTterZt2wYAyM7O9jx27tw5jBs3DkePHsXkyZPxi1/8Al27dkVycjIaNGiA/fv3IysrK6CFR6ZPn47ly5eje/fumD17Nvr3748WLVp40jIGDRqEzZs3W972o48+ioULF+LVV1/FY489hvPnz2Px4sVwuVxMwSCigDBYJiKyKCMjAwBwyy23eEYvzUpISMDtt9+O22+/HUDdyPPTTz+N1157DT//+c9x8OBB29vrzzfffIMdO3YAAG666SbP4xs2bMDRo0fRt29f/OlPf9K87rvvvgv4Pd9//30AwJIlS5CTk2Pbtnv27Ikbb7wRn332GVauXImysjKcOXMGo0aN8nthQ0Qkwwl+REQWjRo1CkDdxLZARlW9tWzZ0jNRrrS0FKdPn/b8TRllvXjxYlDvYaS2thYPPfQQgLrlu8eOHev526lTpwAAmZmZ0te+/fbbuttt1KgRAP22K9v2Lq2nWL16tSctJBC/+tWvANRN6lMm+7FcHBEFisEyEZFFt9xyC/r3748vv/wSkydP9slLVpw+fRoLFizwBIsHDx7E66+/Ls3B/eSTTwDU5dwmJyd7Hm/fvj2AupFfJ2zatAlDhw5FQUEBmjRpgr/+9a+Ii7vys9CjRw8AwOeff45//etfPq997bXXsGTJEt1t+2u7su2XXnrJ5/F9+/Z5gvdAjR49Gl27dsWqVauwc+dOdOnSxXOBQ0RklUsEOyxCRFRPrV+/Hnl5eQCgGUEuKyvDmDFjsGPHDiQlJSE3NxeZmZmora3F999/j927d+PSpUuorq7GVVddhR07dqBPnz5o1KgRevfujU6dOgGoSzfYvn07XC4XFi1ahClTpnjeY9euXZ5KECNGjEBGRgbi4uIwduxYnxFgPcOHD8cXX3yB3Nxcz0ImFy5cwKlTp7Bjxw4cOXIEAJCbm4s333xTutjJuHHj8NFHH6Fx48YYPnw40tLSsGPHDuzbtw+//vWv8dxzz6FDhw6elfkU//Vf/4V58+ahRYsWGDFihKe83pw5c9C8eXMsW7YMt99+O4QQyM7ORq9evXDs2DFs3LgRQ4cOxfnz51FYWIh169Zh+PDhfj+r2h/+8Af8x3/8BwDgd7/7HR577DHL2yAiAsBFSYiI9OgtSqI4f/68WLBggcjLyxPNmzcXDRs2FK1atRK9e/cWDz/8sFi9erXnuZWVleLFF18Ut956q7j66qtFkyZNRFJSkujWrZv42c9+Jr766ivpeyxfvlwMHjxYNG3aVLhcLtOLjAhxZVES7/8SEhJEmzZtxMCBA8UjjzwiPv/8c+F2u3W3UVtbK55//nmRnZ0tEhMTRVpamrjpppvEmjVrRElJiQAgOnTooHlddXW1ePLJJ0XXrl1F48aNPe9fUlLiec6GDRvEDTfcIFq0aCESExPFNddcI5577jlRU1Pjafu6detMfVa1vXv3CgAiMTFRnD59OqBtEBEJIQRHlomIqN55+umn8dxzz+GBBx7AwoULw90cIopiDJaJiKheKS8vR8+ePVFZWYk9e/Z48qOJiALB0nFERFQv5Ofn4/Dhw/jss89w5swZPPTQQwyUiShoHFkmIqJ6oWPHjigtLUWbNm0wYcIEzJ49G/Hx8eFuFhFFOQbLREREREQ6WGeZiIiIiEgHg2UiIiIiIh0MlomIiIiIdDBYJiIiIiLSwWCZiIiIiEgHg2UiIiIiIh0MlomIiIiIdDBYJiIiIiLSwWCZiIiIiEjH/wfqb26YB8XFpgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -376,73 +320,54 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 8, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The training RMSE in the PCE LSQ approximation is 1.91e-15\n", + "The testing RMSE in the PCE LSQ approximation is 9.22e-01\n" + ] + } + ], "source": [ - "# BCS with optimal eta (found through cross-validation) " + "# Evaluate goodness of fit with RMSE\n", + "rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx[\"Y_eval\"])\n", + "print(\"The training RMSE in the PCE LSQ approximation is %.2e\"%rmse_trn)\n", + "\n", + "rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx[\"Y_eval\"])\n", + "print(\"The testing RMSE in the PCE LSQ approximation is %.2e\"%rmse_tst)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "In this section, we use the same PC surrogate, `pce_surr`, for the second build. We call the PCE class method of `build()` to build the linear regression model used to fit the surrogate. With the flag `regression='bcs'`, we choose the BCS method for the fitting. \n", + "The results above show us the limitations of using least squares regression to construct our surrogate. From the parity plots, we can see how the testing predictions from the LSQ regression are more spread out from the parity line, while the training predictions are extremely close to the line. Because LSQ fits all the basis terms to the training data, the model fits too closely to the noisy training dataset, and the true underlying pattern of the function is not effectively captured. Our RMSE values align with this as well: while the training RMSE is extremely low, the testing RMSE is significantly higher, as the model struggles to generalize to the unseen test data. \n", "\n", - "Instead of using a default eta, we call the cross-validation algorithm, `optimize_eta()`, to choose the most optimal eta below. \n", - "- With the flag `plot=True`, the CV algorithm produces a graph of the training and testing (validation) data's RMSE values for each eta. The eta with the smallest RMSE for the validation data is the one chosen as the optimal eta." + "To improve our model's generalization, we can build our model with BCS instead. As a sparse regression method, BCS reduces the number of basis terms with which we can fit our data to, reducing the risk of overfitting. " ] }, { - "cell_type": "code", - "execution_count": 29, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n", - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n", - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n", - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n", - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n", - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n", - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n", - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n", - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n", - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n", - "Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies.\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA38AAANaCAYAAAA51vUKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACF1UlEQVR4nOzdd3gUdeLH8c9sKmn00DF06aEEEAvSRDzriWBDsZ+CCpaf6Knn6dnFA4WznSIKKmLh7EoRpCgC0kUpCkRa6Gkk2ezO74+BDZH07GZ2M+/X8+yz35397swnizzh4zTDNE1TAAAAAIBqzWV3AAAAAABA4FH+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAcItzsAys/r9WrXrl2Kj4+XYRh2xwEAAABgE9M0lZGRocaNG8vlKnnfHuUvBO3atUvNmjWzOwYAAACAIJGamqqmTZuWOIfyF4Li4+MlWX/ACQkJNqcBAAAAYJf09HQ1a9bM1xFKQvkLQccP9UxISKD8AQAAACjT6WBc8AUAAAAAHIDyBwAAAAAOwGGf1ZjH45Hb7bY7BvwgIiJCYWFhdscAAABACKP8VUOmaWrPnj06fPiw3VHgR7Vq1VLDhg25vQcAAAAqhPJXDR0vfomJiYqJiSlXWTBNU6tXr9bKlSv1888/KycnR9HR0erQoYN69Oih5ORkykcVM01T2dnZSktLkyQ1atTI5kQAAAAIRZS/asbj8fiKX926dcv8Obfbrddee00TJ07U5s2bZRiGwsPDZZqmDMNQfn6+TNNUmzZtNHbsWN10002KiIgI4E+CE9WoUUOSlJaWpsTERA4BBQAAQLlxwZdq5vg5fjExMWX+zPr165WSkqIxY8Zoy5Ytkqy9TW63W/n5+XK73TJNU5K0ZcsWjRkzRikpKVq/fr3/fwAU6/ifKedxAgAAoCIof9VUWQ/NXLhwoXr16qX169fLNE1fySvO8Tnr169Xr169tHDhQn/ERRlwuC0AAAAqg/LnYOvXr9fQoUOVm5srj8dTrs96PB7l5uZq6NCh7AEEAAAAQgDlz6Hcbreuvvpq5eXlyev1VmgdXq/Xtx4ORQQAAACCG+XPoV577TWtXbu23Hv8/iw/P19r167Va6+95qdkgfPII48oOTnZ7hgAAACALSh/DmSapiZOnOjXdU6aNKnU8wXLIjU1Vddff70aN26syMhInXLKKbrzzjt14MCBcq3HMAzNnj270LJ77rlH8+bNq3RGAAAAIBRR/hxo1apV2rx5s1/KmmSVyU2bNmn16tWVWs9vv/2mnj17avPmzXr33Xe1ZcsWvfzyy5o3b55OO+00HTx4sFLrj4uLK9ftLwAAAIDqhPLnAKZpKisry/dYvHix368caRiGFi9eXGg75S2Xo0ePVmRkpL755hv169dPzZs319ChQzV37lzt3LlTf//73yVJSUlJeuyxx3TFFVcoNjZWTZo00ZQpU3zrSUpKkiRdcsklMgzD9/rPh32OGjVKF198sZ544gk1aNBAtWrV0qOPPqr8/Hzde++9qlOnjpo2baqpU6f6PrNgwQIZhqHDhw/7lq1evVqGYWjbtm2SpDfffFO1atXSZ599pnbt2ikmJkbDhg1Tdna2pk2bpqSkJNWuXVt33HFHpQ+7BQAAAMqK8ucA2dnZiouL8z3uvPNOv+31O840Td1xxx2FtpOdnV3mzx88eFBff/21brvtNt8NzY9r2LChrrrqKs2cOdOX+9lnn1XXrl21atUqjR8/XnfeeafmzJkjSVq+fLkkaerUqdq9e7fvdVHmz5+vXbt26bvvvtPzzz+vf/zjHzr//PNVu3ZtLVu2TH/72990yy236I8//ijX95Gdna0XXnhB7733nr766istWLBAl1xyib744gt98cUXevvtt/XKK6/ogw8+KNd6AQAAgIoKtzsAIMl3GGr79u2LfL99+/Y6dOiQ9u3bJ0k6/fTTNX78eElS27ZttWTJEv373//W4MGDVb9+fUlSrVq11LBhwxK3W6dOHb3wwgtyuVxq166dnnnmGWVnZ+uBBx6QJN1///166qmntHjxYl1++eVl/nncbrdeeukltWrVSpI0bNgwvf3229q7d6/i4uLUoUMH9e/fX99++61GjBhR5vUCAAAAFcWePweIiYlRZmam7/G3v/1NERERft1GRESEbr311kLbiYmJKfd6yrpH8rTTTjvp9caNG8u9vY4dO8rlKvhr0KBBA3Xu3Nn3OiwsTHXr1lVaWlq51hsTE+MrfsfXm5SUpLi4uELLyrteAAAAoKIofw5gGIZiY2N9j+TkZOXn5/t1G/n5+UpOTi60nfKcV9i6dWsZhlFsgdu4caNq167t26vnL38uwYZhFLns+L0QjxfFE0tqUfc4LO96AQAAgECj/DlQSkpKQM75S0lJqfDn69atq8GDB+s///mPjh49Wui9PXv2aMaMGRoxYoSvUP7www+F5vzwww+FDhmNiIgIyMVUjpfP3bt3+5ZV9iqnAAAAQFWg/DlQt27d1KZNG79d8dMwDLVt27bSN1CfPHmycnNzNWTIEH333XdKTU3VV199pcGDB6tJkyZ6/PHHfXOXLFmiZ555Rps2bdKUKVM0a9Ys3Xnnnb73k5KSNG/ePO3Zs0eHDh2qVK4TtW7dWs2aNdMjjzyizZs36/PPP9eECRP8tn4AAAAgUCh/DmQYhsaOHevXdd55552VLpNt2rTRihUr1LJlSw0fPlytWrXSzTffrP79++v7779XnTp1fHPvvvturVixQt26ddO//vUvPf/88xoyZIjv/QkTJmjOnDlq1qyZunXrVqlcJ4qIiNC7776rX375RV26dNHTTz+tf/3rX35bPwAAABAohunv4/8QcOnp6apZs6aOHDmihISEQu/l5OTo999/V4sWLRQdHV3sOtxut1JSUrR+/fpKHR4ZHh6ujh07asWKFQoPr5qLxyYlJWns2LF+L7DBrqx/tgAAAHCOkrrBn7Hnz6EiIiI0ffp0RUZGFrraZXm4XC7feqqq+AEAAACoGMqfg3Xq1ElffvmloqKiyl3ewsPDFRUVpS+//FKdOnUKUEIAAAAA/kL5c7h+/frpxx9/VMeOHWUYRqnn7R2f07FjR/3444/q169fFSUtsG3bNscd8gkAAABUFuUP6tSpk5YvX67JkyerdevWkgruSxceHq6IiAhfKWzTpo0mT56s5cuXs8cPAAAACCGcqAVJ1jmAt912m2699VatXr1ay5cv14YNG5Sdna2YmBh17NhRKSkpSk5O9tstIgAAAABUHcofCjEMQ926dfPr7REAAAAA2I/y50Bp6TlKy8j1+3oT46OUmMAtCAAAAIBgRPlzoBnLdmjSvM1+X++dA9to3OC2fl8vAAAAgMqj/DnQVb2ba3CHBqXOu/aNH3UgK091YyM17fpepc5PjI/yRzy/Ke/N4BcsWKD+/fvr0KFDqlWrVkCzAQAAAFWN8udAiQnRpR+e6XErIsy6sEtEmKFO9SPKsGavlJdd8pSwCOtxgtIuIPOPf/xDjzzySBm2f4zHLXncWr5koWJjY0vPdEzfnsnavX2rataIKPozRWT3u2PZi5SXK3nypLSNUng5L7oT39B6BFLGHuvhb2QvGdlPRvaShXJ2AEClUP5QtKz9BSXE45b2/+qf9cY1lBIaFVq0e/du33jmzJl6+OGH9euvBduLi4vzjU3TlMfjKfmm9Fn7pcw9qm9Iyj4ola37KVJSw3BJB46UObvfHctepHxTytgnfXW3lJlavvX2Gy/1v7/y+UqyYqq08Cn/r5fsJSP7ycheslDOTnEFgEqh/KFosfWO7eXKtZ7rtSt63sGtkjdfcoVLdVqVvt4i9pw1bFjwC7dmzZoyDMO37PihmF988YUefPBBrVu3Tt98842aNWumu+66Sz/88IOysrLUvn17Pfnkkxo0aJCVPbqmktq219gxozX2jjGSJCMqVq+9NEWff/mVvp4zV00a1teEh8fpwnMHSnVaacHC79T/nKE6tHenatWqpTffeltj77lPM6dP09h77lPqH3/ojDPO0NSpU9WokVUC8/Pzddddd+mtt95SWFiYbrzxRu3Zs0dHjhzR7Nmzy/WVS/JlL1JOrpQeJg1/W3pvmJS9X4qpJ139YenrrYp/1PS8Tmo3tPR50y8luz+R/WRkL1koZw/l4goAQYDyh6KFRUg6fmihIUXGFDOxLHMqb/z48XruuefUsmVL1a5dW6mpqTrvvPP0+OOPKyoqSm+99ZYuuOAC/frrr2revHlB/vDIQrn++fiTeuaZZ/TshOf14lOP6Koxf9f25Smq0zBGijh2KGxkjPUIj1J2draemzRZb0+fLpfLpauvvlr33HOPZsyYIUl6+umnNWPGDE2dOlXt27fXpEmTNHv2bPXv379iP2hJh5Z6XVJYpJTYwnqWrOfGyRXblr+V9f+ck92/yG4PstsjlIsrAAQByp9DXPDiYu0r5+0d0jJyfM99nphX9CSvWzJNyTAk195Cb9WPj9Knt59Robx/9uijj2rw4MG+13Xq1FHXrl19rx977DF9/PHH+uSTTzRmzJhi1zNq1ChdccUVkqQnHrhDL7w+Qz+uWqdz259e5Hy3262XX35ZrVpZezXHjBmjRx991Pf+iy++qPvvv1+XXHKJJGny5Mn64osvKv6DAgCKF8rFFQCCAOXPIfZl5GpPek6FPus1VcbPeiq0/rLo2bNnodeZmZl65JFH9Pnnn2v37t3Kz8/X0aNHtWPHjhLX06VLF984NiZGCfFxStt/sNj5MTExvuInSY0aNVJaWpok6ciRI9q7d6969Sq4EmpYWJh69Oghr9dbrp8PAAAACDTKn0PUr8BtGNIycuQ1JZchJcYXc3XQQnv+Ch+uWJFtFic2NrbQ63vuuUdz5szRc889p9atW6tGjRoaNmyY8vLySlxPRMSfrzQqec3ii9rJ8w2ZplnO9AAAAID9KH8OUZHDL/s8MU970nOUGB+tHx4YWPSkPeutAuiKkBp2qmTKsluyZIlGjRrlO9wyMzNT27Ztq7LtS9bFaRo0aKDly5frrLPOkiR5PB799NNPSk5OrtIsAAAAQGkofwhJbdq00UcffaQLLrhAhmHooYcesuVQy9tvv11PPvmkWrdurVNPPVUvvviiDh06VOq9CwEAAICq5rI7AFARzz//vGrXrq2+ffvqggsu0JAhQ9S9e/cqz3Hffffpiiuu0DXXXKPTTjtNcXFxGjJkiKKjizlMFgAAALAJe/4QVEaNGqVRo0b5Xp999tlFnmOXlJSk+fPnF1o2evToQq//fBhoUes5vPE737mKf97Wn7NI0sUXX1xoTnh4uF588UW9+OKLkiSv16v27dtr+PDhxf+QAAAAgA0ofw6Ulp6jtDLc9sHt8fqe1+88UvSkA7nHbvLuVWJMjhITnLXHa/v27frmm2/Ur18/5ebmavLkyfr999915ZVX2h0NAAAAKITy50Azlu3QpHmbyzz/QFaezn9xcanz7hwYr3GD21YmWshxuVx68803dc8998g0TXXq1Elz585V+/bt7Y4GAAAAFEL5c6CrejfX4A4N/LOyA1uO7fkLV2JSc/+sM4Q0a9ZMS5YssTsGAAAAUCrKnwMlJkT77/DMsCjJ67LOm3PYIZ8AAABAKKH8AQAABFrGHuvhb/ENrQcAlAHlDwAAINBWTJUWPuX/9fYbL/W/3//rBVAtUf4AAAACred1Uruhpc+bfqmUvV+KqSdd/WHp89nrB6AcKH9O5M9DTw5slcx8yQiXYuvxSwgAgKKU9fDMsMiC58bJAY0EwHkof07EoScAAACA41D+nMifh56cuOcv6XT/5iyns88+W8nJyZo4caIkKSkpSWPHjtXYsWOL/YzRpLs+fmOiLr6uU6W2bRiGPv74Y1188cWVWg8AAAAQKJQ/J/LnoSeucMnrtm71UIlDPi+44AK53W599dVXJ723aNEinXXWWVqzZo26dOlS5nUuX75csbGxFc5UlEceeUSzZ8/W6tWrCy3fvXu3ateu7ddtAQAAAP7ksjsAIEk33HCD5syZoz/++OOk96ZOnaqePXuWq/hJUv369RUTE+OviCVq2LChoqKiqmRbAAAAQEVQ/hAUzj//fNWvX19vvvlmoeWZmZmaNWuWLr74Yl1xxRVq0qSJYmJi1LlzZ7377rslrjMpKcl3CKgkbd68WWeddZaio6PVoUMHzVm49KTP3HfffWrbtq1iYmLUsmVLPfTQQ3K73ZKkN998U//85z+1Zs0aGYYhwzB8eQ3D0OzZs33rWbdunQYMGKAaNWqobt26uvnmm5WZmel7f9SoUbr44ov13HPPqVGjRqpbt65Gjx7t2xYAAADgb5Q/BIXw8HBdc801evPNN2Wapm/5rFmz5PF4dPXVV6tHjx76/PPPtX79et18880aOXKkfvzxxzKt3+v16q9//asiIyO1bNkyvfzyy7rvXxNPmhcfH68333xTP//8syZNmqTXXntN//73vyVJI0aM0N13362OHTtq9+7d2r17t0aMGHHSOrKysjRkyBDVrl1by5cv16xZszR37lyNGTOm0Lxvv/1WW7du1bfffqtp06bpzTffPKn8AgAAAP7COX9O8Uo/KTOtfJ/J3FPwPKF90XO8bkmmJMM67+9EcYnSLQvLvLnrr79ezz77rBYuXKizzz5bknXI56WXXqpTTjlF99xzj2/u7bffrq+//lrvv/++evXqVeq6586dq19++UVff/21GjduLEl64v47NPSqWwvNe/DBB33jpKQk3XPPPXrvvff0f//3f6pRo4bi4uIUHh6uhg2LP7/xnXfeUU5Ojt566y3fOYeTJ0/WBRdcoKeffloNGjSQJNWuXVuTJ09WWFiYTj31VP3lL3/RvHnzdNNNN5XtCwMAAADKgfLnFJlpUsauin3W9Fb8s+Vw6qmnqm/fvnrjjTd09tlna8uWLVq0aJEeffRReTwePfHEE3r//fe1c+dO5eXlKTc3t8zn9G3cuFHNmjXzFT9JOq1n15PmzZw5Uy+88IK2bt2qzMxM5efnKyEhoVw/x8aNG9W1a9dCF5s5/fTT5fV69euvv/rKX8eOHRUWFuab06hRI61bt65c2wIAAADKivLnFHGJ5f9M5h6r+BkuKa6YPV2l7fkrpxtuuEG33367pkyZoqlTp6pVq1bq16+fnn76aU2aNEkTJ05U586dFRsbq7FjxyovL6/c2yjO999/r6uuukr//Oc/NWTIENWsWVPvvfeeJkyY4LdtnCgiovD3ZRiGvF5vQLYFAAAAUP6cohyHX/pMaG/t8YtrKN29seg5e9YX3OqhYeXulSdJw4cP15133ql33nlHb731lm699VYZhqElS5booosu0tVXXy3JOodv06ZN6tChQ5nW2759e6Wmpmr37t1q1KiRJOmHlWsLzVm6dKlOOeUU/f3vf/ct2759e6E5kZGR8ng8pW7rzTffVFZWlm/v35IlS+RyudSuXbsy5QUAAAD8jQu+IKjExcVpxIgRuv/++7V7926NGjVKktSmTRvNmTNHS5cu1caNG3XLLbdo7969ZV7voEGD1LZtW1177bVas2aNFi1apL8/9UKhOW3atNGOHTv03nvvaevWrXrhhRf08ccfF5qTlJSk33//XatXr9b+/fuVm5t70rauuuoqRUdH69prr9X69ev17bff6vbbb9fIkSN9h3wCAAAAVY3yh6Bzww036NChQxoyZIjvHL0HH3xQ3bt315AhQ3T22WerYcOGuvjii8u8TpfLpY8//lhHjx5Vr169dOONN+rx8XcUmnPhhRdq3LhxGjNmjJKTk7V06VI99NBDheZceumlOvfcc9W/f3/Vr1+/yNtNxMTE6Ouvv9bBgweVkpKiYcOGaeDAgZo8eXL5vwwAAADATzjsE0HntNNOK3S7B0mqU6dOofvoFWXBggWFXm/btq3Q67Zt22rRokUFC/asl7nzp0LnKj7zzDN65plnCn1u7NixvnFUVJQ++OCDk7b957ydO3fW/Pnzi81a1C0dTrwnIQAAAOBvlD8nythjPUrjySt43rW66DkHtkpmvmSES7H1pPjib4EAAAAAwD6UPydaMVVa+FTZ52fvl17tV/q8fuOl/vdXPBcAAACAgKH8OVHP66R2Q/2zrhP3/CWd7p91AgAAAPA7yp8TxTf03+GZrvCCWz1wyCcAAAAQtLjaJwAAAAA4AOWvmvJ6vXZHgJ/xZwoAAIDK4LDPaiYyMlIul0u7du1S/fr1FRkZKcMwArdBt1cyTcnwSjk5gdtOIIRIdtM0lZeXp3379snlcikyMtLuSAAAAAhBlL9qxuVyqUWLFtq9e7d27doV+A2m75O8+da5f5kRpc8PJiGWPSYmRs2bN5fLxQ57AAAAlB/lrxqKjIxU8+bNlZ+fL4/HE9iNTR0tZaVJsYnSdV8Edlv+FkLZw8LCFB4eHti9uAAAAKjWKH/VlGEYioiIUEREgPdoZe+WMndJhkeKjg7stvwtlLMDAAAA5cTxYwAAAADgAJQ/AAAAAHAAyh8AAAAAOADlDwAAAAAcgAu+AAAAoHgZe6yHv8U3tB4AqgzlDwAAAMVbMVVa+JT/19tvvNT/fv+vF0CxKH8AAAAoXs/rpHZDS583/VIpe78UU0+6+sPS57PXD6hylD8AAAAUr6yHZ4ZFFjw3Tg5oJAAVwwVfAAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOQPkDAAAAAAcItzsAQlj2QSlrnzXO2if9d7C9ecqL7PYguz0KZR908vumWcoKSnk/kJ8/Mfsr/UrZTpA5nj17v/TO5VJkjBQRI0XGFjyfOD5pWYwUEVvwOcOw9+cBAIQ0yh8qzuOWvG5r7HVLf/xob56KIrs9yG4Pr1v6Y7ndKSrG65Z2r7Y7RcV48qRNX1ZyJcYJhbC0shh7cnH0zYs9eR0RNSiWAOAAlD8AQBmVUg5KLQ8V/Lw3v2DsCrFfWydmrzRTcmdZD78zTi6Qvr2WB6QZl1nf/fFHWETJr13hUtjxcUTRr11hJ3wuopTXZdl2WAC+FwCoXkLstyiCSlyiFNdIytxtPd+90e5E5TOhPdntQHZ7HM8e3zg0s2fsCu3scQ2lvy22iltelpSXfWycLbmzpbzMIpYdm3t87M623svLKpiXf9RPQc1jGTKlP3dLT660+Rs/bSeQjIJCmJ9jLcrLlHKOSNE17Y0GAEGC8oeKM4yC/1N/4jhUkN0eZLdHqOWtbgyXFFdfUn3/rtfrtUphoQKZXbg0nlgcj5fGEwtkcUXzeIEKGaZ1aPDx0xEkKTfdKuBdR0gpN0kNOtgXDwCCAOUPAIBQ5XJJUXHWQ4n+Xfdzpx7b091Quu176xBWj9t6PvHhcUtez7HidXzZ8ffdf3p9fJnnhHX9+fWf113K9opad9pGyfRYP4c7S1rxhvU45Qyp103SqX+xDhcFAIeh/AEAgJP59nS7pJg69mYpr+OH20bESDIKzpPcvth6xDeWel4ndb9Wim9ga1QAqErc5w8AAFRP0bWs80SHPiPVbVOwPGOX9O3j0r87Sh/eKO1YVobblQBA6KP8AQCA6iu6ptT7FmnMcmnkbOnU8629mZJ1mOi6WdIb50ivnCX99JZ1HiQAVFOUPwAAUP0ZhtSqv3T5DOnONdIZ46QaJxzOumet9Mnt0vPtpW8elA7+bl9WAAgQyh8AAHCWWs2lQY9Id22ULn5Zaty94L2cw9LSF6UXukkzhkub51pXVQWAaoALvgAAAGeKiJaSr7Aef6yUlr8mrf9Q8uRJMqXNX1uPOi2llBul5CulGrXtTg0AFcaePwAAgKY9pEtetvYGDvyHVLNZwXsHf5O+fkB6voP0yR3SnnX25QSASqD8AQAAHBdbTzrzLumO1dKIGVLLswvec2dLP02TXj5DemPosb2E7uLWBABBh8M+AQAA/iwsXGp/vvXYt0la/l9p9TtSXob1/o6l1iOuodRjlPVIaGRnYgAoFXv+AAAASlK/rXTeM9Y9A897Tqp/asF7mXukhU9JEztJs66Tti/lnoEAghblDwAAoCyi4qVeN0m3/SBd+6nU/kLJCLPe8+ZLGz6Spg61DgtdMVXKy7I3LwD8CeUPAACgPAxDanGWNOJtaexa6cx7pJh6Be/vXS99Nlaa0F766gHpwFbbogLAiSh/AAAAFVWzqTTwIemun6W/viY1TSl4L/eI9MMU6cXu0vRLpU1fS16PfVkBOB4XfAEAAKis8Cipy3DrsWuV9ON/pXWzJE+u9f6WudajdpLU8wap29VSTB1bIwNwHvb8AQAA+FPjbtLFU6S7f5EGPyrVal7w3qFt0pyHpOfbS/8bLe1eY1tMAM5D+QMAAAiEmDrS6Xda9wy84j2p1cCC9/JzpFXTpVfOkl4/R1o7S8rPsy0qAGfgsE8AAIBAcoVJ7YZaj/1bpBWvS6tmWOcESlLqMuvx9QPWjeQBIEDY8wcAAFBV6rWWzn3SukDM+f+WEjsWvJeVJuVlWuOcw9KRnbZEBFB9Uf4AAACqWlSc1PN66dYl0qgvpA4XF9wzULL2AL7QTfryPiljj20xAVQvlD8AAAC7GIaUdLo0fJo0br0UGVfwnidXWvayNClZ+vrvUtZ+22ICqB4ofwAAAMEgobEUlWCNI+OkiBhrnH9U+n6yNLGLNPefUvZB+zICCGmUPwAAgGATlSDduUbqM1oKj7aWubOkxc9bJfDbJ6Sjh22NCCD0UP4AAACCUVyidO4T1q0iet0shUVay/MypIVPS5O6SAuflXLSbY0JIHRQ/gAAAIJZQiPpvGel23+SelwnuY7dqSvniPTtv6wSuPjfUl6WvTkBBD3KHwAAQCio1Uy6YKJ0+0qp29UFVwc9ekia+4h1OOjSyZL7qJ0pAQQxyh8AAEAoqZ0kXTRFGrNc6nK5ZBz751z2fumbv0uTukrLXpHyc22NCSD4UP4AAABCUd1W0l9fkW77Qer4V0mGtTxzr/Tl/1n3CVzxhpSfZ2tMAMGD8gcAABDK6reTLptq3TC+/QUFy9N3Sp+Nkyb3kH56W/K47csIIChQ/gAAAKqDBh2lEdOlW76T2g4tWH54h/TJGGlyirTmPcnrsS8jAFtR/gAAAKqTRl2lK9+TbpwvtR5UsPzQ79LHt0hTekvrPpC8XvsyArAF5Q8AAKA6atpDuvpD6fqvpRb9CpYf2Cx9eIP0Ul/p5/9RAgEHofwBAABUZ837SNd+Io36XGret2D5vo3S+9dIr54l/fKFZJr2ZQRQJSh/AAAATpB0hnTdF9LI2VLTlILle9ZJ710hvTZA2jyXEghUY5Q/AAAApzAMqVV/6YY50lUfSI2SC97b9ZM041LpjSHSbwsogUA1RPkDAABwGsOQ2gyWbl4gXf6O1KBTwXupy6S3LpLe/Iu0bYltEQH4H+UPAADAqQxDOvUv0i2LpMumSfVPLXhv+xLpzfOsIpj6o30ZAfgN5Q8AAMDpXC6p48XSrUulS1+X6rYueO+3BdLrg6Xpw6SdP9mVEIAfhNsdAAAAAEHCFSZ1HiZ1uFhaN0ta+JR0aJv13pY51qPdedLZ90uNutiZtGwy9lgPf4tvaD2AEEP5AwAAQGFh4VLyFVYRXPOutPBZ6cgO671fv7Ae7S+U+j8gJba3N2tJVky1Cqy/9Rsv9b/f/+sFAozyBwAAgKKFRUjdr5G6XC6tekv6boKUsct6b+Mn0sZPpU5/tfYEBqOe10nthpY+b/qlUvZ+KaaedPWHpc9nrx9CFOUPAAAAJQuPlFJulJKvlla+KS2aIGWlSTKl9R9KGz6WwqLsTnmysh6eGRZZ8Nw4OaCRADtxwRcAAACUTUS01Odv0p1rpHP+JcXUtZabXin/qDX2uO3LB6BElD8AAACUT2SM1Pd26c610sB/SDVqF7yXn2NfLgAlovwBAACgYqLipDPvsm4WfxzlDwhalD8AAABUTu0kyXXsUhJet3T0kK1xABSN8gcAAIDKO/GCL78tsC0GgOJR/gAAAFB54SeUvy3z7MsBoFiUPwAAAFTeiXv+ts6XTNO+LACKRPkDAABA5RlGwTh9p7TvV/uyACgS5Q8AAAD+t2Wu3QkA/AnlDwAAAP63lfP+gGBD+QMAAID/GMf+ebl9qeQ+am8WAIVQ/gAAAOA/4dHWc36OtH2JvVkAFEL5AwAAgP+ceNXPLfPtywHgJJQ/AAAA+E94VMGhn1z0BQgqlD8AAAD4j+GSmvSwxvt/lY78YW8eAD6UPwAAAPhXq4EF4y1c9RMIFpQ/AAAA+FfrE8oft3wAggblDwAAAP7VuLsUXcsa/7ZA8uTbmQbAMZQ/AAAA+FdYuNTybGucc0Ta9ZOtcQBYKH8AAADwvxMP/eSqn0BQoPwBAADA/7joCxB0KH8AAADwv5pNpPqnWuNdP0nZB+3NA4DyBwAAgABpPch6Nr3WhV8A2IryBwAAgMBoNaBgzC0fANtR/gAAABAYp/SVwqOt8ZZ5kmnamwdwOMofAAAAAiOihnTK6dY4Y7eUttHePIDDUf4AAAAQOCfe8oFDPwFbUf4AAAAQOMcv+iJxywfAZpQ/AAAABE69tlJCU2u8famUl21vHsDBKH8AAAAIHMOQWh+76qcnV9q+xN48gINR/gAAABBYrU44749DPwHbUP4AAAAQWC37Scaxf3Zy0RfANpQ/AAAABFaN2lKTntZ4/ybpcKq9eQCHovwBAAAg8E686id7/wBbUP4AAAAQeK057w+wG+UPAAAAgde4m3X4pyT9tlDy5NubB3Agyh8AAAACzxUmtTzbGucekXausDUO4ESUPwAAAFQNbvkA2IryBwAAgKpx4nl/XPQFqHKUPwAAAFSNhMZSYgdrvPMnKfugvXkAh6H8AQAAoOq0GnBsYEpb59saBXAayh8AAACqTqFDPyl/QFWi/AEAAKDqNO8rhdewxlvnS6Zpbx7AQSh/AAAAqDoR0VLSGdY4Y7eU9rO9eQAHofwBAACgarXmlg+AHSh/AAAAqFqF7vc3174cgMNQ/gAAAFC16rWRajazxju+l/Ky7M0DOATlDwAAAFXLMApu+eDJk7YtsTcP4BCUPwAAAFS91oMKxls57w+oCpQ/AAAAVL2W/SQjzBpz0RegSlD+AAAAUPWia0pNU6zxgc3Soe325gEcgPIHAAAAe5x4ywcO/QQCjvIHAAAAe7Tifn9AVaL8AQAAwB6Nk6Uata3x799JHretcYDqjvIHAAAAe7jCCm75kJsu/bHC3jxANUf5AwAAgH1acd4fUFUofwAAALDP8T1/krRlrn05AAeg/AEAAMA+CY2kxI7WeNdqKeuArXGA6ozyBwAAAHu1Pr73z5R++9bWKEB1RvkDAACAvVoPKhhzywcgYCh/AAAAsFfz06SIGGu8dZ5kmvbmAaopyh8AAADsFR4lJZ1hjTP3SnvX25sHqKYofwAAALDfibd84NBPICAofwAAALBfa+73BwQa5Q8AAAD2q9taqtXcGu/4QcrLsjcPUA1R/gAAAGA/wyg49NOTJ21bbG8eoBqi/AEAACA4nHjo55a59uUAqinKHwAAAIJDi7MkI8wac9EXwO8ofwAAAAgO0TWlZr2s8cGt0qFttsYBqhvKHwAAAIJHa275AAQK5Q8AAADB48T7/W2db18OoBqi/AEAACB4NEqWYupa498WSh63rXGA6oTyBwAAgODhckkt+1vjvAwp9Ud78wDVCOUPAAAAweXE8/62ct4f4C+UPwAAAASXVgMKxlz0BfAbyh8AAACCS3xDqUFna7x7jZS13948QDVB+QMAAEDwaX18758pbf3W1ihAdUH5AwAAQPA58ZYPW+balwOoRih/AAAACD7N+0gRMdZ463zJ67U3D1ANUP4AAAAQfMKjpKQzrXFWmrR3vb15gGqA8gcAAIDg1HpQwZhbPgCVRvkDAABAcDrxfn/c8gGoNMofAAAAglOdllKtU6zxjh+k3Ex78wAhjvIHAACA4GQYBXv/vG5p2yJ78wAhjvIHAACA4NWKQz8Bf6H8AQAAIHi1OEtyhVtjLvoCVArlDwAAAMErOkFq1tsaH/xNOvi7vXmAEEb5AwAAQHBrNaBgzN4/oMLC7Q4AAAAAlKj1QGn+Y9Z4yzwp5UZ786D6ythjPfwtvqH1sBnlDwAAAMGtYVcppp6UvV/6/TspP08Kj7Q7FaqjFVOlhU/5f739xkv97/f/esuJ8gcAAIDg5nJZh36ue1/Ky5T++FFKOsPuVKiOel4ntRta+rzpl1r/MyKmnnT1h6XPD4K9fhLlDwAAAKGg9UCr/EnWoZ+UPwRCWQ/PDIsseG6cHNBI/sQFXwAAABD8uOgLUGns+QMAAEDwi0uUGnaW9qyTdq+RMtOsZQg+1fyiKaGM8gcAAIDQ0GqgVf4kaeu3UtcR9uZB0ar5RVNCGeUPAAAAoaH1QGnJRGu8dR7lL1hV84umhDLKHwAAAEJDsz5SRKzkzpK2zpe8XutKoAgu1fyiKaGMvy0AAAAIDeGRUouzrHHWPmnvOnvzACGG8gcAAIDQ0XpgwXjLXPtyACGI8gcAAIDQceItH7bMty8HEIIofwAAAAgddVtJtZOsceoPUm6GrXGAUEL5AwAAQGhpPch69uZLvy+yNwsQQih/AAAACC2tTjjvb+s8+3IAIYbyBwAAgNDS4kzJdeyOZVsof0BZUf4AAAAQWqLirXv+SdKh36UDW+3NA4QIyh8AAABCT+sTrvq5lat+AmVB+QMAAEDoOX7RF4lDP4EyovwBAAAg9DToLMXWt8bbFkn5efbmAUIA5Q8AAAChx+UquOF7XqaUuszePEAIqFD5e+GFF/TCCy/o0KFDldp4amqq/vrXv+rSSy+t1HoAAADgQCfe8mHLXPtyACEivCIfGjt2rAzD0KBBg1S7du2T3t+wYYM6d+4sl8ul/Pz8YteTnp6u2bNnyzCMisQAAACAk7U68aIv86TB/7QvCxACAnrYp2magVw9AAAAnCyuvtSoqzXes07KTLM3DxDkOOcPAAAAoevEQz+55QNQIsofAAAAQlfrE8/745YPQEkofwAAAAhdTXtJkXHWeOs8yeu1Nw8QxCh/AAAACF3hkVKLs6xx9gFpzxp78wBBjPIHAACA0HbiVT859BMoFuUPAAAAoa31oIIxF30BikX5AwAAQGir00Kq09Iapy6TctLtzQMEqQrd5P24//3vf1qxYsVJy3fu3Okbv/XWW8V+/sR5AAAAQIW1Gigd/E3y5ku/fye1P9/uREDQqVT5e/DBB4t9zzAMSdJ1111XmU0AAAAApWs9UFr+mjXeOo/yBxShwuXPNE1/5gAAAAAqLulMyRUhed3WRV9MUzq2MwKApULlb+rUqf7OAQAAAFRcVJzUvI+0bZF0eLt1CGjdVnanAoJKhcrftdde6+8cAAAAQOW0HmiVP8na+0f5Awqp1Dl/AAAAQNBoNVCa+4g13jpP6n2zrXEqJWOP9fC3+IbWA45E+QMAAED10KCTFJsoZaVZV/zMz5XCo+xOVTErpkoLn/L/evuNl/rf7//1IiRUWflbs2aNtmzZIsMw1LJlSyUnJ1fVpgEAAOAELpfUaoC09j3JnS3t+EFq2c/uVBXT8zqp3dDS502/VMreL8XUk67+sPT57PVztAqXv02bNkmSatWqpcTExGLnzZ8/X7fddps2b95caPkpp5yif//737rooosqGgEAAAAorPUgq/xJ1qGfoVr+ynp4ZlhkwXPj5IBGQuhzVeRDa9eu1amnnqr27dvrq6++Knbe119/rXPPPVebN2+WaZqFHtu2bdOll16qd955p8LhAQAAgEJa9Zd07BYPW+bbGgUINhUqf998840kqWbNmrriiiuKnJOdna3rr79e+fn5Mk1TderU0ciRI3Xfffdp4MCBkiSv16sxY8bo4MGDFYwPAAAAnCC2ntSoqzXeuy4wF00BQlSFyt+PP/4owzD0l7/8RREREUXOeeedd7R7924ZhqFOnTpp/fr1mjZtmp588knNmTNHb7zxhiTpyJEjmjFjRsV/AgAAAOBErQcWjLey9w84rkLlb+PGjZKks846q9g5s2bN8o1feOEFNWxY+JjlUaNGaejQoTJN07cnEQAAAKi0VieUvy3z7MsBBJkKlb8//vhDktS+ffsi3/d6vVq6dKkMw1DTpk119tlnFzlv+PDhkqT169dXJAYAAABwsma9pMh4a/zbt5LXa28eIEhUqPxlZmZKkhISEop8f8OGDcrKypIk9etX/BWWTj31VEnSgQMHKhIDAAAAOFlYRMFVPrMPSLtX2xoHCBYVKn/R0dGSpIyMjCLfX7ZsmW/co0ePUteTk5NTkRgAAABA0VoNKBhv5dBPQKpg+WvUqJEkafXq1UW+v2jRIt+4T58+xa7n0KFDkqS4uLiKxAAAAACK1prz/oA/q1D569mzp0zT1NSpU096LysrS59++qkkKT4+Xj179ix2Pb/++qskqWnTphWJAQAAABStdpJUp5U1Tv1RyjliaxwgGFSo/B2/t9+qVat00003KT09XZJ0+PBhjRo1SocPH5ZhGBo2bJjCwsKKXc93330nSerYsWNFYgAAAADFO773z/RIv39nbxYgCFSo/F1wwQU6/fTTZZqm3njjDdWvX19NmjRRvXr19NFHH0mSIiIidN999xW7juzsbH366acyDEOnn356xdIDAAAAxWk9qGDMoZ9AxcqfJH344Yfq1KmTTNOU2+3W7t275fV6ZZqmXC6X/vOf/6hNmzbFfn7atGm+q4YOGTKkojEAAACAoiWdIYVFWuOt8yTTtDcPYLPwin4wMTFRK1eu1KuvvqpPPvlEO3bsUGRkpLp3767bbrtNKSkpJX5+zpw56tGjh5o2bVpiSQQAAAAqJDJWat7HOuTz8A7pwFapXmu7UwG2qXD5k6xDO0ePHq3Ro0eX+7PHDw8FAAAAAqbVwILz/bbMpfzB0Sp82CcAAAAQ9E685QP3+4PDUf4AAABQfTXoJMU1sMbbFkv5ufbmAWxE+QMAAED1ZRjWoZ+S5M6Wdnxvbx7ARhU65+/RRx/1dw49/PDDfl8nAAAAoNYDpTXvWOMt86SWZ9saB7BLhcrfI488IsMw/BqE8gcAAICAaNlfkiHJtMrfOY/ZnQiwRaUO+zRN0y8PAAAAIGBi60qNk61x2gYpfbetcQC7VOpWDzVq1NBFF12ka665Ru3bt/dXJgAAAMC/Wg+Sdq2yxlvnS92usjcPYIMKlb+BAwfq22+/1dGjRzVz5kzNnDlTPXr00MiRI3X55Zerfv36/s4JAAAAVFyrgdJ3z1rjrfMof3CkCh32OWfOHO3YsUNPP/20OnXqJNM0tWLFCo0dO1ZNmzbVhRdeqPfff1+5uVxKFwAAAEGgaU8pKsEab/1W8nrszQPYoMLn/DVu3Fj33nuv1qxZo9WrV2vcuHFq0KCB3G63PvvsM11xxRVq2LChbr75Zn333Xf+zAwAAACUT1iE1OIsa3z0oLRrta1xADv45T5/Xbp00YQJE/THH3/oq6++0pVXXqkaNWroyJEjev3119W/f3+1aNFCDz/8sDZt2uSPTQIAAADl03pgwXjrPPtyADbx603eXS6XzjnnHE2fPl179+7VtGnT1L9/fxmGoe3bt+vxxx9X+/btdeaZZ/pzswAAAEDpWp1Q/rZQ/uA8fi1/J4qNjdXIkSM1d+5c7dixQ48++qiioqJkmqZWrlwZqM0CAAAARat9ilS3jTX+Y7mUc8TePEAVC1j5O+7777/Xv/71L02cOJELwAAAAMBexw/9ND3SbwvtzQJUsUrd5684W7du1fTp0zV9+nT99ttvkqwbwkdHR+vCCy/UNddcE4jNAgAAACVrNVBa9rI13jpP6nChvXmAKuS38nfo0CG99957evvtt7Vs2TJJVuEzDENnnnmmRo4cqcsuu0wJCQn+2iQAAABQPkmnS2GRkifPOu/PNO1OBFSZSpU/t9utTz/9VG+//ba+/PJLud1umcf+ArVt21YjR47UyJEj1bx5c7+EBQAAAColMlZqfpr0+0LpSKq0f7PdiYAqU6Hyt3jxYk2fPl2zZs3S4cOHfYWvbt26uvzyy3XNNdcoJSXFr0EBAAAAv2g9yCp/Erd8gKNUqPydddZZMgxDpmkqKipKF154oUaOHKlzzz1X4eEBOY0QAAAA8I/WA6U5D1ljbvkAB6lUU6tRo4aGDBmi2NhYffTRR/roo48qtB7DMPT6669XJgoAAABQNokdpPhGUsZuadtiKbqW3YmAKlGp8peTk6P//e9/fglC+QMAAECVMAyp1QBp9Qwp/6jkqWF3IqBKVPg+f6Zp+vUBAAAAVJlWAwrG+dyLGs5QoT1/Xq/X3zkAAACAqtNqgCRDkil5KH9whgrv+QMAAABCVkwdqUl3a+zNtzcLUEWCovytXLnS7ggAAABwmlYD7U4AVClby9/SpUs1dOhQ9e7d284YAAAAcKLWlD84iy035Zs3b57+9a9/6bvvvrNj8wAAAIDUpKcUVVPKPWK95iKEqOYqVf5M09THH3+suXPnKjU1VREREUpKStKwYcPUt2/fk+YvWLBADzzwgJYtW+b7vCSdc845lYkBAAAAlF9YuNSyn7TxE+u1J8/ePECAVbj8bd++XRdddJHWrVt30nuTJk3SZZddphkzZigsLEwHDhzQjTfeqE8+sf5imaYpwzB00UUX6e9//7t69uxZ8Z8AAAAAqKi25xaUP3e2vVmAAKvQOX95eXk6//zztXbt2mLv2zdr1izdf//9Sk1NVUpKij755BOZpimXy6UrrrhCa9eu1ccff0zxAwAAgH06/VUyjv2TOP+odGi7vXmAAKrQnr8ZM2Zow4YNMgxDp5xyih588EF17txZkZGR2rhxo5599lmtWrVKL730kr7//ntt27ZNknTppZfqiSeeUJs2bfz5MyAQMvZYj9IcPzzCkyftWl36/PiG1iOQyH4yspeM7Ccje8lCOTuAwiJqSBGxUl6G9XrZy9K5T9qbCQiQCpW/jz76SJLUtGlTrV27VnFxcb73unbtquHDh+uss87S0qVLtWTJEoWFhen111/XNddc45/UCLwVU6WFT5V9fvZ+6dV+pc/rN17qf3/Fc5UF2U9G9pKR/WRkL1koZwdwsoiYgvK3cprU7/+kGrXtzQQEQIXK35o1a2QYhu69995Cxe84l8ulRx99VIMGDZJhGBo5ciTFL9T0vE5qN9T/662K/6NN9pORvWRkPxnZSxbK2QGczBVWMHZnWf+D58y77MsDBEiFyt+BAwckSZ06dSp2TpcuXXzjYcOGVWQzsFMoH3pEdnuQ3R5kt0coZwdQumWvSKeNlsKj7E4C+FWFLvhy9OhRSVJiYmKxc+rVq+cbN23atCKbAQAAAKpOeLT1nLlHWjfL3ixAAFTJTd7Dw225l3zQ2bJli5577jn9+OOPWrdunZo0aeK7GA4AACgFF9pBoEXGSfk51njpi1LyVZJh2JsJ8CNaWRXasGGDPvvsM/Xq1UumaerQoUN2RwIAOE0oFygutINAC4uUmvWRUn+Q9v0ibZ4jtT3H7lSA31Sq/P3nP/8p8dDP8sx7+OGHKxMlJFxwwQW66KKLJEl/+9vf9NVXX9mcCADgOKFcoLjQDqpC39ulmT9Y46UvUP5QrVSq/L300kslvm8c201e2jzJGeXP5arQKZYAAPhPKBcoDs9EVWh3nlSnlXRwq7RtkbRrldS4m92pAL+ocPkzTdNvIQw/HUv966+/6ptvvtHKlSu1cuVKbdy4UR6PR4899pgefPDBUj8/a9YsTZkyRWvWrFFeXp5at26tq666SuPGjVNERIRfMgIAYCsKFFAyl0vqO0b6bJz1eumL0rA37M0E+EmFyt+3337r7xx+8dJLL2nSpEkV+uzYsWM1adIkhYeHa8CAAYqLi9P8+fN133336dNPP9U333yjGjVq+DkxAAAAgk7XK6T5j1uHPW+YLQ38h1T7FLtTAZVWofLXr18Zjv23QadOnXTPPfeoW7du6t69u5544gm9/fbbpX5u9uzZmjRpkuLi4rRw4UJ1795dkrR//34NGDBAixcv1kMPPaTnnnvO95k333xT1113XanrnjVrFvc5BAAACCURNaReN0sLnpBMj7TsZencJ+1OBVRatbra54033ljodVnPsXviiSckSePHj/cVP8m6V+F//vMfnXnmmZo8ebIeeugh1axZU5J0ySWXqE+fPqWuu0mTJmWNDwAAgGCRcqO0+Hnr1g8rp0n9/k+qUdvuVEClVKvyVxE7d+7U8uXLJUlXXnnlSe+fccYZatasmVJTU/XFF1/oiiuukCTVrFnTVwQBAABQzcTWte7zt+J1yZ1lXSn3zLvsTgVUiuMvP7lq1SpJUp06ddSiRYsi5/Ts2bPQ3KqWm5ur9PT0Qg8AAAAE2GmjJR27MOGyV6T8XFvjAJXl+PL3+++/S5KaN29e7JxmzZoVmltR2dnZ+uCDD/TBBx/ot99+K/R6+/btxX7uySef9O1prFmzpi8PAAAAAqhuK6n9+dY4c4+0bpa9eYBKcnz5y8jIkCTFxsYWOycuLk6SKr3HLS0tTZdddpkuu+wyzZkzR/v27fO9LukKqvfff7+OHDnie6SmplYqBwAAAMqo7x0F46UvSn683RlQ1Rx/zl9VSkpKqtD9EaOiohQVFRWARAAAAChRs15Ssz5S6g/Svl+kzXOktufYnQqoEMfv+YuPj5ckZWVlFTsnMzNTkpSQkFAlmQAAABBE+t5eMF76gn05gEpyfPlLSkqSpBIPpTz+3vG5AAAAcJB250l1WlnjbYukXfZcBBCoLMeXv27dukmSDhw4UOwFXVasWCFJhe4BCAAAAIdwuaS+YwpeL33RvixAJTi+/DVt2lQpKSmSpHfeeeek9xcvXqzU1FRFRUXpvPPOq+p4AAAACAZdr5Bi6lnjDbOlQ8VfqR0IVo4vf5L0wAMPSJKeeuop/fTTT77lBw4c0G233SZJGjNmDDd1BwAAcKqIGlKvm62x6ZGWvWxvHqACqlX5++mnn9SnTx/f4/PPP5ckvfLKK4WW7969u9DnLr74Yt1xxx3KzMxUnz59NHToUA0bNkytW7fWunXrdPrpp+uxxx6z40cCAABAsEi5UQqPtsYrp0lHD9mbByinanWrh/T0dC1btuyk5X/88Yf++OMP3+vc3NyT5kyaNEmnn366pkyZoqVLl8rtdqtVq1YaP368xo0bp8jIyIBmBwAAQJCLrSslXyWteF1yZ0krpkpn3mV3KqDMqlX5O/vssyt0H73jhg8fruHDh/sxEQAAAKqV00ZLK96QZErLXrFeh3M/ZoSGanXYJwAAABBQdVtJ7c+3xpl7pHWz7M0DlAPlDwAAACiPvncUjJe+KFXiyDOgKlH+AAAAgPJo1ktq1sca7/tF2jzH3jxAGVH+AAAAgPLqe3vBeOkL9uUAyoHyBwAAAJRXu/OkOq2s8bZF0q5V9uYByoDyBwAAAJSXyyX1HVPweumL9mUByojyBwAAAFRE1yukmHrWeMNs6dB2W+MApaH8AQAAABURUUPqdbM1Nj3SspftzQOUgvIHAAAAVFTKjVJ4tDVeOU06esjePEAJKH8AAABARcXWlZKvssbuLGnFVHvzACUItzsAAABAtZexx3qUxpNX8Lxrdenz4xtaD9jrtNHSijckmdKyV6zX4VF2pwJOQvkDAAAItBVTpYVPlX1+9n7p1X6lz+s3Xup/f8VzwT/qtpLany9t/FTK3COtmyV1u9ruVMBJKH8AAACB1vM6qd1Q/6+XvX7Bo+8dVvmTrNs+JF8lGYa9mYA/ofwBAAAEGodnVn/NeknN+kipP0j7fpG2zJXaDLY7FVAIF3wBAAAA/KHv7QXjJZPsywEUg/IHAAAA+EO7oVKdVtZ42yJp1yp78wB/QvkDAAAA/MEVJvUdU/B66Yv2ZQGKQPkDAAAA/KXrFVJMPWu8YbZ0aLutcYATUf4AAAAAf4moIfW62RqbHmnZy/bmAU5A+QMAAAD8KeVGKTzaGq+cJh09ZG8e4BjKHwAAAOBPsXWt+/xJkjtLWjHV3jzAMdznDwAAAMXL2GM9SuPJK3jetbr0+dX93oenjZZWvCHJlJa9Yr0Oj7I7FRyO8gcAAIDirZgqLXyq7POz90uv9it9Xr/xUv/7K54r2NVtJbU/X9r4qZS5R1o3S+p2td2p4HCUPwAAABSv53XW/ev8rTrv9Tuu7x1W+ZOs2z4kXyUZhr2Z4GiUPwAAABSvuh+eGUjNeknN+kipP0j7fpG2zJXaDLY7FRyMC74AAAAAgdL39oLxkkn25QBE+QMAAAACp91QqU4ra7xtkbRrlb154GiUPwAAACBQXGFS3zEFr5e+aF8WOB7lDwAAAAikrldIMXWt8YbZ0qHttsaBc1H+AAAAgECKqCH1utkamx5p2cv25oFjUf4AAACAQEu5SQqPtsYrp0lHD9mbB45E+QMAAAACLbaudZ8/SXJnSSum2psHjkT5AwAAAKrCaaMlHbvJ+7JXpPxcW+PAeSh/AAAAQFWo20pqf741ztwjrZtlbx5UnmnanaBcwu0OAAAAADhG3zukjZ9a46UvWoeCGoa9mSB5PdLRw1L2gbI9MnYf+1y+rbHLi/IHAAAAVJVmvaRmfaTUH6R9v0hb5kptBtudqnoxTSk3/VhRO1hMgTsoZe0veH30kKQK7MUzvX6PH0iUPwAAAKAq9b1dmvmDNV4yifJXGvdRq6D5yloJhe742OsOUBhDqlHbKpfe/JDba0v5AwAAAKpSu6FSnVbSwa3StkXSrlVS4252p6p6nmMFLS9LWvhM8WXOnR24DJHxUkwdKaau9Yitd2x8wrITH9G1pLBwaUJ7KWOXFBYZuGwBQPkDAAAAqpIrTOo7RvpsnPV66YvSsDfszVSV8nOlr+6XsvdZr3OPSN8+Xvn1hkUdK2/FFLeTHnWk8KjKbzeEUP4AAACAqtb1Cmn+v6w9WxtmSwP/IdU+xe5UgXd4h/T+tdKun0qeZ4QdK3Gl7ImLqVOwty4iJuQOw6xqlD8AAACgqkXUkHrdLC14UjI90rKXpXOftDtVYG2ZK31447GLq5wgupZ0ycuFC11UTcnFXen8jW8UAAAAsEPKTVJ4tDVeOe3kUlRdeL3Sgqek6cMKfsbaSVJMfWscEWOdB9msl3UvxBq1KX4BwrcKAAAA2CG2rnWfP0lyZ0krptqbJxCyD0rvXGbt4Tx+K4W2Q6WbF0hhEXYmcyTKHwAAAGCX00ZLOnae2rJXrIuhVBc7V0qvnGUd7ilJhksa+LB0+TvW3j1UOcofAAAAYJe6raT251vjzD3Suln25vEH05RWvCG9ca50JNVaFlNPGvmxdObdHNJpI755AAAAwE597ygYL33RKk+hKi9bmn2rdRsLT561rGkv6W+LpJZn2xoNlD8AAADAXs16Sc36WON9vxQcJhlqDmyV/jtIWvNuwbLet0qjPpcSGtuXCz6UPwAAAMBufW8vGC+ZZF+Oitr4qfTq2VLaBut1RKx14/qhT0nhkbZGQwHKHwAAAGC3dkOlOq2s8bZF0q5V9uYpK0++9M1D0syrpdx0a1m9dtLN30qdLrU3G05C+QMAAADs5gqT+o4peL10sn1Zyipjr/TWhdLSFwqWdfyrdNN8qX47+3KhWJQ/AAAAIBh0vUKKqWuNN3wsHd5hb56SbF8qvXKmtH2J9doVLg19xjrUMyrO3mwoFuUPAAAACAYRNaReN1tj0yP98JK9eYpimtYVSd88X8rcay2Lbyxd96XU+xbJMOzNhxJR/gAAAIBgkXKTFB5tjVdOk44esjfPiXLSpfdHSt88aJVTSWpxlnTLd9YVSxH0KH8AAABAsIitKyVfZY3dWdKKqfbmOW7vButqnhs/LVh25j3SyNlSXH27UqGcwu0OAAAAAOAEp42WVrwhyZSWvWK9Do+yL8+amdKnd0r5R63X0TWlS16V2p1b5PS09BylZeSWutp2Xq8iJLm9Xv2680ip8xPjo5SYEF2e5OUWytnLgvIHAAAABJO6raT251t72TL3SOtmSd2urvoc+bnSV/dLK14vWNawizT8LalOi2I/NmPZDk2at7nU1X8fladGhrQ/M0/nv7i41Pl3DmyjcYPblil6RYVy9rKg/IWQKVOmaMqUKfJ4PHZHAQAAQCD1vaPgEMulL1qHglblxVQOp0rvXyPt+qlgWbeR0nnPWhemKcFVvZtrcIcGpW7C9dqxZ0P67PYzSp2fGB/4vZ+hnL0sKH8hZPTo0Ro9erTS09NVs2ZNu+MAAAAgUJr1kpr1kVJ/kPb9Im2ZK7UZXDXb3jJX+vAm6ehB63V4tHTec1L3kWX6eGJCdJkOcUw79mxI6tQkOP5tG8rZy4ILvgAAAADBqO/tBeMlkwK/Pa9XWvCUNH1YQfGrnSTd8E2Zix+CG+UPAAAACEbthkp1WlnjbYukXasCt63sg9I7l0kLnpRkWsvaDpVuXiA16hq47aJKUf4AAACAYOQKk/qOKXi9dHJgtrNzpfTKWdbhnpJkuKSBD0uXvyPVqB2YbcIWlD8AAAAgWHW9Qoqpa403fCwd3uG/dZumdUuJN86VjqRay2LqWffuO/NuyUVVqG74EwUAAACCVUQNqdfN1tj0SD+85J/15mVLs2+VPhsnefKsZU17SX9bJLXs559tIOhQ/gAAAIBglnKTdcVNSVo5TTp6qHLrO7BV+u8gac27Bct63yqN+lxKaFy5dSOocasHAAAAIJjF1rXu87fidcmdJXPFVK2KPVvLly/Xhtl7dTTrqGrE7lXHuFeUkpKibt26ySjunoAbP7P2+OWmW68jYqWLJkud/lp1Pw9sQ/kDAAAAgt1po2WueEOGTKV9+phOe/5uub2Gwl2mTFMyjEPKX3KrTNNUmzZtNHbsWN10002KiIiwPu/Jl+b9U1r6QsE667WTRrwt1W9nz8+EKsdhnwAAAECQW7/7qObtqiFJahDj1ZWdI2SaptweKd8ruT2SaVq3aNiyZYvGjBmjlJQUrV+/XsrYK711YeHi1/Gv0k3zKX4OQ/kDAAAAgtjChQvVq1cvPfL1Ad+ye06LLHa+aZoyTVPr16/X2L/2Vu6LvaXtS6w3XeHS0GekYW9IUXGBjo4gQ/kDAAAAgtT69es1dOhQ5ebmaskOt5bsyJckdUwM07mtSz6D685eYfrq8jBF5R27QEx8Y+m6L6Xet0jFnROIao3yBwAAAAQht9utq6++Wnl5efJ6vZKkZ5fm+d6/t2/Re//iI6UPLquhCedEK9xllbxl+6LlvmGe1KxX4INXQ7n5Hh3MytOOA9n6eVe6Vnlb6VtPsjLNaLujlQsXfAEAAACC0Guvvaa1a9f6zuWTpE835WvTAY/a1g3TgBbh6t7IpZ92e33vd6zv0kcjaqht3TDfsn99l6tHFmbohY6zddttt1Xpz2Cn3HyPMnPylZXrUUauW1m5HmXmupWZ61FWbr4yc/KVmWs9snLzlXHs+fjyrLx83+fzPN4/rX2cJGla5NNqWfU/WoVR/gAAAIAgY5qmJk6ceNJyrylN+D5Pr5xvXfzl7tOidNVHRyVJV3YO16vn11BspLW379BRUyM/PqrPN+fLMAxNmjRJt956a/G3gbCZaZrKzfdaBez4I8cqYRnHSthJ5c1X0E74zLES5/aYpW+0krLZ8wcAAACgMlatWqXNmzcX+d5ba9z6V/8o1Y91aXjHcD2ywKWxfSJ1W0rBYaA/7fZo2PvZ+v2wVYBM09SmTZu0evVqdevWrUp+hpJs3puhJ/Nu0C6zro6YsTr66DfKzMlXvjfwha0sIsNdio8KV2xUuOKOP6ILXrtWTlV945AaGgftjloulD8AAAAgyCxfvlyGYRQ65PO4nHxp8vI8/fNs65y+n26JVVxkwd68//6Up9u/zFFOfuHPGYah5cuX21r+TNPUW99v1xNfbFSu94Qc2e5Krzsq3FVQ0iKt5+PFzSptYYqLilBsVJjio4sodpHhvuURYSVfGiVt7cdK1EGlqU6lc1clyh8AAAAQZDZs2KDw8HC53UWXoik/ujX+9CjViDB8xe+o29ToL3I0dXXRnwkPD9eGDRsClrk0aRk5unfWWi3ctM+3LFJuxemo4us29JW043vcYqOOlTFfkSu+vJWlsIHyBwAAAASdo0ePFrnX77gDR01NXe32Heq59aBXw2Zla/WeP1+YpIBpmsrOzvZ71rL4ZsMejf9onQ5mFVytdETYt/pn+JtKN+KVeO/vtuRyGsofAAAAEGRq1KhR6oVZHpyfo3oxhg4cNfXAvBwdzil5nYZhKCYmxo8pS5edl6/HPvtZ7/6Y6ltWPz5Kz13WVe3fGaNouZVepYmcjfIHAAAABJmOHTsqPz+/xDmHcqQRHxwt8zrz8/PVsWPHykYrszWphzV25mr9vj/Lt+ycDg301KVdVCc2UmlVlgTHUf4AAACAIJOSklLiYZ8VYZqmUlJS/LrOoni8pl5asEUT5272Xb2zRkSY/nFBB41IaRa0t5pwAsofAAAAEGS6deumNm3aaMuWLX4pgYZhqE2bNkpOTq58uBKkHszWuJmrtWL7Id+yrs1qaeKIZLWoFxvQbaN0XBIHAAAACDKGYWjs2LF+Xeedd94ZsL1upmnqw5V/aOikRb7i5zKkOwa01gd/O43iFyQofwAAAEAQuummm9SlSxeFhYVVaj3h4eHq0qWLbr75Zj8lK+xItltj3l2lu2etUWaudZ5iszo19P4tp+muc9pxC4YgwmGfAAAAQBCKiIjQ9OnT1atXL+Xm5srrLf42DsVxuVy+9YSH+/+f/ku37Nfds9Zo95GCS41e2r2pHrmwg+KjI/y+PVQONRwAAAAIMmnpOVq/84hUu5mmvDVLkZFR5d4DGBYWpsjIKE15a5ZUu5nW7zyitPRS7gdRRrn5Hj3xxUZd9foyX/GrWSNCU67srgnDu1L8ghR7/gAAAIAgM2PZDk2at9n3uvaVz2r/ZxPkSSvLzdANSaZcdZur9vl3658rJK1YLEm6c2AbjRvctlLZNu/N0J3vrdbPuwvu0Ne3VV1NGN5VjWrWqNS6EViUPwAAACDIXNW7uQZ3aHDCkjPkfmiEPnxnmqb/9yVt/32rDMNQuGHKlFX38k1DpmnqlJatdPUNf9OlV16riIjCe+AS46MqnMk0TU1buk1PfvmLcvOtQ1Ajw1y6d0g73XBGC7lc3MIh2FH+AAAAgCCTmBCtxITok5Z3e+BuPXb/XVq9erWWL1+u5a/fI7lzpIhopdzwnFJSUpScnOz3q3qmZeTo3llrtXDTPt+ytg3iNHFEN3VonODXbdkpLT1HaRm5pc6rf+zZlKzDc0uRGB9V5J9nVaP8AQAAACHEMAx169ZN3bp108W7nlSiDipNdZQYoKt5frNhj8Z/tE4Hs/J8y0b1TdL4oacqOqJyVyINNn8+3LY430dJMiSvKZ3/4uJS5/vjcFt/oPwBAAAAOEl2Xr4e++xnvftjqm9Z/fgoPXdZV/VrW7+ET4aukw+3LVq9dyKlLKleXKQ+u/mMUudX5nBbf6L8AQAAAChkTephjZ25Wr/vz/ItO6dDAz11aRfViY20MVlgFXe47Ulc1k0TIlwudWpSM8Cp/IfyBwAAAECS5PGaemnBFk2cu1n5XlOSVCMiTP+4oINGpDTz+7mEqFqUPwAAAABKPZitcTNXa8X2Q75lXZvV0sQRyWpRL9bGZPAXyh8AAADgYKZp6qOfduofn2xQZm6+JMllSGP6t9btA9soIsxVrvVV9ytmhjLKHwAAAOBQR7LdemD2On2+drdvWbM6NTRxRLJ6nFKnQuus7lfMDGWUPwAAAMCBlm7Zr7tnrdHuIzm+ZZd2b6pHLuyg+OiIEj5Zsup+xcxQRvkDAAAAHCQ336MJ32zSa4t+k2ld00U1a0ToiUs66y9dGlV6/dX9ipmhjPIHAAAAOMSmvRm6873V2rg73besb6u6mjC8qxrVrGFjMlQFyh8AAABQzZmmqWlLt+nJL39Rbr5XkhQZ5tK9Q9rphjNayOXiFg5OQPkDAAAAqrG09Bzd+8FaLdy0z7esbYM4TRzRTR0aJ9iYDFWN8gcAAABUU99s2KPxH63Twaw837JRfZM0fuipio4IszEZ7ED5AwAAAKqZ7Lx8PfbZz3r3x1TfsvrxUXrusq7q17Z+CZ9EdUb5AwAAAKqR1amHNW7mav2+P8u37JwODfTUpV1UJzbSxmSwG+UPAAAAqAY8XlP/+XaLJs7bLI/XuodDjYgw/eOCDhqR0kyGwUVdnI7yBwAAAIS4nd66uu2V77Vi+yHfsq7NamniiGS1qBdrYzIEE8ofAAAAEKJMU/rQe6Yedo9S1rHi5zKkMf1b6/aBbRQR5rI5IYIJ5Q8AAAAIQVm5+fq7+zrN9fbwLWtWp4YmjkhWj1Pq2JgMwYryBwAAAISYo3ke3TBtuX44ofhd2r2pHrmwg+KjI2xMhmBG+QMAAABCSG6+Rze/vUI//HZQkhSvLN0f8Z6uHP6RzckQ7Ch/AAAAqJbS0nOUlpFb6rx2Xq8iJLm9Xv2680ip8xPjo5SYEO2HhOXn9ng1esYqLdq8X5IUq6OaHvmkGrkO25IHoYXyBwAAgGppxrIdmjRvc6nzvo/KUyND2p+Zp/NfXFzq/DsHttG4wW39EbFc8j1ejX1vteZu3CvJuo3Dv42X1NX1m9LEOX4oHeUPAAAA1dJVvZtrcIcGpc5zvXbs2ZA+u/2MUucnxkdVNlq5eb2m/u+Dtfp83W5JUlS4S69f21Otp/9W5VkQuih/AAAAqJYSE6LLdHhm2rFnQ1KnJjUDmqkiTNPU32ev00erdkqSIsIMvTKyh/q2rufLDpQFN/4AAAAAgpRpmvrnpz/r3R9TJUlhLkOTr+yus9sl2pwMoYjyBwAAAAQh0zT11Fe/6M2l2yRZh6VOHJGsIR0b2hsMIYvyBwAAAAShiXM365WFBef0PTOsqy7o2tjGRAh1lD8AAAAgyLy0YGuhK5U+fkknDevR1MZEqA4ofwAAAEAQeWPx73r6q198rx8+v4Ou6n2KjYlQXVD+AAAAgCDxzrIdevSzn32v/+/cdrr+jBY2JkJ1QvkDAAAAgsCHK//Q32ev872+Y2Ab3XZ2axsTobqh/AEAAAA2+3TNLt37wRqZpvX6lrNaatygNvaGQrVD+QMAAABs9M2GPRo7c7W8x4rfqL5JGj/0VBmGYW8wVDuUPwAAAMAmC35N05h3VslzrPldntJMD5/fgeKHgKD8AQAAADZYumW/bnl7pfI8XknSJd2a6PFLOsvlovghMCh/AAAAQBVbse2gbpi2Qrn5VvH7S+dGenZYF4VR/BBAlD8AAACgCq1JPaxRU5frqNsjSRrUPlETL09WeBj/NEdg8V8YAAAAUEV+3pWua974UZm5+ZKkM9vU0+QruyuC4ocqwH9lAAAAQBXYvDdDV7++TEeOuiVJfVrW0asjeyo6IszmZHAKyh8AAAAQYL/vz9KV/12mg1l5kqTuzWvp9WtTVCOS4oeqQ/kDAAAAAij1YLaueu0H7cvIlSR1blJTb17fS7FR4TYng9PwXxwAAAAQILuPHNWV//1Bu47kSJJObRivt67vpYToiBI/l5aeo7RjZbEk9Y89m5LW7zxS6vzE+CglJkSXOg/VE+UvhEyZMkVTpkyRx+OxOwoAAABKkZaRo6teW6bUg0clSa3qx2r6jb1VOzay1M/OWLZDk+ZtLnXe91GSDMlrSue/uLjU+XcObKNxg9uWOg/VE+UvhIwePVqjR49Wenq6atasaXccAAAAFONgVp6u/u8y/bY/S5J0St0YvXNTH9WLiyrT56/q3VyDOzQodV69dyKlLKleXKQ+u/mMUucnxpdt+6ieKH8AAACAHx3Jdmvk68u0aW+mJKlJrRqacWNvNSjH4ZaJCdFlOzzTZV3CI8LlUqcm7BxAybjgCwAAAOAnmbn5unbqj9qwK12S1CAhSu/c1FtNa8fYnAyg/AEAAAB+kZ2Xr+unLtfq1MOSrEMxZ9zYR6fUjbU3GHAM5Q8AAACopBy3Rze/tVI/bjsoSaoVE6HpN/ZW68Q4m5MBBSh/AAAAQCXk5Xt124yftHjLfklSfHS43r6+t05tmGBzMqAwyh8AAABQQfker+54d5Xm/5ImSYqJDNOb1/VS56ZcfAXBh/IHAAAAVIDHa+qu99foqw17JEnRES69MSpFPU6pbXMyoGiUPwAAAKCcvF5T4z9cq0/W7JIkRYa59OrInurTsq7NyYDiUf4AAACAcjBNUw9/sl6zVv4hSQp3GfrPVd11Vtv6NicDSkb5AwAAAMrINE09/vlGTf9hhyTJZUgvXNFNgzo0sDkZUDrKHwAAAFBGE77ZpP8u/l2SZBjS88OTdV7nRjanAsqG8gcAAACUweT5mzX52y2+10/9tbMu7tbExkRA+VD+AAAAgFL8d9Fveu6bTb7Xj17UUSNSmtuYCCg/yh8AAABQgre/36Z/fb7R9/qB807VNacl2RcIqCDKHwAAAFCM95en6qH/bfC9vmtwW918VisbEwEVR/kDAAAAivC/1Tt130drfa9vO7uVbh/Q2sZEQOVQ/gAAAIA/+XLdbt31/hqZpvX6+tNb6N4h7WQYhr3BgEqg/AEAAAAnmP/LXt3x3ip5vFbzu6p3cz10fnuKH0Ie5Q8AAAA4ZvHm/frb9J/k9ljFb1iPpnrsok4UP1QLlD8AAABA0k/eVrrxreXKy/dKki7o2lhPX9pFLhfFD9VDuN0BAAAAALv95G2tu/JuVY6s4jekYwM9P7yrwih+qEbY8wcAAABH+8XbVNfm3adsRUuSzm5XXy9c0U0RYfxTGdUL/0UDAADAsX7fn6Xb88YoQ7GSpL6t6urlq3soKjzM5mSA/1H+AAAA4Ej5Hq/GzlytI4qTJHU1tui/1/ZUdATFD9UT5Q8AAACONOXbrVqTeliS1NLYpX9HvqyYSC6JgeqL8gcAAADHWfvHYb0wf7MkKUwePR/xkuKMHJtTAYFF+QMAAICjHM3zaNzM1b6buF8X9rWSXVttTgUEHuUPAAAAjvL0V79o674sSVKXpjV1ffhXNicCqgblDwAAAI6xaPM+vbl0myQpKtyl54cnK9zw2hsKqCKUPwAAADjCkWy37p211vf6/qGnqnVinI2JgKpF+QMAAIAjPPzJeu1Jty7qckbrerrmtCR7AwFVjPIHAACAau+ztbv0v9W7JEkJ0eF69rIucrkMm1MBVYvyBwAAgGptb3qO/v7xet/rxy7upEY1a9iYCLAH5Q8AAADVlmmauveDtTpy1C1J+kuXRrqwa2ObUwH2oPwBAACg2pq+bIe+27RPkpQYH6XHL+4kw+BwTzgT5Q8AAADV0m/7MvXE5xt9r58Z1kW1YiJtTATYi/IHAACAaiff49W499foqNsjSbq6T3Od3S7R5lSAvSh/AAAAqHb+s2Cr1qQeliS1qBerB85rb28gIAhQ/gAAAFCtrPvjiF6Yt1mS5DKkCcO7KiYy3OZUgP0ofwAAAKg2ctwejZ25SvleU5I0pn9rdW9e2+ZUQHCg/AEAAKDaePqrX7R1X5YkqXOTmrp9YBubEwHBg/IHAACAamHJlv2aumSbJCkq3KV/j+iqiDD+uQscx98GAAAAhLwjR926Z9Ya3+v7zj1VrRPjbUwEBB/KHwAAAELeI59s0O4jOZKk01vX1ai+SfYGAoIQ5Q8AAAAh7Yt1u/Xxqp2SpPjocD07rKtcLsPmVEDwofwBAAAgZKWl5+iBj9f5Xj96UUc1rlXDxkRA8KL8AQAAICSZpqn/+3CtDme7JUnndW6oi5Ob2JwKCF6UPwAAAISkGct2aMGv+yRJ9eOj9PjFnWUYHO4JFIfyBwAAgJDz+/4sPf75Rt/rZ4Z1Ue3YSBsTAcGP8gcAAICQku/x6q73V+uo2yNJurJ3c/Vvl2hzKiD4Uf4AAAAQUl5euFWrdhyWJCXVjdHfz2tvbyAgRFD+AAAAEDLW7zyiiXM3S5JchvT8iGTFRoXbnAoIDZQ/AAAAhIQct0fjZq5WvteUJN12dmt1b17b5lRA6KD8AQAAICQ8+/Wv2pyWKUnq2DhBdwxsY3MiILRQ/gAAABD0lm7Zr9cX/y5Jigx3aeKIZEWG809ZoDz4GwMAAICgduSoW/fMWuN7/X9D2qlNg3gbEwGhifIHAACAoPbPTzZo15EcSdJpLevq+tNb2JwICE2UPwAAAAStL9ft1kerdkqS4qPC9dzwrnK5DJtTAaGJ8gcAAICglJaeowc+Xud7/ciFHdWkVg0bEwGhjfIHAACAoGOapu77cK0OZbslSed2bKi/dm9icyogtFH+AAAAEHTe/TFV3/66T5JULy5KT/y1swyDwz2ByqD8AQAAIKhsP5Clf33+s+/1M8M6q05spI2JgOqB8gcAAICg4fGauuv9NcrO80iSrujVXANObWBzKqB6oPwBAAAgaLy8cKtWbj8kSTqlbowe/Et7mxMB1QflDwAAAEFh/c4j+vecTZIklyE9P7yrYqPCbU4FVB+UPwAAANgux+3RuJmrle81JUl/69dKPU6pY3MqoHqh/AEAAMB2z339qzanZUqSOjRK0NhBbW1OBFQ/lD8AAADY6vutB/T6kt8lSZFhLv17RLIiw/lnKuBv/K0CAACAbdJz3Lpn1hqZ1tGeundIO7VrGG9vKKCa4gxaAAAAFCstPUdpGbl+X29ifJQSE6L1z09+1s7DRyVJvVvU0Q1ntPD7tgBYKH8AAAAo1oxlOzRp3ma/r/fOgW3UvlGCPvzpD0lSXFS4JgzvKpfL8Pu2AFgofwAAACjWVb2ba3CH0m+yfu0bP+pAVp7qxkZq2vW9Sp3vMqSrX//R9/qRCzuqae2YSmUFUDLKHwAAAIqVmBCtxIToUudFhLl8z52a1CxxrmmaunHaCh3MypMkDenYQJd2b1L5sABKRPkDAABAlXpvearm/ZImSaoXF6UnLuksw/D/4Z5lPV+x/rFnU9aN5ktz/HxFINRQ/gAAAAIs0BdNCSXbD2Tpsc9+9r1++tLOqhsXFZBtlfV8xe+jJBmS15TOf3FxqfPvHNhG4wZzH0KEHsofAABAgAXyoimhVEI8XlN3v79G2XkeSdLlKc00sH3p5xNWVFnPV6z3TqSUJdWLi9RnN59R6vzE+MCUVSDQKH8AAAABFqiLpoRaCXnlu61asf2QJKlZnRp68PwOAd1eWc9XlOvY+Yqu0s9XBEIZ5Q8AACDAAnHRlFCzYdcR/XvOJkmSYUjPD09WXBT/FAWqEn/jAAAAEFA5bo/umrlGbo8pSbrlrFZKSaoT+A1n7LEepfHkFTzvWl36/PiG1gMIMZQ/AAAABNTzczbp170ZkqRTG8Zr3OA2VbPhFVOlhU+VfX72funVfqXP6zde6n9/xXMBNqH8AQAAIGB++O2AXlv0myQpMsyliZcnKyo8rGo23vM6qd1Q/6+XvX4IUZQ/FCmUL0lN9pORvWRkPxnZSxbK2YGqlJHj1t3vr5FpHe2pu89pq1MbJlRdAA7PBAqh/IWQKVOmaMqUKfJ4PAHfVihfkprsJyN7ych+MrKXLJSzh3JxDeXsTvXPT3/WzsNHJUm9WtTRjWe2tDkR4GyUvxAyevRojR49Wunp6apZM7BXAAvlS1KT/WRkLxnZT0b2koVy9lAurqGc3Ym+3rBHH6z8Q5IUFxWuCZd1VZjLsDkV4GyUPxQplC9JTXZ7kN0eZLdHKGcP5eIaytmdZl9Gru7/aJ3v9cMXdFCzOjE2JgIgUf4AAHCUUC6uoZzdSUzT1P0frdXBLOv2CYM7NNBlPZranAqAJLnsDgAAAIDq46jbo7kb0yRJ9eIi9eRfO8swONwTCAaUPwAAAPhNRk6+b/zkX7uoXhyH1QLBgvIHAACASjOP3c/h2F0dNLxn0zKdowmg6lD+AAAAUGlZeQW3ompau4YeOr+DjWkAFIULvgAAAKBCctweLfh1n75Yt1uZuQWHez4/PFnx0RE2JgMqKGOP9SiNJ6/gedfq0ufHN7QeNqP8AQAAoMyOF77P1+3W/I17C+3xk6TYyDD1alHHpnRAJa2YKi18quzzs/dLr/YrfV6/8VL/+yuey08ofwAAACiRVfjS9Pm6PUUWPkkyZJ3vFxfFPy8dL5T3nvW8Tmo31P/rDYK9fhLlDwAAAEU4mne88O3W/F/SlF1E4atZI0LndGig87o00vgP1mpvRi63dUBo7z0LksMzA4XyBwAAAElW4fv2eOHbmKaj7qIL35CODXRe50bq26qeIsOt6wdS+uBTzfeehTLKHwAAgINl5+Xr21+si7bM/6XowlcrJkJDOjTUeV0aqW+ruooI44LxKEE133sWyih/AAAADpOdl6/5v6Tpi3W79e0v+0osfH/p0kinUfiAaoHyBwAA4ABZuScUvl/TlOP2njSndkyEhnRsqPM6U/iA6ojyBwAAUE1l5eZr3i9p+mLtbi3YVHThqxMb6TuHr09LCh9QnVH+AAAAqpHM3HzN27hXX6zbrQW/7lNufnGFr6H+0rmR+rSso3AKH+AIlD8AAIAQd7zwfb52txZuKrrw1Y2N1JBOVuHr3YLCBzgR5Q8AACAEZeS4NW+jdVuGhZv2Ka+IwlcvrmAPXy8KH+B4lD8AAIAQUdbCd24n66ItvVvUVZiL++8BsFD+AAAAglh6jvvYIZ179N3m4gpflIYeK3y9WtSh8AEoEuUPAAAgyHhNUx/99Ie+WLdb323arzzPyYWvfnxB4UtJovABKB3lDwAAIAgczMrT0TzrZutpGbm66/01J81JPKHw9aTwASgnyh8AAIBNtu3P0pyf92rOxr1ase2gvObJcxLjo3Re50Y6r3Mj9TilNoUPQIVR/gAAAKqI12tqVephzd24V3N+3qstaZlFznMZ0jWnJekvXRqpR/PaclH4APgB5Q8AACCActweLd68X3N+3qt5v6Rpf2ZukfNa1ovV3vQcZeV5VD8uSo9c2LGKkwKo7ih/AAAAfrY/M1fzf0nTnJ/3atHmfcpxn3zBFsOQujevrcEdGmhwhwZqVT9OfZ6Yp6w8jwyDPX0A/I/yBwAA4Adb92Vqzs97NffnvVq545DMIs7fi45w6cw29TW4fQMNaJ+oenFRVR8UgGNR/gAAACrA4zX1045Dmvuzdf7eb/uzipxXLy5Kg9onalD7Bjq9dT3ViAyr4qQAYKH8AQAAlFF2Xr4WHTt/b/4vaTqYlVfkvNaJcRrcoYEGtW+gbs1qhfQFW9LSc5SWUfR5iidyH7sXodvj1fqdR0qdnxgfpcSE6ErnA1B2lD8AAIASpGXkaN7GNM39ea8Wb9mv3PyTz99zGVLPpDoa3L6BBnVooBb1Ym1IGhgzlu3QpHmbyzz/QFaezn9xcanz7hzYRuMGt61MNADlRPkDAAA4gWma2pKWqW9+3qu5G/dqderhIs/fi4kM01lt6mtwhwbqf2qi6sRGVn3YKnBV7+Ya3KGB39ebGM/5jkBVo/wBAADHy/d4tWL7sfP3Nu7V9gPZRc5LjI/SoA4NNLh9A53Wqq6iI6r/+XuJCdEcnglUE5Q/AADgSJm5+Vq0aZ91/t6vaTqc7S5y3qkN4zWovXU7hs5Naob0+XsAnI3yBwAAHGNveo51O4aNe7V0ywHleU4+fy/MZahXUh3fBVua142xISkA+B/lDwAAVFumaeqXPRmae6zwrfmj6KtQxkWFq1876/57/dslqmZMRBUnBYDAo/yhwnLzPcrN9/jGizfvtzlR+ZDdHmS3x4nZF23eV+7PF3Wxi3J9vhKfPTH7wk3lz26nP3/vhgwZhqzH8bEkl8uQIWu5ji13GQXLivzcn+aU+rkTlh+foxPm/Plz3mN/6F7TVEZO0YdDlsYwKnd4ZEU/fTx7eo5bZz7zrf44dLTIeY1qRvsO5+zdso6iwqv/+XsAnM0wzcr+SkdVS09PV82aNXXkyBElJCTYliMtI0e9Hp9n2/YBACivDo0SNKhDA53ToYE6Nk6odEH1tz5PzNOe9Bw1TIjWDw8MtDsOQsGE9lLGLim+sXT3RrvTwAbl6Qbs+QMAANVWuMvQaa3qatCx++81qVXD7kgAYBvKHyosJjJcsZFhysrzKDYyTNef0cLuSOXyxuLfyW4DstvjxOw3VDS7TYfw/XfRb77sN57ZslIZqtqJ2a8/o4VMUzJlymvKN5ZpHaZovS5YbprW+WrHl3lPGEumvN4T5unYoY6+dZjHlhWMC2/HPLZO6w3zhM95j41/2GpdDCUyzKXeLev4/bsJ5HFHP/5+UHker2rWiNCi+/orIZrz9wBAovyhEuKiwhUfHaGsPI/ioyN09znt7I5ULrNW/EF2G5DdHidmvyvEss9cnurLPm5wW7vjlMuJ2UPtv5njhx/WiY3U2zf0tjtOuRzPXiMijOIHACdw2R0AAAAAABB4lD8AAAAAcADKHwAAAAA4AOUPAAAAAByA8gcAAAAADkD5AwAAAAAHoPwBAAAAgANQ/gAAAADAASh/AAAAAOAAlD8AAAAAcADKHwAAAAA4AOUPAAAAABwg3O4AAAAAAP4kY4/1KI0nr+B51+rS58c3tB5wJMofAAAAEGxWTJUWPlX2+dn7pVf7lT6v33ip//0Vz4WQRvkDAAAAgk3P66R2Q/2/Xvb6ORrlDwAAAAg2HJ6JAKD8AQAABFhaeo7SMnJLnef2eH3P63ceKXV+YnyUEhOiK50PgDNQ/gAAAAJsxrIdmjRvc5nnH8jK0/kvLi513p0D22jc4LaViQbAQSh/AAAAAXZV7+Ya3KGB39ebGB/l93UCqL4ofwAAAAGWmBDN4ZkAbMdN3gEAAADAASh/AAAAAOAAlD8AAAAAcADKHwAAAAA4AOUPAAAAAByA8gcAAAAADkD5AwAAAAAHoPwBAAAAgANQ/gAAAADAASh/AAAAAOAAlD8AAAAAcADKHwAAAAA4AOUPAAAAAByA8gcAAAAADkD5AwAAAAAHoPwBAAAAgANQ/gAAAADAAcLtDgAAAKpOWnqO0jJyS53n9nh9z+t3Hil1fmJ8lBIToiudryShnB0AggHlD0UK5V+wZD8Z2UtG9pORvWShnH3Gsh2aNG9zmecfyMrT+S8uLnXenQPbaNzgtpWJVqpQzg4AwcAwTdO0OwTKJz09XTVr1tSRI0eUkJAQkG38e86mcv2CLauq+AVL9pORvWRkPxnZSxbK2ctaXMsrmEp3ebHnD0AoK083oPyFoKoof6H8C5bsJyN7ych+MrKXLJSzAwCqF8pfNVcV5Q8AAABA8CtPN+BqnwAAAADgAJQ/AAAAAHAAyh8AAAAAOADlDwAAAAAcgPIHAAAAAA5A+QMAAAAAB6D8AQAAAIADUP4AAAAAwAEofzZLTU3V2WefrQ4dOqhLly6aNWuW3ZEAAAAAVEPhdgdwuvDwcE2cOFHJycnas2ePevToofPOO0+xsbF2RwMAAABQjVD+bNaoUSM1atRIktSwYUPVq1dPBw8epPwBAAAA8KuQPuxz586duvrqq1W3bl3VqFFDnTt31ooVK/y2/u+++04XXHCBGjduLMMwNHv27CLnTZkyRUlJSYqOjlbv3r31448/Vmh7K1eulMfjUbNmzSqRGgAAAABOFrLl79ChQzr99NMVERGhL7/8Uj///LMmTJig2rVrFzl/yZIlcrvdJy3/+eeftXfv3iI/k5WVpa5du2rKlCnF5pg5c6buuusu/eMf/9BPP/2krl27asiQIUpLS/PNSU5OVqdOnU567Nq1yzfn4MGDuuaaa/Tqq6+W9SsAAAAAgDIzTNM07Q5REePHj9eSJUu0aNGiUud6vV51795dbdq00XvvvaewsDBJ0q+//qp+/frprrvu0v/93/+VuA7DMPTxxx/r4osvLrS8d+/eSklJ0eTJk33batasmW6//XaNHz++TD9Lbm6uBg8erJtuukkjR44sdX56erpq1qypI0eOKCEhoUzbAAAAAFD9lKcbhOyev08++UQ9e/bUZZddpsTERHXr1k2vvfZakXNdLpe++OILrVq1Stdcc428Xq+2bt2qAQMG6OKLLy61+BUnLy9PK1eu1KBBgwpta9CgQfr+++/LtA7TNDVq1CgNGDCg1OI3ZcoUdejQQSkpKRXKCwAAAMC5Qrb8/fbbb3rppZfUpk0bff3117r11lt1xx13aNq0aUXOb9y4sebPn6/Fixfryiuv1IABAzRo0CC99NJLFc6wf/9+eTweNWjQoNDyBg0aaM+ePWVax5IlSzRz5kzNnj1bycnJSk5O1rp164qcO3r0aP38889avnx5hTMDAAAAcKaQvdqn1+tVz5499cQTT0iSunXrpvXr1+vll1/WtddeW+Rnmjdvrrffflv9+vVTy5Yt9frrr8swjKqMfZIzzjhDXq/X1gwAAAAAqr+Q3fPXqFEjdejQodCy9u3ba8eOHcV+Zu/evbr55pt1wQUXKDs7W+PGjatUhnr16iksLOykC8bs3btXDRs2rNS6AQAAAMCfQrb8nX766fr1118LLdu0aZNOOeWUIufv379fAwcOVPv27fXRRx9p3rx5mjlzpu65554KZ4iMjFSPHj00b9483zKv16t58+bptNNOq/B6AQAAAMDfQvawz3Hjxqlv37564oknNHz4cP3444969dVXi7xVgtfr1dChQ3XKKado5syZCg8PV4cOHTRnzhwNGDBATZo0KXIvYGZmprZs2eJ7/fvvv2v16tWqU6eOmjdvLkm66667dO2116pnz57q1auXJk6cqKysLF133XWB++EBAAAAoJxC9lYPkvTZZ5/p/vvv1+bNm9WiRQvddddduummm4qcO2fOHJ155pmKjo4utHzVqlWqX7++mjZtetJnFixYoP79+5+0/Nprr9Wbb77pez158mQ9++yz2rNnj5KTk/XCCy+od+/elfvhSsCtHgAAAABI5esGIV3+nIryBwAAAEByyH3+AAAAAABlR/kDAAAAAAeg/AEAAACAA1D+AAAAAMABKH8AAAAA4ACUPwAAAABwAMofAAAAADgA5Q8AAAAAHIDyBwAAAAAOEG53AJSfaZqSpPT0dJuTAAAAALDT8U5wvCOUhPIXgjIyMiRJzZo1szkJAAAAgGCQkZGhmjVrljjHMMtSERFUvF6vdu3apfj4eBmGYXeckJWenq5mzZopNTVVCQkJdsdxDL53e/C924Pv3R587/bge7cH37s9gul7N01TGRkZaty4sVyuks/qY89fCHK5XGratKndMaqNhIQE2//SOhHfuz343u3B924Pvnd78L3bg+/dHsHyvZe2x+84LvgCAAAAAA5A+QMAAAAAB6D8wbGioqL0j3/8Q1FRUXZHcRS+d3vwvduD790efO/24Hu3B9+7PUL1e+eCLwAAAADgAOz5AwAAAAAHoPwBAAAAgANQ/gAAAADAASh/QDls2bJFf/vb39S9e3dFREQoKSmp1M/k5+erS5cuMgxD7733XuBDVkNl/d4/+OADXXLJJWrevLliYmLUsWNHTZgwQW63u2oDVxPl+e99y5YtOu+88xQXF6d69erptttuU1ZWVtWFdYD//e9/6tOnjxISEpSYmKi//OUvWr16td2xHGHmzJnq1auXYmJiVKdOHQ0cOFC7d++2O5Yj8Du06vA7NLCC5fck5Q8ohw0bNuizzz5TUlKSOnXqVKbPTJo0Sfv27QtwsuqtrN/7c889p6ioKD3zzDP6/PPPdeWVV+rBBx/UjTfeWIVpq4+yfu9HjhzRgAEDdPDgQc2aNUuTJk3Shx9+qGuuuaYK01Zvc+bM0SWXXKI2bdrogw8+0CuvvKK0tDRKSBWYMGGCRo4cqUGDBunzzz/XW2+9pR49eignJ8fuaI7A79Cqw+/QwAmq35MmgDLzeDy+8S233GKecsopJc5PTU014+PjzWnTppmSzHfffTfACaunsn7vaWlpJy177LHHTEnmnj17AhWv2irr9/7000+b0dHR5t69e33LPvzwQ1OSuWLFikDHdIRRo0aZSUlJptfr9S3bunWrKcmcOnWqfcGquc2bN5sRERHmf/7zH7ujOBK/Q6sWv0MDJ5h+T7LnDygHl6t8f2XGjh2rCy+8UGeddVaAEjlDWb/3+vXrn7SsR48ekqRdu3b5NZMTlPV7/+KLLzRgwAAlJib6ll144YWKi4vTZ599Fqh4juJ2uxUXFyfDMHzLatasKUnyer12xar23njjDUVGRuqGG26wO4oj8Tu0avE7NHCC6fck5Q9B5ddff9WLL76oUaNGqXPnzgr///buP6aq+o/j+OvWRSVAwWkLgUAJFX8MM1yJkjD7MbVhmbZq0Qxtzt9NXXNtLJv9YKa5qdM2N1k1bWYbLIusVNSRWppak8wywbG2BhikCLum+3z/cNyvCOqVC+ece8/zsd0/7rmfc87nvj4XPvd97znner3yeDx6++23A1p/x44dysnJUVxcnKKiopSRkaFVq1bZcrz6rl279O233+r999+3fN93Kpxyv9GBAwfUo0cPpaam2t2VdsIl919//VXp6eltlnm9Xg0ePFinTp2ytC+d5fSxKCgo0G+//aa1a9eqoaFBNTU1WrhwoZKSkjRt2rQu2YcdnJ77wYMHNXToUH300UdKTk6W1+tVRkaGvv766y7Zvl2cnrsUWnNooEIh9xs5eQ4NlpXj4ah50tLvGYHbWLx4sZHU7rZy5cqA1/V6veaJJ54w06ZNM7GxsUaSGT9+vGlubu7Svt7qMLiWlhaTmppqVq9ebYwxpqqqytGHrIRL7jeqrKw0kZGRZsGCBV3ah64SLrl7vd4O+zxx4kTz+OOPd2k/uksojMUXX3xhYmJi/H0bOHCgOX36dJds2y5Oz33IkCEmOjraxMfHm48//th888035qmnnjJer9ecPHky6O3bxem5h9ocGiin534jp8+hwbJyPJw0T1L8wVE2b95sli1bZrZu3WpOnTpl8vPzA/pDLCkpMZJMdHS0+emnn/zL6+rqzMiRI40ks3Tp0jbrFBcXd/hHf+Ntx44dHe7zVm+GCwsLTXp6url8+bIxxvkTV7jkfr26ujqTlpZmRo4caZqamm4fgg3CJXcnTWqd5fSxOHTokImNjTVz5swxu3fvNqWlpSYrK8sMGjQopM/FcXruaWlpRpL56quv/Mt8Pp9JTEw0+fn5XZSC9Zyee6jNoYFyeu7XC4U5NFhWjoeT5kmvAAe58YpSgZ5z9O6770qSli9frtGjR/uX9+vXTxs3blR2drY2bNigwsJC/3kyzzzzjB555JHbbjshISHQ7kuSzp07p1WrVmnr1q3+S/heuHBBktTc3Kx///3X3wenCIfcr3fx4kVNmjRJly9f1r59+xQVFdXpbXWncMk9Li5OjY2N7ZY3NDQoLS3tjrdnB6ePxcKFC5WVlaUPP/zQvyw3N1fJyclau3atioqKAuqv0zg997i4OEnXsm7Vo0cPjRs3TpWVlQH11YmcnHsozqGBcnLu1wuVOTRYVo6Hk+ZJij+EvL/++ktHjhyRJL344ovtHh8/frySkpJUU1OjsrIyvfDCC5KuXSyhOyaQqqoq+Xw+TZ8+vd1js2bN0qJFi9TU1NTl+7Wa03Jv5fP5NHXqVFVXV6uiokIDBgzotn3ZwYm5p6entztn4erVq/r999+Vl5fXLft0AivHorKyUpMmTWqzrHfv3nrggQf0xx9/dPIZhCYrcx8+fLh+/PHHdsuNMa77qQercnfLHBooq//nh/scGqzOjoeT5kku+IKQd/z4cUlS3759NXDgwA7bZGZmtmnbnUaNGqXy8vI2t08//VSSVFhYGPIXCmjltNyla/9In3/+eR05ckRlZWUaMmSIJfu1khNznzx5ssrLy9v8FtfOnTvV1NSkKVOmWNIHO1g5FikpKTp69GibZRcuXNCZM2duuu9wZWXurW/K9uzZ41/m8/lUUVHh34dbWJW7W+bQQFn5enfDHBqszo6Hk+ZJvvlDyKuqqpIk3X///Tdtk5SU1KZtZzU3N6usrEySdPbsWTU3N+vzzz+XJI0ZM0bJycmKjY1VTk5Om/Wqq6slScOGDVN2dnZQfXAKp+UuSfPnz1dpaalWrlypq1ev6vDhw/5tDBs2TL179w6qH07gxNznzJmj9evXa+rUqSosLFRDQ4OWLFmiqVOnhvUbZCvHYsGCBZo/f77mzJmjZ599Vk1NTVqzZo18Pp9effXVoLYdaqzMPS8vT2PHjtXs2bP13nvv6b777tP69evV0NCg119/PahthxqrcnfLHBooK1/vbphDg9XZ8XDSPEnxh5B38eJFSbrlMenR0dGS/n/eQGfV1tZqxowZbZa13i8uLtbMmTOD2n4ocWLuu3btknTt0+HCwsI27cvLy9u9oQhFTsw9NjZWe/fu1aJFizR9+nT16tVLM2bM0OrVq4Pav9NZORZz585Vr169tGHDBm3btk2RkZEaPXq0ysvLXffpvJW533XXXfryyy+1bNkyLV26VC0tLRozZoz27t2r4cOHB7XtUGNl7vg/K3N3wxwarM6Oh5PmSYo/4A6kpKTIGGPZergm0PxaPx1G17iT1+3gwYP9bxzQ9TwejwoKClRQUGB3V1ynb9++2rJli7Zs2WJ3V1yLOdQazKHdyynzJOf8IeTFxMRIkv+qYB1pPTmcQxa6Drnbg9ydg7GwB7nbg9ztQe7OEg7jQfGHkJeSkiJJqqmpuWmb1sda2yJ45G4PcncOxsIe5G4PcrcHuTtLOIwHxR9C3oMPPihJOn/+/E1Pdm69St71v8eC4JC7PcjdORgLe5C7PcjdHuTuLOEwHhR/CHmJiYkaM2aMJGnbtm3tHq+oqFBNTY169uypyZMnW929sEXu9iB352As7EHu9iB3e5C7s4TDeFD8ISy88cYbkqSioiIdO3bMv/z8+fOaN2+epGuXSu/OHxd3I3K3B7k7B2NhD3K3B7nbg9ydJdTHw2O4fBIc5NixY/4/HEn6888/VV9fr8TERCUkJPiXl5SUKD4+vs26ixcv1rp16xQREaGJEycqKipKe/bsUWNjo8aNG6fvvvtOkZGRlj2XUELu9iB352As7EHu9iB3e5C7s7h2PAzgIOXl5UbSbW9VVVUdrr99+3bz6KOPmt69e5vIyEgzYsQIU1RUZHw+n7VPJMSQuz3I3TkYC3uQuz3I3R7k7ixuHQ+++QMAAAAAF+CcPwAAAABwAYo/AAAAAHABij8AAAAAcAGKPwAAAABwAYo/AAAAAHABij8AAAAAcAGKPwAAAABwAYo/AAAAAHABij8AAAAAcAGKPwAAAABwAYo/AAAstG/fPnk8nju6vfbaa3Z3GwAQBij+AAAIMTk5OfJ4PMrJybG7KwCAEOK1uwMAALjV3LlzNW/evNu269evnwW9AQCEO4o/AABscu+992rEiBF2dwMA4BIc9gkAAAAALkDxBwBAiJg5c6Y8Ho/2798vSdq/f3+7i8OkpKS0WefSpUvavn27Zs+erVGjRqlPnz6KiIhQ//79NWHCBK1evVpNTU02PBsAgNU47BMAgDA2ZcoUf7F4vfr6eh04cEAHDhzQxo0bVVZWpqFDh9rQQwCAVSj+AAAIEe+8846WLVumV155RUePHlVmZqaKi4vbtOnRo0eb+1euXNHIkSOVl5enzMxMDRgwQMYYnTt3TiUlJfrss89UVVWlp59+WidOnFCvXr2sfEoAAAtR/AEAYJPa2lqdPHnytu2GDBmiiIgIJSQkKCEhQVFRUZKkqKio214wpri4WGlpae2WP/zww3ruuec0a9YsPfnkkzp9+rS2bt2qWbNmde7JAAAcj+IPAACbbNq0SZs2bbptu6qqqnbn8gWqo8Lveo899pjy8vJUWlqq0tJSij8ACGMUfwAAuEhdXZ0aGxvl8/n8y/r37y9J+vnnn+3qFgDAAhR/AADY5M0339SKFSu6fT/ff/+91q1bp927d+uff/65abv6+vpu7wsAwD4UfwAAhLEVK1borbfeCqhtS0tLN/cGAGAnfucPAIAwtWfPHn/hN2jQIG3cuFG//PKLGhsb9d9//8kYI2OMCgsLbe4pAMAKfPMHAECY2rx5syQpLi5Ohw8f9p/bd6NbHQoKAAgffPMHAECI8Xg8AbWrrKyUJOXm5t608JOko0ePdkm/AADORvEHAECIaf0h9uuv2NmRK1euSJIuXbp00zbHjx/XDz/80HWdAwA4FsUfAAAhJj4+XpJ09uxZGWNu2q71N/4qKip05syZdo/X1dUpPz+/ezoJAHAczvkDAMAmtbW1Onny5G3bRUZGKjU11X8/KytLxcXFqq2t1ZIlS/TSSy+pT58+kqSIiAglJydLkl5++WXt3LlTly5d0oQJE7R8+XI99NBDkqSDBw/qgw8+0N9//62xY8fq0KFD3fAMAQBO4jG3+sgQAAB0qX379ik3N/eO1snIyNCJEyf895uampSRkaGzZ8+2a5ucnKzq6mr//YKCAhUXF3e43bvvvltr1qxRQ0OD/6qgvC0AgPDFYZ8AAISY6OhoHTx4UIsXL1Z6erruueeem7bdsmWLPvnkE2VnZysmJkY9e/ZUcnKy8vPz/dsAALgD3/wBAAAAgAvwzR8AAAAAuADFHwAAAAC4AMUfAAAAALgAxR8AAAAAuADFHwAAAAC4AMUfAAAAALgAxR8AAAAAuADFHwAAAAC4AMUfAAAAALgAxR8AAAAAuADFHwAAAAC4AMUfAAAAALgAxR8AAAAAuADFHwAAAAC4AMUfAAAAALjA/wDp5yO8eVWhlgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ - "# We first create a list of possible etas to pass in: [1e-16, 1e-15, ... , 1e-2, 1e-1, 1]\n", - "etas = 1/np.power(10,[i for i in range(0,16)])\n", - "\n", - "# Then, we call the function to choose the optimal eta:\n", - "eta_opt = optimize_eta(pce_surr, etas, 10, plot=True)" + "# BCS with default settings (default eta)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now, with the optimal eta obtained, we run the fitting again. Then, we evaluate the PCE and produce a parity plot for the predicted output vs. the testing data. Notice that the larger eta, 10e-2, retained fewer basis terms (6) compared to the smaller user-defined eta of 10e-10 (which retained 20 basis terms)." + "In this section, we use the same PC surrogate, `pce_surr`, for the second build. With the flag `regression='bcs'`, we choose the BCS method for the fitting. A user-defined eta of 1e-10 is also passed in." ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -451,68 +376,95 @@ "text": [ "Regression method: bcs\n", "Retained Basis and Coefficients:\n", - "[[1 0 0 0]\n", + "[[0 0 0 0]\n", + " [1 0 0 0]\n", + " [0 1 0 0]\n", + " [0 0 0 1]\n", " [2 0 0 0]\n", - " [0 1 0 1]\n", - " [1 0 3 0]\n", - " [0 2 0 2]\n", - " [0 0 1 2]] [-1.15692903 0.24292952 -0.29524043 -0.15503765 0.13276008 0.06118484]\n", - "Number of retained basis terms: 6\n" + " [0 0 1 0]\n", + " [1 1 0 0]\n", + " [2 1 0 0]\n", + " [0 4 0 0]\n", + " [0 0 3 0]\n", + " [2 0 2 0]\n", + " [1 0 0 2]\n", + " [2 1 1 0]\n", + " [1 0 2 0]\n", + " [1 2 1 0]\n", + " [1 2 0 1]\n", + " [1 0 0 3]] [-0.62694767 -0.37426547 -0.08797315 -0.02795855 0.04176134 -0.03783695\n", + " 0.01375504 0.02559825 -0.01616989 -0.01758198 -0.02274328 0.01132392\n", + " -0.01835694 -0.00490663 -0.00938681 -0.00898039 0.00175116]\n", + "Number of retained basis terms: [17]\n" ] } ], "source": [ - "# Build the linear regression object for fitting\n", - "pce_surr.build(regression='bcs', eta=eta_opt)\n", + "# (2) Build the linear regression object for fitting\n", + "pce_surr.build(regression='bcs', eta=1.e-10)\n", "\n", "# Optional verbosity output:\n", "print(\"Retained Basis and Coefficients:\")\n", "pce_surr.pcrv.printInfo()\n", - "print(\"Number of retained basis terms:\", len(pce_surr.pcrv.mindices[0]))" + "print(\"Number of retained basis terms:\", pce_surr.get_pc_terms())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After fitting, we evaluate the PCE using our training and testing data. To analyze the model's goodness of fit, we first plot the surrogate predictions against the training and testing data respectively." ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# (3) Evaluate the PC model\n", + "y_trn_approx = pce_surr.evaluate(value_ksi_trn)\n", + "y_tst_approx = pce_surr.evaluate(value_ksi_tst)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "The training RMSE error in the PCE BCS approximation is 8.11e-02\n", - "The testing RMSE error in the PCE BCS approximation is 1.10e-01\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# Evaluate the PC model with training and testing data\n", - "y_trn_approx = pce_surr.evaluate(x_trn)\n", - "y_tst_approx = pce_surr.evaluate(x_tst)\n", + "# Plot the surrogate model's output vs. the training data output\n", + "y_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()]\n", "\n", - "# Evaluate goodness of fit with RMSE\n", - "rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx[\"Y_eval\"])\n", - "print(\"The training RMSE error in the PCE BCS approximation is %.2e\"%rmse_trn)\n", + "fig1 = plt.figure(figsize=(8,6))\n", + "ax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75])\n", "\n", - "rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx[\"Y_eval\"])\n", - "print(\"The testing RMSE error in the PCE BCS approximation is %.2e\"%rmse_tst)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "While the training RMSE error was almost half that of the testing RMSE error for the first fitting, the RMSE errors here are much closer to each other in value. This suggests that the model has more effectively generalized to the unseen data; a better eta has improved performance." + "ax1.plot(y_trn[:,0],y_trn_approx[\"Y_eval\"],\".\")\n", + "ax1.plot(y_trn_mM,y_trn_mM) # Diagonal line\n", + "\n", + "ax1.set_xlabel(\"Train Data y\", size=16)\n", + "ax1.set_ylabel(\"Predicted y\", size=16); " ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtgAAAIHCAYAAACluyv/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAD5KklEQVR4nOzdeXxU5dXA8d+dSQIJSwiLJEAgEISAsi/KqoBWFqsgrSi2KiqoLK4Vgq9oXQlWq1XBBdRqK6iVRSqLWkEhBBFZZJFFYsIahJiQSAgkmbnvH5M7zHLvzJ3JJJOE8/18aM3kLs8kM5lzn3uecxRVVVWEEEIIIYQQIWEJ9wCEEEIIIYSoTSTAFkIIIYQQIoQkwBZCCCGEECKEJMAWQgghhBAihCTAFkIIIYQQIoQkwBZCCCGEECKEJMAWQgghhBAihCTAFkIIIYQQIoQiwj2Amsput3Ps2DEaNGiAoijhHo4QQgghhKhkqqry22+/0aJFCywW43lqCbCDdOzYMRITE8M9DCGEEEIIUcUOHz5Mq1atDL8vAXaQGjRoADh+wA0bNgzzaIQQQgghRGUrLCwkMTHRGQcakQA7SFpaSMOGDSXAFkIIIYS4gPhLD5ZFjkIIIYQQQoSQBNhCCCGEEEKEkATYQgghhBBChJAE2EIIIYQQQoSQBNhCCCGEEEKEkATYQgghhBBChJAE2EIIIYQQQoSQBNhCCCGEEEKEkATYQgghhBBChJAE2EIIIYQQQoSQBNhCCCGEEEKEkATYQgghhBBChJAE2EIIIYQQQoSQBNhCCCGEEEKEkATYQgghhBBChJAE2EIIIYQQouYpOQMlReEehS4JsIUQQgghRM1ybBu8ORhWzQj3SHRFhHsAQgghhBBCmGK3wYaXYe1zYC+DktNwJg9iGod7ZG4kwBZCCCGEENVf/kFYejcc2uj4uvP1cO3L1S64BgmwhRBCCCFEdaaqsOMjWPEXKPkNohrAyL9Bt5tAUcI9Ol0SYAshhBBCiOrpTB6seAh2L3V8nXg53PAmxCWFdVj+SIAthBBCCCGqn5+/hqX3wm/HwBIBV6bCgAfBWv3D1+o/QiGEEEIIceEoPQtrnoaNrzm+btIebpgPLXuGd1wBkABbCCGEEEJUD7/shsUT4cRux9e974TfPQ1R9cI7rgBJgC2EEEIIIcLLbodNr8P//gq2EqjXDK6fCx2uCffIgiIBthBCCCGECJ+Co7DsXsj6xvF1hxFw3atQv1l4x1UBEmALIYQQQojw2L0U/vsAnD0FkTFwzXPQ6/ZqW37PLAmwhRBCCCFE1TpbCKumww+LHF+36OlYyNi0fXjHFSISYAshhBBCiKpzcCMsnQSnDoFigUF/gSumgzUy3CMLGQmwhRBCCCFE5SsrgW/SIP0lUO3QqI1j1rr1ZeEeWchJgC2EEEIIISrXyf2wZCLkbHd83f1PMHw21G0Y1mFVFgmwhRBCCCFE5VBV+P5t+PwxKCuG6Di49mW4ZHS4R1apJMAWQgghhBChd/oEfDoVfvrc8XW7ITB6HjRsEd5xVQEJsIUQQgghRGjtXQnLp8GZXLDWgaufhL53g8US7pFVCQmwhRBCCCFEaJQUweePwpZ/Or5u3gXGzoeLOoV1WFVNAmwhhBBCCFFxR7Y4FjLmZQIK9J8GQx+DiDrhHlmVkwBbCCGEEEIEz1YG6X+Hr9NAtUHDljDmDWg7ONwjCxsJsIUQQgghRHDyfoYld8OR7xxfXzoWRr3oqBZyAZMAWwghhBBCBEZVYfsHsGoGlJyGOg1h1N+h6x/DPbJqQQJsIYQQQghh3pk8+O99sOe/jq/bDHCkhDRqHd5xVSMSYAshhBBCCHMOfAXLJsPp42CJdCxi7D8NLNZwj6xaqTXFCOfOnUtSUhJ169blsssu47vvvvO5/X/+8x9SUlKoW7cuXbp0YeXKlVU0UiGEEEKIGqa02JEO8u8bHMF1044w8SsY+IAE1zpqRYD90Ucf8dBDD/HEE0+wdetWunXrxjXXXMOJEyd0t8/IyODmm2/mzjvvZNu2bYwePZrRo0eza9euKh65EEIIIUQ1l7MD3roSNr3h+LrvJLj7G0joFtZhVWeKqqpquAdRUZdddhl9+vThtddeA8But5OYmMi0adNITU312n7cuHEUFRXx2WefOR+7/PLL6d69O2+88YapcxYWFhIbG0tBQQENGzYMzRMRQgghhKgu7DbY+Bp89TTYS6F+c7h+Llx8dbhHFjZm478aP4NdUlLCli1buOqqq5yPWSwWrrrqKjZu3Ki7z8aNG922B7jmmmsMtwc4d+4chYWFbv+EEEIIIWqlU4fh/evhy8cdwXXKtXBvxgUdXAeixgfYubm52Gw2mjdv7vZ48+bNOX78uO4+x48fD2h7gNmzZxMbG+v8l5iYWPHBCyGEEEJUNzs/gdcHQPZ6iKwH170K4/4N9ZqGe2Q1Ro0PsKvKzJkzKSgocP47fPhwuIckhBBCCBE6xadg8V2w+E44VwCt+sC96dDzVlCUcI+uRqnxZfqaNm2K1Wrll19+cXv8l19+IT4+Xnef+Pj4gLYHqFOnDnXq1Kn4gIUQQgghqpus9bD0Hig8AooVrpgBgx4Ga40PFcOixs9gR0VF0atXL7766ivnY3a7na+++op+/frp7tOvXz+37QG+/PJLw+2FEEIIIWqlsnOOPOv3fu8Irhu3gzu/gCtnSHBdAbXiJ/fQQw9x22230bt3b/r27cvLL79MUVEREyZMAODWW2+lZcuWzJ49G4D777+fK664ghdffJFRo0bx4Ycf8v333/PWW2+F82kIIYQQQlSdE3thyV1wfKfj6563wTXPQZ364R1XLVArAuxx48Zx8uRJHn/8cY4fP0737t1ZvXq1cyHjoUOHsFjOT9b379+fhQsX8thjj/Hoo49y8cUXs2zZMi699NJwPQUhhBBCiKqhqvDdW46Z67KzENPEsZAxZVS4R1Zr1Io62OEgdbCFEEIIUeP8dtzR6jyzPFW2/dWO2tYNmvveTwDm479aMYMthBBCCCH82PNfWH4fFOdBRF343TPQ5y6pEFIJJMAWQgghhKjNzv0Gq1Nh278dXyd0gxvmQ7OO4R1XLSYBthBCCCFEbXX4O1gyEfKzAQUGPgBXPgoRUWEeWO0mAbYQQgghRG1jK4V1f3P8U+0Qmwhj3oSkAeEe2QVBAmwhhBBCiNrk10zHrPXRLY6vu94EI5+HurHhHdcFRAJsIYQQQojaQFVh63uweiaUnnEE1Ne+BJeODffILjgSYAshhBBC1HRFubB8Guxb6fi67WAY/QbEtgzvuC5QEmALIYQQQtRk+7+AT6dA0QmwRsGwJ+DyyeDSZE9ULQmwhRBCCCFqopIz8OUs2LzA8fVFnR3l9+KlM3W4SYAthBBCCFHTHNsGiyfCrz85vr58Cgx7HCLrhndcApAAWwghhBCi5rDbYMPLsPY5sJdBgwQY/TokDwn3yIQLCbCFEEIIIWqC/IOw9G44tNHxdefr4dqXIaZxWIclvEmALYQQQghRnakq7PgIVvwFSn6DqAYw8m/Q7SZQlHCPTuiQAFsIIYQQoro6kwcrHoLdSx1fJ14ON7wJcUlhHZbwTQJsIYQQQojq6OevYem98NsxsETAlakw4EGwSvhW3clvSAghhBCiOik9C2ueho2vOb5u0t5Rfq9lz/COS5gmAbYQQgghRHXxy25H+b0Tux1f974Tfvc0RNUL77hEQCTAFkIIIYQIN7sdNr0O//sr2EqgXjO4fi50uCbcIxNBkABbCCGEECKcCo7Csnsh6xvH1x1GwHWvQv1m4R2XCJoE2EIIIYQQ4bJ7Kfz3ATh7CiJj4JrnoNftUn6vhpMAWwghhBCiqp0thFXT4YdFjq9b9HQsZGzaPrzjEiEhAbYQQgghRFU6uBGWToJTh0CxwKC/wBXTwRoZ7pGJEJEAWwghhBCiKpSVwDdpkP4SqHZo1MYxa936Mp+75RQUk5VbRNum9UiIja6iwYqKkABbCCGEEKKyndwPSyZCznbH193/BMNnQ92GPnf7aPMhZi7ZiV0FiwKzb+jCuD6tK3+8Vag2XkBIgC2EEEIIUVlUFb5/Gz5/DMqKIToOrn0ZLhntd9ecgmJncA1gV+HRJbsY3KFZyAPRcAW5tfUCQgJsIYQQQojKcPoEfDoFfvrC8XW7ITB6HjRsobu5Z5CblVvkDK41NlUlO/dMSIPgcAW5VXkBUdUkwBZCCCGECLW9K2H5NDiTC9Y6cPWT0PdusFh0N9cLcgd3aIZFwS3ItioKSU1jAHOzzv62CWeQW1UXEOEgAbYQQgghRJC8AtiSIvj8UdjyTwBKm11C5B8WQPPOPo+hF+Smpw5h9g1deHTJLmyqilVReO6GS0mIjTY162xmm3AGuW2b1vN5AVGTSYAthBBCiBovHDnEngHsm0Ph6j2zIC8Tu6rwlm0ULx/5I08eqs+45sbjNQpytx7MZ1yf1gzu0Izs3DMkNY0hITba1Kyz2ZnpcAa5CbHRhhcQNZ0E2EIIIYSo0QLJIQ5VIO4awFqxMdnyKUPSl4Bi55jamIdL72Wj/RLAO7D1HO+MESleQS7AlIXbOH2ujHF9WrsFzp/tOOZz1tnMNpqE2GhmjEhhzqq9judSBUGu6+9A7wKiNpAAWwghhBDVmq+gOJAc4oou5tObdW6t/MJLkfPoZfkJgMzm1zDm4FgKqe/czzP49Rzv86v2MWN4CnNW7/UKilMX73Q+F9fxe9Jmnc1s4/kz0YJrBZg+vGOlLnA0+h3UlsBao59pL4QQQggRBjkFxWRk5pJTUAw4ArIBaWsYP38TA9LW8NHmQ27b+8oh9jyuXiCunccfz3HsPHyKG61fszJqJr0sP1GoRvNA6VROX/smp5X6bvtqga2vmeWurRrx1+u887RVYEt2vtf4PY//3A2XAhhuY1Fg+oiOboGs5zFV4PnV+0z/TAJV0d9BTSIz2EIIIUQtoTfTW5OaeOilTmizq6A/O+0vh1h7/nlFJaZSJox+hq6BYUP1N9p8dS93R34HwCZ7Cn8pnczUG4aw9/hvqC7nURR47oZLWf7DMdJW7XX7nud4fy06p/tzURT9CwlwzDovmdyPbolxZGTm6m6j/ezSVu7l19/OMWFg2yotA6ipzVVDPEmALYQQQtQCerfegbA28QgkuNeb3XQNrjWeAZmvhXKuPxMFxz/P+HPHkVP0S24CGKcvuAaGgyw7eCHyDZorp7ArkeztfB+5HSbwcVJTAAakrXE7h6LCobwzzF2bqfu8Xcfbq433GBUFeraJc/63Z4CuAmdK7ID+xYbntm+tz2JBehazb+hCSnwD3e1ioionwaE2Vw3xJAG2EEIIUcPpBaczl+xEVc8Ha2bqG4dyAeA76Vm8nZ5leuHhou8OeQWGRjO2nrPTgzs0Iz11iM9KGwYxJ8+v3sd13R2NX1IX79T9ebVtWo9opYTp1kVMiPgcgJ/sLXmgdAq7tyRh2bqD2Td0IbFxjPdzAMPgetaoTvROiqOoxEZOQTEJsdGkje3iFeRrv4vUESnMXrnX7RiuAap2seH6PPRoz+3lm7rpfl8L2PUYvUbMvHZqc9UQTxJgCyGEECEUjpQMvVvvesGpr9vx/hYAas+rXpSVohKbYRrKuv0nvQI8fwsPjQJC3dlYxdx4jVIqjH4m/91xzGsM2vf6xRzl2yZPE3vaESi/Z/sds0vHc5Yot+e3ZHI/rzFbcATZes/twMnTPLtyj9dz0KuqkVNQTJeWsUy5MpnXv87Ejn7Fj8EdmunOdOs9b4uiBDSjrJfC06VlLDuPFjjvNvi7mKqtVUM8SYAthBBChEi4Wk7r3Xq3lAdZrnGWUfDkrxKHXmUKiwIzhqfw6+lzzF+fhWpwTo1RvvPMJcbB9Z0D2zJ/fZbb46oKWw/m+60csuFArvEPzMNb6zNZu/ek1+NW7MRum4f64z+ItZdii7mI/Zen0Tj2cs4u2u71/M6U2L1maO+5oh3zvs70eo52FRZ9d9jt65lLdhITZaV3UmNn2groBLYjU+jaspFugGr2wsKqKPRsE2d6RlnvNeI5m6497u9OSUJsdEgC6+q8vkACbCGEEKICXGd2w9Vy2ujWO2AqePJXiUOvMoVdhdmr9no9ZkQvuPcVDL5yUw96JcU500xcj2NXVZ+52W+uyzRMy9CjF1y3IJcXI9+g864fATjSfCitbp1Pp3pNaVRQbDjz2y+5CSnxDdicnU/+mRJe1wmujdhVmLZou9vFmVFZv/TUIbq/S6M87MvaNmZzdp5brWuAxMYxLJncjzMldp8zymYDd6iahYvhupg1SwJsIYQQIkhui+h0bstXZYUEo1vvZm7H+1p8FkhgZcRSXknD8/xGwaACJDaOZt3+k7oVOXonNTYcb05BMWk6M6uBuM6SwTOR79BQOUORWocny27lk0NXsjTPSrd65c1ZhpdXOAGvhZX+cqD9cb04C7TyhjY2z4uf77PzWTq5vzOQXrf/JAPS1rgFqK6z5p78LaB0FYqFi6GqfR4uUgdbCCGECILXIjof5ddCfV7XOtGuEmKj6ZfcxCs32l+uqzYDblUU57i1gFELrMxSlPPBhQWYNLgtG1KH6s4uauf1pAJj5mV4BaqKijOIMhrvu+lZPoNbC840bi8NKeLlyNd4Jeo1Gipn2Gpvz4iSND62DcGuKoyem8FHmw/x5rpM0lY7gmulvL60Nttc0eBaowXRej9/14sJvddCl1axusc7U2J3BtFei2IX7+SHw/mG4/H8mRup6MLFnIJinl3xY0hqn4eTzGALIYQQQTCa2dUWtVVGhYRAbosHegvdaAbcM/3EFwuO8wS6iE1vZlTvZ2sH58yt3nhzCoq9crZdzR3fg55t4lj+wzGvEoCXW37kxcjXaan8Splq4ZWyG5hrux4bVuc2KjBj8U63Y6rlKRvXdWvB99l5IQmu4Xy1FKP0n3X7Txr+fo1mm7WShLqLYoHR8zJIM7lAcceRUzy/ep9zTNOHd6RrK/28cLP0Zv+DqX1eHUiALYQQQgTB6EPeTD5rMAK5LR7sLXSjxWdaYLX1YD5TFm7z+r5FgbsGtmPCwCS3wDzQ52TGTycKnT9bz/Fm5Rb5DHAb16vDuv0nSVu517ldFKU8FPEJk6yfYVFUsuzNebB0CtvV9qbHpM2eKn5mdwOhAu+mZzFhYFuviwnAmd4B3r/fhNhoJl+ZzGseeehaSUKjAFwNYIFiv+QmXNe9hc8LqWDqoJtZIFsTyv1JgC2EEEIEwehDvltiXKWcz2wurq923IHkg7sGR+fPrx++PnndJSRfVF/3e74Ek9/9+Kc/8tflP+rOyPvLE/58dw7vbzzoDOLaK0f4R+RcLrEcBGBh2RCeKfszZ6gb0JgsimO2OalpjHejGGB09xYs3X4soGOCe1MY7bma6Ur50eZDzP3ae5Gns+xgchNm39CFmYt3epUQtKkqW7LzaVzff0dQX9VAPJv8TBzU1tlBUo+v14Le7HR1L/cnAbYQQggRpKr8kDdzW/zNdZl+23Gb8eY35cfhfL6yVoZPL4B8YvluZyCVOiKFu69INtW2PZCFc66MZuSNFvhp/plx0PlsbrN+wcyIhdRVSvlVbUBq6US+tPf2eV6jMoSTr0x2Pi/PRjFjerRk6bajgT1Bned6qrhUt7OlxjUvW2syZLQNOF67KfENGD0vw30hKXDfh9sq1BFUr8mP3sWCK6PXgtECWQhdub/KIAG2EEIIUQFV9SHv77b4m99kGgaWgdxCf3Od+3E882FdW45byv/fNZCavWovPxw5xepdx50B2Z0D29K0QR2vZiSDOzSja6tYth8uCPjnYTQjr7fAz1Uz8nkh8k2usO4AYK2tG9NL7+YkjQz3mXJlMgMvbuasvuGZJzx3bSavrc10Pq8NqUPJzj1DTJSFMfMyKlyFxaaqhhdOmukjOpIQG01GZq7h2gDP10C3xDjSXF5Tnr/PYDuCGs1G+9rX8/WtAKO6xDNxcLtKuytUmSTAFkIIIWoIX13+0gyC61mjOjGya4LpnGij42i0uEkBbuqbyEKXZimalTuPO//bruK18NCuUuFqG0Yz8ht+Mm4wc41lM7Mj59NYOc1ZNZJnyv7Ev21XYVxXxGHgxc3ol9yEnIJiYqKsXtP4rsHnzMU7mX9bL6KjIjiUdybg4NrzDgGUL5z1c5yuLRsBxk2Hlk7u7xWo5hQUu9XB/rXoHFM9cuwD7QhqNAYz+2qv73fTs1mQ/jOf7TzOyl3Hq12NazMkwBZCCCFqEL0Zc6PFfRYF08G18zgmA0IVdINrswINrpXyyFMFZ9WKrNwi4PyCyjfXZermHtejmMcj/sW4iK8BOF6vI3/Ov4uf7C39nlcL5PW6WeqxA3e+twXQT6nR6KZDAE9efwl7cn7jw82HnE1hpg/vyJzV/tNDAN3a4bNv6OIVXOtVmUmJb+BVzz2QjqAabTZaL8fbTKrSgvSfq3WNazMkwBZCCFEjVaRNcnVtsRzsuIxmDK8sb1QC5qp6+Gr8Eqryc4FSgFdvdnR1BEeZvh1HT7mlm8wYkUKL2Lq6rbt7Kvt5KXIebSwnsKsKe9vfQeeb03i/yMa76dnMX/+z4XNTwNnxMNBqJ4CzAZFFPV+60bWc3br9J93KH6rArE93O9vQu5a9axQTeT59wuNiQxvjZzuOGdYOB99dR1MX7/QKrgPtCOpKm42e8ckO1rncVRjdo4XPfQNtrFNdSYAthBCixqlIm+Tq2mK5IuMyWty3Zt9J1uw7afp4nnmwWvB6XbcWbD2Yz9SF23SDUQVHIKmNffil8c4c7FDolRTnDK5+PFbgFkjbVXQD6wjKmBaxjKnWpVgVlTPRCRRfO4/OlwwF4ERhvs/gmvLnlBLfgMeWGgfXeh08XakqPD36Es6W2umTFOc2kzyuT2u+2X/SmVLjmmoyZ/Velk7u73zeeqX6tP927croSasd7lo3W3eceMxcA2/d2pPoqAjaNq1HeuoQw8W8vi4M0w+4p+ws23aMv1zTMaiuojVJje/kmJeXxy233ELDhg1p1KgRd955J6dPn/a5/bRp0+jYsSPR0dG0bt2a++67j4KCwBdYCCGEqHpGNZ71OhuGct/KFIpx+Vrc53o8X50gwRHIpacOYdHEy9mQOpS7ByeTEBtNzzZxjOwSr7uPCvRpE4dSfq7Vu44zY3gKkwa3NT1+Iyo4O/Q9/PF2Z/qFL0lKDp9EPcn9EUuwKipLbAPpd+pp/nemPTkFxTy34keun5vhd1bersL1czP4au9Jr+8pOBrXpI5I8TueWct288yKPYyZl+HWlfCHw/lu+ep65352xY/O35Vrp07tv8H37LpFgTMlpQHPwNuBu97b4uymuG7/SbcuoZqPNh8y7LoYTMdFX106a5IaP4N9yy23kJOTw5dffklpaSkTJkxg0qRJLFy4UHf7Y8eOcezYMV544QU6d+7MwYMHueeeezh27BiffPJJFY9eCCEuTBVJ0ajILeTqevu5IuNyve3vq+SdTVV5d0MWC9Zn+Z0l98zz1uuw52lTdr7zv+2qo6nJksn9nOcLljZ7+cPhfBZv9VfuTuUm61oej/gXMco5CtQY/q/0Tj6z9wMgdclOZ2pFRU0c1I6ebeKYtmib322NKnB8l53nd9/56x2/s7Sx+r8rf7XE7aojUPb1nLXqIZ7b+Ksc4q+hkb/ZaL1a622b1qv2Na7NqNEB9p49e1i9ejWbN2+md29H7cpXX32VkSNH8sILL9CiRQuvfS699FIWL17s/Do5OZlnn32WP/3pT5SVlRERUaN/JEIIUe1VNEWjIreQq+vt52DGlVNQzKtf/eRcaKjVXF627ZhuS3MFeGvd+WoeZheP5RQUB1Xxw6aqbM7OD6qKBrjnFyfERvPZDt+NWhpTyJzI+Vxtdcxwb7BdwsOl93CcJs5tzC7gNDPGCQOTgmqU43rh1Depsal9VIx/V2ZqifsaolZlxjUfXO94ehd8/i4MfZWW9GxEo43T9W+CZzBfHddNGKnR0eTGjRtp1KiRM7gGuOqqq7BYLGzatIkxY8aYOk5BQQENGzb0GVyfO3eOc+fOOb8uLCwMfuBCCHGBCraFt6uKtEmuyL6Btn0OJBgIdFx6M8p2FZZuPcqToy+hcUwUR/KLeX71PmdNYT1mZsm/z84LesY3v6gk4AWS2oJGz9lLo2D0Dz1akvvDZ/wt8i2aKQWcUyN4vmwc79hGoFZSJuzkIcmm7hrosSiQe/osOQXFdEuMY2zPliZm5o1/V86KHUEswrQqirPKjOussV79br0LPjMXhnqz0XqNaDRaqcOU+AbOfPXqum7ClxodYB8/fpyLLrrI7bGIiAgaN27M8eP6OU2ecnNzefrpp5k0aZLP7WbPns2TTz4Z9FiFEEKELkWjIreQg9k3kA/4QLZ1DcTNjsvXjLIdR76v1txlyeR+HM4rdnbm0xMT5TsIVRTfNaJ9ef3rzICCa6uikNg42u3iRPsZ7TzqvVaqd4souu16hj9HfQnAXnsiD5ROYa9aecFX+2YxvP51JnPLG8uM6dGSJVuPmnqe2oLIaYu2O18bL97Ynfp1Inhv40Gf+3oGrp6vnZgoK9MWbfe5/71XtmPe15nO8n+eF3GuqUFmLvgSYqOZMSLFWdHF13b+Zr5d2YHR8zJIK29GVNGL8nColgF2amoqc+bM8bnNnj17KnyewsJCRo0aRefOnfnrX//qc9uZM2fy0EMPue2bmJhY4TEIIcSFJJQpGhXpoBjIvmZn3XMKitlyMN8t+PUVDBgF4mbyyM0szpu/Pov567O4tku8z2DmSH4xRSU2r5bmWw7mk3+mBLV8BjyYWWzPGsieLr6oPpknTjtL2I3u0YLR5YsPFeCGno4243rjv1T5mTm5c0m25gCwoGwEfysbxzmighipeQdOnl+gZ1cxNfuscU1R0V4bKfEN+Ne33sF1Ylw0R/OLnT8b18DVqIa1EauiMH1ER7q0jOXqzs05U2L3e3Fp5oLvo82HnMG1Akwf3tHUzLKptJbyn88/bu5eLddN+FMtA+yHH36Y22+/3ec27dq1Iz4+nhMnTrg9XlZWRl5eHvHx+iudNb/99hvDhw+nQYMGLF26lMjISJ/b16lThzp16pgavxBCCH0VSdEIFzOz7r6akOgFAxVJldGbyfXlM4MqFeCYUdVK7ykK3Hp5G47kn9GtmlEZDpw4zYLbehETFUlMlMUZXIMjoNcLXi3Yucf6Xx6M+IRIxcZxNY6HS+9hg71LlYw5lHzlqR85Vczzf+hCQXGZW3k/vdfOzMU7+cfN3XXPMWtUJ8rsqlebeq0CiS++LkT10jyeX72P67r7rnOtHdetLbpBqUNbeYeb6rhuwp9qGWA3a9aMZs2a+d2uX79+nDp1ii1bttCrVy8A1qxZg91u57LLLjPcr7CwkGuuuYY6deqwfPly6tatG7KxCyGE8K2mVQgwUwnBV/6rXjAQaKqMa6WQOX5amZvl+ZxUFb9pCv5cfFF9Dpw4bXq2W8VR4SJtbBdioqx+92ulnOTvkfPoa9kHwApbXx4tvYsC6ldk2GFjVRT6JMXp3iFQVXjkk52A4+IndUQKdw9O1n3t2IE1e06gp2F0hPM4oH8xF8wCQqPX8JbsfBrX9z6W5zk8/w6cKDzL6HkZXo1ueiXF1biLcqimAbZZnTp1Yvjw4UycOJE33niD0tJSpk6dyk033eSsIHL06FGGDRvG+++/T9++fSksLOR3v/sdZ86c4d///jeFhYXOBYvNmjXDarWG8ykJIcQFoSLpHcEItgKBtt/wS+Pd6hW7dqPzlU9qUdANBgJJlTHbotuM+4a2Z1ini1ixM8etokio/HTCuA+FEa1CxkNXX+xzqzGWdJ6K/CcNlGJ+U6N5ovQ2ltgHgeESzurNguO10S0xjtQR3k2CXKlqeTMdFa7r3kI3IF+2Xb/KimtwrXG9mAt2AaHea1gBZ76/67E8K4ZMHNSWCQPbuv0dSIiNJs0gkK5pF+VQwwNsgA8++ICpU6cybNgwLBYLY8eO5ZVXXnF+v7S0lH379nHmjCNnauvWrWzatAmA9u3bux0rKyuLpKSkKhu7EEKIyhdsAOErsHXtRucrn9SoLJzZVBl/s+OBenXtAerVjWDB+tAH1xVhU1W2HDql+71YTvNs5Dtca/0WgM32DjxYOpkj6kW624dSZbWItyiwdHJ/Z9rHdd1b+AywNbNX7aVlXDQ39010lmfUBDJOC5DUNKZCqUpeXT/Lx+B5rJT4Bl6pJG+tz2JBepbXe9FXIF3VF+UVpahqqKpCXlgKCwuJjY11lvgTQghR/eQUFHu1kLYqCumpQ/zWfjZqPa1ZNPFyZx7rR5sPOQMNT77Ol1NQ7BVMuM62Z+UWMX7+JpPP1pxAy8pVFb1gtr9lFy9GvkGCkkepauXlsrG8Yfs9Nmru3WbtYso1sMzIzA3o92wpz1kO9tc4aXBbHh3Z2fC8rq9tf3d/tNfwr0XnmLpwm9f3HxvViWdW6BemMPNerG7Mxn81fgZbCCGEMBJMWcCcgmI+23HMZxBqVOt3xY4cr2DC1/k8Z+Xe/CaTtFV7nQ03ZgxPMVwA5suA5MZsyNTvElgdg2twDxbrUMJfIj5mYsRKADLtCTxYOpkdanJ4BhciWlMXvZShQGbL7aojL1sJIsi2KDBhQFvneX2lKpm5+6O9hnMKinWPZZRjDjWjGkiwKqcCuxBCiFojp6CYjMxccgqKwz2UgGktmD0ZVSD4aPMhBqSt4dkVxrfrXdM5XH82CbHRjOqagEXx3t5fxYOcgmIeXbKD2eXBNTgClTmr93JbvzY+9/VkUWB0j5YB7TO0Y7Nqk8ncUTnEsqhZzuD632XDuLbk2RofXLs2dfGUEBtN2tjAqqCoKkwb1t7/hi6U8iDZNe959g1dsJbXOvd8beuljxj9HTA6VrfEOCYOaqu7j5aqUhvJDLYQQghDNbGD2g+H8/kuO89nG+oThWcDyne2KgrTh3eka6tGznQOo59NoBUP9Loyauwq/DPjICMujWf1ruOmZiuTm9XXXdjmy9p9J0kdkeLs/BgOCnbusK5mesSH1FHKOKk2ZHrp3ay19wjDWEKfez19REe/M7WBnNeiwLCUi3htzQFTdyUeuaYDN/Rs5TUGo7znYO7+GB1rwsC2LEjP8jrejBEptXL2GiTAFkIIYSAUbc2r2sMfb3erndylpX6O5PfZ+c4FZhqjaiB6t/V9/WwCqXigHcdffLRq13EUk9FXsJU8DuYVkZ46hK/2/MJjy3ab3nd09xZ8uv1YhQLSeH7lhcg3GGh1nPdLW09SSyfyK7EVOGpwLArce0Uyc7/ODOlxu7Zs5Pxvz7xmo9eBAlzZsRlr93nXJZ8xIoVuiXGm26S/+MV+Tp0p5Y7y6h2u9BYQBtsUSu9YXgsiFcf47x5cs+9K+CIBthBCCF2hamteVX44nO/VmGTn0ULdbXsnxXk9ZhRQ6N3WN1MD2LWRh95CMTO53q78TSxbFYURlzb32VjGl4WbDjNt6MW0axZYTenY6MgKBdcjLd/yXOTbNFKKOKPW4emyP7HINpRwld/7fbcWpCQYd0U0ol0A6f0s/OU1JzaO0a9Cg+PuwohL4/l813HsONIqXINT7YLu3Q1ZLFiX5ez8OLhDU7fAXOvuuWB9Fmlj/d+JCnVTqJpYaq8iJMAWQgihK5RtzUPFV0WD77L1F/V1bdWQHUfOB9pje7b0mr2GwErn/Xr6XEA1gFOX7EQtX5iWdoMj1zaU5fe0WfYfjxUEHWADfLXnF4Z1ah7QPsE2p6nPGZ6MfI+x1vUAbLe348HSKWSpCUEdL1Q+3X6M5To1pX3dQNB+/gBbsvPJ+DmXDzcddgbEdw5MAoy7MF7XvYXPMa3edZxlU/obtjhPiI3m0ZGdmTCgLdm5Z4iJsnD93AzdY2l1x7U7Ub7eU6EOimtaqb2KkABbCCGErurW1txfPrhRzvXT118KONJCenu0nPYMLPwFFL5qY6ucn2V2rQE8Y/H5fGhVhRmLdwaV46vgCNA9z+06y56VWxTgUd3NWrabg7+eYbxOneVQ6q3s5aXI10m0nMSmKrxmG82rZWMoqyZhid7vxuj3ZQHnz9+zoUrXlg3ZebTQWff5zoFtdbswGjWJcT334bxiru3mOxDXAthnV/zoczvtTtS6/SdNVwkRgaker2QhhBDVUnW5rWsmH7xbYhxje7Z0SxNxna2+qGFdsnKLyCko9hlY6AUUOQXFbDmYb7gYUY9NVfnUIHAKZuJaBZ667hIO559h/rosRyk/HN0AAT7bcYy8Iu+Z9UDPMT+ETWg8SwxGUsb9EYu517ocq6JyyN6MB0qnsFXtELJzgiO4HdklnhUmZvMrWhf8rsFtdatuqMAOlxQluwpvp2cFvYBSMciY0cvnfjvd9+/QqijERFmCWmMRbFfUC40E2EIIIXyqDjNYZvPBX7yxO7f2a+M1W+05++3apMNfYBFsq3LHeUJbi+KJ5bsZ06OlM3BVgSVbj7jNkkPldSAM1JQrk3ltrWOxYLJylJci59HV4gj+Pi67gqfK/sxpQp9ypIKp4Brg4d914G+f7w/qPK41pY0Wybqyq44mL2+vzw64WosKznKQmkDyuTXanaiiEpvf95RnMF0TqwqFiwTYQgghqr1A8sG7Jca55VjrzX570gILQLe6QzAznHcNbMeorvG8mxFcjrJekGxXcZuhV4FNWfle+wYy3MoKxkdcGs9frknhdHEpZZvf5v8iPiBaKSFfrc+jpXeyyn5ZJZw1cC8EGVwrwOQrk8nKLeJE4VndvHxPVkVhwoC2TBjQ1rBai0WBMT1asmTrUbffy9SF27AocOfAttwx0BHU681AL5ncz2scFgXm39qLrNwz9Cm/8DRqDGO0GHPG8BTmrN5bo6oKhZME2EIIIaq9QPPBPduN+wuQrYrCjiOnuGXBt6ZnA7U79nrfVoAJA5NIiI32SlsxIxT1M1Li67P3uP+SfTf3bc3C7w6F4IzuPt91nLn/3cAVWx5lSOR2ANbZuvBI6d38gnGN8qoW7MWFCry2NtM5Q29G//ZNOFF4ls925Oim4ijA0sn9uahhXZZuO+pVOca1EsjNfRN1Z6DPlNi93iuje7Rg4vtbTNds17sonbNqL3a8z1ddqwqFmwTYQgghagSz+eBeM28jUrxmaZXyf3bK6x5f2U53du6eK9t5Hd+iwCs39aBXUhzfZ+cxbdF2r20mDmrnHJ+WtvLVnhO8suaAqecaihllM8G1VVHo375JpQTYQy1bGPf9fJpaCzmnRpJWdhP/tF2DegE3kV7/Uy7rf8o1/L62mPG77DyfF4Uq6C5C1Wag+yU3cb5XYqIsjJmXEVDNdr2LUjveOfX+qgoZlae8EHK4JcAWQghRbfj78PWXD24086YXq9w7JJl5azOxqzD360yv2UKbqjJPp9nI8EvindUceic11i3XN6G8LJumW2IcRSU20wF2VdAWSPZq412ysCKiOcusiH8zPmINAHvsrbm/dAr71US/+1aX3PFwcS31GCiLgttdHe29kpGZ6zPXOpAmM9NHdOT5VftM3UXSy9cGLpgcbgmwhRCiFqtJs0XBLKDyfH66M28GJfXmutza11tvZjHYd/Wu487FZlrqilbnWjv2u+lZTBh4fvFb26b1dIOWcLEo8OT1lzC4QzOW/+C7RFwguikHeClyHu0sx7GrCvNtI3mx7EZKiPS53x39k8gpPMuqXcHX8K4tgn19vHJTD90yfsHUszdKyRrXpzXXdWvh9y6Sbr3v8veI2cXFNZ0E2EIIUUvVpBX/wbRl13t+gzs0q1AQawFnJ7zpwzuStnqvdx4suOWdDu7QzGva9a31Wc4cW5Xz45sxIsWRyxrmINuuOmpezwqgJbovVmxMtn7K/RFLiFDsHFMb83DpvWy0X2Jq/3cyskMyjppKAZ66/hJmfRrc78OqKPTS6U4KwdWzzykoJrFxDEsm9/NqbmOmqpDZC93anMMtAbYQQtRCwQSsVTEmo9n0QNuyGz2/9NQhbsFEIKyK4gwoYqIsFJXY3MrMuW7nOvuXlVvktzGJXYXUJTudrbQVYLhL++uarLXyCy9FzqOX5ScAltv68VjpBAoJrOV6TXHxRfV54Y9dOVNiJ/2nk7z+daZbC/P0A77zrD25Xhw+sXx34OUgwW/AHEg9e70L137JTQIak96suWd5TAh/Z9jKJAG2EELUQoEGrJXN32x6oLexfT0/LZhYsSOHZ1bsMTU+bVavW2Kc11hHuATCerN/ZlM/XON9FUeVjSevv4Q9Ob9VyiLDyqfyR+s3PBHxPvWVsxSq0TxWegfL7QPCPbCQ0QsKM0+c5qKGdUmIjaZfchP+1K+NW+B6XfcW9E9bo5t2pBnftzXj+rTymh12vTjUO7cnBVg6pb9bWUojrjPPRhe7obowN5o1B6pNZ9jKJgG2EELUQsHkXVYWMx/agd7Grhdl1X08JsriPN6orgk8t3KPz8DXtSJIQmw0X+057ta0xa7CF7t/YemU/l7BkEYbu2ezF3/swKxPd6Mo0D0xlu2HCwLaP5wa8RuzIxcwwroZgB+jLmVbrzSWry30s2fNcU3n5sREWVi6PcftcTvwzGd7eOzaTrqLBBNio7mhh+/SjB9tPsy0Ye29glvPtIx1+0/6vBuTOiLFq+a7vzUXvi52Q3lhbjRrXh06w1YFCbCFEKIWCibvsrKY/dAO5DZ2UYlN9/EVO3OcAYfez2B0jxYs23bMOUM4rk+is+j0wx9v1w2KtNrCnrfJXYOZiuR+qyo1KrgeZNnBC5Fv0Fw5RYlq5cWyG5l/dhT2WhRcA3z+4y+G31uxM4eVO3NIG+sITl1fCwBLt/mue+75+jdKy3B9T+w4espZwUMrP3n34GTnMfUaw3RpFetVIs/oYhfQbZZTkQtzvXzt6tAZtipIgC2EELVUIAFrZQpkNt3sh+/Oo/oB6YJ1WUwY0NZ5DL2fwV+u6ci7G7J4a10Wi747zKLvDvssD2fBMTOekZmr2zJaUeC6bglhX7hY2epQQmrEIiZEfA7AT/aWPFA6hd1qUngHFiYqjuD0VHGpc+GqosDNfbwbwHhyff37u8Oj/euX3MSwgofeMWav2gu4z1IbXey+u8HRvMaulteIL09Pqe1pHJVJAmwhhKjFqsNska/Z9EDKCGrb1ouyMqc8ePBkB1bsyGFU1wSfVQ/mr3PvoucrHhp4cVNnow5t5tC1EoiqwqceaQS1TWclm5cj59LB4piZ/WfZ75hdNp5zRIV5ZOFlU1XSVp2vNKOq+g1gtKDVrhO0mrnDo732i0vK+Dm3iJgoi9tr2le3UteA3Wjx4fx1Wc73gApYVHhtfA96ltdId724FOZIgC2EEKJS/HA4n++y8+ib1Fh3JjmQMoKeM8a+FpA9s2IPz63c46zM8H12HoqiOBuqfLbjWEDNTNIP5LrNDFaHMntVxYKdu6wr+EvEx0QpNk6ojZheOomv7d3DPbRqQcH4teha8vG5Gy41vJvk7w6P62vf1dieLXnxxu6Gx3ClBez9kpt4XezeMTDJq227HWhcrw7r9p+sMaU+qxtFVQOsYyQAKCwsJDY2loKCAho2bBju4QghRLXimc+sBQOus9Cu7ZvBEVSkpw7xmiXLKShmQNqaoIJavRbpVf2hpwB/uaYDsdGRPFaButPXdL6Iz388EbqB+dGCXF6MfIN+1h8B+NzWm5mld5FH7f7MU4ArOjbj630nK3ScueN70LheHVPpWR9tPqTb1MXfa/9Tlwoirsfw5Pneyikodgb7gNc5tJKVZt+jFxKz8Z/MYAshhHBT0e6PPxzO91osuHjrUeIb1uX1bzKdeZ6eYYBRtQKj29/aDKGjlF4CK3Z6p2l47hZMcO1vxtwfFXjh8/1c2bFZ8AcBr+Bae/6V4TpLBs9EvkND5QxFah2eLLuVj21X4lwRWs2MuDSeAe2bcKLwLDuPFrK2AsGxCtw9OJlLWzT0qoFulqX8OGbXPhitl/CV+gHwfXa+M8A2WhCpl0ftmTall8JVVGKrVqU+axoJsIUQQjiD6p1HC5wpEEa3hP0F4N9l5+meY+7XLq3Jdb6v3Rb3PL7RLXTXcmYAK3fmhHx22qooTB/R0RmsBEuFCgV9nm65rDVDU5px53tbQnZMgIYU8VTku4y2ZgCw1d6eB0snc1CND+l5Qm3VruMha7NuVRRioizM+zq44BocFz5TF24LKK1Cb62Av9SP3h7dG80siNSjF+DnFBRXm1KfNZEE2EIIcYEzyvHUq1ftL286p6CYOhEW0+e2eCz8Msr51Jth82yuMXFQW97yyCWtCO08KfENmDykHUXnbLyzIdtw++6tYtl+pGrK7S367hAJjeqG9JiXW37kxcjXaan8Splq4ZWyG5hrux4b+jXHa5r7h7XnH18d8LmNRcFw9jYYdhVSF+801ahF78LVc4Gwq8EXN+WihsavgUAXOOvV864upT5rIsnBDpLkYAshagMz+c2LJl5Ov+Qmutu65mQaBeoAQzs24+v9J/3OQvs6vmveqN6H/A+H87l+bkagPwKn8Zcl0r9dU/LPlKAoEBsdyapdx1m509zMqOvzOVNSGvLZ5coSRSkPRXzCJOtnWBSVLHtzHiydwna1fbiHFjIWYMPMoSz/4RizV+pXoFGABbf1YlineHIKiuk/e43POyLOFCX8p+qMvyyR58Z0Nfy+mQvX7NwznCkpZenWY3xWng5VFQsP/b3vLjSSgy2EEMIvfzmerreEfZUTAwyDa4Cv959kTI+WziYverPQGZm5PnM+9WbknKktRwpI8yjdpwA3903ULZvmyaJA45gopn24Leh8a5uqcjivGBUVRVEYb/Lc4dReOcI/IudyieUgAAvLhvBM2Z85Q2hnx8NJAWaMTCErt4jrurUArRKMx3YqMPH9Lcy+oQunikt9BteuF1MxURavxYCeFm06TL92Teid1Fj3NWym06l2kXmXy4WbXYXUJeZmyINVHUp91kQSYAshxAXMV46n5y1hX+XE/AXqdhWWbTvmNmNtJt/UM+fT9Ta6azqJkXF9Evlw82G/t/uv6Ngs6AVtGgWYumib29fVl8pt1i+YGbGQukopv6oNSC2dyJf23uEeWMjcMSCJJvWjOJpfTNrKvY76zuUzvhtmDuXVrw6w8LtDbvvYVfy2vFcUmD6io9vFoVEah0YFpi3arjvjHEh78i0H870X7qqw9WA+o7q618yWutXhJQG2EEJcwPTyLKcP70jXVo28gmDPbS3A9OEdndv4axWutRzXAnLtmL7G4hrgv/lNpqOpR/n2/kruqcCR/GLG9Gip2wLd1dq9FV+AGIqKJVWhGfm8EPkmV1h3ALDW1o3ppXdzkkbhHVgAtMWnRukegG6+vDY7fM+V7byCa7PU8hlwgC4tHa3IXRcJpv900m1Br975XWecdZu/gO5iQqOsXu3hQGrLi8olAbYQQlzgAmmpPq5Pa04Vl5JWXmlkzuq9NIqJ9FqIaCkvbecaDlgVhfQDJxk/P9NtNtE1ADCqZvDqmgMs3OQeEJkJYPOKSli6zXdwfSG5xrKZ2ZHzaayc5qwayTNlf+Lftquo7vPtGosCr9zUg17l1TN8BdhGbKrK3ArerbCr58+tAKkjUrj7imRnBY+GMZGGDYk8Z6e1C8vUxTvduimu23/SKzjundRYt7Z7r6Q4U6kmoupIgC2EENVUVd7qNZtnmVNQzByX1tCuH+KDOzTj5Zu6YVEUeraJY93+k26z0ddc0twtsDEKAFzH8tHmQ26BRyAUIK5elKlqEOFoQFOV6lHM4xH/YlzE1wDstCfxQOkUMtWW4R1YgLTfZVZuEb+ePhfewZRTgdmr9oLiqJ8Njv+/rlsLth7MZ+rCbV4Xmp6z04M7NHOrt65i/N5IG9uFmYt3OhdYzh7bhYTYaL9rGETVkgBbCCGqoep6q9coX/TdDVksWJ/lNV5tNjomysJonQofvgIAbUYu2OA6bWwXjp4q9rutRYEZw1N4fnXFal1XVz2V/bwUOY82lhPYVYU3bL/npbI/UFoDQwAFnAtRlSAn3RPj6nI4/2xIxwWOtJHrurVwm5ke1TWa0+fK/Ja6CyQP2+iOk5k1DKLq1Lx3lxBC1HLV+Vavbr6oAvPXZTkDYc/xJsRG89yKH3UDZaNcU/Bf4cSVNgNtUaBvUmMmDm5L5xaxDEhb43ffm/q25rruLTh2qpj3Nh40d8IaIIIypkUsY6p1KVZF5YjalIdK7uU7tVO4hxY01fk/jtneYO48VCS49nU+u4pbQKzdgRrcoRnpqUN8pmAFGhzr3XGSutXViwTYQghRzQQym1XV9D7E7xiYxHyPBi+u480pKPb6vmbGiBTD51QvylyDE0WBZZP78+IX+1n3Uy7fZuXxbVYegy5uaipAX7jpkFd+d1Xq1qohPxwpDOkxk5QcXo6cR3eLIyVniW0gT5Tezm/UrtlMFXjkmg60aVyPjT//yqLvDlWoQcyQlGZc3raJI+XDwNzxPfju5zze+9b9Ysw1IA70DlSoguNA1lOIyiUBthBCVDPV/Vav54c4wNvpWYbjzcot0p31G9+3NXdfkax7Di332gxVhZ1HC1j3U67b4+s9vq6uQhtcq9xkXcvjEf8iRjlHgRrDY6V38F97/xCeo/Jcc0lzPt/9S0D7/O3z/cwZ24Vnx3Rh6tD2rNiRwzMr9hhub8ERmOu9JicNSqZfchNQcJb2c6UCPxwu4F+bvINrLSAO9g5UqIJjqVtdPZjvZyuEEKJKaLNZ1vIk0+p4qzchNtqt3J6v8e486t0+3AJMG+boFJhTUExGZi45BcXOrwNZ2GhVFH4pDH1OrVm/63xR2M7tqjGFzI/8O2mRC4hRzrHBdgnDz82pMcE1EHBwrXl0yS5yCopJiI2mT1Kc4XZWRWH22C6kjkzx+p4F+LXoHDkFxdw9OJllU7x/bhZgQfrPXilSSyb3c85Q+2vI5ItWhaQ6vddFcGQGWwghqpDZyiDV/Vav3i1wvTxTreqIJy01RO84iY1jTAfXCvDcDZeSEt+AV9d4l16riuogRedslXwG/660bONvkW/RTCngnBrB82XjeMc2AvUCmUezqaqz2cqhPONA9p4r251P1XDp6Ki9TqYu3OaW0jFnrHvaxp0Dk3jLI93JrsKZkvN9IY3qWsdE+f9dSJOY2kNRjaqWC5/M9qIXQghNda0MEqicgmIGpK3xSglJTx3iFRRkZOYyfv4mr2Msmng5SU1jdI9z75XtAuqq+Nr4HvRqE8cLn+9zaygz+OKmNK4XxbLtx8w/uRqmLud4NGIht0Z8CcBeeyIPlE5hr1rzXlcVpQA39GzJkm1HDdvdK8CyKf2dXRhzCorZkp3PtEXepfS013NOQbFbOpSZ1/5Hmw95dXb09573/Ptw58C23DGwrQTa1YzZ+O/CuLQVQogwM8rL1NIiaoqcgmI+23HM9C1wbTbPla/26jZVNeyCN+jiprqPT124zVktxLV027qfcgMKrv/Ys2UNabficKnyMyuiHnUG1wvKRnB9ydMXZHANjhnoxVuNg2ttm9FzM/hos2NRa0JsND8cOeV1l8P19eyatmE2fWtcn9YsmdzP7fXo6z2v9/dh/vos+s9e4xyrZyqVqN4kRUQIIapAda4MYpbrDJsnLWj2vMWt24p9REeycouoF2XVTeHQC5AsCtzev43hwkW7it926P78p4L7VxULdu6x/pcHIz4hUrFxXI3j4dJ72GDvEu6h1QiuTVzAsUDXk6/ykWbTt4pKbF6vZZuqsmJHDqO6JrjtZ1SSUhvrqTOlzFm9t8bf/bqQSIAthBBVoLpXBvHHc4bNlTaLt27/Sd0UGNeAZMeRU4YtpH2xq5BlYpGYGRXJyw53x8dWykn+HjmPvpZ9AKyw9eXR0rsooH4YR1XzaBe3Kqrua/Guwb5TM8xU6tB7zwM8s2IPz67Y42yv7mtbbaxpq/Ya1pkX1ZOkiAghRBWoCZVBfDGaYVNwVFAY3KGZ1y3umYt38sPhfOB81RFtFi5QigJ9kuK80k2CUZEAOXzBtcoYy3pWRaXS17KP39RoHiq5hyml90twHQTt4rZelNWrI6QCdG3VyG8qhr+UDc/3vCutvfqb6zLdttV7fVsU79ed2aokInwkwBZCiCoyrk9r0lOHsGji5aSnDjG8xVtVuZaBnKdt03q6ralVHBUU9AJwOzB63vl810A6M+qd6KKGdd0CFqX8n1nXXNK8RuVYa2I5zWuRr/JS1Os0UIrZbO/AiJLZLLEPJrCfQM3X16ME3+CLm/LplP7cN7S96WNYwHnHZcy8DK80Dq2ayIC08/nPnj7afIgBaWsYP3+Tz+209/xjo/S7Z85Ztdf5/hvXpzUbUocyaXBb52/Vojgq7hitYxDVl6SICCFEFfJ3a7mqKo0E02kudUQKs1e6l9xz/aDXu8WtutzO9nUb3B8VRxtqLd3k3fRs5q//OaAZ5WBrLIdTf8suXox8gwQlj1LVystlY3nD9ntsmOtyWduM7dWK/xvVie+z8+mdFOesBrLjiHetdSMqcKq4VLeRjCujVIxAG8kkxEYzqmsCz67Y43U+z/bqCbHRJDc7f0dCVaFRdKS0QK+BZAZbCCGqiaqqNBLsee4enMzMESnODw7XD3rnLW6d/VwXc86+IbiFeJ4zdnrBdW2ay61DCf8X8W8WRj1HgpJHpj2BsSV/Za5tdK0Jrkd3bxHwPo8u2cVFDety56B2zuD6o82HmPXpbt3t9V4TKjDbT3Ct0UvFMFqwvGJHjs90kdQR3s1tPF/X2ntTO7zrgkwzd79E9SEBthBCVBMV6QBXVee5+4pkNswc6vZBr6WaDO7QjKVT+nsFNYpyviLDqeJS3eOO7BLvTP2wKI5b/9ptcdfKIzkFxXyfnacbHN3Yu5Xf8dcEHZVDLIuaxcSIlQD8u2wY15Y8yw5Vv618TXV15+YB59R7vk5zCopJXbLTcPuK5szrpWLolZ4Ex+JFX+kid1+RzMyRKW6va8+Z6O+z83xWG5IujzWHpIgIIUQ1UVWVRip6Htc0F89Ukxk6s3RalJNTUEyaTldHgJGXJjCySwKo0CspzlGf+HA+m7PzyS8qcVYesShwVafmusf46PsjpsZfXSnYucO6mukRH1JHKeOk2pAZpZNYY+8Z7qGFnAK0inPc0TCqTqPH83X6bnqWz7rXwY5NxXghsnYnJnXJTq9z+0sXuXtwMtd1a6Fb4k97L3mSfOuaKagA2263Y7HI5LcQQoSSXs3oiuZa6rVe9nces+2a9VJN5qzyvvWu5U+rqIbB0H0fbnPrYNe0QR3dcn52Fb74seblUvsTz6+8EPkGA62OVIcvbT1JLZ3Ir8SGeWT6+rSJY/PB/KD3V4Hr52YwdUgyV3Zsxpq9J03t97tLmpOVW8SJwrMczi/2altuxLO8olG5RYsCSyf350yJ3WeN68EdmhlOj/urb6+3DsOoDKa2IFNmrWueoALsNm3acM899zBx4kQuuuiiUI9JCCEuWGabWJjhayGjdp4t2fmgQK82cX738aRbOcRHExowDmw8O9hdSEZavuW5yLdppBRxRq3D02V/YpFtKNU5q7wiwbWr19bqd+0E/dfKql3HWbXreEDn0ILmw3nFKAr0bBPnVrPdlV11VMXpl9zE5zGzcosM00+CmXE2qrDz6vgejOoaeK66CL+gpqGPHj3K448/TuvWrfnzn//Mt99+G+pxmZaXl8ctt9xCw4YNadSoEXfeeSenT582ta+qqowYMQJFUVi2bFnlDlQIIUwKRa6lmYWM6/af5L4PtzlLkr35TWZAix+NclE9je7RgoTYaNbtd5+lVAhuoVttUZ8zvBj5OvOiXqGRUsR2eztGlTzHItswqnNwXWVC8CNQcFwkdkuM49puLRjV1fFaHNenNUsne68XMBscG732LUpwM856x7MqCj3bxOnvIKq9oALsTZs28ac//QlFUfjggw8YMGAAffr04b333uPcuXOhHqNPt9xyC7t37+bLL7/ks88+Y926dUyaNMnUvi+//DKKXmFXIYSo4fwtZDRK7whk8aOvyiGulm07xg+H80ldvNNt1k8Flm0/Zvo51Sa9lb2siprJWOt6bKrCP8rG8IeSv5KlJoR7aNWGqgYXY3dPPJ9W4ys9u1tiHGljg2v+5NlExgJMGtyWDalDg6rwUdMbUQlviqoGvzzg119/Zf78+bzxxhscOnQIRVFo3Lgxd911F/feey+tW1duGZk9e/bQuXNnNm/eTO/evQFYvXo1I0eO5MiRI7RoYTwzsn37dq699lq+//57EhISWLp0KaNHjzZ97sLCQmJjYykoKKBhw4YVfSpCCBFSOQXFDEhb47WQMT11CAmx0WRk5jJ+/iav/RQFtzxpiwL/uKk7vZMaG37Yf7bjGFMXbvM5nvuGtueVNQeCei61SSRl3B+xmHuty7EqKofszXigdApb1Q7hHlq1Y1UUpg/vyPOr92GrwEpGBciYOVT39atVpbGUzxYHGtDmFBSHJJ2rso4nQs9s/FehlYpNmjQhNTWVrKwsli1bxlVXXUVeXh5z5swhOTmZMWPG8NVXX1XkFD5t3LiRRo0aOYNrgKuuugqLxcKmTd4fHJozZ84wfvx45s6dS3x8vKlznTt3jsLCQrd/QghRVV0Xg3HXwLa6NauhvDOjx/YKkDoi5XynxPJge9qi7fSf7Ugh0bg+715tfLcwtyoKzRrWCd0Tq6GSlaMsjnqCqRGfYlVUPi67gpElsyW4xhGMeJZmfO6GS7muewtevqkb4y9LDPrYKjjWGnjQujFOW7SdaYu2eaUwmRHq0nlSiq/2CEmZPkVRuO6667juuuv46aefePHFF3nrrbdYvnw5y5cvJyUlhYceeogJEyaEtPrI8ePHvRZZRkRE0LhxY44fN14E8eCDD9K/f3+uv/560+eaPXs2Tz75ZNBjFULUPpXRddFsBY9AxjVpYDsmDEzyfzwFruvWguu6tWDrwXymLtzm1vBi9qq9oDg6y3k+b9eqJEr56jQVR+B058AkurYMvhqGBbipbyILvzsc9DHCS+VP1v/xfxEfEK2UkK/W59HSO1llvyzcA6sWHrmmAzf0bEVCbLTbDO66/Se97sJoFODp0Zfw2DL9BjNe23tcAAbajVGIQIW01t7BgwdZsGABixcvBhyLCJs3b86ePXuYNGkSvXr14sgR/3VKU1NTURTF57+9e/VrqfqzfPly1qxZw8svvxzQfjNnzqSgoMD57/DhmvqHXggRCpXRdVGbURs/f5PPhhWBjuvtdO+qHHpVENTyts0Ae48X6uavzl651+v4M5fsJCbKypLJ/Vg08XIyUoeSMXMokwa1QwXeWp/F9XMzAn4u4Aik5t/Wi6YNauYMeFMKeCfybzwT+S7RSgnrbF0Yfi6t1gXXigLPjL6E8X0Dn2lu07ies4mQNoMLkLrYuD62Cpz4zdyaL61yiKt307P8rlHQ7tBU57tUovoKyQz2F198wWuvvcaqVauw2WzUrVuXO+64g/vuu4+uXbvyv//9jyeeeIKNGzfy4IMP8p///Mfn8R5++GFuv/12n9u0a9eO+Ph4Tpw44fZ4WVkZeXl5hqkfa9asITMzk0aNGrk9PnbsWAYNGsTXX3+tu1+dOnWoU6dm/oEXQvgWzKyxr0WEwcyABTqjZjRmM+PKKSjm19PndJvN7DhyivHzv/W5OEyvtNm0Rduds9n9kpuQU1DMW+t/DuRHoEsF7nxvS4WPEw5XWbaQFjmfpkoh59RI0spu4p+2a1BrYRNlVYXkZg0Y1ql5QHcaFLxroN8xsC3vpGf5fA0qCrzylXFOv1biz6LAjOEpztrZRSU26kVZdUtBWso7jrreAdImvrVjheIulbgwBB1gFxYW8u677/L666/z008/oaoqLVu25N577+Xuu++mSZPzNSSvuuoqhg4dSvfu3VmzZo3fYzdr1oxmzZr53a5fv36cOnWKLVu20KtXL8ARQNvtdi67TH92IDU1lbvuusvtsS5duvDSSy/x+9//3u85hRCVLxRpEmYFm+YR6q6LgQTsvsbsb1yewYOWZ21R4N4r2zFntXejGLNcLwrSVu0J8iihd8/gtryxrupqa0dzllkR/2Z8hOPzbo+9NfeXTmG/GnwecXWnQNCvfc8a6PPXZ/msHmLxWIhrNJ7XxvfgyKlir+o4iqJfXeSuge0A3C50XbfzddFr9DerKv+WieolqAD73nvv5YMPPqCoqAhVVenXrx/33Xcff/jDH7Barbr7WCwWevfuze7d5vKlzOjUqRPDhw9n4sSJvPHGG5SWljJ16lRuuukmZwWRo0ePMmzYMN5//3369u1LfHy87ux269atadu2bcjGJoQITmXkNRupSB5mqLsumg3Y/Y3Z17g891Wd/+M4zty1mUEH1xqbqvLqVwf4dHtOUPt3bxXL9iMFgHFTmkCdK7MHva8CDLq4Ket+yjW1fTflAC9FzqOd5Th2VWG+bSQvlt1ICZFBj6EmUIHlPxwj10TahqLA09dfQqOYKMPqM3q/9/F9E/l9t5bknj7LtEXbfZ7DjiMI1ys9qRecW4AJA5MMG75obKrKlux8ru3m3eLc82/Wm+sySVu113kBK7PfF5agAuw333yTqKgoxo8fz/333+9WxcOXwYMHU4GqgLo++OADpk6dyrBhw7BYLIwdO5ZXXnnF+f3S0lL27dvHmTP6dVyFENVHVS88qmiaRyi7LpoN2M2M2Whc/oKHQP86e14QgCMgXfhd4LnjGi24DmY8ehSgSf3g0/umDW3PsE4Xsf6nXJ/jsWJjsvVT7o9YQoRi55jamIdL72Wj/ZKgz13TpK3ca6pwtZZOsuPIKdPHtigwbdjFzgtFvdeeK6uigJ9tLDgCcc/3mr9j3/fhNopKyhjXp7Xh36xDv55h7tfnq+7IIsoLT1AB9uOPP869995L8+bNA9rv9ttv95tbHajGjRuzcOFCw+8nJSX5DepDHfQLIYIT6rxmf0KR5qHNGoeCmYBdb8wAO46ecmvvrDcurTRfqP7iaWkmns1jzPCst11ZUkem8NWPvwS9/ytrDvDKmgP0b9eYjJ/zdLdprfzCS5Hz6GX5CYDltn48VjqBQur7PX7DuhEUni0LenzViesdEV+sikJMlIW0VcbFCrT0JbvqHQDrXYyO7tGCZduOuV2cHs33vShx8pBkBrRv5vZe8zy23vvFNVg2+pvlGly7Pl5Zf8tE9RNUgP3Xv/41xMMQQojQ5zX7E+o0j1CNydf5E2KjmTE8xVEyz8Xzq/ZxXbcWfvedOKgtb+ks8ApWsDFysMH1FRc35RuT6RoAvxSc5TudGsiB0g+uVf5o/YYnIt6nvnKWQjWax0rvYLl9gOnj1pbg2iwFRyvxQ3lnDF872vvQ18Wm3sXoX67p6PwaYECa7zVfr3/9M7dc3sbvsbeUl6x0pQXLen+zjGbAtUWU4sIQkioiQggRCuEIeEOZ5hGoYBdAdWnlXVPa7OzYhIFtWaBToqymMJsLrXlnQ7bpbRVg8pXJWC2K366TjfiN2ZELGGHdDMAmewoPldzLUfwv0K/OQnmHw8jgDs3YclD/oue+oe25+bLWbjPKnlzfN0Z3bTIyc/2+xn29Z1yP1auNd9CsXfjr/c2aPqKjbu73jBEpMnt9AZEAWwhRrYQj4A1lmodZegujtFvO/gJuMzP9RsG7mVvgev7QoyWfbDsaxDMNrcoM/lRg3jeZXN+thc/tBll28ELkGzRXTlGiWnmx7Ebm20ZhrwXl9yo7uFZx1FqPjtT/WdlU1edr3+wiaKNUKldm7475u/DX+5vVKDrSub0FR3B99+Bkv+cStYeiSgJyUMz2ohdCXJh8zU7nFBR7dahz635oouLAR5sPnf8AV85/gOcUFPNuuqPUma9j5RQUs/VgPlMMqji46tKyIbuPFVbrWW9/wVQo1KGE1IhFTIj4HICf7C15oHQKu9Wkyj1xDXV7/zb8M+Og22MWBW7qk8ii7w7rBvMKkDFzqOHMtef7xqoopKcO0d3e9T1ilKcdSFUP1y6TZi7IA91e1Axm4z+ZwRZCiBDzN8umtzDKdarDTMWBcX1ac+pMKWnlt6LnrNrL/uO/sXTbUbdjGx0rITaauHpFpp6P2eC6qhYu6omLieTXotJKO35nJZuXI+fSweKYxf9n2e+YXTaec0RV2jlruk4JDZk5IsVRqq78MbuKz0Y0KniVwdMEugjaKE97S3Y+KNDLo7ujP4He6QrHnTFRfUiALYQQIWSm1KCZ29f+cqpzCordmsLYVVi8VT+Fw+hYZsahHdtMKkk474dWVnBtwc5d1hX8JeJjohQbJ9RGTC+dxNf27pVyvppK7/WRungnN/dNDDjtRDEo9RfMImjPIHfd/pNVVmdfXNhqfsKYEEJUI75m2TRaTqe1PJKwKN7lg/0FDv5qWnseKybKQkZmLjkF50uXaePQPggUoGNz79JyFgVSR6S4jXdkl/ha/wHSglw+iHyORyMXEaXY+NzWm+Hn0i7I4Dqpie+Z2Ou7J3g9puJ7tlqPokBPg5nlhNhoxvRo6fbY6B6+K+e4Mrr4dX1PCBEqtf3voxBCVCltls2VXrA8rk9r0lOHsGji5WxIHUra2PMBt5nqKXrn0WPBEYSMmZfB+PmbGJC2ho82uzeCUcuPowL7fjntdQy7Co1iIpk+vCNK+derdx3n934WAxoZlnJRUPtVpessGayuk0o/648UqXWYXjqRu0sfJI8Lc81N9q++g9BlQXbuVDh/cWlRIO2GLj7v2iz1WGi7bNsx0wGymYtfIUJFUkSEECKEAik16Hr7OtDqKUbNNpZsO+qWqnFrvza8/+1B3ZQVcNzGNzMR7jrzpx1n+Q/HTOzpzqLAr6f9t9MOl4YU8VTku4y2ZgCwzd6eB0onc1CND/PIahcFmDi4LRMGtOVE4Vk2Z+fTJymObonGedFGAfLWg/nE1QtN9R0hQsVUFZGnnnoq+BMoCrNmzQp6/+pKqogIIXwJZQUBfxVJXJtr9J+9xlTAvGji5fxadM6rgUZl65/cmIxM/Y6I4Xa55UdejHydlsqvlKkWXi0bw2u20diwhntotcqkQe24rF0cP+cWcTS/mPc2HkRVHekhqS7l7Dxf96GuvhNMJREhzMZ/pgJsi8WCoiheLcUVo5UI5VRVRVEUbDabyWHXHBJgCyH8CbaRjCvPiiQzhqfQpVWs7jEzMnMZP3+T32Nqpc2+/PE4j3/6Y1Dj0ozsEs/KnccrdIxwi6KUhyI+YZL1MyyKSpa9OQ+WTmG72j7cQ6sySvn/VPZCVQW4smMz1u47abjNzBEpNIqJ1F2M6FmeUlXdF1f6KtunkfJ5oiJCGmA/+eSTXo9lZWXx/vvvU7duXX73u9/Rtm1bALKzs/niiy84e/Yst956K0lJSTzxxBMVeCrVkwTYQghfzDbE8EVvxk6jd8ycgmLDGWwLYOd8fjd4p30Ew6LA2J4t+c+W8DehCUZ75Qj/iJzLJRZHveaFZUN4puzPnKFumEdW9fomxYWkrfyYHi3o1SYOFZi1bHfA+2tTd64vTQvwyvgeztJ62blnyD19lmmLtnvtv2ji5W4dHoUIpZDWwfYMkA8fPkzPnj0ZPXo0r7/+Os2bN3f7/okTJ7jnnntYsWIF33//fRDDF0KImstMqT5/aR9bDuaz77hx/Wm76sifPldmo1urRhSV2GjbtB6pI1KYvWqv27ZWRWHJ5H6cKbE7U0mMAvdA2VWoX6cmLudRuc36BTMjFlJXKeVXtQGppRP50t47bCO6tEVDdh0rDPlxWzeO5lCe/4WAoQiuAZZuO8an249x7xXBdS7Ue1nagakLt7ldWOYUFIc1pzoUd6hE7RVUJ8fbb7+dL774gp9//pm6dfWv8s+ePUu7du24+uqree+99yo80OpGZrCFEEaMUjW0mTVfs9sfbT5keuGhJ+1Yp4pLmVPegEYvz9RsKklt1Yx8Xoh8kyusOwBYa+vG9NK7OUmjsI5rdPcWLNse+MJRPSnx9dl73LsiTE2gl/rhyjUNJFw51aG4QyVqpkrt5PjFF18wePBgw+AaoG7dugwaNIgvv/wymFMIIUSNlFNQzK+nzxnOrPma3QZH2kawE8vasdJTh3BdtxZsPZiPXVXpndTYbbt6URfuor1rLJuZHTmfxsppzqqRPFP2J/5tuwrvSuRVL1TBNVDlwXWounhacASrgDNw9uTaOCnQ6juhYOYOlRBBBdh5eXkUF/u/3XT27Fny80Nzy0kIIao711kthfNBh2upvozMXMNavCpqhdM2tGMdyisynGE7nH/hNdaoRzGPR/yLcRFfA7DTnsQDpVPIVFv63lEYUoCnRl9C45goWsVFM2ZehqnXr0WB67rpz9a/Or4Ho7o66qsP7tCMLdn53PfhNp9pIFXdkjzQlu3iwhRUgN26dWvWrl3LL7/84pV/rTl+/Dhr164lMTGxQgMUQoiawHNWSwUUFZ4ZfQnDOjX32SbdAiQ1jeHNbzIrPA5FgZgoi1uaiV2F1CU7nTNsGQdyK3yemqSnsp+XIufRxnICu6rwhu33vFT2B0qlFYSzxbleq3N/tEWM2gXc7Bu6MHPxTuw+9plUXvsaHHXUPQNn1y6OCbHRXNstmqKSMlN15auK1NMWZgTVyXH8+PGcPn2aYcOG6aaA/O9//+Pqq6+mqKiI8ePHV3iQQghR3enNamkByLr950uSaQ1iFI/tnvrvj/wz42DFB6I6utt5BkuqClsP5pNTUMyHmwNrX11TRVDGgxGf8J+oJ2ljOcERtSk3lTzG82U3SXBdbsFtvXjt5h7cPiAp6GO4pkgsndIfowq+CpDcrL5zxnn2Dea6l7p2PU1PHRL2XOdAxi4uXEEtcjx79ixDhgxh06ZNKIpC06ZNSUpKAhxl+nJzc1FVlcsuu4y1a9f6zNWuqWSRoxDCla+Sep61eX84nM/ouRlB51oDvHZzD/af+I1Xvjpgep+nr7+E5IvqXxALHJOUHF6OnEd3i+OuwBLbQJ4ovZ3fkFlGV3ol8YLluojXKH/a871Qk2tS1+Sxi+CZjf+CmsGuW7cua9as4eGHH6Z+/fqcPHmSzZs3s3nzZk6ePEm9evV46KGH+Oqrr2plcC2EEJ60WS2Lzuydlp8Jjjzt0fMqFlxbFYVeSXHc3Ld1QEvzHl++mw0HckO2nG9kl3jmjNV/zuGjcpN1DSujHqW7JZMCNYZpJVN5qHSyBNc6VEITXLumSGgzzo+N6uS1net7ARzvm37JTWpkgFqTxy4qX9D3yKKjo/nb3/7G008/zdatWzly5AgALVu2pFevXhJYCyEuOOP6tCYlvoHX7LRnBZGKVFuwgLNRzDvpWQHtq6owd23F87w1q3YdR1UJST3tUGhMIXMi53O1dQsAGbbOPFx6LzlI05FQGJDchIzMXx05264tysErRSIhNppRXRN4buUer9fHjqOnqkUjGKljLSpThZPQ6tatS//+/UMxFiGEqPG6JcaRNrbL+XbOwJ0DkwD9PO1AvTq+B6fPlRl2bKxKquoIsquDKy3b+FvkWzRTCjinRvC3snG8bRuBGtyN2gvaNZ0v4osfT3i9vjZk/go40kpGXBLP6t2OCyyjWyIJsdHMGO7d+Oj5Vfu4rlsL3aC2qoJeqWMtKltIVnkcOHCAkydP0qRJEzp06BCKQwohRI2l1eZ9Nz2bBek/89b6LBakZzFjRIpX9YFAKEBeUQmPf7o77MF1dVGXczwasZBbIxwL7vfaE3mgdAp7VQmWgvXFnhOMuDSelQYXTyq4fc+uOuq3a1VqtCC5XpQVi871jVFJu6oKeqWOtagKQV/a22w2nnnmGeLj4+nYsSMDBw4kLS3N+f0PPviA/v37s3v37pAMVAghapoF6T+7fYg/v2ofM4anVCgHepYE106XKj+zIupRZ3C9oGwE15c8LcF1BQVzZ8Kuwrsbsvho8yEGpK1h/PxNXD83g2dX7PXaVq+knVHQm1MQ+prtvupYCxEqQQXYNpuNa6+9lieeeIL8/Hw6deqEZzGSAQMG8O2337JkyZKQDFQIIWqCnIJiMjJz+T47T/dDvGurRmTMHMrFF9V3+96lLRp6Bd4K8JffdeCRazoEVae4trJgZ7L1U5ZGPUGyJYfjahy3lMzkmbI/c44ot227J8aGaZQ1WzCvtfnrstyCZD1GJe2qMujV6lh7jkvqWItQCirAfuONN/j8888ZMmQIWVlZ7Nq1y2ubpKQkkpOT+eKLLyo8SCGEqA604FlvVi2noJhnV/zonL27/8PtXgGz64d45kn3VtY/HitkRJd4t8dU4MUv9vO3z/dLcF2ulXKSD6OeZnrkR0QqNlbY+nLNuTlssHfR3X774YIqHmH1YeZOyV9+p5/W6asyjKLAoIubej2u4jv9adaoToZ1rKsy6JU61qIqBJWD/d5779G4cWP+85//EBcXZ7hdp06d+OGHH4IenBBChJuWT7rzaAFzVu3VzQ/9aPMht86J4Ag0FAUsKtjx3y7dDqzc6X1bXgJrjcoYSzpPRf6TBkoxv6nRPFF6G0vsgzAXSlY/Q1OasWbvSf8bBkEBbujZkiXbjvqsWpNXVOJ1d0QBZoxI4flV+5zdE6cP70hMlJWfc4to17QeXVvFkv5Trtt+lvKdjWrBj+yaYBjEakFvVXVs1NZJSB1rUVmCCrD37t3LwIEDfQbXALGxsZw4cSKogQkhRFXSq17guujKleuiKHAs8NKLYVQVXhvfg8b16rh9iNeLslbmU6l1YjnNs5HvcK31WwA22zvwYOlkjqgXhXlkFVNZwTU4AuZl246xbHJ/juQXs3pXDv/d4X0Bd/pcqXfXT6Bry0akpw5xBqDr9p90u4hUcMxip/+U63YBCXg1mXGtpONLVQe9WkdJISpDUAG2zWajTp06frfLyckxtZ0QQoSTXvWCwR2a+cwn1fJDVVTDbayKQs82cW5d695Jz+LtAOtXm1Ub87T7W3bxYuQbJCh5lKpWXi4byxu232NDLlL8sakqZ0rsjOragg0HcnW36dqqEZ9sOer2GtZSM7QANKeg2OsOjQqs+8nRtGjSoHZMGJjkfJ1rQXJMlIUVO467VdLxVxlEgl5RWwQVYLdp04YdO3b43Ka0tJRdu3Zx8cUXBzUwIYQIVDA1dI2qF7x8Uzef+aQWBXJPn2Xf8d8Mv6/N6GVk5rLzSAFpq/YGFQBrgbNRAH1JiwZMvrI9dlVl2qLtQZyh+qlDCX+J+JiJESsByLQn8GDpZHaoyaaPURsvOAKhBco/HM5n4XeHdbcZ1qk5kVaLz9SMrNwiw5+jCrydnsUElxlq18Dcs5KOlMMTF4qgAuzhw4fzj3/8g7feeotJkybpbvPqq69y8uRJ7rnnngoNUAghzHCdhVaAiYPaMmFgW78f5EbVCyyKYlizWsGR/mEUzI6/LJFpQy9m3f6TDEhbU+HmMhMGJHG2zMbCTfpB0u5jv9EqrvYELB2VQ7wcOZdOFsfz/XfZMJ4tu4ViAusQfCEG14rieG1qgbKW2qG7bfn/+0vNaNu0ns+LFaO61r4qg0iALWq7oALsRx55hH/+859MnjyZH3/8kRtvvBGAoqIitm7dyscff8zf//53mjZtytSpU0M6YCGE8OQ5C62C6VvSWvUC10DAokCruGjuHNiW+eu90zn8BW6/79oSwG/JMrPe2ZDtd5vR8zK4uU9ixU8WRgp27rCuZnrEh9RRyshVGzK9dBJr7D3DPbRqwVIePPt6SakqzB3fg55tHGukBqQZd/xUwRns+krNSIiNJm1sF680EY1RtQ+995a2rbQpF7VdUGX6EhISWLZsGY0aNeKVV15h0KBBKIrCJ598Qp8+fXj++eepX78+ixcvpmlT71I+QggRSkYtyM00q/As2aXtN3puBkUlZV7b+/ujqQUQWw7mhyS4NktVMUwDqAni+ZV/Rc5mVuS/qaOU8T9bD4afmyPBNY6Z5rnje7B0cn8G6pTH85RXVEJCbLTh+0LjGuwalZ/UjOvTmoyZQ3nt5h6M75vofB/4qvZhVA5Pu7Mzfv4mBqSt4aPNh/w+JyFqGkX17BATgF9++YWXXnqJlStX8vPPP2O320lMTGTEiBE88sgjtGzZMpRjrVYKCwuJjY2loKCAhg0bhns4QlzQcgqKfaZiLJp4Of2Smzi31Zs5++FwPqPnZnjN0GlhtwrOcmVzVu81LEWm5V0bzfZ5HlPASMu3PBf5No2UIs6odXi67E8ssg2lppbfqwyjuiSwcleOz5J7GgVIG9uFpvWjuPO9LbrbuL5Wg2lPnlNQbKraR05BMd9n52EpX/ALeL1XrYpCeuoQmckWNYLZ+K9CAfaFTAJsIaqXjzYfYubindg9Hnf98NarFqIFExmZuYyfv0n32BYFXrmpB72S4pzH0RaFWRQY1yeRge2bGgYQGgV4evQlPP7p7iqd3a6u6nOGJyPfY6x1PQDb7e14sHQKWWpCmEdWtSpjMaavi7j7hrbn5sscr/vKDHb13m+JjWN032dzx/dgVNcWFT6nEJXNbPwXVIrIunXr2L9/v9/tfvrpJ9atWxfMKYQQwtSta824Pq3ZMHMokwa1c3aEc719bVQtRDu2Xic5jV2FJvXrOIOOcX1ak546hEmD26KqsOi7w0xbtI11+0/6vC2vAmdL7RJcA72VvayKmslY63psqsI/ysbwh5K/XnDBNcDDBt0UK0LFOGh/be0Bw9dqqNqTa6X9PN9v9aKsuu+zqQu3SaqIqFWCCrCvvPJK5syZ43e7559/niFDhgRzCiHEBe6jzYcCztNMiI3m0VGd2JA6lEUTL3dry+wvmNDyRfX+KBot4lqwPssZxNhVmLl4J9sO5huOz6JAn6Q404kPVkVh5ogUWjXyXT1j1qhOjLg03uc21UUkZfwl4iM+inqaRMtJDtmb8ceSJ3ip7I+UBbfuvsY7W2pjsInc6lDxFeyGqj35O+lZXgG+Vpd79g1dvM6r4n+9hBA1SVABNoBklgghKou/2WZ/EmKj6ZfcxO02t1H3xJio838G/c2Cu9IL2O3A374wvrt318B27D3+m6l0AAVYMrkf7S+qx5FTZ31uezjvDJ/v9u7SV90kK0dZHPUEUyM+xaqofFx2BSNLZrNVDf0Mbk3y2tpM1v2k3wgmGGYu4FyDXc9FiIDPO0f+7izlFBTrNlOyAElNYxjXpzX/uKm77phCMXsuRHVQqdMF+fn51K0bWN1SIYQIVf1c1wWNRSU23W3OlLhnbWuz4BMGJvlcxKVXgswXBRjVNZ7RczNMba8Cz63Yw6Zs4xlxzXsbD1bzBZMqf7L+j/+L+IBopYR8tT6Plt7JKvtl4R5YrbTgtl5s+jmPt3RKTGq0mep+yU3camC71m7XW/Toax2DxihN6q7B5+vS905qbFjCT4jawHSAfeiQ++3Z06dPez2mKSsrY/fu3XzxxRckJ5vvuiWEEOC7fq5ZnoHAjOEpAR1TCwSycos4UXiWohKbW+URLaVEW+zoi1bVoajEFlAgbCa4Bt9dHsOtKQU8H/kmQ63bAVhn68IjpXfzC43DO7BKMsegekdV/n7uem+Lz5QhpbzLqOtr2dc6Ba3zor/va4xqy08Y0Nb5tef7x1e5PyFqItMBdlJSEopLndjFixezePFin/uoqsqf/vSn4EcnhLggVfTDVy8QeH71PmaMSOH5Vft0j+lZvs81QNd4zthpHfC2ZOczbdE2twBKAf5yTQfOldoZ1ukiuiXGkVNQXCmBlr/ygeFylWULaZHzaaoUck6NJK3sJv5puwY1+OzEkOuc0IAfc/Tb3QdqfN/WjOvTms92HPP6XlX+WlRg5S7jlCFFhcEdmnk97u/Okdk7S57vX4sCM0akeL1//XWQFKImMx1gt27d2hlgHzp0iJiYGMMmMlFRUbRq1YqxY8dy7733hmakQogLimvwigK9ykvgmWEUCHRt2Yj01CFeH+h6s916warejF1CbDS9krzHoAJ/+9yRj/3a2gPOwNxXR7xAaIG6dqEwrk9rLm/XmOtNpqBUpmjOMivi34yPWAPAHntr7i+dwn61+nWaDFVwDbBo8yEa14tk7tpMr++Z6cJolgJMvjKZuV97n8cMO+imW/m7cxTInaVxfVpz6kwpaasc76M5q/bSKDrSK53EVwdJIWoy0wF2dna2878tFgt//OMfeeeddypjTEIIAcC6/SeDaoLhKxDw/EDXm+2es2qvVz1tjd6MXVZukc/AyTUwH9enNZ9uO0rGz3l+n4cvC27rRUxUpDO4+e8PR1m2zXvmtKp1Uw7wUuQ82lmOY1cV5ttG8mLZjZQQGe6hVTpVdSxY9KS9dk8VlzJ75d4Knyd1RAp3X5FMw5hI0lbuDSpo33H0lLP5ksbfnaN1+0+6NbrxTDVxlVNQzJzVe92q7OilkwhRWwW1yPHdd9+lffv2oR6LEOICZNRZ0Wy+p55AUkyMqoEo5TOOnvRm7No2rWe4vUYLzB9dsrPCwTVATFQk/ZKb8NHmQyGZEa8oKzYmWz/l/oglRCh2jqmNebj0XjbaLwnzyMLvlZt6cG23FmRkBlcpRHttaakWdw92rG26e3Ay13VrwatrfmLhpsMBHTNt5V6u69bCdNqG9n50S4MySDWB0C1UFqKmCirAvu2220I9DiFENWMU+IaSr4oEFf2ANpPfmVNQTF5RiVdetFVRuPfKdrqzkfde2c654Mv155M6IsXn7KQFOJJfxNp9J/2O3Yx/bsgiJsrCjMU7Q3K8imit/MJLkfPoZfkJgOW2fjxWOoFC6od5ZNXD0fJydkalIv25vlsCrRvHMKxTc7oluqdKJcRG89yYrkwbejGLvjvEK18dMHVMFdiSnc+13bzfF3ppG0YXokbvx1AsVBaiJgsqwN64cSPz58/nrrvuon///rrbbNiwgbfffpt77rmHvn37VmiQQoiqZaYUV0X5m6EO5APa6GLAV36n63NU8M5pTmwcoxtgz/06k5yCsyzddtTt53NdtxYczC1i0XeHHVU9yg/ovEUOPPJJ6ILhz3/8hc9//CVkxwuOyh+t3/BExPvUV85SqEbzWOkdLLcPCPO4Kt81nZub/vnPXrmXTT//ypq9vi+uuifG8sPhAq+7Ecu25wDw6ppM0sa6vxddX/s3923Na2sOmC8dabbjEcZlKfVSTUCqhAihqEF0jJkwYQKLFi3iyJEjhgsdT548SatWrbjtttt46623KjzQ6sZsL3ohapqcgmJnHVyNVVFITx0S0g/HjMxcxs/f5PX4oomXOz+wP9p8yOsD2jPQD+ZiQO85WhTHrfzExtEczi8m/0wJjy/bbbopjFIefFgUR0OZCQOTOFF4ltHzMnymjtRUjfiN2ZELGGHdDMAmewoPldzLUfRTBmoTLS4Nx6/VAmyYOZSE2GjeXJdJ2qq9zvSR2Td04cCJ08z3Uf9aoyiQkTo0oPf0m99kMnuV+10af38bcgqKpUqIqFXMxn9BzWBnZGTQvXt3w+AaoFmzZvTo0YP169cHcwohRJhUVe6kmRlqf2keRrPgKfENnHWrtefkOrute7tbdczGeZbbM0PlfP61XYW307OYMDDJUfe6FgbXgyw7eCHyDZorpyhRrbxYdiPzbaOwV6Pye5UlnME1OO6EfLXnF4rO2dyCXe21/9atPf0G2AqQdkOXgN/PXVrFej3m72+DVAkRF6qgAuyjR4/So0cPv9u1adOG1atXB3MKIUSYVFXupNlbyL4+oI0uBkbPzXA2XwFHMGRR4M6BbbljYFvHokTwqls9f11WSAInm6qy9WA+PdvEhaTudXVpIlOHElIjFjEh4nMAfrK35IHSKexWk8I7sCoW7t/FY8t26z5uU1WyTLQaVzBenOiL5FULYV5Q0w0Wi4WSkhK/25WWllJWVhbMKUzLy8vjlltuoWHDhjRq1Ig777yT06dP+91v48aNDB06lHr16tGwYUMGDx5McXFxpY5ViJpAC3yt5QmalZk7Oa5Pa9JTh7Bo4uWkpw4JOM9b+8D3pLr8v2uZsPnrs+g/ew3LfzjmFSS5buvp2i4JhmOwcD6QdzV14TaWbw9N2bxwB3QAnZVs/hv1f87g+p9lv+PakmcluK6AkV3ine+zULAo0CcpTvc94UpbnBioqvzbIERNF9QMdlJSEhs3bqSsrIyICP1DlJWVsXHjRtq0aVOhAfpzyy23kJOTw5dffklpaSkTJkxg0qRJLFy40HCfjRs3Mnz4cGbOnMmrr75KREQEP/zwAxZL7b+9KYQZVdlhrSK3kNftPxlw50IVAq5F3CmhASt25njNeD91/SVc1bm5W71u1/OkrQquRnF1YsHOXdYV/CXiY6IUGyfURkwvncTX9u7hHlqNNr5vIs/d0NWZo7zjyCmeX+3oMurJ7B2MGSNS6JYY53ZnSE9FZp2l+6IQ5gS1yPGRRx7h73//OzNnzuSZZ57R3WbWrFk899xz3H///fz973+v8ED17Nmzh86dO7N582Z69+4NwOrVqxk5ciRHjhyhRYsWuvtdfvnlXH311Tz99NNBn1sWOYqaLJQl+HzVsa7MMn96CxUralhKM74yqPSgl3trURwd9WJjIjlbauPFL34K3WCqgRbk8mLkG/Sz/gjA57bezCy9izzkb15FKMCT13fm6s7xbu8NvUWEZlgor499RbLzsa/2HOfO97bontuzEomrqijPKURNVqmLHB988EHefvttZs+eze7du5k4cSIpKSkA7N27l/nz57N8+XIaNGjAQw89FNwzMGHjxo00atTIGVwDXHXVVVgsFjZt2sSYMWO89jlx4gSbNm3illtuoX///mRmZpKSksKzzz7LwIEDDc917tw5zp075/y6sLAwtE9GiCoSyhJ8RseqijJ/evnXngJZkKYAKfENDQNsLafbdTbRbtC5rza4zpLBM5Hv0FA5Q5FahyfLbuVj25XoJ8Rc2CwKzL+1F0u3HeWzHcf9bq8Cj3/6I49/+iOTBrVlwsC2gOOOhx6rotClZUO2Hynw+t6sUZ0Y2TXBKxj+ObdI91j3DWtv+F6sivetEBeKoALsFi1a8J///IexY8fy6aefsnz5crfvq6pKgwYN+M9//kOrVq1CMlA9x48f56KLLnJ7LCIigsaNG3P8uP4fuZ9//hmAv/71r7zwwgt0796d999/n2HDhrFr1y4uvvhi3f1mz57Nk08+GdonIEQV06u6MXPxzqDaF/uq4BFsB8ZAGNXlBUcI+OrNPeiV5GjK8e6GLL8LGLu1imXe176D5Zqe7mFGQ4p4KvJdRlszANhmb88DpZM5qMaHeWTVl12Fs6V2U8G1p7fWZzF/fRZDUprpvr4UYHSPFizZetTre1ZF0Q2uAfomNdY939CUi3Qfr0jnVCGEt6CTjrWA9P7776djx47UrVuXunXr0qFDB+6//3527drF1VdfHdSxU1NTURTF57+9ewO/jQZgt9sBuPvuu5kwYQI9evTgpZdeomPHjrzzzjuG+82cOZOCggLnv8OHA2tLK0R1YNSN7d307JAcy6aqbM7ONyzzF4icgmIyMnPJKdBffJwQG82YHi11v6cCTerXceZ3PzqyM8um9Pc597r9iHeDj2AM0Gm6UVNcbvmRVXVSGW3NoEy18FLpWP5Q8oQE1yYs3+4dAJulgmETmr9c04Gl2456vTYtCj4XGHZLjGNsT/f3x9ieLb06QWp8lecUQgQuqBlsTatWrXjppZdCNRanhx9+mNtvv93nNu3atSM+Pp4TJ064PV5WVkZeXh7x8fofCAkJjmoAnTt3dnu8U6dOHDp0yPB8derUoU6dOiZGL0T1pVeeDmBB+s9MGJgU0EyVUckurYpBoKW8XHM/XRcNGt2qzikoZuk246AmJsp9/qBbYhxpY30v/gqFDZm/0q28I19NEUUpD0V8wiTrZ1gUlSx7cx4sncJ2tX24h1ZjfP7jCf8bBUhRoHXjGN27NK/c1INru+mvM9K8eGN3bu3Xhu+z8+mdFGcYXIOU4BMi1CoUYFeWZs2a0ayZ/xqd/fr149SpU2zZsoVevXoBsGbNGux2O5dddpnuPklJSbRo0YJ9+/a5Pb5//35GjBhR8cELUY0lxEYzcVBb3vJoRGFXCbiRjFEda88qBmZKeXm2LQf3PGe9W9VbDnrPlLs6kl/sFVBoFRC2Hsxn6sLAG8qYVZOC6/bKEf4ROZdLLAcBWFg2hGfK/swZ6oZ5ZLXD27f14tips8z6VL92tRHtwrJ3UmPdwFdLf/Ilp6CYohKbYRqJK2ltLkRoVcsA26xOnToxfPhwJk6cyBtvvEFpaSlTp07lpptuclYQOXr0KMOGDeP999+nb9++KIrCI488whNPPEG3bt3o3r077733Hnv37uWTTz4J8zMSovJNGNiWBelZIZmpMirZFUgpL8/cT72g17Nb3EebD5G6eKfPsU1duI3T58q8Zr4TYqPp2QYmDmrL/PWhaSxTM6ncZv2CmRELqauU8qvagNTSiXxp7+1/V+FFUWDEpfGs3Hk+D3tsz5YM6xRPTkExj3+62/Ri29fG96Bnmzjn6z2YwFevjbq/BYtSgk+I0DEVYN9xxx0oisJzzz1H8+bNueOOO0yfQFEU3n777aAH6M8HH3zA1KlTGTZsGBaLhbFjx/LKK684v19aWsq+ffs4c+Z8HtkDDzzA2bNnefDBB8nLy6Nbt258+eWXJCcn651CiFol1DNVRnWszdS3ziko5rMdx/xWA7FwPuXjh8P5pC7e6TdYUXEs4GxaP4roqAjqRVkpKrGx82gBc1btdaafDGrflPU/5V5QgXYz8nkh8k2usO4AYK2tG9NL7+YkjcI7sErmr5706O4tWBZkcyBVhVnXdubuwe34PjufpKYxREdFkFNQzLvp5i/kJg5qx6iu7qkfgQa+nuX+AlmwqPe+ldJ9QgTOVB1si8WCoijs2bOHDh06BNSQRVEUbDZbhQZZHUkdbFHTaQ0uwjVT5ZoWYoZFgTE9WrJk21FCmUJtVRSWTO7Hih3HWZD+s8/xKECvNo34/uAp59c1LTC/xvIdsyMX0Fg5zVk1kmfK/sS/bVdxoZTfq8zf2aKJl9MvuYl7ypOC6derBdgwc2iF6snnFBTTf/Ya3eeojc8M7byeF6RSuk9c6EJaB/vdd98Fzi8Q1L4WQlRvvj6cPWeqQjFLZfYYnmkhZthVWKxTqqyibKrKkfxirkxpxqiu8RzOK2baIv38bBWcwTVA6sgUoiMtPP7pjyEfV6jVo5jHI/7FuIivAdhpT+KB0ilkqvqVWGqrygquLUBS0xjvlCeTJ9S7kxRMXeqs3CLd52hRMJ0GZnTxK6X7hDDPVIB92223+fxaCFH9BPLhHIoGE4Ecw0yTmKqiKDgXPCrATX0Tud5kqsDslXtRasDEb09lPy9FzqON5QR2VeEN2+95qewPlNbsZTiVzuxstwLMHtsFwFTKk0brBDqgfTOvO0nB1qU2qg8/Y0SK6RlwXxe/nushhBD6gq6DLYSovow+nPVqSgeybSjOB+eDgFAL9JCW8ghKiyVUYNF3hwPKw63Ein8VFkEZD0Z8wn+inqSN5QRH1KbcVPIYz5fdJMG1CWZ/ta+N7wHAgLQ1PLvCf4+GEZfGo+B4n8z7OpNDeUVeAWuwdam1NRbW8is/CzBzRAp3Dza3xsjfxa+U7hPCHPkLK0Qt5OvDOZAPcrOzVIEew3OhpRGl/H9U1fHBPrpHC5ZuPYrdYHsVuG9oMgXFZby38aDfcVeXWfTKkKTk8HLkPLpbHN0pl9gG8kTp7fzGhRUcVXaevFVRaBUXzZh5GaZfT5/vPu5WhnLmkp3ERFlp3TiGohIbbZvWC6outZaiNbhDM9JThwS1xsJXh1Qp3SeEeaYC7KeeeiroEyiKwqxZs4LeXwgRuEA+nI22jYmykJGZayonu16UVffxmCiLbl52TkExiY1jWDK5H0fyi71qUivAU9dfwlWdmwO4BQpDUi5i6sJthmN5ZU1mpcyO1xwqN1nX8njEv4hRzlGgxvBY6R38194/3AOrchbOp27MXLzT8MIsUFrQrgWcRSW2gNcTeH49bdF259daipWZaj/OxYhHCpizuuKLEfWqDE0f3pGurRpJ6T4hAhBQFRHPTRU/yYeqqkoVESFCzOxCwo82H/L6cDb6wH1zXaazUoBzpnjbUdMf1hmZuYyfv8nr8UmD2jkrc2jHAdyayqSOSKFRTKTXbLbReX84nM/1czN8/YguWI0pZE7kfK62bgEgw9aZh0vvJYea2769IoakNOO5MV3Iyi2iXpSVWct2s+NoxZsAvXZzD5rUr+MMOHMKihmQtiakd0SsikJ66hAAw5loX5V4tP0rsmBZ6mEL4c1s/GcqwH7yySe9HsvKyuL999+nbt26/O53v6Nt27YAZGdn88UXX3D27FluvfVWkpKSeOKJJyrwVKonCbBFOAS6GNHMh6RnF8XJQ5J5/etMrxltXx/WegGGBbxmDI1u108Zkkx8w7pe3e70zmsUzF/orrRs42+Rb9FMKeCcGsHfysbxtm0Eqiy1ATBMe9D87Q9daBVXj5goC2dK7Bw48Zth98VPp/T36hLqeUE7ukeLCpeU9FVWz0xQH0hZPiGEOSEt0+cZIB8+fJiePXsyevRoXn/9dZo3b+72/RMnTnDPPfewYsUKvv/++yCGL4TwpLeQcObinaTEN/D6sNf4a/ai10XRM7gG/znZereVeyc1YlNWvtt2RrHA3LWZuo97njenoJhfT5/zCtT1AveaWKM6GHU5x6MRC7k14ksA9toTeaB0CnvVC6NWsQV4avQlbDmYz9JtxotT/c0ut4qr5xaMJjWNMey+OGZehtfFrWczGIAlFSgr6a+sXm1bjCjNbERtE9TUxqxZs4iMjGThwoVewTXARRddxMKFC4mIiJD8ayFCRO8D1Q6MnpfBR5sPGe6XU1BMRmaubkUP3WMa3G72t7hKy6leNPFylkzux3cewXUwXM/70eZDDEhbw7RF272DHgVGXhrv9lC3xFi6J8ZWeAzV2aXKz6yIetQZXC8oG8H1JU9fMMG1VVGYPbYLwzo1p0frRkEfx6JA7umzbu+RhNho0sZ20c3nN6qSkxAbTb/kJiTERvN9dp7pEn96jMrqae/nelFWw7UGNW0xovbeHj9/EwPS1vj8eyZETRFUFZEvvviCwYMHU7duXcNt6taty6BBg/jyyy+DHpwQ4jyj1f2qj/q4/lJKfFUMcDV9eEdTKSbaOTJPnA7J7PHoHi2cOa6+avOqKqzafdztse2HK55rW11ZsHOP9b88GPEJkYqN42ocD5fewwZ7l3APrUpYFHjlph4kNo5mxY4cUhfvDPr1ppXLm7ZoOwqQNrYLgzs0c1bj2JA6lEXfHeKVrw647efrro72nqiIRtGRhsfV3mtjerRk2bZj5xcjjuhI15Y1azFisPW+hajuggqw8/LyKC72XyP37Nmz5OdXfBZLCHE+DUOvGoLeh72ZDy7P1A69vGmArq0aeT2WU1DMloP5bsGNVnIsVIu9lm07xl+u6WiqMU11rkcdSq2Uk/w9ch59LfsAWGHry6Old1FA/TCPrPL0TYrj++x87LhW7ihj9NwM3dSgCQOSeDcj2+9rYlzvVnz0/RHn1yowY/FO50WnAgy8uCnrf8r12tforo7ZLqVaC3WjzTzfqzkFxV7vtSXbjrJscn/OlNhrVFDtKhRlQoWojoIKsFu3bs3atWv55ZdfdFNEAI4fP87atWtJTEys0ACFEOeN69OalPgGjJ6X4RY86H3Ym/3gcs0djYmyeNXz1Tu2r+oFRoHF6O4tWP6D+S53ruM1O9Neu6mMsaTzVOQ/aaAU85sazROlt7HEPojAW+zUDAqOdvR3D052LtiNibJwKO8M9+mlCuEIWK/uHE/H+AY+66wr4BZcu3Jdk6AXXIPxXR2ji8FbLmvNh98dds423zEwifnrs3SPDd7v1S0H872er6rCkfxiRnVtYXic6i6Yet9C1ARB5WCPHz+e06dPM2zYMN0UkP/9739cffXVFBUVMX78+AoPUghxXrfEONJcOrUZ5VvqdUs0+uDScke7Jca5dYHTO7a/GTqL4h3uWXDMKt45sG1AoaA23oTYaGYMTwlgT/9qUkgay2lei3yVl6Jep4FSzGZ7B0aUzGaJfTA165kERgWu6+YIHk8UnuXf32Yzel6Gfh5+Oe01M65Pa9JThzB3fA/dn1BFr9X07uqA8ftu6tD2pKcOYdHEy0lPHcIdA9v6rNfu+V41KvhV0+/ceHaerGn540IYCWoGOzU1lc8//5xNmzYxfPhwmjZtSlJSEuAo05ebm4uqqlx22WWkpqaGcrxCCLwrFpjplmgB7hyYZOrYKfEN2JydT5+kOK8KJe+mZxkG19qHI5xv7KEAAy5uqns73xeLgtsHbZdWoV2w2L11LNsOVf887f6WXbwY+QYJSh6lqpWXy8byhu332NBv7lPbLNp0kJ9OFLFq13G/2yrgFZzF1YsidUQKz6/e5zMNKhC+KnzoVdRxHZPr2Fy38+xa6vk8eic11q2e0ytJv4JQTWLm75kQNY2pOth6iouLefzxx3nrrbf47bff3L5Xv359Jk2axFNPPUVMTO28zSN1sEVNkVNQzLvp2V4NXzzrZzs7wh0tcDad8dw2p6CY/rPXeAXK2qKzXklxJMRG+0whMevt23oRHRXhLNtldO5gjemewNLtOSE6WujVoYS/RHzMxIiVAGTaE3iwdDI71OQwj6x6UoAnr+/M1Z3jvV6DFsVRlaNry0a6aVCBnmfykGQGtG/qs6Scrxr0riXpALfSfr6CzDe/ySRt1V5UznepDKZboxAieCFtNOPL2bNn2bp1K0eOOHLZWrZsSa9evXxWGKkNJMAWNYVeQwrXLnGebZY9WYCl5Y01fHVsnDAwydkxryIBjPO85XmZWpA/uEOzkAbY1VlH5RAvR86lk+UwAP8uG8azZbdQTO34u6oAN/dN5MPvDoesfbnGosCM4SnOQNR5TgUyUoc6g+9AKo9YFOiTFOdV1z2YluSBNovS209RHB1Q7x5cfS62pI61uFBUWYB9oZIAW9QURkHx+L6tWfTdIXO1ehVIKw9y9To2zhiZ4pz1rowGLxYFbuvXhnczDob4yNWLgp07rKuZHvEhdZQyctWGTC+dxBp7z3APLaSmDknmL9ek8MPhfD7dfox3NmSH9PhGr8H7hrXn5r6OYLbf7DWmjvXM6Evo0jLW8KIxkJbkvi52/TWECma/qhLsRYMQNZHZ+C8kPXQPHDjAxo0b2b9/fygOJ4QIoXpRVq9FXgqw0GRwDY680JlLdvJ9dh4zhqc4FyRZgHuvTHYG11A53RPtKrU+uI7nV/4VOZtZkf+mjlLG/2w9GH5uTq0LrgFS4hvy7IofGT03I+TBNRi/Bl/56gAD0tbwTrpx9Q5P50rtFJXYDO/IaNU+zPBV2acy9qsKRuVA9RpbCXEhCTrAttlsPPPMM8THx9OxY0cGDhxIWlqa8/sffPAB/fv3Z/fu3SEZqBDCHNfOjR9tPsSYee6LC4N902vNONJW7eWaS5ujKI7FYvO+8W6trseiwKguCUGevXYbafmW1XVSGWjdzRm1Do+W3sldpX8hl9rXiVIBpi3axvz1WSG5GNOrWqNgXFvFrsLb6Vmma6/0TorTrQyiCaSkXCCVfUKxX1WozsG/EOEU1GetzWbj2muv5YknniA/P59OnTp5lRAaMGAA3377LUuWLAnJQIUQ/rm2HO4/ew2pi90XGloUeHL0JT4DG6uiMOXKZMMARAVW7jzuLA/mL8ns6esvYdHEy9mQOpTHru2ke9wByU18H6SWqs8ZXox8nXlRr9BIKWK7vR2jSp5joW0YtbX8nkpgdzn8/RTm39qLG3q29DrHDT1bGn7A2VW4+bJE5/etisKcsV0Y63GckZfGU1RiAxxpD57HM1uZRxNsSbrqXMquOgf/QoRTUGX63njjDT7//HOGDh3K+++/T4sWLbBY3P/0JCUlkZyczBdffMGsWbNCMlghhD69rop6QYxdhcYxUbpNW6YMSWZg+2bOD8Z5X2cGNAa9vFeronBV5+bOQODhj/XrF2dk/hrQuWqD3speXop8nUTLSWyqwmu20bxaNoay4P4s11r+gvEfDhewdNtRr8eXbj3K0in9ST+Qy98+d09fVIBFmw6j4lhfMH1ER8b1ac24Pq25tV8bvs/OJ+9MCa9/ncnKXcdRgBGXxjtf5IoCg9o3Jf1ALm+tz2JBepbpvONgS9JV11J2/soSCnGhCuov+XvvvUfjxo35z3/+Q1yccQ3OTp068cMPPwQ9OCGEb44SfFmmb7dbFYWebeK86u/efFkif7q8jfNDMSMzN+Db9ypwWVIcm11aWk8f7mhzDo5GIYu3egdC2r4XikjKuD9iMfdal2NVVA7Zm/FA6RS2qh3CPbQaqVnDOvodRYEXv9jPOp1OjK6bqyrMWbmX67q1ICE2mm6JcVzUsK7bokIVWOlSh1tVcTuulnfs2trcl4TY6KAC0GD3q2zVNfgXIpyCCrD37t3LwIEDfQbXALGxsZw4cSKogQkhfDNTa1rBMdtm92heMbhDM/5xc3cyDvzKh5sPsXDTYT787rBzFq5t03pBVQPZlJ3PlCHJdIpvSMbPvzpL/ykKDOnYrALPtnZIVo7yUuQ8uloci+w+LruCp8r+zGnkdnowxvZsyVWdmvPEp7t13wd6wbUeO/BuejaPjuoEGLc798WztblZtaW8XXUN/oUIl6ACbJvNRp06dfxul5OTY2o7IURg/LUrh/MBtefMklFgbi+vFBITZaV3UmMmDmrLW+vNV1vQzF2b6RWcqyqs2Xsy4GPVHip/sv6P/4v4gGilhHy1Po+W3skq+2XhHliNowDThrZnWKeLnF1GZ9/QhdQlO53rARRgVJd4Ptvpv/ujZkH6z3Rp1ZDeSY2DusAMJu9YytsJUXsFFWC3adOGHTt2+NymtLSUXbt2cfHFFwc1MCGEMV8zbJ5dFeF8e2Z/gblWKURr1qGXq21GRVI+KqOOdjg1pYDnI99kqHU7AOtsXXik9G5+oXF4B1bNKIr/BbMAAy9uys2XtXabLdVSFLYezEdVHe3DTxSeDSjAdn3tz76hCzf1TWTRd4d1t7UoMKZHS5ZtOxZ03rFReTuzaSZCiOotqCoiw4cPJzs7m7feestwm1dffZWTJ08yatSooAcnhNCnzbB5suAIDq4tzyd19cPhfF5b85OpgNmuwvOr9zFjRIphebJgPXJNB+4b2p6nR1/C+MsSvb5fm4LrqyxbWF1nBkOt2zmnRvJk6Z+5rXSGBNc6zLY8W/9TLgPS1vDR5kNujyfERjOqawvna79bYhwjL40PeBxaoHtTH+/XpuaVm3rw4o3dSU8dwqKJl5OeOiTgmWcpbydE7RbUDPYjjzzCP//5TyZPnsyPP/7IjTfeCEBRURFbt27l448/5u9//ztNmzZl6tSpIR2wEEKfwvmW5p4e/ni74QJDIzZVpWvLRsy/tRd3vrclRKOEo6eKHS2y1fP1imtTUA0QzVlmRfyb8RGOboF77K25v3QK+1XjoE2cZ1FgztguTP9Ev525mdnejzYfYtUu3zPYRq89m6pyJL+YmSNTmL1yr9c+vZIc77GK5B1r5e08uzNKeTshaoegZrATEhJYtmwZjRo14pVXXmHQoEEoisInn3xCnz59eP7556lfvz6LFy+madOmoR6zEBe8rNwir8BABc6U2L22/eFwvmFwbVUUZo5MYe74Hl4z4tqHfXSU/nX4M6Md9a0/ndI/oFnuhZsOu1VnqG3BdTflACuiHmV8xBrsqsKbZaO4vuRpCa4DYFcd5fd8vTZ8zfbmFBS7law0smxKf93XPsDUhdsoPFPq/Y0Q3dGpzrWthRAVF3TB1cGDB7N7925eeuklVq5cyc8//4zdbicxMZERI0bwyCOP0LJlS/8HEqIWqOpKAIHMfn2Xnad7jD9f3prJQ9qTEBtNTkExEwe1ZcH6LOw4ZhDvKG+gYXSuLi1jKSqxcTi/OKg87drGio3J1k+5P2IJEYqdY2pjHi69l432S8I9tBrp35sO+fy+r9ne77PzfAbXWp51t8Q4uiXGcfpcmdfaBBWYq1MLXlUJqlqIHilvJ0TtpaieLRhNOHToEIqikJh44c7IFBYWEhsbS0FBAQ0bNgz3cEQYhasSwEebDzlrWVuAuwa1ZcLAtrq519fPzfDa/+3behEdFcHOowXMWbXXOf6B7Zuy/idHHWzt+QBujSRG92jB0m1HnWkeUPtmogPRWvmFlyLn0cvyEwDLbf14rHQChdQP88hqhiEpzVgbQJUZbbbX6H326NKdLNQJ0J8ZfQnJzRroBrP//eEo0xZtN3Xu9NQhEgwLcYEyG/8FFWBbLBb69evHhg0bKjTImkwC7AuHr9npnIJit4YU4Mi7emV8D3q1iauUD2HX8QC8+tUBFn13yC0gdg08cgqKmf7JDta71ATu2boR2w+fMjXzbMGR231Rw7pk554hJsrCmHkZbvvWxjxqc1T+aP2GJyLep75ylkI1msdK72C5fUC4B1ZrKThSO/TWGoD+e1KzceZQw/ekr/00UkpPCGE2/gsqRaRhw4a0bds26MEJUVP4m53WqwRgx5G/WRkfxp7jGX5pPCtdSpF5Lv7yrHl9bdd4xvRoycT3t5hO67ADo+dlkFb+XDIyc732VYHxlyWycJN+WbPaqBG/MTtyASOsmwHYZE/hoZJ7OYo01KlMKnA4r5iiEpvuRa9RCctJg73v7nhePLt2OPVkAZZONg7shRDCVVABdufOnTl8+ML5IBUXFu1Dt16U1W+dWr38ZI3n9hXN09arm7tSp86vTVXZkp0PSr7XQq9VO3/hmkviA86ZVlWYuXgngzs0o16UVXebHomN+PHYb2w/fCqwg/twxcVN+cZkN76qNMiygxci36C5cooS1cqLZTcy3zYKe3DrxkUAFOC+D7c505NSR6Rw9xXJzu/rvSctCkwY4D4pZHTxfKq4lLRVe93KBmopKRJcCyHMCirAnjhxIhMnTmTz5s306dMn1GMSImxcP3T1Gl94tkP2N+ulbb9u/8kK52mbbd/sGoDojceiBFcGQWsnfWWK/gztI5/sDOq4vlS34LoOJaRGLGJCxOcA/GRvyQOlU9itJoV3YBcIC44ZbNcqNLNX7QUF7h7sCLI935N61TmMmrykxDdgjkdwbVFgyeR+ElwLIQIS1HTLhAkTmDx5Mr/73e947rnn2LdvH+fOnQv12ISoUp4funqrE/QqF4zr05r01CG8dnMPr3J1FgV+OlGo+2GeU1Ac0Pi0mTkzDLs8Apuz9KuKmLEg/WfqRVlDVamsRumsZPPfqP9zBtf/LPsd15Y8K8F1CF3bNd7wQ8miwJOjL9HN9Z+zaq/b+0l7Txo1gTFq8rI5O9875UvVL38phBC+BBVgW61W5s6dS2FhIbNmzaJz587ExMRgtVq9/kVEBF0JUIgqk1NQzGc7jukGptqbxFed2oTYaK7t1sKtrq02A/74pz+GpGNbQmw0M0ak+N3O1yS3HfjnxoMBnddt//Jg4+a+F04FIQt2Jln/y7KoWXSwHOWE2ojbS6bz17LbOUdUuIdXaygK/N+ozmyYOZTHRnXy+r5dhcYxUboXd/by0nmuEmKj6ZfcRPf9qnexalUU+iTF6T4uzV+EEIEKKsBWVdX0P7tdrvxF9fbR5kMMSFvDsyv2en3PqigsndLfdDtkbeZs7vgeoBoHu8F+aHdpGRvwPsEymqWOibLQL7lJlY0jnFqQyweRz/Fo5CKiFBuf23oz/FwaX9u7h3to1YYCzqA0kIZDXsrfLI6W5wm6gW7PNnGk6lxkBvp+Mmry0i0xTpq/CCFCIqjpZQmaRW3hmRbiKtiFTQmx0cTV8+606HncYD60fS2qDDWjU3y0+QjThrWv9aX5rrNk8EzkOzRUzlCk1uHJslv52HYlIWvlV0uowOjuCbS/qAFnS228usa7OYvZ42jrGzzzqC0KTB/RkYTYaO6+IpnCs6XMW5uJSvDvJ6MmL9L8RQgRCpK/IS5oRgsHZ43qxMiuCUF/uOpWMgBeHd+DnhWoj+0ZeOgtxKxsC787RJumMdzQs6VhC/aarCFFPBX5LqOtjuY82+zteaB0MgfV+DCPrPpaui0HyKnQMRRwm4Ue16c1p844KnrYVUeedaPoSABe/9oRXCvlgXegC4ZdK/ro3Y3R3p9ZuUVuXwshhFkBBdgHDhxgyZIlZGdnU6dOHbp3786NN95IdLT88RE1k1Eb8IoE12BcyWBU1xZBHc81IHANPIINrhXgtfE9aBUXzeG8Yq+qI0r5/xgdf/bKvRVLB6imLrf8yIuRr9NS+ZUy1cKrZWN4zTYaG/qlCUXoqMC6/ScZ16c1OQXFbDmY73iNl3/fXl4qEpf3q6rC86v2cV23Fqbfr29+k+k8rgJM1OmAGq7urEKI2sN0J8eXX36Z6dOnY7PZ3B5v2bIlK1eu5NJLL62UAVZX0smx9nBtOe6vBXOgcgqK/d5q9lcf27N04JQrk5n3dabpNJHL2saxKSvf6/FFEy93zt69+U2mo126y/drewqIqyhKeSjiEyZZP8OiqGTbm/Ng6WS2qReHe2g1Vs/WsWw9VBDQPhYFZoxIcbwWA3jxzR3fg7h6UX5rzL+5LpPZK73XWrgG0XodHaU9uhBCE9JW6enp6VxxxRWoqkq9evXo2LEjhYWF/Pzzz9jtdi6++GL27NmDxXLhNFmQALt2MRMI+9tfa05j1GFOj7+ZMjPtm4PhGjB4dnt0ZQGu796CpduPhXYA1Uh75Qj/iJzLJRZHdZVFZUN4uuzPnKFumEd2YfKX9uR54aeUP6BiPNucU1DM99l53Ldou8+1EempQ8jKLWL8/E1e33e9IBVCXLhC2ir9tddeQ1VVbrvtNl577TXq1asHwI4dOxg7diwHDhxg9erVjBw5MjSjF6KKaQurgqEXoJq5rWzU7MK186NR6UBPFmBQAF0P77minfMcRsE1OMr6DevUvJYG2Cq3Wb9gZsRC6iql/Ko2ILV0Il/ae4d7YBcsBXNrCrS0Lkt5MO6aRuLZbdXXBaQrrXRm26b1vIN4kFJ9QoiAmJpy3rhxI61ateLNN990BtcAXbt25R//+AeqqvLtt99W2iCFqK6MAlQzzWSMml1k557xWTrQk1VRGH5pfEBdDxvXizIcg6edx06ZPm5N0Yx83oucw5OR71FXKWWtrRvDz82R4Bpo0zg8gaSiONqe+8vtV4FXburBoomX84+bunvNSNtUla0HHSlR/i4gXfks9VcL1xsIISqXqRnsX375hZEjRxIV5d1UYeDAgQCcOHEitCMTogbwFaC6NpPRcqxd/9togWVMlMV0UDBrVCd6J8Uxel5GQOM+W2rjX99mo6qq31zrN7/JCujY1d01lu+YHbmAxsppzqqRPFP2J/5tuwqJohwO5gXWAMmqKHRLjGXroVOm97EAdw1uy6guCRzOK0ZROF9dR8FnDrbj9aqS1DSGmCj9OaIpC7dx+lwZiY1jfB4H8Cr1l5GZ6/V+UNXzJQSFEMIMUwF2SUkJjRo10v2eln9SUlISskEJUVP4qkttVRR2HD3FLQu+dSxQLH/cNVdUr9JIUYnN9IzbyK4JZOUWBVxN5G9f7A9sh1qgHsU8HvEvxkV8DcBOexIPlE4hU20Z3oHVcGljL2XG4p2G39feH1ZFYfqIjnRt2ci51iGnoNhtzcJHmw85g2sFGH5pPKt3H/d6fU9btB2LAncNbGt43keX7GLJ5H4+y2UCXmsvjC58JUVECBEIqYMtRAV4luPTWBWFe65s51ZKzzVG0FJI0lOHsGRyPzZn59O2aQzRUREUl5T5Pa/rjNuJwrMXVMWPYPRU9vNS5DzaWE5gVxXesP2el8r+QKn8CfRr/GWJLNp02PD19cgnvoPr+bf2IiYq0msBsecCX8/qISrwxe5fWDa5P0fyi8k/U8KsZbvd8q0XrM8yvMC1qSpnSux+y2V6zkobldiU2WshRCBMf7ocOHCA999/P6jv33rrrYGPTIgaQuv8tvVgPr8WnaNJvTocyS92q+Grx6aqvJuezYL0n71rUPtgAZZM7ke3xDhnkCLBtb4IypgWsYyp1qVYFZUjalMeKrmX79RO4R5ajWBVFKYNvZg2Terplrfzx67CxPe3MPuGLm4VOPQW+OqlhWhB8qiuLXRTN+zApIHtvN5D2tiTmsbQL7lJwJ0ZpZujEKKiTJXps1gsKEpw+YmKolBW5n9GrqaRMn1Vy1+t6HBzq1Vd/pi/N5aCY2FXMCX4Fk28nKSmMZVSwq+2SFJyeDlyHt0tjtbdS2wDeaL0dn5DbvWbYVUUpg/vSMu4aKYt3FahizjPOtIZmbm6pfA878S47uerPjXAuxuyWLAuCzuEvJ69EEJoQlqmr3Xr1kEH2EJUVHXvquY5G2c2EBnVNZ7PdhwP+HzazJyZCiAXJpWbrGt5POJfxCjnKFBjeKz0Dv5r7x/ugdUYs0Z1okxVA274YkRb8Osrz9miwIzhKTy/ep9uaoa/1I1HR3ZmwoC21XrWubpPFAghQsdUgJ2dnV3JwwheXl4e06ZN47///S8Wi4WxY8fyj3/8g/r16xvuc/z4cR555BG+/PJLfvvtNzp27Mj//d//MXbs2CocuTDDX63o6iDYQLdNY+MFkr5oNayBoPavzRpTyJzI+Vxt3QJAhq0zD5feSw7SIMQsq6I4KtPMzQhZ6pFFwa3ihxYspy7ZeX6Nggq5p8+xZHI/zpTYdYNkf6kbFalnX9mq+0SBECK0anzrxVtuuYXdu3fz5Zdf8tlnn7Fu3TomTZrkc59bb72Vffv2sXz5cnbu3MkNN9zAjTfeyLZt26po1MIsX7WijeQUFJORmeuzBnUoabNxrhT851LP+8Z8u3O3/b7O5IXP95KVW8SMESlSXK7clZZtfF5nBldbt3BOjeCZ0lu4pfRRCa4DdM8V7TicX1yh4HpISjO3r+0qjJmXwUebDzkfG9yhmdvtHhWYvz6L0XMzOJRXZBgoJ8RG0y+5SbUNpPUYTRRU1d8oIUTVq9EB9p49e1i9ejULFizgsssuY+DAgbz66qt8+OGHHDtm3HkuIyODadOm0bdvX9q1a8djjz1Go0aN2LJlSxWOXpihF7z6KpmlNWgZP38T/9/efcdHVaWPH//cSSMJJCEQSMBAAghBDKGI9CrfpbkUcUHZtSACq9h1JeyKZVcl6Lq6CoiCa/m5IrgUC8UGSBUQCEVpQiAIoUlIEAIpc35/DDNMuVMzk2SS5/16+ZKZueXMnTuZ5577nOd0z1pp84PuC/Nsip/vOOb0x9DcGxdyJY0qRNPIHJSGu6wqb0vrWdYDZqw6yJg5m3waeFbd1OIyfw99l/fCXyZBK2Cf8RqGF/+DuWVDUMH9J65SxEeHk3/R97KrfVsl8N2+0w7PWweVO47mM2PlAd0gXlH9gk9fOgqEEMEtqGtUbdy4kbi4OG644ersa/3798dgMLBp0yZGjBihu163bt2YP38+Q4YMIS4ujgULFnDp0iX69OnjdF+XL1/m8uXLlseFhYV+ex/VlT/yDb0pmeXvdJL5W3LJXHi1QocGZI3Uv61rf+u6IvOja3KGyPXaIf4dNpPmhjwA5pYO4uXS0VzGcVIs4ZmzF4qZtfqgz+t3b1GfVToBNpiCysn/28kaN7OO2uds2yvP35bKyIOW2tpC1DxBHWCfOHGCBg0a2DwXGhpKfHw8J044Hzy2YMECRo8eTb169QgNDSUqKorFixfTokULp+tMmzaN5557zm9tr+78mW/oacksV71E3v6Q7jiabxNcgymQnbJwl9OA3Tr/81ThJa/2J7xjwMifQz7n0dD/EaaVcULV5fGSP7PemF7ZTQtqqfWjmLX6oM8XbSGaRqeUui7HBrgLrs3bcXWXyte/LZWVBy21tYWoeark/dPMzEw0TXP53969vt8anzp1KufOneObb77hhx9+4LHHHmPUqFHs2uV8woQpU6ZQUFBg+e/o0aM+77+6C0S+oSd5l56mk+w4ms+ctQfZcTRfdzvzt+Q6HeBlBI9u614oLnO7jPDNNdppPg7/B0+GzSdMK2Np2Y0MuDxdgms/yDlz0efg2gC8eMv1ZCTXZdot6T7/uPhyl8qTvy2VnQc9ulMT1mX2Zd74LqzL7OtRYF/R40mEEP5TJXuwH3/8ce6++26XyzRr1ozExEROnTpl83xpaSlnz54lMTFRd72DBw8yY8YMdu/eTZs2bQDIyMhg7dq1zJw5k9mzZ+uuFxERQUREhPdvpgbyZ08yeH5L15NeoscXZLNw2zHL45EdGvPKqHY2+3I1cYuGqRqCuza5mkJd+EoxwrCOv4e9Rx2tiPMqkmdK7mKRsSfuh5SKQOqcGs9rt7WzfBdGd2pCdEQoD3zk+cBxgwav39aejil1A3KXyt9/l3zhTZUTqToiRHCrkgF2QkICCQkJbpfr2rUr586dY+vWrXTs2BGAlStXYjQa6dy5s+46Fy+aeh8NBtv+lZCQEIxGYzlbLsC/+Ybe/si4SifZcTTfJrgGWLjtGHd2bUpGcl3Afck9BQyfucHyb2dtSoqNZPKgNBmE6Cex/MYLYf/h5pDvAdhibMmjJffzi2rgZk1hzxzIJsdH+q0U35acs5wqvGRz0dmxqetUEWvmi+GbMxq5XK48f1uCKQ86GMqTCiFcq5IpIp5q3bo1AwcOZPz48WzevJn169fzwAMPcNttt9GokekP9bFjx0hLS2Pz5s0ApKWl0aJFCyZOnMjmzZs5ePAgr7zyCl9//TXDhw+vxHdTfehV1fAl39DXW7rO0kk2Hz6ru/wPh6+mikSHhzj0hdo/VlwdWOiqTemNY122U3imm2E3KyIyuTnke0pUCC+XjOK24qkSXPvIqKBe7QgykuuSNfLq99Sgub4PMDg90ekPhhHThad19R7z3wFn69zRpQnv3NXRq5SJ8vxt8dffpYogVUeECH5VsgfbG//973954IEHuOmmmywTzbz++uuW10tKSti3b5+l5zosLIxly5aRmZnJ73//e3777TdatGjB+++/z+DBgyvrbVQ7ng5MdMXft3RvTInXff6GFFPvtbm33H6q5nt6pDBnbY7T7Tprk6SJlE8ExTwRuoDxocsAOGhM4tGS+9mpmldyy4Kbda+t/fd0zf7TTFm4C+t7eQZg8qA0JvZuTl5BETNW/sx/NzmWv7S/6OzVMoHRnZqQlliH4bM22JSlDNE07u/bwqfvcXn+tvjj71JFCKbediGEvqAPsOPj4/noo4+cvp6SkoKyKzh87bXXsnDhwkA3rcYr76xq/v6RyUiuy8gOjR1ysDOS6zr0loOpR2/R/V1pEFOLd9blOA2UnbXJ3GNmH7AI91ppubwWNpPWBtNg4g9Lb+KF0j9SRK1KbllwM2g49No6fE81QIGmwfgezRjbI8VmuvIXRqTTJD7KNI06+rOJWl90ZiTX5Zb2tt+74e0bletvQ3n+tlTl2R7NpOqIEMEv6ANsUX0F4kfmlVHtuLNrU344nM8NKXVd5l4bFVwsNupO62zmruJBcnwUzw1vw9QlPzq8fiWOcfq4JtIwck/ICp4M/ZgIrZQzKoYnSyaw0tihsptWLRgVHDz1G3kFRQ7nrP1FplLwzrocxvZIcdjOxN7NGdquEYfPXCQq3MCIWRucXgjnFRSxyG7sw6Ltx3hiQCsJGF0Ilt52IYQ+CbBFlRaIH5mM5Lo0iKlFzpkLltzpsxeKHQJc6yDBflpnMN06f/vODkSGhzoELPaDM+23bQDu79ucWatN06UbgNE3JjNvc80t/5jIr/wzbDY9QkwXI9+UtSezZAJnkFx2f3p7bQ5z1+U4DM71NiXLuifY1YXw1iP5DheOSsG2I/kMaStBoyvB0NsuhNAnAbao8vz9I2Md/JoHdSlM/zYHwvZBQs6ZCw5BghG494OtKLsKJ3qDMzW7CNsIzFx1dUIPIzB/S80NrgcbvufFsHeI0y5QpML5R+kdfFTWDym/55qvdz2MyjRp0pnzl7lUWka75DiKSowuLzJdcXUhbJ+id/V5HxouhBBBQgJsUaM43Aa3es1cdu8NnVq8zgYsKqsg2jywS68nUCnHYMghYA9AwNGwTgQnz1/2/4b9pDYXeS7sfUaGrAVgh7EZj5bczyHlulxbVdelWTzfH9KvWuOMXrDsKoA2aHBvj1TedjEA1xUj8PJX+x325+wi05peHXhnF8I3pMTrpkN1vDK4WAghqqOgLtMnhLfc1bk2lzCzDxTMediu+lPNt9Ojw0N0X/c0fh7ezn/BZVUOrm/Q9rI8fAojQ9ZSpjT+XTqCkcXPBn1wDXBHl6bc3a2pV+vonR+uJjxafH83xvZIRfNjJ7/CdLdlxu3tnZbOm78ll+5ZK21K8rmSFBtJ1sir5foMQNbIdEl9EEJUa9KDLWoUd6Xz9G6Jm3vr0hLroGnOb20bNNMsj87qbXtqSfbxcq1f1YVRysOhC7kv5DNCNEWuMYFHSiaxTbWs7Kb5zeFfL/C7NonsO3mejQfLdz7oGZKeRIOYWiTFRjKpT3NmrDrot207u8gE3ydAkQF7QoiaRgJs4VeeTmteWW2wr0yiAVwJmvVuidvna7vqhTYqGHZllkehr7l2jFfDZtHWYEprWFDam7+X3sFvVK/6vv/8cr8lr79jkzi25p7z6/a/2JXHst15jGjfmMXbj7lfwQuu8q7LU5teBuwJIWoSCbCF33g7rXlltcE8+cWWw/l0SjFVFHE2tXrmwqsTz8iYrPJQ/CnkG/4W+l8itWLyVW3+WjKO5cbOld2wgLA+Z/wdXJsZFTa1pf3BXSnM6jABSlXoBBBCVH8SYAu/8PXWcWW0wZMgfP6WXFPda539yOyM3qlPAS+FvUW/kGwA1pSl85eSiZxEf2ZNUXE0YGy3FLpfW4+o8DC36RtJsZGMsJs0ZkCbhkETqFaFTgAhRM0ggxyFX7i6dVyV2mDulbYOwqcs2sXnO45ZamKbA3W9XGvz4LKZY9oH6F3o7zNY9TdsZUXEZPqFZHNZhfFcyR3cVTJZgutKZLhyQoVoGlkj03l6aBtuap1ISv0om9rwYPoubDh4xua7YZ+Ssmz3Cd5ac9Bh2arG2QV4VW2vECK4SQ+28Atfbx3783atuzY465U2KnhwXjYGDcb1SOXC5VKXPdQNYmrRIKZWhc28GIyd5ZFcYmroh4wJXQnAHmMTHi6ZxH6VXMktq9lCNI1F93flYrHRprdar2cXcHguOT5K97uRtWwvWcv2WkpdVsWe4fLkjwshhLckwBZ+4cu05vY/6pMHppF+TazHwbZ9cK43gHF0p2ssyzrrlTYzKpjjpqawAt5dn0OfVg2CMvCtCBnaz7waNotmhhMYlcacssG8UjqKYsIqu2k1igHonZbAd/tOY7QaxJuRbFt/Wq9n1/xdsUyEdKW3d9H9XXUvLK0fmyexSUus47CvylQd8seFEMFDU86m2RIuFRYWEhsbS0FBATExMZXdnArhSW9zXkGRR6W48gqK6J61Urc3zFkPmPX+1+w/bRmAqAH39kzlnh6pJMVG8taag5beNK68Pr6n7xNyOLQPWDypG8NnbvBrkF1RPeKBEkIZ94d8ysOhiwjVjBxX8Txech8bjW0qu2lBRdNgzI3J/HeT9zN7GoCB6Yks333C5mJSAzIHpTGxd3OHdTYcPMOYOZs82v688V3Y+cs5pi3f63ZZTYOsKtaTPX9LrkMnQFVqnxCi6vM0/pMA20c1LcD29+Agdz/qIZrGusy+Tm9h6wXm5iBi+oq9Dq9rmH7wrZ8vz2DFeeO7MH9Lrl9rVg9vl8SS7DyPlq1qwXgT7SSvhs2io+EAAJ+XdeFvJfdQSO1KblnNoQFz7+rI+A+26p7X9t8pM72LXcOV0pX206ab139rzUGmL9/r8vvoap+VydNOACGE0ONp/CeDHIVbgRgcZL5d64z14ES9/etRQNZyx+Da/Nrg65MsJ3yIpjHtlnSmj3Q9O6MzUeEGkuP9++PsaXANkJEc69d9+07xh5DVLAufQkfDAQpVJA8X38+DJQ9KcF3BFFBUYnT6/TB/p+wHI5pTq0KuTAlp/m5kjbR9zjrla2Kv5qzP7Me88V1YfH83p9+hih7o7Imk2Ei6Nq8nwbUQIqAkB1s4sE8FCcTgIPt8aXvWuZHupje35mqxL3blYdBgQo9mjO2RYml7dEQoD3y03av2j5i1gZEdGnu1jj/tOFpQafs2i+M808LmMihkCwCbjGk8Vnwfx0io5JbVXOcuFjvtUQ7RNHYeO8cf537vcCfK2UyLrmZfNI972HDwjNPvneQ4CyFqKgmwhQ29VJBeLRMCMjjIesKX/IvFzF59SHeApLvpzb1hVPDOuhzG9kixPHcs3/ueeKOCT7a6nuSjaXwkR84GpgRYZaeH9DLs4OWwt2ionaNYhfBK6SjmlA3BKDfF/M5c+eOX/CLyLxYzdcmPTj//uMhw3QvXEE3jyYGtLGkd4Fgn3tlMi8rN2ebs+2kAtwOdQSZ+EUJUTxJgCwtnqSDrMvt6XSHEk339Z10O76zLuVpFZFAabRvHOfSW6VUoGd6+EYu3H/Mp6Lbufc8rKGL6CvcDtjylAQ/d1IK218Ry7/tb/bbdqiKCYjJD5zE29EsADhgb80jJJH5UKZXbsGrKuvJHRnJdPt9xzGm4qwHJ8ZFkJNe19DxHhRssJfm8vRPl6bgL+++nQYN77e4SOSMTvwghqisJsIWFqx9gZ7eQfTF/S67NFORgCuanL9/L+sx+utvW2/8TA1pZgoijZ4t46OPtHg1iNGh4nH5iAJ4b1oapn/7o0XvLGmkKEFzdNg9W12mHeS1sJi0Npp7790p/x7TSMVwmvJJbVj1NHdKawW2THAb6OqMwpS6Zg1S975Gnd6LyCopsvqNGBZmLdjmdmdWXvw9VYfZXIYQIFLmfKyz0Bh5a/wD7Y3CQpR61zmtGZaox7UxSbKTNbHPmxxeKy+iYUtdhoNbkQWm6AyknD0pzSD/RE6JpTBuZTv/rGno8ELJXS1P+8Ze7Tni4RtVnwMiEkM9ZEj6VloZjnFJx3F38JM+W3i3BdQCVXok8Nxw8w46j+TbBqDOuBiDbD2Y0aPDkoFa63+etR/Ida10r2HYk3+m+vf37UBVmfxVCiECRHmxh4ctkMd5y12M8d00OY7un6pYSs08pGdG+sSVNxHx7eV1mX5tetLjIsKu3rjEF1xN7Xa0FrPeenxzYirbXXE1V2XHUMdhwxhwcvP/9ES+PTNXUiDO8EjabriE/AfBl2Q1MKbmXs1T/0pRmPVrUY93Pv1b4frOW77WUnPSmLKOrtI/RnZpw7mKJpdrO9OV7iYsMc0jLcFa91Z9FXWXiFyFEdSYBtrDhz1QQPe4GLBrBIThwllKycNsxm8fmfPGuzes5fT9g6hGMDg/hQnEZqfWjnb7nvIIiXlz6k8cT1JhTT3LOXPDsYFRxQw0beD7sP8RoF7mgIniu9E4WlPUBnwobBi9/BNdTBqex/8R5m3PWHcXVgNabuNZVkGoec2A/Q6N9WsYNKfEOQb0GdEzx38yMFXFBL4QQlUUCbOHAWTUBf23b0/J84DqlxJ6znjvz+7EeUGVmnuVxbI9US2C+42g+b685xDK72fDcUQrW7D9NWmIdz1eqgmK4wN/D3mV4yAYAthtb8EjJ/RxRiZXcsuD0/PA2/KlLCjuO5hMTGQYKelxbj6JiI/kXi9lzopB5m456dI5rmn4vsgHTxam7INXTgY5JsZFkjUxnysJdGK9sf9rIdL//XQj0Bb0QQlQWCbBFhbP+Ud35yzleWrHPaQ+WNzWw3fXc6eWwKuDttTnMXZfDtFvS2Zxz1qteRvtt/XXRbv59ezuf1q8Kuhh+4pWwN2ms/UqpMvBG6QhmlA2njJDKblpQe3xBts15teOXc2QfPWdJb8ocnMavv11m7pocjE62EaJpvH1nB+59f6vDDIuL7u9qqRbiKkiNDtf/HKPCHYfjVFTwG8gLeiGEqCwSYItKYf5R7dq8HkPbNXL6I+4upcRZz511bV2AL3YedxmoGxUeDSJzp0wp9p84X76NVIJwSngs9H9MCPkCg6Y4bGzIoyX3s11dW9lNC3pPLXGsQLMt95zl30YFLy3fx7rMvgxJT2L4rA0OvdTmmtI3tU4ka6RjWkWDmFoepSZdKC7Tff5isX5YL8GvEEL4RgJsUelc/YibU0omL3QsT+as5846FcScLexJ3OyPiWwAXl/5s382VEFaaL/w77CZtDGYBmbOK+3LP0rv4CK1KrllvvNmUGBVYE7TUCjdFJA3xrRnSNtGgGPP8pr9p+metdKjWtIysFAIISqGlOkTFS6voIgNB8/olhLT06tlgu6wuicHtSIjua5NaTD7VBBFcAVaFUtxV8iXfBH+N9oYjvCrqsOE4keZUjo+qIPr4e0aBd1nrmnw1Y95FBWX6pbK7NDUdnCh+e4PoFtL2tl3y75UnwwsFEKIwJAebFGhnE3F7mqq5JwzF3QDpraN43SX9VdPdHWWQD7/DHuL3iE7AVhVlsGTJRM5TVzlNswPPs0+Xqk92J7su0OTOHYcLbAM9FUK3t1whHc3HLF5zV+DFq1V9YGFMnW6EKI6kABbVBi9mdsyF+5Cu3LL2tntbVe3te1/jN3lbJsFWwqBPw0wbGZa2Fzitd+4pMJ4vvRPfFjWn+pSfq+yP1dP9t+teT2Gt2/E05/+5PDattxzvHNXR6LCw3QDYOtzXu98NwC/XrhsmYxJT1XNrZap04UQ1YWmnM0oIFwqLCwkNjaWgoICYmJqzqQb5bHh4BnGzNnkcpkQTWNdZl+HH//5W3IdBnYBNrnWmYPSmNi7uc2y2pVIWl3Z9pODWtG2cZwld1Uvt7u6iqaIp0P/H6NDVwOwy5jCIyWTOKgaV27DqqjKvAibOqQ143o2c3heLwAFrp7vV5ZTBF+AmldQZMklN3P290AIISqLp/Gf9GALt/IKivjh8Fk0TaNj07o+/9h50rvs7Pa23oQx1j/GCpi2fC9oMLFXc4dl9W6Hm6c1rwk6aPt5NWwWTQ2nMCqN2WW/59XSWymppn8CPLmLYa5A48ydXZpW2oycN+hM6KJ3B8g8udK6zL5sPZzPQx9vd3jdfhKZqsqXdBchhKiqZJCjcGn+lly6TVvJg/OyeeCj7XSbtpL5W3J92pb9ACsDjkkJrioamAd2JcVGOs21nr58r+XWuHlZ639bqy4zLroSSimPhv6PT8Kfo6nhFL+o+txW/BQvld5W5YPrvwxo6fO6t7nptZ0+Mp3Fk7q5XMbT4NqgwaS+zf2aYNMgxnGQqbsANL52uNPXg4H5AtyaVDgRQgQrCbCFU3kFRQ5TlCtMaRmeVgCxN7pTE9Zl9mXe+C6sn9KPrJG+VTRIrR+tG9AYFR4HFHo/6NVJipbH/8Kf4+HQRYRoikVlPRh0OYvNqnVlN80jxaVGxtyY7FPgeub8Zaev/WVAS3q1TOCbPSd9b5yV54a24S8D0rilg22qzfWNYnw+v/TOYWcBaFS4gQ0HzxAdHlLhAaq3FYFckQonQojqpGp3YYlK5ax6hzmI9fWHz3qAla8VDZJiI8kclGZKC7FiHVC4q0bgbtr24KW4LWQVT4f+P6K0yxSoKJ4quYfPja57bKuaf3/rez3xr1wEzwdOnqfrtJU+b9ueppkmMlpkNwPo7uOFPm3PALpBsfl8tc7BHt6+ESNmbbA8HtG+MUu2H/eoAkl5BWJAYlWvcCKEEJ6SAFs4Ze4ltg89DZp+AGDP03JbvlY0mNi7OWimtBCjMgUm43qkAJ7/+Jt/0O3zV4NVPIVMD5vD/4VsBWBD2XU8XnIfedSr5JZVHUuy8/y6valLfvTbYEgNmDYy3eX3QVnlWC/adsyyb6OCJduPezxtenk4ywf3R753Va1wIoQQ3pAAWziVFBtJ1sh0mzQR7Uqw6u4H0F+9W+6C9Im9mjM0oxHvrjvM3HWHeHttDnPX5aAUNoGHqx9/U/6qfk63BgxKT2TZrhNet72i9TFs5+Wwt0nQCrisQnm5dDTvlA1CSSaY1zQN3RkV9fgjuH6oXwtaNqxDxxTng4jNQa19ypa1MqW4WGy0TEITKDIgUQghXJMAW7hk3cOradDBgyoi/urdsg/Sx/VI5Z4eqbrbmLvukM3+7Ln78detJ6zBnDs7Mv6DrR63uTLU4jJ/Df2IO0O/BmCf8RoeKZnEHtW0klsWnHpdW5//a9OQqUt+rJD9hWgat3du4vK7kVdQxBc7j7u9w1JRgwJlynUhhHBNuraEW0mxkdyc0YghbRt5FCC76t3ylF6QPmdtjm4VE09mb7SemMbZoCz70mgj2jcmMjy0SqeNXK8dYmn4Xy3B9Tulgxha/LwE1+Ww/udfaRRbq0Km3fEkT3r+lly6Z63khaV7HV7TwDKwsSIHBcqARCGEcE16sIXf+aN3a+uRfN3AVuHYG+6uvrb5x3/N/tO6aSvzt+TqTjizZPtx7uza1KOayhXNgJE/h3zOo6H/I0wr44Sqy+Mlf2a9Mb2ym1YlacD4nqm8vTbH7bJlSnHvB1sDOsmMBswY055r6kZyobjM6ayL9hea1szndWUNCpQBiUII4ZwE2MKBp4MTnbGvzmHfu2W/ffPj6PAQLhSXsetYAVnLHHvrzOzTPZJiIxnXI5U5OsHT1CGtGdw2CbCdmMactpKWWIdMJ7M5mvNZb7uxCR9t8q32dyBco53mX2GzuNGwD4ClZTfy15J7KaB2JbesatKAuXd15LpGscxdl+PRxVIgi8poQNbIdH67XGpTAURvnIKzuzPm89r6O1AZZECiEELokwBb2PDX4ETr3G006Ni0ru72R7RvzOLtx7zqIbbvDc8rKCIjOU53OXMQsuHgGd20lS2H8532VBqAnb+cY16VCa4VIwzr+HvYe9TRijivInmm5C4WGXviOGWPMFPAuPe3MmVQml8ulv4yoCXH8i/x8ZZcjMq7AZE9W9TjiQGtaBBTS/eCz/rOTF5BEb/+dln3bpB1cC2EEKLqkQBbWPi79JZ9SsbkgWlMX7HXZvsL7WoHO2MuF2juDQfYcPAMu34psGzTHGIqTPuz7jV3lrbSKaWubilCgPv6Nmf6ir1+SxVIbxTDLh9rI8fyGy+E/YebQ74HYIuxJY+W3M8vqoGfWldx/jY4jRdc3KEoD2efJeBQM91XKfWimdT3Wh68qQWHz1wkKtxg6Yl2Z+3Pv7L+4Abu7ZGqe8G3dGceQ9om2Xx3NK4G8ZLrLIQQwUECbGHhz9JbesH69OV7MfrQrhBNs6ntu2b/aZvePzPrh0YFB0/9ZsltdZa2kpFc16EUodnZC8VOS/epK/9vlxzL9qMFHr0PX4PrbobdvBI2myTtLCUqhNdKRzK77PeUEeLT9ipbIILrto1jaJYQ7fca13rMvdXm80rv7ogrRgVz1+bo5vY/v3QPLy7bY1NmUgEGZcrZ9qSKjxBCiMonAbaw8GfpLb1g3Yh3t9PN+zcHwjuO5vPRpiPMWHnQo15lc03syYPSSG8cS6+WCazL7OswKGt0pyakJdZh2MwNNuvP23xUtz3Wwf6pwksO6/lLBMU8EbqA8aHLADhoTOLRkvvZqZoHZH/BbOexQnYe8+0Cxhsa0NGu2oy7QbZ6jMAfb2zCx5uPOswiqrcdIxAfHSHBtRBCBAkJsIWFu8GJ3nAWrD85qBUvLd9n2f7w9o0sUzvbLDewFW2vibMEwo8vyPY4ncSaUcG0Kz2mrnLKv9jpvufTfDwaxNQi58wFADKS6zL4+kSW7fbvRDSttFxeC5tJa4MpyP+w9CZeKP0jRdTy636Ed8b3bObwfbD/3njqo025ZA5KI8Sg8fzSPS6XlRrTQggRXDSlAjlevvoqLCwkNjaWgoICYmJiKrs5fpVXUOSX0lvzt+Q6BOujOzVx2L75cVS4QXeK5x1H8/3WSxyiaazL7Guz/byCIrplrXTZsz7j9vZ0TKnrkFfuyyBNa9cl1WFP3vmrM2Vi5J6QFTwZ+jERWilnVAxPlkxgpbGDbzsQgH5utrd3UwA+ndSNjOS6uq9Zn8c7fylg6qfuJ6oxaPDs0Ot49rOfbM4hTQNNmXqurb87QgghKpen8Z/0YAsH3pTeclXSz1mdXPvtm//tbDubD591un+DBpMHpdG2cRw7fzlH1nLXgxL1csrfvTK1uiv1akcAOOSV+9Krbu2nvPOWfyfxKy+HzaZHiCkw+6asPZklEzhDbLn2UZ1owB86XsOCrb94tU7fVgms3Hfa9nkFD93Ugn9/+7PH21q684TTANv6vF7qwR0RMJ1DT3/6k+5ARqkxLYQQwUsCbOEzT0r6eRKsu9vOjSnxTtdVCuIiw+javB5dm9ejUVwtHpyX7XR5vRJ/evWzrWlASv0oj2aM9NVgw/e8GPYOcdoFilQ4/yi9g4/K+iHl92wp8Cq4Nq9jH1yDqXf42gZ1vMqfnrP2EGN7pLid1lzvnDJcCaD1duVsIKMvg4vLU8NeCCGEf8hU6cInzkr66U1BXt7tZCTXZWSHxrrrm2d2zCsoIq+gCE3TnIakejnlOWcuuB0wqYBThZeIDvd/1Y7aXOSVsDeZFf46cdoFdhibMaT4RT4qu4nqElxX1XdhwDRgcdot6Zbpxt1RwLYj+S6XcXZO3dapCVkjr04vbq+8AxnNU6qPmbOJ7lkrmb+lqtRvF0KImifoA+wXXniBbt26ERUVRVxcnEfrKKV4+umnSUpKIjIykv79+3PgwIHANrSacVXSzyyvoIgvdh7n8x3HnAbenmwH4JVR7fh0Ujf+1MUxD7VMKd5dn0P3rJU88NF24GpQF6JpTOrTnKeGtGbR/V0detjNgzHdGT5rg0cDIb1xg7aX5eFTGBmyljKl8XrpcEYWP8sh1civ+6lsesGmpvk/8HYStzo1eVAaSbGRjO7UhMX3d/N4vfUHz7h83dk59fGVgHddZl9mjmnv8P7LM5DRXxe8Qggh/CPoA+zi4mL+8Ic/cN9993m8zksvvcTrr7/O7Nmz2bRpE9HR0QwYMIBLly4FsKXVi14QYR0gzN+SS7dppoD3wXnZdJum36OWWj/aIdDQNHQDjQYxtejSrJ7D8gYN5qy5OgW2urKNfwxrw+gbk3nzu4M8v3QPI2ZtcGiDuQKEuVfRgH7gpxS8sy7HL0FhGKU8ETqf+eH/INlwmlxjAn8ofoZ/lY6itBpnbVlf9GTdks6SSd28DoqdCdE0U0UOJxtsEm/bK9w3LYGJva+WO8xIrsuEnqke7evjTUddBq7mc8r+j6s56AUY0raRTW92eSeQ8fRCVQghRMUI+l/z5557DoD33nvPo+WVUrz22ms89dRTDBs2DIAPPviAhg0bsmTJEm677bZANbVacVXSz9ybZv17r4DJC3d5NiukTpendZ62hu3Mjvf0SHHIeTUqHKo42M9Mac5Xta+PvWb/aaYs3OUwKY4/8q+ba8d4NWwWbQ2m9i4o7c3fS+/gN6p/Cba/D2tDiwZ1LBdPX+w87nUVDzPtygmgMF0UjeuRwtCMRgzNaMS2I/k88NF2m9Mo96xtQLxq72n+ungnD/a71nI+ju2Rytx1OW4/ZyNYZly0Po+s855Hd2pCdESo5Y6KmfUgW2eDgK15mlPtzxr2Qgghyi/oA2xv5eTkcOLECfr37295LjY2ls6dO7Nx40anAfbly5e5fPmy5XFhYeAntajqnAUIrgYDbjuSz5C2puXMKST2iyqwqfRhf/vbPBX6G7e1t0z68Y4HgRGYApyth/PZ8UuOZR37gZXmiWeGz9rgcwDoSPGnkG/4W+h/idSKyVe1+WvJOJYbO/trB1WaBvS/riFJsZE2F0u+yhyYxtB2jXh33WHmrjtkmVRo2i3pREeEejQR0UebjvLx5qOWz9580ehJ28wzLlqXabQ/jzo2res26HU1CNiTQcTW2/FXDXshhBDlV+MC7BMnTBOCNGzY0Ob5hg0bWl7TM23aNEtvubhKL0Awp33oVku48qSrIMs+CNGdFVKZSueZ920dXLiqCqEBD86z7d2079kGU8pAlofbdKc+BbwU9hb9QrIBWFOWzl9KJnIS59VRgpGrYzT+SvqF/cWSr15asY8uzeKZu+6QTd6x3pT3rpg/+7TEOlwoLqNXywQW39+N4TM3uN2OfZlG+/PI06BXr5faWU61qztAnvSICyGEqBhVMsDOzMxk+vTpLpfZs2cPaWlpFdQimDJlCo899pjlcWFhIcnJyRW2/2CSFBtJ5uA0ywyKZuZppl0FWfZBSF5BEWcvFDsE7PZBuHVwERVuYMSsDU6DOL2n7etj5xUUkRwfZZkW3d02nelv2EpW2Bzqa4VcVmFkld7Ge2UDUME//MGGedId+7rg1zaozcHTv1l6mMf1SPVLqk2ZUnzywy8O2/Jl02VKWe5WmHuKs0am66YJebIt6/PIXdDrrJfaVU61q8DZmxr2QgghAqdKBtiPP/44d999t8tlmjVr5tO2ExMTATh58iRJSUmW50+ePEm7du2crhcREUFERIRP+6yJJvZqTnbuOZZbTSF+S4fGJMVGsuHgGd0ga+qQ1gy+ktcKrvOu9XoCrYOLyYP0A3xnAZg5YM8rKOLddTnMWZtjSUWZdks6vVomcG+PVN52UzMb4M+9U3n/uz1MDf2QMaErAdhjbMLDJZPYr8p3UdayQTT7T10o1zYC4bmhbXjmM9ucd4MGP5/6zXLMjVcGivrLh5u8L0Pn7s6Kuad4XWZf1k/pZ0lBMZ+D7gJ4vbxnZ0Gvq15qf+ZUS21sIYSoeFUywE5ISCAhISEg205NTSUxMZFvv/3WElAXFhayadMmryqRCNfyCor48kfblJsl24/zxIBWToMH6+BaL+9aAx7q14KbWjdwOpueWXpjx9kPzdVF7POqDRq8eMv1NtOgm5nTDrQr7fVkeu2Na75mafgsmhlOYFQac8oG80rpKIoJc72iB6picG2u26GXxmPPqGBM52Q+2nTU7+0wYPqMXX08w9olcfZCCWsOOC+1Z+4p7tq8Hn8d0pp6dcJNM4TabVjT4Jb2jVmy/bhPec+ueqm7Nq/nl5xqb/K4hRBC+E+VDLC9kZuby9mzZ8nNzaWsrIzs7GwAWrRoQe3atQFIS0tj2rRpjBgxAk3TeOSRR3j++ee59tprSU1NZerUqTRq1Ijhw4dX3hupZsobPOitr4DXV/7MjFU/uw0UnAXxTw5qxfTley09kuN7pTK2uyk/uHvWSt2gUHE1qHYVXIdQxv0hn/Jw6CJCNSPHVTyPl9zHRmMb5ysFEWc9uK2T6jhUbAH9mQsNQLfm9akbFc6bqw86TReZOqQ1pUZlCmyt9j84PYmluxzrkd+cnsTfbm7Nmv2nLeeVniXZeW5LLVr3FOcVFDFdJ7gGQMGdXZvyxIBWPuU9u+ulLm9OtS953EIIIfwj6APsp59+mvfff9/yuH379gCsWrWKPn36ALBv3z4KCgosyzz55JNcuHCBCRMmcO7cOXr06MGKFSuoVatWhba9Oitv8KC3vpkngUJSbKRDTvDw9o2IiwyzCZaaJ9R2mbbiqSbaSV4Nm0VHg2nCos/LuvC3knsopLbP2/QkJaGiuApKf8o7r/v85EFpxEWGWQJe8/t54KPtGDTT69HhITy1xDE4vyGlLg1iajF9xdXgVgHLd+tP9rNsdx5/u7m1zXn1+Y5jfLTZsadc75iazzX7iz1XFXEUpgmIsnzsFbYfBGkuN2i/TCBqY0uALYQQgaUp5b9CZDVJYWEhsbGxFBQUEBMTUyH7DLZcyvlbch16qb0JRKzX1/PUkNZOaxHnFRQ59Ejr9aiGaBrrMvtyqvCSx2X5rGswayhuDfmOZ0I/oLZ2iUIVydSSsXxq7I4/5iqc1Kc5s1YfrPRA25dgf974LqTUj2LrkXzyLxTz9Gc/2hzfEE3jtdsyeHBetu66CsWYOZu82l/X5vUsj/MKiug6baXb9UI0zTKY1f5iT+880lt/XWZfm/Qmb76nprz/q7ne/krl0Gu7fVuFEEJ4x9P4L+h7sGuKYMylLO8tbvP6Ww/n89DH2x2CHFe1iJPjozzKCS5TyhLceBJcm6tlLNp2jDjOMy1sLoNCtgCwyZjGY8X3cQz/jR+Ytfogg65PZNlu5yUkK4K3wbUGrP/5NGPmHnR6XE3lDzWXdzrsX3MW6Gs4zv6ZFBvJlEFpTFu+V3d56wGzznL6PamNbd0rbP89HdcjlXt6pLo99+3LDfojlUNqYwshROWRHmwfVWQPtvREue/NtmbukbQvq+csJxgPa1wbgDl3dWT8B1vpoe3g5bC3aKido1iF8K+yUbxdOgSjXfk9DZh7V0dyzlzk+aV7PHinNYdBg/WZ/Wzypu3vdFh/7q4GmE7q25y/DHAs22nKod7Dkmzb1BKDBq9fmajIk+/QjqP5Tmtjm7+LoJ/HrwFZI51fEG84eEa3p96+R95XeQVFUhtbCCH8RHqwqxHJpbzam710Z57bQLVMKS4WG3V77wCb58b1SPGo9J55/WhDKVND3mds6JcAHDA25pGSSfyoUnTXU0BUeBhD2ibx4rI9fqkBXdEClQtuVLBm/2mXdzrMr5mnP9cz+PpE3eDa1WRG9hMVuZORXJeskekOF3nWvcLO8vgVtpPZ2KeOBHqac6mNLYQQFU8C7CAQ6B/gYJEUG+lRoGo+Nl2b19MN3KyfA5jrYpr1QdcncmfXFNP6Fw9Q8sk4uoTuB+C90t8xrXQMlwl32W7zvicP1E9XcMWcxV0ZcbkB+PvwNrqDEP3FfuZDe+Z8Zmfl954f3oY/dUnRXc9VWoc33x9zG3q1TGBdZl/LZEb2OduuBubqTWZj7tGWVA4hhKh+JMAOAvIDfJVD5QUNBrZJ5MsfTzr0VG84eIbU+tEOt9ntgzn7Y/vn3s2Ijw7nhpS6ptxcYxlsnAHf/oMwYwkXwusz6bd7WG1s51Xb069xrM3tzviezWjeINqmfa2T6rD7eKHX2/KGAVOVj2YJrqugPNSvBS0b1iG/qJipPgTiru7EOJtoyCxE07ipdUPAcWChq+of3nx/vBn74C5f234yG+sca5nmXAghqhcJsIOE/ABfNbpTE85dLCHrSj3rFT+eYPKgNNo2jiOlfhRr9p+25MJ6MiDU5bE9dxSW3AeH1wLwS8N+DM8dxRnled69OYAsKi71+r3WqxPu0L5ThZcYNnOD7vIG4I0x7dmTV8iMVQe93l/HJnFsO3oOo4LpK/Zyf5/mTlNETAFuAy4Ul5Ec7/v5GBXuOG28s4mGzD3E1iXt9ILgXi0TdAdIzhjTng5NPcu79qWOtPmzend9DnPX5GDE1Fb7Kdf1LiwklUMIIaoPGeToo8oo0ydMnA36XHR/V3LPXuThj7P9MyB01//gi8fgcgGERXOuzz/o8EVDjMrz8nvmfa/Zf5rMhbu8TvWwHkCXc+YCu44V6M4qCKZAbtpIU3DprrRceRk06N6iPut/PuPxNOLO6A3mczbw7x/D2rDp0FmW7sqzTGXvrPSi/TF3N9jQXnkHH5oHF0aFGxwG3Na0QcpCCFFdeBr/OXYdCVHFORv0OXzmBh6cl6372uEzF11uM6+giA0Hz5BXUARF52DhvbBwnCm4bnwD/Hkt6+oMchtcT+jZjBDNtIx1usqURc6Daw0Ykp7EP4Y5zvhYphQzVv5M96yVjJmziWnLnATXmqnCSXK8qe60q+B6eLtGLt+DO2NuTMaoYO2BMzY9zO7c0z1FtzK4Xi60OZ/ZmgY8/dmPfHEluAZTr7L9vs2fd6+WCWhW2zAPNswrKPKgtfptMGhw5rdLHm0jKTaSrs3rkZFcl2m3pDucFxJcCyFE9SUpIiLoOBtM5izIczegzTrFoKvhJ+bGzCX60gnQQqD3k9DzCeZvO07mQv0qFtb7GdsjhbE9UmzSTVzNEtk6sTZ7T/zG0l15LNuVp9sT/N9NuS73q2HqTR7/wVZLb7Izd3VpygffH3G5PXfm6cyO6InU+tG6z3+24zgTezV3eH5cj1TeuTIA1YDtlPWumD9vvQsNb6rv2Of7m8sEPjgv2+ta9JLiJYQQNYsE2KJK05sVT2+go6cD2vRmfJyyaBehqoTHQv/HhJAvMFxSlMamEHrrXPJirufrzUd55tOfXPbSamCzH/sybM5qOO858Zvl3/Z5xp4wB+RrD5yx2Y4zyfWiylWRxNdUEFfVULKW7aVLarxlshf7wY0TeqXS9po4p2X6rNtl/rzN6SH2vK2+Y18m0Lrn3NvJYCTHWgghag4JsEWV5aqCg3WPoF6Oq3mwn/WANr3tHTz1G834hX+Hz6SNwdSzO6+0L80Gvc7hE5A5c6VHAaWmmcr/6UmKjSRzUBrTlrkv0aeAB/u24PWVP3uwV9fBrn0wrAGdUup6HMD3bZXA6v2nLRcGGpA5OI3pVwaXekMBT3+qX2VEAcNnbSDryuBE+8GN76w9zKL7u7ps94wx7YmPjrAEz92zHD83g4ZPqRlJsZHUjb7gNBVFgmYhhBD2JAdbVEnOKjhY5766ynGdNjKdIW0b2fRc229vysKdFG+YzRfhf6ON4QhnVW0mFD/K38rGUyu6jleDEo0Kl3neE3s1Z8qgNI++cBnJsQ65v94yYAqGrSngg41HbI6VK9/tO82S+7sxc0x7Ztzeng1T+jGxV3OP17dfwtWxVFc+3x8On9VN6zBPHKR3XEI0jWvqRqKu7MFZib7Xb2vvkNJhk3vvgl4+dk2sRS+EEMIz0oMtKoxeuocz3s5e6S7H1X57Dcjn5bC36B2yE4DVZRn8pWQCp6nLhJ7NuFBc5nJQIjhWrnAXbE3s3Zyh7Ro5pBvYiwoP063NPXO152X37u2VSpfUeIfnF247xp1dm1omTNl57JzTHmkjsPOXAu7ommLz/OhOTThXVGKpZmLQ4PYbm2BUivlbjmJUpuNxT48U5ujMkjnmxibM25yr2yNs0DSnkyqZJw6yLoEXomkMb9/IcgfDoMHkgWm62+iYUtdmf77UuJZa9EIIITwhAbaoEN4EM+Db7JWuclyttzfAsJlpYXOJ137jkgrj+dI/8WFZf0DDAIy9Ul9Zj0GDOXd25PtDZy0D8NwFW/YXFkPaRvLb5VLdCUkM4HQWyib1olzOTmjdxrHdU/li53Hd1384nM+4ns0sdwCGZjTijZUH+GiT4+DFqZ/+SPbRc7wyqp3N+5luVSrQqK4OxDTnTI/tngpgOUZmIZrGgze1YHSnaywzG1q/1qFpXZeBbFJsJH8dfB1ju6fqpgcZFby0Yh+TB6Xx0vJ9ToPh8tS4loGKQggh3JEAW/jMOnAEnPZO+xLMeNtj6Kp33PzaU/+XTO1VUxkVshqAszGt+b5dFvO+vgjY7iOvoEh3QF/vlgk21TrMwaSzdjm7sLCekGTOmhzLfhSwZv9perVMcHg/ozs1ISo8hAfnZevuC0y54JMHppFz5gLNnFTtuMGuJzcpNpIXR7Ql79wlVu077bD8wm3HGJyeSGR4KKn1o13OkmjOmTYfkxHtG7Nw2zHL68PbN7JcCGXpfL4AyfFRvH1nB3LOXKSTeTZNO+Zt6FVoKVOKto3jLL30ntzRMK/nLqdaBioKIYTwhATYwif2lR4Ay8Qf9r3TvgYznvYYuuodN7/Wjv28Gj6LpiGnUGhc6PQA8QOeZnBoOO07FjnsI+eM46A2wCYAtQ4mrZkD+ujwEJcXFkmxkYztnsrctTmWnlwFZC7aZTOw0HpylBtS4h169g3A34e3oW5UOL+cK7KkfGgapDeOYdexq9Oqj+zQWDdgfWvNQd3g2uze97daPt/JgxxTMKxZ1x1fvP2YzWtLth/niQGtSIqNtKnQYVSK4+cuOUyQ4+5uh6s7HZ7e0bBfTwghhCgvCbCF1/SmsTbT650uTzDjrsfQVe84wNRF23k4ZAkPhCwmRFMcU/WpNWoO9dr0uxIInyG1frTDzHzOam3bs79QsLnw0CnNZ7+83sWH9ToKyFy4y/J+cs5cYPLANF5aYZv+MLpTE/IKinhw3varn4uCXccKuatLU5rUi+IGJ73BeQVFZC13XeHEujzdS8v32bTBnvmz9eTCas3+0y7TXtzd7fA1N1pyqoUQQgSSBNjCa65SBMAxiApkMOMqiIsoPMSCsOdoZzANDlxU1oNnSu7m7VoZ5LrJCddLb9BjfaHgcOGhc4zsLyw8CeQV8NTi3azce8qmF7lt4ziHXne97bz//RE2Tunn9HjnnLng0QQuZmVK0faaqykY6w6c5s3VBy2DDp8c2MrSg+/qwsr+eLnan6u7Hb1aJvDabRkYruRwe3peSU61EEKIQJEAW3jNXVCo1zsdqGBGv3ccWuctImb1VAyGIgpUFE+V3MPnxm6EaBpR4Qa3OeF5BUUO6Q1679P6QsFZgGsAS/Bpf2Hh6aQ53+49Zfm3uRd5XWZfm23t+qXAaVu3Hs7n5gzP0yVcMWhYPsM1+0/z5nem4FrToHfL+mStuFpdZET7xizZflz3wsrdhZr9/vR4O3jWnuRUCyGECAQJsIXX9KaQRtnOpOfsdr6/gxn7tiRo51nSZB5x36wG4GS9Gxl5/E5+UfGWtl0oLnObuuAqWJ482LH3GJynwiy6vysXi41OLyzsJ80ZPnOD2/rb9u3NKyhi+grnaR6uylY7mxLcmXt7NLOZBdO6x36lVR63UZlyrp29f08D+8HXJ+k+r1/bfJdXsysKIYQQgSABtvCJfY80UGm32s1tObdjKS2/f4qQk6chJBxuepqGXSbxyfnLNm3LKyhymxOuF/xpwOJJ3XTzmMF5Koyz5e3XNR+3rJHpblMn7Nvrrje4Q1PbNthXXXE3M6aZdRlDT3qgzZPE2Oe4g07vPaaLNPtNfrErj2W78zwaPGsE3l13mL8Oae26YUIIIUQASYAtfGbfI11pvYbFF0laN5WkLXNNjxNaw8g5kJhuaZertAxXqRv2sznuPXHeZcDsj1QY8za2Hs7noY+3OwSRBhyn/E6tH+2053lCL9sygs7SKqyPk/XxMbM/Tp70QLtK7wDH/Ok1+0877BecD57VK6U4d90hxvZIcVqu0ZOJjoQQQojykABbBLfj22HhePj1gOlxl/vhpmcgrJbL1TwJhHu1TLAJWhXu63eDf1JhkmIjuTkjkgvFpTb52ff2aKYbPCbFRpI5KI1py2zTRMyTzph5WpPcOsjPLyomPircYQCh/YWKnsmD0rwur9irZQJLd+bx/NI9NsvrDZ4d3zOVt+1mizRPW+/JRYUQQggRCBJgi+BkLIP1r8GqF8FYCnWS+PX/XmNf9A2kXlQkxbrfhLtA2FmFkqU78xjSNkl33fL2ktpP3pMcH+U2h9tsYq/moDDVwUY/H96bmuSf7ThuMx36tFvSHSbAGd2pCWmJddhyOJ/8C8XM/u6QJd1j8qA0U5ucvE9Xgf6Qtkm8uGyP29KOY3ukMldntkjr5XyZ6EgIIYQoDwmwRfDJPwKLJ0LuRtPj64axuPFfeHxeLka1yW89lM5SIJ5fuocXl+1x2Ed5e0ldTd4zeWAaCsWpwktcKC5zGsBP7N2coe0aOe2Z97Qm+VvfHWSaVW1sozJNgGMezGp+f4DNe9YrH6jHXaDvaWlHT5bzdaIjIYQQwleaUt5UwBVmhYWFxMbGUlBQQExMTGU3p2ZQCnbOh6VPQPF5CK8Dg18mL2UY3aevcgga7cvY+WL+llynKRDW+8grKHKYhdCbNuit74p1AO9tr7n1e7KeqMa6Ld2mrXRbycQAoBOse/KePT1eeQWOs2w6256z5cr72QghhBBmnsZ/0oMtgsPFs7D0Mfhxselxche45S2om0LOwTMB66H0NCfYl15S68DY05rQZuY0h3NFJZap0T3tNXeXf+5smniHNoDDCENPj7s3PdSefIaulpNZG4UQQlQ0CbBF1XdoNSy+D84fB0Mo9MmE7o9CiOn0Lc9U7J7wJCdYr6KFhucTpEwemObVZC9gCmbNOdLgXW6xdb1v68fm9+JJW/R6sN1VDbFWkTMpBnpfUqFECCGENUNlN0AIp0ouwZd/gw+GmYLrei1g3FfQ6y+W4Bqu9lCGXJlNJRA9lD7tw8nkLnqD7l5asY/Jg9Is2/eEAceyfOYeZHfmb8mle9ZKxszZRPeslczfkmt5zf69ajpvJUTTmDYynWm3pNtMYqMUrNl/Gk8lxUbStXm9CglKA7UvV8dSCCFEzSQ92CKgfO7ZO/mjqfzeqR9Nj2+4B373PIRH6y5eEb2hrvahl1ahdMrFmZfVSydp2ziOdZl9+eank0z99EeXbQnRNJ4c2IrpK/Z63XPvSVUNV7W4DRosur8rGcl1ySsosum297SUYXUhFUqEEELokQBbBIxPVTWMRtj0JnzzLJQVQ1R9GDYTWg10u79ATMXu6T6iw0McJnoJ0TSiwg1sOHjG5gJDLwXDnFqRFBtJ8wa1dfc9dUhrbkipa1OyLy4qzOvcYk/zxZNiI4mvrTNbooKLxUbLtuwvLGpShQ6pUCKEEEKPBNgiIHzq2Ss4Bkvug5zvTI9bDoShb0DtBhXTaB+ZLyTsg+vh7RtZphy3nzFx2i3pZFqtY06tGN2pidOc8sE6tbd96bl3lmO985dzDlOau8tvD3T+e1VX09+/EEIIfZKDLQLCVc+erh8Xw5vdTMF1aCTc/Crc/nGVD67tLyTA9KV6+84OLN5+zOECI6+gCDDNEqmXWpFXUOR1vre3ucVJsZFMHpTm8PxLK/ZZ2me9rKu2VET+e1VW09+/EEIIfdKDLQLC4569S4Ww/EnYMc/0uFF7uGUO1L+24hpbDnoXEkYg58xFl6kD7lIrAp1Tnt7YcapLZ6kN7tpSkdVAqqKa/v6FEEI4kgBbBIRHtYePbITFE+BcLmgG6Pk49J4MIWGV13AvObuQ6JRSt9ypFYHMKfc2tcFdWyoi/70qq+nvXwghhC1JEREBM7pTE9Zl9mXe+C6sy+x7dYBjaTF8+3d4b7ApuI5rCmOXQ7+ngiq4BucpAhnJdbmvd3NLeTtvUivyCorYcPCMQ7qGK3kFRXy+4xhf7Dzu0XqS2iCEEEIEjkyV7iOZKt1Hp/fDovGQl2163O5PMHAa1AqeY6hXetB+qu7HF2SzcNsxyzqD0xOZ9ceOutuyXs+Xyivzt+SSuXCXJeVEA7JGelCxRWf/VZlM5iKEEKKyeRr/SYDtIwmwvaQU/PAOfPkUlBZBZF24+TVoM7yyW+YVTwLgHUfzGTZzg8O6n07qRkZyXafbzisoonvWSoe0jXWZfV1Ot95t2kqHfG6DBusz+1WZQLS8wbFPJR+FEEIIP/M0/pMUERF4v52Cj0bB0sdNwXWzvnDfhqALrp2VHrRPydh8+Kzu+j8czne5fa8rr6Bfh9rcNk9mdKwI5Z3p0NPjLoQQQlQVEmCLwNq7DGZ1hQNfQUgEDMyCPy2CmEaWRXzJOa4MngbAN6bE665/Q4rz3mu4OvDQmruayqn1o3VnZDdPXFPZ/BEc+3Lh4Q/Bcl4KIYSoeiTAFoFRfAE+fxg+vh0unoGG18OE1dDlPjBcPe3K27tZkTwNgDOS6zKyQ2Ob50Z2aOwyPQR8G3iYFBtJ1sh0myBbu5JCURXSQ/wRHPty4VFewXReCiGEqHokB9tHkoPtwi9bTQMZzx4ENOj2APSbCqERNov5knNc2eZvyXUoPegsF3jH0Xx+OJzPDSl13QbX1nwZeJhXUMTWw/loGnRoWrfKHD9/fcbeHPfyCsbzUgghRMXwNP6TOtjCf8pKYd2/YHUWqDKIaQzD34RmvXUXd9W7WVUDGW8mFclI9i6wNvOlpnJSbCQ3Z1S9Y+ZRPXQPVORkLsF4XgohhKhaJMAW/nH2ECyaCL9sNj1ucwvc/C9TtRAnvJ3spKqoypOKVMVSdv4KjivquAfreSmEEKLqkBxsUT5KwfYPYXZPU3AdEWOa6vzW/7gMrkEmO/G3qpw3nBQbSdfm9YLis5XzUgghRHlJDraPJAcbuHgWPn8I9nxuety0O4yYDXHe5cYG02QnVZXkDfufnJdCCCHsSQ62CKyfv4Elk+C3E2AIg35/g24PgSHE601V5ZSLYCF5w/4n56UQQghfSYAtvFNSBN88C5tmmx7XbwUj50BSRqU2q6aTvGEhhBCi6pAcbOG5vJ3wdp+rwfWNE2DidxJcVwGSNyyEEEJUHUHfg/3CCy+wdOlSsrOzCQ8P59y5cy6XLykp4amnnmLZsmUcOnSI2NhY+vfvT1ZWFo0aNXK5bo1lLIONM+Dbf4CxBGo3hGEz4dr/q+yWCSueVOuoilVGhBBCiOom6APs4uJi/vCHP9C1a1feeecdt8tfvHiRbdu2MXXqVDIyMsjPz+fhhx9m6NCh/PDDDxXQ4iBz7igsuQ8OrzU9TrsZfv9viK5fue0SulzlDc/fkmuZttxwZbbHQE3WIoQQQtRk1aaKyHvvvccjjzzitgdbz5YtW7jxxhs5cuQITZp4FnDUiCoiu/4HXzwGlwsgLBoGZUH7O0xzcYugIlVGhBBCiPKTKiJeKCgoQNM04uLiKrspVUPROVj2BOz6xPS48Q1wy9tQr3mlNkv4TqqMCCGEEBWnxgfYly5dYvLkydx+++0ur0QuX77M5cuXLY8LCwsronkVL2ctLP4zFP4CWgj0fhJ6PgEhNf5UCWpSZUQIIYSoOFWyikhmZiaaprn8b+/eveXeT0lJCaNGjUIpxZtvvuly2WnTphEbG2v5Lzk5udz7r1JKL8PXT8P7vzcF13VT4Z4voU+mBNfVgFQZEUIIISpOlczBPn36NL/++qvLZZo1a0Z4eLjlsbc52Obg+tChQ6xcuZJ69eq5XF6vBzs5Obl65GCf2guL7oUTu0yPO9wJA6ZBRO3KbZfwO5mdUAghhPBdUOdgJyQkkJCQELDtm4PrAwcOsGrVKrfBNUBERAQREREBa1OlUAo2v23quS69BJHxMPQNaH1zZbdMBIjMTiiEEEIEXpVMEfFGbm4u2dnZ5ObmUlZWRnZ2NtnZ2fz222+WZdLS0li8eDFgCq5vvfVWfvjhB/773/9SVlbGiRMnOHHiBMXFxZX1NipeYR58OBKWP2kKrlv0h/s3SnAthBBCCFFOVbIH2xtPP/0077//vuVx+/btAVi1ahV9+vQBYN++fRQUFABw7NgxPvvsMwDatWtnsy3rdaq1nz6Dzx+GorMQWgt+9zx0ulfK7wkhhBBC+EGVzMEOBkFZB/vyeViRCds/ND1OyoBb5kBCq8ptlxBCCCFEEAjqHGwRAEc3w6LxkH8Y0KDHI9DnrxAa7mZFIYQQQgjhDQmwq7uyEljzsuk/ZYTYZBjxFqR0r+yWCSGEEEJUSxJgV2e/HjT1Wh/banrcdjQMfhlqxVZuu4QQQgghqjEJsKsjpWDb+7BiCpRcNAXUQ/4F6bdWdsuEEEIIIao9CbCrmwtn4LMHYd8y0+OUnjBiNsReU7ntEkIIIYSoISTArk72fwWfToILpyAkHG56GrpMAkPQlzsXQgghhAgaEmBXB8UX4eupsGWu6XFCaxg5BxLTK7ddQgghhBA1kATYwe74dlg4Hn49YHrc5X646RkIq1W57RJCCCGEqKEkwA5WxjJY/xqsehGMpVAnCYbPgub9KrtlQgghhBA1mgTYwSj/CCyeCLkbTY+vGwY3vwZR8ZXaLCGEEEIIIQF2cFEKds6HpU9A8XkIr2Oqa51xG2haZbdOCCGEEEIgAXbwuHgWlj4GPy42PU7uAre8BXVTKrVZQgghhBDClgTYweLCGdi3Agyh0CcTuj8KIfLxCSGEEEJUNRKhBYuEljBsBsSnQuOOld0aIYQQQgjhhATYwUSmOhdCCCGEqPJkij8hhBBCCCH8SAJsIYQQQggh/EgCbCGEEEIIIfxIAmwhhBBCCCH8SAJsIYQQQggh/EgCbCGEEEIIIfxIAmwhhBBCCCH8SAJsIYQQQggh/EgCbCGEEEIIIfxIAmwhhBBCCCH8SAJsIYQQQggh/EgCbCGEEEIIIfxIAmwhhBBCCCH8SAJsIYQQQggh/EgCbCGEEEIIIfxIAmwhhBBCCCH8SAJsIYQQQggh/Ci0shsQrJRSABQWFlZyS4QQQgghREUwx33mONAZCbB9dP78eQCSk5MruSVCCCGEEKIinT9/ntjYWKeva8pdCC50GY1Gjh8/Tp06ddA0rbKb41eFhYUkJydz9OhRYmJiKrs51YYc18CQ4xoYclwDQ45rYMhxDQw5ro6UUpw/f55GjRphMDjPtJYebB8ZDAauueaaym5GQMXExMgXKgDkuAaGHNfAkOMaGHJcA0OOa2DIcbXlqufaTAY5CiGEEEII4UcSYAshhBBCCOFHEmALBxERETzzzDNERERUdlOqFTmugSHHNTDkuAaGHNfAkOMaGHJcfSeDHIUQQgghhPAj6cEWQgghhBDCjyTAFkIIIYQQwo8kwBZCCCGEEMKPJMAWQgghhBDCjyTAFgC88MILdOvWjaioKOLi4twuX1JSwuTJk0lPTyc6OppGjRpx5513cvz48cA3Noh4e1zBNEvU008/TVJSEpGRkfTv358DBw4EtqFB5uzZs/zxj38kJiaGuLg4xo0bx2+//eZynRMnTnDHHXeQmJhIdHQ0HTp0YOHChRXU4uDgy3EF2LhxI/369SM6OpqYmBh69epFUVFRBbQ4OPh6XMH092DQoEFomsaSJUsC29Ag4+1xPXv2LA8++CCtWrUiMjKSJk2a8NBDD1FQUFCBra56Zs6cSUpKCrVq1aJz585s3rzZ5fKffPIJaWlp1KpVi/T0dJYtW1ZBLQ0uEmALAIqLi/nDH/7Afffd59HyFy9eZNu2bUydOpVt27axaNEi9u3bx9ChQwPc0uDi7XEFeOmll3j99deZPXs2mzZtIjo6mgEDBnDp0qUAtjS4/PGPf+THH3/k66+/5osvvmDNmjVMmDDB5Tp33nkn+/bt47PPPmPXrl3ccsstjBo1iu3bt1dQq6s+X47rxo0bGThwIL/73e/YvHkzW7Zs4YEHHnA5hXBN48txNXvttdfQNC3ALQxO3h7X48ePc/z4cf75z3+ye/du3nvvPVasWMG4ceMqsNVVy/z583nsscd45pln2LZtGxkZGQwYMIBTp07pLr9hwwZuv/12xo0bx/bt2xk+fDjDhw9n9+7dFdzyIKCEsPLuu++q2NhYn9bdvHmzAtSRI0f826hqwNPjajQaVWJionr55Zctz507d05FRESoefPmBbCFweOnn35SgNqyZYvlueXLlytN09SxY8ecrhcdHa0++OADm+fi4+PVnDlzAtbWYOLrce3cubN66qmnKqKJQcnX46qUUtu3b1eNGzdWeXl5ClCLFy8OcGuDR3mOq7UFCxao8PBwVVJSEohmVnk33nijmjRpkuVxWVmZatSokZo2bZru8qNGjVJDhgyxea5z585q4sSJAW1nMJIuBuE3BQUFaJrmcSqEcJSTk8OJEyfo37+/5bnY2Fg6d+7Mxo0bK7FlVcfGjRuJi4vjhhtusDzXv39/DAYDmzZtcrpet27dmD9/PmfPnsVoNPLxxx9z6dIl+vTpUwGtrvp8Oa6nTp1i06ZNNGjQgG7dutGwYUN69+7NunXrKqrZVZ6v5+vFixcZM2YMM2fOJDExsSKaGlR8Pa72CgoKiImJITQ0NBDNrNKKi4vZunWrze+NwWCgf//+Tn9vNm7caLM8wIABA+T3SYcE2MIvLl26xOTJk7n99tuJiYmp7OYErRMnTgDQsGFDm+cbNmxoea2mO3HiBA0aNLB5LjQ0lPj4eJfHaMGCBZSUlFCvXj0iIiKYOHEiixcvpkWLFoFuclDw5bgeOnQIgGeffZbx48ezYsUKOnTowE033STjBq7w9Xx99NFH6datG8OGDQt0E4OSr8fV2pkzZ/jHP/7hcbpOdXPmzBnKysq8+r05ceKE/D55SALsaiwzMxNN01z+t3fv3nLvp6SkhFGjRqGU4s033/RDy6u2ijquNU2gj+vUqVM5d+4c33zzDT/88AOPPfYYo0aNYteuXX58F1VPII+r0WgEYOLEiYwdO5b27dvz6quv0qpVK/7zn//4821UOYE8rp999hkrV67ktdde82+jg0BF/X0tLCxkyJAhXHfddTz77LPlb7gQdmrePZEa5PHHH+fuu+92uUyzZs3KtQ9zcH3kyBFWrlxZI3qvA3lczbeCT548SVJSkuX5kydP0q5dO5+2GSw8Pa6JiYkOA3BKS0s5e/as01vpBw8eZMaMGezevZs2bdoAkJGRwdq1a5k5cyazZ8/2y3uoigJ5XM3n6HXXXWfzfOvWrcnNzfW90UEgkMd15cqVHDx40CHdbuTIkfTs2ZPVq1eXo+VVWyCPq9n58+cZOHAgderUYfHixYSFhZW32UGpfv36hISEcPLkSZvnT5486fQYJiYmerV8TSYBdjWWkJBAQkJCwLZvDq4PHDjAqlWrqFevXsD2VZUE8rimpqaSmJjIt99+awmoCwsL2bRpk1eVSIKRp8e1a9eunDt3jq1bt9KxY0fAFJAYjUY6d+6su87FixcBHCpbhISEWHphq6tAHteUlBQaNWrEvn37bJ7fv38/gwYNKn/jq7BAHtfMzEzuvfdem+fS09N59dVX+f3vf1/+xldhgTyuYPp7OmDAACIiIvjss8+oVauW39oebMLDw+nYsSPffvstw4cPB0x3pb799lseeOAB3XW6du3Kt99+yyOPPGJ57uuvv6Zr164V0OIgU9mjLEXVcOTIEbV9+3b13HPPqdq1a6vt27er7du3q/Pnz1uWadWqlVq0aJFSSqni4mI1dOhQdc0116js7GyVl5dn+e/y5cuV9TaqHG+Pq1JKZWVlqbi4OPXpp5+qnTt3qmHDhqnU1FRVVFRUGW+hSho4cKBq37692rRpk1q3bp269tpr1e233255/ZdfflGtWrVSmzZtUkqZztcWLVqonj17qk2bNqmff/5Z/fOf/1SapqmlS5dW1tuocrw9rkop9eqrr6qYmBj1ySefqAMHDqinnnpK1apVS/3888+V8RaqJF+Oqz2kiogDb49rQUGB6ty5s0pPT1c///yzze9WaWlpZb2NSvXxxx+riIgI9d5776mffvpJTZgwQcXFxakTJ04opZS64447VGZmpmX59evXq9DQUPXPf/5T7dmzRz3zzDMqLCxM7dq1q7LeQpUlAbZQSil11113KcDhv1WrVlmWAdS7776rlFIqJydHd3n7dWo6b4+rUqZSfVOnTlUNGzZUERER6qabblL79u2r+MZXYb/++qu6/fbbVe3atVVMTIwaO3aszUWL+fy0Ps779+9Xt9xyi2rQoIGKiopSbdu2dSjbV9P5clyVUmratGnqmmuuUVFRUapr165q7dq1Fdzyqs3X42pNAmxH3h7XVatWOf3dysnJqZw3UQW88cYbqkmTJio8PFzdeOON6vvvv7e81rt3b3XXXXfZLL9gwQLVsmVLFR4ertq0aSOdFE5oSilVET3lQgghhBBC1ARSRUQIIYQQQgg/kgBbCCGEEEIIP5IAWwghhBBCCD+SAFsIIYQQQgg/kgBbCCGEEEIIP5IAWwghhBBCCD+SAFsIIYQQQgg/kgBbCCHKQdM0r//r06dPZTfbpT59+ji0OTo6mqSkJLp3786DDz7IypUrkWkUhBBCX2hlN0AIIYLZXXfd5fDciRMn+PLLL52+npaWFtA23X333bz//vu8++673H333T5vJyMjg3bt2gFQXFzMr7/+yo4dO9iwYQMzZsygbdu2vPfee7Rv394/Dcd0wQJI8C6ECGoSYAshRDm89957Ds+tXr3aEmDrvR4shg8fzrPPPuvw/Nq1a3niiSfYvHkzPXr04LvvvuOGG26o+AYKIUQVJSkiQgghvNKzZ0/Wrl1Ljx49uHjxImPGjKGsrKyymyWEEFWGBNhCCFHBioqKeOWVV+jSpQtxcXHUqlWLVq1a8eSTT/Lrr7/qrvPJJ5/Qv39/6tWrR1hYGPXq1eO6665j/Pjx7Ny5E4DDhw+jaRrvv/8+AGPHjrXJo9brjfZVeHg4s2fPBuDAgQMsWbLE5vUjR44wffp0+vXrR5MmTYiIiCAuLo4ePXrw1ltvYTQabZZ/9tlnLekh4JjbfvjwYQBKSkr48MMP+eMf/0haWhoxMTFERkbSqlUrHnroIY4fP+7V++jduzeapjFv3jyny7z00ktomsaoUaO82rYQouaSFBEhhKhAx48fZ+DAgezatYv4+Hg6depEnTp12LZtGy+//DKffPIJq1evpmnTppZ1/v73v/PMM88QGhpKt27daNy4MQUFBeTm5vLOO+/Qpk0b2rZtS+3atbnrrrtYt24dBw8epHv37rRo0cKyHXM+tb+0adOG9u3bs337dr7++mtGjhxpee3//b//x9SpU0lNTaVly5Z0796dvLw8Nm7cyPr16/nqq6/43//+Zwmq27Vrx1133WW5OLDPXa9duzYAJ0+e5I477iA2NpbWrVvTtm1bLly4QHZ2Nm+88QYff/wxGzZssHnfrjz88MOsWbOGGTNmcPvttzu8bjQaefPNNwF44IEHvD9IQoiaSQkhhPCrVatWKUDZ/4k1Go2qe/fuClDjxo1ThYWFltdKSkrU448/rgDVt29fy/OXLl1SkZGRqnbt2mrv3r0O+zp8+LDas2ePzXN33XWXAtS7777rU/t79+6tAPXMM8+4Xfbee+9VgOrRo4fN85s3b1a7du1yWP7YsWMqIyNDAWrBggUOr+sdN2uFhYXq008/VZcvX7Z5vri4WE2ZMkUBavDgwW7bbVZaWqqaNm2qALVt2zaH1z///HMFqLZt23q8TSGEkBQRIYSoIF9++SXr16+nXbt2zJ49mzp16lheCw0N5aWXXuL6669n1apV7N69G4DCwkKKiopo1qwZrVq1cthm06ZNA16VxJX69esDOKS2dOrUieuvv95h+UaNGvHSSy8BprQXb9WpU4ehQ4cSHh5u83xYWBgvvvgijRo1YsWKFZw/f96j7YWEhDBp0iQAZs6c6fD6jBkzACzLCCGEJyRFRAghKsjSpUsBGDlyJKGhjn9+DQYDvXr1Yvfu3WzYsIHrr7+ehIQEUlJS2LlzJ48//jjjxo3juuuuq+imO2XOpbbOnza7fPkyX331FVu2bOHUqVNcvnwZpZQl+N23b5/P+92xYwfffvstOTk5XLhwwdKO0tJSjEYjP//8s8flA++9916effZZPvroI15++WXq1q0LwM8//8xXX31FXFwcf/rTn3xuqxCi5pEAWwghKsihQ4cAmDp1KlOnTnW57OnTpy3//uCDD7j11lv517/+xb/+9S/i4+Pp3Lkz//d//8cdd9xh6UWuDGfOnAEgPj7e5vnvv/+e0aNHk5ub63TdwsJCr/d34cIF7rjjDhYvXuxyOW+2XbduXe644w7eeust3nnnHZ544gkAZs2ahVKKsWPHEhUV5XVbhRA1lwTYQghRQcy9rD169KB58+Yul23Tpo3l3z179uTw4cMsXbqU7777jg0bNvDll1+yfPlynnnmGRYvXsxNN90U0LY7s23bNgDS09Mtz128eJHhw4dz8uRJxo4dy3333UeLFi2IiYkhJCSE/fv306pVK58mk5kyZQqLFy8mLS2NrKwsOnXqRP369S0pI926dWPjxo1eb/uhhx7irbfe4s033+Sxxx7j0qVLvPvuu2iaJukhQgivSYAthBAVJDk5GYBhw4ZZekk9FRkZya233sqtt94KmHq4n3rqKd5++23uuecejhw54vf2uvPjjz+SnZ0NwO9+9zvL82vWrOHkyZN06NCB//znPw7rHThwwOd9LliwAID58+fTtm1bv237uuuuo3///nzzzTcsX76c48ePc+7cOQYNGuT2YkgIIezJIEchhKgggwYNAkyD+3zpvbWWkJBgGSyYm5tLfn6+5TVzb25paWm59uFKcXExf/7znwHT1O9Dhw61vHb27FkAmjRporvuhx9+6HS7YWFhgPO2m7dtXcbQ7Msvv7SkrPji4YcfBkwDG80DHqU0nxDCFxJgCyFEBRk2bBidOnVi8+bNjB071ibP2iw/P5/Zs2dbAswjR44wd+5c3Zzizz//HDDlEMfExFiev+aaawBTD3MgrF+/np49e7Ju3Tpq167Nf//7XwyGqz8nrVu3BuDbb7/lp59+sln37bffZv78+U637a7t5m2/8cYbNs/v27fPEvD7avDgwbRo0YIVK1awY8cOmjdvbrkoEkIIb2iqvN0oQgghbKxevZq+ffsCOPRUHz9+nCFDhpCdnU10dDQZGRk0adKE4uJiDh06xK5duygrK6OoqIhatWqRnZ1N+/btCQsLo127dqSmpgKmVIjt27ejaRpz5sxh3Lhxln3s3LnTUkGjX79+JCcnYzAYGDp0qE1PszN9+vThu+++IyMjwzI5TUlJCWfPniU7O5sTJ04AkJGRwXvvvac7gc3w4cP59NNPCQ8Pp0+fPsTHx5Odnc2+ffv461//ygsvvEDTpk0tMzSa/eUvf+Gf//wn9evXp1+/fpZShtOnT6devXosWrSIW2+9FaUU6enptGnThlOnTrF27Vp69uzJpUuX2LBhA6tWraJPnz5u36u9f//73zzyyCMAvPLKKzz22GNeb0MIIWSiGSGE8DNnE82YXbp0Sc2ePVv17dtX1atXT4WGhqoGDRqodu3aqUmTJqkvv/zSsmxhYaF67bXX1IgRI9S1116rateuraKjo1XLli3VnXfeqX744QfdfSxevFh1795d1alTR2ma5vHEMUpdnWjG+r/IyEiVmJiounbtqh544AH17bffKqPR6HQbxcXF6uWXX1bp6ekqKipKxcfHq9/97nfqq6++Ujk5OQpQTZs2dVivqKhIPfnkk6pFixYqPDzcsv+cnBzLMmvWrFE33XSTql+/voqKilLXX3+9euGFF9Tly5ctbV+1apVH79Xenj17FKCioqJUfn6+T9sQQgjpwRZCCCGueOqpp3jhhReYMGECb731VmU3RwgRpCTAFkIIIYC8vDyuu+46CgsL2b17tyXfWwghvCVl+oQQQtRomZmZHDt2jG+++YZz587x5z//WYJrIUS5SA+2EEKIGi0lJYXc3FwSExMZPXo0WVlZREREVHazhBBBTAJsIYQQQggh/EjqYAshhBBCCOFHEmALIYQQQgjhRxJgCyGEEEII4UcSYAshhBBCCOFHEmALIYQQQgjhRxJgCyGEEEII4UcSYAshhBBCCOFHEmALIYQQQgjhRxJgCyGEEEII4Uf/HziQ93+nXucfAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -523,6 +475,7 @@ ], "source": [ "# Plot the surrogate model's output vs. the testing data output\n", + "\n", "y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()]\n", "\n", "\n", @@ -537,23 +490,62 @@ "ax2.set_ylabel(\"Predicted y\", size=16); " ] }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The training RMSE in the PCE BCS approximation is 1.62e-02\n", + "The testing RMSE in the PCE BCS approximation is 1.80e-02\n" + ] + } + ], + "source": [ + "# Evaluate goodness of fit with RMSE\n", + "rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx[\"Y_eval\"])\n", + "print(\"The training RMSE in the PCE BCS approximation is %.2e\"%rmse_trn)\n", + "\n", + "rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx[\"Y_eval\"])\n", + "print(\"The testing RMSE in the PCE BCS approximation is %.2e\"%rmse_tst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From our parity plots, we can see how BCS already generalizes better to unseen data as compared to LSQ, with reduced error in our testing data predictions. In our RMSE calculations, notice how the training erorr is smaller than the testing error. Though the difference in value is small, this amount is still significant as we have noise in our training data yet no noise in our testing data. That the testing error is higher than the training error suggests that overfitting is still happening within our model. \n", + "\n", + "In the next section, we explore how finding the optimal value of eta -- the stopping criterion for the BCS parameter of gamma, determined through a Bayesian evidence maximization approach -- can impact model sparsity and accuracy to avoid overfitting." + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Functions for cross-validation algorithm" + "# BCS with optimal eta (found through cross-validation) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Below, we expose the cross-validation algorithm `optimize_eta` and its two helper functions, `kfold_split` and `kfold_cv`." + "Before we build our PC surrogate again with the most optimal eta, we first expose the cross-validation algorithm `optimize_eta` and its two helper functions, `kfold_split` and `kfold_cv` below. These functions have been implemented under-the-hood in the PCE surrogate class, but for the purposes of this tutorial, you may find it useful to follow along with the K-fold cross-validation method used to find the most optimal eta (the eta with the lowest validation RMSE across all of its folds)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Functions for cross-validation algorithm" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -601,7 +593,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -651,7 +643,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -771,6 +763,192 @@ "\n", " return eta_opt" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### BCS build with the most optimal eta" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead of using a default eta, here we call the cross-validation algorithm, `optimize_eta()`, to choose the most optimal eta from a range of etas given below. \n", + "\n", + "- With the flag `plot=True`, the CV algorithm produces a graph of the training and testing (validation) data's RMSE values for each eta. The eta with the smallest RMSE for the validation data is the one chosen as the optimal eta." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# We first create a list of possible etas to pass in: [1e-16, 1e-15, ... , 1e-2, 1e-1, 1]\n", + "etas = 1/np.power(10,[i for i in range(0,16)])\n", + "\n", + "# Then, we call the function to choose the optimal eta:\n", + "eta_opt = optimize_eta(pce_surr, etas, 10, verbose = True, plot=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From our eta plot above, we can see that our most optimal eta falls at $1 \\times 10^{-4}$, where the validation error is the lowest. While this indicates that the model performs well at this eta value, we can still observe a tendency towards overfitting in the model. For larger eta values, the training and validation RMSE lines are close together, suggesting that the model is performing similarly on both seen and unseen datasets, as would be desired. However, as eta decreases, the training RMSE falls while the validation RMSE rises, highlighting a region where overfitting occurs. \n", + "\n", + "This behavior is expected because smaller eta values retain more basis terms, increasing the model's degrees of freedom. While this added flexibility allows the model to fit the training data more closely, it also makes the model more prone to fitting noise rather than capturing the true underlying function. Selecting the most optimal eta of $1 \\times 10^{-4}$, as compared to the earlier user-defined eta of $1 \\times 10^{-10}$, allows us to balance model complexity and generalization.\n", + "\n", + "Now, with the most optimal eta obtained, we can run the fitting again and produce parity plots for our predicted output." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Regression method: bcs\n", + "Retained Basis and Coefficients:\n", + "[[0 0 0 0]\n", + " [1 0 0 0]\n", + " [0 1 0 0]\n", + " [0 0 0 1]\n", + " [2 0 0 0]\n", + " [0 0 1 0]\n", + " [1 1 0 0]\n", + " [2 1 0 0]] [-0.62783727 -0.37134989 -0.08735439 -0.02919352 0.0480559 -0.03471433\n", + " 0.0232746 0.0196456 ]\n", + "Number of retained basis terms: [8]\n" + ] + } + ], + "source": [ + "# Build the linear regression object for fitting\n", + "pce_surr.build(regression='bcs', eta=eta_opt)\n", + "\n", + "# Optional verbosity output:\n", + "print(\"Retained Basis and Coefficients:\")\n", + "pce_surr.pcrv.printInfo()\n", + "print(\"Number of retained basis terms:\", pce_surr.get_pc_terms())" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# Evaluate the PC model with training and testing data\n", + "y_trn_approx = pce_surr.evaluate(value_ksi_trn)\n", + "y_tst_approx = pce_surr.evaluate(value_ksi_tst)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the surrogate model's output vs. the testing data output\n", + "y_tst_mM = [y_trn[:,0].min(),y_trn[:,0].max()]\n", + "\n", + "fig2 = plt.figure(figsize=(8,6))\n", + "ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75])\n", + "\n", + "ax2.plot(y_trn[:,0],y_trn_approx[\"Y_eval\"],\".\")\n", + "ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line\n", + "\n", + "ax2.set_xlabel(\"Test Data y\", size=16)\n", + "ax2.set_ylabel(\"Predicted y\", size=16); " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the surrogate model's output vs. the testing data output\n", + "y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()]\n", + "\n", + "fig2 = plt.figure(figsize=(8,6))\n", + "ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75])\n", + "\n", + "ax2.plot(y_tst[:,0],y_tst_approx[\"Y_eval\"],\".\")\n", + "ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line\n", + "\n", + "ax2.set_xlabel(\"Test Data y\", size=16)\n", + "ax2.set_ylabel(\"Predicted y\", size=16); " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The training RMSE in the PCE BCS approximation is 2.02e-02\n", + "The testing RMSE in the PCE BCS approximation is 1.21e-02\n" + ] + } + ], + "source": [ + "# Evaluate goodness of fit with RMSE\n", + "rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx[\"Y_eval\"])\n", + "print(\"The training RMSE in the PCE BCS approximation is %.2e\"%rmse_trn)\n", + "\n", + "rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx[\"Y_eval\"])\n", + "print(\"The testing RMSE in the PCE BCS approximation is %.2e\"%rmse_tst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In these final RMSE calculations, we can see how our training RMSE has decreased from 1.80e-02 to 1.21e-02 by building with the most optimal eta. This indicates that our model has improved in generalization and is performing better on unseen data. Though our training error is still larger than our testing error, this can be attributed to the lack of noise in our testing data, while noise is present in our training data. While the optimal eta reduces overfitting and improves generalization, the noise in our training data still impacts the training error and remains an important consideration during our evaluation of the model performance." + ] } ], "metadata": { From 51f94a5c3cc9e41f417344172a610a17f94cbb39 Mon Sep 17 00:00:00 2001 From: Emilie Baillo Date: Wed, 5 Nov 2025 12:43:20 -0800 Subject: [PATCH 3/6] Updated example gallery documentation --- docs/auto_examples/auto_examples_jupyter.zip | Bin 30881 -> 39996 bytes docs/auto_examples/auto_examples_python.zip | Bin 24324 -> 32131 bytes docs/auto_examples/ex_genz_bcs.codeobj.json | 65 +- docs/auto_examples/ex_genz_bcs.ipynb | 149 +++- docs/auto_examples/ex_genz_bcs.py | 245 +++++-- docs/auto_examples/ex_genz_bcs.py.md5 | 2 +- docs/auto_examples/ex_genz_bcs.rst | 692 +++++++++++++----- docs/auto_examples/ex_genz_bcs.zip | Bin 38789 -> 53699 bytes docs/auto_examples/ex_nn.zip | Bin 9478 -> 9478 bytes docs/auto_examples/ex_pce.ipynb | 6 +- docs/auto_examples/ex_pce.py | 30 +- docs/auto_examples/ex_pce.rst | 40 +- docs/auto_examples/ex_pce.zip | Bin 6960 -> 8972 bytes .../images/sphx_glr_ex_genz_bcs_001.png | Bin 26558 -> 27113 bytes .../images/sphx_glr_ex_genz_bcs_002.png | Bin 79581 -> 64774 bytes .../images/sphx_glr_ex_genz_bcs_003.png | Bin 36188 -> 28528 bytes .../images/sphx_glr_ex_genz_bcs_004.png | Bin 65708 -> 36121 bytes .../images/sphx_glr_ex_genz_bcs_005.png | Bin 0 -> 41216 bytes .../images/sphx_glr_ex_genz_bcs_006.png | Bin 0 -> 28409 bytes .../images/sphx_glr_ex_genz_bcs_007.png | Bin 0 -> 33575 bytes .../thumb/sphx_glr_ex_genz_bcs_thumb.png | Bin 63270 -> 55517 bytes docs/auto_examples/index.rst | 2 +- docs/auto_examples/sg_execution_times.rst | 4 +- 23 files changed, 930 insertions(+), 305 deletions(-) create mode 100644 docs/auto_examples/images/sphx_glr_ex_genz_bcs_005.png create mode 100644 docs/auto_examples/images/sphx_glr_ex_genz_bcs_006.png create mode 100644 docs/auto_examples/images/sphx_glr_ex_genz_bcs_007.png diff --git a/docs/auto_examples/auto_examples_jupyter.zip b/docs/auto_examples/auto_examples_jupyter.zip index 2daefde4d9d26ab9a915e5562be0f763672e05de..d5f8064c2111f2a9bd6af32f71998d97b6575adb 100644 GIT binary patch delta 9021 zcma)CU2GiJbrwa*iN#2l#9c9xO~3zkIh-nsYObI$jj@0`)sJ{>wZFi>GH!C$dzg^}9mdwx?@{P<>7 zxq)9*n_g9IG~%h9t?|h*^N05zHQzmT*1Y%nlV*PAxt-tJ|Hi%t)y6O+sj6P+4}!4kxxNacrjEF4v;1i?=xN8?ci=BlSNUF`-KcC@S0|mYsgf`= zY!LP%75AekY`ck8-LR>BxtU`ZRHpEB(vNVPq@z_M)UB4+@NnT+g)JqIU%qIctF8u< zVvTqvNJHgD?S7YQ=`G*qrQE)s@OZhCif{H^c&%iivl{dwFGwoAhIYhxm8q%KfLnhi z?5nOjP>oI)#`^zvJv{h$+|v!OHJ}r%?NOu~NnzAEW&Uj9xcQTbig|rvzQq%k5HMFQ zTwJ!7uPU!4kLtuN9#dYd+TNxPu+sP91Yy9X@pa@5sUVH%i#1 zT)z15Jv=H5%p+GHNmV6ig?VYr0HN_&n~XeuC9kJD#s$I&P-7-EI&6(+sg; zfb#;~Kvuhv=MU5dj%s;{YDHn!dWhypwBa**`8a_s5_2r~!!26S)Lpq33Gz57(UoYEoSi=eEpy*JnRIsT!?V%_;NV#6#v^C-$XPx#ArE zgzu~m@%@Z^Zap<8{;?ly>S%*GGpCkZKh{}7t%NGpn$hb;;fAkqDY#q{5MH7MCHVO*JfL`M>KhblrUVdDJ=hS0K`rjN5qxeb2k8luxH8aiEvXT9Iw`!g(gB!mJDj)3y>Icx zq{h}yOsmyZAPkqCu7CEO+I0QhCuDQ43913$l}qH~vOL5xn%6~yHzh9}oOlU*YVZ4r z@`X)r@xlEd)L5C9FMit0S3WTdA0ls>ssoaD)CKrQB2$irFdG1_iFc%Uli2>srK2fu z=2mf<_!7QAiVG;ME3Sk<*DD&yw=5*67D2+1su06dmOElNz@}j%>|z6ARC|%?=?GWr zx&bH>`@@4F?&lH*uxoXV%piyva`!zVeN2t}cUz@=5eK+G>e3aiJLGDwR1 z_3zO4{#wkxJ*Al(W>Fe z8d$u^jV}*YUVqI|S2PMKGiwN!%TnuZ{mX;5e(RujTvgWB_4XR;LT|9XJ|)+3ONmJP zVO0liz&3Cl4J;Xi$c6oO2WW13QVGaKT*`Y~zPP9wz8lAmxiI@3v%c?RJ0DElJNB^` z!tP2~pEmz_>KDz!wV7488Wa~v`rvkLTtMPm)N2;hgv4w!k6G^py?&w)Ko?lhkxfjl zE5jP>XI`qgd-2ydYjfrwYYu-r=FC1TRtgPdu8Gg779nd-zOBeJ=K{T*m@hbw?*q?9 z=1-jyW6InLzh}DDp1C~rXX3C}!V|C#;unWtgNm+G_T z&+89>FecT778tz5$rr;bHV{jImuDb+$2uQk2y zlv3vR>qpbIBnrU(v-QHnxiV&vX;TEY@6`Y8=vz?t9Bl&ceT$K@%s%m&en9pC6>MFp;C$f0K zLp)y&hySnf=5UWK!9x$ylAqSW+v?-=2LWzQO)ny>;q-~HbSP2@wevPV#EJETSS@Sr zW;N-wWc6w=SWDyqo?F44p!#zcr+y9hPLz5?GvFWD$(*+t8P5dV2GZjD`-0qL%dw!%KzjV{Yd z(n0G0Y{_{p5aA^N?PA_FucYEG1!Z>ab$5?zJ{Y- z47W727VgPQaHZR9dQw@iv6!CUwK&C=N$8~wR2NqDj?2bI=$$)Q9z~YB4FnE^f@@HP zk`^~o392};%ATSr6)prK6N&+LNw5dYS^6BcLe*K4F7`GZ?f2jw6@>s8bw^i}RnJGW zfeX82IZKx=pbWSy6FjA_-5zv@+vrqfTa+Yeb^1P%_id}faW7k%!E?Bn zy)d8?psGKrbSgqv|v`@g_>AEjIsi@yS$@4iG8Y&XNvbiILv36dl{A zGv#rAoRM{-OcNcDORZjj>>%cmd88w`75OG_ys`xCMF(}$vo~j^n6I6E%q*XK-~8|F z!hUHu%zfvdFR@3jS27H4yCe!;vpKV!Zyzr6ET^N)?oho3wDr9*HM6NFmj z((-F&{^l2N|L8IE-#4$PxPdfy=o`=y%IeJbI_uS{_I61KjrL+>y(eA)|HMb#%dRe8aXFjC$FC!Mcu=+ zw!JI%FK8>$X%PwTgrtn1KY^2m&n^%b;y&EKQ46}^QY+E|q&(b3QHZb0{G2^e9AP<& zt1LUogGmTS@c@62=4X)dfa=^dJ{M~gOOiPs7o{kg*q1>?&t(HD@`qpNWt&3>g0{dp z@8b3_n9)r~{VX`iw*H(r@CK>Z&UC5t*&wkk?fd8MQG_y)-YXge@0Igs6_No8j8nX385#T9e?g;#bC&;IbP8somRe|Z|` zS%oh%A7(;5`n+E)2rf>cde%FLy1o?EvDDrm!pJ8!*VmKGh%!W80v>->aj1cRQ zr&*^f!xumjL8p?i!NN#GdSuXGnBwF-KjqnyTO5UQMAIa3AuSuIxLHX8idf1EQp%B; z?HsGP3j$y#+7S(f%*}X9R7b2?C#P?4K${3neO8;yjY@BOQyU!ZGzMjIw{-ALoG;4ml?fp46x!6q5wOL)Z^UX z4m6CGZiA7?&hLgP2E`V<@HLMvmwth2Ui9f|baz&nVPQUdu;{mdNM z>qnev$*53LH0dWHnkmdJud$cnh@J7G%0ywLFvi_)pD*#Smus9}BU-y=%h_uNJT5@y zcDU}*v5Gm_tT?W$mqLs1v*yYSd`gt$BwV?)dj`eX#m-YNUOlvT?##|Fyzw9Rj@5U5 ze*Nd}C9&SmCzu_>$t7LO=5k_D?W629rxsUFh<Uyu|(Pf@3V-I4Jd11Hm9?Zq16FARU%J21cpPK zg`~obSVu@X7es@3T_EYdg|-YyQ?yejM6?%2Kno(l(2lf0p2fy-)$~>$O@)Z5w{T;? zBbQ-lu0=v*G-L~DMrGD+P*`Rzsf<8i;hg}ceaC3Mq&8xzwG8Nu>m8x09 z3QrfL;~k(JxPiAqn79-mi~6=?!qMU#TN9YYa2!?Xh^7+a7NHd#66J>wq94LYSp?n( z-G95=wCcXIHMWj>QJdZhpE0lY9{soz= zftq$^rsZe6@|6m}oXX>1lEuR*>nQ-XiyL{6O?e)WwIA|AVl=q+)zSzJWp4=q@)GM5 z%5dZcVC>Z5+seO;9|Z!kuq@az$w)y0(n2Q~c_`ergfgjow;>J2s94N)pb})+U^|>G zfYIm&QjR)v-I#mU>c*=@^IWb>R&1B49<)Y1U|*u$-j~s~QJc!gq?z)y8q0D`K`pkT zad&j+>}7Bg4+^7%!!OPqpx;0oq|{~~Bi^p z9_L%GTmO6v@3@waBhiaj<&b^$O%^ScD+-zL9~a~@HaEk*&q7aL%t(sUz!4AZ{N}+A z#>`)D9XK@l4_VB=gR=P1^FR2>U;ktL+ZO(wkbm)F|M>dnK7Yi_Z$GR?Us3Pbb9iJ? Pe9~-hPu`RKDnI={X?U(Q delta 2964 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 Ezy3;Qj{pDw delta 2799 zcmb7GU2IfE6y9x1v6p`-AXH?a)b7&V+g+jsiv6*r2IR*gppc5q?7g$QH_W}W%*^e! z0%?fGSJ7j9GEozKFhmowzG+PK!NkM|5+5`%`e2MEl4xRl@(<6*(#jW`Lynvj~{Pv_QUvuA#ttFt$*$2#E34TH#M)AL&@OizY^(l1eazXQ)ZfWLsqUV!^d3Du(y@x64s6j@7}%nRRy=@XcNDjks=>(;SgZ$1*Yn*QgBi45@K}xKm7=lE;P6@O5SqhOz@q$f|SMUU(f|Xj03F43J#~XL|0Zj4EydL?#-r>siuyGc<|>5t%6Dil?9U z;f?%0_&&ewQ9O_Q9U!-!SNdPiJ2P|V%5mgnY!G-a?=Dd~SIk1}J^~-R{czpgJcI?D z5;3XLDXbDJ6*Y~$G&Ht~H!U=uZ&YfxBIOumR-!6^*L(Yyc>=W>cmYZpzUlpKGiQ-; zib(^yTl3_UHK70nI#Dgu$kTVYW_I}8AuJAM;8E_y+-TfXA`PKKLui!{npr}Zn65KavDvan z7ReNPq16H$EpJ+4TI_<;H-r_usJmM&vRQa$&+|)c7!YHZ7JlX7{r=^%M})@82`vdk zxGL)Q26VWDGmjrWHb#;R0=$M>yQ)%dJdf&m??ZRAVp`noq7LwY!hmR;b}O2chaeeW zO(4W|F}0paqYCU}&M1g8YNZb8k+o%OUy%qDA|nJs#W}_mg!(=fZsKByK&hBnJMj=R z^d&CP1rqy81dh<5?O69SPG%4^W<7VU3r9wK;e)<*xHQ@VpZDeAdf(B;W4m%qFnmD6 z<-z0d!vj4_F}HaJY`Fsi;E%!aW~bAE^tvO^IMWGVotbDWF)r$c8!*AIH6@F8W6%+X zIhoE=ZHj=u4%D|>yzHbv&p>u?q#A0^mWzI21mHGW59#G_?&P+{YbUR?rHhTDrFCua zNcdxWv5>P4IdB|JA!`hys|((h>t`uXCO}DJbD3{3lW{_+IWP#V;F@V3i|qP>I~&x- zN5`z|;wbWC!Mot%B+q{M#|W4CPSP(eOcm(5NAQ6KodcQh!PCT4Li*FVu56miG-sg3A3|s zV~nivQMfpC0?wQnz+R8Lj|p2+!jN~+WUBc%mkllR1eT1?%Gf>U-B z6EgwBcoqkr$8kU-+Xb<65Qi)Ng)B1f31-`nC^W8AP`z^^H8B%*S24%XFf)1P;0ppD zD9Lc-!841<#}UrSh#2G9i-btDcAq7h34sqAiN@lS8tPogkVg1IL&c52s(2N=KDxCr zwYw<|AMNYhG=4DM)ZTo%_a}UFK5O1?;9Tg~y>VG8#il2t$gR!XdSvlQmrAX)5833u RH!oi9fYTR9>)6xg!`~@_&5Hm4 diff --git a/docs/auto_examples/ex_genz_bcs.codeobj.json b/docs/auto_examples/ex_genz_bcs.codeobj.json index 98eb677..7cddeee 100644 --- a/docs/auto_examples/ex_genz_bcs.codeobj.json +++ b/docs/auto_examples/ex_genz_bcs.codeobj.json @@ -708,6 +708,15 @@ "name": "function" } ], + "ksi_domain": [ + { + "is_class": false, + "is_explicit": false, + "module": "numpy", + "module_short": "numpy", + "name": "ndarray" + } + ], "math.sqrt": [ { "is_class": false, @@ -1076,13 +1085,27 @@ "name": "PCE.evaluate" } ], - "pce_surr.pcrv.mindices": [ + "pce_surr.get_pc_terms": [ { "is_class": false, "is_explicit": false, - "module": "builtins", - "module_short": "builtins", - "name": "list" + "module": "pytuq.surrogates.pce", + "module_short": "pytuq.surrogates.pce", + "name": "PCE.get_pc_terms" + }, + { + "is_class": false, + "is_explicit": false, + "module": "pytuq.surrogates", + "module_short": "pytuq.surrogates", + "name": "PCE.get_pc_terms" + }, + { + "is_class": false, + "is_explicit": false, + "module": "pytuq", + "module_short": "pytuq", + "name": "PCE.get_pc_terms" } ], "pce_surr.pcrv.printInfo": [ @@ -1503,6 +1526,40 @@ "name": "root_mean_squared_error" } ], + "scaleDomTo01": [ + { + "is_class": false, + "is_explicit": false, + "module": "builtins", + "module_short": "builtins", + "name": "function" + }, + { + "is_class": false, + "is_explicit": false, + "module": "pytuq.utils.maps", + "module_short": "pytuq.utils.maps", + "name": "scaleDomTo01" + } + ], + "value_ksi_trn": [ + { + "is_class": false, + "is_explicit": false, + "module": "numpy", + "module_short": "numpy", + "name": "ndarray" + } + ], + "value_ksi_tst": [ + { + "is_class": false, + "is_explicit": false, + "module": "numpy", + "module_short": "numpy", + "name": "ndarray" + } + ], "x_trn": [ { "is_class": false, diff --git a/docs/auto_examples/ex_genz_bcs.ipynb b/docs/auto_examples/ex_genz_bcs.ipynb index 3772d88..b50df99 100644 --- a/docs/auto_examples/ex_genz_bcs.ipynb +++ b/docs/auto_examples/ex_genz_bcs.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\n# Function Approximation with Sparse Regression\n\nIn this tutorial, we demonstrate how to approximate a function with sparse regression by constructing a Polynomial Chaos (PC) surrogate with \nBayesian compressive sensing (BCS). The function we will approximate here is the Genz Oscillatory function, defined as:\n\n\\begin{align}f(x) = \\cos\\left(2 \\pi s + \\sum_{i=1}^d w_i x_i\\right)\\end{align}\n\nWhere:\n\n- $s$: The shift parameter (``self.shift`` in the class).\n- $w_i$: The weights for each dimension (``self.weights`` in the class).\n- $x_i$: The input variables.\n- $d$: The dimensionality of the input $x$ (number of components in $x$).\n\nThrough 2 different build processes, we will construct two different PC surrogates to demonstrate effects of the BCS eta hyperparameter on model results. \nThe first build process will demonstrate most simply the construct-build-evaluate process when using BCS for our PC surrogate, along with a given a eta of 1e-10.\nThe second build process will select the most optimal eta for BCS through cross-validation algorithms (exposed here), which will soon be implemented in PyTUQ under-the-hood.\nAfterwards, we will evaluate both models on testing and training data, returning parity plots and a Root Mean Square Error for each evaluation.\n" + "\n# Function Approximation with Sparse Regression\n\nIn this tutorial, we demonstrate how to approximate a function with sparse regression by constructing a Polynomial Chaos (PC) surrogate with \nBayesian compressive sensing (BCS). The function we will approximate here is the Genz Oscillatory function, defined as:\n\n\\begin{align}f(x) = \\cos\\left(2 \\pi s + \\sum_{i=1}^d w_i x_i\\right)\\end{align}\n\nWhere:\n\n- $s$: The shift parameter (``self.shift`` in the class).\n- $w_i$: The weights for each dimension (``self.weights`` in the class).\n- $x_i$: The input variables.\n- $d$: The dimensionality of the input $x$ (number of components in $x$).\n\nThrough three different build processes, we will construct three PC surrogates to highlight the advantages of BCS and explore the effects of the `eta` hyperparameter on model results.\n\nFirst, we'll build with least squares regression to demonstrate the limitations of non-sparse methods and the need for BCS. \nThen we'll build with BCS using a given eta of $1 \\times 10^{-10}$ and identify aspects for model improvement. \nLast, we'll build with the most optimal eta, as found through cross-validation algorithms exposed here. All three surrogates will be evaluated on testing and training data, \nwith parity plots and Root Mean Square Error (RMSE) values used to compare their performance. \n\nTo follow along with the cross-validation algorithm for selecting the optimal eta, see section \"Functions for cross-validation algorithm\" in the second half of the notebook. \nThese methods have been implemented under-the-hood in PyTUQ. Refer to example \"Polynomial Chaos Expansion Construction\" (``ex_pce.py``) for a demonstration of how to use these methods through a direct call to the PCE class.\n" ] }, { @@ -15,14 +15,14 @@ }, "outputs": [], "source": [ - "import os\nimport sys\n\nimport numpy as np\nimport copy\nimport math\nimport pytuq.utils.funcbank as fcb\nfrom matplotlib import pyplot as plt\nfrom sklearn.metrics import root_mean_squared_error\n\nfrom pytuq.surrogates.pce import PCE\nfrom pytuq.utils.maps import scale01ToDom\nfrom pytuq.func.genz import GenzOscillatory" + "import os\nimport sys\n\nimport numpy as np\nimport copy\nimport math\nimport pytuq.utils.funcbank as fcb\nfrom matplotlib import pyplot as plt\nfrom sklearn.metrics import root_mean_squared_error\n\nfrom pytuq.surrogates.pce import PCE\nfrom pytuq.utils.maps import scaleDomTo01\nfrom pytuq.func.genz import GenzOscillatory" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Setting a random number generator seed:\n\n" + "## Constructing PC surrogate and generating data\nTo start, we begin with defining our true model and input parameters for our PC surrogate.\n\nAfter importing GenzOscillatory from ``pytuq.func.genz``, we generate the Genz function below, \nalong with training data and testing data with output noise. This data and the corresponding Genz function \nwill be used to create the same PC surrogate fitted in all three examples: first with linear regression, \nnext using BCS with a given eta, and third using BCS with the most optimal eta. \n\n" ] }, { @@ -36,11 +36,22 @@ "# Random number generator\nfrom scipy.stats import qmc\nrng_seed = 43" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Define our true model as the Genz Oscillatory function in multiple dimensions\nfunc_dim = 4\nfunc_weights = [1.0/(i+1)**2 for i in range(func_dim)] \nfunc = GenzOscillatory(shift=0.25, weights=func_weights)\nnoise_std = 0.025\n\nrng = qmc.LatinHypercube(d=func_dim, seed=rng_seed)\nnp.random.seed(42)\n\n# As we choose to use Legendre polynomials later in the surrogate construction, we define the domain of \u03be on [-1, 1]^d\nksi_domain = np.array([[-1.0, 1.0]] * func_dim) \n\n# Training data\nn_trn = 70\nvalue_ksi_trn = 2*rng.random(n=n_trn) - 1 # Randomly generating 70 data points within the domain of \u03be (ksi)\nx_trn = scaleDomTo01(value_ksi_trn, ksi_domain) # We scale our training data to [0, 1]^d, the domain of the Genz function\ny_trn = func(x_trn) + np.random.normal(0, noise_std, size = (n_trn, 1))\n\n# Testing data\nn_tst = 10000\nvalue_ksi_tst = 2*rng.random(n=n_tst) - 1 \nx_tst = scaleDomTo01(value_ksi_tst, ksi_domain)\ny_tst = func(x_tst)" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Constructing PC surrogate and generating data\nAfter importing GenzOscillatory from ``pytuq.func.genz``, we generate the Genz function below, along with training data and testing data with output noise. \nThis data and the corresponding Genz function will be used to create the same PC surrogate fitted in both examples: \n(1) The first surrogate will be fitted using BCS with a given eta, and (2) the second surrogate will be fitted using BCS with the most optimal eta.\n\n" + "With a stochastic dimensionality of 4 (defined above) and a chosen polynomial order of 4, we construct the PC surrogate that \nwill be used in both builds. By calling the ``printInfo()`` method from the PCRV variable, you can print the PC surrogate's \nfull basis and current coefficients, before BCS selects and retains the most significant PC terms to reduce the basis.\n\n" ] }, { @@ -51,14 +62,21 @@ }, "outputs": [], "source": [ - "# Use Genz Oscillatory function in multiple dimensions for the true model\nfunc_dim = 4\nfunc_weights = [1.0/(i+1)**2 for i in range(func_dim)]\nfunc = GenzOscillatory(shift=0.25, weights=func_weights)\nnoise_std = 0.1\nrng = qmc.LatinHypercube(d=func_dim, seed=rng_seed)\n\n# Training data\nnp.random.seed(42)\nn_trn = 70\nx_trn = rng.random(n=n_trn) # random numbers in [0,1]^d\ny_trn = func(x_trn) + np.random.normal(0, noise_std, size = (n_trn,1))\n\n# Testing data\nn_tst = 10000\nx_tst = rng.random(n=n_tst) # random numbers in [0,1]^d\ny_tst = func(x_tst) + np.random.normal(0, noise_std, size = (n_tst,1))" + "# (1) Construct a PC surrogate\norder = 4\npce_surr = PCE(func_dim, order, 'LU', verbose = 1)\n\n# Optional verbosity output:\nprint(\"Full Basis and Current Coefficients:\")\npce_surr.pcrv.printInfo()\nprint(\"Number of Basis Terms:\", pce_surr.get_pc_terms())\n\n# (1.5) Set training data\npce_surr.set_training_data(value_ksi_trn, y_trn[:,0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the input parameters of our PC surrogate, we have 70 basis terms in our PCE. With 70 training points and no noise, having 70 basis terms would mean that we have a fully determined system, as the number of training points is the same as the number of basis terms. However, with the addition of noise in our training data, it becomes harder for the model to accurately fit all basis terms, leading to potential overfitting. This demonstrates the helpful role BCS might play as a choice for our regression build. As a sparse regression approach, BCS uses regularization to select only the most relevant basis terms, making it particularly effective in situations like this, where we do not have enough clear information to fit all basis terms without overfitting.\n\nIn the next sections, we will explore the effects of overfitting in more detail.\n\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "With a stochastic dimensionality of 4 (defined above) and a polynomial order of 4, we construct the PC surrogate that will be used in both builds. \nYou have the option of printing the PC surrogate's full basis, before BCS selects and retains the most significant PC coefficients to reduce the basis.\n\n" + "## Least Squares Regression\nTo start, we call the PCE class method of ``build()`` with no arguments to use the default regression option of least squares. Then, through ``evaluate()``, we can generate model predictions for our training and testing data.\n\n" ] }, { @@ -69,14 +87,18 @@ }, "outputs": [], "source": [ - "# (1) Construct a PC surrogate\norder = 4\npce_surr = PCE(func_dim, order, 'LU', verbose = 1)\n\n# Optional verbosity output:\nprint(\"Full Basis and Current Coefficients:\")\npce_surr.pcrv.printInfo()\nprint(\"Number of Basis Terms:\", len(pce_surr.pcrv.mindices[0]))\n\n# (1.5) Set training data\npce_surr.set_training_data(x_trn, y_trn[:,0])" + "# (2) Build the linear regression object for fitting\npce_surr.build()\n\n# (3) Evaluate the PC model\ny_trn_approx = pce_surr.evaluate(value_ksi_trn)\ny_tst_approx = pce_surr.evaluate(value_ksi_tst)" ] }, { - "cell_type": "markdown", - "metadata": {}, + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], "source": [ - "## BCS with default settings (default eta)\nHere, we call the PCE class method of ``build()`` to build the linear regression model used to fit the surrogate. \nWith the flag ``regression='bcs'``, we choose the BCS method for the fitting. A user-defined eta of 1e-10 is also passed in.\n\n" + "# Plot the surrogate model's output vs. the training data output\ny_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()]\n\nfig1 = plt.figure(figsize=(8,6))\nax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75])\n\nax1.plot(y_trn[:,0],y_trn_approx[\"Y_eval\"],\".\")\nax1.plot(y_trn_mM,y_trn_mM) # Diagonal line\n\nax1.set_xlabel(\"Train Data y\", size=16)\nax1.set_ylabel(\"Predicted y\", size=16);" ] }, { @@ -87,14 +109,32 @@ }, "outputs": [], "source": [ - "# (2) Build the linear regression object for fitting\npce_surr.build(regression='bcs', eta=1.e-10)\n\n# Optional verbosity output:\nprint(\"Retained Basis and Coefficients:\")\npce_surr.pcrv.printInfo()\nprint(\"Number of retained basis terms:\", len(pce_surr.pcrv.mindices[0]))" + "# Plot the surrogate model's output vs. the testing data output\n\ny_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()]\n\n\nfig2 = plt.figure(figsize=(8,6))\nax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75])\n\n\nax2.plot(y_tst[:,0],y_tst_approx[\"Y_eval\"],\".\")\nax2.plot(y_tst_mM,y_tst_mM) # Diagonal line\n\nax2.set_xlabel(\"Test Data y\", size=16)\nax2.set_ylabel(\"Predicted y\", size=16);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Evaluate goodness of fit with RMSE\nrmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx[\"Y_eval\"])\nprint(\"The training RMSE in the PCE LSQ approximation is %.2e\"%rmse_trn)\n\nrmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx[\"Y_eval\"])\nprint(\"The testing RMSE in the PCE LSQ approximation is %.2e\"%rmse_tst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The results above show us the limitations of using least squares regression to construct our surrogate. From the parity plots, we can see how the testing predictions from the LSQ regression are more spread out from the parity line, while the training predictions are extremely close to the line. Because LSQ fits all the basis terms to the training data, the model fits too closely to the noisy training dataset, and the true underlying pattern of the function is not effectively captured. Our RMSE values align with this as well: while the training RMSE is extremely low, the testing RMSE is significantly higher, as the model struggles to generalize to the unseen test data. \n\nTo improve our model's generalization, we can build our model with BCS instead. As a sparse regression method, BCS reduces the number of basis terms with which we can fit our data to, reducing the risk of overfitting. \n\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "After fitting, we evaluate the PCE using our training and testing data. To analyze the model's goodness of fit, \nwe calculate the root mean square error between the surrogate results and the training and testing data.\n\n" + "## BCS with default settings (default eta)\nIn this section, we use the same PC surrogate, ``pce_surr``, for the second build. With the flag ``regression='bcs'``, we choose the BCS method for the fitting. A user-defined eta of 1e-10 is also passed in.\n\n" ] }, { @@ -105,14 +145,14 @@ }, "outputs": [], "source": [ - "# (3) Evaluate the PC model\ny_trn_approx = pce_surr.evaluate(x_trn)\ny_tst_approx = pce_surr.evaluate(x_tst)\n\n# Evaluate goodness of fit with RMSE\nrmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx[\"Y_eval\"])\nprint(\"The training RMSE error in the PCE BCS approximation is %.2e\"%rmse_trn)\n\nrmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx[\"Y_eval\"])\nprint(\"The testing RMSE error in the PCE BCS approximation is %.2e\"%rmse_tst)" + "# (2) Build the linear regression object for fitting\npce_surr.build(regression='bcs', eta=1.e-10)\n\n# Optional verbosity output:\nprint(\"Retained Basis and Coefficients:\")\npce_surr.pcrv.printInfo()\nprint(\"Number of retained basis terms:\", pce_surr.get_pc_terms())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Notice above how the training RMSE error is almost half that of the testing RMSE error. This shows that our current model is overfitting, \nlearning the training data with noise too well. To address this issue, we can explore selecting a better eta for the BCS fitting.\n\n" + "After fitting, we evaluate the PCE using our training and testing data. To analyze the model's goodness of fit, we first plot the surrogate predictions against the training and testing data respectively.\n\n" ] }, { @@ -123,7 +163,7 @@ }, "outputs": [], "source": [ - "# Plot the surrogate model's output vs. the training data output\n\ny_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()]\n\n\nfig1 = plt.figure(figsize=(8,6))\nax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75])\n\n\nax1.plot(y_trn[:,0],y_trn_approx[\"Y_eval\"],\".\")\nax1.plot(y_trn_mM,y_trn_mM) # Diagonal line\n\nax1.set_xlabel(\"Train Data y\", size=16)\nax1.set_ylabel(\"Predicted y\", size=16);" + "# (3) Evaluate the PC model\ny_trn_approx = pce_surr.evaluate(value_ksi_trn)\ny_tst_approx = pce_surr.evaluate(value_ksi_tst)" ] }, { @@ -134,14 +174,43 @@ }, "outputs": [], "source": [ - "# Plot the surrogate model's output vs. the testing data output\n\ny_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()]\n\n\nfig2 = plt.figure(figsize=(8,6))\nax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75])\n\n\nax2.plot(y_tst[:,0],y_tst_approx[\"Y_eval\"],\".\")\nax2.plot(y_tst_mM,y_tst_mM) # Diagonal line\n\nax2.set_xlabel(\"Test Data y\", size=16)\nax2.set_ylabel(\"Predicted y\", size=16);" + "# Plot the surrogate model's output vs. the training data output\ny_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()]\n\nfig1 = plt.figure(figsize=(8,6))\nax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75])\n\nax1.plot(y_trn[:,0],y_trn_approx[\"Y_eval\"],\".\")\nax1.plot(y_trn_mM,y_trn_mM) # Diagonal line\n\nax1.set_xlabel(\"Train Data y\", size=16)\nax1.set_ylabel(\"Predicted y\", size=16);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Plot the surrogate model's output vs. the testing data output\n\ny_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()]\n\nfig2 = plt.figure(figsize=(8,6))\nax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75])\n\nax2.plot(y_tst[:,0],y_tst_approx[\"Y_eval\"],\".\")\nax2.plot(y_tst_mM,y_tst_mM) # Diagonal line\n\nax2.set_xlabel(\"Test Data y\", size=16)\nax2.set_ylabel(\"Predicted y\", size=16); \n\n# sphinx_gallery_thumbnail_number = 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Evaluate goodness of fit with RMSE\nrmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx[\"Y_eval\"])\nprint(\"The training RMSE in the PCE BCS approximation is %.2e\"%rmse_trn)\n\nrmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx[\"Y_eval\"])\nprint(\"The testing RMSE in the PCE BCS approximation is %.2e\"%rmse_tst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From our parity plots, we can see how BCS already generalizes better to unseen data as compared to LSQ, with reduced error in our testing data predictions. In our RMSE calculations, notice how the training error is smaller than the testing error. Though the difference in value is small, this amount is still significant as we have noise in our training data yet no noise in our testing data. That the testing error is higher than the training error suggests that overfitting is still happening within our model. \n\nIn the next section, we explore how finding the optimal value of eta -- the stopping criterion for the BCS parameter of gamma, determined through a Bayesian evidence maximization approach -- can impact model sparsity and accuracy to avoid overfitting.\n\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "BCS with optimal eta (found through cross-validation) \n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n In this section, we use the same PC surrogate, ``pce_surr``, for the second build. We call the PCE class method of ``build()`` \n to build the linear regression model used to fit the surrogate. With the flag ``regression='bcs'``, we choose the BCS method for the fitting. \n\n#############################################################################\n Instead of using a default eta, we call the cross-validation algorithm, ``optimize_eta()``, to choose the most optimal eta below. \n\n - With the flag ``plot=True``, the CV algorithm produces a graph of the training and testing (validation) data's RMSE values for each eta. The eta with the smallest RMSE for the validation data is the one chosen as the optimal eta.\n\n#############################################################################\n Before that, we expose the cross-validation algorithm ``optimize_eta`` and its two helper functions, ``kfold_split`` and ``kfold_cv`` that will be called in this section.\n\n" + "## BCS with optimal eta (found through cross-validation) \nBefore we build our PC surrogate again with the most optimal eta, we first expose the cross-validation algorithm ``optimize_eta`` and its two helper functions, ``kfold_split`` and ``kfold_cv`` below. These functions have been implemented under-the-hood in the PCE surrogate class, but for the purposes of this tutorial, you may find it useful to follow along with the K-fold cross-validation method used to find the most optimal eta (the eta with the lowest validation RMSE across all of its folds).\n\n### Functions for cross-validation algorithm\n\n" ] }, { @@ -174,7 +243,14 @@ }, "outputs": [], "source": [ - "def optimize_eta(pce, etas, nfolds, verbose=0, plot=False):\n \"\"\"\n Choose the optimum eta for Bayesian compressive sensing. Calculates the RMSE\n for each eta for a specified number of folds. Selects the eta with the lowest\n RMSE after averaging the RMSEs over the folds.\n\n Input:\n y: 1D numpy array (vector) with function, evaluated at the\n sample points [#samples,]\n x: N-dimensional NumPy array with sample points [#samples,\n #dimensions]\n etas: NumPy array or list with the threshold for stopping the\n algorithm. Smaller values retain more nonzero\n coefficients\n verbose: Flag for print statements\n plot: Flag for whether to generate a plot for eta optimization\n\n Output:\n eta_opt: Optimum eta\n\n \"\"\"\n # Split data in k folds -> Get dictionary of data split in training + testing folds\n kfold_data = kfold_cv(pce._x_train, pce._y_train, nfolds)\n\n # Each value has data for 1 fold. Each value is a list of the RMSEs for each possible eta in the fold. \n RMSE_list_per_fold_tr = [] \n\n # Same but for testing data\n RMSE_list_per_fold_test = []\n\n # Make a copy of the PCE object to run the cross-validation algorithm on\n pce_copy = copy.deepcopy(pce)\n pce_copy.verbose = 0\n\n # Loop through each fold\n for i in range(nfolds):\n\n # Get the training and validation data\n x_tr = kfold_data[i]['xtrain']\n y_tr = kfold_data[i]['ytrain']\n x_test = kfold_data[i]['xval']\n y_test = kfold_data[i]['yval']\n \n # As we conduct BCS for this fold with each separate eta, the RMSEs will be added to these lists\n RMSE_per_eta_tr = [] \n RMSE_per_eta_test = [] \n\n # Set the x and y training data for the copied PCE object\n pce_copy.set_training_data(x_tr, y_tr)\n\n # Loop through each eta\n for eta in etas:\n\n # Conduct the BCS fitting. The object is automatically updated with new multiindex and coefficients received from the fitting.\n cfs = pce_copy.build(regression = 'bcs', eta=eta)\n\n # Evaluate the PCE object at the training and validation points \n y_tr_eval = (pce_copy.evaluate(x_tr))['Y_eval']\n y_test_eval = (pce_copy.evaluate(x_test))['Y_eval']\n\n # Print statement for verbose flag\n if verbose > 1:\n print(\"Fold \" + str(i + 1) + \", eta \" + str(eta) + \", \" + str(len(cfs)) + \" terms retained out of a full basis of size \" + str(len(pce.pcrv.mindices[0])))\n \n # Calculate the RMSEs for the training and validation points.\n # Append the values into the list of etas per fold.\n MSE = np.square(np.subtract(y_tr, y_tr_eval)).mean()\n RMSE = math.sqrt(MSE)\n RMSE_per_eta_tr.append(RMSE)\n\n MSE = np.square(np.subtract(y_test, y_test_eval)).mean()\n RMSE = math.sqrt(MSE)\n RMSE_per_eta_test.append(RMSE)\n\n # Now, append the fold's list of RMSEs for each eta into the list carrying the lists for all folds \n RMSE_list_per_fold_tr.append(RMSE_per_eta_tr)\n RMSE_list_per_fold_test.append(RMSE_per_eta_test)\n\n # After compiling the RMSE data for each eta from all the folds, we find the eta with the lowest validation RMSE to be our optimal eta.\n # Compute the average and standard deviation of the training and testing RMSEs over the folds\n avg_RMSE_tr = np.array(RMSE_list_per_fold_tr).mean(axis=0)\n avg_RMSE_test = np.array(RMSE_list_per_fold_test).mean(axis=0)\n\n std_RMSE_tr = np.std(np.array(RMSE_list_per_fold_tr), axis=0)\n std_RMSE_test = np.std(np.array(RMSE_list_per_fold_test), axis=0)\n\n # Choose the eta with lowest RMSE across all folds' testing data\n eta_opt = etas[np.argmin(avg_RMSE_test)]\n\n # Plot RMSE vs. eta for training and testing RMSE\n if plot:\n\n fig, ax = plt.subplots(figsize=(10,10))\n\n plt.errorbar(etas, avg_RMSE_tr, xerr=None, yerr=std_RMSE_tr, linewidth=2, markersize=8, capsize=8, label=('Training'))\n plt.errorbar(etas, avg_RMSE_test, xerr=None, yerr=std_RMSE_test, linewidth=2, markersize=8, capsize=8, label=('Validation'))\n\n plt.plot(eta_opt, np.min(avg_RMSE_test), marker=\"o\", markersize=15, color='black', label=(\"Optimum\"))\n\n plt.xlabel(\"Eta\",fontsize=20)\n plt.ylabel(\"RMSE\",fontsize=20)\n\n # Change size of tick labels\n plt.tick_params(axis='both', labelsize=16)\n\n plt.xscale('log')\n plt.yscale('log')\n\n # Create legend\n plt.legend(loc='upper left')\n\n # Save\n plt.savefig('eta_opt.pdf', format='pdf', dpi=1200)\n\n return eta_opt" + "def optimize_eta(pce, etas, nfolds=3, verbose=0, plot=False):\n \"\"\"\n Choose the optimum eta for Bayesian compressive sensing. Calculates the RMSE\n for each eta for a specified number of folds. Selects the eta with the lowest\n RMSE after averaging the RMSEs over the folds.\n\n Input:\n y: 1D numpy array (vector) with function, evaluated at the\n sample points [#samples,]\n x: N-dimensional NumPy array with sample points [#samples,\n #dimensions]\n etas: NumPy array or list with the threshold for stopping the\n algorithm. Smaller values retain more nonzero\n coefficients\n verbose: Flag for print statements\n plot: Flag for whether to generate a plot for eta optimization\n\n Output:\n eta_opt: Optimum eta\n\n \"\"\"\n # Split data in k folds -> Get dictionary of data split in training + testing folds\n kfold_data = kfold_cv(pce._x_train, pce._y_train, nfolds)\n\n # Each value has data for 1 fold. Each value is a list of the RMSEs for each possible eta in the fold. \n RMSE_list_per_fold_tr = [] \n\n # Same but for testing data\n RMSE_list_per_fold_test = []\n\n # Make a copy of the PCE object to run the cross-validation algorithm on\n pce_copy = copy.deepcopy(pce)\n pce_copy.verbose = 0\n\n # Loop through each fold\n for i in range(nfolds):\n\n # Get the training and validation data\n x_tr = kfold_data[i]['xtrain']\n y_tr = kfold_data[i]['ytrain']\n x_test = kfold_data[i]['xval']\n y_test = kfold_data[i]['yval']\n \n # As we conduct BCS for this fold with each separate eta, the RMSEs will be added to these lists\n RMSE_per_eta_tr = [] \n RMSE_per_eta_test = [] \n\n # Set the x and y training data for the copied PCE object\n pce_copy.set_training_data(x_tr, y_tr)\n\n # Loop through each eta\n for eta in etas:\n\n # Conduct the BCS fitting. The object is automatically updated with new multiindex and coefficients received from the fitting.\n cfs = pce_copy.build(regression = 'bcs', eta=eta)\n\n # Evaluate the PCE object at the training and validation points \n y_tr_eval = (pce_copy.evaluate(x_tr))['Y_eval']\n y_test_eval = (pce_copy.evaluate(x_test))['Y_eval']\n\n # Print statement for verbose flag\n if verbose > 0:\n print(\"Fold \" + str(i + 1) + \", eta \" + str(eta) + \", \" + str(len(cfs)) + \" terms retained out of a full basis of size \" + str(len(pce.pcrv.mindices[0])))\n \n # Calculate the RMSEs for the training and validation points.\n # Append the values into the list of etas per fold.\n MSE = np.square(np.subtract(y_tr, y_tr_eval)).mean()\n RMSE = math.sqrt(MSE)\n RMSE_per_eta_tr.append(RMSE)\n\n MSE = np.square(np.subtract(y_test, y_test_eval)).mean()\n RMSE = math.sqrt(MSE)\n RMSE_per_eta_test.append(RMSE)\n\n # Now, append the fold's list of RMSEs for each eta into the list carrying the lists for all folds \n RMSE_list_per_fold_tr.append(RMSE_per_eta_tr)\n RMSE_list_per_fold_test.append(RMSE_per_eta_test)\n\n # After compiling the RMSE data for each eta from all the folds, we find the eta with the lowest validation RMSE to be our optimal eta.\n # Compute the average and standard deviation of the training and testing RMSEs over the folds\n avg_RMSE_tr = np.array(RMSE_list_per_fold_tr).mean(axis=0)\n avg_RMSE_test = np.array(RMSE_list_per_fold_test).mean(axis=0)\n\n std_RMSE_tr = np.std(np.array(RMSE_list_per_fold_tr), axis=0)\n std_RMSE_test = np.std(np.array(RMSE_list_per_fold_test), axis=0)\n\n # Choose the eta with lowest RMSE across all folds' testing data\n eta_opt = etas[np.argmin(avg_RMSE_test)]\n\n # Plot RMSE vs. eta for training and testing RMSE\n if plot:\n\n fig, ax = plt.subplots(figsize=(10,10))\n\n plt.errorbar(etas, avg_RMSE_tr, xerr=None, yerr=std_RMSE_tr, linewidth=2, markersize=8, capsize=8, label=('Training'))\n plt.errorbar(etas, avg_RMSE_test, xerr=None, yerr=std_RMSE_test, linewidth=2, markersize=8, capsize=8, label=('Validation'))\n\n plt.plot(eta_opt, np.min(avg_RMSE_test), marker=\"o\", markersize=15, color='black', label=(\"Optimum\"))\n\n plt.xlabel(\"Eta\",fontsize=20)\n plt.ylabel(\"RMSE\",fontsize=20)\n\n # Change size of tick labels\n plt.tick_params(axis='both', labelsize=16)\n\n plt.xscale('log')\n plt.yscale('log')\n\n # Create legend\n plt.legend(loc='upper left')\n\n # Save\n plt.savefig('eta_opt.pdf', format='pdf', dpi=1200)\n\n return eta_opt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### BCS build with the most optimal eta\nInstead of using a default eta, here we call the cross-validation algorithm, ``optimize_eta()``, to choose the most optimal eta from a range of etas given below. \n\n- With the flag ``plot=True``, the CV algorithm produces a graph of the training and testing (validation) data's RMSE values for each eta. The eta with the smallest RMSE for the validation data is the one chosen as the optimal eta.\n\n" ] }, { @@ -185,14 +261,14 @@ }, "outputs": [], "source": [ - "# We first create a list of possible etas to pass in: [1e-16, 1e-15, ... , 1e-2, 1e-1, 1]\netas = 1/np.power(10,[i for i in range(0,16)])\n\n# Then, we call the function to choose the optimal eta:\neta_opt = optimize_eta(pce_surr, etas, 10, plot=True)" + "# We first create a list of possible etas to pass in: [1e-16, 1e-15, ... , 1e-2, 1e-1, 1]\netas = 1/np.power(10,[i for i in range(0,16)])\n\n# Then, we call the function to choose the optimal eta:\neta_opt = optimize_eta(pce_surr, etas, nfolds=10, verbose = True, plot=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now, with the optimal eta obtained, we run the fitting again. Then, we evaluate the PCE and produce a parity plot for the predicted output vs. the testing data. \nNotice that the larger eta, 10e-2, retained fewer basis terms (6) compared to the smaller user-defined eta of 10e-10 (which retained 20 basis terms).\n\n" + "From our eta plot above, we can see that our most optimal eta falls at $1 \\times 10^{-10}$, where the validation error is the lowest. While this indicates that the model performs well at this eta value, we can still observe a tendency towards overfitting in the model. For larger eta values, the training and validation RMSE lines are close together, suggesting that the model is performing similarly on both seen and unseen datasets, as would be desired. However, as eta decreases, the training RMSE falls while the validation RMSE rises, highlighting a region where overfitting occurs. \n\nThis behavior is expected because smaller eta values retain more basis terms, increasing the model's degrees of freedom. While this added flexibility allows the model to fit the training data more closely, it also makes the model more prone to fitting noise rather than capturing the true underlying function. Selecting the most optimal eta of $1 \\times 10^{-4}$, as compared to the earlier user-defined eta of $1 \\times 10^{-10}$, allows us to balance model complexity and generalization.\n\nNow, with the optimum eta obtained, we can run the fitting again and produce parity plots for our predicted output.\n\n" ] }, { @@ -203,14 +279,18 @@ }, "outputs": [], "source": [ - "# Build the linear regression object for fitting\npce_surr.build(regression='bcs', eta=eta_opt)\n\n# Optional verbosity output:\nprint(\"Retained Basis and Coefficients:\")\npce_surr.pcrv.printInfo()\nprint(\"Number of retained basis terms:\", len(pce_surr.pcrv.mindices[0]))" + "# Build the linear regression object for fitting\npce_surr.build(regression='bcs', eta=eta_opt)\n\n# Optional verbosity output:\nprint(\"Retained Basis and Coefficients:\")\npce_surr.pcrv.printInfo()\nprint(\"Number of retained basis terms:\", pce_surr.get_pc_terms())" ] }, { - "cell_type": "markdown", - "metadata": {}, + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], "source": [ - "Evaluate the PC model with training and testing data\n\n" + "# Evaluate the PC model with training and testing data\ny_trn_approx = pce_surr.evaluate(value_ksi_trn)\ny_tst_approx = pce_surr.evaluate(value_ksi_tst)" ] }, { @@ -221,14 +301,18 @@ }, "outputs": [], "source": [ - "y_trn_approx = pce_surr.evaluate(x_trn)\ny_tst_approx = pce_surr.evaluate(x_tst)\n\n# Evaluate goodness of fit with RMSE\nrmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx[\"Y_eval\"])\nprint(\"The training RMSE error in the PCE BCS approximation is %.2e\"%rmse_trn)\n\nrmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx[\"Y_eval\"])\nprint(\"The testing RMSE error in the PCE BCS approximation is %.2e\"%rmse_tst)" + "# Plot the surrogate model's output vs. the training data output\ny_tst_mM = [y_trn[:,0].min(),y_trn[:,0].max()]\n\nfig2 = plt.figure(figsize=(8,6))\nax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75])\n\nax2.plot(y_trn[:,0],y_trn_approx[\"Y_eval\"],\".\")\nax2.plot(y_tst_mM,y_tst_mM) # Diagonal line\n\nax2.set_xlabel(\"Train Data y\", size=16)\nax2.set_ylabel(\"Predicted y\", size=16);" ] }, { - "cell_type": "markdown", - "metadata": {}, + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], "source": [ - "While the training RMSE error was almost half that of the testing RMSE error for the first fitting, the RMSE errors here are much closer to each other in value. \nThis suggests that the model has more effectively generalized to the unseen data; a better eta has improved performance.\n\n" + "# Plot the surrogate model's output vs. the testing data output\ny_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()]\n\nfig2 = plt.figure(figsize=(8,6))\nax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75])\n\nax2.plot(y_tst[:,0],y_tst_approx[\"Y_eval\"],\".\")\nax2.plot(y_tst_mM,y_tst_mM) # Diagonal line\n\nax2.set_xlabel(\"Test Data y\", size=16)\nax2.set_ylabel(\"Predicted y\", size=16);" ] }, { @@ -239,7 +323,14 @@ }, "outputs": [], "source": [ - "# Plot the surrogate model's output vs. the testing data output\ny_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()]\n\n\nfig2 = plt.figure(figsize=(8,6))\nax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75])\n\n\nax2.plot(y_tst[:,0],y_tst_approx[\"Y_eval\"],\".\")\nax2.plot(y_tst_mM,y_tst_mM) # Diagonal line\n\nax2.set_xlabel(\"Test Data y\", size=16)\nax2.set_ylabel(\"Predicted y\", size=16); \n\n# sphinx_gallery_thumbnail_number = 2" + "# Evaluate goodness of fit with RMSE\nrmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx[\"Y_eval\"])\nprint(\"The training RMSE in the PCE BCS approximation is %.2e\"%rmse_trn)\n\nrmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx[\"Y_eval\"])\nprint(\"The testing RMSE in the PCE BCS approximation is %.2e\"%rmse_tst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In these final RMSE calculations, we can see how our training RMSE has decreased from 1.80e-02 to 1.21e-02 by building with the most optimal eta. This indicates that our model has improved in generalization and is performing better on unseen data. Though our training error is still larger than our testing error, this can be attributed to the lack of noise in our testing data, while noise is present in our training data. While the optimal eta reduces overfitting and improves generalization, the noise in our training data still impacts the training error and remains an important consideration during our evaluation of the model performance.\n\nWhile this demonstration calls the cross-validation algorithm as a function outside of the PCE class, these methods have been implemented in PyTUQ through the PCE class. The example \"Polynomial Chaos Expansion Construction\" demonstrates how to call the eta optimization methods directly from the PCE class.\n\n" ] } ], diff --git a/docs/auto_examples/ex_genz_bcs.py b/docs/auto_examples/ex_genz_bcs.py index 1dd7b14..e186469 100644 --- a/docs/auto_examples/ex_genz_bcs.py +++ b/docs/auto_examples/ex_genz_bcs.py @@ -16,10 +16,15 @@ - :math:`x_i`: The input variables. - :math:`d`: The dimensionality of the input :math:`x` (number of components in :math:`x`). -Through 2 different build processes, we will construct two different PC surrogates to demonstrate effects of the BCS eta hyperparameter on model results. -The first build process will demonstrate most simply the construct-build-evaluate process when using BCS for our PC surrogate, along with a given a eta of 1e-10. -The second build process will select the most optimal eta for BCS through cross-validation algorithms (exposed here), which will soon be implemented in PyTUQ under-the-hood. -Afterwards, we will evaluate both models on testing and training data, returning parity plots and a Root Mean Square Error for each evaluation. +Through three different build processes, we will construct three PC surrogates to highlight the advantages of BCS and explore the effects of the `eta` hyperparameter on model results. + +First, we'll build with least squares regression to demonstrate the limitations of non-sparse methods and the need for BCS. +Then we'll build with BCS using a given eta of :math:`1 \times 10^{-10}` and identify aspects for model improvement. +Last, we'll build with the most optimal eta, as found through cross-validation algorithms exposed here. All three surrogates will be evaluated on testing and training data, +with parity plots and Root Mean Square Error (RMSE) values used to compare their performance. + +To follow along with the cross-validation algorithm for selecting the optimal eta, see section "Functions for cross-validation algorithm" in the second half of the notebook. +These methods have been implemented under-the-hood in PyTUQ. Refer to example "Polynomial Chaos Expansion Construction" (``ex_pce.py``) for a demonstration of how to use these methods through a direct call to the PCE class. """ # %% @@ -34,44 +39,55 @@ from sklearn.metrics import root_mean_squared_error from pytuq.surrogates.pce import PCE -from pytuq.utils.maps import scale01ToDom +from pytuq.utils.maps import scaleDomTo01 from pytuq.func.genz import GenzOscillatory # %% -# Setting a random number generator seed: +# Constructing PC surrogate and generating data +# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +# To start, we begin with defining our true model and input parameters for our PC surrogate. +# +# After importing GenzOscillatory from ``pytuq.func.genz``, we generate the Genz function below, +# along with training data and testing data with output noise. This data and the corresponding Genz function +# will be used to create the same PC surrogate fitted in all three examples: first with linear regression, +# next using BCS with a given eta, and third using BCS with the most optimal eta. + +# %% # Random number generator from scipy.stats import qmc rng_seed = 43 # %% -# Constructing PC surrogate and generating data -# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -# After importing GenzOscillatory from ``pytuq.func.genz``, we generate the Genz function below, along with training data and testing data with output noise. -# This data and the corresponding Genz function will be used to create the same PC surrogate fitted in both examples: -# (1) The first surrogate will be fitted using BCS with a given eta, and (2) the second surrogate will be fitted using BCS with the most optimal eta. -# Use Genz Oscillatory function in multiple dimensions for the true model +# Define our true model as the Genz Oscillatory function in multiple dimensions func_dim = 4 -func_weights = [1.0/(i+1)**2 for i in range(func_dim)] +func_weights = [1.0/(i+1)**2 for i in range(func_dim)] func = GenzOscillatory(shift=0.25, weights=func_weights) -noise_std = 0.1 +noise_std = 0.025 + rng = qmc.LatinHypercube(d=func_dim, seed=rng_seed) +np.random.seed(42) + +# As we choose to use Legendre polynomials later in the surrogate construction, we define the domain of ξ on [-1, 1]^d +ksi_domain = np.array([[-1.0, 1.0]] * func_dim) # Training data -np.random.seed(42) n_trn = 70 -x_trn = rng.random(n=n_trn) # random numbers in [0,1]^d -y_trn = func(x_trn) + np.random.normal(0, noise_std, size = (n_trn,1)) +value_ksi_trn = 2*rng.random(n=n_trn) - 1 # Randomly generating 70 data points within the domain of ξ (ksi) +x_trn = scaleDomTo01(value_ksi_trn, ksi_domain) # We scale our training data to [0, 1]^d, the domain of the Genz function +y_trn = func(x_trn) + np.random.normal(0, noise_std, size = (n_trn, 1)) # Testing data n_tst = 10000 -x_tst = rng.random(n=n_tst) # random numbers in [0,1]^d -y_tst = func(x_tst) + np.random.normal(0, noise_std, size = (n_tst,1)) +value_ksi_tst = 2*rng.random(n=n_tst) - 1 +x_tst = scaleDomTo01(value_ksi_tst, ksi_domain) +y_tst = func(x_tst) # %% -# With a stochastic dimensionality of 4 (defined above) and a polynomial order of 4, we construct the PC surrogate that will be used in both builds. -# You have the option of printing the PC surrogate's full basis, before BCS selects and retains the most significant PC coefficients to reduce the basis. +# With a stochastic dimensionality of 4 (defined above) and a chosen polynomial order of 4, we construct the PC surrogate that +# will be used in both builds. By calling the ``printInfo()`` method from the PCRV variable, you can print the PC surrogate's +# full basis and current coefficients, before BCS selects and retains the most significant PC terms to reduce the basis. # (1) Construct a PC surrogate order = 4 @@ -80,16 +96,79 @@ # Optional verbosity output: print("Full Basis and Current Coefficients:") pce_surr.pcrv.printInfo() -print("Number of Basis Terms:", len(pce_surr.pcrv.mindices[0])) +print("Number of Basis Terms:", pce_surr.get_pc_terms()) # (1.5) Set training data -pce_surr.set_training_data(x_trn, y_trn[:,0]) +pce_surr.set_training_data(value_ksi_trn, y_trn[:,0]) + +# %% +# From the input parameters of our PC surrogate, we have 70 basis terms in our PCE. With 70 training points and no noise, having 70 basis terms would mean that we have a fully determined system, as the number of training points is the same as the number of basis terms. However, with the addition of noise in our training data, it becomes harder for the model to accurately fit all basis terms, leading to potential overfitting. This demonstrates the helpful role BCS might play as a choice for our regression build. As a sparse regression approach, BCS uses regularization to select only the most relevant basis terms, making it particularly effective in situations like this, where we do not have enough clear information to fit all basis terms without overfitting. +# +# In the next sections, we will explore the effects of overfitting in more detail. + +# %% +# Least Squares Regression +# ^^^^^^^^^^^^^^^^^^^^^^^^^ +# To start, we call the PCE class method of ``build()`` with no arguments to use the default regression option of least squares. Then, through ``evaluate()``, we can generate model predictions for our training and testing data. + +# %% + +# (2) Build the linear regression object for fitting +pce_surr.build() + +# (3) Evaluate the PC model +y_trn_approx = pce_surr.evaluate(value_ksi_trn) +y_tst_approx = pce_surr.evaluate(value_ksi_tst) + +# %% + +# Plot the surrogate model's output vs. the training data output +y_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()] + +fig1 = plt.figure(figsize=(8,6)) +ax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75]) + +ax1.plot(y_trn[:,0],y_trn_approx["Y_eval"],".") +ax1.plot(y_trn_mM,y_trn_mM) # Diagonal line + +ax1.set_xlabel("Train Data y", size=16) +ax1.set_ylabel("Predicted y", size=16); + +# %% + +# Plot the surrogate model's output vs. the testing data output + +y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()] + + +fig2 = plt.figure(figsize=(8,6)) +ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) + + +ax2.plot(y_tst[:,0],y_tst_approx["Y_eval"],".") +ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line + +ax2.set_xlabel("Test Data y", size=16) +ax2.set_ylabel("Predicted y", size=16); + +# %% + +# Evaluate goodness of fit with RMSE +rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) +print("The training RMSE in the PCE LSQ approximation is %.2e"%rmse_trn) + +rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) +print("The testing RMSE in the PCE LSQ approximation is %.2e"%rmse_tst) + +# %% +# The results above show us the limitations of using least squares regression to construct our surrogate. From the parity plots, we can see how the testing predictions from the LSQ regression are more spread out from the parity line, while the training predictions are extremely close to the line. Because LSQ fits all the basis terms to the training data, the model fits too closely to the noisy training dataset, and the true underlying pattern of the function is not effectively captured. Our RMSE values align with this as well: while the training RMSE is extremely low, the testing RMSE is significantly higher, as the model struggles to generalize to the unseen test data. +# +# To improve our model's generalization, we can build our model with BCS instead. As a sparse regression method, BCS reduces the number of basis terms with which we can fit our data to, reducing the risk of overfitting. # %% # BCS with default settings (default eta) # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -# Here, we call the PCE class method of ``build()`` to build the linear regression model used to fit the surrogate. -# With the flag ``regression='bcs'``, we choose the BCS method for the fitting. A user-defined eta of 1e-10 is also passed in. +# In this section, we use the same PC surrogate, ``pce_surr``, for the second build. With the flag ``regression='bcs'``, we choose the BCS method for the fitting. A user-defined eta of 1e-10 is also passed in. # (2) Build the linear regression object for fitting pce_surr.build(regression='bcs', eta=1.e-10) @@ -97,36 +176,23 @@ # Optional verbosity output: print("Retained Basis and Coefficients:") pce_surr.pcrv.printInfo() -print("Number of retained basis terms:", len(pce_surr.pcrv.mindices[0])) +print("Number of retained basis terms:", pce_surr.get_pc_terms()) # %% -# After fitting, we evaluate the PCE using our training and testing data. To analyze the model's goodness of fit, -# we calculate the root mean square error between the surrogate results and the training and testing data. +# After fitting, we evaluate the PCE using our training and testing data. To analyze the model's goodness of fit, we first plot the surrogate predictions against the training and testing data respectively. # (3) Evaluate the PC model -y_trn_approx = pce_surr.evaluate(x_trn) -y_tst_approx = pce_surr.evaluate(x_tst) - -# Evaluate goodness of fit with RMSE -rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) -print("The training RMSE error in the PCE BCS approximation is %.2e"%rmse_trn) - -rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) -print("The testing RMSE error in the PCE BCS approximation is %.2e"%rmse_tst) +y_trn_approx = pce_surr.evaluate(value_ksi_trn) +y_tst_approx = pce_surr.evaluate(value_ksi_tst) # %% -# Notice above how the training RMSE error is almost half that of the testing RMSE error. This shows that our current model is overfitting, -# learning the training data with noise too well. To address this issue, we can explore selecting a better eta for the BCS fitting. # Plot the surrogate model's output vs. the training data output - y_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()] - fig1 = plt.figure(figsize=(8,6)) ax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75]) - ax1.plot(y_trn[:,0],y_trn_approx["Y_eval"],".") ax1.plot(y_trn_mM,y_trn_mM) # Diagonal line @@ -139,30 +205,41 @@ y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()] - fig2 = plt.figure(figsize=(8,6)) ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) - ax2.plot(y_tst[:,0],y_tst_approx["Y_eval"],".") ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line ax2.set_xlabel("Test Data y", size=16) ax2.set_ylabel("Predicted y", size=16); +# sphinx_gallery_thumbnail_number = 2 + +# %% + +# Evaluate goodness of fit with RMSE +rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) +print("The training RMSE in the PCE BCS approximation is %.2e"%rmse_trn) + +rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) +print("The testing RMSE in the PCE BCS approximation is %.2e"%rmse_tst) + +# %% +# From our parity plots, we can see how BCS already generalizes better to unseen data as compared to LSQ, with reduced error in our testing data predictions. In our RMSE calculations, notice how the training error is smaller than the testing error. Though the difference in value is small, this amount is still significant as we have noise in our training data yet no noise in our testing data. That the testing error is higher than the training error suggests that overfitting is still happening within our model. +# +# In the next section, we explore how finding the optimal value of eta -- the stopping criterion for the BCS parameter of gamma, determined through a Bayesian evidence maximization approach -- can impact model sparsity and accuracy to avoid overfitting. + + # %% # BCS with optimal eta (found through cross-validation) # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -# In this section, we use the same PC surrogate, ``pce_surr``, for the second build. We call the PCE class method of ``build()`` -# to build the linear regression model used to fit the surrogate. With the flag ``regression='bcs'``, we choose the BCS method for the fitting. -# -############################################################################## -# Instead of using a default eta, we call the cross-validation algorithm, ``optimize_eta()``, to choose the most optimal eta below. +# Before we build our PC surrogate again with the most optimal eta, we first expose the cross-validation algorithm ``optimize_eta`` and its two helper functions, ``kfold_split`` and ``kfold_cv`` below. These functions have been implemented under-the-hood in the PCE surrogate class, but for the purposes of this tutorial, you may find it useful to follow along with the K-fold cross-validation method used to find the most optimal eta (the eta with the lowest validation RMSE across all of its folds). # -# - With the flag ``plot=True``, the CV algorithm produces a graph of the training and testing (validation) data's RMSE values for each eta. The eta with the smallest RMSE for the validation data is the one chosen as the optimal eta. -# -############################################################################## -# Before that, we expose the cross-validation algorithm ``optimize_eta`` and its two helper functions, ``kfold_split`` and ``kfold_cv`` that will be called in this section. +# Functions for cross-validation algorithm +# +++++++++++++++++++++++++++++++++++++++++ + +# %% def kfold_split(nsamples,nfolds,seed=13): """ @@ -251,7 +328,8 @@ def kfold_cv(x,y,nfolds=3,seed=13): return kfold_data # %% -def optimize_eta(pce, etas, nfolds, verbose=0, plot=False): + +def optimize_eta(pce, etas, nfolds=3, verbose=0, plot=False): """ Choose the optimum eta for Bayesian compressive sensing. Calculates the RMSE for each eta for a specified number of folds. Selects the eta with the lowest @@ -312,7 +390,7 @@ def optimize_eta(pce, etas, nfolds, verbose=0, plot=False): y_test_eval = (pce_copy.evaluate(x_test))['Y_eval'] # Print statement for verbose flag - if verbose > 1: + if verbose > 0: print("Fold " + str(i + 1) + ", eta " + str(eta) + ", " + str(len(cfs)) + " terms retained out of a full basis of size " + str(len(pce.pcrv.mindices[0]))) # Calculate the RMSEs for the training and validation points. @@ -368,16 +446,24 @@ def optimize_eta(pce, etas, nfolds, verbose=0, plot=False): return eta_opt # %% +# BCS build with the most optimal eta +# +++++++++++++++++++++++++++++++++++++ +# Instead of using a default eta, here we call the cross-validation algorithm, ``optimize_eta()``, to choose the most optimal eta from a range of etas given below. +# +# - With the flag ``plot=True``, the CV algorithm produces a graph of the training and testing (validation) data's RMSE values for each eta. The eta with the smallest RMSE for the validation data is the one chosen as the optimal eta. # We first create a list of possible etas to pass in: [1e-16, 1e-15, ... , 1e-2, 1e-1, 1] etas = 1/np.power(10,[i for i in range(0,16)]) # Then, we call the function to choose the optimal eta: -eta_opt = optimize_eta(pce_surr, etas, 10, plot=True) +eta_opt = optimize_eta(pce_surr, etas, nfolds=10, verbose = True, plot=True) # %% -# Now, with the optimal eta obtained, we run the fitting again. Then, we evaluate the PCE and produce a parity plot for the predicted output vs. the testing data. -# Notice that the larger eta, 10e-2, retained fewer basis terms (6) compared to the smaller user-defined eta of 10e-10 (which retained 20 basis terms). +# From our eta plot above, we can see that our most optimal eta falls at :math:`1 \times 10^{-10}`, where the validation error is the lowest. While this indicates that the model performs well at this eta value, we can still observe a tendency towards overfitting in the model. For larger eta values, the training and validation RMSE lines are close together, suggesting that the model is performing similarly on both seen and unseen datasets, as would be desired. However, as eta decreases, the training RMSE falls while the validation RMSE rises, highlighting a region where overfitting occurs. +# +# This behavior is expected because smaller eta values retain more basis terms, increasing the model's degrees of freedom. While this added flexibility allows the model to fit the training data more closely, it also makes the model more prone to fitting noise rather than capturing the true underlying function. Selecting the most optimal eta of :math:`1 \times 10^{-4}`, as compared to the earlier user-defined eta of :math:`1 \times 10^{-10}`, allows us to balance model complexity and generalization. +# +# Now, with the optimum eta obtained, we can run the fitting again and produce parity plots for our predicted output. # Build the linear regression object for fitting pce_surr.build(regression='bcs', eta=eta_opt) @@ -385,36 +471,53 @@ def optimize_eta(pce, etas, nfolds, verbose=0, plot=False): # Optional verbosity output: print("Retained Basis and Coefficients:") pce_surr.pcrv.printInfo() -print("Number of retained basis terms:", len(pce_surr.pcrv.mindices[0])) +print("Number of retained basis terms:", pce_surr.get_pc_terms()) # %% + # Evaluate the PC model with training and testing data -y_trn_approx = pce_surr.evaluate(x_trn) -y_tst_approx = pce_surr.evaluate(x_tst) +y_trn_approx = pce_surr.evaluate(value_ksi_trn) +y_tst_approx = pce_surr.evaluate(value_ksi_tst) -# Evaluate goodness of fit with RMSE -rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) -print("The training RMSE error in the PCE BCS approximation is %.2e"%rmse_trn) +# %% -rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) -print("The testing RMSE error in the PCE BCS approximation is %.2e"%rmse_tst) +# Plot the surrogate model's output vs. the training data output +y_tst_mM = [y_trn[:,0].min(),y_trn[:,0].max()] + +fig2 = plt.figure(figsize=(8,6)) +ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) + +ax2.plot(y_trn[:,0],y_trn_approx["Y_eval"],".") +ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line + +ax2.set_xlabel("Train Data y", size=16) +ax2.set_ylabel("Predicted y", size=16); # %% -# While the training RMSE error was almost half that of the testing RMSE error for the first fitting, the RMSE errors here are much closer to each other in value. -# This suggests that the model has more effectively generalized to the unseen data; a better eta has improved performance. # Plot the surrogate model's output vs. the testing data output y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()] - fig2 = plt.figure(figsize=(8,6)) ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) - ax2.plot(y_tst[:,0],y_tst_approx["Y_eval"],".") ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line ax2.set_xlabel("Test Data y", size=16) ax2.set_ylabel("Predicted y", size=16); -# sphinx_gallery_thumbnail_number = 2 \ No newline at end of file +# %% + +# Evaluate goodness of fit with RMSE +rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) +print("The training RMSE in the PCE BCS approximation is %.2e"%rmse_trn) + +rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) +print("The testing RMSE in the PCE BCS approximation is %.2e"%rmse_tst) + +# %% +# +# In these final RMSE calculations, we can see how our training RMSE has decreased from 1.80e-02 to 1.21e-02 by building with the most optimal eta. This indicates that our model has improved in generalization and is performing better on unseen data. Though our training error is still larger than our testing error, this can be attributed to the lack of noise in our testing data, while noise is present in our training data. While the optimal eta reduces overfitting and improves generalization, the noise in our training data still impacts the training error and remains an important consideration during our evaluation of the model performance. +# +# While this demonstration calls the cross-validation algorithm as a function outside of the PCE class, these methods have been implemented in PyTUQ through the PCE class. The example "Polynomial Chaos Expansion Construction" demonstrates how to call the eta optimization methods directly from the PCE class. diff --git a/docs/auto_examples/ex_genz_bcs.py.md5 b/docs/auto_examples/ex_genz_bcs.py.md5 index 1ae0028..2aa64b0 100644 --- a/docs/auto_examples/ex_genz_bcs.py.md5 +++ b/docs/auto_examples/ex_genz_bcs.py.md5 @@ -1 +1 @@ -f4d64dfb6a6e4bd8172e2db42886d735 \ No newline at end of file +5470448baa785fa7c8ecd0b4922b46bd \ No newline at end of file diff --git a/docs/auto_examples/ex_genz_bcs.rst b/docs/auto_examples/ex_genz_bcs.rst index d32031f..a747f77 100644 --- a/docs/auto_examples/ex_genz_bcs.rst +++ b/docs/auto_examples/ex_genz_bcs.rst @@ -35,12 +35,17 @@ Where: - :math:`x_i`: The input variables. - :math:`d`: The dimensionality of the input :math:`x` (number of components in :math:`x`). -Through 2 different build processes, we will construct two different PC surrogates to demonstrate effects of the BCS eta hyperparameter on model results. -The first build process will demonstrate most simply the construct-build-evaluate process when using BCS for our PC surrogate, along with a given a eta of 1e-10. -The second build process will select the most optimal eta for BCS through cross-validation algorithms (exposed here), which will soon be implemented in PyTUQ under-the-hood. -Afterwards, we will evaluate both models on testing and training data, returning parity plots and a Root Mean Square Error for each evaluation. +Through three different build processes, we will construct three PC surrogates to highlight the advantages of BCS and explore the effects of the `eta` hyperparameter on model results. -.. GENERATED FROM PYTHON SOURCE LINES 25-40 +First, we'll build with least squares regression to demonstrate the limitations of non-sparse methods and the need for BCS. +Then we'll build with BCS using a given eta of :math:`1 \times 10^{-10}` and identify aspects for model improvement. +Last, we'll build with the most optimal eta, as found through cross-validation algorithms exposed here. All three surrogates will be evaluated on testing and training data, +with parity plots and Root Mean Square Error (RMSE) values used to compare their performance. + +To follow along with the cross-validation algorithm for selecting the optimal eta, see section "Functions for cross-validation algorithm" in the second half of the notebook. +These methods have been implemented under-the-hood in PyTUQ. Refer to example "Polynomial Chaos Expansion Construction" (``ex_pce.py``) for a demonstration of how to use these methods through a direct call to the PCE class. + +.. GENERATED FROM PYTHON SOURCE LINES 30-45 .. code-block:: Python @@ -56,7 +61,7 @@ Afterwards, we will evaluate both models on testing and training data, returning from sklearn.metrics import root_mean_squared_error from pytuq.surrogates.pce import PCE - from pytuq.utils.maps import scale01ToDom + from pytuq.utils.maps import scaleDomTo01 from pytuq.func.genz import GenzOscillatory @@ -66,11 +71,18 @@ Afterwards, we will evaluate both models on testing and training data, returning -.. GENERATED FROM PYTHON SOURCE LINES 41-42 +.. GENERATED FROM PYTHON SOURCE LINES 46-54 + +Constructing PC surrogate and generating data +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +To start, we begin with defining our true model and input parameters for our PC surrogate. -Setting a random number generator seed: +After importing GenzOscillatory from ``pytuq.func.genz``, we generate the Genz function below, +along with training data and testing data with output noise. This data and the corresponding Genz function +will be used to create the same PC surrogate fitted in all three examples: first with linear regression, +next using BCS with a given eta, and third using BCS with the most optimal eta. -.. GENERATED FROM PYTHON SOURCE LINES 42-47 +.. GENERATED FROM PYTHON SOURCE LINES 56-61 .. code-block:: Python @@ -86,36 +98,34 @@ Setting a random number generator seed: -.. GENERATED FROM PYTHON SOURCE LINES 48-53 - -Constructing PC surrogate and generating data -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -After importing GenzOscillatory from ``pytuq.func.genz``, we generate the Genz function below, along with training data and testing data with output noise. -This data and the corresponding Genz function will be used to create the same PC surrogate fitted in both examples: -(1) The first surrogate will be fitted using BCS with a given eta, and (2) the second surrogate will be fitted using BCS with the most optimal eta. - -.. GENERATED FROM PYTHON SOURCE LINES 53-72 +.. GENERATED FROM PYTHON SOURCE LINES 62-87 .. code-block:: Python - # Use Genz Oscillatory function in multiple dimensions for the true model + # Define our true model as the Genz Oscillatory function in multiple dimensions func_dim = 4 - func_weights = [1.0/(i+1)**2 for i in range(func_dim)] + func_weights = [1.0/(i+1)**2 for i in range(func_dim)] func = GenzOscillatory(shift=0.25, weights=func_weights) - noise_std = 0.1 + noise_std = 0.025 + rng = qmc.LatinHypercube(d=func_dim, seed=rng_seed) + np.random.seed(42) + + # As we choose to use Legendre polynomials later in the surrogate construction, we define the domain of ξ on [-1, 1]^d + ksi_domain = np.array([[-1.0, 1.0]] * func_dim) # Training data - np.random.seed(42) n_trn = 70 - x_trn = rng.random(n=n_trn) # random numbers in [0,1]^d - y_trn = func(x_trn) + np.random.normal(0, noise_std, size = (n_trn,1)) + value_ksi_trn = 2*rng.random(n=n_trn) - 1 # Randomly generating 70 data points within the domain of ξ (ksi) + x_trn = scaleDomTo01(value_ksi_trn, ksi_domain) # We scale our training data to [0, 1]^d, the domain of the Genz function + y_trn = func(x_trn) + np.random.normal(0, noise_std, size = (n_trn, 1)) # Testing data n_tst = 10000 - x_tst = rng.random(n=n_tst) # random numbers in [0,1]^d - y_tst = func(x_tst) + np.random.normal(0, noise_std, size = (n_tst,1)) + value_ksi_tst = 2*rng.random(n=n_tst) - 1 + x_tst = scaleDomTo01(value_ksi_tst, ksi_domain) + y_tst = func(x_tst) @@ -124,12 +134,13 @@ This data and the corresponding Genz function will be used to create the same PC -.. GENERATED FROM PYTHON SOURCE LINES 73-75 +.. GENERATED FROM PYTHON SOURCE LINES 88-91 -With a stochastic dimensionality of 4 (defined above) and a polynomial order of 4, we construct the PC surrogate that will be used in both builds. -You have the option of printing the PC surrogate's full basis, before BCS selects and retains the most significant PC coefficients to reduce the basis. +With a stochastic dimensionality of 4 (defined above) and a chosen polynomial order of 4, we construct the PC surrogate that +will be used in both builds. By calling the ``printInfo()`` method from the PCRV variable, you can print the PC surrogate's +full basis and current coefficients, before BCS selects and retains the most significant PC terms to reduce the basis. -.. GENERATED FROM PYTHON SOURCE LINES 75-88 +.. GENERATED FROM PYTHON SOURCE LINES 91-104 .. code-block:: Python @@ -141,10 +152,10 @@ You have the option of printing the PC surrogate's full basis, before BCS select # Optional verbosity output: print("Full Basis and Current Coefficients:") pce_surr.pcrv.printInfo() - print("Number of Basis Terms:", len(pce_surr.pcrv.mindices[0])) + print("Number of Basis Terms:", pce_surr.get_pc_terms()) # (1.5) Set training data - pce_surr.set_training_data(x_trn, y_trn[:,0]) + pce_surr.set_training_data(value_ksi_trn, y_trn[:,0]) @@ -230,30 +241,34 @@ You have the option of printing the PC surrogate's full basis, before BCS select [0 0 0 4]] [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] - Number of Basis Terms: 70 + Number of Basis Terms: [70] -.. GENERATED FROM PYTHON SOURCE LINES 89-93 +.. GENERATED FROM PYTHON SOURCE LINES 105-108 -BCS with default settings (default eta) -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Here, we call the PCE class method of ``build()`` to build the linear regression model used to fit the surrogate. -With the flag ``regression='bcs'``, we choose the BCS method for the fitting. A user-defined eta of 1e-10 is also passed in. +From the input parameters of our PC surrogate, we have 70 basis terms in our PCE. With 70 training points and no noise, having 70 basis terms would mean that we have a fully determined system, as the number of training points is the same as the number of basis terms. However, with the addition of noise in our training data, it becomes harder for the model to accurately fit all basis terms, leading to potential overfitting. This demonstrates the helpful role BCS might play as a choice for our regression build. As a sparse regression approach, BCS uses regularization to select only the most relevant basis terms, making it particularly effective in situations like this, where we do not have enough clear information to fit all basis terms without overfitting. + +In the next sections, we will explore the effects of overfitting in more detail. + +.. GENERATED FROM PYTHON SOURCE LINES 110-113 + +Least Squares Regression +^^^^^^^^^^^^^^^^^^^^^^^^^ +To start, we call the PCE class method of ``build()`` with no arguments to use the default regression option of least squares. Then, through ``evaluate()``, we can generate model predictions for our training and testing data. -.. GENERATED FROM PYTHON SOURCE LINES 93-102 +.. GENERATED FROM PYTHON SOURCE LINES 115-123 .. code-block:: Python # (2) Build the linear regression object for fitting - pce_surr.build(regression='bcs', eta=1.e-10) + pce_surr.build() - # Optional verbosity output: - print("Retained Basis and Coefficients:") - pce_surr.pcrv.printInfo() - print("Number of retained basis terms:", len(pce_surr.pcrv.mindices[0])) + # (3) Evaluate the PC model + y_trn_approx = pce_surr.evaluate(value_ksi_trn) + y_tst_approx = pce_surr.evaluate(value_ksi_tst) @@ -263,57 +278,95 @@ With the flag ``regression='bcs'``, we choose the BCS method for the fitting. A .. code-block:: none - Regression method: bcs - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - Retained Basis and Coefficients: - [[2 0 0 0] - [1 0 3 0] - [0 2 0 2] - [0 0 1 2] - [4 0 0 0] - [3 1 0 0] - [1 1 0 1] - [2 0 0 2] - [2 0 1 1] - [0 0 0 4] - [1 0 0 3] - [0 0 0 1] - [1 1 0 0] - [1 0 0 1] - [0 3 1 0] - [0 1 0 2] - [0 1 1 2] - [2 0 2 0] - [0 1 0 1] - [0 0 0 0]] [ 0.11844696 -0.1286659 -0.23890894 0.20561299 -0.65563148 1.41773821 - -0.20218904 -0.30625401 0.40503892 -0.27250245 0.99544673 -0.90463019 - -2.75925351 -0.66386396 0.13068211 -0.96868699 -0.65718534 -0.27253516 - 3.07988105 0.12550357] - Number of retained basis terms: 20 + Regression method: lsq + + + + +.. GENERATED FROM PYTHON SOURCE LINES 124-137 + +.. code-block:: Python + + + # Plot the surrogate model's output vs. the training data output + y_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()] + + fig1 = plt.figure(figsize=(8,6)) + ax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75]) + + ax1.plot(y_trn[:,0],y_trn_approx["Y_eval"],".") + ax1.plot(y_trn_mM,y_trn_mM) # Diagonal line + + ax1.set_xlabel("Train Data y", size=16) + ax1.set_ylabel("Predicted y", size=16); + + + + +.. image-sg:: /auto_examples/images/sphx_glr_ex_genz_bcs_001.png + :alt: ex genz bcs + :srcset: /auto_examples/images/sphx_glr_ex_genz_bcs_001.png + :class: sphx-glr-single-img + + +.. rst-class:: sphx-glr-script-out + .. code-block:: none + Text(71.09722222222221, 0.5, 'Predicted y') -.. GENERATED FROM PYTHON SOURCE LINES 103-105 -After fitting, we evaluate the PCE using our training and testing data. To analyze the model's goodness of fit, -we calculate the root mean square error between the surrogate results and the training and testing data. -.. GENERATED FROM PYTHON SOURCE LINES 105-117 +.. GENERATED FROM PYTHON SOURCE LINES 138-154 .. code-block:: Python - # (3) Evaluate the PC model - y_trn_approx = pce_surr.evaluate(x_trn) - y_tst_approx = pce_surr.evaluate(x_tst) + # Plot the surrogate model's output vs. the testing data output + + y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()] + + + fig2 = plt.figure(figsize=(8,6)) + ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) + + + ax2.plot(y_tst[:,0],y_tst_approx["Y_eval"],".") + ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line + + ax2.set_xlabel("Test Data y", size=16) + ax2.set_ylabel("Predicted y", size=16); + + + + +.. image-sg:: /auto_examples/images/sphx_glr_ex_genz_bcs_002.png + :alt: ex genz bcs + :srcset: /auto_examples/images/sphx_glr_ex_genz_bcs_002.png + :class: sphx-glr-single-img + + +.. rst-class:: sphx-glr-script-out + + .. code-block:: none + + + Text(84.34722222222221, 0.5, 'Predicted y') + + + +.. GENERATED FROM PYTHON SOURCE LINES 155-163 + +.. code-block:: Python + # Evaluate goodness of fit with RMSE rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) - print("The training RMSE error in the PCE BCS approximation is %.2e"%rmse_trn) + print("The training RMSE in the PCE LSQ approximation is %.2e"%rmse_trn) rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) - print("The testing RMSE error in the PCE BCS approximation is %.2e"%rmse_tst) + print("The testing RMSE in the PCE LSQ approximation is %.2e"%rmse_tst) @@ -323,31 +376,102 @@ we calculate the root mean square error between the surrogate results and the tr .. code-block:: none - The training RMSE error in the PCE BCS approximation is 1.72e-01 - The testing RMSE error in the PCE BCS approximation is 2.73e-01 + The training RMSE in the PCE LSQ approximation is 1.91e-15 + The testing RMSE in the PCE LSQ approximation is 9.22e-01 + +.. GENERATED FROM PYTHON SOURCE LINES 164-167 -.. GENERATED FROM PYTHON SOURCE LINES 118-120 +The results above show us the limitations of using least squares regression to construct our surrogate. From the parity plots, we can see how the testing predictions from the LSQ regression are more spread out from the parity line, while the training predictions are extremely close to the line. Because LSQ fits all the basis terms to the training data, the model fits too closely to the noisy training dataset, and the true underlying pattern of the function is not effectively captured. Our RMSE values align with this as well: while the training RMSE is extremely low, the testing RMSE is significantly higher, as the model struggles to generalize to the unseen test data. -Notice above how the training RMSE error is almost half that of the testing RMSE error. This shows that our current model is overfitting, -learning the training data with noise too well. To address this issue, we can explore selecting a better eta for the BCS fitting. +To improve our model's generalization, we can build our model with BCS instead. As a sparse regression method, BCS reduces the number of basis terms with which we can fit our data to, reducing the risk of overfitting. -.. GENERATED FROM PYTHON SOURCE LINES 120-136 +.. GENERATED FROM PYTHON SOURCE LINES 169-172 + +BCS with default settings (default eta) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +In this section, we use the same PC surrogate, ``pce_surr``, for the second build. With the flag ``regression='bcs'``, we choose the BCS method for the fitting. A user-defined eta of 1e-10 is also passed in. + +.. GENERATED FROM PYTHON SOURCE LINES 172-181 .. code-block:: Python - # Plot the surrogate model's output vs. the training data output + # (2) Build the linear regression object for fitting + pce_surr.build(regression='bcs', eta=1.e-10) + + # Optional verbosity output: + print("Retained Basis and Coefficients:") + pce_surr.pcrv.printInfo() + print("Number of retained basis terms:", pce_surr.get_pc_terms()) + + + - y_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()] +.. rst-class:: sphx-glr-script-out + + .. code-block:: none + + Regression method: bcs + Retained Basis and Coefficients: + [[0 0 0 0] + [1 0 0 0] + [0 1 0 0] + [0 0 0 1] + [2 0 0 0] + [0 0 1 0] + [1 1 0 0] + [2 1 0 0] + [0 4 0 0] + [0 0 3 0] + [2 0 2 0] + [1 0 0 2] + [2 1 1 0] + [1 0 2 0] + [1 2 1 0] + [1 2 0 1] + [1 0 0 3]] [-0.62694767 -0.37426547 -0.08797315 -0.02795855 0.04176134 -0.03783695 + 0.01375504 0.02559825 -0.01616989 -0.01758198 -0.02274328 0.01132392 + -0.01835694 -0.00490663 -0.00938681 -0.00898039 0.00175116] + Number of retained basis terms: [17] + + + + +.. GENERATED FROM PYTHON SOURCE LINES 182-183 + +After fitting, we evaluate the PCE using our training and testing data. To analyze the model's goodness of fit, we first plot the surrogate predictions against the training and testing data respectively. + +.. GENERATED FROM PYTHON SOURCE LINES 183-188 + +.. code-block:: Python + + + # (3) Evaluate the PC model + y_trn_approx = pce_surr.evaluate(value_ksi_trn) + y_tst_approx = pce_surr.evaluate(value_ksi_tst) + + + + + + + + +.. GENERATED FROM PYTHON SOURCE LINES 189-202 + +.. code-block:: Python + + + # Plot the surrogate model's output vs. the training data output + y_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()] fig1 = plt.figure(figsize=(8,6)) ax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75]) - ax1.plot(y_trn[:,0],y_trn_approx["Y_eval"],".") ax1.plot(y_trn_mM,y_trn_mM) # Diagonal line @@ -357,9 +481,9 @@ learning the training data with noise too well. To address this issue, we can ex -.. image-sg:: /auto_examples/images/sphx_glr_ex_genz_bcs_001.png +.. image-sg:: /auto_examples/images/sphx_glr_ex_genz_bcs_003.png :alt: ex genz bcs - :srcset: /auto_examples/images/sphx_glr_ex_genz_bcs_001.png + :srcset: /auto_examples/images/sphx_glr_ex_genz_bcs_003.png :class: sphx-glr-single-img @@ -372,7 +496,7 @@ learning the training data with noise too well. To address this issue, we can ex -.. GENERATED FROM PYTHON SOURCE LINES 137-153 +.. GENERATED FROM PYTHON SOURCE LINES 203-219 .. code-block:: Python @@ -381,23 +505,23 @@ learning the training data with noise too well. To address this issue, we can ex y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()] - fig2 = plt.figure(figsize=(8,6)) ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) - ax2.plot(y_tst[:,0],y_tst_approx["Y_eval"],".") ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line ax2.set_xlabel("Test Data y", size=16) ax2.set_ylabel("Predicted y", size=16); + # sphinx_gallery_thumbnail_number = 2 -.. image-sg:: /auto_examples/images/sphx_glr_ex_genz_bcs_002.png + +.. image-sg:: /auto_examples/images/sphx_glr_ex_genz_bcs_004.png :alt: ex genz bcs - :srcset: /auto_examples/images/sphx_glr_ex_genz_bcs_002.png + :srcset: /auto_examples/images/sphx_glr_ex_genz_bcs_004.png :class: sphx-glr-single-img @@ -410,22 +534,48 @@ learning the training data with noise too well. To address this issue, we can ex -.. GENERATED FROM PYTHON SOURCE LINES 154-166 +.. GENERATED FROM PYTHON SOURCE LINES 220-228 + +.. code-block:: Python + + + # Evaluate goodness of fit with RMSE + rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) + print("The training RMSE in the PCE BCS approximation is %.2e"%rmse_trn) + + rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) + print("The testing RMSE in the PCE BCS approximation is %.2e"%rmse_tst) + + + -BCS with optimal eta (found through cross-validation) - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - In this section, we use the same PC surrogate, ``pce_surr``, for the second build. We call the PCE class method of ``build()`` - to build the linear regression model used to fit the surrogate. With the flag ``regression='bcs'``, we choose the BCS method for the fitting. -############################################################################# - Instead of using a default eta, we call the cross-validation algorithm, ``optimize_eta()``, to choose the most optimal eta below. +.. rst-class:: sphx-glr-script-out + + .. code-block:: none + + The training RMSE in the PCE BCS approximation is 1.62e-02 + The testing RMSE in the PCE BCS approximation is 1.80e-02 + + + + +.. GENERATED FROM PYTHON SOURCE LINES 229-232 + +From our parity plots, we can see how BCS already generalizes better to unseen data as compared to LSQ, with reduced error in our testing data predictions. In our RMSE calculations, notice how the training error is smaller than the testing error. Though the difference in value is small, this amount is still significant as we have noise in our training data yet no noise in our testing data. That the testing error is higher than the training error suggests that overfitting is still happening within our model. - - With the flag ``plot=True``, the CV algorithm produces a graph of the training and testing (validation) data's RMSE values for each eta. The eta with the smallest RMSE for the validation data is the one chosen as the optimal eta. +In the next section, we explore how finding the optimal value of eta -- the stopping criterion for the BCS parameter of gamma, determined through a Bayesian evidence maximization approach -- can impact model sparsity and accuracy to avoid overfitting. -############################################################################# - Before that, we expose the cross-validation algorithm ``optimize_eta`` and its two helper functions, ``kfold_split`` and ``kfold_cv`` that will be called in this section. +.. GENERATED FROM PYTHON SOURCE LINES 235-241 -.. GENERATED FROM PYTHON SOURCE LINES 166-208 +BCS with optimal eta (found through cross-validation) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Before we build our PC surrogate again with the most optimal eta, we first expose the cross-validation algorithm ``optimize_eta`` and its two helper functions, ``kfold_split`` and ``kfold_cv`` below. These functions have been implemented under-the-hood in the PCE surrogate class, but for the purposes of this tutorial, you may find it useful to follow along with the K-fold cross-validation method used to find the most optimal eta (the eta with the lowest validation RMSE across all of its folds). + +Functions for cross-validation algorithm ++++++++++++++++++++++++++++++++++++++++++ + +.. GENERATED FROM PYTHON SOURCE LINES 243-285 .. code-block:: Python @@ -478,7 +628,7 @@ BCS with optimal eta (found through cross-validation) -.. GENERATED FROM PYTHON SOURCE LINES 209-253 +.. GENERATED FROM PYTHON SOURCE LINES 286-330 .. code-block:: Python @@ -533,11 +683,12 @@ BCS with optimal eta (found through cross-validation) -.. GENERATED FROM PYTHON SOURCE LINES 254-370 +.. GENERATED FROM PYTHON SOURCE LINES 331-448 .. code-block:: Python - def optimize_eta(pce, etas, nfolds, verbose=0, plot=False): + + def optimize_eta(pce, etas, nfolds=3, verbose=0, plot=False): """ Choose the optimum eta for Bayesian compressive sensing. Calculates the RMSE for each eta for a specified number of folds. Selects the eta with the lowest @@ -598,7 +749,7 @@ BCS with optimal eta (found through cross-validation) y_test_eval = (pce_copy.evaluate(x_test))['Y_eval'] # Print statement for verbose flag - if verbose > 1: + if verbose > 0: print("Fold " + str(i + 1) + ", eta " + str(eta) + ", " + str(len(cfs)) + " terms retained out of a full basis of size " + str(len(pce.pcrv.mindices[0]))) # Calculate the RMSEs for the training and validation points. @@ -660,7 +811,15 @@ BCS with optimal eta (found through cross-validation) -.. GENERATED FROM PYTHON SOURCE LINES 371-378 +.. GENERATED FROM PYTHON SOURCE LINES 449-454 + +BCS build with the most optimal eta ++++++++++++++++++++++++++++++++++++++ +Instead of using a default eta, here we call the cross-validation algorithm, ``optimize_eta()``, to choose the most optimal eta from a range of etas given below. + +- With the flag ``plot=True``, the CV algorithm produces a graph of the training and testing (validation) data's RMSE values for each eta. The eta with the smallest RMSE for the validation data is the one chosen as the optimal eta. + +.. GENERATED FROM PYTHON SOURCE LINES 454-461 .. code-block:: Python @@ -669,14 +828,14 @@ BCS with optimal eta (found through cross-validation) etas = 1/np.power(10,[i for i in range(0,16)]) # Then, we call the function to choose the optimal eta: - eta_opt = optimize_eta(pce_surr, etas, 10, plot=True) + eta_opt = optimize_eta(pce_surr, etas, nfolds=10, verbose = True, plot=True) -.. image-sg:: /auto_examples/images/sphx_glr_ex_genz_bcs_003.png +.. image-sg:: /auto_examples/images/sphx_glr_ex_genz_bcs_005.png :alt: ex genz bcs - :srcset: /auto_examples/images/sphx_glr_ex_genz_bcs_003.png + :srcset: /auto_examples/images/sphx_glr_ex_genz_bcs_005.png :class: sphx-glr-single-img @@ -684,27 +843,179 @@ BCS with optimal eta (found through cross-validation) .. code-block:: none - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - Warning: Sigma matrix has a negative diagonal element. Setting them to zero, but this may lead to inaccuracies. - - - - -.. GENERATED FROM PYTHON SOURCE LINES 379-381 - -Now, with the optimal eta obtained, we run the fitting again. Then, we evaluate the PCE and produce a parity plot for the predicted output vs. the testing data. -Notice that the larger eta, 10e-2, retained fewer basis terms (6) compared to the smaller user-defined eta of 10e-10 (which retained 20 basis terms). - -.. GENERATED FROM PYTHON SOURCE LINES 381-390 + Fold 1, eta 1.0, 3 terms retained out of a full basis of size 17 + Fold 1, eta 0.1, 3 terms retained out of a full basis of size 17 + Fold 1, eta 0.01, 4 terms retained out of a full basis of size 17 + Fold 1, eta 0.001, 5 terms retained out of a full basis of size 17 + Fold 1, eta 0.0001, 9 terms retained out of a full basis of size 17 + Fold 1, eta 1e-05, 12 terms retained out of a full basis of size 17 + Fold 1, eta 1e-06, 13 terms retained out of a full basis of size 17 + Fold 1, eta 1e-07, 16 terms retained out of a full basis of size 17 + Fold 1, eta 1e-08, 16 terms retained out of a full basis of size 17 + Fold 1, eta 1e-09, 16 terms retained out of a full basis of size 17 + Fold 1, eta 1e-10, 16 terms retained out of a full basis of size 17 + Fold 1, eta 1e-11, 16 terms retained out of a full basis of size 17 + Fold 1, eta 1e-12, 16 terms retained out of a full basis of size 17 + Fold 1, eta 1e-13, 16 terms retained out of a full basis of size 17 + Fold 1, eta 1e-14, 16 terms retained out of a full basis of size 17 + Fold 1, eta 1e-15, 16 terms retained out of a full basis of size 17 + Fold 2, eta 1.0, 3 terms retained out of a full basis of size 17 + Fold 2, eta 0.1, 3 terms retained out of a full basis of size 17 + Fold 2, eta 0.01, 4 terms retained out of a full basis of size 17 + Fold 2, eta 0.001, 5 terms retained out of a full basis of size 17 + Fold 2, eta 0.0001, 9 terms retained out of a full basis of size 17 + Fold 2, eta 1e-05, 12 terms retained out of a full basis of size 17 + Fold 2, eta 1e-06, 16 terms retained out of a full basis of size 17 + Fold 2, eta 1e-07, 18 terms retained out of a full basis of size 17 + Fold 2, eta 1e-08, 18 terms retained out of a full basis of size 17 + Fold 2, eta 1e-09, 18 terms retained out of a full basis of size 17 + Fold 2, eta 1e-10, 18 terms retained out of a full basis of size 17 + Fold 2, eta 1e-11, 18 terms retained out of a full basis of size 17 + Fold 2, eta 1e-12, 18 terms retained out of a full basis of size 17 + Fold 2, eta 1e-13, 18 terms retained out of a full basis of size 17 + Fold 2, eta 1e-14, 18 terms retained out of a full basis of size 17 + Fold 2, eta 1e-15, 18 terms retained out of a full basis of size 17 + Fold 3, eta 1.0, 3 terms retained out of a full basis of size 17 + Fold 3, eta 0.1, 3 terms retained out of a full basis of size 17 + Fold 3, eta 0.01, 4 terms retained out of a full basis of size 17 + Fold 3, eta 0.001, 8 terms retained out of a full basis of size 17 + Fold 3, eta 0.0001, 9 terms retained out of a full basis of size 17 + Fold 3, eta 1e-05, 12 terms retained out of a full basis of size 17 + Fold 3, eta 1e-06, 14 terms retained out of a full basis of size 17 + Fold 3, eta 1e-07, 17 terms retained out of a full basis of size 17 + Fold 3, eta 1e-08, 17 terms retained out of a full basis of size 17 + Fold 3, eta 1e-09, 18 terms retained out of a full basis of size 17 + Fold 3, eta 1e-10, 18 terms retained out of a full basis of size 17 + Fold 3, eta 1e-11, 18 terms retained out of a full basis of size 17 + Fold 3, eta 1e-12, 18 terms retained out of a full basis of size 17 + Fold 3, eta 1e-13, 18 terms retained out of a full basis of size 17 + Fold 3, eta 1e-14, 18 terms retained out of a full basis of size 17 + Fold 3, eta 1e-15, 18 terms retained out of a full basis of size 17 + Fold 4, eta 1.0, 3 terms retained out of a full basis of size 17 + Fold 4, eta 0.1, 3 terms retained out of a full basis of size 17 + Fold 4, eta 0.01, 4 terms retained out of a full basis of size 17 + Fold 4, eta 0.001, 5 terms retained out of a full basis of size 17 + Fold 4, eta 0.0001, 11 terms retained out of a full basis of size 17 + Fold 4, eta 1e-05, 11 terms retained out of a full basis of size 17 + Fold 4, eta 1e-06, 16 terms retained out of a full basis of size 17 + Fold 4, eta 1e-07, 17 terms retained out of a full basis of size 17 + Fold 4, eta 1e-08, 17 terms retained out of a full basis of size 17 + Fold 4, eta 1e-09, 17 terms retained out of a full basis of size 17 + Fold 4, eta 1e-10, 17 terms retained out of a full basis of size 17 + Fold 4, eta 1e-11, 17 terms retained out of a full basis of size 17 + Fold 4, eta 1e-12, 17 terms retained out of a full basis of size 17 + Fold 4, eta 1e-13, 17 terms retained out of a full basis of size 17 + Fold 4, eta 1e-14, 17 terms retained out of a full basis of size 17 + Fold 4, eta 1e-15, 17 terms retained out of a full basis of size 17 + Fold 5, eta 1.0, 3 terms retained out of a full basis of size 17 + Fold 5, eta 0.1, 3 terms retained out of a full basis of size 17 + Fold 5, eta 0.01, 4 terms retained out of a full basis of size 17 + Fold 5, eta 0.001, 7 terms retained out of a full basis of size 17 + Fold 5, eta 0.0001, 10 terms retained out of a full basis of size 17 + Fold 5, eta 1e-05, 12 terms retained out of a full basis of size 17 + Fold 5, eta 1e-06, 14 terms retained out of a full basis of size 17 + Fold 5, eta 1e-07, 14 terms retained out of a full basis of size 17 + Fold 5, eta 1e-08, 14 terms retained out of a full basis of size 17 + Fold 5, eta 1e-09, 14 terms retained out of a full basis of size 17 + Fold 5, eta 1e-10, 14 terms retained out of a full basis of size 17 + Fold 5, eta 1e-11, 14 terms retained out of a full basis of size 17 + Fold 5, eta 1e-12, 14 terms retained out of a full basis of size 17 + Fold 5, eta 1e-13, 14 terms retained out of a full basis of size 17 + Fold 5, eta 1e-14, 14 terms retained out of a full basis of size 17 + Fold 5, eta 1e-15, 14 terms retained out of a full basis of size 17 + Fold 6, eta 1.0, 3 terms retained out of a full basis of size 17 + Fold 6, eta 0.1, 3 terms retained out of a full basis of size 17 + Fold 6, eta 0.01, 4 terms retained out of a full basis of size 17 + Fold 6, eta 0.001, 7 terms retained out of a full basis of size 17 + Fold 6, eta 0.0001, 11 terms retained out of a full basis of size 17 + Fold 6, eta 1e-05, 11 terms retained out of a full basis of size 17 + Fold 6, eta 1e-06, 16 terms retained out of a full basis of size 17 + Fold 6, eta 1e-07, 16 terms retained out of a full basis of size 17 + Fold 6, eta 1e-08, 16 terms retained out of a full basis of size 17 + Fold 6, eta 1e-09, 17 terms retained out of a full basis of size 17 + Fold 6, eta 1e-10, 17 terms retained out of a full basis of size 17 + Fold 6, eta 1e-11, 17 terms retained out of a full basis of size 17 + Fold 6, eta 1e-12, 17 terms retained out of a full basis of size 17 + Fold 6, eta 1e-13, 17 terms retained out of a full basis of size 17 + Fold 6, eta 1e-14, 17 terms retained out of a full basis of size 17 + Fold 6, eta 1e-15, 17 terms retained out of a full basis of size 17 + Fold 7, eta 1.0, 3 terms retained out of a full basis of size 17 + Fold 7, eta 0.1, 3 terms retained out of a full basis of size 17 + Fold 7, eta 0.01, 4 terms retained out of a full basis of size 17 + Fold 7, eta 0.001, 4 terms retained out of a full basis of size 17 + Fold 7, eta 0.0001, 7 terms retained out of a full basis of size 17 + Fold 7, eta 1e-05, 13 terms retained out of a full basis of size 17 + Fold 7, eta 1e-06, 13 terms retained out of a full basis of size 17 + Fold 7, eta 1e-07, 13 terms retained out of a full basis of size 17 + Fold 7, eta 1e-08, 13 terms retained out of a full basis of size 17 + Fold 7, eta 1e-09, 13 terms retained out of a full basis of size 17 + Fold 7, eta 1e-10, 13 terms retained out of a full basis of size 17 + Fold 7, eta 1e-11, 13 terms retained out of a full basis of size 17 + Fold 7, eta 1e-12, 13 terms retained out of a full basis of size 17 + Fold 7, eta 1e-13, 13 terms retained out of a full basis of size 17 + Fold 7, eta 1e-14, 13 terms retained out of a full basis of size 17 + Fold 7, eta 1e-15, 13 terms retained out of a full basis of size 17 + Fold 8, eta 1.0, 3 terms retained out of a full basis of size 17 + Fold 8, eta 0.1, 3 terms retained out of a full basis of size 17 + Fold 8, eta 0.01, 4 terms retained out of a full basis of size 17 + Fold 8, eta 0.001, 7 terms retained out of a full basis of size 17 + Fold 8, eta 0.0001, 10 terms retained out of a full basis of size 17 + Fold 8, eta 1e-05, 11 terms retained out of a full basis of size 17 + Fold 8, eta 1e-06, 15 terms retained out of a full basis of size 17 + Fold 8, eta 1e-07, 16 terms retained out of a full basis of size 17 + Fold 8, eta 1e-08, 16 terms retained out of a full basis of size 17 + Fold 8, eta 1e-09, 16 terms retained out of a full basis of size 17 + Fold 8, eta 1e-10, 16 terms retained out of a full basis of size 17 + Fold 8, eta 1e-11, 16 terms retained out of a full basis of size 17 + Fold 8, eta 1e-12, 16 terms retained out of a full basis of size 17 + Fold 8, eta 1e-13, 16 terms retained out of a full basis of size 17 + Fold 8, eta 1e-14, 16 terms retained out of a full basis of size 17 + Fold 8, eta 1e-15, 16 terms retained out of a full basis of size 17 + Fold 9, eta 1.0, 3 terms retained out of a full basis of size 17 + Fold 9, eta 0.1, 3 terms retained out of a full basis of size 17 + Fold 9, eta 0.01, 4 terms retained out of a full basis of size 17 + Fold 9, eta 0.001, 7 terms retained out of a full basis of size 17 + Fold 9, eta 0.0001, 8 terms retained out of a full basis of size 17 + Fold 9, eta 1e-05, 12 terms retained out of a full basis of size 17 + Fold 9, eta 1e-06, 14 terms retained out of a full basis of size 17 + Fold 9, eta 1e-07, 15 terms retained out of a full basis of size 17 + Fold 9, eta 1e-08, 15 terms retained out of a full basis of size 17 + Fold 9, eta 1e-09, 15 terms retained out of a full basis of size 17 + Fold 9, eta 1e-10, 15 terms retained out of a full basis of size 17 + Fold 9, eta 1e-11, 15 terms retained out of a full basis of size 17 + Fold 9, eta 1e-12, 15 terms retained out of a full basis of size 17 + Fold 9, eta 1e-13, 15 terms retained out of a full basis of size 17 + Fold 9, eta 1e-14, 15 terms retained out of a full basis of size 17 + Fold 9, eta 1e-15, 15 terms retained out of a full basis of size 17 + Fold 10, eta 1.0, 3 terms retained out of a full basis of size 17 + Fold 10, eta 0.1, 3 terms retained out of a full basis of size 17 + Fold 10, eta 0.01, 4 terms retained out of a full basis of size 17 + Fold 10, eta 0.001, 4 terms retained out of a full basis of size 17 + Fold 10, eta 0.0001, 9 terms retained out of a full basis of size 17 + Fold 10, eta 1e-05, 14 terms retained out of a full basis of size 17 + Fold 10, eta 1e-06, 14 terms retained out of a full basis of size 17 + Fold 10, eta 1e-07, 14 terms retained out of a full basis of size 17 + Fold 10, eta 1e-08, 14 terms retained out of a full basis of size 17 + Fold 10, eta 1e-09, 14 terms retained out of a full basis of size 17 + Fold 10, eta 1e-10, 14 terms retained out of a full basis of size 17 + Fold 10, eta 1e-11, 14 terms retained out of a full basis of size 17 + Fold 10, eta 1e-12, 14 terms retained out of a full basis of size 17 + Fold 10, eta 1e-13, 14 terms retained out of a full basis of size 17 + Fold 10, eta 1e-14, 14 terms retained out of a full basis of size 17 + Fold 10, eta 1e-15, 14 terms retained out of a full basis of size 17 + + + + +.. GENERATED FROM PYTHON SOURCE LINES 462-467 + +From our eta plot above, we can see that our most optimal eta falls at :math:`1 \times 10^{-10}`, where the validation error is the lowest. While this indicates that the model performs well at this eta value, we can still observe a tendency towards overfitting in the model. For larger eta values, the training and validation RMSE lines are close together, suggesting that the model is performing similarly on both seen and unseen datasets, as would be desired. However, as eta decreases, the training RMSE falls while the validation RMSE rises, highlighting a region where overfitting occurs. + +This behavior is expected because smaller eta values retain more basis terms, increasing the model's degrees of freedom. While this added flexibility allows the model to fit the training data more closely, it also makes the model more prone to fitting noise rather than capturing the true underlying function. Selecting the most optimal eta of :math:`1 \times 10^{-4}`, as compared to the earlier user-defined eta of :math:`1 \times 10^{-10}`, allows us to balance model complexity and generalization. + +Now, with the optimum eta obtained, we can run the fitting again and produce parity plots for our predicted output. + +.. GENERATED FROM PYTHON SOURCE LINES 467-476 .. code-block:: Python @@ -715,7 +1026,7 @@ Notice that the larger eta, 10e-2, retained fewer basis terms (6) compared to th # Optional verbosity output: print("Retained Basis and Coefficients:") pce_surr.pcrv.printInfo() - print("Number of retained basis terms:", len(pce_surr.pcrv.mindices[0])) + print("Number of retained basis terms:", pce_surr.get_pc_terms()) @@ -727,55 +1038,72 @@ Notice that the larger eta, 10e-2, retained fewer basis terms (6) compared to th Regression method: bcs Retained Basis and Coefficients: - [[1 0 0 0] + [[0 0 0 0] + [1 0 0 0] + [0 1 0 0] + [0 0 0 1] [2 0 0 0] - [0 1 0 1] - [1 0 3 0] - [0 2 0 2] - [0 0 1 2]] [-1.15692903 0.24292952 -0.29524043 -0.15503765 0.13276008 0.06118484] - Number of retained basis terms: 6 + [0 0 1 0] + [1 1 0 0] + [2 1 0 0]] [-0.62783727 -0.37134989 -0.08735439 -0.02919352 0.0480559 -0.03471433 + 0.0232746 0.0196456 ] + Number of retained basis terms: [8] + + + + +.. GENERATED FROM PYTHON SOURCE LINES 477-482 + +.. code-block:: Python + + + # Evaluate the PC model with training and testing data + y_trn_approx = pce_surr.evaluate(value_ksi_trn) + y_tst_approx = pce_surr.evaluate(value_ksi_tst) -.. GENERATED FROM PYTHON SOURCE LINES 391-392 -Evaluate the PC model with training and testing data -.. GENERATED FROM PYTHON SOURCE LINES 392-402 + + +.. GENERATED FROM PYTHON SOURCE LINES 483-496 .. code-block:: Python - y_trn_approx = pce_surr.evaluate(x_trn) - y_tst_approx = pce_surr.evaluate(x_tst) - # Evaluate goodness of fit with RMSE - rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) - print("The training RMSE error in the PCE BCS approximation is %.2e"%rmse_trn) + # Plot the surrogate model's output vs. the training data output + y_tst_mM = [y_trn[:,0].min(),y_trn[:,0].max()] - rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) - print("The testing RMSE error in the PCE BCS approximation is %.2e"%rmse_tst) + fig2 = plt.figure(figsize=(8,6)) + ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) + ax2.plot(y_trn[:,0],y_trn_approx["Y_eval"],".") + ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line + ax2.set_xlabel("Train Data y", size=16) + ax2.set_ylabel("Predicted y", size=16); -.. rst-class:: sphx-glr-script-out - .. code-block:: none +.. image-sg:: /auto_examples/images/sphx_glr_ex_genz_bcs_006.png + :alt: ex genz bcs + :srcset: /auto_examples/images/sphx_glr_ex_genz_bcs_006.png + :class: sphx-glr-single-img - The training RMSE error in the PCE BCS approximation is 8.11e-02 - The testing RMSE error in the PCE BCS approximation is 1.10e-01 +.. rst-class:: sphx-glr-script-out + .. code-block:: none -.. GENERATED FROM PYTHON SOURCE LINES 403-405 + Text(71.09722222222221, 0.5, 'Predicted y') + -While the training RMSE error was almost half that of the testing RMSE error for the first fitting, the RMSE errors here are much closer to each other in value. -This suggests that the model has more effectively generalized to the unseen data; a better eta has improved performance. -.. GENERATED FROM PYTHON SOURCE LINES 405-420 +.. GENERATED FROM PYTHON SOURCE LINES 497-510 .. code-block:: Python @@ -783,23 +1111,21 @@ This suggests that the model has more effectively generalized to the unseen data # Plot the surrogate model's output vs. the testing data output y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()] - fig2 = plt.figure(figsize=(8,6)) ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) - ax2.plot(y_tst[:,0],y_tst_approx["Y_eval"],".") ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line ax2.set_xlabel("Test Data y", size=16) ax2.set_ylabel("Predicted y", size=16); - # sphinx_gallery_thumbnail_number = 2 -.. image-sg:: /auto_examples/images/sphx_glr_ex_genz_bcs_004.png + +.. image-sg:: /auto_examples/images/sphx_glr_ex_genz_bcs_007.png :alt: ex genz bcs - :srcset: /auto_examples/images/sphx_glr_ex_genz_bcs_004.png + :srcset: /auto_examples/images/sphx_glr_ex_genz_bcs_007.png :class: sphx-glr-single-img @@ -812,10 +1138,42 @@ This suggests that the model has more effectively generalized to the unseen data +.. GENERATED FROM PYTHON SOURCE LINES 511-519 + +.. code-block:: Python + + + # Evaluate goodness of fit with RMSE + rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) + print("The training RMSE in the PCE BCS approximation is %.2e"%rmse_trn) + + rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) + print("The testing RMSE in the PCE BCS approximation is %.2e"%rmse_tst) + + + + + +.. rst-class:: sphx-glr-script-out + + .. code-block:: none + + The training RMSE in the PCE BCS approximation is 2.02e-02 + The testing RMSE in the PCE BCS approximation is 1.21e-02 + + + + +.. GENERATED FROM PYTHON SOURCE LINES 520-523 + +In these final RMSE calculations, we can see how our training RMSE has decreased from 1.80e-02 to 1.21e-02 by building with the most optimal eta. This indicates that our model has improved in generalization and is performing better on unseen data. Though our training error is still larger than our testing error, this can be attributed to the lack of noise in our testing data, while noise is present in our training data. While the optimal eta reduces overfitting and improves generalization, the noise in our training data still impacts the training error and remains an important consideration during our evaluation of the model performance. + +While this demonstration calls the cross-validation algorithm as a function outside of the PCE class, these methods have been implemented in PyTUQ through the PCE class. The example "Polynomial Chaos Expansion Construction" demonstrates how to call the eta optimization methods directly from the PCE class. + .. rst-class:: sphx-glr-timing - **Total running time of the script:** (0 minutes 5.760 seconds) + **Total running time of the script:** (0 minutes 6.413 seconds) .. _sphx_glr_download_auto_examples_ex_genz_bcs.py: diff --git a/docs/auto_examples/ex_genz_bcs.zip b/docs/auto_examples/ex_genz_bcs.zip index b37d26851f4a8801473b6493738983e7d6088093..f9021fb84532e603c08c829a8b2b86d8e5aad25d 100644 GIT binary patch literal 53699 zcmeHw>24!ga&CE<`-27sFfb30SL%Vt8HyvRYPts+aDeVw>_+uc?vkf*A!?`;nUb=L z%;aQ}DzOV?!0+NeehEK$8k*);0O2ou1bU7*L4d@#-OA!dl~U&eVE z)t}sNMCGI?@(WHQ1J%BWr%9Q{8F~*#vZkvfDwC|_AoVZqKW((4qst_ipFIbI3V4@E zkwjb)8vY%y8GT#!&?d$Lr>~+rtF&*Zv1$Vj;B$6E)Z%zv%2fksGd!R zXIK!v=APwQk^x98$2GxnYDbqvKDoHW2t@+&O3%-Mr)(UZP0~R>0$uk&zey>?C;REB z$8>pe-_r_qHjgfWjR7$tP{sYLI2*?oNl8FJCsCaBqvU!t$UzIlY=S9!fXpo8G#SUI z(dBfM6n;~H%3z`leU@jt=EQ&&F7tjVz_MkQfF8NQSV1cS){<;~YOZb~2O^Fx(knE*B7HZd6BodDO^S=r%Uk(cG}6=nfU%4(hb8wTFR?-%l2-INFsk(6 zxIn3g`3&2I5hmaZ{Ro>fPDoTrG>jNAajWB!`#2DXqSirvNzbLYRy^KtZb0!H#w zwkUcCK7&*D-PcbaHbC`*3Gg!^EZ8s7Ew+(lk`@st0+<=bSr0IRa&s(jFaQ&b2RWvd z`G||<3zZ$j=?0bwC>vLBR^kYh{1Qvsvg}(T94owx2j`ZUvwWPK<@qxu z83+VRSC=u^=UD<0!4?l>gRx|6S5oW(tli5z?{nNI)1!a6};K^&X}t`#I|gb6TDv;>e^@C~S3Tfm>~i8Y6f6ux0RazmHEQ1T!j9_4%cVN0%|MJ2+H zL=hNBz?$N3JMtR{A`SVgoFI&lK>pj4hE9Ll=m#BebjopD2r~f{UVzZ#^oZc)!1)B! zR!qoO$aQ&eRlGQstfzwQLI7K}Z4CeUIR&XAnxoCEGm_0aJyj$-tel>TkTJ_s*}$Go zF#x1E?cglil@lMb9f8y`CGsI%S3Vh2re=9sf^{5GtCBCdF5wt?0bv0V*|*^ONimzq zJ+MBmM8v8&wdEnch161@2GDWhB9KtBvMjkC8zDk* zBHI#36YzC`IW52~MAW!e1ZP$ZkWcEN+>X9OPaGPf6&N&w;$=6WhmEE!5Cv5PJt2P{ z_G(3T(FIfNL*u%4*AMkT6tp=ixk0fbPKJ=)DH)j4VaggQpo_mbiT+_Vs&;g|-`e|4 zJ^l55<5#~r5Z;w?m?F+DlDh5KIEkbm2ACnWx@d9jz1G2RNnE0*wWXW+qfry0=$2!y zaj&&^@Y@k}de@|VcH#tk{eeDZan~)Ppzish@VMZ+g1q8SFMg86ZbWWTE z$V~_&aC7q2oD>v&l>qmBNVSnuyvqnWFprGtnvU-Ts(PNu=}^^JNDp&C;F5R$`@c~Z zAMfrrqy3XV^=r?{v}?X?gU`0&qKK#UV>D>(p-F4+wfQ{j|Iio5vsAD`wK_H6s#{^ib3sNvsL#W`$Xi4Nb#4I>K8#*9Tyb;AH3T!6H<3&225!hBB~HHHw#dzVlu)1E(%&Zf8*)tw=B1|_s1tS2Tl z!|n^HH_8jBEhNNyLZhLDFvA?jm+_eVyTVaH0%tkk5hcECMPI-~1@9!ma9bcK3Xsc} z*?C@Xz=Bd0N`(l&e{%o3KRR=%8BOyEx&uCTk^w>iwNrBX^9gN+xP%-aJMF>NrOngJ zVT+`_6u-mZIZL2zCStOv%BYPCXxC|`tWMZ%nO#3%ABo~Cb(IpoEoj~1ijIODuZbmy_{o_tEx=M;OG8Pb%Z0)zu z|MLt6fPNvip-8^NnqZ?2ofZrK!Y%y1S@`{6;fGrdH$Bvz;;I#(-;VQ*Gc9$nBQE-I zs~K6qq34XDban+Bbv*|4{nl?A(bELGQsFhOPl-PEt1b`A>~WVfd3@O1JMpCah?*dg zJg1<5AZPUxp-<7h!HSdsbic?*MVEQlisW$MdkYFkUDy>#CCl}=H=*WV8I~4~^E{ux zY^Gibm_X~`{xTgMGXpTgK79;B@oqpX9w!haP*w@Px7KIpH4YO|HRc)zleeP3&z~pQ zd#sY@o1@14ek$e+kRg1EGDfw#fHO9u6c#_s7aFIRu^eX_p&UUqK+tpC!#RPN!YZKS zh;|c9-i)ATi~5A7BbYrfX+eqL8wE8Ypvo#<-h-tJzf1-rASWtvFl}lxLvbFA2C>)) z!f;X?BmzXp1Cw4j2JBUw%xK=#C5|!pW12E5M6b95CIgtHKdJ=`Q1xg-eqvd=TrkZ7 zCL-MyA&E3$Zam|TW9`s_!817$da3^c<~~tdrehe#IE4`D=`)`Gl)e*je9?VJ@);{h zB$=A!G*8e~Ok3G1K(zqDvZqjFD<~Cp`%BdtL~}IOYv8Y0;%W&thHwwb>Oh=vIuJeu zJ8m1A3SB8`r6%mEd8=8vNQJwN=%E2qs1Ra7&Yfx@U3Kw- z&pTG>7FAJ*8Y=YHZ0{8UtmFypW-h`jp8^2{rm>!`Ae!00;YCa+{nEfW{2DMGdoJAq zr>i%b;Ro?`y>S97JH6QFdIsYbew`Fh=F&JVo zedzJ_-@k+Iwb%OWw-g3w-lFMW_jBpA1{cR$|EEiwZJji?T99zn_TAyvruFda26V^= zX?!7qlsl?}Q#M@>Vwj-yts{!B=mE{kDP*32z5l5W%63!J?uk+r%%`x~?*p4`1FQ!+ zq}h?0*=>jQaxAjZW8HmVuuile+<C4)mb?sr3C^6uD@daZ3xPRt}DW`dJC%X7=qdu9M3ku>ahmn zl8<5<2~kN$;zT9;jC)=E6%}qBGIWSNZ#huVJ5JP!oRSy%lN~ds+gALSM6+2|g`-;) zk*E&T2fCI;@RevC!=Vl7D&7!ojhTrYfC4;)a>9=t_X{WBK=9iX@Z&-u=nagu&-UyO zlP2lKV*3LC&>8d<=;8c2(4eeO)y+Wus&=aCVA64%15KQO`ieSXsn_9;P^ZSJv7RD= z3`d^0mIqTRFryeADp>cRd4fRuP(&%nj>?JCXSkGjGzN3-x1w*cAwnu5aJT@NJyy@8 z9Ys&aU~sqyRZ3#KWw0m`Kc1koLWL!GsWYZ9J+G3e&Kj*((SX~}$;Ab3#<+f!;{%%A z1{;$MI+L;8uJn2-yR_(iym^CsvOW+bXx-4%-x8f)mT_U zdxQ7_J^Yz$@8E)c$0};ZZ-#}7T_AUIZb)EC&5FH@w**ED$m=G9T$Fru)*EEX z=33oSD2@_J88@lYF_}4?nCB~o?_tW5hz)b+t14k-0(FARO%0nmJ`bObSHt5AUDR4Ee`tzyIfCmRF;P%t zk^-9NB|L%|ya!z)=-SbN@is$*yjS`*MTw7@dguD~jo^g(w&=lR#4Gh+8FE0C*51BQ zK`P)A_2m~6Y%R6^#nE$We;8- zy2r#3#tRa7%K{bMYN}>ns1~?M0U3eUi{BIs-^?N{=+ZGUN3F=HFl7`!0rWamDUDj%3j7h>(aj2D9S08O5M9`@>7UI*!xQOab-H0mE z?ykU(E1=Pc>SYgsI!VFfV0AW<5$Mds#i83pJRHIz34GYr%N9e4G4X-P72}z(J;N9w zk=D~{eX*RDYA#gq7>+SnmAY$@Y-$bIaSeu9{5Y(3dxv8-XVRmqvUYZ#!U9ce`&sV_A4vR!I7o46uVAeiJLOo&E~pbG$|NLX2SV!9(?#JZ{~(@>XS6-MTgc-zdzW~;yA9yyIjtE zIG4EqM0a6WG8|!>#dlQarz8uZ6aE3a6Nis%!v?_#yNYEK#3%=u6T_UD;hsEhkBotQ zQy>_c{(9XXD;r_7M8U4rGgwpzk0_hC4*&#Bi89!~+c=cqSH@WJmK&zS1O~iuS;q*T z1=tIfS-dMrHqDcMGy3@0F;+U z`*+Ri6l1{xiMzw-^ALx6OCu4y&yp$mF-eAS+lAM0DTo^!S;{VMa^0eNFr}liSPG%a z$l&81w_M+Dv?VBnbm=G8h|)t~LDrW*4Xp7?@NUH2R(5p`(PkLTc;g@ey;p{@^n_>) zp(w~v@(y)A1n3Yw0gFNmvEqY~*N}>1LBQk3ZAFRvC1E2zOhUKoDFTa1KX&WYQk4mvzzY=*3HmwVnw*Gg=4xyTN1?(wE2U z2TW?>qyV3%J~(tB=N0uT7yMkRS9*E_-di12XdnxC7o4H>}KL-y|mn-?a%tNL|wYJ^Dp?h-Nb zl;^{QLdt=#r1TrBf2;TqZY_K2loeU_HF+c$9WTNVi(91EJhu`9l||Q4AMt4YeYRn6 z9|bEj8>FXj*A+bv(DNYZX{~f3+Y74e8Mf*6;!8=PFd&KWFQHT?XikV4h@y%1AK<1L zVR5P(xUV7d?S?*NDn|iTS{A9C==U&{29qIf_v!N2h?8^hG5E-llfa(SDok#)Biw7l zs#rLukUxVt2g$Cklz~19Ej*P#zZ*v4Cru-mTyS$fkl+o#h#iDiABNPFUNNp$)FZAL zOV(&6H%>V~oKtr3doposimvArCkWT*N%CWIirf!sm!Mumzln8KY7ol`_@GY0}xQ8h(C+Fw5SV1gC7FCqq>P(dWoXUzhuqSesYvlF-JB>f= zd#;!@L8D25nP<6+XUUWrGr8#pZ2c0Y5y9ZS5(DNM>GORzn23kQiDUv=_RIg zlooWGvK|No-{<(5FeSI<9o*Nz2@3{veXO0);<&=IPEMLZbMUO$#-5E;nojM=p5*F8 z&+>U1!9-J?Xhq*}TF;|j0{2uu4UuyL3@_b>;YoI&a+YY@28EhPHL<(oLJ1uxE5QtK z`f>Q=fH(x;6LU;t+ui3Ju7c%bi&^4(_8YFvON<454el276}%w2f}PC5{OF;S2<^%` z?rY@w0w$z_4}oE03)_gXprgM12-hgdj2Uv@-_OW^lc88!Bsk{|plb>2sAPPUNf&HI z_lE^_pK zOp1KvNMRhWYlt0Yu&iCgBi=lcyfjXjnGceMRk{u&d)pcdcO76CVJYH9bx~xo91j=$_>ER+mH2y4B{SudL5=1;>D(GJ+Abx(sy(wk4Fe)nz!9{H2`1**T&d$@ai~ zWK>9EQ#oQQ3ceThNhrivKYHZcIfuKbOp)m-yn}#)BZ%IimIGUN*}V&eq{}Y=5}-at z(ub@CI3hcCPAFp<5gYRTq5;rGhOi@i9V1o~k*3H*v!*9KT_${wVq&6z&8jx=8JQ$X z7{@XlZ@*=nwhY(mC&`F^6T2#jY>Sp5NkFn^0r@J=N5FvERl)|jVi}kS3v48_Ato)F zbhRxsLG-!3pRq3;PS~6q?RKBvz@G7fNv32oQowvOD}!7!jHXESq^09k#TiCh*vv>S zPRJiOtV^LmZWc1uB@Tdy5Jx{zqijboRVMUSBQXnyOXFsg(rmH;;s{kG28y5rkf!`; z7b+oz@nkvzQ)u9DBN4i9E%g`zWFrtEwFTh*TC|0kcpTvj{1%izIp&GWt<+Hk)D8fE zLkAJ1QSjU;BsSpR=KSf5^Rxok-FR}oz>9FA@G&##?P9byk_-i-go?g&7fx}64-Db+ z=;HMO7*a@YpkXl?flvUyNEhnBVvnd*Pg)B(FW7c3f!K!_u<=)RjtVHf^Ahysmak#4 zKE49qNlb`FSYRmu4s<2%c9Bc*n2qcWjlret3#ie0evMSDz(O2LoG51Hft8covNBxK zfEtbC9gQWO(bAN(SN8_xRQgvYM-Z;$tThP1FQ#rIa|}6R9nxk9*l#xXzG45 zdW8BoKqOWg@nFo@xwbzJJZL~I4A}bg&z6%joXeiZ80&eI-EK6HTpT0Nxv~_3juCKn zE@4y`<2wGHZ{e9r(UNPwzGlK#PwNf9fT{!>{P#5igwd9Ov>koJJY0oW_KBPrk>VDw ze%pjGlhUfV??GvnSVSIKVZ=h~;4vcljo+1fA)J>jLh&EM6=2Y#cTumI_4t1H!s#^{ z4Mn2`w+VrXpvsl-RJw(@BH?O;m}?*cH0i=!N3qRK7f;YE&NLoTR7U9V=%s|rH1Hu@ zGjy{;H^EVl;W8kT1%KdGK_3^fSE=ZjR%fwd!x^kxf^J6D!VyZ1uP(ZRC=qucaIs{B z{^k@eL*ls7E!zli~@( zedoxmWhY?zE2qcStO7v3-VB64I*Csp1c$^vp&+7&0B#z5A0tVe@TgES(KWWWa)``e zy-Y-bFE}p{u{wx*&ybF37QJPxxvkmhZ2HKdSIE!162no}<<#sj)7HW&^D}Y94a`2*l3-ll8RQqi%?ZDm zR=#na0FB;C4J5POeaLEIY1-b=zxpG*^mMStXj`JrxVub`N|cC3YdBUs8z!*swLRK>slnf5xAvW%Ag~%a zp?u#;0=bP?SZ*#dTtj%iiSE$sG{^({SOA#*ETl%{=&c@sz-mkL(vXSm0Fe0quI8|c zVA2R{l6w0Hi2w|(=I8hS7?`elgAPv%UYaQ4(d9~c!lYcILpMY$LhvgSQ*TWuBqi8H zIGaPi#(F_wNFQN%0LPE1k`|T+q2z_L$v4MJlr3R!hUjA$q1`<-|h6Fn&LWS35 z{9I)xV*O3(3_cbk0QMsr7~@O>z`z%HxHW}D?KU(g@EDzI6s!VniRa7D5bh6matsNK zi_=VE#hybUQa`RSGHLh{4ih-{2u=g!>t28Zxp9G4wy0=L!E%H^DQtiYoNJrbgKIoV zN->dqswGyI1K7=q_+^PGIL#DBY@IxG0QBQ^7-(`q7$&TK%3+{DGRUD7_VL~xLNJ4@ zZhTAF`w3}X9%ZY5uLnvt&*v-6t_K+;e9g^0(nbgofq^%G0G;k?5N{XdjK+gD|bgO7yaDRPrGcOswt&7(SBD@x`r@tGyRV^NO4gi7Z#x<+moV zZ26NJ-+`3hd72J3V8+X3woZ3sk;NcZ3H@2wn(5$0_D<8sVd1+(<|3O(WOg6;^l@I3 zQ(1(fxG;U3-!n;Ltvu#1`@+n1L;Cn_(wMnjuO*N93A8$4b3PEYi0{jhRbz|+1I6^-%0DW5G81*V!hViiA=;Vp?6mfJ~l zxqUPWk-2HuZ~bmB+1)#!pxbX9K&8j;c=uTBKpp}o#%5(P%@t@hGkU5j$$STqlbIx9 zdEu`rDMh8L>V78U2C7w{>TwpyXQ`~lDbK3p8eJ8Nay9)#no)1XL{#OWC?cJ^NOAoM z$%z$HMW921`cpNv;-?=F7X0eAg{gxT>CV0@OqB1s5gEF)-MV>CXXe+CdJYO zDb&_wXKlKUg;1Y-#l@ey!gGsh)tYu1cUh{qRPWIJ@^uT&26UGDYJ_%DUePp?>>xFfp-DSCXD`X)Lq`s7oxdQ!mj_!dS~5t)&bvJdT70qX%1i%X>_KMhl@pN z56^ddF`8T_Jv>*QX9#OShBPE+hDRx#JPoC+5zG|Lcw-+Idr2S7&lv=4zVdQd%}J5! zE*gAmk#L4;rw_w-GV?3mz$BTOzf3$W--dUeF?7!T!C(sa$BO6SJDKP!XwGA??0tCC zYO@F839bx&!xQn9R;%BLuQa7rvFefd4L1Kadek<<4{+O6m@+ZdJZI?PCiK<%6mamu zS07*NoAN~Y8-7y01M}0@kf>NCG&<}pyqGD%b&Y#PtQli9%9qlbn#PJ3<;l3Ac*AnD zDa_{XiYkhv7F4iJ(+Z{?R0>tssYR^&pnNBL-S5eBGd7^X_lp79SIKQ2fg$3&u&iL= zEBKwvKJyNj;=Q{c@amBo4Oh0Y@O^a$HE;ip&z}e7D7=9K(p&IuKX3+KWgqT0e_5@3 z{g?Z-BQVSPgXwR6x*x>Nf)3%^{iM!Uc)cGZ%{|}Gp{|Od|4t@XA-od+(ca=ce}m+}mnJxt2snAtzk+7@c=?(4?8RB9w?kkDjx)M&L@3Tn6*Zm>#gY9I`0xhM3q$iW9}s=iOk?7 zL8zt5<-ho|KNeO9WRwJ%d@QU$Dw4al52mmJ&+V7$G!CCxL*x{$2E=@`kF9ZSK?%$7 zGK_k2P*-6?ZhjkC4fB0j@rD^o-Q5AXi=7X@KEsBHe(%KQ#;+3xf<)8jAkJvL)R#Sm zYt-TOBZG|Mxn_sWl+yPN{~JWrR6IrM6SAmXH<*b#g*c^^)iB_m+N2x?hpZO3kZ`JM zL{rC9#ORRb7@5qIJREBBuTJev~-MVbOhDKh1f_m6*Ly=Gt>o^ zmL=%~bxF993YIt}Hmyvu0xWYvHiv36*>f8ui|9kx6zh?HEPi4ud)O=qp(7?wd@O!~ z93tDuLS+&w3`Ib)0 zPpGQQhfe(;eE>GfcvZ67u_{JHTsIEg)c@7uTnReUXq(#^}q=mi$kChvVWk z7Mvm$IfGR4&|mrI#xmVdF@D;_U3WW$iBL3Xs)Fr zg*5icMW}QrSA|Odyr~S8-5~RL9fOKDEkvag0g1~iQTbW)9d~*Z@H7<4TuDZUyon3+ zA(DBGT2wlpJn+7{7?q#(fqx(#bG%|XDxKF=8-lI*;-#O$=B}6vJ4t}CE)hAE+MQW} zGbO3?3lfqoDaBm~v)+AfZ7>o$@K3<;!~76*vaeH>%J<}ZmOKa;@3v*B{Gf8cd?hJ; z&vdRXm2Xe<1kcLx^<@j!D;B2mV>5ecS!F8U%I)tfmZq{40grU0IMoMhYI||Hw3?P; zFJxkJ%wMgfmJaqxHMO+ss}+tt?cRQ@MRj}7nUQ0(@sK zmpWTP6I*CYKQg7WprOQJr7iu^OvN@EmDZTmCCs7ix9It*|{*tCc0Ug0`$7a9b0#8!};&$0JS8{-{;8pm3P)_IfIZ`SE5!;NM~CFy9iJ@)~M~`SBLb?8-2$ zQ#@?-P+<)l-_n#?u?4|gH86>#WJv~7KFs&v(-XEiKz2PgtRH5{>RYWK=EnzG`Hbm& z2{GFvJa=!PkeEW^S)AjE>s1o7P~v4%s)OLYNJxKkwZs%!p6I#S762T@#5_Dtmz5J+ zJ_bXVIf@_T^;8to8JQl*cTg|||5Gg~R&5g26!XB$SBjzmtvzQfPg_>Zc9vtkR$(z6 zj_p@h7W3_xlI^I5&u2)*Fe_tyyVbSDd^?P%8{vskN1PGtzK2Wje?#TP{7gc5aQ#&3 zi!J-wl9MA!-G!&GR$|Q0VhKsYFl^-aT#d2n*3Z)p7>^%PL@%T+^j+ceVP}Q4th^)%MV`!-8YgFNt59SMZ45Irx=lYK}3h12p2l!5=Iy#?M{r zu+@SDSWe8CEqRL}cn5%!m6a4D6$7YAZ)03MOAFB=kF@;@KQ)}JoW7QEvcbzRi zHs8co!K&6Do2C3400N~gu0S?FBi2=|i8kNF1BG$JT3?dZNJ`_+Tc|?jL0hOegrIqt zi@@|<)NN)>z9WyT#XAI(*d6b<5}6`^Z-KqBQe--XuewByfZiTfRbHnS*=&Dc@um@o z=t?m%i}j$=l{tPJlp|9>{16V1&FYa^Sb+3fRU}hzz+z2#8A|8nCCU7(62U0kW38fO zIt@gFm^*eDo=?OjqUywrb;-gmjA4|gp5JO^GF<{eUO7MZ^G%i}o5ch1xo&Z?&Q?w# z%D5R*j%|5)vW~4!hGYZBZtUV+ChtS&c-87-RV=v}UQ)_jOW&4MysT20Z$-SXSE_6l zOO;|})d4Hj%EEqtDXdpk?X|36S#&yRC!<`0uwJuJ8?m^J`U?qO zo0HlScpQqR9G_E@;sFSgSW>D@rh09)+BVqA+njY5c?>j(h}KNyO6>6(mEab=t&K50 z7J>U8RRoTQ=VJ-DH&X&`_JrMg`N_uB-)6@^;WrNQs)gUU-S436+XpV_Hmg{-W~Q-G z5Jg}ADW)2~Z`#U?o7Yqgl7Od*i#L22+&=uIRbrr$(A&;f`WBtE6I>9oa_%It5Ab3$ z^}(O@I&7A$^u8ffyb4sbd~(62`LyBFNUk2BeHzJq;GRZ$!)cKVs{{t`*#vKD-SSza z75TK4+I1h_)S9huXb+fsip@QsWy!{U@V3b2<7--#VqR~g%t%lx^}Tsb>*j1!lwYOh z^HyKex*4j?q|R+DRZWllSPPOl5FcwnzN1=@Jb@o(CCE)GRRyIDUsEl}1vVR4yHtak z=l5H8D6-il^NS;aB*4>&bL{iHaC^ef=ubEWen<7xFF2FX3DN zo$aNcn<6cyM%9+>h%A`%Je-qi@-W2>sdPC;v)^3r&W!ISp8Na^g-$Uw!alB9Nh>Lc zr`cAc>BW#m2)iiht}V<00!(`Nx9+y~4_cq8JMtwKBMaHe&JfsxdwNW8j|IZq2i;+c zm;3SYUhUX2>FE;s0{O<++d+>kx*Z&8sgVjv{ delta 5508 zcmd5=U2Ggz74|xR_SkW3HICi<`MO)XyLi3cHEk0+aT1*W+DYwrLmPR6Gdp{CcaqtA zmpe0FyG~+|jA$%cMI02MY7!9ez(bW*+ox1boA6NDhtNKO1VU5@h*ThectAW@07rczW;=8%D%#CCRDoZtqvZIU-FYo3)X$2GQ@%~|8hjG^qihSRP#w$oAF za^-O)3mM9YYnv=BkA#lO`u!oITO9xAO(#Qik~T+ii7vg7&P8c^G!j-G*%ZwuZ{?Cr zEer|#A`vlcFCt;?m0hi&-u zc;_Q3C5{e%ES`un%cEM21W6$7z1aA-d z?0(z1<9=#j05wybHG2vz8-{qF{gvOvzDBQpKroFPWT zS(7DA?9<`MQ5df4@{Pgyy0vg^<5!pNL-@mBeRwI7Kmz{Jw9c>aij9b<$7@(zuc9+_ z5k^SB`KeRzm!_L{Iq9!tq95bKwlH+da4p&GG8iGDot4nGJ!n$}?F4o56dPPFnMIDE zwrhD^0ax~{h1Z*x!qw&-7{WVio~Tes#?->Z>BnK^+GERjY?m%aHY4t5;Gis>jsWrOE3rsZ)` zsrhD`n&kES;eb*;J$Y1Wa~b`tQCkTPA_scboy0kASSUk;Y%4X^Q8C~@oJmq1QB@3& zTHJIR%$k$>8khcBoBvltgEo!In%|iq1`+5uI`NKr|;5y(zzg?u?w+Q;v>Z zsoMNVoT>3UVmnFHf{}0(uWQv`hO5?^=l@TB;^LD2jI#v_P&{B&%}(&M*1iQw&^Wub z23@8!C=8wnVHvj0RiNAAY%v9B;Z*KjpZ_kz9cLKnNZq3##0I49ABZt%nhGsMi^f^u z!c?SuIfD#(e`XG#L}`=wuDcyIFf z!z4xH>~mM5P7RX#93=|JMk9(UR!;ALZ=75P1JfOFYWi^D!|5Bo!kZ_%d9ze z?YMNhvT*(Kgm2|M2|LqmtzV3S9S);%cnAdS44(I1``5kF)5X}6#ToT7{Gqw|{^;c4 z*RoPQ$*1H8A!W&W`Bw0DQg#lxw86XY?Lj`N@xis1x(d(!>ZY$|{!3Hn|0qo6i`%lY YI`wwd`}*lOU+INcKJqXB_c?jtf2N6P(EtDd diff --git a/docs/auto_examples/ex_nn.zip b/docs/auto_examples/ex_nn.zip index d3840b37c10a553fb844a3341166d4c2f600fb88..2b8ba851333b95b0ab57a81e3a4853bc30417d26 100644 GIT binary patch delta 47 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 F{{ca-{XqZ# delta 541 zcmeBi+h8UU;LXe;!TTJToKLyKEGINUcax?Q%QY&Ce z(o;*~b2GU%8?yL;EN+w(oBW=Ar+#i~Nk)E(LRx;2LQZC0YGRQB(Ac8X;^NHwJcazE ztkmQZ9fg$Cw8YY!lFYpH$s46)CJS<@PUh#b6euXl%q!6-NKVyDD$UGE(Eti6PkzFw z&XJT{tgfla#Wnf8oaN?)yjhHVAkS}lFL*DFpMfEbf3qZiJoDzALduMjZwUuF#^j;< z4b|(I@@RgaBqAb=#j}$yh-hyP6Pd&^*-`QaSw2mWPMmx}N@Q}9w8G>lX$>}r$2Px~ nTgD9b5+Xh)&sWk^K=ma90}nXjA;gkKN$$xnl;qe}N`V9bjl#MR diff --git a/docs/auto_examples/images/sphx_glr_ex_genz_bcs_001.png b/docs/auto_examples/images/sphx_glr_ex_genz_bcs_001.png index 99f74093a0097c850f3feb2f9ac6863eed3f5dd7..3717b0bf01d4764bc86d789e3099cc16ac08bb16 100644 GIT binary patch literal 27113 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 literal 26558 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 A7XSbN diff --git a/docs/auto_examples/images/sphx_glr_ex_genz_bcs_002.png b/docs/auto_examples/images/sphx_glr_ex_genz_bcs_002.png index a59052342152efb81c07431c59c8e7510304029c..beca382ed5bcff86f2d907a0298b9365cb32ce32 100644 GIT binary patch literal 64774 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�IM!!7YP+tr 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%0Dd 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 literal 79581 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 J(yqha{{<>P0fGPk literal 36188 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 diff --git a/docs/auto_examples/images/sphx_glr_ex_genz_bcs_004.png b/docs/auto_examples/images/sphx_glr_ex_genz_bcs_004.png index 796bf330ac00c8e324b9b293d0e25a7f28f57157..be10c6eeb2609fdf5e4e2bff4a6fe68c0a938daa 100644 GIT binary patch literal 36121 zcmeEuWmHw&`|UwWN<_MqQt9qcNu{KuyIZ!59|50TWi{cL7wYi6wT++N?>#@Nz=g`SI^k@mTft?g$UZUzSP z|M~-ZOKU?0RyeT=a1*4@V#+oU2)Z`(KbW5a*~Sn^u-|*3xAKmO+cOT1@^+IQ2YYdG zPv1RHqlkcb!F?n7>M4eS@~Yjh=&Mdz;LJ(64>DP5^KMPakAmkvUr`I2Jw`@;9P~IK z)$?oG%QtXTA0EY7&k95YZ)8Zkr#f4!sT$?7>4_xnoxX_bWRx5hy8mfIr}d(LbN?|H z9sVf>^yh%^|9|*@dJ+WUnRF2j4i5h2D@T&>Iq%On%tblgB9gkkNnkhssa#4G7#Qe! zI$`LZD-Vr~HV&*e*Lt_t7t=0#^}MI!x@MDQfl^7_Oj=ElC#3vp%NM3&1uK)Lh5Fm$ z#b&d0aW4e@81=fIR+vw%uJs5*Z&3%0I8 zjxbWq_3MRJf1AZNB>szK%z^zr2vC{fnqrleaFPg)6yRA{Hz526N9(FJ=90m=wZ5uGk_8hrv-ohCR4$&}@%(p%W zcz!a)r0<}EqUIZBy*L^WF#h`!14n!%aXSODh-hqVT%|@&z-|`1=h*6pHc_lA8a|eh zm4)NvZen6mJn;U*hsA?V(n7~(=#XSHccv=Cs3hazYJ$mLd%}eyVNxv64{uCSAcf@36Fir3xl$6^xAT~CZtPsro z>){JXT3Xr{KR+C95)6zq$o*G^$gggkMcL>mean$aM^LY|U&$+MI3%*EopC)GQ9RzB zDD5(JKHZMnbM;*5jlp$k2mn7~3aJ=R1**?xUGTZADQ0TymbOa=R@-qkm)im{gGu-Z zJP9r9!aG6;Bfo!#YXX7L=d_m8X*0mrNg1Qo0@l0pY|dlAw6Gqhi&PN$7#Z)N!EnC6 zK*VMJ<$WYoczpbawf-dK8rvMhw2Rq#m!lo|!8}EV)xLzz^f3OOR&;^iafZp=i|s)h z;6YQ};h<9zjx0y|?Rj)^vXq`4g?+8M>3s^y^~&A9k$(6r)MknGkeB{%elYu&{3zD- z^qV#fOYdstGMYwZyI*-iCojNpn4x#R^lIUpgfV|`1>tAP)Ad|xw13&rvWV0(b4mLu zVtWiDM0;@fBLjb`z5+Y)bLeW3VJ}#>T*mF&J=431;@ccLvgfqq{WAK*)-Eda(fz%} zoOZ6B@K@tLG4FFH9)qQKBGKW7t0?#&0Rx?8p^SXy&=$q8)((zRP5%*}psY7*Tg^X0 z48(ujM+2FxN*0pptgk-i3v#+ErM0b+R#8WJEz>-*f3x;sY5&RjG5>fe)s>yCYSpom z(I`!kodVOp;Zb(?cq$AuO~y3sz^URT-aSpUK^!-MtEr(D{rCNxjjrLt!@8EITc3Qi z2IW2$Dr;@!w*0$0a><_m0I4@|ie6)=(IcM}KlT_f_UEY&V~glr>Dt{WW=0}<*`(uR zW8r^9A}fu~AOnFeJqFBpEeU@$;*-1YH{834+rq18Q;6W&^oMIlR6AtO51GbUIj-!K z_^OOdPETt#Hx}$3#x2ViM|I7J9xeSPSfC`#uA1ah+G`)d>la-!ZGJF#)(akXaH zR!_L$uAx)Ae8jqiKVFjy^RQ+){3Xmv#&U|>ZX2ZQZYiH-{#G4vp>8fQXqjCBoyTE^U4i8Q* za(!mzP6Hm>t;&(wmLM&eBYp7OIZJ76MSzq9jWw~6?{<$GoRCNRy1(L2l^M)%=ma)>`&NA$dZ}e0JJNYSSoXX4bWbWPWnUNNVx;M)@XO8ue8u8yniBi`vno{0&HAi?egaI7<*JX|-Bb_ih=g4tXnblB)ch*9@8n30nWwDXKFqWj@kHd+rXx zDO1T7hbtf`Uwd?zRADtxtka6qamMi>~FH+i_S808^4t%F8zL|I2zm=2+|HAiL zbbWt|=I`t^K~)lGzBaF$$*WR1#Ci8Eh6umilVIB4b44)+C>1y^0(si|%Y#qyFIU8h z(yF^8uMX#K1#J25uz&`S#7lr1D zZx@88ha-y<5+!|^f#C>E-O)bPpQoNb`O{>Rtlczufct3BM{oF%(CDLydIV_z?ZL#yd+4&I@aUQkn-SFf4EOjn#6;y`4cjb#9 zZn04QO%k%rksiBE)aOK3ur^n`xm89W*PU+w1#6Px`B?jaBTMj4byYl zNn20h1a!y#ZWojHaye3!rx~ngKX?CwIK9WN(Ofq8+~CPIG^O`8Xkr_+E$yYl*cd+E z^)(zxx`UX2>H5*&>T9S)z*Wh#0^8Im|Jf%J|<(29p<+*6hZ*^0y zWac#`YmAfR9jo!Ovf*IoY#NIFYm0L~kIUZsI$Z#4C#R=a?XV4wgOf z2e|u(F~=Tq<(b0kZ}X{X z-#r6Wc3!rK0U;|PFMp14_LTl4xDj$*-pzP>Fa_EE%fEAj3fqBh(n{y1x~wYByc3yn zVQXqqJch=T$26cmgWsir&b)YX;=6~2y8W~jcS_bOl9<3^GofjH7D>3^rmHrTvOO8P zi5AmMR(LqT=WVvyi@o?c*gu3B&tmmcr6(=CsDvxJPVg&LHYV&S4!hxt}mf;nShsQO#XPs#KTT?2n%!J+0k<9TgP z>eQEkLt1%Y!2EOYT;KjLv}ye3TTkM=3e-xI`lwW3t6pwLnNT3er@=GHV6 z#QX)@{jY#X<;`PdCR|bshU`e>F$H~!hJ{=Y%tYU;Ni2mG!6jd6AzG9!YY<|Ga~Qoj z{n<9oe^6J!UEQ{YTyWvpm_Ue=NPIfS*2q#L&D&bbk!hK?PUcWg{lR)N@ZA};@#H7F zf3SgavSbf$3D@kzHK)KdYuIE)ke8?i*^`yU`z6s>an}rD13&yV-{e9bC8;0G(k1I! zL?~18P;l$UOD8u;W=giWS0;QS7B;Qk3+?8MNNCj_AJX%OD{={UyeXk*u06g{n?don zQVP#VxbxVcik+ zY88ElFLqP*Lb|YRm12v3yJsyuFUwr-@R}LWcl3yQAae>a5RLm;Kt{3kL(Wk?;|hV z_Rh$UX>cKaz<5CL*twNso_x&=iJG;;3b9*~|;oO{lfU{3?!SE9Yf4M@yNj&1>@atW*?_Zfo+9ndY0RY; zvCiSi*nae_`Hu_h&T!-zat;BEM|7<&`AW#Wl${=%QagOfQu0uRsTtv2gBDnMFx zH0b@yw|_(1%uuC^w*U9WMsfd0sAy99gg$$}!z>?e()$?|HrHowdI_rZVYGx4VpKH96@vowC>2+sFM#o*2q zbxoH{DCrsLTFu?SDoV(nIh8oMoorazhD_`HscS7&?K zGU+0jH3NX@XgV3w90hA{6PIRUg%HB7USCY%v1#pyRXhWbZ#^HreZ>)*5t z4=-`8Dg5pm9!@WbXRJc2JT`~XyK}A2E_{W>IvU)V`jMp>5wUzVCz0(1`~X@9L>9Z@ z&KRz(bM%+0C}_F)7GP67?rxQ6aYhR@2ci@;lyk3^Zzbhr&pGWjv9hI-4(p_(r5QXH zK%$YQ#IA3R>VDIUK!Oq{ZYCuiCauO7yIJKW`1i~u#1AI(2HSD>-O=(_yuq#kwC}zL^4Cfl$u-%~yg*+O_d#k_ZmM(s%!y-B;;g;5Q z_^27(c+n2`i1)uxOFStXXb}xNcShYHQeCeaVN|kpVSvV_X@_Rh{;niwGL|AjL#oQ; z$Zu`j6!~k?aqsGi^cynwsP>QlBqa;4R)ZWOMi3t`!pM8ZV1Y7Il1Ou#hVjk1X0PE2 zkIh6raE;Y+HZe994{%wDdsV|5%j-kwZEbDe9dA-RZo8YjU;%^lBnXF&jDjMg?MP5i z5D5*9PT>Z+T6W7jOEUXGHURQZm_|66+m)=1b491b86*gc_r8TR*p(apuwiXX$W(Pv zA*no-)Y997ix`#~%+R2_Jvu3HB_~N*+>CN`%dT=x?6N-i^L6f!n8Bh(zB%U;CHz+~ z(uQn^tklrZkdUZo%4uCPpNsYNxfQ#`wAfgII*d}W4m{w{0ELI;qVDX>4U2&KoR#%E zrFitmQUl4t5qdC01<~f2WD1|jO+*f@}3;^V7p zhiv-#JLC8fHkBK84%O<*Hzegrt=Y=uAyadXU4P1A*ne!+ zI`vDHV}QL5@d;6?W~2M>B%YYk0se&JV_W)$a~)=8W~DMCjD>}TWEWvkQQh)ri1r}3s9W0XWa-a)pItGqRd?i#^INGpZ!o&C zdTQy(-fY?5Gf;*t8`Sfm_*Y^~(LrJ1Dn;bY^?Z`U>_R`!UIrKg*kyibgdO4x^~+9k z3!jT@)})x3OA?l$oaM>Z80=t){_RawWMpJuSlF5B4w#`uLZ@s67~d?V%yE{B3n!?1~VUQxTgISqLG z$1rj;12->7 zKMsE`>KIA(QkFjOJ|cxdA;psojZSH%#rO2z5um`qAMV`O_cOg~M{_tFr zxQVaQ(FsAfKEzyS6N{_lXwS6vGg)t3VOZxk`VghMi|6#i$J>W?;&VSlrJecWnkA<;rfAZ>Lum)-^>ScI6nvJf~hejNK0vdSj33u4ZQ6b&?W|Ph!#|hw2&W2_ELEd5D6l8vrNP+`igQ z7mT1(OB1qBFiNJVbM4T#XEtq<|2=3x5<&I0GbRn4u_JosJQ}4p$TyZyE2-5uVr0@jn?&27a1V(b~senXN02rx?bi6GgQ|R zmutqAIp!era?RP-ls(`|T%09rLk-Gn(+Ax9hq-9zBP6f3g&W4m)A$)QhVeb`aK>lE zRaZYK%NHm?Wq?IP;er*Vswldv65Q}k5x?TIb)(+^SJoB?35%5C_c81Ev&)B#7HO|uLY%+haJ_2_p8&L^2 z<&wZ-)}>MSjesdOVcKxV+JgP)+rpyf^6pC8N4d=Jj-ecU1 z$*vt05{=fL>%B7;OSgp`z52}h@I(M^93bwtFZTm z7TR^msZm7oUsku7+K6&HR~R*|BoP?LM>!^G$Ll8zy;2Ycr6)W*e0;|q%;6*TP_RMY z)Yq8c4hzi5tdne-;Uv_5jq2UOUb(V zH*_HmjZ=y`3{NbL4KkQV*b^E?w}rR5cl|&-YKQO)tqnAk>7pvy8~+~T3EltX^;+La z)Mc6q2(T(_@75=Ncro;19sIi~6QCre)8Baf^zu>tMQY=}L;em8G5hz^+oifhkR3UN z(NYBFbehOx%E$qmWFJE2v{qZ6x!rWj!G?k5AxHiW;Ln_A59E=^SH9BmvzN5Tn&<20 z6Fq+j(5)=H{J#)9`BeQ3{~KG9N44Jtr7J{jBD2`AN4^=s3uoz=@LC16tTyUANdzjI zWc*2J)Go|cb=qCrT$o7!PrQ6JBg%y8qx-U?=X&byFkqE4%&)Ewd$jxwVBB7Z5}voY zJ-G#(J?Qa4rkTWij?Dg8?W7ljM578#5rbxruIa~=%h2ooyDhm4XE|tI3;#gpphwQ3 zRwe1^xWFE2$XVi0ekezbGp%NL6M<;9hpDYM&y2QOL%-^@rog|mA@dAS6*ZA-JyXva zEuUXl-B~4T)L??&+1JXRe|z&Vk00o`c7)Qx(PE4vjxR!y=W4~(C=$*lq+K)+mmHEG z#|dYHG_N|{2NI^AIsf*?5G8#C>FIqGMLv)Ue2|kj(&+OD8)8;mSAp|H9 z@Y3C+9!V`a-x$7NxvGEK(b?L!=}E~(Bem_GCJpPwm332W$&lZ)5UJ2z*R0+V*bcH=R#x6 zIzj%GYob(Lcnj84LUJ-mW36uNI#FMx`}&3qL3PkRHh)I$zbii!8#2$JY;jRjf2Xx5 zcmKUpK?yEkNmSg=-I7hQ%;PB&C#T=Q>#eFLJd&hiL1mQq9Lcw7B{v5rawav%N}coP zJ}Xe90yz4yjlS4@q_ZR{r$U)R=?P3xPgIxCn$c-26Te3V3@>958ekVG0IQ)lO_iLK zduWlDH~*sf&HW5t=gz-70%gN<Zv6?saH%Y0Ze3C?q4B{D!x zEKZn=LoDbS|D=Jdg&wZX`swGrkal~=t<&6hGP*Kt>5}r8eE6Z`x?X8bCaG6top1K~ z#YO%j%TOLRRq+q<05>kCqwa|Xc#eH#VluCcdnv+QMqaQPFzT1T!nF#7puytg6B?}t zasSK#z?+ggv)hsH9Hb*@Dsjkd5rqvE&T(-#1?9%$qrA`CaIJ^3>V5zkP+w<mx*C)aiAEtHJU z%>>M!sY7PC&H!9Vw#LoT4Cy2JknWY}a#w6;0dn)+VmzuKwfYT*P32j8_2u&Yp;}=d zGR2T8NodhI;@GA;){s%3ec@6`6XGsb^yeP!I4U&Tk)WfQwaSS*oV(>>zww5KhgpBQ z1*}#KPjq1aP`;hR{-zD;{6rp)73U3wpg}&}acO)LVC9A?6>J-{!k=Pm=*2kvy8EV; zg#q<=9K`<^b&|Mq6%B7(Im`T5Qq_6-Lfn+Mt$Nfvky+5O{{S69U-HcPyekhduvzHh zZL)12#dd2#>;BV9bu~1Z;8CDS{$2NnV+*+#nZ~f#GP~x;N!L`|^}d={fWRLskOFm5 zr*LA>aDcVB)X3HGEUPRqN6v_%%>+-lU<;5WInHik*N#I+Bcg3JI;{vm!v|RIIi?Eqqthc{B;XO26WGfEW=4CBH8x}a5 zi$_PXuqdNn;-5nN3z{3IPBzcAq`Q4%>9EEW>F|Yjmf_^=->L)2Wzf3?hj3Kc7e6MRPuNPa1rk&Q7gBDi+}>eA#u)|-%!L<(q9bz z9?6U4EEgP!1t248wY2<-br&N|)3d7GAqSa2;^)G027XIplHy^_*0Ykw2W~J<$6PG& z$#ewgCvjxW589Yio|eNApk=XYSJMrTF7vN$ekvwUjg|PmuHXm+;%6~4SU`T#)8qBA zRn$+rylU%fGzDS)0pCOJamn|e^W5l_NO$TJ0h=IkB%kEHAZ9Uv-&!mf%emiu_0BB@JXD;rR3m?-uazfQkc}je z5CQv7#VvYOmhF!;&1y(4IAHR7u@BKI&Y&Tcsm?|2vf`_OgNh&YF5jR_B*qry(C6Ry zC8C|UqJ7%rCYHc2DAM3D16Sd)-B>1P-FbN%B>7g94Ba)>1EwB{cGA^TxDvO%ikF>P zqFJ!5^S(Odrg^JwUA8(!(@7NfWyP&9LTJ>IoPKlt+2Z4)MF9Ih!>azrm}Qk@S(O@v z=ffp&ixs0MQGP`FvR!JRtRTMms+`gtN_f%I3$AIBbi>4(;qe;pVgy(R4{H`@Tqm`C zg$(9CiOYs8@7k}Re^Ltu`&R?(Uv{ZQR=VHzXv@NDjD;u1U2NuJE|=xzN=Dox$J&7x zBF@2yLl}~!&yeml=5UiX&02LkcK4;gZyZLJ6R=HG4&o$M!TPlmzqbYmreFAN4FobA z)=&Gc5IT^yGS254oM7<_J-T;XWDvX$KxVL3iKrCX$3>r9WofB-6r^oEjcQnPq_SGu zU$|dU;|Jq2*$LHOq;DM52E7px%3dGTfJdR<$ryYgt9-vP;liiQ?EvBkx{hjVAW3tM*qxyXRED>D!t8r~RRY(ts-BpR$KWMoz`Vamg)eQ{iq0?FHVxy8m*%Tdiwiyd@^X%Qd^#ebrd^?ewe*N=w8fph1WwVUQZCfb?k&5?bK4>%5! zI5y&dYLqBNxU<*j-YO8U`!lTjxpUmLFi53wky+9{TOV96|KdK|zMZ!X>J^xZ-yB&> zvYhx0kP2%#5zIV|A})zds9vL!pW?2^r{S7oQ^LqSrFZh2I6kfd*&~c)nFV6l_iD{E zxUZMiyC_W8%>W|dK|7FC<&;ih@{5)kG|S^-ywOYyAD#{zWYTZ-vAo7cWZ*IUdRdDJ z5Tu{%qz<8nQ{SgBipM~wwbGC2pdGhudU;m4sPp{0-F9&{v-sc7UQvpur<5vzdcDSS-*GxD;zS^yR2ZbItL6haCDW@vKtWZ8&JceF> z=!Y;WK6Bd{d{BT`6Sf(3EGug`Xc(f$C5l8{>#YR}sj{njD*~)Wr2(~~Vf|#Kv7lLF zV?$;Tq#k8Q7irKVsz}hw_Pqjfgx#3B=!Xx;y)g`(3!fRCkBuxEE)0MT%wf`0)Ac|Y zHGOf4;49#pWz;(N*qQ7;Z0j|+pA}p4?RkSax8maCYp}J`F0sM7>RY#-DP&dqC&&_< zZ{w56a=rFEA3xoh0zR|XgzRRis+AUy>#MmtgZ=qt-mC3WRulQ_P*Q>Geb@oMGom?< zJHF!L;`Zd1WMs{mRiSh6W0Lans2=-DU1|u*9FWgVW=%_>gvzU#$t2a*d*3T!L}>aLVitEj&SMjg*C z5f!S551ZlftO=e3X>=DfmxUVl`HP)oVmu`kmy}!yX6f&8_-#-s)9CI72>qb?-DH>D zG{r&d$7koRWY^Pfbm&+T(Z zydF2Fcc+Z$-m04hEcgb{eYH2(bdKqHmb4bWTo3m^nWubFd50aoDGH>R z$qMscARpj!SP%iaylvt0=d~mU>pr$INBbu3&-0L*%M;z*>FPwc(+QwAU~zH(DKnOP z_Uzg94LPXbF%KNdl*}tLM;h0^%UE|{*JJ2ZbukKF#Mr#DtU_2gUi7#`)4CiKlFWM+ z&MX5t@Nt-R^5@yBiv%(2M1aw7{6{?bjQ9y6kHannIXStf0$^bU>Mr}}BlzbQO0P7H zCfb%NxIp9BtF9imT@?=NSefk)L)(y!o3zM!`GQP89kPfBXmf_*4J}t!-c@6JF0Pp? zfOIYZSsu5WzK@Xr9A#SI29d<%%DcPv@ie`ia3Cx2S62qWaonRbQgM)Dtp=DH=G^|~ znesx+IPuNZd+sK1o?0XVi;q()TR=>rV0Ws4@17+LAZ_3aT}x>+F@@NkVTB*wce@AS zKXBq*FJ8P*vl~&Ew(2BK z1Qus6`rbmQFE}{3&7u+$V2U zfYZuXxOwT_26}|Gu*?bCX0HfaDIzh7DQ3wu-Bi+ zWi#IBAt23vL1ATOWj0+E&ZOHhnDHJHnjV1J7gjwBY!I&ym(U9e*W*$%J*Rb_X@jfS zr>*VGii(#h&VFNRF$%9-gExo=ZeUehie)jv|Da4_eDjtVUS0|lFz5)zcfDANiOmWG zM(97{3@5BesO$%F+O+@1gGF)a^tW2NHa*RMi~{unvFZaL@{ptN5;x0T?AYuN--n1gaxSZz z;AboCS+r6rOCNqeQYrj`o*tk}Kdk4VBI3J8M<$CiLgh)TS`pmK(3luar+WCCW#BV# z!h_iX{^{!`pq?vNnBlJ_+B{LMFavVhE|P6Eh?79D3zY$FpYkL_@m$01B66c*OzG(* zr#bBvr^)E5dnX<0K>T{SpEpp2uIJg6f?GOA`qYH3>5Q&C-<&@E3q0daD^ZH)Knw?_ z4B!H{nKG}m>ZPk3OnnPGPz|1Etp$Z4!)C2NUumI!0r^iS9sKahQ7p?|!MEd`+8RYek>RkxK&nbbdtNzXPq+DQdb! z5wMvs>a;!HZMd=kwdGUp*5&DrIGb7w1CT0Kh*um>gOZ^5acki55{1JQ4ih_w0wk92 z06oU;5GWOx+o3g4xQOQQ)1@mNnG#sMva%JN`7KN_=xvXi-yQi9I$uLY+O2P5o-rzD z-=Lowq%l-r;h$7yVmsHlZ4Xs6%6I+@3w@(F6;D&6n;MHq~7<7{D%a5UWd} zsZf+HDiU2gXyhltA(TP=coNEj$wmMu$n3uGsjy(DtJg2Gcyyqe2f))Y^_YFjwQtCl zd3iH=;IEpzIT`+=d_)k;>Ny`TU+d7{G!yzynC0Xe0Ii9lvwwC#7uU<#q^9C zBWDxZ++|EU+KqtHF$GG;7g+uk^DH_Bh*3R*d6*0>6nyf8N)1Nq|A1IQWzTx33 zqnA%Gat`mWRB@y-Osi%9zLTCyG~m#aWdIY+y9Upz-keN=!04t#7GrC+ocTdm=z+QQ zp3R%vK2$z8GT+t*R-77DcNnc&o={OD-3h&l+(9=w1lpQANQeOBe0n4au;lO4-d69%@Jtr(8BzJc z7_#MM+mVnxD}z2E#Ve>Abpf`?yyc6psxmMspu!fKRVDy=`w6Zx2TaibaUaFnt4}qx z->;IZYgO#N=4E4`W8~m?Q+Z0nF=tMX5%@KOGa26HJct%7EDhItqw3v@A>#V7yr=+qaX;hBT=+;2Wm+86*3|hh zT|7!l7o&J8Kka$zYFA~AHyPR4nE3dCGZp|ClMSwbZ-Tm&HQv+I@y~3U>GFV$HPmAb z@w}^^I{c~2+NhA4-TCFMdDTiC&MdWzP+K~*;>2To>m+f>A1q#8)?4jQ67P#=t3F>0 zdM_ph(K_3mf#$Kum(tAE%VLX5OE+r2z&VPkh2uyKG}4pzhTi5RiW8q;z8Q$@XXwJA z&NE-ZOnw&E^aaz=;B5exkqQpZSdA(hTJ2V^9rn-^4uT!#x<|_I8mnqqAH`-m zx_@&vH(X{s3{lwRxi1#qMVpffRxQVS1yL%TS7s3`3M$-N&s_l&U4FgBHlCy2@6yss zUSnic9dNF8U*BN#033x574!;8pvvPo^@IIvJX^n@f&yyP1L!5}%?)js2tP{ZI+y*MAL2sPDc~3jgHe_i zcA41(Ge|h9X6F#-v8uIX7kbbho$2a>t*Qao## zT;Vb42zlmWVT4E2-D`wX3nTLw-jSfitnRG<=M$FL#xm=+iDXwnUfB1zQFVGJ(pbS1 zyqnYnti~s2PcdGL4AQ?7a5|*GRr?IHHCEWki2CEl58kPr-P!ttvNBeQ;S7N2^VO@B??Dcv0EgSGmb)-QiMSS>8iAV$TJgcIrF_-u4}5E~pABg&?+o(! zH+YGd!#tGkK#u;h#EnyZ^>H?t1emtv&cU$#Q;A`^x0bsjp;i=7T44vPtaNMacLCU_+*j27Zsy2R9UAOVkFZ2^i?4_D%`_33ff$!?Vm zP#_mkMudgxa_(Uu#!rcbZ{)ct6TCLjk=%VZAX}uHV7!62U+r*!2Yly)fMzt3dySR}621=d$>F~B`Qw+7 zccpY%Wp+6rYajLJ#V*xUweayhcWH^XuY88_T0lG%WuG#pw;k-sfWW{sa1!r$W7vOV zINN2`1N1!WBYC(2H^*|2JS>bH4WKxk>(wX#IKQVvatT>7OVMVTcHQJoaL-QGk2d|7 z(<<7_(&D7|nXq6>rpl%o+KG z_ncT*i=E)mU~U+Y5STzY zAK*r}^b5106<`@*p8`?)D~}kncLHS2H-84($Y4e8#gK;^f&+_)ZkNZenOq@4A|lr3 z``Q8ulw{AYt+Q3lXDrVoG!L^7#+^9zNLusrU^sO|7=ibcwAw{(G?_%v-lA<}CIR3P zp|&t@cIZsM6BGp6>xT~?a{4hb!iRf#W_qSjr`2@Ty9F!Gc=`BNtLc|FKtL8j(4Uy3 z&%XffjDJlNpeK|Txt{p@fEBV@jl-V9)DX(x{?`h2FpO`WV4!>2cUWZk{$8Z*wS<`2 zbRPZGMHPsp>$L-CVvK0iF~T88lMv?5^KWiX3O(+(;87n3u2X;G-Hjy()E3Z}ZLVz! z33+$s<=N{?mmj`81cB;eM#?-{gO#U!n2q0Y)bGJqNyNw3Z%Hf(3On5^TnwZlu(Ig9 z`w+{93#!UFcOHSeYZd?%*&qOuY7J*e*4^D+@dEpnkg%{7h+Tv#6+rN8j9A)-A74Bn zou1H3)rSr9{Y^Q_iQM$EfCM<8n_g_jTv#}040>N7mce}7e~N*`*vjg5z?0XbJ(8<{ zO3eKoh7WC7Y zlT&{(cB3ZvjR~sF-TPxA1P4#UO`xZVpe>(5-X{!9Ou@WQzdrEpjcIyNQd0Uh zxLsZ5FoXF8STxSkRNWFG?A10e(cu%pU#6bm{G1#yM^W2MPzh*NwcgP9C65R-3kqc* z7s1s)G`YYUIc?@-OS#MrOAGYDT<0FE}*$;ATDB>WNa+aFH*Z9ITQP;K!+pCU5bz6umAKuL!K3KfW2zXsj@ znf!V{O;cVQsavUe?0}EBESfm;z4o&F?@v%Uu(9M}^!8@!FEs8z3+5ZTV$Gd&eLO4; z#U(g&$5SjA;h+sD9iuq9+|-jO5yi7;Ooa#hTakWa{UZlxL$Yh1#6(E6OVFP1(y3OA3v`R&(ZKj~_zT7H2voi*Rmfbb#9EG(9 zMj_D#<4;ugUCT_PF?i-98)xTjdk#HdUd@{!?sb#S(|$^-koV3mFhFb`P61*(S(fwC zb9<&XMy1>Y0~=dmxth)7Zz?F2sD$jnQx>&-Df%GBkew<=Pbz>9YvK|Khzx)wvEsV3 z($L5Pv@0sC1PhNVFISn5hyYlIqEzJPwGMly*X8Xx3%Pj(I-~i@UNmAt84=V~>lKSEgR zTyeVtTtzJ)FrFfV4Kt?U65=rD76bNk&A1Ji=yt&D`Sck;k8q#r0<`7@%>2vE=pK3} zg~lrlqUOw11E(-RLDgoH_yZQOPCYc41gfr)jl2g>2!{8k+Gb71q4`ljXlNFo|MNBK zC&Quw1K|2W0u4W&2t}T5UVhf=Oy&DKGtG*~ld>RL!cJ`<-1_+Vd_7b{MU9?Jwhzu6 z!UecX^%`5Q9VY<&bvOQGy8jdtYI8ugXJF`I(cJ#|Q8O&7<3-k_flcy>C?sMAEpDBt zmB2x#dY41{Ga(&4E=GF0N?3^U3+eTFQ-D+Fs`W-VULgO*jORM^^9VmH zG1JYxH!@Hwl7ZAa4xLW9LL=#3mQACYsDJ=;1>Zf7x3wsvo-nY0&t?Qo5B+H(aMmZb z`lGXex|K3&eY`GHP`k?wqU@(?B|R|3uM{@ka_<0u^lJ&g3JPA{#DIXuP*TFcAWPa5 zJG_VC!6FMKY5lG{ITpy{m+J5inU73(-=l~l`}fsMN7=pP;O>Z_aRmnu0p($0NP~fa zG>h@g2NC^Gnjj)L9SYz!*HTAFIyn9T0qI%=6A_gyI5Q(Icbp6x|3WC`C z_X{J6n(YsI4V3V!b2|E3ZvX-sm5B2jc$vZH3H=!D(uwgBeH2ACD|ql$f=p)%1+gYF zS$3yv)r)sB00Y#}FLJGoT)+QiJ;UPQp9l0K=V}!UjMqOO=*dU>;47E_rw@2err>LJ zN6Fy~KvTM&FZiq34hi$;X#)za%ycXiuxU{82NF%M-ZS6qGXaRl5CS&p!y4$TAcE*? z0)P)c`f5U9!SW5pYd%fs%1y27ekio9xPHHB+R0zon!&9S~O!v z!W8>J!RJRK?F*J)^^*X{iSM$~tP3hODZZquxr+Mc5S)2fOg5m#3ZbNOPEmKDp6~{ zb4YACRYB)+wo7;F1PwurR6y|wTA{&3f>wgU6_^~LNnxgf0vLB5KX~B&Sf3on{s-do z{kK7)VhTuRWbl#@d=>*#KXCRsQu0lnA;UQ%*Ie76##iN|X6F>VtpyeF>;!5e@9 zK$Ge+?VCK_047fPDYJOhl5CFxYf9!Ju6RC!p+;0L;ymraLi5&lox0?$SiGR!QhHm8 z65X!T%!pcHIVS~>QjyXJf!g1UsA}{v115y5Mo;~p5bLb|j!QOotOZipgx?v^myWl_ z!a!oT25)SE-Cqo1I2_jvJLn*^9E66;@3>Zg1A9S$8x8%io$<+Qp?^#^q5z14*4=_5xZJ|Ljmfn(;D$^-H{ZCUH^6+?eQY*y8l&vYPH$EyWP9v1g-nov<*7+ zeJpa>QnZ>4b$_+Q90S2WiNI%#wuQbi3ZFYTm1(>no<~vyvZoa{pKm0n+||eeZ;5lRhhfr`ip6A zUt~@Xhyej@=rw3z(RWv&0#b#wS>6>mSq%;k4eWa{1wz1;l3IKzp7;&r%#M2IJ+7QWbGjJ zddC(kKGC15X*^?SG*`Pypc1qr#Y33&d%jz1n&Kf~zLYxFVFSMm0v6T(m>p0`wU$D# zparzRju28iT?}=||Ed-A-7|-%FZIrT{|LU4^KB^tg#&KBw?L@&_qx^~Q1s^DX+Gw* z5WNZC+|Jv{2~H|4o*wg$Xg9B*oHn=_2RKxJ4ZCi$CYbhJk1Ydi)ejr;7D4mhs*Sjj z+ew9h!7|CF!3d{@9^U>xC;8w?7voWIj@v8#S_>?x^@ah*5LL7FV^2#p;<#lZ1wiLO z8>Csf^rIaUyER|B@?lUy&m{(fJ+aCx=lJ`%w`ifFuZGhKHUazZIohrLg;wYp!F=UX zzdeu!vm|}?I9#D@A6!CRJ7b2LHXwY2lWh){ z-^X)U_6y^xw*mR<8o-2m)#!he_ubK4$N#?{iI$Qg5-Clil+h9zDncTwY*E=F*`r;A zl$~fO*?Z4I6e1F`BC_}1_wl0dxZnFb=l<@w=iGm8=X7+c_viC^zs7Su9*@`U&uB#e zrfHnb9vylAc$1P`WW7zuiSguLe{8$W`%k))W>?0K81;RmAbg>{0o9H^XrUj13rKbdw zcpIhfiOB;1`zZgb*W8l|3b;9!%zz=e0xE50E6Y6J*acPv0x zL-R#oLm=N(!-oE+9`Rb0R53^2#OSTMU}U;37$?$DdDqUvXX2`jtOI!Fe}w8$|LB{d zPMI8MjaFae3=KabKD7;A|m$9bng4PTKDWt znxl7CNZ9NlY|?5mUh9QcG?m}sdEsc&C2#C@U32jUDsaJY_b!*vKB z>?cIm*UDc~MO{i-dE+pr{AU}ds}V*o9yeKY>TY1?&7dLx%r^jF>VC3oo7-Ed;6&c( z`|X>XG${YAYN6+s-CMac>7Knj$9H=@c7=|dTVaP*ts4;8dG2v^r2%R>6A#_!_EcJY zZ-P7(cLtLA>uG9gww-U0L(@GkJ&l-e64Czfi^>cuQ8P&!Y5bL2wcH7MDC?~#_1I;MjGi96ZzF4oV zTC(SdEb4S~y_rwZ1oTSBjtCOkZL+>m++S)!AK6uOBZCe~mYu&wK0~Qqi8-8B~vh^J~^4?5|R3QjQXAt)8 z2>NYys3zHX6N2G)!QtyXzl5mT&z`7+;c{`^6jhvBJ+{^Iu{0o9fD&7O0F?OrnDYP% zDR}o1Z*|rLa9z~iT|`glHj1$ddMI4du3;<6nH%LJ2OH?MKb&Qg<2m!C*yX9CKU8Pc zUOZeXkH`sdhwCHxT!1+}^hjpot#&xFi9n7wC8qRHXA|Mfu{zWC_F$(!T@f*~ztHz1O#%3zVEkRs`}eyMNPVTC13m{}vhI%n z-MNe-X(!%nW|%3slRWu2Hab_wkL_Td4Z7|9X?t@=Dk_eEGUM6y?y4)TMp`g-jGne% zW8hNt&ykmsT+r(wi74H+c{Za;!7wDEQa-$|WP?Si!pl?s4SmAE&|xmV1og+yIXP3_ zHch<|zg|fH6T4bLrSj{D?=JRj6TbyTM1~9+Vh`kOo?3OVHsYj-*aB)NqCCJu=r><^ z5$4lN^8chHdHrQEBLg3Ije;4F@RP|u_rz@YM1}aLvN)ijd<4+v&6e)XPJK7uW}oTb zu-e*8%kW4+6&OAKru%IwX_LS}O6IJ#C%xQfumH6gR($uh*D^CRcgQb!M{1U)U+NUf zb#jf{le9inGa2q?Sp>bhj$Srk*?TTvYi29k7rS(CeZg@wo zh=p$6nPX^XcGf2BYI2-5eksMkAhx?kq1;%$dEk0>+p^6mS&{-$H)CEhMSmrnha8*J z{{5C35gnC5>o;wDhr&4LaWuyy#Ko7cSh0fG+?o96GBlgay(H1r&!1waEJMM@UhY%S zW*ZrmSZ{>CO#2Yy{RF(HB3fN|tT&?L_63G8?#%tqzq`1~{oo^%jU=~chh$bI04V?M zaHJa6#GE>#l7F#Nj|cfp>JI_aQ3yUXBp2;o7Bet#d{)1q5pf^g#ZH}>FMzOJ^F@{O z&9pRuumL8$Nl%9gay~X~8Zh&U7g05W$V7t8@D;-6-faDg3ZHcv?GGejxAw}2XA(ZI zl;-T045s=^2XE(C7aa&TBou(YOrOc<;jAB(c@z>>j=(nG-O@-?Y_Mn6^yKP1QtpWj z$bG*uW6MLYLUj5$JBQhsGF?A=`v@IfH?&3$wH?tLqivFf%iZM%oiuoJy|(s-ZBn`u zJxCDS;`w|F0TnwHmsIr13c8*0ZKw}Y4RnROJn$eJr}j#v06f^g0izA?_Y8On@)B^X zZJQ%r?!)$L)DP==*W6gaDNjWMt_A2LZe2gNcP0!y@CXQOIajA+lI(b5b>69W7w-U{ zHW_1R=5K53l~36K@CG!OGR?&RqR?8O2qIH>G^5?SUG{`a=i+V~_;09a2v_YCJ`>k; z)WOL;o<%Ix4b{De5-V=+b)JC*;8ja~(vV@bo|TnoD5gzyMXXp=Ib-PgWv7*kqV;N? zUGZu`VM?g~+I>88s$gK*vlERvW`DtUfBH__*x51`Q2uH-S@#B!*V_GlNfCNhMQA8J zEN=T^W#5v&pyhd^qkQWzIEv#op(<_s&YQ~gKLyVBh7HUn*xB;7ZLV7aG{Hf&I}^SZ zEE~T^4$N+~iz+;Mr>;Eix;i$5{;M<$n`>$5UKPV1k@!13w3sO&dg2s zr#6^;JvuCn#MQl^<%O|O#BD^y6&(HF4YKr>b-I$vm5%?RTPzJTLy2g?YuN(lvsQB7Ogo(x76; z?Bm!d$}j4xno}=qea6+9y)s_CT){%KGKr-&LrvdR9eZJDMS##2lAr^V3~<4lay#^R zsD2@jncFKRZqAtWCvVdw)@lC@{Ld|T>!>DnV2fJmb#(5JbvXIjp!!$u=wwE?>gqd0 zOQf^R3b^~o`yZa26u#Dq;}fz3KoLlv%B7eza5fdcnD_DaZYy*V->&?@*fQ(YB2N2x zRPZ{qEq-f$eU(XU$p-4p8JQxaFHuF`9#&@ci&nOVNYnUQ8RR30*ds^)jkjN}*up7q zV_a`h64CtoA7E^sjIS-%+lx>|!SqQO=@JZOTiDy$X7DCH9FG#Ij06{q6fMLvw`0qZ zV6Z;TqIh%;1(c46c=7P01t`)7rI>miA2DlQ-M!RNn<$604rs++-d^0$@Wq~wS|zYD zF7wxNH~o*5!Tqg6=iC-Qj~Aaus_6Kw+G=-Sn{hf@n+5r`=#%M!?ALcVfZ2<8`~Y#5 z6$j5X3+|bz7V^UZEpDjHBgoTZ-!ja>?m>ZmfvupiL69m$zw#XmO-clVr}NP1Gs6jw zH3`}4=cRb&ho+!Y$0ghr5uw{68oq(D&;S~$G7zFG1Im@NMFczMW`84l$2#%t9;hh9 zM4j6^J_?}S1Ec=yQN}wcg(W|acCvkV5S{(DQRyIr!Jf_+?Vc(C_u|CXiv5iSGYgw7hoTjlv4Vg_vuZ!7?yzMP zDma^={s=jC5I|1W1qqrxyR9bPf99IgSItjFZDQkw!FZXwnUi9SJ$;|{s>C|&W8OXwBzXCHf$U6$;_XJ13qo>ml}CzNR!$OKwb3{uvuF)l+8ee7zE`a}ZBiYXskS#DWDXW(l-KLzl9=>m;A$GxjnjS`_+1nB2vgNG zyZ?st$bo>Utc(0loV@-H6~JmwgS}Qf4Fjx7vJ=ida`%Srdh9!Ao?^^!IV#u&tsh7o zMDmY~yjSK~YWMC<(Y-#}+REtqE8pI*Esos=E2MDQ=FHK|S2=pyo}K(-jqszn>l5Pe z!x9Sq{d#3L2Fh~}sO+Jw6m1CV7g;|sE~I|#ys*L>Hf%yg=%IpOrc*X@Y2unVD;_tC zv)uLsjKBSW=Z5Ddrz00w)o?FmoY!3229k;^Hi%)e`F;?aFLr~(v{grcS3r5PU&VRe*Ve)AWFav;` z5F}I+AP2oo8(^Eec$$CFnOFMC?Tqk z;|e=GP)}R4odB9y1~80|adEfCC_d|=76 z-e~wgfUbSh?tScpljWRT&V4U03Ud<}_D=ajq<=t}=?y3X;+x~%bXOJ7@I34aqYP3+%vYJRO8WI7fVic>| z)%6vdQ1aESYJ<$}`|qFOGY25~qafn^EO6#tj1TADqUXzS@fqnr(5NGWxtM7bJW z6M_+N&H4lBDiI?LLaaTnkdU{)*F)Qy_M@TzWSgXn%$~7ylCB|3t^`)v=)k5VgDM@+ zsQ~$luQ7c3^r`jCU}2V0hJprm5UOWS)-tVm(jRj*O7f4J&}Y3h@M874vyYvAZjdWJ zbT2QFkaac8H9kw8$eP_|y(p>xPUjB^_zel6mr#NFUFgw{$>bgkgyy*K^c*V3q%}d{ z^MIG2Q&Y{Ww|HMTRc*=m_8&msT6$6* zg_1(km)goVyJ-iSJk=%76>I$rot&>V^WXV5mk@_~^8a2fi_xY54H9b%rWPqVM!4)H ziu>p=2cXfi4|vMIOrGynIblAzu^ zVs%0NSBs1f!QOIykfjO<{BLz;9zUj|pbR5*BT|XSBqig$R7e2I`OV$~+Q0sAcOR6F z&63K3tr-qv9snA@=X>-7wTo6jEZBiTdsu-Dj;pzU2Vc0Zp7EG{B&sZ=8G8Nqr~S~P zXIrxj9GhL$Y8Gx+mqk)9TT>pRDTbz8aqZP$v|Ej@)yD52Ei|HZhwZO5*iwKBZy;e% zQk*X#Yn2YIqSQ6W5H$;#D}aD!Y_~ac_`4aY?oY}8&ukv;I2D!y zMl5_;BTw5M9^`#M*GXg>2iPP;sQ)pCSWxlajK?59xB?i*fAuRHE&XP;_Z%me7!_w< zX6n+_aD7&9teUIR-Cjd?5NABdYT=Au*N!rCp#CYOTU+*Ew}JB~o%7ecAW#AZFowV? z4~=#urm6tC;+XOZg+e(Sl)x*#g1?rVZTls zNA4fWu-5bJ-h!ZueFNYA4MrNgpz|1c!)nmPlaXEY-D>@^(e`}1*^8KOc}wDz`fZEI(3XUt&G$XC%8&Y1?dzycekB`3Bsvu#m?N>{ zM$@!dtQNv5b-U!a7X;3(_c?pcsV|wp9``219hBnLRSW);8MpJIFzQJUB_1JL=Jt|)Pq(tLXB zP4+q0!-nHtof`jzCO6IrBI{USndqp}KmCN|b*25x&Lo^`YW2H%G-L~w_-Buht z!w$f@6MUvL;<=oXfXrVr%S_X0!9+TvpC(gOWIo+%LuPmM;u3Xd2}@K8TVE}y>+}(^ z_oIt7`c+&$omM->bs(=aG&-TvscU1S+3K-N6Z@Rc(53+5VUvNDE$TUhn?BRpq&a)( zRrhn22R8Kw9ylURANzw=$IoRVBA-TOwA7k5^hnGKG~J#^2>78_EShmMoyZWIgKsc+ z2Uy0zKC9_3md4A^eYz;twzrNGepp%EcYmJEJy}~@ls+4Tshr!R`%2tIodf2c%pSra>&M)p@ORHyx8&3F)^v~EGi4GKr2nZbzSK7NdU;PFpzI9Mel-{hOQC(VNnZh{Lwtrr7=h+__k?$;r^@)@1CtC?IyYzrgAh)- zC5?QmsSj4GC=<3>7wayw=d{CW%tPoMc4|N!K2B1-Ow(}jgHDkTa#_i2vcAuDd>Nfq zecB4Oiv1g?&k8N6SOo7PSNABOc8AB%48LBy4p?BY#@zS1hH}lIi zjCckOLjL^>uR`7hbB~EO>zaG?o;-aqX8-`YMjIvzHRkE)&@(n0LNFT-t)VO@aX4zK zZTS_h>>_3kQEA#s2M9%0$L$TpzNPDfLg8w**V*GM_Y8f8Z9G{Sjn~fa$BFs!D$}*t zLTLXQfr7D}%$J-fS{~DMXk!e!Wjw1kDDlqF6)}x6*g}lP)V7Htw?q21VPI-qx0)0yzcr zj?_eu7z7v)tKsc~(XD{hP<^MbjFo}R#p#Q_IzrNOf_c_oZJ12c_6}VH;?mO{)g_8d z5?SCc5U2}b(W^74{$JGox+Wt}uZkTQ3ko8&4Nm!542^LcMwh9O5Vj2Q#~6D|g@k>ke7}@LP9KLNE(8-Y*38 zD(OuE>b`>2iF9A3QNlHCNh&S32oVBLZ7^!} zzGP4p8+cPUZ^_R#H08y^A1OeJo&|*3`$KGk#1CR6jYr^&$sW(No6W!y;~`i9rTW5#uDC8 z{I5FQr@&Jwc=(!_WW`nCvqy6dY^*n&e&YFq4}Fs$ON~<1Xjik#gBPlt?5@=EsnDSu zQUu-6**SYMji%=*o(8XsR?|Qz?}q?-a5|4KQ|x<=JO~r*gJ#n|!3;txu|}MV;2SN? zVzj#ghPHDG8!y>I>Y7Ye{G_rDqeL>aYgZge__5uW zMU*#nqxP)Je=66_h$V#yzG1bYCJQK`h@ys~eBYG&-S<5^ol$*Q9;2<-|Ba5QW!7~6 z-1Hen-f`KlGgeDb--xd=>hnz>j%OLD5K{kMz3_cZ*ka~G(fvieYaEXxeTJUbvifW4 z_pA0vLd$0GrZY%i?zU<_!#taUiH6`h3GA4+@GHZ6_KG=7>`Tj!4?-bc{~Fsetw#~N zF0fZyY(FLamByy+T4}W&~7Rj@1Ve_Jee_9#&6o9mvj@>n=!< za6`6JwNy1HCg0FjHJQlL{qa$tK>7_RiUJdk@dYSmAcNd989R6FfN~*GJKO3{4TTf! zcF%|1eiHUG#(EWF)%Vs*R}?I?5o|S%j*X@vI*U*V-PLC?U@7atAkxyo=*xa+Z>OJ= z!taW6+K`_OUwBqx4d(KOdA0rB>e!&0zC5c;q7xiHQzwr<+Q)C^PivvhJPhUVoY9d( z4Yq3*hRrYuzpTKmSF4k9XHZ!7ZpmxX1KR_P4T7!%Vq+tI`%-1XmfT}q0Sod__X5T9 z?3+Z@o*$6dGU~UuW0?jwF7UM(+OPfNL7Qn($iId*zE8Lbuk6MV46ff9;1P~#!k za&hr5l2}l0IA~VZLhJmo1HP)&RAxny#f*h+_Fa9qVhBBp;%agF2+ZTp)5>@ve-(L? zn)qFAIoS^0-a?x1d?s;w2>{50zQKgMxMbQxuYxN&DES-GQ-;BHm?K6Fzv0cZH)TRo zc5HO!SWw6F2`;(o{6o(tetpKm=yB=L(jSt-`Wzx(8gg>(73e%Q`O%`^Zbr23vO>?u zNlRk{3kQDTBUjK>-ZftJ%k{ydsqVEbu|-wScd=K~goK{CPC}HjkHat-wCQZbR&yg9 zo$2>bALz^)n69qnGd$21J<@%#yKikxx;bOdDfFY8@73XAfJ@tmE#hQ?)X&`SLn{n} z9tiO{^Q?+|Wv?-Rq_5Fx^ToSM(~t1dX5NrtmX^l%Jh1Qow?gjXgM)R-1GTeeBjY{Q zd!`eTM^Dx#|B}$^{-XUvq_nHzoE!MG8(3+e6*DL|*YrpV6S}=-siSwy(v%U#2`#}) z5kX=5?~m?9H0nA=v~QG?{J1PPC#JXM;&1GS(_n~1p1xVeuy`fQ-`Q9Kc{9^g_1NZ| zfhvWfsr7WL0v%SV4ea9zJ>j>{;nYi>kyuvR>!W!@J{1d%syL~zLzX*Yk{rc{zVOTA z>@~}S>#4a^<24WVt@O>N#J!+Mh(7T#wY{(fyydOxtk>I|ezY9;obuZ{fS#NZ>)<61 zt;-~Z?S*I#WK#K^7g#qXLaTn}RzcTc<8CUu+_NQBN&4!LYP=7n)t~{YpM%8J=2s`u z;;yx}lD^(sE7%|8y=Xc)9yj^%3<8$U;Qr-mZif%_3!g)|>zr=dO1Dp~ebyu};cP^% zHW)NOYgQ{&yN#o?jAzIT911^gtts!iyC|d+AS1;_ik~j=_rh85KxND-DI+sKCC^Yr z%DzeSY`s#-x~1F6cF=murQ$e{zh0I=WeuvrPXS9TW$C6LARQq1sHR5cqAhy{sl&zXyo^Cy1YZPlA>Bv8=AhkS{1&?!>uXSwvJ@zT<4z#tRa&+ zfm6V7bZ+8zJuW!gzH_Hfmwlz6&0qnu&B(ViX)P{19cTuD?A`|SF|S5uO-jMkc}!h< zc1`DaJL|EESaEcn-=M`lc{4@6@;DjgdO!a02}< ziXgDkO@rvP+BWi>h0+VORfEJJzaScwkcd+%t-|6rKz06L z;l9V~=6ho~Hf`!Y?1;YM5vxA69!vCmaU-2iw|}zJOHqWH0J!1kt!=130Y2@kzbopCP8Hvo8Qh()aLCg?RTE+) z!f{>H_2|d?8j6Y70b137@XQS4(J%Z)r<}IJy8bp{qu7kXz0Z0eqNVs z((ncSCJB@tS@?A&oE=?;B+)f!EORYu*eUp)J$x}VUI8(FdR)>+@O(#OGH!G($ptEm z)CQ?)(kyT}LW9Lu^h=AtPECbE{$a2`^8^W_Q7 ziU?@V?7(~d^D-u?Fl`iC)b?MFY6|kLD|{1TY=ye1_-#eKi8-qyxI8BKr=4J)X<2}^ zq$;h|)r+f7F2qkEE0Nd*545*ftRj~~L9YtG6rJB` zJ(9K0nSNi!9IQ&08YW9_h)`afL0tQmzl$#K{eTEiy~NCfbbVvw9rTByJX7|AO(-ysdtf#;>IH+?QKwy9+j-}F!E!_w7y(intQO0Ws9sS2E(tnZ@5xzvlVQcp9=o` zTRD-ZN+kMdMBEY*eo3s|FI_n@Y7(|?3mVR#HtM9*A$DA@!j9bXiqrFw?ue(wnL;s( zsvY;pw(^vJ&)YPA_BD)~>(E_#im!gW@SeQxQSzn|TCibd4wJ*L%n$BJWW9fNHTm0z z3Jxo`v|J!^F)e4rygONqQwTw5U1s9ym(wk611i zc?SwLL(P1(`@9RBzh$jQObpGifBYB4zaliLGA=z-@@z8T&0>-^W8DnRL)F^cZM_7i zv?+WZ9VedIYU}Ez2{kNCbpUok49Z4wU0ljL&x;-PLUL$->Dj_y_x_}j%G?Qn-1o}p z#4M5lON_$1Y5;Qb*O#q~W2wCmwKCrM2T){qy$jd_8h`tVV@7W>a2tTMN-WdCT5a9> zv{Edg#^U}9K!q!YC($jM%1?`>yydYO0V6^(Li$2%{#BQsOxViHMwaG!mdv0nhUGPbyaCdAY zTjgDZ#55teF%uITh>7KqPSBbu66tGSxb8DV9%ZPQ4peBCY|_vMj=G!XHHlyt!a~UZ zh2!=U<^48%(2E8??d!adKT>45>sfG`Vnh*5h2p?c}4qkr-N^ zLS@iriQ6$8NqdE;|LI?FBp3UJT=@npgfn+DpKKpb`^4qynWr6y=CgR~4ZKFg_hsbI z3&SHH%-M2qp$-23`VY9NbxZc;fSnW^Rw`0ALcwh7xSeL-c zlJ{U33}@MyY#cNn^J;agZ|RnX2+OVk|2;p`E{4l%9V0K1>kJv6dV3crDytV5r!**a z83s8{>1)__?zr+b@H0prfX`gbb*2hDYE$vR+a*N}a)S%p)x~bdUC@26gRkvtT?!9f zgmwiXJ>$LgI?7*>9waUbu9a1kI_2GNp^0D#os?E^SN>%5XOre)Js4Ihyi;Y8isysM zj#dNF^iZ2cH2S>#tH|K#f4fWw@ZR5mQ|iK3;{v1~9*R=u1x~r_2M<($pMNN^J*~k+ zVCT+H_J91Z9xX&8)a3sC`vJK4C7Pax(Ui~tWpe9dwePgo0C#Bu!KlrL%wE=X1KCsx zH18i_B@n=d5rK?fjA{{So2|DS>ChIP>UcA^TP`y)GdN8@;13iIOM$X`&c(&GQ)};~ z#G=9~mlTCoi?VKrlpHkt{$BeC+Zs(TuByk5dOMhW0t2N%^ulV7v$;Ngyr5J8Jf^d^ zq&`_cEO!McaAk4-;-AG;k9JkLP7b$Q0Ky6G5pFo%yh}Ey6{-j0C#&S;+9vDiIYdja zAmrK~qO<@WT`Le;mqE^)<5uNVMRackDAYCc(J1#B#SnMnlA9sJd#*+mdm?h6k z|G4tM4UnUFu7vg=%}ad6(^R_d;O!w)+2-ejDS)hBsZYJmtDf$a@b!o*^yu_Um6^^rI{oNR zYu}7>P{5?D*4(|WVA+@Hw07^s`-!AP)Mbeo3xD)4Vp#vgXFKjoh`Zi zpL&K3I=G%E6QDJtx@0$qD^iz-UD$=rY$<5MeupjIDLc|~32Qp`rOn%?7*_9X8U#Hn z-m1TGhJtoi(5Nn|a$5jvs zAX>&$G*{7lGouqYPtR&yU0n*}&&eW#BwI(Ry|Ds#wIWX^_eyacq=E{uRs(grI|IKDC>rL$aBCagv6#g zwhe<-D;Sg7vQl8{)(<5mC3N{7Tl54$u}uI?@elTXDZasv0Ksi~ld5eSn{u3TYGKwa z(5!!_A8m3Qp1=^A#7sPIe;(!0PJpvBM-5$&|6dcLmq#bN_+lJKO3aSD{vQ+ zAC__Wku-I(O_W?;$gkn`rexvwQtVQ3+&(jZKgM+ zsRTHTGLF#7jp)7Jeh3pvWRTYH9=Y1~#XHD?VlmcJ8&qwQQWtpW`s-To4g~}SzxPzf z1jE{#o5$1*;YIyG{EoVqano3Ulk+3+3^%fK{R0ElI{I&EI!+d_9l7z|22@l(01o(t z;Tx{0YJ}Cp0buMqckJ+&2@u?GSQV~^Z>m(wvP}x+@g3sszZ&GbM55}#k1_`gl zrKGjBHFsw1It98)K^Z5HbP}!59ADT)KTbP@6?>&SGw|eOY?Xx))A!llKhP z(9`caaKHz-odrBj9B7o^yUvP-48_r;LyK%M3K07ZM|^;fVb-*l>zOwGnK-B~gS1Wu zq=%9qk>~L0-qWJUrC(zwQh^5*W@B^+^D|ZQ(Q>{G6 z$=OC^rPsAK0uFPc5OSi1vJ|ea*>IhrCtIb1j;56lRz)aV01GpWi_gD>%5nhmzX>Mz z&-{{8;vs9v<%ymzEg(V_Z#!x*HPU(V^l92{ryu9GnbV}BMsb{6Vc_z_-~ThYFa2

ZFz6Q)Wfr;R#60=DFG_Z|?#6an3%-WQ<&kr&%6u9HB zDeiCHe|tO>jvL;gKC|=}LIOQN2qqhw60XwAii|QcYglgu&H$3AUc^~o&>9Y-iuEQ| z*~9P(J^qd~_o{!852XMk0H|y!0U`mHfYsf?%ljDc*Wog!xo6;t`*gM+f)w9Ax;qdV zNU5TJvsw(R<@4V{#u!zBXt10R;z z&yH3L8vZD;DD~pHVBHf}7+Y&J0+$7+csZqxVDU{e2Wf!_2?agvd$jspt_!RXX{)cOH=(7-?53*FRtgUJ_sg@Bw~b46m}r*^6LSI<1gqp zE;v!xp3-p(-&XLDuRx`Rm}@n=-lThtRv8Th!bBl4h~B)IqIxa^=H3 z9iYw$u+}@Z+!1m}%gT;twwoO)neNLdTUxSeZ)&c^4E)Fy6%{{nh%K-)?*%2LZ^Yd2S7AJYD6=QAz41n+%ucPb&dOa)g9uQ**28?g8m4DEq;<3F z`{$)4KpW+hPoJ8d_d%aKee&BG4u4!7_{Hid4^MI6KJD8p{IF7@#tmtK=R#{EFAA*R zchLB!LdPsNVa?JKjMQfe0P$NPT*#bSQ1j9pfVm=!a)fh|I9Nyf;o-?1IC7(dlt&1R zheYqXSFTh*vlkais&@n-q!^xzzO>_!i_4PTf|ik>WCK|Ks(cbe{g%$qVA}XlZ*N6> zS}JBU42L%RHy|oUCtIIEJn138VnZUs zw|#vkSqOqsQkH3?n7lx(E5enTk6Tz+RYODLX$X8$L~QJNxa7)k#R%G?N|f03R7)vZ zVd3FVx9jQZ?%uZTcc`V9{e)JQm{ngOB#JGO8?hg?KHu2b2)1evG!w!h$7i@fXP^Dd zgxu5C-riZ6NpK6iy}Uwx{`@H#W2~>=Y2_3Z6?OL9IiI}d3H_|O#NM{Hw|J`U&mW{& z7a&*se0wJ@Kjigaa2VudWJ;Yx8#Qgldi-%>wsRdg@PnI=hv$NWLl)p% z5tX5`PF4*O$}zO{?bx^5C2eeM0-y%q^y8+PS*#E5MQF}(wzaoML`R=1EiJtSCLUiN zCuK%bEx!eh#;njo0=;y=2Fz$XH`?PUE{&GQXn|HOBxjJSC47 zOe0OFQPwK0_gkGQ6khNRQQ^>p=SB`XbbtS_2AAWJpZKJ?xZEfwL@o{C$LwI=jNbBeI4wFNt zjE#+1MQjtXC=f4r182c~^r#wGwVvOH-y=%(Xl-eE4eaAJcu^$|#GuJHon74BeS(97 z;W6F;>1cX|dukmM)7y#)`Fr>7U3|doI5%_A&CLzsO1ATJS=+gId8MzG1NtVNtkqbIA&dR{4nKTJ0D-f@>)+Z{X7~`sBf3dipVo_Re#G*GMi3 zS1N{?e&diu}s3rb2?Q0IT_;o))J%IaXk zl~R7x9NxWolgDZ&Df!vdq1wrIu;reoZhb?8%!Lb;&Oa&6AM)vzQz$1T;KcX^1d_np zhWS}DW=470w0sMNLdSrZ-~x`=rAwDaMmjGTX04#m?J&w)Maktb0ZGbsdMwJt#pQc_ zeI!~gAD20Ab=|m@LYXr|!l`6z9A)p|KujJQM{r37u@7h{)F&uZ6beOa(^sm+pRi~6 zRk!vS`B8J9vIIYJ55RKZS28(G6iV!BSYHao*_aH8LNPk|_apv)cyyR~^>6RpEW&H} Q$g4}9Iwu}|LhJVb0BKTJ7ytkO literal 65708 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 WYpx#eK4=ebAZn`WDtVU-U;Ym;(RAbh diff --git a/docs/auto_examples/images/sphx_glr_ex_genz_bcs_005.png b/docs/auto_examples/images/sphx_glr_ex_genz_bcs_005.png new file mode 100644 index 0000000000000000000000000000000000000000..ab496da7fda4891bdd5cc8e00518b6ba573f763a GIT binary patch literal 41216 zcmeFZXH-*b)GkV~Z50p|3rbNb0t$*00Vy^hAVsQDMMQchbOJU|6wuI=-a7=O1QG%& z3L?^b36UBgB-Bs>f%`6SfA@TMd}rJ-&iQf9k8h8?2kfx2*1P6A>oe!`zR}iHVL8Zo zkb!}L1*UpOhk=243i|KBKJbY~de=DkA>(oPfrqa1Qx7i-H!B7W3lA3uXAcM4$Go0a zZtk|uPS-?bM6X=pwej$9ahDYnbNr7BM4jEN#U%EqR)CxQVP0{V|JM={%$ zfg!~acIT#^cfu^*%RhR8zP+#-pn2lc?;{2W{0`oXNjrK#TTLXi8*{S^UN&V|R$&)X zUSVXM|3iPj;@-Q3T?UT%20x0Qu)TRbD}VdcxyS-{3W3MV4XMOSdbcrNofOgFGp;~1 zsVdUSXsd1wV5yVP&;<)&VBk$T`%HA_H-;l^jLMpTVkvThrEoWx(eJ$g^R*dnOJ~|~1UD5ab8T08GKR<&{G}W1%-18*ZDktoR*fJe&+bpy-vNSPqTVZ=BVa)>HNyd2lwya zpCQ!N2D5VIb#>`6r6qsL%1ui|)6AC&ybgJ+aW$K70R-W!{ zKR^ZB?=k3z&b4d^4}JYwySK;`K8IVK`Tph@%S^+S!vSj}A(Cc(f1d4+`tV^SS{B-! z6sbKP5`939<*sA(`v@|Mx;{QtQcgoT{iW8@RatnfmwjKc#XyN=$kx_stv#_N(RY0! zHu}Sd)VE?a4+OQ69CWrzN=jG;uCqZe#2E_KcU42T^l9^=U2?0!hC?E$mn3dkfB5d5 zJ5x)oiiSo;amdI>N!t#-fQ26?!S=pKQ1i`UNF5!Wp$i^q>2cjf8|;?_pr zCLzEd_+W;n@aV&J^EVXTLpPSEJ0-1t9hYDDe$0+ggM*ZeSDER|jsRK-ZE@A&ypWI{i2)(~3}!h~1|%!6e?~3K)^1~k{Ok8`2M-<~ zgD&gjfUM-Lc!A4AP}h> zb7*H)>Sd;`i*-uq>*Xo+$pht)eB}=PK!0IG zE;O9f<4dU`j=Nm%%GTncg9RAezyATT-ej(Z=S{uva4O{_c#j~Q>wYdGc#Dj_ zz6Y&i!+vvAyX&z9Y>ZoT+gqsm>)ndSZB!Mhu0Xkxss2qdmsz--zXUP5UC-M(Snf

^GIXiEIJqB-NP3qLava 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

d*NQ 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 M5v5QnZyNOf04l^uhyVZp diff --git a/docs/auto_examples/index.rst b/docs/auto_examples/index.rst index 92ded99..0ef58da 100644 --- a/docs/auto_examples/index.rst +++ b/docs/auto_examples/index.rst @@ -7,7 +7,7 @@ Welcome to the PyTUQ Tutorials page! Here, you'll find a series of comprehensive showcase the functionality of PyTUQ and guide you through its core features. Surrogates -~~~~~~~~~~ +~~~~~~~~~~~ PyTUQ supports the construction of various surrogate models, including Polynomial Chaos Expansions for multivariate random variables and Neural Networks, which can be accessed through the Quantification of Uncertainties in Neural Networks (QUiNN) library. diff --git a/docs/auto_examples/sg_execution_times.rst b/docs/auto_examples/sg_execution_times.rst index d48caef..846e881 100644 --- a/docs/auto_examples/sg_execution_times.rst +++ b/docs/auto_examples/sg_execution_times.rst @@ -6,7 +6,7 @@ Computation times ================= -**00:05.760** total execution time for 3 files **from auto_examples**: +**00:06.413** total execution time for 3 files **from auto_examples**: .. container:: @@ -33,7 +33,7 @@ Computation times - Time - Mem (MB) * - :ref:`sphx_glr_auto_examples_ex_genz_bcs.py` (``ex_genz_bcs.py``) - - 00:05.760 + - 00:06.413 - 0.0 * - :ref:`sphx_glr_auto_examples_ex_nn.py` (``ex_nn.py``) - 00:00.000 From 90db5bf52646c0f7aa8a4df61ebbe2a1ebcb7c2b Mon Sep 17 00:00:00 2001 From: Emilie Baillo Date: Wed, 5 Nov 2025 12:45:54 -0800 Subject: [PATCH 4/6] Updated genz example + jupyter notebook --- examples/surrogates/ex_genz_bcs.ipynb | 194 ++++++++++++++++++-- examples/surrogates/ex_genz_bcs.py | 245 ++++++++++++++++++-------- 2 files changed, 354 insertions(+), 85 deletions(-) diff --git a/examples/surrogates/ex_genz_bcs.ipynb b/examples/surrogates/ex_genz_bcs.ipynb index af77ee7..3e724a3 100644 --- a/examples/surrogates/ex_genz_bcs.ipynb +++ b/examples/surrogates/ex_genz_bcs.ipynb @@ -24,7 +24,7 @@ "\n", "Through three different build processes, we will construct three PC surrogates to highlight the advantages of BCS and explore the effects of the `eta` hyperparameter on model results. First, we'll build with least squares regression to demonstrate the limitations of non-sparse methods and the need for BCS. Then we'll build with BCS using a given eta of $1 \\times 10^{-10}$ and identify aspects for model improvement. Last, we'll build with the most optimal eta, as found through cross-validation algorithms exposed here. All three surrogates will be evaluated on testing and training data, with parity plots and Root Mean Square Error (RMSE) values used to compare their performance. \n", "\n", - "To follow along with the cross-validation algorithm used to select the optimal eta, see section \"Functions for cross-validation algorithm\" in the second half of the notebook." + "To follow along with the cross-validation algorithm for selecting the optimal eta, see section \"Functions for cross-validation algorithm\" in the second half of the notebook. These methods have been implemented under-the-hood in PyTUQ. Refer to example \"Polynomial Chaos Expansion Construction\" (``ex_pce.py``) for a demonstration of how to use these methods through a direct call to the PCE class." ] }, { @@ -77,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -95,7 +95,7 @@ "\n", "# Training data\n", "n_trn = 70\n", - "value_ksi_trn = 2*rng.random(n=n_trn) - 1 # Randomly generating 70 data points within the domain of ξ \n", + "value_ksi_trn = 2*rng.random(n=n_trn) - 1 # Randomly generating 70 data points within the domain of ξ (ksi)\n", "x_trn = scaleDomTo01(value_ksi_trn, ksi_domain) # We scale our training data to [0, 1]^d, the domain of the Genz function\n", "y_trn = func(x_trn) + np.random.normal(0, noise_std, size = (n_trn, 1))\n", "\n", @@ -213,7 +213,7 @@ "print(\"Number of Basis Terms:\", pce_surr.get_pc_terms())\n", "\n", "# (1.5) Set training data\n", - "pce_surr.set_training_data(value_ksi_trn[:80], y_trn[:80,0])" + "pce_surr.set_training_data(value_ksi_trn, y_trn[:,0])" ] }, { @@ -478,11 +478,9 @@ "\n", "y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()]\n", "\n", - "\n", "fig2 = plt.figure(figsize=(8,6))\n", "ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75])\n", "\n", - "\n", "ax2.plot(y_tst[:,0],y_tst_approx[\"Y_eval\"],\".\")\n", "ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line\n", "\n", @@ -517,7 +515,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "From our parity plots, we can see how BCS already generalizes better to unseen data as compared to LSQ, with reduced error in our testing data predictions. In our RMSE calculations, notice how the training erorr is smaller than the testing error. Though the difference in value is small, this amount is still significant as we have noise in our training data yet no noise in our testing data. That the testing error is higher than the training error suggests that overfitting is still happening within our model. \n", + "From our parity plots, we can see how BCS already generalizes better to unseen data as compared to LSQ, with reduced error in our testing data predictions. In our RMSE calculations, notice how the training error is smaller than the testing error. Though the difference in value is small, this amount is still significant as we have noise in our training data yet no noise in our testing data. That the testing error is higher than the training error suggests that overfitting is still happening within our model. \n", "\n", "In the next section, we explore how finding the optimal value of eta -- the stopping criterion for the BCS parameter of gamma, determined through a Bayesian evidence maximization approach -- can impact model sparsity and accuracy to avoid overfitting." ] @@ -647,7 +645,7 @@ "metadata": {}, "outputs": [], "source": [ - "def optimize_eta(pce, etas, nfolds, verbose=0, plot=False):\n", + "def optimize_eta(pce, etas, nfolds=3, verbose=0, plot=False):\n", " \"\"\"\n", " Choose the optimum eta for Bayesian compressive sensing. Calculates the RMSE\n", " for each eta for a specified number of folds. Selects the eta with the lowest\n", @@ -708,7 +706,7 @@ " y_test_eval = (pce_copy.evaluate(x_test))['Y_eval']\n", "\n", " # Print statement for verbose flag\n", - " if verbose > 1:\n", + " if verbose > 0:\n", " print(\"Fold \" + str(i + 1) + \", eta \" + str(eta) + \", \" + str(len(cfs)) + \" terms retained out of a full basis of size \" + str(len(pce.pcrv.mindices[0])))\n", " \n", " # Calculate the RMSEs for the training and validation points.\n", @@ -785,6 +783,172 @@ "execution_count": 17, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fold 1, eta 1.0, 3 terms retained out of a full basis of size 17\n", + "Fold 1, eta 0.1, 3 terms retained out of a full basis of size 17\n", + "Fold 1, eta 0.01, 4 terms retained out of a full basis of size 17\n", + "Fold 1, eta 0.001, 5 terms retained out of a full basis of size 17\n", + "Fold 1, eta 0.0001, 9 terms retained out of a full basis of size 17\n", + "Fold 1, eta 1e-05, 12 terms retained out of a full basis of size 17\n", + "Fold 1, eta 1e-06, 13 terms retained out of a full basis of size 17\n", + "Fold 1, eta 1e-07, 16 terms retained out of a full basis of size 17\n", + "Fold 1, eta 1e-08, 16 terms retained out of a full basis of size 17\n", + "Fold 1, eta 1e-09, 16 terms retained out of a full basis of size 17\n", + "Fold 1, eta 1e-10, 16 terms retained out of a full basis of size 17\n", + "Fold 1, eta 1e-11, 16 terms retained out of a full basis of size 17\n", + "Fold 1, eta 1e-12, 16 terms retained out of a full basis of size 17\n", + "Fold 1, eta 1e-13, 16 terms retained out of a full basis of size 17\n", + "Fold 1, eta 1e-14, 16 terms retained out of a full basis of size 17\n", + "Fold 1, eta 1e-15, 16 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1.0, 3 terms retained out of a full basis of size 17\n", + "Fold 2, eta 0.1, 3 terms retained out of a full basis of size 17\n", + "Fold 2, eta 0.01, 4 terms retained out of a full basis of size 17\n", + "Fold 2, eta 0.001, 5 terms retained out of a full basis of size 17\n", + "Fold 2, eta 0.0001, 9 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1e-05, 12 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1e-06, 16 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1e-07, 18 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1e-08, 18 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1e-09, 18 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1e-10, 18 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1e-11, 18 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1e-12, 18 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1e-13, 18 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1e-14, 18 terms retained out of a full basis of size 17\n", + "Fold 2, eta 1e-15, 18 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1.0, 3 terms retained out of a full basis of size 17\n", + "Fold 3, eta 0.1, 3 terms retained out of a full basis of size 17\n", + "Fold 3, eta 0.01, 4 terms retained out of a full basis of size 17\n", + "Fold 3, eta 0.001, 8 terms retained out of a full basis of size 17\n", + "Fold 3, eta 0.0001, 9 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1e-05, 12 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1e-06, 14 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1e-07, 17 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1e-08, 17 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1e-09, 18 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1e-10, 18 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1e-11, 18 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1e-12, 18 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1e-13, 18 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1e-14, 18 terms retained out of a full basis of size 17\n", + "Fold 3, eta 1e-15, 18 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1.0, 3 terms retained out of a full basis of size 17\n", + "Fold 4, eta 0.1, 3 terms retained out of a full basis of size 17\n", + "Fold 4, eta 0.01, 4 terms retained out of a full basis of size 17\n", + "Fold 4, eta 0.001, 5 terms retained out of a full basis of size 17\n", + "Fold 4, eta 0.0001, 11 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1e-05, 11 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1e-06, 16 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1e-07, 17 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1e-08, 17 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1e-09, 17 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1e-10, 17 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1e-11, 17 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1e-12, 17 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1e-13, 17 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1e-14, 17 terms retained out of a full basis of size 17\n", + "Fold 4, eta 1e-15, 17 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1.0, 3 terms retained out of a full basis of size 17\n", + "Fold 5, eta 0.1, 3 terms retained out of a full basis of size 17\n", + "Fold 5, eta 0.01, 4 terms retained out of a full basis of size 17\n", + "Fold 5, eta 0.001, 7 terms retained out of a full basis of size 17\n", + "Fold 5, eta 0.0001, 10 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1e-05, 12 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1e-06, 14 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1e-07, 14 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1e-08, 14 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1e-09, 14 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1e-10, 14 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1e-11, 14 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1e-12, 14 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1e-13, 14 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1e-14, 14 terms retained out of a full basis of size 17\n", + "Fold 5, eta 1e-15, 14 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1.0, 3 terms retained out of a full basis of size 17\n", + "Fold 6, eta 0.1, 3 terms retained out of a full basis of size 17\n", + "Fold 6, eta 0.01, 4 terms retained out of a full basis of size 17\n", + "Fold 6, eta 0.001, 7 terms retained out of a full basis of size 17\n", + "Fold 6, eta 0.0001, 11 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1e-05, 11 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1e-06, 16 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1e-07, 16 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1e-08, 16 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1e-09, 17 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1e-10, 17 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1e-11, 17 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1e-12, 17 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1e-13, 17 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1e-14, 17 terms retained out of a full basis of size 17\n", + "Fold 6, eta 1e-15, 17 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1.0, 3 terms retained out of a full basis of size 17\n", + "Fold 7, eta 0.1, 3 terms retained out of a full basis of size 17\n", + "Fold 7, eta 0.01, 4 terms retained out of a full basis of size 17\n", + "Fold 7, eta 0.001, 4 terms retained out of a full basis of size 17\n", + "Fold 7, eta 0.0001, 7 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1e-05, 13 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1e-06, 13 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1e-07, 13 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1e-08, 13 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1e-09, 13 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1e-10, 13 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1e-11, 13 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1e-12, 13 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1e-13, 13 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1e-14, 13 terms retained out of a full basis of size 17\n", + "Fold 7, eta 1e-15, 13 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1.0, 3 terms retained out of a full basis of size 17\n", + "Fold 8, eta 0.1, 3 terms retained out of a full basis of size 17\n", + "Fold 8, eta 0.01, 4 terms retained out of a full basis of size 17\n", + "Fold 8, eta 0.001, 7 terms retained out of a full basis of size 17\n", + "Fold 8, eta 0.0001, 10 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1e-05, 11 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1e-06, 15 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1e-07, 16 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1e-08, 16 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1e-09, 16 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1e-10, 16 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1e-11, 16 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1e-12, 16 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1e-13, 16 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1e-14, 16 terms retained out of a full basis of size 17\n", + "Fold 8, eta 1e-15, 16 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1.0, 3 terms retained out of a full basis of size 17\n", + "Fold 9, eta 0.1, 3 terms retained out of a full basis of size 17\n", + "Fold 9, eta 0.01, 4 terms retained out of a full basis of size 17\n", + "Fold 9, eta 0.001, 7 terms retained out of a full basis of size 17\n", + "Fold 9, eta 0.0001, 8 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1e-05, 12 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1e-06, 14 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1e-07, 15 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1e-08, 15 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1e-09, 15 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1e-10, 15 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1e-11, 15 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1e-12, 15 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1e-13, 15 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1e-14, 15 terms retained out of a full basis of size 17\n", + "Fold 9, eta 1e-15, 15 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1.0, 3 terms retained out of a full basis of size 17\n", + "Fold 10, eta 0.1, 3 terms retained out of a full basis of size 17\n", + "Fold 10, eta 0.01, 4 terms retained out of a full basis of size 17\n", + "Fold 10, eta 0.001, 4 terms retained out of a full basis of size 17\n", + "Fold 10, eta 0.0001, 9 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1e-05, 14 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1e-06, 14 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1e-07, 14 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1e-08, 14 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1e-09, 14 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1e-10, 14 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1e-11, 14 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1e-12, 14 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1e-13, 14 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1e-14, 14 terms retained out of a full basis of size 17\n", + "Fold 10, eta 1e-15, 14 terms retained out of a full basis of size 17\n" + ] + }, { "data": { "image/png": "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", @@ -801,7 +965,7 @@ "etas = 1/np.power(10,[i for i in range(0,16)])\n", "\n", "# Then, we call the function to choose the optimal eta:\n", - "eta_opt = optimize_eta(pce_surr, etas, 10, verbose = True, plot=True)" + "eta_opt = optimize_eta(pce_surr, etas, nfolds=10, verbose = True, plot=True)" ] }, { @@ -867,7 +1031,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "

" ] @@ -877,7 +1041,7 @@ } ], "source": [ - "# Plot the surrogate model's output vs. the testing data output\n", + "# Plot the surrogate model's output vs. the training data output\n", "y_tst_mM = [y_trn[:,0].min(),y_trn[:,0].max()]\n", "\n", "fig2 = plt.figure(figsize=(8,6))\n", @@ -886,7 +1050,7 @@ "ax2.plot(y_trn[:,0],y_trn_approx[\"Y_eval\"],\".\")\n", "ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line\n", "\n", - "ax2.set_xlabel(\"Test Data y\", size=16)\n", + "ax2.set_xlabel(\"Train Data y\", size=16)\n", "ax2.set_ylabel(\"Predicted y\", size=16); " ] }, @@ -947,7 +1111,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In these final RMSE calculations, we can see how our training RMSE has decreased from 1.80e-02 to 1.21e-02 by building with the most optimal eta. This indicates that our model has improved in generalization and is performing better on unseen data. Though our training error is still larger than our testing error, this can be attributed to the lack of noise in our testing data, while noise is present in our training data. While the optimal eta reduces overfitting and improves generalization, the noise in our training data still impacts the training error and remains an important consideration during our evaluation of the model performance." + "In these final RMSE calculations, we can see how our training RMSE has decreased from 1.80e-02 to 1.21e-02 by building with the most optimal eta. This indicates that our model has improved in generalization and is performing better on unseen data. Though our training error is still larger than our testing error, this can be attributed to the lack of noise in our testing data, while noise is present in our training data. While the optimal eta reduces overfitting and improves generalization, the noise in our training data still impacts the training error and remains an important consideration during our evaluation of the model performance.\n", + "\n", + "While this demonstration calls the cross-validation algorithm as a function outside of the PCE class, these methods have been implemented in PyTUQ through the PCE class. The example \"Polynomial Chaos Expansion Construction\" demonstrates how to call the eta optimization methods directly from the PCE class." ] } ], diff --git a/examples/surrogates/ex_genz_bcs.py b/examples/surrogates/ex_genz_bcs.py index 1dd7b14..e186469 100644 --- a/examples/surrogates/ex_genz_bcs.py +++ b/examples/surrogates/ex_genz_bcs.py @@ -16,10 +16,15 @@ - :math:`x_i`: The input variables. - :math:`d`: The dimensionality of the input :math:`x` (number of components in :math:`x`). -Through 2 different build processes, we will construct two different PC surrogates to demonstrate effects of the BCS eta hyperparameter on model results. -The first build process will demonstrate most simply the construct-build-evaluate process when using BCS for our PC surrogate, along with a given a eta of 1e-10. -The second build process will select the most optimal eta for BCS through cross-validation algorithms (exposed here), which will soon be implemented in PyTUQ under-the-hood. -Afterwards, we will evaluate both models on testing and training data, returning parity plots and a Root Mean Square Error for each evaluation. +Through three different build processes, we will construct three PC surrogates to highlight the advantages of BCS and explore the effects of the `eta` hyperparameter on model results. + +First, we'll build with least squares regression to demonstrate the limitations of non-sparse methods and the need for BCS. +Then we'll build with BCS using a given eta of :math:`1 \times 10^{-10}` and identify aspects for model improvement. +Last, we'll build with the most optimal eta, as found through cross-validation algorithms exposed here. All three surrogates will be evaluated on testing and training data, +with parity plots and Root Mean Square Error (RMSE) values used to compare their performance. + +To follow along with the cross-validation algorithm for selecting the optimal eta, see section "Functions for cross-validation algorithm" in the second half of the notebook. +These methods have been implemented under-the-hood in PyTUQ. Refer to example "Polynomial Chaos Expansion Construction" (``ex_pce.py``) for a demonstration of how to use these methods through a direct call to the PCE class. """ # %% @@ -34,44 +39,55 @@ from sklearn.metrics import root_mean_squared_error from pytuq.surrogates.pce import PCE -from pytuq.utils.maps import scale01ToDom +from pytuq.utils.maps import scaleDomTo01 from pytuq.func.genz import GenzOscillatory # %% -# Setting a random number generator seed: +# Constructing PC surrogate and generating data +# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +# To start, we begin with defining our true model and input parameters for our PC surrogate. +# +# After importing GenzOscillatory from ``pytuq.func.genz``, we generate the Genz function below, +# along with training data and testing data with output noise. This data and the corresponding Genz function +# will be used to create the same PC surrogate fitted in all three examples: first with linear regression, +# next using BCS with a given eta, and third using BCS with the most optimal eta. + +# %% # Random number generator from scipy.stats import qmc rng_seed = 43 # %% -# Constructing PC surrogate and generating data -# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -# After importing GenzOscillatory from ``pytuq.func.genz``, we generate the Genz function below, along with training data and testing data with output noise. -# This data and the corresponding Genz function will be used to create the same PC surrogate fitted in both examples: -# (1) The first surrogate will be fitted using BCS with a given eta, and (2) the second surrogate will be fitted using BCS with the most optimal eta. -# Use Genz Oscillatory function in multiple dimensions for the true model +# Define our true model as the Genz Oscillatory function in multiple dimensions func_dim = 4 -func_weights = [1.0/(i+1)**2 for i in range(func_dim)] +func_weights = [1.0/(i+1)**2 for i in range(func_dim)] func = GenzOscillatory(shift=0.25, weights=func_weights) -noise_std = 0.1 +noise_std = 0.025 + rng = qmc.LatinHypercube(d=func_dim, seed=rng_seed) +np.random.seed(42) + +# As we choose to use Legendre polynomials later in the surrogate construction, we define the domain of ξ on [-1, 1]^d +ksi_domain = np.array([[-1.0, 1.0]] * func_dim) # Training data -np.random.seed(42) n_trn = 70 -x_trn = rng.random(n=n_trn) # random numbers in [0,1]^d -y_trn = func(x_trn) + np.random.normal(0, noise_std, size = (n_trn,1)) +value_ksi_trn = 2*rng.random(n=n_trn) - 1 # Randomly generating 70 data points within the domain of ξ (ksi) +x_trn = scaleDomTo01(value_ksi_trn, ksi_domain) # We scale our training data to [0, 1]^d, the domain of the Genz function +y_trn = func(x_trn) + np.random.normal(0, noise_std, size = (n_trn, 1)) # Testing data n_tst = 10000 -x_tst = rng.random(n=n_tst) # random numbers in [0,1]^d -y_tst = func(x_tst) + np.random.normal(0, noise_std, size = (n_tst,1)) +value_ksi_tst = 2*rng.random(n=n_tst) - 1 +x_tst = scaleDomTo01(value_ksi_tst, ksi_domain) +y_tst = func(x_tst) # %% -# With a stochastic dimensionality of 4 (defined above) and a polynomial order of 4, we construct the PC surrogate that will be used in both builds. -# You have the option of printing the PC surrogate's full basis, before BCS selects and retains the most significant PC coefficients to reduce the basis. +# With a stochastic dimensionality of 4 (defined above) and a chosen polynomial order of 4, we construct the PC surrogate that +# will be used in both builds. By calling the ``printInfo()`` method from the PCRV variable, you can print the PC surrogate's +# full basis and current coefficients, before BCS selects and retains the most significant PC terms to reduce the basis. # (1) Construct a PC surrogate order = 4 @@ -80,16 +96,79 @@ # Optional verbosity output: print("Full Basis and Current Coefficients:") pce_surr.pcrv.printInfo() -print("Number of Basis Terms:", len(pce_surr.pcrv.mindices[0])) +print("Number of Basis Terms:", pce_surr.get_pc_terms()) # (1.5) Set training data -pce_surr.set_training_data(x_trn, y_trn[:,0]) +pce_surr.set_training_data(value_ksi_trn, y_trn[:,0]) + +# %% +# From the input parameters of our PC surrogate, we have 70 basis terms in our PCE. With 70 training points and no noise, having 70 basis terms would mean that we have a fully determined system, as the number of training points is the same as the number of basis terms. However, with the addition of noise in our training data, it becomes harder for the model to accurately fit all basis terms, leading to potential overfitting. This demonstrates the helpful role BCS might play as a choice for our regression build. As a sparse regression approach, BCS uses regularization to select only the most relevant basis terms, making it particularly effective in situations like this, where we do not have enough clear information to fit all basis terms without overfitting. +# +# In the next sections, we will explore the effects of overfitting in more detail. + +# %% +# Least Squares Regression +# ^^^^^^^^^^^^^^^^^^^^^^^^^ +# To start, we call the PCE class method of ``build()`` with no arguments to use the default regression option of least squares. Then, through ``evaluate()``, we can generate model predictions for our training and testing data. + +# %% + +# (2) Build the linear regression object for fitting +pce_surr.build() + +# (3) Evaluate the PC model +y_trn_approx = pce_surr.evaluate(value_ksi_trn) +y_tst_approx = pce_surr.evaluate(value_ksi_tst) + +# %% + +# Plot the surrogate model's output vs. the training data output +y_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()] + +fig1 = plt.figure(figsize=(8,6)) +ax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75]) + +ax1.plot(y_trn[:,0],y_trn_approx["Y_eval"],".") +ax1.plot(y_trn_mM,y_trn_mM) # Diagonal line + +ax1.set_xlabel("Train Data y", size=16) +ax1.set_ylabel("Predicted y", size=16); + +# %% + +# Plot the surrogate model's output vs. the testing data output + +y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()] + + +fig2 = plt.figure(figsize=(8,6)) +ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) + + +ax2.plot(y_tst[:,0],y_tst_approx["Y_eval"],".") +ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line + +ax2.set_xlabel("Test Data y", size=16) +ax2.set_ylabel("Predicted y", size=16); + +# %% + +# Evaluate goodness of fit with RMSE +rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) +print("The training RMSE in the PCE LSQ approximation is %.2e"%rmse_trn) + +rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) +print("The testing RMSE in the PCE LSQ approximation is %.2e"%rmse_tst) + +# %% +# The results above show us the limitations of using least squares regression to construct our surrogate. From the parity plots, we can see how the testing predictions from the LSQ regression are more spread out from the parity line, while the training predictions are extremely close to the line. Because LSQ fits all the basis terms to the training data, the model fits too closely to the noisy training dataset, and the true underlying pattern of the function is not effectively captured. Our RMSE values align with this as well: while the training RMSE is extremely low, the testing RMSE is significantly higher, as the model struggles to generalize to the unseen test data. +# +# To improve our model's generalization, we can build our model with BCS instead. As a sparse regression method, BCS reduces the number of basis terms with which we can fit our data to, reducing the risk of overfitting. # %% # BCS with default settings (default eta) # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -# Here, we call the PCE class method of ``build()`` to build the linear regression model used to fit the surrogate. -# With the flag ``regression='bcs'``, we choose the BCS method for the fitting. A user-defined eta of 1e-10 is also passed in. +# In this section, we use the same PC surrogate, ``pce_surr``, for the second build. With the flag ``regression='bcs'``, we choose the BCS method for the fitting. A user-defined eta of 1e-10 is also passed in. # (2) Build the linear regression object for fitting pce_surr.build(regression='bcs', eta=1.e-10) @@ -97,36 +176,23 @@ # Optional verbosity output: print("Retained Basis and Coefficients:") pce_surr.pcrv.printInfo() -print("Number of retained basis terms:", len(pce_surr.pcrv.mindices[0])) +print("Number of retained basis terms:", pce_surr.get_pc_terms()) # %% -# After fitting, we evaluate the PCE using our training and testing data. To analyze the model's goodness of fit, -# we calculate the root mean square error between the surrogate results and the training and testing data. +# After fitting, we evaluate the PCE using our training and testing data. To analyze the model's goodness of fit, we first plot the surrogate predictions against the training and testing data respectively. # (3) Evaluate the PC model -y_trn_approx = pce_surr.evaluate(x_trn) -y_tst_approx = pce_surr.evaluate(x_tst) - -# Evaluate goodness of fit with RMSE -rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) -print("The training RMSE error in the PCE BCS approximation is %.2e"%rmse_trn) - -rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) -print("The testing RMSE error in the PCE BCS approximation is %.2e"%rmse_tst) +y_trn_approx = pce_surr.evaluate(value_ksi_trn) +y_tst_approx = pce_surr.evaluate(value_ksi_tst) # %% -# Notice above how the training RMSE error is almost half that of the testing RMSE error. This shows that our current model is overfitting, -# learning the training data with noise too well. To address this issue, we can explore selecting a better eta for the BCS fitting. # Plot the surrogate model's output vs. the training data output - y_trn_mM = [y_trn[:,0].min(),y_trn[:,0].max()] - fig1 = plt.figure(figsize=(8,6)) ax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75]) - ax1.plot(y_trn[:,0],y_trn_approx["Y_eval"],".") ax1.plot(y_trn_mM,y_trn_mM) # Diagonal line @@ -139,30 +205,41 @@ y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()] - fig2 = plt.figure(figsize=(8,6)) ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) - ax2.plot(y_tst[:,0],y_tst_approx["Y_eval"],".") ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line ax2.set_xlabel("Test Data y", size=16) ax2.set_ylabel("Predicted y", size=16); +# sphinx_gallery_thumbnail_number = 2 + +# %% + +# Evaluate goodness of fit with RMSE +rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) +print("The training RMSE in the PCE BCS approximation is %.2e"%rmse_trn) + +rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) +print("The testing RMSE in the PCE BCS approximation is %.2e"%rmse_tst) + +# %% +# From our parity plots, we can see how BCS already generalizes better to unseen data as compared to LSQ, with reduced error in our testing data predictions. In our RMSE calculations, notice how the training error is smaller than the testing error. Though the difference in value is small, this amount is still significant as we have noise in our training data yet no noise in our testing data. That the testing error is higher than the training error suggests that overfitting is still happening within our model. +# +# In the next section, we explore how finding the optimal value of eta -- the stopping criterion for the BCS parameter of gamma, determined through a Bayesian evidence maximization approach -- can impact model sparsity and accuracy to avoid overfitting. + + # %% # BCS with optimal eta (found through cross-validation) # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -# In this section, we use the same PC surrogate, ``pce_surr``, for the second build. We call the PCE class method of ``build()`` -# to build the linear regression model used to fit the surrogate. With the flag ``regression='bcs'``, we choose the BCS method for the fitting. -# -############################################################################## -# Instead of using a default eta, we call the cross-validation algorithm, ``optimize_eta()``, to choose the most optimal eta below. +# Before we build our PC surrogate again with the most optimal eta, we first expose the cross-validation algorithm ``optimize_eta`` and its two helper functions, ``kfold_split`` and ``kfold_cv`` below. These functions have been implemented under-the-hood in the PCE surrogate class, but for the purposes of this tutorial, you may find it useful to follow along with the K-fold cross-validation method used to find the most optimal eta (the eta with the lowest validation RMSE across all of its folds). # -# - With the flag ``plot=True``, the CV algorithm produces a graph of the training and testing (validation) data's RMSE values for each eta. The eta with the smallest RMSE for the validation data is the one chosen as the optimal eta. -# -############################################################################## -# Before that, we expose the cross-validation algorithm ``optimize_eta`` and its two helper functions, ``kfold_split`` and ``kfold_cv`` that will be called in this section. +# Functions for cross-validation algorithm +# +++++++++++++++++++++++++++++++++++++++++ + +# %% def kfold_split(nsamples,nfolds,seed=13): """ @@ -251,7 +328,8 @@ def kfold_cv(x,y,nfolds=3,seed=13): return kfold_data # %% -def optimize_eta(pce, etas, nfolds, verbose=0, plot=False): + +def optimize_eta(pce, etas, nfolds=3, verbose=0, plot=False): """ Choose the optimum eta for Bayesian compressive sensing. Calculates the RMSE for each eta for a specified number of folds. Selects the eta with the lowest @@ -312,7 +390,7 @@ def optimize_eta(pce, etas, nfolds, verbose=0, plot=False): y_test_eval = (pce_copy.evaluate(x_test))['Y_eval'] # Print statement for verbose flag - if verbose > 1: + if verbose > 0: print("Fold " + str(i + 1) + ", eta " + str(eta) + ", " + str(len(cfs)) + " terms retained out of a full basis of size " + str(len(pce.pcrv.mindices[0]))) # Calculate the RMSEs for the training and validation points. @@ -368,16 +446,24 @@ def optimize_eta(pce, etas, nfolds, verbose=0, plot=False): return eta_opt # %% +# BCS build with the most optimal eta +# +++++++++++++++++++++++++++++++++++++ +# Instead of using a default eta, here we call the cross-validation algorithm, ``optimize_eta()``, to choose the most optimal eta from a range of etas given below. +# +# - With the flag ``plot=True``, the CV algorithm produces a graph of the training and testing (validation) data's RMSE values for each eta. The eta with the smallest RMSE for the validation data is the one chosen as the optimal eta. # We first create a list of possible etas to pass in: [1e-16, 1e-15, ... , 1e-2, 1e-1, 1] etas = 1/np.power(10,[i for i in range(0,16)]) # Then, we call the function to choose the optimal eta: -eta_opt = optimize_eta(pce_surr, etas, 10, plot=True) +eta_opt = optimize_eta(pce_surr, etas, nfolds=10, verbose = True, plot=True) # %% -# Now, with the optimal eta obtained, we run the fitting again. Then, we evaluate the PCE and produce a parity plot for the predicted output vs. the testing data. -# Notice that the larger eta, 10e-2, retained fewer basis terms (6) compared to the smaller user-defined eta of 10e-10 (which retained 20 basis terms). +# From our eta plot above, we can see that our most optimal eta falls at :math:`1 \times 10^{-10}`, where the validation error is the lowest. While this indicates that the model performs well at this eta value, we can still observe a tendency towards overfitting in the model. For larger eta values, the training and validation RMSE lines are close together, suggesting that the model is performing similarly on both seen and unseen datasets, as would be desired. However, as eta decreases, the training RMSE falls while the validation RMSE rises, highlighting a region where overfitting occurs. +# +# This behavior is expected because smaller eta values retain more basis terms, increasing the model's degrees of freedom. While this added flexibility allows the model to fit the training data more closely, it also makes the model more prone to fitting noise rather than capturing the true underlying function. Selecting the most optimal eta of :math:`1 \times 10^{-4}`, as compared to the earlier user-defined eta of :math:`1 \times 10^{-10}`, allows us to balance model complexity and generalization. +# +# Now, with the optimum eta obtained, we can run the fitting again and produce parity plots for our predicted output. # Build the linear regression object for fitting pce_surr.build(regression='bcs', eta=eta_opt) @@ -385,36 +471,53 @@ def optimize_eta(pce, etas, nfolds, verbose=0, plot=False): # Optional verbosity output: print("Retained Basis and Coefficients:") pce_surr.pcrv.printInfo() -print("Number of retained basis terms:", len(pce_surr.pcrv.mindices[0])) +print("Number of retained basis terms:", pce_surr.get_pc_terms()) # %% + # Evaluate the PC model with training and testing data -y_trn_approx = pce_surr.evaluate(x_trn) -y_tst_approx = pce_surr.evaluate(x_tst) +y_trn_approx = pce_surr.evaluate(value_ksi_trn) +y_tst_approx = pce_surr.evaluate(value_ksi_tst) -# Evaluate goodness of fit with RMSE -rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) -print("The training RMSE error in the PCE BCS approximation is %.2e"%rmse_trn) +# %% -rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) -print("The testing RMSE error in the PCE BCS approximation is %.2e"%rmse_tst) +# Plot the surrogate model's output vs. the training data output +y_tst_mM = [y_trn[:,0].min(),y_trn[:,0].max()] + +fig2 = plt.figure(figsize=(8,6)) +ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) + +ax2.plot(y_trn[:,0],y_trn_approx["Y_eval"],".") +ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line + +ax2.set_xlabel("Train Data y", size=16) +ax2.set_ylabel("Predicted y", size=16); # %% -# While the training RMSE error was almost half that of the testing RMSE error for the first fitting, the RMSE errors here are much closer to each other in value. -# This suggests that the model has more effectively generalized to the unseen data; a better eta has improved performance. # Plot the surrogate model's output vs. the testing data output y_tst_mM = [y_tst[:,0].min(),y_tst[:,0].max()] - fig2 = plt.figure(figsize=(8,6)) ax2 = fig2.add_axes([0.15, 0.15, 0.80, 0.75]) - ax2.plot(y_tst[:,0],y_tst_approx["Y_eval"],".") ax2.plot(y_tst_mM,y_tst_mM) # Diagonal line ax2.set_xlabel("Test Data y", size=16) ax2.set_ylabel("Predicted y", size=16); -# sphinx_gallery_thumbnail_number = 2 \ No newline at end of file +# %% + +# Evaluate goodness of fit with RMSE +rmse_trn = root_mean_squared_error(y_trn[:,0],y_trn_approx["Y_eval"]) +print("The training RMSE in the PCE BCS approximation is %.2e"%rmse_trn) + +rmse_tst = root_mean_squared_error(y_tst[:,0],y_tst_approx["Y_eval"]) +print("The testing RMSE in the PCE BCS approximation is %.2e"%rmse_tst) + +# %% +# +# In these final RMSE calculations, we can see how our training RMSE has decreased from 1.80e-02 to 1.21e-02 by building with the most optimal eta. This indicates that our model has improved in generalization and is performing better on unseen data. Though our training error is still larger than our testing error, this can be attributed to the lack of noise in our testing data, while noise is present in our training data. While the optimal eta reduces overfitting and improves generalization, the noise in our training data still impacts the training error and remains an important consideration during our evaluation of the model performance. +# +# While this demonstration calls the cross-validation algorithm as a function outside of the PCE class, these methods have been implemented in PyTUQ through the PCE class. The example "Polynomial Chaos Expansion Construction" demonstrates how to call the eta optimization methods directly from the PCE class. From fc83783f585b916dec2a5af62252f42f68388ef0 Mon Sep 17 00:00:00 2001 From: Emilie Baillo Date: Wed, 5 Nov 2025 12:48:56 -0800 Subject: [PATCH 5/6] Added BCS build options to PCE example --- examples/surrogates/ex_pce.py | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/examples/surrogates/ex_pce.py b/examples/surrogates/ex_pce.py index 68672f8..3a970a7 100644 --- a/examples/surrogates/ex_pce.py +++ b/examples/surrogates/ex_pce.py @@ -12,7 +12,7 @@ - Define basic parameters for the surrogate model - Use a sample function of :math:`\sin^4(x)` from the ``utils`` directory -- Set up a PCE surrogate model +- Set up a PCE surrogate model, with different regression options for build (lsq, anl, vi, bcs) - And evaluate the performance of your model """ @@ -20,13 +20,8 @@ import numpy as np import pytuq.utils.funcbank as fcb - from pytuq.surrogates.pce import PCE from pytuq.utils.maps import scale01ToDom -from pytuq.lreg.anl import anl -from pytuq.lreg.lreg import lsq -from pytuq.utils.mindex import get_mi - ######################################################## ######################################################## @@ -53,7 +48,7 @@ # Testing PCE class: -# (1) Construct polynomial chaos expansion +# (1) Construct polynomial chaos expansion by defining at least a stochastic dimensionality, polynomial order, and polynomial type. pce = PCE(dim, order, 'LU') # pce = PCE(dim, order, 'HG') # pce = PCE(dim, order, ['LU', 'HG']) # dim = 2 @@ -61,12 +56,25 @@ pce.set_training_data(x, y) -# (2) Pick method for linear regression object, defaulting to least squares regression -# print(pce.build(regression = 'anl')) -# print(pce.build(regression = 'anl', method = 'vi')) +# (2) Pick a linear regression method to build your surrogate model with. build() returns the coefficients of your PC model, +# and with no arguments, will default to least squares regression. print(pce.build()) + +# You may choose different regression options by specifying the correct argument: # print(pce.build(regression = 'lsq')) -# print(pce.build(regression = 'bcs')) +# print(pce.build(regression = 'anl')) +# print(pce.build(regression = 'anl', method = 'vi')) + +# For a BCS build, if the eta argument is given a list or an array, the optimum value will be chosen through cross-validation +# on a specified number of folds (nfolds, defaulting to 3). Setting the eta_plot argument to True generates a RMSE vs. eta plot +# of the cross-validation results. While this example does not necessarily benefit from building with BCS, the statements below +# demonstrate calling this functionality. + +# etas = 1/np.power(10,[i for i in range(0,16)]) # List of etas to pass in: [1e-16, 1e-15, ... , 1e-2, 1e-1, 1] +# cfs = pce.build(regression = 'bcs', eta = etas, nfolds = 2, eta_plot = True, eta_verbose = False) + +# To see an problem better suited to using a BCS build and to explore BCS in more detail, visit +# the example "Function Approximation with Sparse Regression". # (3) Make predictions for data points and print results: results = pce.evaluate(x) From b6a84725b4b0a7421356b8909f09fc84bb289af9 Mon Sep 17 00:00:00 2001 From: Emilie Baillo Date: Wed, 5 Nov 2025 12:49:44 -0800 Subject: [PATCH 6/6] Updated docstrings and BCS error handling --- src/pytuq/surrogates/pce.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/pytuq/surrogates/pce.py b/src/pytuq/surrogates/pce.py index 51c3f66..869c29e 100644 --- a/src/pytuq/surrogates/pce.py +++ b/src/pytuq/surrogates/pce.py @@ -1,8 +1,8 @@ #!/usr/bin/env python -"""This module provides a Polynomial Chais Expansion (PCE) wrapper class to facilitate +"""This module provides a Polynomial Chaos Expansion (PCE) wrapper class to facilitate the universal coupling of FASTMath UQ tools and libraries. This class focuses on the use case - of surrogate models built with PCE and linear regression, keeping in mind + of PC surrogate models built with linear regression, keeping in mind flexibility to implement additional UQ functionalities in the future. The PCE class supports a minimal API, with methods to construct the model, build it with training data, @@ -204,7 +204,7 @@ def kfold_cv(self, x, y, nfolds=3,seed=13): return kfold_data - def optimize_eta(self, etas, verbose, nfolds=3, plot=False): + def optimize_eta(self, etas, verbose=0, nfolds=3, plot=False): """Choose the optimum eta for Bayesian compressive sensing. Calculates the RMSE for each eta for a specified number of folds. Selects the eta with the lowest RMSE after averaging the RMSEs over the folds. @@ -213,10 +213,10 @@ def optimize_eta(self, etas, verbose, nfolds=3, plot=False): x: N-dimensional NumPy array with sample points [#samples, #dimensions] etas: NumPy array or list with the threshold for stopping the algorithm. Smaller values retain more nonzero coefficients. plot: Flag for whether to generate a plot for eta optimization + verbose: Flag for print statements during cross-validation Returns: - eta_opt: Optimum eta - + eta_opt: Optimum eta value to be used in BCS build """ # Split data in k folds -> Get dictionary of data split in training + testing folds kfold_data = self.kfold_cv(self._x_train, self._y_train, nfolds) @@ -259,7 +259,7 @@ def optimize_eta(self, etas, verbose, nfolds=3, plot=False): y_test_eval = (pce_copy.evaluate(x_test))['Y_eval'] # Print statement for verbose flag - if verbose > 1: + if verbose > 0: print("Fold " + str(i + 1) + ", eta " + str(eta) + ", " + str(len(cfs)) + " terms retained out of a full basis of size " + str(len(pce_copy.pcrv.mindices[0]))) # Calculate the RMSEs for the training and validation points. @@ -361,13 +361,13 @@ def build(self, **kwargs): self.lreg = anl(datavar=kwargs.get('datavar'), prior_var=kwargs.get('prior_var'), cov_nugget=kwargs.get('cov_nugget', 0.0)) elif regression == 'bcs': eta = kwargs.get('eta', 1.e-8) - if isinstance(eta, (list, np.ndarray)): + if (isinstance(eta, list) and not any(isinstance(eta, list) for item in eta)) or (isinstance(eta, np.ndarray) and eta.ndim == 1): opt_eta = self.optimize_eta(eta, nfolds=kwargs.get('nfolds', 3), verbose=kwargs.get('eta_verbose', False), plot=kwargs.get('eta_plot', False)) self.lreg = bcs(eta=opt_eta, datavar_init=kwargs.get('datavar_init')) - elif isinstance(eta, float): + elif isinstance(eta, float) and eta > 0: self.lreg = bcs(eta=eta, datavar_init=kwargs.get('datavar_init')) else: - raise ValueError("You may provide either a float (defaulting to 1.e-8) or list/numpy array for the value of eta. If a list/numpy array is provided, the most optimal eta from the array will be chosen.") + raise ValueError("You may provide either a positive float (defaulting to 1.e-8) or 1D list/numpy array for the value of eta. If a list/numpy array is provided, the most optimal eta from the array will be chosen.") else: raise ValueError(f"Regression method '{regression}' is not recognized and/or supported yet.")

D-)iXI7ZNy^kribh5K-0L>$8_4DV?%PWJ< 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 literal 0 HcmV?d00001 diff --git a/docs/auto_examples/images/sphx_glr_ex_genz_bcs_006.png b/docs/auto_examples/images/sphx_glr_ex_genz_bcs_006.png new file mode 100644 index 0000000000000000000000000000000000000000..7f43ecc321876e9c8cf0800043a0325c662d21e1 GIT binary patch literal 28409 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 G?|%W0mhevi literal 0 HcmV?d00001 diff --git a/docs/auto_examples/images/sphx_glr_ex_genz_bcs_007.png b/docs/auto_examples/images/sphx_glr_ex_genz_bcs_007.png new file mode 100644 index 0000000000000000000000000000000000000000..8115e57ce7405f9f800d152d90c3f67106d2d114 GIT binary patch literal 33575 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%0AGA7Dd0>AmhXv# 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 po&`GmkPhi?y!-s0=l%YE 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 jHE`F2a9f`ogMR#vFl27!z|99@(kN5j! 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