diff --git a/git b/git new file mode 100644 index 0000000..e69de29 diff --git a/matlab/tools/bss/calculate_time_lags.m b/matlab/tools/bss/calculate_time_lags.m index d4d5152..f4d2ce3 100644 --- a/matlab/tools/bss/calculate_time_lags.m +++ b/matlab/tools/bss/calculate_time_lags.m @@ -40,4 +40,4 @@ T1(t) = t + prd + I - wlen - 1; end -T0 = 1:NN; +T0 = 1:NN; \ No newline at end of file diff --git a/python/src/oset/ecg/__init__.py b/python/src/oset/ecg/__init__.py index e69de29..2fe7c67 100644 --- a/python/src/oset/ecg/__init__.py +++ b/python/src/oset/ecg/__init__.py @@ -0,0 +1,3 @@ +# __init__.py +from .synchronous_phase_samples import synchronous_phase_samples +from .phase_calculator import phase_calculator diff --git a/python/src/oset/ecg/bss/__init__.py b/python/src/oset/ecg/bss/__init__.py new file mode 100644 index 0000000..fc7e8f3 --- /dev/null +++ b/python/src/oset/ecg/bss/__init__.py @@ -0,0 +1,12 @@ +from .calculate_time_lags import calculate_time_lags +from .easi_source_separation import easi_source_separation +from .mica_projectors import mica_projectors +from .nonstationary_component_analysis import nonstationary_component_analysis +from .pica_matrices import pica_matrices +from .spectral_component_analysis_dft import spectral_component_analysis_dft + + + + + + diff --git a/python/src/oset/ecg/bss/calculate_time_lags.py b/python/src/oset/ecg/bss/calculate_time_lags.py new file mode 100644 index 0000000..4098597 --- /dev/null +++ b/python/src/oset/ecg/bss/calculate_time_lags.py @@ -0,0 +1,67 @@ +import argparse +import numpy as np + +def calculate_time_lags(peaks, phase): + """ + Calculate time lags for the pseudo-periodic component analysis algorithm (PiCA) + using the R-peaks and the ECG phase signal. + + Parameters: + peaks (array-like): Vector containing the indices of detected peaks in the input signal. + phase (array-like): Vector representing the phase values associated with the peaks (see phase_calculator). + + Returns: + T0 (numpy.ndarray): Vector containing the time lags for the input peaks. + T1 (numpy.ndarray): Vector containing the corresponding lagged time points. + + Reference: + R. Sameni, C. Jutten, and M. B. Shamsollahi. Multichannel + electrocardiogram decomposition using periodic component analysis. IEEE + Transactions on Biomedical Engineering, 55(8):1935-1940, Aug. 2008. + + Revision History: + June 2024: Translated to Python from Matlab (calculate_time_lags.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + """ + + J = np.where(peaks)[0] + n1 = np.diff(J) + prd = round(np.mean(n1)) + wlen = max(n1) - min(n1) + + T1 = np.zeros(len(peaks) - prd - wlen) + NN = len(T1) + + for t in range(1, NN + 1): + df = np.abs(phase[t-1] - phase[t + prd - wlen - 1 : t + prd + wlen]) + I = np.argmin(df) + T1[t-1] = t + prd + I - wlen + + T0 = np.arange(1, NN + 1) + + return T0, T1 + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + Calculate time lags for the pseudo-periodic component analysis algorithm (PiCA) + using the R-peaks and the ECG phase signal. + + Parameters: + peaks (array-like): Vector containing the indices of detected peaks in the input signal. + phase (array-like): Vector representing the phase values associated with the peaks (see phase_calculator). + + Returns: + T0 (numpy.ndarray): Vector containing the time lags for the input peaks. + T1 (numpy.ndarray): Vector containing the corresponding lagged time points. + + Revision History: + June 2024: Translated to Python from Matlab (calculate_time_lags.m) + + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() \ No newline at end of file diff --git a/python/src/oset/ecg/bss/easi_source_separation.py b/python/src/oset/ecg/bss/easi_source_separation.py new file mode 100644 index 0000000..2eac930 --- /dev/null +++ b/python/src/oset/ecg/bss/easi_source_separation.py @@ -0,0 +1,116 @@ +import argparse +import numpy as np + +def easi_source_separation(x, nsou, lambda_, nlintype): + """ + easi_source_separation - An adaptive blind source separation algorithm using the EASI (equivariant adaptive separation by independence) algorithm + + Parameters: + x : ndarray + Input signal as a matrix of size (ncap x T), where ncap is the number of input channels and T is the length of the signal + nsou : int + Number of sources + lambda_ : float + Adaptation parameter + nlintype : int + Nonlinearity type for the adaptation (y2 denotes y**2) + 1: g = np.diag(y2) * y[:, t] + 2: g = y[:, t] * np.diag(0.1 * y2) * np.diag(y2) + 3: g = y[:, t] * np.sqrt(np.diag(y2)) + 4: g = y[:, t] * np.log(np.diag(y2)) + 5: g = -y[:, t] * (np.diag(y2) < 0.9) + 6: g = y[:, t] / np.log(np.diag(y2)) + 7: g = -y[:, t] / np.sqrt(np.diag(y2)) + 8: g = -y[:, t] / np.diag(y2) + + Returns: + y : ndarray + Separated sources as a matrix of size (nsou x T) + B : ndarray + Separation matrix of size (nsou x ncap) + conv : ndarray + Convergence of the algorithm at each iteration (1 x T) + References: + Beate Laheld and Jean-François Cardoso, "Adaptive source separation without prewhitening," Proc. EUSIPCO'94, 183-186, Edinburgh, Sep. 1994. + + Revision History: + June 2024: Translated to Python from Matlab (easi_source_separation.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + """ + ncap, T = x.shape # Number of input channels and length of the signal + idsou = np.eye(nsou) # Identity matrix for nsou sources + + B = np.random.randn(nsou, ncap) # Initialization of the separation matrix + y = np.zeros((nsou, T)) # Initialization of the separated sources + conv = np.zeros(T) # Initialization of the convergence vector + + for t in range(T): + y[:, t] = B @ x[:, t] # Separation of sources using the separation matrix + y2 = y[:, t] @ y[:, t] # Square of the separated sources + + # Nonlinearity adaptation based on the specified nlintype + if nlintype == 1: + g = np.diag(y2) @ y[:, t] + elif nlintype == 2: + g = y[:, t] @ np.diag(0.1 * y2) @ np.diag(y2) + elif nlintype == 3: + g = y[:, t] @ np.sqrt(np.diag(y2)) + elif nlintype == 4: + g = y[:, t] @ np.log(np.diag(y2)) + elif nlintype == 5: + g = -y[:, t] @ (np.diag(y2) < 0.9) + elif nlintype == 6: + g = y[:, t] / np.log(np.diag(y2)) + elif nlintype == 7: + g = -y[:, t] / np.sqrt(np.diag(y2)) + elif nlintype == 8: + g = -y[:, t] / np.diag(y2) + + gy = g @ y[:, t] # Inner product of the nonlinearity adaptation and the separated source + G = (y2 - idsou) / (1 + lambda_ * np.trace(y2)) + (gy - gy.T) / (1 + lambda_ * np.abs(g.T @ y[:, t])) # Update matrix G + B = B - lambda_ * G @ B # Update the separation matrix using matrix G + conv[t] = np.linalg.norm(G) # Store the convergence value at each iteration + + return y, B, conv + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + easi_source_separation - An adaptive blind source separation algorithm using the EASI (equivariant adaptive separation by independence) algorithm + + Parameters: + x : ndarray + Input signal as a matrix of size (ncap x T), where ncap is the number of input channels and T is the length of the signal + nsou : int + Number of sources + lambda_ : float + Adaptation parameter + nlintype : int + Nonlinearity type for the adaptation (y2 denotes y**2) + 1: g = np.diag(y2) * y[:, t] + 2: g = y[:, t] * np.diag(0.1 * y2) * np.diag(y2) + 3: g = y[:, t] * np.sqrt(np.diag(y2)) + 4: g = y[:, t] * np.log(np.diag(y2)) + 5: g = -y[:, t] * (np.diag(y2) < 0.9) + 6: g = y[:, t] / np.log(np.diag(y2)) + 7: g = -y[:, t] / np.sqrt(np.diag(y2)) + 8: g = -y[:, t] / np.diag(y2) + + Returns: + y : ndarray + Separated sources as a matrix of size (nsou x T) + B : ndarray + Separation matrix of size (nsou x ncap) + conv : ndarray + Convergence of the algorithm at each iteration (1 x T) + + Revision History: + June 2024: Translated to Python from Matlab (easi_source_separation.m) + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() + diff --git a/python/src/oset/ecg/bss/mica_projectors.py b/python/src/oset/ecg/bss/mica_projectors.py new file mode 100644 index 0000000..28fa4dc --- /dev/null +++ b/python/src/oset/ecg/bss/mica_projectors.py @@ -0,0 +1,83 @@ +import argparse +import numpy as np + +def mica_projectors(A): + """ + mica_projectors - Multidimensional Independent Component Analysis (MICA) projection matrices. + + Description: + Given an nxn matrix A, which has been estimated by, for example, + independent component analysis of mixtures following the model x = A*s, + this function provides the projectors that can be used to decompose x + into its linear decomposition as follows: x = \sigma_p x_p. Using the + projectors we can find: x_p = P_tilde[p] @ x. See the reference below + for details and notations. + + Parameters: + A : ndarray + An nxn matrix representing the estimated mixing matrix in the ICA model. + + Returns: + P_tilde : list of ndarray + A list of n projection matrices (each n x n) for each independent component. + P : list of ndarray + A list of n projection matrices (each n x n) used to create P_tilde. + + Reference: + Cardoso, J-F. "Multidimensional independent component analysis." In + Proceedings of the 1998 IEEE International Conference on Acoustics, + Speech and Signal Processing, ICASSP'98 (Cat. No. 98CH36181), vol. 4, + pp. 1941-1944. IEEE, 1998. doi: 10.1109/ICASSP.1998.681443 + + Revision History: + June 2024: Translated to Python from Matlab (mica_projectors.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + """ + + n = A.shape[1] # Get the number of columns in A (assumes square matrix). + + P = [None] * n # Initialize a list for P. + S = np.zeros((n, n)) # Initialize S as an n x n matrix of zeros. + + for k in range(n): + # Calculate the projection matrix P[k] for each independent component. + P[k] = np.outer(A[:, k], A[:, k]) / (A[:, k].T @ A[:, k]) + S += P[k] # Accumulate P[k] into S. + + P_tilde = [None] * n # Initialize a list for P_tilde. + S_inv = np.linalg.pinv(S) # Calculate the pseudo-inverse of S. + + for k in range(n): + # Calculate P_tilde by multiplying each P[k] with S_inv. + P_tilde[k] = P[k] @ S_inv + + return P_tilde, P + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + mica_projectors - Multidimensional Independent Component Analysis (MICA) projection matrices. + + Syntax: P_tilde, P = mica_projectors(A) + + Parameters: + A : ndarray + An nxn matrix representing the estimated mixing matrix in the ICA model. + + Returns: + P_tilde : list of ndarray + A list of n projection matrices (each n x n) for each independent component. + P : list of ndarray + A list of n projection matrices (each n x n) used to create P_tilde. + + Revision History: + June 2024: Translated to Python from Matlab (mica_projectors.m) + + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() + diff --git a/python/src/oset/ecg/bss/nonstationary_component_analysis.py b/python/src/oset/ecg/bss/nonstationary_component_analysis.py new file mode 100644 index 0000000..144b703 --- /dev/null +++ b/python/src/oset/ecg/bss/nonstationary_component_analysis.py @@ -0,0 +1,128 @@ +import argparse +import numpy as np + +def nonstationary_component_analysis(x, I, J, mode='COV'): + """ + nonstationary_component_analysis - Nonstationary Component Analysis (NSCA) + algorithm to extract temporal nonstationarities from multichannel data + + Parameters: + x (ndarray): Mixture of signals, where each row represents a different signal (N x T) + I (array-like): Desired time window indices (in 1:T) + J (array-like): Desired time window indices (in 1:T) + mode (str, optional): Calculate covariance ('COV'), correlation ('CORR') or + symmetrized covariance ('SYMM-COV') matrices. Default: 'COV' + + Returns: + y (ndarray): Separated components of the input signals (N x T) + W (ndarray): Separation filters + A (ndarray): Inverse of separation filters + B (ndarray): Covariance matrix computed from time window I + C (ndarray): Covariance matrix computed from time window J + lambda (ndarray): Generalized eigenvalues sorted in descending order + + Note: The time window indices I and J specify subsets of the input signals + for performing generalized eigenvalue decomposition. In 'COV' mode the + time indexes are used to calculate covariance matrices, and in 'CORR' + mode correlation matrices are calculated (the channel-wise means are + preserved contrasting the 'COV' mode). In 'SYMM-COV' mode the data is + artificially zero-meaned by mirroring the samples. See reference [3] + for details of this mode. + + Example usage: + x = ... # Define the mixture of signals + I = ... # Define the time window indices for covariance matrix B + J = ... # Define the time window indices for covariance matrix C + nsca_mode = 'CORR' # Cross correlation mode (preserves channel averages) + y, W, A, B, C, lambda_ = nonstationary_component_analysis(x, I, J, nsca_mode) + + + Reference: + 1- Sameni, R., Jutten, C., and Shamsollahi, M. B. (2010). A Deflation + Procedure for Subspace Decomposition. In IEEE Transactions on Signal + Processing, (Vol. 58, Issue 4, pp. 2363–2374). doi: + 10.1109/tsp.2009.2037353 + + 2- Sameni, R., and Gouy-Pailler, C. (2014). An iterative subspace + denoising algorithm for removing electroencephalogram ocular artifacts. + In Journal of Neuroscience Methods (Vol. 225, pp. 97–105). doi: + 10.1016/j.jneumeth.2014.01.024 + + 3- Sameni R, Jutten C, Shamsollahi MB. What ICA provides for ECG + processing: Application to noninvasive fetal ECG extraction. In2006 + IEEE International Symposium on Signal Processing and Information + Technology 2006 Aug 27 (pp. 656-661). IEEE. + + Revision History: + June 2024: Translated to Python from Matlab (nonstationary_component_analysis.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + """ + if mode not in ['COV', 'SYMM-COV', 'CORR']: + raise ValueError('Undefined mode') + + # Compute covariance matrices for the desired time windows + if mode == 'COV': # covariance + B = np.cov(x[:, I], rowvar=True) + C = np.cov(x[:, J], rowvar=True) + elif mode == 'SYMM-COV': # artificially symmetrized covariance. See ref. [3] + B = np.cov(np.hstack([x[:, I], -x[:, I]]), rowvar=True) + C = np.cov(np.hstack([x[:, J], -x[:, J]]), rowvar=True) + elif mode == 'CORR': # correlation + B = np.dot(x[:, I], x[:, I].T) / len(I) + C = np.dot(x[:, J], x[:, J].T) / len(J) + + # Symmetrize the covariance matrices + C = (C + C.T) / 2 + B = (B + B.T) / 2 + + # Perform eigenvalue decomposition using Cholesky decomposition + eigvals, eigvecs = np.linalg.eigh(np.dot(np.linalg.inv(C), B)) + + # Sort eigenvalues in descending order + sorted_indices = np.argsort(eigvals)[::-1] + lambda_ = eigvals[sorted_indices] + V = eigvecs[:, sorted_indices] + + # Extract separation filters + W = V.T + A = np.linalg.pinv(W) + + # Apply separation filters to input signals + y = np.real(np.dot(W, x)) + + return y, W, A, B, C, lambda_ + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + nonstationary_component_analysis - Nonstationary Component Analysis (NSCA) + algorithm to extract temporal nonstationarities from multichannel data + + Syntax: y, W, A, B, C, lambda_ = nonstationary_component_analysis(x, I, J, nsca_mode) + + Parameters: + x (ndarray): Mixture of signals, where each row represents a different signal (N x T) + I (array-like): Desired time window indices (in 1:T) + J (array-like): Desired time window indices (in 1:T) + mode (str, optional): Calculate covariance ('COV'), correlation ('CORR') or + symmetrized covariance ('SYMM-COV') matrices. Default: 'COV' + + Returns: + y (ndarray): Separated components of the input signals (N x T) + W (ndarray): Separation filters + A (ndarray): Inverse of separation filters + B (ndarray): Covariance matrix computed from time window I + C (ndarray): Covariance matrix computed from time window J + lambda (ndarray): Generalized eigenvalues sorted in descending order + + Revision History: + June 2024: Translated to Python from Matlab (nonstationary_component_analysis.m) + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() + diff --git a/python/src/oset/ecg/bss/pica_matrices.py b/python/src/oset/ecg/bss/pica_matrices.py new file mode 100644 index 0000000..4d685a0 --- /dev/null +++ b/python/src/oset/ecg/bss/pica_matrices.py @@ -0,0 +1,85 @@ +import argparse +import numpy as np +from oset.ecg import phase_calculator + +def pica_matrices(x, peaks): + """ + Calculates covariance and lagged-covariance matrices required for the pseudo-periodic component analysis algorithm (PiCA). + + Parameters: + x (np.ndarray): Matrix of input signals (rows represent channels, and columns represent samples) + peaks (np.ndarray): Vector containing the indices of detected peaks in the input signal + + Returns: + tuple: A tuple containing: + - A (np.ndarray): Covariance matrix between the peaks and the lagged time points + - B (np.ndarray): Covariance matrix of the data + + Reference: + R. Sameni, C. Jutten, and M. B. Shamsollahi. Multichannel electrocardiogram decomposition using periodic component analysis. IEEE Transactions on Biomedical Engineering, 55(8):1935-1940, Aug. 2008. + + Revision History: + June 2024: Translated to Python from Matlab (pica_matrices.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + """ + + # Calculate the phase and discard the second output (not used) + phase, _ = phase_calculator(peaks) + + # PM time calculation for the peaks sequence + J = np.where(peaks)[0] + n1 = np.diff(J) + prd = round(np.mean(n1)) + wlen = max(n1) - min(n1) + + N0 = len(x) + T1 = np.zeros(len(peaks) - prd - wlen) + NN = len(T1) + + for t in range(NN): + df = np.abs(phase[t] - phase[max(t + prd - wlen, 0):min(t + prd + wlen, N0)]) + I = np.argmin(df) + T1[t] = t + prd + I - wlen - 1 + + T1 = np.maximum(T1, 0) + T1 = np.minimum(T1, N0 - 1) + T0 = np.arange(NN) + + # Calculate the covariance and lagged-covariance matrices for the peaks sequence + A = x[:, T0] @ x[:, T1.astype(int)].T + B = x[:, T0] @ x[:, T0].T + + # Symmetrize the covariance matrices + A = (A + A.T) / 2 + B = (B + B.T) / 2 + + return A, B + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + Calculates covariance and lagged-covariance matrices required for the pseudo-periodic component analysis algorithm (PiCA). + + Parameters: + x (np.ndarray): Matrix of input signals (rows represent channels, and columns represent samples) + peaks (np.ndarray): Vector containing the indices of detected peaks in the input signal + + Returns: + tuple: A tuple containing: + - A (np.ndarray): Covariance matrix between the peaks and the lagged time points + - B (np.ndarray): Covariance matrix of the data + + Reference: + R. Sameni, C. Jutten, and M. B. Shamsollahi. Multichannel electrocardiogram decomposition using periodic component analysis. IEEE Transactions on Biomedical Engineering, 55(8):1935-1940, Aug. 2008. + + Revision History: + June 2024: Translated to Python from Matlab (pica_matrices.m) + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() + diff --git a/python/src/oset/ecg/bss/sca_notch_filter.py b/python/src/oset/ecg/bss/sca_notch_filter.py new file mode 100644 index 0000000..3706012 --- /dev/null +++ b/python/src/oset/ecg/bss/sca_notch_filter.py @@ -0,0 +1,89 @@ +import numpy as np +from scipy.signal import iirnotch, filtfilt +import argparse + +def sca_notch_filter(x, fc, Q, fs): + """ + Multichannel notch filter using Spectral Component Analysis (SCA). Designed + for removing powerline and its harmonics from multichannel recordings. + + Parameters: + x (numpy.ndarray): Multichannel input signal (each row represents a channel) + fc (numpy.ndarray): Array of desired notch frequencies + Q (numpy.ndarray): Array of desired notch Q factors (in forward path) + fs (float): Sampling frequency + + Returns: + tuple: (s, W, A, B, C) + s (numpy.ndarray): Separated signal after notch filtering + W (numpy.ndarray): Mixing matrix learned by SCA + A (numpy.ndarray): Unmixing matrix (inverse of W) + B (numpy.ndarray): Covariance matrix of the filtered signal + C (numpy.ndarray): Covariance matrix of the input signal + + Reference: + Sameni, Reza, Christian Jutten, and Mohammad B. Shamsollahi. + "A deflation procedure for subspace decomposition." IEEE Transactions on + Signal Processing 58.4 (2010): 2363-2374. + + Revision History: + June 2024: Translated to Python from Matlab (sca_notch_filter.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + """ + y = x.copy() + + for k in range(len(fc)): + wc = fc[k] / (fs / 2) + bw = wc / Q[k] + + b_notch_filter, a_notch_filter = iirnotch(wc, bw) + + y = filtfilt(b_notch_filter, a_notch_filter, y.T).T + + B = np.cov(y.T) + C = np.cov(x.T) + + B = (B + B.T) / 2 + C = (C + C.T) / 2 + + eigvals, eigvecs = np.linalg.eig(np.linalg.solve(C, B)) + + idx = np.argsort(eigvals)[::-1] + W = eigvecs[:, idx].T + A = np.linalg.pinv(W) + + s = np.dot(W, x) + + return s, W, A, B, C + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + Multichannel notch filter using Spectral Component Analysis (SCA). Designed + for removing powerline and its harmonics from multichannel recordings. + + Syntax: s, W, A, B, C = sca_notch_filter(x, fc, Q, fs) + + Parameters: + x (numpy.ndarray): Multichannel input signal (each row represents a channel) + fc (numpy.ndarray): Array of desired notch frequencies + Q (numpy.ndarray): Array of desired notch Q factors (in forward path) + fs (float): Sampling frequency + + Returns: + tuple: (s, W, A, B, C) + s (numpy.ndarray): Separated signal after notch filtering + W (numpy.ndarray): Mixing matrix learned by SCA + A (numpy.ndarray): Unmixing matrix (inverse of W) + B (numpy.ndarray): Covariance matrix of the filtered signal + C (numpy.ndarray): Covariance matrix of the input signal + + Revision History: + June 2024: Translated to Python from Matlab (sca_notch_filter.m) + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() \ No newline at end of file diff --git a/python/src/oset/ecg/bss/spectral_component_analysis_dft.py b/python/src/oset/ecg/bss/spectral_component_analysis_dft.py new file mode 100644 index 0000000..97c91bd --- /dev/null +++ b/python/src/oset/ecg/bss/spectral_component_analysis_dft.py @@ -0,0 +1,80 @@ +import numpy as np +from scipy.linalg import eigh +import argparse + +def spectral_component_analysis_dft(x, fl, fu): + """ + Spectral component analysis (SCA) using a Fourier domain approach. + Extracts and ranks linear mixtures of multichannel data with maximal energy + in a given frequency band. + + Parameters: + x (ndarray): Input data array (channels x samples). + fl (float): Lower cutoff frequency normalized by sampling frequency. + fu (float): Upper cutoff frequency normalized by sampling frequency. + + Returns: + tuple: A tuple containing: + y (ndarray): Extracted spectral components ranked by their energy in the frequency band of interest. + W (ndarray): Extraction (separation) matrix. + A (ndarray): Mixing matrix. + + Reference: + Sameni, R., Jutten, C., & Shamsollahi, M. B. (2009). A deflation procedure for subspace decomposition. + IEEE Transactions on Signal Processing, 58(4), 2363-2374. + + Revision History: + July 2024: Translated to Python from Matlab (spectral_component_analysis_dft.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + """ + + L2 = x.shape[1] + + freq_indexes = np.arange(max(round(L2 * fl), 1), min(round(L2 * fu), L2) + 1) + + X = np.fft.fft(x, L2, axis=1) + Bf = X[:, freq_indexes] @ X[:, freq_indexes].conj().T + B = 2 * np.real(Bf) + B = (B + B.T) / 2 + + C = x @ x.T + C = (C + C.T) / 2 + + D, V = eigh(B, C) + II = np.argsort(D)[::-1] + + W = V[:, II].T + A = np.linalg.pinv(W) + + y = np.real(W @ x) + + return y, W, A + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + Spectral component analysis (SCA) using a Fourier domain approach. + Extracts and ranks linear mixtures of multichannel data with maximal energy + in a given frequency band. + + Parameters: + x (ndarray): Input data array (channels x samples). + fl (float): Lower cutoff frequency normalized by sampling frequency. + fu (float): Upper cutoff frequency normalized by sampling frequency. + + Returns: + tuple: A tuple containing: + y (ndarray): Extracted spectral components ranked by their energy in the frequency band of interest. + W (ndarray): Extraction (separation) matrix. + A (ndarray): Mixing matrix. + + Revision History: + June 2024: Translated to Python from Matlab (spectral_component_analysis_dft.m) + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() \ No newline at end of file diff --git a/python/src/oset/ecg/peak_detection/__init__.py b/python/src/oset/ecg/peak_detection/__init__.py index 4a16682..f9e14ae 100644 --- a/python/src/oset/ecg/peak_detection/__init__.py +++ b/python/src/oset/ecg/peak_detection/__init__.py @@ -4,4 +4,4 @@ from .peak_det_modified_pan_tompkins import peak_det_modified_pan_tompkins from .peak_det_pan_tompkins import peak_det_pan_tompkins from .peak_det_simple import peak_det_simple -from .peak_det_adaptive_hr import peak_det_adaptive_hr +#from .peak_det_adaptive_hr import peak_det_adaptive_hr diff --git a/python/src/oset/ecg/phase_calculator.py b/python/src/oset/ecg/phase_calculator.py new file mode 100644 index 0000000..b8fcaad --- /dev/null +++ b/python/src/oset/ecg/phase_calculator.py @@ -0,0 +1,78 @@ +import numpy as np +import argparse + +def phase_calculator(peaks): + """ + phase_calculator - ECG phase calculation from a given set of R-peaks. + + Usage: + phase, phasepos = phase_calculator(peaks) + + Inputs: + peaks: Vector of R-peak pulse train + + Outputs: + phase: The calculated phases ranging from -pi to pi. The R-peaks are located at phase = 0. + phasepos: The calculated phases ranging from 0 to 2*pi. The R-peaks are again located at phasepos = 0. + + References: + - Sameni, R., Jutten, C., & Shamsollahi, M. B. (2008). Multichannel electrocardiogram decomposition using periodic component analysis. IEEE Transactions on Biomedical Engineering, 55(8), 1935-1940. + - Sameni, R., Shamsollahi, M. B., Jutten, C., & Clifford, G. D. (2007). A nonlinear Bayesian filtering framework for ECG denoising. IEEE Transactions on Biomedical Engineering, 54(12), 2172-2185. + + Reza Sameni, 2008-2023 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + + Revision History: + June 2024: Translated to Python from Matlab (phase_calculator.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + + """ + phasepos = np.zeros(len(peaks)) + I = np.where(peaks)[0] + + for i in range(len(I) - 1): + m = I[i + 1] - I[i] + phasepos[I[i] + 1:I[i + 1] + 1] = np.linspace(2 * np.pi / m, 2 * np.pi, m, endpoint=False) + + m = I[1] - I[0] + L = len(phasepos[:I[0] + 1]) + phasepos[:I[0] + 1] = np.linspace(2 * np.pi - (L - 1) * 2 * np.pi / m, 2 * np.pi, L) + + m = I[-1] - I[-2] + L = len(phasepos[I[-1] + 1:]) + phasepos[I[-1] + 1:] = np.linspace(2 * np.pi / m, L * 2 * np.pi / m, L, endpoint=False) + + phasepos = np.mod(phasepos, 2 * np.pi) + + phase = phasepos.copy() + I = np.where(phasepos > np.pi)[0] + phase[I] = phasepos[I] - 2 * np.pi + + return phase, phasepos + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + phase_calculator - ECG phase calculation from a given set of R-peaks. + + Syntax: phase, phasepos = phase_calculator(peaks) + + Inputs: + peaks: Vector of R-peak pulse train + + Outputs: + phase: The calculated phases ranging from -pi to pi. The R-peaks are located at phase = 0. + phasepos: The calculated phases ranging from 0 to 2*pi. The R-peaks are again located at phasepos = 0. + + Revision History: + June 2024: Translated to Python from Matlab (phase_calculator.m) + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() + diff --git a/python/src/oset/ecg/synchronous_phase_samples.py b/python/src/oset/ecg/synchronous_phase_samples.py new file mode 100644 index 0000000..7940590 --- /dev/null +++ b/python/src/oset/ecg/synchronous_phase_samples.py @@ -0,0 +1,95 @@ +import argparse +import numpy as np + +def synchronous_phase_samples(peaks, phase=None): + """ + synchronous_phase_samples - Calculation of synchronous time instants from beat to + beat given a set of R-peaks, required for the periodic component analysis + (PiCA) algorithm. + + Syntax: + T0, T1 = synchronous_phase_samples(peaks, phase) + + Parameters: + peaks: Vector of R-peak pulse train. + phase (optional): The ECG phase obtained from phase_calculator + + Returns: + T0: First (or reference) time instant vector. + T1: Second time vector having synchronous phases with T0. + + Reference: + - R. Sameni, C. Jutten, and M. B. Shamsollahi. Multichannel electrocardiogram + decomposition using periodic component analysis. IEEE Transactions on Biomedical Engineering, + 55(8):1935-1940, Aug. 2008. + + Revision History: + June 2024: Translated to Python from Matlab (synchronous_phase_samples.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + """ + I_peaks = np.where(peaks)[0] + D = np.diff(I_peaks) + + if phase is not None: # Use pre-calculated ECG phase + L = len(peaks) + prd = round(np.mean(D)) + wlen = max(D) - min(D) + + T1 = np.zeros(L - prd - wlen) + NN = len(T1) + for t in range(NN): + df = np.abs(phase[t] - phase[max(t + prd - wlen, 0): min(t + prd + wlen, L)]) + I = np.argmin(df) + T1[t] = t + prd + I - wlen - 1 + + T1 = np.maximum(T1, 1) + T1 = np.minimum(T1, NN) + T0 = np.arange(1, NN + 1) + + else: + if len(I_peaks) < 3: + T0 = [] + T1 = [] + else: + start = I_peaks[0] + stop = I_peaks[-2] + + T1 = np.zeros(stop - start + 1) + k = 0 + for t in range(start, stop + 1): + T1[t - start] = I_peaks[k + 1] + round((t - I_peaks[k]) * D[k + 1] / D[k]) + if t >= I_peaks[k + 1]: + k += 1 + T0 = np.arange(start, stop + 1) + + return T0, T1 + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + synchronous_phase_samples - Calculation of synchronous time instants from beat to + beat given a set of R-peaks, required for the periodic component analysis + (PiCA) algorithm. + + Syntax: + T0, T1 = synchronous_phase_samples(peaks, phase) + + Parameters: + peaks: Vector of R-peak pulse train. + phase (optional): The ECG phase obtained from phase_calculator + + Returns: + T0: First (or reference) time instant vector. + T1: Second time vector having synchronous phases with T0. + + Revision History: + June 2024: Translated to Python from Matlab (synchronous_phase_samples.m) + + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() diff --git a/python/src/oset/generic/__init__.py b/python/src/oset/generic/__init__.py index 8b25e4d..08e1f8c 100644 --- a/python/src/oset/generic/__init__.py +++ b/python/src/oset/generic/__init__.py @@ -1 +1,4 @@ from .tanh_saturation import tanh_saturation +from .bp_filter_dft import bp_filter_dft +from .bp_filter_complex_ma import bp_filter_complex_ma + diff --git a/python/src/oset/generic/bp_filter_complex_ma.py b/python/src/oset/generic/bp_filter_complex_ma.py new file mode 100644 index 0000000..3eb67de --- /dev/null +++ b/python/src/oset/generic/bp_filter_complex_ma.py @@ -0,0 +1,99 @@ +import numpy as np +from scipy.signal import lfilter +import argparse + +def bp_filter_complex_ma(x, fc, bw, order): + """ + Applies a zero-phase bandpass filter to the input signal using a + multi-stage moving average (MA) filter with complex-valued frequency shifting. + + Parameters: + x (ndarray): Input data vector or matrix (channels x samples). + fc (float): Normalized center frequency of the bandpass filter (between 0 and 1). + bw (float): Normalized bandwidth of the bandpass filter (between 0 and 1). + order (int): Order of the MA filter. + + Returns: + ndarray: Filtered data vector or matrix (channels x samples). + + Notes: + - fc and bw are normalized by the sampling frequency. + - The filter performs forward-reverse filtering successively. It has zero-phase for even MA filter orders + and a phase-lag equal to a single stage MA filter for odd MA filter orders. + + Revision History: + July 2024: Translated to Python from Matlab (bp_filter_complex_ma.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + """ + + M, N = x.shape # Number of channels and samples + + # Simple lowpass moving average filter used as a template + L = round(2 / bw) # Length of the moving average filter + h = np.ones(L) / L # Coefficients of the moving average filter + + # Exponentials used for frequency shifting + n = np.arange(N) # Time index + w = np.exp(-1j * 2 * np.pi * fc * n) # Complex exponential for forward filtering + v = np.exp(1j * 2 * np.pi * fc * n) # Complex exponential for reverse filtering + + # Real part of the filter + x1 = x * w # Apply frequency shifting to the input signal + + y1 = x1 + for _ in range(order): + y1 = np.apply_along_axis(lambda m: np.convolve(m, h, mode='same'), axis=1, arr=y1) + y1 = np.flip(y1, axis=1) # Reverse the signal (for reverse filtering) + + if order % 2 == 1: + y1 = np.flip(y1, axis=1) # Reverse the signal again for odd filter order + + z1 = y1 * v # Apply reverse frequency shifting + + # Imaginary part of the filter + x2 = x * v # Apply reverse frequency shifting to the input signal + + y2 = x2 + for _ in range(order): + y2 = np.apply_along_axis(lambda m: np.convolve(m, h, mode='same'), axis=1, arr=y2) + y2 = np.flip(y2, axis=1) # Reverse the signal (for reverse filtering) + + if order % 2 == 1: + y2 = np.flip(y2, axis=1) # Reverse the signal again for odd filter order + + z2 = y2 * w # Apply forward frequency shifting + + y = np.real(z1 + z2) # Combine the real and imaginary parts to obtain the filtered signal + + return y + + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + Bandpass filter using complex moving average (MA) filtering. + + Parameters: + x (ndarray): Vector or matrix of input data (channels x samples) + fc (float): Normalized center frequency of the bandpass filter + bw (float): Normalized bandwidth of the bandpass filter + order (int): Filter order (number of moving average stages) + + Returns: + ndarray: Vector or matrix of filtered data (channels x samples) + + Revision History: + July 2024: Translated to Python from Matlab (bp_filter_complex_ma.m) + + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument('x', type=np.ndarray, help='Input data array (channels x samples)') + parser.add_argument('fc', type=float, help='Normalized center frequency') + parser.add_argument('bw', type=float, help='Normalized bandwidth') + parser.add_argument('order', type=int, help='Filter order') + args = parser.parse_args() \ No newline at end of file diff --git a/python/src/oset/generic/bp_filter_dft.py b/python/src/oset/generic/bp_filter_dft.py new file mode 100644 index 0000000..465b2b3 --- /dev/null +++ b/python/src/oset/generic/bp_filter_dft.py @@ -0,0 +1,74 @@ +import argparse +import numpy as np + + +import numpy as np + +def bp_filter_dft(x, fl, fu): + """ + Bandpass filter using discrete Fourier transform (DFT) filtering. + + Parameters: + x (ndarray): Vector or matrix of input data (channels x samples). + fl (float): Normalized lower frequency. + fu (float): Normalized upper frequency. + + Returns: + ndarray: Vector or matrix of filtered data (channels x samples). + + Notes: + - fl and fu are the lower and upper frequency ranges of the bandpass filter + normalized by the sampling frequency. + - The filter does not perform any windowing on the data. + + Revision History: + June 2024: Translated to Python from Matlab (bp_filter_dft.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + """ + + if fl > 0.5: + raise ValueError('fl may not exceed 0.5') + if fu > 0.5: + raise ValueError('fu may not exceed 0.5') + if fl > fu: + raise ValueError('fl may not exceed fu') + + N = x.shape[1] + S = np.fft.fft(x, n=N, axis=1) + + k_cut_low = int(np.floor(fl * N)) + S[:, :k_cut_low] = 0 + S[:, (N - k_cut_low + 1):] = 0 + + k_cut_high = int(np.ceil(fu * N)) + if k_cut_high > 0: + S[:, (k_cut_high + 1):(N - k_cut_high)] = 0 + else: + S = 0 + + y = np.real(np.fft.ifft(S, n=N, axis=1)) + return y + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + Bandpass filter using discrete Fourier transform (DFT) filtering + + Parameters: + x (ndarray): Vector or matrix of input data (channels x samples) + fl (float): Normalized lower frequency. + fu (float): Normalized upper frequency. + + Returns: + ndarray: Vector or matrix of filtered data (channels x samples) + + Revision History: + June 2024: Translated to Python from Matlab (bp_filter_dft.m) + + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() diff --git a/python/tests/notebooks/test_bp_filter_complex_ma.ipynb b/python/tests/notebooks/test_bp_filter_complex_ma.ipynb new file mode 100644 index 0000000..e718d39 --- /dev/null +++ b/python/tests/notebooks/test_bp_filter_complex_ma.ipynb @@ -0,0 +1,103 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from oset.generic import bp_filter_complex_ma" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate synthetic data\n", + "np.random.seed(42)\n", + "n_samples = 1000\n", + "t = np.linspace(0, 1, n_samples)\n", + "signal = np.sin(2 * np.pi * 10 * t) + np.sin(2 * np.pi * 20 * t) # A signal composed of 10 Hz and 20 Hz components\n", + "x = np.tile(signal, (3, 1)) #3 channels with the same signal\n", + "\n", + "# Normalize frequencies by sampling frequency\n", + "fs = 1000 # Sampling frequency\n", + "fc = 15 / fs # Center frequency (normalized)\n", + "bw = 10 / fs # Bandwidth (normalized)\n", + "order = 2 # Order of the filter\n", + "\n", + "# Apply the bandpass filter\n", + "y = bp_filter_complex_ma(x, fc, bw, order)\n", + "\n", + "# Plot the results\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(t, x[0, :])\n", + "plt.title('Original Signal')\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Amplitude')\n", + "\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(t, y[0, :])\n", + "plt.title('Filtered Signal')\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Amplitude')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/python/tests/notebooks/test_peak_det_simple.ipynb b/python/tests/notebooks/test_peak_det_simple.ipynb index e2c9ddc..ae163d1 100644 --- a/python/tests/notebooks/test_peak_det_simple.ipynb +++ b/python/tests/notebooks/test_peak_det_simple.ipynb @@ -9,7 +9,19 @@ "start_time": "2023-08-12T01:27:40.167727600Z" } }, - "outputs": [], + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'oset'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_11268\\3113435382.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpyplot\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0moset\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgeneric\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlp_filter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlp_filter_zero_phase\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mlp_filter_zero_phase\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 5\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0moset\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mecg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpeak_detection\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpeak_det_simple\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mpeak_det_simple\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'oset'" + ] + } + ], "source": [ "import scipy.io\n", "import numpy as np\n", @@ -22,7 +34,6 @@ "cell_type": "code", "execution_count": 2, "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2023-08-12T01:27:41.941381Z", "start_time": "2023-08-12T01:27:41.816228500Z" @@ -51,15 +62,19 @@ "outputs": [ { "data": { - "text/plain": "
" + "text/plain": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" }, { "data": { - "text/plain": "
", - "image/png": "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" + "image/png": "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", + "text/plain": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" @@ -80,11 +95,11 @@ "cell_type": "code", "execution_count": 4, "metadata": { - "tags": [], "ExecuteTime": { "end_time": "2023-08-12T01:27:42.401385100Z", "start_time": "2023-08-12T01:27:42.272207900Z" - } + }, + "tags": [] }, "outputs": [], "source": [ @@ -95,18 +110,28 @@ { "cell_type": "code", "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-12T01:27:42.681979400Z", + "start_time": "2023-08-12T01:27:42.401385100Z" + } + }, "outputs": [ { "data": { - "text/plain": "
" + "text/plain": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" }, { "data": { - "text/plain": "
", - "image/png": "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" + "image/png": "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", + "text/plain": [ + "
" + ] }, "metadata": {}, "output_type": "display_data" @@ -121,14 +146,7 @@ "plt.legend()\n", "plt.grid()\n", "plt.show()" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2023-08-12T01:27:42.681979400Z", - "start_time": "2023-08-12T01:27:42.401385100Z" - } - } + ] } ], "metadata": { @@ -147,7 +165,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.9.13" } }, "nbformat": 4, diff --git a/python/tests/notebooks/test_phase_calculator.ipynb b/python/tests/notebooks/test_phase_calculator.ipynb new file mode 100644 index 0000000..ede7bf0 --- /dev/null +++ b/python/tests/notebooks/test_phase_calculator.ipynb @@ -0,0 +1,338 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "21be3b50", + "metadata": {}, + "outputs": [], + "source": [ + "# Add the directory containing the 'oset' package to the Python path\n", + "#sys.path.append(os.path.abspath(os.path.join('')))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0d274e22", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "import numpy as np\n", + "from scipy.signal import find_peaks\n", + "import scipy.io as sio\n", + "import matplotlib.pyplot as plt\n", + "from oset.ecg import phase_calculator\n", + "from oset.generic.lp_filter.lp_filter_zero_phase import lp_filter_zero_phase\n", + "from oset.ecg.peak_detection.peak_det_simple import peak_det_simple\n", + "from matplotlib.ticker import MultipleLocator, FuncFormatter" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "09c154e7", + "metadata": {}, + "outputs": [], + "source": [ + "file_path = \"../../../datasets/sample-data/SampleECG1.mat\"\n", + "data = sio.loadmat(file_path)[\"data\"][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "851db1d1", + "metadata": {}, + "outputs": [], + "source": [ + "f = 1\n", + "fs = 1000\n", + "fc = 0.5\n", + "t = np.arange(len(data)) / fs\n", + "data = data - lp_filter_zero_phase(data, fc / fs)\n", + "peaks, peak_indexes = peak_det_simple(data, f / fs)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a9af44dd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 5))\n", + "plt.plot(t, data, \"b\", label=\"ECG\")\n", + "plt.plot(t[peak_indexes], data[peak_indexes], \"ro\", label=\"ECG Peaks (max detection)\")\n", + "plt.xlabel(\"time (sec)\")\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1952bc08", + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate phases using the phase_calculator function\n", + "phase, phasepos = phase_calculator(peaks)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "f3ec4a6a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Phase: [-1.54663023 -1.53919451 -1.53175878 -1.52432306 -1.51688734 -1.50945162\n", + " -1.5020159 -1.49458017 -1.48714445 -1.47970873 -1.47227301 -1.46483728\n", + " -1.45740156 -1.44996584 -1.44253012 -1.4350944 -1.42765867 -1.42022295\n", + " -1.41278723 -1.40535151]\n", + "Phaseops: [4.73655508 4.7439908 4.75142652 4.75886224 4.76629797 4.77373369\n", + " 4.78116941 4.78860513 4.79604086 4.80347658 4.8109123 4.81834802\n", + " 4.82578374 4.83321947 4.84065519 4.84809091 4.85552663 4.86296236\n", + " 4.87039808 4.8778338 ]\n" + ] + } + ], + "source": [ + "# Print the results\n", + "print(\"Phase:\", phase[:20]) # Print first 20 values for brevity\n", + "print(\"Phaseops:\", phasepos[:20]) # Print first 20 values for brevity" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "2e32c646", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def format_func(value, tick_number):\n", + " N = int(np.round(value / np.pi))\n", + " if N == 0:\n", + " return \"0\"\n", + " elif N == 1:\n", + " return r\"$\\pi$\"\n", + " elif N == -1:\n", + " return r\"-$\\pi$\"\n", + " else:\n", + " if N > 0:\n", + " return r\"${0}\\pi$\".format(N)\n", + " else:\n", + " return r\"$-{0}\\pi$\".format(-N)\n", + "\n", + "# Visualization\n", + "\n", + "plt.figure(figsize=(14, 10))\n", + "\n", + "# Plot Phaseops over time\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(t, phasepos, label='Phaseops (0 to 2π)')\n", + "plt.title('Phaseops Over Time')\n", + "plt.xlabel('Time (seconds)')\n", + "plt.ylabel('Phase (radians)')\n", + "plt.legend()\n", + "plt.grid()\n", + "ax = plt.gca()\n", + "ax.yaxis.set_major_locator(MultipleLocator(base=np.pi))\n", + "ax.yaxis.set_major_formatter(FuncFormatter(format_func))\n", + "\n", + "# Plot Phases over time\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(t, phase, label='Phase (-π to π)')\n", + "plt.title('Phases Over Time')\n", + "plt.xlabel('Time (seconds)')\n", + "plt.ylabel('Phase (radians)')\n", + "plt.legend()\n", + "plt.grid()\n", + "ax = plt.gca()\n", + "ax.yaxis.set_major_locator(MultipleLocator(base=np.pi))\n", + "ax.yaxis.set_major_formatter(FuncFormatter(format_func))\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "c1ab451a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def format_func(value, tick_number):\n", + " N = int(np.round(value / np.pi))\n", + " if N == 0:\n", + " return \"0\"\n", + " elif N == 1:\n", + " return r\"$\\pi$\"\n", + " elif N == -1:\n", + " return r\"-$\\pi$\"\n", + " else:\n", + " if N > 0:\n", + " return r\"${0}\\pi$\".format(N)\n", + " else:\n", + " return r\"$-{0}\\pi$\".format(-N)\n", + "\n", + "num_values_to_show = 2500\n", + "t_short = t[:num_values_to_show]\n", + "data_short = data[:num_values_to_show]\n", + "phase_short = phase[:num_values_to_show]\n", + "\n", + "# Phase Superimposed on ECG with Separate Y-Axes for the first 3 values\n", + "fig, ax1 = plt.subplots(figsize=(14, 5))\n", + "\n", + "# Plot ECG signal\n", + "ax1.plot(t_short, data_short, label='ECG Signal', color='blue')\n", + "ax1.set_xlabel('Time (seconds)')\n", + "ax1.set_ylabel('ECG Amplitude', color='blue')\n", + "ax1.tick_params(axis='y', labelcolor='blue')\n", + "ax1.grid()\n", + "\n", + "# Create a second y-axis to plot phase\n", + "ax2 = ax1.twinx()\n", + "ax2.plot(t_short, phase_short, '--', label='Phase (-π to π)', color='orange')\n", + "ax2.set_ylabel('Phase (radians)', color='orange')\n", + "ax2.tick_params(axis='y', labelcolor='orange')\n", + "\n", + "ax2.yaxis.set_major_locator(MultipleLocator(base=np.pi))\n", + "ax2.yaxis.set_major_formatter(FuncFormatter(format_func))\n", + "\n", + "fig.tight_layout()\n", + "plt.title('ECG Signal with Phase for selected values')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "1c3ea81c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from matplotlib.ticker import MultipleLocator, FuncFormatter\n", + "\n", + "def format_func(value, tick_number):\n", + " N = int(np.round(value / np.pi))\n", + " if N == 0:\n", + " return \"0\"\n", + " elif N == 1:\n", + " return r\"$\\pi$\"\n", + " elif N == 2:\n", + " return r\"$2\\pi$\"\n", + " elif N == -1:\n", + " return r\"-$\\pi$\"\n", + " else:\n", + " if N > 0:\n", + " return r\"${0}\\pi$\".format(N)\n", + " else:\n", + " return r\"$-{0}\\pi$\".format(-N)\n", + "\n", + "num_values_to_show = 2500\n", + "t_short = t[:num_values_to_show]\n", + "data_short = data[:num_values_to_show]\n", + "phasepos_short = phasepos[:num_values_to_show]\n", + "\n", + "# Phaseops Superimposed on ECG with Separate Y-Axes for selected values\n", + "fig, ax1 = plt.subplots(figsize=(14, 5))\n", + "\n", + "# Plot ECG signal\n", + "ax1.plot(t_short, data_short, label='ECG Signal', color='blue')\n", + "ax1.set_xlabel('Time (seconds)')\n", + "ax1.set_ylabel('ECG Amplitude', color='blue')\n", + "ax1.tick_params(axis='y', labelcolor='blue')\n", + "ax1.grid()\n", + "\n", + "# Create a second y-axis to plot phaseops\n", + "ax2 = ax1.twinx()\n", + "ax2.plot(t_short, phasepos_short, '--', label='Phaseops (0 to 2π)', color='orange')\n", + "ax2.set_ylabel('Phaseops (radians)', color='orange')\n", + "ax2.tick_params(axis='y', labelcolor='orange')\n", + "\n", + "ax2.yaxis.set_major_locator(MultipleLocator(base=np.pi))\n", + "ax2.yaxis.set_major_formatter(FuncFormatter(format_func))\n", + "\n", + "fig.tight_layout()\n", + "plt.title('ECG Signal with Phaseops Superimposed for selected values')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/python/tests/notebooks/test_spectral_component_analysis_dft.ipynb b/python/tests/notebooks/test_spectral_component_analysis_dft.ipynb new file mode 100644 index 0000000..97d9ccb --- /dev/null +++ b/python/tests/notebooks/test_spectral_component_analysis_dft.ipynb @@ -0,0 +1,105 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from oset.ecg.bss.spectral_component_analysis_dft import spectral_component_analysis_dft" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3gU5drG75mt2VRSCV0RaUfFXrChYu9dPrvHevSo6LEcy7GLFRsWRMGKgAhKkSa99x5qCOk9m2zfnfL9Me2d2dnNJoQE4f1dFxeb3dnd2Slvud/7eR5GFEURFAqFQqFQKBQKhUKhUCgUSjvCdvQOUCgUCoVCoVAoFAqFQqFQjjyoKEWhUCgUCoVCoVAoFAqFQml3qChFoVAoFAqFQqFQKBQKhUJpd6goRaFQKBQKhUKhUCgUCoVCaXeoKEWhUCgUCoVCoVAoFAqFQml3qChFoVAoFAqFQqFQKBQKhUJpd6goRaFQKBQKhUKhUCgUCoVCaXeoKEWhUCgUCoVCoVAoFAqFQml3qChFoVAoFAqFQqFQKBQKhUJpd6goRaFQKBQKBQCwcuVK3HTTTcjPz4fdbkfnzp1x4403YsWKFS36nFdeeQUMw7RqHxYuXAiGYbBw4cJWvT9Rzj//fJx//vnNbheJRPDVV1/h1FNPRWZmJlwuF3r27IlrrrkGU6ZMUbcrKioCwzAYN27cwdvpFnAw9ue1117DgAEDIAiC7vmmpia8+eabOOWUU5CWlgaHw4FevXrh3nvvxfr169XtlOuitra2zfapIxk3bhwYhkFRUVHC74lEIujduzc++uijg7ZfFAqFQqH8naCiFIVCoVAoFHz66acYPHgwSktL8e6772LevHl4//33UVZWhrPPPhufffZZwp/1z3/+s8VClsJJJ52EFStW4KSTTmrV+9uaO+64A4899hiGDBmCH3/8EdOmTcOLL74Iq9WK2bNnq9vl5+djxYoVuOKKKzpwbw8e5eXlePfdd/Haa6+BZbXh4969e3HiiSdixIgRGDJkCMaPH485c+bg1VdfRVVVFU4++WQ0NjZ24J4fWthsNrz88st47bXXUFdX19G7Q6FQKBRKh2Pt6B2gUCgUCoXSsSxbtgxPPPEELr/8ckyZMgVWqzY8uPXWW3Hdddfh8ccfx4knnojBgwfH/By/3w+Xy4Vu3bqhW7durdqXtLQ0nHHGGa16b1uzb98+TJgwAS+//DJeffVV9fkLL7wQ999/v84x5HA4Dpn9Phh8/PHHyMjIwPXXX68+x/M8rrvuOtTW1mLFihX4xz/+ob523nnn4a677sKff/4Jm83WEbt8yHLbbbdh+PDh+Oqrr/Df//63o3eHQqFQKJQOhTqlKBQKhUI5wnn77bfBMAy++OILnSAFAFarFZ9//jkYhsGIESPU55VQrPXr1+PGG29Ep06d0Lt3b91rJKFQCE899RQ6d+4Ml8uFc889F+vWrUOvXr1w9913q9uZhe/dfffdSElJwZ49e3D55ZcjJSUF3bt3x1NPPYVQKKT7nldffRWnn346MjMzkZaWhpNOOgnffPMNRFFs8XFRnCz5+fmmr5OOoVjhcr///juOP/54OBwOHH300fj4449Njw/DMHj00Ufxww8/oH///nC5XDjhhBMwffp03XZ79uzBPffcgz59+sDlcqFr16646qqrsGXLlmZ/T01NDR544AF0794dDocDOTk5GDx4MObNmxf3feFwGN988w2GDRum+81Tp07Fli1b8Pzzz+sEKZLLLrsMLpdL91xVVRVuu+02pKenIy8vD/fee2+Um2rUqFE499xzkZubi+TkZBx33HF49913EYlEdNudf/75+Mc//oE1a9bgnHPOgcvlwtFHH40RI0boREPluho/fjxeeOEFdOnSBWlpabjooouwc+fOqP2eN28eLrzwQqSlpcHlcmHw4MH466+/4h4nANiwYQOuvPJK5ObmwuFwoEuXLrjiiitQWlqqbmO323HLLbdg9OjRrbouKRQKhUI5nKBOKQqFQqFQjmB4nseCBQtwyimnxHQ3de/eHSeffDLmz58PnudhsVjU166//nrceuuteOihh+Dz+WJ+zz333IMJEybgmWeewQUXXIDt27fjuuuuQ1NTU0L7GYlEcPXVV+O+++7DU089hcWLF+P1119Heno6Xn75ZXW7oqIiPPjgg+jRowcAKU/WY489hrKyMt12idC/f39kZGTg1VdfBcuyuPjii9GrV6+E3z9r1ixcf/31OPfcczFhwgRwHIf3338fVVVVptvPmDEDa9aswWuvvYaUlBS8++67uO6667Bz504cffTRAKQwuqysLIwYMQI5OTmor6/Hd999h9NPPx0bNmxA3759Y+7PHXfcgfXr1+PNN9/EscceC7fbjfXr1zcbRrZq1SrU1dVhyJAhuufnzJkDALj22msTPiYAcMMNN+CWW27Bfffdp4paAPDtt9+q2+zduxfDhg3DUUcdBbvdjk2bNuHNN9/Ejh07dNsBQGVlJf7v//4PTz31FP73v/9hypQpeP7559GlSxfceeedum3/+9//YvDgwRgzZgyamprw7LPP4qqrrkJBQYF6Xf/444+48847cc011+C7776DzWbDV199hUsuuQSzZ8/GhRdeaPq7fD4fhg4diqOOOgqjRo1CXl4eKisrsWDBAng8Ht22559/Pr744gts3boVxx13XIuOH4VCoVAohxUihUKhUCiUI5bKykoRgHjrrbfG3e6WW24RAYhVVVWiKIri//73PxGA+PLLL0dtq7ymsG3bNhGA+Oyzz+q2Gz9+vAhAvOuuu9TnFixYIAIQFyxYoD531113iQDEiRMn6t5/+eWXi3379o25zzzPi5FIRHzttdfErKwsURAE9bXzzjtPPO+88+L+ZlEUxRkzZojZ2dkiABGAmJWVJd50003iH3/8odtu3759IgBx7Nix6nOnnnqq2L17dzEUCqnPeTweMSsrSzQOwQCIeXl5YlNTk/pcZWWlyLKs+Pbbb8fcP47jxHA4LPbp00d88skn4+5PSkqK+MQTTzT7m4288847IgCxsrJS9/yll14qAhCDwWBCn6NcF++++67u+UceeUR0Op2680OinMfvv/9etFgsYn19vfraeeedJwIQV61apXvPgAEDxEsuuUT9W7muLr/8ct12EydOFAGIK1asEEVRFH0+n5iZmSleddVVUftwwgkniKeddpr63NixY0UA4r59+0RRFMW1a9eKAMSpU6c2eyx2794tAhC/+OKLZrelUCgUCuVwhobvUSgUCoVCaRZRDjMyhp3dcMMNzb530aJFAICbb75Z9/yNN94YFS4YC4ZhcNVVV+meO/7447F//37dc/Pnz8dFF12E9PR0WCwWNbF0XV0dqqurE/oukssvvxzFxcWYMmUKnn76aQwcOBBTp07F1VdfjUcffTTm+3w+H9auXYtrr70WdrtdfT4lJSXqdygMGTIEqamp6t95eXnIzc3V/UaO4/DWW29hwIABsNvtsFqtsNvt2L17NwoKCuL+ltNOOw3jxo3DG2+8gZUrV0aFwsWivLwcDMMgOzs7oe2b4+qrr9b9ffzxxyMYDOrOz4YNG3D11VcjKytLPY933nkneJ7Hrl27dO/v3LkzTjvttKjPNF4bsb4bgLrt8uXLUV9fj7vuugscx6n/BEHApZdeijVr1sR0BB5zzDHo1KkTnn32WXz55ZfYvn17zGOQm5sLACgrK4u5DYVCoVAoRwJUlKJQKBQK5QgmOzsbLpcL+/bti7tdUVERXC4XMjMzdc/HyrdEooSH5eXl6Z63Wq3IyspKaD9dLhecTqfuOYfDgWAwqP69evVqXHzxxQCAr7/+GsuWLcOaNWvwwgsvAAACgUBC32UkKSkJ1157Ld577z0sWrQIe/bswYABAzBq1Chs27bN9D0NDQ0QRTHqNwPRx0HB7Fg4HA7dfg8fPhwvvfQSrr32WkybNg2rVq3CmjVrcMIJJzT7+yZMmIC77roLY8aMwZlnnonMzEzceeedqKysjPu+QCAAm82mC9sEoIZINnftGDH+TofDoX4PABQXF+Occ85BWVkZPv74YyxZsgRr1qzBqFGjdNvF+jzlM82OR3PfrYRW3njjjbDZbLp/77zzDkRRRH19venvSk9Px6JFizBo0CD897//xcCBA9GlSxf873//ixIAlWu5tdckhUKhUCiHCzSnFIVCoVAoRzAWiwVDhgzBrFmzUFpaappXqrS0FOvWrcNll10WJUwYnVNmKEJAVVUVunbtqj7PcVyz+Yxawi+//AKbzYbp06frBKypU6e22XcAkhjzwAMP4IknnsC2bdswcODAqG06deoEhmFM80c1JwLFQ8l39NZbb+mer62tRUZGRtz3Zmdn46OPPsJHH32E4uJi/PHHH3juuedQXV2NWbNmxX1fOByGz+dDcnKy+vwll1yC0aNHY+rUqXjuueda/ZuMTJ06FT6fD7/99ht69uypPr9x48Y2+45YKG6wTz/9NGY1xViiIgAcd9xx+OWXXyCKIjZv3oxx48bhtddeQ1JSku4YKcJWW7nPKBQKhUL5u0KdUhQKhUKhHOE8//zzEEURjzzyCHie173G8zwefvhhiKKoJqRuKeeeey4AyalD8uuvv4LjuNbttAkMw8BqteqEs0AggB9++KFVn+fxeOD1ek1fU0LlunTpYvp6cnIyTjnlFEydOhXhcFh93uv1RlXUawkMw6juHoUZM2a0OAysR48eePTRRzF06FCsX78+7rb9+vUDICUfJ7nmmmtw3HHH4e2338bWrVtN3zt79mz4/f4W7ZsidJK/UxRFfP311y36nNYwePBgZGRkYPv27TjllFNM/5HhmLFgGAYnnHACRo4ciYyMjKhjXFhYCAAYMGDAQfkdFAqFQqH8XaBOKQqFQqFQjnAGDx6Mjz76CE888QTOPvtsPProo+jRoweKi4sxatQorFq1Ch999BHOOuusVn3+wIEDcdttt+GDDz6AxWLBBRdcgG3btuGDDz5Aeno6WLZt1siuuOIKfPjhhxg2bBgeeOAB1NXV4f33348ScRJl586duOSSS3DrrbfivPPOQ35+PhoaGjBjxgyMHj0a559/ftxj8tprr+GKK67AJZdcgscffxw8z+O9995DSkpKzBCw5rjyyisxbtw49OvXD8cffzzWrVuH9957L2blRIXGxkYMGTIEw4YNQ79+/ZCamoo1a9aoFQLjcf755wOQKhkqOZgAyWU3ZcoUXHzxxTjzzDPx8MMPY8iQIUhOTsb+/fvx66+/Ytq0aWhoaGjRbxw6dCjsdjtuu+02PPPMMwgGg/jiiy9a/DmtISUlBZ9++inuuusu1NfX48Ybb0Rubi5qamqwadMm1NTU4IsvvjB97/Tp0/H555/j2muvxdFHHw1RFPHbb7/B7XZj6NChum1XrlwJi8WiCrYUCoVCoRypUFGKQqFQKBQKHnvsMZx66qn44IMP8NRTT6Gurg6ZmZk4++yzsXTpUpx55pkH9Pljx45Ffn4+vvnmG4wcORKDBg3CxIkTcemllzYbdpYoF1xwAb799lu88847uOqqq9C1a1fcf//9yM3NxX333dfizzvmmGMwfPhwzJ8/H7///jtqampgs9nQp08fvPHGGxg+fHhcQe3SSy/F5MmT8fLLL+OWW25B586d8cgjj6C8vLzV7q2PP/4YNpsNb7/9NrxeL0466ST89ttvePHFF+O+z+l04vTTT8cPP/yAoqIiRCIR9OjRA88++yyeeeaZuO/t3r07zjnnHPz+++944IEHdK/17t0b69evx6effoopU6bgiy++QCgUQn5+Ps4991wsXboU6enpLfqN/fr1w+TJk/Hiiy/i+uuvR1ZWFoYNG4bhw4fjsssua9FntYbbb78dPXr0wLvvvosHH3wQHo8Hubm5GDRoEO6+++6Y7+vTpw8yMjLw7rvvory8HHa7HX379sW4ceNw11136badOnUqLr/88ja79ikUCoVC+bvCiEo5HQqFQqFQKJR2ZPny5Rg8eDB++uknDBs2rKN3p12IRCIYNGgQunbtijlz5nT07iTM5MmTccstt2D//v26vGCUlrN371706dMHs2fPjnJQUSgUCoVypEFFKQqFQqFQKAeduXPnYsWKFTj55JORlJSETZs2YcSIEUhPT8fmzZujKusdLtx3330YOnQo8vPzUVlZiS+//BKLFi3CnDlzcNFFF3X07iWMKIo466yzcPLJJ+Ozzz7r6N35W3PPPfegtLQUc+fO7ehdoVAoFAqlw6HhexQKhUKhUA46aWlpmDNnDj766CN4PB5kZ2fjsssuw9tvv33YClKAlCz96aefVkP/TjrpJMycOfNvJUgBUuLur7/+Gn/88QcEQWizPGBHGhzHoXfv3q0uGkChUCgUyuEGdUpRKBQKhUKhUCgUCoVCoVDaHbrMRaFQKBQKhUKhUCgUCoVCaXeoKEWhUCgUCoVCoVAoFAqFQml3qChFoVAoFAqFQqFQKBQKhUJpd2ii82YQBAHl5eVITU0FwzAdvTsUCoVCoVAoFAqFQqFQKIc0oijC4/GgS5cucQukUFGqGcrLy9G9e/eO3g0KhUKhUCgUCoVCoVAolL8VJSUl6NatW8zXqSjVDKmpqQCkA5mWltbBe0OhUCgUCoVCoVAoFAqFcmjT1NSE7t27q5pKLKgo1QxKyF5aWhoVpSgUCoVCoVAoFAqFQqFQEqS5NEg00TmFQqFQKBQKhUKhUCgUCqXdoaIUhUKhUCgUCoVyKLBvMVC7p6P3gkKhUCiUdoOKUhQKhdICVhbWYW+Nt6N3g0KhUCiHG1XbgO+uAj47uaP3hEKhUCiUdoPmlKJQKJQE2Vvjxa2jVwIAikZc0cF7Q6FQKLHxR/zgRA5pdpoP829DxeaO3gMKhUI5vOEjgMXW0XtBMUCdUhQKhZIguyo9Hb0LRzwlnhI89tdj2FC9oaN3hUI5pLno14swePxg+CK+jt4VSqIwdFhOoVAoB40Vo4A384HilR29JxQDtPejUCgUyt+GZxc/i4WlC3Hnn3d29K5QKIcsoijCE5ZE9N0Nuzt4bygJQ1YnEsWO2w8KhUI5HJn9X0CIAL//q6P3hGKAilIUCoXSCniBThg6AjrBplCahxM49XGQD3bgnhw6FNQV4KZpN2FZ2bKO3pXE4CMdvQcUCoVyeMKFOnoPKAaoKEWhUCgJQi5ihzmh43bkCCbE04EEhdIcEUETNEJ08A0AeHT+o9hRvwMPzXuoo3clDkQnwwU6bjcoFArlcIajizWHGlSUolAolITRJgxUlOoYRFCHGoXSHKQoRZ1SEvWB+o7eheYRiX6FiokUCoVycKDt6yHHYS1Kvf322zj11FORmpqK3NxcXHvttdi5c2dH7xaFcmTjqdRyZVRsAr46D9g7v2P3KUEEIsdHiOM7cE8oFAolNmE+rD72R/wduCeHDgL+BgsJxHmjK/kUSstpCkawcGc1OP5vcL9TOg7avh5yHNai1KJFi/Cvf/0LK1euxNy5c8FxHC6++GL4fLQSDeUwoGw9sHZs3GSoZe4AZm+rhHioJExd+SXwQV9g0bvS35PuBio2Aj9c15F7lTCkOyqUgFPqlT+2YeTcXQdzlyiUvweHSht0hEA6pZSE50c6gvg3mKSS4cl0JZ9CaTF3fbsad49dg3HLizp6Vw5v5r0KzHiqo/ei9ZALAJRDgsNalJo1axbuvvtuDBw4ECeccALGjh2L4uJirFu3rqN37dBHFAFfbUfvBSUeXw8Bpj8B7JoVc5Oz35mPB39YhxlbKtpvv+Ix61np/4VvSf83JbZfvMBjdcXqDi9t3hJRqqjWh3HLi/DxX7tpUvRDlF1VHgTC1PF20Fn7LfDu0UD5ho7ekyMGUpTyRrwduCfR/LnvT9w2/TaUe8s7elcOPUghiq7kUygtZkOxGwDwxybavhw0/PXA0g+BNWOAJnqcKW3DYS1KGWlsbAQAZGZmdvCe/A1Y8BbwXm9g88SO3hNKc9TsiPmSYk5YVXiI5tJgLQlt9lPBT7hvzn14cO6DB3mH4hPiSVEqvpjhDWnVryIHwUb+t1j1b2Pa0vG3cGc1Lh65GDd9tbzNPpMSg+lPAoF6YNoTUS8Jgog6L3WEtDUR/tB1Sv2+93dsrduKZeV/kyp47QQviJi+oUh7gjqlKJRWk55k6+hdOHyp2qY9Dh1aix6Uvy9HjCgliiKGDx+Os88+G//4xz9ibhcKhdDU1KT7d0SyWA6vmvF0x+4HRcesrRV4a2YBBNJ5wzQv7Nith+itziS2X7/t/g0AsKlm08Hcm2ZpiVOKI85RW4tSTy18Cpf/djkCR1h1prb8vb+uKwUAbC07Qtv4jsBESB27vAgnvzFPPR9/ZyJCBC8sfQHT9k7r6F05pJ1SQdkBRHNd6ZlXUIU95YRDnTqlKAcDT+VhGwlBLlyltVKU2lG/Aw/Pexg76mMv+B7xkKJUsLHj9qMDWFe1DjdPuxkbqzd29K4cdhyiM9W259FHH8XmzZsxfvz4uNu9/fbbSE9PV/917969nfbwECVBJwulfXjox/UYvbgQs7YSdtkEzlGHiVL+emD119L/ZiQoSh0qCWp1olSkGVGKEKIifMscPmuL6rFgR3XM1+fsn4MybxlWVaxq0ef+3WkM6Qc/B+IWowGVHYDFHvXU69O3AwCentSxgnNbsLF6I/7Y+wdGbx7d0buCsKDly/CGD01R6kgT1ZvDF+Jgh+awRUQvSnG8gJu/WoFnf93cJt93yOSapLQfYb+U1/O93oBwaIyr2pLGgCbGt9Ypdeefd2Jp2VI8Pv/xttqtw4+qrdrj0JElSj0872EU1Bfgjj/v6OhdOew4IkSpxx57DH/88QcWLFiAbt26xd32+eefR2Njo/qvpKSknfbyEIVhgJqdB5SkNsILWLK7Bj4inImSILtmA0tHRh3/uga39kcMpxTpznF0lCi1ejQw82lg1Vfmr7NW7XE4dr6oQ2XwTIbshZtxP5FOqpY6pW78cgXuGbcG5e7oSVuISITrtDpb9Ll/dxrD+sFPkDoJ/l6YiFL/6JqmPi4zud5bQ6mnFLzQ/rnCmkKS6y7Id/x1eSiH7yltGBWl9FgtLBzQzpvRKbWj0oPV++oxYW0JPMEIDoRH5j2CYTOGdch9QulAPEQez8Pw/qts0u6Z1o4blXap3EdzJcVE55RqG7d5mBP+FqH8tN86eBzWopQoinj00Ufx22+/Yf78+TjqqKOafY/D4UBaWpru3xGNvw4YdRqw/NNWf8TH83bjjm9W47HxNMlti/n5ZmDeK0DhQt3TNp4Ie2AY07d6g5oI2HFOqTrp/8YY4i5Z/cJXE/NjRMLXste9FxdOvBATdkxoiz1sEZJTStqXUCT+YN5PJNAOJ1CpT4F0WJlN0pWJLwDY2ehJ/uGM0SlFBwd/MyzRK9dpTu25udsqD/grZhfNxmW/XYYRq0cc8Ge1FE9EEn/Ch0BVH131vcihJUop9y0N39NjZRnY44hSQaLP2VLW2OpJd4gPYUnZEmyt24qaQOx+l/I3h+fiLyhHOl48bxEhL1C6Lu5vqmzUflOwGTd7c2Q4Mg7o/YctggBUF2h/t1H43tWfLcXJb8xDSf1B7hfIxfBWtKFOy5G1GNyeHNai1L/+9S/8+OOP+Pnnn5GamorKykpUVlYiEKATmRYz9+VWv/W7FUUAgPlxwpEozdBYohuA2jjCVRQxv549hCgldFT1N2VQbZa/gOcAQmCBry7mx5BhWqsrV6M6UI2FpQvbaCcThw8HMMv+HN61ftVsTil/WDv+XAuOf5B0WJl8BynMkBPPI4HmRKkWTdIODfPd4Q95TkycUj5CvK31HriY83PBzwCAX3b+0u4OS8WRdCg4+HQ5pQ6x8D3qlDLHwjL68D1DonO3Xzunw75ehVtGr2zV95DOOT9HhUE0lQOzngfq9h4S926bEPICn54EjLtC/zzhoMTfTRT++RZgzAXA9t9jblLVRIpSUt8ya2sFbh29AoU1LWsHqSgVg7BX77ILtd4pFeJ41R21o1Jql2a3weJUXMgIg1YsIKXZj3CzykHksBalvvjiCzQ2NuL8889Hfn6++m/ChPZ3WPz9af3g3sKaO3koLUDgdSKIjSc6hBiDqCbC3t+cgHLQUAbVflmUInNIBd36bf2xE2+SopQyweqICU3PhhXox5bgZuui+O4nUcQJq/+Dl6w/AGhZ+B65Gm523prC2gDgUHBktCfG8D3yGthetx3nTjgXE3ceuRVDV1asxNQ9Uzt6N/SQE2sTp5SfCOv2hQ88xHtA1gD18R73nsTeFAkCK78AahPcXmHfEsBTpf6pTPYPhfvy75DonIpSenhBhIMhrh1D3+4O6BchVu+rb9WCEylSUrcagEl3Ays/x1+/XItTfzr18OhDds0C3PuB/cukPFIK5DUVY0HzkGX/Uun/WOkgAFQ2av1NMMJjY4kbD/24HisL6/HHpubD8ch7I92RDkAS0ReXLqb3ioJRhDqA8L1rPluGk9+Yp3O4HfQ5I7k41orKgan21DbcGQrJYS1KiaJo+u/uu+/u6F3727Oz0oN//bQeu6uaDwtgDeFl2+q24cJJFx4SFYoOachcDyKvS6xt40mnlL6jnLapHI+N34Aaj9Y5tyR8rE0xOqVIUSrQoN82wWowSihKe05o9rr3oj5YD56PLxip1O5Cr/IZuM/6JxgILTr+pCjlMcnDRrqF3l79Nm6fefshMQluD4xOKXJV+5Xlr8AdcuP1la8D68a18551PCE+hPvn3I+Xlr2EUs8hVMkuRPQRJkUZyDBXf0h6vK28Ef/6eX2LV7YBwEpY8xeVLkrsTcs/AWY9B3x2cuJfVL4B+O5KYMoD6lOKKMWJHDihY3MoRuWUqtgMFCZ4PA4ySs6tjnTp3DPrHqysaJ3T6GAR5oRmnFLR7XyQiw4j/2FFESasKY75PTqnFJ1oAyVSwZAnkyWB7/WVr3fk3hwYkSDwxWBg8n3ac02EGEOKUoeAKLy8fDk+XPdhy9pL44ImQZVH+32BCI8fVuxX/05kcbDSp7l0GEhzl3dWv4N//fUvvLjsxcT38TCmtLJK/8QBhO8p7qgFO7VImoNvZCCE/Fa4iNMcmlOKzPFKOXAOa1GK0gpEUd+BxeD2b1ZhxpYK3P5N89W/jO3L80ueR7W/Gv9d+t/W7uVhy+cbP8fj8x+Xko+Sq1iCgAAhVjARUpTSr6Y+Nn4Dpm0qxyfzd6vPdbxTSgnNIy4GoyiVoFPKJydEby9RqsRTgmt/vxaX/HoJOKKKXigSJ3SOmEzYwbXQKaVta5bMlnQLlXhKsKlmE/4q/ivhz/87Y5xAkdeALpRxWvNVc8g8ZYdKIv0DYV3VOvWx0VHWIVRtB/56HeFGbVIALoytZY3475QtqmhOuqO88uNrPluGGZsr8FQrKvKRAu1e997E3rR/eYu/BzW7pP/r96lPkZN9o1C8tnItSjztVziFvB8iQgSh0ecA318NuE32YfvvwMJ3DqigSaJwgibYtbgNb6oAVnwOBNwHvB9rq9bi/jn3H/DntBhBAJZ+BBQtgz/i103Gw5wQN9F5YyC6PyBFXQCo94Xx0u/b8OzkLboFDpKDEr63dz6w+D3tGuJCQGNZ23x2OyHGyM95MOEFHt9u/Rabatqo+mj1dn1lNABoIhYpDjGn1INzH8TYrWMxedfkxN8URwQhE2UHI4JOyA2Emx+HVfi0RPBK+zRp1yQAwNz9cxPfx0QJuNul3W0rIryAx8cZFjdaGb5HFg4ihSijkaHN4QkBtBWilMPiUB/XBWKnHaG0HCpKUfTMfwP4sH+zmykTiqqm5lViYwPT7pb9vfOBhv3Nb3cI8MWmLzC/ZD5WVKzQDx4ETidK6SynMVY699VqwlXIZDXVuO3YZftiDmJbjfIbwl5pABTXKRU74SopSrW3U2pDtZSgP8gHESIGD3zYEDbZWAr466XHxP5KolQLckoR56ApEL162GQyADhSwmCMv5Oscsa0cCBDjgNDnIDfN5Zhf13sCpAdRvUOfaWbGCwv04SV9nQ/VPmqMLtodnR+szEXYvTm0Thz7j3Y5JDt8lwQV322FD+vKsZzk6Wy9oo7SnosXe9KDrbiuti/o84bwmfzd6PcHcDWska1QEBY0CYhCa9ikolPE8Unr+wSAgkZJkd+9476Hbhn9j24/LfLW/49rcR4PjxK29tkIhRMvBNY+JZUUIMLae3YQYA8Li1ut366CZj9fEKis5FDRnjeMR2Y9z+U/3gVLpp0Ef6z6D/qS2FeiJvoXMkplZmshZ+Q9w+g7+tjVTwmE9+3SVsRCQA/XCeNH4uWSM+NvQwYOQCo3Br/vYcoqypWtUu/Onf/XIxcNxK3z7y9bT7QrKgMudBMLmIeQi65/Z5mxujk/RtHlPIR90MwwsNL3AOBSHw3liAKugW+g37+i1cB7/QEfv/Xwf2eNsQb5BDK2IqfU1PU58RgY8JhxG/NLMDNX65AmBPQ4DNPMXLQnVKkKy9O1e9YkAtOtYFaVPoqD53+5W9Ou4lSbrcbY8aMwfPPP4/6emnAs379epSV/b1WUg57lrzf5h/ZoTml9i2RBksfH9+qt6+pXIOd9TvbeKeaJ8AF9KtYET8C5Iooqe7HyClFVt8LNVOFZOiHi/DqtO34fEH8nCq7G3ZjxOoRia8OkOEHvtr4opQ3TvU9osFXYv7bKyEpQ7i7fMSEig8T58dfD4wcCLwrV/gUtXNlR0TnlHpj+na8NZOoXGKAnFQ055RSSDh8b+N4YMIdh8QKaWswruqTf5PnCUCLVh9nba3E479sxHnvLTyQ3Wt7+Ajw+enAF2c1m/tgWfky9XF7ilLvrnkXTy96Gg/Pexji6q+Bkf8AancDET8+zcxAmAFGZ0i5OcAF1dOyocSNMCcgTNwbPsMEOyfVgVg8MWEj3p+zC2eNmI8rP12KV6ZJwh15LyQ8qYglStXs0udjIfHKIQyhRjXUmnSgkOKLImy3J2T4HgAElH7YmNeLvE/c+yXh58MBulxZbQl5Tlp8nVZtkf4v+KPF3xsrPMgb9uLXXb+ixt9OVejqJffe6Ix0eCIezCuep/ZvYU6Ag4kjSslOqX8NOQbZKZIw5TdMtEk3rzeWKEVcpz6uDYT4gunaY0WkLZOdm5t/OfDP7wD+OeefeH7J8wf9e0hnTpuEApk5IUnH2iHmlFLghWYWRMM+7LLZMCY9DaGIV3IcmkBe8yFO0DkJjf2LkfE7xmPybs2xddBFqcXvSf9v/Ongfk8bUuvzYn/nNXg7OxP1rDSe31lUiss/WaKrHB2L0YsLsbqoHgt2VqPOp13vtUS6kYM+YyQXbELNp6AxQi74fLjuQwz9dSi+2/ZdW+zZEU+7iFKbN2/Gsccei3feeQfvv/8+3G43AGDKlCl4/vmD3+hTOhajUypq8ngwKW59zoiixiLcO/te3DjtxjbcodiQwosgCvoBQ9gXM3zP5/Ng7vboCQRZ8S3UTGehbLuyMP4K+Q1/3ICfCn7Cm6vejLud9sHEIMtfC5DXQpQoFbvihgBi4hpp3/A9cuLkFbUOjCfPT+UW7bEgRIXvKRNvtz+MMUv3YfTiQtT7zIUkUkBsMhOlQtGiVMJV+JZ/Kk3o9i1ObPtDDOMklhQmo1oV4/VlgCfuj4JKzX1mdsw7DFJ89sWuXhriQ7pQNV+k/RxfSl6eVRWrsGLBi9JK/cynQQ7/c5RcbMQ9c3xgNQpePxV9GC20pKIpgIlrtUlVdooDs7dV4uTX52LhTv3vX7JbH+7740ophw4pxiTulIrOdYX9y4FRpwLjbzV/j5fYH3nlPpYo1RE530jHGAAElQUBzrAv5D3FhaTwHy6gCUBtzAE5pRTEloejk65KkqcXP41XV7yKB+c92Lp9aSly6MdumyYOKm16tFPKPKdURpINLrskpCoTbUEQcdvolbh77Gp1e7ICL0mb5ZSq3QPsmgNs+ll7zujkbU5saGcK3YV4ZtEzKHQXNrtte4TFk+XlE9mnZlGcUqc/DJwru/Ca/gailNjMdRJ044Zu+fg4MwNj09O0RQGZ6qYgft9YpgtxDUZ4nVvQGOpqZN5ufZt3pDjQW0KV160+9lqltkwMNmFHpQe7q6MXzp7/bTOu/3wZIrygn+MIom4MXE2IUvHSXaytXItP1n/S+srTotimTiklbcIH6z5o3f5QdLSLKDV8+HDcfffd2L17N5xOrQG+7LLLsHjx33NydDgyZfcUnNWjG7bYo8t2HwgscZXxragU02ZfTuKv15fGNWFVhZYvqz2S1pKTCEEU9Ekowz6wNTtwPrsRAMASk87N+ypx//drMXOLtuJmpDmnlAKHJszdPzdmg6/k4dlRvyOhz9M7peoMTim39H/m0dL/njiilEn4XogPNb+61gbUhzShLiBogpCohO8tek+/0hXx6wZ7diaCiGxNJicJ9T7zCXNQ55QyCd8LR4fvJdxBKxMQ78FxQRxsjE4pZdC4rXYbQobcANOWrEZJfewJF+nQcVg1UWLNvoMXutRiSJdOnMFTmadMlyOrTdwPCdI5ubP6uMIiH8dgE0qsmvsoV7mmifZgnP1dnMDswYe2z9XnSuoDeObXzerfLrsFD/6wDnW+MN6YEdtdSKIL3+MSFaVMnFLrpcqZ2BcjOTgpSskCaCxRqiOSoRrbhJCyIGAUIchQmJBHC+85SPmASCG5TSZ9wUZgy69RAo6RWOdgWZnkMNzdsNv09TaHYdHIMtjm0MZZZZ5SYPF76FK9GA5donPznFIZLhtcdule88t52HZWebCisA57a7R7PxGn1AHllPrsZODnm6QUCQrGxYBDTJR6cuGT+LPoz8TziR3ksJytldq4Z7e7Da5BxSmV1RtI7y49jilKHTrhe2ai1K+7fsX/zfw/yZlPtFNbHQ7J1Ulw45cr8PgvG3VpKwKG8D1/M9VdV+yTxtDh+sHS+7nAgYVl1e4GPj9Lap8OE2p82nnwpEh9fyojXUeC4Vjxgojxq0uwvtiNdfsbokL0SFGqhkhQHy8H7j2z78HXW77GpJ2TWvcDjO1RK3JKGRd8KG1Hu4hSa9aswYMPRq9Cde3aFZWVsSeilPZDEAW8vPxleCwsxqXHKHdJJIezWRJ3O1kId0xznYKRA47TZUwu8cYyKcxq9Plx30ompW0P5wE5aJacUsTgIexDn8WPYpz9XfyDKYSF2B9WXgEeu2xfzBWG5nJKKRQ5RmD4wuH4ueDnuNuRif7iQg6A/IbwPWVAlIAoRUIOqGOtfrclbqLSSwBaByZEAlJFqwVvAJsnaG8I+6KcUooTjXThkCtDJGSi8yaTxLZmOaUSdmIo++WN7bo5lFFW9e2sNKELuvfj+9En49YZt6LIp+XN4ABMXbQaw8bEdkqSQm0jkQx1ZeEhlLiSFKLiOL+MCbTbM3yPFBYWJLvwf/l5+D9rA5a5tAWoiNIF1O7EO9bRyIFbfa0zE/t3uYnrPys5scUS8l5IuH0gRSnlHknO1p4zC2XTOaXc0mZErh5yP8jH7VWVL2b4njHsmRSlfDXaYohZ7qk2gDwnbZJke8XnUqWx766Ku9khUyUp7MVemx08MS4qLZwDzH8DV297ohmnlJkoxeteI/EebKeUGQG3PpFwax0NB4nCRsmNVB2oxs76nXho7oPYGm8h9r3eCK//GZPWlugqGhtJdIxlpKRR62921e9q1WfoaJSrLmb0ANK6So911feI3xA5+OOneJDje7MFxldXvIrNNZvxxeyHdTlHGVGMClMsNlmAMjqlfM04pcBK24p8srRPIt96Rw4ATH8SqN6mr4ToqwV+vBH46WagRHM1Iuz7WyQ8r/Nr/YXbKfWRaZCOvbG9IZPO2yyM7lywDIM6r7lTKpxAGKByH7cY40JIsOVJ2s3G21amFXkpKVG0iyjldDrR1BR94nfu3ImcnJz22AVKM2z46wX1cZdYnSsxGbZZDJdOnMaUNEc1F9NNUthYiCETh+D7bd8n9gZfLTDqDMm5IorS6kSdSY6kXbOk/+UKJREhguELh2PMljG6zXY2aLmkzNwpbQ3Z0EX4iL7xDNQjuUkKzzmX3Qwr4YRwQnrfmqIGvDDFPOQinGD1vQgrhcTM2z8v7nbNilJCtDMCvlrogqyUyVEnOQ9T0B3TTk46pcjwtfawVzcEtUlzANpxFyMh84SbYa/u3NkRQWVjEG5/WJe4vNZrLiSRic4TdUolPLlTjvnfVZSSf2dWUhYAILBrFt5zRB9HH8sgn6lHSX3s64N0pJHix+xtVaa5EYz283i0WdJLUgyPU3HMKEq1Z/geeQ8uciVhs9OBzRYe36YTZZOJCfgt1oV4y6a1tWKccO7VhGutR6ZLfRwvxLJVic5JsVzJMUGuoFaatKuk2zDQAFEU1Xx3gOQICnJBPPrXoxi9ebS2f+0UyhfbKWUclBNtWGOpFtrQDk4pTuAObNIHaPmlSlZJ+x+DhF1zB5tQE4KGlAblxP2bxBD7GcMplZ5kV8P3lIU+s8p8MZ1ShHi6vyF+mHNMYjnNAw0AIXo150hvb5KsSerjpxY9hWXly3FPfm7sN/jrYP/jYfzn182469vVpptsLnXj+Ffm4KN5zYtKoihiTVG96hKp9bvV17bVJuhAj/5QYOEIYPNETaxJ7w6ky6IUeV8YcpV2JJyoXZ/xwveaytYCC97WPSfKItXOSk/M4x6MCDohKtDMojjDSOfEBi2Jd6wx5vriBpz9znzM2ho7QsE0X1HBH8CeucDu2VI+QoV3jgI+PwMoWRN3HzuaekLEqXdkAABSEAADAU2G8SpZCCsUEXTzvzAv6MP3DNseFJZ+BLzdTf+cWWGAZjAu+ABAki3JZEtKS2kXUeqaa67Ba6+9hohcQp1hGBQXF+O5557DDTfc0B67QGmGOdvHN78RIUrZrcSls3se8F5vYMcM07eRuZC8IU6XUyre5G3k2pGoC9bhvbXvNb9vALBpPFBTIDlXdsyQVic2/Ki9rnyXIX/IX8V/Ye7+ufh4/ce6/dpet139m1xZbHNWfgn8+SxCxAD0zfkzMKNsJXbZbFiYlARUbQMjh+ecwRbASogQiigFABPXmg/K49lhzbA2U40qrii15VfgrS5S8tMopxQxGFdCk1LzAGWgGMMtRYpS5CAh0A45ERpC2qA9yJCilF8fm64Q9ulWIB2I4LXp2zHotbm6iYOy6jpqwR58OEcTQIOtyCnlSzQuXnVKtSB8TxBiJqH/q/gv/N/M/0NJU/uUuldW9bOckihVL5pP8H0siy5MbMeTIIi6gQ/pMiiu9+O92Tt1Qm6NJ4RT3piHZydv1n2OL+LDlVOu1CXEDXJBXD316gNLkhtslP6R55Vw7KnsmgNsHH/IiFIk1UT4XsgwCT+R1RYLBDC6amKxINuweGGZ5IDRE/Zg7v65pveMDlK8UiYSpHBbudmwPQf4iesr4EaAC+gmVmE+jMm7J2NR6SJdaGV7OXaMYk8wEVHKXaw+5NxSX+IPc3GPd0sxikMHvLDQ5UTt8cbYDt/2cNU2x85KD0I+N8KG+6GMWGTqwhDhw8Sx4gVR7Q9Ip5Qy0avxRl9XnhiiFCmeziko1jkaEiaWSB50J1QduKNItWuRAPubpBCwYKw0DwDIEer2CvPFyc/m70GIE/DRvObD75btqcNNX67ApR9JqUvcZFha3WbTCW+zlKwCFr4N/Ha/1k9kdNfC94Ju7XzpnFIdmzOJFOjjiVICAJRormcGwJjZa7Gn2oMrP12S0HEHElgUZ6Vjb2eTYWOlnG+x2qf7v1uL0oYAHvpxfezPs5j0a7EiAvgQULMDmP9a/H3sAHiBV8fgbkKUarBJC08sI6ITvFGFeSqbtDbXF9aHUgYjPOp0OaW0bWM5pUg3XamnFNMLp7dsAXDe/6KfI8NAd88Ffr0XqNsbvR2BWfiey+oy2ZLSUtpFlHr//fdRU1OD3NxcBAIBnHfeeTjmmGOQmpqKN99MMGEy5eAhiqggcqoEYlXLC5o7pcRf75EG6L8MM38bsVKxv86HBiJUJt6AtMUrqKRQQoZTKSgCCUOIUlwYpR5NyFEmvZW+Sp0j5aCKUrOeBVZ9iVDpWvWpoHMlniv8CTd0y8djnXOww6/Zr09hd8HJafumW1mNQUtFKYtZ4l+CuKLU749Kx3rC/8WvvqdMFG0uIFXOSxOjw47V8QT49nVK+RliYsOHopO6AnL4HplTSuuIyY63xhNCMMLjvdk78cn8PahslF6L5ZTa17gPG6s36vZHgSxFHxflHlCs8N5qqSzxwneADweaOw1mPw+8fwxQGJ1b54kFT2BzzWa8uuLVxL7/ADE6pRbGuPa9DIsuTK3pa3trvDjx9bm6CYbb4DL4anEhnpywUf174toSNAYiUaLv1tqt2N+0H9MLp2Pizomo9FViWfkyFDUVYXrhdLQKLgx8eQ7w5dn6kD3jJFAUpXwuUx9CiRz2oeR3ai9RShTFhEQFoyiVAu09PFjkpDQfDkyGx5iJJEqVV3KiUx+sx/CFw/HIvEfifzgZxpKIKOWvhW66GnRH9REhPqRb2CCfbw+MjqxERCmRGKC7K/fhp1X7ccUnS3HOuwuwtya6jfl9Yxke/nFdi8LyjW32AYePkQsfcVa9Ozp8b2OJG5d8tBgLNxciZBhilQbN26rCilr8tEo6J55gRF1XS0+yIdkhib5KVV6z0LJEwvfAhnSTRx07/5QWzcwIxMi9F2jQuwybKTjR3ihig5FYU9sAE2M8TJCVookPzeVNXbC7DI6831HHS059L+FaC/IBzNk/p+VuSjI8DwAc6YAjFXCkAHLeH6Xqo86BT957peva3aVjdE3GQjCcgxVJTszOLsC7czYgwicuSpAL5GYwcuVLu8WuOupiudDNnIlRtESUUmhFOFlrEEQBj/31GN5Z/U6z29024zYMmzEMgiigkRCcG1gHmlKk9Bv3WWdGOfvJdsUf5uALk6KUoMurSt42sSI7yHHusvJleH7J85iyexp2VB7AMWuQ+7zdc4GfbgS2TgYm/zNuLjyz+zPZltz6faCotIsolZaWhqVLl2Ly5MkYMWIEHn30UcycOROLFi1CcjI9kR2OtxoeYqXIOIFQIQavdlKUMsnbRE6syY7g0Z83wBfWGvN4YUfNCSNRkIPT/ctiv05+btiLcq/WoVf5JQdJuU/fyR9UUUrZFb/5wBQA9hKVelxMCANDm9S/nYigH1OM+1JWgIV5Yx6Ok+/ATPBR4qNFUUSj7CIhV/CcVmfUe1RS87THOqdUnd4ppVxPVichSplboUmbN0m7hO8RTqkAq/2eTfuq8O3ytWgyirhhryGnlHbcqpr0ohQ5sFFWkciwMjKn1NVTr8Ydf96hC71QSEiE4DlAWY1UnFI/3Qh8ezGw8C2gqRRYNy76favkSclvsRPDksngDyaKMy7TmQkAqIrhlPKzDHox0uBv8rpSVfADgP/9vi1qQKlUtXr4/N64sJ8UyrG6SPtNZAVR8n4hr7/XV76Of/31L7BEtyq0okoY6gul1Tt3sb56qNEpRdxbJV4p1Kpfp34A2i+nVFgIJ/QbjX2Kkyh7z0JEVopd1zR8eftJUZ9BOgjN8oc4Zfeu2Srm5trNUc/p0BWVkAe+ZLXDWkMYuDH8NdBgKkopTgwSZUA7cedELC49eIVeopxSSjtluDYK9mlCDkP08UmBSrwwZYuaOHieSYXXx3/ZiD+3VuKHFdG/MxatckqF/UDRUvPXyM+L4egE9BPgjmDWVqk9skU8CMvnghGl/8tiCDw17ia8NHUrapZ+h8Bu6VpJcVhhs7BIUpxS8kTPVJQK6a+BjdUbsaZyjW7BjWHDsbMvjL9VWjQrM3GD+GOJUm69UypO2HFHEMs16Y8x7m2M46JSyErWRHWztomkQpgDe+YKuHp+g5J6Pzg5JYDASSFjzy15Dv9e8G98vflrXbGduBgnyclZxM71lv6vk3PwmDmlIgFgzAXANxe1qhpZayEn98Z2gHTFiICummuQZbEz1Yt94kTTz7VbWXWRgsQXwzkISO5pxSnlZJ2qKBWrfeISKdpkMRFAm3OpRwJoDDW2buzQAjbXbMbC0oX4seDHuNu5Q24U1BdgW9021AZqdf2cByxWHf0YAOCflj/h9+rFoWqdKBXtlIpVgVoRpRYUL8CI1SPUvswsn+o7C//ApR8tweJdsdv++D9wv7TAN49YWC1fHzc5PU10fvBoF1FK4YILLsDTTz+NZ555BhdddFF7fjUlBgUVTRg/dUpiohTRIJCrQXySPi/YnG2VGPi/2Ri/uhgRXtA13oEIr65GSH/HHpBamBaKUuSKnN8kdEdZDSc75VAT9ri1CUeNX2rYqv36SUd7iFKhOMKC8UZ1QPsNToTwnu1LvMR9iocs08w/O45Tyswqq4Tvvf3nDpzw2hws2V2jG8jazVaAFHIHao/JiZExp5SyImRLiuuUEkUx5oTiYItSoijqnVIWqTMSAZTkrcZI61TcnZ+nf1PYq6++R1RTImPsa70hXdiYYn0mJ9++MA+OF5pNjpyQU4o8hsrkrWKTfht7CmISZzDlDroxvXB660IPEkQURVXE7pnWM+62XpbFMUw5ABFPTdqE277WxJ2iuuj7TDkP6Uk2fHjzIADSJE8ZxJKFHciy0sb8XrsadulCX1t1fdYT1vF9hGhhnNzJjp4IgNKA1F71y5JEqfaqvpdo+GwTE7u9yIAXFpbRTYy7ZkRb4UmnVLk7uj1w2qT+olU5m8jfoTqliEFuQ5E+b2KUKOWOuge9ES8K6qIrBob4EEqaSlQRc9KuVlYRagZjmxFiGMxKduGbunW6Cd/01eZ5bJKZENKIHHrxDCNGpyEA/FzwMy6bdB0eGb9IF4ZsDKMj75GYE7EpDwLjrtA/p/wG8nz7Yk9MEnFKHUw3lVKEJJXxq2OsVE66ZptitBMOhHEsipEz79/InyKlukhPkia6ybIolahTatK6fbjjzztw7+x7UeXT2nKGDekWEVUE4lyYuTviOqU8+r+Vz+tg11REiMTsK4ts5g4qtyF/qlmeLvL47aryIBDm8fbMAmwscUdt28hpx35eQRUYi3TuucYT1OeXlS3DJxs+wT/n/DP2jyExjneTMrXHSiEZpV8h2zrluiPPSzuKUmRbYFxYIxeseZg71ry8uesoxWFVFykALd1IiBNiOtmaghF1buK0OmFjpYVXMpKixZCiFCe3U804pXYIAZz9y9l4cemLrf/eBEg0nJnsTxuCDbr7p0kEtqQMRki0wcFEIPhqcMc3q3DRh4vgD3O6xUBfiNOJgkFOH76n+055vvLvBf/GTwU/YWbhTOn7TPKpNgakz/h9Y3nUawkRbAT2/gVUbZEWyE+6U3qeCBdF3V5g1vNAUzkE0Xw83h4L5EcCBy1d/CeffJLwtv/+978P1m5QmmHWl8/iSeZnfNeti/pcTLsyYSslJwjhpGzYlHLKgQY88tN68IKI53/bgiuOz4/+HFYbPMVzSpGTuxAfaj65tlnOFRJlUk50ymKwCXsaNFFKcUqRgzbgICY6lwfWE1JTMLnYXFACtNW6LUIvHMcW6V5zIYRjGckp8aT1VywSTsA2sZdum1ii1NayRkxYo6yUa+eUkWWw0Yul1bU3Z27EyNu1BIFxRZJYK4v+Ws2pA2jny5YEpMrXSWMJmnbPxnjPLlze51p0T+0OTuB0OVlIDnZOKT/n1zkOvLIoVWy1ojKjCACw226HCE1uiwQ8sBECUDynlJsIZVXcOyHDBMEb4sAz8UVRb3NlbRe/D6z/Tvs71Gi+0m2W18GVpQ166wu1QS5BTaAGzy95Hrvqd2H4KcPj70srCQthNe9E38y+cbdtZKxIYbzIRz0qkKUrE00OlNTt5WOfZLMg3WVDJ5cNDf4I9tf5MaBLmi5EoN4XVkNnFLG6c3JnVPqkwSYpCPkivpbbusniDGTYGNG+LSldAl/9XlwKYI/dBk7kkWpPRe/03ur3tgeJDsSWMQMAmLsgk5gwuJB+fzslR08QSbG2yhBuxFgbIWYtQaG7d+sSZ5Phe8EmYN13+iTzYY80cXPJkz2jQBt0o6l6m+6p7XXbTVdUw3xY1+99sfEL3HTsTS3f52YwHocAw+KZnE4Q3RtRtupNvHzmyxAEEWlM7GulC1OPJlESqslckNvLm7Cp1K3+bTO4ErxhL95eLSUm3lM5C93m5+K/l/eX3luhn0Arrr6fCn7CqA2jMPri0fhH9j/0O6IkMycJeYCkDL3YHkeUSmQS5g174UhKsLJsC1GKJ6QgoIpSaTzQZAP8MVbeHYigG6P9Jis4ZLike0NJdK45paJ/nyfEoS5QhyAXwTNTViClj/w86bZlwuZVycg+xWxMGEtgCrr1CZ6Vduv3f0lpFR5ehsrkTthWtw1Dug8BKzvtx+8Yjx+3/4jRF49G15Su5p99gMTLLbfLHkOUUsczUi9f1RRESk4Kyt0BPPfbFtx39lG647e7yoN526swaV0pxi0vws43LlNfq/OGIArasZy7XROlIu7T0C3TjmpmQct/mFEkd5k5pZTwPROnFJlXrh0dhaTgYXT3+ojrL8QwpmlFIrz5ONRlt4CBVm0vN9WB0gbpt/rDHFKd0ee63hcGWGl/dleF4GQ4WJKApxc9ndiPqS8EZv4HGPw4cNS50nPkwnqwEUjJadYpNcbBAbBiWuE0vHXOW4l9dysgFwBEUQQTY95HLgjXBerg50hRSoAryMEPBxyIYH9lHZbsl7ZftqcOVYRQ7g/z8BM5vYIRIWY1yxDH6xzp9UFprNoYNrl/GWm7llSEByAtwFqd0rxkgXycB14H9DoHWP89UE0sKI2/DajdCZRvQOSu300/rqOduIcLB02UGjlypO7vmpoa+P1+ZGRkAADcbjdcLhdyc3OpKNWBXCwuAxigiXRKxcopFWpSGy9S5OB5raGZvXg5SP0jGDXY4cGw2nOxRKkyb5luNbcp1IQcVzOVGptbhVNFKWKC2lSsG6DVBKQBoCJOqd9/sEQp2VnyRnYmEIjdWTXIq3UT+CE4jh2re83KCLDKYXs2hsdHtlG4MvwmQtDcCbFitK/8lAiJIMTCvwpqsfaYOjDWBtgy1qAsfQFunp5gst5YVY58tXq3gRq+lwRky6PllZ/j/T2/YEpqCn4t/ANzb5wb97sO9uqE0hkqBC08GlgWjYbV0wDDwCX/tqCvSSdK2XROKUKU8oZ0DgNFGDGuWnuCHCKsvjPOcGTAHXKrfzfrlJr/evRzpSb5I/Ytls7RWf8GrCbulv0rTEUphbHbxh40UYoctB7b6di425ayGQC8OIYtQ4UgDdCv/3wZbj2tR1zbvRIS0zMrGQ1+N/bX+TCgS5ougWe9L4zuciU4xU5+dtezMbNwJvycH5VebSW0VeJQrCSbslNKFEU88peUI+k4qwUFcjnzAZkDVAGsvcL3Er3/LJb4oQi2YD0ArXpNki3aJUv2OcYcOLaMtYgkL8X32/Na7pQSRX1I2/apwA45H5jNBTjSAG+l5JZSRClftFPKs0MvnCgipZEgH9TtY8L54JphX60PHC+gT56UyNnoWvSxDER54jFp1yTc1u825Dp7qeW8zejM1GGH2EN6vyx++MMcLv9kiW47YzVeXT410YYyt3adfL9yNxyEuVS5hkasHgEA+GjdRxhzib4SrimhJlmUIp1StYCvDlj5OXDqP4E0bVEskep73ohXzVfX1oRlYTuVCSAiC3wZgohSAEFwEGDmiNafwwz4kJ4kHTwl0bky0TOb4DUFgrh52s2oDlSDtZu7bhg2ZF6VjAyVMbunjIsaNpd0HwXcelEq4JZcUpvkJPTz38DrORlYXLoYt/S9BS+eITlC3lolTQw/WPsBPjz/Q9N9PVBaI0o1WqTjnIIAvHChrqocvVd+jg8KB2FxRQ4W76rBNYO0Rd0dlR5M3ywJ8EqbJYoiNpU24tpRy+DIa4JdbkaW761Gan/Zfc2nwNF4E87sH8SKihUt+2FGMZYUpTIVUUpe7CAnz4ooRbpw2zH5eZDIAWfsS7xzNaeQl2XhN0sTwpm39SkOq26omZVsR7k7AEGUnIVmolSDPwJGyf8p2CGK5tcDJ3DmhYB+exAoXQ3smQf8eyPwx2NAEdFOrhsHbJkYM0WFQkjkoUzNx2wZgzPyz4gW6dsAUpTiRV5N2WGEFPPrgnUIcD61ofKJAtz+MPxwoBO8WN24EPZsJ8K1F2JlYR2qiAXA+TuqwQkCOqEJnRgv3P6eptWlASl6gxw72Vknajwh03kYI6fUsLZUlGItQKeekihVtk56buD1Wp9RvV0aGzCMJEgBQPGKmOML6pRqGw5a+N6+ffvUf2+++SYGDRqEgoIC1NfXo76+HgUFBTjppJPw+usmkyVKu5HBeCEA8BJCVIhhpESJBnYWleD4V+dg4c5q3cS5qkbLhTRzkT7vg98oSrH6G9ps8rS4dDEunXwp5pfMV59rtnoS0AJRSms81tdu1W0yct1IvLD0BVWUSrFJq8QHLXxP4GIm2CRplPNgTefPQJMoT97Oeky3jdeei1oxDX3YMpzB6sNGQhyP0Yv34rz3FugmCCQMIUoJ4DF87gik9HkHjpz56mqEQtwwrViD/1CT3n2ghu85gUH/B3Q9GYBUVh6QJnX1wXq8tOylmF91sDsC5brLc+WhS7I08Nxns8FrGCCR4a9hvwd82DzRORm+V+8L62LqH/9lI278YnlUvqMQx+sEKCBalFE6cI4Xoiv2xUoYUmJS3rpwoSRgrSEmheQEo77Q/LPaAeU3JlmT4PEmgRFjr6nY8qSV9j6MVtZ+fbEbz/waP7eQIob0ypJEp6I6qX0iB0/1hLtNGSSl2dPUyWyFTxt0JiwOBRulPCzrv9c72nTbuAHoXYrlViu2OyRRqn9Wf1WUOtScUmDiu5ccYX3brbhASEgHIVk+GgAYi3SNVvurY+Z7MC2WUF0AfNBXHzJJ3hcRvzRwBfRVehRnglLdKuCG16+fGBoFbYUJOydgaZnWT4b4UMsqCJnA8QKGvL8QQ0cuVpOOh+XJhEsOw6q16IW+X3f9iqZApFmnlIIS4mqWP8pqEKXm7Z+n/cGG9E4q1uDgMlxDZHU0AFIuPDOU/kM3yfYBn58OLHkf+PMZ3eaJhOa1lUBohhK+lwa/uvCXRfSjQROngoOJ4IJeWv7GDMajOaVkt6Y/LLkKzKrvNYWbUC2H9to6mecnYtiweVUyMuEykSOq0R+RnKfG8L00RZgRDYm3Rb3A1Viq5lKbsHMCdisue5mD2acb+1GSH9PTzN8j9+2nsjsx2/4MTvv1VGDdWDxdr+WgIce5c7bpFxeLan046fW5uHaUnOdU1O4VxSUFACLvRDDCN7vgYkqUU4oI31OcUmqic/J+kfsnMsqgHUWp8IT/Ux/r+kqBh5cQ+ZtY1tQpJcSo2OeyW+C0acc52WElnIXm72kgnFKiYAME85DzmO0IUbkU312lF6QAqSp47S7z95KfT+SF/Xj9x7htxm3Nvqc1GEWpWJAOoNpALUKC1l94RR6NgQiCohQPUJe/BI6cuWBsdVi2p1a3eLSxxI2tZU3Y4HwI8x1Pw1u1L+Z3hjkBb8/R2qsJa/fj1DfnYXdNddS2jE1qW4wLI83C2jTBFpBcbT3PBLL6SI+DjaahlrFEqSAfxPzi+e22IHi40i45pV566SV8+umn6NtXC7no27cvRo4ciRdfPLhxs5RoOF6QBhWRIPJRDx+jraACQMCWBDxbFPW+VVt2wBPkcPfYNbpKCRbC7XQUq7+JjdUuGKMoJb9XFEWsKqxDUzCCkev0Ljsghm3TSLOilNyZhP0QAIzI7ITn9vwEALCzWgf0x94/UOGVJpa9M6RG6+CJUpHYObwIGiwsmiyd4EYqHowMxxuR/8PE9Ht027jT+2K9IDmOujP6xjvECXhr5g7sr/Pj0792o7jOj19WF+u2YSxaZ8swEYRZLZbeAn1IQ9xEf0ZRypqk2ZjJnCFKR2hzAVYHcNsvwDlPgSWurbdWvYV5xcQEx0Bbl/k25jRRznuqPRU95DxGd3XJw1N52brtSFG305oPwa7T3GzkajcpOPGCGJXfaO3+Bkw1xMYHIwIaDKGpJ+XpE0F7I16Ioojbvl6J41+Zow9RixXaV2oiSilUyWItF9KvkjfsQ2FjIcZsGRNTKE5IQG4FSluRZE3CkxM3QRS0SbbNMKkPpUgC0TFMy/JBKKJUzyxJ3Nkvnx9S6Kv3aseDvD6U5OukKJXQJDcSAEb0AN7uJq2uxkJu38jqZV6WVZ1S/TPbX5SKF35NIiC+KNU3vB1vWccgG9K147CarIrLfYkgiLoqlgDAWKT9qA3Uxhw0mp6LWc9Hh1MYQ5MzZFGqoYj4MPk92fIEMuiGJ6APSzOrkgkAf+77E99v/177OlGIWcghUUihVBFQI/LkMjWGKDVt7zRUe7xxnVL5jPablFBjY/sERDtxycIHjCWAP3cU4LbRKyWnqEGg9HN+3URPqSCp0lQGU1aPlsIujedbcY0YKiYmEl7hO4j5dCRRStSF7+ULPohysnOfyaQ7GUGc0UW7FzLhQXqSHeA5XLbqTnxk+wy+MIeCCo9pFTIP0fbb0raY7xgbMq+eSApJxMLEaW/Nw5D3F8LTYHDnODOkvhzQT9ABfc6jxhLkunLVPzdUb9BtGitUvy1wy/3oQHvibjglp9Qo2yfoS4yJ8mXB1mW36I6fMUfnS79vRYOfvOZJUUq692xMEgALQpyAozM0J3KzKSsUjM5NUpRSUiMEGyVn/qHklCIueV1fUr0dfmKhzxPDKWVhzMUUh9Wi5hgEFFFKdhbGqBRa5wuCYeXXRBsgmue0TShMK04V0OYwmw/UBmpx6eRL8emGT1v9uUbIsa5pOg4uBPCcTiSuDdSCI0SpEn4HysObEIAD1UQFd4bhsaPSE7dCYUq9NMbsleWKSkof4gT8sl4zDOyoktqaBbuiF0QsznI4u30HNFeF3LiQzlqBE27R/s46RqpYaXNqQm51dPVcJSzextrw+YWf69IzPL7gcbyy/JX4+0GJS7uIUhUVFYhEoi9OnudRVdVMJQJKm/P2nzsw5P2FmLFqDr7JSMXElAzd6yGG0eUFUs5cHqMNsh3QBoIpjNZI50A/ITU2SqQbB9BWR35eXYxbRq/Ec5M3m05q28QppVYa8WOH3Yaf0rUV2at6X6XbdGud1CAek3EMgIMoSvFcQiWH3SyLCpsURrFCGIgx/BV4ZsoOhBlt0BJK7YlSUQpx7MbU4FJ2NT62fYYkBHVmmQZ/GENHLsJzv+kHqQxRWQ5sGJwoHa9w/WCclaKPq48fvmfotG1OvZ3ciFLJLyUXuPBlsDYtjGdJ6ZIYb5Joy1VVd9CNCyddqOtUlMl9ii0F3VO05NpeQ94s0inFCmEwxMoTmejcSGFN85OgEMej0isNgIVQNp47/suoRN+cwCHEh7CmSLoHZm6RhJGlu2sxdk4M8alUtiyf9iBwydv615RzEjJM5Ov34aY/bsLH6z82FY8BYEttjMnPAaK0FS6rC0W1PjJlPuyGrsxnlyZH3ZjYFS3NUAauvbKl928qbcTVny3VJdFsiOGUUkQpMmwrIXFIDdczTMacGfq/5YkDGYbUxLLYLYed9MvqB5c8KUxULDpQAqHE2kUREeyy2fB+ZoZpNaunhW8xzDofz1rHAwBYlonKEaGEwtT7w4jwoi7NDWPVRKlYLk7TPsRsW9IBcvP3QKde0uOG/VIVOFHUnAlZx8g71wSPoTJQXdCk2EYMWpWcnfwuQihVHDkRTi9K1cmiVCYsSLOnwRPxoH7jpzjHshWx6EKKUnJf3mCSnNa4+ET2l47sBbAf9TZWV67Cc5M3gzFxSpV5NOEpxVhswR09EQEgOQoXvxvbmdvlROne+vVeoHKraZ9FLkYBMK1s2hbsq/WhMRBBMoJgGRFh+eJNEkVYBNnxZDLpzmB86GrX7uVOilOqaguyGzbiWstyhEIh/O8P83PojdP+WOWxA8PyaAqZTLTJe5t4rNyH7jrD2N2WBCR1kh4bJ+Wkw9Zfp7s+oipUHjxNSnVKZXP6Pvk+d+zxpdJeuQyT3kZRamvz053REQEExj5eJJ1SVqnNSLFJY9EQx+Pq3lfjsl5SHqowH07IRRlpMpwLMtG5g3Aehjz6/HlmTqk4Yyp/xK8Ke21BmGjE/Zxf/a1bdkzBB50y1Nc8MZxSbAwHriCKOlEqRSdKmZ+rGq92nkTBBsbmNt3ust8ua3ZceiCETeYD3279FmXeMozePFp97kDdtXFFKT4CjDoN+HIwgoRIWResgwgi1xcaUe78BNWsHeVWzd2clmS+b1ZiLFzhlc5DXpoTKQ69MzrECWCsRPsjzxvdMeaBttQC7AvNN31NxbjgYLEBvS/U/u5xuvY4V8p/iCp9nkgACMtpR+wWO87pdg6W37Zc9/qfRX/G3w9KXNpFlLrwwgtx//33Y+3ateqNtHbtWjz44IO0Cl8HsLVMuqkm7/8Zn2Rm4KNsvV0+RIwKpqQk4/Re3bE4yamKUtezi7HVcR+etE4CICIZWqNlDAWIKo9rcEoV1kmD3pFzJQv3zC2VByBKuaX/XdnmryuD14hfl0MLAC7qaX4dHnRRSuBMbftGGiwWlFq7Rz3vE7S4dy7jKJSJ0m/vxtTiS/tHuMayHPdbZureE4wI5onPWdIpxYGTzyvn7QuH2EW3adxJlPE1qxNIjnFOAGkwS342qw0mmptct6VVduqeqagN1GLy7snqc8p5T7GnoGty7IpvRpGKxB7HJbK3pnknTTAioEoWpfhgd3R2HhM1mQL0ThBOnoje/s0qTFseI2RNmbDkHKutDCko58RYgrdhn+qSW1BinpB1X2NsW/aBoFwLLpsLnCDCKmgDGZtD34Z55HDTeKFJZjjlgWu3TtKEo6CiCZtL9W1PnS8MXhDx1swC7G+Q2i9SlCKdUgmJUmbujCs+0AQPhUA9sHWyzh1YZLMiIF97XVO6quHGAS6gy8l3UFj+KQIThgEA2GYGyCITwa1dO+O79DS8ldVJfd6fc4JuuxxGO9acICKVcPEoTiklLxtZhp2xSMewLlinuo6Ukt4Kl/12GabtNRSTsMRJq3ny3cCAa7Twvb3zgXePAmYMjxal3MXqNafQkkpubSlKKW27KkrJbUWt7PhICweR63cDAJILtElOjRgdvpQPTZRS3B5m1ceqPUFsL9faCrPCC/acedhStx72TP0gPsAFUOLRRIyoCRLpUDOy/ofYohQfAX66Edg6Gfj+Gl2VXYU7B96p+7tNHYa+OuDzs1A5cwSGvL8QC3fWqNdzSHYO20URdtkp5TdMugX5eQfRnnZivMhIsukSKLtryrCmqAFWlsFJPTJ0n+GP83uSLZpw0RQ06YeI5Nez1u9SE7Ur2MNu/fb2ZMApp31oMrjpaqXxnQhJ5CEXk4qbiiWxtx1QRKn0SAAOuY/MFIB7G2PnDDWOFRV8kBZuAkQC55N7am2bEgIeK10CAFX4yJDTZYQiAqysFS+eKUWQiBCbd1GKIiwGl6ZuEdBi0xxsoSb9omHYB0y6G5j1nPacLELwgj7Z9NrKtbho0kW4fMrlbTbuIse+giiofduw/ZOwy0HkRGUZIuG8hiJKvXvD8fjwZq0vkUQpMnzPoobvxRKlKj3ENSDawNrMF7kDXEDN6agnAZFIEQtT86GrRE1gTA0BaFXBAUmMqg/W45LJl+Cd1e80/50xiBu+55FzKNbswB8rtEXNal8NeBNn7R8Zgq5fPzbfGbUNAF1/7pfHb3lpTjUkWSHMCWCt2vlgLNJ1EW8exsDE2Va2Dpj9gizGGueiFilf1D/nA8ffAlzwsvZalxOl/0tXRy1chWXBXRmDswwLp0X/e9dXrcelky/FX8V/xdxfijntIkp9++236Nq1K0477TQ4nU44HA6cfvrpyM/Px5gxCSS0pLQp1Z4QTmMK4Gxaa/p6ACIEOT7v5ZwsRBgGj+flIFcWpa6yrICN4fG4dQquYZchmVhBMoYCPB/lxtEPIL9aIuU+0qqQCaahYc0mGuc5bQKdE6MyV8gjJ7UN6KzB/xbScVrn03Bq51N1m7MMi6PSj0rs+1uLEDFdATLSyLLYbpHUe1vGKji7/AyAQyeGGExm9tY5pRRyGLfus/bXmQ9UjU4pHtLfIu8EeP2kP26FK6NTyuqI75QiRKkgF4SbT9z91JZOKQHRQp0i9KTaUpHtNKkkqWwXV5SKHlQqnXAiTqk91V7srJHcNyLvgjfEwW4xEaWIiSAZykFO9E3J6BXtytk6GfjhetWlINpT4GEYnRsxlo39YFUhUSotuqwuRHgBx1acBJso4jk+DTZDmMNvNWswOSUZ6Yg+vj0yXchLMw+LUML3OqeZD6oAySkyfXM5xqxehL3yRJcM3yPzliQ0yfUb3FydjpKSNCebFHb49V6EiPwhSuhehiUJjvr9SK7S7OZ+TlrVJif8bcqcF1VBrBNvInKTMBwi8gRkndOBac6rgcfWw3XGvbrNKsRMnH6UdBzvZv/EFuc/cZNlIQBNbFFEKfIcKmEw5EA71WbITQTgv0v/qxc9TO4jFUXUUnLluPdLbdvab7XwPULMVdySGbx+gG8Ux8xoiYBlRp1Pe39YFaWk51IZqa2plVeyU0QBWRGpj60n8nAUEgsP9XLFvc5ETqlGvyTGmolSv60vw+WfLMGKvXWo8QRMr3vG4kMg44eo5/0Rv+4ajXK6NcRwSgFAamdAOXbJufrXwj7VoSP6a7G2Mnq88/AJD+PD8z/EmflnAmjjxacVnwLV29B5teZCTWWkNixklc6JQxTRWQ6H8bEsVgn9AADbhJ7wsbJjjKjGmQnZKUUIcTbZkZef4cRR2XqXWSDOoo6DTYXIS9dmXdDEUUosSNTV1WHxbn24XpQoZXNJwhQAeAzOnZodAICXszNxds9uupdKKtYAb2l9a5W/CjMKZ6CkqQSTdk06YMGWRFnczAh48E1lNY4LhjCysgppcYpfBMh8kQ5NyMuQ+xZfmIc/It0T/76wD24+pRvG33+GWgzDCEPkmGTt0rlT8hEG5arW5KJTs78/0ADWOB4zjreURZufbgbK12vP1xcC26aof/6RkozfKpYhzIcxbOYwXDDpAswumo0AF8DjCx6HJ+KBJ+xBtT86t0+LEYQoV1A8seu53OiFTVEWK47OScb1J5HVoUVdsQwyfK/WE8KCndW6kGN/mMPMrVLIqShYAbDgg7HHe63m9snAkBeA23/ThEIDdZZocYVccGwKN2Hyrsmo8FXgx4IfW70r5Bg+agEr4ocI6X5dEBivPr2xrEi3eK3wV6cw9ti1a7ZzJ71LTSGN0c6vUpwpL82BPrn6divMCWquKECbN/q52O2z6X3y9QXAis+Av16PFr5ZWQjrdjJw/WipMqJCD6k/wP4VUvEMGQHAzgqpH7FZNCHN2Mc/PO9hlHnL8MSCJ2LuL8WcdhGlcnJyMHPmTOzYsQOTJk3CxIkTUVBQgJkzZyI3N7f5D6C0KVVNQdxvnRnl0EmXB9NBAK/P0MfSCgBy4QYDQRcSc75Vb28kGx1Aypujw+CUEpggVpVtBCeGwdjqkXyMufLfrFOKLGmbGqMz+e2fwG8PAGEffPJvPzMQwP37t8Auivj2km9xWz8tqWCP1B7IkCfrBy98L5JQ+F65zYof0jbDnj0PzvwpsKVvhjV9I7yiNHkOMU4Ivc5BqeyU6kqcI8aw8lLSECPROZlTio1AlEUpCA61cpBCi6rvNeeUIhp0Y9XDWLisUofelqKUruR53XbUB+vVwUCyPRl9M45Hbtj8XBlXU8utFtWZYDexmCs5ixLhf39sw8I9sjjEu+AJcih3R39mXUC7B8KcgIC8IpjFNCOoduopVbEi8VQAe/8C/pRWUD/MzsbZPbthtVMTAmLl8wpwAcwqmoVLJ1+KbbXR9ufWojql6gvRT9iLY4J2rCoqwbmBbLBEIVkHK+3jW1mZ8Nr018fHtw7CpIfO1Fn7SZSBa05qjFweTBgrvB/hyx0vIPmoUWrYGJnonMRUlBJ4KaRo9gvS38YktcoEgrxncgeqD0NEqNMOeSCYY00GRp0K+9jL1So6vogPl/12GS7/7XLUBloWxpgoStvViRjU2ok2n5HdHmTIVphh8GOnRyRBZ9Dtus87LpvFJ7dJq5T/s0kCxns2yc3DCSI4XlCLBeSlOfHguVL+FUWUIkkxJsyWWVa2TPuDtZluA0AKOwaAlLzo15QQFhNRKtsgSt107E1R4bZGDnTiXesNg7HVgbHXqOKdkug8VQ7FVc5KsiAiU97HenkC9N/IfdguaPu4T5T6UCl8T3pngz8CbzCiC8Ew8vvGMlz/1XzTvECsxQfWFt0WGZ1SUQsescL3ACnflNLfEHl1Sq0WvM5XYL8sxBVbragOVMPG2pDn0s6n3WLH0J5D0SVFEuTa1CkV5f4REMlajtVOB0LydWcXRbhkIdXPMJjEn4frQ6+Au/F7pGbKubWIapydGA862fWJw5VFp/z0JDhs+n4oLMae5FtEF4Sw1GbVhkzydhGJzpOZABoDEZ1zxhk2uHPshChlHK/V7AAPYGqqITQTQEnEq/MS73HvwXNLnsPlUy7Haytew/gd46Pe01qUkNrMsB8nhML4uaIKJ4Wk6+don3mf7CfGZ/ZL38BNKVIhChcTwg3sYiSFa1WnVOc0J9698QSc2TsLebEWNog8SCceLd1LSo6tCC+CF0TdolOzbYO/Lvo5MqcUoPUpShUxE7wMgxdysvC/4mkYu3UsttdtR22gFk8vehofrP1AtzDr49rgPuECUXOQload85YIAAEpTr3jVRBEpCVpbXuy3aoWBnhq0ibcM3YNfl2n5QebuKYE7qD8m+QCKsGKG8H5e7Vof5olpx9w3jNA3gCtfyEIMgw8Jgm7Sz3avlb5q3Tj3tYuApLXVZQ7NeRBhdWCKakp4FkizA8eCGzzfVVumnZeB+SnARDBQtA5pZQUMHlpTvTrrHfpBjleF76nLJgLbOzxfpCPc+1UbIrOrWpWQVGhy4mAxSEtGJasVJ8elZFumofYKEq1V/qEw5F2EaUUjj32WFx99dW45pprcOyxragwQTkw6vfBG4zAH+bRjamJ6hBy5IFqiBExdlmR7jURgJUR0BkN6MVoOVOGdtELEKkxkqYqVlpjonN75lL8c94dcOZPgi1jFVibufhU0linq/gXheLgcKTpY+iNbJmoc0olKxOooqVAsAndUrTVlsFdByPNLjWWjaFGiKKI2kBt27qmBF63EkdyU5MHU0q1UKCAtQCOHC3pN2MJ4HXuDsziT8WrR/+EFJdLdUqR7hjG8PlRQqEC6ZRiIoAsUomCE6EIj9PztZjruAMloyhlsZu7PhSIzjlWGXUjOS7p8xRhRBRFFNQVtJlIdcv0WzB04qXYWytN5lNtqfAGLPiwxIKeJvnxxonnYUTkVgBAE8vgku5dMaSHdC2ZOaWOyjJfJSOx2BrA2iWRTglPUpxSy3ZFW8trfNpzEV5ArVyNKRvxBF1GqiCmhF1EfajkZBznECAwDJ4iViuNSeEVgnwQ/1n0H5R5y/DckudMt2kNak6ppkpMc7yIf1l/hw3A7xXpqK2RJtQi78Ds65fg5OzjEGYZjM+04eTu2oDnmkFdkZfmRFdLI2wm50VZXXXaLFGWcgCwpa9HPdagNLRO93yqPRVZzgRFqf3LJSfais8ka7jPIBg55P0l75kLXgRyJKdkkBCx6uTkorlW7XpKlV1je9x7VFHVLHTpgJBLcSsuT9IplUUIVAwvi3uEOyDMMEiSxT9YrMBDy1Rx6B9ZiD2Zg+SWIp1ST13cF+PuOSEqTxEA+ALmwuOsolnaH/Ecn8pKtpkoBUj7rFTfgyZKZRlcY3muPEy7dhqu7n11zK86UKdUjcePlGPeQ0rvD9AYlAbziuMo1apva1IFAVlyX19nYcGJLCaIF8ILbWBdJEq/2clE0AnS5zUFI7BOexTrHA8hD+aVBSO8iFK3edgLY/WrzhwAyLUNACCJUuU+LdwrSpRqNClWoEza/XWaQDP4cen/LidheG4OJrJ+tb1aK4vpx+ccD5uJEKmEvR5Q9T0uBMx9WVpdN8GSsgN1OetxX34evPIqe4WQC5fcH/tZFgHRgfXisRA79dJEaaIN6cLU4oLpg4Efr1efU/r6LulOOK36a97oTCdhxSQIYek7GiImZeqJPFIpCMDtjyDCi+jDlOIqdjmSwoZrwJYMGPOBKakUqndgj11/3HOScmBlrQizDIpsscXhNZVrYr7WUurkMDfjPSqIDHpXnI5n66KvXZ2T/ejz4GYywMl5oT6wf4mvLe+o+daURQ0gjtuWaKtEq9T257q0tj7MCWAZFlZ50mxsG3iBxyvLX8GkXZPkN5j0MVFOKfPKgiRkTqDPNn6me23Czgm6v9ukIEDYF+WUmrRzEh77K06xDzMsASQbqrXyooh/nq0ljO+c5oQxIKGgQhvHr93foBZgEOWqe2IkC8GyW9Cm2Im22MQpVRejglxRU5H6uNpfrVskJ9vOlkC2s1EhoqEm0zBC0RqAyJqP+0iyUrSD3T8/FaNtH2Kx4wldXmJlXJyX5kS/fP2crSnAqfnWAKjuLMYgSnFeLSomyMe5JoVIdPhevNB9q0OtBo514xBgGCxLcmJ0J22cTArHTmvsMUtrKKn3R4VLHym0iyh17733xv1HOciIIvDL/wGfDELjTqkUL4/oxIHKCi/PMAD0ApBSne8MdjtsxEqPw6dfYTM6pRSCEekGYxi9mKFUu7Clb4Y1OXa5+Wlb9uD+783DDQFoolRShtaYxMJfq+ZvUMpl48frgZ9uRLdUTZQ6p+s56JzcGVbWiiAfxObazRgycQjunHmn2ae2DiESM6dULs+jt4kAoiIymMAPwUORJ8El5SDNaUMjklX3lAIbJ7SMhBzAMpYAGPk8i4IDIU7AR+d/hFuP/jcAIMS1QJSCGB0eRkKsMiQsSiVJgzhl0j9n/xzcPP1mPDT3oYTeb4Zx8BcWA1i6uwgAYEESnpq0CXZEkE50FkounWImHTtEKRH9fiuR5wtSTik7IrDI95Tdyqo5i4zkp2vnznX0h0juPRKM1a06QUTOBU8wghV7o4XRGr82SfCHeU2UMobvkas6qfmSKBjv/BC4TazlRsiVuwOdbKuE/Vr1PXkSl8/Uo1DojM+5a+AuuxShmovgL3oUnZKcuHfgfQCAArsNNx2fgROZ3eiTLoux+xbjh6Z78D/rd1Ff42xmUmFN3xD1HACkObScUiSmopQcygIA8Ndr1cIUFFE9hXAR25PVv0PGSksA8ljN2ZUpT7DnF2uJP9s8v5RHmsQGGCV8T/t88jEnt0UMo90zYTC6yRs6/wO4aZz0uJnE6cEID7ec26iTyw67lUW/btGDS1GworzRXKAu9xKD+GCcBQZloJmUqcvho5KSC7AWiPZUzHYlYZucA8XolEqxp4BhmLiVtA7UKVVGlK5W3KacPOlItekdIMmCgEy5Dau3WOBFEnpkJsNH9Bse0YVXMvNwddd8dLbIocOiiOSCCUhn/LjZstB0P9z+sJr/wwzGIp0Tf/G9yLNKFUSVMFOFZkWpvOOAl2qixcLTHwIeWQVc8hYK5HOx02HHY7nZmJUi3RP9M/ubiunJssPHLBdWwqz8HFj2MTD2UpMXRTVUCwCWWqVxz0+RS5Es9yF+hkEAdlhTtqHMt8c05P0CdiOshmTsSnGZ/IwkXR4dQMvFkmXXh8wBAIQk1Snl4c1EKe3eSGUCqGgMIswLmOt4Bp/aP4ve3u6KFqUyj5I/qxHrHfrrP8OZoS4C7rDHFqUyHBkxX2spilMqy3CPNiAFZVx33N7kQaphMhggJ+fp3fDClQPQCO2eOo4tUhf6yHYtL918osoQ42clyXtnIvRUWXxVnBj1wXo8OPdBfLPlGwDAqspVmLx7Ml5b8ZrkXDOrlqcknFeIt1ArQ4pSCgtuXqBzeSoO9TZxFIZ9CBrmIGO3jcXC0oUt+hiGDSDV4JRKtlsxoEsaVj5/IT68+QRcPaiLbmwFSLnxdjfsxgtLX8Du+v3qwgYjateiKCRW/VCIE/4ZExMhwyx0z0i1vxplXm3epevPWgDZ50SND0Ietepka0hP1o5Hr+xkXGxZh25MLS63aPmplKrUZk6ppkAAFofWpylRHEr/Eam9EOGG0xEovR2h6kuk3yPEcSfxEZPwvTiiFAAMkBeRChfipexMPNRZH9VFilLx+vaWJqRfWViHc95dgNenR1f+OxJoF1GqoaFB96+6uhrz58/Hb7/9Brfb3R67cGTDMOoAx7FeyuGVBp++szVisvIMAGdb9DmirB79gDHNJIeL/nPjrNw5pc86J/1xdeVSfc3egCW744SgKBbmpE7AoGHAkBdjb1u3Bz75t7vIBqNkFbonaQ3PKZ1PgY21qXmlRqwaAQDY27i37SZ5Quzqe6mCECMVokR6EmEftVlkCzOjJjtXIc5zvFw5ZE4pchIJwY5QRECKPQVjZkuCRsAgPImiqAlKRjtxJKhfISKxOHSVHpVcBScxyegXCsMao4nq06kPAG1Qp1j811evN90+EcwGWv15yRGzbN0u7K/zI8XCIV3Qjk1nOQdEhOVUMZAnTlqIYXA8W4jFjifwp/05MBCQlWxHZrJ5LhstUaqg3oPW1G2aKCW4UFTrh9sfPbGqJfI9NQYiqJWTH2cZRakMImG+UlnMxEqu4EkgvJSEFKXMcl+1mJ1/Am93Rf2+hQCADOLe+0s4CX44AcGJcO1FSLN2Acsy6J0t5WbZb7PhOnYhpjj+h+l5X0lvmnA7LBBwuzU6CSWZhyJXd68IcOTOgNUlXW8WTh8iPGpeKVbtiZ6Mu0Nu3DTtJjy35DlEeAFXf7YUK5Zqbkf4akxEKbntI51S9mR1Eh40JrUFkENUdMqyShMmUpRq8/BjRZRKklYOOxH3hI1oUkUherIZYZkoR4c6aTIm1pexywPkECeoOY2UkI2GoIkzR7QAJjniAIPwHeP7AGi57ljW3Okph4mvTEnD03k58mJOtCillIyOK0qZ5FFsCVUBbWJSL18firiTatcP+EmnlCZKuXROqSDsmJzuwD67DWz6JgBAV2j9b5rFvB/fVe3R5yY0QRQt4H19AFE6HoFIQJeHTSdK8Vx00mzl9cyj9c/bXEBuv6i+ZmGyCyuTpO/KcGREJ/WFJny0doIHAKiJDo1SbgUnwmBt2qKBIDepATEJTsIpVZvkRlL3H/DcqnvAGYUFAElM9HWSTTilHMR9dVH/XHW81dkRnWdTEJyqU8onmCwGEYJtCgIodwcQCRvGhWSqBFuyFr6nQJyjDU799Z9qS0XvDCn8db0z9r1B5m45EARRQI2cvy+L54EuJ6mv1YlpKJFd5oKhu1PHZ6c9CAA4v28u0jP1E9S/7E/hJstCJBP5cwbkxxCCCNeostCSl5wLqyzQKOG3Snvx7pp3sbx8OT5a/xEAfahVha9CrZYXEIm+1njMzEQpZzrQ+Thg8BMAgDJDSHuqLRXZSdmYcOUEvHbWaxh5/kgcl3McgDYK34v4pUrfBwhjCajH/aNbBuGY3BS8ed0/AACd0524/qRucNosePDc3nh0yDEYPlSK0qn1hnD3rLvxx94/UGb/UpvzEKIUEhSlws25WrqerC28KBgK/ABArbX58VKVtxylXm3e1do2S+eUMgnfa4izmN0lEj/5vogwrjw+H//omobBvTVxPZ2o3KektchLc6hFARR45y7d4obFWQ5Xzy/AyMnnw40nIFR5HSDaIArSOC0sxomS4CM6xymA+KH7gHS/Hy9FP8xOiQ7tJcP34uXYrQ+au4pjsbtKGqttLY8zNjmMaRdRasqUKbp/06dPR2FhIW699VacccYZ7bELlNOlDjWzeDY6ow6pTCDKKVXNaDcew0Twn8gDUR9zg2UpAGCX0FXaTh52VYkZACS7vxIr/P5NJ+Ct66RO7KUrJas+Y5UaBj4UPchnGBFCKBuC58So/CyssxSMxSMlZoyYDHqb5JWD1C5SVYXz/iMlDI6BT/7tyYK+M+njc+P1mjqM9rLqoKBPhiSAbK3Tyi63mQOE56JWixSUweprve5DkvcKRJqO071+fA9t0pxkt+KXnT8jqeeXqGT0DbyPqDZyTp84uZ1MJhoibwfAIsTxkp1UjrcXEIEoCFKFIQCjNo7C0F+HYtKOidEhMVwoegVVwSCGKLlvTkruiknllViXfbE6qSNRktIXNRbBH/Ef2Ao3AIgiPJUmVerksLlrmv6A08aiczKrF6V4qXNmLCFJHAHUhM6AlCPgJHYPOjMNOJYtw9FMBTKT7chK0Tq0l6w/4G3r19Lv7iFPRIg8VJakUk2U4l1YU1QPCNGrPA1y9Ul79lysDLyKutr96McUI9uYUyqjh/a4U080h9kKajzIXFNmoTItwRP24JdZj6KOAWqKpTLMOcSkv85QMSxdziORn5wPpygiwjCoXPEhAMBRvBioLtDnnyOwWRjYiNXBPCKvFJtUAnuW9P3hhtPg3v04wg2nqa9/s7QEH86OTii+sGQhdtTvwIzCGdhS6sbm0kZkuony7aailElOKdIpZSJK5RLNWKa8mq24AoC2K9Swv86HyetKITRKA+GAPAnNIAblEQvR/ojm105U9U+nfB5jOKWUXDnBCA9vULrnUuWJCCloqF8rWnW5W0iq/dWaWyYRpxSgd60pDLgGALDNMKHO5gxOKXmBJZ4o1aL+hOeAn24CJtwuuaAB1AY1UUFJWh2RxZcUg9NEyimlOKVYeMQk9MxywStqk6QQtPYpzxFGepINfVnt+u5vN18gKqkPAPJqtiiaDy9FLgUAA0YWLAOcQZQiE517KgCR108glBV+Y/8un6/GGGHFAJDuSDcVpU7JOwUAsLZqLQKceaL2ZjGsiFdzflzQvSs+7JSBVAR0TintPTbYIf22d7I6YV83TbBea0ksfEPJKdU5Xe+UOr9vrioQilwa/CV3IeLpr74ucJoo5Wd3YdiMYfpjH9KLUpWNQXDGBOadj9ce25KiRamsPupDY4hemj0Ng3IGAQBWJMUuBpBQ5eVmmF00G2f8fIZ6b2TxAtDvCnjka75WTEclJKer0dcQYBkI98wGLtUS1luT9ePT3mwF3rONhsOqHf8Tu0eLioA+0blCjitHzXMYktsPRYxbV6UPFScXfXY37FadUgViD9wT/g8Krvoj6vMFs/C9R1YBDyyC2Pk4fNIpHSOy9E7fTLlSXLItGdf1uQ4X9bwIyfKCR5tU3wv7EhKlrvF4cWd97HQHdnsQtuJlwKS7cW3fJMwbfh6OyY0W4XplJ+PpS/ri+G7SQkqtN6z2i4yjXHVKKeF7EvGcS9qVEooIUfe/jvvnAwOv0z9nVqzGaXKeDFQVLdIJUaRrqiXoEp0b28SQJ64rvl84/iJKoG4PPhNHYLrlWXQi8j2mE9WQFadUbqoTVguL607sqr5mS5PMD5xPa+Mtrv1g5Aq3ZBi4KKcIaBR34MtNX5r3pUIkOsy1OacUywJDX435so1Y7I+XNiTRPLkKSnVIJdLhSKNdc0rpvphl8eSTT2LkyJEdtQtHFnkDgR5ngRV5DLWsQyr8UWFjhWJnsILcELERTBIGm35USLRhAj9E91yV2EktYZwK6Qa98eRuGHZ6D2x6+WLcd7bUuLBWaYDB+wzlzmX4YFesL27QqdDp7FFgGBFnpP0OfHIiMPOp6DcqolS61rDBGnsSoORxchltt+u/x7VeH86sKVKfUlw5JG2WyE6IxHSsKV1CbXkXhGovgMjpB3xWq9ZoJdksGLF6BKyuIvxpSA8kELd55xiWcsA8/4SyChHiBBRUeKTJngy38C3gvaOBTb/gq82SC+Wt1W9FfUY45I8erKo/Qj8YVe31aZJwwlZuRt9O0au8PVJ7IDcpFyJE7GzYeWC5QACgcAF8+5dEPV0przzniz4MzOBgE8O68L18eQDZM5vFKb2kQSiZGDVkEBxPYPYiK8WhOqVS4Md91j9xm3UBcuBWnVJk7jVL0n5VzBW5ZFR7QhBFbcBgY6Rj2BCSVpHsnVbAy+xB51U34jvXCzidJcLFAMk1qQh9ilMqDuW2FopSXNuJUm+sfANvZrjwcOdc1MqDpBxi0l8Hc1GKZVj0ktuyQtL197l+EYTMgWdMfp5OJEplLdL1xfDp0godAD7QQ7e9fjArQbYT7qAPLgTRhyEGkb5ak5xSiiilCfe1fAhVTumcBY0iFoA8XpvoZLLR7V5rnFJG2zkviDjvvYV4atImbC6QrOUBu9Q+uAghQBSJa15kIQrRg9vGkOF+VSZNMUQixQESjGhOqVSndH7MRCmIVoA4706hBwKlwyCKDDiR01YvE3FKAeai1IlSknaboRx0lmDulBJjCHRAC8P39i0Eds8BCqapLiIPp4V01oel6yMsTzRSDWGlqYKATEHJKWWBB65opxThuhja24VeWS70ZbTV+aNgkudJRulHxIh5njqRk8+17ELwRXw64SESIFaWldA9pQIiIIlygL5aEqBO8vYGo+8PhXRHumn43jEZxyA/OR8hPoRRG0bhrPFn4fONn8f8nESY6CtErdWCsRlpSGYCYE2EPFG0IYm8X4l8LXM5ExHLhGxI13B+ulMnimQm2+FySseqwcuC9/YH5z5FfZ3jHGr4HgBsqd2izz0X8oCH5BRKkcP3FDFaJZ8QpVhLtCMnWxvn+Q19Yao9FSfmDgIAlMXpY5ri3aMJ8vSip3UTx0yeB3qdg62CNC6tQ5o6TjJKC1VWK94smY6d5LExcbEBAOPVJqAsy6iVRMGG4Mj/FZbkXTqnlEJOUo567hTBnuOi201BFHRjnd0rP1ZFqYDowALhRNSmDdC9J8ILmFpg0v7bnABrwU4bi68zou9Vs3B0pS1rq/C9RESp/uEw+rpjj1sz7E3Ad1dKVQQXv9fs52WnSPdbnWHSn5ks7YuZu9cUYuEwxJsvgMR/f/S43+tovgBOgXu3TnhprSilS3ReMB2b//pFWvAEgJBHV5kVABhiPHBMOIJjG/Ru8RubPLi1SbrOgiUrgd2zgeptSC1frm7TJ1W79h2IIM1pVfNLjrxlEJY8I80rLUmSI51rGmS67zpRSlAiFLwYtXEUftnxS/QbeBNRKl5OKYXUzkDPs01fshNVUeOKUr5WilIeKkq1O3v37gXHxbcBUtqQbtKA5HimEBZG0ESphqEQeSd8VdeAlweKjrxpOrs5AHzHXYC7w//B8aGv8Ruvv1G9YpI6qE1j9Dd/OpEwWKmowAe7ma6kMkIKqj0hnYU21yLliMpLleORN/wo5WL5/lrgs1OBdd8BjXLDnEaIUnFCh5Tqe8mioM9NQVS6UZL5Kk4pkjYpez/hduDbS2KG71nkTmD6Do9U+UYwrBYRYRJJdu1Yegy2W4scxnJc13RkxQgbA7Rk2iRKTP2OSg+u+mypzvkQXvK+9GD6k+pzVpPVh2AgjihlsDArTqnszoOkJ8rX460z/ocz889EfrLWCabaU9E/S1r1LagrOHBRqnJL1HEDgErZJZQqCBhgLQe4MNKJSWd+trQP+ZnA9UOHoFzMhJf4HKPwezxbqAvfI/M9vXJlXxzXVR4cEuGzrL0eDCNAFFltQkech2SLNHhsDDUCbEitCPdYbjou6tEVxUank9WhTegymndKlbXQKUV20AcaejF3/1wAQIHDjmpFlCIGgLWifjBNCklHsdJg5cO0JFSSq36EU+yfx2v3gy7PEaSoZxXZSu5CN0AOquUaT0K4/kywtcOkbZqx+pc21iGLaQTLENMeX42uahgAbWInr1TzAIbMuQMXFY1HgGEQqtgY9dk5YW0Ak8VEH/OWOqXemlmAU9/8C5WN0u9+e2YBBr02R/u8Kql8dkBuY5MIcT+im/Mz+nAImcaQwdKuiFJhj1Sd0IDiAAlxPDxB6d5IMTildP2JaAU5vbwofQQ4z/EQOenYVvmqAEGIn8OKdEolERO0nH7AZe+pFa7qDPdHpiGUQ3FKFdfGFp5a5JQiSrijdhcAwC9ogseiPXsx4s8diMjiS6qSbFomWRS06nssC4/oRI9MF3zQfm+AqGbJhDzISXWgL1usPteZKzMtFABoeYwEzlyUEjjpeCgi7vaaYl21voi3EqIoosZfo4lSpLtTWeEnBRCLXQ0D3+M3yY8kk243d0oxDINzu50LAPhu+3cQRAFfbPoi5uc0iyjCSTgRkhmvGnqiQ7DCzpq7hJb6E5tsquF7GUk6Yd1hZZHkkM5RTaMy4dbaqEjYDggucD4txK6wkcjrGWzE3fl5uKR7FzBMEJVNQfCNhn0iEv0DiOuUMo5zUq1JGJB+DBxCtEhIYio6HwBpPA9OtANdTsQGURLNyJQHZnszce/vuG2GVpk5KjxOYZ9+YevjW0/Eab0yYc9aBHvGWrh6fGsqSmUnZauilJJTKmBS6TfABeAhRNvd1RtVUSoouxv9Yf31vb28CaV+E9eLvCA4p3GX6U8xE6VctrbNKdWcKHWPuwk3erxghdiiVL6duGYTEDAVl3q9T98eZ6XK90icxQMSMrwsFIl/DZt/QPRv99ljOwZz5bnydlZ/fss8By5KlS17D92XPYxbvlwmLUaFmuBm9ddMXyJ0twfHoXfN8QiU36g+10kQ1HFAoLZAfd5RqaXUcBEVO+2IRBU1Ucdg8sIGKZorSKIhcY4M4y4yKbz6Hj6C2ga3/snmnFIKt082fdri1RY/yPng6KGjdfdOS51SAfn+94V5tYL2kUS7iFLDhw/X/XvyySdx66234pZbbsEtt7RxdQNKbLKlWOpB7F6EGUCQG8WuzKXw7noZQqAnRHkCYUstgKuXfqXwFfFWLBRORAh2NEIfjuVDEpogdVhpMSrwAVArKoiRNNMQpDzZFp1vl8qCp9hSYOek1Sy1ekunXsDmCUDhAmlQvvxTwilFDJLiOKV8ilPqlAeAp3ZK1a0AgFC/lRKi/bP6gzWsahywKMWFpJVuIGb4ng0ALzLYEZJt5ZxelBIZbfKfRFQfEQ1x6cdkSsftP5f0RXasUvcAGKuJsGOcaBMOHXVAQUwiLWpCYO03ORDWnDlGDKKUWh0nuz+QnAvwYXRtqsLoi0fjvG7nqdul2FPQL1PKG1RQX6CrBtMQbIhZGS4mFod6TZBwingpCHi94Rkg1KhzSnVOlSZLnrAHjqRkDAl9iLGC5iI0DrpOYAul8L1k6bjmEJXxrujfCSzL4Pf7uuGdK0ySN0fSoDbZxHlIYqXrwxNpBGsy8VniMgzorE6g19nS/z0I59CDS4Czn4SRMtmlkmNx4dhQGDdbsnBMHPs2OYkgHY+tgcxJVWsiShnD98gE8kdbpTaqyG7D+5kZ2kY3jZOSJQN4uHg4zmc3AgBYw7nKcGnfffJR0jFM0YWhsghVXYPGGsUtYIm7yvpBwd0IdjGEVngqJIGdRBFoUnKBlDwE0zQxtspiUa+pkwNBOAUByYKAHiHCBWDSrbfUKTV6cSFqvSG8N1vKk/PV4kJ4gtpkqhMvDcgC8mpjErGKKoj642g2yPdE3PonyLAFk1BcbcImwGPIKaUI2UooEgAwsOry4invF2WhpLJuhzyBiRNyQYYWk+3/w8uB07XQ9hpD+51uFKXka8ZuEr6X7pD2J1FRKhgMQpT7DQBA3R4EIzy6WLV8RhGuCtnLXkFEPic2h16USiHC90Isi3rGiT55qWooEwD4Gb0olZ3iwLGEw88CAXcea55HQ6mQRDqlSMFQEQYF+V7h5PAzbf+DeH/t+7hg0gX4s2yR9GQ6kahbmUw5CNGLOLal/uhCAArpQQ+EGCLICTknRD0XL1dIXCJ+pBELrlZnGRhGBGO83EQr7BaiD4ykwF8iFVJp4InV9ziO1hzGDZuFQSeXzSBKWWC3ScfKE5DOp0hM7kNhOadX8f2ARwpF3te4T329MdyIjU4HGiwWvJ2TBlfeL/CXbVNfD7Iu4FhDUndSlGJYoFMvCAAaWUateKyQJAiwCREMaCYUqDHcivC9kjXAjzcANZLgQqYAyOQFrBP6AFY7RnNX4M3IMHzDXa6+frlPGr8aq+zqroVY4sf2qcDkfwJ7FwCQnOkTHzoTXbK17ZXiPgoZjgzYLXY41PA9+d6MRLfj+yo3oHbxCPXv3XabWuQnIItSxomsIIrwiNHhb7ua9qPQXYjZZdEOcaAdnFJETqk8Yzg3gKPDEQxvcMMhGvJlGcizEAmhfXXAll+BcvOCJADUBUHOECXRKUUODTNxPJtBVoIL80L8Sq7mHxD1lM8We3w+hGNxbEi7V87MPxNA60VbMo/hU3k5OLdnN3RGPYTvrwGWf4oGg1OqL3Gf9ohE0CgmA4RjqRMvIEked5OLsUzJKvWxPaLdyw4mWpSyW/VV2pW+goR0SQH6Ng0AMiwuoHQdREFAvdzmeHx+/LTEkDg8URd/jHyrpPOTXIg9s8uZWHTLIgzrJy1WJlq8ScEX0tqHIzGEr11EqQ0bNuj+bd4s5W754IMP8NFHH7XHLlAAIFtatephKcMmohJKlwxisktMqhhDjiGGiA0WwMLPahM0L5xoEqUOKzVGBT4Ly4C1yaIUl6YKYCS9s6QwCZvnQvz39P9i4pUTEQlKQlWZ1QoPw+AtRwSrdxMD8/pCoF4eTKUn5pRSQqxcPc6QVixkwQ5EFSBl4JHr6IRvho7BpKsmqW4dMm9Oq/Boq7lmTqlsjsc5/gDKLV3U/B6ioG+MIyIRekTY9nvm6leoB/dKwbzh5+LcY3NUMcQM1ho9cTU2+ACrho6p5XyJJIkWpaMlXAYOhosTvqf/fDV8LylbE0yKpRLbpEBhEZ2oqJauix31O3Qlbc+dcC7+s+g/5t8XC4GDN4Y4CACpxAAmlRC88rOk0EJv2Is/y75FVo8tSMkgcrPIx6hclAZ4A5j9yHKxyEqxw2Fl1XwgANSqhbcvvx2v74wOgxQiWsgAOdG3M9KE3htpNF2NjwpRtTqAqz8DninUqiMBUiiGSYEAJafU/XlnYXJ5JV7yiRgYij2RqAloK0gWs6plLYAM//PIgyRd+B4hSnXPTMLjF2or80OStIlsNZlYu8tJ6iTXHqzFOPu7AICKRv09feeZPXHG0Zl45aoBOL+/NDjKIHJznHZU9KA9+n7REMAjmLYXuiNXtwdRwogifLEW4IktCN6vJWSPMIwqYveKcPizpByTyyqQEtTu3UyTOXdrE53vqdEEotOZAvzX+hMcCCONk4S0KkG6ZtM4QpQylmcwEerO7GNoh6wOrb02CeEj860oOaUUp5Qykeb92rVsY+0gK8gqIX9CRDp/VdP/DfzRTOlxIrRYIM+RYQW5ltWfv2MMk1llImeW9L+TQ7qndbl8jCx+D1gzBhwv4J6Rk8CQOdFqdyNUXwYLcd8PsG/FMNsshJX2jNWHuaUIAhhrulp5tiTZilRXAD4ifM9H5lKRRakcg3j0wjmdMG/4uVG7qzgIRE4bHwjBLlHbCTEmfxE+hO+3fw8AGFEth37oRCn5WJFCJrEQ44vTN6dNfwon50nOa+Oku3Ny56jtC92xKwJHQfSD1TW1KK91a5/dVbpfekUAKyHgiqIVTjIHW/0ZEOSw4IAQ1q7gS942ncQCQAbjw6Knz5MqPBLjALuVhUUO8VfL3BOLTKGQcswYRALSNVLYWIgxW8bgndXvYBeRzHpWSjKQsQEVeyT32ATufLzVZyKQSrjMRVGfO9KZDjhS8HhuNs7u2V3nIAaASKgJCPvVEHiSzo4MjB46GkArc0p9cxGwZx4w4f8giiIchBstzDBYLUgO5yYmFV/zV6IGGQCAT7lr8VxdA15y9sW3FbHFzZi56HZMB7ZMAn64Vve0nXDqkuNoQHJJAZpwHooI8IU4RExEqdvmP4xxqdpvqbFYgEYp11sohlNKEKELzcVJd8F/31zcMP1GXPP7NSj2FMOMeKLUAaevcJdA3DFDHR915aLbP9J9G4QdgbLbwHmj035wFmLMs+tPYPJ9wOjzgYLppl/tsFqQ5oxeKOkqL96S/dVzl/WL/RuMTimzXLdxiR5veuM4y7OcWRhZXYsBYQ63978dT54sLSC2di4SjESP4c60bIZln7QQEC1KaeeoO8fhslP64fpB2nirE8/DKbdtugiBUq3iHokdnCZK7ZkHLH4PdgsDQNSK/JgYFxRRqoucikTJKaWQvnUKMOYCvDn7AZzXsxtWOx0Q+AiSYBB4DtDFT0ZWpJjkzM1LltrGFjuliPu3hopSB4cFCxbo/v3111/45Zdf8MADD8DawtAQygEgCy/P5mTjvnzphhFFCzKc2kQqrnXVoo+b9Vm0QaFPdKpOqWNSeYy759SotztsvFrSU+DSpAo8BgZ1kUSlxbvcuKnPLeie1h1efzJYgQXHMHiocy7GJ1lwn0AkFRZ5oEnJPZGgKCU3KOoKWmbv6I1CHqmj+eQknDL7VfTL7AenLKLEiyFOiCZNlAoaBpvvVddiTkkZkkURFTYtbMFmcKeRJVAjhHtEMNhSrUJYTfyYkxrjmDCcem5ATKyNDf5VJ3QB5BwxakJvIhzCqogQxioiJqIUD2CLzaKuQIb4kDp5zkrKAnpIK0EoXglAEyhcVhe+WrQPPy+RJlV7GvbAyJz9c6Kei0vQHTVoJkkhVtetxBy0c560ul7uK8fYbd/AkzwJJ/bJUF9XBMdNQm9ERAscTATdrE2wWVj89dR5eOMiIlcNFwQfZ2AjctrnJhHHlxWl68LHNZk6pZKMCTitTkmINRMKLVb4GQa7iKS0iijV1SVPQNzFGF7vxlvVtfilLHoViJxExB0wVW4FJtxhWrVKwZiTyikISCF+j5JTauzdp2LW4+fqcqb1TemGLyqliUXA6gQuegX412rpt5PiNQBAxNE5+uOR6rThlwfOxN2Dj1Kvy3QiZOjiAYaS9ADAxxZ9FapIgayhKHoDMizJ6kCQGN/5WEYd8DlFEdmCgK4cr0venkVcq3b5UHn8NVhWtgzfbfuuRSWK9xGi1ATH63jAOgP3Wf5ECevB5xnpav6enIh2PYoii3y75EQLN5xp2qd07+w2+d2xk50rotRr07dL4d0A0uScUkoeHDJPod1i1+WUWrFXEruVe6jKagEKNNdaufMY4NovdY4bZYW0uM6P7zbHbu9rifYvCQycoog8VrsOlTLqZq5BpepbTKdU/T5g/hvAjKdQ3RSE07Nf/3rdboSLV6q57wCgySqgwC59Vx4vIGLTT+RSBAGe/LNwjl/6TWM7l+DyKZfDQ+QzIt27kVATclLs6ATpvJQIkoDBcn7kpESLsJoQEp33A9ASPQu8+aSAI8JKQkr+qPRuwHnPSY+vkAoXLCslJlXE4oYyYbablGnPcJfi1cGv4v7j7sePl/2oe40MD1fYUb8j6rmYhL0QAaxxOjDqr+UQCfm5jpX6+648hzTSqSVakUTkJAtHcnXCkf+YC4HTHwb6XgbYY1RzA9AlSboGjeF7IiO3v/LxtxFFUPwh7fhHgtI5nbt/Lj5e/zF+LPgRc63RYpFSJr5I7IwGw3gESZ2iRSlI1Q/NCPlrgYhf53xV3yoIGJg9EIA01mpRzjWShiJ8OGcn6uQiIIA02V4jSotJFsNC1EfcDbgj+DIuvWIccnleJyDq6H9lYt/vrwd++T/0SNLClowJ75Xqzg5CeN9Y4k4ojCzIMIBbDqWW3URK+I9ChBf0Tqk+Q1GRqg+L6pbSDZOOvQ/3ubV+5KA6pT49Gcz2qZooZVLNzU7kIuRgAdd0Ambdqt2zVrlMYmmsOeT+5fq/S9cCE+8C3MWqW4p0cPbKtsnPaffFQ+eZzAtkGDYIKzgMYTcgHPSqVRATxswpJV+PPSLRIl1Kch56cBwmlFXg2VOfUUMpA5EAwiZOs3g0+iOYsnF/1PM9LNq8yhi+14XjcHZdFu5pDCObF3DtmQPxwGCt+FInQVCLMwX6DAWe2Ip4OBBGXprc1v14AzD/DdiLlwIMr7qcl9ui8wcr/UqeMtYzLAQy8v0woVpyaI3MzIAVPFwwjEUNv6+l+BgWkNuVUReOQu/03vj64q/V1/NcrROlSFH5SMwr1S6i1AUXXAC32x31fFNTEy644IL22AUKALgy0SCm4i9ykCDY4HIQNycTu3FjLAH066wNjPwWzZHTgFQ0yR3f/4Z2xfl9oxPDnttfWa2zAYITwaqrEK4/U7fNKd27IcNlQ70vjDVF0gTbE+CREpEaos1kpaOUzkDXU4h3M/qEqHHD92SnlDxhME1cGfIAlZuBxmKgaAkQCcJpaSNRyqMlDDVWQbSLIpRu0W3TJr5OVj8o9XHahLExqAlUojGBHxFqaHRKpTqteGrosTi1t1V5M7qlEivGhvC9vFSHOlhqZFmsdjp0mUU0UcqJKbyUKP8n7kJTAeSrjHQMY6vw/hopN1W9nCvBylqRZk/TnFIlKwFBUJ0GKfYUrCysh8ilQ+RcOpdUqwk0SJ1MDEhRykIMVHt1PQNJhmTtlbx2LkLyZ9aLaaiCdI11hjQo7dbJhUzRrb2RCyIcJyeCEMlQH/fJ1R6zgjQRCPBNYG1uNEuc+wIA7snPxQ3d8rHc6QRc2SizS9t3SZGFnEA9MgUBV/n8GEhYunOSois7xg1zHXu5JAz8dGPUSw2+ML5ctBcM9NdyNs/r1heDkPZtSL9cXTluAIAzQ62u6bXZpdDEHDlpvuF6HHFJPj677aSYu6pUd8xL0dqJE3tk6LbJTLbrJpSxqCQH0Q3RA0NjsuAQpw1MfCyrilIOMkSVWLnPJJKe95dXNz2Bejw07yG8v/Z9rKxY2ew+KjQFo++tPmwpnsgM44tO6RAhws46kBQhhGwweHTgm/jlyl/Aek8xrcD35eYvsLZyrf5JtQJf9D2guAgKa7TJ0H5fAS6bfJnmlAr0UMMnnRY7eH8vaX94O8rc8mKIHFJWRZyD/UIuns4aBQy6TX9dyPf1x3/txsfBK7CcHwBcMypq3+pE6R74d70bkztJbd5RhChlkQe/LExEKWeG9JNjiVJEKCMXCeEoRhKBIy65f907H77ZD4MnVqaLbTY8kSeJDAN6nIe6oE2XfH79Mc/DftSZuK9RO84BLoCXhmlCrUBULgyGvejsCMMqjw3KIU9ow3447dFtpsshV7HiicmCyCJULeWuDNdJYdgCp79XlHZVVxVKiXdL7w6c/xzwn0Lg+JsAAFtqiOufWIBSKoMNb2jA6Ar9hCBFFJHZWIl/n/AIuqfp8yHlJeeBMbgXWiRKhTxYnOTEvfl5mMF/rEuEXM5I4m3XSACpRF8iClY4ifC9SDgHEK1qbkbfdZ8Dl42QhHRjEnGSH68HZjylc0o5bCwicpl0ZXEpL1kbswlEGIwQjq6GvCopWnCMyMenUuykrehf9Qlw3E3AcTfq7x+neU4xhRxPjSRKmTilrAKPFFuKmjZhS+0WfLftu5aPuxgLPl20TRcyZxWBDYIk1BpDtnlYsE7sC7tDOjZJBmHzk/WfSItgZ/0buG40tjrzEb33BH+9BuyYjpr6gpibKIVcyBDlgoqmmJVLSYIsC2+15OYLquF7+jY7EOH1TqmkzKjkyz3Te6JfWi+cEdD668ykaFFKGS8fsCglt3eKKNXFJLewhXDJWCCAZYCeWcmqWHaCW7pmK6wWmPpMqwyiyJgL1fDKOq88biG+IyQoAm5iDhrGEsDNlkUYa38Px8yITkNTJJgsWuk+wMQpJTty72z04D91DTqhPCVNcYuKAKfNRbyRAG78arnxo+Iyc2sFApHoPqeXRRuPGJ1STlHEFQ12DK+XFyKTMtTwcwDIIJ1SFqu0kBBHSFedUsTYheECsNu0ayFdjBajFadUsj06JBkgIjiU38FaYAOPJCYxgach2IDf9/zebFvjYVmgYR9QshonTnkcU094Cmfka+kwFOdtixOdE6JyQYUHC3dWY1dV65zuf0faRZRauHAhwiZx48FgEEuWmMczU9qWBTur8dq07dgj6lcDRcGum8xZTEK4FI7JY/DVHSerf9cTg5rlwkB4ZKdUrJLr/zc4Q3rApwFgAD4ZoaprwAc1ESTLlYmh/aXGfPY2qfFzByJID+sHsE5BAPIGIpxFVGZLydNbMs2cUsnSYN7PGJxSZqVYQx7oLLaeClWAONCcUrX1e1Eqr24bw/cchOjhc2riXpJV38B7iQlLJrFAyTOxRSkyEfTNp3TDz//qikj6NDx7pXTMO6fkIN2pDSyNDX5emlMdLA3Pkxx3P6Vp+2VVfovFgRf5B3BX+Fm8xt1hKkp90Unq0H7e8TMAInTPmQWGYaRy07Zk6Xqq2aG6ZlJtqfIKJwPeJCykNQj+htjhe6INd4RfhNcuDYJODEmdm4u1wW5LwmmdT9NtXkzkwFAcBw1IQbkoTeayiaTEIKr1NCdKnXe05izs15nI18JLx5YTw2Ad0R2gsZPeXBmM65bZLof2Ppifi7O658EjTwy7pHY33X5MRRXO9/nx9mkvRL0W4kNq4tboF+Xj5I4OHxi3vAgj/tyBSrd+uJnbkio3NieS5UmF35gXwJDg/dbeEQzoErscs+KUOi4/D69fMxC/PnQm+nVOg5W4Zo7vlp6QKFVhtWohbmaDe0P57gCRW8ZzyRsIdZXEM6coAlmyC4YQNbKIpOc95cf1xDVZVBt7gqRAOghqDKt1NvC6XGkZtq7wQlvocPJ2dE1Px8CsgUhx2nSD/Et7XYoh3YdAhIjFZYv1X6pMuuOE75GM2fYpSr2SQ9aCJCkkXM5B4bQ5EKy6BqHaIfAVaWF6Sk6pKiKcxgMXfMoEm2yn5GuGZQA3UjEs8qJacU8hIkTQIIcw3ujxortcqbVXIxH6M/mfwJoxEEyqECpOqdhOEO04h4M+9JRFqarOQ9TX9sm5FnuFI2okqOJo6Z9zHGq9YfA+ySUt8kmwdb8C6Vmd0T8cwb2EM6IRhIODKLQQFiLoKosqHjEJjWIyGlkGOz1FsFuih5B2u3Q8GCJHFUQW4boLpdyVYamvCYT171UcMxEiDI4jRSmGAZI1h0c9KXqZOKXSeQFnBg0pCADgizOBWc9KLrTxt+mcuJ2c+sUp5fpKiFAT5skLfiHWBxBCiEd2LOVznE6UgmiDQLhepcS+jJocn+zj44pSpWuANWPgsBAuSQuLkOymVvrxzump4Dz9YAkdDZFLQec0J5w2FmKkE5KteudToT16cq70JW6kIKSISSffBdwwRhp76USpjKj321k7Ph7wIK7w+nBH2W4g7EO2SZtu4zmwDIt0u3S/3j3rbry/9n18vfnrqG3jwlrBWIhxEs/jwSq7uphhjZXPU76ukwy5Kb/e8jWu++M6VATrMSstHbfl2/BSdnQyZpX6QoiQhJNY9M3Ui1IhjsfOSk/CCbeDilNK/k3G8L1AmNfliysRw9hYs1G3Tc/UnoAtCRnEtZnljP5davhepOXhez+s3I+HflinXTfQrqeuJqIUaxCllByPk66ahPfPex99a3vDKQgQGAYVZm6p6u3RzwFA9Q41LyHpitrnlhY34oXgc77eyLBLxyWp6y84PVkqxJJStzlq2yci/8IKx2Dg7hnmH2YiSvnlNPtpgoA7mzwYVK/l8UtNJ8YsYT+S5HysDCNgc0lilToVVu+rB5jo+66rVfo+EZKYQ+IURFxpkfNDMRbAlaUTpVyiqLryA1xA+n1JGTH3Qcop5ZDSryhYHXBYpXNjlRfnj6szuNrleafLbsGD5x4dJd4a87jWW1hYwSEDhrGWSUEVAHh8weN4cdmLeHfNu3HFVx/LSE73Px4DKjZJFSAJSKeUcbzdFG7CqI2jdDn8FEhRecaWctw9dg1emhrfdXY4cVBFqc2bN6v5o7Zv367+vXnzZmzYsAHffPMNunY1hlFQDgZjlhTi22X7UCB0078g2pBit6r5OYwheiS3nJ6NnlnaoCMrorl9qjJOxOn95SouMUQpHyc5n2xihn4XiE6gk6MTzjhaavR3VXkQ5gT4wzwyInqBKUUQAVcW1ng0dwZPVHoBYO4IuegVaV+UROeyBRb2lGg7bcijX7VvKtdEqUB9dInRRJnxFO7Y9S0u694VX2SkRYlSNqIBq0zTkq8mW/WTVU/Eg5//eTqGDz0WZx5DONiM2VQJpwVLDMLCnIBhM2/D2G1jMXL9SABAtjNbDVEEEOWUyk1zqJ2AMhD4NkPbL/XTrQ4IFicWCSdIuQ5i5ZQiUJOcJ8mDIYtVrRiJ4hWqUyrZnqxOmoVQ24hSgUA9xBiVYETegZXCAFTmSC6IHF7AnBvmYO4tCwFIiQ1Jij2aBVrpIBvEFFTKeaUyIsSE1Us85kIIG6qkCSHt+r7tJK38dt/O2jHneQesshDJOg0luwEYi/hM31SmCr5Rv9XQeSpiTKYzEy6TlVMAOD0YwqfVtejpjHZK1fq86PfSLMzbnthq0dayRlw7+nd8t3sEWHuVmr9MIdtkVT0mA65FsuyM8hmdKCfdKYUDKav55MDIBE9EOg6pjlTccWYvnNIrE8kOK47rpg3KTuiWoWvLRJN8CIA0QSkVoo+VikM/OSQFcJ8rE6EMSRx0iCLQ9WQYcREhoEfJYRGlRLU7f4VWDefNGdtxwfsL0RggxD8ujC6MFga627BKZzV4A8qqU9EkJuPDqhqcHgji9JpuatntFIdVN7lKs6ep90tUvh5H804pBSkhqnat8ggAYCDIopTL5gD4ZIRrLoFIuEBE1SlFiFKiC34luaiNcBHLbb3VEt0uNIWb8MCcB9RJslUUkS4IUglpALfXS8LzYHuulGNmxlMIm1y7ymq30SklCCJEUUSEmKyFAn7VKVWc1B+44gMgpx/22aTj2z8cxi11+vtlYNZA1HhDCJTcDe+e/8C75z/IT8sA45La2CcbGvFArnQ+yKpFDOHyCTIMcgNSVdoGMQV+OHB1ty64ce+P2FwbPRlLSpImrB/ddJb63AX9lIUn7TzWePRtTa58fMKEEKAUmogOtwXqSKcVIewoopQrXpjqmjHAbw8AO2cC316ifYxhQScQad6Z4w1xcsUqj85nJZhM+jpzvCqUAwBEqy4JN+QQLDVMSs7rtLJiJXY7Yk+WFZIFTYCxWglHt9yP56clIVB6N9yFDwBgkZ/hREaSHQCLIZ2eww3dnsfpnU+P+fll1ix4xCRsFo42X2wghTMTp1SSLQkXnHg/RriDcHmrgZLVpgsNVlmkJSe9ALAkRlLumLAsWLmAS0bYhoXFZQj5pHxSvCDqxkMkyvgiKvRdZsyWMfh8k1QIaFpqMmbwp5luBy6IRpZFIE5qAMUp5SQSne+s8pgWAjKDlZNCB0XznFKBMK/mi/MzDC5f/O+oypI902RRiijS0Mm4uAmtkmhrnFIvTd2KWdsq8eo0TSxSxPM8s2uAWMxgISBDruKd68rFJb0uQRNS0E1uH0tsxn1lpMq2RIU0FZHHPYN7AQCS7Vq7sbB0IQCA8x6r21xxvIi8E4Hi+3Fqnjbe+zYndi7AIjEPr7mel4rKmGLilJJd/4rD2xnWxL+UjB5aeHnEhySyQAIbez+M8IKIRbtqdKK5gmiRrqV6ltVyEso45XaZZyzATWMBezLsFjtu7387ru56PnpFOCTJ+62OWeII6XZEkJvm1BeX4sKw2aTforgU/1HXC969Whif6pRyWPH85f2x5BmtsBAQvQgbYFlYGBHnsIa+KkYxpA3VUpL8X3f9ijN/PhN/Ff9lul2fcERa2CDngUR7kSu7mUN8KCoZ/ax9s/Dlpi/x1eavoj6XvH/31Uqf3cllj9rucOWgilKDBg3CiSeeCIZhcMEFF2DQoEHqv5NPPhlvvPEGXn755YO5CwCAzz//HEcddRScTidOPvnkI9KdNSBfGvCvtegn8YpTasojZ+GBc482e6tKXUiaWL5+7T8AACmZmutq/jND0a2rLHiRE22Ccp80Yc6wx56QZTgykCmXbG3wR9TJUlZEv2oXYBnAlYlZjdJ3ekUnZnZ7XP9hJtWOMGgYhJu/V0Pm1PA9holyKCDUpM9v0lSuCjbBmU8B7/XRNUIJIYoQ14xBqZyz5/NOGdhv0/82AQDOeAS49gvUZWohRal2g4OCC+DUo9Px7wv7ICwQIT7GxjaGq6uR0wSMzTVSg52dlK1OlABElavOTXVGreCR1uuAMrmyOtVKGgDAkx2oIX+X8n1KFS3dCp0Swle6Rg1p0JxSUshOW+AJmZTrllFCfjgi3CM/JV8KMQTUUuIKZAekiFJuMVV1SiUHCYEmyimlFwD4sOaUy0vJVo8pGUYb4QQ1DMgsWX0YjK56jQUitpSZC8eK+GKkS3KXKLHESJJJVaumkDSoenLCxrjvVfjPr5uxM/Id+OQ1UvVPw7WWw5sPJEzJ6I7kO6VVyhAf0ldPstiAIc8DA6+X/q7bG/3+2t3q/a+Ic6k2/SCrb572d//8NF1OKSFkbt+vsFhRCYPAR+ZiiRO+5414EZTvA6cgGsKXZcJePFbvxqVeHy71RU8eKolz/PWSfSis9WH8as2tJn57KZbYHkE/Rnquwa8f8DqNuRnAYLfYDUP9AYyprIaVS9aJUiBWo1PsKeidLt3/uvLzQFxRym3YhzSnFd6INgHPtZwo7bssSiXHqGIkcHKic4tVlbQakKINBMlceLJTyph3BgA+2/AZVlSsUCd3mTwvDabk89iT47Bwfyk+2amFKIZM2mGH3EeRlZDCnIChIxfhzm9Xo5RIlt3k9aInI7UX+8TOwKn3AQ8tQ0FGLwDAUZEInmiqwLxibXV9QNYA2enGQIxkAYJLmtwla31wr2RJ8CFXbXcymns5xDBI90oTh3qkwi86UC87zZaUamOpQd0z8OZ1/VAfkUT5E/L6q4s453aLnpjVeiK6apWqU8p4uF1Zposa1aR7msijqLg4XDGq7KmYCNGsQTxoLoRje3kTTnh1Dl6bvj0qF5pZufvOnBbiAkjCdf9eN+B+dyM+rtIm0KooFfahsLEQ98+5H9fbmndDJPHaPiiLgBAZNZSSzLkHAPnpTnWyP36xFePmpqPJF3sCNNl2Ls4PfYg6pCMYMTm+zYTvJVmTpMXCo6UQTmz82dQpZeVCgChGiVItLpzBWJDklM5hnvD/7H13mNzU2f1Rmz6zve96170bVwwYAzY2vffeQwsBEnoIEEINEEogEAzhCzX0UEIJEDBg040NGNzb2mtvL9ObpN8fV1e6V9Ls2sbw/cLHeR4/3tFoZjQj6d73nve8581CAPC5ZjQnSecd5XuO43XxJQOI+oFVN/4+d6pzJ52UWfWnkgIs0oMS78ksUUptTfkeYKmx0wW67yVzKozRyfSHtKMp0gTIvFKq2IVEp0nc71O+98ynZJxZ4VHQrChQdPfGKV4mqSxBQ7Gfj5N79RAGGUmXdWwMHSgHSo21TPu3cEDL44r9RuGps6ZDsfmmVQWqEBaJxxf1nXpwzoMQkxOQ3EA6rsbzveb+Lf2c2xS8jlJKDi7XXsIYb0LGdedjG+wUDwY8xnolm4QsyhDAd6uj+GZTH9qi7nH/Bys70J3IQnAhzWOiiFWKgssrnWs0StD2BgYDYw41t1+x8xW4adoVEACrfE8dmJSqD4kYX1fEx175NGSjfI+qFOvLwtBVK1mkG7FswCNx/1M45g8DHkHlSyq3okO3Dh0Xv3exY/shsTjubO8kajxWdd9nJaQ9kscsNbX7StF4ckt8C+xg79+cSn7PkuDPpNQOwbp167BmzRrouo7PPvsM69atM/+1tLQgGo3ijDPO+CEPAc888wwuvvhiXH311Vi8eDFmzpyJ/fffH83N7h0nfqoYUxuB6N2ChdWr+Cc0BbNHVWJ4VRi/PWC0acY6unQ01NgYAICaIQvjpZ1EQnjyLo1Yev2+KD3ur8DIA4l5MGBNBN0uCzxYxMdhY6fh+J0Hgcb6AqzBQZEUkxXuS2bRlyKD7ehYEIfE4vh9BwnMkoKAuBjGE1tqcWL2KszK3InH19gWzXazbQAQBKSGzzEfcllKewmfXSkVs0iplCCQ0pu8TYExELS8I1hdZ5PJ5wWBmHxPPMFsew4AQRc5fcJg6dngOWn3WLIthvYbS4KgxkHOoLzMX8Z1IfIIfFDIKqXMY2AUZkmTlPKYEngAiGeZ4E7NQTPMagHLULPHIIY4g02qfuvbhMEREiwMLR5qyu7zsdGO77A9SPTT4Ye2mk/W7uL6fEO4Af848B8YUTLC8Rz1/+lBCJ4SQ+GSZNRMNqVUxqaUgupDuu1AjA7sjzGlYzBjaBlqinzYqaEY5V5CMK9cX4NUsvDknxUEJGAtRkRoBYPxQvXvdeG6fv0BAMDn0kFMoBm8/mN/E9FUDqKXLM4EKeN4WQXjl7QgOHfA92Pvb9eSgzKDILUvUFu/Ae6bCjxOSCtaRhO2/QYHTrCI+UGlAa58T8q4l3W0yhLXNRAAT4h7Qnjt6y147WsSsLDle/FcHBmDwPBNP5fvnkiR7MLZfVHc3tHFZb4pNru0WO9OWEGtsHkRAOAIiRAOPUk+4PUw5TAAkItOwDeadRyaZJWEh3wy9Lx1DsKeMIYUk3liU2wTXwZNx1+X8r31XfwiKOCRzYBubuNcTAycCcAipcJenkynUAxvwqwooNcgIFbpdUjSxQOrlqVKKReVw6dbPuUel9HfmXl9maZxLlIaM8acOewmvHjIi6b6k13gru2MY01HAh+u6kQ6ZV2zvT1dqDfK6FYaZPXTq57HmyJ538G5PEJCGlWqihOaG1GV+DW+Wq+SrDgDv0ciCzcDQ4yy3HV964BLVwPnfYxWwbrOM4IATxfxVurWI0gxYwktqVZKFqIrcjsG17chr+VR5C1CbbAWLx36Em6ZeQuOGuH0jQP49utVxiI4Z7vrdbbzHoN2xqgbzO9H58J+lVKAq9GwnfQYqMvYH99cDlXT8T8L1wOZONdHs9ultLFGzaNHY+ZUXQbqpuDCw57GHmd+gkN2qsXvDx5jle/l4mbcBcDdO4c9fuYa2xAjsV5QrAUMbz57C/aaIj9X0g8AyzY5CQKKmJZCF8jx2w21AdjKXwN8IgBMEnDCMeT/zhUFPKU0IN5udqek0O2dSgeCKMHrJWNHnTGOfqGReTqaznGlZG7wFriGErkE1zGT82yiyGeAXNq9tMzA5MrJxKoApCscQJSpmbwGUdg6byMaY5jle7bzks6qWK3X4l11IlbU7+n6HoMigwDFD5+u47rOLlzZ1e1KFu6I7nsBowvaKyHyXnslU0RlakNNmTUGSYLmUIv0IYhRhi3MMlZF6A0BVWTtgrXvk0YRr15sPa+p8CkSdhtW7iib3nvQ3njqrF0xZ3QlnvoFUQwOKR4CseNUU5U/oWKsub8qCChEO2WgWGXhLohlnN85bjTNCBqECVs+GvaXETsLAMglIAgCJOOcQ8gho2Zw3jvn4fZP/oqD71uA6Te7K3weWUhIQTdS6qKqChxRX4PPDD+5opildqX3QizkIl4wyEpKSq3pXYOVPSv7JaUm1vrJGoFVSqlZ01OKdo0+cdch+PSKg5lXku00xvDaSvvbZBkf2PzwEsY98rJmfZ9C5XsDQdR13NTZjUH5PNDyJW9w38zHBWYJny2upkkotlM1hV3pCAAlge/XKfC/CT8oKdXY2IimpiZomoapU6eisbHR/FdTUwNJ2sasx3bgzjvvxJlnnomzzjoLo0ePxt13342GhgY88MADA7/4J4QxNUXwNzyKbIBnZkdWlaGp3Aok/rbv3zBn0BzcNesuSF0nItl8BtItJwAAvuv6Dptim3Df4vuQ1nqBylHA8U9Z5sGUlHJRHei6bsoi9xw0HbccMR5TmwzywWauTm9AVikVMgaC/ROGR4IgYGWKGLgu1MajA8Xoti2eHJ5Sg8iARLM8oiCamWoAgC0rR0gpm1KKGp1TRs2lU1S/yKddM6gsilXNzKKEvCwpJTs6OFFlC0tKJXRb6Gojzv5y4mR8+tu90ZJ2ll6U+8tx+bTLkd5yGDLtc+HP8ubPEZ/ikJWznZ/SWo4U98g+aExAF00zx6Rm0DnWmmQi3gg64xm8tZwQA9RnBYBZDoPYFuxWtxteP/x1/HrKrxn1goQ797IIru1FzCCDvJrm6LhDTWD1QTOAQ+4DTnW2Gh5XPs5sNc7CUkqFcOwcQ/YdNUgpTQMSDCmVSyFrKwnVdQ9y3TMxu/IcCIKAR06bhg8vn4WQV8ZN0x5DbMW10NUQeqP9k1JpZnks9UdKFegU4pW8A5ZgevI5h1EwIaX0reWk0FQe4EoWQx6+HLFC1YBIPXD2+xh65t9w8E61eOG83exvY0KRFPOecc3uFhtKuz6bd8w3z5H/N30GaKqZ2bK3/p05vAIPnTIVr184E6NrwhhSZhFRNS4+GQApe43rfqjs2FMxkhBToSr0qV788qkv8cunvkQqq3LETTwbN7OQ3trJriXKep+llAnoOkTb9bw5R651lcnCxlwMzRUj3O6MZyAzobcoWguS5IazoMbH4BvdIqUk2Qqgwl4Zma5ZZpej2mAtynxliHgi0KFjQ5Qxeg8ZqsCYs7S01Zb1zWpxc+y7ccaNKDH83rQcWcRWBIsd7wEAlUIcZcZClJbwLdcGWYsHlpQwflvJVvKs67pD5VUKiXRJq50IiAq5Rm1oVMm1oas+1PsmY3jJcHgMUpot32PvzeZ2S8GZ7toESdCh6gKWx/1I5pK46dObzOeHMC275XQNVjdX4cxHvzA9wWYOL8fpM5qIappVSvnJb9eV7kLU4wWqxqCm2PodMqIAoZ34kPUgjKryYvM5xfBw9FW/il5tDX49/9cAgDGlYyAIAmpDtThoyEGm2bv99wRDStGmCfZMd542WLChl61Lzltzv6WUGoDASDnVsYcOPZR7PJB3DiUzPcgBaoab29tdVBRrdn8cS/Jsm3mJ+HI17ga5rAl/Pn4STpsxmOty1pvuNffussfMAV7RoOQsQnd1L+lqWuOzui9WRbwQoEEySnBZpRSFmCscl+d0awx1Ld9jk3yizKk8AVhNQUbsb8ZbQRfip1RVgd4NGFM2htteKGny1retmHvn+/h2s41wFySMl0jcWaaqWKdVocfo2BpN59zVXgzUAhNXIpfg1I2zxjU6Sc5//RroXGG2jo/YlO7PH/w85u0zz3zsVch+Szb2AgBK/JY6JOySXKCNAaj9Q9pQpDqUUlkVOkSckbsci5sOc7xPfaieGGobHkVHxRI4MRoHkk5lHr0uOa+zrYDG3Iu0C9pCgzgYFyPv+ZuNYWTa97NexMwjG1GDK/dn7xugTw9hdIaMed/5vFYCc8KxltfigjuBD24HFv0PczDUT0p3dAfepWYXjK0twsOnTsMoxiIhr1rHf+rYU3FJlMTbeUFAs1E62CJL+FVlOb4wmzEJjnPB/h73r3daT1BPKa9IfhMPc2uEPCFOKQVYzTNKxG48v+xpLGhZgMdWOJtxUGzpS+HDVZ3ENL68sPqmIp/H3EQSQ/x7mduoaisR6YeUMvbRoePIV47EA2Ict5UWu1PJxtjQ17USG+lYmc8gEqCEHHmVJMmoirCkL9lOFVJeWeRixreDAfyymm+0dV9JEQ6uq8G7IlNZoW8fKaWxsXP3GlLCR7FlCbevaXZui6spod2R7OAtMzQNI7JLEQSv0P25fG8H4JVXXkHOaGv5yiuv9Pvvh0I2m8WiRYuwzz77cNv32WcffPTRtnUr+G/HkIqga2eu+mKeiJlYORF3zboLdaE6BJUg1MQIaJlKiLofaTWN/V/cHw9+/SAume9s1WmqDhLtDl+pddF16E53wyt5MbaMZBpM2aWNsaeGhqmcirYoGbhChvkdK33fkieTVq0hSU9kbAsr1vT8gi+A0wiZQBenQTloZqnImw9ESrVYnlL0ddltJaUy1mttyHbvhtO7sxiXzRKlFEh3PIqgV8a/j/o3njnoGVQYC4nNcbJoZyfXpC07ia41wLJXzVJDSRRQFfGho9dpslfmL0NACSDXuwuyXXvDI/EZh6BXcvj82P0S0oIAyF5uQuY9azLmcQNEJXDJs1/hq82EMOUk+2FDiWIsVBsiDZBFmVvY7Fm5G9444g3Hd7FD1VT8fenf8W2nTdKtaYgbmb/BuTwWbtiE6zusgIySUhGfDEw+GRg80/X93YxBLaVUGEqpsVClpEGyywyQAGBFvAVfdNmPjZcqC4IA2cjAR3w+QCPBgJaz1GV6ns/aZgXB9JsASNaxkMFroaDfL/tJ0NpPh0Ihn+L9yKwn+PvMBX99fw264hmEhAzKRMb/SOLDmfK8CkQ3AbUTUVNahHuPn4QpjSX2t+PQbxtrSjLZF58MOaF3rjIJEPvCAgDmjqnCmNoIBEHA4ROtgE3OuRunt8gSYoKCHGss7C8GLlkBXPQ12uPWYieWyfGkVC5uLvR8ks+1RFlgCGoRfOdIAGjJ9kLXdcSZ8TKWto0ZsEipjlgGfqa9vS4b5TA5DWqSBP/rmAYa9YJl5D+qJgw9W4H4qqsxp/QqzG2aC0EQMLSYzBWre5ksaUkT+b9nnaMs+s5jduIeJzSSYSz1lSKgBMwFXa53Zwjdh+DUMac5vg8AVKEbVYbajpqdr9AbkM1rmHbTO+hIML+Dcc2yY00ik8e6qHPcLBl1COmSVlQP/Hop8MtPHeemLJNDfNUViK++ksxVXWvgXfR38r65BE554xRc99F1yDAL5RamfC/XR8bMKIJojWXQx6hi5LwHjXnr2DvhLJ26Yr9RuO7gseReZMjMYLjOVKdS9dnFc5vM5zOCYJYllJTXYPdxVmDvET04Z0/rmqcKCjuZAAD1QgeulR/DHcqDZtAtMB6Wo9KUlOLHiqSfb85CEWeIVJ25RyxPKfI7np8hc+ixUdtcbZ8nAZw5/kz4e05BcsMvuPcqhHjGUDYY36ePmQvb7V1wAeSrpyKv82OkR3aOqax3T3PMUvV32dVXbKdcAJVyCvuOrcIRk+uwqpeo24YXW4v5mogXr3h+h397roAEFTVFfsNTyoLPxZCfQpCs38OV0GG/syg5Fv0mKaX4gEaSTLDPDGN1BZd29wK9zY5ET1e6y7XJzNmPL8Kq9jgu/Mdic+zQjWMICIT4LdY0fKxZ16W9gYMDguRQ7VEkcglOZXPXcZOcSuKvSAOXpHE9N4R5orox0sglRX2UJG8l12lZwCKlqlRn0oCWu9L4iyqlUjln9z2K7jRvrfH0gU/jxUNfJKSxYlN7JTthB51Ls1rWoYLrD2lGkRYwuqDR+yOaJuPJkbm1yHdZVgiqKBOT8F3Ox7lX3YXhVfzve8mh0zHaILLXSiJSJzwNHHwPMPMSK0HuCt38DnZMqpzk+oo8W0bnCeO0pIqxRsObtUbp4OUV5ZgfDOD0GqtELJHNuzaVeX9VBx5WD8DVuTNwvUKI/Pz4Y5Ey7pe3kuQ4WFI0rIStxKARrwgGKfWI72asXeRsAmAnjle1ETJxaEUIgQI9WWryeby7cTPubO9EQ6U1vlClVKZ4uPNFxnxiV6fen9uMx4siWOZS5UFJqQuFDhzQUIdvPR6kcwmUGF/RVInZYk7a2Id235NFAanm85CP8aQliyeKIljvUbCmYoW1cTuVUg6krHjVvu6lSqnWRCvao2lc/c9vsGxL1Bw70mqat8z4+mk8hmvxoMIn2n8u39sBOOyww9DT02P+Xejf4Ycf/kMdAjo7O6GqKqqqeG+PqqoqtLa6G/1mMhlEo1Hu308BiiRybaEpfJLLItJAwEuDExFFIu8D9GX7l84X+IrM7nZ2tdSS9iUAgPHl483sqt+QXdo7VkV8FunwwiKiYCgxUgYiLO+aFcYas76UTN7sIiuRyUNnL+9gBWBka2mg6bdPwm7le2wpCWt0TgfKAkqp3mQWPQnnpJfPJAsqpXK9U/G596+k7bWRyQ55rcE86JVQ7i/HmLIxGF1GytYue/8y9GX6uODZYeqsq8AzJwFLX+A2dzLEEMWuNYQMo9nTWSP5jAMJnPonGBKiCF3ycMFQlCWl1CzX1SiVT+H9lR1mwMst/MPGvZuNc781NSgdJ6yFckcT6j552HEc9mDghVUv4E+L/oTjXjuO3zETRdQ4J4omIaDriDALeZqFifhdJlYGbi2UM8ZxDhnUAMUo30O8DUh0AlFL0aIBOGrDM/jj+pf472B4rgQ8zgUOW0uv5yxiRszyizi7UmqzXga1QFlCa9I5LoaUEM4cdyZZpLNKoWFzyMLbKOFBNmEtOliIWTf7BA63vrEcZzz6BY7tuBcVsvvYDBiB+G6/Kvi8G/onpfggzwTjDZDZ/CXyBnlIF4uFwC4yAvFGzE0kMTnNL6IyooiVgSwyImOqrQRJFlTxmUQ8ALy46kU8/t3j5uNELmGqaryy171E2YZhOX7xkNJy6M30ckRUZ9y5QFMMNUVHLAMfrOdzhhlqSCNZyruPnYjpQywz8ahUbP49e5Rx/6pBDA5MM8u9aKkrVc8CYEip9Y6A8fCdavDt9ZYhdVonC6baIMk2m+Ok5kNRbm80Fbura0YHY2aZWKtRVrNerza/54Ye5+/AKsoS2Tw29G1w7FPC3vvhalJCEuLHTm+mE3q+BNB8SGTzQOs38Bj34cKWhVjcvhgvrnqRW1Ru6eq13sBQVUX1ALb0pTnvurr1R8LL3NKdRnnonNHkGDyyiIYS5noDgOOeAva5CaibbM1rxqIoz7TiZuer2ZNHIeezrjlBEHDV/s4Sajo/sfid/ATOkN/E4cJ87CMSry1BYpMp5JjtpFSv13kuVU3nSmN0Y4GT1/Lm/UGVUmcn83i6pRVXdBX2DaTwSB5IqcnQsuR8DuQpRRNhIcEgpRjSiCrxTumLIqBpOFipRNinOMrf3Ugp6t0Tz8XRHGVJKRthFOJjWyHdiwdPnoo7j5mI5d2ElJpUbZUbVftVjBfXY5i4GbVCJzE6tymlgoXkQeBJxEyhrqoUkuIgkAJsI4HiQbDjgpSAp/1jUa2qQKoH4yvGO/ah3qRu6EvlsaG9G28EA9h9UB3u9AlIG6b9AU3HI+r+5r7t0QFIKVFGfiuVUl5ZQqs/hNOqK/F2gJ8Dk0YMUB/g52WPTclPiXWKipClOqt0KTOkpdk08UXneHv5D0tM9GR4oum+t/qwsStPmlnY4+GEk5Riz9+2dOBjjymANLIAYsa9ksiXI6b7ERFSGClY825ECRKT8P1ugS/gnHdnTxqJSlVFqapCE4BVWhKYchohSGy+pW6wN5cAYHpz2pG3lxeKEoYaytTVBuGy3OOci3WdGNfb0daXRg4ynlTn4OPgbOCK9UgceLv5vGwQw3km1lYkxVIiGop6wUg2pgQB7QmnP1GXsQZZ3NyD5q4kNhhl8I1lQdfuewAhpW7LHYO5mdswuW4oJlZMRINnlKloVEuHOV8kCMB+fySWAi7QuDWD8Xc+A2gavjTi2OPqqrHXynlQfL0AGD83g5y6deatmFU/B7keYqPhZxK1PjGCfILpxF4AmrcTd5YUIy4InKfUh6s6cOLDn2B9Z4K3dOkPZS6/g01BWBEgcVFnqhO3vrEcT37ajP3v+ZC79joZ8lf7jKxjdpe+BaQEfHWPQw5/83P53o6ApmmorKw0/y70T92WFt/bCXuWXtf1gpn7W265BUVFRea/hoYG1/3+25BRMxDsXdkAqP1IGIPMQrhE2bouidGywXg6HEL3ty8Ajx4MbCR+U1SBMbjIKvOgg0qm9TBEpGrcOONGAOR8UVPD/ywngfjoCmuxR2Wd3/WRQWWQQUoljC44G7uTmHzD23h3BVOvywQANFByLKBdjc55Uso0OjfL95wy5ryqYeIf3sakG95GlpmQVrXFcMJfPyyolNJ1BdVlJVzba9ZTiiUmbphxAyoDlejJ9GBp51KuS1BSdWYSAQBr3jX/zKpZ9BkB7nSBDMInjT4JTUVNAIBXfrk7rjloDC7dhx/oRVGA5OnfcDUpCEho/CDKl+9lOaUUDfwFkfzPKaW8YSsDyZT1UDn4RfKLENQshIV3mQteirzGZwy/bHWWKyKfQfaJY0yJfV4lwU+eOUfUU4pVrbmhP6XUw2fvDSFUCdROBqADH99nlfEBjg6M1ofzSikW7PXAKqUiegW3HyWl7qu5BfPyB+J5dY+CsnI3pdQrh72CmpCLWuGIh4CrNlqmtdmEK8ktCO5lbH02tdZXG3sxO/02ekXnd6WoPOYpYNbvCj7vhn5JKRpkZ20Bds9688+Y0a1OFER+UeUCmTFcFjQFd7Z34vweK3t2uDGOrghFkRKY9/JYf5ulakIOf/nmFqzpswh+rnxP8gJuyjQbZiad48GqnlVcyd6WPuc+imCV7/kFEtyuUhTcX0Luz4AqoqE0gMMm1eEfZ++CQzN/wLz8gXg9YJVATWwotj6z3RoraXOA9ze9b5HHLCllV0PkM6aHBABAJgQDvS7H11ljRsSnQBIFR8c+AKhXYmanJ0oaaEwYpLkQ7qzvTDKrOtQfgM0HjyLI34fFyWazbCqRyQO6Zmafo4yXXDxjvX9Xr7VdNvwnogggm9fQFie/QYlSj948f392GB1uT9ylEe9esidePG83FNkD21EHArtdAIDpAmiQO2zQzCVRAmXmWAmA89VhUR9yli9WMh0dIwJ/vym6jnadjLN2UmpVxNnZLG5TRVNSiiWRqNG5lM9ibDaLrQ3rNV03zXQzasYxj7Cg5XthQynFjl10DgmkS/BS0RzcePRrxNvTdiRu12lhpVT/pBTN1D+17ClsTmyGJEjYfZDVtbVItK4tHSJqi/yO6yLSj0E8q5Ry9ZRiIcqOhT8XcxVbsfWTm1txZm8fTlH9XMMDtyTHZpdkGkVnPIPD73oL8wN+RCUJ/xMU8XmIfOfXcjOxWreuy0JG0Ozx269FikQu4bgufhtWsMjvw2+q+Ps+aSQwS21KKtGmALFfB9URa383fyeqJLGTUs7yPes4+7JW7Jbt2gNvfN2Dfe76AHPv+gBpwTaXuJTvKaJiJl5i21AlkOJIqYx5Hcu6jtfze2Kp4Ul4+tAYrhNqMT2VxmlVhcvyAQCeEAQAYwyTdJr4BjCAUorAXlpa6a8ssKdlOG1CkDDaIKWeCYfR5dKtjsJRwQGeqErlVMBfYnbaFCBDMuYhOymqUeKQ2jwY8WFaFM0ki4U8Lvvwl7j547tw1F8/xhEPLMR3W8h8Mrg8gJyLUgwAKvIqPtAmYJVej1HVRXhs/8dwUuPN5syou5ExALDLufDteaXrU1xJNr3v82noyW5uv4SWQ49GujOanS+NOebAIQfintl3mmuwoNcaC72yWLDbMQvJ247/KY7gtrISLvF18t8+w8LVXfj9q99avncDwa3JjG09SN8rlU+hudsaO1mVYXvKUi+yFeee8DIokW/hr38SmzPfbN0x/QTwg3pK/W+jvLwckiQ5VFHt7e0O9RTFVVddhb6+PvPfxo0bXff7b0N70rrw79jzDvNvt2wBBbsQtnupFMI9fuCm8lL8cv1zwLoPgFdJRzzaKYl9H/r+WqYatw75PQ59/XpgyT8AWEqdeqEDR4+UUWWMEzldMoPNpb1ksKeklKYTSflHazqRyWtoZTNhBim1cHUnNhqLRMcCeiCj83i75SlFgxUXpVQHozqgBsK6ruMXj32B3ljMVSklaYCeK0ZDKT8gsp5SIWYQLvWVYkgRmXi7093cQimRT7nXcDOf25UiAYes67jV04Q/z/ozLpt2mfn8oLIAztx9sEkcsi8XlMKm4ADJDL61gs9KR1PMxKzl8dQia5A1SSkjC+sokWJ8pSjopJ5hAnw7KcVe22s64nj5a0vh0B5NY86d72Peo3+Hp+VTc6G1Lj8YOdGL6hrGS0v3QhYFU9lXCGV+JymVGT4XOPNtCLSsYQ/jN/7kAeCT+8394gVaRlfpMXiQ484DBbtNy1pKqV+k3+SPQQBSugfztYm4OX8iVEhEqcHg0y2f4tbPbuUWQBRsFxzufgiUkqwkvafTvY7sLwCISg/0yIf4z4b/mIH835f+Hbs3NuD1IH+967DaRNsh6DIiw+aaXdG2FoVIqb5MH85dfAfeCAacSimWlGoj12pQ9DoWEnYobFBh+EM0MN5ShxmdR5uDUbzuEyxDTobsamNIKTuc5XsDK6VmJq2FesRY3Ly78V0HKaVpOsCUiZjle/EM/MhAA3BEfQ2+9ZLrwa9KaCixFo1f6cPI9cWoySRRwNFTyELwqCnWgnDn6p3hk3xoTbTig00f4LFvH0PMX0yk+vm00+PLNk/JIWLiTJMcEwcVm8/RrLwbkVsuJU2l1GZZwR25o7nneyUBZ1VX4t+M2oEtp0tk8q7lQ5wPHoWNMNi783E8pPzJeB8V0DXOM8Q8BuYe8zCEbsBYUEZ1cj1TUkpBEJ16EUeodepFOHmXRuwxvAJDKkIYx5B2bqD3OJ1HWHKHJ6XKSZbZQFpNuxJTVUFnfDUoZH1ZWu6mGSb4B8YT2KJWOF4DAGe90Y7V7fw86yg3NTyl6D0uCyIUyQMc8RBX2rc1UDUAjHq7kFpK1XSzM2XI+D5Rl3H8rtzxkOb8EaLiQ8AjoybCkxNuSqmgoeD8ePPHaIlbilonKWVbSC+8B9EvH8PtXxDVxXk7nYeG4jL8es4I/Gr2MPM4AeDMXWpRXeRzlO9FGP+iIoWf00QlCk/ZuwB05DUdebduqCOIL1DvmIMdinpuwccopSZksri4pw/prISXlxvn2lCpP7rfozh4yMFmKR/nQ+eCgJB2nU8zGj/XtA9Uvlc3uSAp5UZMfy67k3lUKRXor3NgvANnfHEYLpGfNTboaEwsN5/2M8rmqnweR8TippWF5SnlrpRKMeNXNEfGkCsm3YJM+wHcft1pAEc8DFQYKkcXUgqwkm+0W/LWgD2moJBGp3EdR7wVaNErsVInyZpjGhM4SlPwcGs7Ii7xFAfje++SMjyqNi+0nmPKWpOCgE98XthpPTY+3HvQ3nh4X6faviBECUfG4hiazaJTlsxEjRvcjKvNRIeQRUz5AM3RZnONJOl+PKwegKgegFpjla239qXx9mrj3jDiFdVI/qYEgfN2BQA5/B2+6f4c/1j5CFRNR2c8i+e+IPNqY1nQYfJOUaGq6AUZo4ZWhIhIIBzCXpk/Ya/Mn1xVaxSu9g0AUmzcVGTc92oGydgmx75JozTfVEoxxykIAmqKyNzMJmW9srTV3SoB4FOfD5pL+V5XPAttK7ryAQCqxjq32TxhTQVyPs15Nydz1rXXkbTEE+wcXuS35rhHVtxaMAH0U8MPRkr9+c9/3up/PxQ8Hg+mTJmCt99+m9v+9ttvY7fd3Fl4r9eLSCTC/fspgJJSDeEG7NtklUH0R0qxXQ0GFRe77tMcbcY1C6/B+r71AID5GgkklhoLl4yu4q31b6E1QYjBoBwEoluAf56HpoxV37vz4iuJadxLRP5ZEvBgsrASC7wX4fYNx0BY9W/yflBMWX6fMcnXMwujeCaPZVvIwM3JZkUJn6ztwokPf4qrXyKBktduEjyQp5SuwmeMk5anFM+M/27B73DTp9czx5Mzj2V9VxJe5MySLhY1GT+gK9wiD+DVOfYSLpqd7053c4GzpmsF1FjMosWYDMpVFeVyALMGzRp4wW2QBYJKJiypQAlYUhSR0ftRSgFoZRQ55BrUTFLK3gbaDDAePRhYv4C8xpjU07DOoWIL+lh5/fOLNkFnehfd/PoyrG6PY8NaEvjRxURULcWTu7yGicc+j9llv0Ji3S/JIfjkAX2R3DJtGX8J0MBk+kfuD4w8gCy815PuZnm4L2YA4DfSy5jv/TU8eg5YeA/w8gWmZwa76N5rqNX5z6frpt8BYCmlWLI0mVXxylebceE/FiOdU3HWW2fhyWVPYlHbIscx+CX3TmbWFzeC2C1fcYoPuuD0Vr4BreQlXDz/Yry46kX0pHvwp0Vkcf50hA9wkoLAqdRYKCga8By4oRApdd/i+7CwYzFpf8ySUtkEkLACBaqUCqcHyAyneqC8c5350GuQOrV5FfUbDsAu8o1oMkqos5KKu4qS+GV1JaGuGBN5SkqZnQsZxHOMUkr2uhqd2zGCKd/7pUHIv7PhHfSlmGskrxGpP7OAl5nyPT+y+NjW0carymZCgEWdbQy75Yjx+OjK2dhzhEU6+GQfpteQ7kYXvHsBbv/idhz52nFWp7XOlfybGqTDE2dOR01ZHHKIzB3UmDrklU0V0rpOcp7dSl7LxARGGD4kb/ircZ/KG1s/WZ7Bp34fLmXUDuw8ksyqriRFic/F1yzkJFlmS0sAWEopj8sY2st4RXmZMatE7wVAlFIA0J4kj2UhiDS8eNR3EjZolfiPOgkn7rMrbjhsHG8q3g9MpZQ6gFIqWIE48zCrZh33lSzIrsqxcsX6LkHBIL+af4Fj1Cpc1dWDzZq7UkEQ03jtaz6xaFdKCVoWvcms5SelhCBc1QJMOAb57FaQUroO9DYDTxyFKdrXgC6Z5vyFSKn2WNos7QwJKeRhlSRxb60pnMpvdgOJv9Q0mdc8Lq+hSqkVPSu47Q5PKZsaD5koVrx1KfJaHrXBWpw9gbSxv2jOcFyyz0jOjuD06TXAezdjxoqbASaNVcIogIaWMO3ODXgr34LoJecj7VKahOP+AVy5EYfN/xX+8PEfuKfSWWaOLnJWIazpyWFdXDK/CwBMrpqMm2fejN1qSczuNkexCCJtdtbkPlvjy3IGVEod8RByAyhjKdx8gyio51NAkIkvkBsW3o1IugW/kl8CABwZ+AqhFa+aT8vM278dk3F9Z7e5aLd7SjlIKSYBFVeJMiUoOe/P7kQWmHA0sOv5ZEMBUqoyQO5Tt85hhcCq6vyMUqrGsGdYRRVs7cutskF7PF4AM1NGV8XWL6x7lRmzbistwS9qqjCvmFnL5TPmGFfsLcbds+7mqjjsmDuGHKep/BUl+HUdl3f3AgDesSXXVABSYC0gZF1JqXROA8Q0gkPuRK7kefz+49+b5ZCC7sNGvQqTMg9iyrQLzNc89OFaRPMGgWyQH2qe/I4pQUAvR1hrgOhc21FvrKayYEGSo1JVMWpIE576xXT4jDVgcUDBer0G6/Ua12QPhT0xTJFi56GIoerNZxCLOkmpzjRRQpqeUrbjPHinWtQV+zGJUWF7FRGerSWTAMREETkjWciWt5YGPf2uiTlUj3Nus6kHKSmVyqc4gUF30oo3OxJtwOIngXg7NOa7lnmt97p95t2m7c1PHVtPLW4j7rrrrq3aTxAEXHjhhT/UYeA3v/kNTj75ZEydOhW77ror5s2bh+bmZpx7rnvt608VlJSiEwqFXcLK4iujCwgAjKkux7+c4wfOeussbElswdLOpfjnof9EU9lotLcRv4i0IOCesA9PvG+Zooc8IeDlXwJr/oOz8BRuBDGD9Ni6GRUHPKgTnYayGgTTTC8nkkGoLORF0CMhkVWRyOSxvDVqfDcNoOOnIOCVr8hgl9Gy8MMKxNM5FYff/xF+5UuAyx1lYrD7J8WNrhtW9z0ryOtJ9+DlNS+Tj5MmQVdD6DMUQlTC60XWDPJ9qoi0RL5DbSqAZQBqi/kFHdd9z8tPBjTw70n3OAashCBw2TUC63FnL/m9y1WVM9t2YO18PKzcjmtyZyAukYm5PHEeOvTX8EjiXZxa68yIJwXB9NigoLJhClG2ebWJOctTyl5GSc3OAeDFs4HffGeqF4phDdyK7VyxmaCyoAeCaH3Pz9cTlUGtYcq8TKgEkIau+SFHKgHFj0klc/FymkiJq4sGIGZASokumHgBFrcvRluyDat7VzszqoIAHPsEcM9EoK8ZOoAT6mqxzGUBDZAMaa3QjdbUFuC9mwlpMONioHyYSRICwMT6cnxhJNTHZTI4IhbHAyVFeKi4CDlBQAYezkOjPZohprAA9h5dWLYOiJBFGTlVw+beFMwlCrugoDLmTV+gu4gJIDQvgASkgJXZbo4247mVz5mP7R2yOgsENQDgF/s3NC+EQqQUq0CAlifEh+wBevhMPM26h/spawEAtH0LJZMAjPbgHqZj3RvaX9HR+Sl8FdWOl0VFEcXM4qeVltK5lD0mspanFFFKDawaEwC83dyCXknE4FwO91RUoi3ZhjW9azBFWIHRYjOeUOdgS18KFSXWZ9LjT+c0+MUMXgjzBKKiKZyy874TJuGxjzbgmgN5k2tZEh3jGmB1pqHYktiCd0sqsHdvM9BpLcZ1ABv71qEhVIkRdRpO26cX9y0BZtTNIK3MAWD1O/jWdyauyZ2Gd32ksYmbAqVYSGBcKg2PKiMrRSEF1kFNWv4ja73Oc8yW7yUyeaT1rSvfW50MwL3QQSdKxWzcteV8jCkB8DCk1LehKGLwIxol13Nnkoxhok7OwZslJ+L6XuKZc5132wJYWpJDVWCsGsxMcEheoGYnxLdYioSMmjHLTigqA5XuCQ4mYA8aHbi0TDXOzfoR0HV06i4lkAAEMYPWKD+f2LtFiloOE//wNi7cn9wPASVg+q2JamYgG0QglwK+eR5Y/TYO0+P4N0aS0hgpbS4W0znVXKRF0zkcep/1O4SQ4soaOegyp7I9cNRO+NsHV0FXA1AkwZVot/uaTKqchMXti51KKZeW69TbZlTpKOd7M4Qnskng/T+iEcAwYZJZ2lbOzJt1oTpX/1Baap/KqlyMAgAQRcAXQVfaSWqs72Dmh2In4ZXRFcSM69muQt+5miR3Pmv9DJquFUyiBZF2TfKkdH78citZ5hCpwdyRR+Ify//R/34A142zMp/HelnGGTWVOLUvZhqdByAi7AnzxsYUcd6AfGZoE/LM2LBHMoUni8LQNQU5UYEHVtMfq3yP3PO9ySzSORWfretGcUBBKqdCCi0DNC8S+W5AABShGACvZqeqfrOjo4unFGD55NA1RTavIZVTUdSP5yZbQhgU0ug0xuZyfzmu3H8U1i/aAEQBbPzUMotmVEL9YXAuj1pdxGYti89bPzdLwxGqAuJteMFIfN1fUozzaDl0Jm7Oo27qbjtuP2oCnl+0CYdONGxMjATotFQaYVVDt+2+fDISRqBsHnKxMUhk90J7LI2KkNe8HzN5FXJoGURPLwDg89bPzQ5tgtEIQYWEuY1zcceed2BM2Rg8Mj+KJE3C5pLQdR2+fBZJABsV2z0o5G12LSqsxRDpclzIqD6Ql3HA5KHYbajV0Y7t/uYvEKtS/G767/DI0kc47zfOnoL6L+YziMXIPsWqiiNicTxSXIS8Tq4Vq3yPV3T9Zu4I/GbuCG6bVxZxcv49YzXJbNc0ZFzGgpgkIpfLwQtSRUEhCnBVQruCKgpZ2JRSVDmWUlNcHNGTYkip9e8BX/4LKB0KKWNtL5c60QKgpmcYJjO+gD91/GCk1Lp1TkLhfwPHHnssurq68Ic//AFbtmzBuHHj8Prrr6Ox0Tkh/pRRkJTqhxUeWxvBR2u6MLwyhJDHXeq5xTDXo12UQkzp1XKPghe0Xi4gDMgBoG2p430Em+KoJKCgRHBO3hpEs3wPhs9JWdCDoFdGIqsinsmb3Us0W8Df3JXkXkcD8X9/24plW6L4QMriAHZedSGlhDT5vcxAnVlAcJ16xDSghswyg4TRpScsWyqmopwHacPotU4Po8ivYFwtnx1iPaVk2+BKs/Pd6W6HuiglioB9Ec1kSTv7SJlWeV51bY1t4rFDMUcCFDyEX8vXkuOWhiDWfBCGBP7t+pKkKGIUY1gJAC9+2YI7mfWzYCOlBDFlKkMc5XsM4aYnOnHza9/hy2ZyzBWCFWQrtqJFlpTK5DWuHKqllwTVdQYp1SIGAaShqz5TncYqLUZWbV356jk7nQMAeHXNq/jtgt+631+ihGermyCrXdg/kSxISAGWL4o33WGpWDJRx37lYQ9enPsoWh/fH2MNr4NqYxLMCAJSugcpZlJcsNoKONV+yBYJHgiCgLMf+xzvrejAp8P3R9XGN4DZjK9TnVHq2L3GkmbDMmln0Zft49RU1NdHRh55yOgSC/8Wxd4B5PwFUIiUcpybXAKQPcj1rMddpcWYkZcwI9plLjZDmkYUFYXUWtEt2DOZQkjTMC6T40gpAKjoWQwtNN0x6/ZIIooZT6k2o6zEzYsrlouZ17VX8m5V+R4AVKsqMQ8G0CAFsCIfRXt8E17wElXnt1oTuhM7Y0WiC9RFjqpZAJLdbrZ5VqiaB3UM2XTQhFocNMHZ5roQ3LwbvvMFsTcAtFldKOcVR3Dff36BSn8l578wodzyysFzp8OHLG5X5uHzk68CQLws7YggBgVARawGLcUbIUe+5kipXsVJEjmUUjbCHQBKvE7CdGFz2pWUCiKNxr7PgZalrqQUuT/I3ESVUp2SiLuqZAAVuCBKfvNnv1wJuRQQjbIk1rC6v2y2G/or38vS671qLKD4EGfG2UVtizjDdcC9dA8AN1dSUgoAvHkyX0f1AmOsmHEQCLTz3gvqTBwpfYgH8wcCAP7y/rcINPLX1p3q0bjMLIsqgGyCKKUAeDXy3XXNA0FKI5lP4utNvTj8/o9w/l5Dcck+I/HWt23oiiVxhvQW3tcmICSkC5Yd65piNuYAgLG1RdDzZL52eNUYYEmpk8ecjHFl4zhS6i/7XIrqyCAcrgdxUWU5ylUV1xlG7ssN4+VRpS7dqNjGLQnrXgowjQwqdOvvQsbPEI3uUQP5StnAxTABJwmZgsdUAnLHCmBs+Vj4ZT/6Mn1Y1bMKI0vJSKXaEhsBIYNml3NRXVqNLTGgOuJDazSNZVuc86gdF0++GKNLR+Paj67tdz9WvZUTBFxTUYYOWcYdZSXY0yifDkAgSVkXa0N71666kIhm5vDGZTOoX3cElufGYL3vNoyAtWin8WRKJ/dwXtPx5tJWXPzMEgDA+EYg0PAo9/6i6qwA6UoY591oslNIKUU7itE1xXHzPsaajgReuWAGMdDWNFJuzRinm55SYhp5pdu8jsv8ZTh3t6HA1GOB268C0r1kv5LBztJUNwTKICS7MDpYj83JZt5v7NRXga+eRrj1X4gZ41qPKGKRz4s9kl3I6ExyZwAUBzw4aybrU0V+ewXAHqkUXmNM6f2aZqqylPB3eHNpK+Z9sBZHTKpDRdiLg3eqRSancU0eAOCVNa8AAASmzDSn6mZli6YtRQrGsWaTSGZV+DQNSQBrFFusJeQBsJUiWew+pAELVnfCI4uoKfK7dh8EgJtS5+KeIK/AZis2BrKxOHbUsWiINOCct88xt6VZpZTfmCvzGcSNiomwppnxqrmbS/meK3JpNAmt2FP8Dk+Bv2bq8irWetzH5fWdMZx249s4jBKNALqTaeRD/STpAQwzlNZuCQG7pxSrlGK7lfalrfm1vdvoQNy9hnMbHJJdjK88Eg7BIm7++KnjR/eU0nW9X6nrD4Hzzz8f69evRyaTwaJFi7DHHnsM/KKfGCgLTyeUsWWEeT1wyIEFX3PLEeNxzp5D8Ny5uzo71dlAiQR24fet1wPYiIKQJ+RQ5py2WxP/Zo8ejPHxBSiBGyllKaUEIzAqDXrMbN2ajjh6DZ8H3UYore2Mkq2GYoay2FRem7XXJKf7HASAlKGklNV978H31+DRj9YjzhBrVPUTTeeBzx+G97P7AKgIKjlTKSVrMvaPJzA2k8Elo8fh3Uv2dJiOsmbz9ruGVUrZSwwSboNYqod0vOhtRqehEilXVSA5cFeiJqHVLDMIeCR4hRyCtkVfcZ4cYVIQsF4vsDABKVcTZH7wNn2qdAFhe2tlxrSyTa5Fz0d/R6VOAqZylpSyHQ9LOvQms66L/FqBvA8lHnTVj4iPnAMfs7AbUV1Adl8AduUBi3c2vIMbsutxXUUZ10LcDTQbOlRhAkTmOjtwQg1qi3w4ZKdaDPeEMTNlfZ6kGaVitu57dnSlCgfnorE4fs9oGnC1/kvg7PnAhGOtnQKlQBnfJljXBUB3IaUyfaZ3AgC0GV5bu4nfQkEeSanw3DChYvuyRYVIKYeKzWgW8LfmN/B4UQTnlpHXxYx7KaxpTu8pFrHNCOs63t+wCQ+2tsErOIMpsX05fLbrtEeUACVozo1tdAHuUr6XyqfM5hQRbwSaxAePOX1gMqJEIOdF6bCUHmVCFH2pHM79u7WNNUX2I+tQgqQFGeXhgcsHC8FtTokHDHLdaJABAPeVFAPgDUEBW5kvo5qY1lQKrF+IfyVPxNHSfO41krHo8SeIKkTytQxI4HCeUll3Tyl7+V46p2JTH3P+y62GEdPEFbii/Qpg8eOu5Xtx6ouEPHzGNcQaaPcYCxPNMAuPpcj5ZL2B3EoX+wMt0XUzOjcTMLUTyefpjHqr61tzMUXhRtCRTkt8+d4x0nt4z/NrhLu+It/HUwxdc54LQUqb6sGW3hT+8t5qbOwh3/2q3Fk4JnMNbs8b45ERE7Ck1IPaoTggczPiej+Lz1zC7Ljph+EDafhKJXNJ3PivZVA1Hfe+SxYQ7bE0zpNewbXK43jNezVCSBYey1267fWnKgH4Lp8TyieYfoVdkogVioK/rnoWv190B1qQx/xgAM9Hwoga49QKQylFSRsOrPqIaRxCCegL/G/iXMlKNjVFmqyvkbTej8ZeGZeucP1BFMn1rruR+74i3JI/AXGdXIs9PZ3cWkERFdNX6pU1r+D1b7Zgzp3vY+FqXtETQMr1XPz2kN1w7/GTcONhpOyGljJVR3w4bKI7mR5QAjh8+OGoCbo0+mBA42uAxD8rPAr3GAACOpyxDQVDSonQUBWUoDK/T0DTUVU0AboaQixHvpvPOH664E/Dg6oIuWZfWmKpgPvSfHyn5wPoTrj76ZAPM5I/BUgpVikVS+fwZXMv+lI5XPmC4RP61DHQ7xyN7s52/OW91TjviUWmsjE89E/4z+BP8YmP3Itmc5hgmaXQAoCG6a6f7cDZ84FD7oWvksQGXKKpYiQw5zrUB6xY9MKqCvy6qgIvffcEMl+SrrZbo5RyIGfNAaxnI0AW1X2McmreB0RF9+LiFjz4wVocdO8CZPIaBFt88MGmDwAAUtZKZbAG8aquI6lTpVQCfakcfMbU1GJTSgmCysUPgpjFFfuNwvE7D8IV+42CJAoFPaXi+SrHOqQ8ZM3z9ooNN9itLDhPKRrPqxnEDD+lkKaTzsoMzPK9/io5AODpEzCv92woLnOpv5+SPkHX0BnP4uEFloCmJ8XHiNkey3qjLlSHg+IJ3NNmjDdu1gn9eEqxBH6K9ZRyuJ0RqDq5roK65uhm/1PGj0ZK/e1vf8O4cePg8/ng8/kwbtw4PPzwNhjL/YzvBbtSat4+8/DAnAdw4ugTC76msSyIq/YfjeKAZ8COBDQoZ6XJKz0eh2o+KAe5Qeazq/fGdfvb2reu+wCnbPgtSgRnZ7vn1T0tBp0hpahnw6IN1gTMklLNfW2IVvwOvtpnTMUM7YKTM8w687ANtrmk5S0TMkpNDIbbNJdM9OGWN5bjule+RWus13ypIJOgOZmIofeNyyB9fguKBt+Nz+teNsuBRF3CbR1deHpzG4q8QZSFnIMc6wliV36xSikHKWWTtq9VZDyXbcWbTx+K456di/tb/gMAKFc1IMV3wHCDJGimf0zAI8OLHBSAmwhqDEXBKqECv8+dyvwWPfBWvorjtfMR1QM4SzsbgqBD10VoefKeokyCMl3zOWX5088FGmcAAKoz63CH8iBe8P4egI5yWMGcR+UnLzYT1JfKcZO0D2k8ptyCnUVSJpSiwbLmt5RSTEZoROW2kVJml0Yb8aHpGm77/DbzsaMcwwZ6rfviTO0sk4257/hJ+PCK2aTVuK2TSdYIYHKCYPpNuIFtSWuHZCOzFF8AqJ3kXFDUTgIA1MlG98LoBHelVKaPayUdk0QkBAGPef6I6+W/IyaR961izMFlXcce63fFlbudV/A4+4MbKdWaaOWOQwdIZn7+rfjMVq4SM8v3dEdGm0OUqEY9IBNrGCnnPpk+k2ik6JFEqLIfB927AEf99WO0xwxPqQJdCwEgrIThl/3oSvHvtYrpLlUIpUbpga+PlFlvlGWkQuvQlUjCB+ueiYjW8fuFjPk7nNIXxU7pDIb21aAsuB0BvQG3OSXuNRbj0RbHc3ZEROaz7QTX86cjjCRuV+aZm6Y2lqBcJtdALkPGc9HTgcEV5DgEybqv2K5fXPe9jLunlH2x+d2WKNp0i5zJnfcJeoRiAMAM0VIKu5FSiVwMCvL4j+dSXCCTcnCVud1eb1gJX93jZglVWw85L+xCYmsWDizsSimWeMvIHlIKs8flAID4AIsEV+8LW7AeFNK4TXkIg8U2CMbC4XdH7eL6WoFRSp32yGe4/d8rcO3LREmXhYLP9NHIG/JDSpawXTJFQcJ3epMjScVCS8eBXoOUogpBo7NVKp+yBNNCDg8seQCre1biQOkTAIAPWYSEVEFfQN2FnB9X179XKdvFc0LFBFT4CRGwWZa5BWgXs6BZoyjIAVjDKqU2LQJaGA8mW+MWimLEAei4VH8MAHBHWwd2jY/B5Eqr4YcvOx75GFFfCYZfzVcb3cfDQj5coqDjyhe+xtQb38Hm3hSw269Ik4dffg5cvh5r9DrEDKVUa3s7XviSHwdOGHU8AOCp5U/hxn9/iNXtcZzyCCGwhwibcZX8JKqlLdBc1KxFgTAO3qkWExp4VfmomjDuPm6S6/FSeBny341Y6mPKIjOiaPo8AUBSIa8N6HphTylmXgkijYoA37FMBjDvfJJAzhgkJ11wm7EoPNh1CCF5vlhvxcEdCT4G0dWAq5+WVb5nEEXZOCFflr8GfPWMuZ/pKZXswJoO677+eG0Xlm3uA9YvgJDqwSl/ega3/3sFVn67CB1LXje+CFkffGH4E5b7GSJq+D7W34O2kpQqHgRMPgU+4353SxikGDJ8iY+ci/VfPYrMV08CAHyxNlMludVgru9paV5xHRcGTgikc6rp+aRlecWglrDI32TOGms1HWb5np5NojeZg8+4BrbYO+8JeQhMUkmQMhheFcItR4zHmbsPhq7rBcv3tHyEK9cDAJ8i4b1L98J7l+5FTMUHQGWQJ6XSggCMOgjY5Xxg+FyyUddMUiqsOztMbrVSag1Zy7ipjr26jlld7mOtttcljm09Set6TjafjkzbIebj6mA1bunowiAam4oy0DST/F1rjJO5BBeH80op6/tlmO/UobmPlUnqRafpwOp3XPf5KeJHIaWuueYaXHTRRTj44IPx3HPP4bnnnsPBBx+MX//61/jd77atvffP2D5k8hkIEMwJJeKJYPe63bngpz+4teZljfJo9yFWLdQqSRBtA0XQE+TKyirDPgh97h0O3ZRSr6vT8X6eeNjQwMinSGYQzk7G7Cf/49tXIchJKEVLzNe9u4zsS7M4bGtwnZpm0wDcaGMqGrXAaVHAl14vvmF8ab5ttYI8QTKMCHtaMLOxHrMa66H5OpCUk1hpBI0imxXux0uHot5mIFzI6BwAojsdw3W3ubSyHH/wZnCZ2mIo2AjKVNUaRD99ELhnJ6Cb9/cCgIAM/OkYUuMf9EhmWQn7Gw8yDJWfFyegBYypcd3T8JQtxFf1n2JC5iF8IBISUs+HzS5HVCmlqwGHHB/eEHDAHdymOqELESTgZRbuii0rwl6ffakc59Gzp/Ql9pCsDoBZyXhO9ROCB7wnzcjtVErZPduimahZ8goA3f7+FycS/YVZnyNmgScIgkVc2jKbWcObIyMIpt+EG9y8PyhEGym1vDWGq//5DfqStoDGyH7NC4zFsUPPQrr1MAwFY4SqErKhLdHtUCzRrjEnyO+aBrV1DCmV03x4LXUoIr5t67pHYZJS+QR0XccfP/sj5j4/1yw5BozA/sM/AfNvwea0FVRcW1mFN4Lk9WFNA1K9hT8oxrcqLxLc6jTg8HrrkUTc9f4mfLs5ikUbeqy2wC7d9yjKjaxyWyzDKUBW6XWFXmKi1DBwzuUJGXl5ZRm+rvsC9689FbJojblspy4vMogb19npvVE8saUN+XzElUjfWrjNKVFJJt5FW4GidQusB/asZbyNezjv5Cn426nTEFTJ98urddB1EYKUQXUJCRBFD6/EomDL9woppexEeiqr4jVtF/wjPwu/yZ6LRCZvLrZZdadbIJ3MxzFKaEajaB0P68nR44tBiXwL0UvuL1Ul559V32yrUsocrwylAUumZ0QRuGSFaVAb1wtfl0ABs1ubP1AIzt9wcF0tgh6Xcy9m0JfKIZnNY1W7M1EFaBA9bRCkOLzlpKkNS3hSfkBC4az5SX99D3ljjLWUUkY3s3wSdIj1lP8H9391P96OXmGWfndKIoJImr4yPtVGiLiQ8zOHu3capKgNWsqdmmANGiONGFo0FClRxJ+GWF47m7K95t+rPB50yBLyggBFB2qUCPDwbOCh2Zayo0D5XrEQ50z1902mMDo3mVMzRnwhUz0WCpAF1i1vLMfy1ig+XWvNITd8fAN2fpJp7sHguy19ePrzjehKZLFkYy+wz43AFeuBihGAKEIQgJihlAoLKby0mCelZix5GZPTadLFNbCMe+4lz7U4R34Nv/A+7/rZdLypCHlt98rAi2w2TuaIFAP2ElYKRVSQNMYmv6Zj5xr334U9FyGk4EcWec73ogwerw/lIQ+yxlxudd8jF3gGCnYdSgglthFA1rbo1dWg5VvIwFRK+YqsMbhjOfD0CcA/zwb6yLmgKpi2ZBtW2+7Ht5asNQkbej097bkBv9hwKWaJix2fyXUsPuguYOdzgJqJwKiDHfv2BzYJ+HXH17juo+vQbczjCZdOiV2SZFYseOMdpIHMtiBn/aaVNjJFEFzGGTEFb9WrEH0kudjSmzIJ9HxsHKoD1v3e12cpu1iTdE3TzeSimomjN5VFwIh5Hd0mxby5zgGA8jBMPzwAZhdkO3RdADQvSgLOMWtweRCDmQ5y/cFOvqZEAdj5bGC/WwCmQ1/cSIiGRY+LUmorSSkDbgkev6Zjt+5ypLcc4XiueOps7DycfCb9XvEcLd1WoCZGcipX1nYCAEnMHv13YO4N5H+K2wYDnxPBjekpZSvfyzEJ8w6BX0clBQH3lBThS4NADWgasIpv1vZTxo9CSj3wwAN46KGHcMstt+CQQw7BIYccgltuuQXz5s3DX//61x/jEP7P496978WikxdhdsPs7Xp9wKULCdt9gwaBXGmOLEGwFZ3ZlVIAgG53/7HBAedkkoGCTo0EdHRQByxDcNZQm82MxhgDOdFHSIFEWoCq6WaGaInOKLZo3TOFYewspsn7tMoyTq2twhnZrzFI2Ix6oQOLN1lyeEFKIowk5F6nfxbNqApsqY1YODB66qzpuO7gMWYWjMIs38s4y/e6hu0FXGyRLqs8PLkwKpOFqOsYn8mQIKJ9GfDG5UDPeuC7lx3HUOoTTVPjKU2lpl8O2yltLyPLkC75CqLPyjzJhtG15O0AIECkBFQ+Ygb+otxLtql+zhTThEv9NusnBcAh3+XL93Kc8kQVdKQEAedVVeChogh0iS5ELE8pdjFa52LU3B/M8j1bQGQ3Be7dh+9OZIfZIraXJaVcjFJfuwR4+nhuU0ojx5wVgIzOnn9+8u/NFFbKSYKXIwnXdSbw5KfNuPG17/gdjS5Ng6Lt2LPqBBwtfIomwRofpAyRpG/s68L6Hv7zWpksX7tBUNWxXiWChl/NdreM3hpQUiqaiWLh5oV4YtkTjn3ioggsfw29osgpEf4Z9GK5QeKGNM3yvHBDdAv3sAhuC2ir7IKiR5Tw8UYXc02X8j0Kc2EQTXPqqJXawEqpEuPj40YZ8waZBKAZLQbdb5E5AS2JPb2r8Gv5efjFGHTjXg8bgXACfkR820Z+sHCbU+K5BFA9fqteX5RgylJYgstWHjlY2IJ9Pj4ZRc1vQzAUCXKwArqRoc6KrSSz7LEW1ql8Cu8uI78FGQd0KEWf49vou+ZipzFS2JcynVOhQsJV+V/gRW0PJLIqYiDXYT1zX4RcfK+S+ThUW2iWdDF1Fr3k+HSVfPfv4ylFfVUWbFqAp5c/zRFvOS0HlSH84wN0JxoUHuTcaPOMDLiQUvAVwSM6lXc+D7kP3IypiwMKPOX/QXDoXQiNuBGilyxyWDJFMq5bsR9SqjTXBtkYq01/JWPMTOaSEI33kALrzddEhBS+9Hoxa1A93q7eiB6jvD2Y4eeqF89z2kWcPqMJR06uxx1Hu5s5N0Qa8Ld9/oZXDnvFSDxIuGQqyew3MwbCm5iEwmpFQZcRR5SpeQgM0WGOW6xSKmbd6+fuXIoHjuJLsLOeIo7cK/EFzPk6WPExKppeRmc8hf3u/hDHzvsEKwwvz2dXFvbviqaseIEq1FlCOeSRTfK2XujECd33c0Sa+MXDGGSoR1TEIPo2gi7pIkY5a1+BWIqSUoIgYHilVR7pt5tEu4AtI9wWUkoWZSQNw+mApuL4UcfjsqmX4fmDGeIsm+QSSncdOhhI9fCLbKPLYmXYh6yhCrSX7wECRlS5JM9sXdg0NWD6FrLookopQQCKjOTG4setHYzmE2z3PUpK0Xng86XLzd29Qg6AjgqBnL/TpNcdn8k1iFB8wAG3Aee879q5tD+wdgknvn4iXlz1Im7//HYAQNxFtdclSWYXbK+uE4P1rYWadxAl3gK+VLpqeANWvAVP6UIEB98HwGgiJVplwr+bchfGlo3F5VOvQjZvnXe2fC+nWuV78srXoW5agqDmXvolCCrAeFYVB/mxz81Pau+avRFfeQ0AwUzMbi8EQcAj+z6ChhC5jr7xevBpr9G8hLnfY0ZpaUgJuiilbN33Ft4DzNuLrwhg5k83Usqn68hCga46z8+575yLZfLVOH52J16+YAZEgVGnuyQSoi5ergiWAzMuJAIAdo5+jYzVftpMK59COmf95nlGpZYRRUSLBwFDydr8ztJiPFxcZCY5groO1E91fvZPFD8KKaWqKqZOdf6oU6ZMQT7vztj+jB0PRVS2u62kW1a7NWGRMHSQ45RSsuwwQgrls5y3BAB+wc2gXnZKw7OQzcAIDCkVtHWAEQXgWUwhuZrBe6A1aQVykp98nq55sLk3ZZJSm/RK7J+5BdPT90FnPUIkLxA22jennQvNF/2XY4H3IixvtX4PUUrgTe8V2GfNdY79O2jJlsYccz/nZbdh5Th9xmBHJx1avpfIJUz5OM1QdKb4kqxK5j47WvXh2c2t+KC5xTTFxlvXMMfiUpLDEIlHTa7nsqoUByYT2CuRBAQdctgiLewTAjU513IRM/D3lC009vVzE7EJn1NRVA5+kpBtSqnNfRZ54yjfE5JY5PNiQcCPP5cWA4YHmK5a5Xszh5djt6FluHjO8G02GqQZEkqM3f757bh38b1cyRgA9BSoJweAxlwOI6mpYgGllInPnaXQKUMplRUEk6D1Vr+I0IgbITD3Vl+2sKeYBA+iKee5/nqT7d4saSL/925AezSDfcXPufbl3gSZcAUxie4kOW/FRhDSatwP3aKIZ8Lk+p2WtgIqRdLx6zl8t5VtwZAiouL6quMrrO11qgABw4Mtl8B3Xpdr30BkQKUU37a+kFLKXr7XLYmu5ZX28j3WkJUqpVqjaSzVmsztW6OUKjFukx6DHM8yl7YiWIsVBTk8KlyHi+QXcYDnfQCARwe8xuFnBK9r57CthWv5Xi4O1Exw2duJCOPrwSml4vx5uFV5CNj0mUHakoPPKmGoWaMkKr8AoZHXwVfNk/FnPPYRAFK+JwVXwVf7Aj6J/QUftnwIADhp9Ek4ZsQxOHP4DdjYzd/XLKENkK59fcb9OFyw1B+1eRUjM/wCIaUmHMmclMv4Y2bkVfK+rPrDrfNgf6Dle0u7luKmT2/CF0YHXQqW4Hdb5AEkvjhg8AE4deypzidtBrBBR2mrAHgjriqrUIDcB2ajEjENOfw1IOTQUBKAt+I/jtewWW06dvdHSg0XrXPiM+4B01Mqb5FS9nuSGhp/G06g2yBDWtN8V6YRlU5Db68s4U/H7ISjphQmkXeu2ZlrUz+teppjnxZGtbZ60BR0H3ALAKBUVU1lCwCrPIxVrDFqwsbFt2P2F3x5tKpEuLivKKCYyua+XBvS/o8hhyy10ieMWsoNaqoB2a6Z5mP7PUK3md33AByQfAn6ezdz+9CynmTw3wgO/gs8Ze9zz/dJNOnH30PsdxnONC7xFzBCZqEz96ObZxpbvscilU8hbsQlATUPWZRxythTeL8vW6nyLnUeINmFQ+MJTE6ncVF3r5kkrS7ymUopv6mUssaGyogP9qGCTd4CRCnV5qaUMozOl7b0IeY11Dpf/I+1QydRFlNSKpFLoGsjUf+cs+dQeGQRyR5r7PUih9lN1rg8Rl7l+MyCHlvbCDo3suPUip4VUDX3cutOSbSUUroOeLaukQ0AhwoXAB6c+1dngx4AdL6hiXCKRFY1z4uueVDiqcXTBz2NvesO5/ZjlVKpXN7qvgdg9KJrEdILrJ9t5Xshf+EqAoohZY246dCdcd8JkzjbkO3FtOppOHQY+T6f+P0465t7sSG6gSTgDeVhzBinw54wvDoQ0a3PdSil3r4W2LwYWMRck0yS0M1TipBSMnS7XzCA5hhJnC9L/hMRn4LigMciCl32dyilWAgC4HIt+1YShZOqazgk9iSzP3/eOsuagGOfxL/rLsALAZ70Duz/J2CvKwt/9k8MPwopddJJJ+GBBx5wbJ83bx5OPLGwp9HP+P8HbguIx7+zsiiZfAZZNcsx8AlRdATTgQd2cyql+jbBFYkOx6YMPGaw2FQu4++nk0At6JUhSAkEBt8FT9m7GFmfRnT4PBw95hB0HPkwNiUsozjR8BWBLqO5O4nOuDWRLdMb0YZSaKxSKlQJGF1oAi6kVJeh7kgyJF1A6kGd0OW6mOgw9hfYgW8ryvfsCCthU1ZOu47Uh0mQ25XiA0R6FBFVxflHPA9hxP4oEpjPbP7Y+ptKk9ksjGGuDDUHf89ynD/TGUwLAIYbKidWOqyrrORXg6iQTIeeL3b4Dumah5uITXjCzLcgqDMUB3mjht9udP7C4vXm39FUjpukvWLaLBXjPl/1m+byPkXCU7/YBRdvByHClu+1Jlrx2HePYd7X8xxkYU/GnRD6RW8fXtq0xSq6Y0vDbAs8FGgckdTI7252zxJy8JR8BkFKQQ5ZGc1EvjApJcKDnqQzq8Z6HQCwSKme9Ri65FaMETfg5L4YyvIqjm6pgaQSUlcQVQiGr8QQo9yTKqVeCIcQk0SMyORwiGJNzHk9/726j+xUsRNKvCWIZqN4d+O7rvtQD7auAh20gAGUUpoGxGjgSY61uIBSym6+2StJXLBpwha41AQsZY6llMrgG91auLbozix+SuQD7tJ2krHsliRkAa5lsuRizg4AQdEgvSUvLs/9Ah+q4/CZPMV1362Fm1Iqlo1Z/n0DoIhRv4Itk23+hNtvpK0TKDwhnDNrNLQM+Q3b9YUQBNVsgEFhmjnnNIge51wUVsJY+d0+uPsVBZc89xX3nL0rWTyTR5+hXCxmyEoBwO0dnQgxfoYZNcF5ewFAsp/r31RKMUbn8raS6AN0oLrny3tw/L+ORywbQyzvTrYeMvQQ/HGPP7qeV1PdaZTFO/wivRFAFF2TZgEf+S2+2EDmDX/dk/DXPwVvxdsFvZnY70MVOU+qc8iGwXs69h8uWDGIqZQy5qZUPmVZ6An8eWV9pLqNsUPL86TFdhkpu8An+xwL302M1+DqdAe6goQAK1M13ieHkumsJx7jKQUAaP2ae5j1V3BeSkU+xUoIGhgxbCU8FW8C0PDVxt6CTYyyXbsjuf6XANNZzE5KaZqOrKohBj4Bmlv3EffYPn56K9/kHlOT82qb8oK9Jo6a0oDqCHk8pZGcr5qiwveAxnwm2xmRopBSCgASRuIpQD0v033AU8cCXz9HHtv98zIxINmNgK7j0S3tOKsvapJSVREvMiYpRY7pG9TjlOwVZJsiOfyABJtSSs8H0VrAUyqazuGgexfg35uM+1BnfsPOleR7KAFT4fSm9zEEm/6C8pIeTGoo5kuTkcPIoDVG50VnXOf2W24P7ElAAJAFme+IzYAr39N1kyQZEF8/C9w1xrF5StUULDhuARTBNvaJOQAar7wRk/DWPA85ZCiHNI+ZiLXHWmzVQDyjmipCACiPfotwgVLqU3at5+LdoK+w3yqFIvlw4vTGbeqgOxB8Mn9PmZYJxva4cRxhw/5lKuPpFDBJqRxXLsnN9Qkrnva4DD2SrhOvYBflEwWdczRdZ5RS1j2U6SAJ1cumXlHwPcgB8NfyBys74DfuGQAYlWdiBFts97xnV6yP6njRdzjyMn+/BiMDJxp/SvjRjc7POussnHXWWRg3bhweeughiKKI3/zmN+a/n/H/J9yUUu80W+ZrGS1DFhQGaPeYvC2THrT7BQFbZWprfo4umwPGqFov9hpJFhYhrwyl+FNIvjZ4K9+CXPw5AGBNagn2/ef+aEktd7yXrinY0JW0DB4ZLO1hJOCRWsBfTP7MJCDYvgI1qw5JveY2r0RY9bSLkqCdKqVYA9StnRQZCIKAUi8JDqgvkElK2XyC6HE83pNFeXEjcMLTwJXNQLlBuLDlFXQCYLdRguq1S4AHdsOemfmuxxQxAnB2QqQkIkBUUqKPnG81XcMN/gCgJge7klIbe9NICvw1OMLIbncrxOvETkotb+1BXsvj4W8eRq+2ilt0Tpe+MTOqHHRlh7RfpQFwWk1zGRZ2EQGQzolu8Og6uCuCDcRtpTB2vxZzs+HN0awo+Negr7ists6UjibUXu51finA7Ce4klIONVuo2vShmLjxcdQK3TggkcR7G1swMSUSRZzxmYIRnA7LUlKKbG8z/q9NlEK6iF8gfR9IooQ96kkJDdu6mwX1S+rtp4y2X0+pZJehABWAUkIS7VTuvkDzO8r3RCRtncE8kgjBVr5X4Wsw/6YlJO3RNL7VLFIqAwUnZH+LP+aOM7f1KnwpREmW3JvdkujoqCcJfEBEETPulbDowbPqLJyc+y10I5DcXrglOmLZGNcqvj/3oghLzrL3wPOnc/sF7aVi/lIcMbkOFw3UhdfsMKaZJccs1nfm8OEqEhR/to4vSbUvuOPpPHo09xLgwbk83uhR8dtO8h4ZLWGUvlhwK9+j0I33ZZVS1UXbV25cCE8tfwpLu5bi8e8e59TQLPpdYFJ1p6E4Dgs29YKhhHVTSulKCzxl/8ETn5M5XA4RxYVc9CWmNDpVSA3hBlw4+UIAhJCiXh635o/HR1PvwQmxXzlew6rXiKeUznXfM0uYbYuJqMSSUmTs0PJBBJnuea4eW9uJqiDf1baF8bTsyfRgU4zML6WqypNSbuV7NkUhi9OzlyETqOKUkMUBLzeXA8DGzKfwls+HHPkGSzb2Fmwz72b2nrXdI/SesXeKTWfziGfy5j1m9+QDADDxBk021XDNMkgJJMWUxhJ8fNVsLL1+Xxw+icRM/3P6NEwfXIrnzt3VefyMUsqVlOqvrNtAIG/c0+/fBqx8E3jxLOML2hQYmaiz851BSlWGfabROS3f2yJE8IFGykA9sohS2nxCzMDf8Df4al7kv4saIMpxG7rjWSwwxrMWvczxPLospdO+gw6ytgs6FkdfxqRBJSgTrO/iE/NoUKxx2T7XADuOlKLjF7sGUUTF4V9J0StJpg+TV9eJp5eLesiBF39R8ClBEFDiC9m26YCQ465/b9Xr8BR/AUGi/kVepIwkht2rk42z4ukcPtNGYaFKOg2mxSAiBUipAyZUQFasudzvJe+j6zqu//h6zPt6nuM121tF0x/s60bTy8pYJ9BrImQk/W/q6MJJfVHsmUxhHFUQqzne4oUtnUyypJRzXFAFgVR1uIw/5uuMkvHepFVNwSqlsp1zEV91Ffau533Onv3Cluzy8uf+gflroKT7IBvHVa1vgEDVusY8UmGMUQ+tzWOvO+Zjc59TjRUI7ziS8L8BPwoptXTpUkyePBkVFRVYs2YN1qxZg4qKCkyePBlLly7F4sWLsXjxYixZsuTHOJyfsR0YqPteJp8x/aSCShA1IfcWuq5Lvr5+SClRNlVKAFl00Wwd2+mPeGhYg5IkWYN1oS4T0BVs6E64klKrY8wgFq4xgwJ/PoqwTXXeaQSjfsk6noYyMtikXBYTtDOLzpXvbZ83S8TLZ06pn4epyKkmpTCUlPIVWQtbKD7A7wzqkUsBnz0E3DGC36brwJePksdf/cP1eAI0GylZEyKbqRM9nZB8RPWjpeu5zGuw9wzkenZHyq7CAfDbf36DXo1fuI8USNDdIZFAXbSVAvemU/jr4r/jni/vgVT/F+65SdKKAt2Svj8hBZB29QIE5LQcVvdYhtobY/xE1p3utr8UgLsBsgn7orBAR7gcs4Do8SXhq7POGQ2IACCt8a+PMOUJui6gJ+G8fxzEoSgCLl4zAggpkMio0FR+DLGUUuT+oQGKqvY/1mwPdq11LjRYrFUU5AHTF8YNof6679FmDcEKYhQLoFR0z9I6y/ckR/leQ6nfsQCOSFbGjLblbo2msZLxlErDi4+0cXhUtToZxUW+21SpoSDYpChYaitXFEX3RaXZgZAhL+wl09sKtzklkUtAD1gLIrfW7hQyu5hz81kzoNjULfAXQxAEnDRh336PTxBySOdUZPIqBMPzjkU3cxsGbR5OdqVUTzKLKAovwIp7m0nTCQA5Lb7VSildF6Eb90vAK+GjK2fj/cv2Mj0Wtxb2jHYhLO1civXR9a7PBTtXF1RtmurOUJX788Y940bgdKrfwVv5NjJh2+I6H8LUxhLTt4XikX0eNUt2aRMTgKisT1hQgY82Oa9xtnxPFHR4kUOVRo45sfFTJAzjaIG5ljTwSik6duhqEOFtKQfaBtDSKQq2aQYALOsmiYcyVeVtEei4xd4zBcyOF2nD8Z42yTRGPmjIQWiKNGGX2hlm+Z4doncL1nYmsKWv1/3AXZQKTlKK/rb8tS6lu3DG3z/HMQ8SNbed1AeAW4stFQNNNtUwXTPtNhIAIRHY+2RUdQTPnLMrpjU5YyJWKcXGk8OKideh3TvSDX7q02ZvJGMvx0/1OOcZl/I9Oo8IDIHtkSxSylfzgkngsuCV6xZimTzeXEqIyi0upFS6dQVe/JKQnlXqTO65tze8gVG1MtcNOSzlUSn0mo8TLmNYSNkx9wkdv9j4StXVggQ6AGwxYm6vrpOk30DJ8bZvBzwOv70LLEjnOxZykD8nuuYx54s1HfzxsnFWIqMiDxkX5Ygpu0dLokR3TyJltSwkRnHjUXLAW7/Dyo/uwPMrn8czK55xvGZHkucUdlLKLHM11LRmXGFYkYR0HVd09+K+tg4rTlKzQJcVQ5teeKvfAZ49xdzsFjNrIN1R3UhxCpaME6hSnNtfgJ4vMucAisuftyVOGaVUXhfxybou5OLd5nglCFm857kE+wVWmIqsWmOMEo3qgdW9K2FH0LbG+6nj+0WVW4n33nvvx/iYn/EDohCL3hRpwvroeqTVtDkBhJQQqgJVWNXjnBBd0d9kECjjVCJZKNAML5DPWz/HlR9eibPHn20EF1aAGNPdfao4aAqau5JW1xEGPTozWUbqTGLMr8YQVnVEJWuCpSU/HtGaUFJaHI9GwvjMXzjY11nz6e2cEOyZpkERGyl1+hvQetYh8+8TAAC+Sadw+7saSm5YCHzCkzjQVeD1ywoeR5OheglJPgBpXjLOZDHl0EoIUga6pkDLVIA9Z2EMQytcCA8YPgd6ABAsEmeUSAKQNrESYwF4df51gpDHBxs/hhuygmAaouqabKqoztljSMHvuC0IKAEMLR6K1b2rMX/TfHM7zWRT9KeUKgh7+V6BLG1W5wMCgZH4CWIKQY+EIKrR3gABAABJREFUpNqLONZw2YmgbNXGa7ruXr7nVmIpeV2JqZCQQl8qh0A+YLaEBoChVCllBIcdSgSACqnOWV7zfVEX4iXQY8vG4tsuK8i8pbwUi3xeFLsYT1NE+ivf6zCk+OUMkZuynVtPGMjGHJn+XknEsTNGYn13Fu8Y5tqDSgPY2MmTgX5YZW20RXxbNIMcZHwz8wH0tW3Apq/JdrYcMC7yY0QJU5Z7QTW/yB0k8h0ErfcwTM4l65oKfF9SyqXMS9VVpHxhBAD8J+DHZZXOckQTVPWh6857onIsUVyt/9D5OmOBV+QtQkgJcc05OIhZdMQyyOQ1+F2UUj1x6zwmsiqyec30crIrpb7a2Aef3j/ZGjauvbyecHj2FVJKFQkjEKct4hUJtdvYkIHCTSklQEDIE+LUB9RPy/U9lr8GVD0OTD7F+SRdHIbdk1X9kVIUUmA915FSz0fQWBaArnsgwBp3FFjjVyy9FeoHFwSQxsniB/gzipHZ+BFiGUMhwRDFSUGwle+R+aSxqBJhT5jz3NxRqAoUIPUMrOgm41BpofK9AqpaFnFj3vAbpNQtM2+Bruv4bkvUoZSi8BcvBTQfFm1yz+pvi1LK7mcTTLdi6brNAEgs5aaUijOqEDqvV+Z5AvH7gCWl2pKWp1BVsIrr4loIXk2D7NYBEXAmmfos83YTVKnvU9BiI6VYb1VFElAW8kCQ4lAi7mpjvZ+kzytfkfF/M0tKjTsSWPoCfMktuPrZTzG6JoKvVsRxW3cn2iQJT1bWoVVNoijSZSql3g34sd6zCodp1txj7xCnCNIOK22l41dz1Lrmu9PdZmOZYlVFr8QnDjaX1ANqr0Vm9G60bAjcsPy1AY/DtQxayHKVAw7VreYx1ZyvfsWTzEkmuUE7KtLyVhE6qvUY6H0BAJ6cD1klTeJ/Zj1SlNsAfPE/0DwKUOc+Bm9tJ/ZtgZ2UMpOwRuMik5QK9DPPq1mg27JfMa0snjiS283NUyovCPAJ2f7L94w557cHjMJtC0iJnd1WBOA7WrqCIfnT8EDXgd6uNvj9GmIQ0SVJWF6cwIWpP2KhQM5BXT6Pr+A1fXbz8hYHKeNaDv8Txo9Wvvczfpo4YTQhO7Jq1gzuQ0oI1cGt8wVBPgtEjUHGLbvoL+UImywUaOl67N+0PwDgtbWv4ebPbjY8pSxlQnt2heOt1CTfFUjXFXy7OYqs6gxZejlSqtZcyIS0OIpt+/87GMCJNVVYV2T5jmxQe3BHWQk+CBReJHAD33ZOCHZSqiFMlFDUU+of617FUZ9ZZuu+8cfwb8Aqpyi2LHH/sM8fcmz6u9SE6eU74e528t1DRqaooYwMLfcdP4lT5chGoKRnagFInOF2SCG/sRvhEUvnuXp6AKgxCKqNOlmIK7bQs0jog9DB+8tQZAUro1qrH4pfTfoVHtrnIVx1wGjX/bcHO1UQSf37Gy0jVrtSqpCnVL+k1FYqpfbbqTDBJkgpVEZ88Fb9y/JYM+AVrWtW0wxZ89bgyIehFTs7ktHyKYlRxcmaaGaJ2mQJOoBsPem6duAu07fu87YBdoXB+RPPx7W7XotRpaPMbW+Fgmbpx6ExJ1ER6q98r8MojawcDXiM69S+77C9AQA+G/HVKcqY0lSBMbVWRqyhNOBQSn3XbC0Ii43SuTbDG0QecxDWDma7L1oLu16hmHufiFsJtYExkrsRPF18h5kgM+Tdtg5vdrBKqbAnDMnwG4p5AlijyLi4qgK5/ozU6XWfS/HeJwBwxptAvdMYmnywteC6eperC769IGbwyurXoZS/BSngTHKsaefJ2t6U9diulHpk4bp+lVIAEDbOS0LYguaKJXyb6AJKqd1rLQKXbfm9rfDKTrKhKljlaO1NMVZzzldZQQCW/Ys8WPcBSWLQUnBKhgRK3BMwRtKrv4VRyBOE18coS3URgiBAtJW5JrPW/cUqpbYFh/iWmORHUhCQMMgt1jQ6LopQmeuTNg645+jdC/5u3xf2ccwO2hGZKKWYucY0Ou/HrNcAXfSy15MgCKiK+Bzl9hSa3Alv5Zt4e4PTdB4AoDuv30yev0foPeNzMem/SH4Br3uuAuD0lAIs0hywlLeVjKeUvoMU0ABwxrgz4JN8uGTKJQ4SQixAHgd0HaBNTuym6HalVI9LQtWIP8fVRczuewFjvJC8HfBWvQSAnKeyoBeCXFghVEgpxYIjpYbNgWpcd6OFZixu7sV3G7Zg/0QSp0VjaDBIsqTeiTolhowAXFRVgSUlq9CmrgcAdOoRJGykVGgHqgnpeWDLR7tSXWaivDLvjClb/OTzvdSzp5C3LUXPevftQSux62ZzIkgZLga2Q9c82NyXwgH3fIjP1ndDEGB22k5xnlLk7wwUaIaP6qQcr7T35cnvcM3Ca6AK1npoS3YdOiXR8hc1UJ+zxs4fQyllkVLkt6f3bcjfT7dFNccrpTpWAu1OOxbZW+TYZimlCs8r9HufvcdQ/OEwI6noQqLblVIOMIkxD0jnyVy82ySPHy8K49ayUhxbXwkYFhbBLDlfgkLWAYLkLDcdqErpp4YfhZRKp9O4/fbbccABB2Dq1KmYPHky9+9n/PeCKhAyasZSSnlCqA1uZR1s30bLi6VsqPP5QBlX2qYZl+yV0680zRbbEm3I5FTXG5piuHwcks1n8hsNo3M39MJOShUDIAatpbY2rN96vfja178nhxtmDmfUG9tZz20fsCgplcwnkcwlcfOnN3OKNZ9dXlw0cAv5/jDFU4KH930EQ42Su6ARCHo9OSy/YT/sPbbE6hIFQFR6AQBSnnx30WORMkGPYSxrI6UyeRV5zTAsdMG6PJnQ7EvtUHgJ1hWYi14JBfG1Ubp09ozxOHvC2dilZpcBvu22gZJSrNkmm8kDCiulvP1wUk65f6/1NxMUT65zKc2ku0kplIdFs0tiavPR5nOyYAXamg50uyilAOC5LzZi5m3v4rvNxkJnzCFYdoxTSUE7bU3ULRWOVxNRZRi/pkQRUVFEwiC1S3zO4OL7osJfAYFZmJT5ynD0iKMxpow3Le0zsqm7pNJ4aa97MdNrkevh/pRSNEiqHGVK0x1EyRTSlcxna3ufE4GiYB4lAQXeqlfgrXwdg1xIqSVrZaipOtQE6tEYaURXPGOWHteV+OG1Leb+J78vvtBG4EMv753U3/LMHrRSmN4PDAlOGwJsL9hSBwGC2YkpJit4PrwVCxY1C+TSTpJW9hGPonCBxMgg6z4/aMhBeOKAJ7jFvpYnn60Uf4G/Lrse3nJ3c/yvN/ILDdYPxK2zWHQApVQRQ1Y2l67Dh4zKNlngvJwx+QAMqQhiSEWQ85TaVvgl52KqPlTPt2xnMMfjJEfSgmAlmB49GPhsHvDhn8hjeo48YYchLADTs5BVZNsTLiMqynHPKdZ8JQXX4Jy3z+GUuAAQZdRR0e1USv3C85apXOsTRYQzrQBUCEybdXtpadp4PLSspkAnru+PgUgpilJVA/pcPKXsKh0X0O53fhvJWRrwFFRKUTQXsGKwNxEACiulvC7k6jnyaxgjErLG50KqsyqcDQoZl5qYBbcLJ7ZNYJVSkyon4eMTPsZp405zKAzLfBaZw5amBTTdmrftajX7fM6qQigMpX5jWRBHTydxcm0+D2jkt/KUfgLJT3x3SoMeQHQqlin0fP+kVMgro1tiSIKqcYgWk3lynLgOLcs+wh7qp+bT1Ltrc3wzKsUYPvNZ45YcXQoAWKwNR8ze9GgHle4B7uXHWS1rqtpCLkTm5iRRMvqohUXnCmDlv8mc4oY+PqEIbwTY7VfA6ZbRvispJWa4hLkDmhcvLW7Bd1vIvbn7sHIMriDniCZodV1nSBEBOZn8dnVaHnWM3YVHc4+RP0+vxWF1NQ6P2wmD9jL//lFJKYOQ7DHirSK227kdatZSogNEKXW/LXG5+28gXLEOdqgAZKj9KqXYe1s0xik3pVTCrTqABXMfewQVPmThzfeZ5XtfuKwRfWlyn1FLE7fr5IdQsP3/jB+FlDrjjDNw2223obGxEQcddBAOPfRQ7t/P+O8FNdZO59Omx1PIE+IUCP2C1teHqkwJP4che7qqiEp9pXh4n4cBkDrlqoiv34HfqzYBuheCbg0MbgMPRY9dKRWpgyoHERZSqCxg5rmtGFfLTPzbOfDYpZ3l/nJzIlgX5Qdpr+R1ZvK2lZSynyPZB8iML1SWLNQSuQR8isSVfrCggVE+Og4AMKF8AvyGLwurlFrbEceUG4ihfqGW3quzZEKzh6pdwW7Tv8uO5yNhNCvk/Jf6+5kQvwd2qtzJsc3eDaZQm1lTKeWWTbQHtTQLPnQ2Ma+3v4cLBCmFxto2CGIOWi4CNWERworIklI6eguQUpc9/zU2dqdwxAMLzW0r22L4XCPZpjdVolQJCSTIG8x4V3k1AV7d8jdqlSXzt9hRbaJZKJLCLbCLjSDfvvClSqkSTcPQ8vEoZRYdBY3O01Gg9Rvyd+UY90U3AFSNAy5YBP+U01wOsBuKJw5P6UfwlH2AiiJgfAO5t4cGd0Zi7UWA7kFy/S9xUNldUCQFSzaSYxlaEUTEp8Ar8wHp9flTcVT29+jQnePq7zrdvcxoR6LX1J257ZSUiighHDuVEN8X7j3c/XtuJTw2co4u4uKiVMDvzQVblhAChGLGxcAFX5C/3fzyAGDo3tzDnSp24haTI8uI2k8pWuJ4qZZl3tM2f/Qy5sF2pRQARNE/KVWfz+O4qHVv/7mk2Pw76fJ7HD/sPIwsG4K3Lt4Db1w083u18XZTStWH6x3ekLvU7IKTRp+E/YqditKavOosxd9ilBDRLLI3ZJZucKCkFLMwYs8JQO7VTXFrfBPEHD7azHdmA4ipPMW2KqUocVifXYtyY2z6yudFtG4elNIF3L7NinPO9kpe+GX/DlWBsChEEtpRZus8h1Qv6VrlUl5tR5wqpWw+aaIoOLrv2dHc6+xSCcBBsANwKNQ5pdTMS6FBwlrNSSy7lu9RP0IAzTK5hhoZUur79i7RbKQGXSjayZAiRq1BE4TkmDWg5Utgwd1OxY2dlNrCd/Ikb2DFKFUlhPAs0TSUrj0VE8onku2N7yOn5VAalLlyMTv6K98DCKmle0L4W35/REceA1SPx+bASADAeGEdLlt/Dq5VrM7bdRly/JsTm1GKPrzPVAekk0R9tEBoxCc+/rfaUX5SQOFGDTQJGCxucjxHTbdLqEpnwV3AU8cA71zn2BeAU0kle4F9bgTKh5mbWBJGNtRMELMQxP6VUivbyPhYX+LHPcdNQsAgZmmCNpPXkGfI2KxsxRhn95K4KqhpkPtJZvZJEr7x8r/T2LrdrOP9AcgP+/1Bk7CqJ4g2SUK3JEHUdTQVNRV+k9ZvgE2f9/9B3hDg0qQmIsi4LX9cv55SqTzjr0p937ZHKWVLjoWRRECNmUqpPsl5fL50BXRdgKj0QZDi/ZOX/0fwo5BSr732Gl566SU88MAD+P3vf4/rrruO+/cz/ntBA0cdujnghJWwQ4FQEF1GVqiojlN54ND7gbPnA3te7pD7zxlNfBVoCUtftg9zxlSivrywc0AiSYIFifHZEVE4wOpjSy0itYAngOWDSEerYnvAZ8PIIicZ4QYfq3LaXlKKeQ+v5IUsyuY5WdiykNvXLYuzzaTUJTYjPpsnACWlaClnIVIKRhvzTMc+uGHGDfjL3n8xzOr5NrjPfLHRlC1LBUipdZkw8sL2Z3mKXGS/OwJNkSb33xwFzgUDk1AKlDmftAexNAvuL+UWfJ5+yrRqSnSUlBNCOJ8YwWfAmc58qg5Xo3Pu43Oa6d2ysi2Oc7K/wSOVV+KOPFFf0fI9thuS3ziVVYasfsvYQ8xr5YcqfWGbApQYZu72wLjXWNAUqxrgi8DDTJEeAEjZyJyP7wdubbB8DioYpZQdvmKgfBj8AadUPa11IcjEb14li50ayBjUFB4JLUPJARF3vrUGZz36Bb5sJuPtpEHku/gU9+m8y6Vc49hYHKf0OBcuVCnVrFch6bF8HuiiLxysxK1HjsdX1+2DcXXf774RbFlbUymVT7qSMK54ZF+gw1CphWuAudcDxcZisBDZ7KLIpaWDAFAdshb+us4fh840W6CB7pBy8vv2MA0z3JRSbIfFZ/NO3zQBwNVdPZjRcTIAYKVHMYl2u1LqmBHH4LczzgcAyJLoICS3FW5eKLXBWq4Mf0bdDDy0z0O4YucrEGTmjYCm4dS+KI6Mxcn9wZIGdKyi/3uC7qSt7iSlaIdJiqASxHdd3/X7PXK9kzgiqhAppblIZ2K6nyNwyw1SISGKSPl64at6g9t/veKcc0p9pRAEAUcOJ34no0t3XDk4ULiUw05WldnU3Ej3Fi49toF6SrmV0T19Vv9+f5rkrvx1I6UyuX6UUntfg2f2XoC3tSmO17kZnSeM+6NVlpAVBSi6bpaHk8/v97AHhF4gwWMnQ9gxrSZoEboBiKRsz054qDlrMRu0qeBYUp0dy5jPfPTUfXHrzJsBADFhOeY8Nwcvtf6e9/S0Q3Pe6yxKgx4EPDJuyJ+MdbvfDggCVkpkzJwmOm0xauPknG+Ob0aJ3osFfiu2oSWtrzQuxVsh/r7fUZ33gMKNGppjhJQKVU8s+NpSW0dLfPpX506a5mzI5GKbwHpkNUTI+CGISQhSP4lsxlv2/L2GGb8/n6C1+xltTFjrhcPjCRzTWoRHtrT1S0oBwH+C1rk539fEJQB/jO573elu6LqOc/PNmDOIVEs0aQL8/SUiKZE++uDC+2SdZM7kysm4+OT3ccbh+6OxxBrX7WMomyimDQu2y1Mqxx9DmRCDX0+5lhtTpPIl0LJknjtgah7BwMBJg586fhRSqq6uDuHwD7PQ+Bn/u2AnA+pjFFSCKPO7LKbd0GOoecI1ZrYUADDxBKB2EvmbGSw/++3eePBkEqjQRaama0ipCSiewtmIlk7FODbrOox4C2eM2BhmfouIL5t78Hr4KGi6gBIXD6oRGWvS+eW4X+PSXp4113IRTOjms35edvG6nRMCO7HTwbYuTAb7V9e8yu3rOnFz3fgGCBK8Rc6Ofbb3DBmLj1Q+BVVTC5JSGg2MdA8OG3YYin3FjokYAD5nWq0XIqU69Qgy8Lo12NkqFHl+GFJKFESzC5QdFf3V0GMgUspWrkQXG0aJKQ1uPcPmFnz/oD+Lb7tJRlZNDOO8Qj5da/3mmqajpbfwfUXx+jdbsLw1ilVtMXQjgtToo9Glk/szIGQgQcWQrEVu+YxTWV1GMrAtw/YyM1Y0UJrbSI5/UuWkAT9/a8Aqc2iwZL8n2owGBkWaCkgKPHYFSc96wCg7ROtS4N9XWc9F6om5tqfAuGIoCtnPpCWFF82/CH9ZZjUSkJQEMkYwFvE6Ccx3lrWZprQTG4oBoCAx0aU6X/+6ujOeE050bKfy/gwUXDHmRBw4YiK6RNEq3ysaBEEQvlepmBsEQTDVJfFc3LVc7TdTfoMbZtyAiCeCe9yGFbsCJ+BCSs36HeDy3my7eDaQVhNDkW4l7c99eh3AeikZ90xDKTnfbkqp4oD1O1UPnwzVW4T20qlYqI11+QIESp7c+7ogmOfDrvgciNTeVrgpDQJKgFtYlzBdOb0Ry59xRiqNS7t7YX7TBKOWoS3Z6TzgCRUo3yP3FKeUssUQOnRHosV8TvMg1XIM0m2HcYsHSpYHbKqfvEvoGxZSXBfMslonIcJipcd5D5QYZShTq6fi5UNfxt/3+3u/77GtmFo1FaNLR2O/pv2434pV5cgQHb6XSPc5Gy9QHHgnMGSW+ZB6N/o9zvGkobh/VbHg0hAAAPLRCY5thZRStAzZF4qg00Xl6e4pRV6zwSAKB+VyXLF/IVJpa3HOTucAAA4ewi+M7WQuWyLOLvhLCinccklrMWsvNx65v/U3S0oxyvSmyhLUh+vN5Ep3uhurY4u5MlOKI4cfiRMaboHbso/tHloW9JjnPmEkCL/MNZHPE9scr63Lkdh3c6wFGSTQwigIaUfKvOw8nh2pJhxQKeUJFdynJGyzGhFl0mmPvWYSHYQcYRPnqpNoYrsw1ocIcX/gpP7HalZ9ONQo2/MbpfE0FrardKjvGwCoohfDYuUYk81BGeAyX2oopaan0jhv8CHcvPdjle/N3zgfn6i95rbRuuJYR7jC3qTJ/JBSYNJJ3Kadq3fGo/s/iopQNY7feRDev2yO+VyJrVSQxp1PL38af1lCGjxVufAVjyxwlgdyOPrv3MMGoR2AFevaIes6ulAELU3Wa77QZoyp+79VqueGH4WU+tOf/oQrrrgCGzZsRUe0n/FfBY/oMSfi3kwvAPeAuVRVcWt7p/MN4sYk5y/muuxxCwdGRVQZ8ZllClQqD5ASvl5DMXLHnnfgkKGHYM96K6vXFSeDenmg2NxW4reC47Igr/j5UhuODr0IX2gjcNrjX+GI+z/Ct70ybsif5Nqh64isNaAPXvU8Tu3pxi4Za5GSj49GXZSf/HzK91dKcaSU8X50EW9v3e3aGYTteiH1cwxKADjBaCMbYb4HXbRXkTK84FBr8E/kE4VJKdV5LH6Fn4jTORXftJAg94PLZsEnOWdcVReQgQcpKNtPSv1ASikAGFrs4pMGpwoAAGYkLfLH7AjDmGianatiWyzvlu51wBrD84aWVl74JXDhEggVhcurotkokkYwrOdDQAG/LlXTsaJt4I5NV7zwDfa7+0O8s4xMxOPripBgAqcg0hjCeB8EKCnlJcH6qj7LYJsGq9fvdj2u2eUa3D3r7gE/f2vABqU0o91nN501QBd1lU3WYg1KwOgEYxwrLbOomQgcdBdw1CPGfrZFd81E4JjHzIfs+MiSlm0pKxOriymTlCryWePEMVMthcrGbsOryySl+Ol8RJVB8uQl4uXDIKH7EPE6idGsMbamdQ/m9/0TzbluPBsJWUbn9mz+DoKu66ZC7o+f/ZFb2ADAcSOPw+njTsdhww7DguMWYLbk4tljV6jZlVLnfQTscanr57NKKfb8aNkK5HpmINVyPCZ7fwOdURFCl1Ee8qLEIJ7cPKXYeWXOlFGQLluFb2b9He9pE5Er0PzYw5QdvRUMYLHX42inXkgZsL1wK99rjDTypBQTzHuYhgayfcFPlWuAlcGmSilv2L0keRei+mI9k+xlvAtaFjjKnym0bAny0cmA5uU67vUZROGURv5aUJnxrk0vBgDkdInrWlkSGcSRDHa8GXKSa+wxDykessM7JymSgmcPfha373k7RxI2RqzzMbd4pPPKSvUWJqXGHw3s/AvzIV3w2j2lgIE7Qdk7i2U6ZiO++nJoGafHqMNTKsd7SoW8CjqMc8PC50IwURPtzw3flsZcHjjuH+bz+nZHBwRHjzgaLx/6Mv4w4w/cdrf7hoKNzYbXFGi6kEtb9wbbmdJfQuYN9jEFGyvKXgiCgCHFfPJLUJzl2QcMPgBjSt0TPDVM105WqUPLx76JBgt64pmeUonN+NbLx9E9koRdM3e6vi4o/3BKKbMbn6GUCspBPHnAkzhqxFG4fNrl3L6lkSb+zbQ88MBuwMsXAPEO4P3bgRajJLxQ91ADSUYtQ8eC8uIBknqMCffQSjI2mr+/ETPZVToxpuIjp4SRNqo+Qjqvaj+r1z2+8eo6ULOTVWKIH4+UuuvLu7htowW/tY7oD+EqUi7JVmdMPRO4bA1QOpjbtVDDAcCpjk8ZzThu+vQmc9sRE5scr1ve6oyD8yyxPvZwHF70DJZq5LUNAknOyIzaWmT83Ly6jrhYDDVFEgrf9LxvdU3/P4wfhZSaOnUq0uk0hgwZgnA4jNLSUu7fz/jvhSAI5gRACQg6QZyeJwPSMdEY5je34MCES0AZN7Kq3iKelGLRj4qIGop2pbpMT6vp1dNx0+434e5Zd6M4tzeSG09h9reCxtKANcnaW2kn4cPumXtwTPZac9vq9jj+R90PmyoOMbflu+YgufE0jC2yCICSL+YBAEKV46031BTkVX4w9LKL1x3gKUUngELKEtfsOpuBLzSQD90buGoT0LgreexGSp30ArDPTfAc+CdzckvmkuY1odvUGlreeSxWIEQm4MXNvcipOqoiXjSU+pH2O9thS4LRsUpToPfXqasfsGVdOxrDi92JIbth7UlZCZd095qPzfa2QYa8YtsV3zuVdFf660wrYDJ8kuANOyZpCp9AgttoNmpJlR318zrycaJgSnbu6lg8bA3G1kaQhYKssYgPIs17fBhO7tVGBpm21fbLftPbIOwJ45iRx2y1j8pAcJOnu/koyLqOoPH7HzfuNMysm4lrdrkGqCC/idlpr9MoZa2fCkw9AxhkmG/alVK7/xoYY3knsgG0fTFBoSJuklKlfuv9jpxcj50H87/HcIN8Yg2CD59Uh3uOI+NAJq8BdZO4YC4JL0eMlhulLtRTKsksa7OCgFWGKsSNTN1RoGRkV7rLVDz8qSuGm3e/GRdPudjcTxAEYjJrh33RbfeUCte4qqQA0o0RAA4bdpiNlCoFICAf3QkhqYpbQFy27yg8ePJkFAfI78p238sYqo+ykBVs1xb5ANmL4kgIUYSwn/dxvDv9EcexyGoGskaO83cVZTilthpx29i8o5VSbMKiMdKI83Y6D3vW78mRUux9KBdbSilHyUjLIutvukijXfgUP1GABMrIguLydcD5n5C28wAGMQos+yKJZrT3bdrXcfwjqiI4egohbGPMAm7RBnJN7DGcJ2BZQvCE7NX4UhuGs/OXIM2U0kiRWoSk/hX+ko0g2ZEL7YFQxPg7Dgpbv9txTEdGE4WUUpKHzBcM6UGNzj0u5XtupNSUqik4Z8I5BY5SgJ5zH78d3ffyfPe9oFdCJ5wJo4Cr0bmARyNhPFxM9m/M5YFRBxQ4pm0HJX7s84VdfcMmoVhSasTQfYEz3iLeqSxySUv5XMVYXsy+hm+UwY13zBhmzGl2RXZ5idOrMqAEuOYUrAcdG/+WhvjyMV3X0dyTQqvurpKryqsQISCr5RzdprtFEZ0uXjoAECzkvbgdsCdcqXKQjhlBTxAjS0fiul2vc/jdlpa4Jw6x5AngjmHAezcCrxnJjAHsLqhtBWDdK5sTJIFYuEmBoc72K2YSw+6vGreVIcfBklIRZAydai2se/zIWBy7pNy9xby6DlSN/dGVUgCwrm8dR/UPlUMOGxBXeMPEWJ7xTYXs49cwBtgkkx1224BUPoX2ZDu3bVN8gE6MBuzl4T15rzl+UqWUwKirpcxI69B1HQmlBLm+SdDyQWxJbTA/d1zZuK36/J8ifhRS6vjjj0dLSwtuvvlm3Hvvvbjrrru4fz/jvxu0jpoaFdMymV/t9wDm9am4rLu3cL4xYQwG3jBfvseiH8KG+kptiBIVniiIZoZCFmWM850MNW5N9iwBUR60SKLjdm7AqGo+AM3AY3b7A4BNPSkAAvxjjjO3pbunQY2PwvC66WjI5TAkm0NYzQPD5iJYbg1Auu5BRuXf38tmjHdA9z06CdKub3YMmF2vdSezkE3wJoJVTOkJPWfhamC3CwB/iWVYnI2bpJSW4wMaN6VU0EvOc9QY6L/e1AsAmNpIfDrqT7gPy/xTcFr2MkeAlNK3v3yvkKx7R6AQ6WBf3Hs8QfgYUtbrVr7HklK5BPDxfVZZDGCV7/WDmiCRCue1vKUScqmfT208BfFVV0JNkoAt7N160rQs6DEX41QtFRRSnINbn6F6qzbKGGmHyB/C5Jxi5+qdHdtOGn0SpgcHcduKVA3CMKL4CygB3D/nfhwz8higwvCHoZ32KCnF3OcAnIodWxaQ7XRWqLwzlosia5QHFDPk+fCqMKoj1r1TFfGaZXusUirsk83HmbwKnPQicKnlB5eCDzUha6FOjZEpKdWrWGPx/IAf3ZKEUlXElKr+S5q+D/YetLdjW2WoFgcPPdjpP+LWFIOqBynsxFU/5SLTa6bjnaPewfW7Xc93Bcxb958ogCOlfjlrGKY0lpqljD3JnFkmlDZUHyVM+R5d+FWGyfWwMS4gqlrPd/qayB+5FDwaH5qtt5WK/ZDlewcOORDnTzwfgiCgivFb4bzeQtYCS7KPvGvnW39TFQg1kJV9wC7nAZevBQ66k5S7Vo42ycLGsKX48RRYqLg1UUmrSYR85NzQhUIym8enRvn3rFH8gvDs3G8Q1324LHc21uh1OCL7B6wr3g1JMPNSuAaVQVtJlQ17JlNmswZgx/rkDAQa+wCEDDl4yME4esTRmFTuLJUjnlIupFSgnPz2DClFF7xuKjG3hWtQCRbsNpjrK1x6bfddsyulwl7FtUmDm9F5nyji0SJyfQY0DQcmCndi3pGwkyGXTr0Uhw49FI/s+wh3j44sGUmSFiNshGouZd0jDdOBM98BLl4KTDuT+E1RFPLYM+7boUU8sVJbTt6T6wCoBMwYCwDnCVhbZH2PMsNTCiBKqfdXdqA7kUWn4E4uKgCqDAuEt4NkrpqcJvd7jySjocr92Heo0bltjmXLWe2fxcZesiAjUuI+B3OgnpFF9cB+t5K/Z17i2I1VSlGCujVBuvzZGzfYMawyZBImdiuLbsavELCIYwBIhxpMUqoc1ucHNM2cz+3wlo8APMEfXClV6D0fbTwKl3f14LBYHLt4K7dOKUUrGtgO4gWIzf6UUnYk80lHw4w5jXMK7M3D3t01lVPNhiaDXEgpOW3FT1lBQEopBrQAsp2zufe5YcYNOGjIQfjbPn/b6u/xU8GPQkp99NFHeO6553DFFVfgtNNOw6mnnsr9+xn/HZgziNyo1cFqVPgr8ODcBwFYEzMlIGgwqdRNwa7nfuEqtzYRN0gpX8T0lXCgH1KKll5RUqrIU8Sx/xVhfrALMSqGypA1UQ0qDeDNi/fALkP6V2X4FBENJVZwrqsBhH0yAvWT8fKmLXiuZQu5qWZdxS2w546qx/4TR2AQoxbxsZPyDijfo5NgUAmaail2EelavgeQDN60XwB7MyacbKZBti0O2MmYJUpsx3TXl3fhxk9vBABouWJuHzXvPJbGMnJu1naQbNOGbjLBDjHq7Mvrh2H0Fe+io3pPnJm9FHHdh8dDZwAA0nCf/N7c2GKqQP43MDhiKZbY37/CZnbtVcJcsO1xU0oV8+QJvrCpLNwW6jaMLK83AxEzq6e7XXsS9Hyx+WjioGKXfdzB3nMJY5EXAp+x6xXIOak2soe0LOeHaqUOAGeOPxO/mvQrPH/w8+a2El8JHj78JQzzWIuy4pIhwPHPON+g0lgMU6UUbVNcblPD2UkpqTChUIiUimajZieYoOLHC+fthmfO3gWlQQ+qmQVEfYn1WazRecgrw2cs7jJ5jRwDs/BM6l40RKwFN73eqNF5n2wFwas95P7fRy3+QQJXitmDZuOiyRdx2wL73Oi+s31MAgDNZshvX8i5vYZBVbAKoiBy56c2VGf+fe5eQyG4lNxR4mnZlihm3Poufv/Kt6YKhJ36KBlVXeSDKBBPnXUxa5xdoZMsvB8ZeAZg2He4UopJWLDea6w6Kst2nWXmWEdVNUdKxcmPkDcMXAdYfPSnlKJwa4QQz8VN4pyqCj5e04VsXkN9id/0aqH4RBuDCZmH8Zy6l7ltWGUYHHUerka5iy/ZYMYbb3I6w3U53dHlev2BJaX8sh83z7wZ1+56LQS35EQmSsq+AUtRC1hJD0ZVmNS3LUkTlIOOZMLE4AmIr7wGeq4cl+4zAncfO9HxOrsC100p5Va+53exT4hKEjpkGaWqigUbNmGkcY6GFZPOaDNqZ2zTd9pasPGXAAEV/grcuPuNmFY9DT0ZiwQ0r+s51wODGSUbS0p5gkDDNKtRg0tDBvJBTqWUvUsmLVurDVmq9oAcQNBr3bfjaq25tqbIGk9KAh5GqZPH/e+RZkTBcp7oYVFj3JPdhipqRpLMXb2yhIv2cS95K0Q6bw8KKaUoWIsGlpQq8ZVA8BQYS8uGObeFa4Dp5wIXLiFqNhuOG0US1nvU72FeG5SUingj3D1rB+1qC5ASSgDoiJFxc10XT7KySql0uAkZQ+3OjkVBTceETBaCrnNNZgDAW09U3ZxS6gcwOmdVSbfOvBW37XEb3j7qbUwqHoGTozHc0NkN2Rt2V0rtwZdZwsusl/a/HaibSs6FC/ojpexku6qr+HDThwCAs8afhWcPehb7NO4zwDcjiKb43zWVVU1PviaJVAFtYbw+03Hrnk4LArJeMv6qSb6yoTHSiFtm3oKda5yJ1J86fhRSatSoUUilBjbL/Rn/f+Om3W/CvbPvxauHvYp3j3kXu9WSdqI0S0GVUpzyRLEN+PagjXYO84YLT8L9DJZ0slnVS5QWxWzABaAixAdYQYVRGYSsQKoyTLYrknVLlAadA2XYp2BM+Qho2TJSC6wrmD64FELtRCgwOnTt9iugbgoXsOw2pBYHTRuB33ZZgUpwK0iEgcAGwezff5z5R9y/9/04eczJ5raCSqlB04ED7+CNNr0h4LC/AqVDgP1v4/f3hknZxeHzgAnHOt6OluF8sOkDc1uDzUxS1J2BwIgqcj5WtsWhaTo2GqTUoFL+mjlxeiO+1QfjtKoXMb/8BABE1ea2jqvKq/12v5D7kfnuCDREGnD5tMtx7a7Xch0p7UbnHm8EPrdueaznV4jP9juMNreiDLHYW+woV9y5iS8p0PLO99mpvnjA96ZIMN0TaSenoEDG/6s6uyHoOq5NksCgOsgHrDsye2qHV/Li7AlnY2SpTdkkKQgWWYvhsmCVu78aVUqtXwg8sDvQbXQOrbC9n718z6bEY+/D4SXu5Z296V5TKeWVvJjSWILpQ0gAU8mQfvUl1n3EGp2HfYqplMrmNWi2aysBL2qKrN+aNiPLGP9nPTYzfQD7TfnhE0h2UjJQNsJ9x81LrL+nEmIaE45z3XVbkWeSI9UBa9waWhHCgeMGOfan5XuLm3uxuS+Nv3+03lRKUaIdIF3yADLHULXbwt4SXJo7B8dnr0ZLgpw/P7Lwav2XIv+QSimWDGKD+0Kd5GQ68laMcnTKhZolpWO0fG+A42a7/dFuvna4zWOxbAxhH/ls6ilFu1POHF4OQRBw+1G8gkizhb9jaiPIsqXM4RqoujOhsVPG6pA0PpPlxu3/LVKK+03scQWNQ969gfzP+uIEKSnlJN8Uyf0aPGToIdzjgBJwkFK7Dm6AbnT9LA54uLiK4tN13bj46cVYsIr4qDg8pXwyeuCcD9grzCvw4/RB8QT3/ANzHsAFEy/AzUaHuh0N9nr1yT5uEc7eU2bZX6AUOPUVS12bS/KkFIuRBxAPndNet30qc16Mz7MrWGnZGpv8CipBTik1nlFK1RQzSqmQBwHjHGyJpvHZeqI2HDq0sEdlXety7vHOhlKqRRLRlnE3iN4WNctAsBPYLBkH8PdKSLFMz+2m1xwOuguYwSdJ4Csmv3npYNdS8ONGHofH9n8Md+x5hzkW0ORfma+soBXBiKoQjppilQYOKSfXfXN3Etm8hg2dJBauM9S2rFIqVzTYVEopHCmloVjTML+5Ba9u2gyJ7SRskEBsOaqblcGOwD2z7sGVO1+JA4cciP0H70/uGZZg8gT533LobODYJ3jzcsnLJzSmnw384j/W+GWAkpMz6vonoceW8Y1GPtnyCQBgWvU0jC4bXfDaPC97EWK6H6dlSVMaV6WUcW7qYAgumDklkba+py4IyBuVLlqWXw/8EAThfwt+FFLq1ltvxSWXXIL58+ejq6sL0WiU+/cz/jsQUALYq2GvgqaCdqUUAOfAffzT7qy4NwLsewsw7ijg1H/xz+31W/L/lNMdL6Ok1PyN8wE4A2e7UirgsR6znlJ0occGT7NHVWKvkfxgEfLKqC0KobLvGiTXnwcA2GVIGSEMDrqbMPhzSfDHBmp+2Q94QpiRSuOGji5cOeIElLPZrX6Ik/7g1n0PIJmzmfUzuazygAsZlkCUvMDE44ELF5PyCjsCpcBOx7p2GmOPoynShBm1M3DvwbznxEMn746gR8I9x0209i0LwCOJSOVUbOpJobkAKXXctAY8d+6uePTM6WbpTFp3J6Vk8C2kA0yWdVYiiZf2fczlVTsWJ485GUePONrM2gIuSilfEaco1GngyWa9gxXA4Q+SDNKYw5wfZO8+BuDyaZdzZFhACTgW/lMayLGkNp2IXHQssl2zYAf1LbKjqcx5/n93oPV5NKMXAgmST4jF8fGGTZgbI+N+RbC6YMeiHxNsJ6DqQiU7DdOI71qiHWj7xtpuNz+1l/DY1CFsAF0ZqMSzBz3rCAj7sn2m55c9o8wqpRoYpZSXUUqFfTLnMfXdlig+XGV1RVul16Mi5DVLofaLk3uNKqWa6pzj0aBR/bRk3k7QDounjT0NgJOULLjIn2yQ7cP3IfPGcU8RYt2BbfeZo11kAeD03cjicSfDTL4i6FxUsB32KKhSatbISlx70Bg8ffYu3PNU4baiLYbn1T3xsTbWNNn2CRn4fmSlFHv92QPilw99GXftdRemVk91fa3ClhpXu3hhJDq2WinFHseWxBbXfdzMpU8dc6pZvkdNgXsM4/kqgwA8emoDXr1g94KffdL0QZhcw3z3YDlHUFJEmDlkdDbLqxN+RE8pu1LKRKDcIsKH7g0c/gD/Qjb5RJMessdMGE6fPgOzRlZgapP7Avqm3W/C0wc9bT4OKkFHJ7XBpWWYM7oKHlnEniMqChJcLy3ZjJP+9ik+X9/tUEqFvDJ0lyUK+05BW4JlXIZP1FQHq3HOTufsMF9CO2iHNcB5T5485mTs1bAX7t7rbucLaayVS1meUvbyYkEgCc6mgVVe5f5yvHXkWzh06KHc9lKv9b39st9UzwLA2FqGlGLmlNKg1ywf+2I9IXYbSv0I9aOUqmWUOMV5jXh6AcgLAu5dfK/53B71e5h/iztw+Wn3CbIrklillCAIZildv9dFoBxotP32A1gkSKKESZWT4Jf9XOkzAEyomIBLpjpL/t64aCZe/dXuEBmPr6qIF0GPBFXT0dydNJVSNAnFdt8TyociYyg82Sg4YIxLpZoGrw74mXUbJW9Y76UfSgU9e9BsnDja1unXYyOlWNROAkYfzK8TXWJbN7xy2Cv448w/4pgRxxTcRxAE/HXOX/HnWX82yadoNgoBAia4lT4zeEObjgmZhzBfI5UoL37ZgrZoGk98sgEdsQxyqo5enXw3H8hYNLWrFvnYKCTXnwvVlhw043yHr+v/Xfwo/Qf3228/AMDee/OeEbquQxAEqKozG/Uz/ntASSmaEehXljtkT2Ka/czJwKp/M28SBkIVwFEuNbQN04i5nYsSpMhjTTZ+2e8o/2BJKY8swscGtMw8RhcWbPAU8sq44+idMOuO+VjXmTC3CYKAk3YZghv+9R0Ag5QCgKk8acYSRj7JZw6sh8UTQNOB/KC7naSUm6cUCzZYHJiU+v7dAAF+cvvL3n/hSjIoZo2swje/35ebiGVJxNDKEJZtieK7LX1o6SFExiAb8SGKAqYZAXPEIKVS8KLQL8iSPSWqhqRR1nNYPIHG0gJKjB8Aw0osUqrSz6uevL4SyABmJ5LoKhuMwTnDzJGdjIMVQCNRJ2LFm8B3L5G/xx1JMq91Tr+fk8ecjBNGnYCJj08EQLKT9oW/31AP5mPjkY+Nt78FACcxSFEc8ABdhNCoCHvxj1/sgmGV1vsndPLeYcFSygZ13fQ3UbxhVPgr0J4iWaUd2SZ6W8D+JgVJKX8J8f1o/tjaNuMiJ/HuUEoVDjj8sh+jy0ZjfPl4LG5fbG7vy/SZSil7EoD1lGKVUuyCw6dInMfUQfcuAADsJv4Wo4SN+ECbgOsrQ3hi5BOIrl+AZc8TxWHa+C6ZkAj0Wp+piArK/P17YmwPbpl5C04ZcwrGl5Przk5KsuMbh11/RZRrw+cSomPUge77SR7SynsbwJK2+46txku/nGGWf509/mwsaV+Cg4daBN30wWWoinjRFiWfIwiWp5RXkXDG7s6mA3UlfmA9b5SaNkgpP7LuqkkGO7r7Hgv74mRI8ZCC3ngAzAUoPCFDpbOY3yHeDuQZo/OtRMQTwS0zb8FVH17FbWc92QCihtm5eme89S1R3NDfNGp03qOJC6DwOAYQU/rKiApQ7laUXDuzepn5xK/r3Pzyv+UpxV0PngBw2r+ISq1xBrkgg5WWfyenlGKUuJeuBHJpXBHiEyZusMcd9pLKoBLEX06chHRWQ1FAweoOp/KSxaq2OKOUIuOWX5EgDsApy4KMgBwwy7/rc04S8YdEdciaKxI5vsSq1FeKe2ffa38JAb0P8qnCSqltRE2oxqG8nVo9Fa+ufRWlvlLIoozaIgmzR1Ui4pNRHrbiT3ZOKQ144Dc8pWijgLE1RXyDGxvqGFKqKidxxC3FmePOxMVTLsb4R8lYbyeSdiTs8wi7TgAIibc5sXkAUqqUqDxZbEN1wy7VfCJiYuVEjC0bi9Ku32Nz9mv4al7EqNJRGF3jXNcIgoDBFUEsbYlibUcc6431B413k7p1vgaPGI9ZY1cCK/nyvYDtHPiUAOLGfeKmlPohS/MdYONae8xHxzJ2fbSV90ZNqMZRyuqGYl8xZg2ahZASMit8hhYP5eLPSYOKsbi5F6Oqw1znPZYof+HLTXjhy03m3wCwXufjx+5sE1Kb5roeB1ve75f9psLx/zJ+FFLqvffeK/jc4sWLCz73M/47YDeKHtA4WvY6M6YDDfYFnmeDxsOHHe6Q7Y5h6uazeY07NkpseGTRnCBZpRTtPkOzRgDMmvyjp9bjkQXrEPLKrpMKwC90/bKfH4glD28eXsjkfQBw5XsuCzj2GAZcyLCLZ/bYthHropZc217bz0J0iThHVhFS6v2VHchrOjyyiKpw4eM2lVJQMCGTxXzDaPPYaAxzE0l0o4jzairSVLQYw15Y07bOYHEHgfUPKvIWIaSETCJXMTw97mnvBPa6E1hmdIyUvGSSzqcJKUUxbG+yuIi3E2+DAt32AN43QIDAGTkDQGArForsYi7ik00z+giz4Cv2KxwhBQBxw1OqDAUUsbIP1cFqk5T6IT2l+gN7n9QE+wlqGnezSKkLl7j/7g5PKXsJsRVg0UDQTij3ZfrM7nt2kr+KWUDUceV71tilSAJkUYAoACy/8ZE2Dh9hHP5++jQMLifHUVG9E9ZSTylfEbDHKWhJfM19ZnWweoeWW5jHLHkxsXKi+ZhdTIiCWHguUXzA6IMG/gBJ2WZS6oxxZ2BTfJOpOphoqKQAEsw+deBT3P5+j4RXL9gdFz29BB+v7YKuExk/wJ8TFnXFznsuZXR+8yPjUrTEY0crpVjY59BCmDd3Hj5e+waOWncP2eANuZNOsS1brZQCgEf2fQRPfPcELp16KWpCNagP1ePkNwqXoe9eR9RPIS9vdN5nkFIRnzVGsWpCOyRRANL8OHXZtMvQEtuIWRsW461gAKf0xTAnkcRaRcGhcbJQ9PxvkVKMVYFj7m+weZFUjGRIKRelFEDik61UJLCfF5SdSqkibxG8smSWFHtcyvdYdMYzjFKKvEYQBFf1cwZ8YlGRFMDgRExy5Acuy6dgF/KZbRln6H2S7rPK8LeWlKqbXPApO8lS4a/AwuMXmscpCAIeOW0aACIK2H1YOTyyiAZmfme771GMrY0AYRcSKVAOJDs5z6JI1g+3X99+bG5G+jsK9jjCrpyiCRbzmGZeCnxoU9r6SwFvJ7/NZg/SH4p9xRxhOqKEJEB9QgVyvVOhZcvwt+NPK/j6IeUhLG2JYunmKNoNb6kzZgzG29+1YVAwDxiVY0LxIOw9vglYCSjMDUM7CGPyqcDwufAvsxSTdF79MZRSruiXlDLub3Y9sgPLotmEcEAJmKQUG4cAwN9OnYZ3l7djVHXYTOr1h8XNvQCA1ajjtq/RC8+nGjN3NEWasKx72YCf81PHj0JK7bkn36K2r68PTz75JB5++GF89dVXuPjii3+Mw/gZPxDsCweHUkoQnUoge/C6lcGQHWyAuv/g/R3P1xT5sfPgUnxmdOHhTIYrQnj9wplcxogNnujfbBvdkJcMlBGfgv9csidEQeBa67JgAzWf7OMHX7tXRT9ZqP7AqbFcSCf2GFgD2wHxPRagMaYj3LZmw0bVRIAlm/GPzzYCABpK/K7kFQVVuKV1D07ti0KGjt2TaQw3DOWXK0Ph16x2ryWqdR0GNa1gi/gfAmy76JAnhFJfqUlKedkue0z2Ff4SYM8rgN4NvPGmpACnvQYku/olpOywGzmLggifPHAwwvqrVUZ8iKapKlLA1QeMxu1vrcDNRzhVVtT7oFrodn9jJcCVCxUy/v6hsVVKKQCYeCLw8f3Eh63Q726X+NvGwyHFQ3DGuDNQ7i+3uu3IhUkpr8iPr5UR6zGnBGXGLq9BtPsUyezgQ6FIAvYcwRCcgTJT/ZGRPcDs36H9Wb6Es1+ibgeCJaUCcuD7Z9O3w5uh2FeMO/e6c5teUxnx4X9On4ZR17wJAOhNGio3xX1xzCrcKKjJ9rQ6L77xSAD483bUiKPw/Epi0v9DkFL3zLoHq3pWYdeaXbdq/11rd8Wu4SHAOwYppQSIusCOrjV8970BMK16GqZVTzMf2+OJQkQl9ZSi5XtuSqlCJKGJSA3QYj1sjDTin4e9DPy+CBf2WKqJu9uNxaqo8MqpbVCCfV+w6qSCTUwoykcA6z80Xsjcy27nayvAfk9FUhzKlOHFvGJHHkDy1BHLmHEUSxzqOnB89mocJ72HQyXSIWu5PBJUxilAQDRjEYklVB3yAxDoOxR0kZ1gSI+tJTSrxhKfKZeY0d7Vt7/OiIIg4ImzppuPnzl7F2g6IXftpNS4uiIg7EKVh2uAZCfqmGYySpYkiq/o6sEDZWWIGhp2SgSNLh2NZd3LsG/Tvs732wHwST7ON1OA4Lg+GyOky2d92Ci/nHU1MP5o4H7r94DsIQ2YuDffNh/YPer3wJvr34QkSCbpI0sCABFqcmi/STja4Oe95SR+LQko2HVoGd75zZ6o7ZSBZx8mO4qSSeR4bJ5SAID9bgE8QfhX/d187n9dKcWV7xn3wpC9SJOM8UeTx+y4vwOSx/fOvhdPLHsCV+9ytbmNnUftXctLgx4cNaUenfFtS2q1yvXc49VaHRRJQE4l50aEAM2g21ml1I2734jz3j4P5+zEW538X8OPQkpRvPvuu3jkkUfw4osvorGxEUceeST+9rf/ey0Pf2qwezw4yA9BcpJS9kFmK0ya3cAO6vZBheL+Eyfj/Ce+xF6jKnDYsBo8t+I50wiPVVIBBZRSTMeSkJcvkekPDqUUG7DSDOXpbxLPjUIm7wOAXcy6ZZ7YY3AzbS2I71G+94cZf8C1C6/FH2f+cZtfe8SkOtzzzipTadBfuQVgqUbS8MAD4PS+GPd83FMJv95mPi5mJM3hAUpkdjTK/eW4deatECDAK3lR5i8zu+R4WRWULwIc/GeS2a4YAVT8xv0Ny4Zu9XUzomQEVvasxL5N+2J9dL253St5B7yOAZ5cDDFmqZm8hl/sMQSnzWhyNbNt1klWaoy4wf2NFR8mV07GorZFKPWV4uiRR2/V99nRCDJZ6n4JmLKhwMXf9J/VtntMuXR9+/WUX/Ofb1uQ9GUZUso2VnplCb+aPQyd8SxGVlnBNnuO6LkIemUHKUVLkJkXwmMoTjOihLyW53yVgB/WgJ6Fw4fv+8ITMktFf2gQIpAEmjQALaiUspFSxQEFqQw5z6UeFQGbcrY6WI0jhx9pklI/RPne7EGzMXvQ7IF3ZMHeB6JsdXNj0f6dNf9vx3HbSahC10XY8JRq7k7ioqcX46tNhEQqYjy/BEGARxYdnd9M7HcrOYHTbQuDUBUQb3Pu74vw5Xs/oqcUew0MSIaxzRhYpVSw3LnvVoA9BwIEjiCr8Fc4lJ8Kcx+EvTJiGb7M7vFPrPnBJ/Pz0cfaWHysjTVJKQnWa4mayvr9zVHtBzJtdsN2ld3Q80VJKckzYHdQDgV8ptxIqa0FbaQBAAEP//uNrokAIRfSIlwNtH2DakYpRQ3uT4rGcET9LExPLQFgESBPHPAE+jJ9Dl/NHQWv7OXWBSFPiFOLA8D/Y++8w5yovjf+Tvpme1+W3kGKNEFApCkCYvkqAnYEC6I/C1YUFRsq9t4QsNEEO0iR3qX3XnfZ3mv6/P6YTHJnMslmd5Msu5zP8+yzyWQyuZlMufe97znnga4PoFNCJwxqMkhYoFK5q+tKNiYbl1SRU0rOtCunwag14ta2t7qWKfWTlGiVKNxzD1wQrmMtnM7mNkkRQOIw4KYvgEbOHEjOa4FWVn1PWCici4aqckqFMrk2m+hcFMPu+lVI/C8aFNj2BOB+N6jpIAxqOkiyzJcoJcJOagDAdZ2SMaprKv5vvnKUl0oXBuYShaiEVNx+eWN8svoEhndKwR5VmMs9x1672sW2w+oxq6vzlRokQb9yp6enY+7cuZg9ezbKy8sxZswYWK1WLFmyBJdddlnVGyAueqoM31OatZJ3LGvolLquxXU4VXQKVzW+yuusekKEHosmuWd/f7/5d6/b0zA5pURRSuKUMvh/yniIUhwHTFwllGeOdCZBbO7frLQ32H3NK5jd2Vnm6olSNbe/D28xHMOaD6tRuE9SlAEPXN0Kn6w+ARUHjOzi26ExpIMgepigMJOii0C75qkw5LhDkaLkTqkQc30rd+4bMdkmAOjC4gRruKUMiG2hnFy+Fvw88mcUmAqQGpEquREb1AbXce4N+SQ3e5qZnYM7bx2t007r8mWcF1FKE4Z7O92LZGMyhrccHtrZOgY26apPpxQg5L7zhUYvzeHiR+lruVOqyFwEh3Mgr+QMeWpYe49lAHBNx2ScyClF/zbC4GTa9R2x/GAW/jmY5Von0uC5j/W3LwRWjkeOuRDr0taBBw81p3ZdM5SSSwcD9poZkPCO0bOBn28Dhr1e+21VAcdxCNdpXE4dwPvEBZugHhBCBCtPCvvYyFkkotS49uPwaPdHUWQuci0LZvhetWDFB46ThoNxasERnMUUBajB4EI+ycWeD6nhbrcIK5b/sTfD9ThKdrzrfYlS0U2AcT97Lu95H7D+bc/l+ijoeLdTJ5The+y5UqULOoHJnciKUtUIR2Jhr9Mcx0kGtEo5JFkXZ4TBU5RiUQqxjDFqISaNVDP9GI9k2Td8DCx7RqjeFSLiDfFIL0uv3ptcopQzgVkt80mJNItqBp1KB4tDcGrW9HhknVI6tUooBKTikN7vDRzZ+CuuVe8WXowS+mdaAM2tVpzTapFW1gdQr3FuJwrDk4fjv6z/0Celj3N7uqAJUoBwfWAnN5T6FFG6KAxvMdyPjcnGJdV0SkXro/Fqv1cly7wl/ZfTKkH627WIZ55zHNCdSR6u4JQyihMBzg4be88QxwXsmKHOnFIiKrV0f7NjkCD1P8R+V7Q+Gi2iWiiuw/ZtOQ74+m6h4Ee4Xo0Jc3d6rB+mU0tEqR/vvxKJkXr0aRmH7s1iMOI3g0uUCvG8eL0gqB7XkSNH4rLLLsPhw4fx6aefIiMjA59+6iXxH1Fv8St8T44k4biqxjdljUqDx3o8hh7J3uPsq4NWFgIDSG/QYviePygmGW/aG2hzTS1b6aY64S1KlYS8UsuZxtrkn3l8aFvMuqcXNj03BLf18p6TChAGfXPvuwJWjjnmnPmZENMMUY3aSJIGs9VJIupAlGJhcyzo1QbgyUPAMyerlQzYXwwagytXjLxzIs/3EamX/vZiyXsR9ojzOrhzcpoXOq1sonMXaj2gUiFaH42xHcYqJhUOFWIYJRCggaUoOgN+iVLyz7Q5bD5FKW98e09PrHlqkEsMualbY3x5V0/cfWVzd9MUhHV9hLu9T64TXFzsrHuV4UEBgj02bXwAkhY37Q08dxbocU/tt+UH8rAXbzmMmsSGSc679imRqOSd1fd4M8Ls7u/eOKIxovXRkgH4RSNKqdjvx0mdUqndhP8Fp9zLajC4kPcnDBoDfhzxI/qk9MGnQ939SaXjGvCc6dZrajDhcvXTwPXvA1c/I10ud0qFUJTqlNAJg5oOwrj246ruB7CiVARTZENfewekXBgSQ6NY2H5VhN5330JJyG0U7T7em8W6jyH2e2tUGqDneGDqBaBt4PpYVSFWVBvdbrT/bxLF3DLnZEGACnzo1Xp0TnBXwKypwzWMuY6lRBtcKRTsPSdguvVe94qRblF4fsJArBq9CkM6MGYDXTjeHfguVt+2WpIDLZjo1XrJPbNWkxvyydkAfIcp1woTSrf39hRvWcTwPRGJKCXH2efVMZMC4Td9CUze5l6FuWeI+4fn60iUkuxXP5SZIBX2EPdJ14Sufo2l2HA7+X3FtU2t2j3Gi2uN1JgwaNUq9G+TAKNOg0e6PQIAuLH1jZL9TwgEVZRauXIl7r//frz66qu4/vrroVaHJvkgEVqqdEopWV7Zgbc+MqS5fXzBukZcTimmE8WG71UF20ENRpJgOUpOKZZqOaWCkCh0ZMuRAOC2THtBreJwzWXJSFVIBqzEoPZJeHBoJ/eC3g8KuZg63gD0eVjiOtIwNwFdCGdTlWCrmenUOmGAEBYb9M+VOKU0Buhlg4Cljw3A3//nLp0eI7v5qjgOg9oLM5339vMcgIjcdWUznOOT4eC9nNva0Agd/uC1yltNYcMx/RiIs+EuraPdIZkx+phqDXQ5LznuosLc1zBFUUpB+EoyJqFHkiD2V2vAVQvYjmG1rle+NxqY7fhBuGzALQ9FEtGoVa5E8wDQo1msK6eU2mGC0W51vSYeG+z1IlQiYbXgZKJUcmfpfURjqNFvIRelwjRh6JbUDbOum+VKHgwIjmalzbPHPuBHXikl1FrgivuBFFnJcH2U1J0Q6OuID1ScCp8O+VSSI8UrUalCrpaONwLRzGA42vfA2B8uixdEiMQw4Zp3Q6sbPNaRVDWuwm1eXOE+9qdd3xGReg3eHe3e7+FqHo0jhGTCg5oOcvUrJl8+WVihOmFwAeCa5tdg+a3LMa3PNP/fJA6yz2wQ/gfIKQW4fw8gME6plGj3tSY6TIsSMNtkcpJFRjRCSngKnhnJhEE58wVpQhhOKRfiAtr3DkCfpW/reOx56VrM+F9nn+sZdRo0YvZ9iwQf15bkTsANn8B+5cOuReHtr5f0fdmqpaLz2cHUrK4rlzqiGle9TpD6imLuMXmSc3/wKUrd+Jkw9rhjkcfrt7W7DX/c9Ade7feqq3J7mB8pNC4Vgnql2LhxI2bPno1evXqhQ4cOuPvuuzF27NhgfiRRB1TplBrzI7B4gjSEgh2o1aFDQg7beRJnssMkTin/Txm2QxBMu7KIN/upSLVuOqrAi2gv930ZVzW+yiOuOxDo9cxNq/OtQnJw53fgW1wFHFsAQKbCd/TsPIcS1inlcc4EEfmMmdwplRipR7N4dwcoxig9bjgO+OqunjiRXYbOjb3ngnvtxs54cEBrXPg4AU25XM8VAlhRpbbcedmd2J+33zXAqTWsKFXN8L1Jl0/CmvNrUGmrxFO9ngpIh57tQCm5PZWOvyRjEt4e8DayK7IV3Q/Bxl7DiqR1CTuY4zjfoRotE8JxLFvIgdezeSwMAzsCWwHOWokwmxWAcJ6Kgyyj1ogVt66AmlN75Ei5OOCkibPDYoVQZNEpVcMQDH8TnatUHCJ00tAwrZrz6PB7K0ziF/JwHn0kdCWMKHURXdMkcBxw6yz38wkrhOTzVYUi++CPm/9Aemk6uiQKBS7mXz8f6WXp6Jnc02Ndb06pcJ0a5bKcd2whh/sHtMKE/i0Fp87QV4B1bwGjPsDcuGbYkL4BN7S+ARw43NbuNnRP6l7j71JbRJHMb+THSbJvgaI69EzuiZ+OCBNuNc0TxF7HUhlhJNKgdVXUBSAV08R7HutqCaFzcFqfafh87+d4rf9rkuU1KpYR5Enk2HD/+nutEsORWSwUiWiZ4GNfchzQ815YT/3lWiR307J555ScUiG/p9y5GMg+BLS8uup1g+QMvq/TfYjVx2Js++rrElHeRCmdWghrHaEQ7g3heGwVIxT0eX5EBzSKNlSZpuRSIqiiVN++fdG3b198/PHHWLBgAWbPno0pU6bA4XBg1apVaNq0KSIja5ZLiLh4kF/8PAY4Ta8AnjwgXcYmEKxhPqlgoJToPJy5Qctnwn2h4lTYcvsWOHhHtUJwqsvc4XOxJ2ePYvVBAHim1zP49cSveLDrg/5vNDzwIlq4Nhw3tA6SEFR03v04vo1EVGMdZLZ2w4GcrcFpQzVhnQ/BPD7kyEUpNsSI4wCDLOToSiYBKiDY4Q1aNbo08S0mq1QcmsUbsZ5vhKZQEKWCZMmuCVG6KHx5zZdVr+gv7Pnjh6jEDmYjdBGYOXBm4NoCaV6dKD+dUolhiTBoDHUiSAEBdEqFEDb/oEGj9jkgYp2gEXoNBl7WHNgKwFImcUqxYeBiCO5FiTZMmjhbpQZimjKiVM3Od39FKcAzX1G4PKk/pGW4lUQRnygUZGH9yaEM36sVza6s9SZaRbeSVEtNDk9Gcniy4rpsv4p1asYYdSi3CKHdHAc8N7wDbuomFXhc1XcHTAH6PgJo9EgBMKb9GNc6vVJ61fbrhBY2UuCym4CbA3fvGdx0MG5odQMaR1ZTKGMI07p/oxQmdFKt4tA0LgLmcg30nA1oxuREFUPbWPE5hK61sR3GYkz7MR7nu7o6rv+7lgB/TwFu+izArasZrRIisPmkUHSkua/wPSdsig65Q4x114rX0CRjEuqMttcKf/4QpJxS7ePa47nez9XovT6dUn4SadDi0SFtq17xEiIknkqj0YgJEyZgwoQJOHbsGL777ju8/fbbeP7553Httdfizz//DEUziCAhnx30a4DdmqnyY69eyc1gopxTynfoiy/kpWiDQc/knoqzkyL3dLoH93TyM6fK6NnAlk+F/Bn1iSQmj4HM5eVgKj927jj6ohGlLkanlFHrHkj//X9XYeWhLEwe3Ea6gWpOPJ7iUzEQ+z1fCGH59JDDDs79mKllB7PByBfEdqCUrmFKx18o3J2+qJdOKUl1Vt+z7SnR7vukXqNyl8auLEKY2n3NCmVIWI0Y+jKwbwHQ/3GpaGMzS5/XUJTScNLj1ZfQp5K9ZrN7hrSzaTz02uqKUp73cyvzmaGcXKhPsI5BNmcUOyHSq3ksJg2soppsiAouBB323tfxxoCKN2qVGjMGzKjVNiROqRjpebtqytWwlp+AXmWRhuuKvw17nocwbA9QvjZUK3yvzTXAEwp9lTpCzCsVF67zKoKw+PquSonOUyNS8fHgjxGjj6ldQ4PNRTKByaZ38ZabMEx3MbqY6w/BT3Qjo3379pg5cybS09Mxf/78UH88EQTks4NVVoIBpKXs808GuEU1R6tUfU9fM6dUvaTzrcCD64Swi/rE5bcDoz4C/m+3x0usKHVt82vx1oC38OfNdS+Es9X36tIpxQ6ejczx3blxNKYMa+8aRIgT1le2ZEJ0/OAYzySrZ0NIG7QoVb0ZSFZ4CIYoFSURpTw7t0qd2YBUv6sF9d0pVVVC7S6NY1yPOY5znw/mEhgZ5SQiQEmQg8aAp4BHdwhCLDsotJkAQ+1FqeqE31RYpMnxK62exxDrlJKHLleJXJTiebCfUKNQoUsALTOYY4VDdv+3Tb54HPNBhz0XAhi6FyhYcT0lSnre6jVqRETHCVUc2fBAMXcsO8ERYlGKRQzFf6DLA3XWhtrSrWkMAKBrFa50ketaXIcuCV0Uv7O86rLIkGZDAlYoKmjUsRj9xZ09EGvUYva9V1S5rreKu4R/1NkVQ61W4+abb8bNN99cV00gAoQ8saDfro+rnwU2zBQSiF4kSML3nIn5WadUdXJKESFEowN63af8EtMx4jgOo1qNClWrfBJrcCc1D0UifBFWABGcUu6bqLx6GMvqpwZh7dEc3NGneslxTziYMILYFkD+CeHxxVJBLBi0d4bSNvYvrCSUTqmqEg2LtIhuEfB2VIf66DphZ0mrckpd2SoOL47s6M7fFt0U0EUCllKE1VFFt4BiM0nzRYagsEGFzPVkV6i5zYpSn93RHRPm7sC06y/zWE8RD6cUDzsJUVXCik/s3tJrVPjizh74ZWcanhnWPvQNqyvEqnuAkG7gIoPt88ZVlf9o4PNAziGg1WDhOetUD2G/Rs4bV72BiV0mom1M/Q2P6t4sFr9O7oeWfoTuAULhmnnXz/P6mkgonfkBodWgOv34kV0aYUTnFL8mHXz1oYmqoRE2UWvk4Xt+X/AGvwC0uMpdOvoiQDGnFDNrRKJU/eOBLg9g7fm1uKXdLXXdFAnR+miMaTcGJrtJ4poKNhKnlEaaU4rtjMppmRCOlle1rPbnte/aGzgmfjhTXbChhGIoYYwDpqYDfgor7G8SFKeUwXf4HktSWBLGdx6Poc2GBrwd/vDRoI/wxvY3MPPqwObVCgVs/sHkKN8iDMdxeOBqd04eqLXC/fD4PzA46rEo1WUMcGARcOVk4Ig78W4oQjDMNkeV67A6Va8Wcdj3yjD/HU7yKmkqDeqfny/0aL040rRqFUZ2aXTpJfpNcFeNhPri61OyeXGaxVURPjx4qvfX6tAppVVpJdU5a0x8GyGaQ8yZFWJ6NAtMRWa5Q75e8MQBIPcY0KZu+iIs/t4j/AmzJLxz8V0NA8TZs2fx+uuvY82aNcjKykJqairuuusuvPjii9Dp6plKfJHDOqU0nMb/alEcB7QaGKRW1QydgiglcUpVM6cUUfckhyfj39v+vShDK17q+1LIP1NehUWnkEctkLx6W1/gDecTa6X7BdvFk0suKFSjgAPbSQy2U6qqsLKrmlyFuy+7O+Bt8JehzYdiaPO674TWBDb8tXFsDX7H1oOB4/9IFsmdyBc9t3wDXP8eYIgGTq93L79IRGi24hRQzZA7+bpDX4F1yY0BaFXDhq14yO5CfRVuwgZLh1FC2fimveu6JYqoVRx+vr8PTFY7kqoQ133SEEL0x80H1r4JXP1MXbekVtRLUSqmmfBXj2gU3QCO+TqkwY6wjx49CofDga+//hpt2rTBwYMH8cADD6C8vBzvvfdeXTevQcHO5Na0BO3FglbDJC11DtDZPFMNPqdUA+ViFKTqCo9E54wQ5auEfU1htw9zsfLjSxzWbRoMUYoV0+WDcjlNI5v6fJ3wDuuUahJbgwTlzhCYRLvbf1PvQi04ThCkAKkwG4Jw3b6t4rH1tFCtKiFCh7du6eqxjkJEX/Xg1ICY7yyxHSaM/hX/LB2LG1uTOOUPbK66auf0aiio1ECPuhP+/aF/m4SqV/JG74eAc1uEyoL1ncR2wJjv67oVtYatQlhvRKl6SKPoiyMpe32lwY6whw8fjuHDh7uet2rVCseOHcOXX35JolSAYUWp+n6x06g8nVJsJzbcR3gTQdQH5AkvWXcUO6MdUEZ9CCx7Fhj5HjDPWcrbRKKUSJIxCY/3eBxhmrCgiBDs7+pNk5rWZxrWp6/HnR3vDPjnXyqwrtomNXFKJbYDxvyA5LBYfKVTh6R6a1CRJDoPft/g49u7YeF/aRh7RVMkRuoVJyMcVYiyVaLRA9YK19MOCZdh6+1b61+YZR3B/iTewvqIes7I+hd63dBh85bW93HaxUKEXoMys7S4RgqJUrXikhphFxcXIy7Od+Uos9kMs9kdVlJSUhLsZtV72M6YX5X3LmKkic6Fx+2ShIEBxwVx0E4QIUJeGljDHPOsKBtQek0Aut0pHZiaS4PzWfWU+7sEt+BD75Zx2H2uEEM7KlcGHNthLMZ2GBvUNjR02PyDNRKlAJe7oH8gGlTX6GtffY+lqoIQSZEG/N9Q34mNHbW1Sql1ElEKqAcVEi8ipOF7lBSYIEIBe+30O8UK4ZOf7u+D1/8+jF3nCl3LKHyvdlwy0xSnTp3Cp59+ikmTJvlc76233kJ0dLTrr2lTCmWoCjbnhQNVJxq9mNEphO9FG7X474Wh2PvysLpqFkEEDFaUkg/ygiq6yp0SJhL8Q8n8B67EvleGIT6CZkmDBVsOumlNwvcaGqxTKgDV91QB6LLW1ih1seTGqr9wSHBeg4Z3SqnjthDEpQHb16N0FoGhW9MYLHm4H9omucfAscb6ncKmrql3otT06dPBcZzPv507d0rek5GRgeHDh+O2227D/ff7no2eOnUqiouLXX9paWnB/DoNAnaQa3VY67AltYe9WLO5cJKiDFRVgWgQsOerg5eKyJpQOAGvmyH8v+Wb4H8W4UKt4ignXpCptLhzQZGNH4A+2v04AE6pQAymah2+R6EvtWb5EwPw48TeGNmFRCmCCAVtYtrUdRMaLCUm97iXBL/aUe96qI8++ijGjRvnc50WLVq4HmdkZGDw4MHo27cvvvmm6kGQXq+HXk+djurAnoRWe/0WpcD0V3VBqERGEHUNa92Wi1IhCU/t+4gQyhcWE/zPIogQEsYkOqd8OZA6pQKQK62q8D1/eGxoW7z1z1Hc2qNJzTagqd8pCuoajgMSIvQY0DaxrptCEJcMLaJb4Lth3yHO4DuFDVF9SiptVa9E+EW9E6USEhKQkOBfVYgLFy5g8ODB6NmzJ+bMmQNVsPKlEC5sjvp9crKzqJdsZRjiksHDKRWE6nuKkCBFNEBGdmmEbafz0a91LSpXNSTY6nsOu/f1/CQQotSDV7fCgLaJaJdcwzxQ5JSqFeQjIIi6oXej3nXdhAZJpbX29zZCoMGOujMyMjBo0CA0bdoU7733HnJzc5GVlYWsrKy6blqDpr6H77HOfg2JUkQDx9MpRcc8QdQUrVqFt27pihsuT63rplwcsCF7dkutNxcIUYrjOFyWGlXz+zs5pWoFRbcQBNGQeO+2ywEAL47sWMctqf/UO6eUv6xcuRInT57EyZMn0aSJ1KbN1zrTJeENHvV739Y63wRB1CPkhQlCklOKIIhLA1aBsJu9r1cFCWEJyKvMQ++Ui2Cmn5xSNaJlQjjO5JVjVFcSbAmCaDiM7tkEg9snUhGZANBgRanx48dj/Pjxdd0Mop6RGkPlPIlLh57JPSXPG9PxTxBEMLDV3Cn1w4gf8MfJP3BXx7sC2KAaQtX3asTf/3cVLhRVol1yZNUrEwRB1CNIkAoMDVaUIoia0LlxNN6+pQuaUDlvogHzzy3/4FjBMQxpOgQA8M3dPbH0QCYeHtS6jltGEESDpBbhe00jm+LR7o8GsDG1YMRM4LtrgX6P1XVL6hXheg0JUgRBEIRXSJQiCBnjejer6yYQRFBpEtkETSLdYc3DOqVgWCcqz00QRJBodHldtyAwJHUAnjsLqNRVrkoQBEEQhH+QKEUQBEEQBEEEnkmbgRMrgb6P1HVLAgcJUgRBEAQRUKjUEhEQrm1+LQCgf+P+ddwSgiAIgiAuClI6AwOmUC4mgiAIgiC8Qk4pIiC81u81XN3kagxuOrium0IQBEEQBEEQBEEQRD2ARCkiIEToInBzm5vruhkEQRAEQRAEQRAEQdQTKHyPIAiCIAiCIAiCIAiCCDkkShEEQRAEQRAEQRAEQRAhh8L3qoDneQBASUlJHbeEIAiCIAiCIAiCIAji4kfUUERNxRskSlVBaWkpAKBp06Z13BKCIAiCIAiCIAiCIIj6Q2lpKaKjo72+zvFVyVaXOA6HAxkZGYiMjATHcXXdnBpTUlKCpk2bIi0tDVFRUXXdHIK4KKHzhCB8Q+cIQfiGzhGC8A2dIwRRNQ3lPOF5HqWlpUhNTYVK5T1zFDmlqkClUqFJkyZ13YyAERUVVa8PbIIIBXSeEIRv6BwhCN/QOUIQvqFzhCCqpiGcJ74cUiKU6JwgCIIgCIIgCIIgCIIIOSRKEQRBEARBEARBEARBECGHRKlLBL1ej1deeQV6vb6um0IQFy10nhCEb+gcIQjf0DlCEL6hc4QgquZSO08o0TlBEARBEARBEARBEAQRcsgpRRAEQRAEQRAEQRAEQYQcEqUIgiAIgiAIgiAIgiCIkEOiFEEQBEEQBEEQBEEQBBFySJRqQHzxxRdo2bIlDAYDevbsiY0bN/pcf/369ejZsycMBgNatWqFr776KkQtJYi6oTrnyK+//oprr70WiYmJiIqKQt++fbFixYoQtpYg6obq3ktENm/eDI1Gg27dugW3gQRRx1T3HDGbzXjxxRfRvHlz6PV6tG7dGrNnzw5Rawki9FT3HPn5559x+eWXw2g0olGjRrjvvvuQn58fotYSRGjZsGEDbrjhBqSmpoLjOPz+++9Vvqehj9tJlGogLFy4EE888QRefPFF7NmzBwMGDMCIESNw/vx5xfXPnDmDkSNHYsCAAdizZw9eeOEFPPbYY1iyZEmIW04QoaG658iGDRtw7bXXYtmyZdi1axcGDx6MG264AXv27AlxywkidFT3PBEpLi7GPffcg6FDh4aopQRRN9TkHBkzZgxWr16N7777DseOHcP8+fPRoUOHELaaIEJHdc+RTZs24Z577sHEiRNx6NAh/PLLL9ixYwfuv//+ELecIEJDeXk5Lr/8cnz22Wd+rX8pjNup+l4DoU+fPujRowe+/PJL17KOHTvi5ptvxltvveWx/nPPPYc///wTR44ccS2bNGkS9u3bh61bt4akzQQRSqp7jijRqVMnjB07Fi+//HKwmkkQdUpNz5Nx48ahbdu2UKvV+P3337F3794QtJYgQk91z5Hly5dj3LhxOH36NOLi4kLZVIKoE6p7jrz33nv48ssvcerUKdeyTz/9FDNnzkRaWlpI2kwQdQXHcfjtt99w8803e13nUhi3k1OqAWCxWLBr1y4MGzZMsnzYsGHYsmWL4nu2bt3qsf51112HnTt3wmq1Bq2tBFEX1OQckeNwOFBaWkqDCqLBUtPzZM6cOTh16hReeeWVYDeRIOqUmpwjf/75J3r16oWZM2eicePGaNeuHZ5++mlUVlaGoskEEVJqco7069cP6enpWLZsGXieR3Z2NhYvXozrr78+FE0miIueS2HcrqnrBhC1Jy8vD3a7HcnJyZLlycnJyMrKUnxPVlaW4vo2mw15eXlo1KhR0NpLEKGmJueInPfffx/l5eUYM2ZMMJpIEHVOTc6TEydO4Pnnn8fGjRuh0VCXgmjY1OQcOX36NDZt2gSDwYDffvsNeXl5mDx5MgoKCiivFNHgqMk50q9fP/z8888YO3YsTCYTbDYbbrzxRnz66aehaDJBXPRcCuN2cko1IDiOkzzned5jWVXrKy0niIZCdc8Rkfnz52P69OlYuHAhkpKSgtU8grgo8Pc8sdvtuOOOO/Dqq6+iXbt2oWoeQdQ51bmXOBwOcByHn3/+Gb1798bIkSPxwQcfYO7cueSWIhos1TlHDh8+jMceewwvv/wydu3aheXLl+PMmTOYNGlSKJpKEPWChj5up2nNBkBCQgLUarXHDEROTo6HqiqSkpKiuL5Go0F8fHzQ2koQdUFNzhGRhQsXYuLEifjll19wzTXXBLOZBFGnVPc8KS0txc6dO7Fnzx48+uijAIQBOM/z0Gg0WLlyJYYMGRKSthNEKKjJvaRRo0Zo3LgxoqOjXcs6duwInueRnp6Otm3bBrXNBBFKanKOvPXWW+jfvz+eeeYZAEDXrl0RHh6OAQMG4I033mgQLhCCqA2XwridnFINAJ1Oh549e2LVqlWS5atWrUK/fv0U39O3b1+P9VeuXIlevXpBq9UGra0EURfU5BwBBIfU+PHjMW/ePMptQDR4qnueREVF4cCBA9i7d6/rb9KkSWjfvj327t2LPn36hKrpBBESanIv6d+/PzIyMlBWVuZadvz4cahUKjRp0iSo7SWIUFOTc6SiogIqlXRIqlarAbjdIARxKXNJjNt5okGwYMECXqvV8t999x1/+PBh/oknnuDDw8P5s2fP8jzP888//zx/9913u9Y/ffo0bzQa+SeffJI/fPgw/9133/FarZZfvHhxXX0Fgggq1T1H5s2bx2s0Gv7zzz/nMzMzXX9FRUV19RUIIuhU9zyR88orr/CXX355iFpLEKGnuudIaWkp36RJE3706NH8oUOH+PXr1/Nt27bl77///rr6CgQRVKp7jsyZM4fXaDT8F198wZ86dYrftGkT36tXL75379519RUIIqiUlpbye/bs4ffs2cMD4D/44AN+z549/Llz53ievzTH7SRKNSA+//xzvnnz5rxOp+N79OjBr1+/3vXavffeyw8cOFCy/rp16/ju3bvzOp2Ob9GiBf/ll1+GuMUEEVqqc44MHDiQB+Dxd++994a+4QQRQqp7L2EhUYq4FKjuOXLkyBH+mmuu4cPCwvgmTZrwU6ZM4SsqKkLcaoIIHdU9Rz755BP+sssu48PCwvhGjRrxd955J5+enh7iVhNEaFi7dq3PMcalOG7neJ58kQRBEARBEARBEARBEERooZxSBEEQBEEQBEEQBEEQRMghUYogCIIgCIIgCIIgCIIIOSRKEQRBEARBEARBEARBECGHRCmCIAiCIAiCIAiCIAgi5JAoRRAEQRAEQRAEQRAEQYQcEqUIgiAIgiAIgiAIgiCIkEOiFEEQBEEQBEEQBEEQBBFySJQiCIIgCIIgCIIgCIIgQg6JUgRBEARBECFk+vTp6NatW519/ksvvYQHH3zQr3WffvppPPbYY0FuEUEQBEEQlyocz/N8XTeCIAiCIAiiIcBxnM/X7733Xnz22Wcwm82Ij48PUavcZGdno23btti/fz9atGhR5fo5OTlo3bo19u/fj5YtWwa/gQRBEARBXFKQKEUQBEEQBBEgsrKyXI8XLlyIl19+GceOHXMtCwsLQ3R0dF00DQAwY8YMrF+/HitWrPD7PbfeeivatGmDd955J4gtIwiCIAjiUoTC9wiCIAiCIAJESkqK6y86Ohocx3ksk4fvjR8/HjfffDNmzJiB5ORkxMTE4NVXX4XNZsMzzzyDuLg4NGnSBLNnz5Z81oULFzB27FjExsYiPj4eN910E86ePeuzfQsWLMCNN94oWbZ48WJ06dIFYWFhiI+PxzXXXIPy8nLX6zfeeCPmz59f631DEARBEAQhh0QpgiAIgiCIOmbNmjXIyMjAhg0b8MEHH2D69OkYNWoUYmNjsX37dkyaNAmTJk1CWloaAKCiogKDBw9GREQENmzYgE2bNiEiIgLDhw+HxWJR/IzCwkIcPHgQvXr1ci3LzMzE7bffjgkTJuDIkSNYt24dbrnlFrBG+t69eyMtLQ3nzp0L7k4gCIIgCOKSg0QpgiAIgiCIOiYuLg6ffPIJ2rdvjwkTJqB9+/aoqKjACy+8gLZt22Lq1KnQ6XTYvHkzAMHxpFKpMGvWLHTp0gUdO3bEnDlzcP78eaxbt07xM86dOwee55GamupalpmZCZvNhltuuQUtWrRAly5dMHnyZERERLjWady4MQBU6cIiCIIgCIKoLpq6bgBBEARBEMSlTqdOnaBSuecKk5OT0blzZ9dztVqN+Ph45OTkAAB27dqFkydPIjIyUrIdk8mEU6dOKX5GZWUlAMBgMLiWXX755Rg6dCi6dOmC6667DsOGDcPo0aMRGxvrWicsLAyA4M4iCIIgCIIIJCRKEQRBEARB1DFarVbynOM4xWUOhwMA4HA40LNnT/z8888e20pMTFT8jISEBABCGJ+4jlqtxqpVq7BlyxasXLkSn376KV588UVs377dVW2voKDA53YJgiAIgiBqCoXvEQRBEARB1DN69OiBEydOICkpCW3atJH8eavu17p1a0RFReHw4cOS5RzHoX///nj11VexZ88e6HQ6/Pbbb67XDx48CK1Wi06dOgX1OxEEQRAEcelBohRBEARBEEQ9484770RCQgJuuukmbNy4EWfOnMH69evx+OOPIz09XfE9KpUK11xzDTZt2uRatn37dsyYMQM7d+7E+fPn8euvvyI3NxcdO3Z0rbNx40YMGDDAFcZHEARBEAQRKEiUIgiCIAiCqGcYjUZs2LABzZo1wy233IKOHTtiwoQJqKysRFRUlNf3Pfjgg1iwYIErDDAqKgobNmzAyJEj0a5dO0ybNg3vv/8+RowY4XrP/Pnz8cADDwT9OxEEQRAEcenB8WzNX4IgCIIgCKLBwvM8rrzySjzxxBO4/fbbq1x/6dKleOaZZ7B//35oNJSKlCAIgiCIwEJOKYIgCIIgiEsEjuPwzTffwGaz+bV+eXk55syZQ4IUQRAEQRBBgZxSBEEQBEEQBEEQBEEQRMghpxRBEARBEARBEARBEAQRckiUIgiCIAiCIAiCIAiCIEIOiVIEQRAEQRAEQRAEQRBEyCFRiiAIgiAIgiAIgiAIggg5JEoRBEEQBEEQBEEQBEEQIYdEKYIgCIIgCIIgCIIgCCLkkChFEARBEARBEARBEARBhBwSpQiCIAiCIAiCIAiCIIiQQ6IUQRAEQRAEQRAEQRAEEXJIlCIIgiAIgiAIgiAIgiBCDolSBEEQBEEQBEEQBEEQRMghUYogCIIgCIIgCIIgCIIIOSRKEQRBEARBEARBEARBECGHRCmCIAiCIAiCIAiCIAgi5JAoRRAEQRAEQRAEQRAEQYQcEqUIgiAIop4xd+5ccBzn9W/dunXV2l5FRQWmT59e7fcFkoyMDEyfPh179+4N+LbF/XX27Nkq112xYgWGDRuG1NRU6PV6pKamYtCgQXj77bcD3q6aMGPGDPz+++9B2fbZs2fBcRzmzp3r1/rZ2dl4/vnn0aVLF0RERMBgMKBt27Z4/PHHceLEiaC08VIimOcEQRAEQVwsaOq6AQRBEARB1Iw5c+agQ4cOHssvu+yyam2noqICr776KgBg0KBBgWhatcnIyMCrr76KFi1aoFu3bnXShq+++goPP/wwbr31Vnz22WeIi4tDWloatmzZgsWLF+P555+vk3axzJgxA6NHj8bNN99cp+3477//MGrUKPA8j0cffRR9+/aFTqfDsWPH8NNPP6F3794oLCys0zbWdy6Gc4IgCIIggg2JUgRBEARRT+ncuTN69eoV8s+tqKiA0WgM+ecGm7feegtXX301Fi9eLFl+9913w+Fw1FGrak5lZSUMBgM4jgvodktKSnDTTTfBYDBgy5YtaNKkieu1QYMG4aGHHvLYhwRBEARBEEpQ+B5BEARBNFAWLFgAjuPw2WefSZa/8sorUKvVWLVqFc6ePYvExEQAwKuvvuoKARw/fjwAYPr06eA4Drt378bo0aMRGxuL1q1bAwB27tyJcePGoUWLFggLC0OLFi1w++2349y5cx5tuXDhAh588EE0bdoUOp0OqampGD16NLKzs7Fu3TpcccUVAID77rvP1Ybp06e73r9z507ceOONiIuLg8FgQPfu3bFo0SKPz9m2bRv69+8Pg8GA1NRUTJ06FVar1a/9lZ+fj0aNGim+plJJu0wcx+HRRx/F119/jXbt2kGv1+Oyyy7DggULPN6blZWFhx56CE2aNIFOp0PLli3x6quvwmazSdYzm8147bXX0LFjRxgMBsTHx2Pw4MHYsmWL6zPLy8vx/fffu/aR6GwTQxRXrlyJCRMmIDExEUajEWazGSdPnsR9992Htm3bwmg0onHjxrjhhhtw4MABv/aLnG+//RZZWVmYOXOmRJBiGT16tOT5n3/+ib59+8JoNCIyMhLXXnsttm7dKllHPNb279+P2267DdHR0YiLi8OUKVNgs9lw7NgxDB8+HJGRkWjRogVmzpwpef+6devAcRx++uknTJkyBSkpKQgLC8PAgQOxZ88ejzZWp02HDh3C7bffjujoaCQnJ2PChAkoLi6WrMvzPL744gt069YNYWFhiI2NxejRo3H69GnJeoMGDULnzp2xY8cODBgwAEajEa1atcLbb7/tEj+rOidOnz6NcePGucJMk5OTMXToUAr1IwiCIOod5JQiCIIgiHqK3W73EDY4joNarQYAjBs3DuvXr8dTTz2FK6+8Er169cKaNWvwxhtv4IUXXsC1114Ls9mM5cuXY/jw4Zg4cSLuv/9+AHAJVSK33HILxo0bh0mTJqG8vByAkIOoffv2GDduHOLi4pCZmYkvv/wSV1xxBQ4fPoyEhAQAgiB1xRVXwGq14oUXXkDXrl2Rn5+PFStWoLCwED169MCcOXNw3333Ydq0abj++usBwCV4rF27FsOHD0efPn3w1VdfITo6GgsWLMDYsWNRUVHhEtAOHz6MoUOHokWLFpg7dy6MRiO++OILzJs3z6/92bdvXyxZsgTTp0/H//73P3Tu3Nm1L5X4888/sXbtWrz22msIDw/HF198gdtvvx0ajcYlymRlZaF3795QqVR4+eWX0bp1a2zduhVvvPEGzp49izlz5gAAbDYbRowYgY0bN+KJJ57AkCFDYLPZsG3bNpw/fx79+vXD1q1bMWTIEAwePBgvvfQSACAqKkrSpgkTJuD666/Hjz/+iPLycmi1WmRkZCA+Ph5vv/02EhMTUVBQgO+//x59+vTBnj170L59e7/2j8jKlSuhVqtxww03+LX+vHnzcOedd2LYsGGYP38+zGYzZs6ciUGDBmH16tW46qqrJOuPGTMGd911Fx566CGsWrUKM2fOhNVqxb///ovJkyfj6aefxrx58/Dcc8+hTZs2uOWWWyTvf+GFF9CjRw/MmjULxcXFmD59OgYNGoQ9e/agVatWNWrTrbfeirFjx2LixIk4cOAApk6dCgCYPXu2a52HHnoIc+fOxWOPPYZ33nkHBQUFeO2119CvXz/s27cPycnJrnWzsrJw55134qmnnsIrr7yC3377DVOnTkVqairuueeeKs+JkSNHwm63Y+bMmWjWrBny8vKwZcsWFBUV+fWbEARBEMRFA08QBEEQRL1izpw5PADFP7VaLVnXZDLx3bt351u2bMkfPnyYT05O5gcOHMjbbDbXOrm5uTwA/pVXXvH4rFdeeYUHwL/88stVtstms/FlZWV8eHg4//HHH7uWT5gwgddqtfzhw4e9vnfHjh08AH7OnDker3Xo0IHv3r07b7VaJctHjRrFN2rUiLfb7TzP8/zYsWP5sLAwPisrS9KmDh068AD4M2fO+Gz/yZMn+c6dO7v2ZVhYGD906FD+s88+4y0Wi2Rd8XWlz2rTpo1r2UMPPcRHRETw586dk7z/vffe4wHwhw4d4nme53/44QceAP/tt9/6bGN4eDh/7733eiwXj4l77rnH5/vFdlosFr5t27b8k08+6Vp+5swZr78BS4cOHfiUlJQqP4fned5ut/Opqal8ly5dXL8Tz/N8aWkpn5SUxPfr18+1TDzW3n//fck2unXrxgPgf/31V9cyq9XKJyYm8rfccotr2dq1a3kAfI8ePXiHw+FafvbsWV6r1fL3339/jds0c+ZMSZsmT57MGwwG1+ds3bpVse1paWl8WFgY/+yzz7qWDRw4kAfAb9++XbLuZZddxl933XWu597Oiby8PB4A/9FHH/EEQRAEUd+h8D2CIAiCqKf88MMP2LFjh+Rv+/btknX0ej0WLVqE/Px89OjRAzzPY/78+T4dQErceuutHsvKyspcbhWNRgONRoOIiAiUl5fjyJEjrvX++ecfDB48GB07dqz2dzx58iSOHj2KO++8E4DgKBL/Ro4ciczMTBw7dgyA4KgaOnSoxJGiVqsxduxYvz6rdevW2LdvH9avX49XX30V11xzDXbs2OFK5G0ymSTre/uskydPIj09HQDw999/Y/DgwUhNTZW0fcSIEQCA9evXu/aRwWDAhAkTqr2PWJR+J5vNhhkzZuCyyy6DTqeDRqOBTqfDiRMnJL9TMDh27BgyMjJw9913S0IgIyIicOutt2Lbtm2oqKiQvGfUqFGS5x07dgTHca59BgAajQZt2rRRDBW94447JHm0mjdvjn79+mHt2rU1btONN94oed61a1eYTCbk5OQAEH5njuNw1113SX7nlJQUXH755R6VLVNSUtC7d2+PbSp9HzlxcXFo3bo13n33XXzwwQfYs2dPvcx5RhAEQRAAhe8RBEEQRL2lY8eOfiU6b9OmDQYMGIClS5fi4Ycf9po3yRdK77njjjuwevVqvPTSS7jiiisQFRUFjuMwcuRIVFZWutbLzc31mnuoKrKzswEATz/9NJ5++mnFdfLy8gAIOaFSUlI8Xlda5g2VSoWrr74aV199NQCgvLwcEydOxMKFCzF79mxMnjzZ53bFZfn5+WjSpAmys7Px119/QavV+mx7bm4uUlNTPXJXVRel32nKlCn4/PPP8dxzz2HgwIGIjY2FSqXC/fffL/md/KVZs2Y4ceIEysvLER4e7nPd/Px8r+1KTU2Fw+FAYWGhJHF+XFycZD2dTgej0QiDweCxvKSkxGO73n6Xffv21bhN8fHxkvX0ej0AuPZfdnY2eJ6XiJQsYtigt+2J2/Tn9+A4DqtXr8Zrr72GmTNn4qmnnkJcXBzuvPNOvPnmm4iMjKxyGwRBEARxsUCiFEEQBEE0cGbNmoWlS5eid+/e+OyzzzB27Fj06dOnWtuQV3ArLi7G33//jVdeeQXPP/+8a7nZbEZBQYFk3cTERJdzqLqIeammTp3qkTtIRMyJFB8fj6ysLI/XlZb5S3h4OKZOnYqFCxfi4MGDVW5XXCaKDgkJCejatSvefPNNxe2npqYCEPbRpk2b4HA4aiVMKVXa++mnn3DPPfdgxowZkuV5eXmIiYmp9mdcd911WLlyJf766y+MGzfO57rifsjMzPR4LSMjAyqVCrGxsdVugy+8/S5iW4LRpoSEBHAch40bN7oEKxalZbWhefPm+O677wAAx48fx6JFizB9+nRYLBZ89dVXAf0sgiAIgggmFL5HEARBEA2YAwcO4LHHHsM999yDjRs3omvXrhg7diwKCwtd68hdH/7AcRx4nvcYbM+aNQt2u12ybMSIEVi7dq0rzE4Jb21o37492rZti3379qFXr16Kf6IzZPDgwVi9erXLXQUIyeAXLlzo13dSEikAuELcRAFJxNtntW7d2uUMGzVqFA4ePIjWrVsrtl3c5ogRI2AymTB37lyfbfTXTcPCcZzH77R06VJcuHChWtsRmThxIlJSUvDss8963cavv/4KQPj9GjdujHnz5oHnedfr5eXlWLJkiav6XSCZP3++5LPOnTuHLVu2uCoVBqNNo0aNAs/zuHDhguLv3KVLl2p/D3/Py3bt2mHatGno0qULdu/eXe3PIQiCIIi6hJxSBEEQBFFPOXjwoEf1PUDIjZSYmIjy8nKMGTMGLVu2xBdffAGdTodFixahR48euO+++/D7778DACIjI9G8eXP88ccfGDp0KOLi4pCQkIAWLVp4/eyoqChcffXVePfdd13rrl+/Ht99952H++a1117DP//8g6uvvhovvPACunTpgqKiIixfvhxTpkxBhw4d0Lp1a4SFheHnn39Gx44dERERgdTUVKSmpuLrr7/GiBEjcN1112H8+PFo3LgxCgoKcOTIEezevRu//PILAGDatGn4888/MWTIELz88sswGo34/PPPXdUCq6JTp04YOnQoRowYgdatW8NkMmH79u14//33kZycjIkTJ0rWT0hIwJAhQ/DSSy+5qu8dPXoUCxYskHz3VatWoV+/fnjsscfQvn17mEwmnD17FsuWLcNXX32FJk2a4Pbbb8ecOXMwadIkHDt2DIMHD4bD4cD27dvRsWNHlyOpS5cuWLduHf766y80atQIkZGRVVbPGzVqFObOnYsOHTqga9eu2LVrF959990ah1RGR0fjjz/+wKhRo9C9e3dXzi0xT9VPP/2Effv24ZZbboFKpcLMmTNx5513YtSoUXjooYdgNpvx7rvvoqioCG+//XaN2uCLnJwc/O9//8MDDzyA4uJivPLKKzAYDK6KecFoU//+/fHggw/ivvvuw86dO3H11VcjPDwcmZmZ2LRpE7p06YKHH364Wtv0dk7k5eXh0UcfxW233Ya2bdtCp9NhzZo12L9/v8S1SBAEQRD1gjpMsk4QBEEQRA3wVX0PTAW3u+66izcaja4KbyK//PILD4D/8MMPXcv+/fdfvnv37rxer+cBuCq8idXHcnNzPdqRnp7O33rrrXxsbCwfGRnJDx8+nD948CDfvHlzjwpxaWlp/IQJE/iUlBReq9Xyqamp/JgxY/js7GzXOvPnz+c7dOjAa7Vaj2qA+/bt48eMGcMnJSXxWq2WT0lJ4YcMGcJ/9dVXks/ZvHkzf+WVV/J6vZ5PSUnhn3nmGf6bb77xq/re119/zd9yyy18q1ateKPRyOt0Or5169b8pEmT+LS0NMm6APhHHnmE/+KLL/jWrVvzWq2W79ChA//zzz97bDc3N5d/7LHH+JYtW/JarZaPi4vje/bsyb/44ot8WVmZa73Kykr+5Zdf5tu2bcvrdDo+Pj6eHzJkCL9lyxbXOnv37uX79+/PG41GHgA/cOBAnufdx8SOHTs8Pr+wsJCfOHEin5SUxBuNRv6qq67iN27cyA8cOND1fp73v/qeSFZWFv/cc8/xnTp14o1GI6/X6/k2bdrwDz30EH/gwAHJur///jvfp08f3mAw8OHh4fzQoUP5zZs3S9bxdqzde++9fHh4uMfnDxw4kO/UqZPruVh978cff+Qfe+wxPjExkdfr9fyAAQP4nTt3ery/Nm0S97f8mJo9ezbfp08fPjw8nA8LC+Nbt27N33PPPZLPl7eb/Z7NmzeXLFM6J7Kzs/nx48fzHTp04MPDw/mIiAi+a9eu/IcffiipqkkQBEEQ9QGO5xnfMkEQBEEQBFElHMfhkUcewWeffVbXTSGcrFu3DoMHD8Yvv/yC0aNH13VzCIIgCILwA8opRRAEQRAEQRAEQRAEQYQcEqUIgiAIgiAIgiAIgiCIkEPhewRBEARBEARBEARBEETIIacUQRAEQRAEQRAEQRAEEXJIlCIIgiAIgiAIgiAIgiBCDolSBEEQBEEQBEEQBEEQRMjR1HUDLnYcDgcyMjIQGRkJjuPqujkEQRAEQRAEQRAEQRAXNTzPo7S0FKmpqVCpvPuhSJSqgoyMDDRt2rSum0EQBEEQBEEQBEEQBFGvSEtLQ5MmTby+TqJUFURGRgIQdmRUVFQdt4YgCIIgCIIgCIIgCOLipqSkBE2bNnVpKt4gUaoKxJC9qKgoEqUIgiAIgiAIgiAIgiD8pKo0SJTonCAIgiAIgiAIgiAIggg5JEoRBEFUg62n8nEqt6yum0EQBEEQBEEQBFHvofA9giAIPzmVW4bbv90GADj79vV13BqCIAiCIAiCIIj6DTmlCIIg/OR4VmldN4EgCIIgCIIgCKLBQKIUQRAEQRAEQRAEQRAEEXLqnSj1xRdfoGXLljAYDOjZsyc2btzodd3MzEzccccdaN++PVQqFZ544onQNZQgiAYNz/N13QSCIAiCIAiCIIh6Tb0SpRYuXIgnnngCL774Ivbs2YMBAwZgxIgROH/+vOL6ZrMZiYmJePHFF3H55ZeHuLUEQTQ02GqmdgeJUgRBEARBEARBELWhXolSH3zwASZOnIj7778fHTt2xEcffYSmTZviyy+/VFy/RYsW+Pjjj3HPPfcgOjo6xK0lCKIhY7E76roJBEEQBEEQBEEQ9Zp6I0pZLBbs2rULw4YNkywfNmwYtmzZUketIlwUnAZ+fwTIPVbXLSGIkGC1kVOKIAiCIAiCIAiiNmjqugH+kpeXB7vdjuTkZMny5ORkZGVlBexzzGYzzGaz63lJSUnAtt2g+fk2IP8kcHodMOVQXbeGIIICG7FHTimCIAiCIAiCIIjaUW+cUiIcm9QFQrJh+bLa8NZbbyE6Otr117Rp04Btu0GTf1L4X5Ku+DIlhSYaAlZGiCJRiiAIgiAIgiAIonbUG1EqISEBarXawxWVk5Pj4Z6qDVOnTkVxcbHrLy0tLWDbvlTZmbUT/Rf0x1+n/qrrphBErbDY3EKU1UaiFEEQBEEQRCigCW6CaLjUG1FKp9OhZ8+eWLVqlWT5qlWr0K9fv4B9jl6vR1RUlOSPqB1PrHsCpZZSvLDphbpuCkHUCqudZx6TKEUQBEEQBBFsvlx3Cj3f+Benc8vquikEQQSBeiNKAcCUKVMwa9YszJ49G0eOHMGTTz6J8+fPY9KkSQAEl9M999wjec/evXuxd+9elJWVITc3F3v37sXhw4frovmXBpzaY5HNYauDhhBE4GGFKDM5pQiCIIJPcTqw+ROgsqiuW0IQRB3xzvKjKCi3YMayI3XdFIIggkC9SXQOAGPHjkV+fj5ee+01ZGZmonPnzli2bBmaN28OAMjMzMT58+cl7+nevbvr8a5duzBv3jw0b94cZ8+eDWXTLx00Bo9FHAKX84sg6hJWlAqmU+qd/95BdkU23h/4fkBz5hEEQdQ75l4PFJ4FMvcCo2fXdWuCislqxwM/7ES3pjF4alj7um4OQVx0VFrtdd0EgiCCQL0SpQBg8uTJmDx5suJrc+fO9VhG8cchRkuiFNFwsUhEqeBdW3468hMA4EjBEVwWf1ngP+DCLuDcFuDKyYDK091IEIFk17lC/Lz9HKaO6IjESH1dN4eobxSeFf4fX1mnzQgFf+y9gI0n8rDxRB6JUiGkuMKKaKO2rptB+EEw+14EQdQd9U6UIi5CHIxjRBNWd+0giCBjtbk7Q5Yghe/ZHe5ZQIvdEpTPwLdDhP9hsUD3u4LzGQTh5NYvtwAAykw2fHNPrzpuDVF/afiD0ZM5lC8n1CzamYZnF+/HCyM74MGrW9d1c4gqsFE+T4JokNSrnFLERYql1P1YQ7PgRMMlFOF7VofV9djOB9mmnk359YjQcTy7tOqVCMIbl4DzPa2g0vXY7mj43/di4NnF+wEAM5YdreOWEP5go/OCIBokJEoRtYeSj4aM9cdz8enqExSWWkewQpQlSKIUWxjAwQd5RlBFtwAidNBggqgVwb4eXgSkF1W4HldYqEgMQcgJlkud8I8ysw2lJitySky4UFRZ9RsIwk8ofI+oPaYi92Ob2fN1SikVMO6d/R8A4LLUKAztmFzl+g7egTJrGaJ0UcFu2iWBpaE5pRSqZdZXsopNmPb7AYzp1RTDOqXUdXMIBarj/OB5npL8EzIatqjJ8zzO5bGilB2RBspzRBDsRCxNbtQdDgePq2euRWGFxWVcPfzadTDqSE4gag9NkxO1x1TsfmzzVM0p0XlgYG/KWSUmv97z9Pqn0X9+fxwrOBasZl1SSJxSQZqtY0WpoOSUYoXjBpTkfOmBTPx7JAcP/rgLO88W1HVzCHgWGvF3MLHy7EoMWDgAWzK2BKNZRH2lgTulMotNKDW73VHl5po5pX449AMWHl0YqGYRRJ3DJjcPZuVjwjflFhsKyi2SSOr5/6Xh7/0ZddcoosFAohThFZO/ZVfZ8D0lpxQREAor3GKFVu3fqbvq3CoAwLyj84LSpksNNtF5KJxSZnsQziczk0i3ATmlykzuAdxna0/WYUsIAPhp2zn0mbEaR7NKXMvkTilvYchPrX8KxeZiPLvh2aC2kahnNPCw9WzZZFOFpfpO2TJLGd7d+S5m/DcDJpt/k1cEcbFTyYxHrBS+V2dUKlyTXv/7MB6dtwc5fk6WE4Q3aiRKFRUVYdasWZg6dSoKCoQZ6d27d+PChQsBbRxRd8zdfAYdXlqOtcdyql5ZEr7n+6JEuZBqTm6pW6CotNix61wh5m4+49c+pf0eGKQ5paT7tLDcEpAcIFa7W5QKyqDC7BYJqjpf6xPsvt+bVkTHfB0z7feDyCk14+XfD7mWsVWTFu9KR4/XV/l0tWlVFLpEsDTsc1o+4KuJKFVhE8L/HLwDReaiQDSLCDA8z2Nj+kZkl2fXdVPqDewkuSlIotTZ4rOYvmU60krTgrL9hkC5j2uSr9cIwh+qLUrt378f7dq1wzvvvIP33nsPRUVFAIDffvsNU6dODXT7iDpi+l9CVa4nFuytemXWKeWwAXbvA3PWBUL4hzi4zil1CwgllVbc+uUWTP/rMNYcrVo45Bt4Zz5UWLyE75WYrOj++ipcOWN1rT8j+E4ppgKatcL7evUMNuylqMIqqWJF1B3ljFjIOqWe/mUfCiuseHLRXq/vjTXEBrNpRJDZkL4Bz214DqWWAFVdbODhe3IRqrwGkxxmxq1eaCqsdZuIwLPxwkZMXj0ZN/9xc103pd7ACralJmu1Jp3Wp63HmL/G4EThCZ/rTVwxEUtOLMETa5+oaTMbPL4mXikBPVFbqi1KTZkyBePHj8eJEydgMBhcy0eMGIENGzYEtHFE3aPT+HGIsDmlAMDHQNpkbzjOjFAwZdFeDJi5FuVmm8QpVVzpFi4y8ouBksy6aN4lh9VLovODF4RzoMRkq7VDJ6SilKXhiFJs+B4A7E0v8vu9FrsFH+z6ADuzdga4VdWgshAwlVS9Xj2DFaKUckplFpnw+dqTmLP5jEcOnVi9b1EqpyIHRwuO4p5/7sGOrB2BafAlyKYTefhh69mAb/eR1Y9g2ZlleGv7W4HZYAMXpeQilFKoTFWw9wwSpS5OdmYL95kya1ngHb12K7DgTmDFi4Hdbh0jCd+z8zBZ/b8WPLrmURwpOIKXNr/kc72cSmGC93jh8Zo18hLAl3uz0t+ULz6wO8htdSlTbVFqx44deOihhzyWN27cGFlZWQFpFHHxoPdHlJK7LWR5pdibrplyTlWLX3dfQHphJf49ko0cRpTKLHaLe9fvGA980AHnju7Cb3vSFTs5FMoUGNiZIDavgc3OHuO1GziF1ilVHvjt1xFlTkHDoBWuWR/9exwF5f4lil98fDHmHJyD+1bcF7T2+cRqAt5pAbzbGnA4gH0LgH0NI1Gxg7n22B08eJ5HMZMfz+bg8e6KY3j1r8NYvCsdZRZ3zjNfTqkfD/+Iob8MxW1/3YY9OXswYcWE4HyBS4C7vtuOl/84hP3VEHJ9IR9Y/HPmn4Bst6FxPLtUco2Si1A1SXRudjCilDmEolRRGnBmY+g+rx4To49xPf5y35eBLURzfAVw9G9g62cNKgebXPAoNVU/6qLcz/4OW5wpoywDb2x7A+dKzlX78xoiPkWpWobvTds0DUN+GYIiNiUMcUlRbVHKYDCgpMRzNvfYsWNITEwMSKOI0FFQbsFf+zK82i79ckpZZWEysjw1rDuKEm/6DyskcRyHnBJ3Z/NEjltYiCsWcrb8/tOneHLhPmw6mee5LQrfCwhsBRiL3QGLzYE7Z23D1F8PuJazN+3lZ5djfdp65Y3xPDD/duCHmwGeh9VuhcVukeSUCoqI24CcUmVmG77dcBppBRUup9S1l6UAAE7nluONvw/7tZ0LZe58iHtz9oa+U1R0XvhvtwC5R4HfHgJ+exAoOB3adgQBVqS1OXh8vvYkLn9tpeK6eWVm5FS4w5FVnAqnik7BIXPIVFgrMHPHzOA0+GLB4QjJoLKowi2KiA5cRy1Krn+8+2MMWDhAkpfFxttqfu9vQANrllO5ZRj24QYMfm+da5k8J0tNckqxFVvFnFI8z2Pyv5Nx/8r7gzdB9Vkv4PtRwLmtwdl+A6KSqVL95b4vcfc/dwdu45n73I8bUHi+SXYulNRAlArThPm1nl6tdz3+vzX/h4XHFuKhVZ5mjHqF3Qp8fwOw/IVababCh1Dud3EsL/xx6g8UmAqw8pxy/4Bo+FRblLrpppvw2muvwWoVLggcx+H8+fN4/vnnceuttwa8gURwefinXfi/+Xvw8Wplu6rOnypv8s4m89zusEucHxS+5z9sB1Wr4pBbxopSZR7rq5zC09k8YTaIbLCBR5JTyu7AumM52HwyHxeK3J1MMeZ+5dETeGb9M3h0zaMeg2oAQrjWsWXA6bXgS7Mwbuk4jPptlCtRLRCk84VNdF7PO60f/3scby47gps/3+xySo3u2QSjezYBIHUU+iJCF+F6fPc/d+PBVQ8GvrG+YH+Hg0vcjw8s8Vy3HsB2TuUD6/dWeg+NqLTYkZ1/1PX8nzP/4OY/bsZX+76SrPfnqT8D1NKLFLsV+Ko/8PNtQf+os/nuY8/BA1MW7kW/t9fUaNAHALMOzEKppRRzDs6RDAJ3Z++uWQMbqLt61znBxVRcaYXF5kCFxebhjPIlSm09le8KG2dhxT8xfK/cWo6NFzZie+Z2ZJYHKdRf/Nzjy4Oz/QZEsVn6u7EiVa3JPuh+LE+tUY+RO6Wu+WADTuV69oNFlMRXf0UpnVrneiyG8rETV/WSU2uAMxuAbZ/XajOBCt/7ePfHGL98vOt6xbrYDBqDt7cFBocDKMkA0ncBvz0MlPlR0IsICdUWpd577z3k5uYiKSkJlZWVGDhwINq0aYPIyEi8+eabwWgjEUS2nxEqH3236Yzi63qtHyXj5aKU1f1cHn5UYavAf5n/Ia8yDz8c+gEZZRnVa/AlwIxlRzDum60olIUeseVWlSY7VRCED7VKOK0tDv9ClwIOzwtW/gY4wy3JKWXjcTbf0w5eabGjsNyCSfPcoQyKCf4r3FXHSkyFOF54HJnlmdiVvcu1PPg5pep3+J54/covt7hEqUiDBiO7CG6pUrP3gXWFxYapvx7AxhO5Ho60IwVHgtRiL1QyFegkotSi0LYDEMI//nleEEZqCCtoyHN9+aLSakfumukey7/c96XkeYMPpcjcD+QcBk6uEjrQQUScxACEWfBf91xAVokJS/fXTrxQcSrJYPtMiXIfo0rk/YsGcl+J1Gtcj3eeK8Dlr67EB6ukgq23pMIZRZW4/dttGPXpJo/XlJxS7ORGwO4pxelA2n/CY/Y3qeehNw/+sBM/bD0rqRQaaJSqItocta/cC553/yZAgxalAGDNEUZM4HmgXIgS+PXErxiy8GocXvp/4MvzXauEaasvSjUYAjQB6SvRuVL43tLTS/H1vq89ls86MAu7sndh2ZllAIDMMvf9RnESN5AsfRL4oCMwawiwbx6wmEL/LxY0Va8iJSoqCps2bcKaNWuwe/duOBwO9OjRA9dcc00w2keECDZpIDvw1ntxStnsDhzMKEHn1ChorN6dUvIO0Bd7v8CWjC2u57MOzMKGcZQgn+WbDULIzp/73IKdyWaXJDoX0cE9+BOdUmIIBjvQ5kPpmtr+NbD8OeC6GUCfh4H8k0BCW4Djqn7vRY5V4pSy43SugihltSOvTPpbWewWiSUcAFCe63qYx4izbH4Jqr7nm6RI9z4Vj/tIvcaVXLvUhyDy+dqTmP/fecz/7zzuu8mz887zPLhQHbOVTO6XQmbwnnccMJcB+gjP9wSaovPC580bIzxPaAtcMbFam/hx2zl8te4UXrnhMtey6syeVlrtyCnLBOJiPF4rsZQgShcFAIrV3DSqandnLl7Yw85aDugjg/ZRrLDOunMdNRB/WHeufJBdY6eB3CllMwnXsEO/A13HAGExNdtuHVPGuKI+W3NSEhouIroSxGuRze7AuG+2SRygdgcPtcp9wLD3jAKTIHZXMNd5Nmdbrfiwk/B/0iYgtoV7eT0XQlYezsbKw9koqrDisaFtq36D1QTs/gFoN0y6H3xQYvZMgZJfmY/k8ORqtlZGcRpQwaRvYCtj13OUBA/2uMfyqcD2L4E7fsErW18BAEwvWYlv97VxrRKm9i5Ksc4qj75aTbFUADtnAx2uB+JaBmabNYUdA9itgFpbo82I16RWCeG488rmeJ1JkaB0r39+4/MAgKsaX4VOCZ3A8zzY6PD00nQAQEa5uw8csGqt3tg1V/r8LOXCu1iotlNKZMiQIXj66afx7LPPkiDVwGBntrUa5UHZjGVHcfPnm/HuimOA3HrMdCLlg2pWkAJCnIizHsDOzrHCRlGFFecKPAWEcLj3vdrplBIH5+zsqPXQr0D+Ka+fa3fYkV2eXfOGsyx/Tvi/4gVg/TvA51cAWz4NzLbrGKvNfTettDhwKMOzc1lhsUsGHIB09tq9orvzmFvuLhKxP3e/63HAcko5HIK4ATSonFJRYe6OlXjcRxg0iDQIAoUvl87ZPPd3l4dTAECpNcgdIxbGNQcA4JhbszxnX7D4pDvwExOCX1h9Z8tLvx/EhaJKTP65ZqFaJqsdZ7TK4tL2zO2ux0qd1nBteI0+86KE1SdYN6PVBNgC64AVnVL3q5eix/YnoYYohFR/W6wDRH7vZ2fCq4W8f2GtBBbeDfzzDPDX4zXb5kUAe4+QT26EOR3qFRYbKi12DP1gPR6dtxv70ouw81whLhRVQg07Fupeg2OxVDhm97v4e7Ah4QEf8J3dLBXV61kojLccWysOZeFIZglGfLwR/x720Tda95ZwLM4e7vdnivcbncrtyMmr9MwFWm1KZe2s5wIhi0kh761EBNnudNOuclfYq1BxKCo663pu532EnjHXGX+dUrkVub5ztG14F1j5IjD7OulymwXYOQcoqKF7tCawolQtJiNFUapfm3iXI11EnlOKdTwVW4Rj8f/m78GAmatcy/NNgpMti+kDB0w4rw72ADgViVrj19TiJ5984vcGH3vssRo3hgg9Rp3adZEprrQiOkwrCb2wKczeAcDszcLF9OsNpzG1rf9OKcI3bEe1pNL9eH96saS0ukg4597X4RAei4NzVggx8XZg80fAjcri0IubX8TS00vx7bBvcWWjK2v1HWCMByqclun1bwv/V70E9K//1wbWKbVkd7riOpUWu5DcmXP/forhe+WMKMUkd2bFEJPdBJ7nwYOHipPOIWSXZ6PIXIT2ce2rbviiu4GjS4EnDjSY6nt2B48Ks2cnM0Kvcc3E+XJKsU4QpZnrvMo8ROmicCT/CBqFN8Ifp/5A18Su6J7UvfaNlyOf0TbGC7+TzeQ5KA8WgQgfcWKrYaLscosJe41GxdcO5B3Atc2vBaAsGBo1yu+rj/DOQQMHCGJyJITZ7Q86Atow4MlDAXOeijmlpml/BnKAa1SdsMJxBY5llWLZgUyM7NLI722JAwzAc5AdMKeUtRJI2yY8Pvx7zbYZSIrTgbnXA70mVusexwrmWSXSPlRCpA5pBZUoN9ux5mgOTueW43RuOe7r73Zb9FYdRR/VUeDwUYD/znU8sH0uMacU65QqsXpe62qFwyq9fhXWr9Bab9Vyj2SW4JF5u3E6txz3/7ATZ9++XnkD4jFY6r/oKg7QZ103C2//9zYO5x9GbmVuFe/ygcMuFMcoPCtdbioWUilow4DwhJpv/yJATHR+S/fGiDZqMWfzWeVQMuZY53igkBE7fI1HlCamfPHbid/w8paXMbHzRDzR8wnllU44xZcymVi45RNgzeuALgJ4IUS5qtjvbjUBhugabUbc50adBnHhOtlr0v4Ym99Owwlyw9/7M8GpyxDhvK3kVgjHPZvrLqQTgiLZB4DUIPTtiGrhlyj14YcfSp7n5uaioqICMTExAICioiIYjUYkJSWRKFXPYEX+U7ll6NEsViKG+FXe3otTanf2bty7/N5ANPOSgR1E55S6L+g7zwlOij4t41x5dAAgAu51IjnhZlyi4JQyqThA5d2uu/T0UgDAnINzai9KxbVyi1IiNbwBBgSeB479AzTqCkQ3qdWmLH7kmaiw2GHneYBz36AVnVKMKOVtltRsN+OxtY/hfMl5/HLDL5IZvGsWCw7VFbeuQGpEqu9GHf1b+L/nJ2mi83rqlNp+Oh/3zd2hmHQzXOcWpSx2B0xWOwwKufFYUapIwbGZX5mPUksp7lp2l2T5gXsPeKxbbXKPCwOFmKbC80qZU8qYIIgQNpMkR19ICcGx0ZTLxq3qjZhjG45iRCDPvg+lWmUDN+vwUHJ7+JvEtkoqC4GlTwOXjwPaXhuYbVYDq8OKMTteQ+PkRHyWnSvkFWveD4hpLhwnlQAsZQEL6Tsny4uXzBUgBfn4cZsQjrl4Ul/0ahHn17byK93X/ewK6UCsxgm2PXJWhkik9YMKawU++ecBXFOZiV7VnHgp85GbJSFCj7SCSlRY7NL8bM5JK7XxNCL4M25Hnc0MaIXkwCFxSrFuPbtF6pQquSC0RxOgEKggY7Yq39MdvKeDTZFKz3tHVYgCSLQuGklhSTiMWopSZzcBB37xXF54VqjiCgDT67drSnRFGXRqGHXC/bxcYVJKuG+5JygKmQk/bxVAL5RdwOtbX3c998ehPmP7DADAdwe/8y5KsecAGzJ3wlldLpSOIDPzWQFwShl1aug1ajw2tC0+WX0CgGf4Hpu8nOM4t6tM5d6/YpVWNr9w0MP3lDi1hkSpiwC/wvfOnDnj+nvzzTfRrVs3HDlyBAUFBSgoKMCRI0fQo0cPvP7661VvjLhosNgckovInd9ux9m8cpzOc1+89qcX4dnF+yTVxTzwklNq6sapAW2vIiUZwHvtgVUvB/+zQoDocgKAC4XufZ5WIDy+vGmMZH02fC8Swo1m6YFM3P7NNhRUuG8IZo7zK4Y8ICEwOoX8NxG1zJVQGw7/Diy4Hfi4m/A8c1+NOpKA1Ckl0ipBus8qrXaUVFrBMU6pKsP3TAWer0PoHK1LW4fTxaexM3un4vZOFp302t4CUwEO57tj/qFSS51SdrPU1l1PeHzBXkVBKkKvgUrFIYJJIuzNLcX+lMXO0KLGVve6eZV5WHt+rcf7RPeBzWGrWXn1igIhpPWjzu5l8uPRGC+IVkDonFJy5LO7QWCx7lU8ofkVb2hnAwCK+EMAgDYWz/OlKlFK7iSsFpZyYM0bQoLxzR8DBxcDP4+u+fZqwaG8QzhZmYX1xjBBc1j/DvDDTQCb/NUcmMFMudmGwgqrK2QPAF7Tfo9thv9DE04YzB3NKvVayXXRsUWYsm6Ka5DNOqXEcPD2sYKTs8hchAprBU4WnsQ3+7/xv+KYh1Pq4hHS5xyag5/N6bivUfXvb75CixMihMFshcXmmmQCgKziSnDaAhibf4NtLZgk5859crzwuKtaGAAUmYrA87zEKRWQAR87mLZbZcnNnYVO6gkmm3/3v7SCCrz8x0EcSJeJO36GyDl4B/469RfOlZxz/QZR+igkGAUHk+gYqRHexI0zTL7WAIf9hhpxrBKmVcOoE+7vSnmmKmTXlULm2PRWzfiFjS9gc8Zmn+vJcxb6lYybdcizLjYv4lhQYY8R8fMddmDWtcCSB/zeDCtKAcCUa9vhkcGtAXj+HqwYbrVbXSYHjhGl0svSYXPYFMP3/jj5B55a91RoIm72/BT0oiJE1VS7F/fSSy/h008/Rfv27pCR9u3b48MPP8S0adMC2jgiuJTKSj5XWu0Y9N46PL5gr2uZgwcW7UzHxLk7vG9IvAnoo5zPhQuIvxeSWl1wjvwNlGUJAwl/cxlcxNV72AF0eqFnp71TapTkeSTnXieKc98Atp7Ox/KD7vAyE6fyKkqxA44wTRjSStJqNtgWURo0hMUK/+uivPcpp7DgsALntgBfXw180bdGm5Ino726XSL6tJK6CCotNkFcZJ1SDotw3P3xKPg/Hxf2L5vo3EtuNXbgxs7esS4Eg9p7+dzrFl+HsX+PxUGd02HFqaSiFFAvK/B5qwATrhc6SmpGmJLn9xJhj/Fi537+NisHw5sL+R+8udcO5x9GfmU+hv4yFC9seqH6jS847X4snnvynFLGOEAsi1xXzpDSrKrXqSXJXBEAoJ9KEKPsEPZDa4tnuCubZ6LE4hmCpCj8+sv6mUL+j68H1FiwDhTsYKeSDdErZsKF/Zxhn7n8KJ5YsAcWL45ncbIpHJ6DpKGqPQCAFdmfYMgvQ1xirMjqc6vx+rbXsercKnyz/xsAQAHj+BMHJI0iGiFSJ7i6Msoy8L8//4dP93yKb/d/69d38BjA1cWAzgvnimsequbtugS4Ralyi10S2nehyAS1wR3uUyEeH9ZKZJVn4dY/b8WvJ351vW7jbSi1lkocC0qhytXi0G/AP8+6n5tLPc+Z0vpTVVmeBwcAOqR4uhBv/GwTfth6DvfN/Q+5pWZkFZtw//c7Pdbzxh8n/8ALm17AqN9GgXda3KJ10UgMSwSA2jml5PcPkRLmmiG/79czRMFDEKWcTimFfkCBw91PsnIcCplQMG8OqN050hyIYr+LvRZrZZEGfolS7DU795jQBzy5GiipXWVTr9htgsC04zvP15QK3GTsAdL/q1aVXzZ8T0TMgTd3y1l8sPKYq2/FXnfMdjMqLXZ04U7jSs0e13Kbw4bjhcclfVoxfG/a5mlYeW4lFh3zbF+txihKFJymhOcXAdUWpTIzM2G1enYY7XY7srODP7NKBI4SpwASoddgxRNXQ6v2nqPiaFapkCtg1StA9iHcpV6FKDg7xuKF3hDjfC50ovx13RT5UULY66wqOxDZOafqDzOVAJ/2BJY941fbak3ucSD7kN+rs1Z9pVCx1okRmHJtO/RsHosnr2knGUwkaqU3XJUzJA9wOqW8hO+xyeb/PPUnRv42EuOXj5eEYlQLpbAfayVw+A9gRirw73S3MFieD6x9K7h5KFgHxTGh/Gx18j+wWGWDu4QIHaLDPOPqS0xWQCUL38vcB8eeHzE+cxnu++ceOBhRKldhkA1IB9+seMvOKvlyHIgzflvDnAIHx3mKtxdROIy/KOVXAwAtUy1UTHYuF98BIKfEBKvDBm3Mdqj0majkhWthtMOOBKfIl1+Zr1h971D+Icw/Oh8FpgL8ffrv6jee7UyJgqB8UBee4HZKheL3UerglWYJYs0n3f0W/MV9Xl0czq4ID+F4T7R7DhRFd4GDdygmQq3V5MaFXe7H4Unux0r7vjQ7qElR2WS85Wx1KTbxvB8DTLuDxxfrTuH3vRn4bM0JPL5gD0Z/uQXfbTqDt5YdgcPBu9y4RgVRSg/h3nqqbBcKTAU4UnDE9dru7N14buNzrucLji5Adnm2xCklEqWLQmq4EF7MVlg6mHewyu8AU4kw8cRyETmltPKJnmqcq+U+RKlEZ1XRSosNGYxLXXBKFbme56vVrs9dfX614raKTEWBDd/7Zbw0VKyy0DMnXoCcfKHApBC+lxTlOdFTWCHcR/LKLPjo3+N4/tf9WH2k6n5EZlkmbvjtBry8RermN2qM0Kq1SAgTnFJ5FZ6TIPIKlt6oKJDlJRL74qw7p5o5ky42RPEwjAnfY505y8ONGJOagv16d3+sQK1CISNSeXNKiaK5iNluRoW1QiKqeDilUIUoZSmXprHIOy5Upv7pFqA8SMUAjv4lCExLpyi0hw3fU7hO+XlPkzulAEjSI3yy5iT2Od2ErEPT7DCj3GzBX/ppmKRbItnmtE0vSSY95NeonArp/vpk9ycYtGiQpB9cJXvnAZ/2AvIUIgu63Sn8//UB4LPeQPZhz3WIkFBtUWro0KF44IEHsHPnTpdSuXPnTjz00ENUha+eIQ7WogwatE+JxOd39PC5Pv/jzUKy7C/74Q3tHHys/Vx4QQzfC3PmDaquKMVU7FHicP5h9P65N9757x3PF9kQk3VvAbt/9P1he+cBBaeA/77xq221wm4TwnS+7Of3LJWvxMwAEGPU4rGhbbHk4X5omxyBcMYpFaOS3mj6l/7uemziOKmV2MnS00sxbPEwj+W7c3Z77eRWiVLybHOJkGjbYQM2fSj8DoBQtWb928CcETX7LH9gRSk/q6p4Qy4UJkToEWuUDkwqLJ7he8v+XYZ1q/5AjlqN3QYDduXuRRbjxDlVqjzTyYpSbIfKX1FKxCU5mIo9Bbm6TnZ+ag3wwWXAiX/9fovdyywZ6y4UnVKuc8puBXbMwr59u9F7xmpszV0KQ6PfEN7qYwCAiucR4eAR7xREvDmlDuYddOVBAARberVgz0Ox0+aRUyre7ZQKhTNE6TPKsoG1bwoziH5Wz5SU6PbCrT2a4Lae0txuDiGlN3gI18kkJVHKOXtabi13OQ1YFIsJ1AQ2D0jReelrGXuB99sBC+4IzGcpwA6EytlrF1upyQ+nFOvE+WTNSfyxNwM7zxXi9b8P4+sNp7HtTD7SRacU5/n7hzlFKZNdaA+bCPiDXR/AbDfj6iZXo2NcR1gcFqxPX684kRGli3INvNmBh9cKV6ZiwU1gtwmDhP++lr4uOl9FQlw1ycE7sD5N+K5y94RHLkUf+LrXJ0YI+6bcbEdGkfu3SSvOgzrMfUzmiyK8tQKbLmyCEoXmQsk9ojqi1InsUmw5VUVVuMpCT1E9lLlyji4VnM9ZNcv1p1TGPilSOR/WNR0FwXrrqXwcySxBPNz7kofyte+7g9/hbMlZj+XReqG/nGQUtil3ShWaCjFk0RC8vLnq1BT5WbLrVHwbz5VMAU5wH2LE30mvUSHM6dJxhfDzPJ5JSsARvQ7PJbkTuleqVMhSuwUTV06p8jxg1/cu8VQ+VnHwDvSZ1wfzjsxzLZM7c6p0SslDWPNOuAv/BAtfeSAlOaWc+4G9vyhM6ny46ji+WCcVcdyiFOOUYgQqADiaKRxrrBhusVtgyxIm6MtUwue2jG4JNQw4UXRcsq580ml/7n7MOzLPtc+/PfAtCkwF+Hzv596/r5zfHwbyTwB/PyFdrjEAl93k/OBsIO+YMM4l6oRqi1KzZ89G48aN0bt3bxgMBuj1evTp0weNGjXCrFmzgtFGIkiICc0jDULHalinFOx72VOgEOHYsBMAg9X7hAdih0fmlPKXqqpefLJHqP7405GfPF+UzODzQlULX4QygR6ba4DtrFYUeLXvsvkjlIgKc3eCw3RqSaJzIy8MHsJgQlsuHRbG5WFScbBZyj1CMJ7f+LzXwZxSiIxfKN0YzaXS3+r8FuH/ua3ODwtiBRL2xusj2bs/yHNKJUToEGuUDq5KTFYUVUjD965O+xg4uRq5TAfpvNktRJQ5f0f5bBx7brA3ajZpsF+ilHgo5B4HeLuwH5y5LFy/l90KFDt/B1MJkLYjIKGuVdqsl08Vfv+fb/V7m/6E/ouunV93X0BemRnY9iWw9Cm0/X0kAEAddlayfpRD8OskmIX9mWfKU+x47svdh/MlzMBQwR3iE/b8sJQLgk++bPbOGGKnlNI1W0k8qwJ50mDWfTuicwp2vHgN3h9zOd66pQv+nTLQ9Zrd2RWxO4X1RIU8L+LxLw6q2XLqQC3D91jYfSF3cG53CiQnVgTmsxQos7rPc+9OqaoH/VXdS/anFyO9UPhdmxg9j/MYrgyAHVbeWdWVuRZlOnOwTe42GUOaDQEAbM/crnguROoiXUnoWTebh6Aj8vMYwU2wczZwfLnn6/IBgyjohsjx+duJ3/Domkcxfvl4yfXaBvgUpXiex1/7MnAyRzh+fYXvNYsXBslZJSYcuODc7yoTDqmmQhvlFl9Ep5TJVIztmdsVt1VkKqpx9b1rP9yAO77djpM5ZeKX8FyposBTlAp2qFjhWWDzJ8LnLLgDyDkMLLqnRptSCt9LjpKKUq25C/hd9xJeaCNc90/nlSO7xIxUzi3YceDx46bjMJ3fhll7v8TJQu+5HgG3KOUtfG/JiSUoNBfit5O/Vfkd9CZZ6J+SKFVX4Xv/fQssniD0L/zkZE4ZFu1Mw8Id5zHkvXUY9elGV9L5MJ0a4U4RpMJiw4/bzuHqt7xfj0/o3PcJ1/Vnw3vAX48Bu78Hz/NeowI+2/uZ67E3l5VX5BMapRnBDw3XMg4/eaiixCnlvB6o1F7Xv1BUiY9Xn8DM5cfw35kCHHReh0SHJ+uUMspEqUMZTlGKue4cyT+CQycFh5QoSrWIagGLKdbja5RZyyTjkt05u/HWf2+5CjKJ+BNl44F8UlYfBbQYIF1mjK/+domAUG1RKjExEcuWLcPRo0fxyy+/YNGiRThy5AiWLVuGpKSkqjdAXDSIoWJRYe6OVbSxeoN2FRzuEDqxwprNDJ7n/RY1xPCxnIocPLL6Ec8ZP19jWtEGO8iZVL3wrNCZzdirvL6kakyQZ1jZG5A4M8HzwLeDgc+uUMzl42v2VMUBEbI47ggm0bnGVgE17HhX+zVW6Z8V3FFOzByHqcV7MWjRIBwrOIa/T/+N8cvH+2z+9sztmLF9RrVL5bpuePf+BXT6n7MBpZKbtL3M2QkIRZlilRoOAL9GhOO0tci9vJq/v93BQx41Fh+u9zhn5mw+i38OZiGMc/++Fo7DIPU+5GgYUcou7KcKjoNVLQwKm0Y2lX4mE8rDnk+sKMXOMFWFLcsZMhOVCuidCenF32v+OODDy4Dz24HvrgW+uwY48qff21Zi2ellGLhwIHZl7/K+ko6Zpcw/5XN7PM/jXH65h2Ote7MYj3VFsX3J7nSMn/Ofa4Br5MVzRjqzHe1UuhIq3NejcgUXWYGpAAfz3aFH1Q5zZTuHReeAlQq5GFmnlKU8eNcqh0MQOKqo8Gfm7RJ3mBI8z3skDR7awZ0A2qBVu8KSNGoV2iS5CyIIciAPq1roGCs6pZxilPg/UheJ61u5y7TXKnyPDdNkxY3Cs8L++ftJwb0TgtAxtiNfoaq5U6oq1+3Os4Wu8L0OCsX1krhCcGr3cVHknNDged51z47Vx6JPoz4AgB1ZO5Bemu6xnUhdJAzOY5kV0L2KUmnbhP8HF/tsv4vyPGDvfCE0/OCSqtevJWLI7tmSs1Bz7ut5qUrlU5RafzwX/zd/D675QEg+7St8r21SBK5sFScJU1Zpi8DL3NCiKJVdnuF1cqnQXFij8D12MkEckCoKf5WFskTnEK5ZwczdOetaYNVLwMqX3Mtkk6b+cCK7VLg3yEiWhe99pP0c3VSn0GrVBElhk0ac+/fO0KjxzaH7cM/ye/Hxvi/wvz//BxSlIVqrXCUzPkwY+IouwvzKfEl+z+rkzPFPlAqdU2rt+bX4at9X4O12YNnTwnl53CkcZewVXEo8j00n8vDuiqMe4fgP/rATzy7ej+eWHMDpvHIcvFDiEmfDtGqXM6fCYsdLvx9ESUmR17ac1rmvMya7Cdsyt+GunNU4rdUAhedQYinxy2Vrc9iq58Ytdt4vxfu4tzFJIJNrqxkxVZ6AX5JTynkeswUsZBNTbKGlMV9vxahPN0mKY4n5OwF3TimRfelFAKSu35+O/ITnC//Baa3GlQsvQhsB3u5ZNbfEUoKVh896LGeL/YjrVRu5Y1AfAeiMQEqX6m8r0FzE+Y5DRY3L1bRr1w433ngjbrrpJrRr1y6QbSJChDt8T9o57NncU7n2hgGMyBMWAwDYWnYOAxYOwIUy/9wvoujx+rbXsSF9Ax7+92HJ60qhGi5E901qd4BTCwLZ308C3wwEzigkrWMvvLVxTVkqqk7azYpSzhvC8axd2FuRIXy2Qp6WEoX8NyKRBi1UzMx5mFYtCd8DgAhUYpRamDE1MwOtcpUKy22C82P1+dWYunGqb6EAwLbMbZh/dD5e2fKKz/Uk8LxbbItvA9wghEbBbhHCJp2cS3MKVOGJ7vcGrToMh50GPV5JjMfr+UwHtBq///70Iqw45Bm/nhCph17jeRnVwYontQvdH+X8LbJZp5TzfXnOZXq1AfEG7zM0rDjoT/ge24ESzyBNidBRKtIlAVpn2WRxgHvSGT63YxaQe1R4vN//BJhKPLfxORSaC/HYGh+l0lkn2+HffW5v1eFsDHx3ncfyz+/ogaEdkjDv/j6uZWx+o4MXSjzPV176u0U7ha7UEiEkOKssS+Ja8Ya3MD+vsGI0m/ODJZypvvfno8BX/YNTJXHB7cDMVh6zuoUqFY4wnfnxRf9h5K8jsTdnr8cmZm08jQEz1+BIZqmrTzX3viuw8dnBuKVHY9d6Bq3sPGEGuA6ew9WaHeA5YQMJCqKUyW6C1W6ViFLT+kzDo90eFTbnsNYi+SkjSpUzv+c/zwCzrxMmOn66JSRuHIlTij03JPlhqr52+bqXAMDOcwWucNdW0Z6hR0lcEcCIIMXZgjO60lbpurbE6GPQOb4zwjRhKDQXKoYpReoioXcOliSilFLhDfYYj23ps/0u/nkW+H2SUJ1w8QT/3lMLWEeexeF+XKpSCTkSvbDrnLs/wPO8yymldP8I12nwwIBW0oUqz/6GeO8o8HENKjQV1qj6Hlvd1OXqUhJl2fA9p/sHq14CPugIlNUiebcvxMlI8Z7lhOd5XCi74Pd1YMqifco5pWThe/GceyDbvZm7f5zIue/Jb8bHochQgiNMTiP+o86wHVJ2OjWJEEKY48PiwYGDnbdL8nv67PfK0MmTpMe39liH97NKYHV55793MHHFREkY+2NrH8Pnez/HxmNM7jHx2Pnz/wSX0oXduOu77fh87Sks2imd8Did5z2lQKfUaITLwveM8G9Cwuaw4YGVD2AfTPgoNgYoz3VVPYzURWLZLct8ph0x24RcU7+dqNq95ipkk3SZ8N+bqyeQ1XVZt7BHnjfmvBc/k81ZJru3nS/wPNcrLDaUm8WE8+7+lUEmSh3JLEFxpVVxwvSITudyShnUYRJRSnSe2hw2/N8iz3Bk+SRhqbX6YziHfL+IkyO3fe9eVhfFfy7sAt5IAjZ9FPrPvoiotig1YcIEn39E/UEM32NDwgBg9r1XYOborn5towXHDNSd4XvPF2yrlrtGzCl1rOCY4us+Y7fFnFJRqUCM1GWC5c97rs/emGsaY281Ae+3F5Lm+er8sDchcwl4nsetK+/D3akpKFCpFAc4SkmZRVhHG+AZvgcAsRxTaUQhSTOA6iUHBKqXW8puEcLDAEH00EUoryfOKLMumeI05XVri92MbKdDKcPGiAyH/5BWR/FCemEF/vfFFkz+ebfHa/HhOklybddylMDACIZW50/BOqXOaYTfUwzpi9HFI4x1Q8hgZ4X8EaXYSjPyozTdHg/EOQc9SuJtgPEZWsXmhauilPina5RDIlJjwvDd+CvQr43beSdPum23uveHBjbInVKxzhnLlDJhYFBqLXWFKYm0i/WcgFESpc4Un1FcfrrotPT8Y79vlzHux6xTChBEwmBUwzu+XMglsfdn97L212Nq87YY07gRVhuFDuNBu3Bd+evUXx6beGPpEaQVVGLi9+4KrX1bx6NpnBGpMe4Op14j7biKnWYrgDQdcLN2FQDA4HAgysvscam11F1OXReFCF0E7ujozu8kn8lOL03Ho6sfxY4sH9VjAWlnXl45LJtJyF3LAcSiY4uqbAsbpisJ32OdDtVwSilVEgOAogor9qYVAQCaRSgMzFGECLV7kFzkDJMTB846lQ5hmjBo1VpckXKF13bE6mNd4Xts+LhWpcXi44sxbPEwnCpyTliwwluEn877EFdMYoUoSa6mKpxSbNGEEpPN9fs0jvV0CoTp1BjSIQnPXNceA9slQqdWgVO5PzfMeX6IOaUKTJ45CcWqrL6cUkuP7MH8vZsV28uKmkUVzs9WOu4qC93V36KZXHGlmYLz9qurghe25BQxbQBOaTX4ZM8nGL5kOH45/ovv9zk560X8SIyUOqWiwtwiVbem0ejInYMeFolT/axWer8BhEmo8uKzip/ROEIQ7AvL7YBd6CedyHNfe9h+r8+8hTwPXaVsglNBlPphnR+FBWrAT0d+wn9Z/2HDhQ0er51b486HxZflCDmdxMnYIndo9Ils6XGlYa57116W7JrQuOHyVLRPiXSFi1VYbEI1PoWceFVh4zhBlHIKeklhSWga2dRnNWOT3YQ3t7/pkbReEXFyI6mj7/UCOdHBTrzJRUilROfscSWbtFMSpcotdlQ6q+/5ckpZ7Twenbdb0Wlu5jjXfU2nMoJ3uK9/ycZkcM5+GVvQQSS3IleS/L/UUooKa4U7VDZjD7B2hk/nt8oh74s6e8fxrYFhbzq/QBAnn4rSgIV3uVOXiPxyn9AP+bcaJoAGSLVFqcLCQslfTk4O1qxZg19//RVFRUVBaCIRLMROh3zwFm3U4tYeTZTe4kEHzjnDrtIKsbkArAoiUkp4itdtiKKUN1eC1xkjh93dCYxI9pxZzT7kmXuDnQWvaYx93jFhgFB83nf+LJlTiu0Y5qrVihc+UShUIlomHio5pVpzGfglMhz3pyS5K/PIcA0AqoHdX5cGO8OgCxdi1hWEqThRPGP3AdNJCSjWSpQ4Z2byHWb30fTX48An3pP7i5byE9llXqu9JUTo0atFLFolSmfX9JwFVmYQYnHeaHPU7nPtvFb4PXOdg/VobRwMPkQZUZSqsFZIchp5E6XYHAjyJKxF2mSgy23Ck30LZC4c5rsGyE7MhiFK4HmpY7CKwUvTOM8BnDciZQ5Qa6X7fI9HCeRSXazTnWOsLEKcQYhnOlF4QrLOTa1vQpQuCv1S++Gm1kJyTHkukLzKPNz4+40eBQTyKvNw0x834dpTc90LRSG2WV9g8Avu5cZ4aX4IQHCC+OCvfRn4en01zm22Qyoeq1GNgdvnYbNzsDUzTuqalec8Y/OxZBabXJvSOQfLTZgBt4dG7hTt50RHYVLTMKyIF64dMQ4HtF6OuzJLmWt2VKyYxCbMlofwTds8DevT12PCigkosZR4OiiK04E5I4HzTAfRl/jHXq+qGXaxJ2cPXt/2Oias8D15x94nylVeumjVyCmVGKnHoof64tt7euH/hrTBzd1SkRotPbZSDJ73nSSuCI3VbtG+2FYBlGaj6Jwwgx2jMYLb8C7gsOOaZu4iN53jO0u2kxye7ArfY4VajuPw6tZXkVmeide3vS4szGUmpvysPCZB431AWRtyKnLw4MoHseb8GskxVskcD8VViFJsjq/rP9kIs7OSa+MYz2uaTqMCx3F4ZHAbfD+hNyYPbg3O6ZTqbjJhSkERAHf4Xr7J87op9rnkOaVEUcpmt+H5/+7BjH2TcLoww+P9bF8kq8R5L1HKF+mwuoVbeQiM3SIkIPenMnJN4O2A1ojXEuJwc5NUzDog5LV9Y9sbyqs7w78dzvt5kix3lIjcKWVg3E8DTOvwj34qPtB+IRFDyhTO1aOMK0SOKErtTSuCzSr0kT5a53avs9cqnyH6lYVQywfaiR1c/XGRnNzcWjhJlTEx/d/c/74GvrtOcm0qY/omz6T9hQELBiBP7OczfXGzLOw7ghmT/N+QNph97xUY368F3vyfcG0Rw/eKK62otNoRhipEBIWvbeUAlOe6rkkJzhybBh/XEJPNhD9P+Uhp4HAAZzYiM78QO444+w4JVUQSBdKVw45H5M4ss4IoxU7iyMYy5/M921VutqGCqYIowj7u0SwGBq0KG0/kYf6OEx7b2IHWrnNCw4UBjFMqUheJCOd4QaUgSp0uPu0hsD+46kH878//CS7ubwYB698RiinVBFcezwCH6bPpF359ADjyFzBnuHSdYI1/6hnVFqV+++03yd/ff/+N06dPY9y4cbjyyiuD0UYiSIidJHn4HuBfFSUA6KASBlW81gDohUFCBHNYGTVG/HLDL3h/4Ptet1FkKkKBqcC7rdzbfbQ8TxiocSphEBfbwvONmftk72EGkDUVpdjOsi9LNDvAtpRJ3GMODopVz0rNPpxSst9JcEpJb8aPdbHhtYR4bA8zYE6MtFMicqLI80YxqMkgr58LAAdyj/h83YUrgaIWUGuRWVyJUrhvOid4QeyM4cphs5hRWsrsP2+hTApklWdhwooJWH3ODxeXpdwlSpnBI1utxp2NkvF9VKRixREAOJxRgr5vrcZTi/bhQpH3Dk9cuA56jRr/PjkQn97e3bVcD6tUlHI+Zp1SaVrBryOGYERpolwz4Erklhfi4IVibM7Y7HW2noUdPJllp3ORLgloP0JwN5ZmCK4xkSDEtXt1O5pLvHekis4Dfz4mGaj6Em3lVFjYdXlwjAMmkSvyCIeJE0PGTEWuEvZye3irmFZYN3YdvrzmSySHC/mScity8c5/7+CPk8I+FIUsq8OK7HK3C+xowVHXY1cXXBQhw+LcOfkAp1NKNlitYvbu/+bvwVv/HMXhDD8doOy1ULymyTrkGUz+BwBQq6RC97Esz2uo3jmgBqRCemG5bODkdEp9GhcDANgSKRwjkYZEaA3SJEdiUvNSi9spJXZe2dxEckdeWolb5L1q/lWSxLUAhOP+nMwpIhahGPkecMu30tfYSY1qdlzlrjtvsE6pCi9uV/+cUmLOSC16t4zDtZcl46lh7fHRuO5IkA2647Se950wzoIWmrOu58WmQuDbwSj6WwjFjSnNEaoz7vkRg5oOcq3XPLq5ZDspxhSX+4AVpdjfyiWasPcZ+f697CZg3Dz4ROu/aO0X5lLg3+l4d+OL2Jq5FY+vfVzSbjaxe6mKAyq8h9FlFbuvc2yV0EbRVQtpUQat63plZCqEukSpMk9RKdkoXJ/kTimz3Qyz3YxTRW7BcWfmfiw7vQw/HPrB/X0Yp5Sr7b4G0ENeAlK7Kb/m7TiuLQ47wKnxW6R04svbROYPW89h4Lvr8NUGQbyXRwmIJMrOD4657jU7PhcAcL36P4lTvYzzHE49lpyAHQZl4UsUpcrNNvA2oa+WXuIWxNn7d4Wva02J8NsX8hF41voAjlzzvVBB9DapEBjJVbiE0EDBurcL0rcBadvA73WfoxXMPllhyoDJbsLvBmEZzzikLbJ2ifnWlj52Fbo2iUG/NgmYfmMnVx9YDN9zqMqhNp5EmNrzetjZ7N5/EXY19LK+1T69Hl/xhThZJLhsxITzerXy7wX4kbfw8G/A96OQ99UNsBQ7769RjT0EQgmBdOWw9z+/nFJMH8kPp9SKg1ngeWHSiR2PsE6pq9slYkBbYV/mlXk6OPehsWuyRQUDeLv7+heuiUCkMwebklOqyFyEC6XutDDl1nLsyxXGeP+c+ce9YoZnVINfiJEbgRSlTq0F3moM7PhOeH5BIW2K7BhwVLeicwOixjmlJBtRqfDkk0/iww9rqE4SdUKJSQzf87Qd+0s3lXBBL7VpAINw4Q1n+gNqTo0OcR2QGpHqdRt/n/4bAxcOlCyT5sNxb1Ay0yPe1IwJgiPHyAxkml8l/D+xQkiKue4d4blElKph+J6/IYAypxQrSlVwQvhemaUMi/cexo9bz2LJrnRsPul9ptVDlNKqESGzLV9u8MxTxcKBUxQxnu+jEOrI8NmWNT5fdyFeXHVCvqL7v9+JLJN7lvEI1xoOZym4pTsO42wm095qVHubuWMmdmTtwBPrnvCrTSXMbOUXsdHYb9DjvXjl3GkVFhtGfrIROaVmLNmdjgwfopTOmQ9EpeIkFUj0sEqqH7pySmnc55qV47A1zIBcp6skShUJg4/vfzArC6M+3YSlJ4UwJ9Hm7K3DyobvmWQd5mJtktBx7fOQsOCvx5lXeS+Paw7rlJKIz/K8auw5s+BOYPf3wFx3MuvcUv+TWbOJOhNQAj2T/y6RK5YkcQaAODF5us2ERkbl0KEIbQS0Ki1UnMqVoPbPU3/ipyM/YdrmabA5bJJB68E8d8gEe965ihCI4aPGOOHvxs+A/30jDK7lTikfoWPsdbGwwkeoJAsbNunMhfOHQY2n1j2FSLV7cL+XGVRpOOm94kim5/WPDdNjQ5by5aKUU4CMlCWtN4Y3gdYg7cSLSYFLraWugZDolFJxKpcwlVeZh492fYQMhUE6Dx7f7P9GulApObJ4fBpigK5jgAkr3a+xFfCqOcPNOrpsPlxAbMiDV6fU+a1A1kHJosJyi0T4c93fDZ73d7ZiqFGnZpL/S2mucTsyi0z5QMkFFDnbJIa7IusgYg2xuKbZNVBxKtzR4Q7JNqL10S73ASvisOeJ6/qQx0yYyPMRVRYBLZl+QkQK0PdR6TpVlWmvLqtfBzZ9iKyz7tCkEqbfwIrOpWrGKcXzwOE/JdUbXW4jGfER7CCYhzZug0exl6gwrSt8z8jzrpxrrvC9Is+wb1E0P15wHGdlIWSlllIczXO7Ko/kH8FzG5/DuzvfdYXCsOF7GUXOtitMpAEAGvcErn7ae7i+r0F5bbBbfeeGtJQDx5a7wnle+VMoST9zuTDR4a1CpTzPl4oRpVRRjVyPw52iVAXHwaIwkctzHHI0yv3rJKOwnTKzDQ6bcC0z80Wu19nrgE+nVJ7wXU7zjbDIPhiZCX2F5W2uAR7eiowWtwAAIlHpUR21trDnwnln+KKNEfnLFfaJheNgB2Avdd/72cIlFpsDVrtwP2sSa1T8XNGZY0haCmPzWchL9AyJ7lrp7nNE2zmPvlWlSoXPI/WYfXA2AHfCeV/XZo8iTHKc+cO6WA+gnXPCHsY43wV9vJ1TNYGd4GP7Ug4HYCmDHcAHsTH4vuiA0Gfw5ZQq8LwnvL/qOADgriubS/JIsY/jI/S4yplGQct5bqNEzaHc2S/gHAbwDvdvrEYYYg1Cv1ylVR4L7c5RFpy0YCb15OkifEz2OtjXglHxeOU0Yd8unaLcNsBd1RfASa0W/RZchc/2fOa53iVAQEQpADh16hRstiBXMyMCiphMsFG0P7OL0gv6aa0GU5ISkKQTOjbFVg0O2UpxX0oSTjKDP9FpECeb+ZZu2XPgK3EVsbH14kXUYQd2zRUei7knwpjPaD1Y+L/5YyD9P2DdDOHCFIjwPTZRni9hSy5KWdzfqVzFAdYKXLXgKry6byxe+vs/PPXLPo9NXN/V3QGSh+8ZtGqEoxKHdVr8Ehku7EU2/EGBltGeyWMNagOidL47jYezLsDqsOJw/mHfFnBxoOZMFnkoo0TilDqnaooiCK/lZWdKE1Tumwfs+dFnO0QUK56V5wE/3YqK/QvwxsrJ2H5GEG9grRDyfTjJloc1ym5A+9KkM0yiU4qdDfrm7p7489H+kvXCPEQp5iM4DjyALGcHtX+F0AH4MyLc5ZSK5MJ9ilKcuhKctgAbM9YCgKvyWH5lvsuFsfrcanyy+xNY7VapCCLrHGbpnMdB/yeEmTz2OGZnzJztsdodSFOYOasui44tQr/5/dyJQj1EqSKmkfuF/4yQnFMq7LflTwxwnRtKg24AeGigkFcjOkyLxpx0gJvIFYFTyUQpJoSxsV75ehWhdQ+6xE4sGyZ5vPC4KxwZAA7kucu3Sxww4u9RIopSzgT3Pe4GLh8rPK6GU4qdAffbk1DKilLC/pmmN2HluZUotbs/K4MRmTQyp9QhBVeWUuJmwDMZqvhbx8uSmofpEqCRDW7jVcLAvdRS6ioDHa1zd0JFweezPZ/hu4PfYeSvIwEo31vYkBNTjo9wR1EUbNYHiGnm+XpJOvDtEGCLf51H1tGllGtD6TWlQR0AIXfGV/1dEyQF5Rb0f2cNhn20weU68FbIBABimYqhsUYdNHblcztB7T5Gip3X0CKnEBIt/m7O/TljwAz8c8s/6JrozkepV+vBcZwrpxTrlGJdB657PHtPLpOFUVYUuCuGAsLjYbIwLVNxYAtmnFkPQHocse7JbKYKqpDo3Pn9zm8DFt0tJHR2kuNFlIrQu69f44fYYEhe5lHsJcqgcYXvGR0OxDsH8XlqNXgA+c79amQGWGL4XkZ5hkQMBIDb/roN07Y94Xp+uMDd9xDDkZXD92THrTEeaDccuNNZKZHNEcmi4CIKCFXlLv19MjB/rKvCqdwBVVShLEpxMmcX65Riy8W3Ugni9zmFfFJV8ciPgnOWdUpZwUxcMkKUT6dUriAUnHCIzivhvNx+Oh9H+SbIjxDCx+7UrIZmTWDz1bB92qUR4XgnLgaW0+4JzDKVCrhlluQq/GVsNIY0a4x8xrnMhoGzVSnDdbJ7hhO9RgUVB2hjBIEiN8ZzcqFFpfv+GWN3QF/FhKd4vrD381WjV+H+Lve7nJ7v7XzP5zYQ4U5Tkigmxw9PECbORZjJCQABzyllA/B6fCxmZ212p91w9j02GMMwJyYK75UeQtcfuuLxo3Mk7xWpsNiQV+Z9AvDRIdLqjmzfNz5ch/5thHNErfb8bhVqhzuk1aGXJDrPL+VQUi48V+mViyT8wibPZ9h4kpmIurAHWP+ue9/6OH9sbGoOMcl9IEMqmeuF4qT70aWSPFLrjGEot1Xg6/1f4/j2S0+YqvadYsqUKZK/J598EuPGjcPYsWMxduzYYLSRCDCzN51Bx5eWY58zyWmXxtG+3wAgwSA9maYnxGFVuBE3NxEGhmZo8eSJhdgZpmBFP7AYqmp2StiEqGyH0DXQ3vEdsNNph+zmnJntOR5oPxK46QugmUIoac5h6axaTauRsGKTl22cKT6D02z1QXOJ1CnlTHQuzhCr9dIOeP828bi8aQyeGNrWtUzuaFPzNjTncjC2cSO8lhCPVcYw6UyzjGgHj9Yxngkww7Xh+HGLu3MdJh8MA+DV5ZiybgrG/j0WPx35yb1cfpEVL/469+xHGe/e3jF1exTywqygxlSAME648e10OOPuT6/32n4WeRgRAGDNG8DJf7Fp+RNYmLkRn69+Eii+AJhLJE4ptsx6Jce5k7Q6yS+X3oyPO5NwPn1de6hVHHq3jMOwTino2iRGsp5R5/59Hu7f2CN8r4LjYHIuur9YOBbWhBuxx+lEieQNMHjJXQUAKk0Zwpr8CIvDhB5JPdAvtR8AYHvWdgxbMgxZ5Vl4Yt0T+PbAt/hq/1eYsXSv670mpi12nkO+VphFh84INOom/SB5dRIAk3/ejQEz12LzyWpWmpMhzkq+vOVloaMtunXCk7x+tojF5kChcxCRFGnAmzd3xsODWuPXyf0V17+yVTy2TR2KXdOuwcxB0mN6iPEsUtXS6qCxzGxto5JsKBGh8xSlWPbk7JGc56woxQ4MK+TXQ6OCCCZ3SlkrhbLSaZ4lzNlOvd+qlMQp5d1heYGZ6T+evhXfH/oeNocNqw5nY8EOwUmTzORmkYtPX93VEz2axWDa9bKEr87raJGsUIBaFQZOFkYYaxGu+2WZe5F3QKhqye5/MbzvSIEQ/mXn7cgoy1AUpdgwypILPkR8NhSMrRIqsvEDwYq/8kXv22Dw6haUIXFIeHNKiTiLFHyy+gRs0ctQErbElZRaFBXkOSMBIDbcPTCKC9eB89IJr1S791+JSgU7gHxnXjGXU8o5mAnThHk4osXJDtEpxX431inluo+wgrhcsJbnSLFWKoeFlSsPZqqDazDnbKO3qzLPJi9Xqdwh6KIDzxkK6nDwyCkrg6Hxj9BES10dbKqEjs2UJ3ajwtzhe+EOHik2G9Q8j0qVCme1GqQ7z9FmVvf7xfA9JeRFGA4XuUNKRNFWdEp14M6ja+V/MFnt4OXHycDngTsWuq9feuWk+qGoWqmIWM11hxCGy+a4yy01o8iLUwqQHVocc01jvktXTvidz2k9hd8PM4skz38a+RMmdp7oev7fGeH6V2a2gXc6pRwq971DMonhyynlrJR7ghdEqQqLDTklJoz9ZhuGf7QRJUz/K3zn54C5DOVmW5XVOf2hRDYp+1N0FPYzE43lGj3Q6HLIP6lArcZSk/v+ywqg5RZ3VUqNQhEZQBANw3UaOKwxXtuWUOk+FnnODl0VolSjcGEsw05apISn4PEej6NFdAuf73Vdv5RyYhoTpOdFp1ukrwdUlDJhh0GPRVGR+LBwF17f9joWH1+MJzc+i18iw7FAFua6puiI+7dhvnd+mXdhX69RIS5cKqyxE7YReg1aJ0agS+NoqFWeQrxZbXFNyqmsDokodeSCFacyndEHOul1/LJ4oYrhqWLliSQrmPBEczGw9g1g8yfOF73vY4uKceMFwykVzRTgUkpRkr5T+B/VBEjqBBVzt5m984PAtaOeUG1Ras+ePZK//fuF2ez3338fH330UaDbRwSB1/4+jErnICZSr0GzOGWLLIt8JrXQKQrYOQ42ACbokGn1Enp2fEW128i6DdhQPpPNJCTsW+8Mxxv2JtD3EeGxPgK4fT7Q/U6geX/gqielG3WGPYn8+Z97QGK1O/xPAsl2jhVEKZPNhBt/vxE3VexziwHmMln4Hge7l7wgkwa2xk8T++CPR/ojiakCE6aTDS7StiOKc/8uewx68D4GO4l2u6IoFamLxMzlbjErRh/jsU6Zfj3Wpa0DALy/833kVebh9z0X0O21Vdh+mvndxUSoWvcxpefcv99pXRsUQLhBa80FLqfUf44OAABzqffwRRZFkdM5GClyOo8yOLtQ/SfrgMQpVcB0dPLVKqBSJkrJbsgnc4R92r1ZDHa/dC1+nNhbsU1syfsuKXpJ+F4OwrGTE/Jp6R0O9DSZ0bvSBAvHIc3Zob38zO8Iq+IYVBsyYVAb8Wq/V2HUSM/bf8+5y2PPPjgbe9PcIR2sKJXGJ0GifcmrXCnkRVl1WBAwfth61mf7fPGB7Ab756k/3QPPxPbCf3OxLOm6G1Es1Ko5xIRpEWPU4bnhHdAmyUvICICUaAM0Kg7tzy+ULB9uXQWrWvo5sXa7K69TcrqnaxGApFx0q+hWHq/vy9knuXaxidLZgWCF3AHDzqaJyMXhykLgm4HAd9d6CKmVjChls/t5HWMH/WW5XgferCi1vvAQ3tv5HhYeW4iv15+C1c5jeKcU3NbT3fGSO6WGd07Br5P7o3m8zEVhKoIdbgeOSJQmwUOQiHS6ckq2fYF8mzAwZkUprVo4h9jrgreEtK6QSrsV8TYfSc2Za5jF4ClAOko8QwR9weaB8+WUYgt+lFeVi+fUaljtDszbcRL6hLXQxW/ClCVbMGXhXtegUylvDhu+Fxuuc82kF6hUOMkMsNnrJs9xyI9thTMq4RyJZsJdveESpRQqWkmcUlDYVplMGB71Ebawori32e9ailL7cveh7/y++OnwT65iAP6cUaUqFVByQZhlF0VeZxsP556DKmYjtFGHEJa6BADwzHXtMe/+PlAzvzHHuYVx+6YP8ezfd+HLvV8iyqB1O6V4B3QAGjsjE25skoojzkTczazue61ScRl5+K0S4vVLrA64XP885upmYt2mjZJiEQCkzjXAe/heIHO0+JlvRV6JE5BeG7edzncVMNk17RokREhdVOzvAvYaxRyXek7YRxkqz3Osm6x/F6GNwPhO4xGn7ojKjNHuzZlt4K3CeeJQuUWechsjTnvbf/mn4Di/DTyAU7zbKZXGhK6fKpFVRss7hWs/WI8h762HyWrH5pN52HKqZpNNrFNKJIO5XxRrNEBksqK4rmMETjbkXHR6sQ5CJcJ0avAOneJreocD0bz7969UO1BZxcS4KKgrpbfwlWcKYEL+FEWpeGmY3PXvobDbJJjgbLu4H9J31myivCxHqOa2YxZgM2MfE26/5MQSvLr1VfybsRmvJcRjizEMHM/jA517HODKc8pMCBT7EGuV7ifsRFS4Xg2O4/DLpL6IDVcIm9PnINtZ8Kfz0Vl4iHOHx/MOg0ug5VTSNgxtNhTNIt2OZXn0jQ0K4ynRbe/lfnvWkYwtXV5zLxAn0wN6vWImWth8Us5q9Shwimx9JwNJHSUTlpnyisWXANUWpdauXSv5W716NRYsWIAHH3wQGi+x08TFg9lmhzr8BMKafA9OU4x2KZFQ+ZHUXCObqWnNdH72GPTCBdbh+fv3rawEzm0RqnIoEG9wD8Z4u/tiyg7sJGFIdhNwep0wcI5u5s6JI4fjgGumA1OOAt3vEpYdkZYzP5cpdC5KTFb0e3sNHvxRIQGdEqybY/F9wJIHhBvL6fXAmY04V+LOI+EacJlLUcK4vypUKlgks45C56hdcgSeH9HBZR836NynqE7NYdGxRXhm/TNCh+v4ckmzylUqifggJ95mQ+soz4E0O9AGpG4QJey8Hb+f/B1PLNyLYnMx7l8yC2WWMiw/sxxm8XfThbtEvtace/Bm10S4nFJacyHCnKJUBi8cB7m5/pW9V3MKF2unUCq6ovLUaojzb6xTiu005anVwgDf5BZD8mW2ZTG/QeOYMESHaT1L2zvhGItKrM4hcUotidVgcrIwcx3tcIAD8EpeAXS8e51WxSd9hu8BgN2chKc7fYsW0S08HG1nS866HtscNmjD3PlgTE3dJdvT+ESpZTlCNqNeKk3IzIq18vCH6jDn0BxcYNyD50rOuavPJbgdgd46Zjklwu+SEKH365olwqftAH9hJ3YYI7CvnbvyWamsoxxvdwjXFAARGUWK22KFwGh9tCtZrcj+vP2S5K+swMCKUh65gmSiFM/z4OVVgNgKcQXSHDKVFrcoJXFN+YINj7JVwuzl2nHB6Omk3Z+735Vr7aGBrRDDhIN5hOl5o7IIxSqVy23yU0YWrigOw/pdLcGXSF1skc7v+15sBHY7O91ininAPWjIZMKp2HxeLKKbCsVpUEOh0yzi3P8H0ovx6zHPUIaSEuY49WNCg3UG+euUEo+TPdGJOKRTSMp8cjVKK62w8u7jbPPpC/h1zwX8d0YQLqt0Shm1roHR8Kap+F+TRjjjDEeSnyNpxsYocl5nXU4ppRwZTsS8X0oVrdjv6brGsNsSHzftA7yQAbS9BnfM2u5+XZzNvvs3odqYa8O1E6UeX/M4Km2VeGfHO64cUbwflxvXPSb/lDsflqUc29L34/blN0Cf5J6cu6ZjEh4Z3Ab92iRIrmVsqoIjG2bgn/x9+GLfF3Bocl05pcKd1+6WVk9XldoS43qcbEzGzW1ulgi1iUYFx58M0dEp5FtyH9d//LseRcVFsg+UiQJykUokkM4DmVvL25mnFOLPDrbfXSFMSoZp1YiP0MMuyzujcl6X4lEMgHP3rRTE6EyV58RuvMMBHXOfjdCGI8YQg37Gl2Ar7uVaXm62weEM34Om2FUZkBWiFJ1SZTmo+KwXRsao8ExivCt8r8Jik+TK2pcr/V5lmceRUWxCXpkZS/dn4s5Z23HHt9tlhUF8syF9A5YcX+LhlAKk/atClQrQR3lOwgAIY66BElHK2Y7wKkQpo07tOifkxDkciIAFKpNwvA8vL0OJF9eViOiUUhIzfVXkA5gJB9kEJwDB8cyGFOsj8Xzpbdhud16zrJXA2c3ArKHA9zf4/BwPbBbg427C2Gb5C4IopffdR+tkseDa/Aw0cX5fUSBiJwTE80SnsM+U0iWoVRx6No9F45gwJMSYcK7kHAxaNXiF30elLUGpWoUkmw39srdjNOd2jvJ2tyglouXC0COpB+7ocIdkIrB9bHs82s2dU9DKewpPeSYOzy7eh9ISz+N0iX0ABlk+xEmOCc3XBkGUYq9XrEFDHGflO121ca2B6CaSkH2l4gkNnWp/4yFDhqCoqMhjeUlJCYYMGRKINhFBYH96EV754yC2ny6Asdl30EQegT5pmdf8H3J6JAsXIrEaECt+vB8XgzKtVJRS8TxeycvH2zn5Qu6NtG2KlcWimASYZcdfgrVUCPGYsm4KNqYLoQnszXnbmUz3oDWxPaBWrp7i/oBGgmsK8Kh6EIkKWGwOLD+YhdxSs8sN4gsH78CjeRvxSgKj0h9YJJQi/eFG4PtROFPgdmCViReYg4tRfNQ9c1+u4mBRcEolR0lvfuxNQadR4fVtr2P52eVCpYmTayQdsnJniJg3+lZWolVkE4/lbJ4cwIvg46RPoz4A4Kp4YUheCiT9hL7z++KZDc9g7gUh3xG0RteN7QLvdBlowqDXqpDPC7+50ZzrmmnM5IX9qVWYeVNC0SnlbHepc5/bOc5VnaiU2Y82NvmyWg2kbQc+6AQsEaz1efKEzBDcOYkRvm/27ZIjcMPlqXhoYCtoHBYPy7rKmYQ+ynkeNLPZMN7srlSVbLfB4CNRr628JSrOPYQwlbA/w2SVpsTfREStcXf6TBp320/zjSTOGg+nFCsKOWzIZUS6OKPyzGRNKDIVAAcF1wCa93ffpJVmG+FOci4v1+2LowVH0WfdQ7gvJQkTkuPwpl44N4tUKoloCACxDjsQKQh0PR3KLhh52KhoKRfJLs+WhB5bHVbXLCo7SPI4T5l8eA4HjzFfb8Xnm6TCDM+GthadlbxmYhLY+l1hyTnjv8IYhnfjYlwJrOVkGGM8ljl4B3Kcv0dKtEEyq13VPWVvzl48s/4ZZJWmu0L3Iu0OXG624KqclsguDAMnSzbb3eQ+BkURixWlxPA9lvOl5xXdrwUm58BBKck5i7OD+vWGU8iHZ849jrkvVZYV+d4WpM4gVqyUI88pVaBS4Z64MIxr3MhTQis6h4rSQnBq93vEgZqYWL7KnFLhOlcup0rnMbDdINyH5KLUBS4MJWpnZUUxp5QPwUG8vyuFhBea3eeJK7RRyXVliJbkKnrHOk54cNPnwv/WQ3Dw5pU4GOYc6P88GjhbRUJiH0jyLzl/Y3/OqBKNc5/mn3QLY5ZyvLv9c491v7qrp+txn5bMuc9c/1lH79KzixHtdB2EOddpYfUcPGut7uPUoDHg9f6v49/RbgetknuKDZ8B3OdHickqyflo5TnkFUgH3WazSVqd1qtTqlJakr42MIM8Hgo5Ip38eepP3Nw4Bfv17msDK0qJ1cXEc8EuC53nOGCUait2GR7G1qJjuLJ5E/wQFekxaQMAOQpOGg5ABPN7RkBop3ycX8bklOI0pah0io0Sx6SS06PwHNYbDbig1WBFRDgyIFwPyy12ST6gE8XSe409z33dY53PvkK25Dyy+hFM3zodu7KFPvXI8kr0qRTO3UyjW1QoVAm/UYXBc2LD7LDC6EwUX1hudV2rxZxSRp0aS44vwV3L7nJfsxmMOg04TrnNsXY75tivg/383XgjNx8Tiksk9/uWFs9zx1deVSWnJ4trwsFL30Wea83u4FEJ5zFjLXclSEfmPliKc/DBymPYfd7LtlgydrtdQHYzyq1l2GT0nSO4m8kM5B1DSqGQzzLLh1OqbbLn+eytYuWih/pi7dMDMWHF3Rj12yhknVoJu91Lzl1ehfdzOYTxPKLYQicOvYcodVnYLfh+xPeI0EVIRPVwbTge6PIgKs6PF5oPz3NkzckSLNqZjp82HvZ4rYIX9r+keI5LlGKuaTYLcGG3z2TpPnGO8+wA9hz/3T0usJuFySyxHxIviFKsq7C0CiG1IVLtb7xu3TpYLJ4XApPJhI0bNwakUUTgOfnT4xi363as+MOdD4jTlGLKte38ev/UoU2wJCIcfVo0xQpjmGSm/5Bej50pKvAq90CXBzC6tBxxzIn8fk5eFbmlNODt7ov35NWTAUidUlN/3+3ulHhLqimnxVWSnABF8d0BAJFcJQrKLRJngc3u+8JztOAo1lvz8WtkhLSjmnfc9fD00d9dj9lOfXGu+8JYzqlgZgcmTtu+XJRiE25qmQtUYXkOkHtEyIkkblOlQqXCjJQ1vz8eKSzCPcWlaGFI9BCdjFrpLJ+v3+jaZtcCAA7kHgDAQxsjFfqWFwrVbc6XASdyhO/3jPUhrOKvAO7/Fzq1CoXO8L2ISvfA/4HrBwAAwuz+JZ9n22h32FFqKcWzljPYEGaQuKKyNVL3lJw8tVooa24pdXUM5E4pQBh4q1QceJ7H94e+x+pzqz3W4TgOn97eHVNHdARslZLwPZZo5hhrY2+L97Jz8W5OHqIdvNecUgNTbkbl+YcAezgqnTOJ8oEemysHADi1e9BssptQ1G0SMvg4fGb7n8RZ4+GUYrGZcD7fvR2rj5xX1aUo/4TQwQ9PAjreCHuYsxqiQl6pA+nFuP8HIfa+Om6tqRunopK3YZcz192RsjRsuPkDDGjuKc7qeQDONmg4B9qbq+6kt4hqIXlu420SpyTgvn5Jw/e8O6UyS0zYcbYQh3Oln8/lMfmPigQXXKnJivwys0Rk9N8plYN9eh2eTk7ED9FRWBGuHMadZ/IM7TBZ7bA5eKg4IDFCj0hG+FB0Sp3fJjhKS7Nw9z93Y/nZ5ZhafhgFzgGlmGRezIvyqf5+yduvL6/AA0VSwVqSU0ru2ABwtjgNVrvnvnAN8GRuMw+cOb3sDh75vOegKsxa5P6s9HTf24LUKeVNlOJ5XjIA3W0w4LaW7qSyZQrXd1NxjuRcF3MPiUQqiFKsuBxr1AGWcrB7yhQpzKKXyj4v3a6BGA0UI97bFZyNPZJ6AABu73A7AOVBXRETBl9hrcDRrBLwSknKZQPaL+03orvpK6DLaFe1wdFfbUFeGTPQ3PW953b8wFvlLW/XcpZivbM/kn/KHb5nNyO97LzHupq9PwrJ6gF0bhyNRQ/1xabnBktEqSzGcbL87HKk6ISBucsppTCwVjOilOgeTDQm4t2B7+KtAW+5yt6LVJx7AA6zdJlLlKq0IQrlOKDT4V9jGNRwoLJMOsh8b+VR9H97Dc7lO49Zbzmltn0OvNUYG7dvx5ML91bLleMBI0p9HhONa5s1Vlzt0z2f4pROh0nJwqSLw8G7Qlqfua69a70Y57lgd/AAZ4EmSnCAqzgOr2iF42hqYgLsHId342MBawV4ADsNetfkQr5C+B4AhDH3SzE0XyU7lsrMdvC2CPA8B45zINPpsmOvA0ohZbCUSoQW3jmcKzfbJJVOyyE991RiuBCAfenuczfXR2JrFvYYPZgvuFGbWCzo5LxfZujc/ZJSODDklyHIudGzMnuFSoUETvh8i92BcmefhA3fm751Ovbl7sNX+77yeH9aQQXgxSmFqM5YbL8aZfZEXF9a6eFA/zgnF3fKxFixr+3qV/EqrDkqTNywEwpKWOwW2OwO2Mq8pJ8Y/hYQ2wK4QchxpNeoUeEUpXiL1JWzZen3+GTNSdzyxRafnyk0jHFiqzXoWyxUPtT7EFAud/5OyRZBEMx2iVLC893nC7HNmZKjUbQBq568GkM7uCculSY5AMEtVWkvQ06lcO1b/cd9MDmU95utshlmNfoG6cZOrkla94tSIYzj3cdvElMV2ag1otxiA28X+i0W3nPsYIbQ1nwFI40oCuaUmpFdYsKPW8+iQgyptJlwKqtAEEo3fQh8OxjY84Pid6kS52+0ItyIe1JTMKhZY4xo0gjLNHagNEsQFTkVENMcSO4kmbAsVKlgDWThjnqA36LU/v37XfmjDh8+7Hq+f/9+7NmzB9999x0aN1a+ORB1T8+oEnRUnYeKmWEfFnYBvaKK/Hp/ozA7picKA6enkxNdFsMeJuFClqW3SWKAeYVO3IBKE7bdsU2SgLNllKwanN1zYMTekDmOKQFcRZiZi5hmwJXuajbpqcMBABGoRF6ZWTKIKzP77iyxySeVQuVmRUfhy3y3HbWMFaUkybY5mJmZds6ZdyklyvuMjI5xIPClmQDvQFmk+yJdolK54+YZ15q1ojUmFlVCC0BnM6NpJJN4D54iFJt3gndIb0CDmg6ChtMg35QPTlOM5rLOZXutMKjfkWHGvbOFhMzH+aZ4wPwkrImCqyTPOcCLswqilINTIzxeiOeP4Mv8mpFg21xhq8CKsyvwjy0fj6QkuXI0AUCWM4TPW2n1PPks6/+z99/hdpRl+z/8mVm97d53eq+kUgKE3nuTXqSjKE0RQVFEFARBOkgTkSIi0ntL6IGEkEAICenJzu599TLz/jHtnlmzdoL6/N7n8et1HBzsrDVr1qwp933d53We56UUXCuGTXqHyiXtS/j94t9zyYJL6EyWkIlkBiETL7mQqRB+38ZsBQcmUxyU0O4F0VNKlLOiWr8pqSdvTk8pZ4gL1Q3dfayf/VN2zdxBJxX2RcFQoFQuyUYBlLKBWf9i9Ce1hC8//Thu/vwO5lVKvB4OQccK+z0geXhqyWbznxPqSyx8XMIJEAFcuOzWktvHZWvfc9PFCZXT6H1MhUUnNzwO1vStsW1jjF8iUyrlvDcEo3Ojcmd6TriF3mp+3vVvM+e6N+kcFDrK6Uypaz68huOeP84Ghpix6D7Y/Ak3VVWaL33q1qSiRBjV/NpYAK9HJhrcBlPqoQM1RumbvzJfWi7nNXkHlsn8PwoaOP13z6FFu5iftOYBv6JSyAV48P31dA5mXEEplTwDAnBkhCmd0yuUnWqJCrkO1hcU1VxAADBiV/0YrOPZsnXb/lI2UKqEn+DHrR8XmbN3KNa1faIsxpuOSnh2sMv2rEsOUMrZIAOshTgYnlIJm2wgXa6NxwaY79WlyQu9U0jK2vFVGOC6i2Tl3v3v5ekjnmb35t0Bd/mL2OWqNz3AQbe+R3e/S2Xd8N4Qopcy/rhwLbN+/QbPLm0hnVP4VLGABlcD9O2ItX3Wgr1KGF+djDG36NXnErXrG55Lb+WB8jLW+7wklGJJuvrCRRq7Wo+dRlcxrDJsM8NvE2TiXakuoikNlA4LTFsjru7q4eLNVWQKVk4k+uAcNOogDhtzmE2aX++bRiE5FlWx308G03MgnSMmpfhxXQ2X1tci+7pJJwfJoi2Werz1PDEwA4B3V+tz4TZysjUv3MwzS1u48+01Q243ZOhgzaAk8cfKbTfpMdgG8WzeVNkeOt3qauzTx6u8ohKof5FQ81+55J1LkCXIoT07ecft9HY4xJmN9dyoj5+Gj+Vp/QMEFIXv9/YB2Dq+yTr7QtxVrqDozCCPyRDZGm/nlfWv0JG0fPVcPaUyg9izL4NpVLAV1tpUu/eOp39D8b6ArsHtA6VEI3DjGMsVhRqvBsq2Oh6VrlQXnyWKQfuELFEjdBs0AGaTKSWwb92YYrNHlSHJ7vn6mOZJOkgn0U9x8Xp0Ls9PK2a6fvaP+/+RQmo4iQ0XcNbDWiFMtBNxi6yS5d53VuHVO3NmVUdeWTsRLl4Gc84AtFw+repg6DdvQavFcq9ueZNS8cWWfrORBUBXsp1DhzXyu6oKvgj4zJnjjP5BzSPTJWbqeU29Pn5Y8r0M/ckcx9z9IY98pOUX5SE/4+tjTBOaYZViSqXzadb3W4Wed8JhBkqwGAvJkSQUP5sDY21ZztGe93hWvsG2raq4g1IRX4REpmCBUkrxnGo8vwGlmIFrgFKdgxnO/8sSrn5uBbcutNjpY+8dzZsv/pWtXyzQXtgWs7pU6CD6q7XaumvA42GLz8f15SFrn+XDweuHxhm2tUpalpn92BzOe/28f+67/w/GdoNSM2fOZNasWUiSxD777MPMmTPN/+bMmcN1113HL37xi//JY/1v/AtRP0wztqvxWBNdWaIbXrxs+3bgoF4bZmx1eW3gW++ieY+rxYmok93x051+yvzm+SQ3adIpyWNHu3OFnG0SRM6WZEqpqspzn7ewttMl4d/natjtEjjhUQa9WiIRI0lXPGOrKoldQNxCBMhMDxbdN6Pd4+G2qgrb9iVBKUkmIy5MdBmb2MXKiEN3aKQmGuDAqVZFs9CvTfLxOstLo93rMZlSaj5KcuN5ZLr2ohCfSFrS93vbDhxYM8sm2cvq11DJaqDjAaMOMN9zUmlfW54il9JADE94IwGH3CyjV0ZSasAET8zfn8qRKyh0qBUANBQ0GnzBE6KiWtunjIq6HWaPYrUumUvaKtyLhMV1u9druwbO6HbQYz/4YjWLN2pJudipp1n/+90t75qvPfH1E8U7THTB7bPhjauL5GFGlAuAy+q0fUEctIFS1v2tCCCjcV7dJDFiqEI73ng2xWOLNmGkxLZr45TviZFLs7HnfwaU6tOrj0+ofTy84mFSEiwMh+D5H8JnD1sbqgUa1vyNKgY4YkYTF+49zn2Hjkjmkq7+EEPFQ5/1mX9/v6+POak0V3T38tPuHuZu3I1TRE8btMXeUeOO4pfzfmkyd8SFpXEcmULG1kre5rEhe20L77Z+7boNCUr1bSSdK5gguljxzugg+9PfPM2q3lW81+LCYH7vZkBlfcB6Vj7bhheF/Tdp39ugg7WifG9ITylB+pKVJHp92ndWqBK/CF9NRv/NG3uKmQGjBA+diKpw7TOf8esXv+LwO95nQ5e1oPISpuBgf4hhspR0ptRt+WM5JnMN38k48hddHltQVF4u7MTHymTUQ/8AVY5CCtDRVizpcca25Ht96T7Oe2Po5PPOygoura/VJABVGiCai3cheUVQyg5CujKlBE+pyrAPsnHbODkoS2z0elmnA/x+RfvN61JZUrI2fhkV7uxgt+mDY0TIG2JCpcXC3pb8RSEHUp5sxoUR4iL9Abj+FY0Z+qOntAXdQ4WDWOTRGFr/rFTsq26LzTxYSJuLPCco1ezi59Sjaq992r+KnwfS3FZVwWmN9a4L51L+beI81urwaN2i+3xF9DliUiaLR/FQWShw3GAcT7qeuOoOShkh+kdKelc2NW8vbljyPY0p1amDY6q/l3wqzvHNDewxchjn191GHO2z97+3nhPv+4hEYWg/OVWff75qLSHr2Z7Q879nY0MDYM7o1zu3Brwyo2qs87ChS9tfQVHxlX8GwOL2xcwaUUlWLwYpjpamX/u152dBOISKxSjcJZXmo41b+F6f9vv8ivA5HVgS2e+pXMEEYQwJ3yMr7+cn7/7E9n0vrdjAk586GHeZuM2KwMghk9m8rbCWIMQemT9wfvYS7fcPrOc+383c4rvbtrvtZUq5sbbKFIVqfQ7bqhbvpzNVXMBLSBZTCqDHAKX0glk0YN1LkktL2Qv3GVH0mhHVwSp8usy4T7XfJ5MzWU05UTnK9bOz6maR3HAhStravyjJv2H+DUWfyRayPPvRCvPfp2WvIqX6+VXuNFf1Ra6gmKCId8MC2GJ11I3k3GV7H6/r5vA73+eIOz8wX7t544ts8vl4tLyMTfp4cWA8wQ/7+okJeea+iSRRZKZER9Cgg1UNet7f4vVo49w71zH4pv23lesAVES/FpK/E8lXbHOiqAqnvnwqp71ymvnaohJFLrUQINc7j2xBoZsK23v7sIoJSr9j+xJMKW+YeCZngup50kWWGX79lY1txWxvUb73ud6J/i+L7b9t1uKfoBoM9X9WfqyPV83D7V2i/aoKxr6rdeN5f4SES2fxbXma/SfFdoNS69evZ+3ataiqyieffML69evN/1paWhgYGOCss87a9o7+G/9/iWC1htIGfdbDqYC7MZ8jZAlTF2uEUVWt0we49bJ9IbZPIskKdRSqixSsL2kNHY3RRu7Y5y4KCc3oOD84zbbt+oH1tsqxJOVQjcHBYaq5ZGMvF//1c/a9eSErnUmPLwj7/womH05S0hdSUoqueJbOge3rOgH2ionJlJp5Mkw4iBWB4kXk4N4/tfYtACAaU8qa3H/ifxQ/OWpjxYPPnSfN4qMr98Hns46tMKhV5pPGYIbmj2QsLBQlQCE5hnzXQYDHrBgA/GDFO7x/vOVP884qbSBObriA1JZTOGXyKcyp1zwvsj27m9t5JS+/eG4FuYS2GArUvs5Wnz1xHtQn7yRBJO8A/up3TKCxL5kjW1BNUKqWPu1YfRGqy6Mk9EkiObDtTjAZQf+eyCfc2SBoQN1QVW4nU+ravy4w/x5ba91fzRXaPbNwi3Xenvj6CVs1E4CP7jSlG6WYUgEhcf96MMT9+UPMf4vyPVVgDarCZwxmXylQSslqoGvBI4K5OdoHrH9vPyiVtKQZQNIhDftobTffe3SJbd/mMW/D/LlPB4w+zVgJq3k9Xr3Stu33B2/jQu9z/HCfcds0QDWPrfUj19edHmqn9w/wUGs7nVI1fYq1WClTVB5u6+DUgUFOGYgzNlN8H3llL7/e7dccN+G4ImmMEal8qug+SYjjYs0EW3entn7tXBqVVNfo3Wgzhx0U2ntv01OqkId4OzlgQLKu0bfxL0jp0qFGndlZNhRTSuyWFWu0vdUb1c5Z1fQTOO7kc9hplL2qL0alkGQnJJlPV2gJXdtAmu5B6z2vWo6adelmqIfJUtKrlBvUBj5TJ7BBdTAGvSFUVaWgqgwQ5cTs1WRmnuEqG+/t2bYf4baYUqK8c8+kCzgjRP/BN5iLKiXeVVK+11wRcmXfisb0XkmCRCeDwj3Zpeb5S3kMVZLYJZGnr087N/2ZXnIeOyjlLyTouvuAIZP27UmqJTlNQF9E5IENXq8285cApYwwvIBSBPkwqsnL/6kuVth9rnKqQlrvLuyU24p+TpI+zqXUPElJokXwRewvwRQoYkrqIQKXrY7PGlJXgykVU1V22Xwwz25pRUZjxCTzFeb2ilL83eLYZyz2VMUBSqV6QFFIJlNEJUsipnjjKJk4a3VAZn3qM/Mzm3qSfLyuh78sEoCTYTtBpR3ANUCpb+NfVBS63GnhNrxznNEX1z5nLLSNS2D8W7NOsK7zzcfPIBzSgWnH5erUr0W318M6n5eE/kxUKAoiBOxRhfsmW1y4TWULZpdDw+x8UXtxEeGbzm6uePoL899Pfv0kn/Z+TU48Lp1tn8gWigCmTWo9n+odjoOpDg7wLOEYz/tEsMaZrsHtuyZuoFS5olATKp1HtCWK2YIJWaJGsvJ0ozGDId8LC92m3SwlRtZo77t5oFaFqgjpxZEBnSn1l61t7J1IcnNHJ8QawB/lyi7tO2/a86aSxw72vP/QMcUs3mw+wzxFk+MOqGEWqZOZlnmQPxUONpnLBUXl8UWb2NKbZCCdt7NvhVBKjKNPL9EK0ZuEIuH7AxbjcJOei4/I52G/a2yg1OiaKbxw/FvcP8daj9Tra7cFkTDnNtTx26pKXl57Hx5ByG3ME1rn7zyRkffwTuJy/vHNP2xz2Lq+dazqFewFhPAKeWC2Zxfia65AzVeQzVsF6lO7ysj2zWW/RLKoFOct1JLOFWjrT9tyrNVtOQ6+7T0QZJhOm46Q7jkWkoqBUkPW2iHkrqmcYoJVAOUkaJZ0hnvnKnjn+qLOwKXCLIjq52nQUawsIEG7DmRWWeu4lLe4iCT6Z/6nx3ZnoSNHjmTUqFEoisLcuXMZOXKk+V9jYyOeEpPvf+N/SZRp0sox9cJiXpbBWU0baNWkHcLAGPB6ihJOg2JoMKWMxGV8Gq7r7Obarm42KA3kfA5pRD5rN1kGmyljPj6F3+9+t4mIr+l10LzlHFmjLbFjcbBFaIP7vUeXkMm7szriqpaExUjSHc+Yhr2A6TlQKmxdAQ22Q8Vwuo6+i/cbxhdtv6hvNZ/rYJU4YCZkiawwuVfI/UyT1hPwFT+SkiTh88j2LoRtWnU4XmlVcwqSxBajuqovaOt0kKtKtY6btuV4/riH8A3apKEWYuQHp/NNe5Kp8qV8f+JN5Hp3MbcK6GbZma598CpVyP5uEwS7Sp/cB3WJUq8aIzTsEQJ1rxEc9hggMKUc1RHFGyLs9zKAljAP9Gx70E8VrHORyqVsUhAx2kLl5nl3M9p3glK1Uj/e2HLkwFbOyP+NvWQt0WiqCNESb2Fd/zokJEaVjSKei3PVe1fRn9EXIYoCy58y95VzX3ewPm8l6t2FML/Jn8qLBe08i0bnIlOqsJ1MKbUQopDU9p/3WPe1JGVt7bBTWW2SX7i602SEuEUhm7QBTimHXPOk+z/mlS/buOb5Fc6PkleHZh0OSgp5YE3GkrW16QvR1ZXNfBgK8kw0Qr/+nI31tDGmdvuq41vjW7n6g6uLXn/56Jf56OSPOGLsEdZxtB/JuxW/5qDUdfSp1jnvV8NclzuFriqNfVEr9QGl2WKixxFARaACgF98+Auu/eha23s2plS9HYhv00HyzFBMqf7N9MSt69LaJ8j3cgUbQ6woaU90ACo9LsmPGEMx8RI6oN5Qro0vNvmecwzrFSSUDs+ZPt1EvTJYxQ7DKnjy/F0IuoyBzsg6pB+qIJdQ8lGT9el+7AmUQh56NwCwUdXmmh6HmfmG3gxzrnuTBass0HQgnXMFpfJxzX/imaVbWNXm7ou3LU8pY3xvDNZwR3snRyRKMxf6JuxvmeMnuh3yPet7Tt1lJB4XHyqRzVZFH4VC1saU6lKzvKcvyA8asABy2W8VscRFT13XJ/Dl30se73ZVeuU0fl2QdEtVBYcPb+LVSHiboJQYvQaQn3EHpZZu6mXPm97h9RXuXV7TDqP1AVkmsWNxsXWOIO2tKiimh0uvR6Z7G1IfsEv/FVXhlsW38PqG123zWFuJbtbhAy02QzA4wvTtbFWrSOTr+HlXDz/syLPfze8XMdhEppRigFJOo/NMD+pfjuIvifOo8VhA6XD/WvZWLKC/P1V8f65ut+59ddQepPf4me19xQSlto+V4xrZOAq4FgGHijtf0fwvDfnRP763K7NGVHDL8ZoE8f7T59rGyvqyIHUVMf24rUhLEl1CMe6TYJCszoarcLBiqgXWUEe3Ns+JdhHJbMFkBqm50ve5IclVVZVP2z7lukXXcdbmZ22FL4OR9+7qTt77RrtuMaGA00uUvGofWysl63p1/QtMqfKCQk3Mbt+yQzrDgWVaTtyeKAbtE7JMDf1E/No5f+D9dWTyFnNMZN+6gVLGcYQ8AXZJaX+PKxuNR/Iwo3aGCWoZc/rMTJbbO7oYni9oxRF/mJMH47wfmMpBozRLj0Xrujno1neLvuvY8ccCsNewvVzPSXbRPfxavdP2fQXd2N7IF+58ew1XPfMFJ93/Mf2pHKkSRacQ7rlsj6MBT2+6lz5hvNios1pH5vJQPtw2Psd8UWpCNZQJ/rH1gvx3USjIE+Ux7qiqoFIvFoMFSkX8HiRvwmTk/vLDX3LEs0eYecZnHRZA7YwJgge1WoiADoJn8wptijbnHpdKE2g92Cydz0hrx55uPxSpUMulT37Obr97m40d1j3xxoouvTO2bALsYuH/0bIY9wxvQfL2mV2+B9QQS5VxvFuYznuy1hgj4cjnRLDQJwnvbXwfFt4A/zi35G8F7bpctuAy5j46l3+sftoEpeK6iuTUyVo3+B6PTK5NB5oFckEiWGwnIHap/0+P7QKlnn/+eXJ6Zej5558f8r//xv/S0EGpvkKf+VJClopb+j5xIrxyObx8ObccP4NYwMuDZ8wtYkoZIFT97j+2vV6T9XJkPEG5orJSHUEW+8Knq7NY5mAwA7SQePajME0hjY3j9GfxBDo4LL6IP5XHSEshzvjzm+zz10O5b/l9NubAhu4kN7zytavpb1ynrUekDF3xDB2CH8vANphSPYIvjJFYbvWHOOLZI3hKB36u6urhJJ1x8VrLu5zW1EC/LBXL94TJPStJxCJhdh5dxTPfPMMflvzBJlEDu6+AwbRwDmCG3MLwgqpzkQMC0LnS+luyJ64H3/Yed729hccW+hGHCLPDlRKiVt7F9plmfYIblGXWqU38uXAAnpBW2fGGNwDaudXke5W2z6r6RGn4+cT7tg1K2ZhSuUTRYsKIdo9snvfmfB6Pg71jmjw2aompP7CR0LDHiYy5nV1bH+Bhv1ZBa6oImdKOydWTuXmvm/HLfha1LeKity/S9tH6udZpUo+cC+Uc4PPcdPPvPh2IG9TvSdFTqrJgJQ35fDEo5ewEB5CPT7A0+OLXy3l6ktY5S2bzHHP3B5zx0CclF2gAmVTCJml1SjKNsHVg0iPr6HZphOG3AdDh9bBF6Ha11evh5zVVHBvNcX5DHb+oreah8jJU4KuKXo55/igWbl5YvFNHvLXpLQazg0ysnMgkwY/L6D51xU5XcNCog/jOsF/wSOFA/rhlBN2U04W1MGj3DeOBwqF8EdVo17W61MAtee9LZnn9C+v5lCXZ7BTzdc/XfNz6sW37pJhk10+1vWfJ91xAo4oRgASFLPFuK9Hf2m8HpcTnoQiU0iV03bofXW0+T22+GEB0gmy249c9PkxQaij2WrcwhucSNlnRcp1ha1wXSZIYVjm0V5oR1YL0Q/Rcy2UjKNnS8j0VlUTvWihkyKketurdQY1FhBG3v/1N0UIgns67glKBXD9vfNXOpU8u40CXRQ3YWTCDQjt0g1FoLrKUAhLwm+hkvjv1u6772tDXYZrjS+leV0+pEVVhTtmltMTl54dO5vi5w3hiy00cPLyJjqjFUutSMibDdEK4zAQuZL/2rEYVhaIrXig9d24XU8qTIoB2vv9Srs1rN1ZVfitQqiOnz1Fpd3nY2X9ezMbuJOf9xX1sci64B2WZAZfrvUvKer66vR4TGOqRPfRIQzNEAVtDklfXv8qfVvyJHy38ke25bfe6F3rD4w+APa+Aw28jGrPm/1a1mh5inDAY5zvxAdoG0nyyoYc1HVbu1p+w9pnPGaCU/XnLK3kGN75LA93s6V1svq54Bx3ymOLfuVWYB+7e2MTF/7CzJ0ymlEuHW4COwTSvftlWBKaJkUr38VI0PKQs3xl5YNUGzZfQYEbNGlHJM9/fjbk6O3NKUxllQWtsaom38ONAmmUBvw386ZVlOr1W3vxhKIjq0c6MIc3/a34vAOZ0jiCowAW9/azaoptmC0zWVNYCYbw6a8Q1dKB5IJ1n04DFRrMxbqXiMXxvwaBaRS7qIlqN9Zx0bqenVEn5XvlI22t+VSVmWFsk3UApiRqpn1PnjaQuFqB9IMOidT20p7bgLfscUXXsBKUWty3mp+9prJ+wKnFbexdPqA3846jn+PCkD5lTP4eQDnY5PbUACrFG0zOwPG/d1Sfc9zFfuxQVLp1zKbfudSs37FEs3QPIfvGk9bscxvLGGuS5ZZpf0eaeFIOpHHncn++IAEqJbHNnV+ilHUtt/95oMKVyOQjEiAkjdMzoLFg/Deqnw/gDGJ3LU+HiO1XttfJB41kJ+722Dq+gSTKNguzi9sW29+qEfGKC2JBB8Zum6Zm8wladHTg2v4blQQvsuattK8raC8n1zCeTU3jlyzYKisoP/mKNJ2LxxSjgGrn+kkCA31VX0h7I442tJB3o5pbKCl5Q53B09lpOz11JPtJksunEGNI2AWDdgiHf/tuqv/HGxjdQVIVFrR+DLsk2QKkp1VPwqiqqJNHVpa/DBKZUwlv8/f9lSjniqKOOore31/y71H9HH330/+jB/jf+hSjXQKk20ddEksHjWPi0fq79f9njHLP0LJZ9fwS7jqshU6LyWDdyD9u/gwXrgVqmjEV1dLP57VPFrZqd0p9XvmzjU30ds6TV3srTX/0ubeS4paqS9zam+LDtLTozm7hj6R20x/XuNPpk9KcPNnDJX7Xfk8jkOfi297juxa8Y1CsUYdJ0xbO0fxv5niDDSesT5bVb37AtMqZms0USodV+PxmH0XlWWKRkJHjw0DJyrR/ziw9/wUNfPsQnbZ/Y9pEUdO1GFyangfdj5ToTQdGSqzq9U9kWfeH1cP4ABgymmF7Vy8cn4hYi8wzAK7Rdr/Rbiz6PqtKos9I2+3xcVT2WlLc46Tz/0SVs7E6SJGhK9QBzkZfyahNUsr9EBxMhxIpyMp8syZRql2G9XjFryBdMQ2UjOj0eciPmQY12DtSQNSG/pHcjC5CluSJodrebWDmRCZUTuP+A+wGtSpQr5GC9BZaolJbv9Rbq+FXj3RyWuc5kw8TRFn2ip9RRWElHLm9d51Q2z8buBMt0HbwRUW8Zmc4DUZXiSU2SFNoGhFbz2YIJZDy3bCuM133Eyuxd6XxKxsYeLAVK+V2kX9nnLix67aHWds7tGyCmLzqWBAKoqCYrJy3LPO/wClnn8/F2OMQ9VQrr+tfx0vqXXI9BjK1xTd66a9OuptwFwKePd2X+Mm7a8yamV83TjlVfKHygTOPu/BE8nD+Ad8ZrEsKP2rX7x5CbunlvPL9sK70DVjJaEagoGgMA/Pp1HpopNYR8L1xtMtsG49aY3NoveN3lFdvCwWmczYAOSkU0cLiqoNgTRz1C3hAxn7upfLqgg1K6NCwiSC1yBcf3iaBUNmljYC3PahX9vYbvZb7mbM0uxu3tnUQVhT+0d9qkHwhSpXSqEiXjLiXx6V2yEn/TvC82q7VFYFTJ3wGa1MbFzDmU7y8ywS/an8BeM4x7s4Usxzx/DD996yJSuiQ7NKiPQSN3oznq3jzmimc+pqAzpTzpHod8L8uhOzTy5mV7luyUBHDO/DH87tgdeLPjU1q9Xl6JWOBLZz5pzjF14RjoRRbZp43NZS4+Kdl178PSR10bVfhKdCcTQ5ZT+KWC7W6VUCFUAWg+LNuK1ow+r5SQ74kmwW7hXHAPyDJxF0ZhrWMxZ5gK93hkU2Y3VKQlibQkcf7r53HFe1dYrwuglOEXNNZjv98ivgjsfRXM+S7lZdbz2UoVvar273IS+Mhz4n0fs98tC8nkC6RzBe58y2oYkdUBPCcoBdCrFzzqA9Yz1u712rv7SsXXY01HHPXiZXDK09z0TQODBfu5MzxeMnnF9Xqe9sAnXPDoEn7zzvNcvvBym5ePEbe0vMlVtVo+YzTa2VbMGj0Cf/gbwFpou4VXtsaxX37wS17zZDi1qQFFmMt7PKv2//8AAQAASURBVDJdwny3QM8TZFU12SlX5c/he9mL+WPyTP6wLsKFff0sX9fCwbe9xzNLLTPlvlTWHGciwnwRkRtsx2UswLvjGRSBtyU2JzCa5Yhx4FT7fpxdRKv+DUwpj6oyLJ+nrGK07Tn3qyox3fzcjRmalGSqpX4qQn52GFaO5O3jyW8e5tX+Swg1/5Uedbm5rROUOvO1M1nRrbGzQ4UcYVVl2oQjkSTJ7CZtzCN/LByG6hh/4v46E5TKJAe1rqdDNDkKeoPsO3JfG9NQDNE/dLK82faeAUqlhdypM55hlOQu+Q4jFpisa93jYM5+0/uN7d8Gs3JELg/eAGVCvl5meFZ6A/C99+H4RwirKm9ubrHJ6wCiPosZLHpKGXNMXXCEOYcb98Jn7Xam1IEJaz4Sc4sjZ4zinPka4SBbUNiSc88vylWFiTobOy0oXrLCnCw29DCKJp8FA/ylLMZ9FRb4eqL3dVI1H/OnijKWRq3PBHyyayfnENuQsbo0VRFDBGB7BUl+XP89Zf4y6vR7s90wYBeYUkndn7lKyEv+y5RyhKIo1NXVmX+X+q9Qwu3/3xl33303o0ePJhgMMmfOHN57z8XEVYiFCxcyZ84cgsEgY8aM4d57i1uL/j8R0QZAok244q5MKTE2L0J+/DugKPRu+aTo7YAnQHnAPsmNFMqnX6kjQbHfE61tLTij3aVCU9B9cRZv/aroPSP6CgEkwTfni/63AThzt9GcqleIV+l08g/WdLGydYAH3l/P1qR2EsJkaOlN2oCobcn3eoRBJi1LdHg8fNBrHWNZocCEbI5YwF6RWr7zmbZ/a0wp69izkoT3uQtY8NTx1u/p/ML+mbgFmBhVwrhelR0VaTK9LQATmKiOaIPuGdkruCp3Nr/Kn86p2SvZqlbxj5ZWLugpI9e785C/OT84GYAdK48yX/NjVZ/KFcXW1nVF+UaCjcVSjqxQIewQqoKSDkplfdq9lB3cNiglJkZDMaU6pQKLg9rCeXY6Q7VjjFIlifaj7iQVqUIFFF+f+d49leW0eTw0S100lodY3bMagIlVGoA1q26WmYR1pjphnQZKpSWJY5obWFVCXjC1oR61cSZfqlbnNoO9J3pKiYboOQdTas+bFnDkXR9wzJiTmVk7k0UnL+L6Hf+KmqsCxT3p7k9biYJ4LXoTWTjxCfjRKhi3j+0zPnLEBZlGKema36XjWnag+FnfMZ3BC1ToLLAluhnm9JrptrHkkp5e7mrTAOB2r5flwrks1blMjC1xjbHWFG0quuZiOCtlBTzcmD+Ra/LfpW7CTgB8Nagdo8GUcqsov7i81TSqBZivBFzlbzV5bR5NiOylBjsoZYDkrhW7YLkJSiXi1oJC9OlzMqVyTgbLYCv9ssQSnRVQrUpMyhYnYgFPgDLHOGZEXvciMZJWWVgcFS02dVBqhd/PNak1RZ2MZtXNMplSgK39tBGKqu1/72SKDzZuYb9kyiHfs54PJd1IIeveUdIACgd7NT+p9ard48oA7AFeWFbcUW8wnTcXM7b9qvFtGgW7MaU2DWxiTd8aXt38NonntA6xZhv5EfNoija57msg228yS30ZB1NKyhALeIufydbldK16yexI2Z/pZ3XvavPtPkEuNqhkzA665YEYM5q045B0SXBRG2/A//Wz8NyFrjK+37/m7jcihteToEuWeVQAWlQkkymVzJR4joXFeJsBSmUGQVXpSWS5Z8Fas/BVCu8cyGrgixso5eZJWFUoMCrSJPxbZ0p5vPRshzdbWpL5IBTkQ4fvnVuXrwk1dial2HW1Omb93aFW0k0Zg2oIWVIZJVn5QsdAhtXtgxTy1iIskykNShm/OaRac3G7x2N19wVXZk5XPEu73ADj99N+pwNYj0rukmMjjHztb1t+zqsbXuX3i39v32BgK0/3WnnRxML2s6W6G7T5eShQSmSVftP3jes2XR4P3fpwJws5V5mimAuqP521C4EdjqadKjI6c2ZjW1eR16k4l1R6R5l/T5DOt20nyRmOlN8nvekz1ISVg9o8dFwM9febUseP9p+AMTx3OTqNVmHNIdtjdP7U6qe4fentttcmZHMEVRWpvJnKgMWC96sqZY4OwfsnkpzTp43bhqdUNOChsTxAaMSDvNv1iPXbFIexe4kIG/Nb/RTb61t6tTFxg9qI9OPVcMJjPOc/DID2wAhzHF+1pYO/Ld7M+yWKCqINSDav8PIXxWqPlMfPZl0G/qUyyvbe2s442bxiYzoNpvO8p2iM+Xa1gjvzR3JaVmN++aUCPizTeiN6HD5s4thtRFRRNNamN0hMyD9iQQdbTGcrB1SKuvSFPdYzXx7yQftXVCXXm0ypMl+FVUTMp0m0f1nEhBM9EccK/nu7jW0y5f3ZvMKmTGk7hjJJu35OosDwsHadc/0zzdcMptStVZXcWF3Jh4LfXK23zSwUdHut5zXg9ZhFe9DIDDXRAJUe+xxQFC4NJMQQvSF7Dc9mb5B4Xjt/EV+EOr0BQofHo5nuV2jrVUW1Coq1Qv73X6bU/9J48sknueSSS/jZz37G0qVLmT9/PgcffDCbNrkPXuvXr+eQQw5h/vz5LF26lKuuuoqLLrqIp59++v/jI/9fEF4/RGrMTiqgs2zUbQCJ/Zth2eP0tRbT3SO+SFHlYIxqTboZ/EiO/VfgkAEWFNdFnprVKmGy370TBUB3zovss97fmNYkMhVhHyftpD3k/akclz+1jJeEieTFr7VjlCWVDY6uDNvqvtcnVO5SksR6nTI7smwkz48+lce3thNUVaJBu0Ttc1XvvILBcJLICB4jRjeeNyLWJL6kw37OU0mrghGXZZBkEjoTbXbNdGYLPheqLmfxeCSiAS9r1WYeL+yLisxydSw/yn2PhkKB49MDUIIpYH5vy4kkN57Hk29Z9GypUGH+XVZQbPp1AE94PUNFB9b5MUApRQcl8oltm++LC7xkPukKSnmQyQMfhCxQqkoASav0ifrFzW+yd8cbXFlbTcJvsYnavV5+XlvNxGAvkYDXNHKcWKmBUpIkmd5n7R/fARs0FuBHoTBr/KXB3msP34nKsP39Qb2LkciUCgkrqGzOGqpFevmuVWfyl0P+QtgXRtXZcWoJrwJJdgdcP1zbzb3vb6QQqadPKpbK5DLWgjcpdJ0SqeU+YyH29Ut03bsrNy74Kec12Rf8YhjeG0uDWvIwtmIsNUFLLjY/maZeTwbbvB76BaliIpdgXd86Tn35VN5vKWZegsWUaoo2cVl/nPHZLNdOu6Bou1LtjQFGVeuUcN0jokzS7g3neNUxmObTDT2oeWssPHn9Z66gVENKu86tUpQWuVEzA47W0x3X2jGrqmqynjJu8r1guZlMi6CUGOmcnSklPisADLZxbkM9Dxa08aQaD5NcmFJ+j58RMXf5l48+dpDWMnLD36CQZ1nnMgJ1L4KULQaldGPQByvKeFr0ttPjkNGH2P79vb3G8puj7UDdtMyDvIvm7WU8Cc2SOHZb90ch0wgF94p2VGc5GSygW/LH2d4fYGjp4GAJT6kKBm0GtG7h1n3P6FZakCRadFDIlPAOm0tQdpeuSZ4kPTorxp/tLWJKFTUDyKXgj/PZ/6MrOOyZw+hIdnDs88dy3AvW72+RinMBr6oS8Ee5+uC5ttcNUOrpwnx+mTvD/qENxc/kne/YZfiqWswirQynuLFaW1QY0e2RSfu08TueLZ6bfZUfEZ34C7yxLwHNM0T7ggJkE1z93Jf87tWvOfeRxUWf7UtmufXN1fxj5Vvs9sRu3P353cWglEfm63wx68oP/Hj2JQAcGk9QpS/sugNhelxk1c5IyxI+l0YQbobQ45usopFH8tjkr6H68TyW35db88ewy4QmAl4P36gau26CZEnJ2wbSrGwdsLVXT6R1qX+heJwywI60wIZq93psDE+xICjG6vZBcwxwAuuisfa2nheAVT12MLP/mfNNr8YQHo46/h/b3IcRss7B216mVKmOkT9oqKMgaQb3Owo5V7kwX+85oVY3h7Zaz4fJECDLL71/Zp6ssXyMuSTs91DlmUBq82n8aPJD5FPDOGjDbG5t18bogLeH6wP3MOWFw1Hfvs78nm6RlaeDhMYlGlkdJuD18MN9x3PmbprPpChPB6gS2KYbu5M8tdjO8hGjLdHGtR9dy/LO5bbXp6le8EWgdpI5vgL4o/WUNc62bTs+m2W/hHYPJGSZadJ6Rg5+RtK3BE/A3qEvUbCADtsctt5ORAjl9Ty6wi4ftAHQ4SqYfBhvNpzDBdlL+KT8YPBrY32YDFc8/QUfrXUvhooFn0ueXMr3Hyv2T9pStSNH5X/DfflDuThnZ4hf8OhnzPjV67ZCIMCryo6cnr2CgzM38Pv8CXykWKCawZYymOmqqtq8j3IFxRU0rctr0m88fmLC2qw87JCzyzLoBdWYA6n3m4VZlb+t+QO/e/JgpjyzPx6vlm9UBC1QKpVN0P7AngBEvGFi3jBeVWVqJstvO7u4pKeX6cIz4pW9Jqs+nVPoyZYeKw0Zo93eBfav/CXzfLegZCwWsZovDW7FJdn0mur3KsjBLQTqn8XjTdJYYY19Pz14Eot/vh/ytjo2e3xm12O36BbsKHqMxhn+qFmIivlj1Onebh1erwZI6Qx+0aJFSv2/yZTarjZGt99++7Y30uOiiy76pw9mW3HLLbdw9tlnc8455wBw66238tprr3HPPfdw/fXXF21/7733MmLECG699VYAJk+ezOLFi/n973/Pscce+z92nP9rI9FJV4VVkU5Istmu0oxAGWQcfgxfPOWaaIW94SKJSlXzXOh+nkTtLNgMsgOUEunCoA34brThQsa90i3GmngGyWcBGGlFO+6KsN80OexJZHlqyRbb53pzXnMNU0jHQZiot8WU6hVkjOkpR2pG2R3vMbJsJKMrxoCupY6F7JWJZR2aMfno8tGs619HUpbJKlmMJZYBSolt2T/v+JyCUjC9g5JJgQoqaxVkA30P+8tozucxYSxBwlUW9BYNopsUDUypyrYio6AMhU+rWic/20v5ctOzKKwqhFQVj6pS0H+HWgiVBEEAOgWmlBzQJk81VAm9EO/tIF9Q8A5RcRZBqGTOXb5XEyinPdNLSpbxITFN8VAtLJjHVoylp62Huz6/C4CXohHqs9q9eHHVXG7rWcxqv4/fTlBpT7TTmtCAzQlVVqvz+kAlLfEW2pc+DEoOqsfzZdQHDvBVjLpwFZUR+z0/6CLfCwmeYumc9fyJyby9c4j+rLnI9wAbo8AZN7zyNaNrInzycQ9XO3L2oJoxfRJSWUE6ICRJJivjrydzR00V/9j4EiUstQCLBbZJB8lrQjW2zlfjcjmzzXavx2MD0weyA1y24DLW9q/le29+jy/OsDMKVVU1QalhkWaGJfr5R7wAxx9VdBwVIfu5aq4I0dKXIuTzmKbqBlAR0xdUzvFq6aY+VBXGlk8mky1nfqaFKdlcEShVF6ymviMHMeiXfRyl/pZPzjqIZLbA3N+8SW00wAs/3N2k7McJ8VJhJw71WCzVrLcMv+7Pk07GAfs4AzpTSngetHFGiME2VgrMsypfhInZ4sVwwBPgih2v4II3LzDvffM7ZHgmcDWej4HqIKevvAN/taI1oshfQDKXZE3fGqbXTEfSE612F1mThMSxE+xzcXU0wCk7j+SGr63XkgT5Ue77fHpkH3/6aBNn9t7OFHmD+b7sFVhT2WqGVYYohhLAoz9ng7LM73InskK1dwcbVEND3reD6TxUFSeIFVKCzT3WgjtXUCyg1nzNRb43aMnBN+gFjpCiaMxFX4igMpxCqhlPyM46lDxJ2vNRRgPBXD+SwHj2V37K4uQdqOrdVvv5tW+jYknCXl3/alF1u0MpnodjioIUiFFpyD/0MJ7fpBoo9mxxyRVqon6MvauKF5CKxqNgxVpeke2AnypJPPbVeh78cCuX7D8BexQINjwHgK/yA/KD00gRQJW9SEoe0v289mUbyGlWxhfRm7Yzjq565gte/qKNsnG/Bx/cs+wedmu2t+3+WW01bHmt6PcA7Dn6IJ5771aGdX7MnZXa+en1B+nxFC9YdlWDfCiwhEp133Nek4gvYmMRVgYrrWsKNJSHODN/NgAfHTudl79oY9Wrw5ktr2GCvJmXFM37sa0/zVdbB0Bor17Iu3tKgQbGgd37rt/jMWV9oHVLdIuWvpS5kE85OoxFBVCq10VK6aFAo9RjPrtOkHBF6yfQWMfwXI6XRx0HNVM5bsJx/H11aZN9I7yqhOxv5xv1Vdb1XcqYijHF2wiglH8bMp1KVWLXVIpFetEr67jvDX/ShKq9HybNhd5nOdP7GmfyGqPSj5vspEjAS8Ank49PJSI30B1fz/hsOTOkDEFFIe1L8JO6Gu5s7yQv3DqiVFSSciz48V7UxgJ0DGYI+633jOYRXQ75XrUjH7/878vZf0o9FeHi3/7SOnfZ/Nh5l8LowyFcZVsP+EfvSSxkL86Gxu5HuHMT0EFCkolIGfb48ExumaQBG9XZI8gUssRDr9Kft+Yk0UO08OfDYLRVLAkV8oAE5XbrASMiwnmYMHIYN6/eiZalnZwyKoQEBPUObRu6E66f701mqS8L0j6Q5uUvtGNSVRlJAGzX+MfQq0T4rXqK6z6czZ0A8PXy1bg3GWybB727ksdLRvURkHJESNNPlGQmD5s+pjc43PbR/lTCZLyKETWKw94gMX85pDWgL+bmD+kNQjZXxHqVdfBpV98iXtz8LJSXcWQ8QcAzgApUBSvpzer5YHwrSf0ebAhU8vDcq8j85SiiqsrhWQ9EqskKEnKv5DW78xpS6n8UducYT3EhIyzZgTkj2vvzrG/zgyCzU4YApQY9Mn06yJ7wZomM1gzpu3MSN+99M2VBL8Orwhw3Z3jJfYiRUrxM++Vr3HjcDhw/t/gz3YLvcE9WO2eSP2LO+VF/lDrJB2T5XXUl5VIth+vbG9I9VZVRcj70dIWqgHtx6j8xtosp9Yc//GG7/jPAn/+JyGazLFmyhAMOOMD2+gEHHMCHH37o+pmPPvqoaPsDDzyQxYsXm8btzshkMgwMDNj++4+J2WfYKisJWaI1N8BjKx8jW8hSUAqsj1YW21euW0CfC0AQ8UVM/bYR5TtdAIfewsAxjwLwh8J3bO9XMgiC1KIvmdWrRfZvVXNVNvNat1iXTNmYUin9ga4M+2wTkTNUZLPtpzHwGeh9d3LA5v3hjF7Bkysz8UA2VGvVmVFlo0CYgKNhuwTFWHCPLtcWQTlJoi9vDapZSSKHvS17IpfgukVWVSyZtAa79T4fyyLl1kAXrKRJoBkbrBkJOxvE6KbRSjU5PHjUHPX04qFAHaVZac5IZ6wFd1bS+F9RYXITK7IAh8+wy1BE+Z4c0RY1tXUas2awt4NL/7asyOx0Y3eCgqKiqIqtcpbIJVzNN+uF6sK02pkE/BGzoh30BBkWtScxHlWly6f9hp082iQwIMvsXB3ngjc1ls3EyomUGaaRQL2ehLV7PGQbZ3DKyNHcJw8tLysLlBVVaw35ngzsk0gyPZ1hRtq6P9IZ90XMZsH3S+5Zyzx5haunFJRmShnRFc/Q46D3A+zr+Qzj+RS77/UKdHSRNbVyCJYYevWuQr9XjAQ75o/ZKtMyUKaoZsfE1X7rfA1mB1nbv7bkVwxkB0wmSmOgwmKDunQ1qYzYr8PJO4/gjpNm8eol8ykP+aiJBhg0PNikFDIWs/OpxZtZuqmXFS3aEmrmsFouzO7JdXonShGU2imV5onVy6nOa/NJQpLpTKks+KaL5Vv6UVXoGMzw1krR5F/iwtwlnJW1mkk8trwfxaDOp9zvM6enlNj1DSA3YJelVTfOYUQuX9Sd0u/xM6ZiDC8c/QL/OKKYkWD6max61WzK4CtbTq6gcOmCSznl5VN4fePrGkuHYuPmY2tm89qxr22X3xBAZyFMdvbZvK/LHiZLm/GSR5IgEhXZlTKjayKoSvEcsKZNNx2VZdpdjIUHt8GUGkjnYNR81mIfOyqI22QGiUyea55fwd+Fgog4ZhkGsRmBGWN0TwpVj4dJGnvMK3tJbvgBlS32PAZPkq1Z7T4I5PuLWCvrUu+zfkBgq658wSx8ALy7xd2M3RkRRQF/pEimbyxkkgTodCx0SfWRzhVM+QzY2SlBOWLLAYb75gPQK6+iOVcM6Pzu/c/Z2p/ml8/ZO3x6Y5ZsXska861EwfBBywwQDXoJNjxDsPEZqyGFHu+u1oo8+bz1nKb0e9XonKntUWJKtV0apL0hMcZbhh/MeWWzKtPrAr5O7W/njU0tzK7TmCMp3VPKGT1pO0u4zF9mk244WYUxoetlZdhPLODlG1W7NycKTKn2gTQrWwfNvAAwO1aJTKlqna16eV0NJzfWF+V9r3tGWT+/BCi1pTdpLjidHcZE+Z7TwydfULjbdxvvBy42X0vmkzy35jkO/PuBXPLOJfy2RjsX0zJZSGn5ys92/hnPH7XtJksZf5qmyQ+zvG8Bly24zHUbr2Sdz4xLTiFGjwxHD1pAxkTVXuM/dActnwmEtRwhLGXYWf7ato0xl0QDXoL6+JjOK3QnsmTxUqMo3KOzpd4NBemTZZuEUvS2Cg17lJc3P0Yk4GV0TYT6Mms+Dej7dsr3TvS8zX7yEvYRJNPru9zBmVJejjs07gwxrYgsKicCnoBpdG5EeMLBhE94HNBy3e821BGXJPry2m/c1DKCygENmB3IWYUQscjS55DThlUVypo0vyQhfn7oZHweiQfO2NF87eSdRxD0yXzR0s/SNp2lpjNyNnW7M/e6ddmcOJanNp9h8zH8eLDMYmbJaUC1PZsAU5vKmDm8wvx3rPlFMnQSbLDu3QT2dYlnwwJ46EBif9rTtq9VPetQVIVKvDQKpuIWKBUgLEjvy6IurHXdUNupchjnW81z/p/zy9A95msvRyJ4PdrapyZUZcn3Blpo1xm+db4oFapEfUHvbnjRZ/CDxfgutnuDGQXMvH7CrlAuZNPOvyg6PBHAFmNDd6LoHlULpUGpflk2mZ85r1A4kluZ2BDjN0dP54I9x5rG+NuKrpR23D/5+3LX98UxPK8WGJQlcv6IOf9HfVGaBL+v173W9TPWcyh+MsJzHnv6AsgXg/j/ibFdoNT69eu3679169b9jx1oV1cXhUKB+no7g6a+vp62NvfuUW1tba7b5/N5urrc9cPXX3895eXl5n/Dh28fevp/IXL7/dKWMCmSxEW+QW745Aau/ehafrPoNxxRpvJ0rFie0FsClJIl2TYRVZYNgx3PpqpWGwQfyB3IwZnruT+vJVOVUpxUy4lISozU1uPoTeaI9n7FJ4EL+a7/bWHvMoW0cO1cvCBa8ykkn1UPN4zvKsL+bQ4wCYFSDXD8jsPAk+Dd7Pkc/8Lxrp/JKTkG8tbElcqn2DCwAYBR5aMgbIFSsWgDbjGqbJT5d59qDUYZSTKvjQeJ3874IbIk8/fVf2dDv/YdyXSf9d2yzKkxhc87PgcgGiijSeygJQATE+qtxGCvCRqNV0GmQ9YSkRFSB9d5H+KT4IXMlop16m4xKMgcUy7tej1qyPbvPcbbKzUfKVPIqzJvFObgma8liGNGa2Z/DVIvLyzbysMfbjC3f+7zFva8aQFX/P3zIjlSMucu32sQgMHZ9bPBHzX9hSK+CI0R+0RdkCQKkgYmjNPlJQVJYknPV6zpW0PUF+X3e9o9Luq9OigVreGzw3/H8l570inG2PKxnDr5VCK+iE2+Fwt4TaNzgNs6unistd1WwUpl3YdqMZGa/9FZPOH/DZMp9jwAhmRKad9RoIdi4OZG3/2c7NGezWSuYAJQ4iLcqGYpYEpaXSNYDv5oUdeXmD/GDXvcgJSr5ZatGtgigSDhE/xusvbqrjNa4hqrpCpYRchgp0iyq0G1kylVFvJx+IwmRurSvbG1ERtQESVFVzzDglUdXP735Rx994d8uVUDmqY2lTOyzDrOsLDAmZrJUlcoMFrREhYp6AFUrn7vOv688j5AITTij9y18qeAytyR1lgisg06c0GysvbvTNpIzAogWc9EkaeUALLfsvgWDirYAb3q0XvjAXZP2Z8hQyYU8ASoDRTPg2bnJ6GZheRJscuYaj7cqhWKnl79NOSSKGheLEaEJA/XHPpnGt2S5SEilS3wVaqKATVMQMrx6XnNrPjVgew5XEvaCyltQT66JkJq85k6K0cLteA3wfK4LNskxEbcnT8SgFcKOxa9BxpTqietcHD6N/wydwaZwzWWZYVkBwg/XNvNwx9u4CcvPs8jn3wOFMv3soUs2Yz1OaN7UkgAgBRVBSS68/Y8RvIk2ZjSxgzJlRMG7S2CZO2b123snEVti1w/44yYooIvTMwfs5kNl5nyrACdDkkQ/Vu4+tkv2f137/DhWi3PEg17o/5y23WJ9w9DydRQIE+LMHYYiy1JZ4k52QaeiCgJtBKEnLEQTg8Q8XvxlWss5c87P7d9Pqv/BhGUMcDcOmHuuGbquTx52JNct5tWIJqcERYHTbMAqNTH6rWSxUYTDYSDikpDoUCZXsRIy+6glDNC3pBNunHCxBNs709pKiPs9zC6JkLQ59Fk5jooNV4ApVr706xss8v3DIk/wmsdvdbfXwQDvB22z+MbhIYGyPZ52Pg5Lb0pekswpUT5npO9PZDOc6Bnsa3DXzKX5MV1L7I1sZW3Nr3FRt0DcGY6Y3af9Mpes9jnFgZgmJMK9Gc1IMsoavRn+nl85eNFYCBAq4O1FnDxUSuvGM3PPCdy0IhjOG+m5gnHjJMBOHhaA0+cuwsHzdIYWWEy1DsKfy16Uaks6DW9dtLZAr3JrNmpcG46Q1UmiCpJfBQK2iSUYpFZ8qS5Z/kdRV2bwWJKOY3OK6QED/hv5vQdIuwyRisOujGGUvlUkbF2VUHhFzv/nOm1VjdhUb7nk31FoFTIG7IBo0tCQZ6NRekr6AyRfIyLeV071oy1RhPHzm4H6BtSFNOTR4xz5o/hy18dyLyx1vNTHQ1w1ExN9rVwnfY7DWPrdSXAuFMeWMSLy7eyrtN6v5CYyDHr9mR/3dB7U7qF0Ij78Ne+QnTCr/DXvGXL8X55+BReumg+F+833nzNJrnWI6kz0g3pWnjDmwD4UnZp40a9A+MIvDabh4gx5niDtnwn6rYe0RnXTlCq2+NhhryOboH592o0jMerzVX10Wqzm2pq62eaLxJQLwUs5U2sEaJ14PEhBa17wCN5irwOowEvUqzYO1HsQqiFSpAMH6/rMQEt850hmFKtXo/pj9jtFeTH2yA9GLFOsZ+7vFQ6v03mkuYcYli19MgeBgNWDhnxRThMrqBBn98GhOfZkO+pSsBWRPo6ESluSvYfGv+Sp5SqqrYK+f8XITkmclVVi17b1vZurxtx5ZVX0t/fb/63eXNpjfX/tehF62wjmjN+rY87z619jqdWPwXAHToV3fZZN/mezpISPQ6MCmPA66E85ENFZqU60qTWjpA62G/MXEYnbyTfP5feZJax8SXUSX0cJNsTZSVrTSbjBorpp6lgN5LQflkzYVWoDPs0+Z6UITTyXnxVxWb4SZ1SXSZnGFsbYfdxNXj1JHdN35qi7YGiTjDpfNoEjJxMqVjMnUrcFG0iohvULgtZg1tWkujV0fzyQp7Dn72cYWFtMDQSpqRLB0TD5yjsC9tAKVU3u5Yk+N2xO/CzQ7T239/dzUreuv3aMU6T13OS9x0ATvAscD1uI64+TKsY5xN95mspl06APq99XAg6DKXfUOYyJfMnfqBejqRX2YhpC9TJUW1ie3OllRT+/vVVyMHNvBo/h3NeP8e2r0Q+YSYt++pJQnMuT33YWsjNrp8NgahpSBvxRUqaODfmcoQ+fchcVGxKaMySEWUjNPARYLAN0gPUe7Rn4C+BAue9cb7b7sy4cc8buWInrdOSwVgDmDWy0mTjGCGhsxT06E24A0qbDTZCvJNIWjtfR1LclADsLXTdYiCVM31qnPFb34OAiqpaLa1F+YUh5WsJhEkP1ao7EAN/1GbiDhojYFbdLEalr2VMyhpPGgrFzImkAAy7dcMxpXvRYVZr+EDMWjUJEfTJtiSpzFHdHFkdJoeXtJ7AlElJOge1xMiIt7/W2E3TmssYVmZ9R7DfklwZAOMOaAtF1QtyoJ1+3zt80P04cqANb2Q9A9IXIOU4YKp1704dYS2QB4iQ1hd6uZR2HsKj7iUy7nfIAa04k84rNlBKTOj/tOJPdMj2Z1PyheDUp/n9pLO5e9+7zNfFcb0rXnwdTAPonnW2bQ+cYd3btf5yyKXo8cimtBdw9dtyxuQqrcHCvMZ5JpP14Q830DqQMc1kK/tWEvZ7OWvK+aS2Hkdys9ZQYlR1hEJyHPFVv+L5w9+mXjmMxIYfmvKluCyxxZ8jOvFq/NULzO9coMxk98yt/DD3Q9djimfymnEtPt6MHUVgvNYYQPNKtM5rS28KObiJyKh7uGnFuSiKWsTA7U33khG6UvXpyX1IkMoZJrspwcMPtAXN3Z/2M6CGXVnMAC2v/wSSPVqzkWS3vePjdkZUUcAfRZZkyv3Wgta4nxVVKpIE0b/FlMz/+kWt5bUIKEW8MRtT6uy+p4ik7ZLI325N86Nubb71Rr/CrSplN3fPU1+m3YN9Osi0elOLdv5U9/OTN0ApAZTZPKjle2IzhYNGaqbdh489nId2uJgH2tphul642v1S2P1SKve9FoB2v3acsYJCRBjiDFl2SB/P0pJMWrgeFR735yHsDTOhcgLHTzieS+dcyogy++I77Pfyyc/245WLNbZZNOhltaIByKOkNprQFvar2gY16alQrFLzMXweCZDJth/BGVPOppCy+/JschQYtgrrorpy1WYUPFEvfm3pTZlzQ5GnlI0pZQcZDXZVv3A/p/IpOnUvzfHlY9gxlea83n6OmnAs7HYx24qworBwUwv1efv4ZcwbV39wNdd/cj0/WvAj7XhLdPEFuKu9k72G78Vlcy6jzF/G1btcjXzRZ5x46s+4ae9fMX3O+XDxcjhSkwdJksS8sdUEw1qeESJDvWTPIZdv0XK6MbVRkynVPpCmoKiEsMbtqUntvfdDQRu4rLjMaaJ8yAiTKeUEkPVo7v7I9FC8d8G6oiYPLYPFTUsOUEN8Z5IdJLXJ9zx+G6sctDw1k7XfUxt9Xgp6R0E1H6XGpStjOp/WunomuooaCYRUtchPyoiAt3jdMn2Ydg4WbtCe8ZCU5TX/T5gtrcZbYoy84ZWvbcxPCYXT5DdMXzh/1Yd4I+sI1CxEklQCtW9SKeR4Rpe33cdZ65icUnyvmVJPvciUkdxZ52bhLaPabB5iAlPKYEIBeMPFMn9VZ5Y5QakvA37uqii3OnkDrV4vDXXa768NW0yp1MrnTAZ0nQoY46aL7yJo6x9np+ZIwIu3vBg0E1mVAPeX/YmlgfNpRhsPZgyz7mW1hIckwBahoKl4rJxVcvPsBDjrNZhwEKsUbX30hdCQCKBcSnC+5wWqGCjCP4xnL+QNmZ1zvw74uVC3Fwh5Q3hlL5W+GNd1atsOoNCf6WdD/waeXPWk9nuUAP1Y89LvPOe65q//ifFPgVIPPvgg06ZNIxgMEgwGmTZtGg888MC/+9hsUVNTg8fjKWJFdXR0FLGhjGhoaHDd3uv1Ul3tbhwWCAQoKyuz/fefEkZXgOpCwdYm3RluMONW/cEeX2kh/cbELnpliJURsd1mw5TdAdgztJabvzOdKr2K0JfMImU05kOjZJ9MRa+DhqSLAXNIY4TYGC9yjsqwH48sEapehDe8gWB9Me04qS/sbjlqPE+cu4smcXPpJgPQn8yRyhZY02sHq/qz/WzVAYvR5aNBWExEXZB/gPpwPdGcVl39LGgNOhpTSnscjW4YBihhUDpTQzBEor6oTb6HTpuXkAj5PZy7xxhuPG4GE+qtpKElPAmAi7yWNKef0oM7wIiqMOd4XuLN3Gmm3Gd0Whss88Kg6aT2O7ucgUoWnx2sKtPOWVnOSqQz+QLPL9vK5p4U3vA6JE+2yGhTrE4cPxDntvZO/tLaRr3OwpCQmFk3E/xRE7irDlXbJRmC8W55Jq7JHvXftzGnTShmZ5neDXDzJPjL0bo23PhF2pNzTWwHzu0rBhDFBE2sos0aXmF6SokRFia8rOJ+b242/KVal5mvzZE2uG6LCErJKeRgC0fPauYHe48DoDOeLQlKAcyVNADUYEWJBqCGrG9NzMW7QA9JVTUJXSBmGp0bYYwb5SGf7R6sz9sXLs5I59NFlWHDa6E51mz545UAICVJokKQFpUF7YmK4U03aPpKJdnal2bpJvviQpJgcmMZ9SHrmilp65oZ91JElxImlawJIoEGUJn7krO2Vt4n7jbR/HtAjZDSAbJCJgEoeEKbkb1JwiPvAQqkcnGb34RTvidGyBtil8ZdYNx+yPtcRbXgPSF6qojeZUaY8r2+jbauVc+us/xdcls/g1zKrKYaEXZ0ZXKLu/a9i8vmXMbv9vgd4YD2+T+8qTE5vzS8oPT7flhFJfn+uVCIIKHQVBHU2QEevETIdR2Amq1F1hflcVmmu/5DJDlHoO5VxFlvi1pHXrDbnDOynMbmL5F8XQymcyzZqF37yY1lZiHCKyk2uUHbQBpfmT5OyWmWt/STztuZJb2ZXjK54up8SJBrGQwjZ/MCyZMkh5djstewVXIHNFokBTZ9DHr1NenCaHUL0cMooihmt8cqoYOTcT/LkkpKSJ4BGGw1u0et1rupJbN5Mp37EpADfGfURYip54H5jRzHp7ZdVOW87J5K41VV5EAXO02wj39jayPsMEJ4VuU8wyu1e2r9oHav3P3qErriWbwuzBEQjJAFBqkh+z1+gmYAf0g8QVhnTcmSzI6zzqHskq/gaL2Lsy8E+11DrHkOABkd8K1SCngEeY8BSgX1eyAtSSbD+Kjmvdi3z86EMCLsCyNJElfPu5qzpp3luk004DXn0WjASycVfFiYgkdSucD7AgDLtvQBUBkOMCH7axLrLgElSF1Mu3aZnl05bPhZpqTPiLUOKXaX3zpXTVUSH1+5r/nvkdXa+d/SmzIBJmezBvEZSYjG9Rs+IPr2zwDoEwqgKqrJavrttAt4qK2DH6YhfPjtrnJssHfQ8+jXuNkBShnzzTubtWLc4naNVTjUWLljOsMd+9zBmdPO5IOTPuD4iS6M+sqRxZ5q+gI9LGUISfb9G2DthPqYyZTaqje6EFvTz09pr70aifBBaGhA38hJxbCYUu7ze237e4yqDgMqZ3bfjPL3s+kRvBMNEESMULh4rt+mfM8bZiBln9OX6j6qSj4CeKhx6ZabKWTg2e/BTWNtPlqgX2MXplSpMJQDq3qscWGivIU/+3/HsMoQHhdgqjYWYItglbCnvIxxUgt+uTRrJhq2rl9tVPuNPo/MrBEVgLudQkGfFw2WUEZg8wSE+6FN93hsyKt2ppQASu0cGwXoTEGXjrGJgnYenZ5Sm30+7q0s510nSzKt3QOVwUqC+jOWkiTTK7I+n7eYUg5W+n3738evdv0Vk6snuzKlfOXWGq5Tl5hGHPK9/bNvEpKynOHVmHTjBQWIG1PKAKJLFklLMaVG7AInP2l2R1yu2FmYVQxwpe8JbvXdRZejI6Jhcl4VrKJK9xW+vK6GL3WAOWZIy31BszC7JtPNHk/uweHPHs4za57R3lf89PTtAUA+OZIJjRXux/ofGN8alLr66qu5+OKLOfzww3nqqad46qmnOPzww7n00kv5+c9//j9xjAD4/X7mzJnDG2+8YXv9jTfeYNddd3X9zLx584q2f/3115k7dy4+3/8bVDgj/vTlnzjhRa2qUVNQbCwMZ5hD3M7fM//9qT5AnbfDeeZ2A/qCT6wAixT/mqiV0Ayfsgv4wvizfcQG1pqL8pbeFCFFG8iGyT14ZUwacbZ7LwqpZmYEz6NKLR7Aw+Xaom50+WizGirJadNDyecv3eLWoMkOj6rUlQUpD/mQXLoP9adyzLj2dfa7ZSFf9Xxle+/zjs9RVIWqYJVGsQ9XwY7nwI7nEi235C6iH0dtqJYtW3Yo+p6MJJmVcmPBHtHZBwndzDwpVNWdEfFFTDqodiLcmTVhgX6/1q8xEcolqwJUK/XhJc9YqQU3eLKhLMjPfY8B8NjWdo4fGGTn9rFF26kOUEoEnzyR1UQn/ApvbLmZLAEQ0xZDnlycqJSiO5HlyDs/4KInlmo/yefu7ybK98Kqwj7JFLUFhWFl2mQysUr3gfJHmJvO8NPuHq7c6Upm1c3i5j1uZ0L2NzYfpjJ9kjckKpt0mWWFATp+fK92bloWm100xJgXG23KBMUQE7RyoYo2Y3i56SklhgcwiIBKplZbBOsxpkZL/gbSefqTOQY2WFKdoKN6E5QM1pw1gYZH3ktk9B3k/d+Yfi9bepN0u8j3jNjRuxbJO8Ar618hr+Tpc5HvrdVXAU5/ItC7agRiEIianlJGGBXWZLaAB0Hqkx/abLagFsxxyAijK834ivGQ1sHBEqAU2FlrZSF7krmDXo0bUC1Qqm0gzdJNfY7tKgj7vXgF4Dg5aD0DRuJnGO1nlAzeiCWj8wStpD8WVhlZHeHxc3bmsXN2ZlyTyJQKk9DvVSWb5LHAteZ7kieD7O+irfwX3Pn5nebr2XULSP5hOh2PHGE75p0aduKZw16lP27de6Kvl8h+ah8sBqUMplQBO3ttweYF5t896W7IJenw2M9ryCVJdkZtuJYzp51JZbCSsAPUXiPplfEObUwuC3rxeSTmyStYFjiXSR0vm0D4YDpvymS+M00bY/okL4og/Zb97qDAtOYyzjigh3jZo0TH/Z6/Ld7CDa9oEt15Y6vBFyKrV7ObpS4k/d5t70sw2W8Z8L/zdQdb++1FhZ50D1mh244R4YjVKSmtL1rVbBVlnkZUY57TWUJr1GH8XtVsUp3d3Fq8Xtj0EWSTqAgg4jZieMyau2KKai6yDxhl+VpZCxm3EpZKvaQxCQuKynH3fEg6p5Dt2p8Xj1zIhMoJSIIxfX2hQKUDpPYqXiKqyvSM9mxW1Www3ztoagNv/WgvkIVFi5SjSe+kNKCD2hG9460Pl1xHyuItW4rkSZiyfzHG+afx0uat/KazGwKOBU9ZUxHw4Gz4UllQbGwwg80Q1BdtoqdUoJCj3GW+gO0Db23HoXddvL1wDAAne97iIPkTjSUF1JcFqQkOQ8loz0FDufW8r+9MuHbiE2PQb40D8VwcWbinDMlz+2CajgHjnNrvuQhpKhlgrvQ1cbGpzMOHULfyYUDzgHGLypy+zxLWCEaILExV0gptzQ7pZ8TrXnwbiin1T8tK9C5vDVKxRNCIiQ1RM0cyGpkEBUn2wekO9k4kycoS6/1Dr11a48Xy/W/i7+OJrKYPd5lTbMsCTlh+Dq/7f8KJ3gUc6fmQrZssK4ct8S1FnwlFi8kAYo7j8/iKmFLlgfIig/tVetONJq+Pv4V/55o7rehewZHdC2n1eIrke0lZgspRrr/LLSbUacfoZPHFpBTDq8L87fxdmDWiwsbEiafzZldcgENkjY0eqB5PyQhsMP+sEQr09502l0OmN1AeKR4763XPNMPnKqdYz08V1vzRntQL8oWCLd+LGgCVN0hDbBivb2rhpc1bXVk2A3rzHCdTaltRGagkpEvY0rJkekrVZ1ICKGV/vuY1zeOY8dqY5GSvxYJe/JVWEX9A73YckdyfxZzepWp8XZSmcsMXr/i+jm7jd0nb6PN2Z/4oLs1+j8cK+7m+v4fnC9Z1xikoKl+29FNQVJMpVR2qpipQzE6LGOfFG6JcmPOchVVPaAv5wenIrZeQ2nQWkxpKF4v/0+Jbj7P33HMP999/P9dffz1HHHEERxxxBNdffz333Xcf99577//EMZpx2WWX8cADD/DQQw+xcuVKLr30UjZt2sQFF2gmxFdeeSWnn366uf0FF1zAxo0bueyyy1i5ciUPPfQQDz74ID/+8Y9LfcV/bCxpN/uyUV0oEFHckkktCkhw+nOw3y8B2OT10uaR8ck+9hxmGe4ZRqqljMFTQteEycNrYJju07HpQ7O7xzcdccp0UMRTSPPFT3bi+mM00EbNl5Pc8EN+vOtpHDCsuD2v0W2vOdpsdlWS5IxZ6dCo6UJIGcKj7sJf+5pJkzUG0Yn1MYZXWZNUNp9nVc8q3lytLUBa+lJ83a39bXgLLO3QwJIZtTMsOeihN8OhvyfsC3PGlDM4ceKJ/HG/P5r7rQo0kE42EynYz78o36syWBW6AXBCP8bkEMabMX8M31lWlyBj0TIU4zNRUwyO1dLHz7yP8Vbgcm7w3o9z0REOeFB0VtH4XI6fdfWxMjetaD8Fhx485BcNOf+M5EkTGva4nSkViIGe1Myq0D7/dZs1EUted6bYYLqbtA7YhYQJeq+R+/GDmT/gmnnXaC/4o8jAKQNxJldrgJw/O5Ulaz02CYcBRhkLr016ZcdkSq1faG47Opsmoih4kRhVNop9R+xLU6TelAmCliQ3RZpsC4yyoI9TdxnBSTsNZ2JDmc1TSoxn1KnEV/8MlDAn7WQtFic1xkzpxOqOQT5+/y3r+xzP9tiQvsjVmVI7DCvHE9SYOVsLC01QalNP0pSGucV4TyuBule4YcnPeW39m/QJRucGKLVGZxvOzBQv9H7Q26ddY1+kaBFmJLPxdJ46qc98vc5RuK51yTN6Mlqyn1fyvLruZT7donVyGVcxDtbqPnUlqupg95VyMqWOmtnM5QdOpL5OA4aGhbWxLutYRN90nP4spa3FdrLX+h3GPRVWVar1j/r0NvYAcshK+uvLtedr13E17DauxvR+AA0cW9GpHUOT2s40j529KXkHUWU70JFtWcx54QwHKXbPx5pQDd+5eyn73bKQb3RGS0AwixWZUu0DxdfT8PlKOgaZ9f2WwXYXisaUciSiIZ/74qhUhAP2BLItoFPq21eALuGvjgR42HcjZVKKUe9eZgLwazvj5BUVv1dmlC7P/DIYQvZZ44knoi3ARPnm9/YayyNn7cwXnfbujkbMG6MtIFJ6U4TXAj/lNp8mf5zU8TJBv2Va/5eP1zOY0b0mCto9psn3ikGpUMRa7FleTB72jPyOxJrLtX14knhC69lzeoKvdG/ABgcb5JVohMtaXkXJDPD9+lpOa7Iv5g8Pj3L9XSIoFRGSZZEZYjCtDQD5xcIutn0Mkyw/mMUbLVZhLBAgEvAiyYIPGRTJeT26/HyqLn2KRay5L6LfC/2CnF2S8qZcZlAH+GNo59brkuoEal8n1PwkoeF/cgWlrnh0MSPyebwef5GBsls4GSEVhQJeyfpcMKotukIJbaxKy5LpGRJSlCKQ3oiQb9syVzGMjmsfK5P5W35PvJLCjb778OrMtdpYgHFSC5MljUlZGfab5+3jdd2oivv3VbkABYbE0fjOI2c2EfTJqCqsbNNysx2EhT1ojMI3A5fz98C1DOvV7RqSdrCmlBy1Kq0/K7FiMMQe1niUxctlhUuYkLVPJKXAp4yDzRhUFPZNJHm8xd23drtCZw9NlTfZXjauCWjsnaCeZ3zZop07kSlVISX5cU/fdn2dkynVkezgyU3XEx7xEFvUau7JH849+cNt23jSvVT2LGWCbBVH2jqtZ9iNKRV2sahwMqXEOUSWZCZVTXLtuggwOtXKTsoyIqpK0OV5WOf3cV1NVZF8LyHL0DzbdZ9uUR72UV8WQEUuMuKvDnuZM7KKZ76/Gw+fuRPHzNYkWN90xFFU9M5xKrt5tLnbV1Hay2yAlebfomqkNhbg7lPmkFeL70FfSBtH5g3XwRahO3qVZBXfOlIaKNWUy9lyXg2IkUD2wqTDaRy5B9E9fuJ6fD168xwnKOUt+KjwF/stGlHx2aOETKaUbMr36pMDlnzPCeSLv9GxLosGvITD1vY5HSwSWZUiS8xgMU9rLufFi+bz+Lk7E84XyzSHWuPCtj2l+ojxjDJ/yJx4XVeCm19fxWF3vM/1L680mVLVwWqTKSWGycT0+ovmvLOmncUxY7TujdneHQGJ/r4GUANMavjPUWxtK741KFUoFJg7d27R63PmzCHvSIr+3XHCCSdw6623cu211zJz5kzeffddXn75ZUaO1Kqmra2tbNpkDfyjR4/m5ZdfZsGCBcycOZNf//rX3H777Rx77LGlvuI/NuY3zzf/rglWES5BaQddydQ406TtGy1vZ9TOIOQN8ZMdtUHuolkXARpbwS1EumvA64ER8/Q3lpiJ0DcdcTN5BAilWm0+BaAtFBoozXpqjjbjNSQMQoLpVIz5ypbjCW0mUPMOSaNKog+iXo/M6btayfj7WxZx3AvHccdXFoC5olurys/M2CfVmXUzXY/rxzv+mJ/t8jOm1kzlgQMe4O5970YmDEgkC/ZBXzQ6N0ygwwYopUs8kkNU8WqCNTBiFw4ZfQhBT5DDxhxJ0Cdz7vzitse3nzSL+eNrOOegnYreq5P62EnvEHOidwGHBpbZ3g/5PKxSrfPUTYxWVVuc3dLeafowKdjPka06IviAFVnSlWk03mmxYlmL5HVnSg22LCGd0hLbgDAReTxezp9xPlNr9FbgLhOl0VlFNN80Jmnj/4avRkWgAvpbTHYGQHn/Vp7d0srbNfvxwtEvcOvet4I/akowARYcv4AXj3mxyMfuuqOmc/0xOxD0yiQECYw66TDz7zG+PPtPHMeM4RUcOaPZfL2xPMTcUdo99OKyrUxQtUXGgBq2JSkBRaFZ973yV35CsOkJ5o21JrisOmgyC40KrTO+1j1KxkitJjD48KLPGExYzL2kLsVYq1/mWWnrOdwpB39vaeW7/YMaKBVvK1qEGRXVeCZPtWDcPDwv+CUUFMpdPKYMr7fbPruNy9+7go6s9vlxm5bARzpjKFbaULvcxpSyJyqyLHHh3uOIlmkJxtiYdV0Pn9HEPafM5uWL5lvNBARQypuw7lcxARku62OVxxofPUELlKorc0zLwsI0TojenHY/zpa/KWotL/uLq/FZJc9Kv5+cY9uqYBVb+7Ux5Z1VGoAisqP8sghKFY89Twenw4SDbV5yzuiWVMgXy/dCJTwnSoWzm2pbYCRIHkj3wV9Pga41VEf9BASGqNHsYpUObI+oCjNSN4lfGbAfc23tZu45ZbZWLNH3cej0RqoifoshCSCwbozqZdpnPU9HeD4CYFjiS1oFL4ueZAKfPjeN0k19e9uWkXUpNIQEVp/oxdQTV8yKsCQphEf9kc/yvwadQdrkInV9Q07T0vMN74eLwYZTBFZMc7QZCYm59XPZuWFn8/WYschBAzGvmXcNB48+mHm6KX5BTyEvzl3I3PQ9fIgGzg6XxC6SWkRJEmz/zHYtjfFaHC+DCmT17rgVOnjp81vnyWCP9WcFibSUp1qXyBhMKa3YpSK7sLm8urTSE9riCkoZMlsC21ehdjJCoqpMXdT6bHCExuYPDmrFgLQkmV6MwUK+SM5sxLdlSlmsT4kdf/iIdmxSkjI9x2qI+bh8zem8EriSKEnKgl52Gq2Nbc9+vrUkU2p0trjwaEgdF16+Ny/8YHemNpUzTJdQLtusXRujsYoY1ZL2PI7r154VNn5ge9+NKRXzxfDp3lLbYkqJOUUGL5/lhrNHyv6cDWSLc4kL3riArGLPWyZmc9za0cX0bBZ0iea3jqh2DqLY51cDdIr4PTRXhAg4Etb6oP15dmMQuYXhqWiEyCSWfL38Ln8Sv8ufRNt+d3B+9hI+V4qZ7gC9XRYQZ3hKiYbyobLmos/YPKVkO+DznQnfQZZk+pI5kpvOolmyd5Ks0ed6CYtR7Iz3Q0Gej9rnjqTHBzUTXbcvFePqtONMOdhSp0y0vrcy4ufnh9q7bjZXhji4IU6z1E0GH/5Kdy8rgC3590Fnp8ccRRXAtWO0HNSOK6azhCTB265aGmBkhQ9Q6clo48iwXMbGStdAKVWrRnv9cPqzsPdVRd/T2p+iX2+eExPOdXbT6fSu/Skz66x73VlArPzoHkJZ7V6Oy5Ipp6yNdwueUqVBKUmSbBK+aNCH1yOzSNHsRP5R0KxewkJhuxrrHt5/Ug23njCTXcdWUxXxs+vYGv7kv7noey7v6S16TQzVleVrxZ++u6Ppk+cWeVXmq60D3L1AY7w/8P56O1MqWAxKmeBuJk5IVW3NMOrCdRzcdA7JjeeS6TjYfN0rS4yt+3b50v/l+Nag1Kmnnso999xT9Pp9993HKaec8m85qKHi+9//Phs2bCCTybBkyRL22GMP872HH36YBQsW2Lbfc889+eyzz8hkMqxfv95kVf2/FrsP29382z/+ACJ1U0tuq4JNg/y1TheeVad5IZ06+VTeO+E9Dh97uMunrbjiIG2QOcsw167S/z+41Uye1jhAKfq3EAl4bR5E5SEfsZQ7IAFaQl2jV1TH1nvIFrL87P2fkQ4ssW8oVGc7jQlTqFQXBIngRW9qUtTu7FZtYpEzbIlrJqjighus8zJU7Ny4M7s3786A3rVOVewVxKzgKWUs2CM6TTWRT3DvB7/iDW/ppKRG1/ffMP8GFp6wkFuO2ZvlvzyQ4VXFSe0RM5r4y9k7a0n8XlcSV4NcntNkmbVSv63b2A5Bu6wl5PMQFwAUP3kG9O33T6Z4bYN7J6iQ34PkGSRQ9yKSZE2CyazjN+kSvnGhYqmiXIop5ZFNKYRTumaLObonhwGOAt0Jq02rEQZDyvi/4ZVVGayErlX2ffZupKFQoFLwgSEQY4zQ2jzkDQ3Z9l5ji0nMS9/BQ7P/gXTiY3CCJpGU0v3cd/pcnrtwN5u0rKkixG6jKwiT5s8fbaRG0s77cmU0QQFwrisUCFdqz50ntBlf+TI65bfN99PKoMmUcp66RcokrsydzRW5cwEYqbaYC3ZP+0Iu/2w/5slam/Z0TiGbzbBeBx9npK3kPuQJMDGb0yabQDl0r7EtwmTJY0ou4pk8V+j3Yn7fa5kqmHL7VZWyEqDUqp5VPLziYdvrzW/+Wvtjxklw0PVFnzP3K1RenUwpM3Sm1cio9f27jKni4OmNTGkSFqRCh8w61QJWRd+GYS60bpE5Uh1zXAgBlErjNyt3M+R1RR28ZH9xV9luj0zWRboV9VaYf3v0haAISi1Y1WkabXcITCmjAcWaoJ9MsJylwdKVxD4ZckCni+HstwknoNuRAqr1xdSql+C1K6mJ2o/DmEPufEdjk42oCrOHp9yehPdqAEx9dYKDpzcSirYTnXAN/tpXzedCHBv+9v2pTKiPcvmBE03pUs5vH8sBQvl2m/eJJGeRdBahYd7f8+m9rm3nRSAiLYBSXfEMqD682Mf0YQ0aANRUoii4petL278rJR8PHvAgU3u3cn9rO78cfRyvHvsqS05dwp8O+pOt81xUUWx022MnHMuNe9xIcs4P2KLW8Of8gQAU8NBFOd/oXQLHSK3sNLqK4+ZYbIoH/bfgeWh/qje/br42KaONJyJIHVUl04uoUmcgJXLWvPJNxyA5JWe1z0Z7fhrKtHmpV9Wu13x5Oe8HLka88wx5pViEwFMMuEaNzrhDLK7E8EoBU1oJUOULIWLLBigVSvUBGsPAnLMK+ZJMqfB2yFzFiAV9PHvhbrx80XxG11eAPq5GJO0+aw5b31MlaQUJg/HXn8qxi7quaJ8Ao+tnFr2WKWTIFXLUxgKmefS4Wu18tfRp31erX5NuWWZJIGBbBvbo3jFseN987cNQkF/WFvu9Vid74Mt/6D/SnSll3LcTy0XWjEofUYZl7WNqPBsvksx8sNUOjoEAlh7zAJz8lOv3bjPK3JveBPVC65SmMiRJ0lk4Vgx3rIfDquraAdAZTlBKlFbLfsu3NTTnJM6/4BKGTZ2HM1b4fXzTa40bxmJ6SuUk6/hdmCBi9z2DJfXjuT9mr+F7ccnsSwCtQUohMYFZ0VMZ5bEW26KXVJ3LPA+asXuH1w7wnB4eDUM1V3GJ+eM1oFB1gL47Zu1rhsqwz8bsGVYZ5rezNLAj37wTPS7gphF54vgqNJnfUM24xPAEo6jAGs8mJF8PsmDZMdO7iZcz3+Xn/vvJKNrz1ZRJ2oqQQ9myiPHphl5zjI0Jhdxsth4KEUYJ9iNThSL82GyWsKoSimvrAoMtLakqFYNtYHST3UbRKSDkXIbk+OTsz5iRvo91qsYqFY3ORZbYlCo4alaz7ZwahXSAUfEyxqduZmYm62ojYYRKMdAuxt6T6njt0j3Ye6IFrH8WCHBaYz0r/H5yeM3uskaITKndm3enZNaT7tcYwkIuUhOqoX0wQyE5FhTrvhxTG3E17P9PjX/J6Pycc87hnHPOYdq0adx///3Issxll11m/vff+N8TRicAAMkbJFJiogS9Fmy0n6yfRlwf8CuDGjNDkiRH9dg9vjN3GK9dsgdXHqJPZIYGfbCNmLD4iwmeRgxok19IqKaWhXxEU6VR7+ZoM3VRLSn64f7DeXzl4zy/9nkKsvgZFcljJbEtPn1AE+ixYpVM8lmDjezrQ/JogEgY2SaT8Egeu2H2EHHKA4vY7xZN+uVxaPszkkSfId8zPKX0uSLZt4m71ljmwTd1dPGLLiu5iPqi5qJekiQzkXUaCrrGXj9leuYB3iholZFKKW5WVQGOmmw/zpDfY6OVv1TYhYZ6q3KZUQK2Dj9GBLwy4dF34K9+3/Z6MutIPnSD+P2HF9h/Sj1/PW8XtLWfWpIp1SvLJnAUGgqUGjYHLvlCk6bq0a1L0Mr8pUEpIyoCFZrJuRh9uqG0WFEPxKgrFHiwtZ3H9rxtmwmJkYy2Us3OBgs1qC900/3wxd/h43tt+5naVMZxS7/LV8GzqKHfnMDXqk2EhSSjsn4HgiF7kt+ZseRVkidR5KN0e/4oXg+Wc2HNCJ5Qd2ONqo0dlQwwzqMxUSf6VuMjzxP+3zBbWs3NvntYu+kjMrJMQFGYnBWfJUF6GyyDplk25pBaCCJJEqqqEs/keUaZT+f5X+Dd/SIaBVCq3yPbfpvx3PWke3hzo907EPTJbdapcNQ9JtjpFuLlsXmciaGzV5qDViKzyxiXZhkCU6qaEqBU1PJPUAvFgE6lcx3sC8GMk+gdeRCb1DrSgnlwxgE2SS6gVKu3uEoLIKvWFxngh+gptXxLH3e+rQE6HYNpUltOpck7j1TLiQDkPC2clVrBT+pKm9sD9Hg8phmqEWJzjO2J/pR9+75kDkSgd+NHVEft407Iwa46Y9dReOMd/FCXVeYT48h2awziLYNbUFWVgeBzSHKBQM0CE6AU5enBUJzXL92TC/XmAAB5Q9ZrbEOGgs/RAUvOoOiehQ060Ncry2TyxYCI6IlTBEoBQbnCtn1C0q5RozAviczozYN2P5iZnjJ2qp8L3d+wSzrDcVNPBTQPGLDmedA9SuqLC1j5vX/B7pnb6HF40BkLitFSG3WxADFBDrmzrDFMY1/+mVTLCSjpBq7v0hY3Ikhd4fGy8wRtzDG6+fZl+piqg7/7Tq5n0Nn0Q8pRr/uLGB3GpssbGCZ14RHmhArDl0WYo4qYUqpEzJjjtpMp1RXP2kzCy0PVBAQZZqh2Esg+s2iSliUBlMqa7GhnbE+XSmfMHF5hAeU6Oziqsw6aw9Y94iNPWdDLrnpHsDLi/Ex62nWfoye4FyDjuTj3L7+fs147i3Q+zfj6KHJwE77K9wGVyrAP1Rvk0OFNfLepnkUCgJ0tKKiqSm6z5Yd4foMFiJK3wN6qQgFaP9f+UYL1+sjBj/CDmT/goIYf2F5XkRkkzLGDceE11WR6DRW1hYJmKbDDdyDi3hxpm1Hm3vTG6LB29CwtF3cypar89ntCAiq3A3RoTdg9pcROkmLRIuL3MHtEJTXjd7ZtPyhJnNjcyBO+54ln46iqaoFSZRbzPhS0j3tQ3H0P4IypZ3DHPneYgJXRIKUy7GN+0JqXRSbYGGde6IhhuRyvbG7htc0t7DpinyG3dYvz9xjDoqv2pSrkmO9fvQK+ftn8pyRJpkn5KKmVHw3cQOVGzSYjMmIWI8vcmVL5QW3N46tY7Pp+qfAFYzwfjfCgfxmRkffiEe7R8+TniagJ5gU18LQmVENMydjsGmJD5b9CLNnQY4JSomrmgvnTuPbIqYwoE0ApIZebqxfkgwPaPbY1qIFP5YqCp5CFbt1OYBuglLg2MeaIAh76iZqqgYjAlKoRQCl0YN8ZBgDVmKhiaoP2zInSREkN2rbfFigFWp5y6p6abybA+Q21fB4McF5DLTm8rO20KzpEptSc+jm8lS7npo4uLhx+EABnTtW6Axt5opgH14ZqTeWGGDOGVWzzOP+T4luDUl9++SWzZ8+mtraWtWvXsnbtWmpra5k9ezZffvklS5cuZenSpXz++ef/A4f73/hX4ta9b2Vu/VzO3+F8G7un1lFhTckyV75/lWaYePLfSNVpA2wpKvm1u2pmu1ftbKeJSpLExIYYPgMVN5KJwVZbshoTuyz0awl0UBi0fB6ZaLJP697lEk3RJhOIUcmY3VrsUbCBGu3GekaYsN3otACSrx9J9+OJINvYOA2RBhu7oFSkcwU+XGstVPwOUCrrIt+L6N/Tt9rePTCqKNQJUo2a0NCLwm3F3FHV9BFF0Q2xJ4csCVC9X2C8+DwEvLLZqvidwgyeqb+QP3/fMsBVgbDPZUKSMsguRuVFTCldvleW7eL+0+eyy5hqrUogp81uJZJiH7bE7hrBIWSpgNalRfAI6dEnAdELoRQoVRmshN6NttdI6tdUXLzozJad0hl2KCHtFMPrkbnnlNnccvwMpjbpibjhgdS1Cp4+W0uWOldx58mzuOKgSew8uoqA3oXwMF0yBLBebbT1O6qK1Bf5kvRkLFp+X6bX5qMDcEv+eH7UWE6m/GsCNW+REPyuPHoi3SVQ8/8RuIZjPe+xaeE1AIzJ5W3nLhOphUgdNM2GqUfDMQ8QmnMW6N2pCvkgTy/ZQmc8Q0FPsMJVTSBJSELXwbwk2draT6zUKPu96V5WrtMSxQPiCQKKwiUDKTjjRTjizm220pXFrpGlttVBwoaAdr/UlwVMs3lbCKBUTLISFtF0c1ilBWjk+nYs2kVZ2GWcO/pe4kf+CZBIqdb9WyzfKzbsLgVKxdPWs9c5qF1Xr9hNSFJZsErb32A6T35wGoc3Xo6SbkJVvKhSluV5d2akGN0emU7HMeRLdJMsFU4fkoayIMw9U9hhmrqwMC74Yza27dm7j2bPCbUw2MaJg3F+V74XlYPncu2huyNLMulCWutOK7A4jTkqLQBH7UmrS6L51Q6mVBWDBL328xJseBZF1vZtdJTs9XjIukiyxec1I8hXjU4/IQcoZTAhKgoKb21q4bVCA3fvdzdz9bF1S9LuhxNSFejfDPm0Buw52qmLoFRozpkwanecEQ16cZpYA6xXtUXmGGkr9WVBmtV2jpXftfnneGQP+YFZeNefw3D9XFQo1r0YlbyEy7U5rVLvBNib6eWRs3bixuN24If7jLP5SYHmKWUwpbpU+/UQl/r1srYoF5lSzi5YIVXlaM+H2nbbAKXyOpjW2p8GwY+pYodTCApAeNAfg9pJZu6QkixPqWAuzTgXeRx8e/leUehAgNHJyhi/AMJkiAV9jK+L0lgeZF95KVWqdZ28glF7U7SpSI4FGuBx+9Lb+bTtU15c9yLj6qJERt9NsOFFvLEvqYr4kS763JT4GlYQAMmBHnb67Vt0t7jla5BLWgtj0aORMXu7bt8cbeb8GecTT4rHqZ3vKCl+1tXD/a3tyPo1KAI2XWL3VBp8wW1uN2T4w+DCKjKKe0fM1BbQYs47tjZCk8v04ubt5QwnU0oE32R/F8fMbuYXh03Ba+TljTNs238oXKP2ZDttiTbiuTheycsUobjtJsEW8yi3+wWssbwy7OfImGUULhYUnR5gYlzY28crW1oZli9okuW6ySW3LRWSJFFfFkTKJorf3PSR7Z91+rhym+8uZvS9Beu0jo1Eajlh4glcMvsSsht+ZPtMrm9HJLx4gm14oys48cUTeW2D5flaqsujJxg15YmSb4BJ/VYRN6oXuVbrHTFHxkbgJV/MlHLLvx2xeGMvWT1TFLPpH+83g9PnjbL5Ck4TmFI76bLtUJ+mGmnTWWQVxrU2/Fa3wTCtL7PuMYMpdca8kdTGAmbTH43dqVLFAPt7l1ofFtjoAOisun+0tPKbzm5G9jeZDRxEUMqvOMDhEt3WxfjNot9wyXtnc1+Flo8ba40Bj8f0vhJjfa82127s0LarjndzUCLJeRNO4O+H/52LZmuWN0ajjDIHKNXn4re27+Rteej9Z8XQ9vMu8c477/xPHMd/4/+D2HfEvuw7Qmvhe+LEE/nDkj8A0JgvFC0aXlz3Ij3pHv64/x9JljVCcnNJKvnR449mnxH72LrMuYZBu073UyZI0cqExZvBlLIZYOezyJkBImoZcT2Ri3nDDOrJeFWwyqzQxHNx92RDziML3ZY6/XlIAVmLFZR0MZ0FkLx9oBuvhpFsoJTIQBsqBtP2ATDgsUFxtPi8tOjeRUY1LKwn6psLKRAkc/KIXYm2fGb++18FpR45a2fWdsaRnqyHgS1IGeH8CX4EIb8HSZII6RKuP+SPI+AL26SejWU+6iLlbBiwM9uWdn28fQdj+BQMWMaafn8Gqh8FNP37+Fyaz4LFiaKkqvi3r1BENq9w3Utf8dQSDQSN+qMYF8SYKJwGkK5MKSNEI23B3HN7THIBDp7uqP4GXZ6lrZ9z2IwTil6ukLSkc0AN0a7aq5fVweqiantv1lpYp/IpFLl0ci75+gDort2Z6s5FpPXumoNOwzZgfXwTVEQYm8vZFoKZYBlc/o19v4fdgvLAbsjyAGohyI+eWsZso1WyZJnnotiT8AEBgKzWGWBip7nTBga5sbMbz/7Xwuj5bE9sV1MyE5TK8MvDpzC1qdwdwBKqeGMKcUBb1IrnY1jtNNALivn4FHwVnyJ5LLZGJKhw06c34ff4uXj2xebrhlmq6IOxPfK9rhLU73zOem4NxqDzN61qH0RVVdPbSDsGD0qmEU9os+t+jRiVzbHB76PL46HTyZQq0RyjVBjVddBkk1ccNAmG7QVNs+CRoyA7yK5lgo9RsJwaT5Ifev7Bc8puTG3SF17xNiTgkFHzOOQozdPk0S0NbE1sLeowpaIAHhso1ZYoNjwekOzAxRR5I6psH++9UcuQ3mDa9npkal0WRaWYUvGM9rmot5JOl3y6QlGoKxSgVmMQVuhysk1pu89YuFCALv15rB4Ljs6Ioj9SvoSPTik5wTpVG8dGSu3URb2cufA7ePx5Ruat8ybpfk3ivC8ypVQkmP9jqB5Pxbg9YOPT9KX7qI4GOH6utljq73OAoXKuJCglkC2p9nSCMhaU0uOyV1U41vOe9vu9ERvIL8bq9kGOuusDztptNFObymxMqbLyYYQS1vMR9AahYTrBNRoAk5YkPAIoFVNVRgeqWJ9xXKtvKd8rCoMpJaVBhVqhyBSR0pSFvEiSxIk7jmDiwsW2Oa9ZHs5Gdb15HCPKRrCmz95YYeOgVaRJ59NMqbOehUC4jZnDK0Do+BtVNLfJTq+HWD5J32CCukCf+X5TLs9WPQ9C8LcyvVdG7gb1QzPTO+MC8033rwzoC9Bd0hmqCgpdXk9R11a32D2ZgvJiX6xvHeXDIGW/tq8GfsrnUy4nGjgUsOe8e02sw9dZXCStapwNPSuG/KpkPkk8GzeZSaLMVfZ3ceXBk6mNBfjDkj8Q9AT53vRzoHqcyXJZGLbuuZaBdgp6EXJMxRhqJGvucWPxiYb/osm5EYlMni9btGe3IuxjotRAXT5Ph9fLTMEWY3zOfX64vb2TvZKO81K+fTm4awhFafb4Cbx7I+Ts+zcKZWMkR1fDSC0xf4yzp5/NCO9WLvvE8jVSchXMa9yND1sXEhr+F1Z0w48X/pgDR2ly52JPswLgQfJHbUbuaclabxSAuyrLeSmigU47VE0GnjU7ewJED74ZhhXLMcVIZPKsbB0gozNjJ2eyhNKVTGiagkcHSxrCFqA+XWhaYzKldKZzjy6HrgzVABYDf1ug1Pj6KF+1aufAAKV+deQ0fnn4VPb7mbafJqmH9wMXI6HSLAnM47Rj7Nefq2H5AsPiCZYIxuQFoXASLIwm47HkyaNqh+7sDPD0Nxpz9O7KCr7XZ79msteHYXU8RtrKpd6/88ueBPjg/nc6+el8FRJaUU+ONTAy3MhzS1vZa2It1YfeDE+eirdmOMS1MbQ6VE1vsrjIt8eEf219938t/ukup/+N/9sR9oW5K+lll1SK7zsTPD0Wty0mr+TNSS0yBAK/TUAKIFhhdpKqVIxBRnUwpTQwwiY90wcdkW0wUZDMSZJkglKJXMIVlJKkvK0NdbdPn/SERUEpppTs6zMN1MOqvaKzvaDUQNpRjZVLd1MwfAwiAxp4YBhtg2b4OeWohyg/06q61Ib+taQp5Pcwrbkcyc2rIW0NxFURbRAP6eaNKQLa4kRYyPooFHUiAljU9qH7l+sAVyqf4oW1L9AX1kGV/s2myZGn/EO8ES2ZL1MUruvsppBuorZlb5tmPKiqLrV793h+2VYe+chKqMsFE3Sz+57DbFNjSm3QN3LIXwVzYpusyPtPVlndQKlWwXReuAePnaQlkf1qtGhBVhmsLKq2D+bt0qLuzFazY2VR6J0WC/v/hp4Z55HVN+t3abP+mQ4kjXNUOUtVBdWCzm7UOx9+tqkPgKjfa4EjSp4TBrTneX9vtQ2UGhYtliBPyOqAWKD08+WMES6+a0Wh70/KDHDmbqNNc2Bb5NJQsBK4Cbkcv+7s5oFWO7tmVJPVYKCQGoGatz8vX/d/yiNfPcIDXzxgY4QEfR6uOXwKe021mC0GSGiEJG0fKnvm1DMpU3cw/9016NZIQiWbV1jflTA7qdbFtGuVbjucZs9exIRquGhWHVAUhungS6vXa/rlGfFtQSnDL8rvkfnrefOYNaJSqzYOmwsN0wHYwyMs1gJRTu6+kx/5/s4z/l9Y13hQB0eEduZGVXjL4BZEI/MeHcwRO3W5gVINDfYK7A7y2qKOhLbt9fP0WTDIGhemWSlQyoiyEp2RTH+KWo3ZXK7fG5vz9mQ6rBSgS2/3XlPc0lxky23LDNYZW9UaMqqPgJSnKt+BR2fenOQRipkDGpOjzJj3Y434QtZvKkgSVI6E3S6iUh9n+7P9FJSCmYsYizpV0T1NpLwpQ+50jIFJYQyu8PRQRy8THJ3QjP2A5lFoRCpQem79yd+Xk8wWuPOdNQym87YOruX+chuDOugNQsUIs2thOlRuyff0wthB1TOLvuNfZ0ppY4shhanyCsxnMqZE9aRZ1ewpLyMs5jY+y9Q67A3bbAoMWaXo4ydLMiOrrXNQV+Yn7Pfa8qqoonJOYx0HDW+mL9hHo9SNLIxZ4lPj67MYPIN1k2DKUXw86wZOf+gTtvS6FxDBOZbpckkByDeKTp2pYlapGDul9E99yw6IrlFuzVUZgYE286ubzMKL6F203+R6m9+ptkGEqkp3U3JndCQtgF7Mh2V/N7Ggl85kJw99+RB3L7ublJqHC96H3S7hH9EIL8SsPH/TQDtf92p+PRMrJ1ImSMXcFAI2ppQDlMoVFI7/40em5Kky7AdviKdb2vhbSysTBCBqggtzMFZQ2DuZKs7xhrAi2XYI45txnR2gVDyRYL68nJzTIShijQ37T26ySd9VJcg+I0oXxZxMT3Rpd94XokUgCGwVwP8PQkHuryg3QduZFRMArTGEEdHxB0LNeBau7mRtp7s89eN13Sgq+ALa7/UBYzcewo9mWL6bI8tGcuzIgzmtf4DagsJdbR3c3dZhdgZ32mRUVDgaKm1Dvmd4z4HButVCliWyHmvMGyZ12QEpKJbvxe1NNcJkUPXjm6bnooXUcCrze9m283kFFnKqi2e+ecZWgHJGsmKCXa0j3N/3+27mcM/HeD3asSmFKKR6wchzIrXcu3AtP3pqGac8sEjLWS5eRi5UYR23L2yyCPfQG0RMby43uwj/vxLfGpRKp9PcdNNNHHLIIcydO5fZs2fb/vtv/N+JPdrXcX9bJxMz7ovGrJJlzqNzWNGtJfv/jL+BLSTJ9HYpL2gJf5AsPklIvAd0+Z7Pgzlh6ElsRLhdf7LjTxgeG26aJxoVxVKgFJKdKdXv1wcfoVIiVpTECPq6uMr/J0DTLQcVOyiVyORdFw9GvLh8Kw++v972WtTnDuI15vOM0k2yo3o122Cxja8cz8ITFlIRqqQ8YnkvuLUe/aci4pKAZwa45fgZNJUHufWEmYBl0JnCX2TOSSHnCl52pd0TQMmjJV43L76Zq96/iovX/lV7o3UZ/LYZbptJc9hi2bR7PQzPF0iuv4i5Cb+tsmtUlB7IH8wxmWuG/KmDDpCwMmSBGMY+ywTDX9CBVwOUanaY24syD3GhJ/+TBoVuoErbcutvAegZHtKuRz8RunWPF8Pwct8R+27zue1J9xRJ+KzQrm/t+LlUHX0Taa82Efd5ZPplmYWhIHlgjc/HR+EgkqqyjwPfcGu/raqqBUoV7MCdmKSg5PlxTx+/b+/kV7W7cbneFvvMqWdyWNkEfpSxJ77momo7vWAAzt9zLMfMauaB04u7ypphMOHSQ1TXnRU84Kh4gp316qJaMxH2u4bqaAOPHvIoe4RvANWL4gCl3tps+WM55WLf3W00+0wXQCkdTKyWhm5vLMaw6DAum3sZHQPWPdQVdwOltFixdcAEpQy2lpIewfTAOfxqhOU1I3oalSuKKVP7IqBdI78wbn5bUOr+0+ew06gqnrrApQrcME37/1rLwJ9CjvFJzbS2WhpkRLUDlBJ8aYbprc03D24mb2u7rSW7TvleV6rLJj9sqrSPd81SN6khjHdHCYuvxfpYGpSse94OShWDvxUBd28bUwJXoy1WynWOz2bF/vyFCjkBlJrguq+jxx1NY6SR/UfuX/J3OGN4VYibT5hFWvdZOaTJmk9rJeHZ6N8MqBZTKlBmMWTRQSk9jGKXoircs+we5j0+j3c2vWMu6mr0gkwooJpAtuEpZYTBCAB4d/S7nFR5GzWyfaGjlmBOddaWZh2sbLXulYF0zjaOVQQqkAXAOOgJwpg9zTkq6fGZoFQoo52HM0cfwQEjD6ApYoGc/y6mVJU3Q3nIR6VXYGSSNr096zo/IiRl6fbUcUg8wZRMhhmVR5rbqqg2UOr8Hc5HlmQWtS6yfV1OtYCUCfXadxvdUUFrVrFUZzl/FRugWbIzO42OhA+2tlOXsZ6D8pqJcPyfOfGvm3l3dSc/ffqLkj+5O5FF1T3DlLR2X/3Ud6XWoS1Ybs7vrfFW18/X5AvaIrxdX+z+q/I9sBWnDN81M7Z+DkBeGB/njqosAkcIVxV1eQRALZ672wTJrp0p1cPXvV/Yxt9ELgG+ELmyRq6tseeSbfEOVvVozV0mVk0kJhQe3CTYoqeUMx54bz0rtlrPzKiaCHgDVCgKkx0gVLlSPO4FS5Ucw/+k15czjGfNAQb+Zdhz/MV/A1WSA+RxeIzZnlUlMKTvbjEopXcvVlK2uWOLAFANOOaUqSFt3sqrVo4Z9Uf5Yks/Zzz0CfvevND1uw1Jfl2ldS8VVK/Ng1GSJK7Z60Z+MvVsqBzFHqk081PWPOI0EK+KNYHYPGsboNT4eus+cXYmzHu3IT90yvcS9rXFjpUJTtppBABXdPdyaMsYkhsuwE+1bUzO6AXEZC7Jua+fyy8+/AXPr33efN/ZCGHNcW/YwLi8MK+MlVtJCR1V1XwMEvrYFiwHb4B3vtbGk6/1bsCqqtLn6ApqeGceNbOJpy6YxxPn7TL0ufgPjG8NSp111lnceOONjBw5ksMOO4wjjzzS9t9/4/9QNGkgYvn4g0tuIj6Y/3KCBGY730hWG0hijja5DGwFpcCVc1WWBC7gybo/w/2ah4BXuF1HlY/i5WNe5uzpZ2u7FZhSbu1+JU8SSWjBnjIqhsIEVEq+N8G/gmqPlsSGM3Gbb1F9uJG9fr+APW96x6T5ipHNK/zg8aU8vshemY25gFJTMhle3rzVXFiHHQN/Y6TRNKMVkxM3mvQ/FW4L+XQ/x8wexodX7su05nJQVQK6F0JG9RNwGkMredfERExMxdhzkjYBPfPNMwB81id0t8sloHc9VQUrAf1erzaZSyhMkja7glLX5U/jM9V9sWWEkxlUHbJ+e5miwBkvEDv0D+ZrMTz4MglrQmwaApQKlsGPv4ErHP5T3yZkD0w6DOqmwGnauaFtucWQEis6SQ3gra+r54AdNdbIC1u28ti405hWM22boFQ8Fzc7jWkhAKyqhM8jmQs+A8bol2XObajjBw11PFoW469l2jXfL5mi1m9n3LkxpRLZAmpBu/aqYj++qJikTD6MoKpyYNk4YrEmDkokeSM0g0vnXErgrWv57tY1XKwDVSf1C2C0G9OsREQCXm45YSb7TRlCu2+AhENJPpzJkiOk4x6C3S8FYEbtDJrCGhNBzZdmdXUkO8yqnxlC5d7wlBpWUmRUHEF9gdQ2YN1DhnzPLTZ2J0jqoLtoJq4C9QJw2yT43JUpCo2618OygLbgr/WG2UVPwr4z4TvbfbwAs0ZU8rcL5jFjeEXxm1U6e2CLYCqbz6Co1jNe2/IWDLZbEhrB70cEpQqytVjoSOiglACqftjyIXv/bW8uWyA0cnFI8JroHpIp1ZwvcHWXXcozTDBL3xZTqipYCpTSx8JqzbOsXGc8pRxsp3Aua8n3SoBS1+52La8d+5or67VUTG0s5+hZwyhv0KrmkXSx/xYA+TS19Ftzf7DcZgYtLnV9so+YTzuGPy7/Iyoq1y26zlzUjSzXwMW8at2/GUeb96xqX/A+1JAu8mJDcQceNpQXe74BZPIFm99XPJO37cPJHA94AzByVyoO1iQ+fWrO9JQK6HL5ULSem/e6mbOmnWV+7t/lKXXVfsNZePle+AR/obAu36NlCfztdAASYw7iky1XkVl/IeHYaPYevjfN0WYmVU1icpXl3TOhcgJjyu3siFQ+RW/Gmueb9dtUnPtbp33X/LtSKZig1ICq/U7jujTl87wVuJyb2zuZmc5y8dwf275rY497ARGgJ5ElueH7hNK7kGo5CYDlwdnwg09gxskmU2przyrXz3tR2SOVJmA8Nv9qMRZAyBn7VEd+tPYtAPadVM8h0xu48dgdNB9WZz6660Wuc/lwAWA3Ft0iU8pp6H7jpzeaC3KAE144gXNfP5fBQMwEhE/U2cntyU6+7tGYUpOqJuETjml0+WicIa4RnPP+459o+dBl+0/gpYt2Z1xdtDSTvHkuJyfs3dOC5S6MKEn+1p33SobfHZQatuYx9+0dRVxJAM1UJWCOW25R5Imny73XK3aQQmRNxYXf6VVVqp/ROsmnHQWNz7f0FX2fqqo8+ekmPljTxYLVerfWmgrz/Twewj6XwuS+v4D9ril6uYgpFaiAUbtZL2yjKDiuznoGIg5Qqj29jUKus/jnAKX2OeJ0rbP4BR9QsccVvBj/LuBh17F11AQtKVy2kEVVVX6z6DemLHmL3hTkuTXPsesTu9r2G/J5bFLwHgeDqVtn2KqKV5OH6/mDcZ+MFdhh/akcd72zhnVd1m954L11Nr+1HUdV2XPh/0fiW//il156iZdffpnddttt2xv/N/53x3EPwcrn8e10PjzunnyJEdkWgr09oS8GgqkOJGmk2ekt743gLaRAycMtk9k53g4SVA9YMjWvJGGwp0SqLFi04cHsoG1CNkJshQuQ9+TIAb61b8PzP4Qj7rC1zhUj602Zi4ywotg8pYLU0jmoLTA6BzOmwZ4RnSUYCGX+ClOPbERTvmB7ICMOkEv0jhIlFj55+xekQ4ZbdcO5CM9nkPVroDGlHBNIIWdrC2xEKVDq7D01IKCgCouvQJntezf4tN/3p9Z2U9NeQZxJ0ibeEc5R0AUULBWiRw1AJGCdwzJFgcaZNOe0tq0qMFMOQ6eexEbroXyEfYfOSThqZ1n9U3HiYxoIVdA7jaX7NZZBxQjICzdPUkvsa+sa+OnRO8NyqC0o1Aa0+2WboFQ2TlWklg3d+v1va5EuM1o39FZVlYwubypIEit1BszzsQge/dQfEk+Q8TfZbPzdmFJdgxmTKcVQTKnDboXhO8PUY8zkvSGT1FiXejJydv8Ac9NpO+X/W8j3tivCegW5d6Mmt5A9kBmER46E0XtoiVuye8hdOIEyg5btlO+J8b03v8eM2hk8cvAjyJJMKp+iIEnm+TXYFnWqJqcQFxulwgCx2wasbXuTWfIFBa9HJuwpJ1nopxDXZGBrOuKWAb2QiCmqSoMgXxabL/hUzasQYINfe7bqayZx28FXsyLfx+y6fyOr2vAUEf1B8ikKwnAg/fVks7MnngAIcjGjg9LK7pXkVGuxa8h7MsKzNpjTFmvvbBbkaBMPhgWW9KFR6mbpNhZKh8QT/FpgJQwP1rBGZ5OGvCFUVeXq5740Pe/EqBUS6x/O+iF3LL2DkDdE1R5XafNnpfZ7KuQAOIs+QDjZAz36vVpdLN8zYltdQ1++aD6vrWjjtrc0gMustAtddkvFcKnDku0HyzRwrE1b/Do5EhXBCvO8gwbUGIUnY07MK3kKSjGAlwcKajGjI+UoSqhKAFlVURy/uT3vzvz4Yot9YdQxmEEVGCuGvM0IY46umXgofH4jvUoGSb9Hggb7UpdyiEWmfxdTKqSmCIX92pilR4Q0FX0r4JmjtPsGiI8+mPVfaA/OyQEvt+92O4qqIEsyk6ommZ/NKTmqgnZWTSKXsC22Dflrj+Bplq6tAR2rrFSyyHShAivVEewofW2yRIyOYgckU8zK11Abs9sk5Aul5/qeRBYl08AuZd/n+ZzGsg8aeUqs3mJKffk3CBTf406fvn+LfK9xB/jqWQCSOFh56xbCnj8h5Pdw9ymCh5vhd3rUvdocU95McPl9RbtuijaxOa75l40pH8OavjW0JyxA2AClTpx4In9d9Ve+6PqCvkyf+X5HqoOOVAfLqmYCGqO1WWfrv93yHFkljVf2atd/y5e8v3ELqfH7uVp2iEwUEZTKFxS29ml5wAk7DreMrkux0IbvzJUjLuKyp05n7igt1wq6AbTfghHtGnVToWMFjN2nJFOqZISH8PpRva6AfluijbpwXVHhXA60scvo4fT77fdaiwAUiUyph1rb8eoKl7SwapAlGUVkJBcUfB6ZF5a3coXALvR5JJprrDkwh5egv8Sc5fwdwQpCiv0cVQYrYeQo+ES/P7fBlBpZbb3vLLyMqI5CacxZK8jmhAYEBig1bj/Y8woYpq9lG6ZBwzRemJbgna87OHnnESx+rc5kQGcKGV5c96KNHdWV0nLpn3/w86Kv9fsgIcwb3Q7fyG7dN1MtRAGJbF+bVh7RVS0+QRa+fEsfv399Nf7qmXiCr1FIN3LdSytprtCuf0X437Sm+z8Y3xpibm5uJhb7FweC/8b/jqgaDbtdvN305H8LU0oHpeR4O+V+iTM9rwJQCFZakoq4e4XVK1SEnAmzAUptGdziKg2RgxpVe0z5WGT9tu8xzHc/e4S17Z+zsW+d7TPBnDZAtHo9ZveYsKriE/KhsMcCH1r6rIF62eY+PtvUa3a1ckalSzvdBkcXxIiDPlpdokLu5q3zT4WbOaFTriRM2Gk3+Z6Sd6WYlwKlsoo2+9hAqXKr88eALJnXaZIgM62V+pkkb7J1rwg6GSVDhLPFvNdjfTakqhCIMTw2nIcmfJf7Wtu5LV8Om3Wz9mE7Qthx/f7dIIgRkgRev7nQNLv/iUypQf15CVbYO83pk+H2MKUu2W8Ce0yo5cCp9fziCKECKuW48hCtQp5VSsh8JYk1OvAwOZslLdnHk4F4gDUddkltZzxDfnAqSraafNzePcdWHQpVwC7f05okGHT4VK8G1ulSSgmYmcna/FBsxvP/jmieowEZiQ5YqwMSix/SWAbv64y6eDEYbgvHMRm/0ynfc8ayzmV0JDtQVIUTXzyRo5beQEK/zhl97A4V8tSFtw8INbxAWvusqqyqQo9epTt9+D0k1v+QQmoUYNHNQTCg1z9TbQA9QEG49WRUm5wPoDZcR7hmPDs27Ggaqv5bwq3lej5TDKoM6l2pYvW252RSpbbYdnZtNYobqYK716A5zzTOgO8vgp2/p/1T6rZ1iXSLsKqaXcAAhoc0IMcn+/DKXlZsHeDRjze5frZOqNDvPXxv/nroX3nowIcI7vFj2Oun5nvlsrskLaSqGgu1eW5R561vE1OayjhrN2us8Bq/2WCh9axz+ZQWRzb12eV7DdM5S/e2vLxipm1b51xZHig3gQ7xns8qWQ51NIzIlADW4g7Q0F+QbazbjwpTOCv7Y7pLFJU29dgXZRu7E4j+NKXG3IpABR7Jgwp060BJSDcNNoBSnyAL+ZctE4wFpQFGCaBUmAxN71xqScFnn4E63JKLRHQA2gAawr4wuzXvRkWggum104tAqcHsoG2eN66RyJ7aNGDd07KUY031N+w1opmPPfU2MEhkYvR4qlnVNsjNr1vMpmzeCV1a0Z3QrtnkRmu8NQHTSK15nVtU9/nsfwSU2uVC2PUiXt7xYVujCgB63LsPmvK9EbuYwLuzGAtaB2gjDPaajSmlg/WjykeZnzcYIWK8N6AdR0hVqNZlelld+js+cDiSGiaT6KNcUWgI1tCbyLp6exny0x0brEJ320CagqLi98jURoVxqRRTKlgOgZjFVqPEs7A9XrZDxclPwl5XwTH3l/SUKhn+0uuhJ8+b5wpK7f/3/Tnt5dOKmmqERzyEr/lB+h1NJwym1BqliQEd1PB1z2WWkAsXHPJNUQY6oOe5D7xnH4uHV4XxB6xzn8dT2rtI8FvFG4KmWUW5dkWgAkYKzKJteKn6PDKH7tBIQ1mQeWPt65pfHl6ikcEIQUotstKNvKt6PAzfqajb8uiaCGftPpqgz8PIcsv6IFPI8NI6rbO5wfobymcurfSjCvvuFGxnFFUyQamJhV4Okz8i3qPnG1FtvjYalQA8+rGWx2e755PacgqpTecA0KLnZJXhf5P65f9gfGtQ6uabb+aKK65g48Z/QZry3/g/Gf8ylRysKmq8nXO8r3CqV2M/OH0limL+j/BEG0q+bUjGnN1hjPBGtGru7PpZZtcug265yevlqFdPoy9nXzg3ZCUkRSYty3yjL7rDimpry6sKldQtvdqAks4VOOWBRZx038esanOX+1SHikGpxry9YuBkShnHbcRNe97E8ROO5/Cxh/NviVJMKXEC0qUqWdVDHq8FSo3TvUfmfNeV1u3GlgHNwLYohIl5Y1A7ptp8nqhwHFOkjVRJcZv5fcgB4g2VuDqZUqKhrwTmxDa3bjbz0hl8qT7YpINSI3YpbvH8r1bsthUVOjOrT0/qRaaUQRM2TBNPfBx2uwQmat3FtocptceEWh45ayf+eNpcdh5nPefzxkXZe6K28CtlArnR5yMvScQKCk35Agndz+P+1nampQp0r/8OP3pque0zXYMZCokJJNZeTiFpN28tSVk2fl+6T2OMpdyBTuDffz28AdhB73y49C/a/zu+tt5X1SIaeVE4ktRwQK+sDSHfM6Ir1UVLvIV1/etoz/SyMKxd05TuaxHIZ22Lk6Ei4AmQzhXo0AFzA0voGtQS3UTKh5JuZpbeDdEApbyyZKv2KaqKR/DNEBf6skoRKLW9oNm3Drd5I5+mLFQisXPMI82xZlfJsbGwK3Xft8UFJlDdJK3Ig9bpq5R8b4reyUjG3rhjcsUYmqPN7NSomeD3DCGnrI9YY09NqIapNVOZVjOtaLtylwUs6LLwQBmc/lxR571vG6J8WzZ+szHHG75VYozeE4DT/Av4/jz9fgiWQ8N0Lunt5/2NW9gtYmehVgbsc2UynzR9bkT2TraQ5YZjp/OHEyygrUimp0ebo9twjDSn6ZKlfHwcJ+V+ztvK7JKyVqfX18buJEjWa5IkFctu0QAeJ5gTVFXNNFcv+vmF5gH/cs5lLCgNFqHAQD5uahRvtw70XLYSjridaMgCDIzxSYx79r2HN7/zJmX+siKwMJFL2Bg4JiglAFWbBi1QSpXzvFvdR4/Hw0vVSf4es55BcdHbKVVz4K3vcsfbVm6XLSh8vK6bsx/+lM0CQJjM5s1rM7nRGm+Dxn0aqTUBl/U+dzZC2sly/GeblYjhC8IBv+aAg45k4jDHODjYqjE/xFBVqwAoFIMnV9sLOOAApXTDadGL0GBKxfwxM4dsibfgjIVdSwENEKwVclwKAVo+H8YO17zOowv1ZhKBKEfd/QG7/+4d2vrtx/780c+z8ISF1IYt8NzIjZsqgsgiYO/sTrzfr2DMXrDLBUXzZdDtOvyr83zFcNjrCojUfHtQaojYeUx1Senz8q7l3Lvs3qLXl7QvZkBXa4zSWd+G0fkKdZTJlEoWKmyfmzxQQSFTR1XuAMDul9qfyrGpO8lyB7OzuSJku69zeAi5dFQG7OuCETtDeXNRrl0ZrNTUAbtdrOVJlaPc9yXEXSfP5oOf7mP62hmxzyQXGwVvEM561SpMihI+w7spuu2GT5fOvpTzdjgP0OYLoxBldEU0mFJu0Za0Yx6dsuCvhmyuJ5sLKe7034G0bgEALfkyEpm8DZR6bYXxfHrJD043rSyM+C9T6lvE3LlzSafTjBkzhlgsRlVVle2//8b//TjSU83zRz3PCRPt7ef/5aodWDKYVB+nKc+YL/tSne4Vb/Nz1UPK1IwJoJQEz2hfPrtutpkU9uiL3I9D7klHrZoklNUWjJ8EtEEjrCpEVBVlzQ/Jrr+KnoQ1ARgT7/quBPFMnkxe4ZmlxZM/QLXQdcGI4Y5FnNNTSpTvARw06iCunne1Tcr3L4UbKKXkYeOHWpL0yf1wq7b4MbrZBIyJ7LiH4PhH4IBfM65i3HZ/ZZHhI9gmnA0xbaIZmbOfm/kejYoc8liJbMgB4iUy9s/YvjdlLTZ2GlXFjFqBMSDKrAzwMNElgFLzzAUooCVP/07mh1uYoJQLU8pIEIwJe9KhsP+vTK+F7WFKiSE2ClAk63tKddEzYmI2iwR0Zjx0qzF2SWc4rmU0/z/27js8irJrA/g9W9M7pBBI6E060gQB6R1RsQIWROT1U7FXiqLYXl8UBRuCKE0RURRBepNOkCq9kxBISG9b5vtjtsxsSTbJJhvC/bsuLpLZ2dknyc7OzJlzzmMuqmnLODBYZghzV9YKFNN025YplQEkW4Jc7n62ishca3Wf9P+Jv4Dts4B/FtofK8wqOSjlcLFjDb4VV75nlZqXilMZ9jvq1qBUgeX96WcoRHRAMT2xZPRqPS5b7sgF6NS2/g7WQIj199+ujvKiU94IFQBqBusV2ZVRsgsZFYBoo0kxW01N/woKSgXWABw/A81GaNzNRBiizKZRCSo0CnfurWQNSrkribSWzNjIGu7mWf7W8ubuz+aaMTfZnsEQLHvMXxuKP+78A7N7zQYAXMlyHQgDgNohsehRuwf6JPRxKhOTC3OzbwSIIpDYVXkHvIzkmbK2+I81U8rat0qu67OAWg9V8n7UuLJNWmYp3xNgaXDskCnt+L5OyU2x9blpVaMV1IL0vrzrt7twOvsI7mwjm+mshIw1qxCzGY9lZOH+SzWRf+kh2/LLGa4vUB1LTi5ez4fgYkZSVxyP43qzKB1nLL9A+XlOubPTrftnYQ5wZjNw1F6qUtdPdq5kKUWSl067ukgVBMGWaekYlMo2ZLsMSsnL9y5k2feZLFl2cnLwFXwYKW3PHyqoJuywPWY2OR/HDSYzHvpmJ9b9m4qnFiXh4vU8fLruBC6kS38vvcZedg7IyvcCoxBvOZfIVnt4+VNMRkxpadQqNIx38Tmd6ZC5ZCyELfNOlql1a8ytGOPXE4/LZsyWBznrh0o3eFwFpYK0QbaZmi9kO3x2AUi1XJD7q3QIN9t/N33ysrFB+wr6qnZDZdmWqAuWArEAVh9Wlunq1XqnwOsly7lxfLjD79LxM6rTBClY7hfq9PnkMihV3DVDaZW2fM+BY2ZuafrxWVlv0ja0TIZhzb75wHAvMi1Z0SZzINJlfcnyVTWQd/o5+OdIPZ2vywLpmfkGnL7mPAtfXKi/IiBohNr9DMzyCorErkBwrFOrDNtxqM9bwIivnLKV3HH7mo/8CcgnTLKOwXrddHItsOkDwGS0TY7lcqImB9GB0bZ+ljmGHNtsuh1ipJtBafnuWzBczDmr+P6q7CaEGSrb3yrSct0WflFKuPjusBHPLtlf7PWInEqAbVbUm1Gpg1L3338/Ll26hHfffRczZ87E//73P8U/ujGFWJrlDc3OwbTApqgbWhcD6toboPtr/L1TcmG9sLxyCKGi/eJXKMpWXmg7CogqNvgSGxTr9jG59tHt7ZlSgz4ARnytmOFCLhz5CC2UPgzTLJ8RAZYP43xDLAoLQnD8iv0D/+L1fOQWGvHPhQzbsh2nlQ1trUL89egZ3xumgjgYrndEl7x8dM1TngAHOtxpdTyZ9Tp5UEoXDNsEzfMGAgeXAivtzUYLLH0RbBclfiFAs2GA1h/1wzybthiA4iTWxpLhg4j6OGK5G9HAoMxsai1Id01DZBlL7QqUF485DgcBURSx6lAKLqTn2cr3Xu7fBPMevRW3xtyKmXfMxO9dPwae3m9/krU3VG6q1CRZ4wfEtJQuIp7eD7R/FOg92eOft8yKy5SycpF9ByiDUvJ9KDZQ2meKC0rJg7zust2smlim3z2fo8KdRW/hf4a78JZBaqAb4qfFT3suoPnk1djwb6rbslYADk3X5T+I5ecryATSLHfNmw52va6rUtTyimkllUQa8oDVryofy0t3GZQ6aq6Dv29fAPxnl9Njtp5SJufggeNJ/dW8q4os0C3+/jAAKPCTTnz9jAWIkV28P52egc9vde6LAEg9ay7aLhL8EWZJFbc22UzLkf6vXzNIMSujtXRv1oNt0bdZNJ66oyGgD8bslFQMyMnF4xn2LAwVRGi1gYpS5zbRDpMDeItK7ZT9BMD1PgJIvSccWPtKAUCP2j0A2C/c3GVKOWUbBNj/ZtZMKXmgrmH2NUWJqbxcrMCkh1qltl3YJGe639eC/bSYecdMfNzj42L7PoW66QHpbxalHipeIH9925fWv4WrSQEiG0j9cQB7ObQ+BJCVrDmWM41pPkbxfXZRNgpMBQjSBqFOSB1bD6YreVfw2Gpp4pPxhueRL+rwhnFUsePPv/ggjDkN0SYzHBoA0Xk1FA3LNx67itRs579FgUNWMwAYsqUbNtaMQHd/G8eMZ39RtGeXQZm167VMqZwrwHdD7McPwJ5hq9JIJeIAgmX7e0nV8I7tBHINuYpSveyibBhMBkWmlPwYYp2V05E/VEBNe0ZQutn5s9xoEm1lSv9cyMB/FuzDx2uO47HvdktjC9TZ+xZByqwCAATWcLr5V6Jw58zvcnFVDphxVvm9PDDiEJjs4NcGbWTnOvLgR2JoIgBl+V6uJbs9SBtkO4d0Vb5n5R/VBCat/fOwd34WdIIJM7WfIVGQLuIL1PbPluNXXMx27UB+vFGQB5o0frb3IQCnLKjG4Y2Bbs9LgawO46QJLgZ+UOJre8xVppSLWQA9pVPrXJZbFsd6PlyvyB6UMgO4hBrISpBKa0WTP66KYbbnGC2Zcpn5BszddkaWhSMtu+QisF4rXBmUev+edk7r2H8Q2f6XcBsQFK1slQDX7UjKJaEL0FN2jmX9HLNeP65+DdjwDvBNL8CSkaSY/a8YjhNDRflH2a5Zrhdedzsz8OlMZQlkuuymlwnSbNQAEGpSHhuSxUisOXLF6XrEnVB/rTKb8CZT6hSLv//+G9u3b0erVmXvRUBVz8KGD2Plzo/wQFY2kCh9kMp7A3mldA+wZ6FkSif8WaL0AVt/2DR7JoorgZHFBsVqBdWCAEFxQucoQBWB2KBY28nUgbTD6NH4ARzTub4I9hdNaOsXjD9ky3LNITgW2AjR+gAkZxbgmKzfyrm0XAz4ZItTvwlXgvUazOj5Meqt+QOAgC/9fnJaR+/wwV+aDKQykR98dAHSzCbWTKZN7ylWzRelD3aVixPv0twhupJ3xalBbeHtz0MfUgtoNgz//H4vYMpGa4eAUz11KiACOq0fYDmG9MpT/t7zipTbXXUoBU8u2IeoIJ2tZrtVfKgtOGC9GFVwvPsSXtd+4hRRFxhcSYH4MMtJoi0o5eKi1UX2HaAMSrWq0Qp7r+wFIGUgJOcm23pOWMmDUtbppJNzkvHTcef3qFw9S+AwH3oYQhLwVV4c8i0H6FB/LV5cKmU3PTJvNx7qVMfp+Rtf6IFP153Af+5w8z63/nyiyd5HwF1GlLdm5HHcZv2ewIElzo/lp9vHFBBpa3p+XQxCUa0OQA3nLKFAS3mM2eDcK65pRFNsu7zN9n1qfiou51y2fZ+tVuG8VoMCy118f7OIEJ09wy/GaERCRGOXP4af2k92kRAArVrahzPylJlSUUF61IkMwKFLUnDBmjkxsEUsBlp794gadM0vRFfLdNHd8/KxKcAfozOzgegWKFLZ76K3jGrpcjxeIbj4e7vL7Gs23GlR57jO+OXkLwjSBuHlW1/GxgsbcTnnMgxmA/KNrrNlLmU7BKVk/U2smVKRJhMuW5rVhjlc4MiDUllFyjKW5Ez3JSSOsxW5E6p1HZRSxbYC2jzk8rHysAVhgl0ECK38I5xLbqznBB2eAHZ9CXR9TvFwnZA6WDhwIX48/iOWn1xuW948sjlUggp6td72N7Jmta0ytcNfpm8Bv8sIxHq3wzHmNoAxuwWaaOYAGvsscADQtk4Y9p3PwIId5zGxjzKTzrF8DwBMOU3x3C0fY1hz6QLv4eYPY8WpFRjWYJhiPadMKVEEatj3VaPZfvHiMjukNKzH4gs7nR+zfl7J3ifyiUt0muIvjBwvRHOKcpDhMANpekE6zmW5bvVx3G1QSnrds/3m4sTKmfhSe6fTOkaHTI1/LOVJ1s+1iCAd/GSZXtbeOgisgfjSBqWi3E8GUCbyIFNkQyDthDJYCNiDUmqdU4mtTmVCtuy8S/53sL63rhdch8lsglqltk0SEKgLLLZ8z8pf64/8gCZoXLgDuSoBPSw3S/WCAd1UUoZ6nmA/p3AsDZPbczYdlzMLbL2nrI2cbeTle47Hcsv56LfJV7Cmdgs83vJxKSDV/WXnsj9vcJUpdf2M63U9nFwoWBeMgvzib+bJWf8udS3nUkZBsAU7rDcPpaBUKBpDCiyqQmsBadKNjKkrjii2l5lvcJntGedQvtexQTFZ1v7hUol8Ua7UWzMvDX6iiJpGI1I1GgRrgyumNF9+PWI9ZgQob9Yheb/0f9eJQHwxgTUZa6anVf3Q+gjTh0EjaGAUjXh7+9sun+cYlEpTCRBghggBOhht7QuCHT6bLonSPmnNLCyJoZhJHG4GpT5zb9KkCfLzy19zS1VLQmJPPJmRhVCzaEuplQelvFK6BzhdOP9qug29iv4LtLhbOti0GOn6eQFRxV7U6NX6Ej8Y64ZLF1LWA/OPx3/EUzum4F9/1wE3vSjizkjlB9jnRXfjzIAFtrtw8qDU/gsZHgWkAClNXqUSbNsx3HKv0zryU8KOsR1dznbiVfJMKY2f8mQoK1mxamBQECICdejWsHzZWyeun3CaiSRbANDlKRQE1cBRyywfrQqVQSnB0hhdKzs5qedQ4ud4Z+K3f6SL+ms5RciwnKSGllS7rdYq+0cVd8FVkZwypVyc6Mj6+8j5y+7MNgxzPsG+lHMJ+1P323qgZMkyHHINuTCYDLjn93sw99DcYodYw9LDKw96PN6tHjRq+zs4xF95Yp1b6JxpkBgViI/vba2YOldB6y/NnAYAWZaTal0A0MRNtlRFSHAz62zedXtvA9nU1dcR5DaIYG0kDLMfvur5EyZ3tmfcOfYOuZp3VVG+BwCH9HpcszSf9xNFRMsaWweKInRuMuey82G7SIgP97cFaK/nGSCKIs5ckwKRtcL8ERFo36a/q0aogqAIMnxsCsOvFy+jV14+UKMxRmVK76W3Q1qXOJtbucgCqbDeCXUItgIAWj/osgl+v8R+eLfru/ht+G+IC4qDn9oPRtGI5JxkW6DDqSQl5xKMZiNm7Z+FFza9gM2Z9kbM1l5GkbK7pmEmz4NSlzJcX8j4aVXue3840GkD0KDIOTCnGvRf7zRvdtyuLVPK9QWOUdBKxxjHkjTr+2fA+8CLp6TAr4MWNVrg7dveVpSAWvtoOd75tn6OmaGCIJQQgDBLn/8hgrQ/ZMM+trvbSRNu7D3n3Luu0EWmFCDg1pgOtvdJTGAMNt+7GS/d+pJiLXmGkc4sQg0AUa6DUipXwdbSsGYYuDpeWINSDuVpE3rUx8AWMWhTu/jsB8f9IceQo8iUAqRZrPal7ivVkP0tlyVCo3543PACzhe6vsklz+J0Glugcn+yTWyi9UekOhB+pcmAiXIu7S0XeUAjzpI96hSUslxjudhP28QHoZYssNYpthO6xHXBo7c8ajtHFCHaSsGsN5aCtcG2oJW8vM+Rv8YfmaHNsPhyCn65lAKzWY9Lt0iTOGgsJUu5sI/rSHKWy9KkLzadwt1fbMfTi5Lwx0Hp/DE+wuHnkf98jp/Lls+FWwsK8Zo+wX4NUhEBKflYrL/7/QuBmS5miQ2Jl/obOXBVSl3a8tszmVIQLMpkQpjl2HHNUhZmPS8TTf64Bvu1QGAN5xt8Vln5BlvppDwDPS7Mz36cBIoPsqk1wITtwMRD0u8+OBYqAIsvp+DLW9/Ab3f+5hTo8Qr5zQtrcD3A+QYeAOm47iHH40W9sHpSrz/Lef4vJ39x9TTb38baCzJNrYYORuhhgFYw2YJSQQ6fLcmiNOZ8g6tjhjNPM6qqq1If8d577z08//zz2LhxI9LS0pCVlaX4RzcoWbq0taeDPOPFaxcUDhfO6ZAdiIJqAHd9LZVHOQqIxCO3PIKnWj+FHwf/6HLTtYPts7bVCXb+oA6yRN7lJ1P7r+5XpGHK6UQR9bOVje80gj9ubxSF6BDpQ1ieGuuYmaNznJlO/uNYSmE2v9QTB6b0hfbur4DxW53W6xlcH5F+kZjaZarbbXmN/M6E1l85xb1BOUdrVFgY9r7RG+0TXfeRG9FwhEcveTrztNOMF9bMnSNpR2AUTYjUh6GWy4sA4MHgxqijux0vXHI+KDqeKFnLkwDYysfclorJyS+yvNnDoDSsmVJZlwCTwU35XpjLp/qr7Sd+8gNyyxrSfnY26yxG/TkKU7dPxX/W/UcxM0x6QTo6L+rsuveXA2up0pD2DfDIbYmK379j74AyH3itP2OWJWtIGwAMnSml81eGW0ZI5V93vAm8mWZr3Iy8NHs5jGz2yOtisGLGOjl5k+imUfUUmZD1Quvh3sb32poep+Sm2O7Uta7RGgDwRo1IbL4uNZ71E82IybcHZoJUOmjdTMucWyi4Ld+7klWIrAIj1CoB9WsGIlwWtHX3c8g/N3S1O6GewSgF1A35eOZ6Bn69eBnDVRU0O6WLMbhtTDx4hvTPBZWgwpD6Q1AjoAZUggrxwVJg8Xz2eVv5nrXc1epSziXsStmF2f/Mxuqzq/HfYz/YHrPOvhcqO0ENdcgIlZ+8phU4ZEq56WXUolao56n9Gj0mX7OXjw+K7oQe8T1cNkX3BsF6G0Wjc54IAkCuKlgKYjpeaFu/FwSp4XAxQmTZFLfHS2WAjhdE6QXp0sxrqkKE1NwDQMqknhLSClOv2o9palFERKD02sGQglJZsqBUnQjp6xQX/b0KLZlSGoe/heMkDa6yu+WZUn7WfoA17IEPx/K+cimujNn6eeXwOfFS/yaY9WC7Et9nrhqdOx4ndiQXk/3uhvVC3toAObfI9bE/u5hjSGSg8sIzq8C+rqDRI1oWLH7zWjqaFRbivsZSz8BJ1xz6ykTU83zwnpBnXsZY9kXrrLqAVDe57RPpaxc3g/XNBqNpYDw+8G+CRYMWQaPS4Ms+X2Jiu4nQqrS2m8nzD8/HlotbbEGpQG2gradUcfw1/siNaAYNpJsdS023I7TLw4p1ssz2cZnMossSvi832W+iWM+NnXtKyTOlHIKPin2nEsqZrAEkU5HUq2jli67Xe3gFEN/eafF73d5Dg7AGmNFjhm2ZUMpxWwPSIb2nIcoyU9x0DEGPxjVsN2+1CFSU74XHJrrd3pu/Hsby/dK5UvsE+/5aK8xf2YexpAkvLLMhArCdD9cwmdGl1m0V11ZE/n6wBtddHFcgqOznxx7QCBpFsD8xJFH6ooQEpbQC6XPBWlp5WqeFruZKBKml65dsW6aUMiiVijCPxpUQKb3/PLomqcZKHZTq378/tm/fjl69eqFmzZoIDw9HeHg4wsLCEB7u5bpSqjzyng5XpTu+8uwo+d27cvFTZvukiS7ugrnqHRUYBZ1ahydaPeFyBhIAiAuyBwystfVywVrptTw96dOJIiLTz0Mv+5BpXSsaATqNol+BO0NbuQ9gWA9Weo3a3tTOxcXUJ53fxuq7V6NWUDEzE3qLJxd2VtqAYgOVr3d8HfP6z8Pgeu6zWAK1gTCajdiful+x3JqmfDhNuuBuGdnc7aE9yC8cYxq+gtw85/dEXpHyPeuqT0uYJ1Ovymf18FWmVFBN6QRVNAMX97gp33P9+SufYlwtqPHrsF/xbtd3MbDuQMV6P5/4GZsvbsaSY8ryNHeNnh1Zg1IJcbEQBAHyLGbHchdPmz46sQa15UGpgAhg4Ifev3hwRR8MPPQzcPsL0omcbeKGdFmmlCwohWB7RpQD+Ux2QXqN4vM20i8Sb3R6A5/e8SkAICk1CYWmQujVenSt1dVpW35mETFZ9j4iWm2gIgAp71tVZFDhryNSWV18eIAt8JSRZ8C/ltlC60YFQq9RK6YmdpuhI29Iqw8Bmg6Vvm47CnrRksGYU0IT+PIaPltq1nzXHPd30uveruxZUgxrj6lzWedsfXAcT76Tc5MVpUnJeVdt57X5lpNeraKHlPKsN0R2XEnNsb8XRFF022C7de0wj8YPAND4oXVhEb5MScV/r1zFe22excxeM8uffeOGIobh4nMyT2051jsFpVwHT12R91VrXbM1AOeg1OnM0/jyoXZo3nwzjAFSUCrSLxJ31WhvKzEGLNmFgWoEIc+WKVUkmzgjJlTa7hUXxw1ro/M4h3Kk4GKyd6yUQSnLe0KWKdUhpgP+0/o/iovbMvOkmX0Zm6k79pTKKcpRNDWXG1LP8xmC/SOk/i6BLmb/kyuu55VjWwHFTZGiHFv2CQDcnZ2DJSlpeL3T69h19gLuyVbegPN6Zo58pj3rLGXyTKmzW+wzvLr6++mDIDydhAEjf3IZYLYGC+ccmoMJ6ybYlgfpgjwKIPhr/FEU2RQ5oh9MooDl2oEIimuCnDD7TJdZovL88Nf9l7H2iD37qtBownWHGY4jA3VoFR+mfDH5eWZF9IEsDfl+YMhzH+hwUzXSOKIxfhn2C3ol9Cr3UEKbDEaU5cZIr2FD8MVDbWznxX892x914+3XFhGxdd3fMJKpX1P+2eanLHn3sBwRgL3PKuB0PedVikwpy9hdZUqF1fH4uA4oJ2sA7BNppOanunuKQl15f9vIHTDXlpIksi2fMY5BKRM8y2ye90gHjO6cgPmPdvBo/eqq1D2lNmzY4PaxpKSkcg2GfKz9Y8CeOUB3Kd1cHnSoqKBUuujiDnqfqVJTTjkPyg3kF3Vxgc4BIWumlKtSxDYh9ZEYkohfLDMmAIBOBISsi4gNjsVZnfQB3r2hdKAoKSgV4qfB6M4JWLpX2VAyNtQPkUE6NIp2cQCWn/x0+T+gfi8IsS1QQcnKzuR3TEs6US3h76FT69Auuh3+PPOnbZloVkOQTaPaKLwRklKTsCtF2QTaekfI2mi4bmgxwQZdIDrWjUBf4wiYBQ126TvbHsqRlYhlFRicaro1KgGBHhzMFZlSwZ411Pc6QQBa3AUk/QCsnQy0HeO8jpvyPTmVoEK9sHqoF1YP57POl7h+aURY7z5bgxIyjrNVlTkoZQ285Vh6Fcnfp96ahbJU47EEpbIu2xs7h9mDUhlikMup1QGgXlQg7u9QG+EBOmjUKmVQyhI4t06rbQ2M1Aut57K3nJ8oIvSa/YI9SBuomFreXBQBtb9U8rjrdDaKLEHCBjWDkGPJIsjIK7Ld8W4cI50Qyqcmdpx9z8bxjuZd30izSUXKJjzQemFa9eLU7Qa8eFLaT9ZOcb2OB/uHlTXT9sR1+wxyjsGPa/nXcDbzrO37fFMBslQqhJrNtkwpeaN3x1BQkCxIlZZj/zqrwOg2O6RVqYJS0ni7WHualHcmtxJ0qCu7YAivC6Qq+5tEhIa6HkcpZjfrEtcFf1/+G21qtrEF1xxn5T2dcRq3NrkV5432Y7mfxg/QBSrKKf3MIoaa1mKcfjbUlmxpoy4YsCTUWo/x2YVG5BYaFWW41s+zulGBipL9IA+CUvJJWWyBSVlAXRAEjG81vsTteMST/o5uMipL4tg7sshcZAvSNgpvhOPXj9secyz1K46/5TxNr1FDp1GhyOhZqV37hHCcvJqDjDwDWsZL77VvRrfHlBWH8fHI1vYVjQVoVVCIvwP8Ea2PgKpWTaCv1EfGv6Tu7t4gz5Sy9Yo8B+yZK/XsuSQrd+z+suttFHNDMFwfjnNQ9vHSqrTQq/UeB6UCAwMxquhV6AUDTLFSyX9Ro8HALmnWy3STHwD7vjTv77OY9/dZvDKgCVQC0K+5c1C6/y0xztUDikbnxZzpVmTpt+L1BQCiVMIXVgdIPey8XilKn8taYRKqD7X9rYqQiQKTPVAaFxKOi7Is66ioaIT4nXCq1HA0om0tfL3lNOpZbjgpMtHUpQhKafTAuI1Sxr5jdps3KXpKWYNSLj5HIjyfWMm2abXO1ocwyjLz6DNtn8En+z4p8bnXi2pDI6bDaPnbGv2lYGy2rXyvbJ8h8eH+eGtYxWQx30hKfcuse/fuin+tW7fG4cOHMXHiRDz//PMVMUaqLAM/BJ75B2jmfFFpEj2rhy2RSq1oCJuOYDzZw+FDpe7twPPH3fdvcUPec0nr4kM2SCt9sLWIauH0WHREQ7zVawbubGBvqmltNB4nq9/vUk8KdhUXlOpcLxJ/Pns7WtQKxaAWsehY1/5B+v1jHbDiqa7QuJqOWB4si23tsrdGhVIEpfyAQR+7Tpe1Pu4B+ewjGkH5HOs07LtTdiuWW8v3rDPExFvTa92MuU5EAKLCQvGR4W5szrFnlMkDH0cvO5cWh/prPTtpCJTdGfJVUAoAer4hvUcu7HTRuFZw3/RbRp4lEViKDAVP6ACgXk8g2LmnjGNQyrF8r7j+IArW8j1rkFx+Qdv3Hen/zk95ti1vsJ4kpUgNYKHWKd4v6aL7TClBEDB9REu81F+6Ay0Pelgv4uQ9dACgflh91A11ng3KTxQhHFmOGVeu4uW062ioC1dkSpkNsiw6URrPu3e2QKPoYFtftet5BhxLkfa9xtHSyaY8U8rt3Vj5Z4QuSDpptQakRn4P1O4E9K6E8mPrvuwuy7MUd3XrhEhBqX/T/7Utk/99rF879stJ0UvvR+vse4ON0u+2nbzZbd93cK7pOASIskypLDMKDCaYzaJiSm9HTpkGxXH8PVTQXe1NL/bAZw+0wcAWsgvROh2d1tPrLb8/d+V7HpjSeQomtJqAz3t9bltW5NDQ/ny2c7Bdr9YD+mBEyvp6iQLwZO4sW0AKAO7tJl0UjOqUgGA/re2mhWMJX6ElUNK2jjI7Vd4o3J2WUS3x8q0v464a7fFS2nWgVvtS3ekvFXmmjbtsiDIGpdxl3GkEjVPgvDQlifLgfEnHhbpRgXigo7Svju6SiE0v9MTHI1thZHvpxkDvZtHY+vId6FBXeR4z9Vo67s3Kxg9DlgCPr5Nm+3KkDZRKw72tqeWGa1iCvVdk7lXg92eBL7sBVw5Jy+54E2jppsdqMVzNhGY9nrj7O8j/lgGaAATptUgSG2KHuZltxrzA1vZz4zOZrs+b3vvzX7y78l+8/ftRAEDtCH90b1QDwX4aPHG7i+CB/DNKXUH7gKcEQdns3M0EF6UKSjnk+FvPea1czc6nETQI0ATYglKH0w7bWlwEaAKgVWmRo7OfF4QG6Dwq+WpUMxh73+iD3/+vm2VwZcyUAqReaLUrOKPHMQMbcB2UKsNxTX7DzlrS+kjzRzC79+wSn/uXoatTf0gjIGt0bka+1nXVgp9WpbgRLs/g1Lq6JrwJlfm3sH79ejz00EOIjY3FzJkzMXDgQOzZs8ebY6PKplLb04kduJsms0xkHyJfjOuLl/q5mCUqONr1jErFeKjpQ2gc3hjPtH0GKhdvbeudvZjAGPw54k/FNODWjAT5XVeti6BUqJ/0QWntKWXVUJYa27J2KGqF+UMQBHz+YFssHtfJVvoSH15M2Zv8TlEFlVgUS35nQq0Hbn0MeOm0vV+PfFYks2dBSnnz+ahA5V0VazaCY8q/NU3Z2tsoPqS2+wtNXSAEQUCX+s4nW/LAxz8XM5weL7HJuZU8XTnEh0GpkFignqWH0Ym/lI/5h3k045w8cFuaWRLlwvXOB1ydSgv0exe4b6HL5+Q7lO9lWFL73x7WHB0SI/DDWOeLWJccs13kJ4iN+gIvngb6TvNsW95gDcictmQQRzVSBGyvI8jjxtTyv02Y5ecM1YciJtB+sd8grIGid56VtQyoV14+HsrKBvxCoRJU0Fiyx0SD/WROFDUI9tPg/g7SdqyBp4y8Ilv5XqNoF5lS7n6O1g/YvxYdshqaDQUeWy3NVFlZ3H1WlNQ3Q6ZJhBQotJYQa1Va298EsPeXkgetAOCKPgBGAIWWfbFO4yHYfvYC5qTISgMaD0CtZp2hk2VlHEvOx23vrcf9X+9w2W+tblQgOteLdJ5SvTiOmQceBK3LIiEyEINbximPa7U7Oa9oPbY6ZkqVIjgeGxSLJ1s/qfjsyjMqM2AzCjOcMrszCzMBXZBiKvM8F8fh7i0aYMtLPTF1qDS9eHSo9F66klmAQ5cybcF16/+xYaXPABQEAQ81ewhTBs5F59GrgfsWlHobHpNfsD3oZvbUcmTQvdj+RfSI72H7nAGkv5E8MKISVKWapEU+07Njjy5HEYE6vDW0OVY+3Q1DWsYiNECLEW3j3Wd1AsCQTxBjMuGNDq8pPludvHoBaDva43F7rF5P4PH1wBObpcxfx+PwQcvfKcb55qknigtKuctYk7eH8Nf4KzL+rJ85+tjmWKXqjs2mFlh/RVpWv4brfXftUSl7JDrYD1+Pbo+/X7kDdSJdvM/kn8muglLtHpH+71ZJCQ/yZueFzn2yAJQqeCYPSn3e63PM6TtHGXR18Zkcog+BIAi2oNTqs6sxfq2UOWn93LtYZyh+MPbC+KJnIQiC00Qyjoa2ioNKJSAiUGffNxRBqSoYEJH/bqyfUa7K98qQIV8ga39h/T2rVWqXCQuORLMeZodg46KQYFy3lARrzRoc6fYZLopReKJoomI9rVqlyLj1+GbsTaRU78SLFy9i2rRpqFevHu6//36Eh4fDYDDg559/xrRp09CmTZuKGif5mNfK9wDFLBshkbHugzTNLXdmPOwVE+4XjqVDl2Jsi7FQufiQtWZKAUB8cLwi48CakSDPsNLZglL2AIz1hMkxU6pZnP1nqhGkvBgQBAG73+iNfyb1VUxT7ER+MeWToJTsBMOaGScIQK9JwMN/SP9bFTn0XXDD2jAYAIIdega4my0xuygbZtFsm3I9Pjje/d0py5g71nM+WG06dhVHk7MgiiL2X8gAIN2psGoa6+FFmrz5ri8zpQB7Y+1s5WyIJZUmvdHxDXSt1RUjG9vvvDrOQiLnaiYZq+hA50wonVoPdP6PInOpUz37CbBj9kea5fvbGkThx/Gd0dLTDBDHZu6OF7SBkZWT6m8lv3MXEg/c+YViP74uBnvcmNpP44eVI1Zi9V2rbcFxQRAwoO4A2zoNwhpAq9biqz5fYUCifbm/4x1wy2es9Y6guUg2TrMWDWsG2T53rT2lUrIKbLOJtrCUvyh6Srm70Gt+pz37tYwXUl7lhR4wjSMaKy4e/NR+GNtiLJpFNsMrHV5x2gfig6TPuRS9v23mPQAI6PEaghr0UXaV0PpD4xesCEpBVCMttwg7z6Tbp6+XWTPxdiwa16l05SCKfi3BpQrKlVtca+dl1nIRx8/yUpTvueIqKHU557Ji2bnsc079eQpcXYj5haJ2RIBtn42xHOd/2nsRg2duxf1f78BzS/ZjwzEpc8FPq1ZMBlBqcW0qtk+h1l/qgffAj1Lm9cQjwGNrleuUMVMKAEY3H42ZvWYiQm//fIkPilcEDYO0QcUeaxzJMxKtzc7diQiUSp+bxYV4vm+0e1jKxO9YwuQYLprUe4UgSGV6/mHS1+FuehdFl62Ux9VNI2uGlE6tUwT9rOT9WP01/opgoK05uSBgSe03MNrwKpIuSseJNnWcX0suOsQPOo2qxL8jANfBnsH/A167rJyIqSLZMqVkQSnHSVRK8Rksf0/eHn87wvzCFL9/V8Fa6zJ5ADE1T7qpYT0vu7dTffwW/yLa9peCpiEOv19578EtL/XEp/e7uDb3dWZaSVz1GHNVudHORSuLEmQb7AFH+WeTfMZ5t8x+yFAr3wMfRNr3g88j30Fks57oWvgpVptvVQSecgqNin53Hu0XNxmPr3wHDhyIZs2a4ciRI5g5cyYuX76MmTMrILWVqiSTh5kxpeauPAyQTh7uWwg8urrUm1ULzicUjpkh8kad1rpieVqntXwvQtaHwjozTK0wf1t9fFiA1taDBQAig5w/7IP0mpIzc+Qlh74ISskv5uQZD/pgILGr8mBsUF4IuCO/A+d4MlRcUOpa/jUUmYugFtTS3Uw3zSWtJ9S1XWQQ7DqbjgGfbMG0P44i6XwGAKBnY/trjumc6NHPoJj5JdD1mCuNNVPKkZuZ96zubXIvZvee7bKfmtOmNP6Y13+e28etjSHlXF10zH6wHR7rKgV+r+a4bpZe0p1w58E5nARXwNT2pSL//Or2nBSUke1HrRqVLkOodnBtxQUCAAyqO8j2df0wqQSic1xnjLnFfjLmN2wWECS7uLVkSFg/88xF9sCqKGrQsKb988ra7L/AYIbRLKJGsB5xlgwRj8r3BAF49gDw4M9A/Ts8/lkrjBfeE1qVFi2j7LPA+mn8EOEXgSWDl+DBpg86zcTXNlqaOjxFq0OeJdihEVTQBkRKGSryklKtP6ALhF7ResL+eW+d0TVRllngsty7JPKgVAmfD16n0Ttn4FiPb07le+UMShmcg1Jns84qllkzpUrkkLlgDUr9kiTdIEk6n4Fllq8BQK9RoU6kd8ugva5Bb6BRP+nr0FpAzSbKx73Qa0z+mRUfHK+4uAvWBSvOq0oiz8ov6fjgOMuex1yUmPuMtYRPzj+izDP9FpcpBbi+4WQNqgPS8V/esL+WrJm/NYPW6pa44i/ia4aU4gaBqyCJIJQraFpqtkypPKBQythH6wfLvLkh9aVSzaYR9qBagGx/C9U5B6WsQcV20e1skzNZ3VZLamkSpNfgx/GdMc5SEhkiK9/74qG2eL6vvUzQbXZt7Y5SRmurB1w/7muubi7JM6Wa3ynNWJ7oPPFLWXkS2BZNepjdrCeKAo6JjRS/8wJZTzxRVF5GadWluMl0k/D4TOevv/7C2LFjMXXqVAwaNAhqdQXdRaAq5fEWjwMAXuv4mvc2Ks+6Kq6XgkoNNBmkLJ/y0PAGw52WBTmclMoP1NZMKXkaurV8L0w2m4K1BjxQr8HKp7vhv/e0wuJxnRQH7qigMt6pl39aVWa2h6vXLCkIWYZMKbNDaY9jUKphuNRQM7so29ZPKiYwRsoacXfX0vI3jQ11fyH6876LSM4sgEoAxnaTsu7qRQXi1kQPZwuNbm7/ujKzDVyp2UzRk82mFE2cS/LniD9twQ9XQvWhTk2fXfVGCA/U4d5bpRIxk5vmj4GlDUo5/pyVecLqivwkqcU9Tg9Pva9buV+icURjPN7icTxyyyOKIK+ijC+0tv3CE7AFpaZ0mYJXbn0FpgLZBY6okmbfsQhzCJa3ig+znZx5VL4HSEGPhr1987nlyEuzZVkDTYClUbaMPCgV4Rdhy7q9olbbmpz7q/3sJ7ny52sDAdEMP9lxRX5yeuG6FJSqFe6PLS/1xK7Xyzibk/z34MXPB489tRu45zv799bPDKfyvfIFRRxbC2QUZOBM5hnFskmdJ3kWlHL4fI8OLb48z0+rxlM9pf5J3RpW0NTo3qYNhOJGixc+Q++oYw9GxwcrM6WCdcFOzeiLI5/ttaSghscl+J66daz0f6P+3t1uceRBqVrtpRYaHceX+bPUVVBK3kvKVXaO/PPMX6vMlIoKtv8NHINSUcF6TOhR39aDEFAGsTyZpdqmovqqlYar8r1yNPMe1WwUPu35Kb7q85VtmfzmrDxAeE+je9AnoQ/GtZQys+KC4rDlvi147JbHbOvc3+R+l68jz8YJ8deiS/0o3N+hNqaPaOE+0KLWSKX1d5bcR8knFOO2nD/KM9P9IyolM7tPQh/F94kRkZiQL33uPJSZhc75st5jZj2OJecobiIVN1FDJ0uFh7yC42bn8RXBli1b8O2336J9+/Zo0qQJRo0ahXvvvbcix0ZVwP+1+T+MbDyy+Nr70vJmKaAbCSEJ2HLvFvx0/Cd8miRNqy4v3wOUB2pbTylZtpI1U6p5ob30SC0LjjSoGYQGll5SWfn2n6nMQSk5V3fPKlNJje09zJSSN9O+XngdDzZ9EAuOLsDQ+kNtv3OrJuFNcOL6CVzLv2bvJ2ULaskOUGo9YD1xtZxQF3fyau1f1Cg6GO0SwrHq2W6IDfX3PN0/rjVw3yLf/00A6UAdHA0UZiqXO2YQlYM1m+qBJg9g4b/OPaL81H4I1YfaUsoBQO8mEOBXTONfQSgm+8bt4MKU3/s6U6pWW6DXZClYaC1LLrLvG4KXggFPt33aaVmILgQdYzoiJS9F6o8nv7NuyfjoWqsrutbqiux+/+Lzs9ZBiYiVXWxr1SoE6NS22Xva1LGPOVyWiVDWmYQqnbueUqXUOa4zZv8jnbDnGpRBePnxsFlkM1v24BWVaOtVFCAP1MonhlBrgbg2uF0TiUTo0axuL4zp0xWDZ26BWQQuWGZzC9RpUDuiHAEb+e+hIqfudic0XvqX+gqw/XNpVl1Auc8KKq8FEa2uF163BaXGtxqPh5o+JF2IZ14s4ZnOYksKSmlU6N6oBlY81RV13fTXqXJUKimYnndN+t4LQak+CX3w8d6PAUiZHo5BKXfle6H6UCmLTUbeuL5n45r4db+yFNNPq0KBpUdhXDE3o8qk7ztStmfd27273eLI3/+PrCz3/uAqE0peFSAPWvWs3RMD6w20TS4DSMf/AJ0aGpUAo1lU9Et1DEqF+mvxUv8meL5vY9R/bSUAYMAtMfhmq7T/OfZeLVZVKCezBsiLcoAia1Cq7L34tCotetbp6bTMSn6j/Ok2Tyv6FgLS9cb9Te7Hxgsb0Suhl9vrMHmmVJi/DmqVNIlKtePl8z2N4BwCaVWjFf65+g8ebPoghtQbAn+NP9acW2N7/JtRXZGwZA56XTyE+gYDTuq0uLuWNC7R5G+b+dMdedX+KwOaoEawHoNbli0rsjryOCjVuXNndO7cGZ988gkWL16Mb7/9Fs899xzMZjPWrFmD2rVrIzi4AqeHJJ8QBMG7ASlAmkq0EoT5hSnKlRzL9+R3LKxZO/IDhs6SNRVjMmFxn28Q6KKXju35srtJrsr3PDZmBZBxAYhtVfZteIPZTXS/ZjNpqu8mg0u9yfSCdDzf7nn0qN0DbWq2gV6tR4AmwNYTpHNcZ6w4vQKnM0/bmtBbm6Er+gr6hwM5KdLXlhPqYnt1WdSxXOA1iSnDSUaTgaV/TkVx1eyxjOU5X/X5CuPWKHsmWLOgXunwCia0noCui5Xp0SpBhXB9OFLzUhGsDUaRuQhvdXnL5faLuwMUqNOUPtDh1Oi8Yqe5L5EgSGV7cjUaKx+vQF/3/Rpm0SwFy4Ody/esnri9sS0oVT8qEMNa11I8HhWkt01tL59RTD5TjOMMilWWq6BUw37Oy0rQukZr29eOkzFYZ1Hy1/hjUqdJuJwrXTifgdHW8DRYfhNEXjZrKUnxe/YAfhNUtn2gZXwY9l/IsAWlgsrbBFV+cVvZ5XtyPV8Fbn/RnoUk32e1AeXeR/zUfigw2RvXZhdl40TGCQBA3ZC69swQywVgpNGENA9myQOcZzvs2iAKW09es7+25bjTooQLkSonOMYelPLCZ2h8cDy61eqGPVf2oHNcZ1zIvmB/Ka0yUypIG2SbzCRMH1Z8UKqJc5Z8i1qhmDykOf44mIzhDp9j5ab1k7LzK1OIPZvcGwFaVyX68qoAeabUXQ3vQvfa3bHq7CrF8wVBwK7Xe8NoNiuymRvUDIIg2C+sw/ylc121SsBrA5vgWEoOnrqjgS0oVaoZxeTHTV+x9rfLS7MvK0emlCvycx75fhHgZj+MDozG8uHLi92mvNzS69mDvhRWB8g47+Z6w3X2fWm4ajT/2R2fYculLeid0Bv+Gn/FzVdA+vxSafzQyCBdx8bd/jpw6lsAQLCfDh8MkK7dbk0Mx+6z11EnIgA5hUaku5hVN9hPi2d7N3JafjMrdc5YQEAAHn30UWzduhUHDx7E888/j/feew81a9bE0KFDK2KMVN1UVH8qF+R36AIdmiLLDw7Wx+S9D3S12tu+bh7THomhiW5fJz7cH7Uj/FEvKhBRgeU4sah7O9Cm7DXsXuM4i5bV6N+A4bOBO94o9SbzjfnQqrXoFNvJFvgQZQeWdtHtAABnM8/iSPoRAJBNLe2m3EB2p0neT1olAP2bxyiud2JKuOt9w3AVlCpjRk7nuM54pcMrtu+1Kq0tG1AQBITqQ/Fd/+8wspG9QXqRuch2N3ZC6wnY/sB2tK7Z2uX2/YrJhArUl6EE3KmnlI+DUq5E1JVmV3rmQIW/lCAI9uzNYNndNoeglPyz7sme9Z2alj/Zoz661I/ElCHNFA3q5c8rLCYNvUqRB6WaDgUeXgncM6/UmxEEAR/3kLI/HMvBb4m6BXP7zcWqu1YhNigWzSObQ6vSIhUGbPeXXr+W/GaOq0xGlVrx+42wZKVZg4Ol7rfmSJEpFVa+bZWXvCxOnjXmhf33m37foF10OywatMi27MBVad9THLMtx4rPr1xFYpEBn165WuK2b6ml3I/evVNZLuLJzZAqKUh2g62cjeat/tfzf1h3zzrEBMY4l+/JM9Blpd+usnoebGo//wn11zr1jTKL0t/l5f5NqscFeNvRQJtRwL3emYVRXuJtJa8KkP/OrWXJ8ioCa1ArIlCHmsHKcyZ/nVrRi1OeoT7u9vr478hWCAvQoWV8KPQaFTrWdXGu4mjMCilo3aYCZjosLWsmTrblpqdK4/VMTvmMfPKWFqUpcXUkD/6F+VeDfcLqyb+Bp/a4njijZrNyb75xuHMgNMwvDEPqD7HtB469cAO1gYr3RHCtdravNdoC1I2Srk9m3t8Wozsn4NuH2+Pr0e1QI1iPT+5rXSU6HFRl5Trrady4MT744ANMnz4dK1aswLfffuutcVF1Nmwm8P2dUtlLBZN/0DtmSvWs3RMRfhG2YAjgMPte87uAYxukcrESZmLRqFVYM1FqQu3pbFtVmrvyvaAayingPXBv43ux5NgSjG7mfNIhPyjHBsYiUBuIXEMutl3aBsDeZ0rxSS6fAlYWoAoL0NnuRux8rTfCA7To+O4620xvpepvUJW5zJQqe/mevB+Uq95QbaPbom10W/x4/EcAUs+P5lHNsTNlJxqFNyr2ZKq48r1S95MCnDM+vHRB5XWyE5VKo8iUCnO7mig632G8v0Md3N+hCpSneoP8IiKkFpB4W5k31SehD/4c8adTqTEAtI+x37Tw0/ihVY1W2HNlD34Pkj6T4uQXh7fcBSR9DyR0cfta1qbyqdlSaXL5g1LynlJVKJNHHojywv7bqkYr28QMIboQZBVl2R5LDEm0r2gJjDUvKsKKS7LZSwWV25swapWAsACtrQTcMQii19ygvUDknxWe9NrygF6ttwWcimt0Lu/PJg+GdKvVDZM6T3LKzP9r4u3YevIanlm8HwBgdvH5dUPT+gHDPvPa5uKC4vBlny+x78o+fHngSwAO5Xuy2fmsfy9XQSl3Jg9phtsbRSGn0OT2nOrHJzojt9CISE9aWdS9vXLLJYtj/Wza8pH0vz7Y69nO8hsR8lnNy1MeL98lSt0SoSrTBztnqj2yCji1XpoIq4zm9J2DBUcXeNQr2XF/8Nf4K0tNQ+2ZjlmF9mNPTKgf3hpmn0Fz9+u9AQC/H0hGcqY9s5eUvNK1V61WY/jw4Rg+fLg3NkfVXf07gFcvOU3RXBGMov1D37GnVKg+FGvvWauoK1aU78W2Ah7+w+O7zDfsXVNXoryXUvrSrS+hX2I/RTmMlTwoJQgC6ofWx4Fr9gyThmHWoJTs5F9+8Jad4Ib6a21BqRqWcsqoIL0tKBVTrYNSYWXenLwflGNDZ1eKTEV4tu2zGNVsFKL8i2/uq1ULUAnS3W1AapadbykDK9NFd1Ur36tK5D2lXPReqOlfE6n5qegc17lUm32+TyP8uPcCxnYr3UyCPiN/DxcTBPKUfLKG4nSI7YA9V/Yg3VK+V0v+PK0f8OgqN8+URAQqAx5lCtrK+XL2veLI35te3n/D9GG2oFRMYIzbkhiFhn2B46vc9iJ7fWBTvLj0AIa3jnP6zLphj/nyTKkK+AyV3wDUq/WKCWTkmVLyTHaNSuOyVURkkB7DWteSBaW8Ptxqp0tcF+hUOntQyk2jc+sFd2mCUoIg4I4mxc9e6KdV35j7hmNrES+X7gHKTCn59Ul5yHeJG6b3Y1kldJb+lUOH2A7oENvBo3XVDgkJgiDYZ2YEFOW3ogclhe/e2QJRQXo82LGa3AT0shv0Ng/d8CohIAUo+xM4zhgGSEEodzXeerVemm405han51Vbj62R7kD0cd0jqCx0ah1ujblVkYVmZc1Ss/Y8kM/6FuUfJWv8KJ+Z0HWAKsRFD5Yasl5fLN9zTZ4d5WofcVRgLIAgCCUGpADpAC4/OW0um0I6UFfOTCkPMhhvKv6ymWlUzr/b30f8jvX3rC91j8D/69UQW166w6mUo8qS96jx4nTRJekQozzJjbP0xfNUuEOZUrA3e0r5unxPTh4E8XJzY3mj4LohHgZRh84E2j8qHftcuKd9bSyb0AVvD78FapWg6JN3w86apMiU8n5QSt4qQRAERfBJfoyRfy3As4tpV5me5MxdmaS80bmtfE/neVCqWouop/y+HE3O3ZFfbxi81F93cEtp9sTbGnhQLknllysr/dbobGWA1l6TxakRrMf0ES2cSsNJ4uP5zYkqlvxD35M7CPKTJ1dBlGqvdgfpXyV5+7a38fWBr/FAU6kksG10W/xy8hcAygCVIjtKcH0h0Cg6GP9cVDZNjZI1na825XuBLoJB5ciEkGdHeZIp5XjnqCT+WvvMbs3jQrDn3HXLdspwR0+jly5qDXm+n3mvqlGpgDveBK6dAOJvdXrYX+N/c1xwXD1m/1o+hXQFaxnVEn6CGgWW0ue4EM8yrKwiApQBmjIFbeVuhEwpL9/Vl1981wur535FuaCawOD/FbuKvPm/Tm2f/e2GzAYBHHpKef8GoUp2jBZFUXGzT36M6RDbwdZk29MMj2pXvldBmkU2Q8eYjogLilNkqskzpayBK3lGoSc3pqqtjk8A144DR3+Tvq+AfUORKeWlmcijQ/xwcEpfBJT3mEGeyVU2P595x0zMOzwPDzV9yEcDqj74DqZqLbCU0x0rZ9+rAlPUVnMxgTF4s/Obtu+H1h+K1LxULDm2BMPqD5OtKQ9KuT55fW1gU1zPK8I97WvblvnLDtLVOlMqqPh0+uLIT0Jd9ZSyerPTm/j20Ld4vt3zpdq+/MKtgWxK6TQXs5F4tsEwKSjlhanMq53bX/D1CHyv2/PAovuAHiX3i/AmrVqLNroobC+8AgCoFVi6mcEcM6W8OvteBVxclZki8O3doJS8p8fgeqWfIdYTOlkfKV1pZherSuSZUpVQAu2Ygb5i+AokpSZhWINheGu7lJXtaaaUu4mBSUmtUuObft84LQ/W2o/B1psUIboQPNL8EZhEkyKT6qYTVBMY8ok9KFXBpXD1wuph/YX1XtlWsN9NeBPdVwqUN79jg2LxasdXfTSY6oVBKarWhtUfhl3Ju9AlzrPeIk7le1SpVIIK41qOw7iW45QPeJApFR6owzdjlBkiZlkDinI3Dq4q5NkfnSZIzZzL0QNM0ei8mEypkY1HYmTjkW4fd0cvK3GJD7dnSaTnFpZ6WwCkrI/sy8yUItcaDwBePueT5t4d/GKwvfAKAsxmRUaCJyIcg1Le7CmlrUIBeaHkGwxl1SSiCfZf3Y8QXQhuifKg7D6yQcnrONCo7J9nN+ykJopMqYoJ7ieGJOJs1ln0SeyjyEDXqXVIDE20zYzYMaYjdqbs9PjYwkyp8pEf4+XnuM+1f84Xw6l65OdX2ZYJEYZ+Bvz2FNBverk33712d+xL3YdQfSgeb/E4TGYTeif0Lvd2qRI1GgAc/xOo293XI6l2qslVGpFrOrUOH3b/0OP15SnkOi/3u6ByUPSR8vzutCeNB2848kypJoPK3TdH3uhc7+XpjwGpfM8qPsweSMouKGPqurVvDJuckzs+KlfrHpSAzzP2o2VhYakbzoYHeDsoJduXb4ayTQBPtHoC4X7hngU4BnwINB1S6tfQam7QQJScPFOqgvryLRm8BKl5qUgMTUROkb0xsMrh+D2792yk5Kagdkhtx00otE8Ix55z13HvrcWvR8VLDE1E7eDaCNIG8cZrSbIsQam2o4Cmg8s1y7GVdYKYDjEdEKANYDDwRjTsc+DQz0CLu309kmqHQSkiNxiUqkLq3wFc/VfKfihFKcr47vXx6/7L1etENkDWU8rNVOal4a/2d/m1txhM9jHWCvfH9BEt8MbyQ/h4ZKuybdAacGBQiqqYhl2ex7KvfkZ4g0Glfm7tCH/oNCoUGaX9pdyz78mDDZH13a/nU94N8ET5R2FC6wmerdxxXMnruHDDluzJaf2B254F8tOBsNI15PdUgDbAlg0lP5dSC8ogmFatLTEgBQDzHu2Agxcz0aFu5fWJq460Ki1+Hf4rBAjVf6a2sgqOlbKkopvZl3khIAVIv/+h9Yd6ZVvkI4GRZT5+UPEYlCKSkc/swp5SVcgdbwChtYEmAwFjIfDD3cDtJfc2qlcjCP9M7gu9phpcSFjJyy2K8sq9uYrOlLqWY+8dFaDT4P4OdTC8dS3468p4h956clgBs0YRlUtABOo+c7RMZWl6jRota4XaJgIo9+x7APCf3UBRjtQrpSqq9ItiAShn9qy2OgSlAKDP1Ep7KXmjbcdMKU8F6TXoXJ+zi3mDvE0FuTDmd2Drx0BXZjERVSYGpYhk5OVepZ1ljCqQLhDoLLsDPvGgx0+9YWdIckcQgCaDgcv7gbrdyr05eQq/411sb0h30dC8zAEpgOV7VLWVI9Byiywo5ZUeeDXK3muuclRyUEqlBso545WuOt3gqCTyQFRZg1JElSaqATB8lq9HQVXEmGZj8N2R7zCx3URfD6XaY1CKSMbshXIoogp37w+A2QSoy/8R7i/rN+PpDEg+xfI9qqaaxtpnxgooT+D2RlHZmVLDvwCWjQV6TS7zJqpNppSPMChFRDeS59o/h7sa3YXEkERfD6Xa49GBSKZReFW/s0wE6WLOCwEp4AZM5W/UH6jRFGg+3NcjIfKq/s1jEeKnQYtaoTdJv5dK/hlb3gO8fBboVvaynGrRU8qHGJQiohuJSlChbmjdm+SY7FvMlCKSiQ+Ox+JBixFmLREiquYq+kD74d0t8eavh/DVqPbe2WBsS+A/O7yzLaIqJDRAix2v9YKqup/83v4SsPlDoN+7lf/a5WxY3KleJLafTvPSYG4+FVEiTkRENz4GpYgcNI9q7ushEFUb97SvjTvb1IKGGQZEJQrQ3QSnZXe8DnR7HtD6+XokpTa+Rz3461To2biKNo+v4pgpRURErtwEZz9EROSJisqaYkCKiBRuwIAUIM2SOO72+r4exg2LQSkiInLlhjk6XL9+HaNGjUJoaChCQ0MxatQoZGRkFPucZcuWoV+/foiKioIgCNi/f3+ljJWIiIiIiOwYlCIiIldumKPDAw88gP3792PVqlVYtWoV9u/fj1GjRhX7nNzcXNx222147733KmmURERERETkSK/W+3oIRERUBd0Q5XtHjx7FqlWrsGPHDnTs2BEA8PXXX6Nz5844duwYGjdu7PJ51qDV2bNnK2uoREQ3rPbRXmpGTkREZPFM22ew/ORyjG0x1tdDISKiKuiGCEpt374doaGhtoAUAHTq1AmhoaH4+++/3QalyqKwsBCFhYW277Oysry2bSKiqmjliJU4cPUABtQd4OuhEBFRNTO2xVgGpIiIyK0bonwvJSUFNWs6z3RSs2ZNpKSkePW1pk+fbutbFRoaitq1a3t1+0REVU3t4NoYVG8Q+30QEREREVGl8ukVyJQpUyAIQrH/9uzZA8D1rFCiKHp9tqhXX30VmZmZtn8XLlzw6vaJiIiIiIiIiMjH5XtPPfUU7rvvvmLXSUxMxIEDB3DlyhWnx65evYro6Givjkmv10OvZyNGIiIiIiIiIqKK5NOgVFRUFKKiokpcr3PnzsjMzMSuXbvQoUMHAMDOnTuRmZmJLl26VOgYRVEEwN5SRERERERERESesMZQrDEVd26IRudNmzZF//798fjjj+PLL78EAIwbNw6DBw9WNDlv0qQJpk+fjjvvvBMAkJ6ejvPnz+Py5csAgGPHjgEAYmJiEBMT49FrZ2dnAwB7SxERERERERERlUJ2djZCQ0PdPi6IJYWtqoj09HQ8/fTT+O233wAAQ4cOxWeffYawsDDbOoIgYO7cuXj44YcBAPPmzcMjjzzitK3JkydjypQpHr2u2WzG5cuXERwc7PX+VZUpKysLtWvXxoULFxASEuLr4RBVSdxPiIrHfYSoeNxHiIrHfYSoZNVlPxFFEdnZ2YiLi4NK5b6d+Q0TlKLyycrKQmhoKDIzM2/oNzZRReJ+QlQ87iNExeM+QlQ87iNEJbvZ9hPO/01ERERERERERJWOQSkiIiIiIiIiIqp0DErdJPR6PSZPngy9Xu/roRBVWdxPiIrHfYSoeNxHiIrHfYSoZDfbfsKeUkREREREREREVOmYKUVERERERERERJWOQSkiIiIiIiIiIqp0DEoREREREREREVGlY1CqGpk1axbq1q0LPz8/tGvXDlu2bCl2/U2bNqFdu3bw8/NDvXr18MUXX1TSSIl8ozT7yLJly9CnTx/UqFEDISEh6Ny5M1avXl2JoyXyjdIeS6y2bdsGjUaD1q1bV+wAiXystPtIYWEhXn/9dSQkJECv16N+/fr49ttvK2m0RJWvtPvIggUL0KpVKwQEBCA2NhaPPPII0tLSKmm0RJVr8+bNGDJkCOLi4iAIApYvX17ic6r7dTuDUtXEkiVL8Oyzz+L1119HUlISunXrhgEDBuD8+fMu1z9z5gwGDhyIbt26ISkpCa+99hqefvpp/Pzzz5U8cqLKUdp9ZPPmzejTpw9WrlyJvXv3omfPnhgyZAiSkpIqeeRElae0+4lVZmYmRo8ejV69elXSSIl8oyz7yMiRI7Fu3TrMmTMHx44dw6JFi9CkSZNKHDVR5SntPrJ161aMHj0ajz32GA4fPoyffvoJu3fvxtixYyt55ESVIzc3F61atcJnn33m0fo3w3U7Z9+rJjp27Ii2bdti9uzZtmVNmzbF8OHDMX36dKf1X375Zfz22284evSobdn48ePxzz//YPv27ZUyZqLKVNp9xJXmzZvj3nvvxaRJkypqmEQ+Vdb95L777kPDhg2hVquxfPly7N+/vxJGS1T5SruPrFq1Cvfddx9Onz6NiIiIyhwqkU+Udh/56KOPMHv2bJw6dcq2bObMmfjggw9w4cKFShkzka8IgoBffvkFw4cPd7vOzXDdzkypaqCoqAh79+5F3759Fcv79u2Lv//+2+Vztm/f7rR+v379sGfPHhgMhgobK5EvlGUfcWQ2m5Gdnc2LCqq2yrqfzJ07F6dOncLkyZMreohEPlWWfeS3335D+/bt8cEHH6BWrVpo1KgRXnjhBeTn51fGkIkqVVn2kS5duuDixYtYuXIlRFHElStXsHTpUgwaNKgyhkxU5d0M1+0aXw+Ayu/atWswmUyIjo5WLI+OjkZKSorL56SkpLhc32g04tq1a4iNja2w8RJVtrLsI47++9//Ijc3FyNHjqyIIRL5XFn2kxMnTuCVV17Bli1boNHwlIKqt7LsI6dPn8bWrVvh5+eHX375BdeuXcOECROQnp7OvlJU7ZRlH+nSpQsWLFiAe++9FwUFBTAajRg6dChmzpxZGUMmqvJuhut2ZkpVI4IgKL4XRdFpWUnru1pOVF2Udh+xWrRoEaZMmYIlS5agZs2aFTU8oirB0/3EZDLhgQcewNSpU9GoUaPKGh6Rz5XmWGI2myEIAhYsWIAOHTpg4MCB+PjjjzFv3jxmS1G1VZp95MiRI3j66acxadIk7N27F6tWrcKZM2cwfvz4yhgq0Q2hul+387ZmNRAVFQW1Wu10ByI1NdUpqmoVExPjcn2NRoPIyMgKGyuRL5RlH7FasmQJHnvsMfz000/o3bt3RQ6TyKdKu59kZ2djz549SEpKwlNPPQVAugAXRREajQZ//fUX7rjjjkoZO1FlKMuxJDY2FrVq1UJoaKhtWdOmTSGKIi5evIiGDRtW6JiJKlNZ9pHp06fjtttuw4svvggAaNmyJQIDA9GtWzdMmzatWmSBEJXHzXDdzkypakCn06Fdu3ZYs2aNYvmaNWvQpUsXl8/p3Lmz0/p//fUX2rdvD61WW2FjJfKFsuwjgJQh9fDDD2PhwoXsbUDVXmn3k5CQEBw8eBD79++3/Rs/fjwaN26M/fv3o2PHjpU1dKJKUZZjyW233YbLly8jJyfHtuz48eNQqVSIj4+v0PESVbay7CN5eXlQqZSXpGq1GoA9G4ToZnZTXLeLVC0sXrxY1Gq14pw5c8QjR46Izz77rBgYGCiePXtWFEVRfOWVV8RRo0bZ1j99+rQYEBAgTpw4UTxy5Ig4Z84cUavVikuXLvXVj0BUoUq7jyxcuFDUaDTi559/LiYnJ9v+ZWRk+OpHIKpwpd1PHE2ePFls1apVJY2WqPKVdh/Jzs4W4+Pjxbvvvls8fPiwuGnTJrFhw4bi2LFjffUjEFWo0u4jc+fOFTUajThr1izx1KlT4tatW8X27duLHTp08NWPQFShsrOzxaSkJDEpKUkEIH788cdiUlKSeO7cOVEUb87rdgalqpHPP/9cTEhIEHU6ndi2bVtx06ZNtsfGjBkjdu/eXbH+xo0bxTZt2og6nU5MTEwUZ8+eXckjJqpcpdlHunfvLgJw+jdmzJjKHzhRJSrtsUSOQSm6GZR2Hzl69KjYu3dv0d/fX4yPjxefe+45MS8vr5JHTVR5SruPfPrpp2KzZs1Ef39/MTY2VnzwwQfFixcvVvKoiSrHhg0bir3GuBmv2wVRZF4kERERERERERFVLvaUIiIiIiIiIiKiSsegFBERERERERERVToGpYiIiIiIiIiIqNIxKEVERERERERERJWOQSkiIiIiIiIiIqp0DEoREREREREREVGlY1CKiIiIiIiIiIgqHYNSRERERERERERU6RiUIiIiIqpEU6ZMQevWrX32+m+++SbGjRvn0bovvPACnn766QoeEREREd2sBFEURV8PgoiIiKg6EASh2MfHjBmDzz77DIWFhYiMjKykUdlduXIFDRs2xIEDB5CYmFji+qmpqahfvz4OHDiAunXrVvwAiYiI6KbCoBQRERGRl6SkpNi+XrJkCSZNmoRjx47Zlvn7+yM0NNQXQwMAvPvuu9i0aRNWr17t8XPuuusuNGjQAO+//34FjoyIiIhuRizfIyIiIvKSmJgY27/Q0FAIguC0zLF87+GHH8bw4cPx7rvvIjo6GmFhYZg6dSqMRiNefPFFREREID4+Ht9++63itS5duoR7770X4eHhiIyMxLBhw3D27Nlix7d48WIMHTpUsWzp0qVo0aIF/P39ERkZid69eyM3N9f2+NChQ7Fo0aJy/26IiIiIHDEoRURERORj69evx+XLl7F582Z8/PHHmDJlCgYPHozw8HDs3LkT48ePx/jx43HhwgUAQF5eHnr27ImgoCBs3rwZW7duRVBQEPr374+ioiKXr3H9+nUcOnQI7du3ty1LTk7G/fffj0cffRRHjx7Fxo0bMWLECMgT6Tt06IALFy7g3LlzFftLICIiopsOg1JEREREPhYREYFPP/0UjRs3xqOPPorGjRsjLy8Pr732Gho2bIhXX30VOp0O27ZtAyBlPKlUKnzzzTdo0aIFmjZtirlz5+L8+fPYuHGjy9c4d+4cRFFEXFycbVlycjKMRiNGjBiBxMREtGjRAhMmTEBQUJBtnVq1agFAiVlYRERERKWl8fUAiIiIiG52zZs3h0plv1cYHR2NW265xfa9Wq1GZGQkUlNTAQB79+7FyZMnERwcrNhOQUEBTp065fI18vPzAQB+fn62Za1atUKvXr3QokUL9OvXD3379sXdd9+N8PBw2zr+/v4ApOwsIiIiIm9iUIqIiIjIx7RareJ7QRBcLjObzQAAs9mMdu3aYcGCBU7bqlGjhsvXiIqKAiCV8VnXUavVWLNmDf7++2/89ddfmDlzJl5//XXs3LnTNtteenp6sdslIiIiKiuW7xERERHdYNq2bYsTJ06gZs2aaNCggeKfu9n96tevj5CQEBw5ckSxXBAE3HbbbZg6dSqSkpKg0+nwyy+/2B4/dOgQtFotmjdvXqE/ExEREd18GJQiIiIiusE8+OCDiIqKwrBhw7BlyxacOXMGmzZtwjPPPIOLFy+6fI5KpULv3r2xdetW27KdO3fi3XffxZ49e3D+/HksW7YMV69eRdOmTW3rbNmyBd26dbOV8RERERF5C4NSRERERDeYgIAAbN68GXXq1MGIESPQtGlTPProo8jPz0dISIjb540bNw6LFy+2lQGGhIRg8+bNGDhwIBo1aoQ33ngD//3vfzFgwADbcxYtWoTHH3+8wn8mIiIiuvkIonzOXyIiIiKqtkRRRKdOnfDss8/i/vvvL3H9P/74Ay+++CIOHDgAjYatSImIiMi7mClFREREdJMQBAFfffUVjEajR+vn5uZi7ty5DEgRERFRhWCmFBERERERERERVTpmShERERERERERUaVjUIqIiIiIiIiIiCodg1JERERERERERFTpGJQiIiIiIiIiIqJKx6AUERERERERERFVOgaliIiIiIiIiIio0jEoRURERERERERElY5BKSIiIiIiIiIiqnQMShERERERERERUaVjUIqIiIiIiIiIiCodg1JERERERERERFTpGJQiIiIiIiIiIqJKx6AUERERERERERFVOgaliIiIiIiIiIio0jEoRURERERERERElY5BKSIiompo3rx5EATB5b8XXnjBtl5iYqLb9X7//Xe3jzn+84azZ89i0KBBiIiIgCAIePbZZ92uW9y4e/ToUerXXrlyJaZMmVLmsXvDwoULMWPGjArZdmJiIh5++GGP1s3KysI777yD9u3bIyQkBHq9HomJiXj00Uexb9++ChnfzSQvLw9TpkzBxo0bfT0UIiIin9P4egBERERUcebOnYsmTZoolsXFxSm+v+222/DRRx85PbdZs2bYvn27Ytmdd96J+vXru1y/vCZOnIidO3fi22+/RUxMDGJjY4td3924Q0JCSv3aK1euxOeff+7TwNTChQtx6NChYoNxFe3UqVPo27cvUlNTMX78eEydOhVBQUE4e/YsfvzxR7Rr1w4ZGRkIDQ312RhvdHl5eZg6dSoAlCmASkREVJ0wKEVERFSN3XLLLWjfvn2x64SFhaFTp04uH3Ncrtfri12/PA4dOoQOHTpg+PDhHq1fUeMoiSiKKCgogL+/f6W/dkUymUy48847ce3aNWzfvh233HKL7bHu3btjzJgx+PPPP6HVan04SiIiIqpOWL5HREREFer8+fN46KGHULNmTej1ejRt2hT//e9/YTabAQAbN26EIAg4efIk/vzzT1sZ3tmzZ8v1ugUFBWjTpg0aNGiAzMxM2/KUlBTExMSgR48eMJlMePjhh/H5558DgKIM0Pr6giDgqaeewhdffIGmTZtCr9fju+++AwBMnToVHTt2REREBEJCQtC2bVvMmTMHoig6jWfhwoXo3LkzgoKCEBQUhNatW2POnDkApIyZP/74A+fOnXNZFllUVIRp06ahSZMm0Ov1qFGjBh555BFcvXpV8RoGgwEvvfQSYmJiEBAQgK5du2LXrl0e/b6WL1+OgwcP4tVXX1UEpOQGDBiAgIAA2/dbt25Fr169EBwcjICAAHTp0gV//PGH4jnWUtL169fj8ccfR2RkJEJCQjB69Gjk5uYiJSUFI0eORFhYGGJjY/HCCy/AYDDYnn/27FkIgoAPPvgA77zzDurUqQM/Pz+0b98e69atcxpjaca0YcMGPPnkk4iKikJkZCRGjBiBy5cvO21zyZIl6Ny5MwIDAxEUFIR+/fohKSlJsc7DDz+MoKAgnDx5EgMHDkRQUBBq166N559/HoWFhbafpUaNGgCk947172wtrbx69SrGjRuH2rVr2/7Ot912G9auXevuz0ZERHRDY6YUERFRNWYymWA0GhXLNBrl4V8URad1VCoVVKry37u6evUqunTpgqKiIrz99ttITEzE77//jhdeeAGnTp3CrFmz0LZtW2zfvt2pNLCk8j1X4wYAtVoNQRDg5+dnKzl79NFH8fPPP8NsNuPBBx+EKIpYtGgR1Go13nzzTeTm5mLp0qWKckX56y9fvhxbtmzBpEmTEBMTg5o1awKQggxPPPEE6tSpAwDYsWMH/u///g+XLl3CpEmTbM+fNGkS3n77bYwYMQLPP/88QkNDcejQIZw7dw4AMGvWLIwbNw6nTp3CL7/8ovh5zGYzhg0bhi1btuCll15Cly5dcO7cOUyePBk9evTAnj17bFlbjz/+OObPn48XXngBffr0waFDhzBixAhkZ2eX+Lf666+/AMDjTLVNmzahT58+aNmyJebMmQO9Xo9Zs2ZhyJAhWLRoEe69917F+mPHjsWIESOwePFiJCUl4bXXXoPRaMSxY8cwYsQIjBs3DmvXrsX777+PuLg4PPfcc4rnf/bZZ0hISMCMGTNgNpvxwQcfYMCAAdi0aRM6d+5c5jENGjQICxcuxIULF/Diiy/ioYcewvr1623rvPvuu3jjjTfwyCOP4I033kBRURE+/PBDdOvWDbt27UKzZs1s6xoMBgwdOhSPPfYYnn/+eWzevBlvv/02QkNDMWnSJMTGxmLVqlXo378/HnvsMYwdOxYAbIGqUaNGYd++fXjnnXfQqFEjZGRkYN++fUhLS/Pob0JERHTDEYmIiKjamTt3rgjA5T+DwWBbLyEhweU6r7/+usvtJiQkiIMGDfJ4HK+88ooIQNy5c6di+ZNPPikKgiAeO3asTNt2N24A4ttvv61Yd8mSJSIAccaMGeKkSZNElUol/vXXX4p1/vOf/4juTosAiKGhoWJ6enqxYzKZTKLBYBDfeustMTIyUjSbzaIoiuLp06dFtVotPvjgg8U+f9CgQWJCQoLT8kWLFokAxJ9//lmxfPfu3SIAcdasWaIoiuLRo0dFAOLEiRMV6y1YsEAEII4ZM6bY1+/fv78IQCwoKCh2PatOnTqJNWvWFLOzs23LjEajeMstt4jx8fG2n9/6Xvy///s/xfOHDx8uAhA//vhjxfLWrVuLbdu2tX1/5swZEYAYFxcn5ufn25ZnZWWJERERYu/evcs8pgkTJihe+4MPPhABiMnJyaIoiuL58+dFjUbjNPbs7GwxJiZGHDlypG3ZmDFjRADijz/+qFh34MCBYuPGjW3fX716VQQgTp482fFXKgYFBYnPPvus03IiIqLqiuV7RERE1dj8+fOxe/duxT/HTKmuXbs6rTNhwgSvvP769evRrFkzdOjQQbH84YcfhiiKioyU0nI17t27d+Oxxx5TrDdy5Eg8+eSTePHFFzFt2jS89tpr6NOnT6le64477kB4eLjT8vXr16N3794IDQ2FWq2GVqvFpEmTkJaWhtTUVADAmjVrYDKZ8J///KdMP+fvv/+OsLAwDBkyBEaj0favdevWiImJsc3itmHDBgDAgw8+qHj+yJEjnf7m5ZWbm4udO3fi7rvvRlBQkG25Wq3GqFGjcPHiRRw7dkzxnMGDByu+b9q0KQBg0KBBTsutGWRyI0aMgJ+fn+374OBgDBkyBJs3b4bJZCrTmIYOHar4vmXLlgBge/3Vq1fDaDRi9OjRit+9n58funfv7jSDniAIGDJkiNM2Xf08rnTo0AHz5s3DtGnTsGPHDkUZIxERUXXE8j0iIqJqrGnTpiU2Og8NDS1xnbJKS0tDYmKi03LrDIDlKUsqzbgfffRRzJ49GzqdDk8//XSpX8tVKeGuXbvQt29f9OjRA19//TXi4+Oh0+mwfPlyvPPOO8jPzwcAW9+n+Pj4Ur8uAFy5cgUZGRnQ6XQuH7927RoA++8yJiZG8bhGo0FkZGSJr2MtQTxz5ozTjI2Orl+/DlEUXf5e3P1tIyIiFN9bfx5XywsKCpy26/hzWZcVFRUhJycH2dnZpR6T4+9Fr9cDgO1vd+XKFQDArbfe6rRNAE4lrgEBAYrAmXWbrn4eV5YsWYJp06bhm2++wZtvvomgoCDceeed+OCDD1z+/ERERDc6BqWIiIiowkRGRiI5OdlpubWZdFRUVIWPITc3F6NGjUKjRo1w5coVjB07Fr/++muptiFvOm61ePFiaLVa/P7774pAxPLlyxXrWfsFXbx4EbVr1y71+K1NuFetWuXy8eDgYAD2AEtKSgpq1aple9xoNHoU/OvXrx+++uorLF++HK+88kqx64aHh0OlUlXq3zYlJcXlMp1Oh6CgIGg0Gq+Pybr+0qVLkZCQUIZRl05UVBRmzJiBGTNm4Pz58/jtt9/wyiuvIDU11e3fn4iI6EbG8j0iIiKqML169cKRI0ewb98+xfL58+dDEAT07Nmzwscwfvx4nD9/HsuWLcOcOXPw22+/4X//+59iHccMGU8IggCNRgO1Wm1blp+fj++//16xXt++faFWqzF79uxit6fX612+/uDBg5GWlgaTyYT27ds7/WvcuDEAaQY/AFiwYIHi+T/++KPLhvCOhg0bhhYtWmD69Ok4dOiQy3VWr16NvLw8BAYGomPHjli2bJlizGazGT/88APi4+PRqFGjEl+zNJYtW6bIOMrOzsaKFSvQrVs3qNXqChlTv379oNFocOrUKZe/+7JkGHr6XqtTpw6eeuop9OnTx2n/ISIiqi6YKUVEREQVZuLEiZg/fz4GDRqEt956CwkJCfjjjz8wa9YsPPnkk+UKXGRkZGDHjh1Oy/V6Pdq0aQMA+Oabb/DDDz9g7ty5aN68OZo3b46nnnoKL7/8Mm677TZbr6sWLVoAAN5//30MGDAAarUaLVu2dFsyB0i9kD7++GM88MADGDduHNLS0vDRRx/Zgg5WiYmJeO211/D2228jPz8f999/P0JDQ3HkyBFcu3YNU6dOtY1h2bJlmD17Ntq1aweVSoX27dvjvvvuw4IFCzBw4EA888wz6NChA7RaLS5evIgNGzZg2LBhuPPOO9G0aVM89NBDmDFjBrRaLXr37o1Dhw7ho48+QkhISIm/T7VajV9++QV9+/ZF586d8eSTT6Jnz54IDAzEuXPnsHTpUqxYsQLXr18HAEyfPh19+vRBz5498cILL0Cn02HWrFk4dOgQFi1a5DK7rDzUajX69OmD5557DmazGe+//z6ysrJsv7+KGFNiYiLeeustvP766zh9+jT69++P8PBwXLlyBbt27UJgYKDi9T0RHByMhIQE/Prrr+jVqxciIiIQFRWF8PBw9OzZEw888ACaNGmC4OBg7N69G6tWrcKIESNK9RpEREQ3DB83WiciIqIKYJ1dbPfu3cWuV9rZ9Eq7viiK4rlz58QHHnhAjIyMFLVardi4cWPxww8/FE0mU5m3Xdzse7Vq1RJFURQPHDgg+vv7O806V1BQILZr105MTEwUr1+/LoqiKBYWFopjx44Va9SoIQqCIAIQz5w5I4qiNPvef/7zH5fj+Pbbb8XGjRuLer1erFevnjh9+nRxzpw5iudbzZ8/X7z11ltFPz8/MSgoSGzTpo04d+5c2+Pp6eni3XffLYaFhdnGYGUwGMSPPvpIbNWqle35TZo0EZ944gnxxIkTtvUKCwvF559/XqxZs6bo5+cndurUSdy+fbuYkJBQ4ux7VhkZGeLbb78ttm3bVgwKChK1Wq1Yp04d8aGHHhK3bdumWHfLli3iHXfcIQYGBor+/v5ip06dxBUrVijWcfdenDx5sghAvHr1qmL5mDFjxMDAQNv31tn33n//fXHq1KlifHy8qNPpxDZt2oirV692Gn95xrRhwwYRgLhhwwbF8uXLl4s9e/YUQ0JCRL1eLyYkJIh33323uHbtWrfjdvw55dauXSu2adNG1Ov1tpkRCwoKxPHjx4stW7YUQ0JCRH9/f7Fx48bi5MmTxdzcXKftEhERVQeCKIpiZQfCiIiIiIg8cfbsWdStWxcffvghXnjhBV8Ph4iIiLyIPaWIiIiIiIiIiKjSMShFRERERERERESVjuV7RERERERERERU6ZgpRURERERERERElY5BKSIiIiIiIiIiqnQMShERERERERERUaXT+HoAVZ3ZbMbly5cRHBwMQRB8PRwiIiIiIiIioipNFEVkZ2cjLi4OKpX7fCgGpUpw+fJl1K5d29fDICIiIiIiIiK6oVy4cAHx8fFuH2dQqgTBwcEApF9kSEiIj0dDRERERERERFS1ZWVloXbt2raYijsMSpXAWrIXEhLCoBQRERERERERkYdKaoPERudERERERERERFTpGJSi6uv0RiDtlK9HQUREREREREQuMChF1dP1c8D8YcCPY3w9EiIiIiIiIiJygUEpqp5yUi3/X/HtOIiIiIiIiIjIJQalqHoyG5T/ExEREREREVGVwqAUVU8mSzDKZPTtOIiIiIiIiIjIJQalqHpiphQRERERERFRlcagFFVP1gwpE4NSRERERERERFURg1JUPVkzpEQTYDb7dixERERERERE5IRBKaqe5BlSLOEjIiIiIiIiqnIYlKLqySxrcM4SPiIiIiIiIqIqh0Epqp6YKUVERERERERUpTEoRdWTPBDFTCkiIiIiIiKiKodBKaqeTAxKEREREREREVVlN3RQavPmzRgyZAji4uIgCAKWL1+uePzhhx+GIAiKf506dfLNYKlyyXtKsXyPiIiIiIiIqMq5oYNSubm5aNWqFT777DO36/Tv3x/Jycm2fytXrqzEEZLPKDKljO7XIyIiIiIiIiKf0Ph6AOUxYMAADBgwoNh19Ho9YmJiKmlEVGWY2eiciIiIiIiIqCq7oTOlPLFx40bUrFkTjRo1wuOPP47U1FRfD4kqgzw7ylTku3EQERERERERkUs3dKZUSQYMGIB77rkHCQkJOHPmDN58803ccccd2Lt3L/R6vcvnFBYWorCw0PZ9VlZWZQ2XvMnM8j0iIiIiIiKiqqxaB6Xuvfde29e33HIL2rdvj4SEBPzxxx8YMWKEy+dMnz4dU6dOrawhUkWRZ0exfI+IiIiIiIioyqn25XtysbGxSEhIwIkTJ9yu8+qrryIzM9P278KFC5U4QvIaRfkeg1JEREREREREVY3PM6UKCgrg5+dXKa+VlpaGCxcuIDY21u06er3ebWkf3UDY6JyIiIiIiIioSvNJppTZbMbbb7+NWrVqISgoCKdPnwYAvPnmm5gzZ47H28nJycH+/fuxf/9+AMCZM2ewf/9+nD9/Hjk5OXjhhRewfft2nD17Fhs3bsSQIUMQFRWFO++8syJ+LKpK5NlRzJQiIiIiIiIiqnJ8EpSaNm0a5s2bhw8++AA6nc62vEWLFvjmm2883s6ePXvQpk0btGnTBgDw3HPPoU2bNpg0aRLUajUOHjyIYcOGoVGjRhgzZgwaNWqE7du3Izg42Os/E1UxZgaliIiIiIiIiKoyn5TvzZ8/H1999RV69eqF8ePH25a3bNkS//77r8fb6dGjB0RRdPv46tWryzVOuoHJe0qxfI+IiIiIiIioyvFJptSlS5fQoEEDp+VmsxkGAwMI5AWKTCmj+/WIiIiIiIiIyCd8EpRq3rw5tmzZ4rT8p59+spXiEZWLiY3OiYiIiIiIiKoyn5TvTZ48GaNGjcKlS5dgNpuxbNkyHDt2DPPnz8fvv//uiyFRdWOWZUeZinw3DiIiIiIiIiJyySeZUkOGDMGSJUuwcuVKCIKASZMm4ejRo1ixYgX69OnjiyFRFVBoNHlvY5x9j4iIiIiIiKhK80mmFAD069cP/fr189XLUzldzL6IeYfnYXSz0agTUqfc2zuanIXhn2/DE93r47k+jco/QHnJnpk9pYiIiIiIiIiqGp9kStGNb9mJZVhybAmWHl/qle0dvJiJQqMZe8+le2V7iubmzJQiIiIiIiIiqnIqLVMqPDwcgiB4tG56upcCE1RhLmVmAAAuWv4vr0KTGQBQZDR7ZXvK2ffYU4qIiIiIiIioqqm0oNSMGTNsX6elpWHatGno168fOnfuDADYvn07Vq9ejTfffLOyhkTlcDw1AwBw8mqGV7ZnDUZ5LShlYvkeERERERERUVVWaUGpMWPG2L6+66678NZbb+Gpp56yLXv66afx2WefYe3atZg4cWJlDYvKyGDJRCoyeycLyRqMKqyQTCmW7xERERERERFVNT7pKbV69Wr079/faXm/fv2wdu1aH4yISstgCUYZzd4J+NgypUzeypSSZUd5aYxERERERERE5D0+CUpFRkbil19+cVq+fPlyREZG+mBEVFrWYJRJ9FJQymSS/vda+Z4sg8vE8j0iIiIiIiKiqqbSyvfkpk6disceewwbN2609ZTasWMHVq1ahW+++cYXQ6JSsgajvJUpVWAwQh10BEViA69sj43OiYiIiIiIiKo2nwSlHn74YTRt2hSffvopli1bBlEU0axZM2zbtg0dO3b0xZColIyidzOlLhYkIaD2fBTktgFwZ/k3yPI9IiIiIiIioirNJ0EpAOjYsSMWLFjgq5encjKJRkAATPBOwCfbmAYAMKuyvLI9ZaYUy/eIiIiIiIiIqhqfBKXOnz9f7ON16tSppJFQWZlFgxSU8lZPKUsQSfRSkEsx4x4zpYiIiIiIiIiqHJ8EpRITEyEIgtvHTZam11R1WTOkzKJ3spAMpkIAgCgYYTaLUKncvz88YpaNy8SgFBEREREREVFV45OgVFJSkuJ7g8GApKQkfPzxx3jnnXd8MSQqJWswSoSXglJmSzNywYgikxl+KnX5Nmhio3MiIiIiIiKiqswnQalWrVo5LWvfvj3i4uLw4YcfYsSIET4YFZWG2Zop5a2glKUcULAGpbTlDErJS/bM7ClFREREREREVNWofD0AuUaNGmH37t2+HgZ5QITJ8r93Aj5GeaaU0Vy+jZnNgCjbBsv3iIiIiIiIiKocnwSlsrKyFP8yMzPx77//4s0330TDhg093s7mzZsxZMgQxMXFQRAELF++XPG4KIqYMmUK4uLi4O/vjx49euDw4cNe/mluTtaG5KLgnYCPUZSCUoJXglKG4r8nIiIiIiIiIp/zSVAqLCwM4eHhtn8RERFo1qwZtm/fjtmzZ3u8ndzcXLRq1QqfffaZy8c/+OADfPzxx/jss8+we/duxMTEoE+fPsjOzvbWj3LTEgVrhpR3MqVM1sCRylD+oJRjZhQzpYiIiIiIiIiqHJ/0lNqwYYPie5VKhRo1aqBBgwbQaDwf0oABAzBgwACXj4miiBkzZuD111+39aj67rvvEB0djYULF+KJJ54o+w9AsAajRMEEURSLnU3Ro62JlsCRYEKRycuZUgxKEREREREREVU5PglKCYKALl26OAWgjEYjNm/ejNtvv73cr3HmzBmkpKSgb9++tmV6vR7du3fH33//zaBUOYmCCQIAQRBhFI3QCtpybc/aOF0QzMgvKudseSaH7C2W7xERERERERFVOT4p3+vZsyfS09OdlmdmZqJnz55eeY2UlBQAQHR0tGJ5dHS07TFXCgsLnXpekZLRbIQgiLbvi4zlDCIBMIn2wFGuoaB8G3PKlOLse0RERERERERVjU+CUu7KvdLS0hAYGOjV13J8nZJKzaZPn47Q0FDbv9q1a3t1PNVBgaFQ8X1OeYNIAMywB7byHLZfao7lesyUIiIiIiIiIqpyKrV8z9rbSRAEPPzww9Dr9bbHTCYTDhw4gC5dunjltWJiYgBIGVOxsbG25ampqU7ZU3KvvvoqnnvuOdv3WVlZDEw5yHUIGuUWFQLljCWaZQ3T84rKmynlkBllKn8mFxERERERERF5V6UGpUJDQwFI2UrBwcHw9/e3PabT6dCpUyc8/vjjXnmtunXrIiYmBmvWrEGbNm0AAEVFRdi0aRPef/99t8/T6/WKYBk5y3EIGpU7iARAhAHW/LXyZ0o5BKFYvkdERERERERU5VRqUGru3LkAgMTERLzwwgvlLtXLycnByZMnbd+fOXMG+/fvR0REBOrUqYNnn30W7777Lho2bIiGDRvi3XffRUBAAB544IFyve7NLs+gDPo4Zk6VhQijLSiVb2T5HhEREREREVF155PZ9yZPnuyV7ezZs0fRGN1adjdmzBjMmzcPL730EvLz8zFhwgRcv34dHTt2xF9//YXg4GCvvP7NKs+hh1R5M5vMZhGiYM9myvd6o3MGpYiIiIiIiIiqmkoLSrVt2xbr1q1DeHg42rRpU2yz8X379nm0zR49ekAURbePC4KAKVOmYMqUKaUdLhUjr0gZhMovKl9QqshkhiDYA0flz5RyKNdz7DFFRERERERERD5XaUGpYcOG2Xo1DR8+vLJeliqAY2ZUeTOlCo1mQCXLlCpvUMqaKaXxB4z5bHROREREREREVAVVWlBKXrLnrfI98o18hyBUeYNIRUYzBFn5XoGxnEEka7me1hqUYvkeERERERERUVXjk55SVkVFRUhNTYXZbFYsr1Onjo9GRJ4oMHo5KGUyA7KgVKGpvJlSlm1pA4D8dEA0AaIIFFMySkRERERERESVyydBqePHj+Oxxx7D33//rVguiiIEQYDJZPLFsMhDeQ6ZTAXlLd8zmCCovBiUkmdKyZdpdOXbLhERERERERF5jU+CUo888gg0Gg1+//13xMbGFtv0nKoexyBUgbF85XGOPamKylu+Z+0ppQuwLzMVMShFREREREREVIX4JCi1f/9+7N27F02aNPHFy1M5OfZ8Km9mU67D7H2FZm9lSsmCUmb2lSIiIiIiIiKqSlS+eNFmzZrh2rVrvnhp8oICk2OmVPkym/IM+Yrvi8o7W561p5TGz77MZHS9LhERERERERH5hE+CUu+//z5eeuklbNy4EWlpacjKylL8o6qt0KFcr7CcQaTcogLF9+UOSlkzpdQ6QFBLXzNTioiIiIiIiKhK8Un5Xu/evQEAvXr1Uixno/MbQ6HDbHvlDUrlGZRBKYPZSz2l1FopMGXMtweqiIiIiIiIiKhK8ElQasOGDb54WfKSIoegUXkzm/INyueXOyhlLdVTaaTAFINSRERERERERFWOT4JS3bt398XLkpc4ZkaVNyiVZ6zATCmVRrmMiIiIiIiIiKoEnwSlDhw44HK5IAjw8/NDnTp1oNfrK3lU5CmDQ9ZReYNSBQ7lgEbRSz2lVFopMCVfRkRERERERERVgk+CUq1bt4YgCG4f12q1uPfee/Hll1/Cz8/P7XrkG45BqPJmNjkHpcoZQLI1OtdIgSmAmVJEREREREREVYxPZt/75Zdf0LBhQ3z11VfYv38/kpKS8NVXX6Fx48ZYuHAh5syZg/Xr1+ONN97wxfCoBAaHAI/j96XlGJQyeat8T5EpZSzfNomIiIiIiIjIq3ySKfXOO+/gk08+Qb9+/WzLWrZsifj4eLz55pvYtWsXAgMD8fzzz+Ojjz7yxRCpGNZG56KogiCYq3CmlDwoVc5AFxERERERERF5lU8ypQ4ePIiEhASn5QkJCTh48CAAqcQvOTm5sodGHjBaM5HMUt+v8mZKFZqUQSkzyhmUsmVKsXyPiIiIiIiIqKrySVCqSZMmeO+991BUZM9eMRgMeO+999CkSRMAwKVLlxAdHe2L4VEJrEEpQdQrvi8rx9n8TOXOlLKU6qm1Ul8p+TIiIiIiIiIiqhJ8Ur73+eefY+jQoYiPj0fLli0hCAIOHDgAk8mE33//HQBw+vRpTJgwwRfDoxJYM6NUoj/MyCh3uZ2tcbqoAgSzFzOltIBap1xGRERERERERFWCT4JSXbp0wdmzZ/HDDz/g+PHjEEURd999Nx544AEEBwcDAEaNGuWLoZEHrEEoNfxhRvkzm6zle2oEwIQciOUNStl6Suns5XvsKUVERERERERUpfgkKAUAQUFBGD9+fIW+xpQpUzB16lTFsujoaKSkpFTo61Z31iCUVvCHAeUPSlkzr7SCP0zIgRnlLLUzW8v3NCzfIyIiIiIiIqqifBaUAoAjR47g/Pnzit5SADB06FCvvUbz5s2xdu1a2/dqtdpr275ZmUQDIAA6VQDyUP6glLV8TycEokC8ClHwUqaUSstG50RERERERERVlE+CUqdPn8add96JgwcPQhAEiKIIABAEAQBgMpm89loajQYxMTFe2x4BJtEICICf2h8QUe7MJoNZKt/TqwMhbaq8mVLW8j2t9A+wB6qIiIiIiIiIqErwyex7zzzzDOrWrYsrV64gICAAhw8fxubNm9G+fXts3LjRq6914sQJxMXFoW7durjvvvtw+vRpr27/ZmS2ZEb5qQMt35czKGXZnr9le6JghNksln2DtkwpjT0oxUwpIiIiIiIioirFJ5lS27dvx/r161GjRg2oVCqoVCp07doV06dPx9NPP42kpCSvvE7Hjh0xf/58NGrUCFeuXMG0adPQpUsXHD58GJGRkS6fU1hYiMLCQtv3WVlZXhlLdWKyZDIFaAMAI8o9W57RLJXvBWqDgEJAEAwoMpnhpypjqaWtp5SsfI+ZUkRERERERERVik8ypUwmE4KCggAAUVFRuHz5MgAgISEBx44d89rrDBgwAHfddRdatGiB3r17448//gAAfPfdd26fM336dISGhtr+1a5d22vjqS6ss+MFaoMs35cvU8poyWKqVZgqLVCZUGQyl32D8p5SLN8jIiIiIiIiqpJ8EpS65ZZbcODAAQBSNtMHH3yAbdu24a233kK9evUq7HUDAwPRokULnDhxwu06r776KjIzM23/Lly4UGHjuVGZIfX8CtF5KSglSplSDVO3AQAEwYR8QzmCSPKeUmx0TkRERERERFQl+aR874033kBubi4AYNq0aRg8eDC6deuGyMhILF68uMJet7CwEEePHkW3bt3crqPX66HX6ytsDNWBNVMqWGfvAVUe1tn7gsz27Ki8okIAAWXcoGU8Kg2g1iiXEREREREREVGV4JOgVL9+/Wxf16tXD0eOHEF6ejrCw8NtM/B5wwsvvIAhQ4agTp06SE1NxbRp05CVlYUxY8Z47TVuRtbMqFC/YGlBeYNS1iCXLCiVW5QPILxsG1TMvqdTLiMiIiIiIiKiKqFSg1KPPvqoR+t9++23Xnm9ixcv4v7778e1a9dQo0YNdOrUCTt27EBCQoJXtn/TsgShwmVBKVEUyxxQtM7m5y+KUIkizIKA3KLCEp5VDJNUDgiVvNF5Udm3R0REREREREReV6lBqXnz5iEhIQFt2rSBKIoV/noVWQp4MxMFIwQAkQEhtmVGsxFaa1PxUrLO3qcXRehFEfmCgFxDQdkHaC3VU7N8j4iIiIiIiKiqqtSg1Pjx47F48WKcPn0ajz76KB566CFERERU5hConKSMKKnReWRAqG15vrHQK0EpnSgiH0BeeYJSllK9KzlmhIlq6GXLiIiIiIiIiKhqqNTZ92bNmoXk5GS8/PLLWLFiBWrXro2RI0di9erVlZI5ReVXYLCXwUUFBtu+zi0qexDJ2jhdZ8mUAoA8Q3nK96Tt/d+PB7Hsn1TFMiIiIiIiIiKqGio1KAVIs9vdf//9WLNmDY4cOYLmzZtjwoQJSEhIQE5OTmUPh0opR5bBFOEfCFGU3kLl6QElD0ppLbHJ/PIEpcxSqV6hWYXLWZayPQaliIiIiIiIiKqUSg9KyQmCAEEQIIoizLKZ16jqkmdEhfn5A6IaAJBjyC/7Ri2N0/WyTKn8cvWUkgJQRmhQYLa8xVm+R0RERERERFSlVHpQqrCwEIsWLUKfPn3QuHFjHDx4EJ999hnOnz+PoKCgyh4OlZI1I0oUVdBrtYAotSXLK89seYJz+V5+eWbLswSgcv2uIkvDTCkiIiIiIiKiqqhSG51PmDABixcvRp06dfDII49g8eLFiIyMrMwhUDnlWXtKWTKkBGtQqozldkaTGYJghAhr+Z4UlCooV08pIy5q1EiL/xnbCoOAZDBTioiIiIiIiKiKqdSg1BdffIE6deqgbt262LRpEzZt2uRyvWXLllXmsKgUrLPiWYNR1rdQWXtAFRpNEF2U7xUYyzf73gmdDhCALH0ujAA0JmPZt0dEREREREREXlepQanRo0dDEITKfEnyMntGlPTWEaCBiLJnSuUbigDLW0InitBZg1LlKN8TTQZc9tdLXwsirqrViC1POSAREREREREReV2lBqXmzZtXmS9HFcCaEWXNlFJBCxPKXm6XI2ucLs+UKjSVsXxPFCGYDUhRB9oWXdZoEMvyPSIiIiIiIqIqxaez79GNxxaUkmVKAUCBsWyZSPKglDaghi1TqrCsmU1mEwDgskZtW3RZowZYvkdERERERERUpTAoRaViDT6pLMEoNbQAyj5bnnXWPq0oQhXVyBaUKiprppQlIypZY08CTNZo2OiciIiIiIiIqIphUIpKJd8alBK0lv8tmVJlLN/LtTRO14siENXQVr5XVNZMKZMUfLosC0pd1mhsy4mIiIiIiIioamBQikrFWr7nmClV1vI962x+OlEEohpBJ8Wkyh6UMhtRKABp8vI9rRoiG50TERERERERVSkMSlGpWHs9WTOkrP+XtQeUIigV2dBWvmc25pRtgCYDUtTK/v3Jag3MzJQiIiLyqnNZ55BTVMbjNREROTGZTVh3fh0yCzN9PRSiSsOgFJVKoSUjSi3oAAAalZQpVdaglDXzSi+KQGgtaCBlOImm3LIN0FRka3Lup/YHACRr1DAabvxMKbNoRp4hz9fDqHAGswGf7vsU2y9vr/DX2ndlH/65+k+Fv051IooiREvw2Jsy8wwoNJq8vt2qymAy4EruFdv3oiiWfdbR8rh2Evh+BHBmS+W/dgXLKspCRkGGr4dRbe1O2Y2hy4fiybVPVshnAt2YKuoYQaUjiiI2HEvFtRwfHFeoXD7Z9wme3fAspu+aXrYNmAzAhneBs9u8OzCiCsSg1E0iOTMfX20+hewCKWPIaDbibOZZ24mD0WxUXCC5Yw0+qS0ZUhqhjEGpgkxg1atA+hEAlkypgCioVXoAngelsouyMX7teHy671MpaFNQYGty3jyyBSAChSoV0qpyo/Ot/wO+vxPISy92tbe2v4Xbl9yOfVf2VdLAfGPN2TX4+uDXeGnzSygwFpT8hDI6nHYYj6x+BA+vehgXsi64Xc9gNuDxvx7Hfb/fV3HjOboC+GU8UJBVMdsvLUMBsH8hkH9dsXhn8k60/b4t5hya49WXO3stF52mr8MT3+8tfkVRBDZ/CBz40auv70quIRfX8q9JM3oavP93f/PvN9H35774+/LfAICP9nyETgs72fbv3Sm78dLml5Cal+r111b46w3g1Dpg/TQAQH6RCbM2nsTFy5eBw8tL/FyqqopMRRi5YiSG/zqcmTwVQBRFfLLvE5hFM/Zf3Y9tlyvu4kcURczYOwOf7vu09MGOtFPAxRI+V4qRVZSFY+nHihscYDaXefvuNysiLacQZrOIQqMJH67+F12mr8O6oyWfpwFAbqER328/i8sZ+V4fW3GuF1xH76W9KzVQOf/wfEzdPhX5RulnNZlNyC7KrpTXBgAYi6T3WRXz+4FkPDJ3NyYu2W9bJooi/j55DVN+O4xtJ69V+pjWnV+HdefWVfrrllZafhrWnlsLs+j9fbskx9KPYf6R+QCADec3lK2dyf4FwKb3gR9HA0UubmYXZAGbPwJOb3T59NxCI8Z+txvT/zxa+td243JGPs6llTHhoBo7dCkT7aetxXd/n/X1UHyOQambxJhvd+Hdlf9i1aEUAMB7u97DkOVDcN8f92HOwTkYunwoei/tjUX/LnK9gZNrgVld4Jf5LwB7MMr6f1Fpe0pt+S+wYxZqHZgBwBqUioCgkrKbRLNnGUG/nfoN2y5tw9cHv8Yrm1/BmdR0W5PzemEJ8BODAQDJYr508uhIFIEdXwAHl5Zu/MXIyCtCcqb7E8Gk1CT8cuIX6YQtL126m3FqPbD9M7fPySnKwYpTK1BoKsS7O9+Fyey7jBJRFHE647TTwXrjsVQ8+cNe7DydhovZF2HMvAz8/DhwagNS81I9PrhbL24yCjOw8sxKj55z8GImzqc5v2cyCzMV2WUHLmbg+JVsmMwmvL39bZhFM4xmI2bun+l22wuPLsSO5B04nHYYu1J2eTQemzObgb8/k05a3TEZgBXPAv8sAvbNd7nKldwr+O3Ub0jOSS7d6zvKuCC939JPux+OWQT+eA5Y/iSwfILisVn7Z8EoGvH1ga+RVVRMAC3tlBR0PudZttvKQ8nIN5iw8dhVHL9SzMXE2S1S8OSX8cD1sx5t22N7vpUCNGmnkF2UjXtW3IM7frwDz87vhMOftZB+d2Ww+eJmTN85HbkG+8nY+azzWHl6JcyiGV/88wUu51zGgqMLYTQb8c3Bb2AymzD578n488yfmLF3BmAyIs+Qhy0Xt7jfj6yfJxaZBTl4b+t3SM25CiT/4/rC+coR4Pif0tcXdgLZV/Dl2kPwX/saor5uDfw0RnofWOQZ8iDmpknvi+OrXY8j/zqw4B5gy8euP3O95GL2RUzbMQ1fH/ja5ePbLm3DpZxLSCtIw9bLWz3a5rH0Y9hysRQZY9s/B74bCuRc9fw57hRkAb/+B/iwYdXOWks/AxjysfXSVkWW6VcHvvIoCPHX4RT8cyGjxPWKTEUwWMru917ZizmH5uDrg19jz5U9no+1MAeY0xf4phcKT21BgaF0x02j2Yixq8fi7hV3Y3fKbqfHRVEE1kwC3o1D9pk92HLiqvT5CQB7vwM+u9Xjz0BHP+w8j3bT1qLdtDXo/fEmfL7hFC5nFmDm+pMlPjczz4AHv9mJN389jJd/PuB6JbMJOPATzlzYjre2v4WdyTs9Gldafhoe+OMBvLfrPZd/7xWnViA1LxXbLm/D4bTDAIDU7ALsOpOOgxczkVNo9Oh1Dqcdxv+t+z88t/E5W7CpwFjgdNy5kHUBH+35CEuPL8UrPw7CsW97YdCyAej/c3+cyzrn0WuVldFsxPlTa4AvugIz2wJJC7y2bUNJLSc8CIQu23cRALD15DWkZhcgNbsAAz7Zgge+2Yl5f5/F00vXoP/P/XHPinvwzcFvcD7rPM5cy0Wuh3+j0jqXdQ4TN0zEsxufxY7kHS7Xycw3IK0KZHa9vu11TNw4EXMOevcGnCtGs9G2LxnMBry9422YROmzKs+YV/rzTsB+TZN3Ddj3HQAg6fx1HE29iLV7Z+HyV7cB698GFj0AZKc4PX3m+pNYezQVX246jaPJ5b9ZmpFXhEGfbkG/GZtxIb36V3yUxvztZ3EtpxAf/XXMed+7uLdCz6OqGgalbhJDW8UBAH7dfxnX8q/h5xM/AwCOpB3BjH0zcCFbuuD6757/4nSmwwWrsRBYMRFIPYyEy8sByIJSKqmMr8js/qLbmp0FAIWmQvx6bCmu7v8BACAapQtQjagC1Fqo1QHSctE5M8Fsdt4xfzv1m+3rP8/+iTf++RTJlvK9uKA4+KmjAQBXUYiskzuQVyTt8EWmIhy+dhhX/1kArHoZWPY4kHYKoihi1saT+HTdiTIdmNNzCzB51mOY/8UApK2cBiQrTwjT8tMw7q8nMOnvSVh5eh1w8CfAehdk51f2zBSHD6FNFzfZfsfHrh/D8pPL3Q/i9CYpGJR5CQBQYDBh3/nrJV8wXDspBUdSpcBjZr4BKw8mIzdpKfBpW+BfKUD0v33/w7Bfh+GpdU/BYDYgK68A079egLFzt+PPQymYuOIHDFg2AO/9MRo4+CO2/PoYev3UCxPWTijxREs0GmyZIwDww5YpEP98pdjn7DydhqGfb0Wvjzdi9sZTtouCa/nXMHDZQNyz4h7kGfKw99x1DP98G4Z/vg1f7f8Bh9MOI8ByYvfnmT9xJO2I07ZTcpIxa/8s2/ebL252HrMoYux3e3Dbe+txJUv2vr24B3/9/AD+t/sDFP46wf1J5Ik10okDgMOHFuGLf76QMnQsjqUfw31/3IfXt76Ovj/3xUMrH8LlnMsAgN1n0zFxcRLSjmwCtn3iMqtFFEV8c/AbdFvUFZsXDZPunn3TG7igvMgym0V8uPpfjJv8vnSXDQCOrQQuSZk7h9MOY1+q9HWeMQ8/HnORrWQ2SwHn2V2AHbOAH0cBhc5BpqvZhXhk7i58v/0sAGDTMftF/Y+7XQd/8gx5MB/+1fJDmSBu+Z/L9YplLARWvw78PFbKBLP+vs5uBX6fCPw9E+LMdnhv6XBcyL4AESLWCQUYFa7Hib9eBCCdNLoqozWYDU79H/KN+Xh1y2tY+O9CzN4/27Z84b8LIUJ6nyalJuGlzS/BJEqfN1subcX8I/Ntn8l/nF6B0+/XwpO/348J6yZgxp5Z+HHPBefPp+2fAR/UlS6GAdzz8zNYcOoj3Lt0MJK/6QlsfBeAFHT8++Q15BcZUbTlv7INiDAd/R2Rez7CI5rV8BMtFwbHVwHpp7Hq7Crctvg2fPD7aOn9seQh4NzfcLL3O+DEX8C6qcCycdLvvDiiCOyeA5zaUPx6ttVFzNwxHUOWD8GSY0vwadKnWHpoGw6eTwf+/UO6gQLpeGC16cImANJnoavAxB8HkvHR2n14ZPUjmLBuAj7ZvgyfrT+BnafTUGR0s98mH5CCmGc24cK6N7Hy9MoS72hvv7wdr215DSm5DhcByf8AX9wGJP0A5KYCq19zOgbIj6NlYix02maBsQAr9n6OK9fdB6kVzmwGZraF+MNd+CxJuokyuN5g6FQ6JKUmYU/KHmw/lYaUzAL8m/4v1p1fhz8PzMO2M3/hfNZ5/P3vOVxdNAGrv34d56/Zg7SiKOLXk7/aPl/T8tMw6JdBuHvF3cg7tR6Lt061rTv30Fz3P5/B4WbQvvmWz1YRF+Y/gdunr0ZKZvFZjz/vvYhnFifh1NUcLDsft+lCAABX2klEQVSxDEfTpUyBRRtfA/7bFLh2AgUGE55dnISu01bCuGsOYMzHjgVvY9ScXfi/RftQWJgvXfBdOw4svr/UWTQms4gvN0nPuZ5nwIX0fEQE6qASgP0XMhQXddkFBnyx+V+sO3oF13IKse7oFdz39Q7stwT+tpy45jI7QVz/Dr5bOxH3rBuHn47/hJc2v4R8Yz5EUcSuM+m4nuv6vfzlgS9x8NpBLDi6AAuOKoMwoihi+anltu+XHl+KLSeuout7GzDyy+0Y8tlWDPxkS7GBKVEU8e7Od3Hf7/dh48WNWHNuDV7Z/Ap2Ju9E36V90X9pfxy6dsi2/qJji2yfpesNVzFSdQWXcpORVZSlOHZbmUUzPtr9EUb/ORoXsy+6HYdb+Rk49Mt/seP9gXhmXmcM2vocfimwbGfdVKAoF0azEVfzrkIURVzJKoDZbLYF1gAp4/jBlQ8i6ciPwML7gBNrFS/x68lf0XFhR0zdPhUGswHISZVunmZaXufIb8B7tWFa9AA2/bsUWdfPAifX4dIV6cbg2iNXcD23CFtOXLP8ToHVh1LwxcbT+DclG4E6NQJ1auQF/YJLOZfwb/q/+GTfJxj0yyAMWnoXBnw9W1lKn5OKf2e2wLVFI23nMfKgMQDpWHr9HM6kZmHDv6nYcCwVV7OVn/0/HvvR9reavG2y4kYNTm9CRtIv6Pu/Tej50UYcv5qCSzmXXP8JikxYnnQJ3+84B4PJ9eezySy6fUwURaw7uwb/2/m+dMzOvgIsfhD4qBGQfACXci5h2yXp5ujXB7/G1byr+O7wd7hnxT04ePWgYltms4izss+yf1Oy8NLSf3DksjKQs/rsanRc0BF/nrEfl0RRxLpz63DrD7ei86LOGPzLYHRc0BH/XP0HAZoA9IjvAUDKlrLad/46pq44jOWHd2LEbyPw9e7/Sec0O2YD1y1B2MxL0jmN1bZPMP/vJDzwxyiM/HMAJh6ajccDDDABgCFXutGXcUF6L276AKev5mDO1tMIQAG0KMTL6z5UXHMcvHoQJ6+fBNJO4dqlM3jxp3/w1oojMLr5fQPA11tO43qeAQUGM2asPWH9BUjBcTcyCzNxNvOs0/J9V/Zh/uH59uNtQRZwaa90E6KUDB5U0ZjMJhy8ehBGcxmDtYYC4HISDIZ8/HH6D0Vg3WgyY80RKfs1u6AQ0zf9ZD8/OLMF+KaX9N68SfoiCyILv4uVlZWF0NBQZGZmIiQkxNfDKbN/Ll/A3d/PginjNjw5/DTm//s1mkc2R/vo9jh47SAyrjXE8ax90ASdwC26CHw/aAk0ITHILMzEgS3vosn2r1DDZMbXoSH4NCIMCerb8PtDX2D4opdxqmglbgkchkV3vQ0IguJ1f91/CROX7Ef3RjUw477WeGfXG/jz7J+oYzBg8eVUbPbX45WaUWhTIGL+E4fwzTd98Yk2GfUNNbB87HqkZBbg8w0nsftsOk6k5uCu2DRMz3kDGfF34J3AkViT/RI0ggbTuk7Da1tfg1k0I9poxBWNBu91ew+zd63AucJteC79OlQZt+P7yBGo2+Qv7L2yBwazASFmEd9fTkZdgxFbWgzG0VqPYfpy6eQhKjYJtzcJxNMdHkBiuBTcKjAW4P7fHkeuMQvv95iCNjXbAJAymdZfWI8Pt85ABqQL7M9TUtGtwABh7BqgVjsAwEsbpuLP85Y7GPmNsC7nImrm/AsIakA0AW1HSxkgaaeAh34GajbFvG1n8PXxSchS7Ud8UDwu5lxEhD4cvzcZh+DcdKD9I4BeygjD9XMQv+iGwqIs+MV3QOZ9v+Khb/fi2KVreOT2hnh1YHMAQJHRDK1awPHrx7H85HJsu7wNOZnnYTIVoZFRRGDkAGw8VR/tMy/hC+1saGCGGFEP64a+j4mbnrf9fe+Mux2P79uN2vnHsNncEk+KL8Mc+w00gaegEUX8eeEynq8ZhQN+UlnmAF00+tQbivnJF9CzTg882vQ2QB8CqFRAyiEc+34w7q4ZDL2ggWAyoEAl4KW068hqNRLtmo1Ep9hOMJgNWHh0IeqG1sVtcd0w9LOtOCw7AejWMApfj26P7498jU/3fw4AeKjpaKzefCtOX8uFyu8iQup+AxMK8Ma1dOzz02NlUCDa1GyD/3b/LwI1YViQtBUpuftx9Nx8HFQZEawJQbYxCzX9amBtj88g1Gxqe6+v+vcwnlk5C1AVol/MWHx6Xycg9xqOfHM7HgxVwSgIuDcrG280HgX0eQsQBBhNZqw9morvd5zFuOTJ6G7agSyVgCHxcUhXqxGiC8HYFmNRZCrCvMPzkGPIQbguFBlFWRAhoktcF8zo/jle+/BTPFz4PVqpTkMEsDK6Pr6Laoba4ZGoJYpopgrAgeyz+D5TumPdsqAQC5KlA6BZpYMQHA0BArZ3Ho+Jx/5E1vmuWG34BrVVV2HSBkNtyAYa9sWVW1/Em1tewXbNVZgNIVBpsxDlH4VVd62CTqWDYPldnPzjf2iwe4r0h1BpAbMB6P4y0PM1299HFEWM/2EvVh++Aj+tCmsmdkfPjzbCaBYBwYjI2L8wsm1NtIhtj261b0ewLhhnMs9g9J+jEZp3HTOSU9DAYIABGkyMnoupo/ohMkhf8odgXrolkLINIgABAPShKBoxB9o1b0C49i9MIbWx0XgNz0bXgCAKmKRJwIrcf7HPzw935ObhnqYf4bVL85FhOoO6AbfirkZDcEe9tjh07RA+2vMR0gvS8WFwS/RKPgk8sATfX9yCD/a8I/06oMFvdy5HhF8Eev/UG3nGPDQOb4xj1+2lQeaiMKh0GRAgQIQIvUqLQrMBkUaTbUZRQdQh++QLuC2xHuY+ciuu5qfg+JUktF/0BIKM2cjXReCPAV9j6oGJtu3GGo34Ni0PtZ4+gNHLVmBf/iyoNTkQIeLZ9Ot4LL43cPgXZIS3gC79OAKEQjxfNB7PxBxAnfS/sb/dA3gsYxeKzEXQiiL+unAJ4SYzVofXRJPbXkS9mHbIiWqIH0/8hIS/v0CP5OMAgBM6LQqCu+Hp/KfRINiAj4RPkFP3FkwTrqNtdFuMvWUc1Id/hrBsrPR+eXQVEN8eMBbBlLwfHyd9ivMwwi+0NrrHd8fgnBz8ufdzvKTOAACE6UKQUZSFmtkxmHP1PBIF6WTuYqN7MNiQBBOkk9YQtR/W1r4PD++pj6N5ZrRsswomZGNa12nYf0qP53/6B/ro5dBFWO7eG4KQfWYidGG7ERiQhcV3v4PG0VGY+eMw7Mk6jUm3vIDoffMQlLoP5zQajIqLxnW1GvV04XjTGIj2LUYDze/EmUwT9pxNx9DWcTCJhRi4bCDSCtJQL6QROvhNwpnUImTn5mJ21lOIKLgAhNWR3qdFOdjQ5hPccsf9CAvQ4uWfD+CXpEt4qV8TPNmjfsnvdUg3gD7c+Rl+PfETEkwm9M9MwUizP0ISugK3v4jCyHr4v2XDsT3vIqJNZsxv9AjiOj+DC5kGxIT6Qat2uGcpisDcATCc345pURFYFhwEf40/Vt21CrOSPseS4z8i2OwH7bUWyA7NhkH/r9OY4gw6zEg9h6ZFBvwcdD/ufG42VCoBPxz5Ae/vfh8CBMzuPRsrTq/AH6f/AAAMyMnFmsAAGAUBgihCFAT8PORnbD2ihcksYmy3uhDyrwNz+gD5GcDDfwA1mwDGIhT9ryV0uckwiQLUgogPDPfgnzaJiK2RgefbPY+YwBisPLMSJzNOoktcF9QPboEu721AgcEMf30hAht8hEKz9caZiDUXLiGkbn/cl/UU9p1PRy/NNszRSMHm42o/3KUbjezMzngu+jievm7vBXNdH4cD5nrILTIhsOuT6N5nGL7ffhaLd1/A64OaoktimHSz4J9FQPeXsSGwH8bO3YH2fpfx6tA2SM4qwO1Iwp5dW/FtRlt06nsvRnYMw3eH52PRoVUoEC4DV29H9rWBtte8K2A/poiz8GnRUGi6PYOX+zaUysRrNsXZi5fx94ZRmB4ZDgBQAzABeFZdG9nXe2HGpSaIjTChWcuVCNNHIvtKRwxp2h5t6pkxZPkQ28WZWlDjhTZTcfp8PPTqQMTVvIYPDtozK/1Ufrj3dBOkh/4DkzkKKzJeQF6RiFea7MWg4DOonXsdiGsjHR/U0o3Of67+g4dWPgQBAnrV6YXNFzc73fQM+//27jtKiipt4PCvqnP3TE/OzAwDAww5ipJBAUEQMWJYATGhorCYM0ZcFbOoGBBkBTOKCopKRiSnIcMAk3PonOp+fzQ2jGD61sVV7nPOnAPV1dW3q+utqvvWDXobr+f8g8xuYxn44SCcASejTE1431uIUBTa+oPkG/UoKHw04iNaxLUAIRCrX+TRg/N5Pxi+R2se05wZg2fwzo532FiyhpYhQY7Q48ruQVBVsZLMocMWthQlUO308X6nLaStewIl6OVtezTTjuy/aFQ+rdNQGoqY034In/nLqfRU0s16E8s2ZHBu1kyWWPdyd9PzOLfnXYyYP4JKTyUpmsLHhYexCoXd/f5JXKfJvLcpn7nFt+AJhROPvaKbM/bQNpLddeSYkynu+TDp392CEnAz5Ugcnu7x8npZBXv0rRjhvBuj2crVvXMilf+B6gammV6nXIthWag9Z7dLY1XNHh63HQKhMrnbJD7c8R2H3VtAEagCLo69g/tGXsmemgM8//X1LPeVER3SuMbYn4rs7nx8+GVaxbXi7bNeQbfy2fBDMS2AX+jZJHJ5P9ifpfqevDC6F71yE/EGvZz1wVk0+Buw6q24g26G5gzlru53YS/fw+53RxATCvKm53Le1nUjrvl0UIPMOWcObRLaENJC+DU/M1cWM2PJHsaH/k2m7jCvp2VjTNdIj06mS3IXLjdnoKvYxV27mvHpPo1HO1QyItfA3qwOLCtegT2o8f2eT1geCHeLz/ULni2to+mROKfF2bzcth+vbnk1crxFq2k4tHAr9VhDKne0n8HQNtnodSr3zd/GnDWHuXNIHuN6N2X8M/+mdf1KFhsG8NTVg3F4Nb7bXcg3jknU+WtJtibz+cgveW3ZId5cuRtr82m4tepGx3e0IZoHut+FrXwnN+6bA0E7toop2E0G7JUb6G/4gXezC3Dowwn2hyqrucDpQgPULqMhvjl88yBbaEGGWkuiVsVFMf3YHV8AAvQIgorCs3lXMXDhQ4ACUcngLGerychNKW3wuWP4rHo9b8ZamRdrQUXlwtRniLVpvLH/VnTA0+UVdHQb6e+dhhMrIzqm88wlHdlf6SLarCc9NtzzpWHbQp78YCnz/d1wYsWsBFg+sJi4LdMJqirvtX2LIp+NO4fmRa47B+sPMnrhaBr8Dbwx+A26pXYD4EDdAS5ecAl+zceg7EE82eFmfO+MZJe7lBqdDjW+BcXZU9npiKZrdjxt0+0cqnbT4A3QvWk8TRNtke1MXTuV9eXrGZk7kvEdxpNiSyEQ0tCrCtXeahItiQA8uPxuPi74nD6WdKbFdMXSbADk9KPQXc5nBz4j3diJz37QE3DWYtMauG5Id7rmJIUf5Od/AgeWQMDN403aMtfgIEq0ZGqP6fSzFVH/xQMsLlRZK1qyMLkcJXYLZp2Za/OuYOyyVzE6SqHzlXDez/ek+Sv4rbmUUyIpNX36dJ566ilKS0tp27Ytzz33HH369PlN7/07JKUCWoCxi8aytXIrCfXZhOxF1Ckhnup+H0Naj2JfhYNBzy6nvX4jlTnzcOpU8oSBQZ2vY1b+HBoC9ahCcJolDV1dMavNOoa59Twx5lsuWfACO70fkeI3MqOslMPpY+kx5hFMqoJn7xJef+8TEvwlzA0NoLpJLc6oDyLlaicSqQlWUGJQ6e818OL1G5k960KeIlyhiRWpuMoHUlPbDgArXj433kMzNVzxGGYfwOGE/fT3hXgxpisX6S3sdh5tKj976Gxe+P4z1td9yKgGBxk+A9MSolHUcMZZFaApkBII0drvY6nNCkLFdWAiJkst+vS3wxvS9GTSi1kX/YsHVv6LlRWfAKCg0DOmJeXOOgpC1YQIHtmuQFMUkgPwZfFhVmZ25NBpY2gW3Zxblt6CUI6G3PyiEpoGQXfOv1j53b3km4yMrW/AJCCU3JZFPd/lpvc3ENXiURQ1yL+6v8b09f/kkOZmkMvNtIoqlMSWMGoOxDdj09tn8XSwjB0mI09VVBEUA3B4C3HaD9LL7SVLF8ucxMk8vj+T5mmzKYs5vuJwLJ0QDHO6GFffwG6jkYdTM3BpPnrpYvk+WIemwCUNDu6qrsUAfJl2IXeaj7bAaefTsd0UwiDCz8eCP0laXlXXwNmJXXGfeRftljzDe2UrmZYQRx+3h/RgkPfs0ZF19YqOl1MH8UWohs8qws2ZB6dcz0dLc4g265k8qCVPfbUbtz/EyDwzO5XbKIn8JgqOgluIsRgIJE1H0bvp5vXxRmk5JXodI5tk4FdAxUAoaEXRH23xoheCm4tjeS7diVBDfFRUyv6YdBanZlNusbO1ahscefpncaUyL607yQWfcUV0gANGQ2Q7j1ZWkxeXx3fNBvLmgQ24gw0YSoaxjocxKiEeTM7iY1s4WfLTk3JewMQbJfupOmM8F5d/RUALcIcvk0tLVrHTZKRENbIwxs53Fj0/58fj8oOOt+H47t8cEtsZ4PJgEYIRTZpQrlewhHQsLDqEOxTPXdE3MtP5GEZClKs6hmSlE1QU/AevQ5/xHqqhniRLEjXeGs5vfjGpnnM5f8W5NBhdzBRncUG/3rT77j5QLMzKG8sa/yp6pvcgNWESE+ZuOhJDGuNT9/JVeTRafC4W8wyK7EefgqcHQ7xZWs2tGTnsUMNPI62a4A5HFBfW7OT9YD9mxE7ksjOa8dmOdQSCZtokZTMkM8RZBU/iNUaR3+NaShvKCCx8gP26Or602dCElanVPnp6Dkc+y22I42Lbg5TZX8CvC3J5rZdba2soMsL5GeloCnRww1brz+7iyPEyraKK/k2H0MNTipsSdCEDIV2A0wIK9tQefFu9mkR9GhNN/XnA9R4CjZA7C191f6yZ4S6cBtXAM7Vubo45egzZhYUGxUOgrgshTzbJGRtp0MJPR0/3eHmhvBKLEAxKa0+5uZ5EZypRxkIOGg208fm40ngBdwZXohqOHt8qcGvWnYxedlNk2U61BcPVS8hIXUiKVkKxwYBDVSLH5vAaAzolxKdxGnohuKzBwSJbHJX68FPPtGAIp9GGQ/PSwu/HX3AdI9QN9LN8zfjUZKqOJNislVfzufcVkoJlHNLreTc+haChC7eULOOrKI1HEuMb7dvJNbXMttup0uu4vraeMw2pjIryoAjB50WlxAVNROFmkc3CHcmJKP4YdKqHoN7PW6XlWINwfWoG9YbwecGoWnAWjyDoi8Oa/RoogvhQiBqdDoum4lHDT34T/L15tNtp3LA13DpvuNPF1MpqygxWrspIoUhp/LT3mrp6rvUYudRzN1t9qQxsnUzH9muZse1oRSfQ0AFv8WVM0M3nNsMHVIhYvhnwGZcGPqFizQu8GJ3BZ+ZmGExOHJXdCNT0Qh+1k/7tCummdSR/X5ACY2sS4+D8blaaKgdpV1eBrmIHBb4aJnn3coDGlfkWfj8zSyvAGMcFcS2pMB9tiZAVCPCoP5NRh2+iX146MwaEUAwWSG4NehMF6xaR+OWl3JySxAaLGVUI7ul6J61ihlPzxY08btxMuf7o+UdFpZ3fjykUpFancthgwK8o6IXgXKeLPJ8fXWwf0roOYuLWlwgeaSmow0wIbyQB9aN2RJPmKmexzUobLYX1heei+RN5bHgvLj/8AOz4lBCwIakp7rMfpUN1BfaFk1liSmCFfShTKufwlj2W5xPC93ExioGWPi/rjLrIZ6RgZWhBFlowjrcSBPr4NWjeZFpRzl6zwsSaOq6pb2C4dhuHmqxCNRZzX3U1vTxeLktPpUanQ/hTeaK0juHaHlwdxuDY9iWpohIBHDDo2W8wsM6ax3fOVhQGczgjaGRG2kLMpeFr2jajkUeSWmD3NxCPm91GIwUGPSYhiNM0znR5EKGWfJ3mpcp3dMw/RQgmllgp1IaQld2cVmX38ordSkdvkEXOh/iqRzH65eFE2X7VxhWZcbhUlQm19cSHgjycmEBSMMj8wgou8z3EvpTNGOOOdunTPM3olpXAxsp1nKHaideZ+TJwdLw7vTMbj2bHYN9GsKEDNnMBPqMjEk8AZ1nasq8wRFHCTkKKQkevjxFOF2fYO5F19v2w7QPuce1kgaeQpqZ+3NHxLmrFau5d9wgAQ5sOJb90B4d9h4gPhcjTJ7Fa1NA0OpNPd21hhS7Iwah4Lq8s4c6cNizGSfuQghrdnGJPCWZ/PUUGA4qAUMiKqnejFxBsfFvSiCIEvUtboTpa85LxRYLAO5ZMnk1REYrAKCz4FQ+ZJFEfKqNBd/R4Uvx2niwOMiXbiUtV0QlBt6gcfnAdjKxzpstDhV5lu8lEgt9KeSAFva2AtJCJWtWL95gYuKLewV014d/8YXtzPkg42nrimYoaBrmcfBDsy2daT4aqP1CDnTZN4ulX+jY6JXwP9r3FTJFez7v2KPYbjbSqS6N11jQ++GEvb5gf5v1kB0tsVtICQZorrVipOwjKz7dmeaAuxMW14fNIUNGjF0E04MPoKLYbrOwWOaTZW2JyHOLLmIOkaQoPBWxcZzrSqkWoWEUIt6qgCsFVdQ4+s8VRaQx/ZgtbBk8Pms6kJZModVTi2H8Zz4c+RRedz2MJ8ZFryY/uqK7lygYHIaFQSzSJSgP1qsrQzGwc6tHvoRcCq6bRoNORHQjQ1mOgXaCOkQ4H57fqSLmvBn9NL4zxR8fKU0MGNF0Af103+ieOpV8bEw9+vQDVVI5RM3K+tZA2zk24dLDQGs1ukwFfdV9AwZS4NLKdNoFhdCqooyZhM4sSXJiI5/6sa7Dsf5dm7S+gWdcxqB+Mwb/7S3pnZ+JRFex1LTHZ9tA86EGg8IPFjFnT8KoqegF5GNmJj7Y+P/+sc9DN4+aewNUYCHKncTYDMzNw6FSeKK9lv0nl9dgYOid3ZrZThfxPEMC/7bFMi4+O3KdnBQIcNhy9/0hxxqPpvVSa3ZF9eFV9A5t0HVjt6Imvvj1NTD4mazNRVD15179AqnsvsXMuQkHgwUylsQkpvkPsMyncmpxIrU6le20cCyon89A57RiTUkDZ1nlc6dpK2ZHrV7OY5nw44gMQMHL+pRx27omUqVVAcEgn8KpHH6LEBHSUVw8lUNedKNy0S3udCms1yT4TccJOINrLBhwc2+7JpDPRQtzC2p2JNMv7kjKxjPvPuJ+uKV05f/5IxJEw7Oj1cUttHQ5TFPcnxOIQ4Rhs4QvQ2+Ohnc/HALcH/ZFHiz+qUlXOyUzHc6ScueUdeM+zGOORFukvx8bwalxMo2M5OxDgbr+VXtesAKONvzKZlDrivffe48orr2T69On06tWL1157jTfeeIMdO3aQlZX1q+//OySlAN7f9R6P/fAY2pEgSQ4GWVRUjqHjpTxf2xP3vpVMMnzMGqvK3UkJuI4J8LhQiFpd4xP/P+obuFNNZmXQxl32Sup1KvGhENfX1lMfHMyZMYeprt/O92YzG80mHKqOAoMRFI0LHU4+jbJFTnzpgSDTkwfQfMR0yhfdy5SC91htMaMp4YtUc/flXNfnKs7Ydh/2PR+y1GylQa/wfFwcVXqVZ8srGej2MMfahX+lHO32tPiixby0ZgGfFr2AWRN41fDndfN4ub+6htiQxuj0FA4dc9IFaOEFlz5EiV7X6IYqxx+i4MgNrNmZiTeqcTejFL/KJc4ahrs8XJCVh0vU09Qf5KCxcaKgj9uDUQi+tVkZ1eCgW2UL5rUdyUbPqwgFetQbeaK6jHjFyUztHGZbEqhKX4bJZ+fFoiBWywHGpqUQVBQmNAS4vrqUQoOBZ+Lj+MZqjnxOdEjjlfIKbktOpOxIZaGNz0c/l5+v9DkcsFehCMEZLkFGQxqXiM1s0ppTbPZRZWlgs8lEieH4JEd7n8askiI+i7IxJSkBgIxgPLNLtvFxtI2X42KPO2YubHDSPSC4Nz6a+FCQ1r4Ay2yWRtvNDASI0gQ7TUZur6ojzpXKPRkQh4eUUIBdJiM6IQj9JLEV8qYRawsyMKkF15V5qN2/jWJrDben2YkOaXTx+VhmtaAIIheWLK+O98oOsi+UQyuliF1muC6uA15L+CbbrEFPj5tcv8YAl4d2AQ83pCSz0mrmdI+XHyzmRmVo6dZTbPbjUlVy/X50AnabjKhBK35nR/SxJx5XxCIMvFhWxB5SeDIVUOA1l569zXryTeUODtTGcJq/jqmuzViOnKqnxOXwUWyI2FD4BqvumP2sE4LR9Q4SQiHy9THstBip0mtMdvj4QefnqygbfVKHsrRgGzpLEXp/FH19tXwXfTQG+rvcbFNbUG0pJs1r5N66Ip6Jj+OA0UAnr4/xtiu5trgBXeqixvugNp0cw16+ijp68TQKyPH72W0yRpbFO5tzuOx82qQILq2exSixESH0vJsxlGeNmxGKwjlOFxvMJsr1emJCIep1OiyaoLXfx0azGUWovF5WyuleHx+b0pgWm0qDtRoRMtKscBDTeJcXkgystFqOS4T+SISMjKmwcrs33MX2ptBYlmZvRDXU0TYAs4sOYwQ2a80YndAaEXu02f4N3mScvn2sNZs5YDSgE4JxajwFzhIWRlnRCUEPj5eVVgtmDWaWlnFlekqjstxa6Wass4oHE+KZHx1Fk5rLOKPlCOaV3oBqrOMCzcpDh3ZxY2YOK/QhLmlw0M8huCnjJ9choWAUGn5VIcuvp1mgIZxg1wx86Iwipm4752ek49QpJAU1KvUqsUEjH5QU8Ex8AgujzGj+eG6vqUQ1NOBVFDZm9WKVM7/Rx+T4VcbUVzElKT58c64GQWl8+5AYFAQUjfqfXC+G+IycWV/OIwkxOHQqFk3Do6pEBYy8XnGYmXGJfGPRox3ZPVMqq3k2Po56ncolDQ5CKHxkj4pszxqK5dPCw6SKOm5MSWKF1UJbZxJbCsfTUbcPW5PZrLUaGO0MUS38fBFtoZ0nxAGTgltVSfSr1ATT0ayNu+8MdLm5qN7N+PTwE1KrpuE+ci2MCSnU645+34crq3k6pgkNRg9NAgGml1cyy26PlLObx8u4MhtjvQ+Trj+IK/ctAkoIf3VvDPGrURSNZqY8Xty/gqyAh1v8N7FI6cPQduVs8jxF7U9aKkVpKs4jSbKUYJDZpeU8HpXL0lgvypHf4XRPuPXndWnJlOr1JARDTK6pI9/Ugnk2L5reTXZAwa0EqNTrMWsat3gT+XdMkOJAuLVppldPUlAQqzio0umo0elo47NzYaWP11NdrLeYsYYET1dWYnVlsV9L4xL9MlyovGLPZYvNQWbAzw119WQGg3iTOhD0e/E79vFIYjzf2E6c1W0ffTrbqorAFK7g/qO+gT1KImvt4YqJoXo0L7Uo4/qarxu9zxzS0ybgxKbBLqOJSn34IDJrGiYhIsdiNkYOCx9CUUjS9FSq4SqJSdPo6/Hyg9lEg05HP7eHcXUNjE1LQShwrbszWa5vuD8pgbigjssc1cyyx+I65hC3B3U06I9WeO2hEBc2uPjYORnFZWNY7ArWpReyRzt+7LGMQJBJtXUMDqjU5J7JxY4Nx1W0f04zf4DxdfWstliYH20jORjkgaoaNptNvBljjyT1TJpCdtCPIgQdfD6KDHq+t1jAncGNJYlco1vAOZnplOn13F5dS3cljovjVFA0gs5W6Gx7UZSjXXPmFpfRPBDgqfhYVlksx90nxBSO4ArrXKYnhK8FUehwiyDaMee/Y6/HBiE4z+FkfF0DQzPTCSgK1xcmMy6wDavi4ztrDMUxLflWu4NhZU/wbpNi9hmPXlNuVJtzw/4lNEQ1Y0Pbuxnww7XsN+g5PyOtUWLzRw9VVuP2ZvNCRgMeVSU9EOTq+gaK4ppQ4qkkWhMcFsl4TLVsM5uICYWYX1zKVzYrz8ck4TnyW4ccHfBW9sea81Jk/7T2+Rnr9PNIrB2nTqOF389eo7HR9wUYU+NldpzphOXTC8GHxaV4FJUX4+PZbYilWucGBZ6sqOKAaufVBCMokKSkUylKMPqjWFC6h0NGHfGaRnwoxBx7NB9ER9PX4yGvrB3vJgpKYw9GPic6pPFlUQm7gy0BOF3dRYM1ngsSoinXHz3X9XZ7uLjWwLxoK9/b/eiEoKvXx1qLmYxAkKdLfDzb/DRWV0UTV9eUNi1W8EOg5ITH7I+J3UU2K2/HRJNvCrdytmgCj3p0X6QGg/gVhRqdDr2iI3hkjCVbSHCW28Vn0eHzbLY/yNX19ewxGpgTY8eqaTxdqmdVVD07TQZurvaxIFrHx/Yo0gNB8vx+3MKKs3Iwu7SmGHLm4FGPdoe1h0I06HSIkIVLK4egWefwYbSVCbX1dPH5GJeafMLf7LeIpSN1bCE1GOTxymompCThVlXOLMvicfc6bEo4QVFmbUGqO9zKbXJyIotPcM5UBTxb4uL99ExWKccP22AQgoAwEKd14dz675mdoCMjqPFFYRFr1Gwm5OgIakHePONJ4uf/k/ujzWy3hfdxH7eH7SZj5B6+t0PwfRSRe2+bptHKbWBjVONkpdGdzsO1BbTXqvk0ysbM2Fh0CO6uquYsh0ZI52OnychGk4mZsXYCx+xHfUhHB18Au/Cy1mLGrapkBQJUq0ZcOoGpoSctDTvYZqnDGlK4oEbP3ER/pExKIBpTwILNWBppVW7SjCSEvJQYTjxSUX+Xm5FOF2/GJbDNqKIPGmla04x9yeGH9So6sgxpHAwU0d7rY6/BglfXuItiU3+AUr0O3zF15m5HHhBGx2bja30hBUlnctuaVzlk3UKUpuFUw/dA/2hwsFGXyG4zOA3h5NYtFX4MQmFWghq5DgzKHsSTfZ9Er/78Q+f/dTIpdcTpp59Oly5deOWVo+N5tG7dmpEjRzJ16q9Ptfm3SEqFgvDR1awuWMStyYk4VZXRDXpurz5+HIktxi7M8bQmJekLllksXORwclGDl1uMN7HSXIEhbg2KGuSGhgA3VoebsxbpdYxPyeSQ8dcHXjzb6eKpymrusHVmUXI1aeaWvNv7bhJT2oPeFO4XvegualWVJxPi+DzKhkEIbvQbya0t4fVYe6QrGIQvIC8e1NNRLUSHxtjUZDZYzOgVPev/sZ6Zm77m+e13AOGWIhNq67myzsWCUC/6G/LxNGvPDbYgzjoXD1fu5M7kxEhCLjUY5NOiUtZYbdyXEIvjSCXhHKfgzso69pv9rDfEEQjYGRw6RKuADwUIdr2Gz/MGcP/qu4FwoqCjz8cWkwm9gOd0XTAp1YzTDmPUBGZ3OvW2skjFAqCVsw2J6gbWWsyRE/f1tfVMqKvHISxcZj2bQ6nh8X3MGgSVcHNcVQiS6nMoMQXRWYoiT5vjDHZq/a5GT7x0QvBIZS3nuo72w36r2TPkdB5IX3ULOp2ObZqbF4q+Zk3pGjICIc5xORlb30BFMI0nxBjWmfyE0heg6LwkqCZ0fhcVej2PVlbzTEwqNcYAQih0rB7LQxdfwiNf7+T6w/fRU93FIlsUj8YnoChBQiiR/Qtwc9PnuKhrL9YcqMGb/wXDd9/GjanJkWTQw5XV7NHZmRPfOKF4msfLQ1XVPJ4Qz0qrhaia9pxTp/BV9qZI5aSL18sL5VXEaBoPxzxCN+d3nBNaQrmIpcTsxqWqnOb1ohcq1/hvpalSxoOGd3gvOopHj2m5MczhYqDbTYZfoXXQzSaTketSUyLJT4SCpeZaKiqysWa9jc62F2tIIS/gYYDLw7cJ6Wym8RgoZzs8PF11fMUlhMq/g2dxue5bAqpgZEZapCIQY4ylrsFO0BeLpb4Xs3on8upuG18ePHYLgt55ZWxRnj9u2z+6paaOl+Nijkv6/ShZH8X0g3tpqbNS5DWz19qATdNYq49nRtLR30FFIeiPRdF5UHTh5uWqEHRzqWy0aSdMEsWHQvgUBZeq0qvByNLie4k1FuHOfhehD7eQuqu6hksanIzK6sdeXQFGTU+XgJc1psYX6thQCJsmKD6yf5KCIZoEA4RQMMR2plfupXxV+Am768OttUZYW9EkEMWr3gI0XQ3ptizmtbySuI+vB+Ce0PXMpR323GloaIyrq+eftfUI1cC/xRDyQtvpqBZgAILAVQl5bLYfvcn9R30DtztDTDS35UB0Ma39bjr7fFza4MStRmPVHDhVFbMxAfcl7zFs3ufkxnzMUzWFRGsmPu42nVXeav655WlaqqXckZTAwqhwBXRsvYPhThdFej3Xp6XgOOam/npHgAlVpQTR0cswHneTBZHXXiutoKfXy9XBCazJXo5qrDvBL67gr+7DIE8VF+mXcYbXi14IzsrMoeZIpSxQ35mgM4+01M8Y4C7n9upa9MAVhlFsCbSnVVQdxQnzGlVGUzxRzKnczej0lMhMqT/K8oc4fEzLlZAvmSuKWnOXOocHEhL5zB5OZLsPXU1Hj2Cu8THWW4yMTwsnx0XIDGgounAi4+OiUg4Z9PwzJSmyze5eP9PKK7BpGq/ExbDQZqXIYCBK03i/uAzf4Dmsrl9Mfs0Obk46gzd3zObD6HDlOjUQpN7bEU/00YSdFrAztjiFq5VNPKm/jg8FWNI+BJ2f5n4/t6h5vB3YxSaLkQ5eHzcXx/Ftm758EvgWnxbAIASpGKghkwavH9VUhqKGyPP5ubzBgU9ReD4+NnIjG6NplOn1GIXAf2S/xodCuBQFn6qioqAhsPmtpB46l8mjLqdv+2ZMW7KMtw7ciXoknpoEAtxZ6eKO+ql06ZjMHtc0qvTFP1vh+jGRaFYtDPKcx0PF0zAccz3Z1vE+codNJuQoZ/OLl9KbLTgVG0O8j+ERJh41vMVuMsm67HIOe/JZlf8NFf4iagwhWvv83FZsZruazKzMYuwhjfMP5/EvLiOl9Rs0eBTq9t4E6OiT+BoG224q9SpFBv1x55PokIZd0yLxH6W3g6LhDISvc5c0OLizupaX4+NYFd2GyoP9SAuotI3ayofpm9GU8DYcOpWRhhQe2bMOj6LQMzOHoO7os/V2IZVWroZIEjIxFOL58kqeSIhn2zFJeISKqoCGhklnIk4kk9RQTYJaR75RpfJIDBi9aVitUdRpe8nya3TwNaNFryE0T2xHq7iWBEWIA/UHePyrpynTFXC+w8kdNbW4zdlY/jGTUd/fzUFX40TAOfEd2Ve6jj3HlucInaKjk/oQK7YrjFBXsz6mnrrU8Dg06YEgJQY9bbwxnGe/BnPLDry2bCpB+04Gup1cU6PwRbAbffX5pEUbqFB9TDUHWWW1kGGM5bPiKhzuMkZmZRJjb8JL/Z9n//uXcofJhxHBuBoD72j30TbvMDtrPqf6yJAH0SEVh06jjc/HvJJyfnok7tfSaK6W4kVlaspAduq2YhCC18sqsArBA4ExzA6dzVT963RXd/FEbC5llkou9BTT0efjU+0MDEEr94rwA5VtRiNvxfdn4pmTyUpvSZHPwuGZY+ntDE/iEAAub57HLs3d6AGlXkRzaZvzyDNdzNwfygnYlrLX/ynW6vZMb1hLF/Ugs+zRPH2kex/A0OR/sv7wK1SavQw5ch/8eFw6c2P1BF25XFENdfFb+CrKxuSaWs50xHC3dzTrtDwC6IlO+wZiv4nEN4C/pge+iiHYmj+Navjl2QZFyBK+JqPQt0lfLHoLHUvd/GPXnKMrqXoY/SlLhZXbll5NetDD7TW19PF4uTNwLUtCHXgw9VlauAppEgwypEkGtXoVoRkiPRB+ZFSNjErogu/QBlYaA5ToQaeptDtwLuaQkXaGEq61LqMyUIFHVdja9Am2JRr4tuw5QkIj4+AQBpsXMz01vN2WPj9WIdh8zP3/Ve2uYlTSUP498zU6BjczI9vBHoMfoelRfkw660z4QuFkz6ySclrFtsc4+kMOOvX4ghopcX7mbPuCGas2YYpeT8gYTs4Prdd4sqYIAdQ3P5NYvRkKf+BlYzDSoiU6pJHnC9EBA56Ag1Kdkb3GFrRqlkP38gIsJZt4PCEOr6oS407g7OKWLM1ZQcUx1722Ph/vlpSjAoeUDLJFOCmvCYXHxBjaW7/k/jQzmYEA46NbU9ysD8vL1+GqOo2tu1qB4scQ9z0iFIXwpdMibj5lMQdPeB93V3UNVzQ4uT1wHTvbeTjkXwYinHwGUISecUkDmbhuBgXWGO5p2YWm8Xm0YiybDt/LklC4hVJ2RXu2V19Kz05byW6Yi9HvZmF0NJ7j2vgfZRBRBJTGYz4FHG0431XNloQiCn/SOCDer2dWeSGbzEYeOPLw+0c/NkRYbrHwubUpddHX0jylJzlJUfTe+zgrSz7jrVg7xUf2c7IGt2afy2FnGd8XHQRnDMlaCr0UH6e5V5CoVjI6LYUdpqPHVuMhEwRTXG1ZEHsl31e/h862H1XnZJBD4V/VB1lGHlu6no0nQccn+77EL9wY/MkkmtpQ2FCJFrJgsG9GUYO86IvmbaWWDT9prKBTdNzoCnFdebj1frkSxVX2rhyOO0SX+DOZPeL/MYbq/xCZlAL8fj9Wq5UPPviA888/P7J84sSJbN68mWXLlv3qNv4WSSkID+K78R2eT7iKFxuiCdZ3ppNygMn6Dzhd3cV+c1vaDByNp93lfLq1gg4//JM2Nd/iSuiAbdTriKRWFNd5KHWWs6N2AxeltcW26V2Ib4YntSuk5PLhng/5fPPr7AjWoRMgArHYdW24s9dAkle8gK1iJ60DGo5O16I7616cipskSxI69Zingts/hg+vAlVPcOBD3Lnjdb42NE522Qw2OsW0gJJNdPUl83TRzVysW8ajhpl8Y0/hnwkmcmNz+eS8T9hfXcLIBedgEnpeLD9MD6+PewPjmK87mwU396ZZUhRCCOrdfhZO/yd7rfv5ICp8Y/fcGQ9xVrOhoDez7uAWbv/uNjKCJbxeVoJVCLZozfiH/x66tcrmjf5+dPPHg9DguqUIWxJ3L7+fzaU7uefQdvp6ylieOBSt/x30b9cFoWlc9slw8p1HW1u1jhrEmbktefnIOEjHStQUZvusJBqTEYMfpy6qGbd++yjbnUcrmjpnUzID59GzZS+yU908t+MGPCEPiZZE5pwzB49Xz4x17+Mum8WBkJNbLbmcdcZkeOcCQEBCC7hpbXh8p59wBVxYvn0cdc1LFBtzuNB1B2Wh8IV5RDcjhYbp7KsLzwpkUU0M9U3Cn+nl87Ln0bk7UXfo0si24nRevuu9i7g2Z7KN5pjfGoBdX8o1qckcNBqINyWzdNQ3kXGKABwH1nPzZzv5Xqygrc/P256vsCtuthuNVOp1+IEHf9LCDyCq8m4yo3N4oN1BYkMHiYvNwVpbiNj/LSKhBboRLyAOrUZ5+8hYHIoKrc6BlLZUpvRh2Cc+PIEgyzp8iy9UzmB3OJGRF9ON7jsSud0/I1y+mFZE/2MOi2uDfHNwFR0zkuie3o6cmObc/uGW8Cw4SgCdYuSDZovoUjQbt6Jwd1ICS2xW4kxxxOtbMmhbFTcqS9is5XJQJDNQt4koPLgHPcWK2BGk167Htv8LpjmyWKYVMqnXuVzVeTBvrz7Mc9/s4amLOjCkXRqaJthR2kClw8fyvZXM/v4QIU3D1mwaqqkKIVTu6/4IH+17l121+Zwd0PF0UQHTk9J4JcpA6/jW3NrtVmblz2JF8Qq6JHdhWt8nSZx9IZSHWwxVihiiFQ9m/MyMieaZ+DhyQjB1+Bxe+jrIwu2lqMYKrhkA57XtxY79YF//D6ZZndSrKhZN4NCpkYo1QBOh41/9P+auT4vZUdqAyVJGasu5ZHsCzDy8Gb8w0sX/ImS+i95WAIAelVENDi5pqOe+xAS2HblpNWoJjC8zco3vBxTA1/VaTOc+DYS7ND+z/hnm7DzmhhxIsabw9pC3aRKVAZ9NgPoiSoa+RY1fzyHfSvaXbuCGLQsx1BfDxTNZ4GrNzXM30VQpZYT6PVGKh+UZ1zKgXR1r8++mUid42W8n7dJ5bPcmsnXLRkZtvQqdtxaye8Nlc/HVl6H7YDT6qsZTLzcIK1f672KLyAWgrXKQJzJ/oGXXXmyx2ujoC6AvWk+gYA0GRyH7hv+LD/0lZPg8tF0/h26OWhTAkXsedymTUIIPsIxDnOdw8mh1HfOiRnNX5WAM1kJy8r7EbrAQW19DQnob4mLTaG7pw/3vN9AiwcTdKT9gMRmpNaSwM9XBqzumk2hOpmVgCt2bNmFsj2x0cy+BfYtpUOx09bxESNEz99oz2LJ2DC/6DqEKwTU552JRryJ/4Vt0ivmap49UOIINbfFVncll7TpSFfMmq0vDLQtj6m+kqCSLXKUIlzBiar6Xfrk59Eo+F6tRT5qooElCFG8Wfs68XfOoPdKdKdmSzEVNh3LDzmXU+Vz0MdSBGmBI1gU8nn0WhrmXhgd4Te0AlbuoFwEUwJ7VG8Z+3uh3cK56jot2vkaJXsedoTb0u+hlLlt4AXW+OmKUFrgLr+CeIadzYed0FFWl3hPgm31beXHzTVRrRwfANQrBm6UVdPKFK0iH9HoeTIxnw09aXQLYQ134euSD2IQAXwPlJRtYXrGeXllDWOPL4MV9d1DlrcKiaTxWWc2Zbj9XqZexIWM9qt6NFozCffAGbuzdndvPzots91/ffsesXa9yWnQOr5nLeT94Fg9sPZpoP8eynMHR89inpvK+7wxqgmlk6KsJpHyLQwlgROXVs9/gtNTTKN23hagDXxBVvBKl5dnQa2JkO9O+2snuZe+xT2RwSMmgdVo0Jr2O4R3SuKpXTmS9rUV1vDl/AQ9U3UMC4cqgS9Wj63cnu3OuxWrS0zTJzK5SBxdO/wF/SKNVSjT/7GZgSNkMnGX5fO0MskpJZ1tCb1omZWCuMJMaLEeXGU/rVtkMzD0dT9DDh3s+pKGhlIu/fp1UUcukwE18pvVEVSAxykSFw4cx8RtMSeFBp5ODQT4pLsWuCUTvyVxZFc+2hm8ZYIfTStZzkcOBUcCLHQazRBfkkZCddlvnEwCWRMcws8kZ5Hv2IpRw5XhA5gDuOf0eUm2pCCFQgj7cFTt4ev8SPjzwLkIJJ1KFZkQtncTMK4bTNftoUuNHaw5UM3HeRvplGri6dZBWHXuBwcLumt08vOZhAiE/1lCQS9qO4Zzc8/C/PpAd1VtxqHpmxN6APt1BiW8rl7e+nCtbj+axL3fy5soCWqXa6HHaSj7a9x4QfpDwcXEpzQNBhKJDOdJSpUgkcrn/XvQJzXhr7GnhMVrqixAz+rM9UE9SKERqKATxzfGMWYA+OhmDaoBD31M5+xyMqpmY65ZBUsvId3przYc8u3MqqOF9MLKhOQ81y0W0v4SVDSmsXfUt15dPwa4d6XbcZTTBYc8z96MPSNz3ER2DW3ErVqYmP4Uwhe/T80vqKW8Ix9oDbatoZarmHxtbYCDEd/FPkOHZzT2Ba5kb7AeAXlUIaoIYnHxjup0kpR66jGFPnwmMWnAJQRFCRUec70JeH3kLLZIbd7Wp9wSYOG8Ty3aXc6lxJUNs27g3o4b6kIu8+DzeH/4+8zbuZP66N3jCUk1OzUYaBj3Fu3VJNI1Np0N6NOmLrsGzdxGW1A44L36PSQuK+GZnBR2bxPD8pR14cN3NbKzYiF7Rc2u3W1Ea+vDQgh00a7qHYuMbKChkWlOpCzhpCDjIsbdgVN6FzNj6OjXeahRUHu/zGMObDQfCg3R/vHgpp5FPtn8ftBgEecMACAT96L97FGX184RsKdyePpuWTZK4vk8OOworuOGt5bjjtuOLCw9nEfIlofnSMMfkE2eO4/kBz9MhqUP4NS3ED6U/0OAy8ugn4Th/Y0w38hLNkP8xGCzQ5jwgPD6rX/Mza0UVb3+7ifOTpyKM9dxY7abG1ISpOfEcFn4e7v0IfZv0BcIzel73zgZUU0mk1ZpZjaZDcuvIzHUXpPbkIXMu9LjxhF2hPt5YxN2fbGBwwuO4zDU8VllNWigEZ9wIgx8L3xcLATUH8B5axaHNy0koWkKiFu6dEbClMS3lCS4fNpisBGt43a3vsWvxXSwwCv5R7yAtFGJ+lC3c6tIUR7eUbvzTFSJz/dvQ7iK0ES+Tv/xDrD88z3TXmXyk9WVAooOp2QtJaHUOhg6jIuUtrvNw2/tbcPmDGHUqfVok8Y8zspi3rpB3lq2hR9tURvWO4p4V91DpqSRaMfBNwQFUfQwdHc8RMNVgbfoiypEujdm21jx/1lSaxzUPT2gRlQJJrSKfV+WpYtSCS0i0JNGae0m0Wbixfy7q2ldh0V0U6XU8Ex/HNpudGlUhVrNyT/k+CvV6nolPQCgaCgrZ9mxax7emZ3pPmpn7o/PXk/fJYPb6q3nN0IHFoiPxxi7MHXsBGcEStM8nMcGzm7VmE/380CvtfM5PSg8nrNuMgJgmjX9Idw280Jmgt46v7bHsa96b0QOfIdYWHhe4wuHl4le/59CR2bqNBLg5agk9ozZwS2wDDYqgsyGOh6uDXGOtpVyv52ynlydHr0KNTqagysWs1QV8svkw9W4NEwEGtMnk1dHhMa+2VORz5efXInTHJ4lbxrTnw/P+TZmrjOc2PMf2Yi97i430aNKJVy46H6unHlY+AyltcbQYycSP97K0YCtZMUl8dcswTL+xBe3/IpmUAkpKSsjIyGDVqlX07Nkzsvzxxx9n1qxZ7N69+7j3+Hw+fL6jM0Y0NDSQmZn5109KhQJQnk9ldGsWbi/FF9Co9wTYVlxPtcvHtIs70So1+pj1g+EZgdI6RAag/K2c1XupV1NZuqeGoe3SiLcZwwOQbnoHmvWH1PY//+aAJzyVePMBkN2TgKOM9766mR/wskd46ZjSmVu73kqKLQU0jSp3gEnzNpMWY+bODh4Sm7Tgu+otZEZnhge3BA7WFWI3WIlf+jjEZLK+yWhiLAZapEQf9/Ga0Hh2w7NY9VbGdxzfKDEChGfpWHALIuhnYmACJX4Lb449jRiLIXwRCvrA8JNKhqsqfKI85iYMwomeTRWbOFB7GEWzcUX7cwG4a8VdLC9azsjckVzc8mLSbGlY9JbjywJUuev597rt7K90cXHHzvTOTYyst7xoOe/vfp+bO99Mq/ijFxeCPijZBE1OA1UHS/8Vnpnr/BnQcdRxn3H0t/HCrs8hdyB+g52yei/VLh9t02MICi9TVk9h4cGFXJZ3GfecHh7YOr8qnwZHPJPm5uP2h7AYdNzYvzljj6mYrFryJZ2WjuVLS0++796aYbkDOSvrrOM+vs7t5+EFO9CpCj2zzJxl2om9eAUYrNC0NzuiE5i8+j5KXaXEmmI5J+cc7ux+589/nx8JAYvuCv9OfW8Lj6FyhNsfJBAUxFjDMfDomkcpdBTyVL+nMCo2Vs1/DauzkNMvvx/VdOJuKSFN8NgXO9l4uJb7h7eha1YsrH0dDi6H7tcRyO4RvmkH3l1ziOnf5FPkDJ+WHx/enMvb2SA289e/xy/YU+5g5qqDfHP4Szwx8xiSdh1PD7kBb9DLhvINdA+qGL66BzHgXgqSm5EZnYlBNSCEoNBRSEZURjh5XLQB5o+HZv0pO+0O4m0mjIeWQe1BSusPkdjpSgxpHSmscTNx3ibO7ZjeqBJKQyksuCX8m2WdQXmToVz2QT7dmquM6GCkdVIHEmxJ+IMaH20somVKNJ2zYiAY4MBHU1jZkMTrNZ3o3NQESXOxGqxM6DSBLI8DFt1Fvd7EHTFGzNYkpvScQhw6mD0iPIj26E/B2Pg3+qH0Bx5Y9QDOgJOr2l3F5XmXYzX8yqBRmgYhHxgsCCG49YMtLNtdyYC8ZM7rlH40Bg//EL65O/16MB9z7ajcAwdXQKfLwzfjED4/zrscDq0CRUcgqS17TnuENb5sFu8oY1+Fi/uGtWZk54wTl0mIxpNMBDyw79twnJ9+PUQlEwoG2JT/Lh0T2mKIyyG/Xs9987dzTe9mDOuQ9puPpYAW4P3d79MzvSc5Mcf8to5y+GIy9U2Hcl9BW/q3TOLCrk3Qagr4eu4IstJPo835bwGwtqCGrHgrlbWr8atxPPq5m9ykKKZe0B5X0MHdK+6maUxTbu92O1uL6lm2p5ImcRZGdspAVY8/D0K44rOrZhco0Dq+NapyNEH91b7vqfPWM6rdkPCCmgJwV4cnoNj7dXh2Gy0AYz6HnJ+MNykE1QtupqpsI60unw9Ryeyt3cvWyq2c2/xcDKrhhOfmYkcR1358HoX46WqI54Ehb9BMZ4F1b4RnG/Q1IFoMoWjQfVSKAA3+Bg5WeVi9x82Us4eSHvvzx+GB+gN8sPsDRuqTaLVxLqLnzaw09ODV1d+zuW4h7eyDmdi3Dz2aJRxXNm8ghNmgO/LVBKv3V7NqXxU7Shu44vRsBrWK50CNj9s+2EJemp2JZ7VAZ3Aye8ds+mT04bTU0362XD+qc/u5Yc5G4mwGJg9qSW7y8dfaRsq2hR+OGMxwwRuQdfpxq+wtd+AJhGifEdPoO5XWe3D5QuQmRx33nhMpKCph7rItzN4VPjc/O6oT3XPiGff2Og5U1tO805scdh7gZY+J3qW7YeAU6P3PyP5SFAWq9sLSJ6B6H1z673DFSAuFJynRm8GaAAYzmtCo8lThD/lpEt3kZ8tU5iznnqVPsbVmDednTeDWXhdHfqP/WOE6ePcS6HVL5Hv81L4KB5nxVkx6HUsLl/L8hmc5JzqXa52+8OywzjKChihe85zJOwzn4r6dGN+vObZjW6ke+h7eGQk6I/S4Cc64AcyNEzccXBWelCWtw3FleH/bSh5ZdyuKMPLpyM/ISfhJQq5iJ7xz/pEHf8vA/svnrJAmWL2/CpcvxNltU1AUhQ83FLG9uJ47BuVgDTpYdCg823J+SQMhTWDQKbRJj+HpXoIW7k1w2rVgMLNg/wI+2/8ZN3W6iU7JnX7xcysdPuJtRnSqwoL9C3hu43M80eeJ3xQ3BP3h+4KsHmC0oWmCvRVOmiXZMOhUqj3VzNk5hwGZAyIJH39Qw6hXKXQUEmuKJdoYjRACZ8BJlCEKRVEod5Xz5vY36Z3RO5LI+U2ECA+On9ii0X0RQL07gE4X4ukNT2BSLZQe7EfT+Diu7peKQTX87HU0GNJQFAXdz5zHj7VibyW3vb+ZgNfF7ed24dLTwvdBmtAaP8wGXl6yj6/yy9Bsa1Es+3lp6D1k2tOYnT+b3bW7uav7XcSYYk70MREHKp08+NE6lOKN3D00j9a5zcOTJvycUDA8O23hD+Hr7E8TJBC+5/nhlfB+rDkAPW/B0e92oozRR89jnjqwxDZ6W35JPV/nl3N+54zI4Ny/laYJFAUURaHSXclb29+iV8pp9N7/Pe607tyyNpYqpx+z2UmnbAtXndGOZFvcCa9jxwqEAiiK0rgbmd8Vns054A6fK9uMRADegMbUF18kGNS4YuyFBJRaWsS1wGY4wXdxlIPPwYtbBPsqnTwwvM3RyWuEQGyZh6gpQO05ofG91M859D3sWwzdxp3wN6l3B1i6pwKLQUdqjJl26TGoqsL2qu18ceALrmp3FcmqmfzZ57LAe4ixHW4ktf8djbYR0gSbC+vYU+5gRMf0RufC9zZt5rEVb5EZZ2dQq+aYTT4a/A1c2upSsuxZjbaxen8VHTNjsZuPr2eHNMFz3+zhgi5NyPmdx8D/GpmU4mhSavXq1fTo0SOy/LHHHuOdd95h167jB3meMmUKDz300HHL//JJKekv48eQ/LULxB/K2/DbTva/QAhBQUNBJKHxe9TUO4iNsqH+dMan/0cZBKJRhfSvRtME+SUNVLl89G+Z9IceB0IIGrx+Yiy/Yba6U0RQCyIQv/uY/cMJEZ7yOyo53JVZOnmK1oOzPNJK4I/i9Nazt3QdHZue2fic5K0PJzYyuh43Y+0pK+gLJ49P0FL3v8HhDeAJhEiODj9ECmkCbyCEpnio8daQbUkGRynENzsp5fmfpWnhynR0CjuqBQlRRlLsx7fuA8BZGU60m35bgvCnKlx1CKGQEvUzyYNQIJxw/w/vVX7K7Q9S4/KTajej/w/vQaQ/li8Ywh/UiD5Bpf2/JRDSjp999D8lBHjrwHJ868e/vJ8+FGv0kji5dZk/UigINfsbtRiT/n9kUor/X/e9v21LKUmSJEmSJEmSJEmSpJPgtyal/taPBIxGI127dmXx4sWNli9evLhRd75jmUwm7HZ7oz9JkiRJkiRJkiRJkiTpj/XXnV/wN5o8eTJXXnkl3bp1o0ePHsyYMYPDhw8zfvz4P7tokiRJkiRJkiRJkiRJp6y/fVJq1KhRVFdX8/DDD1NaWkq7du348ssvyc7O/k3v/7F3Y0NDw3+zmJIkSZIkSZIkSZIkSX8LP+ZQfm3EqL/1mFJ/hKKiIjIz/7OZryRJkiRJkiRJkiRJkk41hYWFNGny8zPRyqTUr9A0jZKSEqKjo/+6MwhwdMD2wsJCOU6WJP0MGSeS9MtkjEjSL5MxIkm/TMaIJP26v0ucCCFwOBykp6ej/sIMu3/77nv/KVVVfzGr91cjB2+XpF8n40SSfpmMEUn6ZTJGJOmXyRiRpF/3d4iTmJiYX13nbz37niRJkiRJkiRJkiRJkvS/SSalJEmSJEmSJEmSJEmSpJNOJqVOESaTiQcffBCTyfRnF0WS/mfJOJGkXyZjRJJ+mYwRSfplMkYk6dedanEiBzqXJEmSJEmSJEmSJEmSTjrZUkqSJEmSJEmSJEmSJEk66WRSSpIkSZIkSZIkSZIkSTrpZFJKkiRJkiRJkiRJkiRJOulkUuoUMX36dHJycjCbzXTt2pUVK1b82UWSpJNi+fLlnHvuuaSnp6MoCvPnz2/0uhCCKVOmkJ6ejsVioX///uTn5zdax+fzcfPNN5OYmIjNZmPEiBEUFRWdxG8hSf89U6dO5bTTTiM6Oprk5GRGjhzJ7t27G60j40Q6lb3yyit06NABu92O3W6nR48eLFy4MPK6jA9Jamzq1KkoisKkSZMiy2ScSKeyKVOmoChKo7/U1NTI66d6fMik1CngvffeY9KkSdx7771s2rSJPn36MHToUA4fPvxnF02S/utcLhcdO3bkpZdeOuHrTz75JM888wwvvfQS69atIzU1lUGDBuFwOCLrTJo0iU8++YR58+axcuVKnE4nw4cPJxQKnayvIUn/NcuWLeOmm25izZo1LF68mGAwyODBg3G5XJF1ZJxIp7ImTZrwxBNPsH79etavX8+ZZ57JeeedF6kwyPiQpKPWrVvHjBkz6NChQ6PlMk6kU13btm0pLS2N/G3bti3y2ikfH0L62+vevbsYP358o2V5eXnirrvu+pNKJEl/DkB88sknkf9rmiZSU1PFE088EVnm9XpFTEyMePXVV4UQQtTV1QmDwSDmzZsXWae4uFioqioWLVp00souSSdLRUWFAMSyZcuEEDJOJOlE4uLixBtvvCHjQ5KO4XA4RIsWLcTixYtFv379xMSJE4UQ8joiSQ8++KDo2LHjCV+T8SGEbCn1N+f3+9mwYQODBw9utHzw4MGsXr36TyqVJP1vKCgooKysrFF8mEwm+vXrF4mPDRs2EAgEGq2Tnp5Ou3btZAxJf0v19fUAxMfHAzJOJOlYoVCIefPm4XK56NGjh4wPSTrGTTfdxLBhwxg4cGCj5TJOJAn27t1Leno6OTk5XHrppRw4cACQ8QGg/7MLIP13VVVVEQqFSElJabQ8JSWFsrKyP6lUkvS/4ccYOFF8HDp0KLKO0WgkLi7uuHVkDEl/N0IIJk+eTO/evWnXrh0g40SSALZt20aPHj3wer1ERUXxySef0KZNm0hlQMaHdKqbN28eGzduZN26dce9Jq8j0qnu9NNPZ/bs2bRs2ZLy8nIeffRRevbsSX5+vowPZFLqlKEoSqP/CyGOWyZJp6r/T3zIGJL+jiZMmMDWrVtZuXLlca/JOJFOZa1atWLz5s3U1dXx0UcfMWbMGJYtWxZ5XcaHdCorLCxk4sSJfP3115jN5p9dT8aJdKoaOnRo5N/t27enR48eNG/enFmzZnHGGWcAp3Z8yO57f3OJiYnodLrjMqgVFRXHZWMl6VTz46wXvxQfqamp+P1+amtrf3YdSfo7uPnmm/nss89YsmQJTZo0iSyXcSJJYDQayc3NpVu3bkydOpWOHTvy/PPPy/iQJMJdiyoqKujatSt6vR69Xs+yZct44YUX0Ov1keNcxokkhdlsNtq3b8/evXvldQSZlPrbMxqNdO3alcWLFzdavnjxYnr27PknlUqS/jfk5OSQmpraKD78fj/Lli2LxEfXrl0xGAyN1iktLWX79u0yhqS/BSEEEyZM4OOPP+a7774jJyen0esyTiTpeEIIfD6fjA9JAs466yy2bdvG5s2bI3/dunXjiiuuYPPmzTRr1kzGiSQdw+fzsXPnTtLS0uR1BOTse6eCefPmCYPBIN58802xY8cOMWnSJGGz2cTBgwf/7KJJ0n+dw+EQmzZtEps2bRKAeOaZZ8SmTZvEoUOHhBBCPPHEEyImJkZ8/PHHYtu2beKyyy4TaWlpoqGhIbKN8ePHiyZNmohvvvlGbNy4UZx55pmiY8eOIhgM/llfS5L+MDfccIOIiYkRS5cuFaWlpZE/t9sdWUfGiXQqu/vuu8Xy5ctFQUGB2Lp1q7jnnnuEqqri66+/FkLI+JCkEzl29j0hZJxIp7Zbb71VLF26VBw4cECsWbNGDB8+XERHR0fq46d6fMik1Cni5ZdfFtnZ2cJoNIouXbpEpvqWpL+7JUuWCOC4vzFjxgghwtOwPvjggyI1NVWYTCbRt29fsW3btkbb8Hg8YsKECSI+Pl5YLBYxfPhwcfjw4T/h20jSH+9E8QGImTNnRtaRcSKdysaNGxe5h0pKShJnnXVWJCElhIwPSTqRnyalZJxIp7JRo0aJtLQ0YTAYRHp6urjgggtEfn5+5PVTPT4UIYT4c9poSZIkSZIkSZIkSZIkSacqOaaUJEmSJEmSJEmSJEmSdNLJpJQkSZIkSZIkSZIkSZJ00smklCRJkiRJkiRJkiRJknTSyaSUJEmSJEmSJEmSJEmSdNLJpJQkSZIkSZIkSZIkSZJ00smklCRJkiRJkiRJkiRJknTSyaSUJEmSJEmSJEmSJEmSdNLJpJQkSZIkSZIkSZIkSZJ00smklCRJkiRJkvSL/H4/ubm5rFq16g/d7ueff07nzp3RNO0P3a4kSZIkSX8NMiklSZIkSdIpZezYsSiKctzfvn37/uyi/c+aMWMG2dnZ9OrVK7JMURTmz59/3Lpjx45l5MiRv2m7w4cPR1EU3n333T+opJIkSZIk/ZXIpJQkSZIkSaecIUOGUFpa2ugvJyfnuPX8fv+fULr/PS+++CLXXHPNf2XbV111FS+++OJ/ZduSJEmSJP1vk0kpSZIkSZJOOSaTidTU1EZ/Op2O/v37M2HCBCZPnkxiYiKDBg0CYMeOHZxzzjlERUWRkpLClVdeSVVVVWR7LpeL0aNHExUVRVpaGtOmTaN///5MmjQpss6JWhbFxsby9ttvR/5fXFzMqFGjiIuLIyEhgfPOO4+DBw9GXv+xFdLTTz9NWloaCQkJ3HTTTQQCgcg6Pp+PO+64g8zMTEwmEy1atODNN99ECEFubi5PP/10ozJs374dVVXZv3//CffVxo0b2bdvH8OGDfudexkOHjx4wlZp/fv3j6wzYsQI1q5dy4EDB3739iVJkiRJ+muTSSlJkiRJkqRjzJo1C71ez6pVq3jttdcoLS2lX79+dOrUifXr17No0SLKy8u55JJLIu+5/fbbWbJkCZ988glff/01S5cuZcOGDb/rc91uNwMGDCAqKorly5ezcuVKoqKiGDJkSKMWW0uWLGH//v0sWbKEWbNm8fbbbzdKbI0ePZp58+bxwgsvsHPnTl599VWioqJQFIVx48Yxc+bMRp/71ltv0adPH5o3b37Cci1fvpyWLVtit9t/1/cByMzMbNQabdOmTSQkJNC3b9/IOtnZ2SQnJ7NixYrfvX1JkiRJkv7a9H92ASRJkiRJkk62zz//nKioqMj/hw4dygcffABAbm4uTz75ZOS1Bx54gC5duvD4449Hlr311ltkZmayZ88e0tPTefPNN5k9e3akZdWsWbNo0qTJ7yrTvHnzUFWVN954A0VRAJg5cyaxsbEsXbqUwYMHAxAXF8dLL72ETqcjLy+PYcOG8e2333LttdeyZ88e3n//fRYvXszAgQMBaNasWeQzrrrqKh544AHWrl1L9+7dCQQCzJkzh6eeeupny3Xw4EHS09NP+Npll12GTqdrtMzn80VaVel0OlJTUwHwer2MHDmSHj16MGXKlEbvycjIaNQiTJIkSZKkU4NMSkmSJEmSdMoZMGAAr7zySuT/Npst8u9u3bo1WnfDhg0sWbKkURLrR/v378fj8eD3++nRo0dkeXx8PK1atfpdZdqwYQP79u0jOjq60XKv19uoa13btm0bJYLS0tLYtm0bAJs3b0an09GvX78TfkZaWhrDhg3jrbfeonv37nz++ed4vV4uvvjiny2Xx+PBbDaf8LVnn302kvz60Z133kkoFDpu3auvvhqHw8HixYtR1caN9S0WC263+2fLIEmSJEnS35NMSkmSJEmSdMqx2Wzk5ub+7GvH0jSNc889l3/961/HrZuWlsbevXt/02cqioIQotGyY8eC0jSNrl278u9///u49yYlJUX+bTAYjtuupmlAOLnza6655hquvPJKnn32WWbOnMmoUaOwWq0/u35iYmIk6fVTqampx+3H6Oho6urqGi179NFHWbRoEWvXrj0u6QZQU1PT6DtKkiRJknRqkEkpSZIkSZKkX9ClSxc++ugjmjZtil5//K1Tbm4uBoOBNWvWkJWVBUBtbS179uxp1GIpKSmJ0tLSyP/37t3bqHVQly5deO+990hOTv5/jd8E0L59ezRNY9myZce1YPrROeecg81m45VXXmHhwoUsX778F7fZuXNnXnnlFYQQkW6Fv8dHH33Eww8/zMKFC084btWPLcE6d+78u7ctSZIkSdJfmxzoXJIkSZIk6RfcdNNN1NTUcNlll0Vmifv6668ZN24coVCIqKgorr76am6//Xa+/fZbtm/fztixY4/ronbmmWfy0ksvsXHjRtavX8/48eMbtXq64oorSExM5LzzzmPFihUUFBSwbNkyJk6cSFFR0W8qa9OmTRkzZgzjxo1j/vz5FBQUsHTpUt5///3IOjqdjrFjx3L33XeTm5vbqNvhiQwYMACXy0V+fv7v2Gth27dvZ/To0dx55520bduWsrIyysrKqKmpiayzZs0aTCbTr5ZDkiRJkqS/H5mUkiRJkiRJ+gXp6emsWrWKUCjE2WefTbt27Zg4cSIxMTGRxNNTTz1F3759GTFiBAMHDqR379507dq10XamTZtGZmYmffv25fLLL+e2225r1G3OarWyfPlysrKyuOCCC2jdujXjxo3D4/H8rpZTr7zyChdddBE33ngjeXl5XHvttbhcrkbrXH311fj9fsaNG/er20tISOCCCy44YbfCX7N+/XrcbjePPvooaWlpkb8LLrggss7cuXO54oorfrELoSRJkiRJf0+K+OngBpIkSZIkSdJ/rH///nTq1Innnnvuzy7KcVatWkX//v0pKioiJSXlV9fftm0bAwcOPOFA7P+JyspK8vLyWL9+PTk5OX/YdiVJkiRJ+muQLaUkSZIkSZJOET6fj3379nH//fdzySWX/KaEFITHqnryySc5ePDgH1qegoICpk+fLhNSkiRJknSKkgOdS5IkSZIknSLmzp3L1VdfTadOnXjnnXd+13vHjBnzh5ene/fudO/e/Q/friRJkiRJfw2y+54kSZIkSZIkSZIkSZJ00snue5IkSZIkSZIkSZIkSdJJJ5NSkiRJkiRJkiRJkiRJ0kknk1KSJEmSJEmSJEmSJEnSSSeTUpIkSZIkSZIkSZIkSdJJJ5NSkiRJkiRJkiRJkiRJ0kknk1KSJEmSJEmSJEmSJEnSSSeTUpIkSZIkSZIkSZIkSdJJJ5NSkiRJkiRJkiRJkiRJ0kknk1KSJEmSJEmSJEmSJEnSSfd/WixaLeyeD7gAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Generate synthetic data\n", + "np.random.seed(42)\n", + "n_channels = 3\n", + "n_samples = 1000\n", + "t = np.linspace(0, 1, n_samples)\n", + "x = np.array([\n", + " np.sin(2 * np.pi * 10 * t) + 0.5 * np.random.randn(n_samples), # Channel 1: 10 Hz sine wave + noise\n", + " np.sin(2 * np.pi * 20 * t) + 0.5 * np.random.randn(n_samples), # Channel 2: 20 Hz sine wave + noise\n", + " np.sin(2 * np.pi * 30 * t) + 0.5 * np.random.randn(n_samples) # Channel 3: 30 Hz sine wave + noise\n", + "])\n", + "\n", + "# Normalize frequencies by sampling frequency\n", + "fs = 1000 # Sampling frequency\n", + "fl = 8 / fs # Lower cutoff frequency (normalized)\n", + "fu = 32 / fs # Upper cutoff frequency (normalized)\n", + "\n", + "#spectral component analysis\n", + "y, W, A = spectral_component_analysis_dft(x, fl, fu)\n", + "\n", + "# Plot the results\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "plt.subplot(3, 1, 1)\n", + "plt.plot(t, x.T)\n", + "plt.title('Original Signals (Channels)')\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Amplitude')\n", + "\n", + "plt.subplot(3, 1, 2)\n", + "plt.plot(t, y.T)\n", + "plt.title('Extracted Spectral Components')\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Amplitude')\n", + "\n", + "plt.subplot(3, 1, 3)\n", + "plt.plot(np.linspace(0, fs/2, n_samples//2), np.abs(np.fft.fft(y, axis=1))[:, :n_samples//2].T)\n", + "plt.title('FFT of Extracted Components')\n", + "plt.xlabel('Frequency (Hz)')\n", + "plt.ylabel('Magnitude')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/python/tests/unit_tests/calculate_time_lags_unit_test.py b/python/tests/unit_tests/calculate_time_lags_unit_test.py new file mode 100644 index 0000000..81bd2d9 --- /dev/null +++ b/python/tests/unit_tests/calculate_time_lags_unit_test.py @@ -0,0 +1,54 @@ +import matlab.engine +import scipy.io +import numpy as np +import logging +import argparse +from oset.ecg import phase_calculator +from oset.generic.lp_filter.lp_filter_zero_phase import lp_filter_zero_phase +from oset.ecg.peak_detection.peak_det_simple import peak_det_simple +from oset.ecg.bss.calculate_time_lags import calculate_time_lags +import unit_test as testing + +data_path = "../../../datasets/sample-data/SampleECG1.mat" + +def calculate_time_lags_unit_test(): + data = scipy.io.loadmat(data_path)["data"][0] + f = 1 + fs = 1000 + fc = 0.5 + data = data - lp_filter_zero_phase(data, fc / fs) + peaks, peak_indexes = peak_det_simple(data, f / fs) + phase, phaseops = phase_calculator(peaks) + + print("Running MATLAB function...") + t0_mat, t1_mat = run_matlab(peaks, phase) + + print("Running Python function...") + t0_py, t1_py = run_python(peaks, phase) + + print("Comparing outputs...") + w = testing.compare_number_arrays_with_tolerance(t0_py, t0_mat,tolerance=2) + x = testing.compare_number_arrays_with_tolerance(t1_py, t1_mat,tolerance=2) + return w and x + +def run_matlab(peaks, phase): + eng = matlab.engine.start_matlab() + x = matlab.double(peaks.tolist()) + y = matlab.double(phase.tolist()) + eng.addpath("../../../matlab/tools/ecg/bss") + t0_mat, t1_mat = eng.calculate_time_lags(x, y, nargout=2) + eng.quit() + t0_mat = np.array(t0_mat).flatten() + t1_mat = np.array(t1_mat).flatten() + return t0_mat, t1_mat + +def run_python(peaks, phase): + t0_py, t1_py = calculate_time_lags(peaks, phase) + return t0_py, t1_py + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="""This is a unit test for calculate_time_lags""" + ) + args = parser.parse_args() + print(calculate_time_lags_unit_test()) diff --git a/python/tests/unit_tests/phase_calculator_unit_test.py b/python/tests/unit_tests/phase_calculator_unit_test.py new file mode 100644 index 0000000..d4f12e9 --- /dev/null +++ b/python/tests/unit_tests/phase_calculator_unit_test.py @@ -0,0 +1,97 @@ +import matlab.engine +import scipy.io +import numpy as np +import logging +import typing +import argparse +from oset.ecg import phase_calculator +from oset.generic.lp_filter.lp_filter_zero_phase import lp_filter_zero_phase +from oset.ecg.peak_detection.peak_det_simple import peak_det_simple + + +def compare_arrays_with_tolerance( + python: typing.Iterable, + matlab: typing.Iterable, + decimal_places: int = -1, + debug: bool = False, +) -> bool: + """ + Compares 2 number arrays with specified tolerance. + + Args: + python: Python array. + matlab: Matlab array. + decimal_places (int, optional): Determines whether the inputs should be compared up to certain decimals. + Use -1 for exact comparison (default), otherwise specify the number of decimals. + debug (bool, optional): Enable debug mode. False by default. + + Returns: True if the inputs are equal up to the specified decimal places, False otherwise. + """ + if debug: + logging.basicConfig(level=logging.DEBUG, force=True) + + if decimal_places > -1: + atol = 10 ** (-decimal_places) + else: + atol = 0 + + if len(python) != len(matlab): + if debug: + logging.debug(f"Python length: {len(python)}, Matlab length: {len(matlab)}") + raise ValueError("Lengths of both inputs must be the same") + + comparison_result = True + discrepancies = [] + + for i in range(len(python)): + if not np.isclose(python[i], matlab[i], atol=atol): + if (np.isclose(python[i], np.pi, atol=atol) and np.isclose(matlab[i], -np.pi, atol=atol)) or \ + (np.isclose(python[i], -np.pi, atol=atol) and np.isclose(matlab[i], np.pi, atol=atol)): + logging.debug(f"Index {i}: Special case for pi and -pi handled") + continue + discrepancies.append((i, python[i], matlab[i])) + logging.debug(f"Index {i}: Python {python[i]}, Matlab {matlab[i]}") + comparison_result = False + + if discrepancies: + logging.debug(f"Total discrepancies: {len(discrepancies)}") + for idx, py_val, mat_val in discrepancies: + logging.debug(f"Index {idx}: Python {py_val}, Matlab {mat_val}") + + return comparison_result + + +def phase_calculator_unit_test(data_path: str) -> bool: + data = scipy.io.loadmat(data_path)["data"][0] + f = 1 + fs = 1000 + fc = 0.5 + t = np.arange(len(data)) / fs + data = data - lp_filter_zero_phase(data, fc / fs) + peaks, peak_indexes = peak_det_simple(data, f / fs) + + ml = run_matlab(peaks) + py = run_python(peaks) + w = compare_arrays_with_tolerance(py[0], ml[0][0], decimal_places=5, debug=True) + x = compare_arrays_with_tolerance(py[1], ml[1][0], decimal_places=5, debug=True) + return w and x + + +def run_matlab(peaks) -> typing.Tuple[np.ndarray, np.ndarray]: + eng = matlab.engine.start_matlab() + x = matlab.double(peaks.tolist()) + eng.addpath("../../../matlab/tools/ecg") + eng.addpath("../../../matlab/tools/generic") + result = eng.phase_calculator(x, nargout=2) + eng.quit() + return result + + +def run_python(peaks) -> typing.Tuple[np.ndarray, np.ndarray]: + return phase_calculator(peaks) + + +if __name__ == "__main__": + data_path = "../../../datasets/sample-data/SampleECG1.mat" + result = phase_calculator_unit_test(data_path) + print("Test result:", result) \ No newline at end of file diff --git a/python/tests/unit_tests/synchronous_phase_samples_unit_test.py b/python/tests/unit_tests/synchronous_phase_samples_unit_test.py new file mode 100644 index 0000000..6a56709 --- /dev/null +++ b/python/tests/unit_tests/synchronous_phase_samples_unit_test.py @@ -0,0 +1,52 @@ +import matlab.engine +import scipy.io +import numpy as np +import argparse +from oset.generic.lp_filter.lp_filter_zero_phase import lp_filter_zero_phase +from oset.ecg.peak_detection.peak_det_simple import peak_det_simple +import unit_test as testing + +data_path = "../../../datasets/sample-data/SampleECG1.mat" + +def synchronous_phase_samples_unit_test(): + data = scipy.io.loadmat(data_path)["data"][0] + f = 1 + fs = 1000 + fc = 0.5 + data = data - lp_filter_zero_phase(data, fc / fs) + peaks, peak_indexes = peak_det_simple(data, f / fs) + from oset.ecg.phase_calculator import phase_calculator + phase, phaseops = phase_calculator(peaks) + + print("Running MATLAB function...") + t0_mat, t1_mat = run_matlab(peaks, phase) + print("Running Python function...") + t0_py, t1_py = run_python(peaks, phase) + + print("Comparing outputs...") + w = testing.compare_number_arrays_with_tolerance(t0_py, t0_mat,tolerance=2) + x = testing.compare_number_arrays_with_tolerance(t1_py, t1_mat,tolerance=2) + return w and x + +def run_matlab(peaks, phase): + eng = matlab.engine.start_matlab() + x = matlab.double(peaks.tolist()) + y = matlab.double(phase.tolist()) + eng.addpath("../../../matlab/tools/ecg") + t0_mat, t1_mat = eng.synchronous_phase_samples(x, y, nargout=2) + eng.quit() + t0_mat = np.array(t0_mat).flatten() + t1_mat = np.array(t1_mat).flatten() + return t0_mat, t1_mat + +def run_python(peaks, phase): + from oset.ecg import synchronous_phase_samples + t0_py, t1_py = synchronous_phase_samples(peaks, phase) + return t0_py, t1_py + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="""This is a unit test for synchronous_phase_samples""" + ) + args = parser.parse_args() + print(synchronous_phase_samples_unit_test()) diff --git a/python/tests/unit_tests/unit_test.py b/python/tests/unit_tests/unit_test.py index bcd414c..70f393e 100644 --- a/python/tests/unit_tests/unit_test.py +++ b/python/tests/unit_tests/unit_test.py @@ -6,8 +6,11 @@ """ Revision History: 2023: Created - + 2024: Added + compare_number_arrays_with_tolerance + Amulya Jain, 2023 + Muhammad Ubadah Tanveer, 2024 The Open-Source Electrophysiological Toolbox https://github.com/alphanumericslab/OSET """ @@ -98,6 +101,51 @@ def compare_arrays( x = False return x +def compare_number_arrays_with_tolerance( + python: typing.Iterable, + matlab: typing.Iterable, + round_val: int = -1, + tolerance: float = 1e-5, + debug: bool = False, +) -> bool: + """ + Compares two number arrays with tolerance for differences due to offsets or precision errors. + + Args: + python: Python array. + matlab: Matlab array. + round_val (int, optional): Determines whether the inputs should be rounded. + Use -1 for no rounding (default), otherwise specify the number of decimals. + tolerance (float, optional): The maximum allowed difference between corresponding elements of the arrays. Default is 1e-5. + debug (bool, optional): Enable debug mode. False by default. + + Returns: + bool: True if the inputs are equal within the specified tolerance, False otherwise. + """ + if round_val > -1: + python = np.round(python, round_val) + matlab = np.round(matlab, round_val)[0] + if debug: + logging.basicConfig(level=logging.DEBUG) + x = True + try: + if np.allclose(python, matlab, atol=tolerance): + return True + except Exception as e: + logging.debug(f"Exception in comparison: {e}") + logging.debug("Iterating through the entire array") + if not len(python) == len(matlab): + print("python length:", len(python)) + print("matlab length:", len(matlab)) + raise Exception("Lengths of both inputs have to be the same") + for i in range(len(python)): + if not np.isclose(python[i], matlab[i], atol=tolerance): + print(i) + print("python:", python[i]) + print("matlab:", matlab[i]) + x = False + return x + if __name__ == "__main__": print("""You can't run this. This is a helper file""") diff --git a/under-development/lsim-deli/chmm_cartesian_product.py b/under-development/lsim-deli/chmm_cartesian_product.py new file mode 100644 index 0000000..b4610ae --- /dev/null +++ b/under-development/lsim-deli/chmm_cartesian_product.py @@ -0,0 +1,166 @@ +import numpy as np +import argparse + + +def chmm_cartesian_product(pi_0_chmm, transition_chmm, chmm_gmm_para): + """ + Convert a Coupled Hidden Markov Model (CHMM) to an equivalent Hidden Markov Model (EHMM). + + Parameters: + pi_0_chmm : list of np.array + Initial state probability distributions for each channel in the CHMM. + transition_chmm : list of np.array + Transition probability matrices for each channel in the CHMM. + chmm_gmm_para : list of dict + Parameters of the Gaussian Mixture Model (GMM) for each state in the CHMM. + + Returns: + pi_0_ehmm : list of np.array + Initial state probability distribution for the equivalent HMM. + coupling_theta_ehmm : int + Coupling coefficient for the equivalent HMM. + transition_ehmm : list of np.array + Transition probability matrix for the equivalent HMM. + ehmm_gmm_para : list of dict + Parameters of the GMM for each state in the equivalent HMM. + index_matrix : np.array + Mapping from CHMM states to equivalent HMM states. + + + Revision History: + August 2024: Translated to Python from Matlab (chmm_cartesian_product.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + """ + + coupling_theta_ehmm = 1 + + C = len(pi_0_chmm) + temp = 1 + + for c in range(C): + temp = np.kron(temp, pi_0_chmm[c]) + + pi_0_ehmm = [temp] + + sigma_diag = 1 if chmm_gmm_para[0]['gmm_para'][0]['sigma'][0]['x'].ndim == 1 else 0 + + dim_observation = np.zeros(C) + state_numbers = np.zeros(C, dtype=int) + num_gmm_component = np.zeros(C, dtype=int) + + for zee in range(C): + dim_observation[zee] = len(chmm_gmm_para[zee]['gmm_para'][0]['mu'][0]['x']) + state_numbers[zee] = pi_0_chmm[zee].shape[0] + num_gmm_component[zee] = len(chmm_gmm_para[zee]['gmm_para'][0]['P']) + + A_cartesian = np.zeros((np.prod(state_numbers), np.prod(state_numbers))) + + for row_num in range(A_cartesian.shape[0]): + temp = 1 + for c in range(C): + temp = np.kron(temp, transition_chmm[c][row_num, :]) + A_cartesian[row_num, :] = temp + + transition_ehmm = [A_cartesian] + + index_matrix = np.zeros((C, np.prod(state_numbers)), dtype=int) + index_matrix_gmm = np.zeros((C, np.prod(num_gmm_component)), dtype=int) + + for c in range(C): + temp_index = state_numbers.copy() + temp_index[:c] = [] + temp_raw = np.kron(np.arange(1, state_numbers[c] + 1), np.ones(int(np.prod(temp_index)))) + temp_index = state_numbers.copy() + temp_index[c:] = [] + index_matrix[c, :] = np.tile(temp_raw, int(np.prod(temp_index))) + + temp_index = num_gmm_component.copy() + temp_index[:c] = [] + temp_raw = np.kron(np.arange(1, num_gmm_component[c] + 1), np.ones(int(np.prod(temp_index)))) + temp_index = num_gmm_component.copy() + temp_index[c:] = [] + index_matrix_gmm[c, :] = np.tile(temp_raw, int(np.prod(temp_index))) + + dimension_numbers_index = np.concatenate(([0], np.cumsum(dim_observation).astype(int))) + + channel_num_states = int(np.prod(state_numbers)) + num_gmm_component_hmm = int(np.prod(num_gmm_component)) + + P_all_hmm = np.ones((1, channel_num_states, num_gmm_component_hmm)) + mu_all_hmm = np.zeros((sum(dim_observation), channel_num_states, num_gmm_component_hmm)) + + if sigma_diag: + sigma_all_hmm = np.zeros((sum(dim_observation), channel_num_states, num_gmm_component_hmm)) + else: + sigma_all_hmm = np.zeros((sum(dim_observation), sum(dim_observation), channel_num_states, num_gmm_component_hmm)) + + for i in range(channel_num_states): + this_set = index_matrix[:, i] + for k in range(num_gmm_component_hmm): + this_gmm = index_matrix_gmm[:, k] + for c in range(C): + mu_all_hmm[dimension_numbers_index[c]:dimension_numbers_index[c + 1], i, k] = ( + chmm_gmm_para[c]['gmm_para'][this_set[c] - 1]['mu'][this_gmm[c] - 1]['x'] + ) + if sigma_diag: + sigma_all_hmm[dimension_numbers_index[c]:dimension_numbers_index[c + 1], i, k] = ( + chmm_gmm_para[c]['gmm_para'][this_set[c] - 1]['sigma'][this_gmm[c] - 1]['x'] + ) + else: + sigma_all_hmm[dimension_numbers_index[c]:dimension_numbers_index[c + 1], + dimension_numbers_index[c]:dimension_numbers_index[c + 1], i, k] = ( + chmm_gmm_para[c]['gmm_para'][this_set[c] - 1]['sigma'][this_gmm[c] - 1]['x'] + ) + P_all_hmm[0, i, k] *= chmm_gmm_para[c]['gmm_para'][this_set[c] - 1]['P'][this_gmm[c] - 1] + + gmm_para = [] + + for i in range(channel_num_states): + gmm_components = {} + for k in range(num_gmm_component_hmm): + gmm_components.setdefault('P', []).append(P_all_hmm[0, i, k]) + if sigma_diag: + gmm_components.setdefault('sigma', []).append({'x': sigma_all_hmm[:, i, k]}) + else: + gmm_components.setdefault('sigma', []).append({'x': sigma_all_hmm[:, :, i, k]}) + gmm_components.setdefault('mu', []).append({'x': mu_all_hmm[:, i, k]}) + + gmm_para.append(gmm_components) + + ehmm_gmm_para = [{'gmm_para': gmm_para}] + + return pi_0_ehmm, coupling_theta_ehmm, transition_ehmm, ehmm_gmm_para, index_matrix + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + Coupled Hidden Markov Model (CHMM) to Equivalent Hidden Markov Model (EHMM) conversion. + Converts a CHMM with multiple channels to an equivalent single-channel HMM. + + Parameters: + C (int): Number of channels in the CHMM. + channel_state_num (list): List of state numbers for each channel. + channel_obs_dim (list): List of observation dimensions for each channel. + num_gmm_component (list): List of GMM component numbers for each channel. + chmm_gmm_para (list): List of CHMM parameters for each channel. + coupling_theta (ndarray): Coupling matrix between channels. + sigma_diag (bool): If True, use diagonal covariance matrices. If False, use full covariance matrices. + + Returns: + tuple: A tuple containing: + pi_0_ehmm (ndarray): Initial state probabilities for EHMM. + coupling_theta_ehmm (ndarray): Coupling matrix for EHMM. + transition_ehmm (ndarray): Transition matrix for EHMM. + ehmm_gmm_para (list): GMM parameters for EHMM. + index_matrix (ndarray): Mapping between CHMM and EHMM states. + + Revision History: + August 2024: Implemented in Python based on MATLAB implementation. + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() \ No newline at end of file diff --git a/under-development/lsim-deli/em_interval_calc.py b/under-development/lsim-deli/em_interval_calc.py new file mode 100644 index 0000000..d84ded9 --- /dev/null +++ b/under-development/lsim-deli/em_interval_calc.py @@ -0,0 +1,33 @@ +import numpy as np +from scipy.signal import medfilt +from scipy.stats import zscore + +def em_interval_calc(ecg_rpeaks_index, thr_max=0.5, thr_fast_max=0.4, max_lag=20): +# if ecg_rpeaks_index.shape[1] == 1: +# rr_intervals_ecg = np.diff(ecg_rpeaks_index.flatten()) +# elif ecg_rpeaks_index.shape[1] == 2: +# rr_intervals_ecg = ecg_rpeaks_index[:, 1] - ecg_rpeaks_index[:, 0] + rr_intervals_ecg = np.diff(ecg_rpeaks_index) + + md_rr_intervals_ecg = medfilt(rr_intervals_ecg, kernel_size=2*max_lag+1) + diff_outliers = rr_intervals_ecg / md_rr_intervals_ecg - 1 + ind_nan_rr = np.abs(diff_outliers) > thr_max + rr_intervals_ecg[ind_nan_rr] = md_rr_intervals_ecg[ind_nan_rr] + + if np.any(ind_nan_rr): + md_rr_intervals_ecg = medfilt(rr_intervals_ecg, kernel_size=2*int(np.ceil(max_lag/3))+1) + diff_outliers = rr_intervals_ecg / md_rr_intervals_ecg - 1 + ind_nan_rr = np.abs(diff_outliers) > thr_fast_max + rr_intervals_ecg[ind_nan_rr] = md_rr_intervals_ecg[ind_nan_rr] + + diff_outliers = rr_intervals_ecg - md_rr_intervals_ecg + std_rr_intervals_ecg = np.array([np.std(diff_outliers[max(0, i-100):min(len(diff_outliers), i+101)]) for i in range(len(diff_outliers))]) + z_score_rr = np.abs(diff_outliers / std_rr_intervals_ecg) + ind_nan_zrr = z_score_rr > 5 + rr_intervals_ecg[ind_nan_zrr] = md_rr_intervals_ecg[ind_nan_zrr] + + # Linear interpolation for missing values + nan_mask = np.isnan(rr_intervals_ecg) + rr_intervals_ecg[nan_mask] = np.interp(np.flatnonzero(nan_mask), np.flatnonzero(~nan_mask), rr_intervals_ecg[~nan_mask]) + + return rr_intervals_ecg \ No newline at end of file diff --git a/under-development/lsim-deli/im_para_eqhmm.py b/under-development/lsim-deli/im_para_eqhmm.py new file mode 100644 index 0000000..ef35e01 --- /dev/null +++ b/under-development/lsim-deli/im_para_eqhmm.py @@ -0,0 +1,123 @@ +import numpy as np +from chmm_cartesian_product import chmm_cartesian_product +import argparse + + +def im_para_eqhmm(pi_0_lsim, lsim_gmm_para, coupling_theta_convex_comb, transition_matrices_convex_comb): + """ + Generate equivalent HMM parameters from LSIM parameters and CHMM. + + Parameters: + pi_0_lsim : list of np.array + Initial state probability distributions for each channel in the LSIM. + lsim_gmm_para : list of dict + GMM parameters for each state in the LSIM. + coupling_theta_convex_comb : np.array + Coupling coefficients for the convex combination model. + transition_matrices_convex_comb : list of list of np.array + Transition matrices for the convex combination model. + + Returns: + pi_0_ehmm : list of np.array + Initial state probability distribution for the equivalent HMM. + coupling_theta_ehmm : int + Coupling coefficient for the equivalent HMM. + transition_ehmm : list of np.array + Transition probability matrix for the equivalent HMM. + ehmm_gmm_para : list of dict + GMM parameters for the equivalent HMM. + index_matrix : np.array + Mapping from CHMM states to equivalent HMM states. + pi_0_chmm : list of np.array + Initial state probability distributions for the CHMM. + transition_chmm : list of np.array + Transition matrices for the CHMM. + chmm_gmm_para : list of dict + GMM parameters for the CHMM. + + Revision History: + August 2024: Translated to Python from Matlab (im_para_eqhmm.m) + + Muhammad Ubadah Tanveer, 2024 + The Open-Source Electrophysiological Toolbox + https://github.com/alphanumericslab/OSET + + """ + C = len(pi_0_lsim) + channel_num_states = np.zeros(C, dtype=int) + + for c in range(C): + channel_num_states[c] = len(pi_0_lsim[c]) + + # Indexing of Cartesian product + index_matrix = np.zeros((C, np.prod(channel_num_states)), dtype=int) + + for i in range(C): + temp_index = channel_num_states.copy() + temp_index[:i] = [] + temp_raw = np.kron(np.arange(1, channel_num_states[i] + 1), np.ones(int(np.prod(temp_index)))) + temp_index = channel_num_states.copy() + temp_index[i:] = [] + index_matrix[i, :] = np.tile(temp_raw, int(np.prod(temp_index))) + + weight_state_column = np.cumprod(channel_num_states[::-1][1:]) + weight_state_column = np.concatenate(([1], weight_state_column))[::-1] + + # Generate CHMM transition matrices + transition_chmm = [] + temp_var = np.zeros(C) + + for zee in range(C): + transition_chmm_zee = np.zeros((np.prod(channel_num_states), channel_num_states[zee])) + + for i in range(channel_num_states[zee]): + for j in range(index_matrix.shape[1]): + column_number_matrix_j = np.dot(weight_state_column, (index_matrix[:, j] - 1)) + 1 + + for c in range(C): + temp_var[c] = transition_matrices_convex_comb[c][zee][index_matrix[c, j] - 1, i] + + transition_chmm_zee[column_number_matrix_j - 1, i] = np.dot(coupling_theta_convex_comb[:, zee], temp_var) + + transition_chmm.append(transition_chmm_zee) + + pi_0_chmm = pi_0_lsim.copy() + chmm_gmm_para = lsim_gmm_para.copy() + + # Generating equivalent HMM parameters to perform exact inference + pi_0_ehmm, coupling_theta_ehmm, transition_ehmm, ehmm_gmm_para = chmm_cartesian_product( + pi_0_chmm, transition_chmm, chmm_gmm_para + ) + + return pi_0_ehmm, coupling_theta_ehmm, transition_ehmm, ehmm_gmm_para, index_matrix, pi_0_chmm, transition_chmm, chmm_gmm_para + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description=""" + Interval Markov (IM) to Equivalent Hidden Markov Model (EHMM) conversion. + Converts an IM model with multiple channels to an equivalent single-channel HMM. + + Parameters: + pi_0_lsim (list): Initial state probabilities for each channel in the IM model. + transition_matrices_convex_comb (list): Transition matrices for each channel in the IM model. + coupling_theta_convex_comb (ndarray): Coupling matrix between channels. + lsim_gmm_para (list): GMM parameters for each state in the IM model. + + Returns: + tuple: A tuple containing: + pi_0_ehmm (ndarray): Initial state probabilities for EHMM. + coupling_theta_ehmm (ndarray): Coupling matrix for EHMM. + transition_ehmm (ndarray): Transition matrix for EHMM. + ehmm_gmm_para (list): GMM parameters for EHMM. + index_matrix (ndarray): Mapping between IM and EHMM states. + pi_0_chmm (list): Initial state probabilities for intermediate CHMM. + transition_chmm (list): Transition matrices for intermediate CHMM. + chmm_gmm_para (list): GMM parameters for intermediate CHMM. + + Revision History: + August 2024: Implemented in Python based on MATLAB implementation. + """, + formatter_class=argparse.RawTextHelpFormatter, + ) + args = parser.parse_args() \ No newline at end of file