From 38ed3f0f8df8938fe067b4674952946311fe64d2 Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Wed, 1 Mar 2023 11:58:48 +0100 Subject: [PATCH 01/13] first version of enhanced sampling with example --- .gitignore | 1 + enhanced_sampling/EnhancedSampling.py | 628 ++++++++++++++++++ enhanced_sampling/__init__.py | 0 misc/notebooks/EnhancedSamplingExample.ipynb | 656 +++++++++++++++++++ 4 files changed, 1285 insertions(+) create mode 100644 enhanced_sampling/EnhancedSampling.py create mode 100644 enhanced_sampling/__init__.py create mode 100644 misc/notebooks/EnhancedSamplingExample.ipynb diff --git a/.gitignore b/.gitignore index 2f4ce0f..573b49c 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,4 @@ env/ misc/notebooks/Figs_august/* misc/notebooks/Figures/* QLMtools/package_installer.py +build/ diff --git a/enhanced_sampling/EnhancedSampling.py b/enhanced_sampling/EnhancedSampling.py new file mode 100644 index 0000000..6369a86 --- /dev/null +++ b/enhanced_sampling/EnhancedSampling.py @@ -0,0 +1,628 @@ +""" +Enhanced sampling module. +""" +from qiskit.opflow.primitive_ops import PauliSumOp +from qiskit.circuit import QuantumCircuit +from qiskit.quantum_info import Pauli + +from qiskit.opflow import MatrixOp, StateFn, PauliExpectation, PrimitiveOp, PauliOp +from qiskit.opflow.state_fns import CircuitStateFn +from qiskit.opflow.converters import CircuitSampler + +import numpy as np +import scipy +import matplotlib.pyplot as plt +import collections +import functools +from scipy.optimize import curve_fit + +from typing import Optional, Tuple, Dict +import time +from random import random, seed +from math import pi + +class EnhancedSampler(): + """ + The class used for enhanced sampling. + """ + + def __init__( + self, + Hamiltonian: PauliSumOp, + Layers: int, + ansatz, + x_angles: Optional[np.ndarray] = None, + binning_range: Tuple[float, float] = (-1, 1), + binning_points: int = 10000, + ) -> None: + """ + Initialize the Enhanced sampling module. + + Args: + Hamiltonian: the Hamiltonian to sample. + Layers: the layers of the circuit to use to sample. + ansatz: the ansatz to use. + x_angles: the initial angles for the ansatz. + binning_range: the range for the binning arrays. + binning_points: the number of points in the binning arrays. + """ + # Make circuits + self._hamiltonian = Hamiltonian + self._num_qubits = Hamiltonian.num_qubits + print('num qubits',self._num_qubits) + self._layers = Layers + if ansatz.num_parameters == 0: + self._ansatz = ansatz + else: + print("Ansatz with parameters not set, setting it random") + seed(44) + angles_set = {par: random()*2*pi for par in ansatz.ordered_parameters} + print(angles_set) + self._ansatz = ansatz.bind_parameters(angles_set) + + self._binning_points = binning_points + self._x_angles = x_angles or np.ones(2 * Layers) * np.pi / 2 + + binning_start, binning_end = binning_range + self._binning = np.linspace(binning_start, binning_end, self._binning_points) + self._binning_theta = np.linspace(0, np.pi, self._binning_points) + + def eval(self, + pre_energy_freq: Dict[str, Dict[int, Dict[int, float]]], + std_dev_freq: Dict[str, Dict[int, Dict[int, float]]], + q_instance_post, + repetitions: int = 1, + steps: int = 1, + steps_pre: int = 1, + ) -> Tuple[Dict[str, Dict[int, Dict[int, float]]], Dict[str, Dict[int, Dict[int, float]]]]: + # Save the standard x angles and layers + standard_x_angles = self._x_angles + standard_layers = self._layers + # Create empty dictionaries for the likelihood, fitted energy, and fitted variance + likelihood = {} + fit_energy = {} + fit_variance = {} + + # Loop through each part of the Hamiltonian + for H_part in self._hamiltonian.to_pauli_op(): + # Convert the Hamiltonian part to a string + primitive = str(H_part) + print("\n\nSampling for", primitive, "...") + # Create empty dictionaries for the fitted energy and variance for this Hamiltonian part + fit_energy[primitive] = {} + fit_variance[primitive] = {} + for step in range(steps): + fit_energy[primitive][step] = {} + fit_variance[primitive][step] = {} + + # Reset the x angles and layers to the standard values + self._x_angles = standard_x_angles + self._layers = standard_layers + + # Loop through each repetition, useful for averaging plots, but not really necessary in practice + + for rep in range(repetitions): + # Convert the pre-sampled energy frequency and standard deviation frequency to Theta + start_time = time.time() + self.convert_to_Theta(pre_energy_freq[primitive][steps_pre - 1][rep], + std_dev_freq[primitive][steps_pre - 1][rep]) + + # Compute the likelihood and Fisher information for the initial theta values + if rep == 0: + likelihood_0, likelihood_1, ket_A = self._compute_likelihood(H_part) + + f_info_A = self.FischerInfo(self._initial_theta, ket_A) + + + + # Check if using 1 layer less results in a higher Fisher information + if self._layers > 1: + self._layers -= 1 + self._x_angles = self._x_angles[:-2] + if rep == 0: # only compute likelihood if it hasn't been computed yet + likelihood_0_B, likelihood_1_B, ket_B = self._compute_likelihood(H_part) + f_info_B = self.FischerInfo(self._initial_theta, ket_B) + + # Use the alternative circuit if it results in a higher Fisher information + if f_info_A >= f_info_B: + self._layers = standard_layers + self._x_angles = standard_x_angles + likelihood[0] = likelihood_0 + likelihood[1] = likelihood_1 + else: + print(' use alternative circuit') + likelihood[0] = likelihood_0_B + likelihood[1] = likelihood_1_B + else: + likelihood[0] = likelihood_0 + likelihood[1] = likelihood_1 + + # Create the enhanced sampling circuit + circuit = self.make_enhanced_circuit(H_part) # TODO: check if it can be moved outside the loop + end_time = time.time() + print('Time pre-sampling:', end_time - start_time) + # Initialize the outcomes dictionary + outcomes = {0: 0, 1: 0} + # Loop through each step + start_time = time.time() + for step in range(steps): + # Sample from the enhanced sampling circuit and update the outcomes + # at each step new outcomes are added to the dictionary + sampler_enhanced = CircuitSampler(backend=q_instance_post, attach_results=True).convert(circuit) + outcomes = self.collect_events(sampler_enhanced, outcomes) + # Compute the fitted energy and variance for this step + energy, variance = self.compute_posterior(outcomes, likelihood) + fit_energy[primitive][step][rep] = energy + fit_variance[primitive][step][rep] = variance + # Divide the fitted energy and variance by the number of repetitions + # for step in range(steps): + # fit_energy[primitive][step] /= repetitions + # fit_variance[primitive][step] /= repetitions + end_time = time.time() + print('Time sampling:', end_time - start_time) + + # Return the fitted energy and variance dictionaries + return fit_energy, fit_variance + + def make_enhanced_circuit(self, Pauli_H): + # Get the inverse of the ansatz + ansz_inverse = self._ansatz.inverse() + # Set the phase flip operator + flip_op = -np.identity(2 ** self._num_qubits) + flip_op[0, 0] = 1 + phase_flip_op = MatrixOp(flip_op) + + # Initialize quantum circuit + list_of_qubits = list(range(self._num_qubits)) + circuit = QuantumCircuit(self._num_qubits) + circuit.append(self._ansatz, list_of_qubits) + + # Add U and V gates to the circuit with angles bound + for i, x in enumerate(self._x_angles): + if i % 2 == 0: # add U gate + U_gate = (x * Pauli_H).exp_i().to_matrix() + circuit.append(MatrixOp(U_gate), list_of_qubits) + elif i % 2 == 1: # add V gate + R0_gate = (x * phase_flip_op).exp_i().to_matrix() + circuit.append(ansz_inverse, list_of_qubits) + circuit.append(MatrixOp(R0_gate), list_of_qubits) + circuit.append(self._ansatz, list_of_qubits) + + # Compute the projection operator for the Hamiltonian + proj_H_m = (PauliOp(Pauli('I' * self._num_qubits), coeff=1.0) - Pauli_H) / 2 + + # Compose the circuit with the projection operator + complete_circuit_m = StateFn(proj_H_m, is_measurement=True).compose(CircuitStateFn(primitive=circuit)) + + # Compute the expectation value using the Pauli expectation + expectation_m = PauliExpectation().convert(complete_circuit_m) + + # Return the expectation value + return expectation_m + + def compute_posterior(self, outcomes, likelihood): + # Compute the posterior distribution for theta + print("\n\n NEW FIT") + def get_posterior(likelihood, f_prior): + estimate = sum(likelihood * f_prior) + return (likelihood * f_prior) / estimate + + prior_theta = self._initial_prior_theta + outcomes0 = outcomes[0] + outcomes1 = outcomes[1] + for _ in range(outcomes[0]+outcomes[1]): + for outcome in [0,1]: + if outcome == 0 and outcomes0 > 0: + outcomes0-=1 + prior_theta = get_posterior(likelihood[outcome], prior_theta) + elif outcome == 1 and outcomes1 > 0: + prior_theta = get_posterior(likelihood[outcome], prior_theta) + outcomes1-=1 + + + # for state, samples in outcomes.items(): #state can be 0 or 1, samples is the number of times 0 or 1 was measured + # for _ in range(samples): # update the prior_theta for each sample, + # prior_theta = get_posterior(likelihood[state], prior_theta) + + self._final_prior_theta = prior_theta + + # Guesses for the fit on the theta distribution + total_counts = sum(prior_theta) + mean_guess = sum(self._restricted_binning_theta * prior_theta) / total_counts + std_dev_guess = np.sqrt(abs(sum(prior_theta * (self._restricted_binning_theta - mean_guess) ** 2) / total_counts)) + + # Define the Gaussian function + def gaussian_function(x, amplitude, mean, std_dev): + return amplitude * np.exp(-(x - mean) ** 2 / (2 * std_dev ** 2)) + + # Set dynamic initial guess for amplitude + amplitude_guess = np.max(prior_theta) + + + + print('Outcomes:', outcomes) + if False: + plt.plot(self._restricted_binning_theta, self._initial_prior_theta, label='initial prior') + plt.plot(self._restricted_binning_theta, self._final_prior_theta, label='final prior') + # plt.plot(self._restricted_binning_theta, likelihood[0], label='likelihood 0 with n outcomes'+str(outcomes[0])) + # plt.plot(self._restricted_binning_theta, likelihood[1], label='likelihood 1 with n outcomes'+str(outcomes[1])) + plt.legend() + plt.show() + # which is the same as + + + + print("Guesses: amp, mean and std_dev:",amplitude_guess, mean_guess, std_dev_guess) + + + # Fit the theta distribution to a Gaussian + try: + popt, _ = curve_fit(gaussian_function, + self._restricted_binning_theta, + prior_theta, + p0=[amplitude_guess, mean_guess, std_dev_guess]) + _, theta_fit, sigma_fit = popt + print('FIT SUCCESS: Converged with popt:', popt) + except RuntimeError: + # plot the prior_theta + print('\033[91m' + 'FIT ERROR: Failde to converge' + '\033[0m') # to make it red, use + plt.plot(self._restricted_binning_theta, self._initial_prior_theta, label='initial prior') + plt.plot(self._restricted_binning_theta, self._final_prior_theta, label='final prior') + plt.legend() + plt.show() + + theta_fit, sigma_fit = mean_guess, std_dev_guess + + + # self._theta_fit = theta_fit + # self._sigma_fit = sigma_fit + + # Convert the fitted theta values to energy + fit_energy, fit_variance = self._convert_to_energy(theta_fit, sigma_fit) + + return fit_energy, fit_variance + + def _convert_to_energy(self, mu, sigma): + # Convert the mean and standard deviation of the theta distribution to energy + energy = np.exp((-sigma ** 2) / 2) * np.cos(mu) + variance = (1 - np.exp(-sigma ** 2)) * (1 - np.exp(-sigma ** 2) * np.cos(2 * mu)) / 2 + return energy, variance + + def convert_to_Theta(self, initial_mean, initial_std_dev) -> None: + # Compute initial distribution and sample from it + initial_distribution = scipy.stats.norm.pdf(self._binning, initial_mean, initial_std_dev) + s = np.arccos(np.random.normal(initial_mean, initial_std_dev, self._binning_points * 100)) + + # Compute initial prior for theta + (initial_theta, initial_sigma) = scipy.stats.norm.fit([x for x in s if str(x) != 'nan']) + if initial_sigma ** 2 > 0.01: + print("WARNING: Large variance") + initial_prior = scipy.stats.norm.pdf(self._binning_theta, initial_theta, initial_sigma) + # limit the initial prior to the region of interest, i.e. from - 4 sigma to + 4 sigma + self._binning_bounds = [np.argmax(initial_prior) - 4 * int(initial_sigma * self._binning_points), np.argmax(initial_prior) + 4 * int(initial_sigma * self._binning_points)] + print("Initial prior bounds:", self._binning_bounds) + initial_prior = initial_prior[self._binning_bounds[0]:self._binning_bounds[1]] + initial_prior /= sum(initial_prior) + self._restricted_binning_theta = self._binning_theta[self._binning_bounds[0]:self._binning_bounds[1]] + # Save results to class variables + self._sampling = s + self._initial_distribution = initial_distribution + self._initial_prior_theta = initial_prior + self._initial_theta = initial_theta + self._initial_sigma = initial_sigma + + return + + def _plot_initial_distribution(self) -> None: + # Plot the initial distribution + plt.title('Distribution on -1,1 values') + plt.plot(self._binning, self._initial_distribution) + + # Plot the sampling from the distribution + plt.figure() + count, bins, ignored = plt.hist(self._sampling, 1000, density=True) + plt.title('Conversion to Theta, sampling from distribution') + plt.plot(bins, 1 / (self._initial_sigma * np.sqrt(2 * np.pi)) + * np.exp(- (bins - self._initial_theta)**2 / (2 * self._initial_sigma**2)), + linewidth=2, color='r') + plt.show() + return + + def collect_events(self, sampler, outcomes_dict): + # Collect measurement outcomes from a CircuitSampler + operator_in_use = sampler.oplist[0] + events = sampler.oplist[1].execution_results['counts'].items() + + for key, item in events: + # Get the binary value corresponding to the outcome + binary_value = bin(int(key, 16))[2:].zfill(self._num_qubits) + + # Evaluate the operator on the binary value to determine the state + state = np.real(operator_in_use.eval(binary_value)) + outcomes_dict[state] += item + print("Outcomes",outcomes_dict) + return outcomes_dict + + def _redefineBasis(self, Pauli_H): + # Compute the A state + ket_A = CircuitStateFn(primitive=self._ansatz).to_matrix() + ket_A = ket_A.reshape((len(ket_A), 1)) + bra_A = ket_A.conjugate().transpose() + + # Compute the projection of Pauli_H onto the A state + bra_A_P_ket_A = (bra_A @ Pauli_H.to_matrix() @ ket_A).item() + P_ket_A = Pauli_H.to_matrix() @ ket_A + + # Define state orthogonal to |A> + ket_A_ort = (P_ket_A - (bra_A_P_ket_A * ket_A)) / np.sqrt(1 - bra_A_P_ket_A ** 2) + bra_A_ort = ket_A_ort.conjugate().transpose() + + # Redefine Pauli operators in new basis where |A> and |A_ort> are the basis states + self._new_sigma_z = PrimitiveOp(ket_A.dot(bra_A) - ket_A_ort.dot(bra_A_ort)) + self._new_sigma_x = PrimitiveOp(ket_A.dot(bra_A_ort) + ket_A_ort.dot(bra_A)) + self._new_sigma_y = PrimitiveOp(-1j * ket_A.dot(bra_A_ort) + 1j * ket_A_ort.dot(bra_A)) + self._new_identity = PrimitiveOp(ket_A.dot(bra_A) + ket_A_ort.dot(bra_A_ort)) # Trivial operator + + return ket_A, ket_A_ort + + def _updateGateArray(self, theta_angle): + gate_array = {} + gate_array_derivative = {} + + x_angles = self._x_angles + num_layers = self._layers + + for i in range(num_layers): + gate_array[2 * i] = self._new_U(theta_angle, -x_angles[2 * i]).to_matrix() # U^+ + gate_array[2 * i + 1] = self._new_V(-x_angles[2 * i + 1]).to_matrix() # V^+ + gate_array[4 * num_layers - 2 * i - 1] = self._new_V(x_angles[2 * i + 1]).to_matrix() # V + gate_array[4 * num_layers - 2 * i] = self._new_U(theta_angle, x_angles[2 * i]).to_matrix() # U + + gate_array_derivative[2 * i] = self._new_U_prime(theta_angle, -x_angles[2 * i]).to_matrix() # U^+ derivative + gate_array_derivative[2 * i + 1] = np.zeros((2 * self._num_qubits, 2 * self._num_qubits)) # V^+ derivative + gate_array_derivative[4 * num_layers - 2 * i - 1] = np.zeros((2 * self._num_qubits, 2 * self._num_qubits)) # V deriv + gate_array_derivative[4 * num_layers - 2 * i] = self._new_U_prime(theta_angle, x_angles[2 * i]).to_matrix() # U deriv + + gate_array[2 * num_layers] = self._new_P(theta_angle).to_matrix() + gate_array_derivative[2 * num_layers] = self._new_P_prime(theta_angle).to_matrix() # P derivative + + ord_gate_array = collections.OrderedDict(sorted(gate_array.items())) + ord_gate_array_derivative = collections.OrderedDict(sorted(gate_array_derivative.items())) + + return ord_gate_array, ord_gate_array_derivative + + def _get_bias(self, theta_angle, ket_state): + bra_state = ket_state.conjugate().transpose() + GateArrays, _ = self._updateGateArray(theta_angle) + return (bra_state @ functools.reduce(np.dot, GateArrays.values()) @ ket_state).item() + + def _likelihood(self, d, lambda_i, ket_A): + delta = np.real(self._get_bias(lambda_i, ket_A)) + return (1. + (-1.)**d * delta) / 2. + + def FischerInfo(self, theta_angle, ket_A): + GateArray, GateArray_Derivative = self._updateGateArray(theta_angle) + + sum_delta = 0 + sum_delta_p = 0 + x_angles = self._x_angles + len_angles = len(x_angles) + L = self._layers + + for i, x in enumerate(x_angles): + j = i + 1 + if j % 2 == 0: + t = int(j / 2 - 1) + # print('even case, j=', j, ' t=', t, ' x=', x) + C, S, B = self._computeCSBeven(GateArray, self._new_sigma_z, ket_A, t, L) + Cp, Sp, Bp = self._computeDerCSBeven(GateArray, GateArray_Derivative, self._new_sigma_z, ket_A, t, L) + else: + t = int((j - 1) / 2) + # print('odd case, j=', j, ' t=', t, ' x=', x) + P = GateArray[2 * L] + C, S, B = self._computeCSBodd(GateArray, P, ket_A, t, L) + Cp, Sp, Bp = self._computeDerCSBodd(GateArray, GateArray_Derivative, P, ket_A, t, L) + # print('C,S,B', C, S, B) + # print('Cp,Bp', Cp, Bp) + + delta = np.real(C * np.cos(2 * x) + S * np.sin(2 * x) + B) + delta_p = np.real(Cp * np.cos(2 * x) + Sp * np.sin(2 * x) + Bp) + + sum_delta += delta + sum_delta_p += delta_p + + sum_delta /= len_angles + sum_delta_p /= len_angles + + return self._get_fisher_info(sum_delta, sum_delta_p) + + def _compute_likelihood(self, Pauli_H): + # redefine the basis + ket_A, _ = self._redefineBasis(Pauli_H) + + # create the binning points for theta + binning_theta = np.linspace(0, np.pi, self._binning_points) + # select the binning point for theta using [self._binning_bounds[0]:self._binning_bounds[1]] + binning_theta = binning_theta[self._binning_bounds[0]:self._binning_bounds[1]] + + # compute likelihood for outcome 0 and 1 + likelihood_0 = [self._likelihood(0, lambda_i, ket_A) for lambda_i in binning_theta] + likelihood_1 = [self._likelihood(1, lambda_i, ket_A) for lambda_i in binning_theta] + + # compute Fisher information (not being used for now) + # fisher_information = [self.FischerInfo(lambda_i, ket_A) for lambda_i in binning_theta] + + return likelihood_0, likelihood_1, ket_A + + def _new_P(self, theta): + # redefinition of Pauli-Z and Pauli-X in the new basis + return np.cos(theta) * self._new_sigma_z + np.sin(theta) * self._new_sigma_x + + def _new_U(self, theta, x): + # redefinition of U(theta) gate in the new basis + identity = PrimitiveOp(np.identity(2 ** self._num_qubits)) + return np.cos(x) * identity - 1j * np.sin(x) * self._new_P(theta) + + def _new_V(self, x): + # redefinition of V gate in the new basis + identity = PrimitiveOp(np.identity(2 ** self._num_qubits)) + return np.cos(x) * identity - 1j * np.sin(x) * self._new_sigma_z + + # Derivative redefinition + def _new_P_prime(self, theta): + # redefinition of Pauli-Z derivative in the new basis + return -np.sin(theta) * self._new_sigma_z + np.cos(theta) * self._new_sigma_x + + def _new_U_prime(self, theta, x): + # redefinition of U(theta) derivative in the new basis + return -1j * np.sin(x) * self._new_P_prime(theta) + + # ***************************************** + # FISHER-INFORMATION + # ***************************************** + def _P_ab(self, a, b, L, GateArray): + if 0 <= a <= b <= 4 * L: + temp = [GateArray[g] for g in list(range(a, b + 1))] + if len(temp) > 1: + return functools.reduce(np.dot, temp) + else: + return temp[0] + else: + size = int(np.sqrt(GateArray[2 * L].size)) + return np.identity(size) + + def _computeCSBeven(self, GateArr, Z, ket_state, t, L): + bra_state = ket_state.conjugate().transpose() + # ket_state = ket_state.to_matrix() + Z = Z.to_matrix() + a = self._P_ab(0, 2 * t, L, GateArr) + b = self._P_ab(2 * t + 2, 4 * L - 2 * t - 2, L, GateArr) + c = self._P_ab(4 * L - 2 * t, 4 * L, L, GateArr) + # print('Z',Z) + # print('a,b,c','\n',a,'\n',b,'\n',c) + coreC = b - (Z @ b @ Z) # .to_matrix() + coreS = (b @ Z) - (b @ Z) # .to_matrix() + coreB = b + (Z @ b @ Z) # .to_matrix() + # print('c,s,b','\n',coreC,'\n',coreS,'\n',coreB) + # print('bra',bra_state) + C = 1 / 2 * (bra_state @ a @ coreC @ c @ ket_state) + S = -1j / 2 * (bra_state @ a @ coreS @ c @ ket_state) + B = 1 / 2 * (bra_state @ a @ coreB @ c @ ket_state) + return C.item(), S.item(), B.item() + + def _computeCSBodd(self, GateArr, P, ket_state, t, L): + bra_state = ket_state.conjugate().transpose() + a = self._P_ab(0, 2 * t - 1, L, GateArr) + b = self._P_ab(2 * t + 1, 4 * L - 2 * t - 1, L, GateArr) + c = self._P_ab(4 * L - 2 * t + 1, 4 * L, L, GateArr) + coreC = b - (P @ b @ P) # CHECK if @ works as .dot() + coreS = (b @ P) - (b @ P) + coreB = b + (P @ b @ P) + C = 1 / 2 * (bra_state @ a @ coreC @ c @ ket_state) + S = -1j / 2 * (bra_state @ a @ coreS @ c @ ket_state) + B = 1 / 2 * (bra_state @ a @ coreB @ c @ ket_state) + return C.item(), S.item(), B.item() + + def _computeDerABCeven(self, GateArr, GateArrDer, t, L): + size = int(np.sqrt(GateArr[2 * L].size)) # get the size from a matrix + A1 = self._P_ab(0, 2 * t, L, GateArr) + B1 = self._P_ab(2 * t + 2, 4 * L - 2 * t - 2, L, GateArr) + C1 = sum([self._P_ab(4 * L - 2 * t, 4 * L - 2 * k - 1, L, GateArr) + @ GateArrDer[4 * L - 2 * k] + @ self._P_ab(4 * L - 2 * k + 1, 4 * L, L, GateArr) + for k in range(0, t + 1)]) + + A2 = A1 + B2 = sum([self._P_ab(2 * t + 2, 4 * L - 2 * k - 1, L, GateArr) + @ GateArrDer[4 * L - 2 * k] + @ self._P_ab(4 * L - 2 * k + 1, 4 * L - 2 * t - 2, L, GateArr) + for k in range(t + 1, L)]) + if isinstance(B2, int): + if B2 == 0: + B2 = np.zeros((size, size)) + C2 = self._P_ab(4 * L - 2 * t, 4 * L, L, GateArr) + + A3 = A1 + B3 = self._P_ab(2 * t + 2, 2 * L - 1, L, GateArr)\ + @ GateArrDer[2 * L] \ + @ self._P_ab(2 * L + 1, 4 * L - 2 * t - 2, L, GateArr) + C3 = C2 + return A1, B1, C1, A2, B2, C2, A3, B3, C3 + + def _computeDerABCodd(self, GateArr, GateArrDer, t, L): + size = int(np.sqrt(GateArr[2 * L].size)) # get the size from a matrix + A1 = self._P_ab(0, 2 * t - 1, L, GateArr) + B1 = self._P_ab(2 * t + 1, 4 * L - 2 * t - 1, L, GateArr) + C1 = sum([self._P_ab(4 * L - 2 * t + 1, 4 * L - 2 * k - 1, L, GateArr) + @ GateArrDer[4 * L - 2 * k] + @ self._P_ab(4 * L - 2 * k + 1, 4 * L, L, GateArr) + for k in range(0, t)]) + if isinstance(C1, int): + if C1 == 0: + C1 = np.zeros((size, size)) + + A2 = A1 + B2 = B1 + C2 = self._P_ab(4 * L - 2 * t + 1, 4 * L, L, GateArr) + + A3 = A1 + B3 = sum([self._P_ab(2 * t + 1, 4 * L - 2 * k - 1, L, GateArr) + @ GateArrDer[4 * L - 2 * k] + @ self._P_ab(4 * L - 2 * k + 1, 4 * L - 2 * t - 1, L, GateArr) + for k in range(t + 1, L)]) + if isinstance(B3, int): + if B3 == 0: + B3 = np.zeros((size, size)) + C3 = C2 + A4 = A1 + B4 = self._P_ab(2 * t + 1, 2 * L - 1, L, GateArr)\ + @ GateArrDer[2 * L] \ + @ self._P_ab(2 * L + 1, 4 * L - 2 * t - 1, L, GateArr) + C4 = C2 + return A1, B1, C1, A2, B2, C2, A3, B3, C3, A4, B4, C4 + + def _computeDerCSBeven(self, GateArr, GateArrDer, Z, ket_state, t, L): + bra_state = ket_state.conjugate().transpose() + Z = Z.to_matrix() + A1, B1, C1, A2, B2, C2, A3, B3, C3 = self._computeDerABCeven(GateArr, GateArrDer, t, L) + # print('even A1,B1,C1,A2,B2,C2,A3,B3,C3:\n',A1,'\n',B1,'\n',C1,'\n',A2,'\n',B2,'\n',C2,'\n',A3,'\n',B3,'\n',C3) + C_prime = np.real(bra_state @ A1 @ (B1 - (Z @ B1 @ Z)) @ C1 @ ket_state) + \ + np.real(bra_state @ A2 @ (B2 - (Z @ B2 @ Z)) @ C2 @ ket_state) + \ + 1 / 2 * (bra_state @ A3 @ (B3 - (Z @ B3 @ Z)) @ C3 @ ket_state) + + S_prime = np.imag(bra_state @ A1 @ ((B1 @ Z) - (Z @ B1)) @ C1 @ ket_state) + \ + np.imag(bra_state @ A2 @ ((B2 @ Z) - (Z @ B2)) @ C2 @ ket_state) - \ + 1j / 2 * (bra_state @ A3 @ ((B3 @ Z) - (Z @ B3)) @ C3 @ ket_state) + + B_prime = np.real(bra_state @ A1 @ (B1 + (Z @ B1 @ Z)) @ C1 @ ket_state) + \ + np.real(bra_state @ A2 @ (B2 + (Z @ B2 @ Z)) @ C2 @ ket_state) + \ + 1 / 2 * (bra_state @ A3 @ (B3 + (Z @ B3 @ Z)) @ C3 @ ket_state) + return C_prime.item(), S_prime.item(), B_prime.item() + + def _computeDerCSBodd(self, GateArr, GateArrDer, P, ket_state, t, L): + bra_state = ket_state.conjugate().transpose() + P_prime = GateArrDer[2 * L] + A1, B1, C1, A2, B2, C2, A3, B3, C3, A4, B4, C4 = self._computeDerABCodd(GateArr,GateArrDer,t,L) + #print('odd A1,B1,C1,A2,B2,C2,A3,B3,C3,A4,B4,C4:\n',A1,'\n',B1,'\n',C1,'\n',A2,'\n',B2,'\n',C2,'\n',A3,'\n',B3,'\n',C3,'\n',A4,'\n',B4,'\n',C4) + C_prime = np.real(bra_state @ A1 @ (B1 - (P @ B1 @ P)) @ C1 @ ket_state) - \ + np.real(bra_state @ A2 @ P @ B2 @ P_prime @ C2 @ ket_state) + \ + np.real(bra_state @ A3 @ (B3 - (P @ B3 @ P)) @ C3 @ ket_state) + \ + 1 / 2 * (bra_state @ A4 @ (B4 - (P @ B4 @ P)) @ C4 @ ket_state) + + S_prime = np.imag(bra_state @ A1 @ ((B1 @ P) - (P @ B1)) @ C1 @ ket_state) + \ + np.imag(bra_state @ A2 @ B2 @ P_prime @ C2 @ ket_state) + \ + np.imag(bra_state @ A3 @ ((B3 @ P) - (P @ B3)) @ C3 @ ket_state) - \ + 1j / 2 * (bra_state @ ( A4 @ ((B4 @ P) - (P @ B4)) @ C4) @ ket_state) + + B_prime = np.real(bra_state @ A1 @ (B1 + (P @ B1 @ P)) @ C1 @ ket_state) + \ + np.real(bra_state @ A2 @ P @ B2 @ P_prime @ C2 @ ket_state) + \ + np.real(bra_state @ A3 @ (B3 + (P @ B3 @ P)) @ C3 @ ket_state) + \ + 1/2*(bra_state @ A4 @ (B4 + (P @ B4 @ P)) @ C4 @ ket_state) + + return C_prime.item(), S_prime.item(), B_prime.item() + + def _get_fisher_info(self, delta, delta_p, f = 0.99): + num = f ** 2 * delta_p ** 2 + den = 1 - f ** 2 * delta ** 2 + return num / den + \ No newline at end of file diff --git a/enhanced_sampling/__init__.py b/enhanced_sampling/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/misc/notebooks/EnhancedSamplingExample.ipynb b/misc/notebooks/EnhancedSamplingExample.ipynb new file mode 100644 index 0000000..4987daa --- /dev/null +++ b/misc/notebooks/EnhancedSamplingExample.ipynb @@ -0,0 +1,656 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.18.2\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from qiskit.opflow import StateFn, PauliExpectation, Zero, One,Z,X,I,PauliOp,ListOp, AerPauliExpectation,DictStateFn,MatrixOp,PrimitiveOp, MatrixExpectation,ComposedOp\n", + "from qiskit.circuit.library import TwoLocal,EfficientSU2,UGate\n", + "from qiskit.opflow.state_fns import CircuitStateFn\n", + "from qiskit.opflow.converters import CircuitSampler\n", + "from qiskit import Aer\n", + "from qiskit.utils.quantum_instance import QuantumInstance\n", + "from qiskit.test.mock import FakeMontreal\n", + "from qiskit.providers.aer.noise import NoiseModel\n", + "\n", + "import qiskit\n", + "print(qiskit.__version__)\n", + "\n", + "from qiskit.providers.aer.library import SaveExpectationValueVariance\n", + "\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "from qiskit.algorithms import VQE\n", + "from qiskit_nature.converters.second_quantization import QubitConverter\n", + "from qiskit_nature.mappers.second_quantization import JordanWignerMapper\n", + "from qiskit.quantum_info.operators import Operator\n", + "from qiskit.circuit import Parameter\n", + "from qiskit.providers.aer import AerSimulator,QasmSimulator\n", + "\n", + "\n", + "from random import random,seed\n", + "from math import pi\n", + "import matplotlib.pyplot as plt\n", + "plt.rcParams.update({'font.size': 18})\n", + "\n", + "from scipy.optimize import curve_fit\n", + "\n", + "#my functions\n", + "from enhanced_sampling import EnhancedSampling\n", + "\n", + "# import EnhancedSampling\n", + "\n", + "\n", + "def is_unitary(m):\n", + " return np.allclose(np.eye(m.shape[0]), m.H * m)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def update_dict(old_dict, sampler, num_qubits):\n", + " new_dict = old_dict.copy()\n", + " events = sampler.oplist[1].execution_results['counts'].items()\n", + " for key,item in events:\n", + " binary_value = bin(int(key,16))[2:].zfill(num_qubits)\n", + " if binary_value not in new_dict.keys():\n", + " new_dict[binary_value]=item\n", + " else:\n", + " new_dict[binary_value]+=item \n", + " return new_dict\n", + "def get_amplitudes(old_dict,num_shot):\n", + " new_dict = {}\n", + " for key,item in old_dict.items():\n", + " new_dict[key]= np.sqrt(item/num_shot)\n", + " return new_dict\n", + "def get_RMSE(results, true_value):\n", + " return np.sqrt(sum([(mu-true_value)**2 for mu in results.values()])/len(results))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0 * ZZZ\n", + "+ 1.0 * XII\n", + "+ 1.0 * IXI\n" + ] + } + ], + "source": [ + "#Declare an Hamiltonian\n", + "\n", + "H_first_part = Z ^ Z ^ Z\n", + "H_second_part = (X ^ I ^ I) + (I ^ X ^ I)\n", + "\n", + "#Hamiltonian = (Z ^ Z) +(X ^ I) + (I ^ X)\n", + "\n", + "Hamiltonian = H_first_part + H_second_part \n", + "\n", + "print(Hamiltonian)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Build circuits\n", + "\n", + "We need an ansatz circuit, and operators to measure on it.\n", + "Here we first build the ansatz from EfficientSU(2), define a set of random angles to apply to it.\n", + "Then we create the simple circuit containing the anstaz and the operators to measure (the Hamiltonian parts)\n", + "After that, we combine the anstaz with layers of the enhance circuit using fixed x_angles on these layers (=pi/2) to use Chebyshev-like functions, so we can take multiple samples of the same circuit, instead of modifying after each shot(this would means using ELF)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Define global variables\n", + "num_qubit = Hamiltonian.num_qubits\n", + "Layers = 3 #Layers of enhanced circuit\n", + "\n", + "fixed_x_angles = np.ones(2*Layers)*np.pi/2 # list of pi/2 ,to use CLF insteaf of ELF\n", + "\n", + "useNoise = False\n", + "\n", + "num_preshots=4000\n", + "\n", + "num_postshot=2000\n", + "\n", + "repetitions = 1\n", + "sample_every = 1000\n", + "\n", + "steps_pre = max(1,round(num_preshots/sample_every))\n", + "steps = max(1,round(num_postshot/sample_every))\n", + "\n", + "n_points = 10000 #to use for binning" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Random angles assigned to ansatz {ParameterVectorElement(θ[0]): 2.5669066339875286, ParameterVectorElement(θ[1]): 3.4053105645086, ParameterVectorElement(θ[2]): 5.416335802913373, ParameterVectorElement(θ[3]): 1.1100229798922292, ParameterVectorElement(θ[4]): 1.414718991468211, ParameterVectorElement(θ[5]): 0.1828234342134787, ParameterVectorElement(θ[6]): 0.7329369178028627, ParameterVectorElement(θ[7]): 0.05532737919413898, ParameterVectorElement(θ[8]): 0.9845144111728377, ParameterVectorElement(θ[9]): 3.227755283768095, ParameterVectorElement(θ[10]): 6.2171673160425955, ParameterVectorElement(θ[11]): 4.357453485004286}\n" + ] + } + ], + "source": [ + "seed(44) #44 ok #1 wtf?\n", + "# Ansatz creation\n", + "ansz = EfficientSU2(num_qubit,['ry','rz'],reps=1)\n", + "angles_set = {}\n", + "param = ansz.ordered_parameters\n", + "for j in range(len(param)):\n", + " angles_set[param[j]]= random()*2*pi\n", + "ansz_assigned = ansz.bind_parameters(angles_set)\n", + "\n", + "print(' Random angles assigned to ansatz',angles_set)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num qubits 3\n" + ] + } + ], + "source": [ + "test = EnhancedSampling.EnhancedSampler(Hamiltonian,\n", + " Layers,\n", + " ansz_assigned)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test._ansatz.decompose().draw(output='mpl',filename='EfficientSU2')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of preshots 4000\n", + "Number of postshots 2000\n" + ] + } + ], + "source": [ + "#Backend and Quantum instance\n", + "backend=Aer.get_backend('qasm_simulator')\n", + "#simulator = Aer.get_backend('aer_simulator')\n", + "backend_sv = Aer.get_backend('statevector_simulator')\n", + "\n", + "\n", + "\n", + "device_backend = FakeMontreal()\n", + "device = QasmSimulator.from_backend(device_backend)\n", + "coupling_map = device.configuration().coupling_map\n", + "noise_model = NoiseModel.from_backend(device)\n", + "\n", + "\n", + "\n", + "if useNoise == False: \n", + " noise_model = None\n", + " coupling_map = None\n", + "\n", + "# SET UP INITIAL SAMPLING \n", + "q_instance_pre = QuantumInstance(backend=backend,\n", + " shots=sample_every, #to adapt\n", + " skip_qobj_validation = False,\n", + " coupling_map=coupling_map,\n", + " noise_model=noise_model)\n", + "\n", + "q_instance_post = QuantumInstance(backend=backend,\n", + " shots=sample_every,\n", + " skip_qobj_validation = False,\n", + " coupling_map=coupling_map,\n", + " noise_model=noise_model)\n", + "print('Number of preshots',num_preshots)\n", + "print('Number of postshots',num_postshot)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_variance(exp_op, sfdict):\n", + " def sum_variance(operator,sfdict):\n", + " if isinstance(operator, ComposedOp):\n", + " #sfdict = operator.oplist[1]\n", + " measurement = operator.oplist[0]\n", + " average = measurement.eval(sfdict)\n", + " variance = sum(\n", + " (v * (measurement.eval(b) - average)) ** 2\n", + " for (b, v) in sfdict.items()\n", + " )\n", + " return operator.coeff * variance\n", + "\n", + " elif isinstance(operator, ListOp):\n", + " return operator.combo_fn([sum_variance(op) for op in operator.oplist])\n", + "\n", + " return 0.0\n", + "\n", + " return sum_variance(exp_op,sfdict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Phase 1: Initial pre-sampling (frequentist mode)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def make_simple_circuit(ansatz,P):\n", + " ansz_state = CircuitStateFn(primitive=ansatz)\n", + " complete_circuit = StateFn(P, is_measurement=True).compose(ansz_state) #simple circuit to sample Hamiltonian on ansatz\n", + " expectation = PauliExpectation().convert(complete_circuit) \n", + " exact_exp = AerPauliExpectation().convert(complete_circuit)\n", + " return expectation,exact_exp" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ZZZ\n", + "Exact -0.10785594226944892\n", + "XII\n", + "Exact 0.4504792175806916\n", + "IXI\n", + "Exact 0.06428637695352224\n", + "\n", + "Exact: Energy= 0.40690965226476494\n" + ] + } + ], + "source": [ + "#FREQ\n", + "pre_energy_freq = {}\n", + "std_dev_freq = {}\n", + "variance_freq = {}\n", + "freq_dict = {}\n", + "exact_energy = {}\n", + "exact_expectation ={}\n", + "expectation = {}\n", + "\n", + "\n", + "for H_part in Hamiltonian.to_pauli_op():\n", + " print(H_part)\n", + " primitive = str(H_part)\n", + " freq_dict[primitive] = {}\n", + " variance_freq[primitive] = {}\n", + " std_dev_freq[primitive] = {}\n", + " pre_energy_freq[primitive] = {}\n", + "\n", + " expectation[primitive], exact_expectation= make_simple_circuit(ansz_assigned,H_part)\n", + " for step in range(steps_pre):\n", + " variance_freq[primitive][step] = {}\n", + " std_dev_freq[primitive][step] = {}\n", + " pre_energy_freq[primitive][step] = {}\n", + " for rep in range(repetitions):\n", + " sampler = CircuitSampler(backend=q_instance_pre , attach_results=True).convert(expectation[primitive])\n", + " \n", + " #\n", + " operator_in_use = sampler.oplist[0]\n", + " \n", + " \n", + " if rep not in freq_dict[primitive].keys(): freq_dict[primitive][rep] = {}\n", + " freq_dict[primitive][rep] = update_dict(freq_dict[primitive][rep], sampler, num_qubit)\n", + " ampli_dict = get_amplitudes(freq_dict[primitive][rep],(step+1)*sample_every)\n", + " variance_freq[primitive][step][rep] = np.real(compute_variance(sampler,ampli_dict)/(num_preshots-1))\n", + " std_dev_freq[primitive][step][rep] = np.sqrt(variance_freq[primitive][step][rep])\n", + " # pre_energy_freq[primitive][step][rep] = sampler.eval().real\n", + " pre_energy_freq[primitive][step][rep] = operator_in_use.eval(ampli_dict).real\n", + " #print(operator_in_use.eval(ampli_dict).real,freq_dict[primitive][rep])\n", + " #print(freq_dict)\n", + " # update dictionary of events\n", + " # for key,item in sampler.oplist[1].execution_results['counts'].items():\n", + " # binary_value = bin(int(key,16))[2:].zfill(num_qubit)\n", + " # freq_dict[primitive][binary_value]=item\n", + " # print('\\t outcome:',binary_value,', counts:',item)\n", + "\n", + "\n", + " #EXACT\n", + " sampler_exact = CircuitSampler(backend_sv).convert(exact_expectation)\n", + " exact_energy[primitive] = sampler_exact.eval().real\n", + " print( 'Exact',exact_energy[primitive])\n", + "\n", + "\n", + "\n", + "print('\\nExact: Energy=', sum(exact_energy.values()))\n", + "\n", + "\n", + "#print('Frequ: Energy=',[pre_energy_freq[k].values() for k in pre_energy_freq.keys()])#,', Variance', sum(variance_freq.values()), 'Standard Deviation',sum(std_dev_freq.values()))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " ZZZ freq event presampling \n", + " {'001': 1916, '101': 1181, '010': 108, '111': 19, '011': 150, '000': 350, '110': 99, '100': 177} -0.10999999999999992\n", + "Exact energy = -0.10785594226944892\n", + "Frequentist pre+post: energy ZZZ -0.10333333333333336 \n", + " \tevents {'001': 2864, '101': 1782, '010': 157, '111': 28, '011': 229, '000': 539, '110': 140, '100': 261}\n", + "\n", + " XII freq event presampling \n", + " {'101': 829, '001': 2194, '111': 74, '011': 101, '000': 396, '010': 199, '100': 150, '110': 57} 0.44499999999999995\n", + "Exact energy = 0.4504792175806916\n", + "Frequentist pre+post: energy XII 0.44533333333333325 \n", + " \tevents {'101': 1251, '001': 3309, '111': 127, '011': 149, '000': 608, '010': 270, '100': 206, '110': 80}\n", + "\n", + " IXI freq event presampling \n", + " {'010': 293, '111': 468, '000': 185, '011': 899, '101': 669, '001': 1214, '110': 170, '100': 102} 0.08499999999999995\n", + "Exact energy = 0.06428637695352224\n", + "Frequentist pre+post: energy IXI 0.08066666666666669 \n", + " \tevents {'010': 464, '111': 690, '000': 259, '011': 1345, '101': 1006, '001': 1826, '110': 259, '100': 151}\n" + ] + } + ], + "source": [ + "\n", + "post_energy_freq = {}\n", + "\n", + "for H_part in Hamiltonian.to_pauli_op():\n", + " \n", + " primitive = str(H_part)\n", + " print('\\n',primitive,'freq event presampling \\n',freq_dict[primitive][0] ,pre_energy_freq[primitive][steps_pre-1][0])\n", + " post_energy_freq[primitive] = {}\n", + " #FREQ: combine pre and post sampling\n", + "\n", + " for step in range(steps):\n", + " post_energy_freq[primitive][step] = {}\n", + " \n", + " for rep in range(repetitions):\n", + " sampler_2 = CircuitSampler(backend=q_instance_post, attach_results=True).convert(expectation[primitive])\n", + " freq_dict[primitive][rep] = update_dict(freq_dict[primitive][rep], sampler_2,num_qubit)\n", + " operator_in_use = sampler_2.oplist[0]\n", + " ampli_dict = get_amplitudes(freq_dict[primitive][rep],num_preshots+((step+1)*sample_every))\n", + " post_energy_freq[primitive][step][rep] = operator_in_use.eval(ampli_dict).real\n", + " #print(freq_dict[primitive][0])\n", + " # post_energy_freq[primitive] /= repetitions\n", + "\n", + " print('Exact energy =',exact_energy[primitive])\n", + " print('Frequentist pre+post: energy',primitive,post_energy_freq[primitive][steps-1][0], '\\n \\tevents', freq_dict[primitive][0])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Phase 2: Enhanced sampling vs Frequentist" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Repetition 1\n", + "\n", + "\n", + "Sampling for ZZZ ...\n", + "Initial prior bounds: [4718, 5982]\n", + "Time pre-sampling: 9.297266244888306\n", + "Outcomes {0: 835, 1: 165}\n", + "\n", + "\n", + " NEW FIT\n", + "Outcomes: {0: 835, 1: 165}\n", + "Guesses: amp, mean and std_dev: 0.028889837040618385 1.676031005258493 0.00433576704071709\n", + "FIT SUCCESS: Converged with popt: [0.02890348 1.67605882 0.00433695]\n", + "Outcomes {0: 1680, 1: 320}\n", + "\n", + "\n", + " NEW FIT\n", + "Outcomes: {0: 1680, 1: 320}\n", + "Guesses: amp, mean and std_dev: 0.04005495822947471 1.677722693235963 0.0031287221244362833\n", + "FIT SUCCESS: Converged with popt: [0.04005808 1.67773803 0.00312918]\n", + "Time sampling: 0.8476636409759521\n", + "\n", + "\n", + "Sampling for XII ...\n", + "Initial prior bounds: [2899, 4163]\n", + "Time pre-sampling: 8.372225761413574\n", + "Outcomes {0: 565, 1: 435}\n", + "\n", + "\n", + " NEW FIT\n", + "Outcomes: {0: 565, 1: 435}\n", + "Guesses: amp, mean and std_dev: 0.028851034102340547 1.103847239464032 0.0043427005953010425\n", + "FIT SUCCESS: Converged with popt: [0.02885848 1.10384344 0.00434363]\n", + "Outcomes {0: 1114, 1: 886}\n", + "\n", + "\n", + " NEW FIT\n", + "Outcomes: {0: 1114, 1: 886}\n", + "Guesses: amp, mean and std_dev: 0.040003023377959225 1.1058318936731604 0.003130581360682867\n", + "FIT SUCCESS: Converged with popt: [0.04003508 1.10583004 0.00313094]\n", + "Time sampling: 0.7151508331298828\n", + "\n", + "\n", + "Sampling for IXI ...\n", + "Initial prior bounds: [4097, 5361]\n", + "Time pre-sampling: 8.802292823791504\n", + "Outcomes {0: 267, 1: 733}\n", + "\n", + "\n", + " NEW FIT\n", + "Outcomes: {0: 267, 1: 733}\n", + "Guesses: amp, mean and std_dev: 0.028919108530071676 1.5003819535679384 0.004332369575282894\n", + "FIT SUCCESS: Converged with popt: [0.02892695 1.50036528 0.00433338]\n", + "Outcomes {0: 580, 1: 1420}\n", + "\n", + "\n", + " NEW FIT\n", + "Outcomes: {0: 580, 1: 1420}\n", + "Guesses: amp, mean and std_dev: 0.04005009812145183 1.5079822041921247 0.0031257479844385987\n", + "FIT SUCCESS: Converged with popt: [0.04009681 1.50797434 0.00312613]\n", + "Time sampling: 0.9897425174713135\n", + "\n", + "ZZZ\n", + "Exact energy = -0.10785594226944892\n", + "Initial energy= -0.10999999999999992 err= 0.015717403067612584\n", + "Frequentist energy -0.10333333333333336\n", + "Enhanced Energy = -0.1067374553671028 err= 0.003111283557352958\n", + "\n", + "XII\n", + "Exact energy = 0.4504792175806916\n", + "Initial energy= 0.44499999999999995 err= 0.014161351841243576\n", + "Frequentist energy 0.44533333333333325\n", + "Enhanced Energy = 0.4483904722251097 err= 0.002798540639700969\n", + "\n", + "IXI\n", + "Exact energy = 0.06428637695352224\n", + "Initial energy= 0.08499999999999995 err= 0.01575613575574571\n", + "Frequentist energy 0.08066666666666669\n", + "Enhanced Energy = 0.0627803643652616 err= 0.0031199481632141163\n", + "\n", + "Total Frequentis energy 0.4226666666666665 \n", + "Total Enahnced energy 0.40443338122326844\n", + "\n", + "Total Exact energy 0.40690965226476494\n" + ] + } + ], + "source": [ + "\n", + "\n", + "print( '\\nRepetition',repetitions)\n", + "fit_energy,fit_variance = test.eval(pre_energy_freq,std_dev_freq,q_instance_post,repetitions ,steps, steps_pre)\n", + "\n", + "freq_tot_energy = 0\n", + "enha_tot_energy = 0\n", + "for H_part in Hamiltonian.to_pauli_op():\n", + " print()\n", + " primitive = str(H_part)\n", + " print(primitive)\n", + " print('Exact energy =',exact_energy[primitive])\n", + " print('Initial energy=',sum(pre_energy_freq[primitive][steps_pre-1].values())/repetitions,'err=',sum(std_dev_freq[primitive][steps_pre-1].values())/repetitions)\n", + " \n", + " #print('Theta values=',test_in_use._initial_theta,' np.arcos(E)',np.arccos(pre_energy_freq[primitive]), 'Energy',pre_energy_freq[primitive])\n", + " \n", + " print('Frequentist energy',sum(post_energy_freq[primitive][steps-1].values())/repetitions)\n", + " print('Enhanced Energy =',sum(fit_energy[primitive][steps-1].values())/repetitions, 'err=',np.sqrt(sum(fit_variance[primitive][steps-1].values())/repetitions))\n", + " \n", + " freq_tot_energy += sum(post_energy_freq[primitive][steps-1].values())/repetitions\n", + " enha_tot_energy += sum(fit_energy[primitive][steps-1].values())/repetitions\n", + " \n", + "print('\\nTotal Frequentis energy',freq_tot_energy,\n", + " '\\nTotal Enahnced energy', enha_tot_energy) \n", + "print('\\nTotal Exact energy', sum(exact_energy.values()))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "lenH = len(Hamiltonian.to_pauli_op())\n", + "freq_rmse = np.zeros((lenH,steps+1))\n", + "enha_rmse = np.zeros((lenH,steps+1))\n", + "pre_freq_rmse = np.zeros((lenH,steps_pre))\n", + "plt.figure(figsize=(12,8))\n", + "for h,H_part in enumerate(Hamiltonian.to_pauli_op()):\n", + " primitive = str(H_part)\n", + " for t in range(steps_pre):\n", + " pre_freq_rmse[h,t] = get_RMSE(pre_energy_freq[primitive][t],exact_energy[primitive])\n", + " freq_rmse[h,0]= pre_freq_rmse[h,steps_pre-1]\n", + " enha_rmse[h,0]= pre_freq_rmse[h,steps_pre-1]\n", + " for t in range(0,steps):\n", + " #print(pre_energy_freq[primitive][t])\n", + " freq_rmse[h,t+1] = get_RMSE(post_energy_freq[primitive][t],exact_energy[primitive])\n", + " enha_rmse[h,t+1] = get_RMSE(fit_energy[primitive][t],exact_energy[primitive])\n", + "plt.plot(np.asarray(range(1,steps_pre+1))*sample_every, \n", + " np.sum(pre_freq_rmse,axis=0), label=\"Frequentist RMSE (Pre-sampling)\" )\n", + "plt.plot(num_preshots+np.asarray(range(steps+1))*sample_every, np.sum(freq_rmse,axis=0) , label=\"Frequentist RMSE\")\n", + "plt.plot(num_preshots+np.asarray(range(steps+1))*sample_every, np.sum(enha_rmse,axis=0) ,linestyle = '--', label=\"Enhanced RMSE\")\n", + "#plt.plot(range(num_steps),-0.01+1/np.sqrt(range(1000,1000+num_steps)))\n", + "plt.yscale('log')\n", + "plt.legend()\n", + "plt.ylabel('RMSE')\n", + "plt.xlabel('Shots')\n", + "plt.title('Root-mean-squared error (RMSE). Enhanced noisy circuit with '+str(Layers)+' layers ')\n", + "plt.savefig('RMSE_'+str(Layers)+'__rep'+str(repetitions)+'noisytest.png')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "NEASQC4wMYQLM", + "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.7" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "8fecc24a9c06863268eef22b722bc39970e040fd4701f3b867876035cf1a5542" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From d73040b40a910ec9616674bf1178012c1c959a31 Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Fri, 26 May 2023 11:30:33 +0200 Subject: [PATCH 02/13] improved enhances sampling code for readbility same for example notebook --- README.md | 11 + enhanced_sampling/EnhancedSampling.py | 203 ++---- misc/notebooks/EnhancedSamplingExample.ipynb | 727 ++++++++++--------- 3 files changed, 471 insertions(+), 470 deletions(-) diff --git a/README.md b/README.md index 8d3c085..d47da7d 100644 --- a/README.md +++ b/README.md @@ -41,6 +41,17 @@ You can find the Jupyter notebook and python scripts in the **misc** folder. Use the Conda environment provided to run the code. +## Enhanced Sampling +In this repo, we're exploring the simulation of quantum circuits using enhanced sampling methods that uses Bayesian inference to reduce the number of measurement, the algorithm is taken from [Minimizing estimation runtime on noisy quantum computers](https://arxiv.org/abs/2006.09350). The goal is to estimate the expectation values of a Hamiltonian operator on a given quantum state, which is a common task in many quantum algorithms. + +We implement the non-adaptive version of the algorithm outlined in the paper to carry out Bayesian inference. The reasoning for the using the non-adaptive is to have a much faster algorithm where the parameters of the ansatz circuit are not-updated at every shot. + +In the folder misc/notebook/ one can find an example of the algorithm in the notebook EnhancedSamplingExample.ipynb. In it, a generic hamiltonian is built to be used to compare the energy evaluation on a SU2 ansatz using the algorithm outlined (enhanced sampling) vs the more traditional approac (frequentist). + +![Frequentist vs Enhanced schema](doc/SamplingSchema.png) + + + ## QLM interoperability explained The code in the repository is mainly written using the Qiskit library. To be able to run the circuits onto QLM quantum processing units (QPUs), we integrated the myqlm-interop library which enables the conversion of Qiskit circuits to QLM circuits (as well as the opposite). Additionally, the library allows wrapping QLM QPUs onto a Qiskit`s quantum instance. This allows for easy and simple integration of QPUs as backends to run the circuits. diff --git a/enhanced_sampling/EnhancedSampling.py b/enhanced_sampling/EnhancedSampling.py index 6369a86..fdb1443 100644 --- a/enhanced_sampling/EnhancedSampling.py +++ b/enhanced_sampling/EnhancedSampling.py @@ -8,11 +8,12 @@ from qiskit.opflow import MatrixOp, StateFn, PauliExpectation, PrimitiveOp, PauliOp from qiskit.opflow.state_fns import CircuitStateFn from qiskit.opflow.converters import CircuitSampler - +from qiskit import transpile import numpy as np import scipy +from scipy import stats import matplotlib.pyplot as plt -import collections +from collections import OrderedDict, defaultdict import functools from scipy.optimize import curve_fit @@ -34,6 +35,7 @@ def __init__( x_angles: Optional[np.ndarray] = None, binning_range: Tuple[float, float] = (-1, 1), binning_points: int = 10000, + random_seed: Optional[int] = None, ) -> None: """ Initialize the Enhanced sampling module. @@ -42,31 +44,37 @@ def __init__( Hamiltonian: the Hamiltonian to sample. Layers: the layers of the circuit to use to sample. ansatz: the ansatz to use. - x_angles: the initial angles for the ansatz. + x_angles: the initial angles for the generalized rotations. binning_range: the range for the binning arrays. binning_points: the number of points in the binning arrays. + random_seed: Seed for random number generator for reproducibility. """ # Make circuits self._hamiltonian = Hamiltonian self._num_qubits = Hamiltonian.num_qubits - print('num qubits',self._num_qubits) self._layers = Layers - if ansatz.num_parameters == 0: - self._ansatz = ansatz - else: - print("Ansatz with parameters not set, setting it random") - seed(44) - angles_set = {par: random()*2*pi for par in ansatz.ordered_parameters} - print(angles_set) + + if ansatz.num_parameters != 0: + print("Ansatz with parameters not set, setting it random:",angles_set) + np.random.seed(random_seed) # for reproducibility + angles_set = {par: np.random.uniform(0, 2*np.pi) for par in ansatz.ordered_parameters} self._ansatz = ansatz.bind_parameters(angles_set) + else: + self._ansatz = ansatz self._binning_points = binning_points - self._x_angles = x_angles or np.ones(2 * Layers) * np.pi / 2 + + # If no angles for the generalized rotations are provided, we initialize them to pi / 2 + if x_angles is None: + self._x_angles = np.ones(2 * self._layers) * np.pi / 2 + else: + self._x_angles = x_angles binning_start, binning_end = binning_range self._binning = np.linspace(binning_start, binning_end, self._binning_points) self._binning_theta = np.linspace(0, np.pi, self._binning_points) + def eval(self, pre_energy_freq: Dict[str, Dict[int, Dict[int, float]]], std_dev_freq: Dict[str, Dict[int, Dict[int, float]]], @@ -75,96 +83,56 @@ def eval(self, steps: int = 1, steps_pre: int = 1, ) -> Tuple[Dict[str, Dict[int, Dict[int, float]]], Dict[str, Dict[int, Dict[int, float]]]]: - # Save the standard x angles and layers + + # Initialization standard_x_angles = self._x_angles standard_layers = self._layers - # Create empty dictionaries for the likelihood, fitted energy, and fitted variance - likelihood = {} - fit_energy = {} - fit_variance = {} - - # Loop through each part of the Hamiltonian + fit_energy = defaultdict(lambda: defaultdict(dict)) + fit_variance = defaultdict(lambda: defaultdict(dict)) + circuit_sampler = CircuitSampler(backend=q_instance_post, attach_results=True) + for H_part in self._hamiltonian.to_pauli_op(): - # Convert the Hamiltonian part to a string primitive = str(H_part) print("\n\nSampling for", primitive, "...") - # Create empty dictionaries for the fitted energy and variance for this Hamiltonian part - fit_energy[primitive] = {} - fit_variance[primitive] = {} - for step in range(steps): - fit_energy[primitive][step] = {} - fit_variance[primitive][step] = {} - - # Reset the x angles and layers to the standard values - self._x_angles = standard_x_angles + + self._x_angles = standard_x_angles.copy() self._layers = standard_layers - # Loop through each repetition, useful for averaging plots, but not really necessary in practice - for rep in range(repetitions): - # Convert the pre-sampled energy frequency and standard deviation frequency to Theta - start_time = time.time() self.convert_to_Theta(pre_energy_freq[primitive][steps_pre - 1][rep], std_dev_freq[primitive][steps_pre - 1][rep]) - # Compute the likelihood and Fisher information for the initial theta values - if rep == 0: - likelihood_0, likelihood_1, ket_A = self._compute_likelihood(H_part) - + likelihood_0, likelihood_1, ket_A = self._compute_likelihood(H_part) f_info_A = self.FischerInfo(self._initial_theta, ket_A) - - - # Check if using 1 layer less results in a higher Fisher information if self._layers > 1: self._layers -= 1 self._x_angles = self._x_angles[:-2] - if rep == 0: # only compute likelihood if it hasn't been computed yet - likelihood_0_B, likelihood_1_B, ket_B = self._compute_likelihood(H_part) + likelihood_0_B, likelihood_1_B, ket_B = self._compute_likelihood(H_part) f_info_B = self.FischerInfo(self._initial_theta, ket_B) - # Use the alternative circuit if it results in a higher Fisher information - if f_info_A >= f_info_B: - self._layers = standard_layers - self._x_angles = standard_x_angles - likelihood[0] = likelihood_0 - likelihood[1] = likelihood_1 + if f_info_A < f_info_B: + print('Using alternative circuit') + likelihood_0, likelihood_1 = likelihood_0_B, likelihood_1_B else: - print(' use alternative circuit') - likelihood[0] = likelihood_0_B - likelihood[1] = likelihood_1_B - else: - likelihood[0] = likelihood_0 - likelihood[1] = likelihood_1 - - # Create the enhanced sampling circuit - circuit = self.make_enhanced_circuit(H_part) # TODO: check if it can be moved outside the loop - end_time = time.time() - print('Time pre-sampling:', end_time - start_time) - # Initialize the outcomes dictionary + self._layers = standard_layers + self._x_angles = standard_x_angles.copy() + + likelihood = {0: likelihood_0, 1: likelihood_1} + + circuit = self.make_enhanced_circuit(H_part, q_instance_post) outcomes = {0: 0, 1: 0} - # Loop through each step - start_time = time.time() for step in range(steps): - # Sample from the enhanced sampling circuit and update the outcomes - # at each step new outcomes are added to the dictionary - sampler_enhanced = CircuitSampler(backend=q_instance_post, attach_results=True).convert(circuit) + sampler_enhanced = circuit_sampler.convert(circuit) outcomes = self.collect_events(sampler_enhanced, outcomes) - # Compute the fitted energy and variance for this step energy, variance = self.compute_posterior(outcomes, likelihood) fit_energy[primitive][step][rep] = energy fit_variance[primitive][step][rep] = variance - # Divide the fitted energy and variance by the number of repetitions - # for step in range(steps): - # fit_energy[primitive][step] /= repetitions - # fit_variance[primitive][step] /= repetitions - end_time = time.time() - print('Time sampling:', end_time - start_time) - - # Return the fitted energy and variance dictionaries + return fit_energy, fit_variance - def make_enhanced_circuit(self, Pauli_H): + + def make_enhanced_circuit(self, Pauli_H, quantum_instance): # Get the inverse of the ansatz ansz_inverse = self._ansatz.inverse() # Set the phase flip operator @@ -188,6 +156,9 @@ def make_enhanced_circuit(self, Pauli_H): circuit.append(MatrixOp(R0_gate), list_of_qubits) circuit.append(self._ansatz, list_of_qubits) + # Transpile the circuit for optimization + circuit = transpile(circuit, backend=quantum_instance.backend) + # Compute the projection operator for the Hamiltonian proj_H_m = (PauliOp(Pauli('I' * self._num_qubits), coeff=1.0) - Pauli_H) / 2 @@ -201,28 +172,30 @@ def make_enhanced_circuit(self, Pauli_H): return expectation_m def compute_posterior(self, outcomes, likelihood): + """ + Compute the posterior distribution for theta and then estimate energy and variance. + + Args: + outcomes: Dictionary of collected events. + likelihood: Likelihood for the events. + + Returns: + fit_energy: Fitted energy value. + fit_variance: Fitted variance value. + """ + # Compute the posterior distribution for theta - print("\n\n NEW FIT") def get_posterior(likelihood, f_prior): estimate = sum(likelihood * f_prior) return (likelihood * f_prior) / estimate prior_theta = self._initial_prior_theta - outcomes0 = outcomes[0] - outcomes1 = outcomes[1] - for _ in range(outcomes[0]+outcomes[1]): - for outcome in [0,1]: - if outcome == 0 and outcomes0 > 0: - outcomes0-=1 - prior_theta = get_posterior(likelihood[outcome], prior_theta) - elif outcome == 1 and outcomes1 > 0: - prior_theta = get_posterior(likelihood[outcome], prior_theta) - outcomes1-=1 - - # for state, samples in outcomes.items(): #state can be 0 or 1, samples is the number of times 0 or 1 was measured - # for _ in range(samples): # update the prior_theta for each sample, - # prior_theta = get_posterior(likelihood[state], prior_theta) + for _ in range(sum(outcomes.values())): + for outcome in outcomes.keys(): + if outcomes[outcome] > 0: + prior_theta = get_posterior(likelihood[outcome], prior_theta) + outcomes[outcome] -= 1 self._final_prior_theta = prior_theta @@ -237,51 +210,25 @@ def gaussian_function(x, amplitude, mean, std_dev): # Set dynamic initial guess for amplitude amplitude_guess = np.max(prior_theta) - - - print('Outcomes:', outcomes) - if False: - plt.plot(self._restricted_binning_theta, self._initial_prior_theta, label='initial prior') - plt.plot(self._restricted_binning_theta, self._final_prior_theta, label='final prior') - # plt.plot(self._restricted_binning_theta, likelihood[0], label='likelihood 0 with n outcomes'+str(outcomes[0])) - # plt.plot(self._restricted_binning_theta, likelihood[1], label='likelihood 1 with n outcomes'+str(outcomes[1])) - plt.legend() - plt.show() - # which is the same as - - - - print("Guesses: amp, mean and std_dev:",amplitude_guess, mean_guess, std_dev_guess) - + print("Guesses: amplitude, mean, std_dev:", amplitude_guess, mean_guess, std_dev_guess) # Fit the theta distribution to a Gaussian try: - popt, _ = curve_fit(gaussian_function, - self._restricted_binning_theta, - prior_theta, + popt, _ = curve_fit(gaussian_function, self._restricted_binning_theta, prior_theta, p0=[amplitude_guess, mean_guess, std_dev_guess]) _, theta_fit, sigma_fit = popt - print('FIT SUCCESS: Converged with popt:', popt) + print('Fit successful: Converged with popt:', popt) except RuntimeError: - # plot the prior_theta - print('\033[91m' + 'FIT ERROR: Failde to converge' + '\033[0m') # to make it red, use - plt.plot(self._restricted_binning_theta, self._initial_prior_theta, label='initial prior') - plt.plot(self._restricted_binning_theta, self._final_prior_theta, label='final prior') - plt.legend() - plt.show() - + print('\033[91m' + 'Fit error: Failed to converge' + '\033[0m') theta_fit, sigma_fit = mean_guess, std_dev_guess - - # self._theta_fit = theta_fit - # self._sigma_fit = sigma_fit - # Convert the fitted theta values to energy fit_energy, fit_variance = self._convert_to_energy(theta_fit, sigma_fit) return fit_energy, fit_variance + def _convert_to_energy(self, mu, sigma): # Convert the mean and standard deviation of the theta distribution to energy energy = np.exp((-sigma ** 2) / 2) * np.cos(mu) @@ -290,17 +237,17 @@ def _convert_to_energy(self, mu, sigma): def convert_to_Theta(self, initial_mean, initial_std_dev) -> None: # Compute initial distribution and sample from it - initial_distribution = scipy.stats.norm.pdf(self._binning, initial_mean, initial_std_dev) + initial_distribution = stats.norm.pdf(self._binning, initial_mean, initial_std_dev) s = np.arccos(np.random.normal(initial_mean, initial_std_dev, self._binning_points * 100)) # Compute initial prior for theta - (initial_theta, initial_sigma) = scipy.stats.norm.fit([x for x in s if str(x) != 'nan']) + (initial_theta, initial_sigma) = stats.norm.fit([x for x in s if str(x) != 'nan']) if initial_sigma ** 2 > 0.01: print("WARNING: Large variance") - initial_prior = scipy.stats.norm.pdf(self._binning_theta, initial_theta, initial_sigma) + initial_prior = stats.norm.pdf(self._binning_theta, initial_theta, initial_sigma) # limit the initial prior to the region of interest, i.e. from - 4 sigma to + 4 sigma self._binning_bounds = [np.argmax(initial_prior) - 4 * int(initial_sigma * self._binning_points), np.argmax(initial_prior) + 4 * int(initial_sigma * self._binning_points)] - print("Initial prior bounds:", self._binning_bounds) + # print("Initial prior bounds:", self._binning_bounds) initial_prior = initial_prior[self._binning_bounds[0]:self._binning_bounds[1]] initial_prior /= sum(initial_prior) self._restricted_binning_theta = self._binning_theta[self._binning_bounds[0]:self._binning_bounds[1]] @@ -340,7 +287,7 @@ def collect_events(self, sampler, outcomes_dict): # Evaluate the operator on the binary value to determine the state state = np.real(operator_in_use.eval(binary_value)) outcomes_dict[state] += item - print("Outcomes",outcomes_dict) + # print("Outcomes",outcomes_dict) return outcomes_dict def _redefineBasis(self, Pauli_H): @@ -386,8 +333,8 @@ def _updateGateArray(self, theta_angle): gate_array[2 * num_layers] = self._new_P(theta_angle).to_matrix() gate_array_derivative[2 * num_layers] = self._new_P_prime(theta_angle).to_matrix() # P derivative - ord_gate_array = collections.OrderedDict(sorted(gate_array.items())) - ord_gate_array_derivative = collections.OrderedDict(sorted(gate_array_derivative.items())) + ord_gate_array = OrderedDict(sorted(gate_array.items())) + ord_gate_array_derivative = OrderedDict(sorted(gate_array_derivative.items())) return ord_gate_array, ord_gate_array_derivative diff --git a/misc/notebooks/EnhancedSamplingExample.ipynb b/misc/notebooks/EnhancedSamplingExample.ipynb index 4987daa..a1409d8 100644 --- a/misc/notebooks/EnhancedSamplingExample.ipynb +++ b/misc/notebooks/EnhancedSamplingExample.ipynb @@ -1,5 +1,32 @@ { "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quantum Circuit Simulation with Enhanced Sampling\n", + "In this notebook, we're exploring the simulation of quantum circuits using enhanced sampling methods (non-adaptive case) (https://arxiv.org/abs/2006.09350). The goal is to estimate the expectation values of a Hamiltonian operator on a given quantum state, which is a common task in many quantum algorithms.\n", + "\n", + "We start by defining an ansatz, which is a parameterized quantum circuit that we use to prepare the quantum state. The parameters of the ansatz are optimized to minimize the expectation value of the Hamiltonian.\n", + "\n", + "We then create a simple circuit to sample the Hamiltonian on the ansatz. We calculate the expectation and exact expectation of the circuit.\n", + "\n", + "Next, we iterate over each part of the Hamiltonian and calculate various quantities such as the variance, standard deviation, and pre-energy. We also update the frequency dictionary, which keeps track of the frequency of each outcome when sampling the quantum circuit.\n", + "\n", + "After that, we calculate the exact energy of the system by sampling the exact expectation value of the circuit.\n", + "\n", + "We then combine the pre and post sampling results to calculate the post-energy. We also update the frequency dictionary with the new samples.\n", + "\n", + "Finally, we calculate the root-mean-squared error (RMSE) of the frequentist and enhanced methods. The RMSE is a measure of the differences between the values predicted by a model or an estimator and the values observed. We plot the RMSE as a function of the number of shots to visualize the performance of the methods.\n", + "\n", + "This notebook demonstrates the use of enhanced sampling methods in quantum circuit simulation. These methods can potentially provide more accurate results with fewer quantum circuit evaluations, which is beneficial in quantum computing where resources are limited.\n", + "\n", + "NOTE: too many layers in conjuntion with noise in the circuit tend to worsen the results of enhanced sampling.\n", + "\n", + "![Frequentist vs Enhanced schema](../../doc/SamplingSchema.png)\n" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -9,50 +36,32 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.18.2\n" + "Qiskit version: 0.18.2\n" ] } ], "source": [ "import numpy as np\n", - "from qiskit.opflow import StateFn, PauliExpectation, Zero, One,Z,X,I,PauliOp,ListOp, AerPauliExpectation,DictStateFn,MatrixOp,PrimitiveOp, MatrixExpectation,ComposedOp\n", - "from qiskit.circuit.library import TwoLocal,EfficientSU2,UGate\n", + "from qiskit.opflow import StateFn, PauliExpectation,Z,X,I,ListOp, AerPauliExpectation,ComposedOp\n", + "from qiskit.circuit.library import TwoLocal,EfficientSU2\n", "from qiskit.opflow.state_fns import CircuitStateFn\n", "from qiskit.opflow.converters import CircuitSampler\n", "from qiskit import Aer\n", + "from qiskit.providers.aer import QasmSimulator\n", "from qiskit.utils.quantum_instance import QuantumInstance\n", "from qiskit.test.mock import FakeMontreal\n", "from qiskit.providers.aer.noise import NoiseModel\n", "\n", "import qiskit\n", - "print(qiskit.__version__)\n", - "\n", - "from qiskit.providers.aer.library import SaveExpectationValueVariance\n", - "\n", - "from qiskit.algorithms.optimizers import COBYLA\n", - "from qiskit.algorithms import VQE\n", - "from qiskit_nature.converters.second_quantization import QubitConverter\n", - "from qiskit_nature.mappers.second_quantization import JordanWignerMapper\n", - "from qiskit.quantum_info.operators import Operator\n", - "from qiskit.circuit import Parameter\n", - "from qiskit.providers.aer import AerSimulator,QasmSimulator\n", - "\n", + "print(\"Qiskit version:\",qiskit.__version__)\n", "\n", "from random import random,seed\n", - "from math import pi\n", "import matplotlib.pyplot as plt\n", - "plt.rcParams.update({'font.size': 18})\n", - "\n", - "from scipy.optimize import curve_fit\n", - "\n", - "#my functions\n", - "from enhanced_sampling import EnhancedSampling\n", "\n", - "# import EnhancedSampling\n", "\n", "\n", - "def is_unitary(m):\n", - " return np.allclose(np.eye(m.shape[0]), m.H * m)" + "# This repo's library\n", + "from enhanced_sampling import EnhancedSampling" ] }, { @@ -61,23 +70,138 @@ "metadata": {}, "outputs": [], "source": [ + "def create_simple_circuit(ansatz, pauli_operator):\n", + " \"\"\"\n", + " Create a simple circuit to sample a Hamiltonian on an ansatz.\n", + "\n", + " Args:\n", + " ansatz (QuantumCircuit): The ansatz.\n", + " pauli_operator (Pauli): The Pauli operator.\n", + "\n", + " Returns:\n", + " tuple: The expectation and exact expectation of the circuit.\n", + " \"\"\"\n", + "\n", + " # Create a circuit state function from the ansatz\n", + " ansatz_state = CircuitStateFn(primitive=ansatz)\n", + "\n", + " # Compose the circuit state function with the Pauli operator to create a complete circuit\n", + " complete_circuit = StateFn(pauli_operator, is_measurement=True).compose(ansatz_state)\n", + "\n", + " # Convert the complete circuit to an expectation value\n", + " expectation = PauliExpectation().convert(complete_circuit)\n", + "\n", + " # Convert the complete circuit to an exact expectation value\n", + " exact_expectation = AerPauliExpectation().convert(complete_circuit)\n", + "\n", + " return expectation, exact_expectation\n", + "\n", + "def is_unitary(m):\n", + " return np.allclose(np.eye(m.shape[0]), m.H * m)\n", + "\n", "def update_dict(old_dict, sampler, num_qubits):\n", + " \"\"\"\n", + " Update the dictionary with the results of a quantum operation.\n", + "\n", + " Args:\n", + " old_dict (dict): The original dictionary.\n", + " sampler (Sampler): The sampler object that contains the operation list.\n", + " num_qubits (int): The number of qubits involved in the operation.\n", + "\n", + " Returns:\n", + " dict: The updated dictionary.\n", + " \"\"\"\n", " new_dict = old_dict.copy()\n", " events = sampler.oplist[1].execution_results['counts'].items()\n", - " for key,item in events:\n", - " binary_value = bin(int(key,16))[2:].zfill(num_qubits)\n", - " if binary_value not in new_dict.keys():\n", - " new_dict[binary_value]=item\n", - " else:\n", - " new_dict[binary_value]+=item \n", - " return new_dict\n", - "def get_amplitudes(old_dict,num_shot):\n", - " new_dict = {}\n", - " for key,item in old_dict.items():\n", - " new_dict[key]= np.sqrt(item/num_shot)\n", + "\n", + " for key, item in events:\n", + " binary_value = bin(int(key, 16))[2:].zfill(num_qubits)\n", + " new_dict[binary_value] = new_dict.get(binary_value, 0) + item \n", + "\n", " return new_dict\n", + "\n", + "\n", + "def get_amplitudes(old_dict, num_shot):\n", + " \"\"\"\n", + " Calculate the amplitudes from the counts in the dictionary.\n", + "\n", + " Args:\n", + " old_dict (dict): The dictionary with counts.\n", + " num_shot (int): The number of shots in the quantum operation.\n", + "\n", + " Returns:\n", + " dict: The dictionary with calculated amplitudes.\n", + " \"\"\"\n", + " return {key: np.sqrt(item / num_shot) for key, item in old_dict.items()}\n", + "\n", + "\n", "def get_RMSE(results, true_value):\n", - " return np.sqrt(sum([(mu-true_value)**2 for mu in results.values()])/len(results))" + " \"\"\"\n", + " Calculate the Root Mean Square Error (RMSE) of the results.\n", + "\n", + " Args:\n", + " results (dict): The dictionary with results.\n", + " true_value (float): The true value for comparison.\n", + "\n", + " Returns:\n", + " float: The calculated RMSE.\n", + " \"\"\"\n", + " return np.sqrt(np.mean([(mu - true_value) ** 2 for mu in results.values()]))\n", + "\n", + "def compute_variance(expected_operator, state_freq_dict):\n", + " \"\"\"\n", + " Compute the variance of an expected operator given a state frequency dictionary.\n", + "\n", + " Args:\n", + " expected_operator (OperatorBase): The expected operator.\n", + " state_freq_dict (dict): The state frequency dictionary.\n", + "\n", + " Returns:\n", + " float: The computed variance.\n", + " \"\"\"\n", + " def calculate_variance(operator, state_freq_dict):\n", + " \"\"\"\n", + " Calculate the variance of an operator.\n", + "\n", + " Args:\n", + " operator (OperatorBase): The operator.\n", + " state_freq_dict (dict): The state frequency dictionary.\n", + "\n", + " Returns:\n", + " float: The calculated variance.\n", + " \"\"\"\n", + " if isinstance(operator, ComposedOp):\n", + " measurement = operator.oplist[0]\n", + " average = measurement.eval(state_freq_dict)\n", + " variance = sum(\n", + " (v * (measurement.eval(b) - average)) ** 2\n", + " for (b, v) in state_freq_dict.items()\n", + " )\n", + " return operator.coeff * variance\n", + "\n", + " elif isinstance(operator, ListOp):\n", + " return operator.combo_fn([calculate_variance(op, state_freq_dict) for op in operator.oplist])\n", + "\n", + " return 0.0\n", + "\n", + " # Check if the input arguments are of the expected type\n", + " if not isinstance(expected_operator, (ComposedOp, ListOp)):\n", + " raise TypeError(\"expected_operator must be an instance of ComposedOp or ListOp.\")\n", + " if not isinstance(state_freq_dict, dict):\n", + " raise TypeError(\"state_freq_dict must be a dictionary.\")\n", + "\n", + " return calculate_variance(expected_operator, state_freq_dict)\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initial setup\n", + "\n", + "First set up a generic hamiltonian as well as general variables" ] }, { @@ -97,29 +221,13 @@ ], "source": [ "#Declare an Hamiltonian\n", - "\n", - "H_first_part = Z ^ Z ^ Z\n", - "H_second_part = (X ^ I ^ I) + (I ^ X ^ I)\n", - "\n", - "#Hamiltonian = (Z ^ Z) +(X ^ I) + (I ^ X)\n", - "\n", - "Hamiltonian = H_first_part + H_second_part \n", + "H_1 = Z ^ Z ^ Z\n", + "H_2 = (X ^ I ^ I) + (I ^ X ^ I)\n", + "Hamiltonian = H_1 + H_2 \n", "\n", "print(Hamiltonian)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Build circuits\n", - "\n", - "We need an ansatz circuit, and operators to measure on it.\n", - "Here we first build the ansatz from EfficientSU(2), define a set of random angles to apply to it.\n", - "Then we create the simple circuit containing the anstaz and the operators to measure (the Hamiltonian parts)\n", - "After that, we combine the anstaz with layers of the enhance circuit using fixed x_angles on these layers (=pi/2) to use Chebyshev-like functions, so we can take multiple samples of the same circuit, instead of modifying after each shot(this would means using ELF)" - ] - }, { "cell_type": "code", "execution_count": 4, @@ -127,95 +235,80 @@ "outputs": [], "source": [ "# Define global variables\n", - "num_qubit = Hamiltonian.num_qubits\n", - "Layers = 3 #Layers of enhanced circuit\n", - "\n", + "Layers = 4 #Layers of enhanced circuit; stay between 1 and 6\n", "fixed_x_angles = np.ones(2*Layers)*np.pi/2 # list of pi/2 ,to use CLF insteaf of ELF\n", - "\n", - "useNoise = False\n", - "\n", - "num_preshots=4000\n", - "\n", + "use_noise = False\n", + "num_preshots=4000 \n", "num_postshot=2000\n", - "\n", - "repetitions = 1\n", - "sample_every = 1000\n", - "\n", - "steps_pre = max(1,round(num_preshots/sample_every))\n", - "steps = max(1,round(num_postshot/sample_every))\n", - "\n", + "repetitions = 1 #repeat the entire test n-times, to increase statistic in results\n", + "sample_every = 1000 # measure the energy every n-shots\n", "n_points = 10000 #to use for binning" ] }, { - "cell_type": "code", - "execution_count": 5, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Random angles assigned to ansatz {ParameterVectorElement(θ[0]): 2.5669066339875286, ParameterVectorElement(θ[1]): 3.4053105645086, ParameterVectorElement(θ[2]): 5.416335802913373, ParameterVectorElement(θ[3]): 1.1100229798922292, ParameterVectorElement(θ[4]): 1.414718991468211, ParameterVectorElement(θ[5]): 0.1828234342134787, ParameterVectorElement(θ[6]): 0.7329369178028627, ParameterVectorElement(θ[7]): 0.05532737919413898, ParameterVectorElement(θ[8]): 0.9845144111728377, ParameterVectorElement(θ[9]): 3.227755283768095, ParameterVectorElement(θ[10]): 6.2171673160425955, ParameterVectorElement(θ[11]): 4.357453485004286}\n" - ] - } - ], "source": [ - "seed(44) #44 ok #1 wtf?\n", - "# Ansatz creation\n", - "ansz = EfficientSU2(num_qubit,['ry','rz'],reps=1)\n", - "angles_set = {}\n", - "param = ansz.ordered_parameters\n", - "for j in range(len(param)):\n", - " angles_set[param[j]]= random()*2*pi\n", - "ansz_assigned = ansz.bind_parameters(angles_set)\n", + "# Build circuits\n", "\n", - "print(' Random angles assigned to ansatz',angles_set)\n" + "We need an ansatz circuit, and operators to measure on it.\n", + "Here we first build the ansatz from EfficientSU(2), define a set of random angles to apply to it.\n", + "Then we create the simple circuit containing the anstaz and the operators to measure (the Hamiltonian parts)\n", + "After that, we combine the anstaz with layers of the enhance circuit using fixed x_angles on these layers (=pi/2) to use Chebyshev-like functions, so we can take multiple samples of the same circuit, instead of modifying after each shot(this would means using ELF)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "num qubits 3\n" + " Random angles assigned to ansatz {ParameterVectorElement(θ[0]): 1.1680220570801747, ParameterVectorElement(θ[1]): 1.795686678025813, ParameterVectorElement(θ[2]): 1.2617255125328317, ParameterVectorElement(θ[3]): 2.2468982716755828, ParameterVectorElement(θ[4]): 5.363571190329344, ParameterVectorElement(θ[5]): 3.379151087751608, ParameterVectorElement(θ[6]): 6.178754944553304, ParameterVectorElement(θ[7]): 1.5628349995081818, ParameterVectorElement(θ[8]): 1.518474424412041, ParameterVectorElement(θ[9]): 0.49962993523475535, ParameterVectorElement(θ[10]): 2.1640358950166863, ParameterVectorElement(θ[11]): 2.451273703185537}\n" ] - } - ], - "source": [ - "test = EnhancedSampling.EnhancedSampler(Hamiltonian,\n", - " Layers,\n", - " ansz_assigned)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 7, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "test._ansatz.decompose().draw(output='mpl',filename='EfficientSU2')" + "# Calculate the number of steps for pre-shots and post-shots\n", + "# Ensure at least 1 step\n", + "steps_pre = max(1,round(num_preshots / sample_every))\n", + "steps_post = max(1,round(num_postshot / sample_every))\n", + "\n", + "# Create an ansatz using the EfficientSU2 method\n", + "# 'ry' and 'rz' are rotation gates, and 'reps' is the number of repetitions of the circuit\n", + "ansatz = EfficientSU2(Hamiltonian.num_qubits, ['ry','rz'], reps=1)\n", + "\n", + "# Initialize a dictionary to hold the angles for the ansatz\n", + "angles_set = {}\n", + "# Assign random angles to each parameter\n", + "for param in ansatz.ordered_parameters:\n", + " angles_set[param] = random() * 2 * np.pi\n", + "\n", + "# Bind the random angles to the ansatz\n", + "ansatz_assigned = ansatz.bind_parameters(angles_set)\n", + "\n", + "print(' Random angles assigned to ansatz',angles_set)\n", + "\n", + "#Draw the ansatz circuit\n", + "ansatz_assigned.decompose().draw(output='mpl',filename='EfficientSU2')" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -240,52 +333,20 @@ "coupling_map = device.configuration().coupling_map\n", "noise_model = NoiseModel.from_backend(device)\n", "\n", - "\n", - "\n", - "if useNoise == False: \n", + "if use_noise == False: \n", " noise_model = None\n", " coupling_map = None\n", "\n", "# SET UP INITIAL SAMPLING \n", - "q_instance_pre = QuantumInstance(backend=backend,\n", - " shots=sample_every, #to adapt\n", - " skip_qobj_validation = False,\n", - " coupling_map=coupling_map,\n", - " noise_model=noise_model)\n", - "\n", - "q_instance_post = QuantumInstance(backend=backend,\n", - " shots=sample_every,\n", + "quantum_instance = QuantumInstance(backend=backend,\n", + " shots=sample_every, #to adapt\n", " skip_qobj_validation = False,\n", " coupling_map=coupling_map,\n", " noise_model=noise_model)\n", - "print('Number of preshots',num_preshots)\n", - "print('Number of postshots',num_postshot)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "def compute_variance(exp_op, sfdict):\n", - " def sum_variance(operator,sfdict):\n", - " if isinstance(operator, ComposedOp):\n", - " #sfdict = operator.oplist[1]\n", - " measurement = operator.oplist[0]\n", - " average = measurement.eval(sfdict)\n", - " variance = sum(\n", - " (v * (measurement.eval(b) - average)) ** 2\n", - " for (b, v) in sfdict.items()\n", - " )\n", - " return operator.coeff * variance\n", - "\n", - " elif isinstance(operator, ListOp):\n", - " return operator.combo_fn([sum_variance(op) for op in operator.oplist])\n", "\n", - " return 0.0\n", "\n", - " return sum_variance(exp_op,sfdict)" + "print('Number of preshots',num_preshots)\n", + "print('Number of postshots',num_postshot)" ] }, { @@ -297,101 +358,93 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def make_simple_circuit(ansatz,P):\n", - " ansz_state = CircuitStateFn(primitive=ansatz)\n", - " complete_circuit = StateFn(P, is_measurement=True).compose(ansz_state) #simple circuit to sample Hamiltonian on ansatz\n", - " expectation = PauliExpectation().convert(complete_circuit) \n", - " exact_exp = AerPauliExpectation().convert(complete_circuit)\n", - " return expectation,exact_exp" - ] - }, - { - "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "ZZZ\n", - "Exact -0.10785594226944892\n", - "XII\n", - "Exact 0.4504792175806916\n", - "IXI\n", - "Exact 0.06428637695352224\n", + "Computing: ZZZ\n", + "Exact (partial) energy = 0.2868678657867208\n", + "Computing: XII\n", + "Exact (partial) energy = 0.057729200917975426\n", + "Computing: IXI\n", + "Exact (partial) energy = -0.1820023221878087\n", "\n", - "Exact: Energy= 0.40690965226476494\n" + "Exact total Energy = 0.16259474451688755\n" ] } ], "source": [ - "#FREQ\n", - "pre_energy_freq = {}\n", - "std_dev_freq = {}\n", - "variance_freq = {}\n", - "freq_dict = {}\n", - "exact_energy = {}\n", - "exact_expectation ={}\n", - "expectation = {}\n", - "\n", - "\n", + "# Initialize a dictionary to hold all the data\n", + "data = {\n", + " \"pre_energy_freq\": {},\n", + " \"std_dev_freq\": {},\n", + " \"variance_freq\": {},\n", + " \"freq_dict\": {},\n", + " \"exact_energy\": {},\n", + " \"exact_expectation\": {},\n", + " \"expectation\": {},\n", + "}\n", + "\n", + "# Iterate over each part of the Hamiltonian\n", "for H_part in Hamiltonian.to_pauli_op():\n", - " print(H_part)\n", + " print('Computing:',H_part)\n", " primitive = str(H_part)\n", - " freq_dict[primitive] = {}\n", - " variance_freq[primitive] = {}\n", - " std_dev_freq[primitive] = {}\n", - " pre_energy_freq[primitive] = {}\n", "\n", - " expectation[primitive], exact_expectation= make_simple_circuit(ansz_assigned,H_part)\n", + " # Initialize dictionaries for this part of the Hamiltonian\n", + " for key in data.keys():\n", + " data[key][primitive] = {}\n", + "\n", + " # Create a simple circuit for this part of the Hamiltonian\n", + " data[\"expectation\"][primitive], data[\"exact_expectation\"][primitive] = create_simple_circuit(ansatz_assigned, H_part)\n", + "\n", + " # Iterate over each step\n", " for step in range(steps_pre):\n", - " variance_freq[primitive][step] = {}\n", - " std_dev_freq[primitive][step] = {}\n", - " pre_energy_freq[primitive][step] = {}\n", + " # Initialize dictionaries for this step\n", + " for key in [\"variance_freq\", \"std_dev_freq\", \"pre_energy_freq\"]:\n", + " data[key][primitive][step] = {}\n", + "\n", + " # Iterate over each repetition\n", " for rep in range(repetitions):\n", - " sampler = CircuitSampler(backend=q_instance_pre , attach_results=True).convert(expectation[primitive])\n", - " \n", - " #\n", + " sampler = CircuitSampler(backend=quantum_instance , attach_results=True).convert(data[\"expectation\"][primitive])\n", " operator_in_use = sampler.oplist[0]\n", - " \n", - " \n", - " if rep not in freq_dict[primitive].keys(): freq_dict[primitive][rep] = {}\n", - " freq_dict[primitive][rep] = update_dict(freq_dict[primitive][rep], sampler, num_qubit)\n", - " ampli_dict = get_amplitudes(freq_dict[primitive][rep],(step+1)*sample_every)\n", - " variance_freq[primitive][step][rep] = np.real(compute_variance(sampler,ampli_dict)/(num_preshots-1))\n", - " std_dev_freq[primitive][step][rep] = np.sqrt(variance_freq[primitive][step][rep])\n", - " # pre_energy_freq[primitive][step][rep] = sampler.eval().real\n", - " pre_energy_freq[primitive][step][rep] = operator_in_use.eval(ampli_dict).real\n", - " #print(operator_in_use.eval(ampli_dict).real,freq_dict[primitive][rep])\n", - " #print(freq_dict)\n", - " # update dictionary of events\n", - " # for key,item in sampler.oplist[1].execution_results['counts'].items():\n", - " # binary_value = bin(int(key,16))[2:].zfill(num_qubit)\n", - " # freq_dict[primitive][binary_value]=item\n", - " # print('\\t outcome:',binary_value,', counts:',item)\n", - "\n", "\n", - " #EXACT\n", - " sampler_exact = CircuitSampler(backend_sv).convert(exact_expectation)\n", - " exact_energy[primitive] = sampler_exact.eval().real\n", - " print( 'Exact',exact_energy[primitive])\n", + " # Update the frequency dictionary\n", + " if rep not in data[\"freq_dict\"][primitive].keys(): \n", + " data[\"freq_dict\"][primitive][rep] = {}\n", + " data[\"freq_dict\"][primitive][rep] = update_dict(data[\"freq_dict\"][primitive][rep], sampler, Hamiltonian.num_qubits)\n", "\n", + " # Calculate the amplitudes\n", + " ampli_dict = get_amplitudes(data[\"freq_dict\"][primitive][rep], (step+1)*sample_every)\n", "\n", + " # Calculate the variance, standard deviation, and pre-energy\n", + " data[\"variance_freq\"][primitive][step][rep] = np.real(compute_variance(sampler, ampli_dict)/(num_preshots-1))\n", + " data[\"std_dev_freq\"][primitive][step][rep] = np.sqrt(data[\"variance_freq\"][primitive][step][rep])\n", + " data[\"pre_energy_freq\"][primitive][step][rep] = operator_in_use.eval(ampli_dict).real\n", "\n", - "print('\\nExact: Energy=', sum(exact_energy.values()))\n", + " # Calculate the exact energy\n", + " sampler_exact = CircuitSampler(backend_sv).convert(data[\"exact_expectation\"][primitive])\n", + " data[\"exact_energy\"][primitive] = sampler_exact.eval().real\n", + " print('Exact (partial) energy = ', data[\"exact_energy\"][primitive])\n", "\n", + "print('\\nExact total Energy =', sum(data[\"exact_energy\"].values()))\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Phase 2: Enhanced sampling vs Frequentist\n", "\n", - "#print('Frequ: Energy=',[pre_energy_freq[k].values() for k in pre_energy_freq.keys()])#,', Variance', sum(variance_freq.values()), 'Standard Deviation',sum(std_dev_freq.values()))\n" + "First we gonna simulate the continuation of the frequentist approac" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -400,62 +453,64 @@ "text": [ "\n", " ZZZ freq event presampling \n", - " {'001': 1916, '101': 1181, '010': 108, '111': 19, '011': 150, '000': 350, '110': 99, '100': 177} -0.10999999999999992\n", - "Exact energy = -0.10785594226944892\n", - "Frequentist pre+post: energy ZZZ -0.10333333333333336 \n", - " \tevents {'001': 2864, '101': 1782, '010': 157, '111': 28, '011': 229, '000': 539, '110': 140, '100': 261}\n", + " {'101': 6, '010': 516, '100': 13, '110': 78, '001': 876, '000': 2204, '011': 269, '111': 38} 0.2785\n", + "Exact energy = 0.2868678657867208\n", + "Frequentist pre+post: energy ZZZ 0.28200000000000003 \n", + " \tevents {'101': 8, '010': 767, '100': 24, '110': 112, '001': 1304, '000': 3345, '011': 381, '111': 59}\n", "\n", " XII freq event presampling \n", - " {'101': 829, '001': 2194, '111': 74, '011': 101, '000': 396, '010': 199, '100': 150, '110': 57} 0.44499999999999995\n", - "Exact energy = 0.4504792175806916\n", - "Frequentist pre+post: energy XII 0.44533333333333325 \n", - " \tevents {'101': 1251, '001': 3309, '111': 127, '011': 149, '000': 608, '010': 270, '100': 206, '110': 80}\n", + " {'011': 248, '111': 46, '000': 975, '010': 525, '001': 337, '101': 496, '110': 92, '100': 1281} 0.04249999999999993\n", + "Exact energy = 0.057729200917975426\n", + "Frequentist pre+post: energy XII 0.05399999999999999 \n", + " \tevents {'011': 379, '111': 64, '000': 1473, '010': 776, '001': 534, '101': 729, '110': 142, '100': 1903}\n", "\n", " IXI freq event presampling \n", - " {'010': 293, '111': 468, '000': 185, '011': 899, '101': 669, '001': 1214, '110': 170, '100': 102} 0.08499999999999995\n", - "Exact energy = 0.06428637695352224\n", - "Frequentist pre+post: energy IXI 0.08066666666666669 \n", - " \tevents {'010': 464, '111': 690, '000': 259, '011': 1345, '101': 1006, '001': 1826, '110': 259, '100': 151}\n" + " {'101': 6, '010': 2002, '001': 831, '110': 11, '100': 84, '000': 685, '011': 335, '111': 46} -0.19699999999999987\n", + "Exact energy = -0.1820023221878087\n", + "Frequentist pre+post: energy IXI -0.1979999999999999 \n", + " \tevents {'101': 12, '010': 3051, '001': 1221, '110': 16, '100': 123, '000': 1050, '011': 466, '111': 61}\n" ] } ], "source": [ "\n", - "post_energy_freq = {}\n", + "# Initialize a dictionary for post energy frequencies\n", + "data[\"post_energy_freq\"] = {}\n", "\n", + "# Iterate over each part of the Hamiltonian\n", "for H_part in Hamiltonian.to_pauli_op():\n", - " \n", " primitive = str(H_part)\n", - " print('\\n',primitive,'freq event presampling \\n',freq_dict[primitive][0] ,pre_energy_freq[primitive][steps_pre-1][0])\n", - " post_energy_freq[primitive] = {}\n", - " #FREQ: combine pre and post sampling\n", + " print('\\n',primitive,'freq event presampling \\n',data[\"freq_dict\"][primitive][0] ,data[\"pre_energy_freq\"][primitive][steps_pre-1][0])\n", + " data[\"post_energy_freq\"][primitive] = {}\n", + "\n", + " # Combine pre and post sampling\n", + " for step in range(steps_post):\n", + " data[\"post_energy_freq\"][primitive][step] = {}\n", "\n", - " for step in range(steps):\n", - " post_energy_freq[primitive][step] = {}\n", - " \n", " for rep in range(repetitions):\n", - " sampler_2 = CircuitSampler(backend=q_instance_post, attach_results=True).convert(expectation[primitive])\n", - " freq_dict[primitive][rep] = update_dict(freq_dict[primitive][rep], sampler_2,num_qubit)\n", + " sampler_2 = CircuitSampler(backend=quantum_instance, attach_results=True).convert(data[\"expectation\"][primitive])\n", + " data[\"freq_dict\"][primitive][rep] = update_dict(data[\"freq_dict\"][primitive][rep], sampler_2, Hamiltonian.num_qubits)\n", " operator_in_use = sampler_2.oplist[0]\n", - " ampli_dict = get_amplitudes(freq_dict[primitive][rep],num_preshots+((step+1)*sample_every))\n", - " post_energy_freq[primitive][step][rep] = operator_in_use.eval(ampli_dict).real\n", - " #print(freq_dict[primitive][0])\n", - " # post_energy_freq[primitive] /= repetitions\n", + " ampli_dict = get_amplitudes(data[\"freq_dict\"][primitive][rep], num_preshots+((step+1)*sample_every))\n", + " data[\"post_energy_freq\"][primitive][step][rep] = operator_in_use.eval(ampli_dict).real\n", "\n", - " print('Exact energy =',exact_energy[primitive])\n", - " print('Frequentist pre+post: energy',primitive,post_energy_freq[primitive][steps-1][0], '\\n \\tevents', freq_dict[primitive][0])\n" + " print('Exact energy =', data[\"exact_energy\"][primitive])\n", + " print('Frequentist pre+post: energy', primitive, data[\"post_energy_freq\"][primitive][steps_post-1][0], '\\n \\tevents', data[\"freq_dict\"][primitive][0])\n" ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Phase 2: Enhanced sampling vs Frequentist" + "### Enhanced sampling\n", + "\n", + "Now we can test the enhance sampling. To later compare frequentist vs enhanced" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -467,125 +522,111 @@ "\n", "\n", "Sampling for ZZZ ...\n", - "Initial prior bounds: [4718, 5982]\n", - "Time pre-sampling: 9.297266244888306\n", - "Outcomes {0: 835, 1: 165}\n", - "\n", - "\n", - " NEW FIT\n", - "Outcomes: {0: 835, 1: 165}\n", - "Guesses: amp, mean and std_dev: 0.028889837040618385 1.676031005258493 0.00433576704071709\n", - "FIT SUCCESS: Converged with popt: [0.02890348 1.67605882 0.00433695]\n", - "Outcomes {0: 1680, 1: 320}\n", - "\n", - "\n", - " NEW FIT\n", - "Outcomes: {0: 1680, 1: 320}\n", - "Guesses: amp, mean and std_dev: 0.04005495822947471 1.677722693235963 0.0031287221244362833\n", - "FIT SUCCESS: Converged with popt: [0.04005808 1.67773803 0.00312918]\n", - "Time sampling: 0.8476636409759521\n", + "Guesses: amplitude, mean, std_dev: 0.036584806215364585 1.281510705663847 0.0034249712200795793\n", + "Fit successful: Converged with popt: [0.03659026 1.28152585 0.00342583]\n", + "Guesses: amplitude, mean, std_dev: 0.0365905915636164 1.278339730637555 0.0034239180417332425\n", + "Fit successful: Converged with popt: [0.0366016 1.27835395 0.00342477]\n", "\n", "\n", "Sampling for XII ...\n", - "Initial prior bounds: [2899, 4163]\n", - "Time pre-sampling: 8.372225761413574\n", - "Outcomes {0: 565, 1: 435}\n", - "\n", - "\n", - " NEW FIT\n", - "Outcomes: {0: 565, 1: 435}\n", - "Guesses: amp, mean and std_dev: 0.028851034102340547 1.103847239464032 0.0043427005953010425\n", - "FIT SUCCESS: Converged with popt: [0.02885848 1.10384344 0.00434363]\n", - "Outcomes {0: 1114, 1: 886}\n", - "\n", - "\n", - " NEW FIT\n", - "Outcomes: {0: 1114, 1: 886}\n", - "Guesses: amp, mean and std_dev: 0.040003023377959225 1.1058318936731604 0.003130581360682867\n", - "FIT SUCCESS: Converged with popt: [0.04003508 1.10583004 0.00313094]\n", - "Time sampling: 0.7151508331298828\n", + "Guesses: amplitude, mean, std_dev: 0.036482323891772514 1.5138739954731328 0.0034340406430913017\n", + "Fit successful: Converged with popt: [0.03649361 1.51385997 0.0034349 ]\n", + "Guesses: amplitude, mean, std_dev: 0.036482323891772514 1.5138739954731328 0.0034340406430913017\n", + "Fit successful: Converged with popt: [0.03649361 1.51385997 0.0034349 ]\n", "\n", "\n", "Sampling for IXI ...\n", - "Initial prior bounds: [4097, 5361]\n", - "Time pre-sampling: 8.802292823791504\n", - "Outcomes {0: 267, 1: 733}\n", - "\n", - "\n", - " NEW FIT\n", - "Outcomes: {0: 267, 1: 733}\n", - "Guesses: amp, mean and std_dev: 0.028919108530071676 1.5003819535679384 0.004332369575282894\n", - "FIT SUCCESS: Converged with popt: [0.02892695 1.50036528 0.00433338]\n", - "Outcomes {0: 580, 1: 1420}\n", - "\n", - "\n", - " NEW FIT\n", - "Outcomes: {0: 580, 1: 1420}\n", - "Guesses: amp, mean and std_dev: 0.04005009812145183 1.5079822041921247 0.0031257479844385987\n", - "FIT SUCCESS: Converged with popt: [0.04009681 1.50797434 0.00312613]\n", - "Time sampling: 0.9897425174713135\n", + "Guesses: amplitude, mean, std_dev: 0.03153589620934152 1.753900309921591 0.007565860560869514\n", + "Fit successful: Converged with popt: [0.03169626 1.75621317 0.00345908]\n", + "Guesses: amplitude, mean, std_dev: 0.02916477584872045 1.751022892096199 0.006867372559402927\n", + "Fit successful: Converged with popt: [0.02930527 1.75355561 0.00349418]\n" + ] + } + ], + "source": [ + "#Initialize the EnhancedSampler\n", + "EnhanceSamplerTest = EnhancedSampling.EnhancedSampler(Hamiltonian,\n", + " Layers,\n", + " ansatz_assigned,\n", + " random_seed=44)\n", + "\n", + "print('\\nRepetition', repetitions)\n", + "fit_energy, fit_variance = EnhanceSamplerTest.eval(data[\"pre_energy_freq\"], data[\"std_dev_freq\"], quantum_instance, repetitions, steps_post, steps_pre)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ "\n", "ZZZ\n", - "Exact energy = -0.10785594226944892\n", - "Initial energy= -0.10999999999999992 err= 0.015717403067612584\n", - "Frequentist energy -0.10333333333333336\n", - "Enhanced Energy = -0.1067374553671028 err= 0.003111283557352958\n", + "Exact energy = 0.2868678657867208\n", + "Initial energy= 0.2785 err= 0.01518772873987645\n", + "Frequentist energy 0.28200000000000003\n", + "Enhanced Energy = 0.2882900719089045 err= 0.003279340607456776\n", "\n", "XII\n", - "Exact energy = 0.4504792175806916\n", - "Initial energy= 0.44499999999999995 err= 0.014161351841243576\n", - "Frequentist energy 0.44533333333333325\n", - "Enhanced Energy = 0.4483904722251097 err= 0.002798540639700969\n", + "Exact energy = 0.057729200917975426\n", + "Initial energy= 0.04249999999999993 err= 0.01579907719488871\n", + "Frequentist energy 0.05399999999999999\n", + "Enhanced Energy = 0.056905268704221315 err= 0.0034293158988178076\n", "\n", "IXI\n", - "Exact energy = 0.06428637695352224\n", - "Initial energy= 0.08499999999999995 err= 0.01575613575574571\n", - "Frequentist energy 0.08066666666666669\n", - "Enhanced Energy = 0.0627803643652616 err= 0.0031199481632141163\n", + "Exact energy = -0.1820023221878087\n", + "Initial energy= -0.19699999999999987 err= 0.015503478301976787\n", + "Frequentist energy -0.1979999999999999\n", + "Enhanced Energy = -0.18174248042214922 err= 0.0034359625364898836\n", "\n", - "Total Frequentis energy 0.4226666666666665 \n", - "Total Enahnced energy 0.40443338122326844\n", + "Total Frequentist energy 0.13800000000000012 \n", + "Total Enhanced energy 0.16345286019097657\n", "\n", - "Total Exact energy 0.40690965226476494\n" + "Total Exact energy 0.16259474451688755\n" ] } ], "source": [ - "\n", - "\n", - "print( '\\nRepetition',repetitions)\n", - "fit_energy,fit_variance = test.eval(pre_energy_freq,std_dev_freq,q_instance_post,repetitions ,steps, steps_pre)\n", "\n", "freq_tot_energy = 0\n", "enha_tot_energy = 0\n", + "\n", "for H_part in Hamiltonian.to_pauli_op():\n", " print()\n", " primitive = str(H_part)\n", " print(primitive)\n", - " print('Exact energy =',exact_energy[primitive])\n", - " print('Initial energy=',sum(pre_energy_freq[primitive][steps_pre-1].values())/repetitions,'err=',sum(std_dev_freq[primitive][steps_pre-1].values())/repetitions)\n", - " \n", - " #print('Theta values=',test_in_use._initial_theta,' np.arcos(E)',np.arccos(pre_energy_freq[primitive]), 'Energy',pre_energy_freq[primitive])\n", - " \n", - " print('Frequentist energy',sum(post_energy_freq[primitive][steps-1].values())/repetitions)\n", - " print('Enhanced Energy =',sum(fit_energy[primitive][steps-1].values())/repetitions, 'err=',np.sqrt(sum(fit_variance[primitive][steps-1].values())/repetitions))\n", - " \n", - " freq_tot_energy += sum(post_energy_freq[primitive][steps-1].values())/repetitions\n", - " enha_tot_energy += sum(fit_energy[primitive][steps-1].values())/repetitions\n", - " \n", - "print('\\nTotal Frequentis energy',freq_tot_energy,\n", - " '\\nTotal Enahnced energy', enha_tot_energy) \n", - "print('\\nTotal Exact energy', sum(exact_energy.values()))" + " print('Exact energy =', data[\"exact_energy\"][primitive])\n", + " print('Initial energy=', sum(data[\"pre_energy_freq\"][primitive][steps_pre-1].values())/repetitions, 'err=', sum(data[\"std_dev_freq\"][primitive][steps_pre-1].values())/repetitions)\n", + " print('Frequentist energy', sum(data[\"post_energy_freq\"][primitive][steps_post-1].values())/repetitions)\n", + " print('Enhanced Energy =', sum(fit_energy[primitive][steps_post-1].values())/repetitions, 'err=', np.sqrt(sum(fit_variance[primitive][steps_post-1].values())/repetitions))\n", + "\n", + " freq_tot_energy += sum(data[\"post_energy_freq\"][primitive][steps_post-1].values())/repetitions\n", + " enha_tot_energy += sum(fit_energy[primitive][steps_post-1].values())/repetitions\n", + "\n", + "print('\\nTotal Frequentist energy', freq_tot_energy,\n", + " '\\nTotal Enhanced energy', enha_tot_energy) \n", + "print('\\nTotal Exact energy', sum(data[\"exact_energy\"].values()))\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot the results" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -597,32 +638,34 @@ } ], "source": [ + "plt.rcParams.update({'font.size': 18})\n", + "\n", "lenH = len(Hamiltonian.to_pauli_op())\n", - "freq_rmse = np.zeros((lenH,steps+1))\n", - "enha_rmse = np.zeros((lenH,steps+1))\n", + "freq_rmse = np.zeros((lenH,steps_post+1))\n", + "enha_rmse = np.zeros((lenH,steps_post+1))\n", "pre_freq_rmse = np.zeros((lenH,steps_pre))\n", "plt.figure(figsize=(12,8))\n", "for h,H_part in enumerate(Hamiltonian.to_pauli_op()):\n", " primitive = str(H_part)\n", " for t in range(steps_pre):\n", - " pre_freq_rmse[h,t] = get_RMSE(pre_energy_freq[primitive][t],exact_energy[primitive])\n", + " pre_freq_rmse[h,t] = get_RMSE(data['pre_energy_freq'][primitive][t],data['exact_energy'][primitive])\n", " freq_rmse[h,0]= pre_freq_rmse[h,steps_pre-1]\n", " enha_rmse[h,0]= pre_freq_rmse[h,steps_pre-1]\n", - " for t in range(0,steps):\n", + " for t in range(0,steps_post):\n", " #print(pre_energy_freq[primitive][t])\n", - " freq_rmse[h,t+1] = get_RMSE(post_energy_freq[primitive][t],exact_energy[primitive])\n", - " enha_rmse[h,t+1] = get_RMSE(fit_energy[primitive][t],exact_energy[primitive])\n", + " freq_rmse[h,t+1] = get_RMSE(data['post_energy_freq'][primitive][t],data['exact_energy'][primitive])\n", + " enha_rmse[h,t+1] = get_RMSE(fit_energy[primitive][t],data['exact_energy'][primitive])\n", "plt.plot(np.asarray(range(1,steps_pre+1))*sample_every, \n", " np.sum(pre_freq_rmse,axis=0), label=\"Frequentist RMSE (Pre-sampling)\" )\n", - "plt.plot(num_preshots+np.asarray(range(steps+1))*sample_every, np.sum(freq_rmse,axis=0) , label=\"Frequentist RMSE\")\n", - "plt.plot(num_preshots+np.asarray(range(steps+1))*sample_every, np.sum(enha_rmse,axis=0) ,linestyle = '--', label=\"Enhanced RMSE\")\n", + "plt.plot(num_preshots+np.asarray(range(steps_post+1))*sample_every, np.sum(freq_rmse,axis=0) , label=\"Frequentist RMSE\")\n", + "plt.plot(num_preshots+np.asarray(range(steps_post+1))*sample_every, np.sum(enha_rmse,axis=0) ,linestyle = '--', label=\"Enhanced RMSE\")\n", "#plt.plot(range(num_steps),-0.01+1/np.sqrt(range(1000,1000+num_steps)))\n", "plt.yscale('log')\n", "plt.legend()\n", "plt.ylabel('RMSE')\n", "plt.xlabel('Shots')\n", - "plt.title('Root-mean-squared error (RMSE). Enhanced noisy circuit with '+str(Layers)+' layers ')\n", - "plt.savefig('RMSE_'+str(Layers)+'__rep'+str(repetitions)+'noisytest.png')" + "plt.title('Total Energy: Root-mean-squared error (RMSE). Enhanced noisy circuit with '+str(Layers)+' layers ')\n", + "plt.savefig('RMSE_'+str(Layers)+'__rep'+str(repetitions)+'.png')" ] } ], From 2ee6050cab5735900d5c163754441128dcbee51a Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Mon, 5 Jun 2023 10:38:52 +0200 Subject: [PATCH 03/13] add png for readme --- doc/SamplingSchema.png | Bin 0 -> 94865 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 doc/SamplingSchema.png diff --git a/doc/SamplingSchema.png b/doc/SamplingSchema.png new file mode 100644 index 0000000000000000000000000000000000000000..4b759c4b889bda94087ccc41c8daf9842e38f0b1 GIT binary patch literal 94865 zcmeFYWmH^E(fn0RjO61c%`64ncyuTX1)G_rYC41{i#T4Km0X zp6@;9{q9=#{`h{}A7`z1uf<~auIlRQs_N?M>gsS+Wf?3CQVawH1S~mONi_rnFesY`T`9`e$^YkFPZ&po&UVs6k#$Tpdz@yEP zsq`#O&J+VkS#v#&`AVr1Mnbqf>9$q4zN^~F%)H-4Y6eR3j_Ufs^J~cm8G!5j;vs{T zME=4g5&;1N!xGNc7bQgjV>=r*LlZkAQ#N-SdpN%c2tuOn_J+n*rq0wxrskHm!ZeWf zZW?M!6JZ*y4@&Gx_7bKRma?9Xrs|%`8pfVh#{4EUq9PbV?gDTEHm1&o)b2LcwoU@> z!ZiQT6@dSK{tTd@{s+a`N|@%0k}9=?ouer=Hybw_JFAqtr7I_m2nMx~qluY-nxyo< zNWkBOX)K(b?F9e;H#avnH!e0iM{@uNKR-W!ofE*x$qL6{b@H%vHgspTb)tPH@n19~ zO`VJ#E$y8x?QE%^X&M^Yxi|~c(7@r;|04dZg8xI^*6CkDfQtk03;}Sku><})y0fL( z{|EXrUoyY|NqZ_ zI{6>T_&?(MkGTFv68Ik>|Hr!iBd-6E1pY_J|FN$ByTpa@?*Px#79Q2P!Na!(@jXj; z=!fL=QBDI5{&=IAgdreMBgjdLYq+l-Z+LkpUS&N!XvNDpiu;G>k`T}vS*ht^M$ms^ zHYvwz{IIMeaguEIz>2E-p|L%%v$;p5UDnI0#?7Xtlc**%QBSYOmA>h_MIKVQ(t3V4 zLDoG1xjYNLm>F8aS1zZ?2}sPSp<}if8h=Mlj0|P)D0y}N#I+|7eCLf%6DM0xSQvsM za^s)IWlr!~B{{1FPPEhjm->(DW{{e>mM+k6(_>U0&?-N3AkrZ_h zE21P#Ww(rg0pVLjx`xL}keg?_P~OGUnxD$Prxz}6ToVvqR#w*H;RD`7R_c~lixBjp z1a!V%h>k9NpZ&U1J5c0@37_>Q;n+n1vcbVnah{W$R z8Xw!qIJ9m1RMmHqe0U7x(XYdUjRT!oX`k76LBS+R6O3Z{`VCnXBRxa>@~(_D74o5R z;u{oZg5K{~(-PbJzynkQxIZ*@SEVHTF6{}6jJ)JTK-D!uY#OlWv9)^mR6D**fDw|v z?ZGF>NB))oqfsm4*(Z+J3loMl#O$`oD=N}4al{oA(BUQE$tkK%i_9{qQoTYo+qUqh z#FVP(Lr0Pjcn2R1iO9>p`{vFy^@2+6|*1Tf9Y#m`PLt0t;X$(W6C*n2Q%r1hSA>31s$W9a1H8)_b z;=ScZSF=H`; zH%FR_K-n+*NCan2uVRsFN+%FE9`CKx_T7kXXx{5yv0QbR_-7iCHhFLfQ~Qg)?lDuK zSxJs$^DLFKfOQxgKe?>q>++@+h*6&6z__$9e) zMhXrta7%vESND+)8F4v2L9S_K-p+?uEmtJ)wi2x#g zaLorqXCF@lH6N< ze(l~n{sM^#+7+}kD3s?4nCune;=Nt>V7i2qzEVnR@YBN4EOKB$qz25%Q6@Ef~d4u6PV zMpi*iZ1Av{U-K0b`-3kl+H=4B;J!FC)}rt?7={H!@wwuU+Qni%sb{6{pEWa8mrVU- z8x5q6Co4C59;VeW_*0I(ME{u^8qN+l?|pf%OG``Pmh25=_^?dEP@x)(&x#xJjKInL z^7OU4F3k<14&fPEh{R2L#+#ylW*IwW{SQl9%NcS}^EAXOLkBUk?E=vk%mt=z;mst< z`CsRa&J*4FP^JcdY~XHwt=avoeq53lI*RyyVyqZILgYj67j~pjv{-ZudxMGc z%t+vCIQ_Ud{vjL`%NcjqX(m-s8J)nHu0l9%n*NYC(e@L?XXyT-zl){bz;k8rvGpOd z{@f${JcY>s=S9rvweqb?&9fc!tI#3Js6?GO$Wy=Wfh<{9{(~*>MN{^~03{Cb>g^&P zQcmCVcu4k?xnm~J%^1Z&$_4irTfzo zuYrX%j4M~n=N14MABB5Avb;0|KkS z3roHV3GQcZ)6!q!PJHq{%kf6%!UyL0R%jepPOi9N7fAk!d8=wQS9K?ljHEp6tw~8*ZYd4#(j6K>2F+8I@! z1`5g4M?=@w4!N21w@%s(o-g0n@i}-YDb5XejmRxj^VS@eJB>aJJ7(5yy&!*Q>^lVS zjA6UQ>7}hr)w783LUT=V(MnXV#8w*6rlM7ey?c>Vd6l0>O@B|=fJ7UqpiE3r&G?!c zk3`z|!}w@h;rNOURi!v@5m@a@?C`vXs0NH5GPn zosgI)siqcBD4j`Al0#pNSYr3=av}w~5a<}CYv`knRfS(;;$dRftD|4rfd`v)$lCY_ zYaXvNm>e6Z4ppxQC?*VagTmz|7g^_p8`8<6_MScO4(9EH?@$a?H8L(^qc^_-YWfR> z=j9_TQX~%TM%rDW-JUOUOB53(<+Ni8OMEKd?)Vl#Vp}cOaj8FN^OvFhfy$L42%W1T!uqF({tTJ4eV`ML0$wtuA% zUa2J2)T6MWFz&X+`heBW1T%ZvnqvNYq$Rk53}Uvhw|XkPzVX5Os{^l-xqcw1Phq6h z1J}xTL#EnoTxk-xRI@YHx-->5w@UkXUY_bTOrvR2)=M!rRb-^COLh5?hmzC5R(CZ2 zzC6`;n>BHvxvQhiQPby&(9z7~cgxQEJzo#{T|1A4`iN%(8N~?sVZc0KsQ7_3h=m|J z8-w-P3U!bx_P=rrq1im(5!+VkuX@vj9&6ZZ_XI?-w9bv!RloW4cSXpth=kqdML91^ z82@?cu2g>ydk?oR$SNZsj`V>D!Hu5YjV<51n}q9*mjlPcfyznRUW^aES|eYZ}`355;kl8{#QUdu8%jQDrx-;$8`R7 zl`5+(W&E8-XS{WLY1U^+Y5I#6vTEcZBvdFjD-JFRdG9xWlMJOwgFo;&9@~gSE16gf zpEx5WR2Ouy>6o;vYRxP^#q3j)msNB}BJ7gXJDX4d45z$f+85INR_rzAyX=r3-sfPz zx9yYqnl*$q7R~O(k;9j!6Wwe&g|-tunQcTVGlVfq6$UG$MPxfdHEEMEgt3+vYS+g` zr;khW>&ZVO47$Q#r_pN&_9Z{cEN@vJd~rS06~FVQsA=w^j88^`^#^=_oaFAMH>dq4 zhHaob(~29-xAl?IWxkJeh25^MUg3MuYLwMsKMtTCy$@OmY1yOm!5bB~;3oDB<*9rb_nmB^H9;gk{b^u zE5`_r`{JW_Q=E6LqWB;PVcq>2!!r5KmabUQi*JnPz9MPmy5*fJw`XEtv5mdlo6*S% z=E%ixq78(`9DU^^bTc1eo{|3I!U|B}wD>CKgAur1)_6={uxdS!H9&rask4Vj{~R zQ3*;=@*P1rD{RxqkD{@1OJy1Cn|7;iWS65PF3w}MS#ffISY?=Ypbo(1%I&Lw12;8xuQy5U^H3?1f^yhxkWg!7 zdKoF>roO8s?PRpimfdE2gJY>5l8FV!GncZmQ}+qYJ=o z^_Hgkl08xkPLV#(Pmfm-+MW=^I^g+S1?+mT;vPu)eaq#l?OquIdY_P~UH_%UjEjD$ zG`ENk&n`4BO_eB6E= z@a@|d(cz}-7K9%g0S{x|5mgh#`)_-|`QIw0#;5*}Ulgi~ zj{*p;LC7$VwXu(R>?Tb0=vMfv)kAJtEbO37FIjtpT=E~F2kNs2Isk}ljQ%21H;0~v z_qDjD?Pe5nk>|R-B%`6rmCh$y@Zn0m0H9jk20y0AD8~rm`f%xdl0ySuCOVH+yaDch zovHjko10X=TIZ(Tgq*aD}Wav+{lbR&Q@F{Jhx(64rbNaV1XhdzE@l z`2f`%s8UhKw9ju*OD!xOf+nXrV4CWgf=MDoaZhLqz$CS%@r^TVK|fZ(F@+J^r_7Op zn;AfT*$p|gkH*z#s&EV`e$E88h4 zDk{xKvvOjt6c3?vyJB=TrUx?rN?9)E8|mOo>05L9;(QdO!R=nU){siWxqKFMUypa% z#+>YQ&1*mpg8^y}vL{XT5+$3-;GxT;Tq7i)L7y_1#6cEEMU{2}9yuVCjXU$!Jt zr_N4U-RMjIgsS zcU82hUgdsL>m9O5($M5TTOEp9b;X=lRdVsM>hbRQQ8zs9kZqYOQt1DuZ?Vk&T9fiI zbT<)Fl6M+)lDN?wHp|K+5mWWbrgD@@Z)gFYOR}{yNZ>%J7w%Jb6uMvX{M{W zbW^a!i7C~^ltrg0fVQ<<`)Rs@a;HF-_zG{MRc0NFZi;klT zfK)$mPc}#i0QF&#r)>3=3F}8L_KaSp-KbdMt}wY@GDXzqk49Wa zVI_JW5bkZZg?$FLk95>oEtoMN8;tzaWY%G8Vr$134oUf)>dP;svaoH3V{w1u;~>-# zHy%Ni7@L6dO|993U#fY^^f86f1SEK1Vqj)5Ou+w2f2}?=#lSZ$=i#!r2c{apY1dhNx*#p{ZuP!^jgOp`_N`Tzfc6&uin8YD z+8sW0jy$d)o?{{al0?@W_Y9n|@uS9>_@?j9 zqXrxl(t%6HV}=@k8DvFX`z%7*Bs-78~3+Lg_2 zeql$>7YxIQW4;%7N67@STpQ7b#C-6j&wWzU_x9WM*yIF##)_uSLFUH=!S>kz2CDFy;cH$y!Q;{x40eF&y}6-%F%kozYdqA zVP$3Y{@aT>k;$*FV1hu?Gu*Z96HyP3B}Y`#Ofb7gN-xWDXSC4z|E=$!S~hGx$Mk)KQ>QTT5WN4H?Sj~Kon!PkXv;42D^Wq zF+ax6`%L?5_q+USQWwCkL088$da2h=!SP;eg(tov)kc4GXgx?j+QkaYc^z)y=Mjl) zeJ7g16aj*vIIYoeK9#ztsp;~J`#mv~S06y6+qHd_-jc-tjcy^(8UYzt%!q7aV(Q4v z8Awi6cDgSt595l9eH|9^yg$P%6tlR&Y6uelya0bm&VD}&^i68Z*!b*n@-TPe1ddzN z{kTz+L}g=@@p|RkCU3H9@Ii9I`J10iclYFbU)^4XJl#;2XRij1hcS$qJ!s0?W+}`> zsPWjoHyw>|G!pc0Z?-MSe<7P8BW`CYqMvz1(d=kqGVON3B&bed6W$bFf7&@yUrX$< z18fY^9tSMh4bPv_a?*tKZO6@tIH1APJuiK&BK-vMu|fQseO*Ct8(fjRdO-yfIR~Nd z>!QG?L+uErG#b_~o}bC4QDLL9Qj*evO`8XLSy%dpoA2LStrpYL+v)oP-!^*jTAjj( z-s`}A^6iOEwZV+anr&7HQbfiVwYE&=@)zI#ofq1hNpW&^l6)9focO|uQ+(b}+S*SR;VAkVej@eK#%uNwNf;!uYQ(XUi9YN3$!Hnbd7RH= z%@Vo70BVg6iOC zOHi*C4&ESoF09#xmFFE_ILB9?;|yKp91xWwY*mwwB3 z*6HUzex>~@0u;j=( zLfs3hE)cUk9-JvBXZD!j;lnJF#0=N1HMpfV*Hk;0_PYcl4JYxRg9KmAviV9KSIEJ> zT(-v+kE?foz)=lq%vMZXdNjvOw6P~cn);s#UstVq7zMsH_IZ(Jy`uu9RWle$65oE5 zRhicn@NnN{cBV-0@^Qk@StzQ%GCI6IN+W1~#+g`%o+1=0lduKa9h$NJN!sgH1| zBHN^52(MDlfLFy+8lP}>G)y_m_h7&5ceGNbkiO7r7JMDD=Tqb(XW;mhN9mv3XGyG^ zuqJKa1vwHrqxScq87DHa*DVtN5r+_tPDeI6G18#^)tv*!r!G|fGC>4Nz5u1=d{0Nu zVI%*Z%gDEA8tl^Z1^ctpAIhkeB<5b;U$kK>_Eli>ERmnV5U>!#H0Ne zr%$aN-jGQLRY|BY_B$|Smp7|kqLd3U1b_bo3okga zp0_7Cp^0-MD+}%K=ThYL>m(j7kXr`bjOyt*>BMY5-fo=4a9pE)ZDg--lwG5PfL$n@x3f(#yhLF#Sjorg9m7hXUTo@q|UbrPsi)#;7rp>9KW{g;~z z$J719A`EKz4KKdcb&;-4t;g-2K=3-}j|!GAsdC8QII+7M0=9O0awqd5ClIoOH`SZJ z>Yc#xDI6ti_mA!$V|k{AB3})2U1JFH>NyLve+wS!SL$%hO>-lCNp6d=T~C9Ak0-05 zL^D~lotoJqqJqD%(~Eqdf?bB6LVh>qM$e9?VO&xQidHQsydBqEd z-jmzvNrP9^(}ax?n;-PRraMkKCSEr93x2PrUx$f=Ud*bGw!Mp5t4^2I)WNC5?_&Vk zJdnL%G=>h#xh@ha8A`t!*>vkX7MhNnBkLmy6O+dyQsHSa8I%Y>u)tbZBvUo~cZ$moD>%0a!qIp&V`;mcD`${MXAgId@Gv)0V$u3I_;yB}Yp zKE;G;9cHY!P2|r+#AYT+4((`|nXhR7Ep;ehL@D(>qC+*>99Cm2ayWW}VtFTv&tD#x z=fulVYO1aC0)9^SZ4wkyzjrn)s0Tf;swE5c%+$o zr&I}lo^MuWONR}H>SKeA&e8h+`s&N}@jjEn6~F9> zRoEkoNB{huA=F=kyaoMnrfl=z)Xu_qO+)@T-S2d@tqk<~xQMh2F1iG=IqZA}DOf zo=DsCWF+>W`YqxKT94DRw=c?_a_+^#e*Bu`Cb!v3YGa518?d(o6s}BEyHc928MH&e zF~is4XCse=>b-Q{#qaB5J{NadaRXN6+ey>PtiHD;)VJ@4Fa zTQhSXfh{IkQ^=aW>ySt?ZFol2^k@T(x!(kV;n(xlgI^*vC@{;koz2({tH#ZFmE}g< z@DYBu+uanmcI!df7}dL-1OyWklS}ukUe#tR-l`^vp`YiYqM(`;1*Oj}+`m6Ke)&6i zQ{EfJY#wK7T|9+!eda3=K!(hs$Nlr1@q4e9)b0^ONT)`hSGj)P80xp!i|%Ajy9TUJ z!nQ({N7D{cJZYOb)8b>oP(LLlj5X2MkaO+o!riF($p4i-V=hwv+nAaCNnNi-r40-BkuDPJo7>{FK%EO?SXj~nWLNHxkCWDsP zj5|R#9MolPkKpruAEC5Zxk0;V)zecjI&ZV;<9AvvR4XxJ&f5hA+iXF~a6dtQ`%DOr z%op9%P17u#UY<*F+O3VP_3OLq4;LUks{RH-o|CKV&Q9bYjr&cdAw41oT|clK%ESGi zg@k$D!CD)Q`=~vj!GK=$+k3wI8>B)%p%sYhy8B<^Lc1bWPdyw1o!fNxwmKDftJhANTj-p6+A4p6UZ!J`a2BioJ^3)7DX?%K1I) zcSsprq(lj{SyD7RyGmfn77i!#vbe?-@{9*#Upo0yKriI|3_XVzd$OA|+CuA;7;i^U z_4_UhBsq_p_9d$-NuzIIIIa?`Le1r&>^|P_d8ZVMZ|;~_rW&1e%^a@@0cNj&3q04b z@5&ud4qJu-xQ9>k%T}q`Jexxe;c^r)cIn4t1(xf=5Z{TWDnrk@sFfAhF2@Z5LU56~ zyY}~HLWV9{#^r`B(p8(V*9)*a^trWD;K}yEW8Wo|IiurmQ;cu7iY3$yV=ke+DnG%=rgqH{&idr>Kh;Jbipmpt}YC<0#!1bFKF4lHJ3(-R;V&MP0><& zOqLPM87;VPVx(*iNkPR8GTE?R>%qFv#_x^-cELD0 zdZLTz$SI~Xt@UAT?d{!fCB{C-<)TuciA(5`h{;-Pocy*+LaWV>UXNhDo8DpTJ5XsV zc+msa;xKjVP47icGHOUF`aRzpIIQ7T%6Wa?NMg`on;($I&=T)p}VZ^6zQmy5`xdZ0&7O|NTYb+ z@%Jyf{yub21#wPA#haF#q!8BW5`6OH zi29l1O~ziH&iiZ~$t*WAFJIN^%8_Z<9Vv$2m+<9NHILJM^1_o{)!Zgq3b zWig=k6uMZ7;?tP;W^1yH;#B!<>_yZG-&RS%`IVB!y@fbzAb3-cxfMh;R$}#J@AT=~ zk%YclE8d2;5kDeQR{yL-zbN!{dQ%}C}s9K4jI1XxfiNL>tc7vOo;Dk7-w*LG8YIO<-z)(v=L}A z%XpRr%u&%ij!;r&fZUa464`#+%}o>u<(nZtfC@2QPN(p$#7zZ~Oj0<;y-nzTGf|>J1Iw4196T{VuRlA--h?}|5*sGl`EA&xhr1^ci!1X)c zAaWkVy&GRjQP!wXksR^O8@8ieE+R+DjU|Q73p!MDCBvcEVEyok#|ikr@{Rpub26p3 z?~zDz1pAn?crMvPh2M@eG|COI?_S6u`Cak8*C=@B zI0dh=lM9zvGj$lym^=oUp6<+MKe=k73qG3LfT1YK31#Vu7?k?MecfDqYM+%4_DDMj zTbh#9Z!KO(>EYonRlTo+=qs&&*^rl*D-4?76yr=h>?U^Crn}@IJIOG`Xh}*qz&aMJ zy_$l*qPCRFYo9Num31&ofyYZdS#tUs0z|1UCeu$1Mh1vIqEU z4tJT>_bDHCwra9Jw#zLTE94utP4>c1XKRk3GRMZ|9do<<79Yh(wc5yVu=yQA3ZI+l2bCi0R@fQL+ z@$;jE5^e`ral)SsQqvYHx9KL^{s`#uy++!1MV|sh!N-+*aE;qebh=Ur<&? z+xm<1DzBp0^7m#OR+=y9MRkdOpI-Ya+4BRP7Wz=pLgO5aUL^*bHUJE`CtI-Hue(=s4Kj#d*+U zI6juBmm7qT@hx*FK`uGM&4n_KCUe>oTeI$#8DotuopUMk&Jta8V&c7L=xo#1`+bz< zKyA)AsG_Hr%Cn@jQzUW5Dj< zZ2+0bQBO{Ge_g27bfEYiSboGsvK)z=cYTaShUv3@4`eqOUC*2h@^qW3@lcT|fZwCs zn{JcH`aMdc3fMox9-5!i&K}b(Z;C~*XPswV&vkd>COWtWX}%(#qIZMxW#;HB4mtn? zeVdS%gz5QQZA@W#`x`6ZYSXotpSmwIzV1!R?~a%!s~=D-b3TG_Hp#ePU`E^QGBLd$ zBth$_i}hCl^$uHUi5;u5qiLP5)bA@pti9_q)1TG@ogCI+R-)D4Jw@Q&960OLpy8A( zG`>jxvOCM?@jDODz-Kk)Xrngi#J0xI6`B5*ZPVwtT6j`55%DU(nmc_t8tzWkKlmZK zAqUMFVLt7Z_&FRG=V;rU7kQ!XsUHo(lT#?TfbX3XT3d?G zOh4jTmWt(G_!2}K3+rcC9yxV>bu&aX;pahO8glq*lXhJ0_KvmX1i6Bll|fwr zUInb0yD4zFKtsHV8q%-n$f>QJFgg}ExXm6FHF*rPdgb-BIF6rP|E18(;&t`cxn$Fd#EW*B)Vhsed6Tn?5Y!eOfsVD+gZHP8pd9kJTBkw zB>Z6Y`x)G9Ve&(VVe9|OIxtGYy5X^S2aDjVx?z`$66beKc?7zEUgwX98-&`9MnL=@ z@nVj%mO}3FQI_~HeZbso!v6e7G8&^dp*<8B))77;37*I#72gxO(t@&<8v=6}zm5z!OvFAN7TbdxRFC zHh%A+OnMTmf(Hkys8S|1{O|4`)d?VaA8*~3RJrXaE)q-KK%TDrg?9Y!?#{SaIu*wy zOd8-P!*q0!CogS~4_^wr(+KyB!NVU-6$r>EQvO}U|N4^W0@gX~(Iv7he1CpZ^61X# zmIYlY#3kJn9-I46%(tx4`^nJ}vG;e+lD4CofgOgAiagoAA(>p$m3myxy2Qxp%bd0T zBGJr!9**xS*D2(Ym@R`+b;5<$atf7b8>=0Rj8Ob;hS+#+S-Tp!(sftZ;MXPyAMoU& zwwh^nDO&zldm4rtS9J$h0L-r4pX>x(q7Cb+tNOA|?#gjvevUtlmMNgYm(WY+JKl6_ zRuq7bdyANX5eph>`*g&}A6FFuq2V+!E_UMR(Lx>&n-^{jqX*6#A*Nku)!ZL7$Ge&G ztVGjRw0mG%Z3-lKsSMkqM!(FaZF$g(79ss!S{C!;&wbyKSu^MQ zR8a->t3Ors8dlc#`A&E4&>vx$SkcId$<=%Pf=hpYcTX7)#}Ji>x?{qFmSmwv%6iI; zp}Y1*6G>@WkRCm>7w^RXAigmxltf;L1`NT*$mae*MN{dnG**bK^;j8IW*c&@n z%Q@Vpn{r;n1Qokst98HNBrlyd)GN7gMM2Rdl7rE&j`|pL4&F*$I>KGXlIGEDLIWgh2l}tX{pcl<8vU1A% z!qgC^OC0EuFWtv)>=LU3bajrL?%a%lVE0!r><<@HTlah$zNDVo{^CHUY+w4g$aVn+ zWs1$UX=*g7zgHJLZyMUFQxfC;YNxJBxWGzZpT1T+vLQM;IL5#w>8n*A7NV8l?@4iQ zUDn$jKw>{JWrT!Xj*l=IUJxcoJ^e-anVl*>*zEKv#h(3$_iy9V z=V;>v9-a+eg>gxf#94RUfI9>njNx^*KJ?}otu}`GY>h7GLh&v083uNnJ-Vt@uf$Hh zzKY)mKXe1s6Sds1KH{f&Od@-O(z!X?3VOvM(}3DbIi9xUKFY^sm7IE6Pq@eDa%;MI zING!|^t_`_(2lcXEVtsXyT0@cVYt3J$v33!mj?T8vWjCjh-p?A+lBHU3zK~gL@!Vw z0Y<40Ie|XRoXk5lq;;bD9G70#R$HYXTN<@nagK|o@zFHpaS_&82q7piEVYzFfu1~Ej+s(M^j835oJ;vLHGEJPQJqJ*Dd8^Zr+}knxW+tZf zpE|9~I!|`DN~4*Fnma3xf}Aqb@u&9ZO0A-TgK1ewl)u=#=E%B!PE5?nY(-(_EB7Z~ ze-yzK1XgmG%??;n)49Aob<^yU&Kl$8>lFNkLCxiydM3^>XKzZZ=J^net3y2zqtWG@ zZH+L=FV2b?1e@VW8<^sb5Qv+3;c;=Ii!EtnR2>M)TW_Gmkyc6Fep}5ll^Xw1z}E=K z4kbUY1#oAlb!tpg3ax+4F{eY-S$1m}&-gs%p1dBftf|szr1)y_KQhJkJVT?w0G;l9lblE8vf_U8wILbCu^>uYUbT zvg%!}*vr~22oFRbW9Z@NR`iQcCc zv*?-3tLJVy$rzAep;`u+tTs4oz`lnnW^Bth-WMd1GWC@ok?d)mW&$J$q?SaL}poFu;a=io+YC1A0 zUKH*6#pnSoly>Dgs8`ro$7u;YuXUCm6EkI7nP{3d+S5CLU*lk(9c}9h+wETNE%MS) z$32qBq{=>}CEgLz=*@o8myt7MTfu(W&t9XFBh}k!wQ>hb`Qqa<@!L{fB<2bFp{a_g z=y$r}u_cOhde#I#G7D?vH=rNOPs^7tp&nKq2hB%JOcV4@@<%S!0HZ5FQxZ|%;Qy`# zsJ;84QTYv*9~P;I(bef1)^}+Lv-~(Sh6leFXB@njsu6PMA3XGjV^s>j)niO9`$*05 z7`D&H>}PsjXmv6%$t@ehWQ*mQv7+u42;MxRq$$=D3h3Y?Ev0b&;P5wMbRw+N*6|wR z=Y48+7-V_!P`k#xNCgV{;ZzgE7z5r@SzT@g@X*DmK7nZ~K!{x&R^G6>a|*kBZ!kw0 zj5+hL)XyVfRF{!vB6YTP2XIrHVtzEGEUYWNC~4NcYi@Tee|77A$1BtNRK&E-SLpH( z%mQ7Y+&yqZDP>!>jkW3NP5r&;_7@3AK`C=Ks8?3@lJ)*kY-w0&=g(+UTs;=nk0SN^ z{bqEQTNu23>(z%)iFt_N*xZ6yGZ!%@TgLJc2|>S-r=~#jLX+yu0rw*s*46OMB5YVr zMS+H%IDcjywPVDd)SeOR6V=rSI|OJBuUuO<@OBkzW?G*PbCbCDb6Ri5y6zM<=mvK` z7(h=2yDBe4h;Cl`FC!7j+N*pj;1iQiX7!Mxj4cSY)PTRw#TOygC8a4N*=tXla!+idnvR9WIRI! zyhXgp3hEC+h1_-?ET1!~{2mn5-l6i&$7#y>x^j``cYI>d16u3$A5OW*Z!BEC-N%Rj zajLxGdBCOgyNjXmyQb)`d5DCFKi@gi(Z-xVph;|j-Ent3om&r7m=_O*7jHWMVJbx; z`A*Wn+IIx1^5rb*sp%tI3c}krBG;(5EuX6;Tj!a+ zTF;pcyXD{*>4sp0l&ZbEe~~JkO?mKyw`K709^u+P$O2J-S@HO zNSQo1*jMe-?e;?*nm=u%oM5S631HJ>_R1?~An>ufS_)zid1@`7R!@Ues6mc3TOwXD zDzvFM?;%M$Q`;R`@f~Klp8H@Zk4n_XdapQSpYV5@eH>pCHE7~$em~!_lPvcP1fpAG z&Zj&WvU`lay1cn_@fC8N#yT=G{9jCcbwE|i7cSl1-QC^Y-BQwx(k&?<-2wvAjUXM; zDJ9+AN`s(uzTw{Aeeaz=6g`|hGi%nY_`YxNV*x(QjnRQFP}F?5EV7!6eJlBGGEWNb zA?C@iOWePcQ?nJVZRG3Cmi<<;i=na4N%~uZ>i)f4Uj~Ey@oAvn_ zzv%%-g?G=gpzJb0Vw63I8n#pB&@J0{qyN!?_r#rNcu1|#mj5PrpwshXJ_Umc(l7BJB|H6m^)^VX-66wZQII-CCb zUpqvznl4H|Vu|I^{;f#Ms}VyF>Y_${RX%dFheYeOrWIK|$Brq9XT9Z~II**Bl* zcCNAB@BO+(H!i|SP5v>Y?anxG^n0GgvKutnN=E!$%&c-wQnbADgv_n1$;W&#eA6$f z@}s8-ESgA7CYf<<_dY{W&+ z)|tUo%*A-&ySzoQ`Dv4Kc>WE&c-!Tk^K@?^a+@@m)GUOz?-L^L z%>Thf;Qgtz>ie3riYU9kf^@uPZ(Ho%sDZI;e8KFsBb?J{s`;NqBs`s}@0I-cmPc~* zXxBon4x{KZU&)i#F&@k%*pjKVndLQ`urB+*Eb4xd8n9?-iM+}mq03y6yX>p?sT>Km z#12&Pm3prdJ&HnmIO4HroEt3_HiWM1M%(1{qi0@K^K=Kjr)!f6u|+xHO62jxebe3e=(nS6TIw5J6zGHo1L4U>n?PNoAZRA zSatC~2r*JJFE`#=O_uQv8$+MMd9?f_5-eBxRc65$$sp&i?e%a^X|7+w`Z4croX1LL zRrvj5rJ7_qnu117g%xF#1w+XUW-|lh%dO6uP}!S<^lFs5ol-J1MB!Sj<#-JN-k(Qr zPTTkzOlvl)Hx34bf5&gxh9Vnk+iTZWqy*hXTKJ;jj*!J1?l1q?i%=4qpGvV^!^`T&dHTfIF0_?Uz-I0s_@Y zEO=?HaShWacpi{G{IGN!#|8`M{`BMHT}I%c&-`*bZY_o|Wl635AQR=^Ifl*maxkcJ z+^V_2hpr+dPuXN-TqQq)gNMJB`@{C^sL+cf2g!uvbpYf$q(kNz*WbH5vu~GPXE02u zH^1wYdzo^Ig6++DRPddfBF(CKBtxgdE1&%yB$1RXcxwWs`ZGIwyazROUpjw|C1{sh zh$4l2&EoFFFEXC-B!+5A^oBcsPdMHa1myp>0^R2ev0+XyoAq8S49tG&7TvHrB-}#- zB&r;jzsET*i;UDI^!vv|n3z+CTLncgvyefg#X+LIJhIK}JVv*B`45lbJ&mpJ{w)72 zQAzD3@I%JsPQHAe?Usb8iQa)l;APjQ%5!({C+<%F z`?VW$`U**~wTA!i&G{vYfC$XjWH-4!htkZekh)=!k#>zmH8B5-C?jLBBRNqaK8XGN zhh_ckNl)HV-$(HDfqn?v|9kn^(!T)>i%lMU1{-DeAK&?R4WEL8h5lW_%b!zR z92);b&wrLnWeDeGK>hEJN)}r#H+9cz#SgEeWO^;IF_ZQ=|NB)Xi~H-7K4b4S&*A6O z3e!iX&bzs4wxdpZwH%pu?*wC1QzY8!1KYhPqfcJXJco6N?lml#`^G(xm9pq?lkYUI{5^FB+soGE8->9rgJAR_SXF zLSTP_QedB^sG!14{kBJ0$dd|N@L}M8d&CgcGAgz>xSCGtYVI|Q3I@5-#24Xvwtf_Q z^d+sU@R-yqrmRpwZZsLDiji<~I;}h1a}n6|5Q2oTx3|}*m}4Q+#ClgT7~0{;hN2Hu zM(944u%g1YsKRFS7^Z|5g+&JK`LA2h?9};i{z-zRmLE+&%rTzYa6GN=TeXEZA%le| z!hf4@nif5Z#L6|Ion$bc5p!;{a&@wQa`bvWfIR5I^FTXSQ;fL zXAi%cZ);(c%4UHqeFxa9@>NN-8Ywvc*^D--Hkq41&?5XGk}%MlgD%0I*sGWC7$#8M zTew3Zw3pQv$9YW7kkXbP8?(QjzjbYK<}hTK=$49$j0MPvv^i{IqdmOsNZD zX3IVuO`ZA?7CX9WU-P@ck&MjS!_@c|iU0?%gNpPNMy%CT`e3V`Ts&!1Xip`y|9l)P z(sDX9Cr#eW|Pm}{g+I2 z!QH!Z_N~>gmuTaL^i+n}?B2~&)4RPsDHO)3RFdw6c&c)|;iklrDNQaW1sM$kmn5CC?0)$ zJ_SQ%@egPQ=u!URw|48p!mRw*al+Qn(8}=(fi*xRO?h%PPcm5(I?m!WMlW-iwmE@L zdDud0`ai?cxKWcEOy2)NC@CC;ny6Bfp3)VKu9}k0{t|iXu4Bun*|he)?gTFV{)B_{ z^S~J<_bT2-!FBFoM!(Jk%Ma%<*|9a*$z6`GQ3E4b7*n)%_L*-_xK8wa<$TMvqUj2W z#!w9z@M$7HX`}U=07s5dQVjiH)JRfT3eVbqXN?njU;3$C{Z>gf?{JrOwqYE3@46SV)0u_Nc{#aCpkr7mMlxtI zh~O9fc69GMHoB9@*H)a;sg~0Yh5L~*q-(~Pj2w^1rl2$&^WW$Qo+9G0>uK_sXKZBA zR(hrRcjHhvMya^pswJxwCHpJil{NFCYp(%Q^YwYy5t;Z&xQJiJqSNOHh1Oc)IW$*b zgx{f@Lg1(STrwVu23*ORVaTulhU9xy&mjW?fe=1Err>Qp(CG0t%_9|O43+4ZubeWW zt|UA_vJL+|@<%N<^Z&Uv4W0RB;j=&(_ir_pJ4?@Ss8`;2d57^(njK%WP!EQd65~<5 z@e1BnBbIJN`3Hc_S7}(O3DgtgTYZJ_DxB)wHS`MR!vlFvub*SY`BO02;%-;y+2*5j z5X$TIrKpoe>$1)rryE@C;R^q$*&2tkLuH!klv8cO$`r3hdpCgM(U{J` zy&2oAzVX(QKzIeNWP6teHD>19=HHE#kcq#Jk}}9X(0id51{2egttQNUr@p+OiFpzg zK0V*#U#Y8)Y1i(j==>L+qTc^XfhK?0VDoW!ip>2rZ<}{G4)v1|yA)Sxi`VxjuT4RH z|A$jN?e7z$*kmLDe{crW4QtQ0-0UupPHALPX4@h2iszy}@$nz8Gf4WDqm0R+evUm< z4vfuXhjHKdYQ|ELRX@Yn@?WNkcBhtS6*wzAl?|FdlVB|W&89N6z^bia-rfcC4wZ0! znL9SBX(&utUW}(tY`b?ryj;R5K*$@9N=e8`yk@Tmn)Sq~*?)`ncUom?L5pV0+U4O$ zAj?V(axkoUz^)M7VT#dzE97Q zy%Cr11;zD+PVLVLq>DE$g7X_W6WQUBA46vFb6z_%%)x#OI-n5Mqn8Fw?LGIU`i2w0 ziH^<96pXaQ|Al1NHyh|eoPpCsoH?IMdoN9^|K^z5| zKF}2ojOFm4LuiG>=uJVTq~P`YmST-qUr1p>864t2=eP*d6B&Xhkpw#-MJWzoA(fQQ zljv=Op@eDBbQQ2#UvS>EKoPY-eN;BUq>2A|FrB|}`2E}}6mqC!kg{>Y#Wprg^`mKY zqAp22v7BSzr~q`q7e@h-@IK;@5&RH(jBs%RISztwHCovcI#@<7#uPV19ydl0CPpqE zE(KX%5-KVs9KTK%f(;HaR`YA$%`@<`?5Mv-h+e3^eQ%ctKXddZ8WChgz{1CkaGfBSEn`aT zrOR`elfp(a(a185Q4;`+dEsg+i3T@J>2N(FVzjcy6&pvZH)rP>5hj z+;~DF`y&RlX8|+Ek!#`G-Vdk4oDFeky;k+#uMj`5KR6R0C~rG$-;HDsCQ_wt>@6F^PxBP=CP@5#HYRR&Wj=Y_ zcSKqb@qWMpwTf|W^D`G}U4uv?1yw5+yQnXYnEX#%5B>*hR3tv@I*Aw!YX+B-+*gzx z5^+}>sPYf(f5Xg2De;rb5KS5+3ej?h%U=?On=4UA>_T$Z)BpI7^%x!Lx!-@ zt@(vaOCESg+Y0U}L63;IbM>h~Ke6mPgAaB6Gm3{ivs1{cqI@5*XlNLP)L}lB6Wa7k zy!mgm&T{fb*llePd{G_my9aMyn;iy~g!&Q9aUsFu-eGh6oKr=gBeVq zn>lQ(CXZM-jw9H3((@eREvc8l*Zdo0v5&+naDE{nL#i54VovV4^Le7u(hrI%`t?ja z#Z^OV%{S4z)Y@OZf-ifZSsZ=vw>}GtO@S#@@g+3Tg3vTF%Pkl!9r`H1H49%qL;2A* zz+64O@v_2_d^2e6DvI}=!<>9q#9gRf3wBJ(tds1aa@Tvy>r%_7#ZVjeoK}Uoxg>n(uy!Hy(BhA#Mz1vntkWx~oH7;pwTymKb@ zwo1}&AcdT#(DhGBIw>}{PL37Kav~mrP#vIsI8T+s|4$pF=Y7c)>VMU3cc`LVzhIb-7fL`!RuEQkBHvx)n%qKQK7}Cc%IBUg(XC<;`3#P zAU!;)>bB3m=|3Gn@wd`;hkq_bo(ZVO+|dj2B2}ug-SndklIDLh7o0}s z6}Z|c#YD<^_9ME8aJeb%I9q})Tg@0W#MB&(8-oMUX@Hrus_go8ZgPlCA>0bntG7>C ztdB{i4>naZu9jL_7I|t7X9*uhg42W&wo=D;q8@dMnm8yfZSo@-=;Xda9^1R`TvqLKPgkJ2R~kDRl}2aobuOlL zfe!f}AAnuo7mVs4mFGMGf|LqT;u2+=f?P;HPORJrVQ;8Jy8e5vbHM<~hXqLPt83x2 zvw47R}p81xxNR|OF@Jj&n;b>H*F7|X@A^kDIJz8F}_f+DUZr~cY!AyQ70 zz+_0`&(ZpMuguC62UR!9`+|cGgB=xo)TZta8K6!n_=22Bk!59=-`LT;?{IW#pCT1i zs2)o${3028^drUfRw$$s<7;TIWof5S9C7+bJkT)t{?0w@1vBYBcB>)SI$MqPED)eM zZ`S_+({Npcn{7$ve+4JXgsO!1ArdRceK{udd6k$m$E2WtF1Ok$SXZ-LGAw(;@q62b z{h&uejc3onhI;oN;&!WewMBm9el)5+l%2ij*2((5o-#2q&Z2SkzXw~ptf`J&$mrZp9dmJjI0(6(H*!y!|$9lWZ%Y&vvy8_K&Ocy`Jt-N_> zp(Yb`awdM=yN7f2N4I#m_HSDpi(2gJpRS|Y-|*Q4;`X?)nP{q(xyV=mPvs723eF5Vc`cHm6*0I4z5&Shr6V|4Rw?!^Ta5Oc z8l^=uoKC&i_ojWZF^}m{44-JyO;OT6UA$>SO|FL&xvM29`=#|_|2>k6TXPiB^mu}e z2L)KJA6f=^yfwen7o^ilrS6?0V0V&9`Hr6@@tq!oy7nmw_U}sf4BOfl$VC-4^cmzq z`>Kb_D03?`_SlQpvUHrQrWhYAM7sc=;fmdPJ&%m=L5gL-jT4&2kkX%;bzzEkJ!w!Z2rJODWh_Z zHc@P2!a!zEK{fSv=icn`Th&ezvYMYlU@57lknW`RZ;Y+dO#+qK4o_Kag105k8<#YS zew;svdms$R#~ZrrN0}IngegVse?5(Ap?D0P0TH$$2AF^cC;C~$tM=(Y5X6Lk79Ex| ztQmfwXU3*t`&G^39YKj{)wzLq=l!xkXA3hrEy`S!LXl7qKgpCIUnw2xOR$W=mUlav zaeXYD6FA!;>$w4)t%5a{!|k>&UKB%=XEy3IIym%QC01+-{CG6uEfvKRn4BfHdH;?l zk~|jD6>uVmw;i3GX+5Hm9cf|vgRC2z@c3s>TQQ{RUn~fiQ9p(>ky}m4Fmp5&X|poO zN|CCkc0P-L`5y7S%uYc5V1_h}gIM+CPa7kXVkI>2_;Ro&-}4_nR11xaJK9~qBDJa3yWN9aU-8>cY6antCUd(e-^qxf3|3RtFSPn zk3oe6n@e3|SCQ807n4*^nGGAQZM}km;3FmQv{4GXW4oUDL5HpXRc@78QshU8`!aM^ zM<)`pSh6Bhy{hk^Cp`Rv{rAm}_reGOqac{kbER~o0_{_c3Lo;*ZmO+8%#K_-C z1mrWe{x?%A$v(%Y{@^&twBE7?d$uVgzm;*NCexXLvh72t~StQ zV;9z6qXZPk!(w6X&?{rOz)wE!Hk-BI7h@`D(Uf&1m?mOGt#Kx!vw|7$%c4(zdsRLO zAdytcmiY_L>oFv!qd#*RC9cNQFP3)60l{-EnVLmL#U)>h$}n{2L7tmoOn39M7VFEh zOaI?~a*dRr*fN0fbt83RncZ_p~KxkLcTKJXb^T+FZ{Y#_7r~NT|hM9VK0f_Ybu;5lE%4Tx4k& zu#FUGXcyaSPiS}+s;+@-w51$fDu&wXR4XdoVCbVclDEdIu-aOm$&bLsoVX~{dsIVKU;AiPdD?9huayestu zcQ2tS5x7Gd-(WKgb}tfZ%1FDovyq}kt82LPBWi9I7|hBqIcaj6jmXfMm*4jKG;({k zY4Q@D?cBdF>Rhv^iFk(hQyN;rtNESBiQ@VHRwWi1OhcP?uGZYK%^mGcb5@d8q)Wp$ z8hU%(Cw7V#YpnKBVLCrtBKG)f5L-?X=#*Jxk{6_}c>f6f#E0)o53Tw8TZL{MsQSYW zV*3gVz6SZC0n%h_2lIo>m{t8|al9qV2L+FYT$$zy_T7Yg+D~HUSGnl651av`ih82& zJ@8Cn0=-A0mxT$-ur-fan=lT-+mQ3eb!r39 zfIttoF8)haxdJ;t8=Q`Wg)dVMvlQ&A0|l(1EvAd7vL%UB^;yUc*x7v&*)k{nSA{Nj z?O+=1f40dUE>agPpPEhYR-N#~C9iS^;~yu#cfRB0>|<-9 zfce-z4XEg>ejePW2^O)0dkOnuckjB)9)>3F^3;;+f1yt?`Brblh*qj)eU2w9+Aye) za<^o1^E~$PXT%%Vux-Pqq6E8aI4C#1*`b}yA|rwn0f~68gstgt;@Akbq#)hk4W(9- zuOizoe!@*Yzp3+w8ncJVi944W(*?>7{XQzp$~P^^FS>SdNIN| z=ZL*JuXmu2Q-BQ6xT(8M5A+y}YJw8%DWZMC>&-q%`YJ~2GBv=d?Y46f)neFRX2T9G zbsP8(mt5soG=CM#dS`19I4XQJD6f9C6aHKaS?$BW8_mfLq`b_6*BxKSK#>mjGnp!yQ41^TY6hLmF zqYk}Dd})%&9~%V(pfKV(h`FlUX4Sr6h!V5KAgnJ9ITnp1BS|w zH~B;tC6I%bVC0LUeE(Pri`qwRTgKX3ZrsJ|KDC?UJ=>Y94$k;le_kf%5!<9lw(UkW ze#2#Bf+(z_5o@etzBiLrI@Ho*6KTw>7Lr=yYV^?{&&t?td~q6W&IW;^U!TAo)s$hq zV}(0LzG_4&I(8){QrF~J7#q_PVEnZlFc3qAY0(wr1`*KWm?oNj+xXCvzuqRk&K;-1 zWZj;78O?~Gk(IQFSsU1Y7Y@}!DQB-T{EHf~RB)o%Xie}SYr#K@B_Y_i#*DN>Ju5P1 zc?jk}%W*S%of_XyQGmkkL$w~*T2w-*fUaueH=w*eM0WS7@zd5MDa@eJ_NT0cA#;=t{h^p0!CS;*w5{QECp3T z%o|eIdIXt<0+onTPA>~N4qaDwHn%tL7)4mC&bPQmL&uCY5+l=+aCU)4F>}qicJbo%BOA=)USA*J&yqe@ z?@BeLh?Gu4fV~34^&RWCHpZw4;urDrzRCZ|XmmW0E9{7H*BersMFi{=1DKJ5Y5p+@ z<189m^}@*St;otP=rJ14De!t}ZwwHqS}g!%@$9b37Pk#K=UX35Z+_1S~xNs=-C z@tUybCaQE?BCS+z94`D-O0(2fy`*miGTy>8_wu`L$08OPc(58zLK_ z;`_*3H|*nP0I19Z#I!<+#zW89(mb1!{+crU0U;6N=R@8_M;&Q4%f!xkmH@9FM?f8G z>9p&-x8p>aRpcqjsy~B!csT=PuR9~ByBiW@DGHdq?y?c})dXQIQ-%NLk6R!pjVu6I z)JA?S{a7HVIMi`6YNv~&+cU_dA4*f|40asu;KXUM0Or7eh|!Cf7eqXXAKJ&w=BK6@ zW!1{onvtJg&RZW(-_n6hgB(Fg%yeQHSeS9k%-1#Q-d@jB+Ni*S{Rj3jqOmOdl^&QxI9t+QJ@BE*-9= z8fbtSiRdyjUi{HIGySq}2VIgjt&Tv(!$7TzJ2(Tf)Xd>=@DGLdS+i6cTZc|eTrSgK ze(n|0K-*P%-iUVL#Q;c=GX2;PS6LpQ??o+jKER6-{NgTo2ReipywVas>ibgSH`4|L z1+*_&Bi(J$0EQ~MgQJ^~XPfuUWg(UPFsO2@4FrTm3w2`Z0Qy7F>d?PnZ3#};IDR(7H~{}f3>UlpvyJ)@Czy%7K|dJLFUaw8!H_E7~uAjcW=qD=P>xh-RI ze(DGYfuZ2#lx`x!0JcOQ0dr?=N~Qs?ge34~{!6_}2f)Zo0>at4`c<6JsOYH$mkXgG z=S>?ZRE0XBU~w@rZ!HFJd)N71h<}6+pU|dbxV1rdGN1-`P+)V4uVyk^y&##&W@{c< z0J?<&jxjHGnFd{&O)3Z~uQxwNr~ub&;O5o(v3|z>*Q*T!grhucY50=8!Bt)Iad7tAi1Ps%2snbzL_E!v;9;}0yP@5#4Sd3tI zcmIUx!%(%-AlsIf66pXAI3X1w$4tCn%ziJ}?m$(Y;cqZ`A=CKmz}6Tm!#@Lt7Cm-z@Upk*dZobdu2; z9DU>2g8CU}PKl~r&JVf?LdwD65lXes5ym0sz+00Ha-u^jxD03vakb+yKt@ew9Vgt)&SSz#kl4{EH?lod!kya8pWe+z01i zeEW*7l>oRY63T3U0;;J(ER^K9hB{3BDMj~ifQ$zw=y%B*56eTF&QVO00&RxzB6hbxHsFyH1fkWw}r%*+`|h{&13JSP$N zifjWNKvT}e>`}IyIsr9hO;`&%3BcyJ*;BSfdW5^aMb57W=h=qMTK)J6f_%MHg^;Bi zP+rCn2^5c^@G__P?(*?_(+XFFYGN1VYN8Cz+M*(JN$ZFD3#D(rBvSLuTp3Cl;Bdis z0Exdw7+4A7j*QhpML}uX$4dVSqSKKvDCSXH+(oCI%@T8T=-O;yzx^^KL}?Tmz+i=k z_QVP^i!@iDLiiBE0u_anAQIIx(Qh5KPX%|aj^w0ljg_)Kv~B~U>!xY)RdILL=5({OEZWIodmY+$_9ISs+Ez%lcVK{OAaH|mqNPA7Ehal9H& zxa<-PA9Z8>(exJysdZDp<{wP;n;$z?5k3Pb6fNH}hF(~GbMX>_uv*yHC-~obKCwqp zerK0cu<~(Lu{eWop^UO~JtZU$7sD7=n|M1af#x@)MFPY?Q#WReXpaqg9P4*Sl2)JI zB$)ITIar`uXH{X5Cl}QZM9KC?pjh%qm^0!Ac^-C(T8H&omm){+1_YybECHxM`!a51X z!&wgqfU`Vwiu)$6>z7Hmhr(sX5Edm*{tO9gUOElip9c9#69I8#aAP=~K zd(hpOzAEZI1s=d;k*Jnb(rUZ)8DvqnLoQ%6<(G_4IRv~QSdS=ikt19c_rL zo6i|Rj=zIfKA-BkL>_pZODJO_%fz!}WW|N)sX7XK0IvqR!fLjRqonn2itJD3Z+b$C z!k0aUaJ2p#!>p|TM4^GM7i*pZGhWmvB_$Fs-LBreZjFh6xrLJW2ajNkv}=Wb8{|AU z+C`V3nD}n`+2&7YIM=mYy;=#xBFoVTz+#Y)oXK@;%xlqpj(szW&!JHI%k_0T5WCox zVjFY41UAX5bv1-wifSH;0zhH`x)qa^qb5j7fC5sfg@7?iqA%1sU2x|^%Z8Y^jSx>< z4$$lVX0r;GsS22l_~gZp2H^RwCY7i)Io`v+gheyO8HY{O?Phg~eE2l9tyV9Q2Fe_+ zHtN0TtfGVe0~b4|n1BE@3l!#9CeRn|hk{cHbYu$b^ECoE*H%i5vFNE58{!^R`{F@4 zZdI2t`SCsJ1dVZbFF`G-2f*Q;zm!0}*GL|zu;2fq;sw}%qlKeH-8>ufNH$CmZeW{` z6j8Ehl`Q(C)h*6$!HL-ynZb1bu73bp5Bl?=FKVIZJz7~e{e(R}_wLe*ot=1$NQ5yo zSe4Xb#{d&9G&h~SH#W_esn-leMVUT8%D`{%8#ZslFBk#hAmCj6EZ9>62=dwwRqlN?!Ab+bkL7LybSQb2snNo!v;3ZO#MBwQHH$`;u+yLX z;<+%(60njcPbMD1xiT)WDa^KF)`Q1ouQ_bW#>~J%pkHdD0$K$cERJ|uDkTzX^3Ud^ zUPuGcO;+_BG)kV=X=df%Q5^?=9i@Ct2*WzHB7k}kj{%KTn7D|%OChl{ARB8e&QQmO zyDmSKd(9DlRo9jgXj=EV&i7UR(Jv~R`v5VPbva4cf>kZJ zZXRU6pCPH|+l5;#WC!%BQ+`DoI-qZH3#HLtAOp3FBPF~j0JKum6d)g+ zE4A`LV*lgNxp__`5E6_qH(itA(k zV*24{+|}`=#BiO^=rGDw6%pTml+2n^#G*Dmqussz3N3cjwDJ9hT|N$h9wPi7{^@HQ zexT)?Tc}qc8)H9}U9T7v%4v5H^`lHP4$!@%6kZT7JZODz{*e$De6TT`6gIBMYu3iCgL|s z;@SI3XLkRJM-fMOPvQ_}W19B!$G0ttQuJSzdHcYD0-TjW)jCOcsPn0XqQjfXH!)DY z5=a(_ewGgF^B8htlj?5Of}Vo#P)0BEf5Ji9uUphMFaf<`i_uLWQ_+_E0qRIU8`s^A zzm=vBRTM&|99wtQb(bTlzQ0rOSu52p)L{$OfA4s@OZw)-OA1wXM0sUydO49UpaZlD zY%YTh%P0Hxr^6V|pw$S2yAP8a8=>5esF{37)9LimHWqdB`blN9u+l0yAyQE0@yJ!cP& z8Cpot07^CH1S7t@QWEj5)YLUyz@^Y+U)O0ijs&kS$n6a--dW$SAD){zXCgy?Dh~BP zd{4JylvuUErBHgq(~=kDYZ3sLV($i$0TRg1FM8>M4?9gaWN5)RTv}SccNA?e(RSs08lHuWR zk2M}Lj~jYKcW`5CK_l_wMNi9Ff4NM2HoDM>eGmV1Ma>cjb@Rv6A3Dgz-Cc$JFZ0Cf zt*ZzFe<~_WL(rds)EH7xr%#~7)N*-H)=^53J%RqRfRT6Ap1`50n}9)NqhVeQ>@-QG zO1q^dTfn)*=5SqLS}kpuA09?&2>IeYUhr8sf?Ql&1_-SzOsPV<_X#o<(4Yi}RB)hM zsZ2k`HQ6=sNA2@aQuDmV>01?!iSk-`SR9hayJ#1RJ{0~~e>uWT3ToIz2cS`gY%x0HuE{2`BOZ(l;wWNL#ov*dHt$Xaofzsy(>@Ir}DZ!Q&F;>P4lH0+tB> z`idBSk-8x09C?utL1G6mnH1}unDjQ^oIUoc+L$(FX*g(8b%FoCY%`S-K?$`DP{Z{Q zyf9E8jBu=34h}`^b-8>#tjm8~k|ZE!P#s!Wo#q3i^KvcF?dlZ6s9q8Qi{x8LNg-Mk zNE4KS?{HZ|o>JP*MgHG4smT#Rqljy-(JVXBivbA;L4w^J10S1-po7`RZ3GZVaU9fQ z*>ifgfZkla0{b5n%2NsPGjYQUHk8pj&z2&PrA?;dfq+jlR%r=RZ0dhEieQB}PBQBI zU_wL#SbR*GeLC-I-GbzPVkYGLYA-yog$?%*CCtwBH3g0wz-9oHmkv-@+p=Oit{2od z+-QIz8*9R9kOf05=rxcuqurNcS2Fx(Y>a<2GPn*FU_|7~m86IRGU0GEm9c~+6*iA2 zFM>?*Z)zUZgXAcdzX7JDdp#}bTOt>|2K2OXL_$$&?Dkm+@nScMO|k0-kpe1DqnMKY6)Y^2ivSD3_1DMO+|116 zo^a6fdq4BIn30Q#ke_~it2WOif6s!tQneJXUd1d|O!q!NC*WoU+@Q*KLkj2rXWVb9 z2s!V0sQQea+@Lu>d5Zj5&}GN5`}vVL?}+9osoPMMZ1wUxVTv`gOF$T2?qUjDqyNEy zo;idx9(k`h1v@Kj1`#0_5b|3Mxq5yfg1|rtbG7P@qrc8{ee+|G3R}}C^SG|Z?FS{n z$VSR=F9s{sT%OcpK=I9)={?Mj;{+OI1sCo?|M|Ua${@KM;EaIUSfKqyZJf;{ovay3 zSNNGY>*K&;6yXgCWRHGTQV?>KE)j5d2wGI{Ez@c~2nZo`(J*%Mw%#*?a#_b$)M6$E z;i^jqLt2cG8!Q91j{5}r-8olI7xKs_zXTTzjiXe<-5i)zLZRL}Z_>oyL+&%3r)ICz z;_~TRaWVW<(wTSa85C|iC!fK8h~MNeImnQinS;}rcNmyYcHXYZT@m_%lLpQ2f9z18 zF)AU7D9}#Xkl-^Zw%zl7DZ+WpT>m1Fo#flrFglBi@5IFJkJ%v?<1o0~7E0tLTXw`$ zMcU>nsnE(_L?ZV|xX*W;gyx?zBDZI6z|LYt!N7uG_erOT6@EsPFYEU4=R^9!sr-Gt zbn_Pb+wIfaRuD5Cff!pkH|b}Q65yHoPkrGIQv3(hke=~&=S!)1)%!uP;Q;>6%);x< z-RXAZxtNpzm1{{*O%{Y7QJO9BMyzR$e>cDdfUN-}!+D!B{XrFyLiGE^o{Q@5I45Ous6y ze}p7C^>BlxO};0Gq_M4j%gSIQ`cY*8D{XnSHS}i5&*mny7rg+G&?ffZcCyLf#exdS zu1!1xx2V3r_?&%4DPk(V*~-*rVZ-dtb+LNB7)aQ9{7(x2u%Y}B%RD(8)wK>#5!CjH z?ShH`5JIPT*nB*={r&D9cfA0b0>$?Kq~rYfMH{aMuSIF;6UHKHv5}!J;R0(_8i-!B z-FaU>I^L|GWNI?P`*YKuFCzcmKJzc(jqMX96=>gq6w!5*n2CqiD6sGOrlw}`MGgr` z8cnGPBE(Waq)cX}a)Gk(k=Fm4Gaf`@siqVpL?H5=4c;y6l~cQrhbUjAw#C~3YNj^y zyxfz-Wa%AV3Duq3m0Q`biXRnU{lEj?_q`d9Fat}!{lt;u<4qKn;b!!@3iIK(Dx8Nz zXs7onFi=ol=G^*cx-13)l*GDRID!m*;kZuT69|a@1)$@<0!8bQ=g=2b)B3&Lv+&x| zu`p5k>@!&dbS8GkD*3xX!XoXD#LkVBn|PfD;FcN|lqsgo<#`!q+6v5#yG5h)_(_@^ zKidsh^E*McW54HDBDRnea~3m=ZD*ylKWGEZkq(iN6Op?41yPhQS#K6c#U5&Gy`J`t z>g(Rui;H*K3FEV0d0tIi>P}QiyAyUvE5}o}p)~)-+|m~V&3>j^hyT=hp>$Qu(+bCX z`fK*}yTf{ZD-io|ya(_`)zaQ-X}I75z49-HRzBj?Z@*+?z1z(UllLs$BhF?q;l&;= zcydIWJkm|l+4|C)X16xTMs3p7U}Q$sCO{#6VSx%DEu@!i91>`|PwH@A#uXXs;xsWv)5GX6Agjm-C^Ex^K_6e&mm48aIC8 zbwXB;mhnaaHT`)LEJVYire1`IQ{{K>zoZf-`7SDHXhm+G*H&7YT|U*{3qwz>AMc+O z*#{hwHfB?8nKe=vZG)p2oNlrpV_Ef|OE$|@%BFEy(5ATNHuOSbr*(Q3K`%l&fj)RF zsJ}+}a19psmzg`zuNT(T?40>9n#<~@-cjhG3;ts9)d)p40>mme;9fDFSVw;ydlb9^ zyto}K0}}C+kq;ZL_qL0(cmeC%H-dAnfmgn7c**$KxOTMlVpRztHf429@Z!luLdKD8 zZTDkp6_F{ddR%9Yr_u2~e`hwfJj?dWX<0QvR82-&ecap@w_Hgpn%2j;g>+xs9xM{A zIo_D!JvH|5?~ojZ!q!|R5Eg@;_IO$%iswB&!b?1kk!X2_HnPg$1I=!UCMs6eQlv@ z-)+W54krm&i-OrN@`0@>cga^sOh@0$RzeVS4Z>v0QlQ>rb>>6g{3<&0-o?eER!8a< zjNRGYN9SLkiSILkm}WV)E0ba3H{5PLf~0u$?Pj8x!+v^b`iDjqu3*eVp>=~_OX6JP z4ez{fWvnb+K{IEanOCb^wT#$HUr_fDmr>S1|Ht38(XcC>RPtd^Qkd-a7f+7(ffPrB zPol}E)R5}clyLgfg`K81xcoR%7P+?o510a_oH-U@0!xWu9tQu`!D{Jq$m z<93fhut{|sAU#-hKpaj)U-hNmyoOX8q{{tBP(~j!MjJD+d}o(&Vlr;_1>aKJ1nE75P&j`0Netqqi#&h06vWS4yQ&HJwrIM% zdok1@tL{wJ?u_-JTy70@qD*CKd~&3)VC=p$yfRyReAA&Dt>pm>%*vA59c~1;4{6PN z&K8jp9<+z#3}HspBJe;hNsw%;H-Be6joCYazIeW5s%q(cKfOnTyX5xJ&uV`&+>x=U z*-w$ZU+|B2HJe?oKToU&41V)m--8O`h(ry6>FKzJp?!lsBK-Z zr6_)d=6c=ax=GDh{xgs3GR-w#p{lzhqnFImpI8U^I@*yYJV~u08Q0&aA0ZSlC{D=} zWk^FlFhs$)pymGFOV;;+tlAKS7=L$`vyrJkZr~xK90e5fs+tAce^lHc-ovj+2OuLf zLtbxUv{nl}bC+68!2ESJV3>pMrcvYPg@d^$FY-uv1L4!=+G>gQp6oTBLvNEAvd{Ix zcB3+KF&%Ez03KPUlCmVBMlB>kJ+yN>iboTiSU9Wcr??iIvW07vZqAD8?Z)rKyE$7+ zf+GE(q>|YeVRX2*P+Fk;k`+^fxfZ*~BKp<+LR;K>a{zn=Tde9%DS7NxOc!A{vt-Cc z`wfFg$Jht*W~#q1Gw+M2wzCXB7kf;g@_Q{mQ>*H{k0f6FkW0x z6XN&@=W?sB=`0roDc}hIaat>p5}so&44XCh(UMDR=23LzWKG~ihpKuT?KoX5$~Lr7 zK8LJ#E8I&YCkr){4!KQfRKWjD{DpPUGsH(KWAgndpu*!*#UjgdU zFbnd=8cGJC;*{Q6j+fa`?W8UO8j7j~okp5GHMcI};+%di7CMB>b;IU&navqKHE+hB z)5SaI!ZVnAf-!sRC!M>aH~Gko0<~tM=!FSN1Y+J$kN?BdTZRSod|ksxHxkm_ zCEeXEB`V$BNJ@uvgGfk+Al=<5(%s$NUGMO_pa09{2QNM_=gir&W9_x}WD`tznZmbf zAQ7I)z0c0;`^hZ9Ep8@OnTdBt2}^^0TO$P53&i4G)@lzAIW)HqIovKB6!xeMa5a%v z=BcOcD4c3JG-r!VSGyWAG{Jwc3G40m`0>L}?S;NPVGGv4x}CB=`<%S+vUpiY@7lt7 zIx?Ph3+>0%@v)aL4RlX(>^IV2KMEQ{To)sz&arW^MkXrGX&94-!Ru7bx2T^-mTz8Q zxMufcD~)D4eM!+DJV=*X)W1%Rwj()PzsoVY-EZy4G;nt?#A@}*M|i1c_-O!+(LOIj zvnm7Mr{G(|VPzUkOTavKVxQdC2={Pb)it+TvtVAV60^_wjHWQPF_$p|2avnkoZIt} z=;e0iLs1cgX~IFh7PfL@jSoONft<>ZG^;oq0cO98KZ$7jpPn7& zFj;)XQ;sFZEy&nQYX31)w|a8%HwCv?2I*0#jfV@mDLk>}t;+4y%pB|DIsk)uRImcXBXyU$y#kNDI!Q*tgClLaoM4Xtg8W0`DPti`~<3G)6{O;+s=0uXOhVS*D znLQ4qRd_YH2wE7ms`-N-0HF0PPBvLkg3!VBxe(@(Vzbe zb=lBKu{u19EbTyDzmT6k4^IPtgME^!ghdwWiO@!~G=FKJ#YF0H>}NZ1w-1kS6qFf& zctXg#7LRm6lii#S>&x%#87}0T+du25D3G8Cj)E z)$xB@F01-oa4LKp+TltPVvwX*4c#~bztDmkUoBHv>BFZ&YaawG$KHbpW;andC2oyR z=(j4g0L&8c$oQ~gn{jgUXmV_SnKF8`oF~gWCFCN4_2yJf{Z@BokA_ zJf^aj!KcTv)5`wa`x!!eXQE_@qGfSioLev5N_juT^W(_I3M76?2686zEym>sYtkXz z&S&_re1D>m21tcU_pSgZv~)&!4fN|FE_rNx5fNONXo;?cK5Kio= zs1bMHmHq_6?IRYL3PSZ!i*sAmA8Ef=ERzwD#L^$8>#5y{Ecp60KCH7aQbd$apX3^D z|AN@0=Ha1ez_==^dK|YvK8EvCIBg)KezVCaN}61hTMkAgZ>#M*95R24`QfkbyH?pr z=MSqJ*f;{Iaf%Y?e+7?4cj(sO`umFvv%-z|5wd$+TI~=&ap6SiHakg%=tfp0SEze9 zD4*8Xq;=g+2861caaNj3kd1R5w2c1vBP~V;x>ShoKw->nWQiph4^diusMb{g%TnuG zmSCkH(dgdpN9+N=U|&zedJOY+>qQ6qSrj7h=93nJz~#4>Hnc|^7G8AY7bmDEL6Oel z<)8g{#W~O=>G?kQuHG{NOb=L-a(LM_hy@93e_I z#2edKf&9l%>+!x(*sB36dJkthHjdEy+DU3*z}A=f_eB$zRw_-#H^g6(f&kn(6X@!&Quj+HJ3OzZ`Z2}L2~eikh2Pv@=Xb3v*<%IUpx~}g zM*t$C{fq8P+s#Yo%J7zE+WfIJb`(O&OH1j-;%N|!|X?}QY)n{R6?rrty zD_yMy)6?QIKH=_W@h26xRaTLFI7>xHXEW?;PRI8ODKUq3L>p@^iD94c=6N4-GHf?G z;Uy@Emdt`#S?RTDc`F0}X5A>tsq>7tN23`Kyh>0tS-?1xMcKbnR*Bet@(VR{R5dCr z_rn+B9l|7urGX>$hdcr7MDx(gRH6>^MEh}M(69{zlT)&PaV*b8AuS82X{RKmW0?iL zS;B4WoxxkjjB(n+M@O?<&?>#-3>S~QqLP$>giu(Q7}BWz;K(o4oXfF#?eX}+q=oXB zQAqHj`!!Hl?Znbdhsv<^c`yHU;0VNQOfX$mjJdiGrE=#4aB2!<3Vq|8Rb9A^sHE%=i(D z__)U~h&d;w6fkKJ#2l0eH>YT z8;JY5qucFkjZy;Xy3p(pyW`HqK_PG1)0LcFeW7TsbMsiBDP{9jgr^#s5N*d~GTgYNBdFfa(PXq%%<}l8cOTrXS3TCJ5kqcj^W^2TvwFe@5pthn-40D|c zqn?v9%PuzG?xVS6nw#NsLywW~rRFTjpUbu4U<3xFQjuyxPl(U@TvANxXwnR%*5M~y zcqtdlv{NvgKUU4LhBn5ZWLwg5wEZS4!qQ^eDzrf{bNI2OOTO}c!LOR}rTDTAZE^Ny z_Xv@21KGJhi9tEz`il~ezvoa`QfwWd?p^c2D#S6jV6!~sjs z8+7(U#hG=9HYgTKeffUALzx-zEux;#3A>F9A755gi@NA1 z$4eqkgF{1#aK5d)rUeW+5c2Db2K=E?y8ifM^X)yBfYK8}>Fmi_v=pvQCO(b`0LetJ zS+>vsE*#6o0HujJ-2&0PPr(Wo~_T-_E{OoK;-AN~z*u zJw(|1*pgk1{0$Le!pp6NPeO2EuQ%DyuZjNYMdZ)h3Di`Y~HAt z8A#h!zYNtMF`^>dV@fvbWL(#ICfmQU`?9onlfulQBnvm}-K`luyRV?rp5!_oydQ<| z8q~7#-Jzp|)~xUsT1LO#h)zHkS~E@RQOLA4sfWuIVOy|f@gH%6ocLKCTk-MWTZh}y z315t|q1cZobm+0GeLi03m1-q7`aVE)Ht2zElo;^kZNt)Xf?x^jstp>gN!EbA-dO3v z{Pi&=<4YJ#t1IDvp+?T7wf=?6OIviSmm}b;wQoW9ZWp9Z;!t04Y>cumR8S8@aNY<8 zCZ^KLvuO=)ph%@5)F$oaY8q? zP7~d`rc{e7j{jTlXGOoizegO55k(2=WXs}kq>K}k>4@SNyad2`#4>$!OOn~&G(Du1 z3q}ODkHf<839jEQ3HF^ml?eohe}EVb5chfDVdK{6t|Fjn9U^|B5TS>}Y5R z<)x;#t(rZ5KR%SWe^6kS$=2T1WO>%sk%ZMbH;7tiF$VI>{t0?wUNojGE9L;BLo#nshCg?d87FQg4!W_n{mFI z!(nP7a=D|(4lT!3AJX@`QZBa*6r$YIi>*bfhv*mqt56?(^&hg9N?1r(^Zx=qAxp zMWa+aTLqo9&Etn+XdK*x{UIERzeBAzS))*uSw57=yrws;B$lo9ofxHsWifNVcpRbc zYov`|zrW(ts@U;6Om6$VIx*{5^u5c;QK0;$KY76>d^ShIE@^{EE0q<$&r;cLmtQ55Q(=>xq8Zh+qh7QzP(+mWR$MgI>m5~!O5c3WvZ~+n7&1vWnZj7MP`F5o#-eEO@ z2t_a+*Tr2_f>P?Krc-1o&h9&%PG4t?F_F-To^`beij$}KCm@x_ zaH@UPGGCgzhSHI`m=J%yYV|MZ4b1 z-VH+kWpRc+Yw6`3cZfK zE2I9Xi#lGS*}adI{m9Q;=gs>fb(2sL`x(yix-Mtkac&VkWSeE{GW%gN=Cq-j3w4Z6 z6FZm|5~L-NtHic_V+Ns5D(AAPLRYX%?E%x%wziuxR{>@?FCN!U5PIG*HB{u}WBVDL z{DOQR;N;1moa2JHnPB$P0NM#)M1JNP7gmezw#zx~5nxgWmN?rU6K4B&jX9~{y=Jt@a=UW z=z?HWiPtaz$1}>#C3s@Qp~41A>w;=a1LXlKjo?X62ij)lcPPPpWf31{^YuNl-qm?l zCGjJUQAM@(`?@e&0N`>ms{XQulFF1WJ zic`b1xZ#AZd9oXf#|-T_oZFk{;WPsb<`&hBP8=V0-wbaSF1w`C@VK>#Dfh?yGdEB7 zNZm?X-|L`w>%0Shk`1M5ukDsu>+2TD=+`pc_yJD z1bHs&qA46FBn6sc^RlcCJl5zupJ+~Qg}?Kj8+jfiC(NFY$Ll95l4ryFJe3lmFDlZ9 z`)QLI8OU&;PT!j4-b9ZGQ|OePGjlas1-?l!ar#^u5|?whhTMF!q`6wyTzuSoTAJz@H8(waBd_zy!c9?rsM> zsGvh={UcrYSSNXyaOGDIoiN^z_|pFpmLYK(B*`V<{Hmr|Q&7F1rTg1#SkK;LYRX?QF9_ zqbx(8*~~uBv-YgThHVl2*88lMjLkx@w7mBHsOR&sT6HlP!%gc+GD#cL+anW7{wmj1 zfe!DuCQ0jFOJmM*XTjUzKTboC2`$arw0JyLhtU-rN8YsUc_OINzyur4-Q?q*%?WEs zVOFHNnS6e4Kf3*TDuJ?wecY%z(KI*lAZyc!%dawcoYl<$**19RpZaTQXL=CpYQ}~n zF%acyiGM@`3vFa!H8h$s#fYl%{dI~T`ZN7IsDmgP0~4xU*aG%i!;y_*DD+s|dZKh* zATWz}3M+rQEF@hbrj+46*nF*d#|r~eN0Ks_(X;CNF~NWY*`U8%n$utpDrr+C@So+nZOE6?&Q38~F#7Zkd*^K$ycr0d7zRBA`V{lm>&q4jFU-|}F0c$7x*KLh9m zdZL{~TtXQPrB@mWLYGsrcF?4=1K64G|NqWRt+0fRF(v9Vw*LLwsr)xm4{;nVm8dV* z?75Fhk^$71T`hUY<2d5;_dHmf`Pt7?K=d@!%B6lDp=|k%5kppUr!Sy$r@N5{H~#Kk z4C_z*Fb}#U$HUplTIdkn-w}o$%oToAet9vZEsNePvs$AMKk=-NJrJ2WD<~x-Vhh_o z-=daY=Un#9svO(NV*+x`(3+dvHV<+>=)w4@rn6+jHI9 zU+@6GU%^9Zkw${jxx9uIkp~!NDiWa91E(r|BgNf66VoLi<;5ki9PZ6-l$hB>d*2b!K}%^*6jU|QaA%cUq~UyVXKe?O)+ z>VaQ{(g+w|>;OpQilW~ObnOx)L1Y@(?9S8tZCOgH-@on_L6d@b<&~kEHoHQ4?R;mS z+>lpbM1KFrV21;BJ{3TE9hj6dO3^Br;OjPpxjo_`ZWBWNBN^)M*Mnz%Up%)G1`sJ6 zdg^|>1Ba{)3WLn_#%bhJc9ZOoUeLB9Z4dL(Z?d#{k4{g z?7?LX3tsw#66}8^4<)Y-37UcX^nvodCXHjkN$K&)|Awh;dmu!DCI4>WahHQkuGE47z-s!du|UW%dsTzEcCw^b~h^5 ze*l+SUgGp&hT@U$@jj?b$8hf`9)2i2I? z1W|Wm!Y;fV9^!T3k*zU52L6#sbLVwn4MH&nMdi>{8u&}*q zD3S<&VMI`YK`8J2msx#co-J*_ADqeVF8wNKJ78pYEE8`YDLU7MS1`BYVq*PoOLE9= z!G3@nh~O|QEe=2>B!m3FgRXu#jR=$pgO=)Hb1RXy+BXGlH3L>N@Z%R7 z3BU<%Ol!mL#TM7Ip>z#x0L;hSlmLX-Cx$dychUqH@-h4)r|hSCpv~)rMZ%(Ia+aZd zMSWgJPt!8qADG@Kaf_A4RIoTL@f|&rK1DXJin@#XgB5;i*SesGj|=YMn&V<>52-#Z zaH%6klw+NTVPoXiZUmeTX=3tvL4n>xD9nEngKxK{BwHBhW7&AtguyLcbhzPQ^g*K{ z5e4|OLyjE*m)X!hR*4^YQ)8L9eme=u-Q;deGXE-#_~7AH@a+##olpJ`@VIA<`C~#w zOY-~kJf$cil;ofaz%quwwURXu|JsWO9N*p56f#^yPhxjDOEsyDII-GXs#}u*`R;~X zT(+{slz|Z!P;U+_rGNJeQmNLNBF||XMqL2@iKJiOPe!{;uMdu8na1L47X{;4 z<7sJ)zq+-H=v*$Sl>?kdmB3o z5>FN7@=qZgwG>^l7|FE9RdM>Pr}n|LbQub9IG9EmT=2fsmS;B@BUbV ztVO+xRA;=>HneZF$3fe(>EYk3dLmNI!+iNQ!yV&W$>v%#xWJvi^t>Qx!yrpHhy&8K zDhXYCV^9*Vck<}apO7uaNyPpx)8*mUv58nmcE&J2yvZz__Y>AeCeAHW_>@(t9Xz#% zJf0YS-ja-Ki{CZcbH-rw{^W*&t1qOvDNda3@~4>m1$zv%tSE0p{==4hVejMbw2O?TsNmx^Q^?MZ(UiL-!eBkoo0Gx@eF1O z;0Iiq+_aX)cHPUsKA*Ze`=9OOXubVaBCXvTE14ZK=~7IRE^ENBa2a{Vh#ZT%60Q!3 z0Ru!$VRjim{_O^h2D6aG2BkLqb zR8+L7yXs8_L7^|VK5({<@tKe}=0hybBbvL7-GHXp4 z2V|?r40PGmk6B;rwJ>wU=7V^!gJg35(=4i}TEq<06UiDsFyeO0`Gp^~=8zJ~>}A7!lFHj>Sv_c0Q=8 zlOp~qo#@)FiG=TEvx^L7)c~k)C}9t|5?My9^ z_C(Ngu{I}}##}Dja-ad!}3Ot^xqHPAFRtu6sJ?oyM6}kYi zAxAmHlGYS-CvP@N+<{qRKi*&@2h32SXk8gB1x+F#0%ijshO9AR%r^ zL0I3AlabWjX*H?2!lI4ajm&`dk2v6)XhJr)QXAFxgl-p^!l3C8N?#$pFSyl4MUo(! zdJJy$tti&Q)W9W2SXDs|6-!MI{}f6B^&VsG7bT{%EX$r-y*L&EEPgL^oijG)IzVWb zrAwYkm!{u=&y#XucNAx1V1=WpY2v}oGAV%S@oVFs`o@AFD5}Y=a4D)&~4Y2WS}>i*AUar)z5iBPj;SUiIGx||&N$Jjy( z@o_9m(R1w>PU~Fy*)AsI#l$g*0)a>4xsL`uCIv?e{Z~maUE~+xiE*oBBNulrk9ZrwPeDw*g8}gA^PjBi`3H zg;md5Op#Ok%umH~2hXb9NJCV^T%(8Q7+J4!VaUKGtTPBX7Kd+%FFoM_6i)A9q;gB@ z%6TMI`w@XR3*aFF;TciTXTgW$)-NUm&1v&d|2r+lM%r3_%r!Kk@QS(L>1F4_%l+dK%HMi7f@a+_sB0PH^uJx95sub*A5dN=L2x zP9iqv5Zy=Ed1h3>Dmx`{{_QU#k?}BG>=5iFeIrm*gW$$n2O1LObgwfK-jGtSk@NYN%h|pR9Co&En6i+gAmFfaA<-g%_L@aS&+y+fBos( z4Q_4fX6*PYPLyqbP*m5&PN$u^*eN1t*fPW8S7=GYgbJPU_p9C?Y~a@@@xVgH1B=!j z_7k{F&AgaS^9yO<_)uFvJ6?ax?_nQh3HzDz)Opj?X>JU{d+g>ZW4uIHu~{aQEi$ES z@uvO=`I%hAb{48iJqlL@g01u(RtWR9e{Ssd5)!C4K0tMtJXxKeU^6A&u z>7bu!ux*)K`VmaXJuoeH6Zi#_E$MJ(uhfnUI=r%&BW$u9>vPgNi=JSOYJO&UQbSpg z`gNAR{8y94BB*EvRm85RU0{M@Hw!?NF|Ab!;W}G<>d1>OltPFJgbYGyfj2K}gw%az z*H;&IPU4A~qR%@0j2KIc9y)16HhrLm4>h4Swyp-|hS6Q6fDy@)=Jz_c&k|*bYEmKxqpM<+C>v0gX4~VZQga za7tG63~3(uPswZom$N0{2o{eXGlOIbLEJIV?M>2vt~kGgzyquzm0b;Ffk`sNd_N7) zc3_ghx3!yUdc`9aP64VWCWM*$%NcoGmXD1~lVy2B>`4B||7@bI8NMYC8ic`ciJ6kJ z>8R_C&gDJ2cNH=^UC044g>FA(vtu!a@Sw7LSkgi|Gg(x+$lnHP_&gP?x;TYlZxiY| zu4%1fASC4j`At|3mHFC@&#_l!(^{no4V%7k8sRy7i=g@sd({Fxrh66VRdcte-`2?UIGJl+?QDD74Lj6-Ux+>8KlCFa5}Wb|K+0k# zUzgHI{uvrQj}L|zA->L%=?2QuwW%2vP&YVmR6AH=n}!k=pTX@tZ2*{sZz_*?kKuAu z${~^<`w|5^;zlvk6rgdBm(0I1qrY^iwij8Ndw)2&g#CZM;OFabGkTaaI!6E5+trLE zc?m4BX|?y^B3M$G6d!R@!Od<*x<6k#?;t`W^ZnlOiconk4ZhF6uSAn_#7XEnC7>GH zXu&k+9d~^#@_PR0aTnDOGX$Vj%N90D?j1o$yN?RenP!2XhF?BZn!?m z%J$bV1ZHF|gce!uBPbhaQ(^ayP8AWLbmiYHv@rhM1M%2Wo5wAZR8VsR$aXbrlo{sc z1I>lrWeoMYl_5cW(a|unb6&kHODW$wkYs#|pupQ=&NGR}G7LI;1FvH=(mq+tz1D!V zx1kO}QIe#HInUtuaI(^?^N2tF{`T9epb`Mn20M?U?h)7H5l%&@axiAxZ*{^|bJ`0> zwpVwB(*vx!y-b=f;>pxre#2~K{4+cHFk8_sOplt{q3cb2uU z8hu&Of4Abdeu;S4%t4_uJmM8i*NE5v|e*C9l1e{-5O7ChhjO^U;);yst$@2jwoX|_g)2$B;(M8an>=>fww<`3P zXF8-VCqO4x?pHZ$Al%&uw5sH}r#|f;!C!M$s*)KPyqjrc87H?k`|RXH&j=%MO{p36 z8Z&H$m?bq82*JQmgZAhM^0B9BTnVdpjL<5$ppfX`T*r>65bS*HrT%?(5d9>2AD&N` zbUOG{ziAHBS~=&NA&4LRfSZdM_?_-UFsIVCSQbVvHLyF+(~&F2Q8vR9d)Pt69kE=A z0RpYo7<0TykV2LAMhm-z_q;`LOojR9Pmb+x>-N&m41aWJUt-&e4U_2c$FbHuSD9g} zK)at9oCGcwE0;#G_aKkqou&D$V&b@#IfPJW_Karn@xwFm-p!A46I2x*${#)YLpT@q z>v|(dy&hIl_J_eJvzPgSjN@#hriF{fh zd4OD2eW#zSx|LbGDH1#mdbF+VrAtCd$6l0a{qIFasd|SBDNS1@CAIu=xlk1YS4l9+ z70a}=L-ulN0mcX+H4PO4*U8P{|Jn+Bq$dP;6>^6_N{!`!c=Ew-LFnD+bT(_No_I6r$myOCt?HPAcNlrQUv! zZIXPWL_&Czy{{TWeE6PX;1JNKaM)yM!qlew*w!kWpiCKNNDh5jWdn+}c#SkHtsfRx z+zb?0dIM!b;ekROqhg>Dduqw1;9yUmH6-L`tkya5Y?6^a*=yE2w+BF)_4CMqO6;d7 zi&rwh=r({?ig~D95)R5a^}2{cWT2GvR(fuGeZxdy>v5>n#G;`>S-zt>==tI24gOoYGdR&HfOOcuWMi;aK8L@ z0INU(^ocT;gAN6aRSivWF5!hjGu`vcbF|oD=m!UugV$364cvO?G8uBr5X^wtZ_|+i z9N{N@LcPZ!2;CCrp@({ba113o&b5c8p?X23A);WJ++%lJ7!K-B?Y9R$-eEnl5CDLi zT_Eb5IpL3w{U$FEE-nE9&Skei^;amlxN-FmWy2&HXzv0nch{d18`F@wpFd#HfjSkc zmvJC-NgfC=d^~)R_1q2K23ziA#Ol5+>t@%=IU4~BMvC&qQldW9K1Fis&mN@rTImV* z--oDAc(j;%*L`8Z22jsjm$uu_5K{n&^&1@EkRu{_mtwJfL%{d62oDS-4I>q=!nR>I z*+ow)j6Ymiu((;*TOsNCqD$C);CwM6!z>rksb|Z*mO;#6Bu}i>^j0=>xVZPajSdah z6Misol?Bk)i^jr(RLrOSs z5jPoC8);@Xj4^*F5ABe41N5%#VKD|20FM!YRs%9FJNUD0dy)sF-E@Wt>(B4VsZsLX z`O-WBHSdY{DzuTqXyYPW_zdiDYWXWByPT5=J zdF0qutuf(B-rg!KLbE(UD=*Reyk-?2H~;wLVd~HXL)O|jP-*?cP$2~wi-uBh6Oj=n z6QLFFh#?~zp64J^=yn%PU)HJr!+6XXY6=eG=qQLLMpc)i zG$9^AE*F__aD_x}H=V|#eF^!6uQ;&{ED*eGl>%PQCL*5oL*P#OH5c6S;{bd8!^xLQ z8T7v!*V(3e1fErjUk8Z$U)dax=wqqCYB!(ij?mV9TCOnm-9f2Djz|==7j8OIsD4-) z0%kaqPp$^4bR6-Z*LgJXtfGy-jJ_g;vD;|lGr8dJ*J>&Tqpc(^Xq&lVz6K(j zJy&V42rYB_eR(;gJbp=>0;`&Pm!YAQxgzu$vR%=d72%LK!ou!XTYGNQdYols5cXs> zeq`*uI@h@qCT|?ud23dzSJyY~V9KYGOOVQ0ga)yW*o|3`adL4ZBka!V7JWIjN3Ztt zpn@$SoE&qkW@{x4xj`)GW1BTbL=!B{*}oZ~4ychbgV@gEHgBwq$CX}iXeg4E@o*E+ zRqQwp|>svErmcjpJ{$L!0Ev5{9FCW;lyc%n^sr zd(MKOnE^0aQZJp~ZPJaLfuelqOZA5fn4};7ot`OuFOgnCMf1Mt!E`%)DK(4jTm>}- z>oP?%8{N*e#E)Y|Gho4@xCIlHm!tnsMhhq1&MsN&TZplZYX?LDwiHGx6qqU*Q~&6O z@_dVmG;WBe4_FrJ(MU#1OdaaE*Ggr3>7Am#FiC0w;}@W|T1`Kws{Tt6i?!CXl>eTt zMT5jZ5L37Lu{(J7DIA4S6@KozF6$y*v_l=B&!4@>f_uoaVL&Hx0ED1-v>{5J;rY=y zzw^^z8Y0N}B=<}IY)6>TH5F0f`&9RIioFf}tGwaXp432E36z3PAJ#-_ph#*O0)%Xh zYVi|36UoJayl8A)e#IP+FS;s7xZrzRK2FTOBpb~>oe*RyJDmSjwc?!*zAr@WNaB(T zoYMOns4z?%DN${YJZYgZ5Utef(`Lo3E8s=gR^?UQ9PaS#GhZ|Xt=JuhCN|*O(DSCx z5(Y0IMliz0{zV?tjNzajfUr?8);9QBI}r&~c^TRiGAlno9Tbj<2cBeHP6sC#c+8D} zleAyXF-XmifoKjpj$0x99OcUL#^nykBrhE0cK1QT?|p}}P5nZ48$norEUz=9IN!jm zc)7a2?foAY;1GcW?fQKir2S{UPy_C%eX1uc?WhbBn_>1<_Jg4i_EY=sG7;`JKpBPYiQ$2&cICUhNeKj zIQY>m9Tr{1jZ*VN{n0|+ZPyA+(0*TraCBul0@jI~Q5N>tfl>w{Zk14K2O4w8ZqS)b z-0nWjckQSL`OgOOF6hez!r|a)+Bvs=9M1PabPfJ}Q>!Gk!B+45PoxfvPN*!4&)#(fL{Pqn_(tND84^fql{0{~39X$67=c^?=o zBY~w+ZOTdfd_~=S0mN^^?jLL(^dUBuFlTSg0!Mo)+HNAbHLN0Jpt_ z1t49~+>}ALuTMm?D$N)q9Gt7>9|iAwkJj%gJbjh0@pN=lv%AB94_a4`J;88V6@o9 znpVt0a6NnY537kZgS!SRc4u0J$;>QQa!)0F5{O%-p-(t{=XrMs_=~#6?X_YQSYMgO zMJPD|s?7rjC^!!Ci^p4T7tpBl+670iz&1Zp%`31yF*rd;juHJX+KhsF!55&k{`#K( z_If-78?3;LYaCaSO}w1NU(^`6iPNoNNDl`O~BDykQ5o z&jR{2->qr-V&{&>cb0>M+0>%GUTwj1OpZl|P)h4nvDMBa`6=NibwHyAsEcbP=~F2= zpxB@fOc0P`pox5^F! z065>N4{Z=AFuR<{|I@IAlk)Px_K&gF7nujX=;zmAPU+Yb9NTvF_@$d@CBl^)0GDah z{V0@^@q#45Ij`@wC7fy9)K0|hf0wO>yK+ILP`pBn-ZnyEW#}NCh2C~&4u8TOC2iQl zbfu}+sJxW>iIiP2kT4t{Ce#v(#zKD;GDl)S^#;!Xsb=yjd`9@`DICC`SF&QS{n z9X(YLXkxp8^5WHf@mvj1R}+G3nP=RKNv>UJila@){|E&2H2%|C5km54qR>w@0CRg^ zZ&;Skg3-xA}fb`Mc{^T@=t661Nw{T0{p z-vG^y$2C*OenqAUO8O-Wby}KDxtiT(ZpO0N3^F*QB*;VH^eNzV(_R&f@=uiU1L!$Z z6jDWItmNO7N_sZ;wOIRAM^V%h^ZFVYg)&0Tzu`CI-jX?KKS#ptpXek3a|;azq?8lp zscaB#Bq#!$$Tfxj5z7U0aUte=k73zo*ys@iEu^ZSnNvGqUsV<>9aMOGKHA}IH_ODo zE(~rsMA|k&cx9%L-`hv_S-ooPaKz(a5fdI8+eY|t9!qpm;QZ@c<}9XOSp;q^sXa8= zCUmY^7!k7gv)45SyV>Pe`hCGr<#jyzUW}N3iiQRXnQ)d5dy`+R(=S?Wd~{G9Oa1uK z#xUX}-EO|;^@@09@gvHM0Q!y-6x@R9lfi(vt83k=%SbYM$5FNO46wr+6efU5j+I<~v90^%xv32b!t(ulZy<=hE>#{c&4i6qLOLb>#2QWQR2mF(X1eGRq>6XK z{;XlH%h}iv-8_*Iy)Ho@dwB{&M0x`e8XC&uv(_2+7|{WQHh`St#YyqzrpFl1zE3Yf z?9cjxG>`W3^WNTG!JiTnQJMR)e#SRSqpx2s*B+T_gELUxW1XcC2{(Lz8}=!sZeItG z=SBf-^UFWxAsOZwGN}O&RwX)&moTF1384TQk+lIbR4;Inh3+&c_>_<{^`#Lp{uxqU zxNnN%n5$DK#6Rt*anUx4hFseb**at%=W#iu5vN}~1If149SxbQ6*&hh{n(?;M@;eVHWO^4&2Z9!*doQRuIpy%^ z2cAS5MTbb!0CPe&<05kQGLpQS@Td!*rTTWRh{qX(X<|Sp3IG$dIaf-+*R%6%f{V0s zHY#4=+<8JUVWsuqz^u@4KZcN4_-#u`ueJCNNd@-14pyohK7*B-p}8R zO-u|%#L?dGjnLN?Bfna}dV;*DyIu^b4gpnH=~p6vf@Maoi*llmss5dh^PQY>Fb8=4 z4w`c(Kj-`U6;1)Xvkv!zhbME-A_DOb8y7;qPyN(>oD6Nk>ivG+(tC!%kA&5GK2Ow$ zU|Am{gmOLxoJ9!<`ESTQlCn5UTcl5SI~jeWqi?;RFEW_#Mi`Z}X$V=Q){xrpy4!C- zw@&nbtr`wF;t#+WYG~6SP0;cvoFnm2%3QLay8L|mw26xIOIayEUOLISUH&vIRED-R zMe+JXEw!=VNb;4Gb3E;+$EUUGvl1KH+_v!qUUEp*tdsSIdW7RQGJ_Zr9CcD$B zan~IO0uFZ$5!2;#ROZeh{QbyW*&P_pWI={o9DD$gL8YHL>=g)BH{XlOs;AvUL2`{b zKD)OsHKW%DW63WGIKMm-6@Apt|MV(JljDs}2@N415({vKIBjg%EX0~_jCv}A+?r3aKhFF&3o0NN7=|Ct)O5ejGyJN;k!^lmo z@!aph=BilFk(pITBRSOE1Y8*g-k5YphcQ+7@d{k%0|tRs8Y(K~vfeaN2ngR#{~vj8 z{T9{t1qvfdhyn(Pl&G{wNJ=9JNDSSLbR#K43?ZPT(j5XrGjxYYNe(f9v@|nx3^7C8 zgI_<-`!BrDz5C&ZIqX_z^8s^ur}uE1 zwPoc9mFHAdXe-U1+H&eDlx{S!8%9A&n{u*yYg30cWEXq6vXYCzVB9*01%{uy?)li* z2gY#X;NaXDxyMhYm(5DkV4#HT?M-ngW)r1vQ5hq~YP5NU`Y|6pOFn626c}b*~F|v6xj@n{*7~aTpTPa@KD#=g50eN@b>X~1V1HL*Hi2FLsGZdJUE2X$o1~eB3fE%|!`IEw8GlL?0E`Z~ZOcmk{&J7| z*6)fU!ZAjhqhC4G2?*uK^lbNG2Buu_N|1^65TGkcu9uNbl@Q(P4(aJ9(Go8#xs$2ya$) z=wAg#waBE2`RZMr!>?Y-O;?zO9&gXc=13@CVcRyRf(RJpJm=gg1b@DGG*qVkt5ExO zljEAP#xrI;w-z-Xge#PuIcY-UX{r5FcIMZGtag$Q-K}hXYceJFBY85D z(c+i&^ZR4s>~fffOswF=co69*%kag?0!-QGd^sjp+3z40yzrod2k}H;v)5h3OINvU znN2ue-CH}H!NzQii59!~0q^G{;u;x6B_$N!;9yK{Z7n}-ufA3GsMuMrGU^1fd$QI- z@&@?)0cDDk6VowN~v=;cpCv>YXW+6rGBK~o(^*Do1v0|rhd@%t88|DDd4C*vcAuqtE zQf=7;q|F5#oIUY{e?&v|Vd|bIGe_RWr=l&{t&e(6ZlM4=A-UeGssSp)#qi4%((W0+ zWRm56$6LBW)By3&^M@HH1%-t+!B0vJcQFWhaANLh-OgCc?paLKy5*$?Bz7Kq<@3(z zH<{YU4DVlx%>|*Crw_qLN5Kj|8<*=^vt|9(N%$uAJf5mBs~F$2EVzk-6Spgmhq4>Q zpf{2B0JP)!4P3spYu@w4zLP$3J;oWAqCOW*?h6pV#ImL>_62Bn5GiVeGYUStM~vyZ z(wH&D=+Qb+Y_IQm82nOtMvD*NajRmC{2hWlc99)G%?p;{k~Ly4*O8kko|fQN=cl_V z*)mXe-5_8vtc+RQ5mc z^C0qP0+@6*NT?jHM-~iVdu{!G?e2B0?kA*|!<&aMBL*)i0gx^52H3P+gCzi-!ztK1 z&3JVz4ZPouNHs7naDE#0C+W-IIv}OjfDl3P>nmAx0Ty^Su1q#TBW{rTqx@Xp35T54 z%nZtI9T?mclg|ZEQllx$!eHOs>hT`%0DMVFpL#$A?nIhma$oq%jlZ-W5Y#FPtf-Yv z7Xun(ahuu2R=A7dqPw;jQexgfNdQQ}B^r3k+y3PDI)H;wI9a%6n-cyqzofESlVo^u z?^PiH2*Y%s=Gt$v98;KXUa{Gq?{#1{AkF%1dtI+1uWKzZ=oRA&=+4Fd!bq%ON{${S z{+*ad+jhgZ!p+8_fkBJF5pT2nEEIuA8>(BtPXdC8@1V;34gzE@;|_3FX5Hp|v`7JS z=;N0fRsQ5AzTbcHXWxF*R%J~U(}T$c2B6R!)Ab3Ekbs*0I;1Qw{j}dfx~ZOd$>w|U z;{!VLiFODR0LK~k1^D1fB#Yp(4Kg0idBP@Efp2v9BFPKBb@ZObNQWV)^4hFb-D1yq zfyy_gf>9FT2iYgZb6tMV*s`1SzB(5c`nV!E2T@Mqzky@Im-JX$ zuqpn%ZSE?DiBGA);y+4`mB#K8T5--2EJw&5QbyAS%N6eBmsE2gI}18`Q26>mxC%rK zf}JGbGm=XE(#z_)Wj1_EVfKUh6~Mj{i&@XA_qcF{XG?bngscp{oP z9II(0CHDBPnz(P-#hnxr8_58qUbb#xR~f+n(-!)zxhO?MP3e`y?117bwooo`@ z|2$vwXC~OaC-h3m_{w>^4#&!CD3TIIF2N4yjPeA$0hDn``j{p_e1GnqlY}najKilY zFn<*ZP46%sVB~}7;3CLVGD3WFE~9G+;Rx?#Iiy#Cy``s8OCNkf1!!3BmsLU(^z42a z3HHLB_}7irs0H*N1z;@h6==URlpx{)0YY2y>YK@STA>v|5H~2~+A{p`F|!(KL7MZh3e!5<=IA4! zaXio6@ktZBcoVJy1CD%qj=DYp6@yG~Y$RronLD0xeID!8a(=R_MlVVSc$3S$S08eA zfGF8Pna^oXqw9t2dfQOQ32Jd(*^bV}Z1BAY*efa9$n?H#;Y}R>8m_h5@&Qz|a@?B$ z8{i}jlHijQI`ihzRIB9)XY#dhX)`J411QrJ^5@NaN35-M`xb6x&>O+2aS;T?92ZDgh}QNY z-dPL9gF2mqc;36a9;jk3ku@J#VL7SOKa|d!3FF^ z@+Vw`I^Yl$D-3gMw1ss~Cs_2>I`F>)Ff@_tZ^24KG5SZTl?O_yxx}%fb`i0Sx^Bmv^FALZ%;it%iv`0_jg!KsoCwg zf*p_C1Nfa}apweeDelcl`~mpH{Ec8i9#`b{yN4xd*1x{4E2s-vUZWE=`8Z)>T8#@} zkk(zc)cz4*=pQMQKI@#Dm&&tj4)wa*xu5w4c|p=Bl=WvKE}w-HW@hH`$;o_b$NGRr zx;NIDd@T&8fnFLg^fx3W%1#r^U1|{Z*I;XfhPZE9ez) zOA?3Nx5m#~CSQjDI{T+srr?``^Je0h>ba>pLQubD0jg;-J$gk}ZB1a)cz)*&U>h+L{rf z6IGjcyR4)!3;6!c8SA4LcsMxPGQ-@6a(s%X>`lIbZ+f|S1qJ2IfIeBMDG!y!d$E!U zcU->~NxWv^`!p4F-QJ|!K`zq$6EgAP-CJaZ#j!TrK7g1@pou~yKOy@gC{dcv$-b5q z#WK-I=_XDAizkyaY5T%?COJ;;KQx3a?~_yd6j=e}J_RNz$fzi?U?n5!t<J@$|JYN z^XD_>M?j#ngQOC`p?JYU!>i$>zGQ(EX0LtOKZ-!axs)jc0h5_@QHEqYv+%a8k!sxy z0LK&ISxUP1Bz91C0d>7W+sFeB_lO#{?#h?a&+mf-qtXglUy)wBJ#37R2@TR#0^+5! zj0S~mpoqu(yz#N4QLr@GRDfW3+;^n|)eOJtBKsN5XNd4|T`Hq!nEyBB)GgeEt*lZB zf1Q&shnp!`_#UIUYAhx!+wWopdviztW5*)(`n4#%=#L`7{vlpau#_p@%{PKk9pCe= z(R2Ed$9yKvvk(`!Y=_~!!eSOQ$el_229Cer?*JqvlHUqa_PW1PLtC49#+`5Vb>ICG zfLBazD~@S!J^o5tZSgqGMUR*eVYdx3e>d_q+gYV=C70C_Xyi}1n3b*K|FnflCn4{h zVYXa-QfizZW2i6C1+*3%CbgE6jB8fsx zS;+P@DR|9Qr}I!c35@-fWR+4B3hf`C1YNt=WIPObRuk){6(cABZHK}mYMuOK75P$V zMI{%P0SGSO_>(RTDDaGeEK4-5hQ0x#5djKubvA7_tvD@pSy2i=EuXkj9PWgh{}V!d z%9+WZt&c(FU`0-&7pn#~eepDwr8jZPi;}vJJX>hL+J^^tIP7o%PE{cAci?MWCQMth z?!v({2}sMtK>d6Y$*`5>_f)3*l!*tp=<#}0cBvZ*MRkll@s(w9?!FeHQU}R+csLRu zUs&qc)t3LWnUsw7!0~pjyMV#~{#Y5#S|J~f8`r)18aN^W=c=42iD$X>&Z6L|fvpc+ zB$LjZ{pQb~<{>_Ex|1qHsU%Z|@WlSNEP(%MoyD#T&CX)PD@8t?V~{ZBIk18m|MAK& zn2cZd<`MTEFc(ceWB4x@05B2-)BDZO#&|hH)+qceRY%5yC4AYpb6Gh}NR8^>9-Jc~ zWder~2si{0+<(!01&|ZZ?~01&rkzxbPja{0JIBW%FFO(~lsK8>ougueEqH`YgMAj- zPMyFa>-{G!$OWrz7j7tA>1b6sdU>sR>*s5@RWmT{MCa*jQu0UJ0Rxqf$*+6^pq%wb zo|N5PZHbuBng9t}3eT;ZRmbD<5W<129K-Xe)U%79Ly4TdhdyUKbdo7&*dwL+*^@gs z67Hn+zLYTo$%vU>ZL?{V8ph4`YgaObPNK`)Z8uks`=^8*;>B!EB~_drcXwr4T{u`; zabG!ID!z6qIK5_`_{Ud@Rvm}#kqJsZ-srUDHpF|d*EB+P< zO2X?!#^1tn^Y0Sx?{ABz*YS(LCF|}jK#%>e!~uBt_w)b4!S7|=R^c}Wq^EUVfqMme zd1Ntm_09ZUtN2CEZvP3R6b~e&p%m%_MtT}H8h)X(Dl=0QZ{CHU^SWkIWKQM*is8DL zpt&Lx1iyY@wMmIeicpaIX8Jg>%oAx_<@f5Y6gPCYCsF)@*$iXEX|%hvo6?{R!F-5B z7C#PomK<{TdjVfKz-ec#D^0DtVf!nd@!&9}E7>{3-GGMSi2FZz!c z62f=o%GP@a<#ijl?}Fe)ZCv4^)+_O)Z%Uu47rRD%3K)EM|rN{sot_OHN~+|BU` zCyFTpFfUx5z4ffRh5XlSa4*lkTa$meuM&hOl`xPc*QD_b7p(_@oy7>Rz7SsR^DIPO zn=POqxF`2lgfdF9So`_O33Ykp$)BmfR9nS;<==5E_gP6^$1{LZUR2LxN52L&!26ki z%ij*>16DC_C<5K0DgVv+qiAi_N3bx>U`G9^dGB|!0dhd6OU;(#8+7N%{5MFq!Am@| zRH9Gpx;FyRYylE2_@}Kfd!hVUvN!)VNiZaw2>Rw9XxjIqgclcW3kfn8wHOoZYx*A? zIQ1;4L%r}bA{kunq>|S6goxrZ(6 zva{in!uo~f_XS{7;J1Yn2` zeT|ibm`6PSO;vJ_Qy^Udqo`>Nm^kvaT$ckEH@$x|vGu!)STO61ePAU-XsZAa3iKB> z{;MmCNLzl9noWa#f4=~Bk8_h%xOar^U!As=$7p=2+0yQN;CgbLg-N$Lw|_PDqdu?B zJih_MN${t~uB!?BQ;ZVsNo57?41a>31Ivzvh~il?S?_;cG!nOR**JUN{s{)eMJ8j@ zHSV8WNsK>lGkA=PUfqgFPV*tz``5le&2d8AF$_<>ABc)Z(2nHM|Ksce7eOZc#7GI> zDWPZX|DjAnTwXgdTEdrd1uD{@YnlHKVFknuib@&%yy$*_`?(e}cYOYht|EMQH7Ul$jkpniUPw{W%8&qU=?4K<0Y0a_1_D5IZou= zeZ-u8Cjgu$M4A8QUt=A{f^Jo+05D#?ZgkhX|7c9bK`to&9Ec*Ue}@8Vo9p7Q*?HpQ z0)K$Z+pgxFuu?WUMmK9^G%A%zTl_;b*%n(PI_-)*plzeXoU2b?X*f<;q(acd(@o)K zGJJV3ZR0E8g!zGZv8Trd?NtlNR4+el6>*ZUj5JZcw5Sz=c-J{@8vJsfAj!|yj=q@6 zilM-Oxr)jb{7M_^CU&e6Qqc^%OFgY6f6ifDUMT5{!}W)ad&E@U>$I3JnGt&)*EI9D zot|_R(d9qW1LA*-eHMmiGzB+s;_O7qf-?K>j9C;RX(!>IkWpZ9KM6Q3dp$@tbmwA@ zU%D907kRu{u^?2~89Yg5Gcix#VS6ZI#^J3Hgc|JZ@_0uR!FCoqgODJ-#*cr|qNU-P zkpzBnBgb}^nVg6cz-^i`!-0XVt$G>!FsDcJk4opc4AoG> zI`cOIxoh5%_lu)f;$H#hro*o>E5WyafmESQ1cLV85_7o4ak4~uA)-(U@Ijw?FcspW zm7mYxlwT}X?YZH(W{clUBg$8G`2#H`G53*3Gf~+XCgGeDQN6^uz5)1mK)BOFB=MYw zj?p;b$I0aTP;T;VYYpFzrgdKoyDF$nN+EOAExY`s%J5730y`rq5Z7q{RDIbtG&aHSB0XiV$mg8oIzbq4}8P5+}6D@=zRhnr+(R^R!UWW8YI7;;s|py6?H}ruJ}Jg7!Ls zj#B_N)SFD)#d6;b>b@6%iK&nC2I%|DHA`8vWxfQqP@8F^?dm*H!wVi|ZT;XKG@;!g zCll^62V_d0fjQ}iYA&;su^BL8Hg;!{*7k|aDv zsc2W&Eag{fh>e4d>SU>DZ$HcB#T&FJ5A;+*Cb^oK&Azy`Ms?7$Sw{HSQN=C$P5(zV z-)K@)XVq;+Sz1AEi=O9U4hvaP-qVQIyokCtFA6Vj(o=0wYQJYG{j#5Cpk4X1HgLor z#Xn)^+oNgQRwX?M%8P{|4ljg02*KbwwfqZnMbOVHccV5sPmIP3JJ$KW>8!ZMt)xX2 zpI~#Sz-P@dA7qs#V#!HZ9*0|B)VwlmDVEmv4C&{{|8qAQ=rm-#@!N}$W7e1}t8vYJ zdbq|&f8lr0U}~QtW|S2z{;EJ7&d4jY^=qG@=~c<^V`5u~S#hmLNMim#hlZXMK?qtN z4)88_U&J~`Ym`Y&skMGiij(~)UsM04{?MP#7}6-)jSVkG`0EtK^_52GmivvV`}&K6 zXj{~DZj>Q4;vVZ+Z+2&ZA93d)M`g}5CYE~qDXXiSglsGIEYO{EbqDG4{d3SVc%&^95cuBw+^aib$=5=@-0tkZda zkh+%tMYDVxNeRBbdyE$c?04!&?Q$gkD$B8?YB6z}>vmYaMN zR~|}^Te4CMqkF8eAly`Q!cLsmVE`W)){aJWrDh&? zJ8=hJz#TQJ|L`z*Sxbm2ud>%$$yl_N>4Lw@E?nh*;+}t=nZuCxKILb8c$qfx1hXmZ0Uqr5X|Us6JiR#wR%8=o`8)7bWVA~1A5O4v3n zA;rwiOBuTDkxPhT9HC)&UdGnQr7Tg$QLu=t+?RS1pCjoOmFJ3_T}bMQ_UKCq&ZD6Z zkY#$I(-FFjhWxOOqXwg0vrHNlmni-|5r{^#s0s~~V)k1MHrn>8W4Q?Ng)Z4D3e}WJ zmjS`T!EB z?^k)0@7mW4Z@h~5K{_|+bA^l^uY_#ZOZA)o!8XDsB!NvYo zqdaw?>Y1zD7l9@YT<7Sfo?3^lotPKFz|HYr$2q@QEIsq~MYQZbsrV zQu-p*f!gFe!G}^crEuzpwR?F;v{=mN%m`NC8%S;3+sWs!|wD-HK&%0pAtOYkUbH#ZNW1fQi`rSrFn>4$^4Cu*n*Xu=Uq zJP5UyA60y%_$Bp|y)-pwRgKbuNNTk(F6yG|1K-?2UhTQ?02Fa3fxJnrWv1i)j8z~* z)zbEOfjbmieU)7>kIDGGHT63uNN6wkJv?z*vP(5OuQECX(ZzdnaMvEZ{&d0x+~o@7Au?o$$xv=wy{Mw zb;d#WfLG8>33l!+S$JN%PlJY7s0cgFLA{iVlH?0KAzqy9XB!_{RCc^AoK-~OwKlsu zXUjw8#zh~Sa%uDA?du14dffj^%gni-5RpFZw>UeN*uy-+kXqZr`j8ejDOqHLZZl1kXCsb?u za_#|}nliE76+yI}^{epMgx6#Ja_f&Xt_dj-pRLxzxK+V1I-Q=rW4-Zhnd$`=Q!C_G z)i5COOQR#hp>dTtWxSg8Y2GN+)xhiT&l(n#U@xYTZyl~U14w+I`fC>}@ zr9B?`*0!yF<@`oBnJ!&jWDdH~)kkE5_7zawtB0n{U+B%D6E?PnPfI~UdstDF@`_;s z$R>9|-D<#~d!2=`?XWT`{l#5yhpqPsx^cVg4!Tw}kK|I)n3q@nHcBIp+XjkZDcJ zq0pR%=hl1CJ;eq84DY>M{2`5vNOw$02>g*jt$V89dELzT*EYHNsj^G>xdcJR;LK>8vZ4L6Nwir8Py=(roB-=@^nP)9(&9k})ol+iHmeZN- zC#wBDO}WxavC#AFA&H0u0vo@$6eJW$jKXx$q8iNBc&i7sKz)ta1(f>a(-0 zx-H=w0v(MQbe>ofUNbY3(}?mkYLC8HZ5^!_ zZ2z%}?0lIhsQfied|~t6PI}||O^4}O+kTRiN;B1(wkrL)IU}E0D;HvWmSpj8H&n9>!JV>)VK!L9ktGxE#y1W#cXo%> zYtz)|6}+ORK1GRYz24-{TFY$H_1+mWZXVUB_D(%+hBa85cB~xIH-4lsv3)B`v;&`> z%JvqkFEv?IRUb(eu0FYmce0*0exft~J`s68o#pO#^5M0U*%DFgdoQ>$k!Q6HTvn)B zP%pW4CBv0h_w-TeonIW7&O5~y8ISlJz7%Ame~RlHaqoJaahhC4+1GM z-hS6^Q?m5$XnDJP;ByT}b#-ZE( zV|DAC@0CkY%~rk-sw`gII$FCYov z3Dp;DU4b#)D-j`9VvpwFUX82ydesfUwdpX|)Sa^q2iJwEA*DI2 zM9)@#V8Ey^=Qdg5q^cLe!h0wCOhZ4}7&5KHq0b0?=X`AeJ8!G~5SxuCR?PSjU=Gw9 zkVRC7v|^Eb#n>Hddr)U&eL4$(eR5|r;^j(eSs*b8`rrZt?U zyaNbO@5A-*N1+k(^{OD(nlF@N?2vl>x`F-m&i?f~f$YjRGkw*JFSl@whR+V=JM#wF zM>~;+(rQA+!;g{q+cGdC3E&f`0 z&`!(jOEYgQm=CVr%IL9)&*x)yJm9n*pBppZEgeU%%c5W5;7apJmqOL-E#95^#$H z{GCOX93U$MSSiblc@+pJerv9wDoDNWegPLo%;_y+9jY}2w7*l{B_mL=SeZP= zG_1o?v+-t4U*u)4_mEwws^#P}$5F9Y{91p`zA6YcVkaTmoOvXiIzHA(nUCvqSN5S5 zW6ir*tMHq>n88FZKai<3h@73N(Ih*vaXV2j{`AP?4QStH$69`WBn}9GE5quj=xrMt zbZJkji(1@wqNS}qD&7nove`11x56^>elUI3pVwAl4%b|Ju5;c^D1)0vigRmFdhju+ zQ(5Mf$DpcoX<(4vZQ0n-^YBuwTpRoG!3KOO6-ym8+a14jxz(`g#W6yK3>|jXX=rcEwBOjvqGxH02@+bl&coI{7& zD~f1a*{oI_MHSdfyNsvK-*z?FUaxC7^m4mTY0URq|Dl5vtY^G?!Q*6Y+ehT(lCO0j z2<}tzlCG=Rd_?_rb;X>mg2O+5R#Cr!aR*Lhyml6hOO7?EZ4yR5g#6CRxSD~@Q;Y)H zz+O8a_4Y5A$*(T`G4u0zqE2i{?IL2(4&#mSijL$nD{lgj?!lwFg7+pv87i0F@4uxk zw9b0mP9ef)Tx~0}SJKsHD}N9w2mv`9y3`qUVn@q5!~3j7jOtCCTi&P2w>YR#QL^l0 z9Vdh=)sSh$M?8?iBj6|z8W-4){~Jag{~Sg;24vvP1Q-Ynqt*(p+UYia@Gx3B$o>p7 zY*Hdl{b@T(qd69plm-zj$j|62-QeL353KD9#!!e64Vdf$alKXrL)tsx^&RYES9OwI za#^WEHuHTa>hXrRMr>`gPJ9PZN>;pJH$^GYbux&T!533m#!2#HmoP}4tg^s7w1vWU zM49nuHuI>!v%d32AhaN5dUJd)lN62H;hdBrxe@eUC?-G zU0z^Oe_?iY?nYXjJna+2p3ddmZ(H!3OqV3|`z!sbpq?}`-F#?Nm#-qi>1DIHjgN`s zAwCNB=w*Q}D_{m49W=*Ed1}H&ZMux9Mt)R%KvN7F!EH7wOc{?I)fLs2jKSeQ-R#C> z<_?U7#v5w>)O?gnFKWLOyPx^B_}A>>wzW**PkP$OT9oadn(;O!0|aSoPj{S`f*tbR zoPzBiYdl=Ey;5v2LH&d>j6n6sYb-OxPzg}^8BHGNwjY+#WQe9&d>lFs67TQ|jJH{NI6tf#qlx^Mv zDmtM9yT63USX<|Kv^nOyk9j{?7K`ruU4jL!ljrb+hX@8~c{(e?nqvfb#5G_EsX3L5 z(sgC(I)%F1NnXf^rKzNppw&9;^Z9IfbSF9B`C5@%KLH0_H?QaO#^uYTwE4@p2KIBD{ z-Nh8xKQ?GT%x5Db)VJ0__Qu23+R;qr_|vp)R)cE3tVqMozq?T?r7UMIrn}_f8=}1J zw(Dt}919N|GIB`TH6-_A+2{)N4MEd1lp_*;{@%7KvKdYzJNn^P0m7VjQ5tW&@HVH5 z5h7Kmg>!ScYr{z)2bK{+@Ye4SPaIXO3LD|-a;DK8RI&{_$c{K_tP)@b5*dnbjs1ly}DTGypQhci~Hea zn49N#Y>5^II9XVVW?pjABy1bP^c~w&es-v%hUG*rx;~EB4-b0s8^7?r?=TTHcR>Yy zzN@ExyJfEpywVDjN*C^+=#W@HDkr%DWr7cXx+R;|EW`?=idMgw@eCcmvcAj#%b$;# zZcn;5nl0c;lpA zU;^)P?bl|)WMh0ywz)K4rm}|WfGA^E=a%zFk?aid3s2hc5KW5x6$To?DS0u+eaZd+ zlP_n;`TA~*f?EnADaxnyJcsAl-J#Jzx!R*~7FmyP#QKp~z;SdOp?tl$oS6*@E%uu>&eYQ?f&2On+wF<4-;QfpEk+ z%jGWx3`QG>xK43bMaAUA8xHef8ntSC`2;sV@PvZV+Y3>fs2MZ8wvmK*_qf+W-_=7$ z@v59bd@W^OP!UBPkUs7xa<=3|;(XUHtH%#fGC1>-C^T=YSdN(H@rd=$)ErL4PyLyZ zVJS`&n{f@f1JSQE7v5KTwjq^;Ap%Zg6W!BZ;<6`3`TC@y`9Yy!*yPkcmiPtn!SWPO z`TY#W4EFo{7P>J9b-smQ&K%ZsQDf9WE+$hx;ldf@Fk_4IHa}XBA?hOx9=}|s);f7! za_wi8Q++LXSio7dpmJz2UggxHH|gVU@1er3T$o{sK8o|Ca}=sOcdGb>KXifGfXH)yW;vu+|k-_9!^US_m{EH-9= z>R;N0@+Ve^Wz3Bf&Fykz=q6LTYONINv6oI`2?UBZ*PJPzbRm#B`nV4IzG+WU%jx=KI~6aFDv_TGTd zIB?K;g}Y1DZ>h6$bTck=!e%*PdWx*@;wIi|y1j$1ck%bXrdUHX(MgPEx&l65|h_xAgH<0Jsi9d3*Ugq`_ierfW+j)p` z?q{mY`0kL8LA9A-n~1R-Dj^S}Wh+{X(J^>k8S8hQ9{ie?Z0T)%PP#aK5Vd8(*zW0TYIF7s-8qZ3{JSm0$>4SzAHl62Ltde| z(5N(62WVIU2NeX>hy-3L<7^Gc^FppzCX;rekYb2+zb`i?Cn~LkSr@wXxfC;q)>~*W z(grpYQuXB_3^Ks7y>v3F@T3W5n`PzG$Znvn#gK(r19u6Psm(;!6genJBr`98cO)*` z%dgVRLbciRrtI;5bMoX*uH3gSX!uswC zR>h9V>q1js0!O(lCE77~;-g1PHTfLAEavJ_2CG(wl#v-FKah76^nSPn=gGRARv=1( z2t7QT8g(Q7Mg?pGcVi={T6eLrv9YMl%`swuSqT`66p*$ecbyHw*8>>DCz#paCH-41 z0x0ojrw)`)`&2dlakS0zD~13S4gHgD4Y01JYzqXl3oc{c#cxk?#8#yu8h+%M^}=Wo z0&OvM<<>p?bJ(VBJ1~>Sk{uj5W89mX@x*qR9kQplZN1oX`&y0EJe|E4N2xOt`#mYU zl`!o$kWc$F1+k}%MQE4rS=%1cHkQ5}bgXld;G|<`8L28NFGCTidXC!9v3 zci;^14duT}64ejRVyCZuNVGrC24a@KzyE&zWV*5TO~v^%7I~X-$YNk zqiogW(H7kIKQ~F?uDmIal<%uwV>hz2lBUm(JsiXk!rspY_CH1W@@JcITS$X!UN8&j z``CE{d*Y33&Gn&C-H6#2UCM*!J9+URyJGbw<}0?Y1Hl_-&1yE^k{r*Jw`&@HuwP@P z#I$wSu2fsqO55Z9Ym%Ede7S|1uq(8Kt>a6ytg>T~ThfyqU^Q`4!~X0jvS2&mS4oe2 znqq0ovGU!`o@T1mvO&9IbeFPCd#0{MxWFzx(|k}`i?=B(zPww`I-|aD&T`+!cQ^KbnwLvSNel% z_-wx_bHC^~@rAg!sQLQ(HZF!xZ;)F!Gr9DE8hCHvAf9vPuk?O;kk2EZ4)2X;WqY8) z`$)BeFEXs_^~B%&G6_}>Ux|RPHNX*2DpdF%b>P6BZ6c+LRF4dw+wfl&#d&$Rt2{ZR z?(xcBj02NSP%%*f7Ke!7{WS zS+i6t+=?@RYfl`mU^5tc6IZaUB4<2p@3`Zxq%?s`gr2u&p@N=C2R`Eq>6rG=jMbau zvz^i0bO+g+0bdj#PX8+Sn{#=9joTO*`>pqvGgF?TUblu!pVG(&ZGXD3cZ=oc&MjnR zu@KGJ=1Kc+b=kV}HGs!5sd-^{I+B$0(8^WFm!o)IRTfzSt6pY}N5^^iG-SX-jPe2# zvfmA>bnC9!!6bVnh!^Q=JVuxCl2DUm}_FxrNB+hS`?a5uT13UwW&7ixj;*pU`=_ zFJP}k!!4_wYJo#7DQbWVJ**EKx0hRHnGr8 zOpFo_Cf>^zPNm4!~p;G#6~9N%nuC~d!i(hGj*B< zYjqu3_a0jRD2h7qLad{0f2`+4g8D3LUa)s%-}Md~RilwtmQ$7UXti8hvy;&(<6wKK zba`W+z^V80@{ul;oyCWfv4Y+SSc5`>%^s6 zsvD(fs&j9rq}Yr_*f)i_s=t=Fp{SE!!u5D-cUKz(ihRUrr1%KoE$Mr{V|p`}$T3&^f!@9wfcXsum+p3G}< zo_?XvT@FhLsmxJt6a7t3C+C{h<5;sXgqMuj3QNnqh=^K;JoR4HqUy&vcctiWx*Q`S z8+g|TKhYb!(c)~9nBv`J^YW9fx>`|ND=K7V8+Lhm)u+{x7{X1sfSOrtxQLZI^onX| z#w^x)&|2>+4qry`GA|U4_IkvFKG=?E0P%CYO+3-BX2-0whD{#;G z+iS*G($2D81+K~+Ci^w##F`6zA043^j`nmzxytdX1G%eko5w*e&3m6Pu`Jn_ejT@C zke{ao7UpyFcYI!Z;kWO$$#KtRsm;$my^7H!Qp}7khYyb~D-W4BO0P5NF~0N7S4O9c zVz%3#I0)jsQ)fSqEf{1wWw@NpaivD&Lc- zogw|5z8#}3`A;!r2^j6p*rc(;SPm!OrU15aeBBf{{^t5Lo5bLg_`P9;P>;;>o1 zoCB=5vT(?ResAn5@rUk~uTh;*(R6yf(n*4`>r?6^i!4r?n0HqlqehQU>npaWWXv9? z`L5H&F1a>q)ad)#|B1X02A_DilQ3N3=F}X2UO60oif>sw&t})(`>FZFyXFGCX>A-x ze@`)NYJ*;NW^r73eiso07eMt03ymYT*Cp^xw)_O2;e?!|2E}7Qg$~Ho>O(1JJs*`!VG_r;_gmNg9{fjsq6AFMwduA%*w9NUz5v$2; ztLfZFNMhqfs%0ISS!#8H{n>TcQ?`gOKSV5;Ez#_PVhNH`OGRM;YH9sJaq00Y;MN1 zwio|#kEN~5h>B6tktgNjYRK8vWU>HFV*@Fg1LwdH>a~p z`Y`Rz6vZu^+*|RaREd-zWYT!Q@_thB_2EnfZX(+Ss147A-(_k zP2gw};}~P%g79VPfiBD0`|tC76te!RnRkM=ZkSNr;Frb6IcvV{HFIM@Co(<+;T4cO zD2s7Jtd1p?4UMPCk>KJ!Ep#p=eW;|aoOrp0Uihk*$#Tx{WZ>t6r_ZkU3?8DL;0f~# z$xq}4S)*H<3qiXXChv*;S0p8AANFOdvty>Isoly;lT9MBQvW7fe}+B%auiOrhj&ye zpoH`!m?FiOILKPL!xUi%a>pD`O!EFYc@S~mu+Y~=g?QPb$ulnzvr`!lqKl& zQ$Soe3^V}Z2+4_i{tsJU9Tw&Dy}bg02qK`864DKl(j}eJodVL*u%t+*v~;sHBHc&| z(y*j}bc4ha3k$zz@$>!befPTd;$ml>GiT16nK?7heb2z2I(A4-lulX8i-lGm?s$(tm{JmCMfDAZ zM*ba1@Be|SE&twRu_2tF%DI8UC4p48ytTx3#Gx(P{VM&77|TU;gO$6xwfYOvBotX} z{9TSh^3j0yngchtmPIskmT%&WNLAkQdzyiG2yV^wLz!%@G0_5?WB_4jZ4rE$3p-S} z=Clj~!N`0c$DN+lO!iN#=`Xl_pOm2lMKJ>+Ga(mtGcoWrG&3J?C^B1s?AOoSn_%Gw zzDHzqlMjfDX{Jn>j;5g7y{JiOfw!-ac}!5=%&v|8*Azs9M){xdi+kfpqgert>f{X)w;y>g+Jb+=!iRcm8& zqwl6YvO`P!?-QzD){~P@6*bc`y$Zxy3k&8F<1MqtUVn2T>MX{o<&9HR(ISw_C|`m? z3uDwFeX#tq3zZ^a#k{gI1xVl3CGk-9f)q7n(OLubr+&wj&%7Lwx3{-JSy&J9DLRa* zQbIVwO*r7t>f4-bmo2o(gY&)KHeqnFP`U{yOpp!ws|_wns}wCT(ut~7OrGvDnur9Wn8{?x~LPD@$xwFs2EN&&aW6q0w&dJ zT-Nf-;W0fj<{T@DlbKeYQ=UcS~LJQ9c)B6w-tmPA22q>QyC=&ah_b z>b)rLTjBPeD^}DQw)=JY0$S^h+5Y4C`}wmogcKS|7`08Yx+EF;)Ee=aEzM+tF$WQ^ z;o1`H!ba{#?XmEbHvqvPE`b zIf+GVEu(7rUk;6;x!Ime;}jhf#?Dd_qMuI(`U~=-Xrmlf0;S;44q@KIqw8H2 zl`M}@j&zw<*0pDsFiWMX>5*YdBG76`JUd6mu*}nOi`OXAB1li?sLs)8azIOuJ;Or- zIU!y7bUM5n?T475BGSt_sIh9ouvfaJ83y}L6pe$IAC30IBv4W9ewd^gI|TEIgK+tPZq9(ApZ+NDhtAi6d)A2vwv?03D7Qw89~EPa^rE1GOg) z1W_V8K1WP_Hr0Kn59l$&t9%7*Y(;w@X7EKd)b!;MWv+wHKSeq((J@`4f&>EI05#|? zK5)iE%Qr*6SCR6Qa&3a@e?`@00xBVE-ubic91h*W1UwEnRt|XN=#cUedT)d*GO?(0 zS6{Mh?|rgBz-*jq=&Q49A!pbH-XnMhGWE-wAp*|YJ~j%V-duo5f{G5=0+9(IkaR^! zzX~p>2hapNx2YxX8^MkXT@KNnu>w7eF}-zz&Zf za4_cm@I?9JYp%n48AGHIERiYpi2td*?bh-cFu)LC8r*qsN$x*`Qqn<4jVOsUI#Rw1 zgUo;-HDqjuobo@jnL5`nx}G6TfNa1Z2mF6DO-kv^MBfLv)X3l1fJRy~_q}IdP*#J5 z{eXh$Xr|)Md_DyPidRySQrO=MlVyp`u4W9F{h}%}af;pu{>L#i+d7W>CtVgSB1#(a zuhP+P%ZWYZUW3B$00;QS16RyKp8j2?hn`~(gTB)?w2y56Z-~OvmmP? z3m*DMNTngCH69B1{{6qq{VD(GNnxnQ0a(=cCX$PV>L6tX1ex2}JieuTf=S7XtTGUN zkUs$DAd{j7yM`>e{?$`-K*vQ+o1H0S%kGwV1+4eJh`COkk8^K} zGn644-Y5SWDB$hxHhn+npHhH7kWV2`rT~Fxl7n$UVVIb1G{X41n|SZ7|07;u15OuD zj_G!qLwhe3Wbz(qUD@Jv2%{Wu)1wPBbSp!oeSps4%D0AqblzE=_y5C=5o zzcdi#NAY!1e(;0uQ|ysIX~cPZ zP+Nx!ypT!f?#+`=@2uzkS~Trl(Cj0$Hw*WgEL=W3dUkm`PJp1izTK-vT4F`P-@)!Mv@Wwcomm z+Ydl_>sSHD`t3hBiL8pN_V9b?B86tJQTk$-wy=xR~zYL{@fK3YiLg>($X z=g1cM*_GBu*05B|u;CUG?%8)g_es9UH zCI9*cnOzZi$)4`6>q6UK5)Ho&Qye^1z}7crE%03)I2?9C&yBXg{}{LX`1;Q(Gd`Ty z(tSpD$%v%;kF&FL9gv4w9vA;@x zR$@h2?lPn>y#aokgYQO?770qeh+oQc0YInv{Odyc4mruF-~cOwWd|74wstq9hi>Y~ z^A>ZS49F(hPE(EPwv`YoC-W3&Fpr&81=#LWa?*>7HW-8+Qv?L;5Cb+4n~K>N(q5(g zs5Y#Q3*^m)9ZIFN$kC|tEfAptf5XybN`I3!H(dxb zioFH?4+swmLWaQ{_%b;1$Tl!fJsTfE7bzf6^}sE+cH zgyj_YRmrqD#0tQ#HC#$HW%TsV4y#G(&d+cSfTBJFbCs-ffn^y7mnP2D)a07lWB~DP z+2gZL`-|O5mh4gwA&4lVQ%VvwY@XDgUwb-kD{dWz0X@PjUMAJBjaBJi5E5`7%(v(9 zwb?$y*CCQQ5HGPB9wXj8>YzVZqIMfjx*er2pzxF0O~p&gZNFi%UdaJYD{<=?>jVos zEW(XNHJpsH*wRHLDOfuU5+=Ape0@|W24dV{;NNLk31uu+r4#Be)8bQ0ywo4Ny3A1_ z=637g-`bT`?EO_R(nv8m`<8+8bVhyT;E1Y%CmodJbQgb1g?u-6Z}3Ff8LT@=RkP`f z$s3I64UNbIH^$pT9vldbvsa1Aete+l3Cx0Wv?)uK^z7_kXvk)7%iF&(_pR6PNMdcV zLn{hvG(`Aiu1b^#CJT!yl@CPQjY-cnOTd4+{L`+kr1UgYbG+1xin&FNxh4(a<5k8` zttuM*dM)E>>8C@iTGq`fb)ogUq>kDp)_)Z)_iA@kBM+Nf#R{>KZ8r{wODR)$s&(uq z_&V5MC??!qpvK3dg2r2}u4ObcQt~WlcbXwW`cnLigg!p{u_~2D9gk}c29;|V1(nj$ z>}OW3OX3UI%ad^UT44Lp(mYIy;k zVk5A8MB?ffHCmp`#QHW|_|{N@C85G1kD73Q)411-2(-4Yw1}0v`^J0kDE6|^H~IG7^UH7A;LV_bI;fxrlv?E~jXkQShd~ zTZFjTP(x9OE+E_9afbQ2na3kSa)$lq)Dx`lY?q!@qQ&O+ zkH(;dxmXcxSpmEh+tXYN^U$S!{12dKz(xV(2q%PXhOnwdZSQ3NBIe45#U zz#6t%*lf`|+-$MKY43Awf!LN!5yBH}Rj)mXS4$!sn%>=+bCx}Mxm+P%RZy8i}Tm=8)r^&{u>ZMh3n0ArHgu~I8tyt9$~jZ1s^1=# z6t=R;)@PkaWNA5U+&#{EJQ`OWWUp3WC%U|bwtd?{_ zDC$&TCF>#Nd1!^M9479PqH@p{XY~s4C%XRCfGZ=n_s-{M2=Lh!Jq)PIPYNOd)YFqx zYj{JfvbxPxP5t8v-ZmI;G1bS^@n6z9x&hV|wG^{E! zhlBGSM?T(?3af3j$7NFRNVf#dFTF(1I(vXsLf9{3we~|}-=sm63w7_9qlpkpiY>7;~-Bt76JdYmPYly>4-p*tq^bPE-jyj2% z`3jGV@J*sJSLY_6dsIG6lYAK;ER`Y}dG!QU3|d8JgmK4CDO`gVvk$-R{$O^-WDCFy z4HCe`h}lu7^Mj|BdsZ>wXzxiZq&3@|XQ#Jid4-ef;hRn;@EC7Qey5eIGvo)Gfb+9v z-+5H3l~u?_76nBBC|M{Tw_=RaJ2H z$I}(lEtb7F!rXTS!XG)};QTP^5Nnok5%KX7VeU1eV9aLd2eyO{*%t8Q%$uU<;J?Z} ze2P{J$rUNx!k~q^y*;cL9x|`P=^I1M#;I86r@(}T&tx;pKWVAT?Jnz6cGMVM2Gg7< zolR z<{8*CWG<;g*nN6e))iZvb)6oW1OjWn9;O-YGw$`?F;-gMVHYRJ>?k3I)WoCkcBWn+#J z;-^Y;X8&CGbTa!FL=@v+O&DDISXfD>{6E&UNWjL~^ZGX)+Y^wGn3ecUvt;UX108JD z8p8LoVlqVdvwT~Im(Tcfei|4z)cQ`!MNdR?ze>$sOiey+nw=l&||30Jr;)&?dXpnjysK8#QfCHp`gV^pX4x zqb7MFt74@Oc>QQJj&6$H>a7S}dP~bA&efxNeM!>TX$?8Y8xe_)k0I}A$vEDzu**fx zVwAo7VIwJbGLel60+vdjh~_l?=#E+CPD;k1c^?Swz{*WiL~kx!ZfobZ@K5WhDufKt zb0O{WRT&);Zwhrbg5Bjr4ywu`cM(&~#_7tAiF%#`&K1gqFvZ@L#6x~Vnak9>FG6_9 za=^|)2D(Z7*^fsUCJCHWqeFH(CwT9p3N%GwhWZ=naU-VTi zh42qK%tifGa#$3}#^L6XLXhy6Sf>eEJI^A79U5@B`S9QOXoHJf`}-vt{9%b2{#0EY zbW&+UoAS?!MEST{Yp3D}8k*5jsP{*uvci`pl>Bizdw^v}*bX~`{;4xM`-AgeP(lk# zG>DDZ8OxFgx^qL8dmjIsd{WT{>}44ijyHhEjcMay*p z+J7IKLTSEEeyLbI1T8XF2)&T|@#ix06opmI*L&N2?OnL!?9{$iI)TjW7grU@HlI)1 zzlTAt$dO3GigIbM^#AdG0 z-#4lf!nj}j5U$(pA$sUaVUZTJE84p_+>OvJ;<-+1@pqTszvdKplzL-wN^gEonxKs= zRA-$?UY0{e#Fz1O@jI5YQGpBKlWtR_$`j;t4aMIW%nnZD620XVJIn{2&S3SDC9yw&KB?tv^A^m}~Tgnmhkl z*hINpOqhbVN6fe13P#OJDKcMo+Ar1v=D|8tQF!0x3a&+8G$Ycp<(4Lwed4q>qAXI& zk|#+cThgqbB`{~dHb9&;Z=>rIMBZ*TlkzYMw~oRl$rh&GB3yeG5ZRA2nHySJ>M})S z9)4CcFF2)1V5JL`Eqfx|o^#F>25QZJP_NY3puiO?Fc!#sALO`vmtOU z-EPrF%WI=lea`}c?`}f>`eW}rmFu!H4dFitGRpkT?z{SqS|yC719>83Z&V9W{p6fW zeSrASnSi4{zG)(9CfJh9-skW)A`X8S2a+fn{PmShT>PJjpDB-)4YR2AfqR-&99@8Z zJT$)`QNtcf7PqtvUU6B{p^GpWR_mm$YnY^?BP{U)&vXJu;OMcze`ANL-`zcF_%Qt2 z%d}&m(Xqkk@+18NX&=MyZ)zhT5Pe|v7;?)t;T7*3P-ImnyMd=gdRRj7rJoR?oY!Q{ zYiLZ+UVW04fI6?appx@I@r}C#sE4wbuKx;ir}&o%e4XFX%+fMK3CA&s+`Du)aCE<9 zu~gL8W^Y@><=U^!s6zrvVc+?AqBSCl4BVPboEHKcR|&Pu>^QM4DKj6-vHqIsG8rLh zfgix|b{@Eb{n^+LI*+NU>Te91**bBg?sp3^VB!GN_ne%PZl4Or=)6Dg70Jjy-%!D< zSaN#Wb5~Q_LgU}kQy`?Spdj~7SNyUlItk|1tV%LyT4Q_AdIf&po0JyM?<#GjI>F8? zI;K+JCK-TdOrY?=A5#v#c$%w}juELL(^mZEtkvYpWvYhtC-u3K6|Q1wy~7P=K0*dT z`|Z+RF;)0&x;+|kXV6=~$v<`5PzXp0Z>yhK1S3w+d?oL&E7p$b=gL?y%3!K;sV7Ml zZYgXN>UAx>Lhn$SjA@6BS?aRmZ@)Qh9~o5SHg}b54Rd5^Q5{%FzhoP+toyJN^|yH| z$qjLWkw@yu&L9t6Ugqbqa|au?Xy1KrN}@D>e|Y&dF^lnFo=%g32;RcAQHfroBT+LI ztKENB)3`v}piT03jE%0|bsl@JJTB$Lkhe|ez_;xL{bumvo1_gzX!(s#k`n7wMEu;K zvp{#2OJkjsN_&GQ#q=0j2x{?!6y1nY*o;m$V9M=RcRuhoO9fBo-!S6()kJk z-<9TpW@qI~nn;RvXwfbKpEx?lD`0oi?9Xwga!xj}tuA+^TtnS7 zP&q;u^I!@tXHC#6`RXT1MSLDtXB)^@blhbuc&_6pY zZ?#&k_!o7PaC}P9>zWndv~wI}_O=fXNYn3B26I z#j3h%MQb#~(LeL|+Y+5#qku5q+zQygnaFElWB*cq)odYG;#XIgmb54BylAf`9;e~0 zF@LMI-aj=HLO)fK6wY91gzqJ-o=u;V!JXcWA@LdZJY8z!d0El>d2V4osSR3dJuY^x zRm-CEbGN-v$GVakGRjV()N2Y%Ls=h0gPMZ*<&p5=*rvDo=*OyH^niv^$cSCPonD5596Fq3c9Zgo-$L3_CX1l zP!p2Lm-v1g%V8`1G;R1WaQ658fDZ{l4X`w zAFhVDGdoa~Z5vc#9UU}*MK%hyi3G5h){|GIz4#;7Uu~Rz%HBESf^hbLyo1)I4&$QC z+4|Fz&6XRWjhKly1?=TsEOx5iLSIMAldqqX8*rMaC5OaO%tU zxQh_q7TDS(Y?SMzaz(0sDLa7w+jr_Wgt!(Lriz*EZz#n(=uzxGz1=Or60OhGO4FBK z{urnu#HxwoeOdGuD^d+sqmmM3x4(U|3q=^tUz(yf+aSdCfdwlLH?wT z#3`~~mx_`>d14=#sx*QAYV^$h3i6JE#4)SzTL}>U;RuGLTad@mm(p`1&oS5bT31Fs zHBRr3MCgPwk5kNvIqEZY3Vb_!Mf6*Et@cgD-68BSZ%c4kJ| zC-tGBm^6J$i%%7BtUmOvhNmH`8WRLZ`|k4<8iGNJ0eBj%UBWom&8M8SW*>py`_n+w zCQ?p1_DPyf3e;%=1f@D?g3#G~7fiP@^{X9sxpszlG~z*uRuuLzVC}Tr=zG?66F4 zj=_#Q)?O6y>cR`*hXBGd2mMCRp9t;5AvJfK(q?p72~+H0rX(#xQYLZO#39qKNNp6If0yWU^EdqRGe`8Tdn0w*x?zIZ$NsgBppLUxCbUx7FPAk8%Vv z21lcuOB;j@uRharJ!#Zf;4$*Qdf4nHUi~t@fX#l+Ted*^$!fa{O_>sW%~ox405I)Z z;?xYOpD0({$MFX`>%>YeHjYJfF`_uOI=`KyAY2>hlI&$Y?&T$ zc(t81sYB>T0n`aE&XSwQ6%3u~Z9-YwPWF~e--l|*2`;x>uBGo5iUqikn`wPXEwtw6 zH@(oFo{{poSqcI3c!Z8dH2U451cq1F>@!&}NtCpxgExA&v(){mP7oRNN|4q!N^zy9 zPm}?Sigau|yI2%>ch9xQxb$T5*(4VI2DAF-g#9=RWk%JNIR!mny(8#1zSR?|&Pr@ifbZLe)aAOMW*oXM!O`sh%?`Ui;9Bl^B&|WL1OL3$0U( zX-d7K;z^mN(M!0Cvtm|}R6U~fukocym5)vPNKyH3w|TWmL6K~}8byy`fwr5f8hO&P z#oAmv17F|bm~S+T*Yvsm`MoSO1|LBLO}~FB`l-Mrbg4`g zcW-Zu*trDHsvwcGR9zsuufza$;kA+FaDtZ6vyK_+cR_f~ED{pF{_6Ryw=055bq8!@ z*7oDAj1MIbDGVhROHO_{&dj6`G8?y*3VoBj^K4X(9vsh`OWDn()!x}lVVQxqrNb&b z%Ah^+-Ql!c`ppNQ#t!Ijbp^m5-jDikzq8))BJ}TD@1n-Hu&FoXI#KI7TgBy8W>LP`^ACvyLxw>dh7fj?ToY zs`NTasd8-|HT?FdjQJZY{YJeeM;5;47`$xEEh*p}FiWLaK)l#s|J>yMRY?|DC|yGKAU2~h?~5c z3rtFJq}uXc>F-tQSFxvT{K_@5_gzZ?@7wtg7tU{*&(D9;5^c07Az*7V6#Y3{&VFMm zDhCT+AHgU*i&E|QIO9$2?}rF~gz3g6lvc{F?YuI)@c>k9uC7K&j>6XV%`FtiQ&My@ zg>A;L`#{Ntc??xSL9%9UWBOC3qfNf8kBH@Fxs;wSIJRP5vZXF5scV4U|GVp&VeSHH zc7lL%^#1a=q#6g&ZS&CVTeMy;My8*SJEq%D(STm2P4I`Q#5I?DjAEYMtYEA48P7_U zHLy7p+(Yn=xY7?EO3$99>VNvv^dXhcR?K^siTFak?MREeg%j5k2426Ds}>&EdHpLR^QHw&20}cqOjyl(Q1E9Tyg;M(`sjrht+s8@16|B&DIg3Dr|lx5cfW2zysB?yfyJ1W9d3sF zyx_XVf5#N7dRVx;2hE+19OdwU!ECGy?Pn1)!|CklJQ1eaOU?*bgqelBT4$j)Q(1`a z!S>`QVL{E6WSSQFUo*S81GS4mAD5|fU+_UOWM7tdHXmk8dduH{9zMrZq(RNkJJ$HC~5cXr-#k1`taWvmR_3V z-|j}+@I=pq{xUAmhXh+@HQTuFBst78?+mBWSLi%z7M|CY?S7I$#QiEzRv`#g+?o&5 zEh^N_BZzm7bUTIDk!aDjQIFO*NLUfTHasSXlv02M`->i0zhU&JY))gUq7Wf+H+Il# zP9ANX4Yq3;Oksg`aaqI)mcrZ@9+EF&jrn*(hA-I<#^|1N9K{OnrLe0&Rz|-+h-aBV>a%>-Oq3tXeK^d{gji z05=x^STIw> zK(X;!ra2GEUvN?yr>kV=-d2jW%)#+W_E*2~!|W8_^Zue{^U}6IB{LNf^XOiiL&=hA zx8;S+v=DiA*NK>-_tim`5QXXstQG+YLN@i$>k%th9wRV2+^`K^03a)1rPLR=P*{=V zXk%*;??b-DvdGEDExT8;Sne9X z;mlmYnqf*E4?6z1AOp<6PtFw5`TG1u1VwX4u-)F8&cb)z*~xL&H_WtW+NM@f+^H=1gFsY})7t?;6O^CX4YFkb z*jPdToIF1A3(ZyP9NnTvbIix`nlCgqkEsVA%yMw0*~k@}M=3ETPA`!(ll|I1tJ!Kb z9W>Bo=^-Jkwb|VNc8%U@q}fmxv+YKe*2%z1WVMm*9rGtnLDN}mbR`013!sYvau1say< zHKDX(=+-z_ZT@jjyjJ{_$X*Z$92=z`u$u?U_8J*s6< zUpjxvFEqfbXFYCKA8B>pP!)s`P%Ug$9j2rzK!rQ95<#4YIVwCZBi&(()!S;iROM!W zFQrBBUg2WzMpK7&9kOQ{Ttll1-xys1N_@`G~QC$>zI40@OKGMe;y?j&G& zo_>hAh=VS2TycsdPf3+C{8R#b{vy?Hi*I8WMbi@R$0yrrX8|4ZEol=Rif)OVB za$X&)U5$h^#Am<5ebvypXS)}^Ott*k&q=tWKWZ7gC2v@VDYl9~%X3ErvdmSigcl?` zQ2h8YTMd!T_B{JNDp=pQSe2ST@7_DdzQzuQ3GCIrqQ7Vgj*!SZ*FB_I~fKixAwWyf+3b$WxB?F?sW1dCic~%O+|Nx zZaM7-=IdFZk~Qq3#gUWz?9|Q@;*lwME*Tba8u2Mr7%7IicdbX_{0DK*#&wk;hI6^@>rC@h5Vle=jjS z4($e2Ae)i=II59nV_Ts{k81mNu4f%mlHaxm6fn=EwK#rQt?s4QS}&z!KJl^}IMcW- z0#S~9?E-z(8Mx_X@{r#xo31Ktj=G@uQmwYU)Mz-&GoU*f-&X!=!{6{&P(HA}% zx?~kOnd3QE`ZN7l*M4GtpPMzbo-j zci{L?b%?gOM5t$@bA>A+b1O4pHIYTneS^a|!lmFUvatI)O!RDkS!*XjyF6mI`n2fz z_K^d&ea5vO^nveIwCGz{>u_kZ!^`fj#EhrYO+f8Ftnz=xV&uP-0?b>uCI zj;&qDIcJg0^Q&jXGaQ-dXqCAR;P3RoRtO(pMM!W>^EoDx>`GiKzx`zv_uU0}otlf! z*`3rmI27N0+j#anVFCz)vImkw((LTw(#*zhN|YD9tYa#TIc^?yjQY_StJfTW5hk%V zdcujPr~z+)cv`kp_`7CoT`)Se@PXmxW$gDCJJSjg>t8gyKQz>nxY;GC7p0Rka2@?f zNuaN2m2O7ltId14Jw5WL;Rek&*si+;lZ}j_`)K>n2wC&Yl2If~a27Ne#m%P`fXMd4 z|Ey?w!H1w%?}XjY--ot?!SHE8Xd8SXS_us|pU=0bcC&A+xAm0$%=gxIA|yLB{tYUE z+I#U#vE)NY?PgIfv+u}7Z%2ZWr~EvkeQG67nC_d^(sCv66)8G8{yjnlcG!xE^tTw* z72?h%C;EX6>m1t%#Ubq$lx(>o-#H8oy+f4RO5O#E?{tu-h=hGFf_r4eJLg|7%_K_f zjCSBPBYH#?T9&wUmluT0BbAK5=0AFI-4zA{S|9f&e@N<%KYh55GXI>8?k zfr`Cg1>7Xl3@uVDTaPdsp9R*Ti$=T@0P2m%cApy^K%{{%S9kVE(u71iir^35gse|4 zIyWKE0P43%)IS_)z}uZ2jkQ0FyULL7EaO7sMMD}}O%$k^HoNab00>{F4zLYJ8UAE@ ztR{B1nKn4B-lnbn3e5Ein8r8p_tn%#bF$UB5-ElmhST!ptUvpmd+fZWUqK_%2Z8!X zFx@}{dp~2(uBt>TB0_N7$h|a|ue!8rt5d!Ksy)MOtnIK+#pqAY?K)$~vKr7b-Ob51 zWSv*(B@C#32r?N0RQ%Ga3>*{rxAR+#B$+E1xHhWfQe$qmxF%t$;wp`Q&hHpvv1PlN z69l$LIPp9TqwAbS0dY*(w^cf9@Tz(yGZRLMYyzEqR{<0d_1 zQ)!@M+l3SBv4*E5H{r*URUNEP|5X2!iAy=B%R&&y@y?=rs)5g8rmo6fTfNVs`Kss_ zcTzE+ehqQ)G_y=gE!ec4rsO@GB}qqLgOtdRNZUxQd}vbCEA7HolG*g1I8*=++(G$@ z11nP6$%zJ{$S15S{TGRoywa$)%EmEpP9m76QDTGc{w9M5+kOodRHy?tpPoH!n{W1} z005JH1fT#Xi2=fY7}gnSp!krL`9ga4hM&}O^(Yk`I~2T$fn6})su(lVkFZ-N^<%DKojk;dq5I;=PNp`OR0?_jn;E};#H z8`YOwDcZ<0Rj*WeH6I&+cFEX|YV$G6BA|Str%2d#IgP2(J%qXOQHO&55?DDYl)xI% z#aY2(nBULlHfVZW0;y7{gSEi&OBd%of4^XQ3SgoGkemp)SfA$9dFO&?{v65C+hCEq z#V4hMI)$Q$PJPKl*zJYDV?rfs0A_4d&K}fe>4I%-6?pn+PefqDTv1?ql-r&z|^VB5qTh9+=tI27vK3Xyc6{pwjn9 zUy#_)egV-xgnrg=m+51qa9IvI-gJq_78ZcYHIL%6GVd=n2L-&%UyWp(mHo$LK!Wa( znFD&L^BvF`36e=bVNZa*cb7ue5Nt2L7K^9LWQ9mh%yX}Ka5nJU@`1#yfO)mIB*b^%}Ac-rQa_n9+ zfYiZXvOkIbPh7$z=cB;!*T@^x0aA+zur-0pJVM10bOYdYOg@U=Urh`G;WI3XlVFSO zze(uCrGr@EqkXR7`0o+18s~%maZ%_X>L}p`lmt+_O7COiTS?=T|lDR2t(*F@^S~YlSkmq9j6x-Jh1ju_V6wn}azr-mdK(pOcy})8_OgV0M&)?+yTVzt zMY#>f=eiDmZAYFgfDE}cVpvj`efJQcg3KX$=%?PP#{p!>`Va9-tp_$FU1;r1dtb;G z+!%7RSDGpOVnaHMUtS~11nPI{01gSCV~hL@fl|?H?8Aya-Um6U=O7D!VD^6m|%r~}M=?=3Qs?|jPN$+e)SuU-=u?DCY38*{Z zTnhrA@=YCo8Z8UXY4;KIEhMfmjC6o4^M>0awRDqBVcY7`&-MwBNjEhMl0+PyiR%Kx z=$Lu0O&x9ev7amzZhd%zCu}umQJpQ=q22Q34`~nVl=CcQN*SXMjc1BhF!Vvx{=DvK z-PMPr^V+Fr*r<&@S1B(2fAJ08hC$$%aKAh9P^p3>p%ClF(@iwne(iVD8Z zXV1SAEP+7S1x))P7ss^Bk0kKF$(FkUqvoam!J>YYfroGB@p9A9&DZx2pF|GH^j z`DMavlQ@a7Yf{*3?#r;Ik%4*AJOY{ykiZw-Y z_~U5q&TRD({GAEx(JpoyLcgI!+*;j8sF@ImR5*&9XC&(c9nF~!o6Pzs1E9X`d??aC zd@-uR$<+6rpa7%3o`&XI%cOS|BJMhh7+TpmBeEY}NC|!127d+|Du*{I+StaW|I<#R z^GuL9s7zVa>ix?(H>2Nv12534&#Q=l;UI^X(0-=}RSSY@`&QMez~?N&cJ2FICVF+U zPaY6S1dy=HQM4*6Vob;6jQsTa`!o9W;to+yS}Sl3EGPheGw;pY`!Ib0{XsdgcxGIU ziw&J0VmJMX8FX$B7)%4;zum6jjj%4c&!FioZ&bkmzqZXl0x*{b28DO2LTBfBoTPnY`5GC{nQxbrhi*0wMjfi+= zY_q~g$j&qMVcAa5?_zTpNS9W%TK7d(qnnU|J1oh>4LPdw%<(P6EVo#=xIQL?i20(q z^>y{*7!rCIfqzn>Z}uYRVpx-%H@)B8H0x_9BQ|QWrZrkrKYuc%F4lFj=m-;7@$MR^>(>F1bMWv()A#kjd9toE15o_GRHZS zsA#?mOG^x`7|**=mzDRnFWA#KEf732hdX^%qK(3pOKW;KAL#VkInEE8_CLP-x`>zU ze-?MSbUGSyTs8r{BUsdWBJSH2$w8;Rofe}`{jXySY zIulRDXW<8tGs3>bMj&)%8>LjQUENw!>b+N#v%zvrZj?99aF6%ssop~(a;@TS{fq`v z7oQX1hF(d&m(d7)52Bxsn@rZG!A5qYhnzR>8b8dt`5nZr{C>iU5x64kA3;^h>IaGL zIWZ{nuak{H@PQM+fop&G=L74VH`!Cl}%6MrinLhcP$L zpH&aUTk@8f6sP@ODU2Yl@7}(|d-S`;-DAsjd=XaJ?qVTVO&<|`#g@D?w{J#tI~dzf z_qlK$S=q^;ity{$FYbs%b-I}P*JrIYLSp!SF3(QZsNXDpnQN{LdwP%_@$@J=;&-&p zr&qMa-PQ&T-j2xcO+Q!vDh2tSvd`7P5zY+Oh>p>e>Zxs#LcLwpf%gTD0c-KorX|`? zlH)fxhZ$k!?CtvjAN#hHo}D!uMs=+a*&r5=Yb`^dg8vq(!*b-4qVmbhHbu?fs}YXgtVs zb6Su(+(W?@)o&NeLwcK|k%z6%E#YCbH@hf)%Z#Jl+1hY&hh^1WE-!|qN8j~@k>0|E zapMk-eh2oc)MW03^wFv%8Z4F~HGCl1II|$#j@37#36sE~jkz@B?r@cRG<1f-zGuzz zZb@OSvs|-1BUO-Hc<>OWyc}Zn=*hfZS`0%_F2nOm!QC^>!mg5t z2Y;Z~ehUMF1)E2=Nqs`eT5-MfmCJu}zU)7naSYQM&nR2Edg?nRPOKIgx=h%Hg~Pph z%)R0v*u7SC$`)bkab!QVR#L>*)5Yq+&mp-D2rE19|JxatIy+{sCqJNU1lQy-Mj3HE zZQKYPxXeuF?O*=g!bRTdZoa=f?S6tnO)!Dy1SAVslS6COZdREv!V%=&t5VpTT3>CsVuhAvMtTGrq69I-#NJ6 zu0EymzG_6}VHpkeKsd7)xtXt#&m1>3U3OR9mmIv z6`C^HF}#uj_h$4%g>%UDxM&z3$J4yI{Ld+%>;6??g_Vj$S^zP}pe`6HaKY zGoPMK__5KmyQ$G_^+#&XQiCq>(tq6HLK>k@robXNY4o4ey73R`IWeR43DL#e=(@}p zam2pwlQ$y<6AqIqeWEnL#9RU?XYIr~PJNKQ>BAJ4__}Pq6r90*$+x@fT*(fcVtpzUTPsbDK&lNxV z9I$zpgd(2|QED8{P%KHiho~7@;G~k{SM0|wz&1a=fB)v{?3YIuhiNSNd9iwCQWZYf zG_ic(e0N#kNCnn7JmZp=Nn*R=yL|PFVgt{6rQT26>MxbX)qARL-b)Y2Fv#)1%*EOa z@V%o@NyzpsR2`(0NEREV!-P)J#z9i&EhSMPW4q)NY`c;qdBdI(49!Uz8lT`-F`WDXYCuR5|9_k07z{FS^{F!ry(zB+X8lDs8q8-Kp!yNhw)w%%nom3 zZ?q*szs)x!s0x_Nl<5Rz=oMka0s7wJA9VnUGeUE~IeKWhcD zWC6YT?4SiV1L}B6LtPk$zD(%8!=+A9r2Ghy$hP68UNz47!fz1JD>JLzfc|RRwXsk< zk5G>Mvn6sT}g-gP@!!R5?9^dO<)*Rfb+l>ElXO}?ZnLTD5sv}&%DoOuC?vDXx-43cA@9BP}}%c<2bGZ=M`D zPN9n9fphKu^6|v>_kZ7}zmwQZG~NA3%+LU$mcMiFPqTi-L6(OsZIu zCkujWbh}AjK?Fz`1$0sO*uCYKU8vLfO1&W0j7P@_FEnOm^j{Z+jYDE6u!@_qdwb2D z?48NdcytoSrvhYy7vg_ZCE3?CKNF~1cMA2Miaw{E1UA4lp9H8A!;1+{+t{VIG36rY z=BXouggaA|N@W7&vo9Y5yJa<>Qoj1oqKz^5au791)gXNVeq{%q`?>xfI|V5+p)yjU zUagR1{KYN@NbueEDfo&2(YXdGk-2k)(0{-QvOoVD9CtfU{u@7jUEiU$TOEU4fw;+kmnr?9Q@30k}rzhu!CJ%#yP&U2h!8i zDd4mI;O%b%#$3&Q37wOUbIqpw#H%%aj=d!ge$}e0cH7LHxqRL- z3>i!+giNJ4p5swh7dE8hnwB-Hq}(0&1B}{WFu#&nmCg)KYfItVKH2*d&$#hw(~;Mp zrUzwxR1HJ<3vLNnqs9QI9E|seD{Khuar1Y~;2mF;!1UY2dRT7ksS(rf$fSRiSwxY+ zdT8*dYiC=|h@mceI6w56oIr7PTN+SjCnQ^)ReGuf!dNMGeSX8$ZOQ|!H$ow0;4gY; z(39&|Zr01PBzAM7DGoE};r^=F92diJIVOm;{eQ=GoJdOLwXi*VTd&8lDU4&gVxp_VmsW-X))5Hql$p@e7|6R1-(h%&x zfV)+E*SEep=b?GfS-Wq&B@s8U)7vY^M2$RW->cpS%0jt2i4W(j?^0kc8@C_`F7=_KPbi@y+b*0-mYp)|!t`K^0aF&pp`=Umt7+f!S9Zg97VprcT z`kB8{^EUO^&oL@l`a}2y^&e$>URRtQ2{#6DI*!nj4NDIhA&rIuDrTfaL@^d4^iQSZ zEVG|KeYN$it&u?>WO!%){@4QNK3mYfc0J4H`+Q~&Vta8ANQx3q zg%31SGVnDkW64Hh56{WunJHZ-=jopIjV)gva+z7!fEv#=pvv8y1cs$3Y(DD8ZG3{r;~kAYY*y=jq!WV**Z_pX2gt7 z4h5C&*WjKJqMS@Yt`*W}Rbp~zWp##B$ozC-e-_@Blk5YqLpqY=YzKdn>@l!SvXHyN zZXJ}Y%M7Xi*{FX(0N36>4=ulR@k Date: Mon, 5 Jun 2023 17:18:24 +0200 Subject: [PATCH 04/13] cleaning plot --- misc/notebooks/EnhancedSamplingExample.ipynb | 145 ++++++++++--------- 1 file changed, 77 insertions(+), 68 deletions(-) diff --git a/misc/notebooks/EnhancedSamplingExample.ipynb b/misc/notebooks/EnhancedSamplingExample.ipynb index a1409d8..4496916 100644 --- a/misc/notebooks/EnhancedSamplingExample.ipynb +++ b/misc/notebooks/EnhancedSamplingExample.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -206,7 +206,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -230,16 +230,16 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "# Define global variables\n", - "Layers = 4 #Layers of enhanced circuit; stay between 1 and 6\n", + "Layers = 3 #Layers of enhanced circuit; stay between 1 and 6\n", "fixed_x_angles = np.ones(2*Layers)*np.pi/2 # list of pi/2 ,to use CLF insteaf of ELF\n", "use_noise = False\n", - "num_preshots=4000 \n", - "num_postshot=2000\n", + "num_preshots=3000 \n", + "num_postshot=3000\n", "repetitions = 1 #repeat the entire test n-times, to increase statistic in results\n", "sample_every = 1000 # measure the energy every n-shots\n", "n_points = 10000 #to use for binning" @@ -259,24 +259,24 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " Random angles assigned to ansatz {ParameterVectorElement(θ[0]): 1.1680220570801747, ParameterVectorElement(θ[1]): 1.795686678025813, ParameterVectorElement(θ[2]): 1.2617255125328317, ParameterVectorElement(θ[3]): 2.2468982716755828, ParameterVectorElement(θ[4]): 5.363571190329344, ParameterVectorElement(θ[5]): 3.379151087751608, ParameterVectorElement(θ[6]): 6.178754944553304, ParameterVectorElement(θ[7]): 1.5628349995081818, ParameterVectorElement(θ[8]): 1.518474424412041, ParameterVectorElement(θ[9]): 0.49962993523475535, ParameterVectorElement(θ[10]): 2.1640358950166863, ParameterVectorElement(θ[11]): 2.451273703185537}\n" + " Random angles assigned to ansatz {ParameterVectorElement(θ[0]): 5.217821253966976, ParameterVectorElement(θ[1]): 0.693399108952002, ParameterVectorElement(θ[2]): 6.018201104967258, ParameterVectorElement(θ[3]): 2.4093745671219824, ParameterVectorElement(θ[4]): 0.4734899931825716, ParameterVectorElement(θ[5]): 2.4153531856488564, ParameterVectorElement(θ[6]): 3.112057761700599, ParameterVectorElement(θ[7]): 3.2787477451175286, ParameterVectorElement(θ[8]): 6.011213436552083, ParameterVectorElement(θ[9]): 1.2623651513831313, ParameterVectorElement(θ[10]): 4.6847509118203225, ParameterVectorElement(θ[11]): 5.7273834967682875}\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAp4AAACoCAYAAABJyu4KAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABQQElEQVR4nO3dd1RU1xbA4d/MMPQuWFAxoIK99xJrbDGxvKixxhJ7ibGXaDRGTSxRk9h77LEbW+zYC3ZsoGAXLIACUgfeHyOjwIBGh6G4v7Vc7+XcM/eeOeeyz55bFQkJCQkIIYQQQgiRzpQZ3QAhhBBCCPFxkMRTCCGEEEIYhSSeQgghhBDCKCTxFEIIIYQQRiGJpxBCCCGEMApJPIUQQgghhFFI4imEEEIIIYxCEk8hhBBCCGEUkngKIYQQQgijkMRTCCGEEEIYhSSeQgghhBDCKCTxFEIIIYQQRiGJpxBCCCGEMApJPIUQQgghhFFI4imEEEIIIYxCEk8hhBBCCGEUkngKIYQQQgijkMRTCCGEEEIYhSSeQgghhBDCKCTxFEIIIYQQRiGJpxBCCCGEMApJPIUQQgghhFFI4imEEEIIIYxCEk8hhBBCCGEUkngKIYQQQgijkMRTCCGEEEIYhUlGNyCzuXEAwh5ndCuyD5uc4FlX/zLpa8NKq6+F8ch+bVjG3K9l7NKfxCkhiWcyYY8h9H5Gt+LjIH0tsiPZr7MuGTsh0p+cahdCCCGEEEYhiacQQgghhDAKSTyFEEIIIYRRSOIphBBCCCGMQm4uyuQGz63NtTsnUKnUKJUqcju40a7eaGqVbpXRTct2pK9FdiT7dfYg4yiyC0k8s4D29cfQvv4PaDRxbD3+J5NXt6NQ3rLkdSqU0U3LdqSvRXYk+3X2IOMosgM51Z6FqFQmNK7cHU18HLceXsjo5mRr0tciO5L9OnuQcRRZmSSeWUhsXAzbj88FIJ+TRwa3JnuTvhbZkezX2YOMo8jK5FR7FrB6/0TWe00jMjoMlUrNoFaLcHcpBcCkVe2oW7YdVYo1BeDHZc35omofKng2yMgmZ1lp9fWu04vZd3aFru6jYH9KutVkZLtVGdVco4rVwMW78CgUVEookgfcnEGhyOiWpe1BCFy+BzFx4GQD5T4Bc3VGt8q4JIZkDxKfRHaQqY94xsfHM23aNAoXLoy5uTmlS5fGy8sLT09PevTokdHNM5p29UazZUIoG8Y9pVKRJly8eVC3rHezmSz7dwyR0eEcubwJK3M7mTA+QFp93bhSN6b3PsT03ocY3X4t5qZWdGk0MQNbazwX7sDYjbDyOOy/Cnt84Pe9MG0XPA3L6NbpFx4Fs/fB1J2w+zIcuAZ/n4YxG8Hreka3zrgkhmQPEp9EdpCpE89u3boxYcIEevbsya5du2jdujVt27bF39+f8uXLZ3TzjM7G0oFBrRZx6voOjvtsBcDBOictanzH7K0DWL3/Z3p9OSODW5k96OvrRPHx8Uxe055ujSeT2/GTjGmgEV25D8uOQmRsymUPQ+GPvRAWZfRmpSkmDuYegJtBKZfFamDzWTjqa/x2ZTSJIdmDxCeRlWXaxHPNmjUsW7aMbdu2MWTIEOrUqcPo0aOpWrUqcXFxlCtXLqObmCFsLR35X81BLNk9ivj4eAAaVuzM/Se+NK8+AFtLxwxuYfahr68BVuwdj1vuklQv0TzjGmckCQmw9TykdjY9IQGeR2a+JO78He0p9oQ06uy4oE1QPzYSQ7IHiU8iq8q0ieekSZNo1KgRtWrVSlJeqFAh1Go1pUppr2u5ffs2tWrVwsPDg5IlS3LkyJGMaK5Rtaj5HcEvHrH37F+6MpccheSRGukgeV+f89vPWd89dP98Sga3zDjuPIPHL9JO4ACO+xmlOe/sxM3Uk+VEkbHgc98ozcl0JIZkDx97fBJZkyIhIeFtc4rR3b9/n/z587N48WK6du2aZFnbtm25fv0658+fB6Bhw4Y0a9aMPn36cPz4cVq1akVAQACmpqZpbkORyh0R03odpHTB2gb5HsY0ZW1nmlT+lhJuNTK6KUlcvHWIIfPq6F2W1fo6+EUgQ+bXYVK3XZnyFFZaff2+ClX8H59/t+Gd6s7qqNQeAs0Euv1+D2vHfG+td2TNUM7tmGbQbWe1/TpRVowhhpZVxw4yf3xKZMzxFMb1rulkpryr/f597WGI3LlzJymPjIzEy8uLxo0bA/D06VOOHj3Ktm3bAKhWrRouLi4cPHiQhg0bGrfRIttbuW8CEVHPmbqus64sv7MnA7+an3GNSmcxkc/fqV5sdESmSToBol+GYmXvgkKZ9kmdmJfv9v2EyOw+xvgksqZMecTz5s2bFC5cmBkzZjBw4EBd+fjx4xk3bhyzZ8+mT58+nDt3jq+++gp/f39dndatW1O/fv33vuvdey2EfqSn39KDfT6o8LX+ZdLXhpVWX7+vOA38uBkiolOvowAqF4Svqxh22x9iz2XYeSntOkoFjG8JNuaG3bbs14aVHvt1amTs0p8xx1NkTpnyiKe7uzulSpVi0qRJODo6kjdvXjZs2MDOnTsBPso72oXICCYqqFMUtl/Qv1wBKJVQq4gxW/V2VQvBwWsQFZv69alVChk+6RRCCJG2THlzkVKpZP369RQvXpzevXvTpUsXnJyc6Nu3LyqVSndjkaurK0FBQURHvz4cExAQQIECBTKq6UJkO3WLQY1XL0dJfmW0Sglda0Iee2O3Km02FtCrLpgnu9Q78dLuEvmgpfx+FUIIo8uURzwBPDw8OHjwYJKyjh07UqxYMSwsLABwcnKievXqLF68WHdz0YMHD6hTRy5cFsJQlAr4qiJUctc+Nun0qytbmpTSHjW0tcjY9qWmgBOMaQZn/LXP7QQo46o9Glo4V+Z/45IQQmRHmTbx1Mfb25sqVZJeSDZv3jw6d+7MzJkzMTU1Zc2aNW+9o/2/evr8IWOWNuVO0FX++Tkclep1t63aP5Ftx2fTqGJXujT6GYAXL4OZtbEXLyKeUqZwPdrXG43XxfWs95qKAgVt646iWolmBAT6MGtjLxISEviu5VzcXUoxc0NPAgJ9UCgUDGgxB3eXUqzYM54zN3YD0LnRz5QrXI+XUWFMXt2OFy+DaVqlJ59V6MS/Z5ax9uBkHG3yUCR/Jbo3ncK/Z5axx3sZAP6PLjK150EK5S3D3G3f43vfm0J5y9G32SyiYl4yYUUromIisDK344eOf2NqYpainr6+OHN9N2sP/gLA/Sc3GNBy7ns9Q+7a3VPM2/Y9CoUSz/wV6f3Gg6z19UGisUub4ZanJF0a/Ux8fDwLdwzj1sMLWFs6MLbjeu4EXeW39d0BKFuoLp0bTeBxyF2mruuMJj6OZtX7Uat0a4JfBDJx1dckkIBLjoIMab2EE1f/YfX+iShQULPUV7SqNVjv961c9HMGzfmUgMDLzPv+gu6xNGd997L2wGTiE+Lp+cV0lAoVc7cNBOBxyB1a1PyOljUH0mWKJ442eQAY0HIOBXIVY/Dc2iSQgAIFHT4bS9lCdfXuR8bimgPaVX2deDYoabRNvzdLU+1lAImJ5zcZdMP2Xu+/2HN2OfHxGka2W4WTXV5Af/yYuPJrgsMCiY2LJjo2kvmDLnDxlheLdgwDhYIGFTrzRdVezNk6kFsPLwDav+3NP4XojQGJZm/9jrCIZ4xot5KIyOdMXtOeyOhwqpdoTsuaA3X1Nh6ewZHLG5nZ96jessDg2/T/ozKuOYtiojLl1x57AGg2xo5CLmUB+PGbTdhaOjJozqegUKBSmjCq/RocrHPqLdt/bhXbjs/GxtKRke1WY2Vum57D8Z8kj4Fvio6NpOMkN0a0XUk5j/qc9d3Lsn/HYKa2YEDLubjmLMLNBxf4Y3NflEolXRtNoqR7Tb1xasfJBew+swSAFjUGULdsO73jpNHE8cuaDoSEB+GZryLdm07hecRTxi79EpVKrY3fHdZhprZIMSYmSjU/Lm+ORhOLpbkto9qtwdLchgkrWhMSHkR8vIbBrRaTP6cnAM9ePKLTZHcWDL5MXqdCDJ5bG4CIqOfkcijA+M5bmLK2M/ceX8NUbcHnVXpQt2w7/tozjmM+m7G2cKBqsS/5qtYg4w2YyPSyTOIZHh6Or68vffr0SVLu7u7O4cOH03XbtpaOTOmxn3HLW6RY1qTStxQvUI3zN/frylbsHc83DX/CNefrC982HZnBtF6HUCgUjFzUiGolmrF89xhGtV+DUqHk9019+KnLVtrUHUEeRzfuP/Fj8c4R/PjNRupX6ETHBj8SHhnK2KVfUq5wPXaeWkjtMl9Tu8zXDJ1Xh9pltFdrt6o1lCaVv9Vtt2HFzjSs2BmNJo4+sypQ0KU0fvfPERkdzow+R5i1sTc37p3hceg9irhWpuNnY1m1fyLe13fjbJ8/RT233CVT9EXFIo2oWKQRAP1/r0y5wvXfq59z2Rdgas8DmKrNmby6PQGPLuOWR5vd6OsDAP+Hl4iOjdSt48jlDbjmKkrPL14/Imf7iXl0azKZUu6fMnzBZ4RHhrL24K90aTQRT9dKjFrUmBolWnLg/GoaVezKZxU68dv67tx6eJGCeUozs+8xlAolg+fVpkmlb/V+X5XShPGdt7Bwx3DddqNjI9lxcj6/9NiLSqnSlU/vfQjQJsyVi2rfj21n5awrf9PUHvuT/NDRtx+JzO3p8wdc8vdias/9KZbpix+jO6wF4Ojlzfg90GbMGw5PZ0zH9TjZ5eO7P6vyRdVe9Gk2E4CbD86zwWu67vPJYwBASFgQgcEBWJlpE7odpxZQt2x76pZty/jl/6NeuQ7YWTkRExetS2YT6SsrX/gzRrRbmaTMLXfJFPvwlJ77MVGp2eO9nL3ey2lde2iKspY1B7L95Dx+632YI5c3suPkfFrXHpp2pxqJvljpmb+ibvmuU4t0MQpg5b6fmNJzPy+jXjB320B+6LCO5XvG8kOHddhYOjJ+eUsmu+/WG6fKezTg8yo9iNPEMuCPKtQt207vOF24eRB3l9K0rTuSP7f059bDi3ySuwQz+hxFqVSyYs94Tl7dTq3SrVKMSUxsFCPariSHbR52nlrIHu9lNK/Rn5HtVmGiUnPxlhebj/7OgJazAdh0ZCZFXCvrPp+4ro2HZ2BhZqMrH9FuVYpnwPZsOp1yHu83F4jsLVNe46mPtbU1Go2G/v37G33bpmpzbCwd9C5zsMmV4pmgtwN9WLN/EkPm1eHq7RMA5MlRkKiYCCKjw3XBPywyhJz2+XGyy0t4VKi2nqMbACYqNcpXyUpimdrETHd+8Nrdk5Tz+AyVUoW7S2nuPda+fHrzkZkMmvMp5/ySTnKXAg5Tyv1TFAoF1+6epLzHZwCUK1yfq3dO4PKqfQARkaHYWuXQWy+tvnj0zB97m1xYmFm/S7em4GibG1O19m4PlfL190+tDwA2H/udL6u9/jFy8up27gReYfDc2uw8tRCAfM6eREQ9RxOv0a0jMNgfN5dSqJQqHGxycf+pH/mcPYiI0j5eJzI6DGsLe3I6uKJSqlC8OkKjULz+k3nz+yoUChxsciX5PlfvnEChUDJqUWN+WdORyFf9CxAZE0FIWKAuWIe9DGbQnE+ZuaEnMbHa908qFUqGLajPxJVf8+JlsLYf9OxHInPzvvEvmngNQ+fX488t/XX7IeiPH4mO+WymRomWgPaxOBFRz4nVRGNuapWk3lGfzVQv2VL33/piwKYjM2le/XXsfPTMH/c82mvlC+Qqxo17ZwDYfXoxn1X4Jsn69ZVduHWQ7+fUZOPh12cl7j6+xvdzarJo5wjd8/xMVGpA+yOsQK7iessePPXDLXdJVCoTXZzJLPTFwESxcTFcu3uS4p9UT/IZC1Mrctjm4eGzWwCER4bgbJ8Pc1NLomIjiI6N1BunEp+9qVKaoFJqf2zqG6dHwa/LCrqU4ert46iUKpSvHh2mSdCQ16kwkHJMTNXm5LDN82o7r2Ns4phExYTr1v084ikvo16Qy+GTFP1y4uo2qhXX/uhVKBRMWduJMUu+ICjkjq7Oop3DGTa/PjcfXPhPfS6yvyyTeGYlV28f5+u6Ixndfi0Ldmh/uVcv0YLeM8vSa0YZmr2aABISXr/mLPkzEBfvGkmLGgOSlP21ZxxNq/QEIDwyVJd4WJnbER4VSvUSzZk/6BJjO21kwfYhSSa4o5c3Ub1EC91nLd/8bGQoeZ0Kc+3OCb6dVhzf+94UK1BNb720vLmND+H/8BLPI55QIFexFMve7IO7j69jb+WMtYW9bnlIeBD5cxZhSo997D+3ipCwIMp7fMacLQPoOsWTogWqYqa2IJ+zJ5dueREV85Jrd08SERmKp2sldpxaQNep2lOIuRxe36R2+vouXHIUxNL89a/8t33fkLAggsMeMenbXRQvUI0dJ14/T+/M9V1U8Gyk++8ZfY/yW5/D5HQowI5TCwAY02kD03sfomrxL1m9T3saVt9+JDK3kPAg4jQxTO25HzO1JcevbH3rZ+I0sQQEXqZwPu2rgauXaMGoxY3pOqUI9cp1SFLX+8ZuKr7al/TFgBcvgwmNeKJLRgDy5/Tkkr8XmngNlwIOEx4ZSpwmlou3DlG2UN0k7Uhe5mibh6XDfZnW8yDn/Pbh/1D73Kplw/34rfdhwl+GcOLqPwA8DrnLgD+qsu3Yn7ojg8nLwiNDsTR/HWci3hJnjCmtGLjHe1mKsQDt3/3dx9e5F3QN0J7NCAj0ITT8CbcDfQiPDNUbpxJtPzGPqq+SOn3jlP9V7AK4ePOg7qDF9bun6TOrAhduHtD9UNc3JgCR0eHsODmfumXbAdokeuDsGvy5pT9FC2gvZ9t0ZCbNqvdL+f3CH6NAgb21MwA9v5jOrH7HaVNnOPP/GQxA8xoDmDPwLANazmX2VolTIilJPNNBPmcPCuQqioNNLpSvjpCt3PsTi4ZcZfHQa6zc95O24htHOt48krbpyEwK5CyW5A0iRy9v5sXLZ7pAYWVhR0T0CwBeRr3A2tweawt7lEol9tbO5HP20AWzhIQEfAKOUtL9U+1nze14+eqzEdEvsLawZ6/3cqoU+4JFQ65Qucjn7D+3Um+9tJy49g/Vin35vt0GaK+P/XNLPwa3WpxiWfI+2Hj4N1rU+C5JHStzO0q510KlMqFYgao8eHqTZf+O4YeOf7N0mC+3H10mMPg2beuOZOepBUxY0QpX5yI42ORig9d0OtQfy5Kh17CysOOSv/YSjkfP/Pn70BR6vXHN6bt8XytzO0p8UgOVUkWZQnW5+/iabtkxn83UeOMoVeL7sauXaMHtQJ8UZQGvyvTuRyJTS9wngRT7QWou3jqU5A06i3eOYFa/Eywb7sees8uJinkJwP0nfjjZ5sXc1BJAbwzYfGQWzar1TbL+xpW7c/X2cUYtakwOWxccbHKx7+wK3d9WIn1lpiZmWJhaoVKZUKVoU24Hvd5fFQoF1Uo01+3DOR1c+b3/CTo1GM96r2l6y6zM7XgZ9TrOWL0lzhhTajFQo4nD+8a/VCrSOEn97k2mMHHV16w98AvFXh0J/bbJL8zbNohZG3vhlqcUdlZOeuMUaK9zP319J23qaC/Z0TdOVYp9QXRcJEPn10NtYoaDtfZMSxHXSsz5zpvqJVrorhXVNyYJCQlM+7srXRpP1H0ftYkpM/seZUzH9Sz/dyzhkaE8Cb3HJ7mLp+iTE1e26hLjxG0AlHCrQXBYYJKyfM6FU3xeCEk800FeZw+evXhEZEwEmvg4QBuszdWWmJtaEaeJAcDWwpEnofd5+vyh7he/9409XLl9nPb1f9Ctz//hJbYdn03/FrN1ZcVcq3Lebz+aeA23Hl4gf84iRLwK3tGxkTx46qf7RXrj3hkK5yunu86wWAHtZwHO++2jqGsVEkjA5lWwsLVyIiLqud56qQl+EYhaZYqtVY737rfEi+Z7NJ2Go23St1bp64OgkDtMXdeZhTuGcfD8Gi7e8qL4J9Xwf6Q9AhMQeJlcDgVISEjAxsIRpVKJpbkdkdFhONjkYnznLYzttAG1iRm5Hd0g4Y0+sMxBRNRzXkaFMXVdZwa3WozFG6c43+X7euavqEsybj28oN0G2qNIdx9fo6BLaUB7tCEmTvtIsCu3j5EnR0EA3XheCTiGy6syffuRyNyKFXi9T956eEF3NCotx3w2JzmarlSqsDa3R21iilKhRKOJ1VtPXwwIDA5g8c6RTFn3DedvHcDr4t9YmFoxot1KJn27i4SEeIoVqMq9Jzf458RcRi5sxJ2gK2w5+ofespdRYbrtJe6v2lin0ZW55ChInCZWd8rd0twWM7WF3rJ8zh7cDvRBE695a5wxttRiYEh4EI9D7zJyYSP2n1vJ4l0jCXsZQrFPqjKt10Ha1RuNa66igPZAxK899jDwq/nktHfFRKXWG6eePn/A/H8GM/Tr5bpYrW+cVEoV/Zr/wdSe+1EqVVTwbEhs3OtYYGVui6naQu+YACz/dyzFP6muO4qdkJBA3Kv9ydJMOyb3ntzg/hNfRi5sxDm/vcza2Eu3/mM+W6ihZ5+79/iGLpFNLHse8RSNJs5QwyGyiSxzc1FGitPEMmpRY/wfXWTEooZ0qD8Wn9tHaV9vNLtOL+af43MIexlM2MsQBrSczTcNxjNpVVtiYiPp8NmPADSt2puBs7W/gJtU1r5VqVOD8fy8sg2ALqGavbU/lma2DJlXR/e6swU7hhISHsTIhQ2xMrfjpy5baVz5WyavbsfWY3/QpHIP1CamrD0wmTM3dpOQEM/XdUbortt581oxgML5yqFWm/P9nJoUdClDEddK5HP24OeVbdh3dgUmKjWjO6zD1tIxRb3kfdG18SSKulbmeLJfwe/D69J6fO+dYeGOYQB0azyZAxdW06/5H3r74Jfu/wLao0Pn/PZRumAtCuctx5R137DpyEwqeDbE2T4fbeoM59e1HVEqVbjmLIpbnpKcuraD9V7TUCpUfPv5rygUCr6o1ocp675h5b6fsLXMQdu6o9hweDqBwQFM+7srAEPaLCWPo5ve7zthRWt8bh/lwVM/2tQeRrUSzSjlXotBcz7FTG3JyParATh/8wBlCr4+dRkeGcKoxY2xMLXG2sKBEW21N20MnV8XM7UFpibmDG2zLNX9SGRuhfKWwUxtweC5tbGzcqJumbas2j8x1fiRkJDA1Tsn6Nf8T9062tQezvAF9VEolFQs0hgrCzsATl3bzvjOr0/dbzo8I0UMGN72LwACg2+zbPcP1CrdGt/7Z1mwfQgKFLSuPQwztQXdP/9Vt56Bs2vQvEbSU6SJZaeu7WT5v2NQm5hRwq0mRV0rc/PBBaav74qFqTW5Hd3o1GA8z54/4Je1HVEqlKhVZgxts4zgF49SlJmo1DSu3J1Bc2pibeHAqHar03M4/pPksTKnvatu7GZ/p70u9q894yjxSQ1sLB1YtX8i5/32YWuZg4H/015as+v0YvafW4mp2kIX5xtV7JYiTs3c0JOQ8CDGL9fG6knf7uJO0NUU4/T0+QMmr26PUqGkfvlOONnl5frd0yzYMRSlQomNhSPD267g/hPfFGPy9PlD1h36lWIFqnHMZzO1S7ehYcUujFzUCIVCgQIF/VrMpkCuovzeX3s965S1nXUHQiKiXhAeGUpOB1ddH/2yuj1hkSHaJ7G0nAvAwu1DCQj0ISEhnm5NfjHOYIksI1O+MjMjySvTDEtemWk8xnoV3cBV2v+d2T79t2Uoxmyz7NeGJa/MzF7klZlCTrULIYQQQgijkFPtydjkzOgWZC9p9af0tWFJf2YOMg6GZcz+lLFLf9LHQhLPZDzrvr2OMAzpa5EdyX6ddcnYCZH+5FS7EEIIIYQwCkk8hRBCCCGEUUjiKYQQQgghjEISTyGEEEIIYRSSeAohhBBCCKOQxFMIIYQQQhiFJJ5CCCGEEMIoJPEUQgghhBBGIYmnEEIIIYQwCkk8hRBCCCGEUUjiKYQQQgghjEISTyGEEEIIYRSSeAohhBBCCKMwyegGZDY3DkDY44xuRfZhkxM86+pfJn1tWGn1tRDiv5H4ZFgZEZ9kDA3LUGMoiWcyYY8h9H5Gt+LjIH0thMisJD5lfTKGmZOcahdCCCGEEEYhiacQQgghhDAKSTyFEO9EEw8PQ17/97NwSEjIuPYIIYTIeuQaTyFEqmI1cP4OnLwJd59BXPzrZRO2gpUZeOaGGh7g5gwKRca1VQghROYniWcmN3huba7dOYFKpUapVJHbwY129UZTq3SrjG5atiN9ndTVB7DuFDyPTL1ORDScu6P955Ebvq4MjtbGa6MQHwuJT1mfjKGWnGrPAtrXH8M/E8PZNO4ZDSt2ZvLqdjx4ejOjm5UtSV9DfAJs8oYFh9JOOpPzDYRfd8AVuYtUiHQh8SnrkzGUxDNLUalMaFy5O5r4OG49vJDRzcnWPta+TkiADafh8I33+3x0HCw+DFceGLZdQojXPtb4lJ18zGMoiWcWEhsXw/bjcwHI5+SRwa3J3j7Wvj4TAMff8uN7Znvtv9TEJ8CKYxD60rBtE0JofazxKTv5mMdQrvHMAlbvn8h6r2lERoehUqkZ1GoR7i6lAJi0qh11y7ajSrGmAPy4rDlfVO1DBc8GGdnkLCutvt51ejH7zq7Q1X0U7E9Jt5qMbLcqo5prUC8iYbO3YdYVFQt/n4IedQyzPmFYMXEQHQvmpqBWZXRrxLuSuSDr+5jnmESZ+ohnfHw806ZNo3Dhwpibm1O6dGm8vLzw9PSkR48eGd08o2lXbzRbJoSyYdxTKhVpwsWbB3XLejebybJ/xxAZHc6Ry5uwMreTQPMB0urrxpW6Mb33Iab3PsTo9msxN7WiS6OJGdhawzrmB5Gxhlvf1YfwIOTt9YTx3AuG5UdhxN8wZpP2f1cdh8DnGd0y8S5kLsj6PuY5JlGmTjy7devGhAkT6NmzJ7t27aJ169a0bdsWf39/ypcvn9HNMzobSwcGtVrEqes7OO6zFQAH65y0qPEds7cOYPX+n+n15YwMbmX2oK+vE8XHxzN5TXu6NZ5MbsdPMqaBBqaJhxN+hl/vsXRYp3g/Vx/AzH/hwh3t5RCgHXfvAJi+C27JO62zDJkLsr6PbY55U6ZNPNesWcOyZcvYtm0bQ4YMoU6dOowePZqqVasSFxdHuXLlMrqJGcLW0pH/1RzEkt2jiI/XPlSxYcXO3H/iS/PqA7C1dMzgFmYf+voaYMXe8bjlLkn1Es0zrnEGFvQcXkQZfr1+gYZfp/jvXsbAsiMQHw/Jn/mfAMRpYMlh7XNbRdYgc0HW9zHNMW/KtInnpEmTaNSoEbVq1UpSXqhQIdRqNaVKaa+JGDt2LB4eHiiVSjZs2JARTTW6FjW/I/jFI/ae/UtX5pKjEHmdCmVgq7Kn5H19zm8/Z3330P3zKRncMsO6F5w+630SBpEx6bNu8e7O+EOMJmXSmSgB7TNZL941ZqvEh5K5IOv7WOaYN2XKm4vu37+Pj48P33//fYpld+/epXjx4piZmQHQqFEjOnfuTNeuXf/TNhSpvGJlWq+DlC5Y+z+3Ob1M730oRZmVuS2bfkqnTMHAvLwOUbGt/jtMslpfB78I5M8t/ZjUbRdqE1Mjt+7t0urrt6nU/AeqfjUhSVlad66ntXxgsuvg87oVJeTh9fdql6F8t1KbcqX2d5/dfT5wE+5lv0CpSj3kx2viGDFpGfsXdTdiyzKvrBafMrsPiU/vK6uNYVafYxLe8R3KmTbxBMidO3eS8sjISLy8vGjcuLGurFq1akZtm/h4rdw3gYio50xd11lXlt/Zk4Ffzc+4RhlM+iVkinRct3g3SqXqnd5nqlTKLe5CZJTsPce8pkh41xTViG7evEnhwoWZMWMGAwcO1JWPHz+ecePGMXv2bPr06ZPkM7Vr16Zfv3589dVXH7Rt77UQKm9eMRj7fFDha/3LpK8NK62+fptjvrD+zLvVTTzSmfzIZmp+/h9Ym79fuwwlsa1vO4qbXe2+DLsvvb3e/ypATc/0b09WIPHJsD4kPr0vGUPDMtQYZsojnu7u7pQqVYpJkybh6OhI3rx52bBhAzt37gT4KO9oFyI95Uun+xDsLTM+6RRQtSDsufz6bnZ91Cqo4Ga8NgkhPk6Z8uYipVLJ+vXrKV68OL1796ZLly44OTnRt29fVCqV7sYiIYRhuDiAudrw6y2Y0/DrFP+dnSW0rKD9/8lPuCte/fu6ClhkvsvKhBDZTKY84gng4eHBwYMHk5R17NiRYsWKYWFhkUGtEiJ7Uqugojscec93tKemqtxcm2nU8AAbc+1p90ehr8vzO0Lj0lDUJcOaJoT4iGTaxFMfb29vqlSpkqRszJgxLF26lCdPnnD58mUGDhyIl5cXBQsWNMg2nz5/yJilTbkTdJV/fg5H9cZdoRNXfk1wWCCxcdFEx0Yyf9AFbj64wB+b+6JUKunaaBIl3Wvy75llrD04GUebPBTJX4nuTbWPSVh78FfO+e5FEx/H1J4HCA1/zMRVX5NAAi45CjKk9RK99ZRKZYqyvWf/Yo/3MgD8H11kas+D5HP2YMKKVkTFRGBlbscPHf/G1MSMudu+x/e+N4XylqNvs1lcu3uKedu+R6FQ4pm/Ir1fPXi42Rg7CrmUBeDHbzZha+nIwu3D8Ll9DKVSyeBWS8jnXJixS5txyd+LsR03UM6j/nv3dWDwbfr/URnXnEUxUZnya489umVrD/zC6Ru7iI55Sdu6o6hRsgUxsVH8sbkvgcEBFMhdnH7N/9Bb76894zjmsxlrCweqFvuSr2oNYu2BXzhzYzcAvvfOsOqHezwOucOvazsRGR3GylG3Abj54HyKsojI50xe057I6HCql2hOy5oDAVL0a0CgDzM39ECpVOGSoxBDWi/h+r3Tevv6zy39CXh0mTw53Pn+q4WolCoGzfkUFApUShNGtV+Dg7X28KHf/XP0mVWe3b/EJtkfP9SnHnDcT/tQcUPI7yhHPDOb0q5QKj98v1r73yO/gFy2GdumrCKtuWDK2s7ce3wNU7UFn1fpQd2y7fTGpxV7xuviTudGP1OucD3uBF3lt/XaJwmULVSXzo0msMd7ObtPLyY6NpKGFbvwZbXX9zSMXdoMtzwl6dLoZx6H3GXqus5o4uNoVr0ftUq31hufNJo4flnTgZDwIDzzVdTNQfpi/P5zq9h2fDY2lo6MbLcaK3Pbd477+uplJqnNdQC7Ty9h1b4JFP+kOiParQTQO4agvXu714yyNKvejyaVv+Xp84f8uqYDMXFRfNPgJ8p51H/nuUjf+Osb14u3DjFl7TfkdnQjp70rw9tqH7+UfN5JbT/d6/0Xe84uJz5ew8h2q3Cyy5uizME6l979xNCyTOIZHh6Or69vipuKJkyYwIQJE1L51IeztXRkSo/9jFveIsWy0R3WAnD08mb8HpwFYPmesfzQYR02lo6MX96Sye7aINOq1lCaVP5W99nrd08TFR3OlJ77dGUHzq+mUcWufFahE7+t786thxeJjYtOUU/fZxtW7EzDip3RaOLoM6sCBV1Kc9RnM0VcK9Pxs7Gs2j8R7+u7cbbPT2R0ODP6HGHWxt7cuHeGXPYFmNrzAKZqcyavbk/Ao8u45SmJW+6SSR7/8OJlML73vZnV7xg+Acf458Qcen85g+/+N48dJw1z1135wp/p/ujf9FWtwXxddwSR0eEMW1CfGiVbsPno79Qp245yheulWQ+gZ9PpSZLir+uO4Ou6I3ge8ZSf/voKW0tHTJRqfu9/kpELG+rqueQolKJsx6kF1C3bnrpl2zJ++f+oV64Dj0PupujXgi5lmNXvOABT13XB97633r6OiYsiLi6G6b0Psd5rOqeubqdaiWZM6bkfE5WaPd7L2eu9nNa1hwKw7cQcCuc1/AsUnG2hUUnYcfHD16VSQtsq73QjtTCyN8dEks53l9ZcADCi3aokz8/UF5/qV+hExwY/Eh4ZytilX1KucD22n5hHtyaTKeX+KcMXfEZ4ZCh1y7ajQYVv0MRr6DOznC7x9H94iejYSN361h78lS6NJuLpWolRixpTo0RLvfHpws2DuLuUpm3dkfy5pT+3Hl6koEvpFDE+ThPL9pPz+K33YY5c3siOk/NpVKnbO8X91OaHzCS1uQ6gavEvKen+KSv2jNPV1zeGACeu/oO9tbPuv9cd/IVvGk6goEtpfljSlHIe9d95LtI3/vrGFaB++Y50afSz7rN+98+lmHfccpdMsZ8+ff6AS/5eTO25P80yr4vr9e4nhpYpr/HUx9raGo1GQ//+/Y26XVO1OTaWDmnWOeazWbdjhEeG4GyfD3NTS6JiI3RBYvORmQya8ynn/LSDfPLadp5HPGXIvDqs2PsTAPmcPYiI0r40OTI6DGsLe7319JUluhRwmFLun6JQKHDJUZComAgAIiJDsbXKwbW7Jynv8RkA5QrX5+qdEzja5sZUrb0DRKVU6x6pcvfxNb6fU5NFO0eQkJCAhak1VuZ2aOI1RESFYmuZA4Actnk+oIeTunDrIN/PqcnGw0kDlolKewFidGwkn+QuAcBF/0OcuLqNwXNrc/zKtlTrASzaOZxh8+tz88GFJOs9cWUbVYt9CYCluQ0WplZJlusre/TMH/c82uuMC+Qqxo17Z/T2a2JbANQmZjjb5dfb14+e+eP2an0FXcpw5c7xFN+lQK7iANwOvIKzXT4szGzeoTf/u7rFoMhbhnPgqrff0d6ivPa6USGyi7TmAoVCwZS1nRiz5AuCQu4A+uNTHkft3VtqEzPdL4B8zp5ERD1HE6/RLUv824/TxOCas6huO5uP/Z7k6GdgsD9uLqVQKVU42OTi/lM/vfHpUfDrsoIuZbh6Wxtjksf4B0/9cMtdEpXKRBfH3jXup1YvM0ltrgOws3JCpUx6LE7fGAIcPL+a2mVe394dEHiZ4p9Uw8LMGkszGyKiXrzzXKRv/PWNq3a7a/h+Tk0OnF8DoHfe0befet/4F028hqHz6/Hnlv5o4jV6y1LbTwwtyySemVWcJpaAwMsUzqc9AmVn5UxAoA+h4U+4HehDeGQo1Us0Z/6gS4zttJEF24egidcQGhaEtaUD03od5G7QVfzun8PTtRI7Ti2g61TtqeZcDgX01tNXlujo5U1UL6H9pZPXqTDX7pzg22nF8b3vTbEC1QiPDMXSTHuYw8rcjvDIUN1n/R9e4nnEEwrkKgbAsuF+/Nb7MOEvQzhx9R/UJqbkdnSj6xRP/tzcj0aVuhm0Lx1t87B0uC/Teh7knN8+/B8mff7L75v60PO3UpQtVBeAR89uUbnI5/zcbQer9k1Ao4nTW695jQHMGXiWAS3nMntr0h8ux3w2U72k/iMYqcmf05NL/l5o4jVcCjhMeGRoqv16/Mo2uk8rQWhYELZWrwPxm32dz1m7PoALNw8Q8eqzj0PuMuCPqmw79qfuV/mmIzNpVr3ff2rvf6FSQtdPodh7Xu+nQJt01vAwaLOEyNR6fjGdWf2O06bOcOb/MxhIPT4B/LVnHE2r9ASgvMdnzNkygK5TPClaoCpmau09DCv2/kTnXwtTOJ/2KS53H1/H3soZawt73XryOXty6ZYXUTEvuXb3JBGRoXrjU/5X9QAu3jxIeFQokDLGh0eGYmn+Oo5FRIa+c9xP7/nBkJLPdanRN4beN/ZQyr0WSsXrpDU+XqN7OUViv8G7zUX6xl/fuHrkq8CSYdeZ9O1uthz9ndDwJ2nO528KCQ8iThPD1J77MVNbcvzKVr1lqe0nhiaJ5we6eOtQkjcjfNvkF+ZtG8Ssjb1wy1MKOysnrC3sUSqV2Fs7k8/Zg5CwIKzM7Sjlrn0daOmCdbj7+BobvKbTof5Ylgy9hpWFHZf8D+utp68MtNed+AQcpaT7pwDs9V5OlWJfsGjIFSoX+Zz951ZiZW7Hy+gXAEREv9AFsRcvg/lzSz8Gt1qs+y62lo4oFAqqlWjO7UAf7gRd48FTP5YO8+WHjutZunu0QfvS1MQMC1MrVCoTqhRtyu0gnyTLB7Scw5Kh11m9fyKg/UMrVbAWFqZWuDgVIiQ8SG+9xHcWJ7/e6GVUGM8jnuqOQryrxpW7c/X2cUYtakwOWxccbHKl2q/Vin/JwiE+ONnn4+TV7UDKvi6Utwyf5C7BkHl1eBn9AnubXADkdHDl9/4n6NRgPOu9pnH/iR+W5rbYWTn9p/b+V6Ym8G0taF4OTP7D88SdbKD/Z1CrSPq1TYjMKDHGlHCrQXBYIJB6fDp6eTMvXj6jbtl2ACz7dww/dPybpcN8uf3oMoHBtwHo+NlYlo+4xeFL63kR8YyNh3+jRY3vkmy3bd2R7Dy1gAkrWuHqXAQHm1x641OVYl8QHRfJ0Pn1UJuY4WCdS9fuN2O8lbkdL6NexzErC/t3jvvpPT8Yir65LjX6xnDX6UU0rNglST2F4nUqldhv8G5zkb7x1zeuFmbWmKjUWJhaUdL9Ux489Ut13tH7PV7lDGUK1U2RRySWpbafGJoknh/omM9m3RFG0J4u/7XHHgZ+NZ+c9q6YqNREvPpDjo6N5MFTP+ytnSn2STUCHmmP6N16eIHcjm6QkIDNqx3T1jIHEVHP9dbT+1ngxr0zFM5XDtWr0wcJvLE+Kyft+gpU5fyr0/3n/fZR1LWK7sLzHk2n4WirfVtUZEyE7tD/ldvHcMlREEjA6lUSbWflRETkc4P25cuoMN3/v3L7GHlyvL5BLCYuGgBTtYXuF16xAtp+0MRrCAq+jZ2Vs956if3/POJpkqMOZ27somKR12/BelcWplaMaLeSSd/uIiEhnmIFqurt18S2AFia2WKmttDb16CdZKb1OoitZQ4qF/2cOE2s7vVjlubazwYEXsb33hlGLmxEwKNLzNzU6z+3/V0plVC7KIz+Aj4rnvazOPM5wteVYVgTcJebicRHKDHG3Ht8Qzf564tP/g8vse34bPq3mK37bEJCAjYWjiiVSizN7YiMDtPFDrXKFDO1JWoTM4JC7jB1XWcW7hjGwfNruHjLCwebXIzvvIWxnTagNjEjt6Ob3vikUqro1/wPpvbcj1KpooJnQ70xPp+zB7cDfdDEa3Rx7N3jfvrOD4aQWvxNjb4xvP/Elx+XNWfD4elsPjKTu4+v456nFFdvnyAyJoKXUS+wMrd957lI3/jrG9fEz2riNfjeO0Muh0/0zjupfQ//N3KGPI5uesv07SfpIcvcXJRR4jSxjFrUGP9HFxmxqCEd6o/F5/ZR2tcbTUJCAlfvnKBf8z919XedXsz+cysxVVvogsumwzM4c2M3CQnxfF1nBCYqNVWKNuW3Dd0ZNLcWrs5FKP5JNXLYujBl3Tes3PcTtpY5aFt3FEqFMkU9jSYuRRkkvdYUoG7Zdvy8sg37zq7ARKVmdId12Fo6olab8/2cmhR0KUMR10ocOL8G33tnWLhjGADdGk/GVG3B9PVdsTC1JrejG50ajEelVGFpZsP3c2pqb2JqNguA2VsGcPLadk5c3UbT4F58XqXHe/X15YAjLP93DGoTM0q41aSoa2X+3NKffs3/YM7W77j3+DpxmhhavbrJpk2d4UxZ+w0vo1/QpHJ31CamzNzYK0W9hduHEhDoQ0JCPN2a/KLb3lGfzbSr9/pX+ePQe0xb14XbgT4Mm1+fQa0WoVSqUpS9ePmMBduHoEBB69rDMFNbUDhfuRT9etxnKxuO/AZoL3so79GAQxfXpejrIq6VGTq/LkqlirKF6lHUtTKPQ+7yy9qOKBVK1CozhrZZhqNtbmqW1I7v4Lm1Gdhy3nv183/hYAWfl9E+budZGNwPgZfR2svTHKy0d67LA+LFxyCtueCX1e0JiwxBoVAwoOVcQH98WrBjKCHhQYxc2BArczt+6rKVNnWG8+vajiiVKlxzFsUtT0n+2jOOi7cOEaeJoX65jliYWfNL938B7Vm2c377KF2wFqeu7WC91zSUChXffv4rCoUC3/tnU8Snp88fMHl1e5QKJfXLd8LJLi83H1zQG+MbV+7OoDk1sbZwYFS71VhZ2L1z3NdXLzPxurQ+Rfw9cGE1/Zr/wcmr21l78BcePbvF+OX/48dvNuodw/mDLgDw75llaOLjcM1ZhNa1hzFlbSeiYyPp1GA8gN45S99cpG/89Y2r18W/2XlqAQqFkjpl2uJk54KTnUuKeSf5ftq18SSKulbGTG3B4Lm1sbNy4n81v0dtYpqiTN9+kh4y5SszM5K8Ysuw5JWZxpMRr6TLKj72V2YmJ/3xdhKfDEtemZn1GWoM5VS7EEIIIYQwCkk8hRBCCCGEUcg1nsnYyM0RBpVWf0pfG5b0pxCGI39PhpUR/SljaFiG6k9JPJPxrJvRLfh4SF8LITIriU9Zn4xh5iSn2oUQQgghhFFI4imEEEIIIYxCEk8hhBBCCGEUkngKIYQQQgijkMRTCCGEEEIYhSSeQgghhBDCKCTxFEIIIYQQRiGJpxBCCCGEMApJPIUQQgghhFFI4imEEEIIIYxCEk8hhBBCCGEUkngKIYQQQgijkMRTCCGEEEIYhUlGNyCzuXEAwh5ndCuyD5uc4FlX/zLpa8NKq6+FEO9OYpPhZUR8knE0LEONoSSeyYQ9htD7Gd2Kj4P0tRAiM5LYlD3IOGZOcqpdCCGEEEIYhSSeQgghhBDCKORUuxAiW3r8Aq48gHvPXpf9uQ9c7OETJyiRD0w/ogj4IhIu3YN7wa/LZu2B3HbgmgNK5Qcrs4xrnxDi4/ARhV0hxMfg9lPYdRFuBKZcdjNI++/wDbAwhaqFoEEJMFcbv53G8jQMdlzUJp2a+KTLAp5o/524CRvPQLlPoElpsLfMkKYKIT4CknhmcoPn1ubanROoVGqUShW5HdxoV280tUq3yuimZTvS11mbJl6bYB28CgnvUD8yBg5chfN3oH1VKJQr3ZtoVAkJcNwPtp6HmLi314+Lh9P+2gT1q4pQwS392yjencSnrE/GUEuu8cwC2tcfwz8Tw9k07hkNK3Zm8up2PHh6M6OblS1JX2dNmnhYekSbSL5L0vmmkAiYux8u30uXpmWIhATYfgHWn3m3pPNNUbGw8jjsv5IuTRMfQOJT1idjKIlnlqJSmdC4cnc08XHcengho5uTrUlfZy0bzoDPBzw2RZMAy47C3Wdvr5sVHPWF/Vc/bB3/XADvAIM0RxiYxKes72MeQ0k8s5DYuBi2H58LQD4njwxuTfYmfZ11XH2gvUYxLTPba/+lRRMPq09ArMZwbcsIj19oT6+n5V36A7TXfT5/aZh2CcOR+JT1fcxjmKmv8YyPj+e3335j/vz53Lt3D09PT37//Xd69OhBrVq1WLBgQUY30ShW75/Ieq9pREaHoVKpGdRqEe4upQCYtKoddcu2o0qxpgD8uKw5X1TtQwXPBhnZ5Cwrrb7edXox+86u0NV9FOxPSbeajGy3KqOa+9GLT4BN3oZbX+BzOOYLtYsabp3Gtu08xBkoeY6M1V43266qYdYnPozMBVmfzDGZ/Ihnt27dmDBhAj179mTXrl20bt2atm3b4u/vT/ny5TO6eUbTrt5otkwIZcO4p1Qq0oSLNw/qlvVuNpNl/44hMjqcI5c3YWVuJ4HmA6TV140rdWN670NM732I0e3XYm5qRZdGEzOwteLGI3gabth1HvPTJrRZUXA4XDHwm1rO3YGIaMOuU7wfmQuyPpljMnHiuWbNGpYtW8a2bdsYMmQIderUYfTo0VStWpW4uDjKlSuX0U00OhtLBwa1WsSp6zs47rMVAAfrnLSo8R2ztw5g9f6f6fXljAxuZfagr68TxcfHM3lNe7o1nkxux08ypoECgLO3Db/OJ2FJn/2ZlVy4+99vrnqbOE32uvEqO5C5IOv7mOeYTJt4Tpo0iUaNGlGrVq0k5YUKFUKtVlOqVClCQkJo2rQpHh4elC5dmgYNGnDzZva+O8zW0pH/1RzEkt2jiI/XPpSvYcXO3H/iS/PqA7C1dMzgFmYf+voaYMXe8bjlLkn1Es0zrnECSL+bgd58yHpWkl79cTeL9kd2JnNB1vexzjGZMvG8f/8+Pj4+tGqV8tlWd+/epXjx4piZmaFQKBg4cCC+vr5cvHiRpk2b0qVLlwxosXG1qPkdwS8esffsX7oylxyFyOtUKANblT0l7+tzfvs567uH7p9PyeCWCU08PHmRPut+FJo+601vgc/Tab2h6bNe8WFkLsj6PsY5RpGQkJDprmY6efIkVatWZceOHTRp0kRXHhkZScGCBWncuDGLFy9O8Tlvb2+aN2/O/ftvv8hJoVDoLZ/W6yClC9Z+77ZnlClrO9Ok8reUcKuR0U1J4uKtQwyZV0fvsqzW18EvAhkyvw6Tuu3KlKc/0urr7MjEzJK+iyOSlL3Lndr6DEx27f7Vw0vZu6Dre7Ys43T+7RZ2Od2TlL1PnyTvjyB/b9aOrfgBLctaslpselNWnAvSS1Ybx6w+x7xrOpkp72p3cnICwNfXN0niOWXKFB49epTqjUUzZ86kefPmxmii+Ait3DeBiKjnTF3XWVeW39mTgV/Nz7hGfcTi42IAbbBL7Yfk+4qLiTLo+owlLjZ92q1Jp/UKIV77WOaYTHnEMz4+nrJly/Lo0SOmTZtG3rx52bBhAzt37uTu3bucPHmSypUrJ/nM+PHj2bVrFwcOHMDS8v1fNOy9FkINfFfox8w+H1T4Wv8y6WvDSquvs6uJ27Q3A71N4lG/5EfyUtOyAnzq+f7tyihLD8PFd7gR6L/2R9VC0Kby2+tlFxKbDC8j4pOMo2EZagwz5TWeSqWS9evXU7x4cXr37k2XLl1wcnKib9++qFQqSpUqlaT+zz//zPbt29m9e/cHJZ1CiKwlfzrdP5Fe601v+XOk03qzaH8IITKfTHmqHcDDw4ODBw8mKevYsSPFihXDwsJCVzZ+/Hh27tzJ3r17sbe3N3IrhRAZqWwB7XMmDcnBCgqkUwKX3sq4at/RbkgqJZTMb9h1CiE+XpnyiGdqvL29k1zfeeXKFcaNG8ezZ8+oXbs2ZcqUoUyZMhnXQCGEURXLCw4GPslRvTAos1RkfM3JBorkMew6y7iCjblh1ymE+Hhl2iOeyYWHh+Pr60ufPn10ZcWLF3/nu6je19PnDxmztCl3gq7yz8/hqFSvu2zmhp4EBPqgUCgY0GIO7i6liImN4o/NfQkMDqBA7uL0a/4Hu08vYdW+CRT/pDoj2q0EYM7Wgdx6eAEA/0cX2fxTCDtOLmD3mSUAtKgxgLpl23Hx1iGmrP2G3I5u5LR3ZXjbvwgMvk3/PyrjmrMoJipTfu2xhzhNLIPmfEpA4GXmfX+BvE6FeBQcwJS1nVCgwMkuH8PbrkClVNFliieONtrZaUDLORTIVYwJK1oTEh5EfLyGwa0Wkz+nJ2OWfEF4VCgmKlOGtVmOs30+vC6uZ73XVBQoaFt3FNVKNGP21u+49fACsbFR9PziN0q4VX+vvg4I9GHmhh4olSpcchRiSOsluptG9G1j4sqvCQ4LJDYumujYSOYPusDNBxf4Y3NflEolXRtNoqR7TU5f38W8bd9ja+XEzL5HAfj3zDLWHpyMo00eiuSvRPemU7j54Dy/ru1EZHQYK0fdBkCjiWPq310IDA6gStGmfF13BMEvApm46msSSMAlR0GGtF7Cv2eWscd7mW48p/Y8SEhYIGsP/gLA/Sc3GNByLtVLNKfZGDsKuZQF4MdvNmFr6cjYpc245O/F2I4bKOdRH4CbD86zcMcwNPFxtKo1hMpFP9db72OmUkLz8rD0iGHW52QNNbPgtZ1v+rIs+AVpHzf1ocxMoEnpD19PdpDWXDBlbWfuPb6GqdqCz6v0oG7Zdnrj/sVbXizaMQwUChpU6MwXVXsB2hvkes0oS7Pq/WhS+Vu980OisUub4ZanJF0a/ay3TN88kmj21u8Ii3ima0/yMn0x8MTVf1i9fyIKFNQs9RWtag0GYO627/G9702hvOXo22yWbn0bD8/gyOWNulibmVy7e4p5275HoVDimb8ivZM9ZD/5OPy1ZxzHfDZjbeFA1WJf8lWtQXrnE319rm9OUKlMUsxx3jf+1TtP/H1oKsevbCWXQwGGtllGRNRzxi79EpVKjZW5HT90WIdKaZJi3o+Pj2fK2k48Dr2LicqU0R3WYmflpHfe0ZcLADx78YhOk91ZMPhyujyaK8skntbW1mg0BnoB8X9ga+nIlB77Gbe8RYplbeqOII+jG/ef+LF45wh+/GYjm4/+Tp2y7ShXuJ6uXtXiX1LS/VNW7BmnK+vTbCagTS42eE0HoLxHAz6v0oM4TSwD/qiiCxj1y3dMEmQAyhf+LEnwUClNGN95Cwt3DNeVWZvb83OX7VhZ2LFk12hOX99J1WJfYGflzPTeh5Ksb2S7VZio1Fy85cXmo78zoOVs+jT/nTyObpz13cvGIzPo9cV0Nh2ZwbReh1AoFIxc1IhqJZrRs+k0TFRqgkLu8PumPkzstuO9+jq/syez+h0HYOq6Lvje98Yzv/YRLvq2MbrDWgCOXt6M34OzACzfM5YfOqzDxtKR8ctbMtl9N0VdqzBv0EWGza+XZHutag2lSeVvdf/tkqMQv/c/yciFDXVlx69uI3/OIoxou4IfljQl+EUgB86vplHFrnxWoRO/re/OrYcXaVixMw0rdkajiaPPrAoUdCmNQlGGikUaAdD/98qUK6xNFN1yl0zR/9/9bx47Tia9c3HlvgmM77wVc1PLNOt97Eq7QvlP0n6L0bvcRKNUQNuq2mQrK3NxgMal0j7l/q43FTUrBzmsDdKsLC+tuQBgRLtVSSZpfXF/w+HpjOm4Hie7fHz3Z1Vd4nni6j/YWzvr6umbHwD8H14iOjYyyXaTl6U2j4SEBREYHICVma2ubvIyfTGwYJ7SzOx7DKVCyeB5tWlS6VsePrtFZHQ4M/ocYdbG3ty4dwbP/BWJiYvWJcyZUS77AkzteQBTtTmTV7cn4NFl3PKU1C1PPg4APZtOT/IjX998oq/P9c0Jmvi4FHNcxSKNUswTIeGPuXDrIDP7HmXtwV855rOFGiVbMqPPUZRKJSv2jOfk1e18WuqrFPP+rYcXMDEx5bc+h9l/bhX7z62iZc3v9M47+nIBgE1HZlLENf3uJsyiJ5SMx1Rtjo2lg95leRzdADBRqVEqVQBc9D/EiavbGDy3NsevbAPAzsoJlVL/bHbUZzPVS7YE0D23S6U0SVL/4Pk1fD+nJgfOr9GVXbh1kO/n1GTjYe0vNoVCgYNNriTrtrF0wMrC7nUbFdo2hr0MZtCcT5m5oScxrx6TYqJSAxAVE457nlIpvp/q1Wfz5ChIVEwEkdHhumCV+NnI6HDcXd7/8EjiegDUJmY42+VPsUzfNo75bKZGCW0fhkeG4GyfD3NTS6JiI4iOjcTG0gFTE7MU29t8ZCaD5nzKOb/9AFia22BhapWkzvU7Jylf+DMAShesw/V7p8nn7EFE1PNX7QnD2sJeV/9SwGFKuX+a5PE+j575Y2+TCwsz7Qx+9/E1vp9Tk0U7R+iO2OewTXp+9NEzf2LiovhpxVf8uKw5IWFBeusJra+rgEfu9/+8AmhXFQrmNFiTMlS9YtpLBj7EZ8Wh2geuIztJay5QKBRMWduJMUu+IChEe9Gxvrif39mTiKjnxGqiMX8j1hw8v5raZVLeLvzm/ACw+djvfFmtT5I6yctSm0c2HZlJ8+r9k3w2eZm+GJjTwRWVUoVCoUClNEGhUHLt7knKe2jjYrnC9bl65wQAu08v5rMK3+jto8zA0TY3pmrtdSMq5et5O5G+cVi0czjD5tfn5oMLAHrnk9T6HJLOCWnNcW/OE773vCntXhvQ9u+1OydQKVUoX10DpEnQkNepsN5538kuL/Hx2oN04ZGh2FpqL1jXN+/oywWeRzzlZdQLcjl8knZnfgBJPA1g8a6RtKgxAIBHz25Rucjn/NxtB6v2TUCjiUvzs943dlPRs1GSsu0n5lG1eDMAPPJVYMmw60z6djdbjv5OaPgTHG3zsHS4L9N6HuSc3z78H15KcxtPnz/krO9eKng0AGBG36P81ucwOR0KsOPUAgBi42IYOLsGf27pT9ECVXSf1cRrWLXvZz6v0hOA6iVa0HtmWXrNKEOzNwLWuGUtGLGwge6o3vs6fmUb3aeVIDQsCFurpHd46NtGnCaWgMDLFM5XDtD+ggsI9CE0/Am3A30IjwzVu53qJZozf9AlxnbayILtQ9DE6z+aHh4ViqW5NsG2MrcjIjIUT9dK7Di1gK5TtZc65HIooKt/9PImqpdIekQkedmy4X781vsw4S9DOHH1H73bDQkL4sETX8Z23MDnVXqyev/EVHpMAKhV0L02VHuPs0I25trPVnAzdKsyjkIBX1WEpmW0lyP8F2qV9rOfl0mPlmVPPb+Yzqx+x2lTZzjz/xmcar3qJVowanFjuk4pQr1yHQDwvrGHUu61dAcG3vTm/HD38XXsrZyT/NDVV5bozXnkxctgQiOekNfp9S8JfWVpOX19Fy45CmJpbkN4ZCiWZq/jYnhkKHGaWC7eOkTZQnXfaX0Zyf/hJZ5HPNGdWgb949C8xgDmDDzLgJZzmb21v75VJfFmnydKHv9Tm+PerBeRbN4JjwoF4Prd0/SZVYELNw/oDgwlZ2vlRHRsJF2nFmX7ibnUePXDRd+8oy8X2HRkJs2q93vrd/0Qknh+oE1HZlIgZzHdWyKszO0oVbAWFqZWuDgVIiQ8KNXP3n/ih5Nt3iSnUq/dPcXp6ztpU0d76NzCzBoTlRoLUytKun/Kg6d+mJqYYWFqhUplQpWiTbkd5JPqNmLiopm67hsGtVqouyYp8R2+1Uu04Hag9rNqE1Nm9j3KmI7rWf7vWN3n5/8zmM/Kd8LFqSAAK/f+xKIhV1k89Bor9/2kqzeu82b+6H+KJbtG/af+S65a8S9ZOMQHJ/t8nLy6Pckyfdu4eOtQkjdTfNvkF+ZtG8Ssjb1wy1MKOysnvduxtrBHqVRib+1MPmcP3RHF5KzM7XgZpX0v48uoF1hZ2LPBazod6o9lydBrWFnYccn/MKC9Psgn4Cgl3T9Nso4T1/6hWrEvdf9ta+mIQqGgWonmuv5PsV0LOzzyV8Tc1JIyhepy9/G1VHpMJFKroHVl6F333e5KV6u0ieqIptqblLIbhQLqF4chjaGYi/ao7tvql8oPwz+HGh5GaWK2kRhTS7jVIDgsMNV6i3eOYFa/Eywb7sees8uJinnJrtOLaFgx5auek88PGw//Rosa3yWpo68MUs4jm4/Molm1vknq6CtLzaNn/vx9aAq9Xl0TaWVux8tobVyMiH6BtYU9+86uSHI9aWb14mUwf27px+BWSd9+qG8cEsc1n/Pbk/PkfQ7654TU5rg354nk8461uT0ARVwrMec7b6qXaKG7pjS5s757sLNyZsnQa3RsMI71XtN03yX5vJM8FwiPDOVJ6D0+yV38rd/3Q2Txq5kylveNPVy5fZwfOqzTlRUrUI2AR5colLccQcG3sbNyTvXzx3w2J/kl9PT5A+b/M5ifumxD9eoUQETUC6zMbdHEa/C9d4YWNb7jZVQYluY2AFy5fYxmNVL/JTZzQw++rNZX98suNi6GBBIwNTHjyu1j5MlRkISEBDTxcZio1Fia2WKm1j6uatfpxSgUCj6r0Em3PlMTM8zVlqBQEKfRvjkmJi5amwybWSc5ffRfJa4HSNKOtLZxzGdzklMj+Zw9+LXHHp5HPGXutu+TnNp4U2K/RsdG8uCpX4rrehIVLVCV8zf3U8S1EhdvHaRO2bZcCTiKzas/WFvLHLrT7jfunaFwvnK6sQPtK9DUKlPdL9vImAhMTcxRKVVcuX0Mt9wlU24UyOtUmNDwx2jiNdx6eIHcqfy6FSl55tH+u/cMfB5o//dpuPZmGwu19hrIT5y0d2tbprwCI9vJYw896sDTMLhwF+4FQ9BziNWAqQpy24NrDm1/OLz/n+9HLTGe3Ht8Q+/Rx0RKpQprc3vUJqYoFUo0mljuP/Hlx2XNefriASQkUMKtBq45i6SYH4JC7jB1XWfCIoN5EfGMcoU/01uW16lQinkkMDiAxTtHEh2njXdeF//WW1ardOsUbX4ZFcbUdZ0Z2maZ7jR8sQJV2XFyPrVKt+a83z4aVOjMkcsbufXwAttPzONO0BW2HP2D5mnMTRlBo4njlzUd6NF0Go62Sa/N0TcOOWxdsDK35XnE0zTPXuqbuyHlnJDaHJd8nvDIX5Ftx+fQps4wzvnto2iBKsTGxaA2MQXQ5QT6JCQk6BJKOysnIqKe65139OUC957c4P4TX0YubERA4GWePr/PlJ773qer0ySJ51vEaWIZtagx/o8uMmJRQzrUH4vP7aO0rzea2Vv7Y2lmy5B5dXSvtWpTZzhT1n7Dy+gXNKncHbWJKSevbmftwV949OwW45f/jx+/2QjAqWvbGd95q25bK/f+REh4EOOXaw+NT/p2F14X/2bnqQUoFErqlGmLk50Lp67tZPm/Y1CbmFHCrSZFX10EPGFFa3xuH+XBUz/a1B6GvXVOjvpsIijkDpuOzKRFje8o/kk1Ri1ujIWpNdYWDoxou5LYuGhGLmqEQqFAgYJ+LWYD8MemPni6VmLw3NqUcq/FNw3H07RqbwbO1t613qRyDwAmrmxDeGQo8QkaujWe/N597X19NxuO/AZoEy+3PKVYtX8i7euN1ruNhIQErt45Qb/mf+rWsev0YvafW4mp2oL+r77HjXveLN45gtuBPgybX5+fu25n0+EZnLmxm4SEeL6uMwITlZrHofeYtq6Lrt6gVouoWuwLpq7byMDZNahUpAk5bPPwRbU+TFn3DSv3/YStZQ7a1tUegX3zWtNEx69sTXLq5cETP6av74qFqTW5Hd3o1GA8ALO3DODkte2cuLqNpsG9+LxKD5pU7s6QebVRKJQMbbMs1XpCv/w50u+B6lmRk432CKh4P2nNBb+sbk9YZIj2CSct5wLojfttag9n+IL6KBRKKhZpjJWFHfMHXQC0T9rQxMfhmrMIkHJ++KX7v4D2LM85v32ULliL0gVrpSibuaFninlkeNu/AAgMvs2y3T9Qq3RrXZL5Zpm+GHjwwhoCgwOY9ndXAIa0WUrhfOVQq835fk5NCrqUoYhrJYq4VtK1deDsGpku6QTwurQe33tnWLhjGADdGk/mwIXV9Gv+h95xSHxyTUJCPN2aaO881zef6Ju7zdQWKeaE5HNc+VeXvyWfJxysc1LS/VMGzq5BTntXWtbUPuVgwY6hKBVKbCwcGd52BZBy3q9c9HP+PbOEwXNrk5AQz5DWS/XOOy8inqbIBSzNbfi9v/Z63SlrO9O+/g/pMg6Z8pWZGUlesWVY8spM4/kYX5kpRHqQ2GR48srMrC9bvzJTCCGEEEJkP3KqPRmbbPI4lcwirf6UvjYs6U8hDEP+lgwvI/pUxtGwDNWfcqpdCCGEEEIYhZxqF0IIIYQQRiGJpxBCCCGEMApJPIUQQgghhFFI4imEEEIIIYxCEk8hhBBCCGEUkngKIYQQQgijkMRTCCGEEEIYhSSeQgghhBDCKCTxFEIIIYQQRiGJpxBCCCGEMApJPIUQQgghhFFI4imEEEIIIYxCEk8hhBBCCGEUkngKIYQQQgijkMRTCCGEEEIYhSSeQgghhBDCKCTxFEIIIYQQRiGJpxBCCCGEMIr/A1sA5RoKCRMVAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 5, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -308,15 +308,15 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Number of preshots 4000\n", - "Number of postshots 2000\n" + "Number of preshots 3000\n", + "Number of postshots 3000\n" ] } ], @@ -358,7 +358,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -366,13 +366,13 @@ "output_type": "stream", "text": [ "Computing: ZZZ\n", - "Exact (partial) energy = 0.2868678657867208\n", + "Exact (partial) energy = 0.9448982362267818\n", "Computing: XII\n", - "Exact (partial) energy = 0.057729200917975426\n", + "Exact (partial) energy = -0.07972285693391248\n", "Computing: IXI\n", - "Exact (partial) energy = -0.1820023221878087\n", + "Exact (partial) energy = 0.03207794169271983\n", "\n", - "Exact total Energy = 0.16259474451688755\n" + "Exact total Energy = 0.8972533209855892\n" ] } ], @@ -444,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -453,22 +453,22 @@ "text": [ "\n", " ZZZ freq event presampling \n", - " {'101': 6, '010': 516, '100': 13, '110': 78, '001': 876, '000': 2204, '011': 269, '111': 38} 0.2785\n", - "Exact energy = 0.2868678657867208\n", - "Frequentist pre+post: energy ZZZ 0.28200000000000003 \n", - " \tevents {'101': 8, '010': 767, '100': 24, '110': 112, '001': 1304, '000': 3345, '011': 381, '111': 59}\n", + " {'111': 28, '001': 41, '101': 266, '011': 1926, '110': 86, '000': 649, '100': 4} 0.9513333333333333\n", + "Exact energy = 0.9448982362267818\n", + "Frequentist pre+post: energy ZZZ 0.9526666666666667 \n", + " \tevents {'111': 50, '001': 84, '101': 482, '011': 3878, '110': 159, '000': 1339, '100': 8}\n", "\n", " XII freq event presampling \n", - " {'011': 248, '111': 46, '000': 975, '010': 525, '001': 337, '101': 496, '110': 92, '100': 1281} 0.04249999999999993\n", - "Exact energy = 0.057729200917975426\n", - "Frequentist pre+post: energy XII 0.05399999999999999 \n", - " \tevents {'011': 379, '111': 64, '000': 1473, '010': 776, '001': 534, '101': 729, '110': 142, '100': 1903}\n", + " {'101': 24, '001': 248, '110': 41, '100': 390, '111': 1144, '011': 803, '000': 292, '010': 58} -0.06600000000000009\n", + "Exact energy = -0.07972285693391248\n", + "Frequentist pre+post: energy XII -0.08766666666666677 \n", + " \tevents {'101': 64, '001': 487, '110': 86, '100': 751, '111': 2362, '011': 1557, '000': 591, '010': 102}\n", "\n", " IXI freq event presampling \n", - " {'101': 6, '010': 2002, '001': 831, '110': 11, '100': 84, '000': 685, '011': 335, '111': 46} -0.19699999999999987\n", - "Exact energy = -0.1820023221878087\n", - "Frequentist pre+post: energy IXI -0.1979999999999999 \n", - " \tevents {'101': 12, '010': 3051, '001': 1221, '110': 16, '100': 123, '000': 1050, '011': 466, '111': 61}\n" + " {'101': 156, '001': 990, '111': 111, '011': 959, '000': 360, '010': 326, '110': 64, '100': 34} 0.0266666666666666\n", + "Exact energy = 0.03207794169271983\n", + "Frequentist pre+post: energy IXI 0.03399999999999997 \n", + " \tevents {'101': 338, '001': 1991, '111': 190, '011': 1947, '000': 712, '010': 650, '110': 111, '100': 61}\n" ] } ], @@ -510,7 +510,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -522,24 +522,30 @@ "\n", "\n", "Sampling for ZZZ ...\n", - "Guesses: amplitude, mean, std_dev: 0.036584806215364585 1.281510705663847 0.0034249712200795793\n", - "Fit successful: Converged with popt: [0.03659026 1.28152585 0.00342583]\n", - "Guesses: amplitude, mean, std_dev: 0.0365905915636164 1.278339730637555 0.0034239180417332425\n", - "Fit successful: Converged with popt: [0.0366016 1.27835395 0.00342477]\n", + "Guesses: amplitude, mean, std_dev: 0.028464571998210765 0.33420180724848 0.004401991792751517\n", + "Fit successful: Converged with popt: [0.0284682 0.33423223 0.00440329]\n", + "Guesses: amplitude, mean, std_dev: 0.028487818621582856 0.32974058292482666 0.0043974072129629935\n", + "Fit successful: Converged with popt: [0.02849807 0.32976921 0.00439866]\n", + "Guesses: amplitude, mean, std_dev: 0.028464571998210765 0.33420180724848 0.004401991792751517\n", + "Fit successful: Converged with popt: [0.0284682 0.33423223 0.00440329]\n", "\n", "\n", "Sampling for XII ...\n", - "Guesses: amplitude, mean, std_dev: 0.036482323891772514 1.5138739954731328 0.0034340406430913017\n", - "Fit successful: Converged with popt: [0.03649361 1.51385997 0.0034349 ]\n", - "Guesses: amplitude, mean, std_dev: 0.036482323891772514 1.5138739954731328 0.0034340406430913017\n", - "Fit successful: Converged with popt: [0.03649361 1.51385997 0.0034349 ]\n", + "Guesses: amplitude, mean, std_dev: 0.02854948319793575 1.6484991239003453 0.004389235798953513\n", + "Fit successful: Converged with popt: [0.02855183 1.64851816 0.00439033]\n", + "Guesses: amplitude, mean, std_dev: 0.028548235978245292 1.6488147600275134 0.004389433536944412\n", + "Fit successful: Converged with popt: [0.02855053 1.64883388 0.00439053]\n", + "Guesses: amplitude, mean, std_dev: 0.028543146124964766 1.6500818787015148 0.00439024535261324\n", + "Fit successful: Converged with popt: [0.02854523 1.65010137 0.00439135]\n", "\n", "\n", "Sampling for IXI ...\n", - "Guesses: amplitude, mean, std_dev: 0.03153589620934152 1.753900309921591 0.007565860560869514\n", - "Fit successful: Converged with popt: [0.03169626 1.75621317 0.00345908]\n", - "Guesses: amplitude, mean, std_dev: 0.02916477584872045 1.751022892096199 0.006867372559402927\n", - "Fit successful: Converged with popt: [0.02930527 1.75355561 0.00349418]\n" + "Guesses: amplitude, mean, std_dev: 0.028575079975428956 1.5377552250528526 0.004384532856796375\n", + "Fit successful: Converged with popt: [0.02858291 1.53774784 0.00438552]\n", + "Guesses: amplitude, mean, std_dev: 0.028579477608263248 1.5421650819918697 0.004383571563636443\n", + "Fit successful: Converged with popt: [0.02858921 1.54215866 0.00438456]\n", + "Guesses: amplitude, mean, std_dev: 0.02856401462863978 1.5372016764573646 0.0043846714535691654\n", + "Fit successful: Converged with popt: [0.02858201 1.53719417 0.00438566]\n" ] } ], @@ -556,36 +562,37 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "Hamiltonian parts measured:\n", "\n", "ZZZ\n", - "Exact energy = 0.2868678657867208\n", - "Initial energy= 0.2785 err= 0.01518772873987645\n", - "Frequentist energy 0.28200000000000003\n", - "Enhanced Energy = 0.2882900719089045 err= 0.003279340607456776\n", + "Exact energy = 0.9448982362267818\n", + "Initial energy= 0.9513333333333333 err= 0.0056272122881294295\n", + "Frequentist energy 0.9526666666666667\n", + "Enhanced Energy = 0.9446532934071042 err= 0.0014445160956443547\n", "\n", "XII\n", - "Exact energy = 0.057729200917975426\n", - "Initial energy= 0.04249999999999993 err= 0.01579907719488871\n", - "Frequentist energy 0.05399999999999999\n", - "Enhanced Energy = 0.056905268704221315 err= 0.0034293158988178076\n", + "Exact energy = -0.07972285693391248\n", + "Initial energy= -0.06600000000000009 err= 0.018220647555244683\n", + "Frequentist energy -0.08766666666666677\n", + "Enhanced Energy = -0.07922117739422849 err= 0.004377503651542197\n", "\n", "IXI\n", - "Exact energy = -0.1820023221878087\n", - "Initial energy= -0.19699999999999987 err= 0.015503478301976787\n", - "Frequentist energy -0.1979999999999999\n", - "Enhanced Energy = -0.18174248042214922 err= 0.0034359625364898836\n", + "Exact energy = 0.03207794169271983\n", + "Initial energy= 0.0266666666666666 err= 0.018253968484088667\n", + "Frequentist energy 0.03399999999999997\n", + "Enhanced Energy = 0.03359551184266223 err= 0.004383145991593109\n", "\n", - "Total Frequentist energy 0.13800000000000012 \n", - "Total Enhanced energy 0.16345286019097657\n", + "Total Frequentist energy 0.8989999999999998 \n", + "Total Enhanced energy 0.8990276278555379\n", "\n", - "Total Exact energy 0.16259474451688755\n" + "Total Exact energy 0.8972533209855892\n" ] } ], @@ -594,6 +601,8 @@ "freq_tot_energy = 0\n", "enha_tot_energy = 0\n", "\n", + "print(\"Hamiltonian parts measured:\")\n", + "\n", "for H_part in Hamiltonian.to_pauli_op():\n", " print()\n", " primitive = str(H_part)\n", @@ -621,12 +630,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -656,15 +665,15 @@ " freq_rmse[h,t+1] = get_RMSE(data['post_energy_freq'][primitive][t],data['exact_energy'][primitive])\n", " enha_rmse[h,t+1] = get_RMSE(fit_energy[primitive][t],data['exact_energy'][primitive])\n", "plt.plot(np.asarray(range(1,steps_pre+1))*sample_every, \n", - " np.sum(pre_freq_rmse,axis=0), label=\"Frequentist RMSE (Pre-sampling)\" )\n", - "plt.plot(num_preshots+np.asarray(range(steps_post+1))*sample_every, np.sum(freq_rmse,axis=0) , label=\"Frequentist RMSE\")\n", - "plt.plot(num_preshots+np.asarray(range(steps_post+1))*sample_every, np.sum(enha_rmse,axis=0) ,linestyle = '--', label=\"Enhanced RMSE\")\n", + " np.sum(pre_freq_rmse,axis=0), label=\"Pre-sampling (Frequentist)\" )\n", + "plt.plot(num_preshots+np.asarray(range(steps_post+1))*sample_every, np.sum(freq_rmse,axis=0) , label=\"Frequentist sampling\")\n", + "plt.plot(num_preshots+np.asarray(range(steps_post+1))*sample_every, np.sum(enha_rmse,axis=0) ,linestyle = '--', label=\"Enhanced circuit with \"+str(Layers)+\" layers \")\n", "#plt.plot(range(num_steps),-0.01+1/np.sqrt(range(1000,1000+num_steps)))\n", "plt.yscale('log')\n", "plt.legend()\n", "plt.ylabel('RMSE')\n", "plt.xlabel('Shots')\n", - "plt.title('Total Energy: Root-mean-squared error (RMSE). Enhanced noisy circuit with '+str(Layers)+' layers ')\n", + "plt.title('Total Energy: Root-mean-squared error (RMSE).')\n", "plt.savefig('RMSE_'+str(Layers)+'__rep'+str(repetitions)+'.png')" ] } From 2daea3f7830c8d967942d46297c24e35c8ca1242 Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Tue, 6 Jun 2023 17:52:10 +0200 Subject: [PATCH 05/13] small improvement for fit routine --- .gitignore | 1 + enhanced_sampling/EnhancedSampling.py | 12 +- misc/notebooks/EnhancedSamplingExample.ipynb | 232 +++++++++++++------ 3 files changed, 168 insertions(+), 77 deletions(-) diff --git a/.gitignore b/.gitignore index 573b49c..65bb178 100644 --- a/.gitignore +++ b/.gitignore @@ -10,3 +10,4 @@ misc/notebooks/Figs_august/* misc/notebooks/Figures/* QLMtools/package_installer.py build/ +*.png \ No newline at end of file diff --git a/enhanced_sampling/EnhancedSampling.py b/enhanced_sampling/EnhancedSampling.py index fdb1443..bb998fa 100644 --- a/enhanced_sampling/EnhancedSampling.py +++ b/enhanced_sampling/EnhancedSampling.py @@ -99,6 +99,7 @@ def eval(self, self._layers = standard_layers for rep in range(repetitions): + print('Run:',rep) self.convert_to_Theta(pre_energy_freq[primitive][steps_pre - 1][rep], std_dev_freq[primitive][steps_pre - 1][rep]) @@ -112,7 +113,7 @@ def eval(self, f_info_B = self.FischerInfo(self._initial_theta, ket_B) if f_info_A < f_info_B: - print('Using alternative circuit') + print('Using alternative circuit with',self._layers,'layers') likelihood_0, likelihood_1 = likelihood_0_B, likelihood_1_B else: self._layers = standard_layers @@ -126,8 +127,9 @@ def eval(self, sampler_enhanced = circuit_sampler.convert(circuit) outcomes = self.collect_events(sampler_enhanced, outcomes) energy, variance = self.compute_posterior(outcomes, likelihood) - fit_energy[primitive][step][rep] = energy - fit_variance[primitive][step][rep] = variance + if energy is not None: + fit_energy[primitive][step][rep] = energy + fit_variance[primitive][step][rep] = variance return fit_energy, fit_variance @@ -189,7 +191,7 @@ def get_posterior(likelihood, f_prior): estimate = sum(likelihood * f_prior) return (likelihood * f_prior) / estimate - prior_theta = self._initial_prior_theta + prior_theta = self._initial_prior_theta.copy() for _ in range(sum(outcomes.values())): for outcome in outcomes.keys(): @@ -221,7 +223,7 @@ def gaussian_function(x, amplitude, mean, std_dev): print('Fit successful: Converged with popt:', popt) except RuntimeError: print('\033[91m' + 'Fit error: Failed to converge' + '\033[0m') - theta_fit, sigma_fit = mean_guess, std_dev_guess + return None, None # Convert the fitted theta values to energy fit_energy, fit_variance = self._convert_to_energy(theta_fit, sigma_fit) diff --git a/misc/notebooks/EnhancedSamplingExample.ipynb b/misc/notebooks/EnhancedSamplingExample.ipynb index 4496916..92a6dc0 100644 --- a/misc/notebooks/EnhancedSamplingExample.ipynb +++ b/misc/notebooks/EnhancedSamplingExample.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -206,7 +206,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -230,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -238,9 +238,9 @@ "Layers = 3 #Layers of enhanced circuit; stay between 1 and 6\n", "fixed_x_angles = np.ones(2*Layers)*np.pi/2 # list of pi/2 ,to use CLF insteaf of ELF\n", "use_noise = False\n", - "num_preshots=3000 \n", + "num_preshots=3000\n", "num_postshot=3000\n", - "repetitions = 1 #repeat the entire test n-times, to increase statistic in results\n", + "repetitions = 5 #repeat the entire test n-times, to increase statistic in results\n", "sample_every = 1000 # measure the energy every n-shots\n", "n_points = 10000 #to use for binning" ] @@ -259,24 +259,24 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " Random angles assigned to ansatz {ParameterVectorElement(θ[0]): 5.217821253966976, ParameterVectorElement(θ[1]): 0.693399108952002, ParameterVectorElement(θ[2]): 6.018201104967258, ParameterVectorElement(θ[3]): 2.4093745671219824, ParameterVectorElement(θ[4]): 0.4734899931825716, ParameterVectorElement(θ[5]): 2.4153531856488564, ParameterVectorElement(θ[6]): 3.112057761700599, ParameterVectorElement(θ[7]): 3.2787477451175286, ParameterVectorElement(θ[8]): 6.011213436552083, ParameterVectorElement(θ[9]): 1.2623651513831313, ParameterVectorElement(θ[10]): 4.6847509118203225, ParameterVectorElement(θ[11]): 5.7273834967682875}\n" + " Random angles assigned to ansatz {ParameterVectorElement(θ[0]): 0.4861659063917148, ParameterVectorElement(θ[1]): 2.7668222319297935, ParameterVectorElement(θ[2]): 5.603472273814803, ParameterVectorElement(θ[3]): 4.753285964818125, ParameterVectorElement(θ[4]): 5.797005480902437, ParameterVectorElement(θ[5]): 0.41317357276705563, ParameterVectorElement(θ[6]): 1.9381257393636764, ParameterVectorElement(θ[7]): 0.2040576341312275, ParameterVectorElement(θ[8]): 0.6131230799846231, ParameterVectorElement(θ[9]): 0.8310998799423408, ParameterVectorElement(θ[10]): 1.6275117173559792, ParameterVectorElement(θ[11]): 6.098509684007178}\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "execution_count": 25, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -308,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -358,7 +358,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -366,13 +366,13 @@ "output_type": "stream", "text": [ "Computing: ZZZ\n", - "Exact (partial) energy = 0.9448982362267818\n", + "Exact (partial) energy = -0.143972900885816\n", "Computing: XII\n", - "Exact (partial) energy = -0.07972285693391248\n", + "Exact (partial) energy = -0.8290798119067536\n", "Computing: IXI\n", - "Exact (partial) energy = 0.03207794169271983\n", + "Exact (partial) energy = -0.06712263074732826\n", "\n", - "Exact total Energy = 0.8972533209855892\n" + "Exact total Energy = -1.040175343539898\n" ] } ], @@ -444,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -453,22 +453,22 @@ "text": [ "\n", " ZZZ freq event presampling \n", - " {'111': 28, '001': 41, '101': 266, '011': 1926, '110': 86, '000': 649, '100': 4} 0.9513333333333333\n", - "Exact energy = 0.9448982362267818\n", - "Frequentist pre+post: energy ZZZ 0.9526666666666667 \n", - " \tevents {'111': 50, '001': 84, '101': 482, '011': 3878, '110': 159, '000': 1339, '100': 8}\n", + " {'101': 41, '100': 62, '110': 559, '010': 308, '000': 92, '111': 1197, '011': 574, '001': 167} -0.15600000000000008\n", + "Exact energy = -0.143972900885816\n", + "Frequentist pre+post: energy ZZZ -0.1486666666666667 \n", + " \tevents {'101': 101, '100': 131, '110': 1157, '010': 643, '000': 160, '111': 2364, '011': 1136, '001': 308}\n", "\n", " XII freq event presampling \n", - " {'101': 24, '001': 248, '110': 41, '100': 390, '111': 1144, '011': 803, '000': 292, '010': 58} -0.06600000000000009\n", - "Exact energy = -0.07972285693391248\n", - "Frequentist pre+post: energy XII -0.08766666666666677 \n", - " \tevents {'101': 64, '001': 487, '110': 86, '100': 751, '111': 2362, '011': 1557, '000': 591, '010': 102}\n", + " {'101': 186, '010': 45, '110': 797, '100': 112, '000': 39, '111': 1657, '011': 154, '001': 10} -0.8346666666666667\n", + "Exact energy = -0.8290798119067536\n", + "Frequentist pre+post: energy XII -0.8359999999999999 \n", + " \tevents {'101': 364, '010': 92, '110': 1672, '100': 206, '000': 73, '111': 3266, '011': 303, '001': 24}\n", "\n", " IXI freq event presampling \n", - " {'101': 156, '001': 990, '111': 111, '011': 959, '000': 360, '010': 326, '110': 64, '100': 34} 0.0266666666666666\n", - "Exact energy = 0.03207794169271983\n", - "Frequentist pre+post: energy IXI 0.03399999999999997 \n", - " \tevents {'101': 338, '001': 1991, '111': 190, '011': 1947, '000': 712, '010': 650, '110': 111, '100': 61}\n" + " {'010': 122, '001': 201, '101': 393, '110': 136, '100': 527, '111': 854, '011': 512, '000': 255} -0.0826666666666667\n", + "Exact energy = -0.06712263074732826\n", + "Frequentist pre+post: energy IXI -0.06933333333333346 \n", + " \tevents {'010': 217, '001': 418, '101': 805, '110': 254, '100': 1034, '111': 1717, '011': 1020, '000': 535}\n" ] } ], @@ -510,7 +510,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -518,34 +518,121 @@ "output_type": "stream", "text": [ "\n", - "Repetition 1\n", + "Repetition 5\n", "\n", "\n", "Sampling for ZZZ ...\n", - "Guesses: amplitude, mean, std_dev: 0.028464571998210765 0.33420180724848 0.004401991792751517\n", - "Fit successful: Converged with popt: [0.0284682 0.33423223 0.00440329]\n", - "Guesses: amplitude, mean, std_dev: 0.028487818621582856 0.32974058292482666 0.0043974072129629935\n", - "Fit successful: Converged with popt: [0.02849807 0.32976921 0.00439866]\n", - "Guesses: amplitude, mean, std_dev: 0.028464571998210765 0.33420180724848 0.004401991792751517\n", - "Fit successful: Converged with popt: [0.0284682 0.33423223 0.00440329]\n", + "Run: 0\n", + "Guesses: amplitude, mean, std_dev: 0.028693586328196772 1.717523768408822 0.004366064771350368\n", + "Fit successful: Converged with popt: [0.02870024 1.71757655 0.00436785]\n", + "Guesses: amplitude, mean, std_dev: 0.02863619973821637 1.723421866664488 0.004373436920380994\n", + "Fit successful: Converged with popt: [0.02865098 1.72347985 0.00437542]\n", + "Guesses: amplitude, mean, std_dev: 0.028693586328196772 1.717523768408822 0.004366064771350368\n", + "Fit successful: Converged with popt: [0.02870024 1.71757655 0.00436785]\n", + "Run: 1\n", + "Guesses: amplitude, mean, std_dev: 0.028437907197759047 1.7240600848825065 0.004404097846328297\n", + "Fit successful: Converged with popt: [0.02845099 1.72411833 0.0044062 ]\n", + "Guesses: amplitude, mean, std_dev: 0.02855861857105287 1.7134332763288858 0.0043866142507879465\n", + "Fit successful: Converged with popt: [0.02856601 1.71348255 0.00438835]\n", + "Guesses: amplitude, mean, std_dev: 0.02851427697276258 1.716476381986741 0.004391040474953304\n", + "Fit successful: Converged with popt: [0.02853682 1.716528 0.00439287]\n", + "Run: 2\n", + "Guesses: amplitude, mean, std_dev: 0.02874159488386755 1.7121351146272261 0.0043579402951817725\n", + "Fit successful: Converged with popt: [0.02875441 1.71218377 0.00435957]\n", + "Guesses: amplitude, mean, std_dev: 0.02867962791102911 1.7202648455036413 0.004366368469782744\n", + "Fit successful: Converged with popt: [0.0286979 1.72031999 0.00436823]\n", + "Guesses: amplitude, mean, std_dev: 0.028688236238548378 1.7186787510866939 0.004364536628440301\n", + "Fit successful: Converged with popt: [0.02871017 1.71873253 0.00436635]\n", + "Run: 3\n", + "Guesses: amplitude, mean, std_dev: 0.02843233258740827 1.7142393119834392 0.004405028279945181\n", + "Fit successful: Converged with popt: [0.02844631 1.71428899 0.00440683]\n", + "Guesses: amplitude, mean, std_dev: 0.028478573199404892 1.7102762511312304 0.004398673232317516\n", + "Fit successful: Converged with popt: [0.02848788 1.71032306 0.00440037]\n", + "Guesses: amplitude, mean, std_dev: 0.02852205484036646 1.7060161200926105 0.00439261738335302\n", + "Fit successful: Converged with popt: [0.0285276 1.7060601 0.00439422]\n", + "Run: 4\n", + "Guesses: amplitude, mean, std_dev: 0.02851450972322152 1.713119943804542 0.004393399103814715\n", + "Fit successful: Converged with popt: [0.02852185 1.71316888 0.00439515]\n", + "Guesses: amplitude, mean, std_dev: 0.028501556048185894 1.7136194703183254 0.0043941528574501605\n", + "Fit successful: Converged with popt: [0.0285169 1.71366878 0.00439591]\n", + "Guesses: amplitude, mean, std_dev: 0.028493320170164725 1.7151357983676678 0.004396512070265529\n", + "Fit successful: Converged with popt: [0.0285014 1.71518626 0.00439832]\n", "\n", "\n", "Sampling for XII ...\n", - "Guesses: amplitude, mean, std_dev: 0.02854948319793575 1.6484991239003453 0.004389235798953513\n", - "Fit successful: Converged with popt: [0.02855183 1.64851816 0.00439033]\n", - "Guesses: amplitude, mean, std_dev: 0.028548235978245292 1.6488147600275134 0.004389433536944412\n", - "Fit successful: Converged with popt: [0.02855053 1.64883388 0.00439053]\n", - "Guesses: amplitude, mean, std_dev: 0.028543146124964766 1.6500818787015148 0.00439024535261324\n", - "Fit successful: Converged with popt: [0.02854523 1.65010137 0.00439135]\n", + "Run: 0\n", + "Guesses: amplitude, mean, std_dev: 0.028601756105903885 2.5516247525784803 0.004379487577712187\n", + "Fit successful: Converged with popt: [0.02861533 2.55164578 0.00438059]\n", + "Guesses: amplitude, mean, std_dev: 0.028596710347053304 2.555195763643663 0.0043813960124788245\n", + "Fit successful: Converged with popt: [0.02860279 2.5552179 0.00438252]\n", + "Guesses: amplitude, mean, std_dev: 0.028630969502018464 2.5443484401283625 0.004376255444742647\n", + "Fit successful: Converged with popt: [0.02863661 2.54436732 0.00437733]\n", + "Run: 1\n", + "Guesses: amplitude, mean, std_dev: 0.028669759044897263 2.5424261035594418 0.0043707894748995155\n", + "Fit successful: Converged with popt: [0.02867248 2.54244457 0.00437185]\n", + "Guesses: amplitude, mean, std_dev: 0.028665655901721022 2.5449034545718527 0.004371520386565615\n", + "Fit successful: Converged with popt: [0.02866764 2.54492263 0.00437259]\n", + "Guesses: amplitude, mean, std_dev: 0.028664987310664528 2.545214965646094 0.0043716186272914235\n", + "Fit successful: Converged with popt: [0.02866699 2.54523423 0.00437269]\n", + "Run: 2\n", + "Guesses: amplitude, mean, std_dev: 0.02849183052025133 2.543544959493932 0.004396880187814008\n", + "Fit successful: Converged with popt: [0.02850219 2.54356302 0.00439798]\n", + "Guesses: amplitude, mean, std_dev: 0.02847620359008764 2.5473351334183025 0.004399754108703625\n", + "Fit successful: Converged with popt: [0.02848349 2.54735429 0.00440087]\n", + "Guesses: amplitude, mean, std_dev: 0.028506089692459567 2.5410530868484393 0.004395136485163805\n", + "Fit successful: Converged with popt: [0.02851354 2.54107046 0.00439622]\n", + "Run: 3\n", + "Guesses: amplitude, mean, std_dev: 0.028571143003262696 2.5520425835348557 0.00438508620066877\n", + "Fit successful: Converged with popt: [0.02857876 2.5520636 0.0043862 ]\n", + "Guesses: amplitude, mean, std_dev: 0.028578658627869607 2.547249532109206 0.004382417607760048\n", + "Fit successful: Converged with popt: [0.02859626 2.54726911 0.00438351]\n", + "Guesses: amplitude, mean, std_dev: 0.028564369491206082 2.554973094189846 0.004386919251590878\n", + "Fit successful: Converged with popt: [0.02856675 2.55499502 0.00438805]\n", + "Run: 4\n", + "Guesses: amplitude, mean, std_dev: 0.02850741749552203 2.5476163437619714 0.004394192408739664\n", + "Fit successful: Converged with popt: [0.02851957 2.54763573 0.0043953 ]\n", + "Guesses: amplitude, mean, std_dev: 0.02852245119295139 2.5435183895772724 0.004391444835340805\n", + "Fit successful: Converged with popt: [0.02853749 2.5435366 0.00439253]\n", + "Guesses: amplitude, mean, std_dev: 0.028519352834784475 2.544143974460518 0.00439184466639333\n", + "Fit successful: Converged with popt: [0.02853488 2.54416236 0.00439294]\n", "\n", "\n", "Sampling for IXI ...\n", - "Guesses: amplitude, mean, std_dev: 0.028575079975428956 1.5377552250528526 0.004384532856796375\n", - "Fit successful: Converged with popt: [0.02858291 1.53774784 0.00438552]\n", - "Guesses: amplitude, mean, std_dev: 0.028579477608263248 1.5421650819918697 0.004383571563636443\n", - "Fit successful: Converged with popt: [0.02858921 1.54215866 0.00438456]\n", - "Guesses: amplitude, mean, std_dev: 0.02856401462863978 1.5372016764573646 0.0043846714535691654\n", - "Fit successful: Converged with popt: [0.02858201 1.53719417 0.00438566]\n" + "Run: 0\n", + "Guesses: amplitude, mean, std_dev: 0.02861886056440159 1.6414022302017064 0.004377437880104227\n", + "Fit successful: Converged with popt: [0.02862894 1.6414195 0.00437849]\n", + "Guesses: amplitude, mean, std_dev: 0.028635290063372135 1.6344804782248863 0.004375247239760163\n", + "Fit successful: Converged with popt: [0.02864338 1.63449591 0.00437628]\n", + "Guesses: amplitude, mean, std_dev: 0.028614849456186208 1.6395791971763618 0.004376793289263237\n", + "Fit successful: Converged with popt: [0.02863319 1.63959598 0.00437784]\n", + "Run: 1\n", + "Guesses: amplitude, mean, std_dev: 0.028607306259554856 1.6327853007017454 0.0043803501776962335\n", + "Fit successful: Converged with popt: [0.02861 1.6328001 0.00438139]\n", + "Guesses: amplitude, mean, std_dev: 0.028594039515772354 1.634270253864707 0.004380886139317762\n", + "Fit successful: Converged with popt: [0.02860648 1.63428544 0.00438193]\n", + "Guesses: amplitude, mean, std_dev: 0.02859061451535112 1.6357629800939684 0.004381457764218887\n", + "Fit successful: Converged with popt: [0.02860273 1.63577855 0.0043825 ]\n", + "Run: 2\n", + "Guesses: amplitude, mean, std_dev: 0.028568313689844384 1.6309733483450486 0.0043862996622410855\n", + "Fit successful: Converged with popt: [0.02857119 1.63098747 0.00438734]\n", + "Guesses: amplitude, mean, std_dev: 0.028541339785384222 1.6390612607995676 0.004390403462473054\n", + "Fit successful: Converged with popt: [0.02854437 1.63907748 0.00439147]\n", + "Guesses: amplitude, mean, std_dev: 0.0285457964859027 1.638150609833979 0.004389888937587011\n", + "Fit successful: Converged with popt: [0.02854773 1.63816659 0.00439095]\n", + "Run: 3\n", + "Guesses: amplitude, mean, std_dev: 0.028598558580327924 1.6409026878819093 0.004381042001474265\n", + "Fit successful: Converged with popt: [0.02860538 1.6409197 0.0043821 ]\n", + "Guesses: amplitude, mean, std_dev: 0.028606960391303886 1.639382949121022 0.004380405206460311\n", + "Fit successful: Converged with popt: [0.02860956 1.63939955 0.00438146]\n", + "Guesses: amplitude, mean, std_dev: 0.0286242198078119 1.6319098514068893 0.004377776943701399\n", + "Fit successful: Converged with popt: [0.02862684 1.6319245 0.00437881]\n", + "Run: 4\n", + "Guesses: amplitude, mean, std_dev: 0.028541102640252718 1.6358138415999683 0.004388190202188744\n", + "Fit successful: Converged with popt: [0.02855881 1.63582922 0.00438924]\n", + "Guesses: amplitude, mean, std_dev: 0.028556271221516088 1.6304592313982094 0.004385689221167089\n", + "Fit successful: Converged with popt: [0.02857517 1.63047324 0.00438673]\n", + "Guesses: amplitude, mean, std_dev: 0.028535289642065934 1.6415825371002113 0.004391395986433034\n", + "Fit successful: Converged with popt: [0.02853788 1.64159946 0.00439247]\n" ] } ], @@ -562,7 +649,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -572,27 +659,27 @@ "Hamiltonian parts measured:\n", "\n", "ZZZ\n", - "Exact energy = 0.9448982362267818\n", - "Initial energy= 0.9513333333333333 err= 0.0056272122881294295\n", - "Frequentist energy 0.9526666666666667\n", - "Enhanced Energy = 0.9446532934071042 err= 0.0014445160956443547\n", + "Exact energy = -0.143972900885816\n", + "Initial energy= -0.14213333333333333 err= 0.01807354577778678\n", + "Frequentist energy -0.13853333333333334\n", + "Enhanced Energy = -0.14352016816877455 err= 0.004338478887903055\n", "\n", "XII\n", - "Exact energy = -0.07972285693391248\n", - "Initial energy= -0.06600000000000009 err= 0.018220647555244683\n", - "Frequentist energy -0.08766666666666677\n", - "Enhanced Energy = -0.07922117739422849 err= 0.004377503651542197\n", + "Exact energy = -0.8290798119067536\n", + "Initial energy= -0.8265333333333335 err= 0.01027276966312897\n", + "Frequentist energy -0.8268000000000001\n", + "Enhanced Energy = -0.8277797921622317 err= 0.0024604025260982704\n", "\n", "IXI\n", - "Exact energy = 0.03207794169271983\n", - "Initial energy= 0.0266666666666666 err= 0.018253968484088667\n", - "Frequentist energy 0.03399999999999997\n", - "Enhanced Energy = 0.03359551184266223 err= 0.004383145991593109\n", + "Exact energy = -0.06712263074732826\n", + "Initial energy= -0.0664 err= 0.01821893151900459\n", + "Frequentist energy -0.06446666666666671\n", + "Enhanced Energy = -0.06656642010091043 err= 0.004374726787250592\n", "\n", - "Total Frequentist energy 0.8989999999999998 \n", - "Total Enhanced energy 0.8990276278555379\n", + "Total Frequentist energy -1.0298 \n", + "Total Enhanced energy -1.0378663804319168\n", "\n", - "Total Exact energy 0.8972533209855892\n" + "Total Exact energy -1.040175343539898\n" ] } ], @@ -610,10 +697,11 @@ " print('Exact energy =', data[\"exact_energy\"][primitive])\n", " print('Initial energy=', sum(data[\"pre_energy_freq\"][primitive][steps_pre-1].values())/repetitions, 'err=', sum(data[\"std_dev_freq\"][primitive][steps_pre-1].values())/repetitions)\n", " print('Frequentist energy', sum(data[\"post_energy_freq\"][primitive][steps_post-1].values())/repetitions)\n", - " print('Enhanced Energy =', sum(fit_energy[primitive][steps_post-1].values())/repetitions, 'err=', np.sqrt(sum(fit_variance[primitive][steps_post-1].values())/repetitions))\n", + " num_samples = len(fit_energy[primitive][steps_post-1].values())\n", + " print('Enhanced Energy =', sum(fit_energy[primitive][steps_post-1].values())/num_samples, 'err=', np.sqrt(sum(fit_variance[primitive][steps_post-1].values())/repetitions))\n", "\n", " freq_tot_energy += sum(data[\"post_energy_freq\"][primitive][steps_post-1].values())/repetitions\n", - " enha_tot_energy += sum(fit_energy[primitive][steps_post-1].values())/repetitions\n", + " enha_tot_energy += sum(fit_energy[primitive][steps_post-1].values())/num_samples\n", "\n", "print('\\nTotal Frequentist energy', freq_tot_energy,\n", " '\\nTotal Enhanced energy', enha_tot_energy) \n", @@ -630,12 +718,12 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -673,8 +761,8 @@ "plt.legend()\n", "plt.ylabel('RMSE')\n", "plt.xlabel('Shots')\n", - "plt.title('Total Energy: Root-mean-squared error (RMSE).')\n", - "plt.savefig('RMSE_'+str(Layers)+'__rep'+str(repetitions)+'.png')" + "plt.title('Total Energy: Root-mean-squared error.'+ str(Hamiltonian.num_qubits)+ ' qubits. Noise='+ str(use_noise))\n", + "plt.savefig('RMSE_'+str(Layers)+'__rep'+str(repetitions)+'_qb'+str(Hamiltonian.num_qubits)+'_noise'+str(use_noise)+'.png')" ] } ], From 521ba5d330d793305c0ef8d5bd1d42d6b2ba990d Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Wed, 7 Jun 2023 16:07:04 +0200 Subject: [PATCH 06/13] addition of nrep projection --- README.md | 10 ++ environment.yml | 2 +- n-rep_projection/example.py | 88 ++++++++++++++ n-rep_projection/projection.py | 176 +++++++++++++++++++++++++++ n-rep_projection/transformations.py | 179 ++++++++++++++++++++++++++++ 5 files changed, 454 insertions(+), 1 deletion(-) create mode 100644 n-rep_projection/example.py create mode 100644 n-rep_projection/projection.py create mode 100644 n-rep_projection/transformations.py diff --git a/README.md b/README.md index d47da7d..edde8e0 100644 --- a/README.md +++ b/README.md @@ -51,6 +51,16 @@ In the folder misc/notebook/ one can find an example of the algorithm in the not ![Frequentist vs Enhanced schema](doc/SamplingSchema.png) +## N-rep projection +In the repo we include an algorithm designed to mitigate the impact of decoherence and shot noise in quantum computations carried out on Noisy Intermediate-Scale Quantum (NISQ) devices. +The algorithm utilizes the Reduced Density Matrices (RDMs) of the system, which are typically distorted by noise, and projects them into a constrained space where they preserve specific conditions: having a fixed trace (corresponding to the number of electrons/holes in the system) and being positive semi-definite. + +The energy of the system, given by the expectation value of the Hamiltonian, is calculated using one- and two-electron integrals, the energy offset, as well as one- and two-particle RDMs. The algorithm considers that due to decoherence, the computed energy is likely higher than the actual ground state energy. + +To resolve this, the algorithm projects RDMs into the closest space adhering to the conditions mentioned above. These projections can be done not just in the particle sector but also in the hole and particle-hole sectors, using one- and two-hole RDMs or the particle-hole RDM. The algorithm performs all three types of projections and returns the one that yields the lowest energy value when transformed back into the particle sector. + +For a comprehensive understanding of the physics behind the algorithm and its performance, please refer to the associated research paper: Tomislav Piskor, Florian G. Eich, Michael Marthaler, Frank K. Wilhelm, Jan-Michael Reiner,Post-processing noisy quantum computations utilizing N-representability constraints,arXiv: 2304.13401 [quant-ph] (2023). You can find it [here](https://arxiv.org/abs/2304.13401 ). + ## QLM interoperability explained The code in the repository is mainly written using the Qiskit library. To be able to run the circuits onto QLM quantum processing units (QPUs), we integrated the myqlm-interop library which enables the conversion of Qiskit circuits to QLM circuits (as well as the opposite). diff --git a/environment.yml b/environment.yml index bac1e1c..e219137 100644 --- a/environment.yml +++ b/environment.yml @@ -50,6 +50,7 @@ dependencies: - mpmath==1.2.1 - nest-asyncio==1.5.1 - numpy==1.21.2 + - openfermion==1.5.1 - parso==0.8.2 - pexpect==4.8.0 - pickleshare==0.7.5 @@ -90,4 +91,3 @@ dependencies: - traitlets==5.1.0 - tweedledum==1.1.0 - wcwidth==0.2.5 -prefix: /home/gsilvi/miniforge3/envs/NEASQC4wMYQLM diff --git a/n-rep_projection/example.py b/n-rep_projection/example.py new file mode 100644 index 0000000..68b2c2c --- /dev/null +++ b/n-rep_projection/example.py @@ -0,0 +1,88 @@ +"""Example file illustrating the usage of the n-representability projection.""" +from projection import get_energy, best_fixed_trace_positive_projection +import numpy as np +from openfermion import (MolecularData, get_fermion_operator, jordan_wigner_code, + binary_code_transform, get_sparse_operator, get_ground_state, + get_density_matrix, FermionOperator) +from openfermion.utils import depolarizing_channel +from openfermionpyscf import run_pyscf + + +# System definition and FCI calculation of H2 +geometry = [('H', (0., 0., 0.)), ('H', (0., 0., 1.))] +multiplicity = 1 +basis = 'sto-3g' +prep_molecule = MolecularData(geometry, basis, multiplicity) +molecule = run_pyscf(prep_molecule, run_scf=True, run_fci=True, verbose=1) +hamiltonian = molecule.get_molecular_hamiltonian() + +# Setting the Hamiltonian parameters +number_electrons = 2 +number_orbitals = 4 +energy_offset = hamiltonian.constant +one_electron_integrals = hamiltonian.one_body_tensor +two_electron_integrals = hamiltonian.two_body_tensor + +# Getting the ground state density matrix of the system after conversion to a qubit system +fermion_hamiltonian = get_fermion_operator(hamiltonian) +code = jordan_wigner_code(number_orbitals) +qubit_hamiltonian = binary_code_transform(fermion_hamiltonian, code) +hamiltonian_original = get_sparse_operator(qubit_hamiltonian).toarray() +energy_original, wavefunction_original = get_ground_state(hamiltonian_original) +density_matrix = get_density_matrix(wavefunction_original[np.newaxis, :], [1]).toarray() + +# Getting a noisy density matrix by adding depolarization +density_matrix_noisy = depolarizing_channel(density_matrix, 0.1, target_qubit="all") + +# Constructing the 1- and 2-particle RDMs of perfect and noisy ground states +rdm1 = np.zeros((number_orbitals, number_orbitals), dtype='complex128') +for i in range(number_orbitals): + for j in range(number_orbitals): + rdm1_operator = FermionOperator(((i, 1), (j, 0)), 1.) + rdm1_operator_jw = binary_code_transform(rdm1_operator, code) + rdm1_op = get_sparse_operator(rdm1_operator_jw, number_orbitals).toarray() + rdm1[i][j] = np.trace(density_matrix @ rdm1_op) + +rdm2 = np.zeros((number_orbitals, number_orbitals, number_orbitals, number_orbitals), dtype='complex128') +for p in range(number_orbitals): + for q in range(number_orbitals): + for r in range(number_orbitals): + for s in range(number_orbitals): + rdm2_operator = FermionOperator(((p, 1), (q, 1), (r, 0), (s, 0)), 1.) + rdm2_operator_jw = binary_code_transform(rdm2_operator, code) + rdm2_op = get_sparse_operator(rdm2_operator_jw, number_orbitals).toarray() + rdm2[p][q][r][s] = np.trace(density_matrix @ rdm2_op) + +rdm1_noisy = np.zeros((number_orbitals, number_orbitals), dtype='complex128') +for i in range(number_orbitals): + for j in range(number_orbitals): + rdm1_operator = FermionOperator(((i, 1), (j, 0)), 1.) + rdm1_operator_jw = binary_code_transform(rdm1_operator, code) + rdm1_op = get_sparse_operator(rdm1_operator_jw, number_orbitals).toarray() + rdm1_noisy[i][j] = np.trace(density_matrix_noisy @ rdm1_op) + +rdm2_noisy = np.zeros((number_orbitals, number_orbitals, number_orbitals, number_orbitals), dtype='complex128') +for p in range(number_orbitals): + for q in range(number_orbitals): + for r in range(number_orbitals): + for s in range(number_orbitals): + rdm2_operator = FermionOperator(((p, 1), (q, 1), (r, 0), (s, 0)), 1.) + rdm2_operator_jw = binary_code_transform(rdm2_operator, code) + rdm2_op = get_sparse_operator(rdm2_operator_jw, number_orbitals).toarray() + rdm2_noisy[p][q][r][s] = np.trace(density_matrix_noisy @ rdm2_op) + +# Getting the enery of the perfect and noisy ground state +energy = get_energy(rdm1, rdm2, energy_offset, one_electron_integrals, two_electron_integrals) +energy_noisy = get_energy(rdm1_noisy, rdm2_noisy, energy_offset, one_electron_integrals, two_electron_integrals) + +# Perform n-representability projection, get energy after projection incl. respective 1- and 2-RDM +energy_projected, rdm1_projected, rdm2 = best_fixed_trace_positive_projection(rdm1_noisy, rdm2_noisy, number_electrons, energy_offset, one_electron_integrals, two_electron_integrals) + +# Print results +print() +print("Perfect ground state energy:", energy.real) +print("Noisy ground state energy: ", energy_noisy.real) +print("Energy after projection: ", energy_projected.real) +print() +print("Energy difference noisy to perfect ground state: ", (energy_noisy - energy).real) +print("Energy difference projected to perfect ground state:", (energy_projected - energy).real) diff --git a/n-rep_projection/projection.py b/n-rep_projection/projection.py new file mode 100644 index 0000000..346a8bc --- /dev/null +++ b/n-rep_projection/projection.py @@ -0,0 +1,176 @@ +import numpy as np +from typing import Tuple +from transformations import (get_q1_from_d1, get_q2_from_d1_d2, get_g2_from_d1_d2, + get_d1_from_q1, get_d2_from_q1_q2, get_d2_from_d1_g2) +from openfermion import fixed_trace_positive_projection +from itertools import product + + +def switch_indicies(rdm2: np.ndarray) -> np.ndarray: + r"""Switch the last two indicies of a 2-RDM. + + OpenFermion uses a different definition of the 2-RDM and in order to utilize its + `fixed_trace_positive_projection` funtion, one needs to switch the last two indecies + of the 2-RDM: + + .. math: + ^2D_{pqrs} \to ^2D_{pqsr} + + Args: + rdm2 (np.ndarray): The 2-RDM to transform + + Returns: + np.ndarray: The 2-RDM with the last two indicies switched + """ + dim = rdm2.shape[0] + rdm2_new = np.zeros_like(rdm2, dtype='complex128') + for p, q, r, s in product(range(dim), repeat=4): + rdm2_new[p][q][r][s] = rdm2[p][q][s][r] + return rdm2_new + + +def get_energy(d1_rdm: np.ndarray, d2_rdm: np.ndarray, energy_offset: float, + one_electron_integrals: np.ndarray, two_electron_integrals: np.ndarray) -> float: + r"""Get the energy from 1- and 2-particle RDM, as well as the Hamiltonian prefactors. + + The energy is given by the expectation value of the Hamiltonian, + + .. math: + \langle H \rangle = E_0 + \sum_{ij} t_{ij} ^D_{ij} + \sum_{ijkl} V_{ijkl} ^2D_{ijkl}, + + with the energy offset :math:`E_0`, the one-elctron integrals :math:`t_{ij}`, + thetwo-electron integrals :math:`V_{ijkl}`, as well as the one-partile RDM + :math:`^1D_{ij} = \langle c^\dagger_i c_j \rangle`, and the two-particle RDM + :math:`^2D_{ijkl} = \langle c^\dagger_i c^\dagger_j c_l c_k \rangle`. + + Args: + d1_rdm (np.ndarray): The 1-particle RDM + d2_rdm (np.ndarray): The 2-particle RDM + energy_offset (float): The energy offset of the Hamiltonian + one_electron_integrals (np.ndarray): The one-electron integrals of the Hamiltonian + two_electron_integrals (np.ndarray): The two-electron integrals of the Hamiltonian + + Returns: + energy (float): The energy + """ + energy = energy_offset + energy += np.einsum('ij, ij -> ', one_electron_integrals, d1_rdm) + energy += np.einsum('pqrs, pqrs -> ', two_electron_integrals, d2_rdm) + return energy + + +def best_fixed_trace_positive_projection( + d1_measured: np.ndarray, + d2_measured: np.ndarray, + number_electrons: int, + energy_offset: float, + one_electron_integrals: np.ndarray, + two_electron_integrals: np.ndarray + ) -> Tuple[float, np.ndarray, np.ndarray]: + r"""Project the 1- and 2-RDM to have a fixed trace and be positive semi-definite, in either the + particle, hole, or particle-hole sector, depending on which projection energetically yields the + best result. + + The energy is given by the expectation value of the Hamiltonian, + + .. math: + \langle H \rangle = E_0 + \sum_{ij} t_{ij} ^D_{ij} + \sum_{ijkl} V_{ijkl} ^2D_{ijkl}, + + with the energy offset :math:`E_0`, the one-elctron integrals :math:`t_{ij}`, + thetwo-electron integrals :math:`V_{ijkl}`, as well as the one-partile RDM + + .. math: + ^1D_{ij} = \langle c^\dagger_i c_j \rangle, + + and the two-particle RDM + + .. math: + ^2D_{ijkl} = \langle c^\dagger_i c^\dagger_j c_l c_k \rangle. + + If :math:`^1D` and :math:`^2D` of the ground state are obtained from a quantum computation + on a NISQ device, they are obscurred by decoherence and shot noise. We assume, that the + dominating noise source is decoherence, and in this case, the calculated energy is higher + then the actual ground state energy. + + One can mitigate this error and the statistical variance from shot noise by imposing + constraints that the RDMs need to fulfill: They need to have a particular trace (depending on + the number of electrons/holes in the system) and need to be positive semi-definite. We impose + this by projecting on the closest RDMs obeying these conditions. + + This projection can be done in the hole and particle-hole sector as well, projecting the 1- and + 2- hole RDMs, + + .. math: + ^1Q_{ij} = \langle c_i c^\dagger_j \rangle, + ^2Q_{ijkl} = \langle c_i c_j c^\dagger_l c^\dagger_k \rangle + + or the particle-hole RDM + + .. math: + ^2G_{ijkl} = \langle c^\dagger_i c_j c^\dagger_l c_k \rangle. + + This function performs all three projections and returns the energetically best result, + transformed back into the particle sector. + + For a more detailed description and details about the physics and reasoning, as well as an + investigation of the performance of the method see: + + Tomislav Piskor, Florian G. Eich, Michael Marthaler, Frank K. Wilhelm, Jan-Michael Reiner, + Post-processing noisy quantum computations utilizing N-representability constraints, + arXiv: 2304.13401 [quant-ph] (2023), https://arxiv.org/abs/2304.13401 + + Args: + d1_measured (np.ndarray): The 1-particle RDM, as measured on the quantum computer + d2_measured (np.ndarray): The 2-particle RDM, as measured on the quantum computer + number_electrons (int): The number of electrons in the system + energy_offset (float): The energy offset of the Hamiltonian + one_electron_integrals (np.ndarray): The one-electron integrals of the Hamiltonian + two_electron_integrals (np.ndarray): The two-electron integrals of the Hamiltonian + + Retruns: + Tuple: The best energy of the three projections, the corresponding projected 1-RDM, and the + correponding projected 2-RDM, each transformed back into the particle sector (if necessary) + """ + + # Get the number of holes in the system + number_orbitals = d1_measured.shape[0] + number_holes = number_orbitals - number_electrons + + # Get RDMs of hole and particle-hole sectors by transformation + q1_measured = get_q1_from_d1(d1_measured) + q2_measured = get_q2_from_d1_d2(d1_measured, d2_measured) + g2_measured = get_g2_from_d1_d2(d1_measured, d2_measured) + + # Perform projection in each sector + d1_projected = fixed_trace_positive_projection(d1_measured, number_electrons) + d2_projected = fixed_trace_positive_projection(switch_indicies(d2_measured), + number_electrons * (number_electrons - 1)) + d2_projected = switch_indicies(d2_projected) + q1_projected = fixed_trace_positive_projection(q1_measured, number_holes) + q2_projected = fixed_trace_positive_projection(switch_indicies(q2_measured), + number_holes * (number_holes - 1)) + q2_projected = switch_indicies(q2_projected) + g2_projected = fixed_trace_positive_projection(switch_indicies(g2_measured), + number_electrons * (number_holes + 1)) + g2_projected = switch_indicies(g2_projected) + + # Transform back to the particle sector after projection. + d1_from_q1_projected = get_d1_from_q1(q1_projected) + d2_from_q1_q2_projected = get_d2_from_q1_q2(q1_projected, q2_projected) + d2_from_d1_g2_projected = get_d2_from_d1_g2(d1_projected, g2_projected) + + # Get the resulting energies after projecting in each sector + energy_d = get_energy(d1_projected, d2_projected, + energy_offset, one_electron_integrals, two_electron_integrals) + energy_q = get_energy(d1_from_q1_projected, d2_from_q1_q2_projected, + energy_offset, one_electron_integrals, two_electron_integrals) + energy_g = get_energy(d1_projected, d2_from_d1_g2_projected, + energy_offset, one_electron_integrals, two_electron_integrals) + + # Return best energy and corresponding RDMs in the particle sector + if energy_d <= energy_q and energy_d <= energy_g: + return energy_d, d1_projected, d2_projected + elif energy_q <= energy_g: + return energy_q, d1_from_q1_projected, d2_from_q1_q2_projected + else: + return energy_g, d1_projected, d2_from_d1_g2_projected diff --git a/n-rep_projection/transformations.py b/n-rep_projection/transformations.py new file mode 100644 index 0000000..a514352 --- /dev/null +++ b/n-rep_projection/transformations.py @@ -0,0 +1,179 @@ +"""Functions to transform 1- and 2-RDMs between the particle, hole, and particle-hole sectors.""" +import numpy as np +from itertools import product + + +def get_d1_from_q1(q1: np.ndarray) -> np.ndarray: + r"""Transform the 1-RDM from the hole to the particle sector. + + Yields the elements of the 1-particle RDM + + .. math: + ^1D_{ij} = \langle c^\dagger_i c_j \rangle, + + given the 1-hole RDM + + .. math: + ^1Q_{ij} = \langle c_i c^\dagger_j \rangle. + + Args: + q1 (np.ndarray): The 1-hole RDM + + Returns: + d1 (np.ndarray): The 1-particle RDM + """ + dim = q1.shape[0] + d1 = np.zeros_like(q1, dtype='complex128') + delta = np.eye(dim) + for p, q in product(range(dim), repeat=2): + d1[q][p] = delta[p][q] - q1[p][q] + return d1 + + +def get_q1_from_d1(d1: np.ndarray) -> np.ndarray: + r"""Transform the 1-RDM from the particle to the hole sector. + + Yields the elements of the 1-hole RDM + + .. math: + ^1Q_{ij} = \langle c_i c^\dagger_j \rangle, + + given the 1-particle RDM + + .. math: + ^1D_{ij} = \langle c^\dagger_i c_j \rangle. + + Args: + d1 (np.ndarray): The 1-particle RDM + + Returns: + q1 (np.ndarray): The 1-hole RDM + """ + dim = d1.shape[0] + q1 = np.zeros_like(d1, dtype='complex128') + delta = np.eye(dim) + for p, q in product(range(dim), repeat=2): + q1[q][p] = delta[p][q] - d1[p][q] + return q1 + + +def get_d2_from_q1_q2(q1: np.ndarray, q2: np.ndarray) -> np.ndarray: + r"""Transform the 2-RDM from the hole to the particle sector. + + Yields the elements of the 2-particle RDM + + .. math: + ^2D_{ijkl} = \langle c^\dagger_i c^\dagger_j c_l c_k \rangle, + + given the 1-hole and 2-hole RDMs + + .. math: + ^1Q_{ij} = \langle c_i c^\dagger_j \rangle, + ^2Q_{ijkl} = \langle c_i c_j c^\dagger_l c^\dagger_k \rangle. + + Args: + q1 (np.ndarray): The 1-hole RDM + q2 (np.ndarray): The 2-hole RDM + + Returns: + d2 (np.ndarray): The 2-particle RDM + """ + dim = q2.shape[0] + delta = np.eye(dim) + d2 = np.zeros_like(q2, dtype='complex128') + for p, q, r, s in product(range(dim), repeat=4): + d2[p][q][r][s] = q2[p][q][r][s] \ + + delta[q][s] * q1[p][r] - delta[p][s] * q1[q][r] \ + - delta[q][r] * q1[p][s] + delta[p][r] * q1[q][s] \ + - delta[q][s] * delta[p][r] + delta[p][s] * delta[q][r] + return d2 + + +def get_d2_from_d1_g2(d1: np.ndarray, g2: np.ndarray) -> np.ndarray: + r"""Transform the 2-RDM from the particle-hole to the particle sector. + + Yields the elements of the 2-particle RDM + + .. math: + ^2D_{ijkl} = \langle c^\dagger_i c^\dagger_j c_l c_k \rangle, + + given the 1-particle and particle-hole RDMs + + .. math: + ^1D_{ij} = \langle c^\dagger_i c_j \rangle, + ^2G_{ijkl} = \langle c^\dagger_i c_j c^\dagger_l c_k \rangle. + + Args: + d1 (np.ndarray): The 1-particle RDM + g2 (np.ndarray): The particle-hole RDM + + Returns: + d2 (np.ndarray): The 2-particle RDM + """ + dim = g2.shape[0] + delta = np.eye(dim) + d2 = np.zeros_like(g2, dtype='complex128') + for p, q, r, s in product(range(dim), repeat=4): + d2[p][q][r][s] = delta[q][r] * d1[p][s] - g2[p][r][q][s] + return d2 + + +def get_q2_from_d1_d2(d1: np.ndarray, d2: np.ndarray) -> np.ndarray: + r"""Transform the 2-RDM from the particle to the hole sector. + + Yields the elements of the 2-hole RDM + + .. math: + ^2Q_{ijkl} = \langle c_i c_j c^\dagger_l c^\dagger_k \rangle, + + given the 1-particle and 2-particle RDMs + + .. math: + ^1D_{ij} = \langle c^\dagger_i c_j \rangle, + ^2D_{ijkl} = \langle c^\dagger_i c^\dagger_j c_l c_k \rangle. + + Args: + d1 (np.ndarray): The 1-particle RDM + d2 (np.ndarray): The 2-particle RDM + + Returns: + q2 (np.ndarray): The 2-hole RDM + """ + dim = d2.shape[0] + q2 = np.zeros_like(d2, dtype='complex128') + delta = np.eye(dim) + for p, q, r, s in product(range(dim), repeat=4): + q2[p][q][r][s] = (d2[p][q][r][s] + + delta[q][s] * d1[p][r] - delta[p][s] * d1[q][r] + - delta[q][r] * d1[p][s] + delta[p][r] * d1[q][s] + - delta[q][s] * delta[p][r] + delta[p][s] * delta[q][r]) + return q2 + + +def get_g2_from_d1_d2(d1: np.ndarray, d2: np.ndarray) -> np.ndarray: + r"""Transform the 2-RDM from the particle to the particle-hole sector. + + Yields the elements of the particle-hole RDM + + .. math: + ^2G_{ijkl} = \langle c^\dagger_i c_j c^\dagger_l c_k \rangle, + + given the 1-particle and 2-particle RDMs + + .. math: + ^1D_{ij} = \langle c^\dagger_i c_j \rangle, + ^2D_{ijkl} = \langle c^\dagger_i c^\dagger_j c_l c_k \rangle. + + Args: + d1 (np.ndarray): The 1-particle RDM + d2 (np.ndarray): The 2-particle RDM + + Returns: + g2 (np.ndarray): The particle-hole RDM + """ + dim = d2.shape[0] + g2 = np.zeros_like(d2, dtype='complex128') + delta = np.eye(dim) + for p, q, r, s in product(range(dim), repeat=4): + g2[p][q][s][r] = delta[q][s] * d1[p][r] - d2[p][s][q][r] + return g2 From 49850688dd2fc6a499efc68d25996b846de0e24e Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Wed, 7 Jun 2023 16:12:23 +0200 Subject: [PATCH 07/13] updated readme --- README.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index edde8e0..4b4ff67 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,10 @@ # NEASQC repo Variational Algorithms -This repository collects Python scripts and Jupyter notebooks that allow the user to test different variational algorithms. It contains our custom functions (e.g. VHA ansatz, PBO Hamiltonian) -that are built upon Qiskit libraries. +This repository collects Python scripts and Jupyter notebooks that allow the user to test different variational algorithms. +It contains our custom functions (e.g. VHA ansatz, PBO Hamiltonian) that are built upon Qiskit libraries, as well as method to reduce number of measurement and noise. The repository is organized as follows: -- **misc**: contains the notebooks and scripts that showcase the variational algorithms +- **misc**: contains the notebooks and python scripts that showcase the variational algorithms as well as enhanced sampling method. - **qiskit_mod**: contains our custom functions that are built upon Qiskit libraries as well as the QLM custom junction and helpers: - **qiskit_nat**: the customize function built upon qiskit_nature - **qiskit_ter**: the customize function built upon qiskit_terra @@ -12,6 +12,8 @@ The repository is organized as follows: - *uploader_junction.py*: helper to upload the junction to the QLMaaS server so that it can be found in the remote library - *wrapper2myqlm.py*: helper to wrap the variational algorithms using QLM stack - **tests**: unit tests for the variational algorithms +- **enhanced_sampling**: folder containg the class for Enhanced Sampling: a sampling methods that uses Bayesian inference to reduce the number of measurement +- **n-rep_projection** : folder containg the method and an example for an algorithm to reduces quantum computation noise via constrained projections of density matrices. - **QLMtools**: additional tools to upload qiskit_mod to the QLMaaS server - *uploader_library.py*: helper to upload the qiskit_mod library to the QLMaaS server - *create_conda_env.sh*: script to create a Conda environment with all required libraries From 2f7bda50f906b9ce6c67b3d103d91704066f19d6 Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Wed, 7 Jun 2023 16:25:07 +0200 Subject: [PATCH 08/13] update environment.yml --- environment.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/environment.yml b/environment.yml index e219137..1d14c0c 100644 --- a/environment.yml +++ b/environment.yml @@ -51,6 +51,7 @@ dependencies: - nest-asyncio==1.5.1 - numpy==1.21.2 - openfermion==1.5.1 + - openfermionpyscf==0.5 - parso==0.8.2 - pexpect==4.8.0 - pickleshare==0.7.5 From 0b6949cc822b07607648a5d48a02ea748828f697 Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Wed, 7 Jun 2023 16:28:50 +0200 Subject: [PATCH 09/13] small update to Readme file --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 4b4ff67..54b08a3 100644 --- a/README.md +++ b/README.md @@ -12,8 +12,8 @@ The repository is organized as follows: - *uploader_junction.py*: helper to upload the junction to the QLMaaS server so that it can be found in the remote library - *wrapper2myqlm.py*: helper to wrap the variational algorithms using QLM stack - **tests**: unit tests for the variational algorithms -- **enhanced_sampling**: folder containg the class for Enhanced Sampling: a sampling methods that uses Bayesian inference to reduce the number of measurement -- **n-rep_projection** : folder containg the method and an example for an algorithm to reduces quantum computation noise via constrained projections of density matrices. +- **enhanced_sampling**: contains the class for Enhanced Sampling: a sampling methods that uses Bayesian inference to reduce the number of measurement +- **n-rep_projection** : contains the method and an example for an algorithm to reduces quantum computation noise via constrained projections of density matrices. - **QLMtools**: additional tools to upload qiskit_mod to the QLMaaS server - *uploader_library.py*: helper to upload the qiskit_mod library to the QLMaaS server - *create_conda_env.sh*: script to create a Conda environment with all required libraries @@ -26,7 +26,7 @@ The `LICENCE` file contains the default licence statement as specified in the pr ## Building and installing To run the code in the repo a setup to build the Conda environment is provided. -It installs python 3.9, qiskit libraries, and our two qiskit mods on top of the following library: qiskit-nature and qiskit-terra. +It installs python 3.9, openfermions, openfermionpyscf, qiskit libraries, and our two qiskit mods on top of the following library: qiskit-nature and qiskit-terra. These two repos are modified to include additional functionalities not present in the standard qiskit libraries. Additionally, the Conda environment installs QLM libraries necessary to use QLM QPUs as backends. From 91bfa20454f0beb75fa1353fe996c01cda5ffc6a Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Mon, 26 Jun 2023 11:04:42 +0200 Subject: [PATCH 10/13] add benzene folder with script and dependencies. --- README.md | 3 + benzene_CO2/D45_benz_co2.py | 71 ++++ benzene_CO2/Github_calc_Energy.py | 516 ++++++++++++++++++++++++++++++ benzene_CO2/Github_calc_Hamilt.py | 290 +++++++++++++++++ 4 files changed, 880 insertions(+) create mode 100644 benzene_CO2/D45_benz_co2.py create mode 100644 benzene_CO2/Github_calc_Energy.py create mode 100644 benzene_CO2/Github_calc_Hamilt.py diff --git a/README.md b/README.md index 54b08a3..6df8a01 100644 --- a/README.md +++ b/README.md @@ -64,6 +64,9 @@ To resolve this, the algorithm projects RDMs into the closest space adhering to For a comprehensive understanding of the physics behind the algorithm and its performance, please refer to the associated research paper: Tomislav Piskor, Florian G. Eich, Michael Marthaler, Frank K. Wilhelm, Jan-Michael Reiner,Post-processing noisy quantum computations utilizing N-representability constraints,arXiv: 2304.13401 [quant-ph] (2023). You can find it [here](https://arxiv.org/abs/2304.13401 ). +## Analyze formation of a benzene-C02. +In the folder benzene-C02, it can be found a python script that contain a function to calculate the ground state energy of a benzene + CO2 system. + ## QLM interoperability explained The code in the repository is mainly written using the Qiskit library. To be able to run the circuits onto QLM quantum processing units (QPUs), we integrated the myqlm-interop library which enables the conversion of Qiskit circuits to QLM circuits (as well as the opposite). Additionally, the library allows wrapping QLM QPUs onto a Qiskit`s quantum instance. This allows for easy and simple integration of QPUs as backends to run the circuits. diff --git a/benzene_CO2/D45_benz_co2.py b/benzene_CO2/D45_benz_co2.py new file mode 100644 index 0000000..097ba26 --- /dev/null +++ b/benzene_CO2/D45_benz_co2.py @@ -0,0 +1,71 @@ +#!/usr/bin/env python +# coding: utf-8 + +import numpy as np +from pyscf import gto, scf +from .Github_calc_Hamilt import save_H_into_dict +from .Github_calc_Energy import save_E_into_dict + +from qat.lang.AQASM import Program +from qat.interop.qiskit import qlm_to_qiskit + +from .Github_calc_Energy import HE_circuit_for_ansatz + + +def build_benz_dist_1_co2(alpha, d_benz_co2, basis='sto-3g'): + """ + Input : alpha (varying R_C-C of benzene), d_benz_co2 (distance center of benzene-O of CO2), basis set + Ouput : benzene (distortion 1) + CO2 PySCF molecule (according to paper https://link.aps.org/doi/10.1103/PhysRevA.107.012416) + """ + mol_benz = gto.Mole() + mol_benz.verbose = 5 + mol_benz.output = 'benz_co2.log' + R_CC = 1.39*alpha + R_CH = 1.09 + c_h = '' + for i in range(6): + angle = np.pi/6 + i*np.pi/3 + x, y = R_CC*np.cos(angle), R_CC*np.sin(angle) + x_H, y_H = (R_CC+R_CH)*np.cos(angle), (R_CC+R_CH)*np.sin(angle) + c_h += f'C {x} {y} 0; H {x_H} {y_H} 0;' + R_CO = 1.16 + c_h += f'C 0 0 {d_benz_co2+R_CO}; O 0 0 {d_benz_co2}; O 0 0 {d_benz_co2+2*R_CO}' + mol_benz.atom = c_h + mol_benz.basis = basis + mol_benz.spin = 0 + mol_benz.build(0,0) + m_benz = scf.RHF(mol_benz) + m_benz.kernel() + return mol_benz, m_benz + + +def calc_benz_co2(d_benz_co2, alpha=1): + """ + This function calculate the ground state energy of a benzene + CO2 system : + - Benzene can be distorted by varying the alpha parameter (see https://link.aps.org/doi/10.1103/PhysRevA.107.012416) + - d_benz_co2 controls the distance between center of benzene and one O of CO2. + """ + + mol, m_mol = build_benz_dist_1_co2(alpha, d_benz_co2, 'sto-3g') + + ############################################# + + save_filename = 'test_github_neasqc.benzene_co2' + nb_lumo = 4 + nb_homo = 4 + dic_H_save = save_H_into_dict(d_benz_co2, save_filename, mol, m_mol, nb_homo, nb_lumo) + + ############################################# + + hamilt_filename = 'test_github_neasqc.benzene_co2.H.pickle' + save_filename = 'test_github_neasqc.benzene_co2' + + + ### qUCC calculation + dic_E_save = save_E_into_dict(d_benz_co2, hamilt_filename, save_filename, mol, m_mol, nb_homo, nb_lumo, ansatz="qUCC", nbshots=0, N_trials=1) + + ### HE calculation + dic_E_save = save_E_into_dict(d_benz_co2, hamilt_filename, save_filename, mol, m_mol, nb_homo, nb_lumo, ansatz="HE", nbshots=0, d=1, N_trials=1) + + + return dic_E_save \ No newline at end of file diff --git a/benzene_CO2/Github_calc_Energy.py b/benzene_CO2/Github_calc_Energy.py new file mode 100644 index 0000000..904b65b --- /dev/null +++ b/benzene_CO2/Github_calc_Energy.py @@ -0,0 +1,516 @@ +#!/usr/bin/env python +# coding: utf-8 + +import numpy as np +import pickle +import scipy.optimize +import qat.dqs.qchem.pyscf_tools as pyscf +from pyscf import gto, scf +from qat.dqs.transforms import transform_to_jw_basis, get_jw_code, recode_integer +from qat.dqs.qchem.ucc import get_cluster_ops_and_init_guess, build_ucc_ansatz +from qat.lang.AQASM import H, RX, RY, CNOT, QRoutine, Program +from qat.qpus import LinAlg + +################# +### HE Method ### +################# + +def HE_circuit_for_ansatz(theta, nbqbits): + """ + Input : + - theta : list of parameters + - nbqbits : number of qubits of the Hamiltonian + Output : + - Qrout : object containing |psi(theta)> obtained with HE method + """ + + Qrout = QRoutine() + d_inter = int(len(theta)/(2*(1+3*(nbqbits-1)))) + LL_inter = np.split(theta,d_inter) + for ind in range(int(nbqbits)): + Qrout.apply(H, ind) + for L in LL_inter: + for ind in range(nbqbits): + Qrout.apply(RY(L[ind]),ind) + Qrout.apply(RX(L[ind+nbqbits]),ind) + compteur_nq = 2*nbqbits + for ind in range(nbqbits): + if ind%nbqbits + 1 < nbqbits: + Qrout.apply(CNOT, ind, ind+1) + Qrout.apply(RY(L[ind+compteur_nq]),ind) + compteur_nq += 1 + Qrout.apply(RX(L[ind+compteur_nq]),ind) + compteur_nq += 1 + Qrout.apply(RY(L[ind+compteur_nq]),ind+1) + compteur_nq += 1 + Qrout.apply(RX(L[ind+compteur_nq]),ind+1) + return Qrout + +def fun_HE_ansatz(H_active_sp, theta, nbshots, qpu): + """ + Input : + - H_active_sp : Jordan-Wigner Hamiltonian + - theta : list of parameters + - nbshots : number of shots for quantum measurement + - qpu : specify the quantum processing unit + Output : + - res.value : estimation of + """ + + global compteur + compteur += 1 + + prog = Program() + reg = prog.qalloc(H_active_sp.nbqbits) + prog.apply(HE_circuit_for_ansatz(theta, H_active_sp.nbqbits), reg) + circ = prog.to_circ() + job = circ.to_job(job_type="OBS", observable=H_active_sp, nbshots=nbshots) + res = qpu.submit(job) + + return res.value + + +def vqe_he_calc(H_active_sp, d, nbshots): + """ + Input : + - H_active_sp : Jordan-Wigner Hamiltonian + - d : depth or number of parameterized layers of the circuit + - nbshots : number of shots for quantum measurement + Output : + - res.fun : minimum of E(theta) = + """ + + qpu = LinAlg() + depth = d*2*(1+3*(H_active_sp.nbqbits-1)) + theta0 = np.random.random(depth) + print(f'theta0 = {theta0}') + + global compteur + compteur = 0 + res = scipy.optimize.minimize(lambda theta: fun_HE_ansatz(H_active_sp, theta, nbshots, qpu), theta0, method="COBYLA", options={'maxiter': 1000}) + + print('--> Ansatz : HE') + print(f"E (VQE) = {res.fun}") + print(f'Number of optimization steps : {compteur}') + print(f'Number of parameters : {len(res.x)}') + print(f"optimal theta (VQE) = {res.x}") + + return res.fun + +################### +### qUCC Method ### +################### + +def ucc_ansatz_calc(H_active, active_inds, occ_inds, noons, orbital_energies, nels): + """ + Input : + - H_active : Hamiltonian after active space reduction (orbital freezing) + - active_inds, occ_inds : list of index of active/occupied orbitals + - noons : list of natural-orbital occupation numbers + - orbital energies : list of energies of each molecular orbital + - nels : total number of electrons + Output : + - H_active_sp : Jordan-Wigner Hamiltonian + - qprog : quantum circuit of |psi> obtained with qUCC method + - theta_0 : initial guess of parameters of |psi> + """ + + ######## + # 1 : preparation + ######## + + active_noons, active_orb_energies = [], [] + for ind in active_inds: + active_noons.extend([noons[ind], noons[ind]]) + active_orb_energies.extend([orbital_energies[ind], orbital_energies[ind]]) + + nb_active_els = nels - 2*len(occ_inds) + cluster_ops, theta_0, hf_init = get_cluster_ops_and_init_guess(nb_active_els, + active_noons, + active_orb_energies, + H_active.hpqrs) + + ######## + # 2 : transformation to Jordan-Wigner basis + ######## + + H_active_sp = transform_to_jw_basis(H_active) + cluster_ops_sp = [transform_to_jw_basis(t_o) for t_o in cluster_ops] + hf_init_sp = recode_integer(hf_init, get_jw_code(H_active_sp.nbqbits)) + + ######## + # 4 : creation of the qUCC ansatz + ######## + + qprog = build_ucc_ansatz(cluster_ops_sp, hf_init_sp) + + return H_active_sp, qprog, theta_0 + +def fun_qucc_ansatz(H_active_sp, qrout, theta, nbshots): + """ + Input : + - H_active_sp : Jordan-Wigner Hamiltonian + - qrout : quantum circuit of |psi> obtained with qUCC method + - theta : list of parameters + - nbshots : number of shots for quantum measurement + Output : + - res.value : estimation of + """ + global compteur + compteur += 1 + + qpu = LinAlg() + prog = Program() + reg = prog.qalloc(H_active_sp.nbqbits) + prog.apply(qrout(theta), reg) + circ = prog.to_circ() + job = circ.to_job(job_type="OBS", observable=H_active_sp, nbshots=nbshots) + res = qpu.submit(job) + return res.value + +def vqe_ucc_calc(H_active_sp, qprog, theta_0, nbshots=0): + """ + Input : + - H_active_sp : Jordan-Wigner Hamiltonian + - qprog : quantum circuit of |psi> obtained with qUCC method + - theta_0 : initial guess of parameters of |psi> + Output : + - res.fun : minimum of E(theta) = + """ + + global compteur + compteur = 0 + + res = scipy.optimize.minimize(lambda theta: fun_qucc_ansatz(H_active_sp, qprog, theta, nbshots), theta_0, method= "COBYLA", options={'maxiter': 1000}) + + print('--> Ansatz : UCC') + print(f"E (VQE) = {res.fun}") + print(f'Number of optimization steps : {compteur}') + print(f'Number of parameters : {len(res.x)}') + print(f"optimal theta (VQE) = {res.x}") + + return res.fun + +#################### +### Results save ### +#################### + +def save_E_into_dict(l1, hamilt_filename, save_filename, mol, m_mol, nb_homo, nb_lumo, ansatz="qUCC", nbshots=0, d=1, N_trials=1): + """ + Input : + - l1 : varying parameter + - hamilt_filename : filename that contains the Hamiltonian + - save_filename : filename for saving + - mol, m_mol : PySCF molecule + - nb_homo, nb_lumo : characterizes the active space reduction + - ansatz : choice of method to create |psi> (qUCC or HE) + - nbshots : number of shots for quantum measurement + - d : depth or number of parameterized layers of the circuit (only for HE) + - N_trials : number of times one wants to repeat the calculation of E_vqe + Output : + - dic_E_save : dictionary contained in save_filename.E.pickle with + * 1st key : varying parameter (e.g. : bond length of a molecule) + * 2nd key : chemical basis set + * 3rd key : nb_homo (characterizes the active space reduction) + * 4th key : nb_lumo (characterizes the active space reduction) + * Then, on the same level : + --> HF (Hartree Fock energy) : unique value + --> VQE (for VQE energies) + ↳ qUCC => nbshots => list with N_trials VQE energies + ↳ HE => nbshots => d => list with N_trials VQE energies + """ + with open(f'{hamilt_filename}','rb') as f0: + dic_H_save = pickle.load(f0) + try: + with open(f'{save_filename}.E.pickle','rb') as f1: + dic_E_save = pickle.load(f1) + except: + print(f'Error : the dictionary {save_filename}.E.pickle doesn\'t exist.\n => Creation of a new one') + dic_E_save = {} + + H_active = dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['H_active'] + active_inds = dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['active_inds'] + occ_inds = dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['occ_inds'] + noons = dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['noons'] + orbital_energies = dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['orbital_energies'] + nels = dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['nels'] + + try: + dic_E_save[str(l1)] + except: + dic_E_save[str(l1)] = {} + try: + dic_E_save[str(l1)][mol.basis] + except: + dic_E_save[str(l1)][mol.basis] = {} + try: + dic_E_save[str(l1)][mol.basis][str(nb_homo)] + except: + dic_E_save[str(l1)][mol.basis][str(nb_homo)] = {} + try: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)] + except: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)] = {} + try: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['HF'] + except: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['HF'] = m_mol.e_tot + + try: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE'] + except: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE'] = {} + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE']['qUCC'] = {} + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE']['HE'] = {} + + + if ansatz == "qUCC": + H_active_sp, qprog, theta_0 = ucc_ansatz_calc(H_active, active_inds, occ_inds, noons, orbital_energies, nels) + + try: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE']['qUCC'][str(nbshots)] + except KeyError: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE']['qUCC'][str(nbshots)] = [] + + for _ in range(N_trials): + print(f'############ Trial : {_+1}/{N_trials} ############') + E_vqe = vqe_ucc_calc(H_active_sp, qprog, theta_0, nbshots) + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE']['qUCC'][str(nbshots)].append(E_vqe) + print(f'\n') + with open(f'{save_filename}.E.pickle','wb') as f2: + pickle.dump(dic_E_save,f2) + + elif ansatz == 'HE': + H_active_sp = transform_to_jw_basis(H_active) + + try: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE']['HE'][str(nbshots)] + except KeyError: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE']['HE'][str(nbshots)] = {} + try: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE']['HE'][str(nbshots)][str(d)] + except KeyError: + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE']['HE'][str(nbshots)][str(d)] = [] + + for _ in range(N_trials): + print(f'############ Trial : {_+1}/{N_trials} ############') + E_vqe = vqe_he_calc(H_active_sp, d, nbshots) + dic_E_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['VQE']['HE'][str(nbshots)][str(d)].append(E_vqe) + print(f'\n') + with open(f'{save_filename}.E.pickle','wb') as f2: + pickle.dump(dic_E_save,f2) + + else: + print(f'Error : ansatz must be "qUCC" or "HE') + + with open(f'{save_filename}.E.pickle','wb') as f2: + pickle.dump(dic_E_save,f2) + print(f'=> The dictionary of results is saved in {save_filename}.E.pickle') + return dic_E_save + + + +####################### +### Results display ### +####################### + +def display_results(testeur_E): + for cle in testeur_E: + for cle2 in testeur_E[cle]: + print(f'{cle} HOMO - {cle2} LUMO :') + for cle3 in testeur_E[cle][cle2]: + if cle3 == 'HF': + if bool(testeur_E[cle][cle2][cle3]) == True: + print(f' {cle3} : calculated') + else: + print(f' {cle3} : ---') + else: + str_cle3 = f' {cle3} :' + for cle4 in testeur_E[cle][cle2][cle3]: + if cle4 == 'qUCC': + str_cle3 += f' {cle4} :' + if bool(testeur_E[cle][cle2][cle3][cle4]) == False: + str_cle3 += f' ---' + print(str_cle3) + else: + L_nbshots = list(testeur_E[cle][cle2][cle3][cle4].keys()) + L_len = [len(testeur_E[cle][cle2][cle3][cle4][cle5]) for cle5 in L_nbshots] + nb0 = L_nbshots.pop(0) + len0 = L_len.pop(0) + str_cle3 += f' nbshots = {nb0} : ({len0} trials)' + print(str_cle3) + for nbs in L_nbshots: + str_0 = f' ' + str_0 += f' nbshots = {nbs} : ({L_len[L_nbshots.index(nbs)]} trials)' + print(str_0) + else: + str_cle4 = f' {cle4} :' + if bool(testeur_E[cle][cle2][cle3][cle4]) == False: + str_cle4 += f' ---' + print(str_cle4) + else: + L_nbshots = list(testeur_E[cle][cle2][cle3][cle4].keys()) + nb0 = L_nbshots.pop(0) + str_cle4 += f' nbshots = {nb0} :' + L_d0 = list(testeur_E[cle][cle2][cle3][cle4][nb0].keys()) + L_len0 = [len(testeur_E[cle][cle2][cle3][cle4][nb0][cle6]) for cle6 in L_d0] + try: + str_cle4 += f' d = {L_d0.pop(0)} ({L_len0.pop(0)} trials)' + except: + str_cle4 += f' --- ' + print(str_cle4) + for _ in range(len(L_d0)): + str_0 = f' ' + str_0 += f' d = {L_d0[_]} ({L_len0[_]} trials)' + print(str_0) + for nbs in L_nbshots: + str_nbs = f' ' + str_nbs += f' nbshots = {nbs} :' + L_d = list(testeur_E[cle][cle2][cle3][cle4][str(nbs)].keys()) + L_len = [len(testeur_E[cle][cle2][cle3][cle4][str(nbs)][cle6]) for cle6 in L_d] + try: + str_nbs += f' d = {L_d.pop(0)} ({L_len.pop(0)} trials)' + except: + str_nbs += f' --- ' + print(str_nbs) + for _ in range(len(L_d)): + str_d = f' ' + str_d += f' d = {L_d[_]} ({L_len[_]} trials)' + print(str_d) + print('================================================') + +def display_full_dic(dic_E): + for cle in dic_E: + print(f'####################{(len(cle)-1)*"#"}') + print(f'###### l1 = {cle} ######') + print(f'####################{(len(cle)-1)*"#"}') + for cle2 in dic_E[cle]: + print(f'--> basis : {cle2}') + display_results(dic_E[cle][cle2]) + +############################## +### Distortions of benzene ### +############################## + +def build_benz_dist_1(alpha): + """ + Input : alpha + Ouput : benzene PySCF molecule under distortion 1 (according to paper ...) + """ + mol_benz = gto.Mole() + mol_benz.verbose = 5 + mol_benz.output = 'benz.log' + R_CC = 1.39*alpha + R_CH = 1.09 + c_h = '' + for i in range(6): + angle = np.pi/6 + i*np.pi/3 + x, y = R_CC*np.cos(angle), R_CC*np.sin(angle) + x_H, y_H = (R_CC+R_CH)*np.cos(angle), (R_CC+R_CH)*np.sin(angle) + c_h += f'C {x} {y} 0; H {x_H} {y_H} 0;' + mol_benz.atom = c_h + mol_benz.basis = 'sto-3g' + mol_benz.spin = 0 + mol_benz.build(0,0) + m_benz = scf.RHF(mol_benz) + m_benz.kernel() + return mol_benz, m_benz + +def build_benz_dist_2(alpha): + """ + Input : alpha + Ouput : benzene PySCF molecule under distortion 2 (according to paper ...) + """ + mol_benz = gto.Mole() + mol_benz.verbose = 5 + mol_benz.output = 'benz.log' + R1 = 1.39 + R_CH = 1.09 + R2 = 2*R1*np.cos(np.pi/6)*alpha + x1 = R1*np.sin(np.pi/6) + X = [0,R1,R1+x1,R1,0,-x1] + Y = [0,0,R2/2,R2,R2,R2/2] + X.append(X[0]) + Y.append(Y[0]) + X_H, Y_H = [], [] + xh = R_CH*np.cos(np.pi/3) + yh = R_CH*np.sin(np.pi/3) + X_H = [-xh,xh,R_CH,xh,-xh,-R_CH] + Y_H = [-yh,-yh,0,yh,yh,0] + c_h = '' + for i in range(6): + X_H[i] += X[i] + Y_H[i] += Y[i] + c_h += f'C {X[i]} {Y[i]} 0; H {X_H[i]} {Y_H[i]} 0;' + mol_benz.atom = c_h + mol_benz.basis = 'sto-3g' + mol_benz.spin = 0 + mol_benz.build(0,0) + m_benz = scf.RHF(mol_benz) + m_benz.kernel() + return mol_benz, m_benz + +def build_benz_dist_3(alpha): + """ + Input : alpha + Ouput : benzene PySCF molecule under distortion 3 (according to paper ...) + """ + mol_benz = gto.Mole() + mol_benz.verbose = 5 + mol_benz.output = 'benz.log' + R10 = 1.39 + R_CH = 1.09 + R2 = 2*R10*np.cos(np.pi/6) + x1 = R10*np.sin(np.pi/6) + R1 = R10*alpha + X = [0,R1,R1+x1,R1,0,-x1] + Y = [0,0,R2/2,R2,R2,R2/2] + X.append(X[0]) + Y.append(Y[0]) + X_H, Y_H = [], [] + xh = R_CH*np.cos(np.pi/3) + yh = R_CH*np.sin(np.pi/3) + X_H = [-xh,xh,R_CH,xh,-xh,-R_CH] + Y_H = [-yh,-yh,0,yh,yh,0] + c_h = '' + for i in range(6): + X_H[i] += X[i] + Y_H[i] += Y[i] + c_h += f'C {X[i]} {Y[i]} 0; H {X_H[i]} {Y_H[i]} 0;' + mol_benz.atom = c_h + mol_benz.basis = 'sto-3g' + mol_benz.spin = 0 + mol_benz.build(0,0) + m_benz = scf.RHF(mol_benz) + m_benz.kernel() + return mol_benz, m_benz + + +def full_energy_computation(dist, alpha, basis, nb_homo, nb_lumo, ansatz="qUCC", nbshots=0, d=1, N_trials=1): + """ + Input : + - dist : choice of distortion applied to benzene + - alpha : distorsion parameter + - basis : basis set + - nb_homo, nb_lumo : characterizes the active space reduction + - ansatz : choice of method to create |psi> (qUCC or HE) + - nbshots : number of shots for quantum measurement + - d : depth or number of parameterized layers of the circuit (only for HE) + - N_trials : number of times one wants to repeat the calculation of E_vqe + Output : + - dictionary containing energies of this benzene created by save_E_into_dict + """ + if dist==1: + mol, m_mol = build_benz_dist_1(alpha, basis) + elif dist==2: + mol, m_mol = build_benz_dist_2(alpha, basis) + elif dist==3: + mol, m_mol = build_benz_dist_3(alpha, basis) + else: + print(f'Error : dist = 1, 2 or 3') + + hamilt_filename = f'benzene_dist{dist}.H.pickle' + save_filename = f'benzene_dist{dist}' + + dic_E_save = save_E_into_dict(alpha, hamilt_filename, save_filename, mol, m_mol, nb_homo, nb_lumo, ansatz, nbshots, d, N_trials) + return dic_E_save diff --git a/benzene_CO2/Github_calc_Hamilt.py b/benzene_CO2/Github_calc_Hamilt.py new file mode 100644 index 0000000..0402df8 --- /dev/null +++ b/benzene_CO2/Github_calc_Hamilt.py @@ -0,0 +1,290 @@ +#!/usr/bin/env python +# coding: utf-8 + + +import numpy as np +import pickle +import qat.dqs.qchem.pyscf_tools as pyscf +from pyscf import gto, scf, ao2mo, ci +from functools import reduce +from qat.dqs.qchem import transform_integrals_to_new_basis +from qat.dqs.qchem.ucc import get_active_space_hamiltonian +import scipy + + +def ob_tb_integ(mol,m_mol): + """ + Input : PySCF molecule + Output : one-body & two-body integrals + """ + + ######## + # 1 : calculation of one_body_integral + ######## + n_orbitals = m_mol.mo_coeff.shape[1] + one_body_compressed = reduce(np.dot, (m_mol.mo_coeff.T, m_mol.get_hcore(), m_mol.mo_coeff)) + one_body_integ = one_body_compressed.reshape(n_orbitals, n_orbitals).astype(float) + + ######## + # 2 : calculation of two_body_integral + ######## + + two_body_compressed = ao2mo.kernel(mol, m_mol.mo_coeff) + two_body_integ = ao2mo.restore(1, two_body_compressed, n_orbitals) + two_body_integ = np.asarray(two_body_integ.transpose(0, 2, 3, 1), order='C') + + return one_body_integ, two_body_integ + +def H_with_active_space_reduction(one_body_integ, two_body_integ, mol, m_mol, nb_homo, nb_lumo): + """ + Input : one-body & two-body integrals, PySCF molecule, number of HOMO and LUMO + Output : + - H_active : Hamiltonian after active space reduction (orbital freezing) + - active_inds, occ_inds : list of index of active/occupied orbitals + - noons : list of natural-orbital occupation numbers + - orbital energies : list of energies of each molecular orbital + - nels : total number of electrons + """ + + ######## + # 1 : preparation + ######## + + nels = mol.nelectron + nuclear_repulsion = mol.energy_nuc() + orbital_energies = m_mol.mo_energy + + ci_mol = ci.CISD(m_mol.run()).run() + rdm1 = ci_mol.make_rdm1() + noons, basis_change = np.linalg.eigh(rdm1) + noons = list(reversed(noons)) + basis_change = np.flip(basis_change, axis=1) + one_body_integrals, two_body_integrals = transform_integrals_to_new_basis(one_body_integ, + two_body_integ, + basis_change, + old_version=False) + + + ######## + # 2 : calculation of the reduced Hamiltonian + ######## + assert nb_homo >= 0, 'nb_homo >= 0' + assert nb_lumo >= 0, 'nb_homo >= 0' + assert nb_homo <= nels//2, f'nb_homo <= {nels//2}' + assert nb_lumo <= len(noons)-nels//2, f'nb_lumo <= {len(noons)-nels//2}' + + homo_min = nels//2-nb_homo + lumo_max = nels//2 + nb_lumo + if homo_min == 0: + eps1 = 0 + else: + eps1 = 2 - (noons[homo_min-1]+noons[homo_min])/2 + eps2 = noons[lumo_max-1] + + H_active, active_inds, occ_inds = get_active_space_hamiltonian(one_body_integrals, + two_body_integrals, + noons, nels, nuclear_repulsion, threshold_1 = eps1, threshold_2 = eps2) + + return H_active, active_inds, occ_inds, noons, orbital_energies, nels, eps1, eps2 + +######################## +### Hamiltonian save ### +######################## + +def save_H_into_dict(l1, save_filename, mol, m_mol, nb_homo, nb_lumo, calc_E_exact = False): + """ + Input : l1 (varying parameter), filename for saving, PySCF molecule, number of HOMO and LUMO, choice of exact energy calculation + Output : + - dic_H_save : dictionnary contained in save_filename.pickle with + * 1st key : varying parameter (e.g. : bond length of a molecule) + * 2nd key : basis set + * 3rd key : nb_homo (characterizes the active space reduction) + * 4th key : nb_lumo (characterizes the active space reduction) + * Then : + - H_active : Hamiltonian after active space reduction (orbital freezing) + - active_inds, occ_inds : list of index of active/occupied orbitals + - noons : list of natural-orbital occupation numbers + - orbital energies : list of energies of each molecular orbital + - nels : total number of electrons + - E_exact : exact ground state energy of the system, obtained with diagonalization + """ + try: + with open(f'{save_filename}.H.pickle','rb') as f1: + dic_H_save = pickle.load(f1) + except: + print(f'Error : The dictionary {save_filename}.pickle doesn\'t exist.\n => Creation of a new one') + dic_H_save = {} + try: + dic_H_save[str(l1)] + except: + dic_H_save[str(l1)] = {} + + ob, tb = ob_tb_integ(mol,m_mol) + print(f'Nb of qubits (before reduction) : {2*ob.shape[0]}') + + H_active, active_inds, occ_inds, noons, orbital_energies, nels, eps1, eps2 = H_with_active_space_reduction(ob, tb, mol, m_mol, nb_homo, nb_lumo) + + print(f'··· nb_homo = {nb_homo} | nb_lumo = {nb_lumo}') + print(f'··· noons = {noons}') + print(f'··· occ_inds = {occ_inds}') + print(f'··· active_inds = {active_inds}') + + print(f'Nb of qubits (after reduction) : {H_active.nbqbits}') + + try: + dic_H_save[str(l1)][mol.basis] + except: + dic_H_save[str(l1)][mol.basis] = {} + try: + dic_H_save[str(l1)][mol.basis][str(nb_homo)] + except: + dic_H_save[str(l1)][mol.basis][str(nb_homo)] = {} + try: + dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)] + except: + dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)] = {} + + dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['H_active'] = H_active + dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['active_inds'] = active_inds + dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['occ_inds'] = occ_inds + dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['noons'] = noons + dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['orbital_energies'] = orbital_energies + dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['nels'] = nels + if calc_E_exact == True: + EIGVAL, _ = scipy.sparse.linalg.eigs(H_active.get_matrix(sparse=True)) + E_exact = np.min(np.real(EIGVAL)) + dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['E_exact'] = E_exact + else: + dic_H_save[str(l1)][mol.basis][str(nb_homo)][str(nb_lumo)]['E_exact'] = None + + with open(f'{save_filename}.H.pickle','wb') as f2: + pickle.dump(dic_H_save,f2) + print(f'=> The dictionary of results is saved in {save_filename}.H.pickle') + + return dic_H_save + +############################## +### Distortions of benzene ### +############################## + +def build_benz_dist_1(alpha, basis='sto-3g'): + """ + Input : alpha (varying parameter), basis set + Ouput : benzene PySCF molecule under distortion 1 (according to paper ...) + """ + mol_benz = gto.Mole() + mol_benz.verbose = 5 + mol_benz.output = 'benz.log' + R_CC = 1.39*alpha + R_CH = 1.09 + c_h = '' + for i in range(6): + angle = np.pi/6 + i*np.pi/3 + x, y = R_CC*np.cos(angle), R_CC*np.sin(angle) + x_H, y_H = (R_CC+R_CH)*np.cos(angle), (R_CC+R_CH)*np.sin(angle) + c_h += f'C {x} {y} 0; H {x_H} {y_H} 0;' + mol_benz.atom = c_h + mol_benz.basis = basis + mol_benz.spin = 0 + mol_benz.build(0,0) + m_benz = scf.RHF(mol_benz) + m_benz.kernel() + return mol_benz, m_benz + +def build_benz_dist_2(alpha, basis='sto-3g'): + """ + Input : alpha (varying parameter), basis set + Ouput : benzene PySCF molecule under distortion 2 (according to paper ...) + """ + mol_benz = gto.Mole() + mol_benz.verbose = 5 + mol_benz.output = 'benz.log' + R1 = 1.39 + R_CH = 1.09 + R2 = 2*R1*np.cos(np.pi/6)*alpha + x1 = R1*np.sin(np.pi/6) + X = [0,R1,R1+x1,R1,0,-x1] + Y = [0,0,R2/2,R2,R2,R2/2] + X.append(X[0]) + Y.append(Y[0]) + X_H, Y_H = [], [] + xh = R_CH*np.cos(np.pi/3) + yh = R_CH*np.sin(np.pi/3) + X_H = [-xh,xh,R_CH,xh,-xh,-R_CH] + Y_H = [-yh,-yh,0,yh,yh,0] + c_h = '' + for i in range(6): + X_H[i] += X[i] + Y_H[i] += Y[i] + c_h += f'C {X[i]} {Y[i]} 0; H {X_H[i]} {Y_H[i]} 0;' + mol_benz.atom = c_h + mol_benz.basis = basis + mol_benz.spin = 0 + mol_benz.build(0,0) + m_benz = scf.RHF(mol_benz) + m_benz.kernel() + return mol_benz, m_benz + +def build_benz_dist_3(alpha, basis='sto-3g'): + """ + Input : alpha (varying parameter), basis set + Ouput : benzene PySCF molecule under distortion 3 (according to paper ...) + """ + mol_benz = gto.Mole() + mol_benz.verbose = 5 + mol_benz.output = 'benz.log' + R10 = 1.39 + R_CH = 1.09 + R2 = 2*R10*np.cos(np.pi/6) + x1 = R10*np.sin(np.pi/6) + R1 = R10*alpha + X = [0,R1,R1+x1,R1,0,-x1] + Y = [0,0,R2/2,R2,R2,R2/2] + X.append(X[0]) + Y.append(Y[0]) + X_H, Y_H = [], [] + xh = R_CH*np.cos(np.pi/3) + yh = R_CH*np.sin(np.pi/3) + X_H = [-xh,xh,R_CH,xh,-xh,-R_CH] + Y_H = [-yh,-yh,0,yh,yh,0] + c_h = '' + for i in range(6): + X_H[i] += X[i] + Y_H[i] += Y[i] + c_h += f'C {X[i]} {Y[i]} 0; H {X_H[i]} {Y_H[i]} 0;' + mol_benz.atom = c_h + mol_benz.basis = basis + mol_benz.spin = 0 + mol_benz.build(0,0) + m_benz = scf.RHF(mol_benz) + m_benz.kernel() + return mol_benz, m_benz + + +def full_hamilt_computation(dist, alpha, basis, nb_homo, nb_lumo, calc_E_exact = False): + """ + Input : + - dist : choice of distortion applied to benzene + - alpha : distorsion parameter + - basis : basis set + - nb_homo, nb_lumo : characterizes the active space reduction + - calc_E_exact : choice of exact energy calculation + Output : + - dictionary containing Hamiltonian of this benzene created by save_H_into_dict + """ + if dist==1: + mol, m_mol = build_benz_dist_1(alpha, basis) + elif dist==2: + mol, m_mol = build_benz_dist_2(alpha, basis) + elif dist==3: + mol, m_mol = build_benz_dist_3(alpha, basis) + else: + print(f'Error : dist = 1, 2 or 3') + + save_filename = f'benzene_dist{dist}' + dic_H_save = save_H_into_dict(alpha, save_filename, mol, m_mol, nb_homo, nb_lumo, calc_E_exact) + return dic_H_save + + + + From c4b555892891474228a466267042a560760c9cac Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Thu, 19 Sep 2024 16:48:16 +0200 Subject: [PATCH 11/13] Added example and code for classical shadow tomography using HQS qoqo library. --- .gitignore | 1 + classic_shadows/TMB_Example_compact.ipynb | 526 ++++++++++++++++++++++ classic_shadows/create_quantum_program.py | 107 +++++ classic_shadows/qoqo_shadows.py | 318 +++++++++++++ classic_shadows/quantum_program.json | 1 + 5 files changed, 953 insertions(+) create mode 100644 classic_shadows/TMB_Example_compact.ipynb create mode 100644 classic_shadows/create_quantum_program.py create mode 100644 classic_shadows/qoqo_shadows.py create mode 100644 classic_shadows/quantum_program.json diff --git a/.gitignore b/.gitignore index 65bb178..90550e1 100644 --- a/.gitignore +++ b/.gitignore @@ -10,4 +10,5 @@ misc/notebooks/Figs_august/* misc/notebooks/Figures/* QLMtools/package_installer.py build/ +dist/ *.png \ No newline at end of file diff --git a/classic_shadows/TMB_Example_compact.ipynb b/classic_shadows/TMB_Example_compact.ipynb new file mode 100644 index 0000000..cbfe585 --- /dev/null +++ b/classic_shadows/TMB_Example_compact.ipynb @@ -0,0 +1,526 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Notebook Example to use Shadow Measurement\n", + "\n", + "This example show how to extract the spectrum from a 1D disordered Heisenber chain with the following hamiltonian:\n", + "\n", + "$$\n", + "H_S = 3(\\epsilon + J - K) + \\frac{3J_S}{4} - \\frac{J_S}{4}\\left(\\sigma_1\\sigma_2 + \\sigma_1\\sigma_3 + \\sigma_2\\sigma_3\\right)\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# hqs open-source libs\n", + "from qoqo_quest import Backend\n", + "from qoqo.devices import AllToAllDevice\n", + "from qoqo import QuantumProgram\n", + "\n", + "\n", + "# Generic libs.\n", + "from numpy.linalg import eigh\n", + "from scipy.fft import fft\n", + "from collections import defaultdict\n", + "import matplotlib.pyplot as plt \n", + "import numpy as np\n", + "import json\n", + "\n", + "# local import\n", + "from qoqo_shadows import (\n", + " measure_and_process_circuit,\n", + " generate_operators\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max frequency measurable: 0.05\n", + "Min frequency measurable: 0.0005\n" + ] + } + ], + "source": [ + "# Number of qubits\n", + "num_qubits = 3 \n", + "\n", + "# Trotter steps\n", + "max_trotter_step = 200\n", + "trotter_timestep = 10 # This has to be the same value as in `create_quantum_program.py`\n", + "\n", + "\n", + "# Max frequency (Nyquist frequency)\n", + "print(f\"Max frequency measurable: {1/(2*trotter_timestep)}\")\n", + "# Min frequency\n", + "print(f\"Min frequency measurable: {1/(max_trotter_step * trotter_timestep)}\")\n", + "\n", + "\n", + "# general device and backend\n", + "device = AllToAllDevice(\n", + " num_qubits,\n", + " [\"RotateX\", \"RotateZ\", \"RotateY\"],\n", + " [\"CNOT\"],\n", + " 1.0)\n", + "backend = Backend(num_qubits)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A pre-initialized quantum program is available locally. Created using the file `create_quantum_program.py`.\n", + "\n", + "### Initialization of the Quantum Program and Hamiltonian\n", + "\n", + "The quantum program is initialized with the following key components:\n", + "\n", + "1. **Device Setup**:\n", + " - An **AllToAllDevice** model is used, with `num_qubits = 3`, which defines interactions between all qubits.\n", + " - The device supports a set of gate operations: `[\"RotateX\", \"RotateZ\", \"RotateY\"]` for single-qubit rotations and `[\"CNOT\"]` for two-qubit entangling operations.\n", + " - A decoherence time of `1.0` is applied across qubits for the supported gates.\n", + "\n", + "\n", + "2. **Hamiltonian Initialization**:\n", + " - The Hamiltonian is built using the `SpinHamiltonianSystem` to represent a **spin-based model** for three spins.\n", + " - A simplified spin Hamiltonian, , is \n", + " $$\n", + " H_S = 3(\\epsilon + J - K) + \\frac{3J_S}{4} - \\frac{J_S}{4}\\left(\\sigma_1\\sigma_2 + \\sigma_1\\sigma_3 + \\sigma_2\\sigma_3\\right)\n", + " $$\n", + "\n", + " \n", + " constructed using parameters:\n", + " - `epsilon`: on-site energy,\n", + " - `J`: Coulomb integral,\n", + " - `K`: exchange integral,\n", + " - `J_S`: effective spin coupling constant.\n", + "\n", + "4. **Noise and Quantum Program**:\n", + " - The **quantum program** is initialized with the Hamiltonian and key parameters like:\n", + " - `trotter_timestep`: dictating the timeframe for time evolution. Default value is 10.\n", + " - `initialisation`: specifying the initial state of the qubits ([0, 0, 1]).\n", + "\n", + "5. **Measurement Circuits**:\n", + " - Measurement circuits are generated using the **XYZ Shadow Circuit**, targeting **state reconstruction** across Pauli-X, Y, and Z bases for the qubits.\n", + " - These measurement circuits are tailored to the hardware using the **single_qubit_gate_decomposition** to break down gates that are not directly supported by the device.\n", + " - The quantum program is subsequently combined with these measurement circuits, and noise (if specified) is inserted by the **NoiseInserter**.\n", + "\n", + "6. **Program Export**:\n", + " - Once the program is fully defined and noise is applied (if needed), it is serialized into JSON format and written to a file (`quantum_program.json`) for subsequent use in simulation or execution on a quantum processor.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quantum Program Loaded\n" + ] + } + ], + "source": [ + "## Load the quantum program\n", + "with open(\"quantum_program.json\", 'r') as f:\n", + " quantum_program = QuantumProgram.from_json(json.load(f))\n", + " print(\"Quantum Program Loaded\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Run the simulation \n", + "\n", + "Here you can run the simulation for `max_trotter_step` steps" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running for trotter steps:\n", + "1, " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50\n", + "51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100\n", + "101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150\n", + "151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200\n" + ] + } + ], + "source": [ + "evolution_snapshot = {}\n", + "print(\"Running for trotter steps:\")\n", + "for trotterstep in range(1, max_trotter_step+1):\n", + " print(trotterstep, end='\\n' if trotterstep % 50 == 0 else ', ')\n", + " all_shadows = measure_and_process_circuit(trotterstep,\n", + " quantum_program,\n", + " backend,\n", + " verbose=False\n", + " )\n", + " evolution_snapshot[trotterstep] = all_shadows" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Post-processing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### `Measurement Operators selection`\n", + "\n", + "Here one can choose the operator to measure on the classical shadows by specifing the locality, i.e. the number of non-identity Paulis for a given Pauli string. \n", + "In general low locality offer higher precision measure for the same shadow snapshot." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated 9 operators for 3 qubits with locality 1.\n", + "Generated 27 operators for 3 qubits with locality 2.\n", + "Generated 27 operators for 3 qubits with locality 3.\n", + "Total number of operators to measure: 63\n", + "XII,IXI,IIX,YII,IYI,IIY,ZII,IZI,IIZ,XXI,XIX,IXX,XYI,XIY,IXY,XZI,XIZ,IXZ,YXI,YIX,IYX,YYI,YIY,IYY,YZI,YIZ,IYZ,ZXI,ZIX,IZX,ZYI,ZIY,IZY,ZZI,ZIZ,IZZ,XXX,XXY,XXZ,XYX,XYY,XYZ,XZX,XZY,XZZ,YXX,YXY,YXZ,YYX,YYY,YYZ,YZX,YZY,YZZ,ZXX,ZXY,ZXZ,ZYX,ZYY,ZYZ,ZZX,ZZY,ZZZ," + ] + } + ], + "source": [ + "# Pick max locality \n", + "locality = 3\n", + "assert locality <= num_qubits, \"locality should be less than or equal to the number of qubits\"\n", + "\n", + "operators_dict = {}\n", + "for loc in range(1,locality+1):\n", + " loc_operators = generate_operators(num_qubits,loc)\n", + " operators_dict.update(loc_operators)\n", + " print(f\"Generated {len(loc_operators)} operators for {num_qubits} qubits with locality {loc}.\")\n", + "\n", + "print(\"Total number of operators to measure: \", len(operators_dict))\n", + "for label, op in operators_dict.items():\n", + " print(f\"{label}\", end=',')#, Operator:\\n{op}\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `Signal Analysis`\n", + "\n", + "\n", + "### High-Level Overview of Matrix Operations from Shadow Snapshot Data\n", + "\n", + "This code extracts and visualizes insights from **shadow snapshot data**, a quantum or simulation-based method of estimating operator values over time. It performs two main actions:\n", + "\n", + "1. **Data Organization and Transformation**:\n", + " - The code first **standardizes the measurements** of different operators over time. This data is structured into a matrix \\( D \\), where each row represents how a particular operator evolves or behaves over a series of time steps (or experimental trials).\n", + "\n", + "2. **Matrix Construction and Analysis**:\n", + " - From this data matrix:\n", + " - **\\( D^T \\)**, the **transpose** of the data matrix, is computed to reorganize data and is visualized as a heatmap to observe the operator behaviors across different time indices.\n", + " - **\\( C = D^T D \\)** is a matrix that reveals **similarities or correlations** between time points by examining the shared behavior of observables.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize dictionaries using defaultdict for simpler list and dictionary management\n", + "shadow_measurements = defaultdict(dict) # Organize by trotterstep and operator\n", + "aggregated_measurements = defaultdict(list) # Organize by operator\n", + "\n", + "# Iterate over each trotterstep in evolution_snapshot\n", + "for trotterstep, snapshots in evolution_snapshot.items():\n", + " \n", + " # Compute the average shadow once for the current trotterstep\n", + " average_shadow = np.mean(snapshots, axis=0)\n", + " \n", + " # Measure each operator on the shadow density matrices\n", + " for operator_label, operator in operators_dict.items():\n", + " \n", + " # Compute the trace for the operator on the shadow density matrix\n", + " value = np.trace(np.dot(operator, average_shadow))\n", + " \n", + " # Store the value for the current trotterstep and operator\n", + " shadow_measurements[trotterstep][operator_label] = value\n", + " \n", + " # Append the value to the list of aggregated measurements for this operator\n", + " aggregated_measurements[operator_label].append(value)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Step 1: Compute Mean and Standard Deviation, then Standardize \n", + "standardized_measurements = {} \n", + "for op, values in aggregated_measurements.items():\n", + " values_array = np.array(values)\n", + "\n", + " # Compute mean and standard deviation\n", + " mean = np.mean(values_array)\n", + " std = np.std(values_array)\n", + " # Avoid division by zero: if std is zero, keep the values as zeros\n", + " if std == 0:\n", + " standardized_values = np.zeros_like(values_array)\n", + " else:\n", + " standardized_values = (values_array - mean) / std\n", + " \n", + " # Store the standardized measurements\n", + " standardized_measurements[op] = standardized_values\n", + "\n", + "operators = list(standardized_measurements.keys()) # list of operator labels\n", + "\n", + "# Step 2: Construct Data Matrix D where each row is the set of standardized measurements for an operator\n", + "D = np.array([standardized_measurements[op] for op in operators])\n", + "\n", + "# Step 3: Construct the covariance Gram matrix C = D.T @ D (D^T * D)\n", + "C = np.dot(D.T, D)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot the Data Matrix D and C" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Set up the matplotlib figure and axes \n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))\n", + "# Plotting the data matrix D^T \n", + "cax1 = ax1.matshow(np.real(D.T), aspect='auto', origin='lower', cmap='viridis')\n", + "fig.colorbar(cax1, ax=ax1)\n", + "ax1.set_title('Data Matrix $D^T$')\n", + "ax1.set_ylabel('Time Index $n \\leq N_T$')\n", + "ax1.set_xlabel('Observable Index $k \\leq N_O$')\n", + "\n", + "# Plotting the matrix C \n", + "cax2 = ax2.matshow(np.real(C), aspect='auto', origin='lower', cmap='viridis')\n", + "fig.colorbar(cax2, ax=ax2)\n", + "ax2.set_title('Covariance $C = D^T D$')\n", + "ax2.set_xlabel('Time Index $n \\leq N_T$')\n", + "ax2.set_ylabel('Time Index $n \\leq N_T$')\n", + "\n", + "# Show the plot \n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Retaining 1 dominant eigenvectors from 200 total.\n" + ] + } + ], + "source": [ + "# Set the cutoff to retain top n dominant eigenvectors\n", + "cutoff_index = 1 # Adjust this value as needed\n", + "\n", + "\n", + "# Step 4: Perform Eigenvalue Decomposition on C\n", + "eigenvalues, eigenvectors = eigh(C)\n", + "\n", + "# Step 5: Sort Eigenvalues and Eigenvectors in Descending Order\n", + "sorted_indices = np.argsort(eigenvalues)[::-1]\n", + "sorted_eigenvalues = eigenvalues[sorted_indices]\n", + "sorted_eigenvectors = eigenvectors[:, sorted_indices]\n", + "\n", + "\n", + "# Check if the cutoff_index is within valid bounds, cap at the max available\n", + "cutoff_index = min(cutoff_index, len(sorted_eigenvalues))\n", + "if cutoff_index == 0:\n", + " raise ValueError(\"The cutoff_index must be at least 1.\")\n", + "\n", + "\n", + "# Retain the top dominant eigenvectors\n", + "dominant_eigenvectors = sorted_eigenvectors[:, :cutoff_index]\n", + "print(f\"Retaining {cutoff_index} dominant eigenvectors from {len(sorted_eigenvalues)} total.\")\n", + "\n", + "\n", + "# Step 6: Compute Fourier Transform of the Dominant Eigenvectors\n", + "frequency_components = fft(dominant_eigenvectors, axis=0)\n", + "\n", + "# Step 7: Calculate the Shadow Spectrum\n", + "# Number of points from the FFT\n", + "N = frequency_components.shape[0]\n", + "# Identify half of the FFT to focus only on positive frequencies\n", + "half_point = N // 2\n", + "\n", + "# Generate positive frequency axis using the FFT frequency function\n", + "positive_frequencies = np.fft.fftfreq(N, d=trotter_timestep)[:half_point]\n", + "\n", + "# Compute the spectrum as the absolute value of the Fourier components\n", + "spectrum = np.abs(frequency_components[:half_point])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot spectrum\n", + "\n", + "The spectrum for the provided Hamiltonian is plotted agains the known peak." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Observed peak energy: 0.028274 atomic units\n", + "Expected peak energy: 0.028883 atomic units\n", + "Observed peak frequency: 0.004500 1/time unit\n", + "Expected peak frequency: 0.004597 1/time unit\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "fig, ax1 = plt.subplots(figsize=(10, 5))\n", + "\n", + "# Plot the spectrum\n", + "ax1.plot(positive_frequencies, spectrum, '.-')\n", + "ax1.set_xlabel('Frequency (1/time unit)')\n", + "ax1.set_ylabel('Spectral Density')\n", + "\n", + "# Add vertical line for expected peak\n", + "J_S = 0.019255\n", + "expected_peak_energy = J_S * 3/2 \n", + "expected_peak_frequency = expected_peak_energy / (2*np.pi)\n", + "ax1.vlines(expected_peak_frequency, -1, 20, linestyles=\"--\", colors='g', \n", + " label=fr'Expected Peak Energy($3/2 J_S$): {expected_peak_energy:.6f}')\n", + "\n", + "# Create a secondary x-axis for frequencies\n", + "ax2 = ax1.secondary_xaxis('top', functions=(lambda x: x*(2*np.pi), lambda x: x/(2*np.pi)))\n", + "ax2.set_xlabel('Energies (atomic units)')\n", + "\n", + "plt.title('Classical-Shadow Spectrum')\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Print the peak information\n", + "peak_index = np.argmax(spectrum)\n", + "peak_energy = positive_frequencies[peak_index]*2*np.pi\n", + "peak_frequency = positive_frequencies[peak_index]\n", + "print(f\"Observed peak energy: {peak_energy:.6f} atomic units\")\n", + "print(f\"Expected peak energy: {expected_peak_energy:.6f} atomic units\")\n", + "print(f\"Observed peak frequency: {peak_frequency:.6f} 1/time unit\")\n", + "print(f\"Expected peak frequency: {expected_peak_frequency:.6f} 1/time unit\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "QOQO.venv", + "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.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/classic_shadows/create_quantum_program.py b/classic_shadows/create_quantum_program.py new file mode 100644 index 0000000..b17c8d5 --- /dev/null +++ b/classic_shadows/create_quantum_program.py @@ -0,0 +1,107 @@ +import json +from hqs_noise_app import HqsNoiseApp +from struqture_py.spins import SpinHamiltonianSystem +from qoqo import QuantumProgram, measurements +from qoqo.noise_models import ContinuousDecoherenceModel +from qoqo.devices import AllToAllDevice +from qoqo_shadows import create_XYZ_shadow_circuit + + +# Configuring the parameters +num_qubits = 3 +noise_mode = "all_qubits" +trotter_timestep = 10 +shot_per_trotter_step = 10000 +initialisation = [0, 0, 1] # Initialization of spins + +filename = "quantum_program.json" + +# Hamiltonian values: +epsilon = -0.582863 +J = 0.148819 +K = 0.009731 +J_S = 0.019255 + + +# Device +device = AllToAllDevice( + num_qubits, + [ + "RotateX", + "RotateZ", + "RotateY", + ], + ["CNOT"], + 1.0, +) + +# Noise model. Optional to use +noise_model_con = ContinuousDecoherenceModel().add_damping_rate( + list(range(num_qubits)), 0.001 +) +# Here insert the noise if needed +noise_to_use = [noise_model_con] + + +# Function to create the simplified spin Hamiltonian +def create_simplified_tmb_hamiltonian(epsilon, J, K, J_S, number_spins=3): + """ + Create a simplified spin Hamiltonian for TMB as described in equation 12. + + Parameters: + epsilon: on-site energy + J: Coulomb integral + K: exchange integral + J_S: effective spin coupling constant + """ + hamiltonian = SpinHamiltonianSystem(number_spins) + + # Constant term + constant_term = 3 * (epsilon + J - K) + (3 * J_S) / 4 + hamiltonian.add_operator_product("I", constant_term) + + # Two-spin interaction terms + coupling = -J_S / 4 + for i in range(number_spins): + j = (i + 1) % number_spins # Next spin (circular) + hamiltonian.add_operator_product(f"{i}X{j}X", coupling) + hamiltonian.add_operator_product(f"{i}Y{j}Y", coupling) + hamiltonian.add_operator_product(f"{i}Z{j}Z", coupling) + + return hamiltonian + + +hamiltonian = create_simplified_tmb_hamiltonian(epsilon, J, K, J_S, num_qubits) + +# Define noise_app +noise_app = HqsNoiseApp(noise_mode) + +# Create the quantum program, without providing measured_operators and operator_names +quantum_program_initial = noise_app.quantum_program( + hamiltonian, trotter_timestep, initialisation, [], [], device +) + + +measurement_circuits = create_XYZ_shadow_circuit( + num_qubits, shot_per_trotter_step, max_circuits=None +) + + +# Combine the constant circuit with the measurement circuits. +measurement = measurements.ClassicalRegister( + constant_circuit=quantum_program_initial.measurement().constant_circuit(), + circuits=measurement_circuits, +) + +# Create the quantum program, and add noise if specified +program = QuantumProgram( + measurement=measurement, input_parameter_names=["number_trottersteps"] +) +if noise_to_use: + program = noise_app.add_noise(program, device, noise_to_use) + + +with open(filename, "w") as f: + json.dump(program.to_json(), f) + +print("Quantum program saved in ", filename) diff --git a/classic_shadows/qoqo_shadows.py b/classic_shadows/qoqo_shadows.py new file mode 100644 index 0000000..2d0d234 --- /dev/null +++ b/classic_shadows/qoqo_shadows.py @@ -0,0 +1,318 @@ +# qoqo_shadows is a Python library for creating quantum shadow circuits. +from qoqo import operations as ops +from qoqo import Circuit, QuantumProgram +from qoqo_quest import Backend + +import numpy as np +from typing import List, Optional, Dict, Any +import itertools +from functools import reduce + +from typing import List, Optional +import numpy as np + +XYZ_MAP = { + "X": [lambda qubit: ops.RotateY(qubit, theta=np.pi / 2)], + "Y": [lambda qubit: ops.RotateX(qubit, theta=-np.pi / 2)], + "Z": None, +} + +paulis = { + "X": np.array([[0, 1], [1, 0]]), + "Y": np.array([[0, -1j], [1j, 0]]), + "Z": np.array([[1, 0], [0, -1]]), +} + + +def get_unitary_matrix_from_ops(unitary_ops: Optional[List]) -> np.ndarray: + """Given a list of operations, get the corresponding unitary matrix. + If None, return the identity matrix (case of Z basis). + + Parameters: + unitary_ops (Optional[List]): A list of unitary operations. + + Returns: + unitary_matrix (np.ndarray): The corresponding unitary matrix. + """ + if unitary_ops is None: + return np.eye(2) + + unitary_ops_mats = [ops(qubit=0).unitary_matrix() for ops in unitary_ops] + return reduce(np.dot, unitary_ops_mats) + + +XYZ_MAP_MATRICES = { + key: get_unitary_matrix_from_ops(ops) for key, ops in XYZ_MAP.items() +} + + +def create_circuit_for_shadow_measure( + num_qubits: int, + n_measurement: int, + map_for_ops: dict = {}, + base_label: str = "ro", +) -> Circuit: + """Creates a quantum circuit for shadow measurements. + + Iterate over the map_for_ops and add the corresponding operations to the circuit. + Important: the operations are reversed, which is relevant for multiple operation cases. + + Parameters: + - num_qubits (int): The total number of qubits in the circuit. + - initialization_circ (Circuit): The initial part of the circuit. + - n_measurement (int): Number of times measurements are to be repeated. + - map_for_ops (dict): Mapping of qubit indices to operations. + + Returns: + - Circuit: Complete quantum circuit with shadow measurements. + """ + shadow_circuit = Circuit() + + for qb, operations in map_for_ops.items(): + if operations: + # Important! the reverse order is for ops, not matrices + for op in reversed(operations): + shadow_circuit += op(qubit=qb) + + shadow_circuit += ops.DefinitionBit( + name=base_label, length=len(map_for_ops), is_output=True + ) + for qb in range(num_qubits): + shadow_circuit += ops.MeasureQubit(qb, base_label, qb) + shadow_circuit += ops.PragmaSetNumberOfMeasurements(n_measurement, base_label) + + return shadow_circuit + + +def create_XYZ_shadow_circuit( + num_qubits: int, + n_measurement: int = 1, + map_for_unitaries: dict = XYZ_MAP, + max_circuits: Optional[int] = None, +) -> list: + """Generates circuits for shadow measurements based on specified measurement bases for each qubit. + + Each circuit corresponds to a different combination of measurement bases (X, Y, Z, etc.), + applied across all qubits. This function iterates over all possible combinations of measurement bases, + constructs the circuit for each combination by applying the corresponding unitary transformations, + and then stores the circuit along with its unitary matrices. + + Parameters: + - num_qubits (int): The number of qubits in the circuit. + - n_measurement (int, optional): The number of measurements to perform. Defaults to 1. + - map_for_unitaries (dict, optional): A mapping from measurement basis labels (e.g., 'X', 'Y', 'Z') to the + corresponding quantum operations (unitaries). Defaults to XYZ_MAP, a predefined dictionary. + - max_circuits (int, optional): The maximum number of circuits to generate. Defaults to None, which means all combinations possible. + + Returns: + - dict: A dictionary where keys are strings representing the combination of measurement bases applied to + each qubit, and values are tuples containing the corresponding quantum circuit and a dictionary of unitary + matrices for each qubit. + """ + all_combinations = get_combinations( + num_qubits, max_circuits, list(map_for_unitaries.keys()) + ) + num_circuits = len(all_combinations) + if num_circuits > n_measurement: + raise ValueError( + "Not enough measurement shots to generate all circuits. Either increase the number of measurement shots or limit the number of circuits." + ) + n_measurement_per_circuit = int(n_measurement / num_circuits) + print( + f"Created {num_circuits} measurement circuits, each with {n_measurement_per_circuit} shots" + ) + all_circuits = [] + + # Generate all combinations of measurement bases for n qubits + for combination in all_combinations: + map_for_ops = {} + + # Construct the list of unitary operations for the current combination + for qubit_idx, base in enumerate(combination): + # Get the operations to apply to the qubit + ops = map_for_unitaries.get(base, None) + # Update ops to include the qubit index, and append to unitary_operations + map_for_ops[qubit_idx] = ops + + base_label = "".join(combination) # Label for the measurement basis combination + # Generate the corresponding circuit for shadow measurement + circuit = create_circuit_for_shadow_measure( + num_qubits, n_measurement_per_circuit, map_for_ops, base_label + ) + + all_circuits.append(circuit) + + return all_circuits + + +def get_combinations( + num_qubits: int, + max_combination: Optional[int] = None, + measurement_bases: list = ["X", "Y", "Z"], +) -> List[List[str]]: + """Generate all possible combinations of measurement bases for a given number of qubits. + + Parameters: + - num_qubits (int): The number of qubits to measure. + - max_combination (Optional[int]): The maximum number of combinations to generate. + If None, all possible combinations are generated. + - measurement_bases (list):A list of measurement bases to consider.Defaults to ['X', 'Y', 'Z']. + + Returns: + List[List[str]]: A list of lists, where each inner list represents a combination of bases. + """ + + all_combinations = list(itertools.product(measurement_bases, repeat=num_qubits)) + if max_combination is not None and len(all_combinations) > max_combination: + indices = np.random.choice( + len(all_combinations), size=max_combination, replace=False + ) + all_combinations = [all_combinations[i] for i in indices] + return all_combinations + + +def inverse_channel( + post_measurement_state: np.ndarray, n_qubits: int = 1 +) -> np.ndarray: + """Applies the inverse channel operation to a post-measurement state to estimate the pre-measurement state. + + This is a part of classical post-processing in quantum shadow tomography, where the aim is to reconstruct + the quantum state before measurement based on the measurement outcomes. + + Parameters: + - post_measurement_state (np.ndarray): The density matrix of the post-measurement state. + - n_qubits (int, optional): The number of qubits in the state. This affects the scaling factor + used in the inverse channel calculation. Defaults to 1. + + Returns: + - np.ndarray: The estimated pre-measurement state as a density matrix, obtained by applying the + inverse channel operation to the post-measurement state. + """ + return (2**n_qubits + 1) * post_measurement_state - np.eye(2**n_qubits) + + +def get_shadow_from_outcome( + measurement_outcome: bool, unitary: np.ndarray, n_qubits=1 +) -> np.ndarray: + """Constructs the shadow state from a single measurement outcome and a unitary matrix. + + This function first constructs a qubit state based on the measurement outcome, then applies the conjugate transpose + (dagger) of the unitary to this qubit state to get the shadow state. It then constructs the density matrix + for this shadow state and applies the inverse channel to this density matrix to obtain the final shadow + state in density matrix form. + + Parameters: + - measurement_outcome (bool): The outcome of the measurement, where False represents the state |0> and True represents the state |1>. + - unitary (np.ndarray): The unitary matrix that was applied to the qubit before measurement. + - n_qubits (int, optional): The number of qubits in the state. Defaults to 1. + + Returns: + - np.ndarray: The density matrix representing the shadow state of the qubit post-measurement. + """ + qubit_state = np.array([[0], [1]]) if measurement_outcome else np.array([[1], [0]]) + # Apply the dagger of the unitary to the qubit state + qubit_shadow = unitary.conj().T @ qubit_state + # Construct the density matrix for the qubit + qubit_density_matrix = np.outer(qubit_shadow, qubit_shadow.conj()) + # Append the individual qubit density matrix to the list + return inverse_channel(qubit_density_matrix, n_qubits) + + +def measure_and_process_circuit( + trotterstep: int, + quantum_program: QuantumProgram, + backend: Backend, + verbose: bool = False, +) -> dict: + """Measure and process classical shadow circuts. + + Measures and processes a dictionary of quantum circuits with their corresponding unitary matrices, + using a specified quantum backend. This function iterates over each circuit, performs the measurement + using the backend, and then constructs the post-measurement state. For each measurement outcome, + it calculates the shadow state by applying the inverse channel and the conjugate transpose (dagger) + of the unitary. It then constructs the multi-qubit shadow state from individual qubit shadows. + + Parameters: + - trotterstep (int): Integer index of the Trotter steps to apply. + - quantum_program (QuantumProgram): The quantum program to execute. + - backend (Backend): The quantum backend to run the circuits on. + - verbose (bool, optional): If True, prints additional information during execution. Defaults to False. + + Returns: + - list: A list of snapshot from the classical shadow measurement. + """ + snapshots = [] + + # Run the quantum program on the backend + (multi_bit_registers, _, _) = quantum_program.run_registers(backend, [trotterstep]) + + # Process the measurement outcomes to obtain the multi-qubit shadow states + for base_label, bit_registers in multi_bit_registers.items(): + if verbose: + print( + "Processing: Circuit with unitaries", + base_label, + "\nMeasurement:", + len(bit_registers), + ) + + # Construct the post-measurement state in the computational basis |0> or |1> ket + for measurement_outcome in bit_registers: + shadows_per_qb = [] + for qb_idx, single_outcome in enumerate(measurement_outcome): + # Obtain the shadow from the outcome + base_measured = base_label[qb_idx] + unitary_matrix = XYZ_MAP_MATRICES[base_measured] + shadow = get_shadow_from_outcome(single_outcome, unitary_matrix) + + # Insert in front to match little-endian convention + shadows_per_qb.insert(0, shadow) + + # Tensor product to build up the multi-qubit shadow from individual qubit shadows + multi_qubit_shadow = reduce(np.kron, shadows_per_qb) + snapshots.append(multi_qubit_shadow) + + return snapshots + + +def generate_operators(num_qubits: int, locality: int) -> Dict[str, Any]: + """Generate operators with a specified locality that include at least 'locality' number of non-identity Pauli operators. + + Each generated operator is placed in all possible positions across the qubits, with the rest filled with identity operators. + + Parameters: + - num_qubits (int): The total number of qubits in the system. + - locality (int): The number of non-identity Pauli operators that each generated operator must include. + - allow_periodicity (bool): If True, allows operators to wrap around the qubit array, enabling periodic boundary conditions. + + + Returns: + - Dict[str, np.ndarray]: A dictionary where keys are labels representing the operators (e.g., 'XXIY') + and values are the corresponding numpy arrays representing the operators. + """ + assert ( + 1 <= locality <= num_qubits + ), "Locality must be between 1 and the number of qubits" + + combinations = itertools.product(paulis.keys(), repeat=locality) + + position_combinations = list(itertools.combinations(range(num_qubits), locality)) + + operators = {} + for combo in combinations: + for positions in position_combinations: + operator_label = [ + "I" + ] * num_qubits # Initialize operator label with all 'I's + # Place each operator in its respective position + for pos, op in zip(positions, combo): + operator_label[pos] = op + + # Construct the operator based on the label + operator = np.eye(1) # Start with a scalar for Kronecker product + for label in operator_label: + operator = np.kron(operator, paulis.get(label, np.eye(2))) + + operators["".join(operator_label)] = operator + + return operators diff --git a/classic_shadows/quantum_program.json b/classic_shadows/quantum_program.json new file mode 100644 index 0000000..5f53b26 --- /dev/null +++ b/classic_shadows/quantum_program.json @@ -0,0 +1 @@ +"{\"ClassicalRegister\":{\"measurement\":{\"constant_circuit\":{\"definitions\":[],\"operations\":[{\"RotateY\":{\"qubit\":2,\"theta\":3.141592653589793}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"PragmaLoop\":{\"repetitions\":\"number_trottersteps\",\"circuit\":{\"definitions\":[],\"operations\":[{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,0],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,0],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,0],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,0],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,0],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,0],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,0],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,0],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,0],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}}}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2,1],\"execution_time\":0.0}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":1}},\"circuits\":[{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XXX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XXX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XXX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XXX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XXX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XXY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XXY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XXY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XXY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XXY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XXZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XXZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XXZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XXZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XXZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XYX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XYX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XYX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XYX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XYX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XYY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XYY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XYY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XYY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XYY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XYZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XYZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XYZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XYZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XYZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XZX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XZX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XZX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XZX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XZX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XZY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XZY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XZY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XZY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XZY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XZZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XZZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XZZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XZZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XZZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YXX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YXX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YXX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YXX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YXX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YXY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YXY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YXY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YXY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YXY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YXZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YXZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YXZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YXZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YXZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YYX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YYX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YYX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YYX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YYX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YYY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YYY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YYY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YYY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YYY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YYZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YYZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YYZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YYZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YYZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YZX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YZX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YZX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YZX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YZX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YZY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YZY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YZY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YZY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YZY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YZZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YZZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YZZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YZZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YZZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZXX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZXX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZXX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZXX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZXX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZXY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZXY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZXY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZXY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZXY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZXZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZXZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZXZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZXZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZXZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZYX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZYX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZYX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZYX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZYX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZYY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZYY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZYY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZYY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZYY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZYZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZYZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZYZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZYZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZYZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZZX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZZX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZZX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZZX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZZX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZZY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZZY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZZY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZZY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZZY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZZZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZZZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZZZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZZZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZZZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}}]},\"input_parameter_names\":[\"number_trottersteps\"]}}" \ No newline at end of file From 3cde5b77eee66a3a99892ff17897e1f74babe2c8 Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Mon, 23 Sep 2024 12:05:53 +0200 Subject: [PATCH 12/13] reduce shot to 100, added readme section for classic shadows --- README.md | 7 +- classic_shadows/TMB_Example_compact.ipynb | 137 ++++++++++++++++------ classic_shadows/create_quantum_program.py | 4 +- classic_shadows/quantum_program.json | 2 +- 4 files changed, 111 insertions(+), 39 deletions(-) diff --git a/README.md b/README.md index 6df8a01..a22e485 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # NEASQC repo Variational Algorithms -This repository collects Python scripts and Jupyter notebooks that allow the user to test different variational algorithms. +This repository collects Python scripts and Jupyter notebooks that allow the user to test different methods for quantum computing. It contains our custom functions (e.g. VHA ansatz, PBO Hamiltonian) that are built upon Qiskit libraries, as well as method to reduce number of measurement and noise. The repository is organized as follows: @@ -19,8 +19,11 @@ The repository is organized as follows: - *create_conda_env.sh*: script to create a Conda environment with all required libraries - *environment.yml*: Conda environment file - *setup.py*: setup file to install the qiskit_mod library and with unit test recipe to run the unit tests +- **classic_shadows**: a method derived from [Algorithmic Shadow Spectroscopy](https://arxiv.org/abs/2212.11036) for estimating energy gaps using few shots and no ancilla qubits. + - `TMB_Example_compact` is a notebook showcasing the method on a prepared quantum program (`quantum_program.json`). It uses only open-source libraries, specified in the notebook. + - `create_quantum_program.py` is the script creating the quantum program, but in order to run it the user need a free-license from `https://cloud.quantumsimulations.de/` to use the NoiseApp and Struqture. + - `qoqo_shadows` is the local python file that contains helper function built on top of qoqo library to run the classic shadow method. ## Licence - The `LICENCE` file contains the default licence statement as specified in the proposal and partner agreement. ## Building and installing diff --git a/classic_shadows/TMB_Example_compact.ipynb b/classic_shadows/TMB_Example_compact.ipynb index cbfe585..26808e1 100644 --- a/classic_shadows/TMB_Example_compact.ipynb +++ b/classic_shadows/TMB_Example_compact.ipynb @@ -6,13 +6,25 @@ "source": [ "# Notebook Example to use Shadow Measurement\n", "\n", - "This example show how to extract the spectrum from a 1D disordered Heisenber chain with the following hamiltonian:\n", + "This example show how to extract the spectrum of a simplified TMB molecule with the following spin hamiltonian:\n", "\n", "$$\n", "H_S = 3(\\epsilon + J - K) + \\frac{3J_S}{4} - \\frac{J_S}{4}\\left(\\sigma_1\\sigma_2 + \\sigma_1\\sigma_3 + \\sigma_2\\sigma_3\\right)\n", "$$" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Requirements installable via pip:\n", + "- qoqo\n", + "- qoqo-quest\n", + "- ipykernel\n", + "- scipy\n", + "- matplotlib" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -62,12 +74,11 @@ } ], "source": [ - "# Number of qubits\n", - "num_qubits = 3 \n", + "num_qubits = 3 # This has to be the same value as in `create_quantum_program.py`\n", + "trotter_timestep = 10 # This has to be the same value as in `create_quantum_program.py`\n", "\n", - "# Trotter steps\n", + "# Trotter steps to run\n", "max_trotter_step = 200\n", - "trotter_timestep = 10 # This has to be the same value as in `create_quantum_program.py`\n", "\n", "\n", "# Max frequency (Nyquist frequency)\n", @@ -103,7 +114,6 @@ "\n", "2. **Hamiltonian Initialization**:\n", " - The Hamiltonian is built using the `SpinHamiltonianSystem` to represent a **spin-based model** for three spins.\n", - " - A simplified spin Hamiltonian, , is \n", " $$\n", " H_S = 3(\\epsilon + J - K) + \\frac{3J_S}{4} - \\frac{J_S}{4}\\left(\\sigma_1\\sigma_2 + \\sigma_1\\sigma_3 + \\sigma_2\\sigma_3\\right)\n", " $$\n", @@ -119,6 +129,7 @@ " - The **quantum program** is initialized with the Hamiltonian and key parameters like:\n", " - `trotter_timestep`: dictating the timeframe for time evolution. Default value is 10.\n", " - `initialisation`: specifying the initial state of the qubits ([0, 0, 1]).\n", + " - `number_of_measurement`: ~100 per trotter step ( 27 measurement circuits, each with 3 shots)\n", "\n", "5. **Measurement Circuits**:\n", " - Measurement circuits are generated using the **XYZ Shadow Circuit**, targeting **state reconstruction** across Pauli-X, Y, and Z bases for the qubits.\n", @@ -149,6 +160,44 @@ " print(\"Quantum Program Loaded\")" ] }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The quantum program contains one evolution circuit (with a loop of n trotter step):\n", + "RotateY(RotateY { qubit: 2, theta: Float(3.141592653589793) })\n", + "PragmaLoop(PragmaLoop { repetitions: Str(\"number_trottersteps\"), circuit: Circuit { definitions: [], operations: [PragmaStartDecompositionBlock(PragmaStartDecompositionBlock { qubits: [0, 1], reordering_dictionary: {} }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 0, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 0, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 0, theta: Float(1.5707963267948966) }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 1, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 1, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 1, theta: Float(1.5707963267948966) }), CNOT(CNOT { control: 0, target: 1 }), RotateZ(RotateZ { qubit: 1, theta: Float(-0.096275) }), CNOT(CNOT { control: 0, target: 1 }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 1, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 1, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 1, theta: Float(1.5707963267948966) }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 0, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 0, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 0, theta: Float(1.5707963267948966) }), PragmaStopDecompositionBlock(PragmaStopDecompositionBlock { qubits: [0, 1] }), PragmaStartDecompositionBlock(PragmaStartDecompositionBlock { qubits: [0, 2], reordering_dictionary: {} }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 0, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 0, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 0, theta: Float(1.5707963267948966) }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 2, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 2, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 2, theta: Float(1.5707963267948966) }), CNOT(CNOT { control: 0, target: 2 }), RotateZ(RotateZ { qubit: 2, theta: Float(-0.096275) }), CNOT(CNOT { control: 0, target: 2 }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 2, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 2, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 2, theta: Float(1.5707963267948966) }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 0, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 0, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 0, theta: Float(1.5707963267948966) }), PragmaStopDecompositionBlock(PragmaStopDecompositionBlock { qubits: [0, 2] }), PragmaStartDecompositionBlock(PragmaStartDecompositionBlock { qubits: [0, 1], reordering_dictionary: {} }), RotateX(RotateX { qubit: 0, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 1, theta: Float(1.5707963267948966) }), CNOT(CNOT { control: 0, target: 1 }), RotateZ(RotateZ { qubit: 1, theta: Float(-0.096275) }), CNOT(CNOT { control: 0, target: 1 }), RotateX(RotateX { qubit: 1, theta: Float(-1.5707963267948966) }), RotateX(RotateX { qubit: 0, theta: Float(-1.5707963267948966) }), PragmaStopDecompositionBlock(PragmaStopDecompositionBlock { qubits: [0, 1] }), PragmaStartDecompositionBlock(PragmaStartDecompositionBlock { qubits: [0, 2], reordering_dictionary: {} }), RotateX(RotateX { qubit: 0, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 2, theta: Float(1.5707963267948966) }), CNOT(CNOT { control: 0, target: 2 }), RotateZ(RotateZ { qubit: 2, theta: Float(-0.096275) }), CNOT(CNOT { control: 0, target: 2 }), RotateX(RotateX { qubit: 2, theta: Float(-1.5707963267948966) }), RotateX(RotateX { qubit: 0, theta: Float(-1.5707963267948966) }), PragmaStopDecompositionBlock(PragmaStopDecompositionBlock { qubits: [0, 2] }), PragmaStartDecompositionBlock(PragmaStartDecompositionBlock { qubits: [0, 1], reordering_dictionary: {} }), CNOT(CNOT { control: 0, target: 1 }), RotateZ(RotateZ { qubit: 1, theta: Float(-0.096275) }), CNOT(CNOT { control: 0, target: 1 }), PragmaStopDecompositionBlock(PragmaStopDecompositionBlock { qubits: [0, 1] }), PragmaStartDecompositionBlock(PragmaStartDecompositionBlock { qubits: [0, 2], reordering_dictionary: {} }), CNOT(CNOT { control: 0, target: 2 }), RotateZ(RotateZ { qubit: 2, theta: Float(-0.096275) }), CNOT(CNOT { control: 0, target: 2 }), PragmaStopDecompositionBlock(PragmaStopDecompositionBlock { qubits: [0, 2] }), PragmaStartDecompositionBlock(PragmaStartDecompositionBlock { qubits: [1, 2], reordering_dictionary: {} }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 1, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 1, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 1, theta: Float(1.5707963267948966) }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 2, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 2, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 2, theta: Float(1.5707963267948966) }), CNOT(CNOT { control: 1, target: 2 }), RotateZ(RotateZ { qubit: 2, theta: Float(-0.096275) }), CNOT(CNOT { control: 1, target: 2 }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 2, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 2, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 2, theta: Float(1.5707963267948966) }), PragmaGlobalPhase(PragmaGlobalPhase { phase: Float(1.5707963267948966) }), RotateZ(RotateZ { qubit: 1, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 1, theta: Float(1.5707963267948968) }), RotateZ(RotateZ { qubit: 1, theta: Float(1.5707963267948966) }), PragmaStopDecompositionBlock(PragmaStopDecompositionBlock { qubits: [1, 2] }), PragmaStartDecompositionBlock(PragmaStartDecompositionBlock { qubits: [1, 2], reordering_dictionary: {} }), RotateX(RotateX { qubit: 1, theta: Float(1.5707963267948966) }), RotateX(RotateX { qubit: 2, theta: Float(1.5707963267948966) }), CNOT(CNOT { control: 1, target: 2 }), RotateZ(RotateZ { qubit: 2, theta: Float(-0.096275) }), CNOT(CNOT { control: 1, target: 2 }), RotateX(RotateX { qubit: 2, theta: Float(-1.5707963267948966) }), RotateX(RotateX { qubit: 1, theta: Float(-1.5707963267948966) }), PragmaStopDecompositionBlock(PragmaStopDecompositionBlock { qubits: [1, 2] }), PragmaStartDecompositionBlock(PragmaStartDecompositionBlock { qubits: [1, 2], reordering_dictionary: {} }), CNOT(CNOT { control: 1, target: 2 }), RotateZ(RotateZ { qubit: 2, theta: Float(-0.096275) }), CNOT(CNOT { control: 1, target: 2 }), PragmaStopDecompositionBlock(PragmaStopDecompositionBlock { qubits: [1, 2] })], _roqoqo_version: RoqoqoVersion } })\n", + "\n" + ] + } + ], + "source": [ + "print(\"The quantum program contains one evolution circuit (with a loop of n trotter step):\")\n", + "print(quantum_program.measurement().constant_circuit())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "And the quantum program contains 27 measurement circuits\n" + ] + } + ], + "source": [ + "print(\"And the quantum program contains\", len(quantum_program.measurement().circuits()),\"measurement circuits\")" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -160,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -168,17 +217,20 @@ "output_type": "stream", "text": [ "Running for trotter steps:\n", - "1, " + "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, " ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50\n", - "51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100\n", - "101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150\n", - "151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200\n" + "13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30\n", + "31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60\n", + "61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90\n", + "91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120\n", + "121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150\n", + "151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180\n", + "181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, " ] } ], @@ -186,7 +238,7 @@ "evolution_snapshot = {}\n", "print(\"Running for trotter steps:\")\n", "for trotterstep in range(1, max_trotter_step+1):\n", - " print(trotterstep, end='\\n' if trotterstep % 50 == 0 else ', ')\n", + " print(trotterstep, end='\\n' if trotterstep % 30 == 0 else ', ')\n", " all_shadows = measure_and_process_circuit(trotterstep,\n", " quantum_program,\n", " backend,\n", @@ -214,7 +266,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -223,15 +275,14 @@ "text": [ "Generated 9 operators for 3 qubits with locality 1.\n", "Generated 27 operators for 3 qubits with locality 2.\n", - "Generated 27 operators for 3 qubits with locality 3.\n", - "Total number of operators to measure: 63\n", - "XII,IXI,IIX,YII,IYI,IIY,ZII,IZI,IIZ,XXI,XIX,IXX,XYI,XIY,IXY,XZI,XIZ,IXZ,YXI,YIX,IYX,YYI,YIY,IYY,YZI,YIZ,IYZ,ZXI,ZIX,IZX,ZYI,ZIY,IZY,ZZI,ZIZ,IZZ,XXX,XXY,XXZ,XYX,XYY,XYZ,XZX,XZY,XZZ,YXX,YXY,YXZ,YYX,YYY,YYZ,YZX,YZY,YZZ,ZXX,ZXY,ZXZ,ZYX,ZYY,ZYZ,ZZX,ZZY,ZZZ," + "Total number of operators to measure: 36\n", + "XII,IXI,IIX,YII,IYI,IIY,ZII,IZI,IIZ,XXI,XIX,IXX,XYI,XIY,IXY,XZI,XIZ,IXZ,YXI,YIX,IYX,YYI,YIY,IYY,YZI,YIZ,IYZ,ZXI,ZIX,IZX,ZYI,ZIY,IZY,ZZI,ZIZ,IZZ," ] } ], "source": [ "# Pick max locality \n", - "locality = 3\n", + "locality = 2\n", "assert locality <= num_qubits, \"locality should be less than or equal to the number of qubits\"\n", "\n", "operators_dict = {}\n", @@ -267,7 +318,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -296,7 +347,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -335,19 +386,39 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<>:7: SyntaxWarning: invalid escape sequence '\\l'\n", + "<>:8: SyntaxWarning: invalid escape sequence '\\l'\n", + "<>:14: SyntaxWarning: invalid escape sequence '\\l'\n", + "<>:15: SyntaxWarning: invalid escape sequence '\\l'\n", + "<>:7: SyntaxWarning: invalid escape sequence '\\l'\n", + "<>:8: SyntaxWarning: invalid escape sequence '\\l'\n", + "<>:14: SyntaxWarning: invalid escape sequence '\\l'\n", + "<>:15: SyntaxWarning: invalid escape sequence '\\l'\n", + "/tmp/ipykernel_433773/3904856626.py:7: SyntaxWarning: invalid escape sequence '\\l'\n", + " ax1.set_ylabel('Time Index $n \\leq N_T$')\n", + "/tmp/ipykernel_433773/3904856626.py:8: SyntaxWarning: invalid escape sequence '\\l'\n", + " ax1.set_xlabel('Observable Index $k \\leq N_O$')\n", + "/tmp/ipykernel_433773/3904856626.py:14: SyntaxWarning: invalid escape sequence '\\l'\n", + " ax2.set_xlabel('Time Index $n \\leq N_T$')\n", + "/tmp/ipykernel_433773/3904856626.py:15: SyntaxWarning: invalid escape sequence '\\l'\n", + " ax2.set_ylabel('Time Index $n \\leq N_T$')\n" + ] + }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABBQAAAGoCAYAAAD2L7Y1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOy9d7hlyVUdvuvm9HLqHKZ7ch5ppFGWhqCAhJBNxggwGQzGmGBjfgZsY2MMGLABW2QBIlgIhCQEKIzCKIxmJI0mh87p5XhzrN8ftdZ5fW7vepqe6TBzu9b39ff61j33nMqnqvbaaxtrrQQEBAQEBAQEBAQEBAQEBAScDxKXOwMBAQEBAQEBAQEBAQEBAQEvPIQDhYCAgICAgICAgICAgICAgPNGOFAICAgICAgICAgICAgICAg4b4QDhYCAgICAgICAgICAgICAgPNGOFAICAgICAgICAgICAgICAg4b4QDhYCAgICAgICAgICAgICAgPNGOFAICAi45DDG/Igx5mPGmGPGmEfw/x+/3PkKCAgICAgIeGEgrCUCAp4fMNbay52HgICAKxTGmN8Tkd+11t53ufMSEBAQEBAQ8MJDWEsEBFxeBIZCQEDAOTDGPGqMee0leNQNIvLYJXhOQEBAQEDACxqX8N38QkNYSwQEXEaEA4WAgGcIUOrqxpiyMWbNGPNpY8wPGGOe0TjC77/yOT6/ZYyZ7Ev/ojHGGmP2Xah8WGtvtNZ+7Fnmcwz5qeDfCWPMu40xNymXD1lry8/mOQEBAQEBAZcCxphvNcY8gHfarDHmg8aYV17qfDyXd/PFgjFmyBjzX40xh7A+OmqM+d/GmKnneN9nvZY4z98GBAQ8R4QDhYCA88NbrLVDIrJXRH5JRH5aRH7/Ej7/qIh8Cz8YY24WkcKFurkxJnUBbnObiCxba0vW2pKI3C4iXxKR+4wx1531rN0icvICPC8gICAgIOCiAD75vy4i/1VEZkRkj4j8toi89RLm4UK8my84jDGjIvJJEblORN6I9dGrRCQtbp30XHCbPPu1xDP6bUBAwIVBOFAICHgWsNauW2v/TkS+SUS+g6fexph/Z4w5jFP6x4wxb0P6n4hbhLwPp+U/tdX1W+BPROTtZ33+DhF559kXbHVPLR9gLPy0MeYhEakaY1JnsxiMMQeMMSvGmDvweYcxZnEL2uVt4l7crKtla+1/FpEviMh3n3XdjSLy6Jcpb0BAQEBAwGWBMWZERP6TiPywtfY91tqqtbZtrX2ftfYncc31EANcg0vC1yL9p40x7+67328YY34T/9/y/f8M3s1bveuPGWN+whjzkDFm3Rjzl8aY3Fnf7zbGvAfv8mVjzP8+67sdxpi/xndHjTE/ukUV/U8RWRGRr7fWPi0iYq09Za39fmvtA8+mzs/CbfLs1xLP9LcBAQEXAOFAISDgOcBa+zkROSXuRF5E5DD+PyIivyAif2qM2W6t/XYROSGO4VCy1v7yVtdv8cjPisgwFjBJEflmEfnTvmu899wiH98iIl8jIqPW2k5fGQ+LY2L8qTGmICJ/KCJ/vAXt8nYReVBJf0JEdp71+UYJPo8BAQEBAc9fvExEciLyN9qXxpi0iLxPRP5JRKZF5EdE5M+MMdeKyF+IyJuMMUO4Niki3ygi78LPn8n73/tufga//0YReYOI7BeRW0TkO8/Kx/tF5LiI7BP3Xv4LfJdAeb6E9K8QkR8zxrxeKftuEfl2EfkP1tqeVj9nXft+HLho/97v+dlzWUs8098GBARcAIQDhYCA544zIjIuImKt/X/W2jPW2p619i9F5GkReYnvh+d7PUCWwleJyOMicvoC3PM3rbUnrbV1Tz5/V0QOich9IrJdRP7DFve6TfQX+YiILJ51z1+11v7hl8lXQEBAQEDA5cKEiCwpm3niLhEpicgvWWtb1tqPitusf4u19rg4iziZA3eLSM1a+1mRZ/yu9r6bn8HvfxPfr4g7JLgN6S8RkR0i8pNgXDSstffiuztFZMpa+59QniMi8rvijBf9+EoRWbTWfsZTN2fn9c3W2lHPvzd7fnabPPu1xDP6bUBAwIVBOFAICHju2CmO8ifGmLcbYx7kybuI3CQik74fnu/1wJ+IyLeKsza8s//LZ3nPZ6Jl8Lu41/+y1ja1C4wxWRG5Xs6iGiI9KSIvF5GPP4PnBAQEBAQEPB+wLCKTW2gY7BCRk30W+uOyaQV/l2zqHn2rbLITnum72vtufga/nzvr/zVxBx8iIrtF5LjnkGSviOw4m0EgIj8jTjuiHzPiGI8XHM9lLRHWIQEBlx7hQCEg4DnAGHOnuIXDvcaYveI23f9KRCastaMi8oiIGFxu+3775a5XAavHURF5k4i851ncM5aPLdLOvm9JnCjV74vIzxtjxj2X3iQiXXHMibPxAyLSEmclCQgICAgIeCHgMyLSFJGv83x/RkR2m3i0pz2yyRz8fyLyWmPMLnFMhXeJnNf7X303P9v1A3BSRPZ4DklOisjRPgbBkLX2Tcq1J0Rkp3kGka6Mi4pR8fz7oPKT57KWCOuQgIBLjHCgEBDwLGCMGTbGvFmc3+GfWmsfFpGiuJf/Iq75LnEvNmJeRK466/OXu34rfLeI3G2trfalP5N79ufjmeA3ROQBa+33iMgHROT/eK67XUQes9a28fzdxpj/Is6/85uZHhAQEBAQ8HyHtXZdRP6jiPyWMebrjDEFY0zaGPNGY8wvi3MDrInITyH9tSLyFoEmgbV2UUQ+Jk576Ki1lpvc5/L+f66//5yIzIrILxljisaYnDHmFWd9V4YYZN4YkzTG3ATjST+offBLxphh5OMa44QnY0wLa+0bGXFB+fdG5d7PZS0R1iEBAZcY4UAhIOD88D5jTFncKf5/EJFfE5HvEhGx1j4mIr8qzqIxLyI3i8inzvrtfxORnwWN8CeewfVeWGsPawrKz/CesXx8uWcZY94qTtjpB5H04yJyhzHm25TLbxORW4xTnV4VkQ+LyJiIvBgClgEBAQEBAS8YWGt/Vdx772fFbeBPimMG/K21tiXuAOGNIrIkLpzk2621T5x1i3eJ0xt411n3fNbv/+f6e2ttF3k+KI5lcEpcxCp+92Zx7/KjKNPvidMe6L/PhjhdiGtE5Gm4R/yNiFSttUvPtCwe3CbPfi3xXH4bEBDwLGCs3ZLpHBAQEBAQEBAQEBAQEBAQEHAOAkMhICAgICAgICAgICAgICDgvBEOFAICAgICAgICAgICAgICAs4b4UAhICAgICAgICAgICAgICDgvBEOFAICAgICAgICAgICAgICAs4b4UAhICAgICAgICAgICAgICDgvBEOFAICAgICAgICAgICAgICAs4b4UAhICAgICAgICAgICAgICDgvDGQBwrGmDcYY540xhwyxvy7y52fiwVjzB8YYxaMMY+clTZujPmQMeZp/B27nHm8GDDG7DbG3GOMecwY86gx5l8jfaDLbozJGWM+Z4z5Esr9C0jfb4y5D/39L40xmcud14sBY0zSGPNFY8z78Xngy22MOWaMedgY86Ax5gGkDXQ/J4wxo8aYdxtjnjDGPG6MedmVUvaAS4MrZa3wfMOVPK9dbpzPutE4/CbGx0PGmDsuX84HB542+HljzGmMiQeNMW8667t/jzZ40hjz+suT64CArTFwBwrGmKSI/JaIvFFEbhCRbzHG3HB5c3XR8Eci8oa+tH8nIh+x1l4tIh/B50FDR0T+rbX2BhG5S0R+GG086GVvisjd1tpbReQ2EXmDMeYuEfnvIvI/rbUHRWRVRL778mXxouJfi8jjZ32+Usr9OmvtbdbaF+PzoPdz4jdE5B+stdeJyK3i2v5KKXvARcYVtlZ4PuJKndcuN/5Invm68Y0icjX+fZ+I/M4lyuOg44/k3DYQceuZ2/Dv70VEMCd9s4jciN/8NuaugIDnFQbuQEFEXiIih6y1R6y1LRH5CxF562XO00WBtfYTIrLSl/xWEflj/P+PReTrLmWeLgWstbPW2i/g/2VxG42dMuBltw4VfEzjnxWRu0Xk3UgfuHKLiBhjdonI14jI7+GzkSug3B4MdD8XETHGjIjIq0Xk90VErLUta+2aXAFlD7hkuGLWCi8QhLF9CXCe68a3isg7sfb4rIiMGmO2X5KMDjA8beDDW0XkL6y1TWvtURE5JG7uCgh4XmEQDxR2isjJsz6fQtqVghlr7Sz+PyciM5czMxcbxph9InK7iNwnV0DZQft/UEQWRORDInJYRNastR1cMqj9/ddF5KdEpIfPE3JllNuKyD8ZYz5vjPk+pA18PxeR/SKyKCJ/CDeX3zPGFOXKKHvApcGVvla4nLhS57XnK3x1H8bIpcW/gmvJH5zl8hPaIOAFgUE8UAgArLVW3It7IGGMKYnIX4vIj1lrN87+blDLbq3tWmtvE5Fd4k6pr7u8Obr4MMa8WUQWrLWfv9x5uQx4pbX2DnHU0x82xrz67C8HtZ+LSEpE7hCR37HW3i4iVemjQA9w2QMCBh1X6rz2vEeo+8uG3xGRA+LcWWdF5Fcva24CAs4Tg3igcFpEdp/1eRfSrhTMk5KGvwuXOT8XBcaYtLjDhD+z1r4HyVdE2UVEQP++R0ReJo6GmMJXg9jfXyEiX2uMOSaOlny3OP/6QS+3WGtP4++CiPyNuEOkK6GfnxKRU9ba+/D53eIOGK6EsgdcGlzpa4XLhit4Xnu+wlf3YYxcIlhr52Ew6onI78qmW0Nog4AXBAbxQOF+EbkaCvAZcWImf3eZ83Qp8Xci8h34/3eIyHsvY14uCuA///si8ri19tfO+mqgy26MmTLGjOL/eRH5KnH6EfeIyNfjsoErt7X231trd1lr94kbzx+11n6bDHi5jTFFY8wQ/y8iXy0ij8iA93MREWvtnIicNMZci6SvEJHH5Aooe8Alw5W+VrgsuJLntecxfHX/dyLydkR7uEtE1s9yjQi4gOjTpnibuDEh4trgm40xWWPMfnECmZ+71PkLCPhyMI7dNFhAuJVfF5GkiPyBtfYXL2+OLg6MMX8uIq8VkUkRmReRnxORvxWRvxKRPSJyXES+0Vr7TMVfXhAwxrxSRD4pIg/Lpk/9z4jTURjYshtjbhEnmJQUdxj4V9ba/2SMuUqc5X5cRL4oIv/CWtu8fDm9eDDGvFZEfsJa++ZBLzfK9zf4mBKRd1lrf9EYMyED3M8JY8xt4kQ4MyJyRES+S9DvZcDLHnBpcKWsFZ5PuNLntcuN81k3wnjzv8VFF6iJyHdZax+4DNkeKHja4LXi3B2siBwTke/n4Y0x5j+IyL8UF+Hsx6y1H7zUeQ4I+HIYyAOFgICAgICAgICAgICAgICAi4tBdHkICAgICAgICAgICAgICAi4yAgHCgEBAQEBAQEBAQEBAQEBAeeNcKAQEBAQEBAQEBAQEBAQEBBw3ggHCgEBAQEBAQEBAQEBAQEBAeeNgT1QMMZ83+XOw+VAKPeVhyu17KHcVxau1HIHXFyEfvX8QGiH5wdCOzw/ENoh4IWGgT1QEJErdTCGcl95uFLLHsp9ZeFKLXfAxUXoV88PhHZ4fiC0w/MDoR0CXlAY5AOFgICAgICAgICAgICAgIArDsaYPzDGLBhjHjkrbdwY8yFjzNP4O4Z0Y4z5TWPMIWPMQ8aYO57xc6y1FyP/lwXJoaJNTY6JiEi3XJXkUHHL61Pprvc7u55S02emVtX0cjenplfW8/5nZM6v7pPpnpqeMJvp7fW6pEfcM9v1tP9euY6abjzXj2dravpGWy+3iEizklHTrecYK9n03krF9PRa9P/yaluGxjbLO1sePa97JVp6erqi17mISHvG037VpJpsC/q9bNNXIf7+YTqbLdWtViVZdH3dV7cmc57PFvF3Bk8/HMvX1fTVim8c+suXWdPTu5nNTHUaVUnl3L3T43oDNpr+MZDLtvXf1PV+60NSL7ZYvRu47zzV7vvN2e3X3ahKctiV29T87dfzzC9n951Yumc6TFf19m5Nex8t6WX9Ga1hT6fydYWzLu9WqpIsndWXnsFvYs8+eWrJWjvl+dVzxutfV7TLK/53yjPF5x9q/qO19g0XIEsBXwbJYtEmMllJFjCe0NUt+xCHF9IN+lyio6fzd8mm+6KbTUiiE++oNuEuMl2XzjHfSxv12T1OYX3PPmeu6BumvI5/e0k+3/1NNZnpeBmkxwR8TCWiZzFvCXTzbiaeF84hfEZ/HqP67Zu2ki2RTn1zPjf99d1wCRZ1FI19s/V9eymDv2d9Z+J/mef+eo6WVcwDy9b3u6hsNp6eaPE/aNe+du/mEn3PsbHrNusfXyfPqs+oj+ChXf7G4tl9k2BfGyfR9r2k6cu7lXarKplUIZYXm4znnfVquUy28bwyf1G/4HhJnNW/Tfy3if4lKeqF9S5R3tnYTHD1GLVLL96vu9l4p+hm8XXO3ce04t9brrt67Ox8Dv52ElF52HaJvs/9eUg0OBjjfYGfO+gLbJduzkinXpUE9jBsn142ft/NTHvGRVf/nGxstk2yEa/PKO8m3va8N/PO+Srqn+l4VlhfXG/YtPucTLlMdFt9eyzUc6KulyVVw/hA30s2upt9gHlNYUxh7HULKeRZkGf85ThK9Y8f92dqeENERE4/ujEQawZjzKtFpCIi77TW3oS0XxaRFWvtLxlj/p2IjFlrf9oY8yYR+REReZOIvFREfsNa+9Jnkg991/wCRaY0Lvu+7cfPSS+8fEm9/s27H1HTRUTe9XevUdNvfu3Tavrjf3+Nmj6j71lERKR+h75Jt12jpvc6+ubBJPpnF4fEon9jVDi4rqb7NlNvuPoxNf39n3qR9xljV62o6RuPTajpQ8f0+3Di6seLvvUh77M/fuSg/oXV7zX0Gf3g58A3PeV9xpc+c7X+CE97JJv6s1NVPX3iNbPeZ588Pqmm//Qr/15N/x//+BY1Pb3h35Ce84IHcncuq+ndj+rt+j9+8C/V9P/y0Ju8z54ZKavpx0/q5d69S8/T7PKI9xl7pvX+eezhHWp6Zt0z/m7aUNMT9w97n90e0vtIz3P+0ZnSJ5LCIf8Yb92kzy9ySu/r+Tm9HxZn9QOFtWv9fWfqQb3zzN6ln5j0djb09Jr/FTW6Te8j6yf0Nj/+r37yuPdmFwBLK1257x93Pef7pLcf1jt5wAVHemxcdv3ov4k+t4fd4i5Vcf2UG4d02Y2N/KIbt41J97l42n3m5jy75n7QLrrfZ9Y70SJ1Y48bq6Z/OOH7xrj7D20Tvb6h3cUBYaLNxbP73C7h2StuPGb6piNuIvJL7sHJlrueh+WJFg4/8jwFkNjfXsZIAr9ZP+AmKC7uO7l4nhvT/BFu0bfhPGeTgM1DAsaE4hkby2M3i3pfcoXIrLmDY256EnVX3/VdbuPVKrky5Jdd+uzLXSUm65v1Xt+GjWQnvolIbxiUwT2L9ZxsoIwZ5tF9TlfYHkif6+C+7v7tYVf4zLpLb465z6yz0Ser7nPJ1enKdW6n25iIb9a7OdRFxkqq5r7j+4PPTrAsKGNnxP2ndNj1w9yKuz636srWQVuPPrSC62GEGnGFTFXaeLb7faruflfd6Rq6MYp2w/hYvd79za6gDqeQkam4lahXTUui4Z6dXcJBADe2uDSNaT1TZh9wn4ePurbPrKMP1F0ebd7VX2sM9ddXzx13NiL1qfjhCY1IzGt3KH5ilFp3GevmeUrg/hRPJCWFVyvHwdBJd7MOxn3pKWd4XLnDrYmGTrjCJSvuul7e5bGy29V7fcLVRXHe5WH9gLtPbXsPz4lvsjk3dMZcA2Tm3f3aY7geaxWWdfRJ97eL9UVufXMSKsy6vJkuDu2wOa+hrUtHKyIiUt1bct9jmmCeqzswRudd+vp1XdwP9Y1HdUdcXhMbLq9cD/N7jjMakzi+xp5yFhvTxty85DpIe/uoJMtu3WDTaKuSq5jWkCso5w/OCx0sfToFl145gDYvury98lq3v7v3cze49B/9iYFYM1hrP2GM2deX/FYReS3+/8ci8jER+Wmkv9M6tsFnjTGjxpjt1lr/hgQILg8BAQEBAQEBAQEBAQEBAS8sTBpjHjjr3zPR35g565BgTkRm8P+dInLyrOtOIe3LYqAYCr2sldr+cy15k/93VL3+vd97s/denaJuQXz0wzoTgQymfqR0w5uIiOTzOk2719Nv1vLQt33Xb0W5rlZ0VwUfO6LayerX57ag67xPt1hf9VBVTT/9mpL+DE85nlzzc65zOY9FN6vXuVnX68PX3iIivRHdctsr6nXyhtfojIoPfPEWNb12Sq8/EZHUmj50v1jZo6Zf9+un1fRj37rb+wwfChm9blc8ng1/cPIVanq77e+g5aZuec8f09PXJvT2S2c8NAsRObU8qqb3Cnr7dbfrFv/2mv7snD5kRESkU/Dw9X1HvJ7LffOUiEinrM8XQx4mQmFe78/1SU+mbtQZAiIirUN6Z+iMeOaLpt4X0qv+V9SrXnRYTX//iWfs8neBYaVr/S5SAc8/2KRIZ6gnybLr4wm4gHVBLU7AWkcLb3HO9d8eLGK0pNMamsrAQj7vXvymZ2X9oDOR0pobuQmga2fX6PoQt9jl5116eR9+B0s1XSgyq+5ZrckO8gwLH8iHaVhPKzsT+Bzvm8kGLImgDfc6tOgmY8/pZkyUN1r4WkOgO2OOI8OgU4hbc0lzzsKC2tzWjn3OrMbrgqBrFOsmu9JEHaRieU5WmrGyR+1QpZ+Hq2ybEGmNoDzjLg+ZM7DGX+coHal7HbOpAzcyE7+FFE+BsQA2ShJru/xKB2VPxNKzq22kgyWw5D7Xp9y8XNvhKrO8Cxb1fLwucovu78YBUr1tRDdPgtmRW6I12dU7GYdpsFXYb9lPyfbMrdBvBnUCi3n+pKuL9RtG3ffo/62u+35jn7svLfSNCZbV/a3vArsD1ubco65QEWOh0JPcPBgKa+zP7iuyLTaZIC3kDWyfNVjSYaluTxZQb+77iJqPP80x95/S6S4+w+q/2z0wtcHf4WdZ5LEMmnwq7j6SZ75XbTS2IneiLNsebAcwPljviaa7sLovvsZtII8dJK+D4cC+yjywb5CJ0i2CXVR219PtIFnB/LMYZ6z0cJ8sWB/5xVbE7ukWwDpCHumeUTrm6q18lctceY971tSDrh3W92VjdRCt0/E3u+Dy0hwHMwpu5KxP5rl4Os5ySrTBoKrT/YM3ZHu5cdpLJ8QOux+1h+NrHbrmtEruN2RR0H2mPo2KKblO97U3ubX53z18a6xMFx8XbM2wZK198bPOhbXWmMjp7VljoA4UxMqmL8xZOP1qfbH6Ewfv9d7qtz75VjW9ManX+Yte+aSa/vQ7r/U+I5XQO5Lx+M43fQcKDb18ZguNBuv5jXgOJ9Z9WglbcFyqOz2nLMaz2fBsjnz+5stlv0bGaEnf/KU9dd5t6s/u+iUwpFfybI481f6hf9A3OsMrej1tf4ufbTV+nV6+e//2djU9/bX6fZ7NxJlPe7QHpvW6XfygTuma/IoF7zPW7tcPi1IeF6JaVe+fuzyaJyIix0/rBzbRwqIP2S/oB15mWG/wTun85+cdn9B/c+ZtnkOOjF8jojStH9w1VnSXgKFT+n1I6+zHVpIn5d0+XRC9HG+57Utq+vvu1/uziMhcw+9ScjlgRaS3hS5IwPMPpuvowXQ7o9wBF70p6KPQFamBTUm00V13/bk+SRcH0LDT2OyXUjL6hKMML98y5NJGSKV392wNIS+YdprjWAyPus/cVPQLNXTz8c+kmzfxu3bJfR46ic0H3nGNcZfX4iH3DukOu41Bb5juDF08F/T6QlLaxfiBAt8b7SFkGmWIXOjwSmtNuHu1xt3f9LJbcnIjHLljzCGPaIC2jd8nWXWbS9ZrY8LtOrtZ9+AUdF6qM65sK9cxo6iis6cj+MxH1O2ye3ewKDxMSsHlIQs9mHQ1vonMboCCXeMhE64ruwtIb+/k3Ma3tg3uF9hksi9F/t3YSFOTh5t1mXYzrW0kxdZx8IX3YGsUh0vr8UMQ9oX8UieWt9ySyxM3uN0hV3YeerQPundDBmVrjOPgp86NMevI/eUmsr7bZSi9Auo9XPTqCfc5VUF7t5PR2OnkcQBWpu++u9fY0+4htRlXIdTw6RbRP9fotpFE3tEnRvv6DPp7cwSHhDyQwyayg3GVQp67oOInJuBa8bjrQ61R9/zmBDa6ZZEODrAKqKfCIbfOqO8bdVloomObPjeLdtyVJ41XdAOE9STsXfTMTeGgswsDRKSLxIMC6EAUT6MMffaW4RPd2PO40TbtXuTiEGl94LvmNreu7mAznmrgN7isut21Q3SAgCy1+DqG+0ALbjE9HDKWjqRwnftBYTF+gJqu4OcwbEQHnZiHeNjVK7rO182nJIV63phwbZXgQQIOPOvT8bV1tLLb7vrYHXucIf7vHoFRr4p69K3tLzAu85phnq4MxpjtIsIF+WkROdvSuAtpXxbB5SEgICAgICAgICAgICAgYPDxdyLyHfj/d4jIe89KfzuiPdwlIuvPRD9BZMAYCsmGkZHHzi0SxYj68d8n3ui917Uf1kUL124cUtNTr/KwDbY46EolPZR5z4HVyJBulV5te1wFPCKOIpvCKOf8xsNq+PxT+9T00lN+CynFcPox8bCnHDeeJwtizvMAERm5URfcK7d0HrrxVbo31IFI7oxe9pRuGBbzCt1a7nvycMbvL1PxuKDsfa8uTrjyP/SOWP9Hv9uIz9UkeY6qmMM3vPqzavqn5q9S00sZv417frtORUic1Ou866H3r5f8UUiMR/CvcFIveOmkJ1KGp57mX+Gnsk3t0fvCqdyYmu4bAt1hP8Wk29V/5ctvvxo9sfwK/Rk3Ty96n/3YuD4n+YbTR0/orkWFE/5X1KMnPOyvHZfGuqCh1y+1H/C8hs30pLe3IYmHnYWL4mVr14AqDksvRQlpARx7zLn7NKbdO6iw4MZIetlN/u0JZ+XrpY20xt0clN2IhyLowOpf206RP/c11wytSbgk5N29s4fdfVqgEGfgupTue5ePPQUL4bB7ztBRl6dNPWLMiSladFFGWE8bE+5+dJFojRipT8E6W6Xlz33XG4UoHN6FZHIUIFzYwnSWhBsBxS1Jd6Z+caQUnyAln1ZoCBTCxSQBi2Qbomp1WNCzEJmjlTRRYLuhiN1NBiSZW73jo+7LfbDiZ9w71Y65d48p00LuLht7wlEH1g+4vpKqg8oN6ni2DUG8MhgFKSr3s91dGWhJr20DAwQW2/7IAWTNWLBGUyvpyMqehbsL2Qyc08kmG3/C5aG8x5Vp+AiE7VDf7WFXtsyyW2Nkl9311V18X7r7V3bTxQF53hFnabTgwpJahgge8mdqFDWFdXlh0xo9/oR75vr+OGW+3yUnu+q+yM26gUHhyF4WLiJF5AkueaSzs83pNpOG1TqzBpbNAp4L5keqirxjOdlbgysM6jbZigv6ZTd60VhpIw+9EsuCMbTD3Sy7gr4EAcn6hHsv5lfIHMA8A4FCWu/b210hkksuLz28502ZA8X9oXgs23/oBNgUoxRohUjsENgciCaRWq1Jc8cw8oB5YMw9qw3GB0Vbl29i+Ab3Z/Va5HUK7TPn8tTYBbFMWvkhchlF0UDzZlfBTNkgAwFlQX33C1TWJzHGF1w+Kntd3abL3ej/nJc7YDOs3kT2hYn95Rz4X+98j4iI/Mz9/8x9DwH7whn37Pr0pbO1X4o1gzHmz8UJME4aY06JyM+JyC+JyF8ZY75bRI6LyDfi8r8XF+HhkIjUROS7nulzBupAISAgICAg4HLAipXuAIVhDggICAgICLg4uFRrBmvtt3i++grlWisiP/xsnjNQBwrdrEh5/7mnPWXdQCrDX/KHXFu5Rbd4Lt2tW1VXP3q9ml7a4qDLZ0H0aWOsnRjVbzSkW3NNfyzis5DwxKIXz29sQ0/vvMQvzGYf09kcT7/dwxLI6ZZQ69F1yJ7ysyOWa7q+QjZ1fqIBPNXW0Pb4yFeu0i2k2S/p1ufu1TpjY+2n/OFkVq7X2Rm1t+n5bT+s5zX/LGYA6wm9+VcP3Hle9ymMe8IaikjO07b1fbqoZnJFv/7AjXrIWBGRhx7V26N2nT7Gm+P6fBGFdOpHwm8p775Xj/KT3qdf3z5PsUYRv1hrd5tePpvQ6zBd0Ov84cd1AVARvw4FRaT6US/rc8Xtb/KHbZ3/tQNq+mk96uclQdBQeIGhZ6TbSEYiaE1MCYVZWLYoGEfhMQyp2m73fqGlkrpatX0juJ6MhoQ0Rl2fL8zDWggLIK1qtEyX91FHIJ5F6h0xVGAGgnu0bNPqz7B7ZCak4Pfege85rf8piDG2xyBoVowLHRIbuzdjuEdicH1TYBKW6dYMmAqwVtKSnVmm5gR1HmCBhb4DRS4J+u6nyxBvBHuiOZmP8iKyqWdAbYfGOCyyWI6wLiOL44yNLP6tR1wbtfa5Z4ze69py/Vr4wz+RRR7cvdiWLVhwC4sd5IUilq4OaAVujWaQJ/eZlncKRjZH4/oRkT88pl+Gz6MmUfaQayebFOkWGNrPXUshO7Io2HcaE+5m1HnoFvCi78X1CioHSngm9ATwd2Ovu754xl24sR8sAFr/t8FiDiZCeh2Mkd0QZQSjIbMe1xDoZkUWbneZHj4OscQRalqYeN7BUGiPx8UXe/ie9RmJOeZp5Xef21gCVnfFWRXU+WCf4bjKoq/m5ygG6K7PLVHDRPA8K4W5Fn6L/o6wpWxTMgSGjruHLr/YTSwUiqxPUfgRt+b8gj5gKu4LaiaQAURdpjQ0M7g+pR4L2y9/CIKWOWpuuPShObfmak+WJIHwphSzLO+MayNEIrJYrnM8RNpQ6ENtMH/ITGAo2FQVwrVk0ZCJACYWWUUc8wy5mcJ4SbT5vWvg1hQYKshvayQlLYx/akRw/s6fScbyShZE6TrHDP0P7/lW5CEu1kiGT3aLdf+FxiCtGYKGQkBAQEBAQEBAQEBAQEBAwHljoBgKybrI2GPnniyl3qb7+lbm/P7jS7frVjmfLkF72KOHkPaHxmt39e98lsVE03NqVtct/lv5V6eWPJEhPEZVnuSdc5/HPL7SIrJ6o14nuTN6t+vduEWMTe0+S36GScfD/mh5tAfyWb18VFHWUDjtYXOk9Lq95rVH1PRHjuohXmdf7o872PYwQzKeMImtw7qyP9WfNXiICNLs6u1HteR+ZD1RLLKv9IRsEJH0Eb3vNCc8z1jVn/Hkkn+MpyseNkdT7ztD1+m6HL0P6dEietf7NSJWX6kPtERKL7dvot7qbLu5rIcoGXpav1vLE2VlfFhnknztDfd5n/23J/VQqIuzej+c3LbhvZcPqR+a0794Ytt53+tCwIpId4CsDVcCTNtI9lRm0xK4Flf0J4ZOIXpDglZmhjJzf+ivPXTCXdcYo+lxU3G8DUt2B5ZTWvt78KMuHYfFFK9UMhGo/k8zL0NR05K96YMMtgQtqbCsV3fAJxzWyzYsubS49r/za1Pwz6duRMJIZk1ieWeEI5MFo+CMq4hMmVZmWIURdYuW7to2d2+GqGV90orfHE3F0mlhZV6prh+puE/y94J095dW6Po0NQdMFLowgegNCVjXK7vdNcOHYG2vxNkP2XVYOfGu5NuBKvm9DBknJnbd0Ak3/68dzKJO4tbkLtq5jbCfudPQoWD0gWqcyZBsitiEe9bEY2BJ0FoLKiwZCYzoka656xpg11Erir709SlqJMTV8RvT/ByPiEGLbwLW594QmAq9fs0EWtBxPV71vZSRkWMI24g2L8y6CinvpY6JexdU97nGTJeh5L+XehksAxkJ0CLZgfbgeDrGeJCIuBKF+UafmXN1wrUDihBFN+F4Yt/MlBF9oNOT1qhrq/wpRw3pQpOivAsRU9AuS7fEw0eSPcH5JpoDEK0h6lyMvtrl9e5vfi7OFBk9El/v8blkJCQQgYTtznHVHkpJC4wa6pEUoQNDXRKGi6YuRrQWxlhM9kUc6eE6RqbIrqFImIeoidCC7kTxtGv3HsJBRqFeUYZumvMhQpaCMdVFu+cXe1EUB+qjUOeCDBzOkbte4oIUnPqCoy9GAXNI3HF/Ih2HtCey1YXGoK0ZBupAwY50pfmm9XPT3zulXl9/Zd17r+QZXcwtoZ8zyNiL9EOL2jH/hqbVPL/qZ/zkc1DXN7CJov9AIdnS6c0evb1ogurHqu7pISIi3WF908QYyv2YHKnoefLcv73mDxu54Slfs+6jdetP2crlofwSvf+M3qv3nfnH9qvp5qv0g5TqXj9lPtHW+07+Ezp1vHuz3ne6G36SUsLT3VZrnliau/X6aOxWk6Xq2VyKiMx40q2HSk/RqH5UKv5DmWHPHramhJ4VEel+RD84+Bff/49q+ntO3uZ99lpFd1lJPqC3X+MWvW4LRf8hXNkjVLnrLcfU9IU/3atfXzp3ThUR+bM/P8f9LsL+1x9V05dq42r68pJe7qV5f2jIRPbyiS/6MEj0xSsBpuvEEDPo4pELA16ppVn3Dq3scGOJoejyy6D4r3B36NLroD43xjdFASOxw6n4hpKbBB4A1GdAHSajGHnILXOTgA0m1904IGAU39yamxsZtrA14t4Rw4fcpqcx7eZtzgoUC6zOIJwbNpPRhpoHISWR+i48lAt1ui5tgNaMhTtp5pHLCNZLpPkPIYwdN8IUrWOIugw2j02EVOw/7CBNnQcbpCpvbga5+YFgYm3TvSRVwQENNpy5BbqGxJ/BTd7oEeQtjw3SKgT22gwjCMG8VJw2zc338k3xdQD7VBQOFOHBk+sQtaPbyCou7MZ/18laGYUHWHMYmzD0R4YvzS6Dij8cn/sZ2pJuGaxnhmSs7IS7Bl7JdFWo7oy74bB+eXCQXHN5Z6jT4nHehwd07neRWOdCT7IIXdkpgWKPjeMI+ml7LB8rI0UDc6vunrXp+MFbp0CXBo4vUPivxmEH3ufJKn+HMqB+s6txCj/bMbfajV1n4CLQzSWjMVbb4zoi+zPHbv/hEccWDxIoEtjJ09+Fp3sY0xsMAxr/Hd2aMjhUqU3AnWoJ7jpz7oIW2j875wxP/a5YnUIiOohk28y/CO3BMTQSPwzqllhBSK/ExygPcKJDkj6xRQrb5uFyFR1u4MAgVYXrA0KYcrNfZ6helBm3kfKehPSwvOMzu8X4hDFzq3N5nf20M9olUnRnwU1qPPBEf61celHlQVozDNSBQkBAQEBAwOWAFQmijAEBAQEBAQFfFoO2ZhioA4XEalKK7z7XorXwUv3UadsH/NbLuZfrv+mM6I0/Pzuqpuf9RnRp1zyigh4LaXpIp0d0POHveg2/u4XxkBeSHgZGflmvj8ouv4U75QmrSHGXfmSSusUxn9JN5bVFPwNjcUG3ANuC/huK5fTjN773/3qf8YN/+X1q+spL9Pzmj+kuGtumdAvwUsbvTpLNeoQ4Ozo74ubrTqrpTy7qrAkRf9jPZk0fN8nDHuaCj+Sx329db3+TXifmuC6kmC7r47LnsdKLiCTr+m8YBqkfkw/rLgy//UndUl/apjNuRERSKb2v+14t5qTeru0D/jFg8voznprVWVO5Sb2hbhjWXQseuskvGjqT0wf5oym9hJOT+vW1T+nilSIibc9c3CmG0I0BzxDWWdH53oss4hhWtE7TWklaexc098pe94JvQgiRVNnouuwmk4DWelruGDKuOwTqN8LVUgzOpEG1J1NhibTpOBWe4ShJa44o+HAPqOyjYFx8vDRg+YsE/jB9d8DWs2flMzeLUJIUPbzWvX8yC6Chr/K37i9ZDv3iiXQHIAWconZ8R1BQMrvmCre+Lx6OkqHmWAcU1COzklZqC8tveoEMis1n9OA6mltGHkpkS8SFCZsjsIyi7Sle2ct43CNLcVcR1ist6RS3a49QDA95B/MkBbZHawJsg3mER4QFfuiYSHWnu3bsSVp5BXnHesCQrs/wmmAQoK1zYNasXuvWImTcsG9GInbIK63ThVn3oPJ1DKkJlwdYeoeejrtGFBDSlHVJyzg/u3tTYBKMgv2un1Kkj79hv14/QBcG9yfqnxSmhAtjE2FVKQxp07T6I09wj8mU9XFJRhGZEemKy0+yvfleiazosLKT7UN3ATI6atvj7Ala0lmvZE9kwUJqbIuzIoqnwXyaibOHKGjIsJWRCGyWQqDIQBusl3X3wCaERW3CRHnnWCKaO5A5dOAeXBvYPztgSrNeOR7Yz0sn42Of7KQ0XBpSy4zHSXcFV2e5Yy7k+cpLt6GMZCuhjhfgwgUP4V7aRmOsM4l+CWHI1730ERER+egXbnDPzMVd2uiinsc9GfaXTJPiU3r49YCtMVAHCgEBAQEBAZcL4SgjICAgICAg4JlgkNYMA3Wg0ClZmX/Fuc2TXdSLOfvVHnO8+ENKHvjnT6vpDz6sx6bkCbqGxIaeL55cn3Mv0fPkE1L0WobFH9Gu5zHo5uf1umoP+1keNu1hHNymO68PZXQLcC6pW+Mb7S2GokeUMT2v16EvBOTP/ILOQhARSe3WK3joc3olrl2r53f2sK7xMfKYn2GydqteJ4lX6lb/1ad0IYNEwd8/ewVP/XoYMQlfdj0kFjvv7zsrVf0Zu69eUNNbn9VVF1KeMIUi54ZnI0ZfNq+mH9mhayj4GA0TB/xhMX2hYTtP61oCp79Wz+xo3i/8mP6Mfq/KAX1cUrSsHxse1kt3C/bHrvyqmp4c0fvtylO6toLd4ddJMGOe+XvVL9Z6MWHFDpTA0pWARM9ZKvneSzf7LKrwMW/BnztiF8Aqx1dTa3STkSCyaanv5mRT/JBDGPNhBhZTWe8LCwn/9Ww0hCio5j4NnYyzJWhVkw4trhQfhB92FJbQXbe+nyH9kHf4zUdh4sBUoBUvs5qIwtm1MaVQQJA+3bTqFs+4zxSyowDb6OEm8gArPiyovUx8fm6jntf3M34e8o56rW2Lsyfa47DmL8Tvw/C0XBu1h22k3USmB78jU6E06xqTlukIkXs7+gRYKNROqM6QWUJ/d1h+Ua8Mq9cDa4KMBIra0T+evuvDT8RZGymEhDRdkeFjYF5UKR5BfQ4yDuDnn4mXgZZc1it98CtYw9CnvAerczcf10ooH2TniOt5ZBbjzyHTh5Z0htikf7xNGEltuDVKZyzOaMyuIUwk9DQo4MkdV5NCn+hzFOKL+vcNrqLsOjpLA30N2gnUoohEMbO0+rsbbGqQgCWA9k7Q55+ChwkbjTWO89okhAyn4iKBnC84lmzB3auXJ6MDjJsExwXHLIUm3e+HD0NDAeyXHBgptLCn1p3Vnyykxk43UM2k+1vbnsXzwIQYM5HOCxkeZM5wfjIJfE6jTxlXGGp+UAeCotts81QUghTMq6fQB9Zdw9m864OJNddeyabrB9Xrp2JlZLtSHLO6A+MlYkbYqE0N8nj1TadEROSe+26K5Z1zJ/+OPcIws3hfY3xkEK62tROD90m5qBi0NUMIGxkQEBAQEBAQEBAQEBAQEHDeGCiGglgjpn3uGUnnoK6QbjxaBSIiGzfqlrTH5vSQZOkVT5jCCb+FLbOsW08ji0MfOudpAd7q4MsXEtCXfs6pPZBZ859JUem5H7Ul3Q8+9Vrdb6nnyVRyC4ZCflavrKTHoFu5yuPT/k16qEARkfSHdWbBN//IP6np7/35r9Sf4anz5Zu3aEBP3515v271t55mmrt7i0ggHr0Ju6BbrPM3rKnpG4u6FkTpKb+Fu13SMzy3oo+/Uc/YyHjCnYrIpiRzH1bLHvEID3Mo5ZFKqLb8lvLVdV1cZWRSL3dyQb9XTydNiMimn/M58HQ4Wi/6cffI4/qzX7RFhBDP5NNt6b8ZPeyjsXgfIS/5zifU9A/dp4esvOiwkdh/wAsEyUZPxp6sR2HgGphIqJ0QhU6E1bk478ZUZbu7nv69Dajcp+r0qXb3t6nNdQZZcGmEVmxOwDIKKy/DENPqRlXzGuaE4kIXz6AV2l1IdgDTE7RSjrnfDZ1GpAqEZCQ7kSwM+p7TB7pfj6A9bCW/gLxFMRMlBvqh51ao1A7tCWghVLdl8L3LSxe+/QxzRz95Mhqi8IYFquEL8khLrfucWYTuAP3mm4wuQX/6zTJSzT+36q4tnnGNVN0Rf2dmNlwbJ+rx9x99/KOQc6wL/G2OSuz7iMsc/cD9SdX6/LjPxFXtqzvB9jgVZzyMHmpvhq5sxcNuFk45NlxrDGXBH7IoqGFBFgUt641pMDwQRtyAqWAZgQRlyyPUd9Rnl8hUcN9TJ4R9J78M3QFYqak5YLpWGttL8WpJxPPWHKI5GfWxO25l7gz3aSRsA/sFrFTTjFv52VfYR9uQWZt8OB4KNl1BdJRhV9bMhvucPuXWpfXr3dqjlzRS2UE9DWQ1Ga8PjmFGRiAzIYqSMg5r/WwO94E2AqI7ZEDiZbjV3LL+Lk/PgWYEhkN7G5gJGNv90T4ErIvGRCKqj9o+d+8UmAcm58qdQANZrBe6YCclTyHc5gr7J/KKULDsc6Wn10REpHrVqLv/BnVU0D5FV3ayKrLLrk4W73b9Iz8PnZo9eC62cb297j+95awkJtxvfvK2D4mIyC/f/3qXZ0S4Sy2BSYWykvVFtlivb6+VrLgLTfsSRZAasDXDYB0oJK3YoXM3QV2POGF6wb+h2X3naTU9+6P6ZmrhZfqmaWW3v2OmTp5f9Sc6+qK744kf39WzKiJ+1wYfDdx3yOHboIuI1LbrvynevqSmt3p6ffgOFLZCxiP86HVYGtYn7LWH/aJwt/1znQ/1zj9+vZqe3KHfh8I9/ehs4Y6w/eOevvDt+qFMtaFvSPNb1G2vp39ny3r6rTP6mHmgs0dNT5f9/b9yvd4eyVVPH0l7+qdf99E7Bgr36GN5yHOvhmdTX2v655fRj+qDc+Orqmp6Z80jytj1u3Skl/W6Srb0umrs0l0IPrZxnfcZPiQ98WdNwjNXebxfai/yh/ZdbXkOfi4TrAyWP+SVANO1kqw0JQFhsAxcHFIQYmtMuDHMjTEP1nldZZcbf6T6r19NdwMKwJloE8aplt+ly3EhO9JvI5E50MRHNxg/EBRsHCCMzrlNZLfg5vYm8tpNM5QchNsKDLVINTv3pwnKc3U/NtBVHlBwk8/8bh42RCKAa6hAXJODSFxmDSEBC64QDGPIzUcNBwsUXOO6oowY83QdIa09s4ZDFZwj93K92O94GNO9Cs95JI/7uN/xICS7aqODhGhTXnPlzsGwU0Vo0JGnmig/Nl8z7p7RQc0I6pPildz/YrpvYT3GtRE3lcVjoMVvQxkyPABiXEj3J1+PU8iHTrXxubMpAlhnCEsc4Iy6+s6ddqfb9b1u97d8Qxr1gLxPxqn47ION3egDCAUYud0iNG8LYaqzS+561m9ugQdtaH9swpNwE2iOZ6K8i4ikl2tS3e929FEIw3x8LVOfRhnxvo1CKPJA5iq3ia6sufnftiC8OY+whzNYOyCcOsvIzX5+kWOULkI4qMNmMlV2f7s5V2Y75J5DN53m9qx083BrwSa7vh33gHuF7Hfv8cRp99seQ1VuYIyi7e0Qwnf2vatLp+JuTTSeMRxkCptv03B57U24Ou2lIJ65G/UO95wO3Dsak5uHAAwLyZCVtu/d3EFYe0vXqTTHj/ue7UGXIT6DB5bdYdcni0fWRESkuR2HHTw8hEAkD3F5GJlfdN+v3YBxhAO45kHXIWwVbjvTdfmF294nIiI/+/m3unvD3ZGhQ1MNjheXJ7pPZMuuLKXjmEMhZsnx1C9ge7EwaGuGwTpQCAgICAgIuCww0t1KuCYgICAgICAgQEQGbc0wUAcKJmElXTjXytY9o1uyxnQmr4iIzNb0kGjdb/FYkz3ii7mS34SfqnvMcp7DsZqP7eDrj1soZFiPYbPjYWk3R/WuUtvroVWLSGbJ85uGXu56XjcBd3sea/yUn1LO8FL94Kl0P5pKvxERSa74aR73P7lfTTc36+UoPqLfK+2x+P/AW/7R++zfbn+1mn4wrwsBdv9OZ1rk36YLEIqIdD3shY2aLvb3maO6MGniiB5O0mPEFhGRr7xRH5yf+4tb1XRfiEuedmto60QEGX7brH797+nuFt236W4xW7EHep6u2217fuOpq65HfFTEP8bTuiaq5Kd1Wk+9qzMtvvB/bvM++84f/KKep5aeqZd+05fU9HsOXeN9xqMfuFb/Ygshx4CAs2FTCWmP5yMRuwREGYWW4DbF6mCRhCtWDVbULlhk9VTc1YGhSzsjVtKrDDHnvmsjTCSp7wVMN/1MhXaRof5gPQbN3XTwtwkr8C6InCGv9fF4OEhaJfuFyTg/5BDemeH2knDhYog7SYok8FqhOCKtknQJYfjBJPI0dNRZaBvT8XceXR5Ie+5nllEwkeKL7WFSySmkCEYCBIMjyvliNlYmtgNDBLaLRkaOwN0CLJPmNJgHsJSPf96x+6oHxvBM9wyG12QYPK63+t8fHQobMm8sOuZuvu8ovpheScW/x+2Hj3Vjn22Kbh9JSW/AIp11v+1CFJuhQlv7nKW6PunynIJllu4EDPtZPQB2BsQ1mYdIOBJuA8l1slbc9xEjFaEeGU6c7jVJuLRFfZWuK3nUYSIRiWGy7Ruj8TCndFNJwn2F4VUjZk3ZVWwelMH6nGuIiAG0Bss6+gLzTus0Wbi9aMzy/mi/HCzgZ9ZERKR88zTKiLro2EjUkpR5iim2x+DqAWZCdwzuA0n2V7AjlimiSQYN2ycubEgmT2rVNWR6zjVgb8jVQWe766vdostzewjsJIhh0vrfmAAbaQdYUMWuJNDGiRIqCIyFyVE3Acwfc0LJdB1JLTJELNlXYAEtxRcnm+5KYFPMO0ZJqpyNfd8cjbsQrV8VF2KlSwYZW6lT7ves4++58VPycw++xdXHsvuO7Ajek0yn0inMbSgqhTfbQ5lYnrqo12TVL9gf4MdAHSgEBAQEBARcDliJRNcvGowxORH5hDgv6ZSIvNta+3MX96kBAQEBAQEBFxKXYs1wKTFYBwqNhJhD54qdJT3h25L36ZZTEZHmtbqVeefUmpo+9wXdepnP+k+6TFXvST2fYdPDREh6/P/tFh3Vp7vAMEH9aI7q6SbntwYWTuuWzeKLdD/xxYouVNdu6920MOG3zlLQqh8+q/hIUffVXrjF7wefWPAIIHraL/+aRTV9uqir+v2v+1/nfbaM6mIXS3+m6xV0hvX2SyX8NIGETwzT06Vv33NSTX9g8Wo1PbvufbR87l06E6E06wltuM8jZtjyD4LKqP6b40d1sc3k1+lzQu/4qJpui/6xse+fnVHT65/aqaY3Jz2hHmt+lo4t6XVVyentusszV90/p/epf/iFX/E++weOfp2aPjyl9/X7/lJv7+6N/vnTF/r2cuIS0BebInK3tbZijEmLyL3GmA9aaz97sR88yKDPN98PtPR1YUWlxYvigJH+Cq5nmD0iA1ZCN78Z2owixXzH8h70Zy8uQEisFh+33VwilkfqB9BPniH5ajPxd1UUChOvW2q99GAhb48iTN467g/f/VQVjAYUOrdkNq3nj0O4rhTXf4jyCl/k1mjc8hcxPCZhSYWeA8tOcUtqqRTm3e8qiHbcnoBvPsJBsn5bY3ExxkjQEpoN2bXNumyBZZmfh/95Ny5sWLlmDOV1c87GvhzqAXnDVEvGB9ucApCdsXge6btPIcnadugMQLOBYfooEjhzP3Q7YAkfORxfk6TW6lK+djRWBvr913bFKXpcQ7I+yjthIec7CX2wez3m4zo6C9757M3UVGCIU7ILiqfhB19y6TOfWXNlGXcDJD3vaHCpDVdpZFQ0ZgrSGoqHM81AK6I6RMZAnJlALan0NreOt0vuGfU1d29bcvVu1qHPsezuXzoFxg4iSg8/DvFBjKM2hEFTy66eqUNBfYrVO7chf+56MlmawwlpYIlAnYfOaFx0sTfp2iW5hHHQQf1m4n0mt0KRTfc1GSUc0xw3zW2gw2A8Uc+DTJA2NGA4Lpsj8fFZn7Gx/CYbyWj8ywqYA9hGLKy6z4VTCN9J0UZorGSha0LGR3M4LsBaPOraPgpheZVjx3I5ubHX1UkG+58qwoNG4SH7yOHJPW4Ca6269vnul39CRER++5NfIYK5LAlxxsRxsI5QltwK+sAUhG2xfuT8Tg0Fak+kwaZYexE6jU60vKAILg8BAQEBAQEBEaxc/MWBtdaKCE9l0vg3QDaOgICAgICAwcelWDNcSgzUgYJNW2ltP9dan39Ut3zb7/T7j//m1R9Q0//zz3+nmn7VE7r/ce0Ov8ZAw/MVT+rOgSdsnZ33aDFM+fUbujnPMzy0BoaB6sfYpzzPFpHd33ZYTf/S43v1H2R1k6PxjTdPFAkRkeK8Jwyk52YjOZ2hML/ij/Jw4FY9qsHpj+1W05dGde2Btice6MHf95tgD3+P/pv6jF4+qhD340BOZ4uIiNQ8ghobHqPxwx/Sfdrznuttcgt2hCfayJm79d9kFzwMjIb/GZHqeR/GHtSnxTu/6xE1/Yv/dJuavvgK/7NPLoyr6QdedUJN32jp42zu2BZxI/OeNn+nnq/CL+hjYLWmM7le8/s/6X20uUkXavAxKszt+rOHfKE1RKQx7mcPDTKMMUkR+byIHBSR37LW3neZs/SChWl3JTNXlvqeERHZ9FenWn27CAsrpgrT56PLUH+0kNOaavCuzs8baUzB0gpfYFrNyBygFZl+vYkmLaLQWphbExGR1m431hnNIbMW1wRogYXGd0BhFpZxWFMZmo6hdFvQGunSunfMjfPGNKz+rU3VdvpLR1oTWLuQYZBbjI9ThjpMIRpGFqEYa9e7Z9Dvmv7zXFOz/tauRR1Rob9GkzvyjnDcph33QWc4uMJCfI4bPlSV+g737NSiW6s19oy6LxNkN+BvKv5eINOjuhO+/pl4Xg3alcyELpT7Wd/Mcw4REhi6rnQqHnWDGgITn3eaPLU9jrqQQzSPznAuYiZQgyIJlgUjT7AvsV3I+GBo0CiMeRn+7SlofaC/pk+4wrWhCcZ+3URUh/FHaSF3txl92uWnvsNZ0JNNMCFGwJhAH2bd24SJ2rqBKCPtob76Rl4irQ+wYO1ht463k2AkNGDZnnd5ZshWjs1MBWE5l6m/wYoG82YB1ukSmA6wUrfBVGC7M0Qkx0BjSqQ1ykgduNeEe3815125R8fc4C7PugYgm4VR6Mwq78n5BveeIBPE5SnPMKspMm7cOOrkEQIWbIvaVDz0KPNe3waGECz5Butfs7cmyT4Gqj3t2qh4jPOJ+03hGKJnoD049rOI7MJwj/VtqDdEnSGbgswpPi674X5X3UadD7AIppkfMKjASpJld98/fsM7RETkO/7p+0REJL2alM4u9+z0E67eU5iGGG6T8zWfnVt198wsuvZKNF1honCbk+5vbtkfTj3Aj4E6UEimezI6eS6ltnVIX7yP/rR/QfqTb/2Xanr9dfru6Nt/5uNq+rtP3+F9BilUzxTGs+Ee2aYv3ldnh/33Snue7dmjU8ylH10P9V5ExPyJLtKX0hnw0vVs8KznIKXtoXSLbC4s+pHo6b/xUf8Tk/5DmeP36cKd7X16H6EQTz9qp/TN4qFv8x8oTHxSP1BoeM4/pg/o4SS3cnnIJPXn+/ptw1Nuhko6J09f3MJdZl4/bcut6Peav8vjPpTydGgRaXncCA78sR7W9J49t6np7ZfpnY3CVhr+4Cv+UE3/0f/5Q2r6xrV6XlMV/zOufukpNb2W190qfKgs6AeynvMKERFpzOu/SU/qBwftef3QIvMxvyhq9m16n14+OubP2EXGswlxq2DSGPPAWZ/fYa19Bz9Ya7sicpsxZlRE/sYYc5O1Vj/tCtgSNpGQXiknXYSuyy26OWz9gOuPdJlqjUBAbpxUZSzQQR2vg87eHcGGAfHPGxNWMmvx0GWjT7fwnVt+pavxUIipNbcqNl03wBZf48ZrjgJtcIlgCMY0Nk68b7rq0nnAwMPZ5g78B7uO0pPuukTT/a3thBDcEgX2BPm2kUgcXRiY1+Ksm6d7cHXgYUh2tR27vgz3AW5GKtvd9dz4cHNOCjg31w2EikufzMauzy4gzBteXxQLHDoJoUrQ6odOukK0hzPRxr12tVsPklZO+nM7CgOZieWBG6fGJEMquvtk4CrSmIYQXx31tgHXikVs4rExoxhuklRxuHmUTuPgqO7+rt8wKiIiI4+4g4XmDoZZ7EltBuJzEKlcud7Va2GOQnfxNq/v7Hs3IQQg3Qo6EAFOzrn7tmaw4ZqPCxsWT1MY0n0ef8xtxmvb3fNHHnAufMuvdH11uO7u0xlxdclxVdm9OZ/TuMODNm7+WtMQMmQYU4R/5OaR66jCLIQ9sYtJ4YBu7CmE2Syjb2ZA1Z93e4PaXghXbnNlziNvkVjnmLthZSep+Kg6rE+bE12xXD9jo94AHZ/1urrkNqaJna7/jn6a7jPxcI48gCFGjrhKKB1y1PseQleWD7j7rR5090lBSLI1jEPAqbjwanPMfc922ziAgyCctnTWs5IouvqxOC1NYzNO15zkWQeKIiKlY73YZ0MXkHGsXymECJeRxnZ3yMRwkjzoaY7SFUiQ983DVxGR9jXISNWV/ZNv/jUREXnV+39cREQyE+77brko6ePxA5s8vIpr0zy8c+nDJ+GOhPlp7QZXn/kl9DWUxSLk7uJtKNNH5KLjAq0ZnhcYqAOFgICAgICAy4ELSF9csta++Ms+z9o1Y8w9IvIGEQkHCgEBAQEBAS8QBJeH5zFsJSmdT53LRugM69bLU7/gt+411nXL9K6/06vsV5pvVNN3H9CF+EQ2T+6eKRKLHgp6Wrcymy1MiDbjsUz39Dz1hnQr7MyH/CyPyi4PDV03UorxhIf0eQj39nluJCI2qdcVBa7OuZfnlLBb9ZfP7tbp2GZNf3ZvxGPJLuvX/8Ar7/E++30fuVtNX7lNv752WKfGT9+ii+SJiGQ8fgc+q3/Kw6Dxuct08v7x19ymj7P1g/r1tqDnlafsKjz5nfvKGTU9Cl/Vh8JxvY908p6OKyI//os/qKavv9LDiOnodZWe94emfOL4djX9tn9/TE1v9fQ6z5/Uy5f2dx2xRs9Xa1hPT2/o5fu9n/117zPe9sEfUdMH5/V8LowxUyLSxmFCXkS+SkT++2XO1gsXxtHHcwtu3DWmnGWKzITGWJwOT0EyMhVqe2HRXYIQH4TherBgpmomshoy5OLKde4/pP4yvjNDLbamHbsnXXaW09JsnK3FEM4MwcgxtXYwbils9xEUTT0+xloIExeF2wMjgdP+2SHsGB4vgVvkl2Dd5C0jqyUo77i+MxyfU6rb+0QuwUygcCHzRGG9/JPOIksKPl01kw0yJOKW+eoMaNSwAJPGni63Jbvg6rczAuHA2TWXiV1j+G02nvc82CfT8bCfnRJDAKIQcaZ25PJgETabVmtapRkKswRadn4RlnS4MbBuekWI5XXZTkZyqPfqdjcnF8/gnmBXkPJdn4ZFGlboxGlYtmsQR9wOAdCnC3i2+13xkPsPmR8MD5op92J/W2OwtINd097h1t2jT7qXQnMC7VaCsN82d99Ozkh1F0U/3TNa46gvWv2xBk3AnaUzAqs9wm43xknjl9h9Ro4hVOIEWBet+Bq3sRMipjV3vzTccCggSiFD1j/bNXJxYZhQa0RyYCLRFYrumwjBmFhwec2CTVHb7m469gSYTBBbZH2SyRON3UnXLmQBFM6AqTOMEK8jYG3Q+o8x2xnmX1fGjQJdKMD8GQd7I9eR9prrX+k1hsOEq9QcxhaYM8ZuzgMim8wd1i+FITsFMH0gzMl5ib8j46OBvtlFiFKbhQsEwq1KxTXsd7/skyIi8qp/+DcuHWwQe8TNjwnZDNs7+pjL09BpVxHRnAvXqwRdcTAfcO4lM62JfUE7TzFZCXgWGKgDhYCAgICAgMsBK0a64j8ku0DYLiJ/DB2FhIj8lbX2/Rf7oQEBAQEBAQEXDpdozXDJMFAHCpm1jux+78I56eu36o7lrSMj3nv1POJ28y/WrY6ZFf0+9T1bWLg9td8fionoejQDEvO6n7Et+BkK2TG/2JmGbaO66GS7pVtzRUQ6BT19xyd1K+z8SzxhGD31MTKm50lEpJvR29zozSfVtkcszsP+EBEpfUH3++ZpdD+2f0RPbxX1Z/z1r36l99mr/0xnZ6SP6nlqTeoWfF+5RUSqon/n67eFgt6uP/Wi96npv/Gpb/Q+e+nFep3MfEofl6vX6P25XdR9+UVESqO6iX3tpfr11+2dVdOfeEQX4cxtwR5Yu1tvv5HPetrPI4dit9AltB620aOzOnNhx/i6mm4800jNo6sishmeqh+9tl4nDFXXj3/1Ez/qfUbiFR7NFZ8+zCXAxfaHtNY+JCK3X9SHXEkwIjaZiCzr9XHXP9ehL0u/XlpFi33RXinEF33GFNgmKzIhMgxtYlq8Jx91Y3/hdjfWJx7Bjwy1FuJzdQs+/rSY0te+MQ4/d2r74bLSKff97E1u4I4+6CYJWsB7mNbTaxQLjFseKZJGQb9EZ1OkkiH3Nva4LzOwUA8/7PRMOhNuvqWFj2HsyrvdX4arpsWUebEM/1aDpfBaV0c9sP1yZzyMJwj6ZdYpdIl2AquDAoutkbTkWl3kAfW22zET1q5yZckhxOTGHvcsCjs2xyB4SAFOWM7JQqHGE+fJJEItsqxkUxDUTMgtMxyf+7t+0C2Y8osQBB12+aKoXX65E4li0prOvQjXHMkaywumByzpTVh/uxQtB1OBGiDTX4Jv+UGX94nH4Ac/yr4HCzdCDmcRWpOW9UTLPae2q4gy9YdadPdpTG+yTNhvqQPURujFBJg0vC4FCzrLRDAs5GYoV3fDkUMQW4SuRxIq0j0KGTZRvyO5WJmqO9xzKZAY1eEqtTDIJpDIvz857sZuF6EXi0fjeWUZi9DvZpjNkWMQAyy663Mr0BxpQx8F2hRZCK9GYxdlrOyCvgN0I2o7MODwQIN3P8cTmQ/Uk+itpCUHViBDUqc3UF9YmlS3U4cE4WXLYGUgJmmyhnmKgodz7qVPhgJR3ov25HyC6Y5MV9OOz2+/9RanL/WDH3m7ew7CgiaPxfc5hVkTzbcUos2tUTg1zgBJol4pZkkmU36Z4rAc06ScyCVD0FAICAgICAgIiDBo/pABAQEBAQEBFweDtmYYqAOF3h4rzd86V2m+9re6ibv6Sr8T8PCHdcvmjV/zlJr++WN71PRyzR9WMVvwdCSfUTyhW94SM7o5sFf2my/T6S0k2hVMF3Q2wP13T3t/M7VH14/YOKGzB3w+2T5/ppmCv/3mslPe7zSUqzqd4tpf9+s0PPFDer8qPa3X+9xLdSuL3as/Y2zEH9Ix39aHrl3Ty9HyRH8oN/39s9b0sBc8P2kc1hk//9/xb1DTJ7cwJN9xqx5y9KEJPULBeEmvw8pOPVSniMhkSa/fyrJeh8MZfZyl189P+0NEZOZv9bqtf7seuaBT1VlIiaf8DAxpe/RQjuu/Wc7qkTUmH9bZLSfe6i/g9If0vn5mm56n+i59Prr9LU96nzF/7/VqevcyMhQCXlholxJy5pV5GToBK1yNPstxqxr94Ct7aI3GX3Q1+h1TuTy3uBkOsYVpceiE6+Pr+91YnnqwEV0jIrJyo/txYR7jjbegezV9zhHBgL7+5X30k3bfr16LiBUnYYEcRRnqccs636uNSTATnGE38hlnJAub3PRFttCkmfiSYzN1hlwFbdzsNHro002GAK2cpdP09cczYMSsgSyVn4NVHz7RLaxdyPIi+yK7Ercg0po8csSt+6jQnwAbwUKXySaSUt0FvQC8OqtX0/IP6yUs1dSe2ID2D/UbGHoxj7aubWfEBGSJVmFqUSA9DwZIbhXRHBClg9ElKjtchQ8fde+w9LwLB9GDgn8OrIR2MSn1cTA90M96fWEie7CMM4Ri97C7MM9QoXVGM4kzRNaudjcaOk6mDnQ6VuNhCYfWmHescdAO9QmE7UP0ATJ9un1rBdMWSRjWc3xhF1nTt7txYRfjkRPIehs9BJbMvmTsc7JBRgm0ASpgIoyBiQB/eWvQZ/eCqYLHst+T9cLwntU9sOBPufZpL+VFwOzogEGTWXU3qeyBLsY8tTvcPTi2qM3CaAMpRKJgiFj6+NPCXt6N8JHLiF5CXQLcr7IXDBHkJ73h/jYxeXRnwCRBeNAk9hC2mZP2kEsrHaWGgrvn6CGXp8y6+y01JjJrrkMnG6lYeqru8taYdmut8k73fdMRgCIG1Pp10L6gthuYPQloJrz9dZ8QEZEfft93ue+hsZB7yI2DLpZA+QWUISFSOuUyPfGwy1tzwrXtyBfd3qOxD9phmK+p5xVFm9kJ3QeOJ4bb3O+JdR6wJQbqQCEgICAgIODywEjX558VEBAQEBAQEBBhsNYMA3Wg0Kqn5ejj5/oHlzwW1Z4vqoCIlPfq6Q98QZeZt0Xdwtby+DGLiCR1d2mvZTM7qltIOx5rtXT9z04lPHoMnvRiSj+xG37C34XKczpL4NZ/+YSa/vQ7r/XeS8OOgu7zLSJyfNQTzcGT3XpdtxjP/YJHdV9ESp/SmQj5Rb0BG7frVvTOuv7sWk63GIuI1E6V1PTSK1bVdLOud7Zqw6+h0Pb4u5shvXz//O7Pqukf+IuXq+n0kdTwyEev0fO0Xa+T3ITeFxr+KpRsUre8T35ab9fTf3+1ml78Tl1ApXuPHllDRGTlG2tqevP4qJqe266zKZJbRFpoeSJD3HzXITX9oZO71PRxq7dTzjMfiYi0inr/TK2d3yvns5/SWQgiInaH/vw3X6dHUPyt83ry+cOKSG+ABJauBCSbIqOHe1Ifj78raa2kJZAWcrIAqPmRhmQTLVvpjfjnREckC6surY4F+Min11z/ZYz5scf6FPJhTSMjgdZNWlCpyRAxDhL0n3bPbo3Q5xtK57Scg2WQ4txBJgSseEVoB9APPtnsiU3QN9+N3/qUM+NnyrQOx1kP6/uhfQCWQw3MpNo2KLvDOsl6bI5tRsUQESkd0a3HLEPpTDdWJ/UpRCfAVMUoBPTTTrZ6UjzlGnP1Ojc3jT/pbrZ4G6/ls6AhMYoy4TXBPNZ3Qt2+QSs0LN/oI7kl/F2lX7v7w/ZsQP+guACNC0RG6GVdBjZudesm1in1EmoziU3WCLorGR2sN9Zrazy+jqM+RnYFDAcwRYaPxRk3jJYxfALaC7CIjz/q8tiC9T/DCAmIOpBbg8UdERRaJVenjGhBJoWxIr1sXHuCGgrRGHrCZY7rg8IctRLAbCgmkHcwB9hP4dMfWfuzjLzSwLNd3tmX09C6aGLsk2nShF4KNR3InOiecvmyIx0xQr2BeNunyxjjs/E8ZzfcvRhNJlmHhsKoG+u9HFgCiJhQnCU7IO7zz/YhsySqS0ak2OXKmky55/WWsO6j7ge0SkqnEtGYIvNj6Iyrv06R77D42rAz5D53Ua9kLVXH4pERMogO05ji2KZWgvs+gbrrjbiEu1/2sIiIvPOeV7sLuNwAm6I+42488nR83ivO9aQBJgzbknNW7epJ5BFjlJEq8H11msyleB2QjWTqfv2rC4lBWzMM1IGCWJFE89xNdLqiL4iHiv4F8c1feURNP/TrN6jp69+obxZr835KctuzMfMdWBUyntB4Sf0QoLaFy0Muo++0rEcgZDqruzxUXux3Ccg/om9iH/i0fnAw7tm7+zRL9uZ0eriIyMc8epvWM090VnRKudzrb7/uqOcZX6/nq/hPut/B+i36YY1vQy/iD7M3mtf7dP3JUTW9NrHFZOY5DEsU9X77Vw++SE331WB9yn/g9ao3fElNf+CPb1XTS9fonWfBI2YoIpJJ6oeA+RU9fe079TFQXtDdKiY2/Acmdc9hX3GXZ5zNeg6QngW7/4uHdfcsael9oe0J+9k+4R8bxXl9rlq5We/TM5/T77PwFv+B3thH9TH7/tU7PL/4c++9LhQGyR/ySkA3I1LelYgOChjakVRtiqtxw0a3AdKDa9vc98NYLrSwgRo6iQV9erM/pCGmSJdGHiSkK6BwHyji2Vwwu4dQKC8dbb7d7/sPCKKwhhQDpIsDysLNTkTDbmy6NLj/9NUNKOKmayNXAoLhC7nh4RxBgbzoICAbFwnk2pmUfHvWRlNks155n8warq/xL9wP4DZQOOQO0GsHx/A85Jlh+ISbkISsXevql5vp8k6IVTL8IN0H+sID9xiqskIXh7gbBjcj3EixHpPNuNjl6BNuU96YyaNs3GGhXccREnAYtGzks4NpLtkSqUF8rroPAnmd+EFCep2baBxGTbnrSkfja8GorDwEwRo5h3dfZq2F+7j713e4POchvGfhtkAKOdu/uS/eT3ho1UQ0907BRhv1/rwwnHhrNL6B5BiioSbRJc3fXc82zx1zHbs77to5WYEbzCQo8+jP5R2p2H1Id+fhTLT+Zh8eQ11XIaB4IiPdfHyMsQwZ2DWyOGgrzeIADdNAoo0N72730NwiDjtwCNIazyEPcFnJxA9bOI44pnsIuZiGyHqnifpnn4aoeHrVJfAQwOUFl2IeSLTRB3DokVp1g6414+apZCMuEEnxVgp3clzxYIYHQo0ZHMyMQByz7vLyz275ooiIvOeh290PIL6Y2IBgaJPuOagDlInhVpNNG4WuTJXdQ00V/bPgKoguWZwP6pOuIqN5BnmmqGkUKf0Sek0O0pphcI5GAgICAgICAgICAgICAgICLhkGiqFg7OZp/dlYuUu3AJvjHjO2iHzmiTE1vfM6j5jhii7kltrwW5nbI/q9jMckX97QLf6JlM5QSK/5n93aqX9X9DAXnk1ok+pV+r0Kkzrdu/fEFuZkBW0f3UAkOkE+5zfDel2lPBb/iLaooPpKnZ2xvKJbk+2Nen2Ypl6O/Vf5GRjzn9CfMf/ANv0H+/W8mlW/KKPxifoNe5gyKzojZs8bjqnpT9/v8SsSkS/+7i1qemHD3x4amuPnd72IyOnX6H3hLbufVtPvfd+dano37x8z1mPdb+pVK7mrdd8Gc8gvOpkc063733D9F9T0d3/wFfozrF6Hd71Md10SETl633Xe7zTMv0RPHx32C5Mu36n3N1+/vdiwdrD8Ia8E2KQTTaRlkRbARF8fIsWYFnOKNzL8IcPj0XoWWdzbNrKm0wLIUHGpRlycj1RevmrXDrr+zS5FKxqF15gnWgRpxWToQIoDFg7huZgq+i2JBVDvmb9kkyHWQE1OJyILdBZh2DooA0UCGxPx+mpHIf5gUSUToR0XkGyPu/9kF2A1xisyt0whxLgrBY15nRzcAMBM4P1I3aeFke4CzVFz1m9xCenOeGZjNO6GQUo4BSRzS2gfrJoza/Eyboozur/sE5l1N6lX97iKL8y6C1ujrsHaRboRxNeD/H1rmKyLzbyYVlxcrkuqmomXLb1MUzW+pojofFyIsgWae4b1BnG7/LxbNyTBrumlXUOW97rvGQaRlt2oj5fizBQyUjqlnkgGVuWlvvkbHb9wJs64YX3SvSW3ijCCcHFoTrqGqu8fQ17QHnBJqU2757Dfk5nAPsu+00FY9swK+j3ZLlW4PCC8d3u4F7FWsiuk3JPJ5O5FwdRUBeEgOR/A1YFjrD3s8t4ccffJomycE1av3mx7d4P4upb7i7ZAwJJhV/F7hjDl3JBZI0vJRv11HK5WjUl3jxRcRKSLeatJthXdPCAQOeFuSjYXXboa8PQ0aIf0KvKYdNe/9EYnuP2eBx2TMFEGewJijRx/PTB7MnAj4zxFBs/kocqmG0YBzAPk0aCeOyWXXp+Ay8hYXGyXbkybbBf3eXTPmoiIHJeLi0FbMwzUgUJAQEBAQMDlQm+A6IsBAQEBAQEBFw+DtGYYqAMFk+tK7oa1c9I7J3XLNwVVNEzesqCmZz1+14v37FDT7RY13JnxsB084SHHxnQrZaWm+xK3PVb6rdDq6tbyan/8H6D0BZ+ypEj1Tp2JYL/oYYYYPb++A7y5pp9h0prxmHo9bI7UvF6++Zf7Ldx2Tf+NyevtWjyqW1Q7d+h+88fu9fi6i8iYhzmxdounT9X1jugNeSj+cJ2yXWf8fM9L7lHT/2HuRjW9M+wPXXrdv9TDs372M7rlO9P2iEs+i7l658f1gn/iwAE1vbpfv09Oj5rqvlvQM0ZBqH60Gnr7JfwEExnyhNL8q4/qIpn5FT1P6bLeTg++V9eTEREZ9nSe7Kre32gh7sfKiJ+1NPqwXifr151fSNyAKxc24SyT9Fnu8J0Jf2pqMtHyGL2iqLeHLkihRYbbyy84C1kvk5BujiJwFGN0psHVGxzLjL7BFIeL/K3xCmtsh/jcGnQKiv3WaFrOYcFFSEBar2nZFbxmKGZHS270fsVl9Emnv3UvlYhE9ygQyUxymJvot3gmWBLMY3ubK0xm2a0vWmAm0HqZha5tFlZ/+nUT9IHOlGlFjmsF1XYibCEs6dQtYNlsYrOtErRI45Vh8dnudPdsrqfxDDBJlsHCmEb9LpEhgr4BX/LsOkUwqU3B6yAi+KgrZGP3CPJEbQD3Pi3vcpVX3c66Y79BfgsijV3u2lTB1We3hTzOszDuT7KB/oy+QsbHJquF4ny4H3zQJUF/dfrug+HBcJxRnzGxvwyNSlYH67o9DJbFDljmV1PC2ZlilySaFhFadB3axzs+RYFH+NIvt2N5ysAKnYIVPn/EMTqbe5xgQ2076nNHXDuE+gNtsDraUzRPg5mCOcCOu7pJnsEPwFRIVxKSmkd1YSnEcUAGD8X/BH2gi/pM1109Zxc4DhAadNnloTYDi/ok9DowhjkntKEvkUReOmQ5Z6FTgD6bgFB7B6yK0pk408F0RdLotzXoYxROODZgLwdB1GIG93CfM6tufKzegHcy8lSfiYtasl6pRdJD+MdX3OQYnp96xDVwsoTCgdlKsUaGwOSaIF2FFgnG2/BxV+k2YaL+lwC1kwylzkQe17h7ZKouD5XdqAc0eQZsLwo/kn27trpFOO4ALwbqQCEgICAgIOBywIpIN8gSBQQEBAQEBHwZDNqaYaAOFGwjKY3HRs/9YpdHKXzCb32+aXxOTf/C7+u+3bWX6lbb0uP+sHy5kv6bnkddP+2J5tDteLQEUn6GQrOtW8trDb1z18f168sH/dbAoft0XQlf1I1O0WNO9hRjK6pQcUJnR7Rael1lPVoCL37z495n3PsFPaRdak5vc5/FP3Of7gdvtjC0zn2lrsdw8A/1Hx3+er189FdTn++p90xO77e/+3dfrf/AM1+O3aCHWxQRWazrGhE+NDoeC/6MP5LLQlV/RvkG/V7Nis7G8Sl5tPVmFRGRD3zvL6vpX/+LP6mm5+7QTfirCT9DaHVJz0DKE2Ei6ZkmV6/V+3Nzwj+/mKN6euOg3h7ttGdwbBGp5vmHwfKHvBJguiKZlUSkMB+pp2eoeg8rc18kBFr3sgi7V59I4XpYCuuwyK+0I6VxWv67aYZfw7OSjCDhPndgHKPPd6oc9/vtjsEyC8teCq8CA/2oLgiLjJSQrsBCCy2H7EoT17k8U72doRb53qGvcnajF1mJadmu7ILuw1kRCEREartQ/krcx1+gRt9GCLn8GfdsMj/IxqDvfb880ujTUHFnSMAMng/rKdXe6SvN9qF103RFatv7tBFgQW1Og1mw6CqYBFFa87MukMQ57ZJFCMccwoJmV11h6XPO6A0N+Pg3tzvLLkMD0ppam8nE7pvCFFmfga8/89c1Im1YpsE4TC3Dj70A5sYqrfnuHk3O9Sau85CuuOur292zh9EH6NOfO+rezZ0p9w7JgqFS3p1BHhlxAc8pxBkhzUlEi4DFvNPZDAOaOQ1tELRxdiWex6FjZOqgvdJk4ODmjL6A0JQRi2KvYyYwrCHDbpZOx/UiqiB+0kqdQgSEzpDLc2fctWMu7/42S2SsYDwsb2pZsB7IrGEUjOa460vJBTeoDcZa7RoXEpShL8m6aI65Z9CCzrHLPDauRfQCaGd08L5MgKnSq6ZQdrIC3N/hJ+IRGIoIZ5lf7EiqgfIiZGVnBHluMHwkQrHi1VzZ79ZLKcwBtcl46MVNRpT728Pc8NY7nWbTe+93mglp9Ik2+mYB7c9x1hp1f/vbjetR/k0tbkiyAhbKVe5H6arL++o12VieqCHB+qzudWW3CLmbgPZEcp1aLpfKDWGw1gyDdaCQstKeOJfqnsnq9PeEx7VAxH9wUPbQm191g07RfvjzN3mfkc7qGzMf5udG1fTckL4TaBj/Yrxe1TcJtqt37tmaTj0unPALI27c4BEh9LgE5J/whG704Eh5wvtd2uOaksjpG5eM55DjoXf52y+r63ZGIjL9aHg2YD1PM9k9/pCcZkU/IDj2NfrNvvU196rp7/vjV3mf4ZvnRjyhKQt3zKvpSw/MqOlrHvFKEZFq3XMAslsX6Vuv6hvrbE7vgyIitZZeV93bdBeUxGE9v+1dnnF82n+Y+KbP/aCa/is/9Ydq+r+5/5vUdJPbwq3Jc3DAEGP9yHrcDkgjPuc+Cf/Yr854Xsgbnjr39DWKTKnPvzShop8xrAxWTOkrATZtpb67E4mbFU67ftsejrs6tHA2x5CNwyexscVhwMhhLPhTpJojnOJIZjM0IjdfCLPGTQgp7lHYR7hbtCbi9GYeepguDhJAa2fYQtKvI0G+aLMeH++NaS62SYPHJhE07U7B5W/4mFtXrF+VdaKGsrnJJg3fFlgvcFWAuHEG4QZbSM/MujxH7gKYBnhIwpCL3ACwrvJLbu3Geu3mEeoxcidgHaA9cF1lGzY71CQ0Z4UCHUMoP2wmkmVeC2r1BOj5MAxwQ1WYxcHMWYcUZ+cl0XIJ3QIOOXCoxDB87WFs/rmBQxhDbpgYHpHtSZp7Bq4urREbhYXkb7ugk2fhSsI+wM00Kd10x4jaHC4hpTMubzZJVwf0xawre2WPe6+Sgp/F4Qk/N0fd8+o7IJQI9wMevLX2IgQh6jJZM9GhBt37+l1umNc2DEyjhxooKyd89K0hbPTXXXvVp9FefDYOwXiAxDDVCbgANeGGQVHsFOsWZZJHES4R45Gb/F5apIjNLin3qT6RRR7aETwMSbThEoE2ZtjVqH7hmtLCPqPHZc0a3ALwTqcbgV2PlzmFucLWKY7p0jnXtDFe04WENHD4lltFv82xD8XXzhRgpevjwh08yHHfcxxwvW9q7vqrbzolIiLv++SL3X15IIDxxL7MQ9zGpCvb2FPx9UZploezrtKSVdfJG/snJVVzzyweWRMRkcrVo7HyVjEPRKKLDGsLYdBk2eWBY6yJObc96V83XkgM2pphcEoSEBAQEBAQEBAQEBAQEBBwyTBQDIXpUll+5BUfOSf9HY/p4dC6HoujiMjGQT09WdctbyfK4/r1bb8FMZXSrejJhG4RNFO66bvhsbQaj+uEiEiv6jGLe6jHx5f18jWu8bMs/vVdH1bTf+dv3qimt4Y9deU59lqo+NtvKKezNrqe8Jc9TzttXOt3izEjetnbHoHHdFkvCIVz+pE44aezZ67SBTpbXV1M5oO/80o13Wwh6md0Yo/kUvrpbbul32zXXafV9GzS8wARObwwqaZ3Turl603qbbF/55L3GUeOTavpB/frTIu1D+r9Lf9Z3VR+6iv8fWfbX+vl+NHGt+jPKOrlqw9twVDwPL7nmfUzFf0HC3fo/bY9toW701N6nZiOPv7ye3VWSHXeL4706rd/UU1//2fu8P7mYsM3vwQ8T9EzkqglItZODdrKdAWjVbIEwThauWmVy1TiFvRekmJqEAdMmEjgrskQi6Nx6nYbXdzilUwWgAzBtWHBMffaQ+6eaboTYEqob3PpuXm6JTBvpHy7C2lppHWb9GxSm1sjCN+WNrHrWsMmsso3wQigZZpheXug3NPtoj1O6z+sngybh1dHZEkHfbqw6CqU9Uohy9wiKOPtLu5Lizmo+XAxYd5pqWVYz439DEFnpcuYiPwDIbsE3ARaELxLrLr6GDqGMoKVkt6I533oZAvPhPUXFnNap5sTjE9JJggZCe4vrafsY3QfSPRN9RS5s/muWLg6UNzWsD4pcBixU+L1Wjjt6CobB9w7bPgw1g+Goop0d4Fl96BjpEZhIbE+aqLvVneifcGSMaDeJ5dce3cRnpshzTvou6lyMurfxVMU8wMNf7mHZ7pnFBbiY4thIgkybchcaDAkIPpOeS/dXtBn4YZBJgrp7XwnkUmUKLpKLczGWR/cE6SrNrKyF2fdl4lu/N1JYc7mjKMEcCwxnUyQ1WsoROh+xzCbkTtUgfWGcJAQYczBZYhspiHENyQzhfmzGHjsD9yPJBs9yc+3Y3mycB1pTMH1Ae1C94wNuIJm8KpmeMiozy267+963aMiInLv55xoM1kyZIqwzxTPgJXE8KhDcZFSIr3i5oBenq4ymGOGktKY5D7G1TPXNmT90NUjYn9BpNR0wMgBE6GRxw85Bjcu3dZ4kNYMA3WgEBAQEBAQcDlgxQyUwFJAQEBAQEDAxcGlWjMYY/6NiHyPuOPUh0Xku0Rku4j8hYhMiMjnReTbrbXn54ffh4E6UFhYH5bf/uDrz/3Coy7X81iGRTbDRfWjtU+3fHd6nk6xhQHRePLV9dxro6yLHHY2PL7aW4gy0pJwDjyihc2q/myzxenab37+bv0Lj8+5rZ+fVbPyqM6aEBHZ9XJdFc4nxOeRXIhCdWkoPK4zCPZ/09P6s2u6SF4+rVv8Dz213fvs1CP6vRLX6WKUv/pT71TTf+w3fsD7jPP1UT9zUte0mPy0Ps2kvlEPzSoiUrxHt0xTtKsf1YzOuJkr+ZURk2t6vo48tFNNLw3rzx49orefzfun17lX6f3qXa/4PTX97ff9SzW9l9mCQZPVvxt5SK+rniekanvEw6Bp+Md+5U5d/yN5UtdJqR/z9OctDu+/9PO3618or4BLhd4ACSxdEUj3xMw0pdtwk934fdAngA9yfZqhAWE9HYK/NfQG6tPu+jTCkiXhS21wfWN79iyrMdJgSU3Baljd5b5PQTwxsqAjT80DjkmQPuksh2Qq0NI39gh98GlFpqXPmT039sLiCOsky1bZHX9/ZTZQpglXpjys/92sSCcfH4hROEaIwJk2Q/PF+z/DR6YhfUMLKkPA0ZpMX3RaGIunYJXMMoRdXDuBTIbaNMQJcd86/LDr22D9hJU1WTfSnoJFFusMAyE7A790+tDTIl2BeF/puLtHcQH1QQZHgSH64vNja8zVd3bJlaE16j7Xx+MCedRUogAc9TqivDNkINZYqYWUtGBlT5+ECB/E9wqwUFN3YPiIu1ltez6Wh+GnnHm5AqZCuwC2CrQq2iVY+0epBQJrMF7HkVA0ukNjJwQMj7p5vbHHVV4kvJh2+SyeBNOhYyO2SwOMnX7Ng6FTfRbqRVeWyjUjIiKSrFO/wH1f2eGexT5K3Yyxx9zf8j73l6KK7GNk2OVmGRLTpffKrs5ouW/Dcs5+kKnYSKQyYiYZsE0KDIPKNsRYxVqKYWWpF8BwngwZy75A1mpqPa4FQo0KhmSkJgkFoJnn/BLqCOOlcAY6FND36KWMrNzgysl+zbYlg8b03D3Ke9BHFty9l2+P9/dE033/Fa95UERE7vnwbe7ZCMeZPYaxm+b17i9ZGGRPDJ1G3wYjobHNdbrmVfEwlQaqszZhIrFcCkXWJ1xeOG9T66Wyj4In1Ahxn/NPu0xQ94x1UN29xcbtAuNirxmMMTtF5EdF5AZrbd0Y81ci8s0i8iYR+Z/W2r8wxvwfEfluEfmd5/KssPoJCAgICAgICAgICAgICBgspEQkb4xJifMPmRWRu0Xk3fj+j0Xk6y7EQwYHiU3107NR3Kn75zYb/igInbZunv3PL32vmv6Lf6KrsOc9iuoimyfP/eh50o1HWyE9qqvudxb8Pvg+f35fqMKO51bdcb8aaua47lPvs3x3POE9E746rPijQqzUdUaFj/2R8Byt7XjpGe8zjj+xTU1/5IzOLOid8uRpVNcSMC3/ed/MA3q9n5jQ6+R7PvsdanpxKxaCp9rbvfOjLqzcrN9opO2ffrJv1dkL7Y/oESPS63pd7b1p1fuMI4+M6PfSp4vIstSPxH9c1L84oedVRGRyx5qa/i0f/z41fWpa109Z7mwRBcETCaT2al1/I/83egET4zqjaGbCExZCROYe0/UpfHohpWN6nypf659fTn69L9Tk5XmtWRmsmNJXBLoJ6a1lonB71Z1kJLivqUdAS+7IMdcfqUdQnMUF6IrtIVgAs4zk0JX1fbAmZxjuwf2pbaN1Hta1XXSEx7MReSIxDCV+CN7Qos7raO3v95un5ZdMg1QtHtKSYSNpIKPiPLUX6mOwhqbP0jbIkz4BC+ucu4b6R60JPAt5z4GZEIVEJHEJRcgvwtceftRpaFIYhF5szWTxe+hDIJpDca6J57o13Mq1GPMoCyMl0CfdWCumGp9jGImCZaOFmtEcaFFl1AHWR3EOeaSyPsPvgZGWXnd5q2+DX3cm7qNPBgkbkP7urKP89WsiIrIxiygDjHRjTcQs7UBXgSEXyZChZXrtamfdzSCdGhPJtmOzko2Swvepehd5o85GfA1KSzqjnEXrxB61Q8AEWab0v/uTXXb/aUASKbNuIpZJ6Qz6YyPe9g0yZBbce4d6DuznJnomoz3EtRjqqN86XkHd3a7T2TVXdmoosI9Sh4DhDvPz7vccn6UTZCYgNGe5KymEJ+zkqYGAemR/p64DfPzbhXgeu4iywfT2cJyVkqqxjO5zj7oPYE5nVvE9Q5uuxH/PMZ1Zx1gHMyGzyqgeZnOeQRjTLpgJ7PdrV3HeEpSFWha4DhGmxm9wOlUf+fhtIiKSBnMqdRzaLCQYoJ9n1liWvryuIa9FRJ3BfMWwoNQmWbvaDZTsRi9irJb3glVBlkWBWhXuMzUoWLb0KgqFfspQlbyefeBi4wKuGSaNMQ+c9fkd1tp3iIhYa08bY35FRE6ISF1E/kmci8OatZabj1MiolNzzwODdaBgrFhFVLDzxVH98rR/s7/zi/pi9T+ufIOanvNsxClwpKHuEVP0HSh0PYccXmxxecLj8pDwrN+T+pmF1Dw0cBGR9pheh9klPWOZkn6g4BOp7C37D0xSnt/UPEKVCU87nZj3u1UUj+vlyH9ep+svvkbfmKWyeufpeML+iYgs3qr3nWRd79MdT7g+X8hKEX/YyFpb/1H+mCckYF7Pk+9wR0Rk7qRe7+Ov0UUW7ad0EUffwZLIFn16p953hg/p+T384C41PbdHD3EpIrJ0TC/f2O41PU9N3a0pV/C7vO3dpYtLPv6knl8KGfVjqKS7L8wv6wcyIiL5fecnstjWo9Ju6bZVfEw/MKnu9otFXkxYMQMlsHRlwIpN2ohSnMeQoQhdHgt1Luwb2FRSDDDRjPe19AY21qNuvHazJqJFcwVPqi83H1zMJivxRW+3BNryGSygq/GNKem8/etRbs4jtwT8JR2af4n28CYNWmSTNnz2wX+0QM/wnrhXRIHH5xbp+3GqfGE+vmkzELHLVEAdT/S5PhTgSrIBQcmCOyjvZhmu0FUi3Ue4WWGYvM063qSS8z3UGerGymKwGe7fpHFzwc0fw9dRZJFgHzA4RGqOZ5HHRKzMzTHS0+O/b07CTQZ09+ZhN6+mW3E3EJvaXDuRfk73lc3Ntrt26FQTeXfXJxs8EcKz0Qe6FOosxMNGsh5JrY+o+GNYIHZ5GBN3M6BBz3Tjfagwx/xujh1u5jY3dTj0aHGcIAQpNpqmhH6KslZ3uO/TOABj/dL1p4sNb/JUDmVj/0fe0IczZYZ0lBgKsyh7N/432exGoRV7o3C3YD3m4oORIpfsQxW4D/AAkvXDftqcwnjIsE+gD2Fu4HWsMx7Q0aUoW44f0nAuiA4LMpuDmvXYRr3WpiCoCZtU/6Fcou9QMbPdPXT5aefqauliCbcMzjs52Ft4UJnlYRZcwKLwqTiEyTQ5PnlIgPadQLhbfK5NJ6SDAxm6KTWmUF6IWXL/xcM/hlntwkWkeJRuT+5zvsw+cWlcHi7gmmHJWvti7QtjzJiIvFVE9ovImoj8PxF5w4V4aD+COSUgICAgICAgICAgICAgYHDwlSJy1Fq7aK1ti8h7ROQVIjIKFwgRkV0ioodjOw8MFEMhWTUy/vlzi7R2g8dVwEOTFhE5/Rr91Ci9oadP3623xdKH/CySRs3jEuA7sVr0xPib1i371iOyJiKS8ggg+kLNlU57BN4O+2kQ0z+kCyM+/Pn9avq2gkfIzSNeWVv3nyIuVXRLaK2i1+GoJwJlr+4fIjwZ70fmm3XLcP6TuotEc8pDAz/l75+1XfpvrId184dfrYv9ff+7vt/7jIRHDLNc190qbnrjk2r65z93tZpe38LlKDurf7f7Wp1mf3JVF4RcXvOHFi3qzH/peIQfG1P69W997efU9HtO6+UWEck+oYsQrqZ0U32ypLvFZHN+hsLjR3bo96rq/arlYRu9fMcxNf1D93hEEUVk/NY1Nb2a1BkjtAb140Vffcj7jEe/cIP3u8uFXjijf2EBYSP5Xs9skCKPrxlKjqHNcgzZ6Obf6i7HkkuDDk0L79qBs4TeSGkHoS4SFNzBh+APreqw7lOUkSEtaeWlUF5Ez12MvwvSsFJSIC4SkJyk4KT7YWsI1v6RuNWT96ULRXPMRN/RiksGAK2V6Qrp4e6euRW6MrDMtPy59MqOuGWQFnPmmUug2gwo45iTGcq4hTxHwm6Yyyn4Zq925tXkIVfpqdom8yB/Ku4eUTwFqjw81EhizC1B+G61G8tTZsNVwvoBN5c1JuKWdbrHdPEKa4zHXSiSZB7gXU3hSlrUeyWIP+J5FNE1vU36eKqPXTf6pBMutCnSUnCvIvLWN7Vv7HWVQUE+hgYkzZ/3r42iTiBgmKjE13u9YYSLXIDQZYfW/nh7ne0+yb4QMRQ4DEhtX6LLCMQtV+AKAXYQ3ZLYHg2Q/djXOM7SG+jfO1x7JSG6SZeWOt7nZAqRgl+ch4UclZZfdL8n06iTT0XhYdnWm8+Ou2FQLLSKV3EWHphROEOwJrqcGzpkfoCJMktXH/c92QMZrH0jN6e5NtLdeqA95NqXFvr8cccYrO9x647K9lQ0j0RhS1GG5hj6DsPYgnmQhXvT6+5+UEREPvSZW5E39F+wmHLLgjpwfwtww+mApZFdbqPMYM/ADSRVQQhHhAPdDLXp7kP3EOarNWykMRl39eghNKzNY8zimYkaXFMgIEkBXO5rirNtlJ1hWf0hzS80LsGa4YSI3GWMKYhzefgKEXlARO4Rka8XF+nhO0Tkvc/1QQN1oBAQEBAQEHA5YK1IN0R5CAgICAgICPgyuBRrBmvtfcaYd4vIF0SkIyJfFJF3iMgHROQvjDH/BWm//1yfNVAHCtmJpuz/9nND9j1yj24p7Fyth9gTEdk+rougdf9UFxsrn9CtgZ0tZC46Puu3z/A+pgscJOc9zIWtwmL6DJueZ/uEFFe+zl+Hs0/sUdNTbd0SWvCET8wm9dPCpk7MEBGR6oLOUDAeXYJNoaQ4KIyl3utrltX0tXt0JkL9Oj3DO9+v94PTb/YX8M6rj6npjy3oz/6vb3+7mm7f7H2EdD1sh7aHWfDwh65V07e/bE5NPzM35n32qMdi/cS8Pv6Kvn476xfuTHn0JnwhY336Iu/5nOq6JjN7V7zPXrpLZ+OIR4izu67X+dgWwoj1UzoLouuZF6xHmfRgXhfIzH/Ffd5nn26MquknUzqTZOVOvXK/+D4/C6H1Cs/cs+yZDy86jPRE7zsBz09kylZ2f6Qr1em49Yv+vnwf0n946LTrp7Sc59bIBoCFdzIeCs8mRFqQGqnvhH9zlb7fuBZdP78ISx99+3GPIsmP6FppMBIYhpK+z8wz/aXpt20Zs85AbG4qblXldcwnraYMnZZsnu3HD8sorL/0r6b4Hu/RREjAHKaO/DLyijCPuTWUARoJ9RloJMCvuwFxQOo9cL1Sn4m3Ey3g5at6sfwVv+jMrpXr3A/NiYyky/QZd9eMgPy0cZX7u+2+DuqFVk93zzZChaah91Db7vKaX4mLaNamIGKHV07EokB7tkbj4T7Jzoh0KdBMuTPQjyjzPu5vqi4y/UVY25vxEHv1XY6JRyE7dpbckjNtdxB2c/lWZxong2R9v8tzk5I+tAYjVDAFozNgDLZm3Of0svtd4YlMrMylU+4vmSO0pNPKXJxtbYZWhY4G9QgaU67NOiX3LIbnXLkhG8szWUCsT+qBNRCmMNEAe+AqV/biI+6+ZAFUoZE0+aD7zJCwKQh+VtFHR5+GmCOYE+lVdEJrpbyfcTSpOxJn+TTxmmta+vC7eijf6O6RzEOAsAnLOdjEvTLmlfl4XyKGTsaZP1noS6Rq7i/1O8gCYX/oD7mZX+1JEzoXZCZuCpi6e0frBJTpJV/7sIiI3Pu3jpmYGo6P/dyTDNnorp/+AtkSroxjj7kO3S24PsOx34WYabKBslSpwQAGBbSdKjvj79ZO0Up3BvdgIgSZUyvQthiGvgnqq3gyrlPDMLM1iL+OHKVYqV8M+sLi0qwZrLU/JyI/15d8REReciGfE8wpAQEBAQEBAQEBAQEBAQEB542BYii0ekk5VR49J52hdfrRO+aPErB8SP+u+Vr95GrkIV2FvV3yswRMzWP99jEURvRnU4n3fJDwuQh5bpX0MBq6Hb8Ff/gJ3aq6cbN+s6G0J/ylhx6RXferuSfL+m985eDpbD8iVV0FhT/ULewrX6M/ZOf2VTX9zN26c37mjN6nRETub1+l5+moXueHvtFjlc75fcVMUz9vtGX9GQdefUJNf+qIHkYzveSffjZe7dHTeErXRPC1q49tILLpM9mPxja9TtLrnr6e0PtO3sO4Edm0TJwDD3sn6Rn7W4186wk9k1nQ6726U7/bkzU9/OU9R/waEf/6lnvU9AdWrlHTaS3qx8qbPUIXItI744ngsUX0nosJK8Hl4YWGTt7I8o1pSUPVu7AAy2w27gPNqA9tqLmTsUBLOq+nDzXZTO3hTYt4CYri9FmmNoKFVb4O9f/sKiMluOsqu9znkaOwwqOLNYcRcWKNFl+J/aWWAv2CiUgbYSQeGYDzYYeh1sCk6GVttF5I1Bkywv3JQIeKKv/UQonYEmlqU8CiztCAk/Dxhuo8rcQGFt0U8lKdZvi9uJp7ivULEhbneYuy12dQl7D225SNLIG5JYN6cM8cfZp6DFDaH4Hfersvb2BL0JLdKsXDgLbhNx9F1aAqPtZnrM/WZFzJPwGLbHY1PnewDxURaSTVtFKfZJQRXDTuOhPDaVKHIIkwkOW9hVge01X0Y2hSNLGEoQV3MzwoygytrdYU6SzxMjJcaPEMP8d907NrjDqAsnZ7kmiTmkH9ANdGZC6s789E5XUPc3/WDsYjRzAPnX56In+27u7TgiYAo3ikwAxqoOx5MiWgXxAxE6BHwSge7WF3P9OzUX8mU4nMGjIKorFIzY9RfEZ99sBISM1jjcdwpxiLUT/HMojzEsG6YvhKsmkihgoYERHbgxEdoFHSTZtIL4NRR6g/QM0EhtWcvNXRjD7+ebAFtzHCDZlQLrkx5e43fBx9McNwjy6PrbFcLM8MW8voDp2868utIWrHuPtWdsW1FGr73MAw7YRYRMFIFaHLgPmgiwmJ0THICuJ8wblu9DDCf4IFUTzu1htkUVxsDNqaYaAOFHobKal+9FxKdMWzgU0X/YJmN+yYVdNXm/oidv6o7tvQHfFvejNzevV7NAil09I7OSeCc+5T8G8WrTm/Z/v6fLfm70KVPfomNunZxPoODhKebRNfUhryi3q+ep59XG2vnic77O8j2+8+qaYv/6NO/a/dr2/M9h7VN4vHv9b7aMmP6xvummf//Cuv+Us1/Sc/rYdBdQ/R+67PxebYp3er6emr9fCJydN+UcbOiv6M4k1raro9Mqo/wxMeVUS8nT1Z1TuJz+3nRTfo4qPa4SaRWtLLPvGQnqel2z0HZJP+zXOiqPfpXlYfG92Sp7099bT7d/3t9/gv6S5gZod+aLiQ0dv7mm9/wvuMWz+nj83/d+9Lvb+52LhAMaUDLhEyax3Z/b5FaW53anftaDHr5g0u3FcPur4+9pSbqzs50ODhNsUFKanjFCs0XZECYppX7nBzdvKkW1jzncqQbxQ25GYkC7o4F72NcQi1LcWF9Apn4mOqAyG+6g5Qi6t0jYi7QlAYjiEhCdOLiwTalJV0nb/F5mwdAmuIKV867fLUGsYmAhvJNETi6tvJ3U7h96RoQygSm/sWyrSxj2Hu3K8oStfEfNdhKOK+sLIliEQ3pm3f740UGQYQ00Z+wbVlfdrloTDndhnJivub2HAnOl0oNq9f53YjOWyQ6AayfsDlNb8IcUcsQUnJtwUKGrofpNdQl9hwjWKKW7sOBwd4tTcQCZlCfcmWleEjcHGAi0gLh0rFWZfnTsp9Lu/N4jfuHht7uTl2n0n5Zl20YVBpj7uy5U65Cxr7QNFfdp8zG/GDHYavbMFldOxp1A3GD11corB8Kx1JJXiYET9IsHAfyG64zyvXM6RlnIpvrnIDJv2Eaxce0BC9HNaFCCGfRKhN5oGbyaFTEF/EoVfhjKvbbgF55qYcnzPLrhOu3TAUHdBs7OMhlfucXXW/oeAq33edDRxGcD0Co0xnPP6OLiD0Nu+TW6XLCA7IYESjgCGXxtHBQTZ+wMnDMF5HYcPaNhMdWNEtgGMpic35b331n4mIyA+/+3vc9zCOJjEXlI7H3Y9Gj/BwI+4yFB1mwcUhuYaTUghbdvaNisimoOTyDc6dpDjrft8cRx2043VU290RgzY2fWsUiwOxHhZto9AL59wZHcChnoaOuj5V2e/61NBTflfSC41BWjMM1IFCQEBAQEDA5YAVI70LE1M6ICAgICAgYIAxaGuGgTpQ6GWtVA6ea5VLruiWtNFP+C1sh8d1Om9tm26t613voWh76NAiIkmPuF3CQ2ogNakfhTO69bIx6Rf163q8PYyH1BCF+ul/9rhflLF7ZkRNT+7RLfKdnn5SV+/o9dQp+t0tUh6mdM+j15Yo6Xk6uG3R+4wHDu9V0821el8YOq4LBJ56nV6+vdec8T579jOekIAH9Wf/5Ae/Vc/TXv9JbKvtmR4qejlanmfbeZ3Vk95CVFOG9fYoZHWrdNvTFfJz/vHX1nU75bo7j6npzf9PF7x8Ylmn8Y+8ThejFDnLKtCH4hk9fe1qveNu9TLKPaoPct8Y6O3Q63yuros7rl/lpwVOZPQB2G9JIErH9AZ86tdu9z7jxF97Gn3GzwoLCDgbNpmQ7lAuYiZk19wY6IHuzOFVwrhcuxpzNS1+8MCiFY1fdIvog4lNUcQEBWJxT1qPaX2n5ZRCdrT0EQxtxncx89YZcnmipZWidZzfuqDB022A7glJTNcWRSIjgemdIVeG3EJKMnhNUCiNeaQ1mfcsnWwij6SRk5oNy2oDTAbkOYFQixQ0ZJ6zeF4TS4g2qPVkSETW6jrYFBCQI+W8jfl1+jN0mRApLNK6i781V58jjzjrZGOXm+dI1e5NFVC2+LpkfT+swbm4EF91l/tLiy0FImmANHBna03Ckgv6exusDobbo/WfFlq6WKTqvchFJF2mGB9dECg4STcN9+y1g/yMPCEvDLfHPtgZot8LGAdjaL8NsCqqZLWg3UEhpysM80oWQAphVRkSMA2ae3qxJq0Z18gMI1iHS04X7kIM5xi55aJ+u2TitsAi2ku/GIRorcVdIgws6b0U3ZmQtwZdizCe0EcTNVcZtPYnIcyXgvBhdZ/rH8n2JiOJ46K6C2yGIscu8rzkXrYprMXtmRy+53sb7Ja5OGuIrCUKhA497R5U34k8oO82J907PnfGCR62x90NWsPuOZwT2kVS/vGcko1cCIgkGM1vvvYRERH5oc99mysDxlJmlb4mKBvGGt0xGEKT/TW94e5HdgXnBEnD1WHE3aBT5Phy6wnOg9WdZPK43xWW3efqPpefmX0rsoSw4FwHWcZ8NXEmFefY+gQYVGg3hoc0EIQsnG4gr5fHbfKFjoE6UAgICAgICLhcGCT6YkBAQEBAQMDFwyCtGQbqQCGXb8uN153r137iffvV61ev31LSTE31CTw2ErrVNn/QbwFOlnXLrU+vwJfemPCwJjr+juq7l896SaGifnz9wQe9z/jTE69S09sndYvnYtYTNjKl0ybqk1sMRM9XtKz0Y3hIt64f/7jOQhARsds9ugtpXdth9U26lkDpXl1o8HheFzMUEUkU9HIUHtD71NSbTqnpzY5/CrA5nUKw4bFYD/+TPgZe9mP3q+mf/TU93KKISP16PX330Jqa/mRR16egCJUG+hP247ZRva7+/G16X0hs01k6i2t6u4qIJIf0vn7k2/WOO/wl/T6L6/5ntHfolvpvfuVn1PR/PHWdmp5K6P3ZbEEE+NLaLv0LD0OhdVdZTbfLfuHcqQf18Xfy9ZeHQmhFpDdAAktXAmzKSHMyF4lx9SKhMPeXFr7qNvomu9+lK7REUnSQGgq01FKpz0QCd5lVWtzcV/n5Td94kc3QxYVFWERnEL7uMZc3m4EVfwiidRDeS685q1rlKljYU3E/dwrwsWuS2VCFblAKAsa0qDNkIH33eykb6QIw1GJxvhOrH2ogLN/k3gGTX4rPidkVMBea0C2YysTySjE/PofzRBRSkcMK00ePei+Ymhhqkd+XjkCUDZby7Oqmj357CG2bBTOgHfdLJwuA1mEKQ0ZCexT9g8GWGlYUhqQQd27KrSlap51FnqyV9Cp88lcZFs/dJw1SV3EO+amTjQE2QaMbtXVz2r3n6XfenHAdk77zrNfMBpgdEOVjCEpa0JvUH4CQbXoxXo9kQJAZkmzGRUezEP5k3eQWXf4aUxDgg0hgAu3QGctHeYuYB3kKmrrPFBmntb47xBCZqPA0tA/Yn5EntkvhtPuCrKGh4y6d44zhPxmmMFFHu2PsZ+bcu4jMotr+YXxGH50wUUjQ2vY4MyMSL90JvZTDrhBtaF3YCYgHgp1SOEm9Bvc7Mh4i/QbUTfWqYVxfjeW1Cy2X2l7XsGQAUSusARHPyh5SetAfCr1NBg3w7Te5MNB/8ojTIKI+GsUXOW/kVuJW/9wqREbJXtpoo8xgHCBPKYhb1vYMo5JYZ2DTgP1FlhLHPoXR69BFSYCVtLRWEgHjg7ovCYzFzEr8PZxfcXliSFAKslIXw+biuhm9zKXZGg/ammFwShIQEBAQEBAQEBAQEBAQEHDJMFAMhVYnKUeXx89Jb+z0RBto+C1Z7e26r3ayqZvw+/2RiJLHyisi0mp4ojP4gxeo8GkuJNJ+E2LHZ/jzWBAjf8E+fOB/vdr7jOx2/Tc8he3H+jbdwp1M6nnKFP3tV5jzWFU9ButiXlefX5/y1+H0p3Qf7vJbdYt18nPDanpuWc9rYwsGxvhdun/+/A79GUee1v3/r9lCp8GnXZHUyRwy8z16tIMPfORONX3Eb3wW2dCfvdzQhQ98eghU3tZQn9T7z1+/R2fWJG/QdQHa6/qc4GMhbIWp6Q01fW16Uk3vtvw6IlQT78fH/vvL1fTR79H7wpdO6xFssmPPggng0Xxoe8JoMtSehrm7fG17nhPoBYORrjyLOgm4bEg0OlJ4ellau0ZFRMTAWtYagio+fcJr7GtgIoBNUN/OMG1gAUDRn+FfTWLTt5sWt+KZeIi5/BIsqSfcfEGr+sQj7p3UHnMTZXrJvVcyLYQ6G3LzTnVf6ewsSBtWzeZEXzQHRkbAnygMLg3GVKAnC6MMn+jqZoQERjaIQrthisktuvXSto+7+Yu6A/TpjnQJ0ohOUEIoOFp2qQyPPLTGqUUB//YGfg8rv2kwagHqnSE4Iysp2pFhDM90JAnF+0h9Hnmv73Avj/yce7FVd7k8pitgGiy7+l6+KYNnoQ6G4xEnknQxR3Sd1il3X4bhi6zReDzDghYWXUJjNM5Y4XOyqNtEqyudEiJ3rLl1ZW2Xq1+WjWE6+Vv20yi0JUKY0uovCF+YRtQhWrYZcYS6GmSrZKHzMHyyE39uHv7tu1xfpS96exjRDMbOslYbMjOQKQYi6H8FYLHG8NUdRhkANaG3irqox8tM9kTpGPJ6nLoo8bmZOinNXW785M64Bilf7/YQ1P2gNgAZjd2ciZhKZCRw7JGt0uWaYKdrOwOdB+YgVWY0lPiYTPUtQxnVg6Bvf3PK3T+3BHbSblfvtZn4+7IDAiND0dZnUNlD7SgvN+1z7/0/+swrY3khOCbJVuEcMLQYj5hAHRqD8WXxbIaFbI248cBoGss3uwvYD3jf+g4yhtDuOxB9Bczf7iJYCV0jvSLHMnQx5hg1xiVzHiAzYeh0vC/0yEQjK4l5z1+q9/hgrRkG6kAhICAgICDgcmDQ6IsBAQEBAQEBFweDtmYYqAOFVLIn08PnWhGPjeqm0NuvPua91xcePKCmdzxK9i/Zp99rtqZbjEVEdA7EWeq2fUjV9ZMsX3/0KaqLbJ72nvObrv4Mb3SLLXrQtXfpFuvHTni0AZr6zdpdvYCd7f7yDZ3wsD88PylldCZJou4f7D6WR2PWYy7fo7Md2i/WGQ3NskfQQkTmHptW00evXlHTv/L6B9X0p8tT3md0PB3L5zv/5Cd0rZKJF+mRMjKfPpdNRFSW9b5w/Et6dItEUW9YxonX0BrVv/ONv7anPTKLel5bKf+zr9mnM0wODC+p6fc09HbqrPkjLdCicC48+jBJveDJpI9B4y/fQ8d0VkOuqM96qUf1MTP2FbPeZyx/TJ9H2npwmUuCQbI2XAnoZVNSv2o8ihg09KgzwRYSTo+gut2Nec4Jte1xX3IL3/MkrGn0Yed71LSN9KChkIJfL6fV0in4XzNiBCx8uaedn3S36MZ2Ar7Hpu0y0S05q3S3AH/gDfd9c9x9rk8ZpMOaiWm2M0I2BQpP5h+7LPMMizD1ohKtzfd8pux+M/KEoxm2Jl1eEo02nuFeiqkl54eebLgyZBbd+5Vsi+SIKyt1kOpTYEDQV7/B6A3uuREzoRlnJqSqUMmfRxlhFWV7ZaB1kd7oSH3G5SU/5/LSgd908UnX5vX9Y+6ZsPI3dyaRlySuR/XBEk4rda/AdgTrAv7xtOwm8ZnvGyrP03eclu+xp8BEgBp+coPMBFcYa4wI8hxZViNWBKzoxbi1ns+kH3rETECno7J/G2wW6TBvtNjicrwCsoxA0ozP/Yycwb7M6B7dXAJlhuZGJhGxXVtDcV0Hoj3at8CAyn8yh3ss5GLPIntCesyb+zh6qIU6cHWVApsiC50HAZul8KR757a3j7rrqvGyMGpHbdumFgmjXUSaHugDqRFEitjAexl9Jw39FPYJ1mumjHqCxkVxjpQHd+PadlfW3LL7gU3yPj2UzXXCJBg+XEJXd6K9yZ4huwD5TKZ78pqrnCDKPU/Go1SRuZRej7/LyFIi64dMmi7YR9QayS657xtj7nPptKuTOrRfVm5wg7QxjjyhfpsTaJ8lRGbZBo2L/kh5/LyUlRTqM7cYv1dhHuwW9glUa5JzaZfzCKI8oL9W90DzAqwU+ZRcdAzSmmGgDhRazZQcO3Huwjs7pG8WH/zcQf/Npjzb/Tl9U/FoUaeUT5Z0IT6RzfAozxSkn/XDelwCjC+WnohY3708/hbJqn6vyQf9m4q12/Qdt63o3c53mJHo6OkUClKfkfQMUk84mITP1WPYs7sUkcbr9YOAf3v9J9T03/6Tt6jp9ZK+KUxk/e4WGc9GcvWIvkn/66fuUtNve8kh7zOKaX0MrHnqkKG9+rFwdEJN39PyU9P7BYOIm16sH1I9/AX9MGMrdD2HaoWdutvB9WP6Yc2Tp/XDx9SSPyztoXVdtLByg96uzWm9LyS2cNtqTOnla+reEzLuGQP1BV3o87q/WPM++8jP6GXveg4HW/v0vrZU9hzOiUjiTo/v1Gm/UGVAwNkwnZ5kl+piE66PN3e63Q1F1LhhowhbCq9zhlrkprwLkcDoABpDKbuaiMLdZdawEG/GN5I89MysQ1Atn47yJiKSrGADPOn6dRshF0mztljQt7Cp5Cu8Rbq77RvXfQcKpsYNRPz3vH+ibSW/zDCQoPkjLF2q7MZtLwsRxKr73J4ZxvXud/Xd7jM3k6Q501WNBwikjDP8XmoD7ZDmgUMPdYQ8wm3UgsKcx0aCGwu6UrRLKcnPu7xlTroDhM51EPLFJq2BA5kMXB3SeL03h0m5jx8mEQw5bdZdndgRuKTgHZbCBo2bntwKDjkgGMwwe50CKOOg9FMYNH/CzXO2kIko77Vtbh3KjQ/7EN1bWmPYSGHjyoOa1BoOR6ZA/SZ9HH2BNHOWMYfz7UhIdAlCno24EF99Ko2yoezFdOz7tQNZlG1zLDGvFAGVXvwwzmLjaPDXziEUIjfvkcsOxRbjhynMk0T9GN/D1SG16hq4ep3bM1A8sDEBMUL0nX7Bxdr2nliGL6WbEOn4EELnIUcUKhSuD6XHXD2ky9yMw5UE4VfbcAWiu01+3o39RAv1zQMF99TowKayLX4ARIHPxk6Kp8bX7y/ff0Q+fiS+/2GeeeDJMVQ6aWN57CEPuSW4czAcJN1q4OZCUdEOhCObQ/H24XKDoUuZ3h7G+BvFISTcR5Ij7jNdOVsTXcms02XB/Ta3jH7cjB8oUDSW7jXZM26N1xlDaNh0fF3COSDg/DBQBwoBAQEBAQGXA9aagaIvBgQEBAQEBFwcDNqaYbAOFIyIxh5pNXRrmR3yW4DNqm4pzC7pjd+7yiM21vWzBHoetrKPUk661DO+z1b9dFi3CBqfwXNEF5hbKPgp13Z2TE3PLejdjlaIc2+kJ2du9FgoRcR8Ug9t6Bu7LU87FY75rcz1jm4J/e0HdCbCgTccUdMf/4xuXd/1Ir9g4nJJtxq3nx5V08euX1bTyy1dCFNEJJ86P1HBV77kMTX93i/oMSA7BX8HffVXPqSm33PvzWq62abTfVpFf/kSo7oQZ6Ws/+ZLc3v1Z0/oA5YWP/W7iv7dmSM6fSDluT61BUMh4WFA1a7S27XnEUwsHve4n3ytPr5FRJIP6+mNq/U6L47rrmS1LdgGuXnP3DqzRTzLi4zuAC0OrgTYZEJaYznJInwYRe9qU65vMeQirXW0nNPaSasqRQP5riKrrjnWk9xiXICwU6BwIEKXwWWBFlFSt7uw8pKWy3QyDhjNtTaB0HHb4nmltZ9rIlr7u7Dw2m7cbSAK01aJCxua7iaVPg8htlQZ1sNRN1cyBF8Hn9OLjsqxcb2bI9pgT9B1ogFBXNYnrdIUYWSeO2AkMLRlCkxJWjPJbKA1NAEL/vCJFsqCEHZDmciS2trj5tg0wttVD7g8Ztdc2VavRb1jmiQln+yUBoU4yeSggDCs1okyKPaoR4a0Y30SrNMEyp4tuzrMLMDlZRgshCmIOyYTkWsO2Sish/IuuNyAuUGXkCbmQjLZehRZBBU/s8bfxVk0xdNxYUh4HUi62onyIiKSrCPPeNfljq2650LklOyOFJkkCRONAwpERpZxMDosH0Zm6joYO0hORiwK95muOYUFim7Gae75+QZ+H6//2r7R2OfmuHsOWQMUN63u3hzL7kZWLMQsLfozRRelSRcDUupdcmohi7y673Pr6NdV5Bn9NolQsDYKrRkXDyRrpQmXodp0IpaPFopU34a8om/1Jt142DGzJiIin/zSZohoisZyTssvgDkFFgXdKSjAWWrErfdkzUQuPCXkbQpsC9y/PUx2EvOKeQ7zUWLCVVYX7Ntug6wnlHHNrXm5SklWk5HAe+kUXXkwH4CRQIFbzgPsA2u3TqDM7OdoY7AoGlOXzg1hkNYMg3WgEBAQEBAQcBlgRaQ3QP6QAQEBAQEBARcHg7ZmGKgDhUK2JS9ShBZPlUfV6ysf14XtRDZPevvR8Yi/FT6sP6P+Rr8PPk9C+2E8PurdmfMTXbDtLSyked1KmUrp1r3hgm5ZPLBft3yLiHzq0avVdOOpkoxHRM5jOJV00m+JbA6d36lfuaVrY9AXTcP+G0+o6fOf36empzzUE1/Yz2PH/P0zO6sP3d2f1iv3dFfXMcjf7mchVNs6+6TjCSH6ySf09h5+Srcktwt6PxcR+fAXb1TTC/vKanqv52EO+Qkmks7odXVgShdGfGrOI4zoYUClT/lFNW97q87m+NTDeh3a3fr4Sz7sj71Zv0m3+mc84WRXG/q9Ep4u0pj2+xkOHdHbo17T+21t3dNQW7xrGx5diYCAZ4yESDeflE7R9X1aqjqwTqYh6rdxVfxnnMpHHnX9uQ1CHHWO6M+dqplIJ2DkmJtv6uNxsbJulsKEbgwUYEVrTLjPyaobgHUItNHqS9Di1y+QTMsvtVbJAMysQvRsGpbxJYqsxctGH+dU056TJh1a/tyPajud9ZDMjtSuLJ4J5gGmwsgYR2tzvx5BM+57TmFZWqOj59MlOh3/nKXld6OJOoAlOZGR1oh7n9FK2RiH4CbK1gIbhaH86tPUoMAjMnG/eVp0o7rpmw7JTKBgJOcyCu9RtI46CIXTaKgU2QdkdaB/TKYl1USIyYm4HkMTmglkmUT6XJ04M8HmXWYLT7sLm+NxnYD8AqzG6FO5VdQf8t6Cf3y6TPFA94dhI1s7HJ2jPo3rwBxpwjrdLm2GXIw0wdgF+BfWfwOFQTIWsnNxf3muI4uz8Yqn/kCnSO0Ll5fMIsKC7nestyjEZt+ritomtPZ3kE8yhLul3maFMFzpEJgap92z2mAzjD6OtoNcB0VbuYYi64Vr/tYo2Rj4DKFW5jVKHyZrApnuG1cUi5Wca9iXHDwmIiKfO7TPZbuaiBiU7CvsQ9nVuMYH24VtXHrK0QLqe92kl2iDSVBjv07FfldF+HgyRlojrE9kGfsgi/ES6aa04qymBJhZ1pJFYyLNhGhesCwDBDlHqKOB+ppwnSfSLcnFQ4ImsdZpD/nXpgF+DNSBQkBAQEBAwOWBGSj6YkBAQEBAQMDFwmCtGQbqQKFWzcqD950buWHvbbovevWuNe+9Gou6ujhPSfvBECr9KNf8Vsq0T8DcZ5KveLQgfFEeCn52RDGvsx26HkvvTEE31d/3Cd0/XkTkVa95VE1/YseMmt7+e90C3O/7Rty5TWcIiIh8dkS3yPv0GJoNvZ1qe/wnlU9+bp+avvOb9VB3x9d1n3N7QI8E4iGwiIiIOan3hROv19kA+Xn9ZtWW34RfqelaAklPJNTJKZ09sP4y3cSd/Lhfwd/Xd3/k+o+p6e86+RI1vZr2++CPD+n1fnJtVE2fHtXHwOwTOpMk6QkUIyLymc9ep6bfeMdxNf3oP+o6G76pQkRkdEQvX/0+XaehfIdu8R8/rLdFc9yvD+ObD6U/BBSw7dP6vLPwIn8B01X9u6ZH0+Jiw4pfh+JCwRizW0TeKSIzeOQ7rLW/cVEfOsDopYw0RpPnWHyjSAlDccsgrWVUIm9hSqclneH5yOpJ1ew5FmwqiJOZQKThT93L0HIIlXSEW0s2aS2GNXgk3tfoB99vOY8sgn3DglZMfj9yGPfBq5A+/6lGT9IIC9iDGrppusnN5uPvj/wKleDdZ+pFMC9kLNAyTit1pMCPImU39DIUz8CS2GDEBfc9/bd7KVrkXb4YDSHZspuK+qtuPqNvONcEzTGG/uTn+DNodaYVmPoO1M+gHgGZILTAkjURhXRE5IOhU2BRtOiPj/B7++IW9OJpagCkpJ1nBAjmkfWBeppEaFFGTEC9Jqnng78M0Vc6gftBkim3ynZmf46Hf8yfwTslwbpC+M8JWpNdX2X7l6+K63NIb9P6y3CqpoiwmNAhMJU+33nUJ8cm+31uKW6dZlhI6hFk1qD3gHHWQYjF9AbCESL6wMZeRHXokCXg7hdpNoA10+J7xcpm5IgKrOkFDnL3p3gckVOQpybaoQANEuqmpKBJwRCwGVjWa9sZxYP6EO56MoDIoOL46Kapu4Is4j37quueFpGz2KPQzugOdaMxRx2m0gmMj414HtlfmdfGTtc/k7Dyc8zVduRieW6OkuXlHr1xDfQ8wPRojTEcLvomImSwDrmvGX4amgw73OfCGc7VvYhRkC67e1EXhWFrU6tgkE3E15q83oK5UJ1BpJfpOGPnYuNSrBkuJQbqQCHZ1Km2p/eMqNfvnVj13uu4J+Titvfqm6zOj+jU/5U5fRMpImJ0XT2vS4D1LMaL0/rGoTrv37BlJvUR0/a4W+Q8An29LUI3fvpeD2396jU9T55NiG+85ZN+ur6P6t5PCyXq6zrdeytdwva4Xoe939Y3mJU79T7VT/uM0m9b9z7bevIVvdj673WXfq9yxU+ZTyR1SrsvXOfSrD7OkkU9s3xRqd919A3mL3/II3h502k9T1uI60xl9EO1pc97Drw8AogpT31s9VL6xa/5SzX9v/3Ot6jptZv104mRL/lFUdcO6yFEe3v19jBl/VCtMKb328S1fn+g5JP6QU5mVK/zXkqfDBmOT/1NdnBexOeBjoj8W2vtF4wxQyLyeWPMh6y1ug9NwJYwPZF0rRfRyiPBMLgwRFR7UMdJu83NYUOV2byPyFkU5h43o1YyGCZ0VeCmLQptjOmDYevaQ9hQYaNJV4jG6CZtXGTzgCAKa4cNAjey3IRTZK3bN1UMHWL8NsH3WLAv0E3ApWeXW9KYhnsA3tHtbW6uJ0Wbm7nqDCjbqCduirlJo5sUxa35DAqzsZ550MCDmsIcXR9AaeZhR52bdRzCtBh+DyEXF3DwkTLSG3N5K+9xFZFfchW3djAVqx8eKHCnyvcUN+e9IjaDy2inJg8q3M94mFTA/el+mYIHGoUOuZkxuH+nCEp/Mn7wsHqtmxs7BROJT7J+DBZH9V1u0ZiGO0vUdte48Hjtx4ZjZcsuU4gP9HYc4FR2uN9P3+82ZPUdbn2QwSa8M4R+0MTBQwYhMeEaQTG8+h4cDqBvZtbc33Zxc0x1cUBjVnhghvog056vqXbcDYnrY1LyTZ+gIQ8U6PbShXB4JLwH8UW6HfDAp7oD9HcceLSx4aUIJMdJej0p7dFurHxJHCxkNuJjmnkbOeIuZKhFHhryEIltzfrMlF2eatPxQ486lpbcC3QLcWHLLoTm77zJnQ5+8kFnuDB9B0zFkwlp4xVNNxeOLealg8Or7DJcs3IMTUn3GhxsDlF0loex+D3yVt9FYVXU7zj66nB8LdA76fYrDOfNMlZ3Yl6a5eGuuz631pXalKsXHi51GFI34+andoFjlPOLu27lOrhk9c2J3GtEh4cB54WBOlAICAgICAi4XOiKfhB2oWCtnRWRWfy/bIx5XER2ikg4UAgICAgICHgB4WKvGS4lBupAwRo9hGJzVWcVHGrqFHsREeNxI5i9S6+yob/WrZpyi/+kq13Sv/O61KT0PFXndCZCouXvqMbo90p7rNJ3jeohDz+X0UXkRET2fkC3hLZu1q2UTQ8zw0PMkGrH707CkDTnwJdc1dt170tPeZ+x/ie71PTZl+vX9zztl/EwFLZimJjrdZG+bVM6E2HlCzprgqfwKnyuNKN6Hyk9qdNCemk9vTnqf3TxSd3yXjzj6be36OXwsSlERBKeMdDzMPk9hAbJ3bmiptt/8rjdiMi//8TXq+k3ft1RNf3xk9vUdFJ/VXimnozHbas9rs8X/WJj0fUn/P0zW/YwoBZ1RszCy/RyjDzuf0Wt3+IJfVv3u2JcTFgxF4q+OGmMeeCsz++w1r6j/yJjzD4RuV1E7rsQD70SYY2zVDJMWGsY1k0wDUgFjyytsEDWtsFqNtcn7IbmT2F6TnQ2rbYdMH1IJ+c9GfKNlsDqds59cTp6eyhu/eT8SWowLbz1nbCsIlxb5YB7seZPpZDnuPAeKckphryDlT+iUxdSkctDY9zdo7zL/TgD0coOqO9081o/0MdAwDzcy6Eu6AohrAMwD5aTsTzR2h+5jdA6jfxkVxC+sugqqTlMi7n7fv0ql8/sRi+yUnZhWS3vRgjGUZQfbd6jsB3axfbNf8l1zC8J5gW/o/5bL96+WYQHjcLqFWj5RWi7susszbH4O48WeQrwdYqbfYcuDo0ptBUF7DJ0J4AY4lNgJoy464onSJlnnul+EZ+v6WaTQj2nV9wDGcq03Sdw2QFbrLwTITfp4kIXIVr9h6xYCAWaGizeYP5FfaAvzGo0llpxdkrkCmJZFrIuYOFOo0/WXKesQIyRTB+iPtVHtedHhq3cjhf/kltvdgpWsgh9zmeTFZSfR97mXMetQZxy+KijpzQn4RICNwG6ZZANkKMLBD+D+VEBe4JhEitXuXQKK7a2uefdeMAxNe9/5IArO5gT6TL6DfKZWbPRvYjinPvSoP4oZklBQzI8MuuuPmo7XSciQ4H9n3XBcZCox8dDEiFgO1nUIeav3CoYJBhYdGlkXycjhSydXtrI0En3sARCwqbna+4eM66tM3CBoOsTkV1z15f3oP4YwrJEN6ZLw368gGuG5wUG6kAhICAgICDgcqF3YawNS9baF291gTGmJCJ/LSI/Zq3duBAPDQgICAgICLh0uEBrhucFButAIbF58no2Ju73FNP6i79yq26W63l8a5YnPZbTdb+1jH5YzxRJj1Dd8FBNTd94UvehFvFbZ5MJvXzHGrqQW+GEv3wt3aVeTh/XLbcTnnHls8FmEx5Kg2yKZp1zr7R+t8yyXo7j9+ssBBGRF3/vE2r6Zx+8Rk3PndGf0blZ90XPP+IXFKx7sjV3RtfsMJ76oKCU+l1bPzntTOrMk8aUfq/Mmn4fL4tERJJ7dF2QckavkylPf27t8isj+k6Gxz3k8f3fr7f3fbAG9KPkl6eQHbt1zZVXTRxS030Mha4nhKeIyI0v0tkOvvClD3/6XEFbEX8Y29En/M9ujHjmBc+9klM64ya3rLPLRERSn9GZLyu3Dbb/ozEmLe4w4c+ste+53Pl5IaOXcVaqFF6hkRjjCK318evpXzyKqYC+7EMnoX9QpGURlsZMIrICM0xksgFxsylnNatNwO8dokoU2iMak7TIxYUhc8sUgIT/NIxw+dOwAMKHmcyE/CJ9pN112XWI19GC3iYzAdZthH9LNazUkcd0DZbmYWoaoB5goaaPd7sE33yEz+xwrZOg/zWdzN0fhrKkDgFDbTIsHH3KKazIdqjuyiMfFHdE/kqwVqMs9cmEpOrUczCxZ7TAuGtBbJjiirmFRKwsuVVYzvus0qyD4ROuXclAYJ1QbDN/yr3T2mPxOa057TJC/YKoD5KZwPdIQqQ+g/JBfJH1SVZWegWie2BDJKFBkSPzo0wGjkuniGZ+HlZniAFSz4Oii2s3OFGRwmLcol7dFn/nR2wP6EWQXdAaY6VZMRSzhKWalmhqSrA+mVdqUbDt2RdoOSfjJLPg6rc77MrQHIOffDbeZ8gOYKjX+h63nqE1n+MjMQa9AzAVctD96OaspPuWJ5EIa4NjFaFAF0ixiTMSmJcmGD/5eYgxbnMMBoYzJGo7oUPQJ0TMde5X3+wE0P/pYadblsK+g32Ue1bWbS8tUppDvWJ+6kAjoTDv1qM2TfFFl2cDFgDDrzYZ0jLDvKC/o90oYmnTGLsQAqUwZDqLvjRfwO85J8R1PbhNIzuJ7IJ0tSPpVbBU6tBKAeuBDI828sh5oLzDfd/BMjKa3/HoNMZ4e2Sw1xAXC4N1oBAQEBAQEHAZYK1I9+JHeTAi8vsi8ri19tcu6sMCAgICAgICLgouxZrhUmKgDhR6GSu1vedarUundGvZwsv9DAGf5daO6hbPXF632iZODnmfIXs9iueeDubrdpmUXg5fOEkRkVZHb/pmR6+rER459+GqN+naCiIiCQ+3oP17V6npGrtEZNMi0I9qv2z12b8Z09vJtj1W9FW9PjKvWfI+44ETe9R0+oz1oz2iF6RT0cvRvU6vc5FN/7R+pE7ruhK9PboFOPuI34zeKXoifgzr/bazpFuMUzqBRho36HkSEdk+prO4my/XmQuVll7uRMp/0mw942zhFTrzJfUbOvPkmu/XdTZmn9L7h4hIram3+Z+/46vU9MTL9Er0RS0RETm8pDOBfOXOrOvppdN6ex/7Xv/8MvpRnVlgs57IIUt6+y18tZ9hMv4Jv4bK5cIl8Id8hYh8u4g8bIx5EGk/Y639+4v94EFEL2OltrsjuXmogTdoxYQ1n5oINVq3YT1DhNyRowhNl6ZiPJgKJVibu1bSVajPgwFAqzq1FRisaPkm+HzTP36CqunIQyWu6F/LxC3mVHDPrtLSSws5vqeFD4wE5pXWUlrzcssuQ7mVTpS+aRV2f4ZOwFqJUIhtWPdrB914zR+Djz2JCXUwBlpUs4fVfyEeASHSHViNsylSCFFXONPC89y7hhbfJKIO1GfysfuQUSEiUtnFcJvxe0d5RN6a06iXDBgbdepD0Mrsrud6pXQaoQERxYNMlNYIQgGuufqswoefWgAW9U3dB+a1uh3tiiqn5ZZsGBERA6tv6gwjGCBPhbh1l/oO9D+n/gDrq3DCdQ6bjbd9oub+tqGaP/K0u27xRa4Muah9qOjvnpPBa3vjWtcuZH5GjBQrkjnu5m1asA3IeoxYwHuyTNSeyKIekzX0f/jwF4+6wWhabfzevXtopS7vBPtlzd2HZFvmKTvnyticwgCh1hXCV5JRQR2I9LqJxhLbqDiLvoKfkuGRQuQJC1ZEquzepYkKQoba4dj3DegYNcYxTihjAAt7C9HZuD+5886nRETkQ/fdIiIimY1NFoWISBKfWZfM9/CJTpT3/FwD9eLqrbHD7VkYJpKRJxiFpDadwvVxBg3ZEOW9gochHWFBewh7n9pw92uLex410jjXMlJfhmwasI+KJzFJRFFXupJYdh3O5sDsGHGZqU+AqYD6KyyDjYFlCVlfnVK8PjsMDdq56O/xCEFD4XkK0zaSO3NukRZe6QmT5tlciogMH9a/y31O3wis3KAvbjP+PaEkcp58eXbQ1SO6D4Fvy5tb9Jevtlff/HW7+m+erOiik0f+Xj8cEPFvJJs6Qzx6UffDJ1I5X/cf1qQz+qZwyBO2ruvZ1Hc+rLt6iIgkPS4d7Z3n19+KT+vPTui3ERGR8nVbfKmg2/CE/tviNhTy6Uc2p9dhuau7I9R2emjuW2z2Vz+wQ//C0xcSr59T0/NF/4Z0seoRFezq5V66xXNQ1NAPZbba7Nc84Tq713vceOoeIcUtziuvntTdKk6/a7+a3vLca+2g57AmqR/uiPiFHFMeFzDf9ckVv8tDx68JeVngBJYuepSHe8V/thzwLEHaexQeEvMiN+VckDN0WaYC4bJ8XHyQImCms0m5T1ZdGgXtKChYn2R4SND64RrGcG7RhnKMi2Hcs8lngubf4KYcmxYOS+YJrg35FcSXX4/PMQmIMGax6KYYW6JDN4O0tBCqkrHluYHkBpY7KR4k0E2gM+qelegTSo1E4vAqofsBRXdTUQg7XL+OekU4yhQp+QgLx790OSE9PqrL7ubmrD3CkH9oW4SBTM4j5BwNMaS6Yx1FdwwKf+dWsGlj6EUcCHSK2JwvNlEGbu7jB0sMD8k+ROE99r3meNw9JOaptppGuePvVh468RCph6nbMmRln3hoZ9RdwHB6FOTjAQP7fXm/ayAedtUnQQ1Hu7Fuq3tRty26I7h0urQ0ZzrRpjs3h2fQhWcFApEnqVbq/iQRGpShKtvD7qa5BQhyjrt3aSfnGjuNAwce3JRm3e+q0xRFxeZ8xl2X6jMmGYwni3q3WDvxkDHZNNGBFzeorNfSMVfRFK1MNHFwgLav7XYv2R5cN+miU90WP0xk+7DtN2n/cLk64ISg778fRg7kjVR9Uvcj1xMIGbLPpsudyC2jhT6QW3IPT8DFoVtAuFoISXazaPMCD13dvaMwtXBr4eFrB4evtgbXqY14mNoUXF4471Ekku91HlpFLhUjDC+Kw5pmR9q7ndGkl+2bX+Bm1BtxeV67KoWyst3o3oU5AKKx7AudLcJVX0hcijXDpcTglCQgICAgICAgICAgICAgIOCSYaAYCpI498RWRDa5NH0oHvMLCpZfrpvXm48V1PTvf9s/qOl/+luv9z6j4LH0+gQTmzv1PKU8Lg8drS6A1oZu+UtmdFPhk0t62ME73/aw9xmf+thNanp3l051TzzqsfTqZApZ9ViGRUSyHobCcE5/dtnDvq/s8ddhd7f+I7OiW3RtSc9T50V6u27//a3CYnoYJj4vEE/sza0YCglPnQxldat/5YBusW5v6OUYzvvZA+Wr9f6ZmtAzVVnU6SK7Z1a9z5hdHVbTt39cP2dt6HqXUu54ws/6jevS87Agxh/U56Thb5hX008veJgcItLq6vcinbIfxVmPS46nHO2yv3/Wp/VnWA8rZeQx/fraG/0BDMoN38Tgd4W62OgG8sALC0ZEsj3pUbSsTFcF95kW2uJpWDUhPJaHUFwG4fQ6JdfnWqCIF46RipuS1rgbQMk6LePxcUaKe20mLlQYWaRBb+/hr3Ti85PFMiKBv7RGUnCPVlAyHhjqL7nh5t/GNqxpEunY9e0iqf49sUn8H8+obacIIrI0hDymEEKu4D7nZmH1p3gg5z2KoJGKv+Y+Z+FakaWoZZauErDuI7a0aVNQztUtWQGFBVemhTtcOoUoqzuMNCZRHwyxCCp75jTa7Bb3rqg87iZ6WlpZZrYLRedKpymMiPSK+5xecu9zhi2s7oXlHFbqJt7dFDRkeEgyHxi6lGvZzIq7rjnTFSmhwkEfF7p2lN01yTrdXuIW9OIC+577nF1yhepBiK+bpzAoywoXH7hlNMbigoa8b32Grihx1ozk0R9wwwTc6dJryegZGYYGRTWSSdMGY6M4CxFTWKQbUwgBuoLwhgxZmaNbhbtxedy9l8hSqW1HO2LpQNZGIo8+1uxj/vQJd+dPu20S3UeSDRuFxcwuxkOCsj47EOZM5cBCMhR2RIhQ5LG8O4V6c/er7OYz3F8KrTLc6s3XnxARkUcedn4FFumZJbh1gOVBQXT2A7Kg6OZkOpuxBTIrjsbAsJD17Y4iQCFDsn4IisZyXU7XWDIWWuNkJWGcDaGei2BPQPSUYa3JcMjAHYchTDkPVbaD4VDHfRgetNyQ+jVOeJ5za2PCZYrzdLsUH1uR8CM6IedEuilHIpZbuItfaAzSmmGwDhQCAgICAgIuA6wMlj9kQEBAQEBAwMXBoK0ZrogDBdPULY71bX4fbp/V33pIDb/9pdeo6aNb+ah7QjT6MFz0WMQ9jIb1rW5W1wvSq+ldYt3j//+xFV2oTkQkX/UMlBO6ybPlES30OebMnfCHxdy2Z0VNzyZ1lkDZ8+jODr8VPeHJ15BHf6N3t27BL2T0TrJ0q99BvrVHZ7eMfE63Gpd3632NYY40+Oa5XErPb/FjulP71Ft163opo5dBRKTjCX9Zy3us0p7+OZr1i5gcX9VZNz4L/uodet/Z6QkBufAFXXdEROT/ver/qOk/s/OfqelHF3SBxZ4nDKqIyEJF17Ro3qwzYoaP6eOyvM/T0bc4xffpRxhPKNKf/Xd/oqb/mw9/q/cZtNye8wz/LwICzkXHbIrH9b0WqevD/kyLN/3gk5X4HEardg+MheRyRXoQCmwjjfNqZNEDUSoKsQj9gfY4fPvXoRNQpDojrPhn3FxIqzQtqFFYQ1j46KNPqz81HVoTbryny3EBPgpK0ldarJHqTlh5MZ12h1zeGFIvWYVF9iqXiVYDmgZ1hiGkFkVcL4KWWVpiOwiDm6YlPNs399ByPuHqlAJxZGWsXp1FmdzndUTCzaxtVoyZcm3G9Vcb+gvrx51ZNwPdDFrz6YfO0JSZCq2+tE7D8kpmAvLYGXJ5yS67NUR1l6tvWkXpz77s9PQkgefSYt/DXNmc3Ay/Z9ZdG+UW42EBWY+FOViL8ZocOewuIIODWgn0Oad1n/25NZ5G2cFwSMfrokkyHvswmAjNCV6HdsX7mGEOu/lNTYzSKfir16lJYGPlzlMbAf3R4uHUJ4nGD6z/ZAO0hhKx7zsQDGX7cZxRC6G3AZHAalzIMBIQJfsGFviRwxiXBRMxbFLw1WfeyKSpT0LjAvVLMcalF4+661CfDC3axHKnC82ELnz6Oc5edvPTIiLymYevRl2hr2BcMY8cV/kFd7/CIiz3Y8hHfTMEJPtApJUw7fpr8YhjV21cG2d9lneDBYNtSHMsrvHBPKXXydKATgFYzwVohUVha9c4l0LfYS3OTEhVXJ1mMR+R2ZOqU+cjFdU7WQsRK2UbtV7Q7zCvU2OktQOaLBuuD7FPMARv4bhnnRmwJa6IA4WAgICAgICLi8ESWAoICAgICAi4WBisNcMlO1AwxvyBiLxZRBastTch7edF5HtFZBGXReGvjDH/XkS+W5yX2I9aa//xyz3DJq20R89lFiRqHovxtN/6LI/r1uHmlM5cGPv4Fg7THvi0EryMg7KuGbBzck1N3/CEFhTxh8X0qa13c/q9kjm/Guqe1x1X0596bJeablN6uX1IVvwaGIW0bkWvtXX/aqpK92Pqo35/7MpOvU4K83olzs7pfao+rPfDzvV+C/7I53UmQverdc2A7rxurabStAb6KD5T0L+yHz978ANq+g/d+y+890oO68++9eBJNf1Lj+1V0wsp/xinv3Q/Xvc996np73nodjV99RPb1PT2Pj896b+depOafuzTu9X0zI26lkC15Gc5VWp6Hyl9VteB6eT0Ou95xuWOHToLSERktqyzP3wxYH/8g9+mpu++dsH7jFOzfobS5UIv8CMuGC7FmkESVpJDbWnDnz416+Z7Mg3o10ukYR3rFBDqr+jGWC9LJXOEYNvm2FrZTkGaI3FdBvr3RiERQVyrHITq/BqvhxWySSsv8sDwvDbuy0wrXHYNVlNEc8iuxMvQS1NRHiyDLNXW3VxZK0CXANbTZFski6Feh85D6Ygrb3VX/P3fbsEnHDomFnPK8GH4NMNqTOs8rdJkytHqTwt58WQ1lmeKBjByAn8X6RCk6BuN9MJZFnvQRbnushDOMMhrBr7dtA5TWb/biDNAGE6Tz4is/hmwMsYQtpD6D7D+16bcZ+pGcK3Vz3qlhZ3aDQloZnSMSHYp3pfISCATo1NgXl16fdp1juFDrh4bYMukKtAhsO772ozrx7T+1ibjUR4in3SETqRGBpX7O3gPRWs4lI3MBNZtoiWSQdhSslEESyyGBq0jL8km2Q/ugsJpxwBpTCOqQyEeXrM2Ex9XzDuZB2T+MDwowyfTqt9EKEGGT2afp5YAI52UZrtR2zOiBEMqJvpCuaZhZa/uY3QH5MnEtSg6+XifaCOE5UtvOCwim8wErlmivoGyDB9F2bruBo0x6LJMx0OSsl16mWSkN1BAFIxWCZoHVztmAsdYbZoMDomhWyJLK94OHUSaSELXIz2fi9UJ9Wryy/ExX59weR062YpdP3TYhQWl1gvHR3NbSWpTqHfMIxsHwDBAtBgyq9rQeCETKrlMvRjkGd8zWmTSE/r9YmCQ1gyXkqHwRyLyv0XknX3p/9Na+ytnJxhjbhCRbxaRG0Vkh4h82BhzjbV2y1geqYqRmU+eu1HmZHgODvrDnjU8SmTJcX2T1xrWF+mc2PVn6NWf9LhCGI+wXspzfWeLzQYn+H74NvWmo1OAMuv+DXdqp/78q/9Up6Ef/hF9g2c9VZie9Ysytj2CdOt1vV1zab2PLLzc3+W0EKUiIuU9et2mhnWXlczDet/JbrGfX79Bp99PvG9Uf8Y+/T49v66e1+eh3c8LZp5u0TfQP/SB71LTr77plPfRh9b0Q6erh/QN5pPzeizSjbb/oC/l8Yb49MJ+/YuO3q65Jb2h2rf4D4S+eP9BNT15tT4nVdf0vm4KnjCTImJP6C4oxtOlE55bMbxWP1Y+qx+kiIjY3fpBTnpen0e4COnHyWP+sK2lw/q9qrsvTcinflgr0h0gf8jnAf5ILvKaQXpGupV0FC4sP0eqrPuamxMubiOxRlL1QbtulyDcthLfENe3F6JDW0thsCIFw9xnbnS4OYvo4cl+cT58jzk7jddJRJHH/SnA1hwDPX5JH4uML9/FJogbV25GSMeu7djcwETUd4Q0ZGi9hFvzS2uDmxS4TVBgMBMXQYso49jAFk+5wrRGIW45AjE7HHok6+7d0phxDUOhNoqukTZf34a6BNXeoG5MZzN8XbeOkH6gNzNkHDeQTbi8ZeHJlkOb8vCCbduBkCFXAb0MxAAR3pMigf0h7bjp72BKt+hc7WFsxBrxzTthOiZy/4zCmoIeXjrJAxWXXprtexdjc5hZhQsE3G9YhuKpOtI5pyZjddGlBiTC6dGYY/vd3uCGZhBqMbMa32Bn1kQyZW5gcQiHvsUNbWEeNHbUI8UsLQU/sVZrjLLfut9HBwn8i7pgX+DnyE2wE6/n/usYopQUf46rRNtGQpH1KVePdCfiJpyvgcakW39wY1+fQt9ac99TSJXt2YLB8vqDp0VE5L7H3LqG4ZZ52BGhr/opuphDiFi6gaRrPPChK1EqqteNq+Jri3YhHhK007f0qG/HvdDWCYSa5+EdDbhRu6A+k7CJjBx2z2VoR45xinE2RzEXL+H+CGNZH3fppdObbjxsk8qu+BirYvnI/tkvtNmdxOEiDpDTG+7ZrN9URS4JBm3NcMm4FtbaT4iI36QVx1tF5C+stU1r7VEROSQiL7lomQsICAgICAh43iCsGQICAgICAl4YeD5oKPwrY8zbReQBEfm31tpVEdkpIp8965pTSDsHxpjvE5HvExFJjo3KwkvPtRaOPOWxxn9YFzoTEbnhG55S04/+6dVq+upNuiFk6LCfll9rnZ/wR7ej3+vw43roOLPFcVHacwLHU/V+ZHUmvVTu8IveHVvRKcmpl+j0+6HSM107Aot+hsJqTf/O52biC7c4ut0ftq415RG2fGBETbeek8j6tbolu/iYnz5A4aB+VPboz8h4iuEhG4jI5slyP8pNPV+mpedp6IievnSVzswQ2QyT1I97569S09Oe8j161B9WcWhNr6u5o555wSOAWJ/R7zNS8sTdFJHlSb1ye6f0Otl246KaXmtu4ZLjYTStZ/X2m3hQL4dPdHL5tJ+hcM2+OTX96ao6jUfhz/oxvscvLdvb5pngTujj71JgkPwhn8e4YGuG1PCY5I+nNxkItKSi26UhHJeFYBjZqRQOYxjDBCy9lYNxunCiYyMqdkSvxauJFj0yCSmwRsteoh4PBUeLIa1yzCPp17w/qfaZDVgpR9w6g5bd7CpEGWEJbA6R0gyRu3ycQSG9zdCx7N7McySyyvqD1bcFwbbhQ0inVR/W+Sxo79k1WHbJ4uh3wQM1vDHt5sX6ZJyZQHeP9hCYCphyyYxIkbpsNt+ZmfV4iEOGXGR5R5+Kh9tkvW26KMQ/k4HSy7AeYbHNxSnjkcsLPB+bCGNJ4b1IfBPTM69nfrs5K2kwQch8jfolGAW0/lPQzqZp1SdjxD2DbhpNiPVVt4NOjvXAOaJ2nNbY3LT84npaeC0EDskMKZ2Eu8DwpgsR67OwDGv6vFv/dCDCyHqkywP7c3vIdcLqDEJZjsfHFfPS2Ea3GIyLBi3mJnZdbiFuSSdjMRrbIPYUFt0FhWNuwLWnipGYZW7ZPZwijOwT9Qn0NbqeTHHicH9q2+Jjn/U3vM018ONPOhN7GqykTUYUXYj4GXlv8D4urz20ewFMldaYWyew3dsTCUlXGOoV4x1jkyEn2dYcS+1hhm5FG3O9F7FP2NdcwtBRl97EcoqMA7pikTVDl6ChY/XYc1sjLs9NzKmNSbYf2TXnhqem60i3wBi58bKkMNbNGtycyvH5a+RIN57HS4BBWjNc7pL8jogcEJHbRGRWRH71fG9grX2HtfbF1toXJ0v6RjUgICAgIOBiwoqRnn3u//5/9v473rLsKg9Fx9p7r533OfvkOpVDV3VuSa1WTi0JgSQQApMxwZhg/MDg6/t88b32u/D8jG3sd21zjTGWQaSHJQQGBBJCCKEcWmp1kDpUd+V0ctw5r/fH+L51au0a86iru1IfrfH71W/XnmftNeeaac05xze+L7Zt7dquGQp2WFBsscUWW2yxXU/baWuGm4pQCIIg1JPzPO+/i8iH8PWSiFzOTrYXadtaoiuSv3Sly7X31g3z+ncf+przXu9/6uVmuvcm2yNPAqUr8s5tE+ffukqEQtW+3ivZsevBhtt7mbB/4uJMC8lchi2ZcvM0dJ4dMdP9t9pIhHLerlsXR8TqYMyZ98BBSNl0eHQLDp6NwefcxG+DV1TN9JaDjO/O3bZ8YvX/ton45r/HlvcTEUmet/tV2yEn6Z11oAquTrlUREQqdZuXIHDE87/5R75ipn/o+L3OPGY/aZ91rt5jk/3lHWAAb5u5lrJVV/wm75CMdYyNl779aTP96RW3bKSs2/0wsddu87WKQ5Jz1B3sVz1ne+rHnrIrpe2Qy3TNIqmXbDjz9pMuogY72clN8xk3h8Jrv/tRM/1j5+9z/ia2F7dd6zWDNxBJtba8lvSsJujJI9lfUpdKo6f1HdWaRBw+UIadEmQn/WgM9SCVCEn4Koe38tT/6Ed2kVwGmGAwRhhLTxQZve+5FfweExJj+5lPEt7KzIqWtTuqc3/H12doTkEeshAlU+Ozp0jghgK2JoKQ52EwqhelL+EeY4iDBnFkCtwJ9PiRiyK7yrJGPYeM4Zd89HdbsdFa9jS9qVgC0Xvv4Wch2V0mGg/fu1s5aXpr2RBN0SnrvYrniCTQ346dAEllksSGQGEMWHZ4vr0omqIDrz/7EGPQ+QwsK/kdfHhFSaiXWKV0HapgSMKOazWv54WEz2F8epKe/2hZ63t1fVA6re+H2gF9f3B91xuJ9lMiEsKYfBLslaLEe+T5oAVBFKlAMrtUg/fVz9wSCfgCSdWByCACIQcuhTplTRUasHmHrh9bY2gP0Au1y8gD46G2HzH9Y6goSAF6IekiZCXHcV0iStJIT3pIlok6KMxrObogXOxMq8Oyn0mECACSsw7za/TBm1EhZwIQvg2QmnbHtA6I6Ln9DVqIZz6j/E2cCtjfibRhPbK/jz3bxn00nfNSKK2YYntofv3cVvvVdgMRg3uFnBNou8rdWp+pDRAfYp+R3NQBkwTih5KVRD2T0FZQz+UTUa9/a0LvVzqDsVlCmYGq6edJYqEfHE+cQ4hMGaQvJ9zEuMCYyi4AxTI9iJQls7KFWBK5jKQRaJQQ/VK+2b72a2+e55VF5DdF5B7Rkf73ReQZEflDETkoImdF5HuB+HtedlNrzfO82cu+fqeIPIH//7mIfL/neRnP8w6JyFER+dKNLl9sscUWW2yxPVcbiPeC/8XmtnjNEFtsscUW206xG7hm+FUR+asgCO4QkZeIyNMi8s9E5ONBEBwVkY/j+/O2Gykb+T4ReVBEJj3PuygivygiD3qe91LR05KzIvIPRESCIHjS87wPiMhTItITkZ/5umzNoie8rakrXa79dTsu+aN/8XrnvfpvsJmRE5s2SmCQcSgtFFwuf5Fuw+H7u0qvcdB1nAsVtosDsvN2McC71Crqc24ERn/Czt/FappLuWX2LEu5Q9RlfckBZfXtym2PObgVtlFB+Lm7Pm2m/8b/71vN9ONdG4kQfIud9+TfuOu2/k4bHfEv7vkrM/0/Pvy99n32ufunqx/2O/a0UXjGrqwPZe6x79NwTz8L77THX+64jY6gtNMVVnHn4VI1SKYdg+Ci3R5f6NiKDWPb8G/QSzVsvXGH0okD0dArbYNimbIHyPj32pwICx+1++ehERtR9PlTtzvzbpZcJC12sv+UQ8rSTbMhh0NX7a1hgcgtBT98sduNWDMkuirzS+UFKhv4FcaOwzO4gtjkNGUfJPKdjOn0vnVKRBd40ppCXpyjhuQCO6OMLUasPJUT8DqkV5IxxEQSZDfh4U1HvW7Mp3YQXmnWAv5e35XE/elNRVmHYvfJKZDoeWHs/gCoys40JCkX6V2WSJkbs4j1PgfPNFQYyM9ADyrL0AKDO1EBdbDi8xn5vT0xpDpADyWY+vOXwBSP93lwXieQpCeSpXcSzcDQZfILNSY1YeoRnbsSDX2YjXvLIiKSw7QZciqQE6EYXX/R41vbg9h/8jkANdEuk3AC5UiRqyHK6UBjLH+iv1WPRJXQy98Z0frJz7XxXd9Vralc5FnpgSUKJUSn4LMFXgf2zdCbj/j5ZB0x/T7RMBgvm0R16O/osc9sgquBiIikSOWQVtDY8RZ+q5+NvdpfEyPgUkAZ0lW9R3VfdOyRi4Lv0h7c+YMJMPjjPd5OaMcmRwkRQaULkApEn+RYZx23y3q/wkW8YwdAgfT8EPrI8b95MB2tN3wypp+qKOwD5CE4eM+ciIg88dUD+gMofZB7jWOS6CS2U2EhOrU1Zyh9Ck4XIBa8nv6gW4ruW9ojiRBBw/FPjpbusGQ3uUKgAuMPcVb4FaAwIAXbwhjNL/cjZWL9UomCqh0cjwN8b41ThSVaDvJwEJ3RGg+kNw5US5UKORgP5egYJd8DURil80A8JaPPnl3XPAtzboWua2k3as3ged6oiLxRRP6eiEgQBB0R6Xie927Rd6yIyO+KyCdF5Beebz437EAhCIIfMJJ/a5vrf1lEfvn6lSi22GKLLbbYrp3tJIKlm23xmiG22GKLLbadbNdozTDped7Dl31/TxAE77ns+yERWRaR3/Y87yUi8hUR+XkRmQmCYB7XLIjINnG6X99uBZWHa2bpfFcOvHTuuf/gB91/6jtUAvy/tWPq/aZ9yjT/OrcHOLFpV7+rfwXFq2Qe3ebgyxU77zk8vWkHQuF73/J5Zx6f+ZevMdM3f9S+Ppu8OoRCuuqGciTrdiUm27YHeDskict+7U/faaZ377Q9w/4F24M//bD9HEsPuPPubNie+l/81Hea6d4xV4O7n5uekyt+4vCW5xYd93rcdjOH8W1m5nY7+TYww4ms2c6SjkPongM58e63ftlM/8hHXmGm777djVB4aqxspr/68Fkz/aHTB830pINfRERELthz2Kl1W/kiNW6330zGfo7UhFvh5d4xex4+13Eo0jjar3XUDUN67we/yf7D6PMgBontG9K8gYjfCEK0Er2emY1oTDo9wJwuO+AfaJXh7YdHsHJQ0wuX4P0rivThpeTo6sML6SO22wMLPac8xs4nSXqO7pxBDDEVEkIP7mY0Jn3tTn3P0IvZGqMWPbxviMOv7abaAcpFxYTxKFN6op0IPdIJcCWMHNeLW7iWSKLMBstEJYQoQoFx1IyXH2Si6gSsz3Q9ihChx5Hefb9GVQd4GMGLUDsMjodVeCyzl11PfgZMKSxTdgP1ugZlBHhK27vUbZlfJImBfgxyqLc0Y/nhBUafCBn9Q0UE/Qz7QYrPJqgLxPp3qG6g6axTxnfnVgYhgoNG5yb7CJU6iue083TK9JxHve/83eqbkRn4tqh8QKUEfwPqEGX2MdQBOMNy816krPQep5eIttDf5efhpU550h7zw/+LiPSL5COBN38sOtZW70E9A/3Qmhl6WfBhRqPrx2BB10iFebTnBPpqIcptQfQtORPo1U90gHAYz+BZwCHQ7kvtgD4wlTyoOkKvf8gdAlRM9Ta9Vxeo3e+8+zEREfmzz6iybQCEs78efXY+M8dufkl/TyWR9FwFVTCKsmr7Z9ZxXUa/tyaiXA/9tEhjBgiaUfA6jOhv/E2UAf2xP6uNnvSjPAXsvwnUYw8or7FnoQZB9NGEtnfplC7e2lBsaU1p++Qv6EP2wPXig2OjNkvCFP2oHiJChEiFQLwsuCiK2jbeGu/Bwbd1rf5Wk7l3ILorjXrOLbbwjM9jQXlzbSUIgm12DJISkftF5B8FQfCQ53m/KkPhDUEQBJ63zYbgOdiOOlDo1n258KUrlaK6szZ82s+5N7DddXvDVthj79JHzjhI/cruPNKXHMRsPQdpWsLeZKXX7c1z5+DVw3ZcspGBQ4LuL87acHYRkebrHaENnx8z0zvv3DDTU47Tj76jrCIiuSW7Tvp2xIp0Ju3DGi6cLMsvOMp10j44qO2zy+v99JKZXv4Dtyzf8j4776mP2XnnVu3nu/RD7v7Zcxy+pBbsfptfsSfhjTsd96m5T2ZTDiR/8FabL8b787JdJoOklTZI2n16ZLJupv/5Z+35Opiwn3uuYpOSimzJFw1bpesgvFyz2zU57Z7/Q3Kk4fSmXSetffY8eaZuy2h2q+54oJW2rbiz9z5bTnJ/yQ6rOPmf7nLmUXPMxd1R50+ur91ijMuxfX3z+oFKrZV0KVTAho0kZqmajon6jPbnHjZsJLFLA9Ldz0UJDi+X7+XGhRvLzAph5/qdG9zsGha5frQPjT+pq93WdDZSNsJ1e0XCfbVs3DTy/chwjhDqj1VffQ+g9vnoAUe/QCKzrfInsIFMYk4hrD+3hI3lKuM49KN0Ub83sTksndWHpHxhApu2DuDN1T2Qg0SoCIkSGY4QhiTiUZqzhE1j47rBOohCy3nwUJgLQnm6JDc6o4Rc47BjXcvYz+PhEtwsQg4P9d0ewXdcRtk9hrZ0sWHtgyQwe1EvbO2KwrMz617kevadmS9pn2tM+6irICy3X8OByQWNvxiM6qFH9ai+axq78Juu1mduGWEbR33UIx6Zso94x4fLO1aJHz30yCynIr9jaAvDEUiYSPj81mEK43CQPAikeFo3ls09WvbmRHQbwjBTyq3yUCrgUoz35iEXyUtBxJ2ex4EF+T4XWGZA7jeiUP/iRa3vRJvEhQi/WdJy9vbqBpib+H4mEdZLc4owfbQRNtvNg3rP5DoIDXFo+AOvVafE//iqOiHYPwV9guOsXdbk3DLGKOeONV3TtyZ1gAyKmUgdsa8kOgOUC9KL6LM9kJZ2S15I+EjiTclhXmng4bjEBBl8H3/nvNXF8qZ4gWSXXqQMJIfl/Jeo6A+zXeST4331s75Ln6U9yk0+xikIEjme6IgdZAaSWIOEJJ2tmejhHg/jQgJUEqQitDQH6VKGMSWaCBlpX51z83nbjVszXBSRi0EQPITvfyx6oLDoed5sEATz4CeyNyPP0WJ8ZmyxxRZbbLG9QAskJmWMLbbYYosttti+vt2oNUMQBAsicsHzPBJfvVWUb+jPRYSY8R8VkQ++kOfZUQiFIBVId+bKk6XXHDttXv/wZ+5w3iuRsT1/A4fDmqdqw5Yt2l4/EZFUxfbwDRxOVcINr8jb4VkcK9ueVhGRvm97Ql2hECSZGrbBl8vOPO745jNm+tOPHDDTmz27chMOFA7hZuZvHAeMKUeVBC+1odXNV7rbb3xyw0wfy9ju9a993ibvW/nMrJnev93tfS581W6/jW+zyfCqX7U9xpmsm9SvWLDrpHPC7rcXvsk+n5x5yH4OykFZNvpuGzI/nbdjHk7kbNSLi3hRZMvDNGxHJ5bN9K8s23WYqNsDNuO7M687/nT8YXtsJB2opVbPPYUnHdECb/zuR8z0T5w9aqb3HOEn5cfd6J2z++zQsEtzdnr1IXsMVL/TPYd1HWE/lIe7GRYjFF5c5vUHkl5tSaKnc1qvANI5ep2nNWyIXm16qemla48R8k0PIb3aW7DqPjyAmSW9d2eML9loyEEDUPs0CCHp/e0VdJz5lR6+QxYPXkmSnjV26YSWIZHhbHTckiytA2//IAsPItYVlC0UeHoTl736covRtNwKUA31qEcwg7JQVm/ykQ0t80g2UubmTDQci2EHoewmnaT0oqJ+A67LCFhAWbujgNZfhBQekAqFi3pdZ8ST0kW9pnBW35E5QKyTQKG0p9QTnZ3XvwdJLaOXgRd6klKB0frqIAyD0yTh1QnAsVszUWQCjc+YR91y3bdyH0np9Hv5FDzD9b54fYR23KvoxcyKeqxzC/rZhmxgAxD3+q5spGwMWejAu5xZADIE/bU7FPo5/P4MwzPwGma4B9e/409rBn3UWXoDCJ+9Wo7Mek8q9yqEjOShRLtQtnh4CmXZuHbzxtAJKQ3ehOzgMghDKcmIv6/frWXJIVKcfXb0cSX1rd6t0sSpJn+HPnpI1xTDiIpedut5w3AhvIpCOcgakAmYD175RpWWft/fvk5/h7HH8IuRU5C2RLsQmZBfYp/VMgRpvW/+AtATZYwr1GVmReumNaV9u7qfcrZ63w7IJBvH2lcgpCmx7e3WhUNQQb0iBCK5FiU8LWCJRqRHYRFhFiCqJEoi2YBc5CFFOiYhv9oh+WaaqKcoumX9Dv1Pfh5zaRV1CrSBTHYl6HOiAJoFY4zID4bIci7lmJr4iiJdA6Aj2OcYfpNcd8TWXge7gWuGfyQif+B5XlpETovIj4m+hD7ged6Pi8g5EbHZ25+j7agDhdhiiy222GKLLbbYYosttthii00kCILHRMSK233rtcpjZx0o9D2T6PCLpw6ZlwcOWUMREa9he+X++Q/9oZn+UPWwmf65eTtvEZF+q2Smpxx8IEHS9gAHDqRDq+TmUPAcioQuhILLs59y87LJs188aKbnV+wTufodtsu42XFIdU64T/ayq7ZXPNm101M5u64qddsLKiJy7rjNcXBuYJcrddCuxOAp2/NNr4xlmbs3zPTX77pgpn/xsfvM9JkR90lspWU/+8ABahh/wn7uhTfb42z8y+72O3d2ykw/37TrvOgI58+uuOuwOW3nv/rL9pgt3W33w/pL7UGwumG3q4hIzjEGSO40bC6kRaPtgFnIlidy2D77vvvN9OJbbBnGpy7ZdT446iY/bFVt2daEb09u9//9p830R99j91sRkXf93KfM9N/99Bucv7meFkiMUHixmTcIJNHuqhSciHiQRmNcPCUWsyBp7GB8tkErQonH7jj6dRR8IOIPQs9p+5C+YzJndbLiOzUPMltKU9LbmLsIErNd0XkkO6fp/QK8kAf1ZU45NsZ6k0uhtj/6zJ3d6sX0F9O4HuiAPfBM1rS89KgnOp5k1okgENSL5jF2UvMsnanjWnAbAMnRmYBsI2KT25NAgpDMLg+vZzkaa98CgZ7s17k1WNffBR7J1cgIR5QGpTAF36MogtzyQFKU9gTZor+p9VA7qPU7cnxDfwMOhZCcr0vvPbzSJM/EnEwPekDiN3pQV/BSykXnPMZxE+1Borgk0lnXxUt6QWcUntn+ICQILJzeFBGR9ZeoF52EgiFZKIghyR+wQTAu+mdviLeBXuH+bqyDwLPTLdGDDi8yHol8H5zuJp4A/0QOHmIQGLYn9Afsm4N0QjIVkPaRwBC8JKE8IfIgkodt6oPkODgR5SYaJo/OzVGCVL8X5geRsqeaen1njyIlSALYy5HIk159fbjNOzQ/9qXWeCIkXexhHU0ukdrtQCig/r7zW74oIiJ/+lElKPdQ1tJJkCVOkohS7zNyBmgmzDfZFa1Xomfo3U8GHAfom0Vwu4B3g8iR4iUgiCCNWcE2JbHhS4fcT0DSpMH10QVpbGpS+0L6nOZNRGdxLoiUMST8HOJMIPKHFgC5EBKJotnIn8Jxxbpgu2++VueA5CWgbcCdMegmQ46KAZBLySbHPXkcouiHseN6LxKutscxoQVR3plsEWIHNsj6mtlOWzPsrAOF2GKLLbbYYrtJtpMWB7HFFltsscUW2/WznbRm2FkHCp5sK5U4bLlz7hhg/wGbTf7f/9r3membd9ouxH1H7HhsEZFGw/YgutQLAkdrdUu2pzCzjQKIy/vtObzrLm9uc69bXiVw5O/1bPRHt+aATTgs6W4+8ZtXp35Sytle5uKvuSnj3/X//ZiZ/ru/+XYzvTbukKycsutw30fdz1CfKZvp55+1UQXNn7AD6vsDNy/reM6GIiy37XI1HH1kz75VM33w8Wln3oVTduN+xw98xkz/n39me6UL8+46dI2zlXvsvBkrO2yptN1+3ZZ7eq3cYc8XjFcctsyaXdbGNkoLLgoH1zziau9Myr7Rrn0XnXmfXreVIVz2yVM2f4P3NjeHwv/4izfZf4hlI2N7jhYkE9IfyUqyFUUHUM7QB1KxPqOfPQBvMhAlYdy3UF5vCPXoL/sygEct94yO1bQ6l0MJN8Z0t8tURNB3EVnQMwvqau0X1EXYmdRCULWgOKeexMoBnfspiUYuhhIUqOp7EVcMlZ7uOBQDyvr77oq+f8nVRI9uuiJSn9W08incu7rFESGy5W2kJFx6VZ+BiIXUmo7j7ii8/+koI3xnjJwV4Btogtkdcoac/ZLgq+mXkHEKXmzIROYgV9hBjPv0l+so50C6I3ovv6Ke034eEovgVNi8W12jlLcLfMR4A60SerZx7/aQiA+VsAKurVg2xNOTcb4AECH7Ej2ypXNAJsxBdQDtW3pq6/05SI7i+bVxRk/o89WhREDlbaqPhMpS9MDu13WAtwTEx7j+IJ1HnZxRtAb7bLoSje0nLw/fnURv+IuKHkiOajk6Y5DvgypFahMcD9M58aAG0JzUeqnv4b303p1xyKJmo+/b9hlF9CaA9Oy14dmu62cWfBAcX0TokKuhcFoLn2xqRvUD+qzFU1r2cLytaN8lMiFEcaA4nRGRNsoo0/pcA8KKoQ73Dx78WxER+W+ffIumUzIUagQ9ynQCqchxRARUss0xq2OSe85EX58x1SCiCnUFzpL8kj7byr2AE+B39QNANkDBIfCDrUEFpY/giL7/E5eQ5xwQAVwv4Hqii9Jox+wK5DRb5PrQ7wOoZRBVw/7cLhNxA24MjKsG5hgiTjojW0gEEZHRu3TS3VjXgZNcSUtiD8p8RtNYj7llzGFYDhOxXD2gZcmuA1l1AmMd831yU9u+fpvNyRXb9razDhRSA5GpK6HrnHCGbXDfNsQbn7A7VON1Nund7rKdnvfdpH5NV3hBy7URd8ChHWSNhaw77zXHgcIgZaeH8jZDlrvoluVrO3TtCakaNlfohssSU+6Nw6jNwykOfjnxE/am8NyD7iHyX/7mm+08jtr3Cjp25q+5/1kz/ZmDNuxfRGRt2ZYk3P+j9iav/D6bEDL7PW55nFTCrl8X4WWvYLd3/UM2ZD4XuNuvsc+uw8XhVRyM0OOrse6Io6/P2309XXGMvy84Qlb2b7OxdfTDXtnevGfWHKdnFfepmot00nutfVjqJ+06n5+3D9UuXXAfGqQKdifJZO309nzeTP8P7/gDZx7/xxM/YqbfLNnIQGLZyBejBQkv1ECndBwX6pRwzK7r97XdIGGcxQYBUmYBNNsTNQxsLr6Lg1BqTzxsztA/S3NR+cf8Au6F0EavpWsZEhqmsNjt56NjfuNwdOFfg4wkN6otSCySrDQ5i0X4go65bgbEZBleh40ZDjFzi0EYKpjCoiXZxsHCGuQgoXefPQ05w5LemwSSyabWL8kbG1OU4CO5He5fo6QmoMvY2Arkt/tJwNlxgBNgIk3CH0DHB8MJeiVAwOs9ySzjwLRPgjbKY2pZfIRENHfr5qSyHxWKInQRoRpKWA5JLG7JbGKTiANlhjTwPrWD+jlyCptxLEP9BqH5ILi8sKE/y6K9PU8GhI0Dyt0cIl0k0TEJOMPwDEy7idN6fRtEkV4Fmz70Xy83iDyTfxF1U4+GSHBDRutOl/B31C0I+TiOumPso5604FjpMioO9TL8zue4YX32J3D48SQkXHfp9VmQnZIokgdhRYQ69NDHeEjIw8PCGV2zMyyH1tqHDTXas4NQFx4eJjtbG/7kSb22jfCBV91/QkREfuOzb9YfI9zFa+HA6ywOElajB3KlizhoyEXJTVmfqZo+e68IWVBs3uv7ogcOvSwbHGXHGseHtHyXByGlrqRw4NVf1QobzOm9GNY08RieG/PIMLEhjX2iDYnKdAVlxYECpS7ZV3kg0ZpAuBP2CXSMFs+D/PQ2hDrM6+82GmV9VswV/cIgPEjIrHK+0LKk4Kz18cn6IWEtwzPa01EnZn+GZbwxAog7bc2wsw4UYosttthii+0mWSz7GFtsscUWW2yxPRfbSWuGnXWgEHgy6F55sjQs10NLP2uTIoqIyJttL97k+2z31+pdtpey+PrzzixcBIiB43CsNWN7EFN1+wetrrt5Q8jgsDlCHjojjuvn3KRwg5z9gKP7Ns302jNXBzPqTbkRGAPfIUHpgIG7vPHdsjuk47aj82b65u/vNdNXbC48+cIzR8z04nF33R54wvb0Pv0KGzpecoSAuCQ5RUSKvk1U6UJ5DBxSq5t32nWbX3JPpMUzdiZ/k7vTTPccMPftZCN7DqRMwyHD6p2zQ3J6s47r17eJyXHYwcNLZvq5li2r6EItiUjo+Rm23sOOcfZNG/Zt1u1+6Nfcp/g9B6ltsNfut0f+p12H/1vjh515lC/aD9iacf7k+lqws+IhvxHMGwSSrLSlNY1whH6U5CxFYsM9dEfDYwj5vEEHMPoqyRoBcwcxn7+cCEOlSGCcW4J3rASPaZfeXxKtwbMKSTjCyXtTul4heRy9kMU5HVNrd0RhzgTdUa6yPQ1I8hO6VukewFiEB9hfAuR7Pert6+UUxSGy5Zn1EVYRevtbIOHbr7KwfXhaUyC8a86qJ7E1Bk84nfqYn9tTRIYQsQDUxpyWvcFxlYbnG0XPVKPhGXkQxrHd0uv6DguSngSQ5Uw0QPQIMkCvo4Wo7Nd6KZ/UuSgLr25rnGgKPDLh6yMoRHNIDtJn3aAOmpQDJXkdL9T7ZBGewFAVEhrS6++vKbKiM1MMESGVIyCWBGKkugdEguwCaPvmfr2X19IyZHcjhGwFXnkCarBuzi6jT+LVz2dOAN1SnAd0Hh7eNIgtE/D6MyzHw7N1IQ1IZIo3EKkiDKMPlGwP68TUJuoZYRmJhQyuQ16QOWwe1Dy9OklDtYwkYCYhIUNVMhXcv6oXsh8MSF6Ksg/SCHNCCNL67RgPa0GkTppTW++d9kFNfPVRhcR+8ZFjeo8p7WOZr2ifak6T9C9K/ufX0JeS7PcSMYYysGwk6OxCIpZ7iPpuePWxROE81C+iIwBxQunFoJOQHpDbbFsOMc5tvdxwf9UPevlDNAqkTFNDEZN9IBHao0BxlKPPSKQWv/sYH7VDmAswLw2wV8mOaUFaq3q/1EZSegXNu3AJbUe5TRDcEu2TXYU0bBkSvBvoYzVtvwZCHDhftUfcyOtrajtszXBjcB2xxRZbbLHFFltsscUWW2yxxRbbjrKdhVDoeZI0Yo3Lxx2EZm+vOG/V/1rZTG/dY1/vkk/sDNwnXc4/OY55/E37DzwxH7aeg/xQRMQvub37lrlin+vbxHCnXB7Mj42byclpB3dE38HfcMyhXygiCUcg9cBR3E7frqtQAsqwi2tlM739Mvs5kpO2x//Ae+x6WrnXmbVsHLEfZPYLdrve868fN9Of3LA93yIirZ6dhwtZk16znyP1Chvt0ymWnXm7+Dd27bbvtbRqcys0ptxEn6lRBwnhV+14/qRjjNf2OkhRV9zntdk1+/nOj9tjIyg5uBXObSMb6UBttKbsvLuOMeCadygpZlnCMW46bbtPXXqD3U6l0+48Qim0W8R2mgTUN4IN/IS0dxclt6AeKxL3NaZ1LLQmEas+FUUZhPJk8OD2KB2Y4H3hicyJ5BeipHP0vlMmkrH8RB6k21FUXOuQzgnJBuKs4e3tAgXA2HuWxa9GyQM5XydIdAiyu9QqvJXgTSJvQR9TSm6ZHmQv9Epm1nuRZ5BUdG7oAnWRn9OKak0qyoIeaqInOiOoP6xASUbbG4X0ZUbzq8M7naro3ynHF6LkMD0QmUBvNFEfA6ISegMJfP1R84hyv1B+s35Y3x05zMn13VoB4fpsaBoln1RXMJchplswRSe6UXk81ivRGLnV6A1zy/rOHpYtJA9B46CuZZLtgbRmdJ7slOD9BZFniPQYen144EZgG7fmgWyoUx4V9YZ3N0kt2Wd6eSATwPfB+PdsmxqPuL6Nzg1iw+YUODPYR4GkaE4kQk9/DwDhQQFSo2grypZ6WaJfiHZB/8Qan6igNJbxbPP8PAggJ7QdC88qmd8gD8QDxngH6AmOWcbNEz3TA6Ff52CUz6Mz0wsvet2xUyIi8vlnFWWaATloZww8EQAucw5gvbIPFOa7KIsOhBwIDlsTWjb2DZaVqAt6+8lBwnVtyJtEBBCQggMgFQJIRCaqqRDFwjEZSqwuguNgUr+PnCXyI4hcR36Cvk8JV5QFFUoEViixib4zjKIZFDlXYqyXQRBKzjGUr72kNyqcJxeGSC+PeQFIqTTQJX1wjTA9CSLWBDhdKrcB/VMvoIzgt5mGnOc2kvTX0nbammFnHSjEFltsscUW202ynbQ4iC222GKLLbbYrp/tpDXDzjpQSATSL1zplVt9wL7cu2TzHoiIzL5i0UxvftAO0N18re2+rLTcygX9vKMjOZJd8eC9hO3Fa7fc6IFc/uoQCrm0jVCojdjpIiLZA7YHuLLXljbMP351spHlnC2FKCLSzJfNdBc/xWbbLlNxvxvFUj9royDKh20veqVqe75X7rPzbrzGLZnXX7TrKuVo8y8sHDLTC2l3P1hpFsz0btHuoM2Ddl/wHWVy0FyIiEh+zs4j/yo7j3zBRn+kWnbdioiMjdr126nb7VT81gUz3f8je04Y9hZdbuv324M5fdZRXseckLQfW3/iQJJk9tuKNMt1u71zDq6LV7zlaWfej/zlXWZ6K2/Phw++y0bQ/M0jdzvzKO+2x+bm+Zsj87DTGJu/EczrB+JvtKVf0MmoPkNPIC7AqzW9ibhixH0n8PdOGeiAEYznFuP0EZ/d9ELGcXrkKJfGT8ZPZ1Yh6QfEwiDPeF94XKd0buC4ZhmbE4RF6EftAMseXRf0RxFXDJ4kIhbo6aWXkzHTAyhcjFzoh/HSPuLQ6fknAoHzE2PDK4ch44Yi0KPahgoBvf+UCEw2ohwJRJrSs05EQngdjKiPYZnoNFjyO2VyXHRDxQl6/luzUAvIUBoxiproAgXQ96NlpaWIUkH78VnZPv4m4+T1ex+v7AwUEsgz0UW5sistpIPbAXXOPthPJ6QFREIKbRSWGWUMpSuTLANQKfAKU72BtUV+gh64MfhuJ8qleAnx6ytod3ijUzV4kYFIGOS0LpOQDAzlQMM6RYx/wQul/FiGJJQ9KBPpr1GiFeOG1cBnAkIkg2UW5SHZ96iEkFts4Zm1PolM4DihGkFzEjKqWI8T2cO+xbpNgN/DS/fljv26FvjcU6qe5S/rRX3ySEGWk4gmciVkwJfB+mFfpPwmPevZVfBogMulOY5Oie7PMdobWgby9RPugzhciPJFZQbpQBJAEBNBw7VEdl2vyUGJIreMsQRegeyqfg/nAvI7AEXRnoj2384o+Wf0gxKWqSq5LNDOQPb01yBpWsCcynoH6pH9pzAXSAfPRR6NdAXKOZR6bYDDZa/OR+kN1GuoNoPxhD5ERE7fvW27prbT1gw760AhGUjCkCtLnbcX6S6ZOxGR5UfsTUL3JTZJX3LBzqOecbPC+Y7988DRKpSmGbbAIfUoLXfIQ2nC3oz3HLDnvO84ONgmj9o5e2GfmrYPX1xhI8OQw+divYI9SF0hD62mY1Nf22Zm8e16rzXs3/Q79mmG99Y1Mz37KfeO1BUS4KqreyZtAsnPnbUPGkREMo6+O3D02937Vs30+VO2/CUXYpaNnLPzPrtgSxXeNrtspi+MlJ15TGbs3fjZV9odsf1FW/6y9Rr7UGbkCXc4wuhX7Y64eaf93JRJG7bMunsOa+xzkBa6DlL32AcN2Y59n8c+aB8aiIiUz9odcfF2u672Zu1DuOyi+xV19F67zR++SQcKsb34bJBOSO1APtzUc4E+SEc3lyERH4Yh14DZRWxGO9zR6Qfh2X5NJF3BRqlJcjdAeykFl9dMqNsuKEN9l75HKCHHTUUoETgZhVETSsyQBoaghRszQsdrQ8SIWKgT7s6NVGER4Q1Jb2tzMKZl4uYiBYgxpQAzG/yOvPFa5UKdhyo9yNmxHhmu4QGizTJwE8EQEx9nwFzw87Ams6k39mtaZm7SSR4Y+AkRL7r5ru3BxnNNf7uxa0jmEcb6pPFQI6xXPBOv4oaX9ZvZwH82cMHQay/VBBw9yfbBpgcbYB481Xf50iny3ppGsj8S2jH0hoTY2Xl9ps4unXdJvMlnzF/AIQueIbcyiDwT649ylSkcGHTGo+slHj51INPZGuWhgOATMPrxIHSMDUBQSDj+FeTpkI3MLEQPUdhnCgv9SNm3Dr20jJSJHGChPUD9BggTqBzAIYDvRX6/dTgjeFYMMDTjkb3Lcvz8rkhhWJ9pkoSmuaHVdPYB9oniOf1DP8P+jjkBcpCUXGRoEfs7y9YtRNNJcNlF+3O90B1l5eCD8qA9L+wzPsqYbEVDG3iQlsShR+mMNkB7Moc8U5FnaCPMg+E4LCNDRdtYuiVa0THdJSErGELDMGOGU6PS0hskDmVyIPlFEJnWeDDDyZAHZJSt1TwaILNkf2X9hfM/fEkuAvzYtreddaAQW2yxxRZbbDfJgh3kbYgttthiiy222K6f7aQ1ww47UPDMxvk/v/sD5tX/7ulvdt5p9y/ZjXz8p23v3iBje+Ta23i4Bw4vc6Jt553ZZYcQdFp2Mw6a7uYdSdve2XrX9qruL9le9KW53c48cq9cMdObD02a6QmHJ9RzHBa+YvKcM++/Ktlkgy4Cy/aa7Xbf/dfuOqzN2oiD9uvsPEYftftC5aDtrU6+wh3y8J132BDxj//aa8z0Tz1kQ8cTDqJIEZH6piNUIW8/3/wz02b69FG7H6xv2MgFEZHGm2wEze4/dMAjfsZxn91uD76fcCB++na7Tj1qowfWmg4kgjtr6ToUa5MNB/HqPkd4zzl3SIfXteeRwnk7j2rOrltHNIm0pt3QoZGzdnomZyOdfu/jbzTTk3fYqAkRkSc/fLv9h903z7uwkzSlvxGsnxHZPJwM4b70SgbD0/4QnJ0SuYTfZta03QsgB+wWtsIZSuf15oTcd0oMUdB5I4ReT0ffD80pva4Orxq9nCF8PUQqED6t31MkDQQpa/FsVL6Q4Qe8HyHjhGHTi0rvdHPalzQQAFxe+VV4UgvwhMIbWYCsID21q/dFPbWls4JnwI1Y3/iav0iSNf1OyU1KAlK2cAv6T0JJyL2N6TsrCRJAysb1c4mwbVuAYDP8og/INiH0G/dDlhBQfIYNEPFBicvcXJQ0jvVP1FgAD3ua3lPWL/oQiSsHIIvsQNIuuwAJzjHtL/VdJKELwrAJSvp1SwN8wrueB1JjDeRye/Re+ZPwzKLvsD3SgOCHZKOEjm/quy5VR5hMnugNza8Dwj2/pvmt3o2yo52aU1q+5oxen1tCKFB/C/VDZEyiCEQB0Clco/mQ7aRX3sNyaPxZXE9kQY9wdXjfu+yrJEjEswMGT3JAtn8Kr5j6Hv3sTOgzE73BdvzRN35GRER+72/fKJnNKKllbjnq8R45Ew05SNeiUHyGjiSb+iwkpPSX9SFrL1F0Kr39aYRMNGYA1d/NPsUQFXrkURcjlHaMhjcRFZKfT4TtkMY8kKUcJBAxpRNali7RKF4UycGxRqQp0TO1/Xo5JTLZt4joYTgGy5LcBIpgr3bK3iWFCWTQ/ukN/X1uOVqng5QnpbMIE2L/BEIhOYi+h1m/DHWoHkB7oa9lVvV7fT/QEmNXFxL+QmwnrRli2cjYYosttthiiy222GKLLbbYYovtqm1HIRQSTU8KT1zpsftXp7/PvH7i1TbJmojI6e+yORSSVfv6goNErnrQffo0cMTg9xxe9JRDPtFlido2/AYOJIIrB9/B8Db7povOPDY+sMdMD+xQdCeJnCu9G7ifj56NYaMs1bAlKvZQ2DzsPnNrTdoFSz5ro1gar7W9rYOG3RZBx/18X1o5YKavvcl2J0+M23mvnhlz5uGybtl+7tJJu7zJz9mIlOCl2+Sxbnve519n99A7kna7hiRJhqUdvxn5io0kufQm+7m/5Q2PmOlf+J37nXk39ttoB0pkDVu5bKNVgoQboTB7x5KZvjlnD0DXfJGpupAI7vmIXtBh65yxoRm//O3vN9P/+V/ac7eISN4B4Nn7jx4y0914pmtjQbCzGJu/ESxIaNwsPbX0UibhPW3uVQ9iZkG9cfTshnHcQCSE5IHkVlgj8eIgjM8lSSLjohlzTE4Fek43j+gckAEocIAhXttLUjIiCaIx/DR6q3MLep/KUb1g7An9XrwEDyG8pclOFKHA7wH+nl/syMo9WgjyQQwjOeiV7IF0ld7PYEbdk+02vMWjjGkW1I9+hu/4KHdcyEVBOUh6xIcl7xKQ2kx0ozJy7TLk+Ja7svSAlm2LJwNtfkDvPfY1eI3h3R9MQc4Rbv0MvNB8z3Xw6qRk5TApIz2+wwR8bH9+dkua3/ox7WNjoh7a9gi9qnq/1oQXIg78leh6hQjZkOAQzzbyNDgNgGIZexr1ApQGSQK5lCIyYavM/cizMX6efac5qeUgiSORCSEB5So9+fq9Wx5Idh78CvCme2dwMa4pnidHhX4ntwelSzmOiKwhiiKzDlQKCFbJRTEY4khYu5vIB+Rfxm3Rp31IlBKB9xNv+qSIiPzmpx7U6z0JuaoSQAFy/uBzJkOJWDzDJSAPDuv7rwuuiQw86oz17+WV/ydE8OAjRPrgnTcAmSZlIPszaC/yqc2DFBLyoFwH0etfvDgI25x8JSSGzJ/XTU57SvthinK1RfJvgE+liHpMcl7Sz5GT+veNO/W+5KAIZeRZpjLWQOv67N1l7QeFhSjJ7JUSpvq7QcoTf00n5DQ4Kbp7lahhSxKU3Dicg/WDqAnOlU3UH/8+qG3DGH4NbaetGXbUgUJsscUWW2yx3SzbSfGQscUWW2yxxRbb9bOdtGbYUQcKgbcVX3i5dYu2h632lw5XuYh4r7ehCImB3fiVEdurmV5yV3Fnjx1P7CXt8vba9r1SDjb+7QAN2ZRbfcKyZt8+scv8Q/fz5e9x8EqMuz3vlrmACEttRyC6iPRGHHHUvl2mVNPOZPZtF5x5bDokCVsft7kBsiVbPaD2hI1oKJ13e9c3Sjb6I+lg9l918CGk190IDJciRm+Pi3fBrsPmuN0RXXwWIiLJEUcMW92uc9cpb2LKLS1a7dhjNr9k95HN++3x+ldP2vwUo9twKBw7Omem137DbtfqQccgcEnPisji2oiZHrzU5mLJPGXLZfYc/DD04FmWesyuW7KPD9uv/8L3mOnJ77fLKiLSaNsylyf+86vsH/zsHzvvdW1sZ0lAfUNYoN7uNuYoyuhRdSC1TrUA/U6VAXpH6aGnJzK/FH2v+o1eGGucgRQc5SE3j+m8v3lYFy30uvtYejBuevMOeLopm4b1TLJO2UcoKoDbZvJRva56UO9TOg2v/SA6IeXWepF8+QxETHSLYKBPejL1VX13BYijnn+tzsPFi3rPAl6TTdDohLHJz6rXsU2mfHD2DJa1gtPL8HKivimxSMZ5ej1ZRpYpf1Ebor5f67A5k0Vd9JCf1nlhTvNrTaYlA9SIBylDxp93y3rvtVcgdv405O88bZcclDwau4AkAV8EeTPorSeKgkoX6Q2dH2v7UFcXILNH9QF8kueB/AOLrwAPBKUByVkUeKHyQW+33itoRZnx2RcY2189rBWXWQETP5BjpYvw8sK7XDij82xzt7ZXEkgFqnrQaru1w+eX9b6bh/T7yHm9foPM/7g+DWXfxh6MF38gzUPg2ZgHkqAenTOJTBg5G5VUJGIjRFHAu9/LQc7wnGY22A0vP8pCzgzybVCSuqOXSRPtKmWt0xS8+9/94BdFROS3Pv5mEdnigfAGW/2RayTOH1Qd2BpLmmdrRt+tpSeUT6pf1u/1veALgJzhxmEgfMiT4pEwAJ70PdH5JWgDVVNEe67rDwPMEdkV/B28bLnFLTRSZjXKi5K9pIOPcrVJyteCY4T8BI092p+JqGrM4tkXgkjZKUeZOqR9qw3UgLeGCygTmSfXi7ZXewzcI5TqxdKHqK8O5oCxLy9IZ3dZn2EmuobmPMG5LFSdyUXnEypHdMYwp5JrorfN4u2a2s5aM+ysAwU/kObeKzfKhWkbG1vb7Ya1BJfsxWpmzd6A7XNA/xfO7nXmIQV7Qe55dmc+MLFuph8s2XJ9nzzxUmfWa3V785BI2Av+TNI+gDj3Pe5DmeYd9mZu5GF7cxTCvK4olJ3c6Lll+ZIjDplLh/lV+14nT7qf7wqZI9jgPnvDnfywfdDQ32O398a3ukkZf/aeT5np/+GLbzPTZz9mD/XKAfdk5jrISTqI9XpvsJ+7+9iomZ4/uOnMu/OU/ZuZB+wwpZrjcODQjD02RETaPbtOlh6w62T3RxzkmW17zGwccWYtnYFduYvfaddhf9Wej0a36eZ+2h6z3dP2QZyL/JTw2GFLXXITzrYm7DrMLtjPfeHb7Llw9PMOiUsRKbzT7gvzJ9xkn7HFdrl5gUJ+myDyJCyXG4LMBonf9DsdFoQe59aj4QPpTe3HiTYW+JmUFM7qQr1+gH0ZGynISHbzJF7Te9X26xhpgFeYRK2cj0m26sFj0D6k71n/go7Hxi5C6kFuh016GrB0Lqqzc5CuK5D1Dgv4vGaUrkCCsZgKZRi5oSRMunI4mhfTeyBe6+FMk8R2iRVCsfG7EOYeDd9g/XPjmz+nFd6HlCLh2Nk1rW+WjwcJPDyZf51ukNObQbiZ7oxF4c0eDq+9VdTfYYQVrCL0AWWkHCQPdopz0Q1vFgc0SUDESbhXvMA6weEUQh9IzMfft8bZh/T6DuqOm50gMxB/EW2F+ulhM0Zoe4dEnOf0e+GifvIAgMZ6zmIjy80iibEZLtDel8ezQ9oRfye5HcfFxbehbiDj2S+BPHNobZOoJkPYfRvPxY1neCiHQ6oODm5ya5AtvAjpyyoOU/CKSWLcVO+dwrNFIfk8SGiP6g8qR3HwsxaVT03iIOGBNxwXEZE//agSXPON1dinD1s8kwqlL0fOR0NxWC8jJ/RUsLFXxzzXCO29Za0HhJIwHKM+GyXNbM5E552QmLLHAwb9CBD+FCxp2RmqxTAB1imJDRPhQYgX1h+JVb0+wicKedwDYxJEnBtHdSwxBJIHYQzNquNgoXMUZKN1FHoTY36NhKk4GG1HN/d8JhK3pqskltTvuWWMyw2d77qzZUm2tIIaE+inIIul/7Obp3QowrvQFzbuRX/HIdIAhxxBISoRGtvV2Y46UIgttthiiy22m2U7Cb4YW2yxxRZbbLFdP9tJa4YddaCQaHtSOnHlIyWfsL2dHYdnWGQLbjNsTYdU2ulTNonjiBuxK/mC7cEfOIqVS9nuyM9dPGymO4AOIiLS6dmewp7D659O2e7LqUfdLtILd9kFGDh6XeBS33N4ys+tuwkF0xmHF73n8La6wADbxI2QcGjYGg6PbvV1dshDwkEOGJyxvdIiIr964R2Oe9nXz3+LXR8uKUsRd8hDIW/3W+/9Nvli9d0V+z4ZN2T+1d/0VTP94d99iZmeeIctTbnZdJMW9hzykCRYGzbv79skhxcX7H5Yesw9vc5/3g5tGFlw5P1OG2nRGLPrXEQk4ZgA+rtsFIR/wRFO4ugi5fvsOhcRkQ/Y5epnHOPJMS6Tb3PnsbBiz+s3ywLZWQRL3wjmFXuSec2qtE7qGO5OIgwA0NfOAJ7eS1HyNb8BLzPmW3ogU0s617X3q+ybX+1IP09JPZ3v2pCxq+7TH7PLVA8SUk1yRE1vMzSS3kk6KfE9scyQCSAPlqNEe7xPbgUSdYC5h9DmOsjrskQfDJGtpb3LvOl6r9YEodMSyas9Be88ideGwjN4Hb3S/H0HYQjFS1HPbT+tv2vtUg9k7lIVdabfByl6SSHNCelbojBIotkteCEyIQyHpGcaU08CZRoAyt0rRdEnhUvMKzqv0pMakm/io1vW+ZTEcJyOScBHcrv1Y6nI39tlFI9En1l4U2vJrVAHSCwm61GpxSzCM7oAw5A0kGXz65CVrEEWch1rEixrU03Ib04ghASed5JbhtBxAFzbkD7PLEM+FO29FYKB8mFtN5jqSLejX0ZPoGyoLx/ohhTCBLKX4JEGIqFb0t8lNkHAN6MQji6IIRkK0ZqgO18/QqnFXbgvwmxIqs163vPyeRERefgzd+gzzmqfInIhvQqpzGqwJTOLPChbSqlVjqVki2Sh1JtFWADCXXqZKGEk+z0RP92xKNkj0UmhTH0vikigfOSW/CfCB0CmSoRCZq0bzlmZJSAK8pCxXapHvjcQBlNAONcmZM4pfc2QnGQLZVnQvsMtQw+vaY67PsdmjeMJYx3rjA6QUj5CvrLrDM0C+iVHpEM3RFURTdUZAbllNvoe7qCsA64/2Byr6JgjmIgQQpJevTFb4522ZthRBwqxxRZbbLHFdlMsCAnIY4sttthiiy222Ny2w9YMO+pAIUhtnZxfbt1Z2xOaf9btnWXc4bClX2vzGPQ+NWGmk5TFskL66jgUNto5O2+Xd6/pPvlqVt2eW8tqabuu1l/t5qHY+4d2/pd+wIZtpE7az+cyN52gyIjDi+5CZiSaNhogvbaNNOWY3U6JnB27njzt8AA7qjDpduBL19F8gUOKNLVkwz8YM2n/zU4vZRxx/j88b6YP3jdrpud+0KHBKiKLLTvO/1t/6jNm+vufermZPjNuoyNERBaWbQ/37GftOrn7dfbzXTpje+Ob0+66LT9jpy+/wUaSFLp2J3FJzIqIBG37N4mUg5i0Zd+rOWmP49z/sOc8EZscV2QrpvO5WvVJdx7j99iojdV1N7fKTjDP894rIt8mIktBENxzs8vzYrZ+JyUbF8pbAqjwDHogX86sIy4Y0xFJ5sj3Q6RCCp7fxu06F2QX1evXz/mhLCA9ggP8NiRsG496Gdu7Qd44p+M3kYbXHu795Do9sPRq6lfGMofSi0Nx1IkevZr6kax3wjKKiCQ68PBO67u+PbL17uvjfcO5gDHyPiQAm0f0nZA9g99OM1gbH1hpEvkZ8kHgVTL2rD4zPb2MzybfQC8LKb9Zdb2n1/WHDZDaVfbDu4p4+vrssCd9EBLUEVZCj+lgA/HrQCSkNvXvbPvMOjyjmFaym+TbwO+Bosgu6LqmM5HD9UB6oL0LZ/V9t3knSAPhjc6BjHHtLr0/Fzb9aW2f9AXNuFseSNAn2gGNvFvXOZmnNc9QhhPv7vxSFP2YO6dl6I+CWG8E3uQaCAkrWq+dfboe8oG+aEyDABReY0r4sX1bu4BMIZkyuDK6xSEOhVV/q+0pC4gdFTlFKFkZeu2BQkn0EbsPQsNkA/HvaXIyaCdrTAFdBA4KrqM4xkkQOkAffsM9+jL+7FdU59ADL4GgX7Cc+fktrodMpR8pKzkR+kT5gD9DwPnRxJgiaWhzysf1ehnJF0NJU4yXDPosZdD7BUowYi7AGr+9C/mBF6IAfo8t/iPUMearfjYp2bM6YXDOyl3UTU93TAvR2K2FC1FYWCsSScB5h+OCfA+srz7HE1AqvTG9IHdeHy6UrUQXTWJuLc4T7YEyE+VBaVj01d5ELqw3on66efQVck+ko3m0C1FETQ/fByBd4HXbKNLHto1d5fIutthiiy222GKzbCDeC/73HOx3ROTt1/dJYosttthiiy2262k3aM1wQ2xnIRTE4QHrOGLdD7nj/1NPOjyCXbvKXvZdT5npx997pzMPl3KCy04t2p7QbNZ+DpeXUEQkcMgkuthNa31bFaJ434Yzj+q87QFOnraRCE6vpqOo7Tm3bORt95wx09daNhKh7mC4P/I7NpO8iMiF77A97/knbPjA0mvtTDLjNreC94T7+Uqn7Ekks2E34Mo324iNxEk3UsUhRCB+wn6OiaxNRPH4EbueRrYh+Tj75zYvyNMzh8z0/rg9BvIz7jE+qNpjfOHV9nwx9+X7zPTXvPRZM/3Ln73DmXeibz974YQ9CH70hz9hpr/n2W925uFSpNQsUAABAABJREFUuOj/m2kzvTlll6m2z77/4htspIOIWwHFd4BSRnbZf6h2belLEZHWpx38Efscg/k6WyA3hmApCIJPe5538Lpn9A1g6UxX9h9dlPPzynmQBFs6uQL4Se9bF6/B0TOakFnRuZseyT48vokKEArZVCgfGICHIGRXzzLOXL839mI8gcOAXv40EAq9sGvpvDVIk4U9GrvPd/j4cS2DB88u2dqTa+qJDLLwwKbpKoSnfQmx4y3Np7rfl/oeeELH4T0EJ0Jzvz53AnLMnTIkExFv3jmo7x3GodPrT882Pd79LBj5gVDgJy1/EnNZGp7dUibyrCXE2zcRTx+qceDV2q970tyLsha07bKQ2+5c0DUBX0dELqSa8KSiyGxzlo3x7ul1eEyLadQbpBoX4PEd107TmdTPFOLsKwfhVS1FFTKoJtHIRT25QXoQolWSy1oPPRBP9TO8h/529BwQJGS9R/32IW+erGq7BBm9T3MPEAmIRU8APVPbDXQEOBn4zA3OscUuyqPX+RPgXID8UACeouJx/XsvJzJyBl5hPheVPi5qmcgxQt6HBJj8Bx5UNzJoY8hFNqbZ5ojNb1LFA97roVcIeT3+H6/5WxER+fUvvEXz6RCRElWwIDqghzrIrAeSAx9KB1KI5Mnw1/UZakdGcK3WQ+lJRTavvFbfvUQnsaxrd5NXQPOg57wH1Y4AnTMB9bIe6iDR0c8CpE6JpmF5Rs5BqYWqHFh35M9uSH9S15f+JjhUgFQKiAiB+kh9BrKcULRpTaL9OP8AzdWapcoJ5rkMEAWoT385unfKLZF7Qb93i6h/qKUQ9dHcpX22eEYrp7kP62LvSjRLa4Iymfp9E0pbRMH0JzEXQyp00NIypdZSyBvPcp+9Jr/WdqPWDDfKdtSBQmyxxRZbbLG9yG3S87yHL/v+niAI3nPTShNbbLHFFltsscW2je2oA4ViqSWveuPTV6R/8XM2SuCbH3zUea9PjB010zvnbK/x59bs690RwOKEqiQcMIED02tm+oWVspme2eaQjXGCV+TtcO4xpnHYHrj7gjOPL4/a5Rp/0vZsLrzFkXnSwVVQcXffetfmfMj7NjFAw+EsP/GTu5x59HfZXv+648SxcNwuU+5LRTO9+AOXnHlf+spuM71ym/0g5c/bSITtYtq3Uwmx7MsnDprpYxft60u+zcUgInLe4S3nCfIV5iCiaO51c3ykHF70XtlGDqU27f72haeP2Bk47iMisvIO+299B5rqj87db18/667Dkm/3zyfeaqMgxp+067y9yy6rvw0TMpmfhy1w/KT1RNlMz/Tcp/d3frtNRLH5ehuZcc55p2tl3rVibF4JguCBa3Gj2La3TtOXi1/bJT75htBt6XVjHHZ+Xv8wcg5ebsZOw9MrKcbk6nyTQux6otOX2gH1TDemk5F7tmbgzV8jyYF+zBzQ9/zieUVNdBqYw9rQi8/p7/xNeOMaUQUKerRbk/CYt+kJ1DJ5IBZIVDTmP5HWQdncrV5qxvz34NVuTnrShuc5yAM1sYDnhVexUNR6qFOpALwRLDPnqcGKvoeyQNJR0z43r7+nJ7FT1ndldqGOMmu+9WNYUSGf3KL+buUl+kztMjy9aJbqXeAGWPVlfPemiIhUqnpt9xyeFx7rPGK7vSUwvVeo6KH36iE+OweuhD7amrH8AeqRihhkyW+PA1WBemVcO+PlU0QkADHb2c1KxHVQdpBAJAA/DKeZ3CUoD8CzHXq+64hfb0RVHej19VqaF9ETrM9eHpwYQHo0dpHvQ/9OXiAffXZQ13YagMuhVcEap0teCb1PG3xTmdWt+TFEJlzSsoVqGINof60d0fVR8az2BXqsu8VE5Hf0cJPvpD0R5Urw8G79kdd8TkREfv2zb9V8QrUBqD9M6e9GTqD+AWotXkBfXe2FCJt0hfMBEoCqKJyDN31Wf9x8SRRNFyIS6hhrhagCAjkAPPSBAZQoEjVwXqA9iEgZRv6RD4l1yDGdAfdIbywfIpa6I9E1UreofaAOdQxyJqy8VD+peNMA8JSIHh98Y12gmMgBQx6D3CKVV4hQ0e/li1RoQV/e1L7UAwop5H0AgsJvaOXUd2VCronaPqAgwMPQKZGrBeMBYyx5Fn1nBMop08h7hMoSUAw5fnV8bs/frtma4ZawHXWgUGun5aGzB69Izx6xidk+45BbFBFpL9kQ/6Do2PQm7AW0i3BPRKTbtzc0rg623ri6Tt7fJm/KywybK7yAA3LYvviRe515lB9cNNOX1+1DGT/hhlCbZTrtjumodOzNu4uU0XPUVX/GzYw49jk7j81jdl/IOyQB1+5xhCmctqHpIiITp+z01jts6PjmwK7zkVPbnCg4mqPdt6eN0UccxJ0vt8MOph33ERFJH7XHbOqTdhgNFxXDVm1tQ7zqGAPp22zS0KN32BKGXztvH+4kHAdhIiJ7ft/ucOe+1670Rtvu67mi+0Dh0acPmun77rfDeJrP2odnhUm7PuoDt6ypX7YPM2TDPjzzjtn9tusIMdvOTvznV9l/+Nk/vup7Xa3tJMbmbwjzFLpLuHMPm8vCOX1P5JeikFrKlBH63To4JiIi6TXt7wmQCNZvnwrvz43k8Fog0cZGaAjWvDhX1guQJQl1+zhIyF+KvsNIOsfNeWuM8GaJlh3WHYOcIcgDuQHujESl7EKCOH/r8KKDjU1nFPUCksDqMsY1NjgJyq9tIJShqQ/P+syt9pAHZA6xqfGxQQsHEjY9lZfuwvVbxHgiIt1C9KA8lK+EnCHXZb2RvqyfHkd94Ll4kHAuFUnn5tlHBF9IOkfCthRZE0mUB1JHSgFiU94eTUbu25yMkgVy09gdwaZnnQcSOBiaQMMiNC/Z9sL65AaSGypu0nKApbfHAFNfhiRgmvKSfuQ7yey44WyXEG4DolCGYXQLzEfTmwe0bF4LFY5+kNwAFL/NQykcQNS3Nso89CmfwGYc9ZiqcpesH1wGk5yPBJw9OLe4aWToEOU2OyRdTFPCUq8/cEzfe7//2ddrmarRtU8H7TD6DDbfm/r70hzHJw48ekFYxmQlGs7UHUXIFAgEW+MgEx2LhiVRqrIN6UoeYHIeCokNUX/p9Wi7M0wgXUXdtaPzVHaFsVr6UUC4QIA+2prKhIeinGc4/jlf8SCBY8rHwUt9T3SNwpCr8BAE30kYWTwfJTWlleZ6kTLzMJEhLSTbzJ/TtSAJWRkK0y57W/MBnrPFaZdzH58Nc2wCZctDArZT1/mDkpccT6Onr24v8kJsJ60ZdtSBQmyxxRZbbLHdLNtJ8ZCxxRZbbLHFFtv1s520ZthRBwqJRCAZg6Dw8IQNgT3zF26Ewh3fetZM/8+HP2Cmf/t/+9/M9N42oILNpkNG0NHBmg3b2zro2l7mRMZ99OWCjg8cPcIFfw89AYYdGrFDNJZWbaK1QuHqZDT7NdvbKSJSddSt617JrAOxMXAP9tf91MNm+rMVG1mw/Ox+M/3XvuO3zfSf+eIPOvOu7bMbqr1ke429cbtue5fcpIwutErF4fX3v8X24IuDnHOtaaOARESadTsPz+EUd0lcVjfdA7DoCAnKZGxExYm/skMbJl6/bKY3O26I0Ll324iDqU/a6Stvtfvt2JhD31ZExIEsODJqt9MjozZ55mjerqjuipsw0Z+2kVxdB5Jr73+zn3v2/+OA4ojIV/76LjP96C993ky//iEPN8Y8z3ufiDwoyrVwUUR+MQiC37q5pXrxmtf3xK8A8lqBZ3cNXlFAvssn4fVMRWUP6c32SBwHD2Ufnvde1guJwnzEA4Retb3qZuzDy5sb1e+plI6d6qpOdv0CPKZL9IBrnvQej53Q6zsgXiOEnJ5HkgN2pgooOz18ILPDNMVnI1y6A2h+kAqkAxgzIewheqKOMI5j8FhvZCNlY/1QznviCS1bbY/eh0RvJICjlzJ3Rkns2nvLIiLSLUQJ9/pAUdR3AQ0whvJgqmoeBFngKonmRPzdCjlIPqpove4o21afbf6N+tuZz0ff+QyfYBkTCHFogxyO4aAkvAvlQMtYl5GHElVHCHiHsGugOnqA5pf3qEd2Y17n1/xcEteJ1A5r/fVXNK10Vu9VnI8SRsoYyBZnEd7SiXpcByC3ZChEZUL7bWM2ik5h+4XEkZzWIVUeAAWQQChGbp5SmXpZekM/63svC3lgfcATnkB4Bkkt67NaljTkOVtAWwwjfLhMbu6iV57kgNSj1I8/e/uviojId3z45yNlTm9s1avIllebyAQiH1JtojVIfDmQ1DoIT7uA3x9T9Et7BIicNqVi9TdNvFrHnsSzA+FUP6h5ZRYxjkBqml2OEkNSrpbtMnIe4SCzkDi9oN/zF7SP9xFu0x0h6kV/mKoh1KWQCGUg05DAJOKjekDzIOJgCyWB+t2DEAeEPAZldJJVzSODvplbBnqiRcJEhIPM6eXJJsJyIFUaeJg7mkAugJS0PVNEOfS+a3eRkPIy6cpcFAVBeU0iSTh3EqnAECHWawZ9jSgiFzl9bNvbjjpQiC222GKLLbabYUFww1QefuC6ZxJbbLHFFltssV03u1FrhhtlO+pAoZRuy4P7Tl6R/peff5l5fWrCfQx14ksHzPRv+6SNRCjN2feq73Z3lnbL9sq5YmoCV1hP1W7GbtH9fLklu1yeKw/HrQbT7hjuLzx1m/0HR2z5dNH2trpQBWvr4868N7sOwr2OnZ53OOrp4bDMhUQ4/SUbidC93/ba/uM/+HEzfbDXzd9wtTb5CdvjX7WLKiJuVErDgVBI+zZ538yedTN9s+5GD/zzV/ylmf7vs28z04sfs9EqLoJMEZFU/eqOoXmaPWybNfs5ZsccPxAR/3EbtbHywNXF7k3mbRSCiMizF21uh9nDm2Z630E3sadoX99YcBOWHniDjYJ4fMZGpZz5O/YcVv8vbunNe/+hTcr48MTN41DYSQRL3wiWbGnMND2JYVw2UAQkYmNseemizsnkHaDntzOj3v/aHsTT4zUzSG9J7jUR30ueBg9SignG/Vf1QoTzhp7R4vlofC+99FlIxHXziFnukoiNJGaIE56ELCI86CEyAcsPPivv0+B3rB+65UHIidCa0TneB6kzeWjSJ8jHgJh5cC5lV+HdHJpC8ssgd9yMxlH34ZWs3q+VldkAqVySiIQooSG90JTY9EAWmZ7X93YX8fRBri/Jx4AowLt+BOCnygH9zfjjqL+u/oYkgLWDkFSEtnRzL+T2ILEYjIJ0EaiJDsgCG3uihHBEOnRLKBPVOqm2jLj6ypmyPkvoycdnSmTXZ9Cm6FOFxeiagnHn5JhIUQ+b9YS2H5YtJqGhP+QJb01GY8976ejvspf02UOJU8T0d0Byx7ITETt6thvyZmRWMZYQ1x9yKATg+EhG+TKyG1qW1bsR608ELl6ZjZkoJ8CDL1OC9nf/1c+hDkikmow8awev4hLGOvMrn4bkKUgA+xnCkjwZAE3RnFEUCZ+JXAbNcfTTPLlZtH7W7wbRIZEdY/rM7UEGz0weARCutqJcFvkNjnH9LF0C+SvyDfwkytxBmdFf0O7dArU6RdIb+lwbt+mz1A4KyoYyQKKSPBn9PXrPDGTfSWyYvKDtVTqrv1sHcDDkdkG7EamQn9dnToAYtI+6TGDc9Uei+yISifbH9Blyi3qflfuDcMx4XfaV6PdBPopIYONyTuZcWtsDpAfm1JHTN0Y2UmRnrRl21IFCbLHFFltssd0s20kES7HFFltsscUW2/WznbRm2FEHCrXVvHz2915+RfrMO221gRWH2oCIyKBvnxq16rbHOuFgIydzrGW9qlulwDSHZ99zEPUPXIoUoozB5r3cPzEtkXI/X/KiXSepO2zPbSZle7hdJ3jDp+yXW8dVtw5ZPrJWX2F73CeVI2kHk73DyZxedpAS3Gkz3BdSbm91r2QjQ+6etj3DT2Zsb/V2CAxx1Hu/aruyWx3bUx+csPtB6za3rOLvX3i1md5pblNeK++Go85ly2N0xW8c12e+dcm+/iM2UsX7dtuzL7LlwXmuls3baBWX9Ox29j8/9Doz3SvYT74ra4/XL9/jbr/7M3X7D4551WUP/ONHnX/rbqd5Gltsz8UC9f7RW0yPVW4tOvfmF+GtG5CdHXHdkIskmmuYg8gbiPRyVBzANVBroFwdGd/9Cr2Xel12mVJmyHOULPO4HRAJ5D7wEYtOlERuRS9sTUIlgGiKUlQOjqz79IKG0z4+s/PJsOy9Amnq9YOx9elNIjpwT3IaQH0gC6RBu6z1VTyvk29nTMvqV7WsTZSVDPRsF3rQiS5g2Qf0Uvf5d6AqyE8Apnmv7m9JTWIaJyKjdJFM+3heMOS3pnKoF9RzkvWsZW1PaFmpOhDKdcI7nZ/X79VD8HyvRa8LMpDtQ7umF9F5QiUAlBfqUMnOVtsQmZDehNTkKFUydF3QT2tFMVafUoCMm6/CI9s/pJnUd0c5EnqIQU/V4WkHqiYFZYSASiCQB2ZfZjsNx88TsdPPJMJ1G2Pi05v6bqsfAvID/ZgKCW0oJNRR5mCofuhRD/B52+1a8Z98BHLxuD7RITIiESkboSD0qCfb0bHfK2L81LWuAz8ZypoSZdEH78PmQdQzuSfgCQ8951QKGce9OluIAZEttQePvA4oCtGUIe9BFRegLjkvBUmMbSB9BOpXlBGl1GZzMiGtMUh+YixlQHlW38PBDR4HePtlVS9kmxOdRA6QTlkvK4GsKF0DegJj2cd8xHb3+hijUMRoozyUtqzug3Qs2mv99mj7e/0glARlB+OYkib6Fvgcagf1uuJZcOQAOUUOBnK5hIs/h2pYbNvbjjpQ6GdEKseu3BH3HAR9E2U3oVn3g1Nm+vrr7I1c4zZ78+c13Rsar25Xf8KxTneR5BEWNWzd8jZHX469qmuNnnSg7wfb6MTLIXsz/l2Hv2amP1WxSeFce6ZO0Z2359hIphr2A3JhNGxjn3LD8k96x8z0xFvsfuXaDI981j7YarsjOuTwm86a6ac+cchMd1Evtmbdm0KXufo0tamHrfcaB/R/xU3KWPkTuy8Er7AJE12nAOk19/i7WuIdl+Soy9IJ9+nc1DddMtPPHbfDCHqOEJ5m133AMnLcEQrlOEdt7bLL23NMPMm6e0PvPOhwHEAmHYSsH//wlQfEtHu/yQ55uJm2k+IhvxEs0VcStjYICHmQEErZQQO9sUvHGRf4YZgBFvgbRyGTiDPEUHIxvSXxxndMiuECIILkPfneTzX4PbqJyGxoemERG9oyNy+4rqnjN0UpxhIPPfR3HerL7yGWXiL5c4PWHeVie2sTROg6NzrhmoPyeVgW5dZQhibKgAOI5AIk+NZA3ojNhDe0uaQ1JrlBRTqy44ECNzXdca2LzAI299gIUxKQ13n9Kw+NOFS52R05p+uVxm7NhBtbhg1QLrI5qZWRAWS8tstVRtQNDjWah/XZGY7hbYIwLxM9PBk9oZ+d8KBnC8pfWOiiTCDXAzycZJbVA5ppGP6CaZUEg/WZaFlrB6IbqVDJmcqYLBs3xDx0WRgKG8ABEo0b5z4ONEbO6iAIUp6kqgx10Myau3KRMiRb+uPGjP6dY6lXjIaQhGtYlPWOu/U06/iT+3AdDnYWseHFey895L/h4UxmXduzM6r5+nM6mPsTeipQ3weCy34gbUgsJjEG+Zx85fNArYdD+hTCLDqzOJhk0eHQGUxoevakbqK9obHJA8t0DQcDeS1j/pSeAgQg2exOahl5+MWQh24+epjVy2+FNAUkZb1svItcNj5y0c1CFvKmJEBNIwyDIT8MxwhlP3FgkDmvZW0cndT0NXU6dKejC5L6Xm3wNGRw14/50bLjgDbR8SS5iL8d0MIkkpi/L4HIkdfCgcp5ivMZ+5CPeg0PXUeuznH1QmwnrRl21IFCbLHFFltssd0MC8TbUYuD2GKLLbbYYovt+thOWzNc9YGC53k/GQTBf78ehXmhluiIFM5d6U2rFWwv87HbbAiziMjcu+301GM2cqF0ry1Nub7mljZMn3X4jR1seIQWDVsIqRy+Tc7tfQ4hUc/RKKsybKXH3LKDCQdf4/t7D5jpd+2fN9N7A9sTSlIqy9LrDi+6A4ndu9subG2fg6lORO5+45UEoCIiu3J2CMNHj99ppo+9y/ZWr9bdHvyzHz9oppcu2HWy6eDHFN8dVuE5Qi78Cw750iM2ImVv2UYoXHzGHXK0/lK7v40+5goTsp871XBP1oEjhGj96QkzPX3IbtfmPTZqYmzgRjTMPWSHoBTX7fLWSo7woYS7/QhBHLa2Q9IxUbZRAqerdn3ILjch63zDlpT0HaE6vSV7jt4upOr4n9xu/+HQVcZtxXZd7VZeM4iIBAlPxp5RD2ovT4k6fefUZ6IQfKIFuAZcvY9eOf3epVcaU8LA3/IA0pNKryMRQVlImiUBbKNHmjBcEr5l8Q4mbJnQ/PS6Zl47qGsNvxbt//0svJQgW6TEbmuSnnE+G/4Ob17ooUxvwcpzG5DARFl5TX4pKv9YAIyd9UmvbzJNWcEogSHJMOnlJBydXn56T8NwANRlArKVDHVggfg9lN/ri2TgSfURhjFyShcD7Qldw3TK+m7JrkXDW3pZygsSiq/P0ipTmg95op3pSWUZQtTEUtTrSe9pqh5tl+ohkNeB6Jt9aeRcSxoz+u5NlogQACIEnlVK8TWn4bGe0rIOh9g1ZtGeC+jnh/HMhLmjD3ApmqoxPAFkdwxFwTRfOsNQIcDcu0Q26N9DEtPuQLqQVuUrO0QHrUAudR/CYBDq01KHdhiS055hXIaW5di9ikx45nFlmA4RP7ie/Ty3oNdnNqNhAkQm0JtfOKOdu3VAYQYpIn8aW2SnDEti+FAH9UDPN8lLk40oMiBRgdQiiVfR9t0Ewiowj+RWULbKIHJ9osNQEqBmcpphZwLIFKABWhMkeRxq92kgdwpBGF7BsIkAZQ8yRCrg7z2GTaDtU6w3/BnoFxJyFucg2drkfAUkzmFdR5Astn77BMqMesU81ZwgEijaB7tAe/RmgHJqpCTIob/hWYI5rYc+0Besz/wSSC6b0VCH/FoUKZVGuEWvcOMQCjvJnk8Q6suueSliiy222GKL7UVuwTX4twMtXjPEFltsscUW25DdqDWD53lJz/Me9TzvQ/h+yPO8hzzPO+l53h96nneVpH5X2vMJeXi753n/XUS+gn9fDYLA7aq6gZYpt+XIu05dkX7pdw+b13917YjzXi40QH7BTu/caVdl3uGRExGRhu3dp6dg2NpjDi9s074+N+omFAw8O++B42CuXbbPnqoH3R7SmWPLZvrG/JiZXmnbZeo6EAq1fe7zsGGZKpqLCyKds73MnbL7pLIzzMAF+/hH7fWzl7Xbb+MLe8z01hsccApxD9zGLrsvMC532NLjbtnBnoMzIFm126n/jI2oqH3E9j5nJ9zogVe8+Vkz/dEpu64SH7M94kkH8aLIFvnZsL301SfM9Me/cNRMT+21x1mnf3WcCyIi2bfYY6Z20kYJVMbdCBrXs2cc5KD+HvsHq42Cmf6mI3Y9iYi0HWPjXNImBunmbVRB8dC6Mw/5kAM5cbMs2FnxkNfQbtk1gzcIlDyM0nQLOuf2iyAs8/GJ7rxxGyTu4KFPcuij2bsgYW6OQsaw70kAFFh6GdJt8J7l5nGvoSmYPA6Mgy4/q2VK1PTl1d6l4zG9oVXYHYXMHp6hNgsvKDkRiiTm0+/0nNOTOyAfQQGeWMT2hxJ23pYMJMs6cg5e3TQRBfDej+kzja5SGo7EbIj9Rsx/mp51IAx6WXhay3r/+n54QVf0/u0Jxnsz6Bme2jCeO4pMSG1C5vM8ZQ+3vOaUqmRZiDxIr+jD9cpALJR8fCYi9UVSzAqWj9kVlhltDo9uMCRpRz4C8k+wfkkIPfYUCA1X7TXVIJWQ/JzO0ZRazFzc0PrZV0Ye8MRSBnUiWvbawWicfHOarH9YmwytJQeoT39D0+ntp5SpXyWKAnW7oeuoXiGF71hwEemw2ZTmPn1XN4bQP5sHwakwzfrR3xANE/I5oN5e9VJ9/3zpYeWyCtGIXBbiaxEkgeSZIMoouwYJ1A2t00Re+0Pgsw4HkWcJUlvoDEqtkiuhPYkKJUVFAXKoFcwfkFcPGnovD2t8r6d5sT57WFpxvgklM4FGSrYgVQrSQBJZZlZB8khUEcpKDpP6LMqeId+ByADSlQHGUmJM2yoASiV9TstOmdMBUEokteR8UpiL8s6Q96QPNBIJJJOYv5ItbffWFEgegQCqgNAyD1lIIhPILdOHBKRXg3zk7po0uRZdykTqK7PO+tXv6QrmhTbnB3wCdUIUitcER8ng6uS7n7fd2DXDz4vI0yLCxfKviMh/DILg/Z7n/YaI/LiI/NcXksHzQSh8VET+NxE5KSJvEZH3vpACxBZbbLHFFtuOsBiiYFm8Zogttthiiy22YbsBawbP8/aKyLeKyG/iuyf6Lv5jXPK7IvIdL/RRng9C4aEgCNZF5G/w75axZj0jT3zpSjTCbT903ry+8rn9znv9++//XTP9P/z83zXTF8fLZvr4qxecedSbo2a6S7qxM+aIaa/Y50LjWbcTaNNNfWAamZGv/IO7N1c+PWP/4aCNBth0qHEkXXHi2xyHUWbnip84RALKRdvLvHrGzYHx5Bk7Dj6Rt/POL9gFTtfs61vP2J5hEZGpx2x+jAvfa6e/9OAFM32p4eYxcLVsrWX/5v7veMJM/8wTdqz71Gfd08/nH7F/k5qwvegJhwxjZs3dPzuj9m/uKNkys49kbCIKFw6h2nKjBzqT9iBff2LSTJ98yr5P+4B7ELSmHOPGcSBeTNllWlmy0R+ffcyNECi+xOaUyWVsiFA7ZcNFvD9z51G1BU1iu/Xsll0zJGptyX/uWQkOKvKpA5b0LU8vVB4Qi56FHB49YWT0J7KvP7kV3yui3ukk1JzoYc2ubMUxi4jksUQgqzlZ0tMdHY/JFeVu6e4pi4iIX4my5GfmlaOmO6Lu0tCjF3p4gZoA/RMlo9uz0bj5JOLk6c0WxCX7LS9EYvA5Q3UGxp1f0Hk51QDrOqT4UmBybx4s4/d6fXsMaI08JSzpAR+E9abPiDLDq9/jNMH4bvJRIGZ99KlUpJyXv8SITKA3MtGGF7kLVYH98Pau6Lopu9LCs2oh1u4EI3+adaE3p1JCyD0Bb7SswTsN9FUGspBUfeijnUZO4354HbaIBsUjjj3Dyg8kgbJSFaM7q3NzL0cuCbQtUBXVA6gGMuRD/jGAd9prkfABPA4oU/4S+yiKgnTG9rNi85AC9IAySFXbeEbtW81ZHU8cL34uFfJptIhQDKJqJ6zXUCJ0BEiCNf3dD7zqiyIi8r6HVFraSxH5EX0Xbnm4gbKo85N8E+AhgNSiv6jjaDAKpQT01ZC/ACiM6tFUqJQUKiUA3ZM7q52jd3cTtQTVBqhkyBDyORyrlIrFeiW/HOWi8IDwCWUh0f75S5oPeUCo/FLbTUlaiXxS9aRfHEgC9ZUcb6OMyIPCH3coNMQ/XkRZNJ31OnIOXn1wUSTg/feBSKDcJjkUqExBJANRHkQ5jZzV+y29nO0IhBSRKVnODfr3ViMtxbKiiqpYk1KanWVNAeQbtj04RnJzUIVoR9fLQQ5j3N9xktT/SfRQn4v3CRHZCIKAFXBRRGz471XY1z1Q8DzvQBAE5/g9CILfeaGZXjfztmA5l9vhkr24Pd8+4LzV//qnP2qm/9av2YiQrkNa7d+fe7szj3bDsdlxJFOqZ9iGZXBoza67eTsjdiaBA+FPwpQrrs+7Dy1yyw4yxdfa8QibVTcJoWXpbSJ+0lfJyzaasTeqtaMOyUMRyX/GPhDqOs4garfbm6ng1fZhRvmP3Zv9Y/+vJ83081+9y0x/ZnnaTN816ug8IuI7ZA9d/faRD95jpmedh1fuzf7YARvqPviIveF2SWy6JFhFtgi/hu19n3idfa8Zu4/kv2TfqHKve/wVZ2xp0bpD07Fy2B773Zr7ZHDkjD3+Nu61K6WYscfyasIxV9zmDslZcxxCZEfsPEYesQ9f1hzknCIiE45wiNUzdkjVjbA45OHFtWYIMmkZHN0vfUDICc0PCcJAwEfCsY1j1HnnohiLXYbsoP0T3DSO9mWAzXJ6FeSLmO5z4ITuc9MMbXS/hg3Uul7Ym4m+ZzySA05rKFkYlodhSgI+EsX1IFdJCH5/PwrQiM5P/THAqTcgmwfpxfSGSG4Fso+Q/1u/U/Mun9TxPEiDtG9B3yeDYhbPDwk4kp0V03hmzaNdJjQbddCOkv61DyJ0gqEObZARguCwO6Flzp2LSstx3i9e6qCOUuGGNbWk7/T2fp0nsme4PozOvZ1RbA7DQw9N5yEHYdX1g2x73H9Onz2UGC2yr+CyIQnGxozeZ+JJHHg0hjZqOFhKNDpSubMsIhKGPmwcBRlfJ7pJYx9g2FtzDyokg00ZQk323qGH5xdO62lTYjekMwXtthElFeTBAje8PBAaeVbrlOSA6SV9N/BwJtnooK5K0sRBgl+J1kN9Nw6NcNA2wAaShx0/8q2fEBGR3/vwmzUPvhrIHVhk2IUmjB8HQSEOaFI4HMwt6CaUfXYAgvJesRy5X3Uv5EFBjFjdhwO3YMvpl1lDmdva/5qH8bwXtR4yWD92n9HByHBmyq+yzxTmEU6AUKDcIg6zOB+BJLANOcPssv69j006w3LaI9HDGR/Q/sEQOWOikRBvF+6xoh2aMpuCMJcAY5HLwNHT0VAsEkSSJDaZ4IGCoAxcNzD8APPWhB+5T2ucYRmYg0mQCALQ+j1ap/5FHM4c0b4VnCpIr6n9NAFnK8emYHlFstjWGAg5N3hIgYNHtH0SMqwc85QJls/JdbdrtGaY9Dzv4cu+vycIgveIiHie920ishQEwVc8z3vwWmTmsueCUPiI53nTInJcRL4qIl/jZxAE7t1WbLHFFltssX0DWbAzQxau1uI1Q2yxxRZbbLF9HbtGa4aVIAhs+TyR14nIt3ue904RyYpyKPyqiJQ9z0sBpbBXRGy5uauwr3ugEATBXZ7nZUTkLhG5V0TuE5F3i8h9nue1gyC4ZYCnXrov2T1Xev6+f+KL5vWv+2E3qdgvfeVdZvrf+/SPm+nFr9oetr3vOuvMI4QWPkcbODzyzRm7R076bvfsRunqerHr6nfcY3vKRUQ+PmeTEyYfsr3M/b2O8joyb0+4K7B44epO/fyk7QltNtwwiMF9DnRGz/YM50/a9+r7dnrr+9aceX/mo/eZ6TkHoWfqKRtNMfZ3bHi/iEjPJXvoaA/K+gzby97yjJn+7O87ZP9EpPqkDXUPjtht7gAIbdsPXCidQcnuh4en7fa4OGmTTnpNNyljLm3H3iRO2b9p7nKgBNbc/bN2wP6N17b7Z8F3IGi69vUjn3OH5Kw+YNdhuWiTgG6O2MiMwEHWKCKycr5spt8sjEAgMUJB5EW2Zuh2JXlxWWSXzjfNvdqn6fGj53fjNnjrcRxSHcfYAkGcB/hwUIRcXIukdX6IZiDseBiOX7qofZzyazR60Rg20J1U6Nsgi3AKrEQHPmDuI/C4YkqgZ5EeWxIeemcwX03A8w00xaAHSHInSuCW6HnSRx7Vg+p9n/nriyIi0p9Uzyuh2N3pKDxvkIyGOJAEjV7jfhg+gE/UUUiyCJk9oWc3S3g1CAzP6w9DwsM2vdPaDo1d1MITSQ+AwCjoM/ibeH/3KQuIdgAZYxfSjPSksh2JOEiHOqDwzALZ0SuR7A6hECC5JCE0Pa85hM/kl0Col6SHnmSdfdQN8sn5Ujqp7t/KUZ0vfdbnGOQLhxAfLHOyifoWFBnEkRcXFKXh5RG6cFI96z7+nltkH9DfFRZxHV7Do09uiIjI5j0KESye1/m9i9ChThnhPukcfheE/Z5ymw282whPD8YRilPV377pFRrv91uffaNeMA5UykVC6vH7IeJQhn2EUH08Q+2gVk7xlO4VBhiYfg99ZreWlcgEylq2yxLej+HHIQki4fgNer61TO0z2k4DrI0YLhBguzD+pCZQNpUhJZQtJMFhZlU7T2aNcqzo97noPEU51hZITPsMccB71OugL412ZdDiPII+M05S1mTk2bIA8LTG9bfjTyFEYsB5Te9TOAk0xhRQMwgp2bhNxxuJO0nwzjAYhlMzBJXLztphbY8E1jhEI3kLev+Ut1VG9sf8JU0oXUI4C8grx57tRMqc2gQS5wBgXEB+1HcBRXaDKINvxJohCIL/XUT+dxERIBT+n0EQ/F3P8/5IRL5bRN4vIj8qIh98oXk9Jw4FMDI/6nneSRFpisikiBwT9TrEFltsscUWW2yxiUi8Zogttthiiy22W9h+QUTe73nevxKRR0Xkt17oDZ8Lh8LtouyQ3yYiUyLyMRH5AxH5qSAIHCJ8N8e8elK8R66M3f3R5Z8yr89MuGUVU8/acdGzr5k30y8MbI9q3yF5uJ255OxcZI2e44Sru41s3WDEgQbgEerw9UU7j796yo7ZFxHJ32mjW+sbtkc3tWQTOLiQHP3922gCih1b7vJkDxx1mP+qXVaRrRPUK3Ket4eVg5IglI0atuqJsjPv3a+yyT4XHtllpvfvtePdNzvu50s6Kj5wdOnOlP2Aj3/sDjO90HOjZPLzjvZ4+5KZvnDeJlHojLplP/tFu/1uO2SjNub+Zp+Z3rvLnkeSc25+g6pDMrZ1p41cmPiS3acqt7nnF5JbDZvL699zzFXJDTvvtZe6EUKeA6UzlrXrqvGAzYfQumBzMYiI5A00mohI45KbSPW6WiBbLpNvYHsxrRkkmZRgbET6kBD0q5BDzEAysBAlyGtORz2NlCfsluGhrOB3JDxsJSV3KUp2SE9scS7qGU+vg4SxDeI9xEcnN+mV17KRh6AH7yTLGJLYwftJgkNKYPdKuP8o5hiUlXJs/ga8oUA0UBrTrwchsV26Bq/tYcTct6MEh0kQRtJ535lVb3AoKzkBrz9JLMkrQG7AAmLGQbIYgDRwQGK8NtEWkHuDVCClAVMteny1ANk11HGzJ4lmdL4nkV2KRGwpxnRT3hN5lUgeqB9EfLR24X708MKDKvDuJyvgldigzB5jzOn1J+IBvBB1xM9fUBRCkIZcIbys3dGMJBvg10A7EEUx/KoOkQlYIrWnoxcM8tH+GqJS0C70SrNdkiC166KvZVfRF8GR4Vej7xSSBtK4ZmiVE2FZiaxNoMu09mi/TF8Ed8E9GyIi8qkvY40JNFASqBWiWUpn9ZPcVSQ2ZNuTQJRkgRy73fFs5O99xNM3x9FueGbKWPJ92p4ebJGCskwNjEGQXnr8O738Q3xi5CMIUQDrRNig/4PslH2EBIfkISCxZZOyoKj+3tCyguSmLA/JOKWZDMsWEpV30A+B9GDZMpt8Jv3eJq/MhvYBSlZ2ZnSsUy6SYz27gd8DUUXEBwkna1hW9QrRPkqkBOs9hXUI+0+y7UkGy4Y0ielJlgtEVSifWeKzgVdjVjtL2J8pywmOFnIuXHe7wWuGIAg+KSKfxP9Pi8grr+X9nwtC4WnR04tfEZEP3ir60bHFFltsscV2K1nMoSAi8Zohtthiiy222L6u7aQ1w3M5UPiHInKPiPyMiPya53mroiRLXxMlWfqz61e8q7Pbphbkz/7Bv7si/Zs+84/M60c+7PZkrX2LHevrNEdccscVhy5bnoRhC5L2iRVjGq+83r5Po+2Or86P2p7CXs++WcohKTdVcjO9r3/YllXcf9r2DC+/5CpP6hxl2s5c3vVmz/Zk1444dCZFJFG36yrpAE4kHL653rQjj20mmsSv2jwUwRvt65NP2X298RrbyysiMpWz25anvsPmis1/yduOm+nH/9BGLoiI/NBPftRM//WH3mymF6bs8ZpZd3u4/TG7oU4+M2um5xyzZf5xG+Xh4jwREek9Y7dH4oBdpo277L7mb7oRCp4DhDR6wn6Q1gEHQsjRD4un3XObC1V0cY/N5ZH907KZPvqDbtnd9Y/b7ST7rn5eiO2a2otmzdDPpqR6x1g4p9Fb2RyPyhlyTh8WYens1kk9fUkHe3BE56EkJH+9nkhzt/bHsa/pPUOmcXrR4NGr7dF7lJ/ROTlUc9inY4bjMFRcCr/rZy9P9nX9np+H9B/Aln0oAGSe0Pkq5HQYkpQLvZy4vxeITDwRjZumUoLXhad6V1lERCqHNbPCPGKW+1EmeHpDGT9Pr2efMebwqCYXtrgPRK504pXOa0J+GbKeM5CvXNIb0hOZPa2u9s7eMQlSqA+w+9NrmTu7ISIiC+9SJSR6uDl/hl7+o0Bh1PEs5M2ABzW5GZ0Pw3h5JO/+nJaJcdpUZEhRyu6Svm/b09p3snNAKiSgUpDwZP32AsoOXgcqT2DqJo+RD56G7t3aH/2z2ubd2Wh/7YILgIoehYvw1qMPhH2V4wPtTw96CopPuXkte2NvEc8OpAjaPXzWlsjGUdQP2r4zEZXV/LHvVGXZ937wm/SCvVrmxJo+JNuDv+f38ok2yo72HUIX+UB3dApR5Ad5B/iM5IuoHMQzYhnUmEXfv0ymvTsOpMEu9PdNrdcEOFTSa0Qa6PXZIRlroihYf61dBTwTkAjgoMgt6rNtHgYiBH2GKBq+b9nXqNZGxE9QIHoGiIZOQoLkFkfK5cb5YOIJLVt7RH9TugQVkhoQCWP6rERLZIBYaExH5SFru7VQ1YPoKwCANnZTlUPvPzgIqc0F7Xy9ETRwgnMO78u+H4QyqbklqGRUiVyiBC/mAyjmVI/qejALVEV+Udtt/SgkXjEn993g0ti2sedCyvjfLv/ued5e2SJa+i4R+bPrUrLnYeefnZSfeduPXpHu/yt7Ze2SjRMRGf2UvUm4eK99CuDX7IX9ZtPdMznJvlAjDHDY2i033LtYsDcuyaS9E8g7SORW6+5K7L3eliRsrdmbKedG3LExyjmeQUSkPWbn4drkeW1Hu464EbrdlF2/5bts8r6FVXszVf6c3dc273RvjFo/a0uhvmzEho4//Ohtznu5bK5mb8Zdky0XsMP2zPvsg4O+O9pC/vA/fbOZfuffPWemX9y067Yx6x5j2ayDGHHS3kEXvmz3qa4jHGg76+y323b31KaZXvuKHcriOkwUEWm+3D407N5rO4y7jpAHV/hJ5V732Bj5mj3Q2m3Hwd0r7XnnSMpNLOs6MLmptoO8Dc/XXkxrBm8QSLI5kN4Ysd3RTUUTarsk6Qp147lxw8a3A0KzwmMgdRxDRxiIlE6QZE/TKJM29mx0/hk7rgcJfZAutqawOQHhGjfnjSlAvrmJxPzTHiPMXb839+H+AaXqQIK3HxsDQPIpfcdQB1oOm/V0dRC60bw+NvDHNMTT60VDQPILmmd1r75PScRGv0rlEOD/JMTlB89IKPvdJB5bP7KrgGHjPh1M9zyMya5GN76UeuxN6zss0emHcPHumJaNJJjr9+vhfH4pWtbqQeQJuc0MNjTdUWzSSMiJeuUzcKPL0Ig0NuVrd6ZQRyBjXIySMXIzyft0J9CXIAsaJERSbZ7y6Ac3u60plAF9oodDjsEiXtYIgcid0mdvHgTJ35z+ILfAgwL0/240xIUyhbX9IMQD4V4XUPyUN1Tv2eh9+EyVQ154ANMdZUiCXvumtz8mIiK//ad6kNBB2Ev2NOQCWa9YVnJcFOdxqFWgtqV+jB7Xd2mvRFlEvK/wquHhSG0vNrBYj9f2Rg+7avujdT7IBDIAOaiHUJHkedxjlPWFjTvfUXh+ziMZhDfxMKNfSEfK1JjRemX9N6ej61NKWHLMM6ypOxINuWDfTWz6kWeSgSd+FWVHtfBvqSY/EToCQkgeIrVQFpaVm/PKgUy0zBPRsI1RcODX9+gnQyu6JIif1zpkOA7rm8SrSUxnPJRMdDwpLPYjefAgoY2DmNIq5FXv0gmDYceUrqTsKeuA8uM3NHJxB60ZnhMp4+UWBMFFEbkoIh+59sWJLbbYYostthejebHKg2HxmiG22GKLLbbYhm1nrRmu+kDhVrb2ZEpO/r3pK9Jft/8J8/qvfMte571SHy2b6dlF2yXoksyrNx1xDSKSsJXSnNB4ekGGLXfRbsZu/+o76nje9mq2HQSPHYccoYhIcNiGoS+/yvZGlp+wPaQuyHVuG1nMdYf3e+AAbaxXbKRF7pFtEBgHHO3hO0IY5u2+sHGf/Rz0fFhW+jd25zl9bMq+1z12Ja5W3NJ/g4Gdf2obZIFl7Qdtcs7ga+5wBJfXv7Zsk59OjtjhGevbzHC7S3a4x+mv7jHTSfg1bJQ7GrbtZGHz5+2CLbSunL9ERNKOqiLUz7L+ut3fgsfsPr3xKhsdkXI8x56/dMMjWmN2uSrrDnhL0r7+/Bfcc3Sxfgse7d+CRYrNbQPfk8Z0KoSQ06PKdqQ3rLkrOgh8wHR7RXqpAdvFsM6sbEG88/Ci0VufwXRIzzRJGFuTIIkjuIHeeKAnQs91gd5g/U5kH6HLvC5/Dp7tJJ+VXjz+nl5p/TtlDMNQTJSjU0pIkEAivYaAYCc6WvbQcw0PYXYDknGHUSEsE2QIGyQyBFJhkAFEGdB7ek8HzBav2hCJ4Eef3Yc3lbBreii3CA390DM9TEaXAhHe2oEo2R+9u34FCAIQGw5AapsGRJ/SfH6dSBD9Pcm1SbiXqfA6wLLrCKFo6g+aILBMINSlDS8qCeb6GS8ktCNCgx5qH1777pTei1KVgyIg36t8KEHZ9d7ZlWjoxMh5EILCcx6SlCLer3gWYRnoqyQUrR3IRcraCSUhUQdAmKQaW22XgJTlwfvmRETkY19SKexgEvULREgPa+syIif5vmV9NieBtAF5YG5B17AdSFdyv9bP63eiWGp7UpG/b4V1SMRChOw+7Wy9mi/JqubZR/32Mfay81HS0cJSFKFBY/hFckkX+91R1CeJI0F8yHADykLy2UlAybHM8CXKgYYICoY6tNKRv2vfRhtzeUYURZOoI6IfEBZT0THfmmLIFMuCvob+TmRCayJan21K7Q69JDkOiVglOWyvSCQQLsR1hXmEg1y2Rkxibca5NLcEcksQ25bOaZ9Yv0P7AOfK4bBzfu859nPXxXbQmuE5SxB4nvd2z/PS+P9ez/Ne5nneu65f0WKLLbbYYostthejxWuG2GKLLbbYYvvGsKtBKLxT9CzloyLykyLylIj8cxH5i+tQrudlXm/rxPVy++Jf3Wte3z3mJl584IeeMdO/9MhRMz0xYccld6puZrZU3j6a8hweYH/TgY4o2fcJNt15j8/aMfgumcti2oZNLG0j3ejyX2aW7L+QxOUKcyRntomvDmM0h83h9O837KHgkoYUuez0d8hc8oITlxxe24N23v79Nh+CiMi5d5QdhbKTR4/Y91pfccBkRERcCImio98etlECU++zURCr97izvlor+Hb/XM65j38LKfs3/+RbPmym//qSvRdK2459d38WkdpL7flicsLmHdl81Cbh3A4F4UK4OPv0pj3x7FqyM1l6ufs8unjeTqdnZ9hGT9rX0xtrWcPByXjTLJAdBV+8BnbLrxkk0PhbknH5AC01EZNOtIA35P1Ptnk9UAYA9oWSZp0tz+RgSMIsvCfjeSnDtqkJ9Lh2QbKY2aQnlp4/idyH1s8GkU/Gqmfn4E0FOCiBqYcoAHoIfSB+GJdMfoTOSDIkDmSMvSB+ur4vH3nu9dsRUw8vpw/eiPoe/V19L2Lz1+EhzMGrDM9uawbx14ijnnoYxIfItg3+CT5DaVkLTwnNLuLok52oh1JEpF3Wv4VSfIjzbwEBQkTB5THaIiKdMlAR4HfILOg9OxOaB9czRJYyHrt0PopgZD9IQR6ytk8bpLAAss51/WFzJsrxwDmwU/IkXaGnWu/JNqRHNVHVsmVX0FeIxuCrDv03VYvOU4VFoC9QXSPP6nuoflBd4ZkNrZQu5VWBrhiQ6JLcC332eyIcwOcxBQ9yxwu99/vuUcLds19V8u4AfSG9BkQOrssvcOwNcRlgPBUv6sPRO90Z1TKSkK89EeUiITKB/AYB2p0e+dZkFMkTesjP6/sxkQ7Cd6sPCOQwgobzSG4FiJkxoij6kfrp51E2ErCi7TuFKJfL1jPjO6lG9oBDAA3NPhpKQ9dRvqE5J72ZCPk3iLwMEZj4IGdCBpKwg3SUo4JGYsSQE47IpjJ5V6J5E01B0kXyUIS8D+ij7AfZFfw+iJYvv9IPEWXkc6AR/dX3IasKQnuiWEKkD5BpnK9CktjcNgura2k7bM3wnBEKovGP78T/v1lE/lqc25fYYosttthi+waz4Br82zkWrxliiy222GKLzWU7aM1wNQiFT4jIr3ieNy0ivSAI1j3v1lobBMnL43S2bPRlK+b1iffZ8dgiIk/8Hdv9lZ21vbC9k7and7CNh7Q3asfgey7uA4dHPGjZXj+v524fl0e350AouJAL3oJbxSJVsfP/5u/4kpn+2V9/hZ2HowrHMm6EyXkHPCKUohnOo2H/4K77HK7WbezppM3In1u26yprd09J/0nZmUfLobjoQgn0P273de+w+yTWpa7RdfTb9LM2EuHSt9l9zXMrVjoRPxN/YSst5H5iyUwfuClMpOfQEP2//uadZnr5NTaqp/r0uJlePO8ef4d/206f+xkH78HzYLtJTNvooe+78xEz/Y8++jozvbuNGo7LUjYViwycJ/8OhYlvsttVRGTppHv+vnl2a70Tb7Ld+muGhHrW6Jlafp1OemS/7+P9TY9uCq+cHqa6MFZ6Tq/jWElXt15aRCvQm5YEU399VzRmn65Qes84PdV3wUM9pt/pWewBUBR61ofUnvj6DxUqVqMoDMYdZ6rROG/Gxddn9capZhB6aSlnt/xyrQDyQ5B1nkoW63frdcWzmt4B+z3XJEQQpmrkBAA64nxUZo9Ig1Z5CJkACbsE/t6B8kVhkRwK8HJ7jJdPyugZ9bLTs71xm36OnNN7rL9K31Ojj0RVBWr7UX8tSl8iXn6OaAjWG+sIKIJS9FlKFxCDPg7+gnW6bPWjMUvvtP6uvhsIlQ3GtG8hPfrwQPdKrEctC2UKm0B6pKCWQbQFkSRpxs2jj/hg5qeXuT2tnatwUR+qsVu/5+d0Yt+8rRC5H+9DVAWfiXH15JnojQ7krQ8op9knP6mcCSmKkXRI9oH6Oof0RBC5V/ESkAybvUjeCXjSe1NROUPKdLIPsz5p6xDAYntn1lGHUMLInYHEZnELuUAlFXJ4MPaeKJ/skIrDAB5zSoPWDut+gXwDI2fQiVA0Kld0IG1KToo25gCuidOr+PsB7VsBpLvTC36kXERus48GSZHRc+BxCJEJmKeo3EKvf4JIjahcLT/r00ASrGm7UMmF6jGst86eIW6xDqVHMU7a5E3Z6u8iItmN6JohVFPpXYb6osoD5CF7I1ncEyiVSW3DygEt6/Sj2nBrd2gFtTG/tCcHkbLcGLu13okvxJ4zQiEIgpYoU/M/lpitObbYYosttthic1i8Zogttthiiy22bwy7Wr/XR0TkV0Tktfh+C4EtNPbN0kxfKdsexMwR93lKp27zDwzatic7v2mfMm130tU5aHtuEym7WvsOJMK9d9pe9Gc+c8iZd7tnN32770q387Y4K2gDR+/6xO+/0kxPOZjexeHUPLNht6uISG/SVlrIjdhe2/7TNsLkqSf2O/Ng3NqwHX7ZJTP9zB22ekD+tg0zvf3xMWfeU/cvmOnzS2Uzvf9K22Wcfdot2dBzcHwMpmzoQulRu4+sOoj6GeNrWeYJ2y2+/CobHTHSs8ert8+NYnGhcVyolLmKLbXwitcfN9Of/MCdzrzPvcNGIqS/YqNYenscyBoHykJE5MEjJ8z09z38KjM96+jPXQfNhgvtIyLi20AZSVXs8tKjeeX1bnjEt73WRlp86Av3O39z3e2WeiPeEnZLrxn6eZG1lw4k2Yj2SzKM0xNJbxn5DMgSXrwElnfEkI+dYEy/zoW5S3UZ5EjB7kX+xphlr8/Y7miMMpEH5D5ojzMmXL8HaYwZIBrJjk7PYJpoEDxaYR7x3VAZCL2cUEbwq7oeGfj6g9GnNY6+X9iSRqIGfQuv3m4xymrfKUvkGRq74SlvEJmAegXDf8g5MVTPjHdnjDNj/LMrYMUfiS4uyicwz7OOoS9P3ol0JZDVu33cE/ee1Xu1gG5IbOrfG3vgEef7KSyT3ju/oAltMO4TjUI1B3p66fWn9TNaV/l5XYN4Pf179bB6++ndbwCRwjokW34/E4ReeqIlaAHWTiGSLRlFfJBzoXQeHlhM3bnl6DqJHnZ61BnezfaoHNGykt+jPcHgfpR1kuUAigBqKIOsfj94ZFE+/rCSJ2Wa5JTQ31K1ZOQM0Azo9/kVlBkIH7+qhc8saP/sTqD+SmmUmXHxA1aOfqDKGtPkncBDJ8C3AYWMwRo6M8ZVaxZKGXyWlEiW/AOor9wq+nmLSBzUA5SyCvPa13qjOn4y6+CkAIdCcwqIAiAaQkQCxhk5Moga6Jaj/AMC7gxvQE4XIlP0z0QpEZ0xSG0pspAPJQm1E3r5mwdKkTz7mBeaU9Gxxz4Z8h1xWhpSTEiuUQ0iik4iDw37mof/FC7ymfEM6IPkIMkuNkQGQDDNKnK1M6mN2oHKSzimpqPjZfUu7Vy1fUTORNEunEtviN1Sb8QXZld7oPCXIvLjQRA8hu+L17Y4L8z6uUA27jE2O1l74dvepiF/4iWfN9P//KJN8Nj/vC3X15x2b7h9x+Y2lbAX152s3cmfWbCl5lJ1d94rDXuh3nEcNLiMUE/Lxn7M3pid/9sDZroz1MNh6YQ770zRhsy7zHfU1Z1vPOv8zTNLdr2ffNYOlymftjdTGwV7x1Z486Yz77k5+zClULYPDpKfGjXTB/Y+XES2Fs3Dlh2x89j9Q3NmemfdPhjpdt19rZG2N9x+zj4och2Q5XIODVYRWarZ4RMZhxxp9bhd5/Mvs8exK2RERGTgODRs3WXfK4SDDlk3737xPbJkH2B5GXs+TLRtTdXaQXs+mv68e7w2Zuy+nnRwuPZ2O6RTT7plTT8yuNv5t5tmO2hxcI3sll4zeF2RzHJSOuXo5pybSZ8HYGhXErmFkO4hYjhuEhNIl1RC+lmdm7hpoEwhF7mhBCJeWc1pbHgRBpBZhXQcDj0YhkFCuH6aO95o2fg9B6lGLtgprdjPAmrcx4YqS7I6hBFMZMNy+9h8VPfi0GJD79XF8CSRIaUVucFNQE6zMws5vBoPIKKbCsrfpmvRAZRbBiwbdcbDjnBzWdP7Vg9G1zP8exVLDb/mbW2OEbKQ3KC0pKZz0+v1cQiB8AG+I3sF1BPLgGmU4V3pCgj3OC0OhZCQiK8zBgm/fvR3TchEdhAOMhxu0x0bhGVqT0FacZWhJtF+ys0v4eulC9jUMbwAl2fPaBjfIK9t3d6lDepXQBCJUIfhfs8DNB4GcN1NOeT2RIDfa/ptR+dFROTkidmw/tlv05vRgxpuRCkLyXornNU4jfpBXS8lm1q2rT6h7cPDjo0jWp8Mg2b4Bx0lmfXopj2xrO3SL+OADVKbrH++z72BSHqD4ULo76HkIiQW1/VF14HEYntM75Vf4jzBQ5NoiAjlsrtDvguOr/CgoA1i0DGQMrYZgoHDRbQLD/j8WvRAIkh4YbgQZR9TTb1Xd0rHUhNksXwmhkDxoIebbx5WsV1bu/U+KUjA8pCwP4Y+cgoHP0PzFecUGg9cixe0LlsIZUmv60TZ3F0Iy0wSRq8d7QOUlvSrHFNeJO+wXjF+gmm9d+rC84gxfb62g9YMV1VrQRCcEpGXXvb9bde6QLHFFltsscUW24vf4jVDbLHFFltsse18u4HHMDfAEiJe/kpP139//e+al/+Dh37Yeavf/MSbzfSkAxa89wds72z3z20voYhIMWe761xQ7LbDo5vJ2F5bz0GMJiJSa9jQ6mTS9ka6vLar97nzCJo2CuL+dz5lpj/253fZ93E4QoNtPNyu5yhkHWSUm/Yx4VfPOPD6IlL+ou3eT5XsAjdn7PvkHaehd91rhzWIiDx88TYzvTtvw/L7r7flCDOfdstGBg7ndzFroz+evmSTUf7Sy22VuF98+NudeaeWbG/5q9/0rJn+xXMHzfSkK4xG3H1k85SNqBg9bd/nUn+3mZ4qO7OWo++zYwKe+TE7BGXqwLqZXj1nI6NE3JP7yMP22HeFKOUW7Plo01bQ1Xs56j2zYY+N4qTdP/2PuMOa1nv2/NKfcIdiXFcLxD1ZxXZLWpASaU/2Q5k1r86wAZDcASTGsB/C0UfOAolAAjN49Qm5p1e6n01J9qx6gVuTOj8S1UC4dAeEYBx/DHXwQEwbbOp4JVkZxyM9r0T2MdQhJHa7oGUqLETDMJKNHn4HuUR/yJM4FE7Qy3lb5HCoB3pAKVndQygDIdhEdnQwFolMGDkJScwhcFjoKcTruXBBFy9BmvAB/UjVAB0vkngPMoYkFRwKdQg96mmRAKgwyj0SRZFewbNhOumPa2GCirrKc8t4VqIA8DH2bBf3JqJB13OU1xsgxCEB+cL6Xm1Hel7bI1EUAaezLMgzq0dB7NcFZD8VhKgVSup19kAy8ZSWlWSXI5Dhza4j9KBKKD4qkrKFE9qgralspL5IcMhn81B3RKqs3QVCPa4xfaA3gKrog7j5Bx54SERE3veFV4uISG4utUWiiLZuAc0wDoQC1x0MH6BRYnGYCJJIm9oeyEV2GZakfy9c1Atr+4FUwBq+dgfQAggXYN/j2yN/ieEH+r0J9E1+ISG9PFELQNiskiQUZJkIbWD9FS5q32hPkPATCAegMDYQfk2URgfhNEROEZnQmsK8w3FWjRIgEj1AlAfrmPl04aHPrQ1C0koSrfaBgOY8wXZg/dKrz3AMhteQ6LGO8AFvFGMU5KLpc1qYQQphCOgjDE/vYS4geqI4j36fioaI5c/VcR3n2svQFZhve5CN5W9pRIG1y3iGUYbmYE5dxLwB0HFr1w1aQ+ywNcPOOlCILbbYYosttptklMqOLbbYYosttthi28520pphZx0o9D2RypWezZ/8yE+Yl6cm3S58r2mfGpFcaNg2GrZnkUQilrmkGz2HTqJLurHXd6RvEx/fqW3zR8MSY4662u0IihaRlVXb+93+mO1V7RmSnyJbp4vD1tx0Ewru3WV7dHMpG82x4jiQzJxx6w5WDzvaqWDfzF+z28lFevf4p44585Z9NkogNe8g9Ttu8wWkmlc/m+V9uw4LX7A9xv+i8l1m+sz+NWceGyftti37dj/sOkhUjx2xCTJFRJ487UAPlWw0TtLBMZC9c8Mu02NuUs3T3+WQv5yz55e7HSScn09POvNw8aHU7rKfb/wRG5KyeczuI+lNNyFk0sG/kbC7jqyetusq9Z1uUs3+3PPQs7zetoMWB98I5vkDSU01pVuj95MxttH4bcaKk+cgBQKm0tM6hw2y+vtEHV7qks7DXrcvvWl1cfo1xspjXA4Nn+oheM59epOBRJiOvk8aRzB+e0NeeHACFC9FOyE9jOkNeLMb+pnahFdvLB95Vnr3GJvu9UUGueh4bu6CJxpx8CFBZAlx2DUfz4/6A1cCvfD0nOaW4TVGffogXOuO6O8pG5leVq3LIEVvKd7LQITwOkpu0ouaumz6aGF9EQDFmkSZO3R4oqyCeZ4e2TCmH6SLubUo8V6mDn4IcFGkqpD8S6Ne09GGJvEekQmU3LQkz0VEekXEyRe6Ik14voFW8RcIZ9GP9AbrA0iGKuUj8czgRvC6QI5gN0PyRNZne0a5FIiaGaDe124PmfP0ujIKCQnA9ozmU55WxBkJgBmj3ikPpHiOeekH+au4zqO3nxwTSSA8klUdfLkupQDB7zAENCQvAe/HPsfrWrtwfyIU8SxE25BHheSnNHqxc4uBZDejXnS/rvdk/xyko2OuU6b0ZHTMsp8STVE5op8kXQwlM7kcwtwwAJKqXyIPhTZUBogq9s30kCRs6QLafxBIqk4ZVbTdZBQ9wb5DCVaiJlif5KIIuSXwbh/UwcUCCcsOyGSzS0BIYQlHBER2JYjUCUkXyYuQQt0Kyult6hzrV3ohqqE9DnLLCSKgSHBKrhXyZWCOTXEu0Lxa7OjLWgfp2g1EDeygNcNzPlDwPO8tIvJ3RWRDRJ4Qka+KyBNBEFwd+11sscUWW2yxxbajLV4zxBZbbLHFFts3hl0NQuG9onrSvojcJyLfISJ3i4gdzH0TLNUQmfrylV6z9Tvs60tfczOIhxJAQ7b4btsj31qw3czbhfMmHWoOLss5PMMtz27GrtuBKF7N0fQOdESjaXtUJw7aSAARkeDPJsz0vu1E3zohvqJMjuQ1N8qiuN9es3YHthfW8diSXXFmIaNfsj29vZ9fNdPrT9scA8032vHjg1N2nYuIZE7aldg4bPeRkaccMI/tjkcdf/ITdqfuO8AcuUt2X7vtPnflPtawFTT+6oTNs+E17Hatd7dB4rTsAZK/aJf3yE/Y8pAPf9FGkgQj7vEdTNropNcds6Uev7Jgc3l0t8lj3MF1sf9XbP6GlTfYXBBkZx42/6K7bit32f0w81W7HxbP2u1X9R2ThYhk9trP0Vm8iciFHRQPeQ3sll8zJBMDGS22JF1WD/ji15Tohsz+ZEcPPcAVeubhrRvy7vcR2++vqWs8SHrSmFX3og/PdQas/tVRxzuY6gDzeq/CXfqOrdbAao/3XqikAO8wmfxpeSgkNKajccaJSlRiMUVeE8Qmt48pWqhb2PIk02vZGcPzA4lAFAWVYxJLmcjfBcN6mDvlcvk6EZEk6jW7pOsrKk4kW/D8+ojvLun9k214MeEhJuqDse2UBOyW4JH0RIIykATw+o6N6vyxChWiUBYQU1QoFboGjy04L4pntK/0c9G5LFHT+ba9R2nv/UobZdb2ysCrzfagJCYZ/Tl1UFaP0pBJoGJ73QSbbIujYjwqy0kEmN8IoveEd9dv6wWdaV1bNKe1bMXzW/1VZEshgao81YNA7iSj46E/q8/oARn8s2/8GxER+c+fe6s+8yKVAsAJMBqEqEhySYQyj+3o98xGdK3dmdZGTa+pi5ue607Zx7NE+xjHKuuZHCT08mfykG7Ed5mjPivqCssy9lGiaXKrfcktaH0N0C/JSeEFaA94/ztj7K+aTiUProGJ1KHXn7wEAZXpsIgneiYgShkfI8+gL6EPJfDKHzutdUNZ1xzUJdJzCmFoHRyTblLbngoUhYtar+TTSGDMb0LOlvXJ8dGHtG4ACdj+hD5z+lL0GYkOoFII59SBDz6ac5BvRd2QByF/Set443btq4V5jN8irssnQ/6H2iy4E9JUENG8qCBSP8D5AmMLZU4t415YR+UuRvkjbojtoDXD1RwonAuC4M/w/z+6DmV5wRaM9aXzXVducF86sWxe/6Zxm+BNROS3/8O3men5R2wodt+1tnbtVMUdwuAKeXDB9Tea9qLbBS8WEfErdifmIL8iPWuXqfoVN+T6R37u42b6X87Zcm8bDilEzyUPWXV3X1fdNrv2hsaz90xSu83dfhv3O/52zj5I2X/OzqQyZx9s/dA7P+3Mu+WIA/nzP3utme7a7Ps1ZxbOA4WBYwJMvN4+XOo5oP9nK27CvdKDtrrcwpwDGl+327u1jQwqJbeGbepBm2C10rHHGaWGho1kWqY17HJ95vQRMz2btQdzUHSfWBbT9qHFiZ+yDydI5DVsnoNgsXzSrYvZ3GU/X88RpdS4zw5l8S+5DxRSMw55Xecvrr9tM91/I9otv2botVOydmJrHqKsXhIybLlVbP73RRfVJAEMZfoWK9H7TkLDPQgku6I9cuOo9uXGDDY4lCPMRztNoqCFSE3qgrr+FOY8kqChjJTBC8MOQhk3bD48fUeMnNf5yV/W+/XHdYE+yBLaPzSfh5tQbNYnvVAGcDCpmeef0RdKcxYLdYSKEFaequAAAPNTY7f+YfxxbBYBpyY8PbeEjWkTRIcgW0xVEZaBgwTBhreOjTDXKzzgIWkmN1bJO/WZO/W0SEvLROLIlaZu/Elwl10BGeIRzTOzTolLvRfrl1B7hllQfo8HMpQvrB7WemaoS2NKG5DtTqh4egP3PYyNLt5Lift089dYwW7TD6T0OKDdMzyAAbQe3S+BUAf6Tfyq1qe/rvPrIMeDAs189Ek9VKncWRYRkT7qM78MqcAZbLCwBitc1PtWD+pn5rT26b//PR8VEZFf+wREXPDOaO9GZ8XGuHgqFYZ6DAhpx0ECiTiT6APNWV0XdUEIOvIMNsOQtmzhEIllZugoSf9qqM9wMz6m4zCBsnXP6X24Mc7WopKc5VO4DzarrUm9T2ExkH5B69FfQihOBhtTHCgmNrXfJXEwtnqP1lMSz8pQB+4bSGbJMA+vGV07MGQoA8JObtbDww7KrlZI8IlnGWVIBcqX07muM5qU7EoXf9Pf8CCBB4n1WRys4ACABzbst6EsJA8KzuOA4pAeBAVY46QrUdJL/t6vs6yYKyBFWjqlfXKQ1t9NfFbDVut3qUMuN6d1vnmoHJKOhtKvqA/OQ41ZHAJdSkau64KUsTsOKctzUYnR0pkbt8nfSWuGbXzYV9inPc/7XzzPu3E1HVtsscUWW2wvBguu0b+dY/GaIbbYYostttgs22FrhqtBKNwlIveKyC94nvcVEXlMRB4LguCW8Tx460nx//RKD+bDD4ya159+1E16V3GAMgf7bU/au+943Ez/2/e+2plHu29Xvwuh4PKuFzK2T662zXFRykE6KQ4OtL7D7TdMiHO5vf9332qmu0gWM/fb0H+X+U+6CRNrR23ISKNtp3suD74DySEiMthte4eLE3ZYTOUn7Hb96SNfNtN//aE3O/MunLCfY+AIG8m93CZAHGwjy3eF5wrWcIQRVNYdUPNdtifbFcIjInLqaRt+T4m0YfMdJDrZlNuL7vrN4mftvFv77PKWpmyYR6+3DULhcVveMzlj36vVtOs8N+ImRa117N/0HGESJJQatlTGrsPb/sUzzrwbK3Yddj5mI5qCdbus4/fZ6DIRkeU1t+RpbLeE3fJrhlS2J9N3LMvis0oU7FdBagcPdw1w32E0Tv6Cvqt6I5B0LAJ6wygBkN31sympHNSXS6ai464LSG9zGtfk4GXL4LOl64LWBsInDsNjt6h5BD7Jyujdh+cQpICTX9PCp5f0d91xnZcHeX3xUtaQ4z2UiaNMG0gctwilt+ZJ/xK8kPdA1rGNOQ4e6H4BXnpAinNzIIvD64dw/lYZkOMWvZ+AhoOMMYf67U6i7JQv7BFyDwh9cQjmDlK6zTu1vVLwQqcGIr1peGRHIIkI4kiiURp74J08DfK4VpTYrggPegIEh/RSk6a9uyu6zixc0rm5vlufjRDyDmUOD6C9d+l1qQval4K79dmbl4BwAKFhqu5JBc9FqDtRqDkgCrKrkLxE2zI0pD2j98os6vulOaX1Sg86rYuQkcp0lDiREPCNu1FmEFre/ZrzIiLy3j/6Fr3gMJ5lHn0eRKEMH+gVtoigcysks4SnugAyv5AoUhed+XNa75t3IzQF0pVEJtT262caAEmi4DIgAWztQT5Vba8E6rM/046UlUih0Sf1d5X9ep/squY3ehr3CSSUMe2XGLtAIkcdH9UDUeLxDGTJicghWWhzlvB/fHIaQZ/keockjf0MiSETkfvQGObEcZJbQGhSPxqqkuykQgRSsknJT9QL6jWNsKTKYf0NUTCh3GaL4QG4N1AsWaBWiLZgqAgRKUQREF0QlhVknIOMXtAd0bps7Na1BMM2Fl9T1vLUAqnsT0aei23f3IsQLEiENm5D2yE0lmSMuTNYd+ARxp7GfW5BvucXgz3nA4UgCL5LRMTzvJxsLRReJbcolDG22GKLLbbYbpx5Oyoe8oVavGaILbbYYostNpftrDXDVctGBkHQFJGv4N8tZb2cyNo9V3poQ4KTIWvscnsQA0fc/mDFdmV/6r++ykzv2+AIERGpOrzlvb5drsqKHWtfnLBhBS7yQ5GtuL1hCxyohmTH7vTVY24v82DJQRa5z4Y7jOXsWHQ/aXtUmz23h7LZcZEQ2tYrODzfbtU66SzafSH5ebvia/vt+/wPeYWZnlp1P4OrbTu77PYY1Ozg9azjuUW2CIKGrebot6klO33mJTYfwlLVTToZypANWeG0XScJB4Km1najWHyb08/J31D/mxkzvXfe5nXIPOCWxRx7yC7whaI9YRx95Tkzfa3pPkqfytsPuJC2USmUhxq223bZKIG//dqdzrwzozZyIuXgULjnJfbzLdW3ISY9bt+sNbMNE+71tlsIfnir2C29ZmgnZeHchGQ2SZAHbxn4RBjfTUtv6vxKZAJJ7EJEAmKpKRPXKW2Nqfo05QH1O2PpuaD04OUPZSPLOkcEZ/S978G7n19AbHMl6nUkoqw5CU9sG3HbNUrF4b6QWuuOgkARnknG3dPr3x7bIjgMPajgUmJ8tKQwT4OckXHVoccQXt/MetQzmwE3AscLY/9TTXAyINbfBzEf4+YDcCW0EYPey0VJGLl+oWeXiIggGUhqhXHu0TJSapG/5buEyAR67WkDePVZj14PfBB5elb1s12CxxevoJCTAlJ2lCgdAInSA7rDf0bnPA9oQ/bAQWqL5DANjzcRCiQeTFeILgEaBl5eSi8SrULEQbcENEyZcpwS+UwOLcko/zhzVN8Jjx/XRU0KHAD+RUoP6vX0GPvwbmdWg6167hGxEyUNbQ8RGXZH9Z1IZENtN7gTMlGyP5JbkhOhhzh5oRQs9gGJdbQLECrDhKGUBfXryB98BCQ4TFf7Ic8DOROIHKCR24Mon9a4/r0xM4RIwHgij0eITsacEPI7LLCOBHWBsgI9QW6GUOa2SX4E1EUhypfiDQIJEhj3qMfNg+D4IPCGvAQgsySPSgKcCAMgq/z1KEqgj2cqXAJfCvoq+SI4bvJzWCOgTJ2RaBnZR/Pzel1tP7lLNL1yKBHmxTHcKWNstYfGNPjWBpB0Ty/4qCdB/eFZMa1lNq6OMP8F2Q5aM1wNh0JsscUWW2yxxRZbbLHFFltsscUWm4g8D4TCLW3JQPrlK+N9b/+vNu/Bpbe4Zc+Sy7bn1nv9hpm+JrZnkaysljWrtnfRxaGQH7Ofo+aIXU+n3UdfwyfPtIQj5JystFfcp7YNysPhYN/7Z/Zvcv9oGziAYa1tHJEbaw7PpqNuM47L+3c43NgiMlixYQLVQ3Zd5Y5t2Hl82sFjMONuPxeChnFtV1y/YQ91l/qD3sxOrjrQDqWz9vVzxSkzPTPtbm+vY5913vaOU2b6xd8/bKavb7qlYUe7dh2urNvIl9FN+/rqnTYq5OBIxUwXERn/pQUz/dyXbI3bp5+xlRmOHbUVKUREvva0DYkhA/uw9Qr282227X7+d+53O5w/OWeT0GxO2u1x4hN2+/kvXXfm0TxoozyGGbJvqN0Ab4PneW8XkV8VFeX7zSAI/u31z3WH2sCTZDUZyu6VziOeOB1VLQg9vvDokhnd39AX6eYd6h5NDcmYSSBSx9BlHDm9ZsyTr6TuqP42DWRfoq8v0C7GZeksPKUYQiwbvcH0ho4+tSEiIq1Zfal1Z7KRfOkpZ7w9Y6Zb4/DyjUZjnQd+IGl4dYla65TJNUGOBKgv7NfCFM4lkQ7+gQXNqw7JRJYhD54Bxs+zfilnSOZ38g90c2T0j7LkEzXcK+p1Saj+hIz09YS0J4DQwMV5lJFezfEngshvGO+eX4F3v6TtkV7XNm/N6HuQnvXGLj/ye3pYKWXZmqIXOVrmoAC+h0WgWsA5RKnn1iTQG40tGUdyTxTPa0IX3l0qTNAL3Af3xKBIhQlmrh+NSfBFYCptTkU9vfRCZ1b0uv1vUM6E0w/v03zy+ne++9nXyQEw9VXIF+a3UCEjYPHvQMkjswIP9EEgcdjWQJIQKdCYis7rtf2I2V8hnwbqqUJkCFEv6KstSotiPJ0E4mCT+UX7PfMrzkHudQW8IamEdEd04cQ2D5EIY1F1BXJ98J5cU4V9pDuEfslH1WPC9TW/s/3rzE9/Xz6lN0w2yEMApZAO6r9ExQVIZRZS0pxMRcraKeu9w3qjXOkIJxiMD5YpSfSPfk0DhZTGPEcvP8dR6QJUNjoch+AUgQwkx3h7kqga/b52l+5viFBpc+5pSTiIGnv0noMsJ2wgFVrkXkHZFqJKK0S3kDNhBGoZmQ0399Y1tx2EUHjOBwqe590VBMFTQ2kPBkHwyWtequdpfronu/deCTO+9JZd5vXbhQQMHDXTP14208t32fDmSteGQ4tsQa6uMEcH63oOQsGWvfniy9X+kePAxIH0cUHKE45QCBGRXsm+2eCnVxxFssubStj34aRqWdBwbCocmJxh6S7avt92hx0E/9TeFC797R4zvTpnb1S9e+3TnclPug+8xn74gpl+4ridd+HIppledxyEibjbtufot/1v2TDTUy37+tbaNgMwb58WHf+kLatYdAyagYPsbzsbLNrl+l/+6QfM9F/80PdcdR6f/7J9cHD03otm+qnH7AOFzDakk67Ds7GnzGTZsIskra49GT78iw84s07/zKqZ7iJknXrMfo6NlzqzEH/FvhmhwzfFrvPiwPO8pIj8FxF5m4hcFJEve57358Pv5lvBXgxrhkRPN8OUz01DzrDDzUwzSqRIiH1mXeenjTugkT6nL8i1O0HA19vapBDezMNbvksZXsFNBuXtSBJIOC4361z88tDDb3DhH50rGwdGImXwq/rD9jil4/R+67dnUEbkj9sMS9mJiLRAQJwE03OyFT1w4eZ48mEcPHjRzTnvXT6tO6K+j8MRwpxTfEZsGih3h7PadjF66MFNDA8JMuvRcnWx9khic9kZCSSB+i2cBxklNhHTD+u1zQluYLUM5WcbkTJm1vQ9HZJaogzrIICm1GJ1f1RusjnNTXcCz6DpA5DjeoBj835jX8GhCiLseNDRz2y1OQ9a6ntBgId2yK6AFBPelvqsli0LwrvNQyl8xyZ9FvUVrhVxIIMlSR+HWS97m7LVPfoxDXNj+A1DXOpYdjDUpHSBZdbvPBTw+oE0dutBTLoSJbcsntf63jiKgwUcinSwGa7vJlGh5pWAQ4AHLpQoZSgJwzMYysPIWZKYcjzywKewgL6EzST7tF/T751xkg0G4aaYBzvVPTyYwXNjCUEiw60xhpCdqej7jof8qU39JBk424FykOwj7AfjkP3cRJ2Vn9JJo4uy1vdDIhav8NaYpjcnvVBmMzzgSrLtGYLA+QlhBQi34cFn7ry2W3YF7QC1dLZLG2E05ZOQAZ3COFpHuyOsKTenZV67W8uaxvjr+9E+RHLIzIaE5WPIQ2ZV82pCnrZ0XO9NuVof8wDHSR5RrSOQcucBcn5BK5xEqjfEdtCBwtWEPHzA87xf8NRynuf9ZxH5N9erYLHFFltsscX2orFAdBX6Qv9tb68UkZNBEJwOgqAjIu8XkXdf70d7nhavGWKLLbbYYovNshuzZrhhdjUhD68SkV8Rkc+LSElE/kBEXnc9CvV8rddPyrIBVx5bsI+All7rxswTMjdsLqK66aIt97buIFkTEUlWHfB0R/9Ib9pl4indsPX2OOIaRMTr2SdwLmRGz4Ec305W8cArbTj2mUdsb+s9rzxtl8mFvd/mOCzRtv9IKN6whbCuIVv6aTvMRERkfGDnkVux2yN4uQ3x7560kQvVb7X7lIjIxrIdJuEiIK2es/thkHN7c/uONk9u2p2k4jsIAtt2P/c33ND03LzdTpRZGjZXqI44ZCZFtjwdw0Z477D9u1//PjM9+Vp3O7mMEnHP1fIOhElim+Nt1/ziCl/qFewKmczb/fbE97oJE189YiO2FvJ2vyUkcdiK79tm/vxBOxxi87z7Ny8Sm/Q87+HLvr8nCIL34P97RORyeNJF0XfzrWi3/Joh2REZPTMIofT5c3ApwstPcjXCsAdJeNZBthgSt42QqE9/3pzeIgWj56+1B9D2dYQ0AKlAb2bxLGDK9OrjXvROZoGKoDct2YrOIf0s5QX1us5oNLygMQOPLaZveia7JRLFSaRclNBs7uqHMPKQyHAzilDIzwORgXdGFpJz9EbS2mOE5gOSHCISonMVURQeytRHlF1nLAqJCGHZWAORhJGSwD08W27JCz3S9PJOPaae09perZDSpajkXpAmUSFRD5DMHIsSGbJOKgej8PQtYkN4WG8DegDIvz7WHKk1SCtCBrQFZV3WKWH0yU4guWVtnD4g7alaVCaSbc2yh7KcgLezr7Um2FcE9Ya8p7UOEkC9Hj6mKMwvPH5UH3USIS3oq4SOU64z1SAyJUoSGKTQh5daIXCuvlfXC5l1fYbWVDbyW0Lbw/c0Q0TQf7tlojGAZmlTKpPhMAyJiEossp8XLiFsBOgiEqySfJHjyOsCnYPfd0u+dDDea7uT+A3uTTJAlLFyBB7yajT0gWufUA4S5ItEfCSBzMlsRBEjSYybdA1jHEiEwrz+oDOh33tFSp9C5rMQJd1MdkQ6QyELRPcQ9TOAvCqlFjuzmkdyDfKzRBBkiULR+4RykZtEB3TwqekMy2EfrhzRSSO/DFLOUYasAHUwHS1fB2Sbg5SEIe4tH3Mq+m1jdhBeI7I1p5UuaHp9N5BLQKIlQhJRhGpt3kRi5xexXc2BQldEmiKSE5GsiJwJguAmYktjiy222GKL7dYxR5TJ1dpKEATueJIXj8Vrhthiiy222GJz2DVaM9wSdjUHCl8WkQ+KyCtEZFJEfsPzvO8KguA5BRB7nvdeEfk2EVkKguAepI2LyB+KyEEROSsi3xsEwbrneZ4o6dQ7RaQhIn8vCIJHvn4egWSyVxKkLb3GPm0qnHU/ft6Bakh+/5KZvvHeffb177Tl00RE0pdsjy5JUYZtkHJ4Zx3KjYnUNms3l3ff0bmzq/Yf1t/qfr7T85N2Fg7vbL1nx7v7Cbv9GFtlGT0oz9UGe+xKbFx0e2HrWbv9Jt9tx4/vy9me3le8/XEz/Q8eerUz7+IpR/z4PXZ7jJy0G7z2Gnf7JRwzXXLehi5MPWqXqbrPgazZJkzNhThwyZr2HHKE2aVtYCwujoFn7P45/2aHlOUjdh8ZfIvdD0TcxIgn52wCS2/JrqzN+7YhthzYY6Byu+P0vWSPgYJvI50yObdk7EbHbhAvbed94ZvtvnPk7kvOPG7L26iNz95MhML1XxxcEpHLXzZ7kXYr2i2/ZpBA0QcpTIPNvYoWy6xqn2/MqsePZIspeHLpjeY81R4jCR46AJ3XA5H+uF6UntM+znkvf56ebxQFvyFJXG4NHruRKJEeURG8vgd+hyT4HhoziFWu6Pe1O/B3DGPmR2/+MMKxN6759uqM505Iqh7lNKAVL2ke9KKPnNdnbYLsLwVJyuIJHauULSQJYy8Pboos3c/6kYV0X20vPI57IPk3xBfVKzI2H4gFlDOMfweC0gtEMuusV6ApgDIpne+G14iIZC8pq9zmXWXNkwqXScbeIy96/9E+jOUPJTNLUa/zVpnxLCC3o3Sgv7CFahERGTkH0kwgT9KVXog6KZytIQ/KNKIti+Qb0LWU30Cf2AVPbCgzqZ9NoGZIYpcCefNLXntCREQe/bKS66YbUd4BfhKhUlgEMeWU5kO0R2ZR3daDDCU102E98hkqx7QwRCQQFUTvcgfTeRecE/lLiIdvR9s6QH/uYZ2cXktGykpOEq7tcyskLKQ3X9MLF/Sd2gNZYA/IFKI/2uVkKCVKRAZ5GKpHgfBoAhEAxGhnaK1KvhSiKjIr1DfUj+xydEyyHTn20yCD9dp6/0Eec0tWn4W8BCS6JCcJSR1bk1tIDXr+Qx4xjoOz+twtkIQm0TfyC0QFoXDoAyRNJIlp4WQFZVR4QG9S27kJMlPOsZmKXt8c1/vn1jS/1bvAr4K+SaJQ7h+8diKUqxW0OY+rU+DPIF8GUQ3kdRh7Bs+Eeb0zwj6Awe7gmLsutoMOFK6GQ+HHgyD4P4Mg6AZBMB8EwbtF5M+v4ve/IyJvH0r7ZyLy8SAIjorIx/FdROQdInIU/35KRP7rVeQTW2yxxRZbbDvRviwiRz3PO+R5XlpEvl+u7j18Iy1eM8QWW2yxxRbbN4BdDULhK57n/ZCIHA6C4F96nrdfRJ55rj8OguDTnucdHEp+t4g8iP//roh8UkR+Aem/FwRBICJf9Dyv7HnebBAE89vm0UxK58krvVPJw3YcfHDB/fjrd9np2ZbtKfyn/+KPzfT/+Mw3OfPo120PN0/Zh63nCFF3IRoyGbcHsZu3b+ZCO7iOnkY+42bqX3+VLQ3xI2/6rJn+13MOmnmHufgeRLbi5YbNxU9RKNme+uy4Oz7+4KgdJ378T24305ccYIA/uG+3nfeEm7/h6J1nzfRq126PU4Ht+S7l3TwbzoPTqo1QWL3HrtzulN2pis+4FTS6DmBI8aydR2A7/J3pIltxusO2aQtJhF6wYWvstb3u7b67g77tzY+a6Z/6k/vN9OYuGx2xVHEjaFzzQpC27zUyYve3Z1emzfRux/18p5ZsdFJhxB4ELd8uk4tvRUTkXN/xt5up8nCdLQiCnud5PysiHxWVjXxvEARP3uRiueyWXzMkmz0ZfWoj9JyHXuis9m0iE+glbszAa18lszk8jR1+6n1Dz68nkp7Xea4zofNEbg4x+JiS+c4tn4zOIz149xkfTc9tejP6Xg3A60BJwERfy7h2Jzx+4PQhS34bsdCM3WfMOeO5sxcgV0kZy8oW/0CKoCCsB8jnMPasvkdSkK3zEFxPhYnaUV2XUaKSbPiMYW5D/o4oigZ4Xoj8IDKBMob0igbgfUkt4l3CKY8IBUjYpRqB5IB6SDUZXx3lx6B1x+BBRRw1FT4Y203+ASIJWhNRdvwBvf1AJnRH6fVEmTbIf4A+QzQeipGDd5poBK5Zku2k+FWgR0a1QTqQsuS9Gfc/gOQhY/xZ1uYM48/ter371cpj9fjnlTNhUNL7BZCjpnea/T9UBkG7Tn41+g5p7tb3E+PmE/1AmuCg6Izo39gXBikqdej3GpSHOT4Su/XeDdH2Cd/teBavwz6knzkw+XeVDiWUMM0vof9DHSW5BA86pCDJ5UBeCSJ/wvZIbsmW+jUqEWgeIfIAn0EOeczpBeTJYP8lJwiRHjnIFpYuAZ0CHgHOBRJE6yrIYS6Z8CP3WbtD8yvOgQcCa5f6Hs5vQdgvB0DKEIlD7oRWAbwyZ8iZIOHzi2wpeZDzgv2Y9dXcX4r8nXKrnMc6ZZ0jKvshPQu+iJV7ouvCzgwQXlCZ6AD5E8gWEsQLUUQSKStRFFkgFajqECKiMJFRare5b0Rie/52NQiFXxeR14jID+B7VVS+6oXYzGUv/AURgVCOSTxl6uF5nvdTnuc97Hnew/16/QUWJ7bYYostttien3nBC//39SwIgr8MguBYEARHgiD45ev/VM/bbvk1Q6fvDhmKLbbYYosttutpN2LNcKPsqlQegiC43/O8R0VEELd49SLvDguCIPC8q68asF+/R0Rk4s7J4FVvvdJZs9S0WfTn8u7TqN667cHPfMiOz/3FjXeb6ft2215sEZGq7cB3uoY9h+Mt1XS43ZNuT50L7eBSsfAdjvp7f/BpZx6PfNiGeYy+wvaEVhq2dz1wwAqCbQ4Ts47wdWobD1sua3vqax/d5czjvh/7mpn+6K5jZvr+++1Q50Npuz4WG3a/FRF59NkDZnp60fb6B+O2F318t3tB3erZnaHlADXkHcoM1awNE0i5ARghG/WwVV5r/yj/uB2z7+JCEdnyLg5b+mjFTC/l7Adfftb2xs+tuWP5Fz9t7nUk4Riy+XmHaskB9xhnbOSwTX/WwWnxYzaSZHG+bKb7BdcEJpLP2n8rZOz0Rs1GfhWObjjzqNccnWT9mr2Wrt5uIQmnW8Bu+TXDSGF3MMimQmRCogOPYk3Heu2IjuFOCazgeOfQu8247n4e3u+y9m9vPYP7JKTLWHrwppBFvfwUvJyNqLe+dKETKYv/xBnN614VYvd6+vteUauSPAREUWwehtftlF63fidZ0+FJBDdCsF/nUvJOdddykfJdjroYYApPwJs/Cm151gNZ5YlQYGwyyxZyKEzmURZNb06QQ0HvX9+jv6OuPFfLfXhTPcam0yvdJD8E0Rv6M3qA6aHVi/WDygjkccie1TVad09Z71XXvzd2a6Ho3d9Cr0ikzOSg6OSRVxaZk+8BZU2i/f3N6H3oVS2fAIIFHnN6o1MVRXUF6VSo5kBUBQdTfZf2N9bnFm9AgGdBtaSJTEAZZrWfv/uer4qIyAe/BIQc2POzQNeQG4ToiT4yzm5G3z9en/weqGx8ZBbU2deZKYRl6qK/V3ZTnQFImr3w7gO11p2FCsMGHoqKXECCCBSCvA44KbjcQN5Uy8hUUTaqOUCpIVXVOvCXdS2U8jE+fJTvtgLuq79rzHphTD65E1q7+pEyJ3fpvQZz+C3qr42+EoRli6Jd6GlnH22XgZZZI0yD9Ur0RA/3ASpghlIm+rF+O+Yc8A9IAu2XH4T9ksiE7gTQRUCjEGETIkFQxtJ5zA9QnMiuYjxhrLNv+jXcr09UEZAeaHcAQEIVm+oBTec4WHoA6hxQxenux/qLSFEvkEExiqpiPY+cksj3EHmNaihc1DHVntD6as8oWsYH+otj/4bYDlozXJXKg+d5SUGTeJ43JeG0/bxtkbBEz/NmRYSMh8+LeKrV9+XZ9SvhuemkvZlK/0XZea9d322TL2a/32aLW39i1kwvHnRDyhutq1sLVQ87QhtW7Q1C2bFJFhFZGrXv5eA/DF8gw3aksOzM4wl7XybvP/dyM71Zd7D0Ocjl/LS7/lykfgnHHijv25up+Ze46/BDv/KgmZ66zS7v/KdsiPbmvOsEyZm1JB+0oeN7PmVfP/+T9nO4iBdFRMay9uZ9uWn/pnTRrsNUyz7kcJGMiojkF+2/DZ6wDw5csqau8CGRLbm0Yct8wT4IeMcPf9JMf+gf32mmH/8/ys68E/dVzfQ3Hjxh5/HfX2amry25Qx4m7FtJ5ZB9wLPH0d5LKfvkLpNxaXWKDBwvyWbXfuUErkMARyiSiEiw5vjNznk/v9jtll8zeN2eJOdWpX9M398DbHTF0wVlso0DgyGYeweSdQHDikAUNjaqG6flTWz2x3vhAji5oZfm50DEhs1YF9Bizp+pWvRAIdivZeNGyGuBTG5WN+eEbodye+N63XqKcGlsfiZBPogDhUFN5+UGDj+4QSNMm1KNvXU/JGUeP67jsTWOkIZ6FM4/SOOAAJsLbioGeb2eBwmUZuSzp7FW6EBVNpybMY94GYQ2FAFPX81G80XZSZaXXeOmZotkjc6E9LkVfYYH9FDXa0NyD+ED+Q19xlSDcHT93fJLIHmJac8ZHgrjARJJF7mO4e+51CJRXn4BYSOLeioyGEUYDja4iXpbWvv03USyw8odOv+HEqCEqS9r2Tduw2ESDjkS08jsgjbuH73xN0RE5Hs+/dP6dxzYDHB9el0v7xWi4RwkYWRIS3pZy7N595iIiIw+qT8MQx0anMcLUjmYipSZSxAeejA0aHim2HdY15oXjysoKZQnBPEywwILc1rWiaei744uDpA4XlI4OOLBHA9uGE4ShhFQUpDSkEmRzhjGSCa69vZwiNRppCPPRhnTNggO2Z/zj2peoYwqru+M6u/zi9onunmGYGFOYLgO+nf1du0rjelE5H6UVW1NSOR7P+NJsoCDxDBTbPSxn0jCUUlp0Ax8oySGDA8TIbVIadKxp9X72EeZq/u1bIV5Sp7qfVqpqGQj+8Pq3cnIMwwO6uFM1ke4D4gYk2eLWwc1kDPNLlHOVNOLlzSdfY4SlwnModklHABV0VdwUNM77GD5jm1bu5qQh/9bRP5URGY8z/tlEfmsiPzrF5j/n4vIj+L/PyrKCM30H/HUXi0im18vFjK22GKLLbbYbpoF1+jfzrF4zRBbbLHFFltslu2wNcNzRigEQfAHnud9RUTeiqTvCILAjXcfMs/z3idKpjTped5FEflFEfm3IvIBz/N+XETOicj34vK/FJV/OikqAfVjzyWP1LmBTPzDKz2xz/xrG5KcmXa7staWbS+lf872orsqMu1y+W9jLu/6zEN2esN+PCcyQ0Skn7N7Yd8lFdi0z57e/6E3OvPo3G0/iF9xxFtUHCR9Dp8W4aaWBZ5dXhdJXyZpl9XbRnpz9SV2/znywDkz/cwX9pvp/Xetm+mVqvuU1OXRrf28HWIzeMzuJLnXrTjz2I5U0LLqz9mQlNV5eyyVH3OTMi6+xXb/UHpt2HpFB2rizDYIhTF7fHTL9vV/8t4HzfTGLznCRpbdz9dO2OVNOwZ/Z9R+DkqPWeYK6eg7upUTrVK1n6O54kavDxzooTvuuWCmZ4/Zz73wtE0IKbLlmbqiXLuvfs69ZnYLvdxvtr0Y1gySSEhQzIsApssR05rSvl3drXOgB/h5Egg3enD9cfVsDQbaF5cvlvW6EZCqNVIhCV8o44qP5iRIF+HtzZ7RuTvID60x8ApKz+v82t2loXDpdS1MF571zUOQi8QroFcAMmGMLnFAyQlfH1dEUrOi3v7Epj6rXwHUGNNaZv0yWU3UC722ySZg+if1HRZsahn9PTpue6M62bSmNY/qHspFkphN8He6/VFFJLWjxDS8kn3MOXy9p9eiIRA+aLRYPkoCpjd6kj2/oddm9R6ULezuncBvtQzV2xSR1SpHCSPZbo1ZeGgRFhCuT9h5MAdwjUXvdJLeYYArRs4AMr6uhWWfS5b0Xe1XgVhZR0N4niQRUtId13otLOo1rfEtwkARkaX7kVeeHm0UakEzfxlkIb//Az+veRJEwb5xif1e00vnEIoCVA3HA2UK+5CvZLhGAE9vZwze/iOXQQhxzy6S+O7uzOizpBdAYgqvc2JV6+XipvYpSjH6y4DC4/cjJ6LhICRRZF+gTGFqpYb7AIFAVA3IOLsl/R3De+q7iLpBefNBiD5hk/cZXswwgjVKHmoyCcQzC/qf4rkhlAZ+noVkIpFRDL9hfSYgE9lCaEMHYRvNcfTVst6HpJAMXyKKuQkC6SDblz7f60ABpVfRlnit+1jOkdSVBJT1ab1u5BwmwwRDt8iUCtTAGOajDchCTul3yq3WEerC0CHON4190bVAcg5zCNBgAdZO3T3dkFi2eFbLRCQV10tEF+WA2MmgfjsTWTyjPgORPxxHHJM3xHbQmuHr7hg8z/snjj+9w/O8dwRB8B+eS0ZBEPyA409vHU4AU/PPPJf7xhZbbLHFFtutYLcSQdLNsnjNEFtsscUWW2xf327EmsHzvH0i8nuiJMaBiLwnCIJf9TxvXET+UEQOishZEfneIAhsD+dzsOfigiQz3O0i8grZ0pF+l4h86flmfD0sdXggY799ZWxy8sKYeX1hzt2SwcvtYPteykYokJhn2FpX6eUV2TqxG7baHtsj5yJrzKXcQX7euB1T73DsS69uPwcJnix7w0uOm+mfedSWh/SrV/d8YaydVS4HyiNwPd/A/oN/2k3OUniZzfzo/RPbIy/fZSfXnrb754G/cZPenfluu79tPmIjEXwHl8Bq04EWEZGRtN1HXBwyq/DODdvY7k0z3euOO/Om1NqwTX7Vfu65b7YbPEi6UQLiQAl4GbvDBW+2eQ968zZ5ZspBiigiMjZh3+uDD9tcCVNLdll7BXfU2sg5+zk2DzlIGR1jgHJcw3bXA2edeZ/66GEzvXG7jWrY+JRNfjpidx0REdl8pYPfpHr1c25s19ReNGsG6Q9EKjWRGfVKd4uQYSuD7A9xvET7dEBuRrm9/oLOnwmQAiZ2g0APQ89rJUKSODoxCwvgZfApwYfY4Gktgz+n67l+GZJ7Cxo73juiXAqpTe33rRnNu5dH3PuQrBs9jfmz4ErYjzkSqLsW4rylHfXy893J+w1SnnggVMusk3SRce7kXQC52aFDmneWTIb60UUZee8UiCjJC9GeBCIBP0hNaj12ye8A4j3KGJLgkB71dAXcCfBQjh0HizTKPUinpDut3dJf0rm3tUvrjzKc9dk07qW/ya9CNhIe6zbkIUPejDbdy/qRQEw6uSlCt7/QW6rf6O3vZTSdRIrlZxUx4h9XFFewW3VFBzkQI+b8rRh79FPGsVcOMnZe/05vb2+chHh63fe9+fMiIvKHn3itXr9P8xwsAaXSobdZf0Y0BaUyM6gbf1Mb0l8D+SBkVtPgIRhk2HmCyLP3fZEOlkfsp0Ru5M5q/TePYF5vk4MCP8Z72WskI78vXIi+n0qIm6ekqQ8UTSivOqIeb/J9JDe1zM0Dpcjv6rP698wGxsskx8kWL0aANs5Noh6e0nt0D4OH43wW9ULuAhQSaw/2gSzyCLkRwFPQBE8KOUcC9MUexhfrlZ54ErQ3pzGW0Z6NoyCLBYlpatmXHmRik1VwFvQ4hlBG9DX2qRZQEJOPDyEyMYaLp7QvVY5hnPEZplKRZ+8W8YykN0E+rSn0lbz2rcwprbvWfpSd0tIgjSyc8kOuFdZDD+jLsWeI3sLztkgWKqgnSGZmKGGK6yB5uXl4m3Xji9N6IvK/BkHwiOd5JVFJ54+JyN8TkY8HQfBvPc/7ZyLyz0RlmJ+Xfd2VVxAE/28REc/zPi0i9wdBUMX3XxKRDz/fjGOLLbbYYottR1mMUIjXDLHFFltsscX2XOwGrBnAJzSP/1c9z3taVFb53aJhhSIivysin5TreaBwmc2IyOUu045saUDfEtZcy8oT77tSqrDwNtuTvHGngxpeRAbnbPb0kbsdMeofmzDT2/e4q7ifuTZ05ANHKPNm2+1dzxfd6gWW1Xt2WR0qjCIicvI/2bKR3jscagCX7LpyIRQSx9y6g/207TXu2c3q5AtI37fhzGPtUtlMr36vjdrY90qbdHyxYpd1acOBdBCR7Jyd7uKI6L/c9ohvp/JQ69oda+A4vPXX7Mwzn7YRGLXd7v6ftUVWpLLf/k1+zO4Lvbw7zr8wZXMfNOv2b5rPls30t7zRlg/9wofvc+a9ctZGZ+Qv2nVIybdhS2wzjBtTNuKgM+ZAOzjgOy6ljCceO+jMOzFhD9pKy0Z4MbZz2NKbbgTUsf0LZvqzT9pqKjfE4gOFy+2WXzME6ZQM9k1Lr6iTGpEJRBV0RiAxV6LHT9PJv0JJs/5uHYhBA/HX8AT6VU/SVb1HCk7z0Cu5CSlE8jdAXq27qywiIskGFA0OKzKhNa1jZ5DS93p9hl41/T3XAb08yooh1TyGSQKe3UQF3u2xLsqq4z67op+UiE5vwuvZDiRdjY7PxqyWpXQCvA6Qg0xBC7uXy6EsqD8gFFpQoOA7hDwP9PSGqg2X4GqkRCD4H/xVeMI3gGjA9VRKyFT0+sYe/X3+AkgVEp4kwewe5KBQAQWK7kiUF4Lv0PXbojwC4buVUxs95yx6GA+PmHTwOxC9QpnkXg5oFiyDckBCMJ/2Sw7imaKM/r1sUtpj0dh78nCE/RJLidYevXkSvBgHXqZrj/c99Opo2YFMoMRwZtWL3L9wSa/LrUQRgPSIU24vs6idpj2rBUj06HEHkgd9s7ovEd574Ef7Ld9x/rwmdCF1Tf4u9kDKGZZAVcWYesoPEmGQ2YDCCL3+GF/0SrcmoTyyh4ohvI6oJE1uzEbHb2t/V5JrlCkEegHykFw5JC/gnnjWJIYgkSPpKsY8kQnox35Fy8z6yy6C52QW4wHXtUeiqJduCaiK/eCX2BySo8R8RLnQRF8kO4e5iqgh8o+QA4TcBuA8oJwt5TTZ76mGkUb6yCmtqPq+QqQM7KPDCNc2UDRZqnUAkcN5jPwp5M8iZ0aqKZIJwfnkUGHbgQthtYd7Ufc2Om+EfQB9hpKWLlW762LXZs0w6Xnew5d9fw/kka8wz/MOisjLROQhEZm5jLx4QV7g+/lqDhR+T0S+5Hnen4p263eLnmjcMhaIvaFaX7E3bGM2d56IbE0iV+TxV/bBQSJwQNCb7k29S+rO1cFSjv0zIWTDtrLplpRz6cRnfAc5oUNmMv/X7k3v8v2ODWPN7na+vb9z1ke9695spFyP7rhXrW1vdLxP2ZthERHvNnsTlFuyn3vh4/ZGxyWRuPIG925x//+0n/38u+x7zRTsztPpuacA12FRP2c/3+h9NsFj+x77eu9T9lgSEXnlDz5upj/zr+8205sP2odUrW3Uf3Jp+ze9r9l9unTWrpCvPXWvmZ5yR3TIP3/LB830//g7f8dMb07ZdZjc5kCh7cjfr9j3qrTsuSqzbl9fOu/Omy/oYesetvvtkQ/Y89Hov7JJHEVEHv/CUfsPuReqTBjbNbJbf82QTEh3NCPtMuUi9aM9RGjKDRc3rh52xK29gONuYlGNhTwJ+RI9L9yAJtualsfmrDUGyDUW7F0caoThBNjgbEASjgcHLZAEcgNFuUg6KAqX9HPzdkjTHUc4wjiIJQGLTq5Asg5Dj4STLGe4oWhL+Az9NA4foD0fpEHkCNlAQt3Tm/r3dpl5Y1OM9zLrkUYSxlSDC3qUFaENVxBF8rADdVLdFz0MHQCGncChTGs6H5Ij9lGmzIq+E+u79Xt9F0jihkJIuPGnzHEAokOSWAbYGPvn0/gdYPCLOEzBM4+d0BvVZ/R3+WVI12HT2AZR3GBow9bPXfZsSNs4ivrAJrA5o3/IrKFvgLDw577zQyIi8h8//G164ShkCyERyE1cbhkQfLwvi3M45CDKfGiDRjJGktp1QWjI/sFn6JT0k3Ke6U2R+n72VxwoFFGfIBgODmp9ZE7inuiHJIpkeDEPgEgWyPoMN6yoq0Gahy6UQ+U4Q+gRQh94AM8DBUoRlk7r3yt3avtlz6fDUJsB1kJBlhKjOORDPy1eAEkgtiCTX4M0ZS76Hswu6zP3C9g045CLUoy5Jc1784imk3SQDgW2W7KOQ8G79KCveR4ZM2QouzUH8DCPh3PJDsqKw4rRM9HDDspstiYRHoN5hwcQDA3qFfTZqvuSuB/+PsJ2w3w3Ee2LXewxMrNaeZ0W1qZ1yLVijsgvbB1Ksqxjz0KeFCFqbFvKbPKTRJH1XVph2TX0idHogWff3g7cyrYSBMEDX+8iz/OKIvI/ReQfB0FQ8byt91wQBIHnvTBGh6tRefhlz/M+IiJvEB2qPxYEwaMvJPPYYosttthi2wnmBTEp4+UWrxliiy222GKLzbYbuWbwPM8XPUz4gyAI/gTJi57nzQZBMO953qyIOLDBz82e84GC53kZEblDRAr43bs8z3tXEAT/8oUU4FqaF2ydWF9uiQ37Mce+y4agi4gMPmh7k0vvtqWtKx+eNdMbdTdCIenwnroIHgeO1gpJa4bv33cTto0XbDhAyhVf4LDqfnceLjjA/mOLZnrlCbsOXVbIu92z3bRNNuiSy+w27CPJ9r1uYkQnVOlBWz6xfdL2fOdfZ4fRFD7r0AMVkTWb11IOHrb7dO19u830jW9yh40kknZfSNiAH+l82S7v6KvsOarpjjiST589Yufx7XaZbs/XzfRzOXcdjufsMbB6wO5XK7bqp/yTV/6Nmf57/9c7nXn/q8++y0x3VYlLfZaeJcs2HI/+/2fvP6MtSa7zQHTn8f6e68u7rmpXaAN0NzwJAhABUKRoJBA0EkVS1MiS0kjz5mk0fEscaZ40M09L1EiUqCXKkUPRiCIJAiToYAk2bDfQ3pevut6de7zNfD/29+WtPLXjAgVUdVXfzr1WrVMn7skMkxGREbG//X25u2tmeqtr4/ySDiBQ46gzaydywnegihL/aM1Mf+Lxk848PvjtXzDT//ujb3EX7Gabi7H0dWivhTWDn/akPZcOETW1uzSd3vrQiwqvcwbEpZQ5JHnsYAIesRaRDPCmLQWShIeb3jNKwFGaLFPTwdKH53wwQZwyvLoNkJtNR0kAiaJkWAG7Xg+gulRTf986rgXILpPcj0Rm8HIClEhPb0gQh+wKS73QI00pvv4EpOOaeu/2sYlI2Zr7IekHKDbXLkQeDMfWPkERHvEGvcS4kUe0BLz+mCZI6kiv6uQr8ES2ouEDtft3UHBpSC7SY731hgrKAnREl8/ai7RTF8gOrrNS64S7AyFCgk7KRNZJjKf5Uh6yNReFmBfOb+t1JUgAUubQZ535XX/fmUyE7UsPOFEURF/Q63zqHRdERORff1iRCaNZoCGuROHk1TPoW/DMpgHFZ4hK5aJ61L0+wgXQDwJAx4mqINqG7ykiEggdb+LdOaiOwvCV/ArGEp5VEgSCqed07UaPNRE1lAQtItyT/ZTInEEJZegT8RMNC9i+E+EZGHckNG4cgSwk+iTbkmEDrUMgokS4TXf/MAzvpNRishsliiQ5aHsfxjre05ROLF7Rdm0epVRlCelYj2Uh4Yi+WD8GSVEgexIoK9EvIzzPUVnL2ntZ+3aA7xnIRnoIH/CzgRSvsF2JdNJ7FVbRPhgX5Ys6P43yDDeKhj60QbpYfUUfUP0EEFXt6DxDAlaOZaJoOHfSegwf2UboyibnVJST8+loB5Uyykb3IUQkDIqYeIhWQRnKl7ROG/dq/23vR59BmE3hshv9fMPtVVgzeApF+E8i8sKYytJHReRHReWYf1REbOjs12nXE/LwERHZFpGviMj1BeDHFltsscUW2163GKFwtcVrhthiiy222GJz2auzZniHiPyIiDzjed6TSPtfRQ8SfsPzvJ8QkYsi8qFvJpPrOVA4FATBB76ZzG62jUq+1L6l+7V/CLu85o6PzzrQA5cvOdx+b3Ssl+pudg+/5OhJDgxM+qjthe1u2IUdbrvzTs1fHxKhmLE99aN32HHzIiLJoX3Kd+UpG4lQdatcmpbPudeoy1OO+jkAFX7DRiiQfMey6aft9PX326iU049cMNOf+8oxMz1Rdc80LiDJwuM2EiE7bZ+CDnfpn65+mHL0W54kj9v2l+fM9N6cW/Yz86JNgpG9xyaXDBynvEPXGBMRV7hYuWojFxoXbYTJr/5/v8NMT+wyu2YX7X6VcvCIbN9rc5sUltwn6cMD9vhI/0HVTG+80X4eE45hRlIsyzqOabK3ac9V5y7Yz/vg59x95Hc33m7/Yd59TWyvqt32awY/rXLMvZloPDFJGVOjaBx8bxYeP3ootxnPC+IwgNOKK9oH+8WEFFYRK0zPc5bx74zphizhBL28+rvmAX2PhMiDKZLG6ffOHOO28YMoh1koVScBPON4hbPMtOwWkAnbej8Sk2Wa8F7PZSW33sc92E5ap9Zh9UY299NzLZEy0rtPSTrmTU86PeyFMxnUXSJ1CeOmVxEjPTYNknCvdAVe1CyJEIH+APdCZyYl66d17km3GddOJEK0zOwLwyIQCURNAF01Kmh68XKUwJOoltSYxzdX0xuT8LO4rAudzhF9n7BfJHvID9J19PySeHFQkhChQC/voEpZSP2YPL4lIiKvPHoMZQEKpa8NTS9/6YogD8Tco8zlSyDVLNBDjronoyR/7O+JAfpMmciVnfh2kR2Z1cwW0QIJ8dAXuui/fhlSpGvpSN1y69F+Ss6QLBA7bK/MNuUJ9frConr5yUOQ6FNbUf/eOIzxBi4SLgP4/JtHeV+SQdJ7DcLEdjL8LY3POrOJsmNMscwZSCgS+cExX7rUQTtpWXvTug6to4w7iBTMCYei6Bm2c6pNJFAUlUHCSnICpLHGzmx5O7KNI9Yhuh7K0/sPvgc+ayKn2vOQWcU8sfxWnSRD9NFYXw3JvDktcZ4CeSm5MsjrkVUAjwyRTnq3/Bbmgn4g+YuQgD2oeYeym0OihcDlAvLF7iRRFeR2QZEwh6aISjnq0J1/jVoQBI9K2PLX2HtvVD674dXH7fOe59nsY7HFFltsscX2OjfGRH4z//aQxWuG2GKLLbbYYnPYXlozXA9C4Z0i8mOe550XhS96osSQbm20V9kSnYTknr/WA9ZzeKu9rjt2pb3PvmbiaduzSJbdceNJvGWjCccpmKNYo7rtRU8UHa79NTdVqcs7m0rY9W464qubnV3oUJ+1g+39WZcH0T7fCq6nlzKPkiMPR9t6LdvTO/uE+/lt3mvf7Nh/sevxwrcfN9P9CVdZ3ed9ftG+Jl22kSTDrh2dz/hPM3tH9xw6+m31BftBrb/FLquXd58CD6dst3j5M3afSn/IRsoMJ915uCQzhw7ukeOnba3OjTM238r4iX8kj5M2d0VywUa3vO3+V8z0F565x5lH0LP7dOOY/XtXX3D1g/oJZ9aScwCXyEJ9Td4OqpKVR3aLZbyN3qS027BIt9Bu+zVDkFAPNft46PUfjcXvYjrKwptGDyA9kAXQxGSaUSnIwvpQBApQO95DxFPPgL0ceTNmeTimosPY4/ZBeN23iHCIxu6z77GsjOem6hCRCOPs7Ok2POP4TKMOHTD7F5f70oM0HD2s7TnEnReiZSWSg+seetApTdndr/cunYNHu0K+AL0utRm9TwmyhVl4+clvEPJRoG3IME/j8/EzjNuW8N3fIvdEid5beL4RZ84hzPlwiDj03DJQGOkokz9VMag8Qd4Aev2HOb1PYSWqQpAEiqIzC5lEPPciGOrJAXB1m6YbUQ8159PS3YpM2DqvqNsskB1U9igswYPNsjG+Ha9m8keQoT9Tg4pHknwQlNrUC5oHEE8PzoVIO19loaKQt1OH0CMOOc3MZgZl0HR6rrPw9vM7+dEYS0+EAscTxx5VCJjup7ROHXindzgXeB+01QyQDx22HWU7MW4gu1pYSIRIGr63yBGS3+D8ge9r2o4evPv+PvBlVCn/mYrUiaoYHKPNw6g7EAjkSuD4Yhv2uKbGvDXC+jB/JaqMQVWQ8hU/bJ8U0BNcfqfaVPhg+1H9BH1jEyiWHLgRcB37O9uXyJ/+JNoVCi5DrneRbW6FPAdBpI4CVEtuMzq/0RLDQIbTmklmSye99iFFTHGX1psG8qMCxE0uyu3BvcWgQtQLEQ6vIhfSHlozXM9Wzcb13kaWrvTlwHuvlRnrOaTxVr68z3mv3Jq98D30F86b6bO5ppn+xT90O2hG+x34Zgd8O5W2N2a+b/8+4QiFEBEZ+PZC3XWg4JIXDJ53MPTJDuHPuHlvtXcb3edtCVTPIcnZcGjai4hI2s47nbcPX7wVe8O95SA/FBEpXrHT63/PhuVP/7qt47d52n4Ww4o7LCXngMz3pu1+e/d7zpnpZz7h3hW6NpLdffZmv3nELlP5FbvvtB9yE14Gq/bGun3A7guDkd2G6ZI7D98xzg7+rF2PM3/dxvEnDzlCJy44s5aJP7HrN75Ap33xK3fa93FnIUnHQWOwZT+PVMPOe+AY4oc/4W7b7RP2AWSib/dP13OdedL9tt2471V86X89dpt5C24Du+3XDEFCZFAMwg1aAF359BY2jxgqhPEGSf1dEcsMLlC5KSdxYuW8jo3eZErKZ3Rt0JsD5B4w3FFG5wAS2FECjTLQJGBr3ov5lgeEmLd6B/Q+SZBOly8DSo5pipudcHONunAzxDABP8mNFjbUOPggGWR7bmcsc9PLzS43lFunsXFdpGwgNv5YoI+q+jIpnsHBBF63IfHjMsoEuUIevvQoj4fwSW60Mqta9kFF78cDHG4y1x5EW4NosjvlhWRu3NyyPdIIaWgD5kwJS5LylS9CVhBOoxwOmfJr0WeebgG632OZsekbkJgP8PYpPPcSDmxAxLf2oDbKxmlsgiYxmSSIyRdp34m+MNA8v/ONGnf5R596k6YXCQfXr5Su5KHVxPkRyqqfrXmQBC6DGLQcffd5wyhBJ/tuEodNHYRMUBqwNx3dlA/2aUEyC+hDvidDOHtyyyTu1PqVMKYY2pOtcyOJwykcZmUaWob0ksYX9Q5VtY6UDOxoZfsTkAic1+fHEAdC7wfY6I4mIf26qM+FoS4BSTc70XfWoBKEh3TcdE9cjK7NCwv6TLdP6TMtn9fv5Ve0zN19ms73BcceD85EtMwTZ3CYiK3KoBwNc+LBRZCH9GYdMpOX9ZNS8yVwdTMEYpD3wkMlypIyVKQ/wf4HedMVbZ/8FZ3HNh6s4mb60TyIPhCSaGp6b3qE75hf5vU+SZKakvAWBzYMN8tg+czytQ5o+qFPYY+FNh+WMpKq6STZn8ZBQl2fPQ/AeCDGsIzWfpJoSiTvwgJCo+BIDhwOuxtue2zNcD2ykbtEzMYWW2yxxRZbbLGpxWuG2GKLLbbYYnt92Nc8UPA8ryE2KIPwxcoNL9U3aL1uWs68dC3hX37BrubglJvUb+iQzLtUq5rpL1w4aqY71OxERCSTsz2ImZR9OraxYROXpTIO+PsuJIf1ru0h3fJtVEMyYR+j9ebckPIVh9dRzk+byVUXYWLC9kRWdiFl7BftZ152SE22W3bbEjJo2bv/hy+Z6V9aO2amLz9o34dehHEb7EJaWFywG4vepnF7YcFG4xRsYI2I7Hglrsm7ZBOfthwKfyMHjH83++C7vmim/95/t4n41lo2wiSTdfdP1zWbf9lGKKQzdt8ZOFAhwUU34WXn220US/azNhxg/522rGLznBtlVSnZYRV1O0JDks/bUqtpRx9xoRBEdmCP16bbv9/3Jbuvrz3ofkWVz9tjc/NB5yU33/aQt+EbtdfSmkFSgQxnBpLa0DEfgNGQ6DA/G/W0c67Ob5DRDB6wOjyEgDant3WuSIwCGUzq/JeCB7uzX7+35uG5A1y8dQTe5QGJC5EFUBEBliT944QuUMYN1x+MwtuJriiskNBQ/07YOgn30nX1HKYwzsOQjP06HwxzXvgu4D0JQyaxIaHtjVNax1QtiXQgFmY1j+5MVDoxBYk+EhnShmj3whq82avRuTcxoEwkUB0gtfOz9GITfq2/708GO6EMeHQMHyAkmzDnMPQLU1gXyxWSXBKePiiiL2zSK49n34fsXgnvEayd/Cwajx5WeIaD2eik2D6Ivjc29Xm+iNfSxDvu0fC7jz2h0UNJeFrTNULm9Rr2odJitA+wn049XdMyZNCXkFeqoe1NTzrlC5tHtO/Syx96+xE+QII9Qsgzi3rHPr3VzWQYTkTYfpaEjQFRJnrPdAPSfyAJrb6iiN5hQcvqH67q38va1/LLOi468xxfms6wgdyGfnZnAfWHrOrQgzcbXul0HeE8FXjUNxniAqTJRnBVOAvqnyeaRd+59IxPPqWhKK0TCjsqPaPfgwO63iTqgogeInKIVmL7MnxJ+Ik+PDwAKAoQK9l11ImIK8xPoVQt5CwzLV/yayBaBaJjANnaHbQP+ykynSJ7qUTqzjUyx3LA5RNQFMNp3YhwnzJKY65ln21GyTEZCkHEydQLQJJARpV9N9kbheFHnLOCVDQkjeivbC+KtBmNbXO6IGJle3udV1M28tXL6mbb1zxQCILAjWmPLbbYYostttjU9tDi4Bu1eM0QW2yxxRZbbF+H7aE1wzdAd3cbW0LEK17rkRzdb3tUS1+yvdIiIo27bff+O++2ORQeSx0x04evOPTTRKRatDkUXGRx7ZIjRj1ve047fdsDKyJSb9leYxdZ43Bgd5XiBXcXymzb92raTRXG4V1jjgG3cMlGOoiIHDyyYefhiLVP2c5cCY7bnmQRkd//3bea6fNvt8n7Zk/bXubSG+1Y9O1fdriSRWNCLfPTdmMdnKmZ6Y22m2fDQTHglOtsbNke7ty2faPihBu+8+SmXffOAQePSM/2lhd2QbG0HRwc04/bfXrrHrvvlBZthEK/6sxako/bey6SvI3btuM5jXbx9SYcYzbjQCLQezFu9PCM2/3fYhNFioi89BGb88GFUEj+7RUzvXtp1pnH5It2/U79lI0civH3sY1bMu1LdbYpzU0ls2Osf2YJEnZAA1Q+xfhqvY4Ecd0peARzJDDUdUOizuDljHh4gTHeN4X3eHcK8byY/omCGOzDPbb1nhMTuk6odXXOCNokQ9APegQZu08PYvkSPOXgediJz1YjMoE2KoLfALH99Ip6vkivCsQA5BvXH4BXEXXL3rWt3y9rGRkfPTii7RA6WClvh/j0NIkN+/So6vfJZzXWvHFK70evdO5STX+XQxse1geSbkQl7vh+JFKhsOBJ4y1aFn8dxHjzIMwD2Z6UQUTY13dJ6N1fjSI+QvnCOkksNW96cjObqHMXsfzgTCA3xbAEksDpKKFkvxwlIdyR/kMbdT35qff9gYiI/MtPQ40V690s4tL5zEjAWb60w78gIpIFoV4oRTqP9kNfIAFf65iujTPbQJyAv6O5X/9Oub3evP69AkLm5nEWWj+IXMiugRQvK5Jdh3zmQhRFQmJIXpupIXZ/SZ9L46T2hdIFXTfQYz0CYegQ/XdH9hQoGpIt9vH7PBAp4E4I+vByAwkkQNcElIyd0TrmXkIbe17I61BaAoJmJcqPQalKEkRmN8BRcTi6Zg1lOEkOWIqik+it782Q+AT7kg2sd7YhB4pxRVnQ4pJ+UoI03YmSRWbXeyGKws9ofbOrOhgHVS1zfkXnq/oJXXvkQX1GUlN684dAdgwmOc8B0UEejQzmSAygHEhlya1QWAE6AH2Xkrskh+ySvBbIhM68dpjClbaM8pizMIYGRb1n/Zh+so+tPJxEGaPklclulIuCqKWhe2sY2y62tw4UYosttthii+0W2V4iWIottthiiy222G6e7aU1w946UPBFgs61Vco+ZXvju2/eJYB823alfer332Sm94/ZKIipvru3FNNulnTL3rh/wUw/u2176tMNd971msNVmLKvSTok/londyFqmLYRGA4nugxest2tzgHn4HUQEcmm7PLmHcQS645H0W26lSQyLl6J/2LHta98wM6k8bxD0eAhN4dC4HhOkrG5P7Y/csBMT+3SP11WcvTb1KqNEvDsIsmBUt2Zx0ufvMP+w7R9s65jvB6fsZEqIiIvrNn9Lfh2e14ofc5GFTQftuEtqYtu7ojBERs5Mcrb1xyf3DLTXy67IQoZB8Ske6c9V2W/ZOeddoB0Lv6XU868Rwft9MKS3d+urE2a6aWX3DwNa99tzy/L73iLfcFP/qbzXrG9Pm3UT0htsSLeHOY0xM7SY1j6knrnhgD1jKPuZv5Y1XP8Oe2/iS2dO4KKuhhT2z0ReAJr91X1Xrkomzlj9Oklo/fMm9dxun1J469T0zpnDLHGoWe9Bw6A/DJi8uH17E2QTwDeSXp+N3S+8nrUvtOPAPw72X7UExgkd+QG1x7Gb3GzgEiENa1vckbLSO/uqI4L+fuS3rt4GXltEamgn/SKdg9og1eer2kR25o+mkRMPzyT9KD3J7RN2nPwfmJ63SavjxeIX4dLtYy1QQ/ym7N6b38hH9ZXZEflYYApNrcWXF0V8chH0IWXuom1xZgqVbKt+ZF/gPwQZJqnhJ0Prz+lSTtHgFTB2mvf3TX5uY/+Wc2bMoDLkJwEuoGcEqGXnzKmwygCJL2pc2caqDS/qM/aB68G27V2h6aTk2FcFpL8ZPUHoJTQQN9EXw1aQA0AMZLeSkgGr33yBBD1Qm96+YI2DBEH5MuovFDT9Ap4HLKQcVzRvGonUDjUsXlI/1M6N8bgj+dPpI8H5SFyaBCRkL2ibRtKxGLsJ/si+XUoemCsEN2TW9Lx73Xx7PaV0W6aV28KKAnwprTBozLA/BJKmebICcBxhjHctFHK5HfgPEUeFo79IbhFKGOZGPriQS0jQNmITBjlgEY5GK3/xmmMOTy/FtStOE7Y7n3wqpGHgJwkucuUyNTfEZlFNBEVSNim5EXg8yX3SPmlml63vySpDrlrgEYBr0mmpt+3sUQJeRoAg6CqD/kdOJeyD7gUr2Lb3fbYgYJn6pyPT4K0g9Pbzlstv2iviP2kYwPmGOi7xcekXDsth12o27KDxyubZvrLMue8V7LpIB1xlHc0sgdY9UlHvUWk9oANra4+Y1/TuduxgXY0U6Lh7r5dh8xlJnl9cjATk25Yfq1rt+GyA6Wd2LI3R6UrdgUn3m2HSIiIrG46NpKXbGj89r12vacfdzAv7mJJh7Towc/YhzhrD9rPe7Hp3gz7p+1N/fFfsO917vuvn0QnUbP7SG9g9/W042yp9BW7zev37HLYNrTbvbBoD8AXztsHQl7GPcHMT9gnAalJ+/ltDu0wk+68ncfgAYfsrYgMNu1Jt3TZfk5JBxHtzFPuQ9eVjD2/jOZfJckny/aQt+F1Y55IGrJ2hGhTYpBrBx7OF1cIMddN+eighjRyg5u+jNAdHCj0Z/OSW9BxOITkIuXrBoDVMjwgPFDAQTVnofSc5jXokDFMP7jWIVkgw/a4SefmInsJZV7Vd1l/RsuWvayHlN4AkP0Jncf6VUDIsfFt7d8hZaQcIGHqPqSsPWzOE9jYDloUekeRKWu3qXNu6OxAXbgh4CaCNpjVSmQW8W5JQKJuEiSMILNjWbk54WZlhAMMr++FByf5CRxOvKibvfk7dIdU/4K2S2c22gd4oFoEuSWfIyH5qW30BWx0SWo3Agx7VCAcm3qVKBsOlniAwTCQTjUKy37/XS+IiMgfvXSPBIVo+3AJyVASEujmt6JzfKpLCb/oO8kvYNPY1/btTQCuDig4N77plt6PhyuEp/t8Jw5Irom+DeK9FNaZCewJkz0vJLXkIQXJ/1iXRBPtir5ASD4JUCVB4kKGikQP0gjFl7Hv4TjDbVIbOFBAc/f3YSMcknLiAIFtgedVudQXP8lxANj+Bd1LkBSQ1p3KoK7oE+ivnRmQMbJqeKzMa1gYI47E3xkuQiJR/p59KoXlagoHdMUF9PU8CA1HIOds9cKGGKF9h0VsthGiwANJhndROpeSpCFpaIbzF0hN8cy5ie9XcWDUjl6X6JOUE3XtUIYV4WNL0TAchuUMq1oQP5uQAQ9rT6Yj92wcYzt4kTz5rEeQPk/QKQi5zWQfY9sRpntTbA+tGb7u3YSn9pc8z/tH+H7E87w337yixRZbbLHFFltsr0WL1wyxxRZbbLHF9vqw60Eo/LzoOdh7ROSfiEhDRH5LRB65CeX6hizZE6m8cu3J0o//1MfM3//889/qvFfhoXUzvft5m2RxULFPtFzSeyIivlzfKVjK4RluD92wYJeRAGrceEI3bp5vp/fcvIihV2LcDn7wipm+felayU8RkUTKrrfn8MaLuFEbC60JMz05sI8JA0ebi4hI2v6bKzyk8LjtUaXEz7glftGNMBm+y9EmjnulZxysk56buNN1cjrwbS/z2l+1PdbBk3abzxXdIUd3TtrojC//1aNmeuqyPQZ8F7OkiGTq9uDsFu1+O3qzHaIx40ACtFZtRJGISPY5B5LkTvu5vu2us2b6F14+4cxj5Nv1u7hkD9qKQ+rRL9j9eeJP3H1n6xEbndGdsl853vN2OMnKLttPyo7dNhbsrXjIG2C3/ZpBxBNv6O3IrBUw9oF+S5MkFUODcqgBvKTJ1hgJ4xzG1oCogLYMJ9RzvSM1Rwk+QLAZpoY8SlM6j/ZBItevR6FRhOfSs00IMb2SCXjIC2uEwcPz2gO53NlVLeIhlHUMok+UACXXEiORASHCQHD4uWiZpaLtMFzFvIY65RcJ9SZJGi/Q++RAFElvfwJEhrkVSjkCUj6p707K36Vael3rgHomexVC9fXuzWNRgj+/MAqh7f0LCg0Zgehu+QkNURyd0LwovVdY1otJ7EhPeH4DkHl4R4coW2pFM/fL+n0wgbLB68/n36tEvab01Psl9D3A3L/zvmdERORjX3lA05OBcDkSrivxPb8O+HkzSuxIKUuGPHgIH2CZE4DmM4xgx1MelZms3QnYOpbFzaOU4UNfm9E+2+1gHkf+wwqQKR16u72Q4LNyEV52rL0yNcDP/SjkfQjvOhEc2yd0POSAwmC4wAjIkc48r0MZGS6AdVkA6c1hGY2HEIgMUEoJrIEZNpPHOCIJpzcKJIMxxXlgMKWFSK/qWmAwr1AOho6s348yI8SEpJYk0Q5RFGOhrPSoJ4AA6k+BZLE+5kkngmGb3n79bB3U51pYRkgKEAqdIxOSXcEzm6VcpN6D81NnH8boehQBtX2/Pqf0OkMlUKYthA1gjBLRkATig4isiXOURQVZ7DbG3ZqWJ9GHzC6QKomWPoj2sarWua75j7IJ6eyLIj38YvTZhSEjGGtcMxSeQ3gHptYdSVH9LKy+Si/yPbZmuJ4DhbcEQfAmz/OeEBEJgmDL87zr38nGFltsscUW2160PbQ4uAEWrxliiy222GKLzWV7aM1wPQcKA8/zkoLqe543K87o9ltjQWJHduVq+9lH32df4OAFEBG5414boVB7l+2t6z89b6b7GXcejb4dlB04vKpLW3bMea9ie4yttqDxRO6avB2h6L6jp6TcYdQy9Vm7fmu9Y2Z6/nttD3AyaXezQdv2+IuInKnZSBKnLGbObquTVRvpICLSbNtx4k+84z+a6adbf9u+0dDO+0Nv/bIz78f/Xw+Z6emftok7L29V7awd9Ra5Np6V1uzbe4J+z+Y38Bx8CK2Be2/x3Mt2PP++w/bzqD9te8u7QzfHR8LmRZSJZ+1rGFs8boN32IOgWLTJD0VEEm+xESPJz9qohi+8aJNUTs66ZU2rOTuPO+6057YnHr/PLlPJRhukvqvmzFsWqmaySzby2G/az/XCB90oj9EhR/s6uEpeFdtDi4MbYLf9mkEkkCAVSBKxytkLOsYZzz2Cl624pAmFBYx1ePV78+p284IoB4AHiTM/m5StUyC8C2UD9RaM0ffh5ZQJTWiDCDixoO+Xgw8qL8PKk7rGCL2+QCpQxpCye9OfU824wYHJsAwiIv39un6g1z8x9CN/71Xp7UfcO+ONMzseUXpSkyBcoyc8SFDCD4gN8NOQE8YDZwzXEf15eD3hvUw3UMaMNnju5WVti9OKWiQagJ/JHryaNf3cPgkPOB7PqABvchXSgM10iD5JzGpa8Yv6IOhtJ2qziDJzrso0IIvnMw80DOPoEePtTen9GPNPjy+fOz3p/QlyaMDzXUOd6nrdz3/vfxIRkb/+2R+Vqy1/KS29KT47Tctuwdt/AR5ozD99PMNhgUH6+pF6SZF/g4cV2ZYHqmJUqOrvgcBpnIZ0Jsqch7Tf1kPw5i+Df+AuDdr3nwYKcSLqraZ3uzu9w5NAYl72V6IoKP03yirKgZwfwwIQIECljM+xbdALlc8HyEsibTGxHxwZZ7WOwYTWofCy1rE3HSVlDEkjUSXypuSW0bkSCRlC+jVEKoGjon1S31fsn80D5PrQSwurGOP7M5E8iFQISQG5pEAdiA7wwVWR3YyOR/IQkISRRrRSqoHFDsZ8v5qRUSX6niQ3SGs/4S9RNEVoRP0AMVLZr2uQTq0qIjsopHEemmH4GV1zkpuCKC9/RueA5jFd0wVA0U6AoHXjIS1QuuWHfDREpTBvyplmNghd0I+Qk6JI9Bb6J5AJHqlaHIjlm2J7aM1wPYxs/1pEPiwic57n/VMReVRE/tlNKVVsscUWW2yxxfZatnjNEFtsscUWW2yvA/u6EQpBEPyK53lfEZH3ip53fm8QBC/ctJJ9A+b5O/FuV1tuyfYs9o45XJQisvjfjpnpI5dHd5/D8+12ost2x/ZwuxAKg579uFY3bORCwa14GMZdjlui7aqHXabRLs7AxnE7vT/t4FYo2h7VkaM9tnfxdTW7duXzGdvb6vKcnvtVtzRe/wG7Hvf/+t8x04vr9vmdK8z/j599uzNv7+/aEJOgYcei5//QgW6pOrNwFqznQGaMtuxGTE3bz3Vx0+ZW0Ivsftju2R0u5aCIcMkRiogUHegaxrpek7cttCArDsWNQ7NbzryvPGHfrOwYfzKw+85s0a1Ccn7T9u6vZkt2FnayEyGU+FU3gUrhz9vICf+K/cxf/gc2p0TxCWcW4l+w++Gx/88XzPSL7lvdEPNkb8VDfrP2WlgzJPqeFM+nJLeJmGPQ+KTH5gaysw8monNcAhJnlNuji6Z1GIoJZS+cT+rH4ImDFyyY1/VHGvKyAZAJ2bvVa9wLNH35OeXSoUBR+Qz4HZpRtvxQ2m9G56PmIb2+uKz5pLb1s3VUBzrjuztzULgokD0fXr85ePHaIr2HdJ4ZQAYwkdPCBJt6Lb3/laeinu3NB6Eu0KZsnaYz5r+wpmUgW35uSRu+/mZFqNG7T4/voIB47Hn1PLb3Rd9RzJee3mBby5NqJcIYe7+mP2KMN5EEFdDUUI2hAnWMQRGcCkvR9WISspv9eb1RApwXbM/GEaA4vGg+lHgsLKNPAVz3Le98TkRE/tbv/AQKRCQK6lwMJAXm/MJStN6tfZAtBCcFPeeUXKQHfXD3YRHZWccO5yciZaZKRihAhmzqAMhRGWEAJELqrPal4XT0OdOIYKHnON0KJAPFiDzkAHuTUSUEKqh0DkfXMkRbEEXbAbKAyiPbp6g2oH/30SdrCzoeUvDu+6MoQoTe62xNIt8rZ4HKuFPbdlKgOFIbSLIDVYypqNwm+0p7FvwnE1GOg6W3s676fVAmOibabpSNTI/xPGUIkGK7LnFccJxwTojyp1CFhmoPQcITHzKxzf2QysUcR4lYjo80lhiUp6WKg4BXbfglXWPlqeKAKZJ15DyVV+qWq8Y80Ra6JifvRAdtl9uIytrW76lq+pamb92ZCvsnlW5ah9Ava1TDgKTrCngzoJ5B9AT7UqrJuqLd268OkG6vrRmuSzYyCIIXReTFm1SW2GKLLbbYYnvt2h5aHNwIi9cMscUWW2yxxeawPbRm+LoPFDzPe1hEflpEjuI6T0SCIAjuv0llu24b5QPZfOO1XuPcol3Ngx9xV3/xW+yn7E/YHu7vuP9ZM/1Tv/8mZx7dplulwM7coSThiBnuVd09deKMne7ylrsQDeV3rTjzqDVteEbpMduLXjzl1py3rL6L3Hyva6NSuo70pKOtRg7mexFxqjxMP20TUXzgf/oTM/182/b0fuFPTzuzHi7Ynt75R21P9vqD9n0yNWcW4Un1NXl37T8Uz9v1Hq7Zru/dEEKeQ9mj/XLVTK90HH19l+PflOOa4g8umekjB+qldtEuU3afzbciIjLK2nlvv91uk9SS7Y0f7iIj07pkIyf6dcc8UrbLtK9qow2+9x8+6sz7F55/h5k+7vkN887abfX+v2SjDUREfvv5B830V37uLfYFP/mbznvFduPttbBm8LOBtO4YiIi+F6qvkL1e/04egeKCjsvmYaAItuEJxlDqT4CJHh71fpkx/yKbb4BXeVF/2z6I2PHLOqbpsSYbffLJqv4Qc0RhQQsTjC1XUngnB9GQZ2ke0fdu5Zy6FtsHdJ3RmWE8N1QmDmQj19GbuqMQAA9kIZDRst6jsKZ/7M6AowBZp1e0/Rp3arsUL+q7YOIl/Zx8uY92QWz9BtQFxmL8a/fq2iCJZRY5Kdoz4CXAa6E9H/UyF1bQ7ngt0pOf20DMdE6kAyRAEtr03Tm9WeUMYujBg1FagjcfaAh6McNXCX7X2Udkgt5n6y59nkksY3JAYTDOuwewXAr51x7SPvWWO8+LiMhjH1YOG4rqJC5FeSe80Y73t7yAuP41oE4OaVlS4CPIL3Ui7dfZr32iPauVycP7u/hOTWecO9nxO/vgje7Ca42+GUARwYNSwuiwdsLy40DkVPX6NHgIypc1nzRQCf1KUnLr+nD9DFArS9pPu/NalsYd2gfIl5Fu6j3W79M+VgCfw8b94A2g0gH67aCkeWVWqA6B9kPfKZzX+1CxZOp51Bm0W5NntY4cJ/kN8EI04FnPJWWYz6BeQPnMAuEBBQsiZ7IAKYZ8JNmoCkdiEEUtDab1P6kttG8hirpIo1+XFqF+gjJOnNNOR96JURkPFM9/+xRUKOB5TwwCqR/TMudq+M1x8propVUcA2/dh3mpE0WvsGx8Thx79P4TmUCujMJKP9JWpUuENOjfa3fpOrH6CtBQ4KnozOonkUPNI7h/XcJ5g9wHnCOpPpJsaX/vHowqU/B3aSxtWKepF6EoMRdzB38jdj0IhV8Rkf9ZRJ6R245YSc1LBZKuXrvzDVbsDc32CQcDoYjInI2hnp+yF9dfWDxmphPSZJnfdBPGWcbBMG6ER43bsOTO2yUPyQXRuHmOvdH3H3Zjkv/dx95vpg9m7fKmk/YJgUv6L+Pmo5O2q21dhzIOCbrsG2rOPLxt+0CIsMFx+/B5ex3datibxfxJm6RSRKT4aftAoeeIIjj0wKKZvvCkLdUpcq2EES2o2ZPtX/txW5711//xd5jpi/t2GX8Zu+9OvGT/3HVuECzbbbvbNZcW7QOe7AX7QGFy0b5R7n73gcI+xz555TvtdNcBxGTWzYp6LucYT47QKdfzbvXtsfS7SzaJo4jI0Wk73OPMAZs8s/yofcj4e8+/zZlH5Y02keP2rSJl3GMSUDfAbvs1Q7LjycQz6ZDYkKRplDcNpQGL+p0L/3ATXt2BEIuI1E5FJQebh3bGLom/hiAMTAEezoOENGC6HIfceNIyNcJxo6EOmXoU5s5NY2YiCiVvzUfJAsO65VkuidYRT6w/M5Jki9JvhOvr9/FQwfQlkvGBJG0Z0HC0UxrEeqMcSQMhJ3lF11u9StQJkcRmZLgfm3IqXaJpuMEisSIPC7gmGra52QkkvcWwCxzwPIsNaVOfefOAljG7hU0zCO0GJW5CcO804NSlBNqLxIPYkGHpmKJMJA4SuGnhYQwPEr70ssaGVgEtb4NgjoSG3OSn2kG48WeISG86izr1ka5lSzaxMTqOkIbpaPhFd5LtLxELybdR1uGUtgUJI2Vd+xTnuQCH7ISKh1KL61FpQNa9fK4l/alcpAylwY4co4hId4oSk2j/OcDVsUarQymZZWA6N7wBnEODSnQznsXzZxumGwxHwMHCCyAURTl4CJJAaAsPZ7qzO++XViUaLsQyMUyAYYQ81Ei3eLjEjX10jCcbUTJLSlayLbqIYuShzLCI542QFsp/BqnoIRnblvKq6VYQjl2GafAZcSx5DBGBjHa6zjkRZeVYG1ubMPyABwn5NYQ0lKJzgM9xBDLYLMhPh0UcJMzpZ/MACHO3o8/VT4sM0D8pCZuEPOkIkqGcH9INvVcoJ4k6MESeYRQpzAWDY7vEi99I22Nrhus5UFgLguCjN60kscUWW2yxxfZatj20OLgBFq8ZYosttthii81le2jNcD0HCj/jed5/FJFPikiIyw2C4LdveKm+UesmJPHStWiEtMOTXXjvqvNWyY/Nmemrj9gQ4+Kz9omWf48bxp+sXReFxXWfZCWm3XkPc27PrWUu0rv/eu4R9zVt21N/4FuumOmDke2xTiZs55a/i4PbJQmaXbMvoszMuH33MTuURUTkD//NO+2sHU1bW7a9sOV9dgdtOEIFRETSB+3OcOdbL5jp5z5uM2QOj9khPCLibEOeoo/bv/zMB+z72Oj3kDjLssmDNjqjM2/LgVLW6po8dhkzniNkpvCiPZYnztn9cNnBnTmzi2Tl5j32POL37LalR3DcErtUMLts53/4nZfN9DPn9pnpLnnU3qP2sxARGT5k9+nAMSd12nabzz+y7Mxj+Qm7vFK8hc7wPbQ4uAF2268ZEgOR4oofyoQRmUCPYOBA7ZCojR50eq8Jdyfk2c8EoTesD68k571kl8SB8Equ0uOnv88oN2Po6ctt4Xp4HRN9eOogTR14gE9jXmseAgybnvNW9PckVGbIBT1/CaAXKWWXW07JMI92wDRECTgiMWj5TUDjMbUzrx2vJPIu0JsP+PppRS4RfcHrmwe1bZpHoh5wepcJHSck30e5EvBUUlYv3fCkfBHe2kB/y7ALIjWKywh1QFjGECgAyukx/JFeXj+cXqNl4fs/JPH12e76ue9eXXc+9qU7RUSkALLmNoi9WbeQYO+qVzTDMVJNEtbxWdLLjPZ8WKEcRByE5HNo7/pxeKpBRsffDSZQ1hzJ7TAe4OkdoR/Qm50P30tAezSif880/Uj+QSoResTpue5NQ75xIvru60P2fMDwIcDYKfUXhoL4rCPaC1KkYZhAI/q9BNnKwjo84jmGFGH8dKOIn/5EFJWR7PrhPD8k0gZ9hOFMpQtRVNL4WjUkvcR9GLbBMcz1NvsU8y4uA9kwiqIvKFXantdOydAG/p0e+NY+kGoWvTAUh7/pT+LZ5zUhg7AWH97/8TCNUSaKpMoCQZXDHJDqRpEnJFYlUWRvStu1NQekypKmd6fTqAuQCZDEJKlqGm3Vnx5JAvK17BPDMETEi3xyLmU/zAL5ka0jdATzVO0unYcmX3QjP2+47aE1w/XsaH9cRO4WDTa8ejjcNouD2GKLLbbYYovttrB4zRBbbLHFFltsrwO7ngOFR4IguOumleQGmOfvnGBfba3Dtsfqvglbek9E5Cv7Zs30ctU+uarf7YjzL+2CULhgx/q6eNYyjpB6F3Ggf8TtfQ6SDje647Ssb/O7ybDjjjX6xz/8a2b6Ly7YLt324PpinweOMonsxKN+vZYs22312ZWTzmtc7d46ZDeiC4nQe65qZzDlZp30D9ssmS88cdRM96bsMZAuu4kRk0m7HolLNtKi8oTdHsvfauftQjqIiFT+rYMM4m+vm8n+x2zeg4SDK0Tkag9T1GbeY/NNXNpve8RdIIGtrpt0tfLwmpneetSed1yol0v1SWce/aP2s00n7H6VdsxVo5E9IX37B7/izPsT5+90/s0yehbGrfZHbo4Pb+r2O9rfS/GQN8Bu/zXDKJBsbSgDxCLn16knph+M9W8jjrtXjXpHMxhidcz5uQ14Kg+Q3DGQTI38A8wz6jWjhy/VJu8A451BuHa+h3sx5ls/6I2k93FQiv6dxJD0cHfm4NmromxZenThzRsD6SV6hBnsoClIMldY0XvQM0tkQbcKDgl4f4miCAnt8pjzwZ3QL9MFyzpFvw8Y4+9RnlP/QNJASgMWLiDu+oB+z69E4+VzG0Eoh1lYxbUZ8kCgzAu6thshhrt7NLq2IUkjESQhpwK+9yfoiSU3BWLI4cU//v4LIiLy4uP6js5uR5EOubUoMiELXg+S0aU6gWS39GF64MVI9ODVndV3TWsece5ov+KK/n3rFNpnZueZiuxIgwq8/6MiyRhRtgy9zujXmI4LkIGkh9dPsm3hfQbaYAh5ytwm+mglIznIBDYPwvNPok2geqZe0HssvkPvQW/8KCRXxPdctL0Hc3rf/DkQJnKpziqif2e3SbIIAtHzui7rzReRDzgc4EknDwT7S7ealPb+6NgK0RLIo3UY6WNLnFEZ3v8NcB90iMJgXyFSQX/PZ8/xlamTMJLPB39f0PVgGuiaXoXICWTMZRDnhooX9tdMDWWATGmyHuWsyKzjXugb6XXyEnBOiKIlQuLHPudA9IHLOuHVTysRRBGkjN1JSI9ifPVADktSR85rXO8PKj6uT4Z7pfbBUaSebF8+n9EYooqoLyITCsu69unOgACycn38dt+M7aU1g5si/Fr7vOd59960ksQWW2yxxRbba9mCG/Bv71i8Zogttthiiy02l+2hNcP1IBTeKiJPeZ53TjQe0pPbUAKqffxaT7PXtj2hT/zRPc57lR6xPaGNZ2xPqEzbMfiVokNvUUR6bTtG3rMdutK3HcOSrdnp6dwuHAoONYfA4TR2naINlm1pSBGRf/2PfsBMX3q3XcHJA9tmejJhZ+7yaorsxPyNm8M5K3nHc7p8wR0nfvr7z5vpzz9lowRaF2yvu0MhUQqX3cPzrg/Yea/P2H3qyrLtyS7mdkGxONK9lp2+9pDj9w4uhlDuybDu37UZ/LfO2s+jnLPvlbOHsYhcdXo/Zleesr3iqcN2xZMvurkuXNb8oo1EmDxjd9DF99hPY+S7z4SnHrURP2eW7P6Zu6dmpjdr9hj/019xPHARmXy/LSebrNj12HrRwd/wgHv+dGrcNq6Pm+aG2W32cr8N7LZfMyT6I8ldqUs2o32mczCqQtKt6guRjO+Bp+OtM4uYWywhGL9dvzfKOh54gfSnd9AKIiIpILM6UDvKr0a5D+jpm32yhXvAQ4dY7nRd3+vlS/rDPrxpHA5UdaC7jt5Temi5vkggtnwIz6SAL8KDdzpI0yuakgzAnPQatucQBw82/9ym3rxypouyqts+2YZHFUgPykaGcm9h/Lt+ck6mx5ZeUrbJiLKFPRIWRBELxctUytA/Tz2nF/YqCSktQjoOZRKy+aO1BlUoFqB9p57T33fmKbup9yYykWVu74fCRDeKAOGiKfs2bbzzf6Q8RgnKhKIKRH2wzOPSupWLWo5keyijAuLai+QVgMoAFCdyNa0v++36G9KRe4/G1kx8xmTylzF+D7Z74xja9wqVLYgOAIIBHBkJKDYUVqGM0Ce3xY7KRAPSq5S4pAc7DUTG6pugBgB+hx7Qlf4EUC4oY6Id9ZxnlrSuffzew7uRyF7KPyaBmqEHvXVMF9ZELCT7+tk8rG5t8kBcrYCWBMcBUUdcixI1QVlC8hFQXSy3nIr8nnNCYTHapyYuQD4SXBlUcSDfRHajj3JoeudQMVLGsC9RaWQC89a8po+yQfhs24eHaA8gcKYJu9CPAAoJRFql0D9DPgf0hTTQE6HcZx2KOXNZtE0V99Hf1U9qmUP+msno3Mq2oIoE5wSiTpvHhqFLPNnEfwL2X/1KJThy3WQwj2cxXxGdRLUMKrwkhq8SD9MeWzNcz8rr/YIFwU0qyzdt6cxQDh+5dgdx5RWbYJHQGcvyv2RvwLYdEudHP2KnJ/++e0G8ucta2TJXyAOhkuNWzTuYFEVkcZdwAcuo2TtuxSNuacP73mZvepeeeoOZ3u46QkAcG4dQ9scwK/RFxC1/Wczahy81Zw4iGx17o1U+ah+MJD5h96nsn7XJQQcfsTedIiJPffUOM91FNJhp2hvPybfZG/fdrN6r2vd61n4e2R+w67d90UGqJyKbdVte8PjdS2b6yuVDZrqLTFRkR85r3Fxt6LLyI3b4Qr3lJj7N1ez0zdP2iV7xov37zrwbmufK/R3vtolGX67Z/a3p2ScvXExatvKKffBz6vSCmb50r/2gZj7hbsP+hN3f6qeu8wHGdrPstl8ziIhIEEiirqtkb1903iE0tnYKG1UMtwE2uuGrCRuGRE5fMIUZfQG1GjkRLMjTIF+k3Fp+FYtcbFgoPcewiz42uIWXdX5JbXKXgt8fmEAZsdnAJjKECFOyjlMECQwBxU9O6gKEi8BhB3D5EnUl9WOUC6SPilIOb/IVLWPhgr7rOod1QcFwAW6Axq38iv5+6/6qlgUbIMLdQ417bswgH5xCWf22rhGCNE9fsJnZikpiZhtRSLPni2S39JkkmoA3H9QGyp/VDb83q3UIkthkFBDuMsuDBJQN0yE3bT42PGxXlvmDDz0uIiK/9eib9Yc49EgB5l68gueApUd3Jho2sCPPB+nG7lCSXYQUzOQj9edc3MahR/Mw+5j+rAMpysEEGxgbrw7h/NwEYpMOufMCDmh4+E95VbZzcRH9/KDO07lVnccHFTQWw0Ry7HxXSVPCtu5KRNqBxI+UT/XRH9Or2rfCzXiaB3Q45BgQvs7wjCBSdh7gFBa1jIm2Zjgo6XNnKEUK/aME7uLOPq1LB3KWvSlvR35zFociPIzDPOCXsDFtorKYD7pptCvCMjjGCms8XIm2DUMbSGhYvKinLKMCwnIgYTnM83c4xGro7zfvwrzF7HCAMZwYSQrPOoHDucwhHdzdNe1bJI/N1qIbfJK7MgSF+49MTeu40zf1I7eu7dmZz6JO0dAeHtAxHIdjn0SLYUhLhVKQCPfIeZLexLNnaCvaj4dRtOoZLVvjiJahdB4hIpRHxVzbm9R2LV5yeM1i29W+5oGC53mPBkHwThF5TqILAy4UrnNrGltsscUWW2x7z/ZSPOQ3avGaIbbYYosttti+tu2lNcPXg1B4t4hIEAQOwP3tY4NuWq68dC0aIdm1vbOZLbeHe+F9NhQ8d8X2IDYO2U15OO0mvdsa2T0p4fCiu9JdYQrltBsCQXmgcXN58EcOvsTuSzaMX0Tkk2ceNNMTaTvvntOnaptfdY/E4hX3s7WslLGfU/G82wO8vm0jX0Z5Bwmhg6yx/YTtGQ6+zS1dk33O9uAPT9snq72aTZ7pqreISMtBkplydKv1N9r1K33cRiLshh7Iftyu37m32WXKlO28XagekR0P3jV5n7AvOjq1Zaa/cPaAmS67dMGiw7vfnbM9e0c/Zv/+yn1uIlOvahfgS793n5l++N2XzPTEmp1HZ95dwSDnIAFN2vULHMSP6w/vAj28HV/Et7hMnud9v4j8byJyj4i8OQiCx29BMV4zawYZjcSrNWR4VOdyetZJwEaPISG0JPmiZ1Kq0XVCJgtIPlaJiWRA1cDQ45ry6TEFDBow2+ISPHDb8KTXO2EZRUT8SUCE21E03RBEhyxrdwpeUry6CMH3q3i5w/NI5J8/gKxem15+eAbbO+RrlIRjHilArQezkHtsaDuktvSd5ecAxZ/Sdzrh5dv3ViN1Z1k5brozJIwEbB3e00FHK5MCAmTY1fVWcn1sbsJ9+JwIcU5sBaF8neeTlE9/5JcVaUiY87AEAsM5hJJgfRWSXsI6h9CelCtE2Wam1D36m195WPNDOxMyTpTHEK+4JCDfDGFJNRHi0AIB4wBzZtIToaxgMyq5SPI+ev/ZXylFOZiKht0IoPjDsRHqgcwu9Pqjq3HTQ3JAhg3wORaWtM8SmZDZaOP+gLtnSEyaCL37jSNRVEmP6zn8nQSR3iA6Fr0prFk2EFYDlEUotYjrJ59HSNFGFPEREhpW86gLSQS1IKM8QieqkLMsR2Unh4Ug9PizXSizKQPqqu4gMkREApa1H+3v+bUokoZoJZKZhlKLWx3kp+l9zAWZbYwHjLfmAbZpNAQjlHtlyEvaD6VbA/SF3qLeM9WLhg1wLCUR7pTEdxJtZjf1efQx1rMbCHuqaJmIsGGZdgg70URALPhYojLsqTcLZE4T8xvmBMqISmIHNcQwDPYBIj7Yzq0DmUiZPY71Sg55IrQNYRutIxicj8nNt9txHfMN2tdDyvilm16K2GKLLbbYYovtm7VnReTPi8hnb2EZ4jVDbLHFFltssb2O7OtBKFyfq/dWWiKQoHitByx32XbhN4873PGyQ0w0bsO7ba/xdtmOMz7qYlgUN/miq8UpzTNulMG5HhtMOOKMHQSIPCUct/AE1CrXPrutujUbieB1HOdbjvYYltyx0t7I7tq+w6GbStht2L3fjRIIVh31mLT5GNL7bdRLr2OjIApfsb30IiJDBxemd87+Q6nmaEQ3L6mUHegFBx2DBBW7fuXLdv26k+6phRJn41Z51n6A9TvtsZypuac4EnyNWypp94Xl/2aTGWbebaNCBmtu2UgXx4eLiDPZtS8IVt2yreUrdj02Tttt6zmwd4xhHLf3fqdbNvJjjz9gpneGdl8Ihg4SVUe6iIjvQAJ5g1v3yrrV8MUgCF4QEfG8W/rafu2sGZJJCarlkPiQhGKhF/VwVH6MsehBge5KnQwnZ5T9q9nW8TgY6DhOpYcy7JLsj4R2eim9vaEEID2lHWSWBqcBPolMGFZ1ju8wfhqEtJRc7I95ehmDnsggFr1Ecjt4o4GqGAANkF7V/LJAcHrBTpw0Sf/oVUuCwNDPk/kR3lx4Uvm7QQlkgvgZJRy5BiJHE72Q9PoHKGumAF6JurYlSS/Jo0SvP+dVcl/k1rR8V9MweVuKQEsNtS5BQe/ZL2t7Ep1C+bre5BjiA8SyqYree7Sl1993p8oNP3PpgFlGksuR8DDA64He1cp5vR895YkGZCxnFEbgjQLpzuZwjyghHvkHhkXGmyMd3vtEFe2A5vX7WM+NrXMTQKeMUtE+VL4IRANkQnPr0Xdnehm8UXj+fikbqYsXoPE8T0bor0S98k9EEITrYiJ6gJrgmjWJdx65K0K5QnjQs9tRXgnG6FNykcSRoyz4ITbUrd2bK+B+8KRDApUEi+wPg5Ifvpd8om2JOqLUNh3kkN1Mb0d5HopLY2XvkNiTPBtAq4CXgONpMKNlJDKE0puU72xmo/mEspbZ6PNMbaRD3odEC7wnbS/y2wLoqkIuDyAWQllI9D1yvQjK2JvCfEcEUJYIqiiXBcvSHaNbYpm9epTAlTLjlN5MbaUk1Y3O10TUjCM+/HHyVyBnetPpSNnY97oT1yOA+M3ZrV4z3Ej7eg4UZj3P+/uuPwZB8LM3sDyxxRZbbLHF9tq0G7M4mPE87+pQhV8IguAXbsidXx2L1wyxxRZbbLHF9rXsdXagkBSRkrwGvA7ewAulY662xDvs2Of0C1XnvQb7bC/zaGCfXGWONs307sgdg+8ynqiOW7Jj97x+2f59Y7ALJ0HO9u4nHBqGQctGKOQXHQQOItLxbG95yMj69aa7eB1OuIPwRzm7a7sY/F2eU3/d7QH2ph1e46HdRzrb9vOg52jcujPumWY45WiUpOOak3Z/dvEkiIgkHEen40zENK9ut+Han7dRHuVPuREYrufUfMjxzLt2P0za1da/lW1ERX3REfr9Fvtmib6dN+NQLVt/s4NnwwH/oCfimjzsaUdERFxTz8Ah3dhzoHpcz+Ll/9ENb/F+wB7Lg5HdVqWX7fr1ptxjIJh0FGzwmpeNXA+C4GHXHz3P+4SIWMQkPx0EwUduSAm+OXvNrBlERMQPQlk7WncaMfrwyvWoFs0akXegoPNwbSs6l4Wzcz0tqTEG8uwmY/n1e5CK/p0oiTB2nrKR05CGy+xI8InsIB3oncutg58A749EkwoVmmEPc34aMf8DeCgTfMePTUHpeiBprD0SiOmmF98Dv0OyTuQCkAUp/N3n92js+ADNNQAywR/nVaI0IBAK/U28O9lUbSoxwAMMRvjcZnReZRv6hbRID4iEkq5LhpBYTjahVLAfPA1kyt+OPqc6hJV8eJ0Zw18+rIiHp589pvfP+JHriOIsLBGxAPTEFuQO0Xb9CeTfoWyn8lORl2I4kQ891+15fYZUHiAPA73+RIIMZ1HnDl2zJMGAR7wdfdjk+aCUKeX22rNA4ryinSzVAOIBz3k4B4UMPmakkzW/Dx6CYX4HXUm06KDsR671iXoFWmIwidEURD3c5TNRBQP2Lb6viFCggkWiRylLxPSjjJ0D2hn5vBjj36tEJTKvRreGiBd+Uil0xLEbnfpYphwEoShDO8xF+RmIUqL5UHMYVSgPCqQPeAe4Nq4fAZqJwBNQm7FtiTL00TdlZiB+E9759ngZoLoAaq/Jl6P9lGoylFclAmGIOZScFM3DCsFJAPFBWUh/jJOE+XJcDap4Tn50zkhiXOSBePVGO+gezoF8Djsyv/o90yA3BdEVqBM5KKDo0toXbcebbjduzXBb2Nez8loKguCf3PSS3CCzwgiyH66av228x01INzVlr9Q7X7Ll0IKUvVlsv73hzIPwsXFzhUK09zsOGhzVGO6iUV+dsmHaLtjzVs8eYcGWe0MaFB2b3nHdIFh21S6vqz28gvv5idiHGa6Qh97QLtP9D1xw5sAFxLiltxz1GNnPz7/L7mvhi9SwZN1+HiNHKEu4IBuzTtkd0uEKA3E8Ppm+wyFB+VvTZjJlssy/zToOtjbsA57cAbs/D/Pu/lku2YcTb7rjFTP9s5+1yQz/t+/5DTP9/3j2B5x5ew4SwuCkXY/Ml+zwifyq+81Xu8seyxMvOw68TtknECPHmdqFn3KHWqXP2nm4SBldITypk+75s/BZWyxgr8tGBkHwZ251Gb6GvWbWDH46Kd3DEzKoYFLDkBniUD/sl9zjcLODjVcAqcUEw/XCTREWrLVECHHPwq9BUltCqwlzZuhDkNVxOJjWzNNbXfxO3wfNwyASy3GToPfjoQdJGMPNHULRPIQzphYRljERJWFM4wC0fFF/R7iwBEFIEjfCpiG/onMnSc2SCNPocpOOgwdugDpTUTlDhg8Qmu1zrUAdNx7YLOO9RZgzpDcpKVc5zzkuiLRJfgsbaWwaMysNGZX1XgxxoNNhUMYGBVm35iAXuT+6kfTHQhZOvVlJbF989rCmw8EwrIMAbgVlxSt2/HCbkpk8nMkva5uOCtjU4PkNJ3Tu71cz4cFMKDG6oYXuYMOf4LkOZQzRvsFYPw4PtzawycPzIIlxfo0bXpAubiDkARsvbu5CGDuIDr0wnIBSkPq9O43Nf3Ln0KMHAmJK/w2qJGGMhg/kVilFiusmsUHFgVn5vKZPXIAMZJlSl9onObZZ1mGV4wfhTCgjSThpHPvDEg8kBOXaeZY+N704+EqCwDiF8IEslkRcM/FwggcBhbVoGAYJI4eUZERZWHZumHnAQ1JT7gG6s9GNNeehxDA61r2lnHDlwGvDECf0ofwYsWE4t+HAsz9BZkr04xTDLHAwQNJH/J77Hc4l3TmOLx5WIn+GOeIjhzVOf4KHmSh3xwvHbAaHdGmGOFAulsT3AfNCX0tF5TZ7lagssLiXNrHtYnuLQyG22GKLLbbYboF5Er8sYXEzxBZbbLHFFtsuttfWDF/PgcJ7b3opbpAF2UD6x671Wv8ff/GXzN//5Fd/2Hmv2pkpM/3ol23Y83mHM7LRc3tIRy7ONgcExgU9dqVvthxuPxGZLOyi2WdYs2h7uNNNd/26Dgi8i4Qk5XKWO36fcHjQRUQ6DklAF1y/3rXdsDN522MsIpJ0QNoDx6j6ke/+lJn+X556m5meW3CHywwqDkK6rN0ZZv/Url//oNvD3RjY1ySLjhCbut3fRg/aDzC76Z5KR46QjsIZu78V7nAQSGbdynWFlN1Wn/uj+830ict2PX72X3zITM/ugmU7+L7LZvrS7x8x01cdkpzFhV1IUR3t2/5WGxGTDuzfJ+zIEJEz7pAVF1nrwuaEmd6ftZ9FxYFCEBFJtew8vuttXzXT/63zTjfQbjF80fO87xORnxORWRH5mOd5TwZB8P5XuRivmTWDN/Ils9WV7rTOEz1IrdIzG6726O2Hlz8BgjB/AvBpEPQlz+pLPXuJXtGrPNQ9ErEBAg/vJCX1cuc39BogFIYzeOdO6mcfntYwJBIflAwkMoEe9GEBHt8mwjcAbR7l0Unx+sqsk0hRv7f3wbO4qt/zm0Ho7Q3l54pj7yZ4KemRbu3PRO7JdqVnNixrhzEMaJu2ljW/oO3bmdff5a+gDlh+MWyEKDeSRpKYL7+s7uwEUB39+bJkVhTtxNCRNGD7m6d1scDQ0XEUI0kVu2jP97z7KRER+dSnH9QfYK4LFvTZFzdsuHtIvommzK9BahOyeqMx8roh0B2E4IvsoBaIGuuDPK6PabU3jRAUhoTMAJ3SjoazeCAr5vMgsoEeXz63XE0TSG7JEJIgCQQCpC17c+j3dX0Pd/ZpAVv7gALA6zk9CML+lQE6orcPXnrKlqIMuWUtI/tKBoWnJz2/wnAa1L2KvrNOpAK+X9bn7hfQJ4EI8lGHAbzTI4QREEXDcJr8in5vnARKppGQEUNtmkCMCMYDyp7CsnEHmYBPynAyFIi8gwgt8ShBOmAoEJEIaIsSy4Z+T2VZTBWcn0YIByS5fBhShOefbnk7ZSXZIsYO+1gexJtExTA8Y+KsTmhE9oRIGiAQOpAy5XNpHeQYlUjZOQ8SRVG6ADTTvmiZ2YYktU2GoV3BTpgL6rITngKEyIb+uD+ZieTZmidJKMqE9hs5UOM31V5PIQ9BEDhwzLHFFltsscUWG+1WMzYHQfBhEfnwLS5DvGaILbbYYosttq9ht3rNcCPtFrFX3RxLpUYyN1O/Jv1nXvke8/f9rrv6P/W+PzTT//2hbzHTvUXbW7edd6MEkqXr60kuLoGEIza/ue2WrdtfubadRERGDhd+Pu8gpOu5vZSUfLomvWfn4SJldA24etNdv0TGvsjhhJVu10YDvHnygjOPlaeOm+kbD9iZ/PbPv9u+0d12WdO7EO4Vl+w8NqYd6Xb4v4zW3B58L213OJfTP3HW8TwcMfi7SY5Ozdr9802nF8z0cw2bp2Gr7M6jnLVRDetH7fRtBx+D7+hrU0+7T7ubDjLM9n67zTMOXo5k312/+kkH8ePLjrnqTvs+JHkbt37VmbUUz9jpWxWH1KqDb2X7tBuFdN/dNsrj977wJscVv+a8V2yvTwvSCenuK0jrADy9mNuSoSdRP+klY+z4CJKlyS2QpMG7msDvGItbWvBDr2ISnunikv6H8ej0krVPKT8TPYL0bA/ziOmfhXwe7jcoRfPiHEEitgTesyNIaY+K8PaTSDmIIhOS8HamOiQ6BGdAz5f0proXe/OaKWORU014qGd07q8fTUXajd54emLpWae3kbwEmRWgMoCeoDRjFvH1lFykR5hlKy2AWBJx8+kGY/31fn51R8KufbyK+ulv1u/WMvNZkzMhU48iQPgc7rhXZSE//iVFsHkoUwooC/I6eKSDgMd3hzMD6ZDdSw4IB4jOr50ZtgX4H0Ao15pPhLKQXKaxnYhKScAjPQSXUmKbSIRonyLqgv26tBBFz2QgQ5hq4z6Qf7xGEhByoUQH9Cd0AHWBSCH5JjmREn1vx/MMzzTlAFMgJO7NaQOmWiCxbEY5DOjlJxFffh1lgTd/UGCd9e/NOyaQHh2HKTyH+mGgiTh2M+QLARcAxlt2DbH8UzvvJMb9Z3tRLoMMCD3ptSeChvKO6SaRHngulIUsEqWi9yGZJcc40Ulsg+4syyGROpBgNUBb83knIGU6LAaSakb7RLYWRPImKqK02EMdotwJnDdIZEjeknYxivThmCYnRQ6En6HUY5vzln5nX07Xo6gmlqtyHv2mH4TzCnkd+J08DeT2CEks9c8ycVYnuy3MAWzX1gHMK5f2UiCCiOd5HxCRfyVKmPwfgyD4P29GPnvqQCG22GKLLbbYbpntIW9DbLHFFltsscV2E+0mrxk8z0uKRnx+u4hcEZHHPM/7aBAEz9/ovPbUgYJfT0n7k3PXpB/8xJb5+4W/6Y5R/9ef+ICZXn3BcXK1z07vZtwcA37V4X1zJKdcknIn7SBnr+mun4vBv5BwcES0bQ/woe9ddObxjsklM/1zi7Zn33ty0k53DLj8LioPzZLtCQ2yjsZt2G70X/z99zjzyB60n7nvkN5sfptNEvHAAbudnigec+adLNge3bv2r5rpV146aqa3C0kzXUREHFKhg5JD/cHR3VwcH7vNPt2+fbMnfsHmN5j5i5fM9FHFrZSRTtgFu+Ow3YbnNg+a6X7eIcHqUA4REdn6nKX6J+I5UEvdU3ZfL6y455f8HTbK43C1Zqa/8NIhM31w3IFUcShriIj4GzaMxXPI7iZL9hyWLrnH+LNP2X36lrIcxQcKrykbFD1Zfksq9M7TO0lP3xCgK/KRUMosCZnanNIehB75/Lr+h0iHUdqTAtJSHf1s79O5jdJmNHoE2X870/RQa5lCfgcgE0IEQyHq8SXDfxqKCEQE5lYpgyeRT8oYEpmQ24RXmioUnZFsn9Z387hcXihXh2E9IA8BqhLyNZBLYVYzTdeiMf28b25tx4MqIlK6FPX0Fle1bIMC4qmhJpEGD0FnFt5TxKh3ZqAusT8VPtNRGugFvPKbUA3Ir8FLeQhKBUB0zD+iWn+Ln1A1ByqMDoB+q5zV710skejpDdny10eRstDrnOxpOXpVficyBM8RXAr1I0CmVETSmNIHVf0sIL5/+66d+H4RkQBIBbZniLihRB/aYvp5nXf74BEYl1ocjejhpTKGfm8cggIJPO/knyAihf0gjVfEsMDn6ocs/lzPZmpAMwBtUX0GXCFYwhE9Qak/IgsoX0h1AW/I5wYZw3RUiYJ9iF5sKo8Q5bd9NIqKITKifQD5wsufanjXKLeErm8M6dIixhBj+tPRvDkeOpCnzSFILCwjxkN3Oop84HxEpE9vEmVrEYEQRcmE8xW5SvAx8fLOGCkuQ6ElLIuWPbui69XOoWKk7OxDnUmggtAHqI4yAO0Ry0wJUqJVWofRSOSL6BJxFUVTcE6dOAt0DPhCRuibflokB1REdk1hQD3wzrBu3WmMdfQRqmP4RwuRMvWmMddhnPTsrcjNsZu/ZniziJwJguCciIjneb8uIt8jIvGBwm7mp0Q6c9c+nbM/VDV/P3Now3mv4MP2BrozZ69Wiw7CtkHJLd04cskCJux7+TP2xsUbOhbpNffjTTh26e2hvUHJZu0F//IXDjjzaD9sbwr7Q3uj6tiXOTVh/V1kMYOy3bbpvF0Pf9GG6w+m3RvSk79sb9jO/Yzdhm86eMVMrw/sw48/98YnnXn//mceMtNfHs2b6dmHbPm91BkHe6W4Q2z6c3ab5C/Yz3vmWfv3Cx90sf2JtNdsWH777fY1045YlqQj7EbEHd5z7mn74CBTt38/3Nc10/2Ue/y97TufNtOf+CU7NmVrykEA6h4Csq9iP/Pav7eJH7132HNCpmZncvpN9kGYiMjZwBEX43h5jrbsA727Tq8481j+AzuPzQdjzafYvj4L0oH0DgzChXZ2gRJ10Q0SjRvkJOC/7M9dcDhz8Rt4+tLK1kchbDy9oQt0P6Ur7mwNsnaAaPf2R/PkAW3tbpQNyxWS1IUHmQh5TBLmjIU6N2rtw4RZ68+LK5AEBMyXEPwMwwUItV9nvEIQ6rVz08FNL+XWelPRTQBh/u3Des/cql6XakbDPMKNDowb0MmXoWV/gHJ3ml5+Rd+5o6K+Y30QGSbruhPwQQbIEAgS7WXrvmzeg/bhuQ1eDZQvzK3hcGROd0Lfc+8zIiLykcc0hCpTjB6O0PfCAx/OxRkSQ65q+5H8sQNJzTCkpAnCyLLWhRtbho3sbM7100+JNI9HN5BtnEuHoQ4Id2H4y448p35WL2ie7ekoASSfW7rFzRsOzHBQ45Fsc59uxFIgEexNEAaPAwgso/g6DkNf6Kcq7cDJCdfnQUJ40ID2YWgCD7YYJpDZ1psFyRzKwn6LdkM7FhZ0vG2fgpQpysBNZGeeh4P63UcYE8vD0IxgEiSPCW3M/FIyJLFkWVM4iOlO4jCihXYb8JAPzyPDQw69vvpMTctyWB8yyRhJZtmbis43XAt3QWRJ+do0Qoa6cyBi5SsbD4JyoCSLzNZ96cywj+hncRFjCJvvZE0njOEpLVtuQx9I/Yj2Vx52UPqVMpA8BGwck0iZ2Qc45n0SSWI8cr6qXMDcggMEfvKwi5ZfH0p2Qx9eKF9KSUsc2mW39UHVTkSlYblPDMMuULbwAPS1t4SY8Tzv8au+/0IQBL+A/x8UkavjQ6+IyFtuRiH21IFCbLHFFltssd0SC/YWwVJsscUWW2yxxXaT7MatGdaDIHj4htzpm7C9daCQCWS0/1qIbPFp2wPs8pSLiGQdjs2M7fST2ntsL2XmRTdxoByzr0k4EAo9B3Hg8QPrZvrq0zaEWUSk0bc9gq5QCELfxi27C593d2B3r86S7RXPuCRbvoEBlynaoRs5B9Ki27HJM7Pr7rARr2Z3ht627eF+/OzdZvrQIQF5Yb8tXSoicvgB2zu8/KgDln+v3aFJzHM9li7Zbfs3f/iPzfTfWXrATM9sTTjzKFRtOP3WObtNWg6Sw33T2848BiN7/NPD9/XaqO8KDXG37aeet/tC+rD9e1eIS5BwT+FnX7TRQ5U5eyyna3a9HVFQ8vwfO1gcRcRzABRK5+y26jxshwOdW7eRYiIiqYnbkDgpPlB4TZmXDCRdHMhgi5BuTSc0P7cErzVeA0QuFJbxoAkhPsuwgSjZmgQiqZquSYYgJKWntXFY86T3nZJlhAx3ZwD3LwE+3aMHlv0ekG8gFXifEFGEIk49SW8dkArwQhevQArQp0cWXmveHkRx/clMCM3uV+CNBEy/fZDeedQf75NQkRdl68KTTinAAbz9/F0G03RuC+iJXJR8sbCGdk3AwwvJvwS804ScEw4teM33SQ5YSobEjkOEKoTtSPg5vJYPHdfwud99XtFiyXFyQNybYTKE4lcuQrKxRyJDeKfRFyoXtR/0J1KR9CS80gwfYZ1bB+D1Z7lLQeg5HeF1FxIboowhkWF9BxYuIjL5CjzmaC7KQRYgqch2HUEOdGJB0zuHyvjUvkpkAsNxSLzXPhiVq6SnN6hoYyU302g77xqPtQeETSiBjMdCUstMneEceq8AJJYZfk8QUo8wD3jSm8eiKMfuFNsT3+dB/liPInuISi2cQ0hKoJXckbJOhmFCRCoQjZIhwWSdDJIgPm1E5wBvBJQRyEMZcsK26eG1RyQD25l9ISQMBckiQ1iITOF1O2EH0bApz9+RcSSKmqSLRIT4FV0Tj6iISQnLmeg4CFFc6Ju1u3D9pP4hUQPJKEJls+skjMT1ILQkUqE9x+eI5w80VJ7SpQgj6U1mwmdPclAa+zkJNzmmiDDvH8G9toBI63G8oN+6ueZvvN38NcOCiFy9sjyEtBtue+tAIbbYYosttthukcUIhdhiiy222GKL7euxV2HN8JiInPI877joQcIPisgP34yM9tSBQiY9lKP7r+VFGM3bHjn/F64lcKR9zz+2va0//9n3mumHZ2pmeq3tRigUix0z3cVv4HAgylrTPk7Lbrl7qqtc6dC1EDXfd5BOGpwVtORjNrPJ5FttRMXg3Ix9I4cjstNyE9KVyjb6YyJvpw/bdiaZt7ohGItvrZjpyVdsL2x2y87jQ9/xeTP98f/hQWfetbv223nbAAUZuHgrHIgbEXGenOZLdr/9062TZnrPQU4Y7DKRBh+zPdPlD9TM9I4DDdMbuBEmSQcaJ7Nlt1XxiotjwKGLuUv9Mot2uUYn7Lb1HSiI/i5e+gfvO2emN+62EVuXPm8jmpIOhIK/29vDVSxH+uxH7TKd+DsvOrP43J02QsIb3IbIhdhuSwuGnqIT4JkaVkhIFpU/zNb0k/HXxZVR5O+FS/ToKvqu+LKuQ7zhSBr36TqjsKhjO9XUAdXar3PA5ml49eEx7IEkkISyHkgVewfp0kXhQXCaAT8Blw3kIchtgnRtkfllUA54duHl786CJBLICXI+DCrwzGYS4VxGObyNB0mghrKB34mEkf4DWpnCk+rh7k2joUhDQEI2jNWQ1BHSfrNPaPy21wfPwDRI1KaA8tiGx7ekZWwe1fVM+bKmL71Nf1e+hHjsyUQor50F+WLnuLbL9Be1/n/tf/qIiIj8i9/8Hr12Neo57cwCLQHJ5hBNAS6K7Cb4DSCl6SNunu2YBlLFK+kNt09E1y+MEa/dpd99EEiXz+l9mvlA/FnwBzTSKBu8uNtAO1BSEd59Ij2GOSI79O/FJf1hG7H79PaP4IUeHSzj/vT+RxEjfYAL++ir5bN6Y6JqRuSb6IHLAgSXQTch22/SvHPns5Ey09vfhhd55hktE6UsezPR92w45g5opyss6tqudVj7Qg9oms0HgMYAhRXbIERTFIDc2URZQXLaPqH5Tz0GaVgQrPcmdwhNidiondS/VS7pHxp3aPtNPKesjZ3D4E1Za6PdcpHrSNy6dQe4V7DsJDdJb0obZ+KoQnlaz+vammgi8qoUlqKIBbYtx9fkS5B5rSalAFRFdlP75Qh8JMMS0CSlKCqF3AqhVCP5Y2b5d6SjPZMb7KMoywT6GHhUiKQK+VEwVpkfUVDsw91pEK6iP5Re3pLNh3SdWFjVdidJKwk3SS4aImkOAJ31nNYtRF9y/gGhZzhf7QELgmDoed5PisgficLa/nMQBM/djLz21IFCbLHFFltssd0yixEKscUWW2yxxRbb12OvwpohCILfF5Hfv9n57KkDhUEjLSufudZFu+8x28V24bvd9/r5z9tygeUzdpPVX7Q9xqmBu7dUMrYkmudAKHQcUnpHJmpm+nLPHaPe6Nrefd/BlTBs2Hnf9TtNZx7nv9fmSvB+x/Y+923yeafsoD9wc2AcnLBj59uOWPuUHbIv2f9edeZRP2q3VaJoP78P/OAXzPSP/+w7zfSD/+KMM++5tN13Xty0VR7kT2fN5HHm3KvNpfJQytrj6aXfvMtMd6l0VN9ryzOKiAy+065f46KNeknP2p79A1NuDoXLqzYfQ3HL/n39Djt9UHWoXiy6p9e/8J2fM9N/6/feYabf8fbLZvrlM45BIyJDR8OffdaGsZRqtme/ecIegG9/40vOvB/79D1mOiWhxm3mb14w09f/jpsHJvX37X442nAgRl4Fi0MeXmPmiUjWFxlSbg0ewTF5wzRY9Wef2lE+ENlh6m8fUY9k8dFXRETEP6n91k8npHhWKdYbd+v7mB43en0Li1HPHyXL0huItT+mc9uwA6WEPOabNfXE9oEOyMDDWlyClw5x7sM79J03A69/b1q9o4ULNb0OXApBXsdN+6iWk325X0qEsfjtecYaax7dQ3ptZkl/MDis33vrWrbiwzr/jjagDnBYX7T5r2p7EZVRXEYdEC+/fr+uHbKIVaen1+uAh+CwNtIQHsV0U8tTO6V1mHxF77P4br1/bkmkN6tpR06pcszSY7pm+1f/678VEZG/+8/+tt77If1dH6/M7KrmMQmwFPkicpvk2cAaiPwOiPFPbWl6kNT2bB9EGwABUlrU+2wf07ZrHCfngt6OfB2V71S+pPZmRfw1fXZEdqTXoh7VPKRB+e4uLiNuHWz36Tpd1vpROqPv4CCrZRgdm0Id9O/NA9rn8ht6n9WHKfWof+farHkUZafsKtoog3h5SpuKiOz7OLgJoKZQwrMfQF3k8O+qTOdgDuiJS0C0JuF1LrPfa3uyn9ZPaDqRDuQL2P9Z/V4DgLJ9RJ9bAggFeqf9o5R7QN3qOm627tOE6nP6w5lnRjLMUo4T0qKf1zHOdsxBSaV+d1XreEH7QuMENV+jqgRbp6IcCvU7/EjdBN799tPa7wcHyU+Qilw3BIKKz6d8Ocrpws/JJzdEwOPQukvX4/lFHZupmrbD9hu07OQlWXtQ71k5B84PtCc5EKiakhhQzlO/Uz0j/4w+H/ZN/p1oD6Z3oepQPaNjfVDWHxJ9QARQ70BFiotRyUvyaFCBgvdsz2MeeUnL1nqn1nUIXpo8EM2Ds4okyS/vIp91g20vrRn21IFCbLHFFltssd0SCyRGKMQWW2yxxRZbbF/b9tiaYU8dKCRLQ6m841qv59yftePgU/+zg1JdRK681+YlcLGRB4Hteat+xo4NFhHJp2zFgYTDNTxbtN3oraHtdXfFPouI9LevL+47PWF7jBP/v2s5K8K/2VQJ0t+wKeCHRbvenoO/wXOoYYiI9EZ213ahP1ynhK197pNKP2tfFDhG1Zd/5hEz/eg/eNlMX/hXNieBiMjij7vb3TLvLTUzPfkRN4rF1Rdyjn5bWrSf38r32rwV02n7PiIinT+yveipt9pjwNWfs7MOuRYRGfVsD/6pv2A/j0LKHlCXmzZq4nLbRi2JiPy3T7/dTN/3yIqZPp2z632u4h4Da217Dpt62h5PPbsakt6yx8DnnjvlzDvv4iSp2+V9qHrJTH/lX9t9R0Tk/KdsFMRoYu/EP8Z2cy2bHcjJYyuyXNd3Urul80jmnL63i+DCTjJW+g71QJYXdF7JX4JX78yiiIj4J1RZhZ7A1EZLOsd1YBUWtC+3D+i9+2UgFfA6bJ9GX99GHneqd3/7ks7R6Rlorl8E+3qBrlT9KALE1Dii43X6WdKw60cAFYfCGX13BFmsG1KIHUfMNFUfBmVNTwyDEE3BWOyQZT6D+PPT6qH1htC0n9b1wuailj1/WeuUBas678NYfz8dnS+mXlRURqIPd3MfvAQFbbthnh5J1Anx86Os1qF5ALHonE49kSCr97qyXhURkf/6Q/9GRER+9Nd+UrN4q+aRgiIBlRLISTGC933mqSbaJxNpt9S6po9m1Avdm1PPb6oVje8OOQGqWof6SU3PAV2QAtiufrdet/KYSmQMpkYiBSA5LmRQhgD3BocCrk116JHV5zIsaxn7E3pdblnXsfWH9T1L1ASZ/IcF/Sxd0TKsPahtQs936xjeq1REwsfMQe2zW9v67ulTbaAJvoLqUOpHtQxFIDTo7Q+98/dpu6UbUI6Y1T40mNA6kD+Dlt3QZ984qO1OdaUs+D7WHgKXBZCELEv6qD7YLpA+o7rWkaoPxQVwbcC7zft2ppJSWtC+QnRKkIku+gZVoIDYL8H10atE60pVmRSGPvlT+DzlkD5QD3xP/RnwpbQwNoFUSQL5l18BpwWQCSOgofwk20rbrnNkZ92XqcPLv68Q+Q2VKzpz2i6V83qv1iGiHYBGSZFXgwoJ5H6B4sU2nj2WaEQy8PmX0ZabdwFJ9aw2RuYKoKKHdP4kh0OoSpPyJLvaQXuBj+ZufZacV4hU8HOYvx+AgsczWBth/AwXOBfqx2CXdVVsbttTBwrDYULWt67drLY+bZMvNv+qe8ddftZOTz5hywu2jjlw+bv0y1TCcY3DJrI2rHutY4cW7MZ6l2jamylK+IzbwJH+Qse9aZr4qr3Jm3zZbvfGndcHM0ruIumYPmK3bckRKuDir+RLybKug9PTFSqw9RM2A+Li521yue/+X77kzPu3H7MlZ++601aDmaraB2FnAveBguuQxUUaunXKfn4/cvrLZvqljlsW88p+W/JQLtvjz3Mc7lQy7g0p4YLj9sxn7Y0yIajX2AN1M3k05T4wyTmkNxeX7F39RNaux2jOPYfdP71opn/yXjv8pXjJrl/CQXL4jtOvOPP+fM8Of6mete/1i4/ZByyll93Eq/077bp7HXco1E23eB3ymrTmFuDoa4B+Y6FP0tNcXx/s5CsglLsACD42ugEWuckNyPBh4xtkd+aY7ZOaB+XrePBMwrAAJItSArFbS+8xcQQHCzW9PphEOMZGlIyREmpzX9V3XKoVldVLreH9Qym7NXW0eCCbkwQ3ZNgItAGJPpGWLqbq3jzIKDEnZAsgfNzUhfzsfi3r+hoIizHcKSPY86IbX27WGXqXQIhoogsCt4KWLdnG/JemdCY24YDitw5qW7VJwE1OwDv0usRaRnJwivzY3V8UEZG/9MWfEBGRQ49oSMHqn+g7pzcL+D42MAksGapno+R1mQ19p3ptkC029XsKBzRJSAcOp7VtCMcegTCuO4UDhCZJBzXfwUG9T/KKPu/k3Xhu2zlJNLT+bE+SMYakmQ2GY4xwT82bZIDpFYY86O8qj+vz6h9VQmwS8tE278EmG8uHxp2jSH7JEg561nWtt7GpfSjAepHryXQdIQKdtEw/r/2XUPp0K3rQwgMYkpfSspd0zA3ntG/Rh1e/QzeHHAeE0Dex8U0j6nGEgwvvgPaJPuDuPEAYVlE33DeE5ENelCTnpYVB2E+7B3S/kT8bPaRL4mBmEB7gaEfPbYNEdD9CHNBdW4e1DUhUyJCiJCrl+5BJ7VGuE22GtSbHEUNQOjN6//KlPu7HOUevL7y4Iv3DCD3GmBxlUGb0geZBLSs35STcZHjwYCI6F/Dgkn2U7ch1Ew9NeLjBea81r/kx7Inja7C/KiI7YU2FV3S+Gs6CMDThSf2uMuqNwwzcm2XmwUBYBpQt8UhN/77KGBG0Nw4TvZ69TrkptofWDHvqQCG22GKLLbbYboV5srfiIWOLLbbYYosttptje23NsKcOFDxPJGnIHgYOx3c67/Ygdt/s8Pw5QhsSvp1JkHSHPPQdumu+I49MwoZvZ5N2eifrPmXLOmDMLgLEvm97/cqH3KR33/5XvmKm/87H3mbnnXN4HJMOl3/D3bbNvo2OcIWmuMIUervI8iX69kxQvN8Osbl72iYhfLxrIy1++8k3OfOmxNG4nf2yTdLXfdOSme4aGyLug1NXOEn3gN15fumpt5rp9x+10RQiV0H+xswxBCTVsn+/1bMRDSIimW278v2TNhJodtbu6xtf3GemJ0/Z9xERmSrbIQzrL9poo5dSDrLNXcJ+Hr18wkyfecL+fa9qp3f3243+xfPHnXm7jJ6EcZt42kYiNA/vgrLK2f3t5F993Ey/+DXKFtvrz/zAk/YgHRKxhR5fWB8ervJFQGMBBffLIMeD83i0ryoiIt4QnsMBZBTLWRmU4J0lQTMQA02gGpMdwMun1A1Mieb2tnqXW56+y0IEA/4+LGleJBrj/duAKFefA/FYBSEWB7WMRC4M96unNzGIeuTpOQ49hcUdZEKyRa86vJZTgCnvU5RWu4dxTC9lnl5HLRvDMuitTPaZ3o60DVEU9KT7s1p2Eh4yHGOYj5IQ8n1GeHXQ2yG7+5G7FCn3iy/q+2jU1jJeekXnVvDpSaoRJZljuw7z8JQu60MfoQ94hLtXoyFmDHsZFPTv7TkgGxD21YHk9mCSLHUoO+SwibrrrBd2/j6jqAe/q3kn2Y5AUVB2Mw0vP+/JcJdhWT266VVILt6DcAqgUvjS70yxD+C+E0SOEHlAST/UHeEgDE9NbEfDRhJYaqe6niSGqHchiibJbGkl6EX3M5RxRJjMlI4HPuP+hObNNVpnlmWLtsnojUANLenzqZS1rzEcJ8u1QwLPB/LefE4cF7lthhh5IUlpBlKgfgWEgxj/Qzxzfm8d0/f6CEgBIqDGZZT7CNcjkWFA4vFaOvL7/BI87WjXIsJNc1scb5BznQQKo00UCEInjsxIZ177WXYz+n4flii5qN8HWJKkmxx7QCo08HxyKCvGutdPoW1IXBmtI8c+JUirL+k81TrEkAv9gdcD+eKUzlPNexVRQcRVpjaUBObE9izrG+1vJIzkXJlA/2xdqqAM0QdAafdhXmL7BmxPHSjEFltsscUW2y2zPeRtiC222GKLLbbYbqLtoTXD3jpQ6CZEXrmWiIyxP+MWrLiPoYqXbO/lt/3wY2b6p37TJtwbObgPRUTqPbeH3bLl2oyZPujZj3Gi7PauJx3OU5cHeFCx0x+av+LM4ze+asf5f8932G34x+fvNtOzabtQzYXraz8RkYVtB2eA4zm5+BBERIZH7bj2uZItpfnlL9hx5eULDvnJ9ztYLUWkc97uC6P77Ly3/sDmJEh8Ayexrb7tTX74AVvm8symXdaFhpu/IfOArd2Y+d2qmd6dtfv6SsPBLyIiCQcIyW/b46ni4DHYdiinpgo2X4eIyPrjNuIg5SAzTDrQVKW8O4+1K1UzPfcDNoJm9Bn7ObkIWUufdaM/th6w0QPNQ3bbtvfbc3T5vHsO2561x81dj9uIn0885LzVDTNvF96a2G4/G7TTsvrUvKTx2AalaMztBGhCSEpYXNBJo4+4+ERFXxx+kp5HoAW62v/rxzPhPNOD17ePaS+9TQI8zbO5CRk8cICw5w9C/UYgGc5HY5T5Sb4fooDaR/SlnQNxmQ/vfvuglp1ey0QPsn3F6LipgRPHTwUhMWt/DpJ78EImVvVdsLmhJAtEiiXwPs1fIpJAv9M7zUU0vc0kX0xsqTe5f2QGdQGvwKS+67vT8FajziS2bIJfm6gCEiany9r4b73vvPynT74b90TZtqMe8mwNX9FOpUXwEIBIL7Otc3B/HnKGK43Id3qjBxUtY2s+FakjyeQaR0EUh06Xv6Jt1Ach3xDpAeK6E+0dAr7iC0A7HCSZpd6b3AlELLT2gVwUMpzMm32je6SKsiG2Hu3ZnQTPQx5cF5j6+arMbujfO/v1vqlVLcBwTtvGQwx6bo1cAKg72riwHMj2cU2cOD9GGjqGTPDAQ9CGJz0FUsthLjrvUx6SnnOOh+EMpBUXdU8QwJNefwGkj+grXXBXFC+DrBGec0plTpzTH/arlC8ciTeI8j4QAeLniMzQFmsc17w7eFcR9cCyEqkQ4JlnIQPqN8l5oN9za+gzWHplN9G/20TPYP4Bgii7pXUflIhk8JEfODiyCcmDT2NQIdIj6uXnPEUJUF+IDIAXn8AZIJqyl0BSSn6PGspaixIkcrylQHTbndNGSHUgRTur3zPb4HJpRSVPt09pm9YPZ8Nn1ZmPEkUm6lG0CvsjSS8Li5zb9O/jCKeUG1x6w20vrRn21oFCbLHFFltssd0KC2RPeRtiiy222GKLLbabZHtszbCnDhSC5FWnlFcZY3nG7W988A+c9/q5r77bTP/Csh03PPmS7ZHbutPNOL7Vtt3Drv6VTtt5VIq257RbcLufeWp4Td6O4rq8uZ/94/udeZTvq5npf7pox3ZPFO1jwaSDtaS9i0hGo2tDDvIZ29PbdIAduvvcsoOlZ+z2LRy1G8uFRCCD9rj9xaNPO/P+pYbNS/DGgzYvwUtioyOGbge+03ptu7Ge69hcAkenbLTB9i4IneEf2N7ypk0RIYVlh8pDwX3UvNW2FRUKF20P95V5G1HRvNt+3sdKNk+CiMiFGbvh3/5nXjDTv7p8yEzPpdz98767L5vpz7xsy+UWXIIKjvHXeY8DmiEiUrOfbapl36twZ81Mzz7lRrEcPWgjeH7vCy7ukV9z3iu216d5vnrV6dFmzC291Yyf9xj3uwFeglIV18Mb1+gjHXJ+8AxmtwMZYVx1AEry8Aqi95Ye1fSKJgzo7UX8v9dCTPIGPNWYbsZFoog4oFQc0QD9SX0XJvtEJES91f0qPIuIu2YcfgbiNd2pq7yOQCsFUJgYTUEiDpwJ5CKix5WSmGxXegQpa0jPINstFWBepNfOo7dULxxmozwP9MxTrrJ7CHJ+i9qWH7pX+VR+7fmHxS/CWw/5yKCuc1Rvn36nLF5nDt7MSpT7YlCG9x2M/cNJqDC0oaZBLzXKRn4Ifm6ejvIUkK+DMeUdyGYnoJwQ1LRNggwRKl7o1S2f1yTyOOWh6sDv/Qr4Hi7UtExjk3sfqhiUZqQNC9EYcrLkp8ErMSyy70SZ/TNF7ZSjreiWgigMetZHWZHSAsqKdk22o+8wygV2TmINgKwyNSAFoD7AdK5ZffI4UKyBSB/eHs99OK3tXHoJigyU3MS4orLL9LNQMDkQRXsEnidD9AWOoUSITgFnAfplZxrqDHgurQNAUzCmHwoJqSl0AqgOcG4IJRmr+n0CINABgNhEKNDYZ3PrQECgLxYuKW8E5S37EwUZQEqUHBRET4RKEZivON90j+h/spBY5LMlusVPRedQLhvYZzmncswzH6pLEFXhU22CbYy2rZ+Mos8Twx00BZFl2c0oRwXRX0RT5Feifw/YzkQioz9Xzu6hXf6raHvqQCHVEZl+6lqIbP2E3Tn+/W/8Wee9vLKNdV8f2Dvu2b9qw4j7T9kbIxERcZDx+Q6Cx9G2veJvOWTd0pPuQeHagFHrddxccpKZXfYUmd+rmuk/+vd+30z/6LJ9OJF0xB3UGm44dKdjt1Wjbz+/lEN2MLPuPhBqHrc3c42BvZmaOOsgAf12W07yP33hW5x55xbsvvPCE/bBwdx32qEpV7500JmH62Rr0LLbNrVgH+KsnrfjZbbf7d7sp6btdP9Oe5OeuGLD7y8tu6UpJzt2BV1yoFP/j12P9jvsflhMuyUdKy/aU++fNk+b6dRRHrfj99nzjojIUy8cNdOTFbtcg7JdpqOz9oHQ4ifsgwkRkeIjNoFl47jdhrnP2oc75b9iH4rsmr+DHPTVsL3E2Px6MW+0Q8SWx0K8chGSfwhhIDFb7X6dmLi5aGKzkUBsIzfMlAQc5ndg6BkMo3CzwM1Wjht9bIC6lCVEuECBmzpcx30pXovlK4Cf44TdCxhKgQ1xF1BihAuMwg2v/n3rFPLja4j7Vw7VxFXQ4PO6qCfEPXcRhxGYnyafl0geDKHkYUamqZ+EMQ8LhPvjIGZCy8jN5gCScdsnEEoCCP4Qr9h2hlBwbCiW9Pq73n1WRER+48Pv0nKnAykCBp1qR9+d0ygzZY8nzuN5DNnu0Q2wD9h4d06f+QDEkHwuwxxDGvR7b5LPQb935omvFpQHGzCs43iQkGzrddwEJbsifRzQ5AB5Z8hH5SIPFECeifau36vvvwQ2voUFfed2pqJkdnxe3dloSAo3k/0pQPyHhOJjo5bV9MKTehDEUBc+9xKWHfl1XB+IjLLccOLgppqLlDlV0jHWnWK/1PT1+/V37IvcJPZBasl2HGDtnt5EmM5+7auZRZIQ4nAEfYiSmLlN3GcRIUP7tTK5DRzwhGFNiXCsdef1N30Qr/IAwQtArIl2aMEfwFBjljWE2D+n44oHdyQHzOA1yiUwiSfzq9HnxE17uhkdV4XlKNElZUE704kdmD+WL43D+pvmCcjSUk4Th0ulF7VOnTdqJbwrDE2IbtInn8fYxeEUD+RSGzxEiYamMOwmJLTF98bR6DhN4SCU4SO9qSAMKefhRBeSr34ZcyEIb7NYx7cP6N/zKxxbes+pF7VOwyIOSjPXJ2H/zdheWjPsqQOF2GKLLbbYYrtltocWB7HFFltsscUW2020PbRm2FMHCsNCIOuPXOudKl6wq/kjf+njznv9hz96r/0Hh6e+9blZu0z73N6ywAELdqEBKmdsb3nfdvpJv7oLo6DDQtKkMRs5oyfcKIH2Afte//cffYeZftcbL5npLhnNkRsxL0MHUWXQtdtwMGE/p4fuO+fM49yvnDLTF67YntP+e+3nkXnM9qI/8oGXnHlfOmx7dDefsvth5z/apIzDt7hnM6ekZM1GKIwO26E3mxP274OWjbIQEck7ogVyf3ot6aqIiPiOEJ6OG2GScABG6BEct5UP2YiKtEPqsZK220NEpPWIfa8Hj9ge+a9+9aSZPpltO/PIX3FM7w/a13SLdr3PvLLfTE++wY0wCdr2M/ccRWreYY+/7prdz0VE5l6xr+nYXf1Vsb3kbXg9WLKnHml6+ELSOnjzSRTGuTCNsAISyxHKHUrM4VVFz1m/EogPkOKwivAASJ3RI+2RbPEK4P2V6JyVXwUh5DKx3CgLPOejHD12OrjoMacHl3Jv9JwzLIEhDvTQtufplkZ581d15iTJ5/Rr+TmteL8Kz/cSyg4POkMa2D707opHuUEgGFAlIiPpfd6BUUc9ua1D8HY2o+lESOx7w4qIiLz4mTu0TQ4ASXElHaIb2H6E3hNNsv8LOl83DlNzUj8oUZlqQQJwvzYsvfrsOyS1C4m4GRVAL/VhQOaBTKH0c2IYJbvj80gB/RmSeDYDqVyKkixOnB2ijFECSNr4em7rbn1XMbRhBzofvY59YMBQlzrqhnbOLVMCM1rG4gKeD6D4yTC8B0SXl7shlJ2Sn1mEMvSqrEM0rGXz7qhEIj+HgLlTRpXSpGmUlaEMDG3gc2EIUohEYVgTPfboq9lNQPCzJJhE+tZA2nPR9xtDcdjfiSDozBFdAgQI0Ck+kB2lcyBEnLJDS/idz3vuq9pHmX/o7UebdCf1uWSBoOoARZMY6u/ZRxODHSLDEYkzUf8C1g1E1NCr3zoK7/6zedRB/87+ShJGlpWEiQMQRpLkkggVtrMfytXqDTk3sI8WV7Qu28eAmECfTfS9EPHRA7Em+6ngMxiT1WbYMecphodt3QmiWoZn1F89lONeWjO8eriO2GKLLbbYYosttthiiy222GKLbc/YnkIoeAPP9ModfJ/t+f71f/ftznulvs2Oa/eXbA8pT7fH7dyPObOQ1PIumpJW3g6H7sgR/x9Mu2O4g8T15e05Duy6x9yydbN/Ynsp195hcw+MHNwRLku6HcAiLbtru2Qgg5JdpicuuuPEj/yFRTN9+Ac2L8GoYCMtko4mfH7VJjkUEfG+aJPVeQ/ZpBadK7YX3c+7Sf0kYzdWetnuiMffsGamv9y1PdyZFff007jLhg+kavY1ZQeQhJJblrnGU+mi3Q8Hm3Ybpu2pQppD9xgbOaQpn7hg97fqC3bf6T3sbkNXuRzADAkq9l/SObuPpJ53oEVEpH+3jV4YTTvkL1+054pew53Hyp93ICQ2rm9uu6G2h7wNrwdLtYYy+fhaKKNHaTha6C2FlzK/SkZE/R09kpSu6yKNfuAAANT1SURBVOwjSSA89GmREeJ56eVPNKPyaSEpHLxjCXjNSgvR+ZeevOw2ZNSaOi7JhUAiSEpWtii/h3xGY7H99E6HKII080HZJ3D/WkpS29E5kd7eEpZWRHJkt/WzPad5lxZBpFdKRvIm2SK9o+QfoDwnvdD0JjOOmx5yenxH4E6YPa3vnuVnlQAnibbOXYHMZCqQ0mIURZJf0RdvsqeZtPfp5+TzcLuj+UcV/B3x8oNSFEnQOjAmYzgVnQRIGJdfRBz3EW2TEZBw+TUST6KuQJYQoVC5gNj+biDJDlEpei/2S1oS0oodSC2SHyMNxB9RnSwT2yJI02uM3wGZkOhG3zspeszZd9FnS3XmjzptoI4k2CtRGzII5TTJp0FkQr/EdgDCoEOCSTxzjJPOQb13DuuHIM8+Ae8zkLkDfGZXtVL5tehzya/rfRoHtY9MvaCN1JvCcwbqI7+iC00/m0RdUiFagd73NsgWyTnROI6xhn7Yn8aYhRQivfPtg/CsjxHHF8E9QURUKmwLLVNuS8ue2dI+3DoEyVnynwBVw+c7KFCfVT+GeS/sXwPOWUBGk4jcA/Ij2QCiCn0jjet8rFuJiilfic5XmW29D/lniEgJUV9omxHITFmnzkntuxwHjcPksUHZMW78bCDerBbC3wKBKVARLBNRP0RCEdFRPQOeDfTBYZGoFiJsXkUepj20ZthTBwqxxRZbbLHFdkss2Fvwxdhiiy222GKL7SbZHlsz7K0DBW/nlP1qyzqk1XgaZdnUb9mescYP1s30sx+yvZelilsGYXjOJgFwxXa7rHzRTvdPu+Or+2VH3iOH2sGW7SEtLLm9gY3vdLhI12xChqEjaN/FoTB0q2JKsmnfK+FwyCf22WgO78myM4/iIfuaNYfn+7u/44tm+m9+9SEzfeb3HOQYIvLBv2fzf7hQN9nvWjXT03VbHWE3Szdsb/L5L9nedQfQITw9tiy7ZTdi9X1LZnrjko2CSLmHgJMjonHCPp2+/4ELZvr5D99hpm923G2bLNgdsfBVu1O3DjoUKUbuKbznELioFmxoj+d4s3mOxxTsAm7J5uyx4TvYkyvvsdUq6p9yo3RSl+323b771qk8xPbasiCdkMF8RTJbOibSTXgh4ZUOPaxAlzUf0Pcm39GcQ7r7GL8d9aJK1pfkJpADnainjfMfvcLkb5g4r/2XzPET57Rsozxi+ZtknacnF569GfI+gIG/wPhrvT/5Cep3wgNZxCe8e+R0GE2i7ANK3nmhF23yRf1P8yDuTfAF2oOoiQo86eQfKKz00W5AMOxDvHQhOh9QtYCoifYBKlgkIvlRwu477ntWREQ+8fE3av7dqLrExDk/vC+fVX5tgHtDOhGKE4XlPvIG+oQKH5gAyVnRhEebPAGdWXo1iZrQfEYzmAPx3NvHkM8FoCbw3MldQa6L2SfJKQCPLtapme1hKJ+ZW4MKCVjp6fFuHmLMvF5Tvqz1J4M/Y/MTfaAB5qNzZZAHR0OL6Bb9XQ9KCoXFqGIFjdKYRCYQ2cPnXb6gFwxKaSktsJ2pNAHVjOkoMmfjPiJBMKaO6nNLQbI09FRTcQIcJVkgF9KNaFmpNFFc0ITOvD7/3Da91Ppc0i2gK7LgHZgGYgF9tTfhhWOLiBuiTLtApwxnIP3aibbjoKrtSyQ1ETfkHwg5QcAzkIfyxBBIiMIyOnaInCLiQZPLF3TB053VunWr+gdyOYQIlFwQIhLYjqMyEEkNoImA/EhxTEHNYYCtDvkzKpf0OvI3FFbRfrmoykxhTcvWQ9kKZ7Y0n7t1obJ9gpK7QGJB2r4NrofeNPUmkf9WQhIr+UgdenNAgmxG59rBGN8DuSSoIFJ+eRvto9d191//uji2PXagECRE+pVrdy+XfvOE+fuBQx5ORGTzQXsXNPHJqpnuPWzj1ifyblx+06H45tv7tXAgj1t2y04/OLHtzPty1t5t+L5j9+BIbhx1H8q8/ZB90vH0n77BTN88aA/ioSMUwneEeoi4N6uu08Bszn5+jaKj0UWk3rMPZdr32Pf62IffZqYnJxwSpe9wnyz94fK9Zjr1isfNdexTzLvDYlJJu1yDlt0mQ8cc7Lsyd58nhFrt43blFXvQFh15UxPZsp6D7+/I3Stm+lMvH7HzdtRvV9nIR+2+032vfWCZ/xP7cGmp5T50yjrml/Wa/fwmK/bpy9a2I+xgxk36OlqzrzlxctlMdxKv7hK9MHjYcWC5cgsXA3vI2/B6MG/oS3qzLeJzsYqNQpaSjdjI4s/cqIZhA+WofFsXG7T8rI6lfj8lQRKQbsCeEz2+z0DGhyGfxeKWUOHECMR3C/qCH02SjQzX97Bwz6cjZSREmPMxIcctkiSDEC4YgrhsApMtZCsFIRQhPDuxQ4LIKK4iwge8ACRmm1FpPR5y8JPt2q9w0wZo/nRUcrEzhw3ZLDaPa5S6BJR5StMP7tM2+YNndC2R60cPTwg9JyQ9W/PDTS+fFaU/UyxrS+/N9kz0QAZ3UhuScOl0Qz/rx7lJw2YGz56bcuLNKbXo9aJ9ieEHJN4rQMKO8onFRUgAQjoz0R9J6azC8gMcevAQirKbhHaT0JAb0TDsBZvEkNCQHyCv83Cgxj7KQ6jsBjaHaFcS7mXrvAE2n+FmHBtpEPTxgM5Pe2HoTuMgyBZRBzqIKGU5LIA0Ec82jYMEbsoZQpTigR0+w3c+ijZOBtivalkKSwiZQxlHBZJF6n2Kl9QZ2NkPqVSEDPWmvLCsfprhAvo9fIthbJEwkg8g7AthyEg0VILjIN3kIRPJBnHwgIPPUQlhAUWGOaEPIlyD4QV8f/IAtIfwkWHFl0SHcx0Kw6gU7gqHPEjDV4biIHwmt8Wy6c154EK5z+wWxlcr6nkY4qChfVIXYOyrvakoUWh/InpoSTJTyun2pkdhe6ZQl/wCxgWnHYy1PGRWC2sIhynyMAUHxtMY4xjzLnL6m2J7aM2wpw4UYosttthii+1WmCd7C74YW2yxxRZbbLHdHNtra4Y9daCQKQzkyH3XQqJXNmySvBBCY5nDU799yr6mULGRCKWMm7Sw7TgFc5H0la7Yv0/17DIldumpA5cTzwED9x09JUi583j892wkwtAhJ5no2TD30dAm1nMRLIrsEMdccy+H1GQ+beO3/dMO+IeIXL44Y6YXz9r1KC7Z9W4etBu9PeH2rl9+yob4p99oe223nrDlJGcfsr3xIiKphN3AzbZdj74jBKT4ou1m3s37XFyy867fY+ftQkfsFvLgyn/pMbttv+cDj5npH9t8xEw/u2y3uYhIMWs/2/kJx/PzbCRCren2xh/6il35Qz901kx/uWaXd1S3+7Ob7lIkM2nPh72hPZF0Pjxv32gXFJlrXrilFuyh1cHrwIJeX/yXz0vykI750bSGuJHgkHB3ki5SonlATx885qlNHSPlwwo36PXhOUz64h1Ul16/C+/8uk48KThIE/CcZ7ei76DiGb0XQxu8Abxn25o+mlUWvyA95vmmx2+aZHVIBwQ/W9TPXl3L4ZEssqLpozpl9gi1T0iKw5mEhoC2j5OXJbuaTvh4dllfxL19iooawXPKcA4/E4VRBylq90mkTiSYfuedZ0RE5NGXVLI5uQX0Bwj46PHNAqFIVIIXiBQu6XNI9ICmANIj0dbKdY9Pi4hIerOLvEHc1tZFQ+MQoOAkiiwSKj7mMQeJ7bCLPgRESBKEwkS1UC6SaA9K1pFoMdvQhWC6gfeq74vXBYqipM+us0/L5o2FqvYr9PbSK497V9CHAGtPTWtdh2tYGI0vRehZBzw+DU95eQEoGqApEiOgXghHX48iKQYVLW+6M5L1+8ZkBwGkJfqhvZ/tg7oA2RMU0M5E+AyiBJ4kbWRfZb9naDMRCuzDSbRv55CO+dyS9lVvUsvXPqSu8nRT883VkP1UaifcFkXpT0YhCgwbGBURQoKGSTVIUokxT6lQErKiLoVVyJ2ujL3D8X6hJz2N9m8cA/T/GmlYL1LO0NvvBeLjkbN/sk+wDgx14DNl2TLb6K8IrRoAJZHb0B8QceJzXiKKZiqHdITnTKJvFKOIEj/DkC3OX3jOHYbtYDy1EzLC/0fonySaLCxHw74yQBWRtLSwBDJHIGn8JGUmGUryKgog7qE1QywbGVtsscUWW2yxxRZbbLHFFltssV237SmEwmCYlMXNiWvS/co3cALk8O6Hp6RjlvrMtfmKiBQ+aJPhiexCvuhwTI8cXs1hzvbUVTNu9+xgwkHA5vD6Jxzh4LlV95lU+5hdwf/r3b9hpv+DR7/fvtHIrneisAsCo+S4xtHmrnj3zV08wPs/abf7yp+z5ewGFRse8c73Pm2mf+qpe5x5+3N2eVNftkkk2/c7JPZ2MRe6pu1ow9Jztsuf3pFxqzikHkVEDv31M2Z6Z8P2orea9vjLL7tRHl2bWkWmn7LL+5EDD5jpdz582Ux/ZcHtXnchKi68YnvqTz3eMtPPPOxgABWR2in7eVy6eNxMPzLjRuNYdu/DF5x/e/aZo2Z6drpmpm870Djdk24OmtsQn7Cn4IuvB/NyWfHuPBFKlw3L6n4muWB/v44heukYez6E/Gm2rHPkCCSrSaC69lUVaXRlbTJE+GQ2GVusN8uBcI1ewyFIF3OrOlcntoBQKKr30VtRUhR/VvmP2mOcQ2HcPKkWME/3Ke0MqdpeoHXKVjR9sqzrhPWt6LuDHt9MbccbWb5MngF40Z9TucbBIfXuJ7f0Xil4APtHFMVHr7+IvgOHOW0Teiu7QFP4IKlLNECMeEzb4kdOKzrsl598i7YFECEJeKmT24ylRltg6su0dngpyPfgbdONqWUJ8vgxxm4Hnun64ejymGVkuwwnRpHrMmjPfhtIlAIQH4v6nEKZPHhB8wAHkoiPEoH06LK8ibpWyhsMpXNC2znV1v5GPoJ0l7Hheq8m+JHppR+wrGgvHwSGwQA8GfkoisLP6ffSBSAZgEpMd6ITHPk5BEiQFLz+3hBkghPk99C/d2cy4f/J8UMyxnFpcnqqQ+lKoAA88mrkojwQyTFkAnkIyCNB3ofi86soOzlCQPp4EEiFZe3DQxCHDiAp2AtRHzve85A7AbwjMgnCyRG5EsifEa0j54BMjbH9qBtQy9l1feYhP8poXEIWSAe0L5E43akoJ0l7H1FGeO5A1yR6CfFLQKuAgJOIGZaRBLO8pgCEbcjxhsdC8kWSWaZqIOCc0nkrQFn7ZZI06AfRA5RLpZGvhRbOj0AE+diDpTdSkoBUKAlNySFChE5xGf0a/Cfc37B/pjqYz4og4AQHRX75+tfL36jtpTXDnjpQiC222GKLLbZbYoHsKYKl2GKLLbbYYovtJtkeWzPsqQOFYORJ35K0m7BRBWQItSy/aPu/gjfZnsLBu+wTLd+lTSc7HoVx42nauGWaDtb9vH2fWt/tXaeszTXmQig07a6SarnbMFWzr/kn//kvmuneQfs5uZj6RwU3iUJieGOieUYvumUj12y1R/mB018x0588eMhM/8Lv3W+m71I9+dAPfM5M/5WFd5npU5N2v50rOJjyRaQ1sD3cri4dOGaT7BtqZnpdqs68z9dsFZLWWRuJ4Dsc9cOiu3+OXGgjh1M8s2DLrzz04CUz/dzjtoymiMhbv9tGpZz5p7Z6ByWuxi25vEs/d1Q9/zlb5SH5vRtmeqphz4XPPnnMmbVrXnDxulTeY6s/9J50cCuIyKDimNedV9x8243XJbbbz4KEJ34hI4l2P/wuItKA/F7zcFQ9IPSiwiM5HOikd3K/ej0vbSpzeSjB6gWSXY1OjEQO0Ls89aLOwZ19+r5OLSlSKBhCju1IVUREcpfhIZ3R34WIBHgI6Z3OrWveDfA9BAMyzutHBhwK/bbOZytr8KADZcF4eSolJXtBKOFG5MYoB9b+SX0/ptai75EAvARkoR+UIZOH2OTGEcRXI06e3nuiEX1I2P3Y6S+LiMgvP/dmzWcBiBFUiUoA5XNQIQAYI1vX9Nwa6fMDGYIZX8o6p5DvoXFcG67ykgbz149VUSZBnaOcB91ZeD0xLwb7tK79JuQ3sVYadKF0gPtQKSGP51NaYFtG47ZZrgQ++wf0QabX2tKbghJBCUz3QHb58La358hN4eOT7nu6hb3IZ2ID7/ixebmwoPdLYllL5IcPFY/csq4nBlV9L6WaGD/kTIB3mmgE1q0zk5Ac+hL77wD9lIgDFoWs/j6Lhn6c7UT7Z/jux+8mLkCyEWOVPA+ZVS2zPwHVhjK4TLr6w84s+nS2iO/0rOt96CEXLwi5wxjDX7yk9W57kATF31NVbZf841QK0VsUV/xI+5BTpHQFiCcgE9gXWoe1TOQAoJIC2zDkGkFfIwKSyAQidobg+0g1kiGKgmiUZJeytLgGS47iApA5fX5qen4ZSAQoeBBdERDtBeR0az9kPIEQ4dgl6ov3o9xqF1KxefTBzl2aT+YCEEUtzkueFM6i/aq4F0G14+9hPLp0Qx8AxzxVaULURJ6cLphMvyw33fbSmmFPHSh4A0+yxqL/jl9cMH//ws/YpHoiIgMHRDz5tE2Oln9k3Uzv+25gbmJkL65dBw2plr2AHqXtx9jou1nvuKgYt8BBRumtOAgTHSSHIiKVe+0NyvCTdrtntuzNkeco02jKJlIU2Zmcxi1wbDw7Q/sPc19xj/bNv2QzP/7eL7/TTCf86pr0nN0Pho6DIhGR/372jWa6izxz64VpMz1zn7sNcyn7b4GjS3uOW/lfmDTTk7vMPvdM26FCn0/ZBw3pfXZ4z3DVLfuZmrHHePWn1sz0eq1qpv/6o7YcaLbtfn6fev5uMz39F+3TjNxjdj1y9rQjIjtSYONWv8ueR2YdJ0Wuw4FwE2CY64BnImO3+dK2Pa9OPePO486ffNFMf/Rxd6hQbLFdbd7Il+R2R3xukFOE4UYJ30hwyE1Ksg1ZNmwgXmof0D9gzA0Bkx610pLyogvpcKODBfgoB1KzdR37/qSO9cSWvl/yr+hc2D05h7Jhgd4kzB0HCuUoweFgHvBzhDoE2GRms1qp/hZe3khPrWobEI6dvHqoYgroQZ4w1cGGFWVPLulE1HuDHqJmENLAdwUl5WonNaFyUa+vnUrgfmj3WX2J/NRbPyUiIj/3xfdoWyAEYjA3iJSn+IqWh5sdtmkaa6VQjTaRCDdnlAj1UcYe2o2bYZL4Zbf1d2tvpISipudXIHvHkM4mJjv8PSS5a/OAAJB7vKJ4OEPJOhrLXnhOicVH+ybxO2zQjpal/Ioe3Gy9oYIy6jVbp6Kyjqw45+hkHbD2g/pQh+skc9Sfp0EWyM186Qo3rqg7qphtRzeN6XWtVG9fdMM7ygCKDknBzmFdi/rJnUOP+klsHJe4OWZD6IeX079nlyGFiPYcYr0UgNxy4uUoeSAlEzmWq1/V2IrOcaxDQLQaSlxmohKZfch0UooxmeVcALLTqWDHGVlkKAfGFsKaBmWs9eqA/VORFWSOBSwxeggDKK7iUGMuunDNbDPkJCpn6PnRNutNkoQUbTBGaBiGaPgMYwhC+UUe5DCsOQuSzB58Nyxbr6y/Ly7hh2jHLIgjAxAcNo9pXxjk7fUEw5F5CMDDqu4BhI2Vtc/4K9pYuTM51FHbtPoSw6R27sWQHB4I81CpV+Wz5IlLlFCS/Zskm5TnHDrCy2Pb3fbUgUJsscUWW2yx3TLbQ/DF2GKLLbbYYovtJtoeWjPcFgcKnuddEJGGiIxEZBgEwcOe502JyH8TkWMickFEPhQEwddkDbMQtc//tE3k5jlk8UREHj5sE61d+J27zPSlIw7kgkOOUOQquZTxctkORGkecMi3OUIkOgM3YVsmY5cr4/BKb844XP67WO4PbCSC74jEIDzrmt87emki7WgocXvRA8fBY9chZ7f+fS7mTBGvbbdJYp/jeTxse58Pzdrd+uKL+5x5y6Ltsc5v2RU8+u0XzPT1dtGZhe9oLJf3uTflmBlP2OEWqWfc6IHHP25D/+/+1gtm+pVtOxQicJCJioj4Dg9+b2T3hdY5O4/kwBG65FaMFa9jd9DZAzbqZbRiD5r2vDvkIdWx60do87g1+9c3xt/6NhshICLyxc/ZKIHVtoM0tG5DnVrf6h7jK0/YKI9bGvKwhxYHt7PdqDVDkErIYK501XfAqeH5pQcsCbRRfyq6ZkgU4U0bC7EbrqnLK7+SDD2A2U3Ca/G9BoRBWSdUksHRSHSYvqJIP0K3KQ1HSDEhs0QmhHKPQGsOJqNSjI1lHYOhJ5AEcnjR0uuZX8F9mn64xsiTsA7klYMSyBH367u+V9V7DPNYD6HKoSwepp76McDJJ4AWqOgfTh5XpsKf+/x79XLMk4S/kzSQHmJ6VflOSobf4T0FSWCi1pThfnj8y1H5uvIVbYe1N2oDpuHtbB6EdxivL4Y6dA6iPdP4JAqV7QhZw+xWNKyD7R9CviX6vfyKzv3dO/W9n9lU1212o4ffedI8oWUk2SSNMtmUYmQ7ENI9qOo8OtrCD9JEGugnETgVhI6M0Db5dXjet4D4SJH4E6EXM9qW+cuKnAgA1R9U9Dm1DlNfUW2U98I1GL3lfRCEj+DV9/r4QZN9Kdp32L9za0QsaHppMYpKKayAFHMK8o9AS5DsksggoioSJO5Ls452SMWw7O+QsyP0yUeZhgzxAMll5YrmwX7qjXWZ4sqY7GqPSCjcD6EtDIngOKIHnc83jT7aAwiDspT8DN9L+Ez0vLBemU2GyaCMQEFULkRfZkQBjUAey3v6QHh0pximwTAO/TuRttzXhCScnLewBM2sQ8KxhnCeaYSTLEDeFf2iPa+fpSuBdGfYTzFXAZnUr4AAtxb97qHSJIhMtyh3in6fiYZ7vBq2l9YMt5Ns5LuDIHgwCIKH8f1/EZFPBkFwSkQ+ie+xxRZbbLHFFlts8Zohtthiiy222G4Duy0QCg77HhH5Nvz/l0TkMyLyD3a7wBuJpCwHn8stXXd78J/5iO1hmxg4PGaOo5l6181j4Dscgk7aBc+BaHBwDPRaeTNdROT4jM1v4PLODuftQg2/ZMfHi4iMHNn3HrI91oUv2N5yl9Sjt2sMt/03V1t1B3a9cwW3i7vfs/uPS2JzsGn3hW87/YqZ/qtfPuDM24ViGdxnt+2FTxwz0/0H3KSMyaSN4Ek6uB1mn7R//77vfNxM/5XzNoGkiEi6Yeex8utHzfTC99i8Bw33EJfpiqOtHrPJM3MOBM0HPvhFM/0z//4tzrxbd9htVe84yBenHPwGbfcY2LrbgZzYtBulVrJREPRyjNuXLx1x5p10jIH1hj3Gk6v2ZEgSKcsKl+0x2zngvuamWiCh9zm2W2LXvWYYZRLSPJDd4U4o032Kv1NRkO+aMcI4qWu/zdTgRQNaaQQyvNxGEHoRE/DwhZ5UdF/yEUiK3k5KWEIe704lEQy9/zkS8Qk+4fFDkVJd/j3aF0mSnARfwYAx/igzydgKQCZQIjC7PZLupF7bndeXem8iGk89nNCGooe1M4P4bL7yyLlIcrixGO9TDypvwEvn9ouISGYt6p2mLF9uI4ogCQkTR1EvNmOpQ+I9zwvZ/XqTJIhkbDy8vnkvkk5vL8sa8jwATUGSwEQn+uzZjkQe5Dej/BsDyOVNP6fvn960lrG7X+dfesxJItmvgt8j7YXPfkcilHH9em9KJvb3wRsPSUC2P9c/ARJKF4AUITEink9qnJIIdUl2tBKUOKVk4GhC31uduSzug7Ya8/L3yzvtmQMXRWc/+AHQH0Oeknr0O9eBhQWS8gWRe2caJBeEBGNAroqoRCmRCr3Qo67XEZHCOPouALY+xj7X68lOQhK1KLcEJUTZ/qk2ByfKvAZOiqqWIUfPOXgJ6CnPbPVRZ82TCA/OS3zurf1RZEJ3FqgASmsOyYMSlVXknJHo73An5NfYjtF75jei79EAEwwRDOT2oI0TQ44jWXuoO/kKRhjb3J6Ru6WzL1oHrj+yNSK8JKwLZTfz6yAyHUS5FPwM+Uu0cEQqcGxy7iTSgeisjHtZfGNtj60ZbheEQiAif+x53lc8z/trSJsPgmAJ/18WEZPu2/O8v+Z53uOe5z0+6tgbhNhiiy222GK72eYF3/y/2L4uuyFrhmE3XjPEFltsscV2a2wvrRluF4TCO4MgWPA8b05EPu55XiQ4NwiCwPPsZguC4BdE5BdERIozhwPG0lxtzXsd3updZCNbb7Dj3b232yzlsmTHBje33SiBpCPm3MWWzxPycXPFrvc23HknZu1r9hfqZvr5BYcixiG3NzDZtM+r/CW7XM6Yb8exl8uDLuJGfwwrduMO2zZ6IHHB3YaSscvbn7fz8Dp2RR5dv8NM/64PfMmZ9W9/+WEzPXnF9jIX32bLAawv29wfIuJE9qRn7Hq7OCJ+5QW7rPRUXEfWYaznuO1z8KHwtNu8xsEX4pIjLd9vo3pcSISEmz5FUlv21Nsr2+lpB9VFyRawERGR/qxd96mDNTN9a9PmtCiu2g+jk3DL0mYcc1X/op2HP2dDGspPuxFejXvta1z8FK+K3eKXu+d5/1xE/pyI9EXkrIj8eBAEtVtaqJtjN2TNUJg7HPQmvKs8WvobMpDTO0lvWhpeU8rCkc2dnnbypuTWd7zU2S1qTuoHZQIZa9ydwphHaXv4zjj20GMO5QkiG8L3IlET4IShl40jMLuWjNSFaAsy++cwrWW3GG8Njzw8t8N8QlK9KA9DBrKM3Wl4f5NRhAe9lPRKEq3I+HcWzj+i66lzX1S0UyJknAdaAl7LxJiXehyhN66cwXI2D0NqLpkLPaj08vM3g2l42QEOG/esjveizBJ4Iwb0vhONEkUm5DaJbAgi6fSktw5po6TgPWXZW/v0/hmgC7rVHZRBbwpeW0y9lDIM49HxOk+ts4zRstMLPBhbrhaXgsjvKVFOdQEalRG6QCKQB2xwXBuPsf1893Xmx9A0mSAsK5EJybF1UaYe7UNUGyHqLQNUSnFRE9rzUBTBbShRSolTjifaAKiA7gR5PJKR/FoHUQeMZR+vLPaDUToIf5tdh9wj0HKsJ7kn6AHnMy5DOpGKbfSoh0oTQCdxTgj7Kox9k8oIobc/x/kJdeHvwzUq25T9xZP8GsqG/pnEmKZ6DFVIspsD3FvbmzKREkpeQt5xlqomRClF58Qu1o0DoChSVB5BX+lX0TZtciZoepaopHoUkVJY869BJOxMhminpubFeYoynVR3COWAKQCDcdFw8YHdDLuNDgS+WbstEApBECzgc1VEPiwibxaRFc/z9ouI4NPWkYsttthiiy222EREPi4ibwiC4H4ReVlE/uEtLs9NsXjNEFtsscUWW2y3j91yhILneUURSQRB0MD/3yci/0REPioiPyoi/yc+P/K17jUsBrL25mu9ckmHNzDRcyMURoHt4u661BHWba9Yf9qZhdMTGqTsIyuyqV6Tnrd/n95ye+pKaZuCfuiAA2TyNpFBr+3uQqm23b6FZccF13lSN+y76+fP2uX1HMz+o237ed/99gvOPJ578bCZvu/Qppl+vGKnf+HpU2b6xZodyy8i4h20n9+73vi8mf4nf3qfmb6bL3dUsj3c9IqM2y+/9T+b6f/04neZ6S/sUr/yC3bJmu+yEULVnJ2+OmujJkREskl7LJfP2XlvdG21mBM/YCvCbPyq3T9EREZFe+ynX7GhCK42dyE59GZ2HlMFu622Ljn4UBx5+Dn3gO1P2nm75ryUg0OhcZdbZWX/J+y5Z/kdt+bI35NbDz8MguCPr/r6RRH54K0qy82yG7lmCJIig4oXeqiIgCLyIMiC5X5F+xpRAEQ35pcRAw3uJnrKqeDgp72QQyG7HfVK0gNIBYXOHDgTEPfbhTeaaIkcjkcG8EoS4UVUxaCi9y+f1bIyLt7DEEr16S3V7+kW448RXwwmecamJ/g58MXPwoufpW57FDVBT2wYK18lCgLfoebA9jn8gEamLHwlyhOUg8e3ckF/3zii3wuLUY9vYVUf2KAIxAjamPxTGXjWe/BC+0kvXO2yXek5HWLK7cyxjFEvO+PguV4cVPA78BEwPp2/pyeV3tCQ3wHtybYbj/lvHspE6pxfiU68g7InnbnoBEMkB+PeGW9OLgSWje+JdCOI1HH6OShIUL0hH+0DTE8AodI+mENdUZccOQGiCiSd2WjZ+T5IXKWIlFuN8jsMoPbAdkxvRlETzCNUDgGfQ6YJRv91fdf7GagEQJmsOwkUwaLeuDWXQluhzkB7sG+S/2Q4GUXLhLxORZFUK/rM2R68B9UYgrH1Zm4VZQRfyrBILgqikTB2MRZZ17CsGPs7CKlovuyr6Xa0biHKA304tx6EZeR8kxhDCGdqQHhMYlB7+tmtRvtIr0pCAkEdoqgiloFKI5nNKCKEa5sy+Dx6VU0nCmP8+fN5pjp+OMZoiT4y9bQdyZPBvNpzQGuhSomxeX/kBkTeFLsd1gw30m75gYJonOOHPSUcTInIrwZB8Iee5z0mIr/hed5PiMhFEfnQ17pRbnUk9/yb2jXpft4mITvzg26497e97Vkz/Usfvt9Md3WKIL3LpvewvdmhjNM16Q4ZyNJBO0wh+YJjgyAi3aF9r9bQIYXo2IhXn9vtQMG+ZvMNdvrEy3a9XW3r7YKvSWbtzXC+YG/EOxt2X6j33Poxx+5Yse/1S/vN9C+8a8ou04LdhsEuhImjBXvj2RnZz7V8wW7b1mH3bJZetsvVPWpDzf/y537CTM8/6wgbOe6OCWjvt8ubeNmut7/P0Xcc/VZkF3nIg45rDtob8YU/tskJiw45VxGRiUPbZnr/it1HBvfbsd6JF3cJa2rY9Tv77EEzPcg4wkbm7XRXHUREgk/Y9eg5yCWTD9j3Gi24pUXXvttxWLTxKq8KaEFwuxEs/RVRGcW9ZjdszSC+Qmv7E/p1UI32da9L6UCdXwgN7+LVGobpYfqZOK+rX268k51RuNntzOh4JCEbIde8tnJJr12/T9/BJBwcIIxg+zTJHLWMuQWEGxSjG1zKsBGKz3AMHnrwIKG4ovMvSdZymzqvJ5v62ToKicJaX/oZLVOvomVuHo6GXxSvAK6PzXpvTss6wMbIL2tef+a+F0RE5NM44Ob0TOcDNw/1o3rd1IvYhNT1+v4EDnbQZoVlfZ/XAblnG3CjxhCMxHAHjs7wixA2/iZ9z2aeA94Z9+aBzRAH60kcKvHQg/crXYludLlJmXi+JiIijVMTqCMZ+ngIol8Jx+ZmnAc+Ixw88H3kZ3xJIYyUZctoFtI8oZkWzxN6jw0Sli8kK2fZuDbjgUGyxwMYbM4Bc++hbITB9yC3F5JfMrQF6QzJoF+Kfa4DKe1RKpBEF6EGOGSovqjXtEE6Xr7Iwzi9NgdywJCsssBNOCDzfYbyoG8e0UpTMrC0oIXl+KNsITe8DAsYVKJweZnRvjUCmXb1ZQmvD0MeatFr8ghvIsliKF8KskVKVXJ+6E5GD1UIxWfd2Y48oOPhBje+/D6c1DqO0P9H6GOVMyS2xFyA5W9+cyTZdYQwTGhmlP4cTuoAGRTY3/V3HGM8mGnjYGb8MIWHIxzLraPRg4SQ6DYdvS7J0CA4YQP0B8q4dma0LjywSwz8MDQkU4csaoHStyyD/rZNwk08rzbWi2EYxrTWiaGoKUdk+w2322/N8E3ZLT9QCILgnIg8YKRviMh7X/0SxRZbbLHFFtstsxnP866WRvkFxP2LiIjneZ8QkX3GdT8dBMFH8JufFpGhiPzKTS3pLbB4zRBbbLHFFltst5fd8gOFG2nd2ZS8+Dev9coHLgnBvpvU71NP3mumJxzeOhIcXZNed2OSk0Xbw5ZyEMz1ivbjcuWQ23DXrzGwvXiDkY2ocPBbSXeXkA7fdtSLX7TRA0HS9q47nO5OJIeIyPys7fFs92wERtIRnpF0PAsRkYX1qpk+fJvdVrOfs59f3wGUSeZsNIWISLdkP7+nP2rLnSYdJJWZLXcbuqQp8xW73/743V8w0//DwvvM9Mo+NwKjMbQb5eSv2W3SfptdwWzWDZnvDR3jyVHvYcvuiG0HMWm25obQ1DZsz/v8ZQdK4C02KmRQcBMjyoz9nO7YbxN0uuQyXRKQ/S/aKAQRkcEBewyUL9i/TzxiP6fKo+7+2Zmx6z73bz9vpl903unG2Q2CL64HQWAzmYpIEAR/ZtcyeN6Pich3ich7g2APuT9uggVJJahLAQDUr2hnDyivh7C63iRg6nitkHCPcPbcJryobfV0Zbbg8Z3OSf6Mjjc/g5ApPJHtO/WzsKz3rh/V+aXxBsxxPbyLx1BWHjy8A4QRkCgyJDzktINPevm5UEhCpjK7ofNDaqWm9zug49nrReezxvG81E4BZox2ohedhNCb36JlTi7jvYSBkDuqc/yP3aXSuj//xXdr0Ui4B0h+flV/X1qCLCGJK+GVTm9yLlMvKcME/DQlG/WvJAmka5feaA1tQYgBmxfPtLeNe+LvDEfLLVNmEyR/eF3x/VCAtzMLMjsiPUgGOJjW+SkHbz//Tq/1ACiKLKDlK2+GB7am9+8iBCOYQp/sJsXbD8j8UH/bAmFjEpKgRCSQfJFIgiz6K+Xz+JnZ0sZItIFOAbw9vakPeFhQ1MYwr/cvItRk+xhd6PpRe0DvV1hEmA68/e0DqANQHpml9A66Yhv9GK/CynkibdB3tsbIAdFf/bT2MZIE9g9rO4/6WkaGFtWP6vfGMb0/STNbp/U+ySVIXOajoRZ8/ol1/XsAdE0Ddc5uiaTgJae3nIiE/JIOkERT23U4pXChIMV+CrlIoAKIcBqgjkSOMMSBf2fYE0kVfY51Tg2Yr1I1Sl9i/DD0glMJ6pjsBpLeUjc8vfpBlkgZIAnynEgwDhDi0AcaheSvHGOcEzrzDPlBEfOoM+axZDOK+spsR5EITC+PrYUmzuhz601rxqNcQgrL2geah/RZFfG9X2IIFkKklkGEegDoGCA+GIKZXUa4WY7t/+q9NvdSyMNtQcoYW2yxxRZbbK95C27Av2/CPM/7gIj8v0Xku4MgGFeTjy222GKLLbbYbhe79WuGf+553oue5z3ted6HPc+rXvW3f+h53hnP817yPO/9X+teewqhIMFOTNHVNso5vMwT7hju2U/bHuD1hxySchfsp9qvuD1skw5yNN/BtDb07fOfksOTPUy7895s2d69hMMj367ZsdrVNWcWMiw66nHUId1YtD3ALuK5YOg+Dxs52iqfsT2ho5YjBv+f20R8IiIThxyICkcI9/q7HYgDRwXdDBgi9526YqafuXDCTK9cdDzXWXcbhhJcY5bJ2i7r//hhG4kwOGT/PuN4RiIimQ0bKXPpfXa/zbbttnWPAJHtjs2PMay4pSbNvB1lJbmQZfnzDhJCB49jr2WXNTfprqFrfCz/kZ1JxvE2aB+2x2uy4kZ/5J65PmnYat7e+555qxsFkXBwVMw5r7j5dht4G/6NiGRFpRRFRL4YBMHfuLVFun0tyPnSu7MjQZ1SaPDsrun3MBa8QY85vXTwfEGmmkRk+fMaND6a1Hkq1RyIZCDhB0TkoMQ4dXjm4OUM35cBSdIQT831S07nJQ8ePr42upApZowy4+XzoPiht79yXscY47jpCR7NIsa/pn/v7ytH/p7s7XgbQ9JFEOjRu5svwSPb15ef19Oyf98dT4uIyC++9FatU13zLiyBR4BT1Ng0Rg868x2V9Hlkl7VywwmdD/tVxFBDHq5ficZQ05ObbnjSPRKNM+dCvDit9Q7Oazu0p3Re62IiyYJwOwdOZZLZkVeAiIQd6VHwZ7Sj82Z/UutAr2kaZd66Ex7Xgn7Pv0xpUv3s4HmJt7N3yJ7V+hN14efx2SXHAfrjGlEZUU96uqFl45prNKXPLbuhdW+C94FolvYs21XzJ68DuS988O80T+C5gXyR6OD0CvLJBlK8DCRGg975KKcB2zUkM92KtmP+Qk3LDu8/USzbx7VwfMeE6IytMUJDIH9G+0FI2SKvgf6dhJXZTfBCzAA1A09+8YpIrsZ+BQlEEET2ZiAFCt42EkRmNrSPrb+pqteNSYnuePnBFwDOiSHIYRMhDwrmhLxWrnAR+aSj44kolxCVhOURn3+m1pNRWSucGENqZzf1x0Q+bZ/UuYxzXn4TfQKSoCEhKLlb0F35PDPgemGf5JyRg2wlUR7tOSATLqGM6AfZmvbJIRDa4Xvfk5B/gPNF/QjQK+CJIYFj7S700yTblTqz+tHDHEopy1fTboM1w8dF5B8GQTD0PO//ElWG+gee590rIj8oIqdF5ICIfMLzvDuDIHAukPfWgUJsscUWW2yxvU4tCIKTt7oMscUWW2yxxRbb7W+7KEN9j4j8ehAEPRE573neGVF5Zju2WfbYgUIyN5Lyydo16a2O7Q2c+GObMV5EpPu9195HRCT3uO03HpeHCcvUcx8/VbIOlQeHx/pNM7Y83eeXj5vp2aY7/n/D4fF0wgEcyRPfu+jMY/VPDpjpLs/p0EFYz7ixa4rUdp8mHirXzPStnu3hbjma6vg/edGZh0t28A8//6CZ7m3Y/TCYsj29/h/OOPN+9h67H37X9z5mpn/uP9gh2TzJvR4rOhAKPQfKY+CQFp0/7OZQSHzKbquFb7U7ScvRn+/Y54bQvHJ53v6DQ+1gcs4ub++8TSTiO7g/RES6p+yxX63aag4PTK+a6V89e7czj+KEjYA6/B1LZvrl3z9mpqe27XFWOmCry4iIbO+3YTrzj9l9/eXzFsegiBTcaJGpgzZPyis/9xb7gp/8Tee9bogFIuLfendDbNdhw4QEm1kJgLYpY8x0VrT/Mr6X6g5ZSP0V1hDz/zzG5Qgs41PK/ZK6rLwJwXAo7YeP6v/BWk7EAD1z5FII1wqYflIH1Ks5WNM5rzyp3+sIOieXQqJPRQnGDev19AAnwYLfn4CXH7HoHuK5PaC7/JLmQ2QC47qTvSDkOKAndQgJOA+eUh9os9S9Oif85N2PiojIv/zkB7TuWSocAKUBb2dxgXXXz5AtH4zz3tKGfhZ0fu+enENdNV96iOtHtW6U/6SXlMz9w7yI18E8hpj4yWnNY/NyVdvlQf0+8agiNEJZO7xaqJoR0NsLZEIKqhjeEJ51PGe/wLhsSNUBNTECQqEzpemU1csv6vet00QdRLkvEsWBBCs51AeeWfAQUKmgsAQkDZ55+aIWljH7oeTitvbz9hH0V8hsDspQQgA3QyoXVbSgigN5PYhUSQE1E6L76CkHeq8/if4y8qR5TP8/+Zz+qHpuGM0T/BipOlQWgE6hJ5fIBC8gSkJ/n27p9YyTD9E0lSiahm2QuQCUyzTkXEO0BfoMuB4KT+u4qJ4BCqbshcvkHKQqu3N6r9xiO1L/ZEfnlfZh7VN5cKts3pWKtB/5OdpYMpPbipKmwby2RS8PFAY4M9hHGfNPmVDyenBOIWKn8sKW/n6qIOkVHasJ3HM0xss1qGg6ZW27c7w3ypRmmYEIwat9BO9/Doojvcno32mhNCnacu6rUZQp0RZE/lC5haoe+ZWONI5H93AZLOQpbUlJXY4XWuUl9HPIsIZSsJR+bb5KbAA3bs2wK5HzddjVylAHRQ8YaFeQ5rQ9daBQSXflzxx+6Zr0z/zcW83fb59y3+tvnbIPYX6u8W4zvXeXfZ/JP3HLDmYS7pALyy407Y3LTMHehDR9N2h+VLc3bC5LlOyNwCMzbqqzJ99jbwb6/7fN1rjwLseu3nHIQV1oyza79mFRKWND4zccj2KhPeHM46Uz9oHJ7BN2uTI/aMtMrjxpb2wLf27ZmXfmV+1rPvvyI2Z65z1NM736MfehmstyKbsvzH3VPmhof2vNTD9W2nTm8Sd/3Ya6FwtbZnpnuWyml484pAVFSa4sO3nK3nBvOMKEiu+wDy02X3AzlhbLdrmabXsj/pWOHaYQ7HJokXBg6XJJd6iCZaOSPS4LjoMlEZGa41CGclnj5rXt9Oym+9CwfcFx4Hbg+kJWbqjF5wmvKcvkBnLknmW5eEn7UvsM5nscYlNykXBf7hSqKxi/PRDmtfQd7JVBwlbBpqfblz5CHEjgyHsxTIJw8dQJvMc3dc1QzOu7qubphqZRQxgF3sWjHmDq61EpvxzCMArL+jtCxwUb3SRJGA/p/JTqQiJwvhApF237eDJcmLN/c0HeOAbyQ8DGf+0D/05ERH7iib8sIldveEk6B5h0SHCIzcH6KJJ3f1bbL4uycZOeahH+nI5cX1jFwcIRhEA0os/PG4rk7tB3IOetOg6hPRxa9le0/gm8SgjZDiUSMUWR+I1zWWYV8yDK6Pkgd8SGLL2tz3H7uN44V9O/d2b19+0jmlH5ZRw8VCHnCdnf1Jxu/v3A24FsQ940vwa4PkMMMF2WlvQelADN9RDiUMbmfEEPwtJTqHMfpKJd1lXv1zjETb6mUwIw1SD0HhvXFg6fGqjDHEJgQILNMILMVkIK8EEN83w2OJxbgFzpfr1mohZdqyWaWoghQnKaB/V3OWzS0yQbxWa8juhPHiz4ONRK5ECaWUbo0ap+dvdren4xKk3K50/p0sQgGZa9fUDHJg+2Eg09UOiemMa927gGG10c2DBMgONhgD43Qnu2y+i/OOhMZ1DmZe2zPDjoHNM2K5zRtihd4SadYST6vYfyDjCuUrWuDGc0Ux4urT+gfWH6WRyS4MCLISkkI6W0ZW8KMrY4gOHhkYew8zAsCuuHFA700tscJxj7IN9s7dcHVTmv5WGfZOhPAYeIfmpnrVBY1LL2q5lImbsz0TAXEnL20a7jhyDhe5shbvaW6ubYjVkz7Erk/GopQ+2pA4XYYosttthiu1V2G8RDxhZbbLHFFltsrwF7NdYM36Ay1IKIXO3JOoQ0p+2pA4V+kJTLnWu98snvtz2IyS+56bt+5V98h5mesqMLxHcQ8d1I6wxtd+Sx8oaZ/uLIloET2ZGXGTfPARIYOHr9Sw0HbFxEzj1to2Om/4Zd3tHl3WgIrzWSVlnmQiK42tBlrzztYMkTkdIVO//CD9thIJdetNvKO2h7q9eecLft4NtsLzMJcK75/aodKuCKcBFx9wWXXf4xG+Yx8WGb2PK573Pfa+qP7fJu3mcjflx+7KZDHlVkx5sybi75RO+YfWw92LLLlJh3y35O/WdbNnLpbXaZTr39gpn+XMuNNBqs2Xk87UBBuKILPIPoVkRkabXqzDvtmF9G2evrVN4b3GEV7VUbMXLn3/qyme7GUsX2erWBn5DVeikMnxsBsl04Dwk1TEPltej7jx73oIQ+WC3jeh1bScC1B0emJAdSOc61/gHNi8RrSSDtehjLx06o93i9CW/itHrshl145S9ooQJ4CCl1lscyp18F8mEZyIUeidgguzeh80KyAVI6wqjhARyUooSUyb5I8w56vFF2EkUifODvP/IJERH5oT/8myIikpvVMjMEotPUdpn4U/2kh5dIgkxD32epK1ombwnSthOQLZzRMofkcySknANcmyqGWNFuQfWbUGfPF6mAkHltSVEoxSktY3BZ7zGYhEwh4eMg4syAgK9yESEODfUKpwIS60FGrxKdV0P5vSyI+Zog3JuKwrHTkBeu3wfpxg0Q7dHLv67vlyDrSwlhgsMnqyKyI8tYPk98uEQ+Ez2t8wCIGZJaehMa6kAYuQ9yy1TTRnq0DiBE5ZL+vnkM7/oUCUWBqkgwLATzP0MxriCf9E6Ix8R5kh2in8KbXjkXDRtIsF9Og4QRKJXcFsIpStFQB5Ir0vs8PIbQP8h/Eh3ICE0S96WXSZqJMmMZ18ISsHYSiJNWEMrE5tawdgMqZTivfYtynCRl7FV3iDX1u35SapHIEiJ6+DsfJIFcWfmQtBwibLj4CsqE1yRJMyuXgeSB9GNhDQgKSMKOihlJELUCAtnqWSCVprX/ZRA20TyEvoHlD2UhQwJ8ELAybIBEnFw/ls7vPHuRnbGbwmNhCAOBB6kNzWiwL4o6ZdlJbiqyg2jqTkTHFNuVfYFhF4MZENiuANlDUtklyK/2or9/PdhVylDvGlOG+qiI/KrneT8rSsp4SkTsxRVsTx0oxBZbbLHFFtsts+D1sxCJLbbYYosttti+Cbv1awZTGSoIguc8z/sNEXle9Ezrb++m8CCyxw4UOls5ef63ryUpYyzPuPX2uzkMJt5ix3dP/oodt7vyXvte/jm3R7w7uj5veTppP8unN+xYfq/o9uBna7bXMXBeYneVlx51QDZEJOPwbHY+bXusEw/YJHIJBylj0uF1FxFpDWzPbbNne2dd3vjdeBpcpHuLX7U5IoJJu4+kL9kebnpILPvQd3zJTP/o1BvM9MTAfn5+2vZii7jbpOtAebzxiE0a+uz77faY2AXrlXEQipbP2p7vriOcfqVhcyuIiKQdJJKZB22ehpbDs1+8YLft8CG7P4uILL/FIVlZtuvtImotT7mD/Vy9p//k9SGB0ofsPKYr7rzXs3a/8r9qj9mj99h8IZdX3bKRJAIbt1tGyihxyMNrzYJhQjq1nCQRgy59SDKia1EqsLgMEsA6vMj1qHff6+Pvy0oU6oNEMPC8MB59+1hUei/0nqPPpOAhvTDS92OmpHkNapgr+B7EO7pwEbHe+O6jzIVlEoyBSHIV4xSe9ICykd3o+8hPRr3/jMOWQCQD6USSHKZm1DP7juPnRETkXz6miFpvgPjqNt4RNXhQ8S5rHYL03Aq8nCN6+YHSgOxeOqfhvgmUMX1FUY2949o27X0gPExHuQO6M1HuhMG8el0TmynZ2NQ5KV/VsreBmgj2w+N9JeqhJhcFLdWE15ckgSBhTIHckp50cifkL6vbePONOoeNc1PQwn4AlAzfuwH6omQpxZiQ3ktAVwCNUrqMWHF4/UtLUc+5X9Q6poBOGVbQL8mdQAk+fOzwEsA7fZjeZzwnTrkkjERnId8DoYJcN/E5hHwEA5Hy5SjZZOmSOkV7kK5MLdc0zwOTuBcQPml95vUjWgeS+rXnUEa8ckimGCJMXtY+1ZvVfBuLWBMAXZG/RPJMetbB8wEJx/IFVHkDfBEd4x3ts95aVvbjEHnQorQlJSr13vSo96f40PFBLz/X0PTe16ML9NxaFA1AAkXyexQWsQbBppV9N9keyKCq7dieT6O+4P7AmOrO6z2I0upPUM4TeXUoG4nfow8m2lGSWM53+TWOdYnkR3LN/IqOr/p9yj+RqQ0jdWvcAUlacmv6Ii2UkQhx9jOSVBKB4M9i3l7VH/YPaF7JrVTk+gx4nnObu0B3b7Dd6jXDbspQQRD8UxH5p1/vvV4lKsvYYosttthiiy222GKLLbbYYottL9meQiikW77Mf6l9TfrKm+1Y20OfdiMULr7f9qLLfY4Leg4pxIL7pKves72UI4c30nWn5UXb4zibc+eduraZRGRHHmjcelP2MdqhT7sRMIXztqzblX/mkKFz3Gfk2207SLgRCsFu5ADWvRyZj/a74+C7aRsFQQbeawtlpxfeYHvED/yPbg93+ofsdu++UDXTXWiD3fqn65qttt3uLpnQzkm7DY9M2fUWETn7sP3ME0O7H5LZedy2t+2xLyKSdzxa75P2eKp27Lw3HrH5LCoZ9/wybNvl7e+zn+vCtq02kk25xx89ctfYCZuzI/GCPR/1anb65vNu9Ef/iK0A4afteruQQ/7Q3T9/9P1/Yqb/0me/xXnNTbVAYpWH15r5niSaKUm2KU1GKTr9M72g9EaTrX0wo/NKelN/2J/TsZYCo3/3AOadYCdGnF74LGLyO+DcHgG5ll1DLD+onUZXqCdI9yNuSdEGJNPDxRj94hLj5vUCSgPmFxSpMAJCIQkEQmdf1JvKuOvupBfeP4FxyHn2Zz7wURER+Udf/W69CB7q8gXwAUAWLwUvZXYz6knPbhNJgBh9MPsXl4DKgJd/OI+555i2L+OtiZ7oQMqOXs9MDcU5rfdJr1ANQiR9Ru/Vm8J7OxlFiAyADiufRXz6yjDSHsNSGmWGIgJiunv7WDY+EP1oH9M5uzMDb/Gq/r12CooXY9OwNwX5ycuoM5QRyPUTJINweiG3QXdqjIsCXt36Hco3UFjRe3anteELS+ifM9G1S7pF2Ui0ay7arvykZ10Qw58soO8ilr99DFwY6A/5VTL662W9qkh7Xusz+xXtj+QZCFLIM02vMVQBFhQmtP4m5TYqLQCxkNzpn3oBPsPniT6GPpiE55xSsP0q2nA/nmeDf9frm0DTFCAZmwrbKCmFhS7+D7SKT8QBEDqQwKQHvQjUEPs/PeD1u7W9MqtaZ/J4kIOI46Z5AgoHlIRFHSiT2DgCHghwKZQvAplT0zYOskAKYR4blrOSWde5qzOr/ZRolfY0eR840TBPIkGiaBXuGbIrUYRNFu3IMqewfiL6lO3ZndEfcH7qn9D+n8XysDOrf6faRqjakfKucYmTM6E/F+V8IacHJegTkN3MbkS5R1KYj7Ir10kg9o3aHlsz7KkDhd5kQs79BWPx69gZfcuPftFMFxFZ+a/fZqanHHu89tBBQuZWjXRuzFxyb/V1W+IvvW5D0MMJwTBqYI+bK+ShN23fa+XH3LJ83U17E+TV7OdxYJ+9wXS1x9rAvr+IyMJ61UyfnLBh2oS7XfP7z7lJ/Wp32ddQW3vcSpfsPtI6YMO6a//OLRv58f/d3jTd+ZMXzPTLH7FDU9whLu6+O3SET5x63zkz/cUv2HlfLLnh7Pk1R0iOo0snHYcD+aL7QCjdtCvYOmg/11HeTn/PAy+Y6Ws9dzjJi5Wqmc4F2rg1z9t9/fSbLjjzmHbIyV7++FEz3TlX+XajFxfcb8LBnXY9BgV7rur27fTcGfcE+v8kHaENt8g82YFvxvbasMRAJL+cCBeixQVsPjBtFJd10ds6wI2DpnPzMwKkPA1IefOEHrIx/GBQSISbiOaRYOwe+pkFkW4fmwkZez2mt3mSgDItat6pFjYxGDr5NR1z4QJ9rY+yIJxgLo+6aQb9AjYxCI2kPFy4UcB9+9VABke0QR4+odSm//jXfkhERIYoMwnahhiuhUupSJn5nildxuasw7bAAn6bcoRa5s4+bbTcOg4YSpCpPExmN9xvQfPfuochE7j/Gg4SIMXZ385KCpsIwslzi9ENECX3+phq2S6Uy+OBAcd4Zx7tiQMGEhy25lOR+/IAqY3N5QiQfM63Och+tnEAxFVCootNO/riKC8y8xTKWAHcHIdI3AgNC7gHDl5IDJkFMegoFw3pYR/ZvBuFGet73HTzvZsBgWQPbZhc1es6d2khk1iLphBuMMCSNQOZ0JlnRzsbyTmEnKB/Ep4/nKugjtqOzW9Rcu/JF/TvK29huIagzmgfruHQ1wYVSmHqfYb4PpzBc2xpI+RBGFlc5HjSz+oZrVP9aHQNmKmPJIGNOY/zuyAyZLvz2TNsgodKIUkgHHTpTS1b/yAOFhbTkesZrl08D7lJqH+HxJNwsFQuIBwhwetAKlucxv2iz9HPJKR1APD/Ep4V5oP+hBfJO4mxTdJFHtCEIb9YnycG0QMeOukmzkYlYfm8e5M42MShbX9ax1PlkrZ7Z1bn3PGwKB5IrD2YCuvDduHhR/klLVzjpPb7wgUQnTIyB/4OhmNwX0cHW+C9OuD9vbZm2FMHCrHFFltsscV2y+xVcmzEFltsscUWW2yvcdtDa4bXxYECT9TG7dMrdzqvcXnrslsOz/5J2xvYv2CjCkRE/OZ1ak2OXFB6O7lfcd+qsGpf5JQKdLiGp8tuYraFph0ScP/xK2a6S9Kx7zvQHw6PsYjIqG9fs75mN4pXsO+VdldPqqds4k7/nM0QWL/H2bhm6uKSmzwvd69DKPHfHLHzfr9DZnLVPQV4DjR9r27325d8W4Z1MG17qzNJ90zqCrGZeMX+/cjuajIa7UJMOrDzoJdy3OqP2GiHc41pM/2EQ85VRORZB/ni/ilbJrH+hB26kXnYHVbx7NM2EuH7Pmgjsz76Sdvjn5m0UUj1E7vMbQO73Sk/dk0eCbs9+kX3GJ/+hD1JT/7iF8z0i847xfa6tUA9wLNPqMuK8m709LX2wYuNubAzp+8oQsl70zoXZkBy3K0CHp+jl08kQQ46ygzSeV9FaIJP7yY8fyCLIzKI9+a7iGECuW0dM8Xz6p4jAmGHmAxezYbOEX140LvTmk6vKT2NJF8jtLgH77SfC+QH73tcRER+/ZmHRUSEyPd0HfWcQSVBcpbbgGcWIQlDzM+F53Hz0FOKv2dZFp3nhjmgJooIUwDaclCKIiFGYyBPnwVjGyNsJNPxQjg5odksY3IsOovozdwG2m0C8OgVbefBVHQuHsCTPshHER7teTw/TOk9vM5D0kuUtYt1TLqo/SH7IkJfsFQhwWFm25P2XLSM9ICnKA26rfcg9H7EzxzDWIBQgLe3A2QCQyfYNz2+VtCcI7yv0pAxTJBskWSBS1rmEiZZtgFh9MUV7R/Zjb4M4D2nZ5oSoj51AxHO0i+h7AiTaxzL4Xf6M3rQCcHn+EmBJJDEhN15SAVugFh0gmE4QCissw0ByYfEIscr0SCF1Z06tw9qxxvko+Od96gfRajDEsuIdsQ6k/2U4yexrZUi0ofhMEl89gDmzG0S4aPfw/AOeNZLi5hTIKWZ6mhd2pi3dkgiA+kjvIXjvYbtUH4VeaPf+RmGfUXf3QmMm/H9FfdIgyJJGRmWo32oi3AQkjJmtiELWkbfIroGiAbOn2xjzmuJ3g6pZbhv4dzHaEz2T8yd/Sr+jnVFYQntBiQaCTc7s6+LrfENt7jVYosttthii+0G2F6CL8YWW2yxxRZbbDfP9tKaYU8dKGTzfTl5/7Xe75cv7jN/v/CELWcnIjI8bpOK5R5p2Bc8Z8eDD6tu0jSvZrtVA4dMYuGKQ/rP4Z0NpWisvF0kfQ4iR5dE4tpj8848ph60PbQXfusOM/3A910w01MOOkrP7ZyVwEXm5nBYBwW7QdYfcCABRCSo2R7a4GHbkx04iDvnP2vnsfo+90STsAEHoefh2gvsew0m3H0k1XAQI247+qGDyyPtqEYr5Y6PL9xte+oHCzaXAD0149bbBQVUcrRh7V57zOYdpIVXlmwyymPvshEsIiKTT9ltO3naJmlZmbef03TWDaHJbNr96rcfe9hM9xxjYOhApGR2USQOHLwL3UN2ow9frprpLkSKyA5p1rit3yrZyD1GsPR6sMRIJLMdSB/x69kaY811fJKMkF62VOjB0pduB57d5Kx6LLsz9I7q/ftVP/Q6MsY7AALB20S8NPoM32eFF/ViAvPoQc+vR6Xl6P2lTCG90pSOGxQ4xwCRALI1engZex56oeE17U9GY6ILR+vy3/7k7SKyQzhMwjS62/NrUUlMljW/znvDS7mllRkWQbyXAloAMf69CaAoJqNjm9fT8xhKLZJ2gl5UenjpNb1qSiuAw4hIDxJD+qlobHYSXAnpBggG2/DyHqugLEBT4Pn0KpRWpKcdZUYZ+/C4E+XCsnVBwEtJztQzup4gOpZtzXzya0F4j3HuI3p5SbaYX2UcevSdzLIy9r4LbiySkIYyhpCJHBZBoFeP8j+kmyCWZOw6jFwOlCmkR5x9Mbuxg5oI2ylL4kbNvHkgGSnTEJ7uPnlLgEoZRybQY85nTq6MLNqXHvb8YhSZQBQAxxNj/MkpMPMsZEbnQWzY8sN1FiUrQ/JWP+pVbxwBomYMAeuRbwCoY7Yjny/nj8Iy0TJAT4CEkW1IfoH8RvRlnMPz701nUCdNp9e/X/JCgmSiJ8izEHrxyySijSIZQq4E9sUQjYI8gDghd0gafCmhlOXqEL/3I/mGnCW5aHmI/BkRARSiEIKrkGP6ScQHx15+bM9Ews1QGpQ8NKiDl4nOBTfd9tiaYU8dKMQWW2yxxRbbrbEgXEjHFltsscUWW2yxuW1vrRn21IFCr5eWl89cizqgdMi4lf//7b1nuGXHdR246+b8cujwOqKRE0EQJJhEUpAokpIpWTSVZUn2yFQcy+OxxpI99tj0jGWPbcmSbCUrWYlKI4oUI0iRFAkSBECASAQ653753XdzPvOj1jqvz+1dj2gKjW7crvV9/d2+9e45FU5Vnaraa699wn2vDUfUyPKpcTV97KxuLavucZhBRSR+Qrd4Bg6jeLekdzyGlrnk9ze6IzD0U3qECZ60XpLe0i2q0692RyJYfEpnL8y/Xb/GFR5y4NBvcLEmRERMS29E+iNecq8ZnZESuMzYIhJ3aAAknnO1rX6fum7glviS27pOK9Iwlu/R6zf/CX2oL77ZbWbuj+ttkn5er1/SQd7pvt7BNlhxh3SkWvUwEt+4oab3Pzyul2nZ3UlczJ7Zh/U23Pejz6npZ35B12Jpvt6dd/Utjmgjf7ZfTU/pxAwZbBOmY+J5vX8u7nSM8ZL+vPtrej+kr6p6TVrvV7GMTivKztbU9PWsWwjG9ZxabtKUh0cEiXpfph8rS2/cvovrOxC1ARYqRh+g5ZxWNCr2U6eIyvBdMhJpqE0EMgjVzWFlXIsq7cdbUV97Rm/IrsNiHir4wy/7XPS93kd4PVpYWcZ2iZZW+3eqt1N/gO9PWvN6sEiSQXHw0HkRETnxyEJI7KOeA1/JGfhLk7ZLxgCtzvSTNihyc4fNnL7KJB+2JqM6BGSE0BrNaANkUdC/uzuB9k7Cmjrki8427ZREimfwTMtQ+0d7Zjaic1WygnnQsAwIo1diH4AFFjoGbFeijXdzdw5rhw6s+YjWQf/57JnoO5lW7LGj9jutpls6CUFotQ31jdDP6vOp8DciIg304zbKNuyLTyszwzzGyTqMRZkF2UXUeTgEI9YyxbO0mNOKjT5eiUbEiEHjIV7vSm+P7QPUqGhOI7pAkWEJo32svpv3IPuHfU4iv2PI1zjbDREpMqtkMMDaD8s5I19QX4AsD1r9GWViAB2m7LJtq34mJrU9DIsKpgeYSVwmhxES0E5kSwwYiYLPr0Y9jyhbIA1yY58hF8m6QJ/MLdkbU3eC44fPtTkHlhNYHb1h637BhO3XA9OjOzT+EwhXynYnW6V4UiL3TCJkaRbjiFFlMmu2vSr7bFnS6BNkgPQwb3EuYJ+mnge/M5Rpa5paDmiLmITzB+vCSDkMccnoD4y+wfYonSFLAv0djBOD/pus6mshj+0xUgcKxWxLHrj72UvSH76gC9VtGscqXUQSjo1IbklfxDbn9EV6NucOW9dv6hszR5REZ5i2WF/fOAxe7d4M99N63pwkLsnDcatz59yh/+K7dPp25w/1FX//O5f1MvUdJyzu/UxI0bukTC39ovh+/TnV19yb3tITeh/ZdIj3vf4mnb/9N0/crKZzAaKhv9PhVuEQ7ix/mz5B5rcRRmzW9R133BE61SXi2FzV2zDmOKQScYspThf0jfhqdkLPo+M+/eXLZRiZsr7pffiwvtmfcxxMnK2OO/MWh1hr7f6Gmj7xcX28bnbdbiMUanqhyDnmqkpN7+eME66hX9eviRX0flir6vXYro8s33ftySO75m6PaxNBzEg/nxID+m3htJ3c+hm7NKKAITeXzalo+DcuYAcZbJiK2HQ0yaEVMThcCyp2THBzVjwOii/6DA8OChcoEIZPlC27ZOelUNQviQ1qigKG+MxGF+SVA/aTNOwOwr8N8kjAQUcCIWv3zNrdzOEj9qQ7ngwkswLK+mZ0o5RoceOIPLBAT5dtO3Chnlyx81qAOaN6wO6cePBAV0uKttLNo7GAthtyAx1wusBBQnyDIeiwmYGrBduU1HERkR6E9JLVfrSMNYrD2ecUur3gHdIJNzak6Nv7tadwbx6mkN7OzQ42eTyViQ195wYpu8znhn6AMKAsX3q9I+1JuDRcsO3Z3GHfrVlszuvz2BwPUbbDQw9uvodeyXQZSa9hg7pgnx/XgzxIIO19WJw8XYkepJHOzvCqibq9cJBNSP4C3F540FWiSxA3vxIpK3PihpcuDhQp55pugDGZgKsI+2RuyV4XCie2KDAJEUw85/AwLMXNKA+ecKgyuTW+eJDIZxP2113R0K8dhqikuyvS443ohjcRumzywIaHH9HxlaxH+2wYdhWHI4N0tC4UM+VapwX96CARhIceggOEAJkwTC0P5Zh5osEDymhfSOEAtDkJtzEcHLDd8ovsx6g7w9ZC7JThVunmxLmF7jh0jWEfzeCgqJcPwnk4iTClWwcDTMdhCQ6pcisD1AGHTRg3fXyP93kw+tK9yEdpzTBSBwoeHh4eHh5XDSNEX/Tw8PDw8PC4ghihNcPIHSj0FApwdbGo/FIk5jZ+yezdS2r6+kO6wOM3veMRNf2pDQefXUTWy+NquouKzZO/YcRbenpmm5COGzk3O0MDLTHD2Luw6rxmtaZbYcs36dbWRF1PjzkEBR2eECIikqrqf3SJURYyunV2co9uMRYROVfVmRaZIzpF/G9aOhPBhZ4j3KKISDKl/63fc4TYPFZQ07O3uoUD0+M6LWXQ0J9Ty+EmZBysifTqNgyFnfqDOvPoLjU9qRdpe1q+w7jvHE+n9Oda+VbdpaPgYtZsU67uGQdrydFvn1/VQ3WKiMTSeh7ZCZ1ikog7KCaOJmzNu/uny7Xhvr2n1PTPH3O4eux3+NGISPe4Pq/3s9cec8Hj2oTp9iR5bl2CJOjNE3aeDJJRKnec7HW8NikIN0iBag8mTXGHHVutlLUUDwZGeghhHCvZm5hF0JExnaRIwa6QLm5/F2uDobCBd1Cf9H6UNQPBtRLEHWkVhTWa6wi6Y3SmMSZp7cdnMmfzu32XdXF46qydYyliF2+Y0EpI1gMt0kl8kiXZy4IpALeBWAvW6HFrEg9SDLMXnfsZYjF0v8DSIQBrIkGWB37fr9jKxSFsSfZFKMKIOSt0G2kPJAkrOdtVYIWM1yBgt8POJxRhpOWwgRByYXhDtGt1Ly3qUcaHgYtD6PYC9koAiy9DM9JqnIB1m6Egt9p2aA4dBCGLYpiiTZCZwPCloZglXv+tWZSRotUQpwvyEHWEhTtWI/sF94WYHUXs0ghZShHGFBgpyVWE1pwu4PoY6gwLcKsntT3ZSPvQIs33MRk8/TA0KCzoRVtGAzZKv4C6oHPS9ZfWafbV4ZCOZJzEerYOubN1lJVuA2AiFCk0GnUXGCS3ykbmLt1cBgWUsY0xD5fZ2GYGeW6NKZEt15ItwU57n4kj1kfFQCC0Mw7hVQgppjbsfWt77bgi26ZLa/941NpPSz7dG2IdkSCNuQtsCcGzZnuHVv6aidyD7gOhuxPGUeFcVNCW44gMhJDBgz7WnIyGrWXd2CZkULAP0vWCbd3Pbokyco0ZuphQDJTMhGW4O2Fs8Tr2T5aVjJpByr1283Bj5A4UPDw8PDw8XnIE7oMfDw8PDw8PD48QI7ZmGKkDhWo9K5/5/G2XpLsMb/fd/7zzXjGHY0utqjMUPvA3eii2W+7WLXIiWwI2w3B1MJ7gDSN3Thdf3FnSwzaKiFyY1kNmuvx5XEKRZ57R20NEJL9/U02/5+v0dn/k+F7nvTSEPqAKgrKjazusrYmY3uibH3GHFp16YEVNLz817bxGw++89dfU9B/5jR91XtOc1637ibqe3nNoLuRSbp2NUlrvVyt0xLskbwcrZFHvPK4+JSLSu6DrLrzjgUfV9I9/8FX6jbaZrBnGbRhLr9KZCC7RyeYx3VK+vtstyjh+Xs+78g06q8g8o7N9Ol33FD53Un+254/o5c28QmdluUKObgvHOJtL62yOzLM6M6M75taI6E3r9TPNq2hdGCH64vUBI2KM9KftmIhX7JwX2wQrYLelXTWnaOmFdQwCZTFoJgzAQujDjBnD+6RVzYZzEIWCGTYwd4GCYPbvmXWYBOHHm1i2Y2WwZN8zsTlblu4kwguGYow2g9ouCBtieNM/m2UN/dth9Z+ftu/nd+x8RkREfvuZ14iISK9h75Os0s/bhP7SFAikhS+1HmU7JRcxSQ5gtR+DBfW8ZcI1brasPlrSqwvwT4fgdH+HfU8FsPAalGV6viwiIksroIiQsQBmCK2sFLProA3INkuVOyKw6ifO2R8FYHiYHqy7hXEREcku2WfanLV/74Vh6+w9A8yHZG0GWTAK8tAdaEOwD3F1ewwPjjmRoe34fOjnzbal/oQB6yN5fkNERAalnJh+9J1Cf/QuBCNbY9BAmKY5XfA9KrgXkE2BuTI3a59j5zBDY8KSjSmW7+rMOtJpGR5ew8bow0+/fKbbj24xFa5vazujwqahLges9+0Z2+moNzBAWSlsaHpgYcC3nmKAkDuRTJVMBLarLXRmkYwEiKOSmdCChT0fZfyQScLP5qwJF8qhWOgEmAlk/RRte3IdQ5ZQv0CtCvRvypiwnTHOGLIynoiGMKW+B8tO8dhBEswfapJAOLS2AAYJluKsU3dsEDKUqEkRMBzk0CNl+E4Ke4bMEjAVyKRpT9gycx7rZ2wZGSp2mGURamRQpBFLvsxqdF7MnYO+yqttQeLH7UBMrMektRPMmBMU9LTXZJcDtS4UtUxRdJHhTZMMBUtmzzb09RcbI7RmGKkDBQ8PDw8Pj6uG0VkbeHh4eHh4eFxJjNCaYaQOFGJdkdyFS0+WXvFtT6u//9zDtzrvdejOM2p6a1J/+lTBHUYu4Q4/4lLFNw7X5OyKI7RhXD9Ny8fdedOX6pK8XRZdF2ui6GYJvHHXcTX9sdXd+r2aju440NuW4bc08PR/GC6/+XRCb/TF3W4Td2VR16GI79F91B983S+p6f/X+ber6a2Zy+dChcq8LxDTWbfORmegt68r4keoGjyEwGGoTzh0LkTcY+CDn3ulmh7P6nm7QqqKiHQcY3n63gtqei6pj6cjF3Qdg4Ej3KKIyPo9Dk2SKZ3Vs5nXGQqtVYd4hLgjtmRuKavpSQdLR3qO+1xwMzCCmD6Wz+zTo3E09uoPfPxJ9yuq1dLFZtpT7jnJwyMCIxIk4mK6VE+H1XS3NXHTB5dK9AarP/ofx2Hly01a61mjYcd8IgELcCyQAD7ZyU3K/NsP+iTTD51RHVLny/bvY3bMBydOXXxZ6PtPC16q3EZZ7Q17nAvpHw+/7hisnbTgfufCYyIi8kdn7JzabTCOZFTZX8zWnE/rY2oD5uRedM7ogT0Rb0Tnyt7cuC0LrbzTsKSD7EYLbgzt2afuDnz7N6rQYKA+Aa2bE9BqWLEvdlokJ45AfwI+6L1iUmIdahnYa4IxmDPxrNLr0cgUVIJn2Dpa29uzdMC2H2QmBGSnJKNtkqiAvYIoBalz0BNgE1HvYRl1aTOyBfQHkhRd2LpntwQNiS5V6+2za09EIyXwuQ0mwHpA+2ZyNq8mfthqJS8uylYoU4QJTWBJw1CAbGczpIpvmrZfJGB1HSRtG3cL0CNIx6SN9qTvPFkTbbzi6LPPwvQLqDhjJ6JfJ6ClwHGwxfQBwwd6BLT+k8kTq9ixaqhBAoZCP482rYMNMIZoHwxhivHazwZhiM8wDDnKZKoIgYmoDskWGQNRvQKusxnNgWWnThqZJ7GO7Qu09mcWbdl742ncB0wJhjSlVBaeTxcsmh7msUhkF44x/LZXsn/Ln4q2K8vIPhCGBnVEw0qg/dpTaZQ9EalzYzrKzggZXCGbhkwJ9CG2O/YHgzHoIazEJX8iGSkjtRSol8GQsK0JMDqgoxKvY/Bh/upOg0lCzQ8vofA1YaQOFDw8PDw8PK4WzAjRFz08PDw8PDyuHEZpzTBSBwqD7EAad15qHX7sL2/XL7hVtySLiCz/8R41ffe7zqnpf3fn42r6x1fcLIiBo/VjDgMb47oOoz2vW+rKXbf1cjDmMAEzRvIwHEr9pWfdVsrPzBzQs3D4fcc39XQXa6Izt00UhLpeLiUIiIiIJByZlI66LdyFb9U1Klz6Gw88+I/V9NSiXtbYNqekxVs31PTvfYsebeSXPv0NarqLhSAi0uxdXht2dusW/PxzuqV+u/i7Li2ItiOPnsPnLVlxT3FUZB7GqROOcBWOsCIH/kQfsCe/eRsGxqyuaXH+C3pUmH2P60yS+m6duSCy5Xc5jHcf0OeqBxcdUUgcDKFDb9YZSCIiTx1ecP5Nw/TuspreOu7WIyncq0eYaZ/QWRAvCUZocXBdoNcXWStLLA4L3wwsqkX7vTkdtdDSXzteRcz1aWsx3Fmyegcn2pMishWZaOf8hpw/YucTWmTpQ59bgbUfPsjJdXsvWqbjq5atNLjrFvuJIsc6YBzAalk5aMtMa3RqEz7HNyAB2g1mzM5TP3fvn4uIyE8/8u02vzB0AizsdWoz2OT0eiCpGtXhEf0C+g1xXGzgf548a9+JfTASegXqENjf1+eg85Cnojv8sKHX0IalvThvtRjabVjea/Ydki4hIkPVfg/q0HvA9EhLZWhVhsVxkDaSI6ti3Drtm7Z9lzRumEIZbIU7E7bMtHLSd54Wc0b0IIOji8gW6by9X7sMtgSYKTFY4A2s2WQmxGFBTyFyQmcM94HVNHXGtmXroGXAJTdb0pmIvkur8/g+NO308mS94JluwPe+ZJ9Ts2Etsob+83Vb5v6k/Xv6QlRHgNEdWlM2vXTMUkBpfY61KAJAn3T0IUYqoZ98Jib9DJ+NvWRYMyEF/as4oqLET9qyDfbbhosfoTUZegTr0egboRYD27fKaBB4niV7PZkK3ZmoJkntUBb3iWowNOZgvTaBDBDZI4Gxkj1l26V3u22X+Al7z+68LXPqvC1c8aQtG6Nk1HHP5FqUJRNGIgHIQuqXomv99hjmLbARqXPQHref2XPR9V1zFxkRwRbLB5/pFTA1sG1IbbCs9ppuzv4ws4G6N6KMnljPXl/fncV3tP+Gfa69nO2rZNFQm6GJYGl8niFNZsC62PT8EVv3bn5Lx4Ushw6iWnA5m1/CPMB14dD4aO6wz6c1CZ2HOrQoMNaru19CisIIrRlG6kAhFgskk710w5FZ03nu6Yfcgl+z7z6tph8+rYsQ/slAp2JnEm7ROxf6DvHFTkHv5KRMDmOwTVzFdEHf0ASOa1wiebV73Icy4y41TAeChkPUz3XAMuauX89xluKi67f7+lC4+Xufc+bx+EdvUdO7N+uhJk1CP7RI1BxtfrfDb0NEBh/XhRF/5bVvUNODlJ53pe0eA66DkYHrDKntEF90HED09XMwERGZeUJ/6Gd36G3F8EyXwj3Fkao6jG5lm4IpOPkteoNkltzCPm1HtMfU7brLQ+NxXUjR1XdERNZv0evx+3/+FjV95n7d1SO5oT/Xow/qB4YiIomiQ9S2qx8urS6W1HRzmy4MKiLSKLsPU64KAtlWBNTjGkQiLjI1LtXb7HxKGi8XotyohvRsUPMHEOJrYGN7Tqz7WyaDTWnHzjvnzkxthYqjGOMSF/XcZEGsMQv6bt2+Uweg5BscIPRLdq7ujNlx3ZrC3MahhqmggZC7MRx6mHk7hm7eaUVXf/rRv2svI4O8moxcn6oglBqGXqwnkqzzIAHih5t2/UDrWoCNZWM3RIwDisFhkz1p8+BBAgXYWHaGqqMAbHUF3G0aODCVtuvRcJH5s9zMoAqMjAnBuEQLm8laID2I7aXK9qH2Zu2ck16zFS3fZPPkQQI3ezT8NHdic4zD7lDoGAeuXTxzwQFC+jw21ViShqE3sdEirTrWxYbpFEIujtvnHGRs30qt2vK257dCP3exFqQIH+vPdQ/7Gtt1gNCV0qPbDcUZQbFfsW2TrOAT2pqXinHiEy5CMYavxAa4vW8Kf4+GO2xOoS8GW7T8LlwkuQlmKMvmDrh8bCIkKNopOI9DjzQp+NjgrkYF+DIQX+RYpuhf6AaA9k0kou9n1o0HER26utAdAeFd63sGYfvRDaI7jn6GdXIKh0cGBwmpDXzns8c9i+f6kbK1J5KROhHtEsUYo5T8dolhOe33xsyQG0ORz8t+p8Al3RvsH1l/fA65Y4TzAg6VtkRK6RphIunpTYicwmWovisT+c55heKx4aFiJdpnO+MUPaVPBA6a4EZiBhcdHtWjh3MEQ4RyhUZRRo55ERxWpXnIZT+TQ/e5YhixNcNLKGXp4eHh4eHh4eHh4eHh4eExKhgphsKgG5PGyqVWq2RGt+Jt3uqmzG88t0tNT5Z1a93SCZ2qPP4aRyg22Qrtcgkch2Nth0XeOFgFX1mdc+Y9VdIp1HGHVfqMg+WRy7mFHxuP6nTlnIOqHLj0AR3tES+58w5cgo0OgblGV7cyr7d1ZoaIyMyTev+ZfkB3i7lj7Lya/tEZnemwdMZN3R7cr7MgfvC2L6jp//PPvl5N7+x0U7vaDteUmGM87X2//qDyz+oCp0f/F12cU0Sk8UO6S0dsU7dKj5X09ticcgsjjuV163fzK3oe7Sn9KHnPbbplf/2UPoeIiHQd7J2bppfV9JMTugBoSo/CKCJb1pNhuAQvqy39gkHaIba5jQAoRdaGsd7Ux9PO3etq+vkTbpeH3Jw+YTQ2Lo9h8mLBSDBS/pDXAwbphDQOTUtzApR7UIpppeuM20/Sc/kuyo7buaO5bk3C6UlrAtxYg9kN1tVUZWuMZLEU6MMallmJsgRp6etPW8t5rILQczP2nhRmq+0EvRrrhzamhlAobwr3Xbbj+Ydu/7yIiPzm0/fb+2xifGRgVaUIY52h0yi6Zn+WW+1LsmonjTB03i47R+ZO2wmoM86YiqBHw4LemrTjnSxKWqe5ZIkh7y7DGHajNq6AZYTQYeokXB9g8U1VYFWmuB3um2iAUQGLbqreDkPtsT0747Ydq6Bojx2z64nKfts+lZuRN90CaJXOwXI6GHInKMBqX8M7lZZevGaSZBHguU0+h5CjaNPeWHT+pcBlL2/fw+2xeGhBjQ3dixZvujp0p+wPKFrXh5Bk9rDNo7HP5p1YtX9PwOrLUKZ09SmegQDeOsMW0ipNVxIKGtr71HbZtqMYXqJJs7dtk8acCS3hyc0o+4Tsn8wFe08KH1IYkmOxeMJ+hiECQcHvha4UsNpjPKVWogwPpsfhurK5Hy4qeF5kTlKQtXrAFrh0BG4+zZgYjBW6awRgA1GwM38WTJv99l50c+E9afUnC4BuT3QNGgZDMiaatpDNSYZb5fixv2vutvcpHIM4JG6XZDnRxsmN+FYZKMAJcmQS7k2ZMkNS0lUHrg41W8dOKSq2SGZ1og4hxHGE+UzwekxQYL/UhrzKA5Cds0vo4122Be9jv2XgadzNi+QvIGRrg32ADA7Msct24q7cYBsoTfFQslXg2lZdgHsSmByFc/r67MXGqK0ZRupAwcPDw8PD46phhBYHHh4eHh4eHlcQI7RmGKkDBdMzklm8tEr1XfoDS624rbNxhoMZQmdCt1LGHGKG1abbR71f0NNdmgGFcw6/5N2650rPYWEWEZkrVtX0lMNyeiah5534rG45FRFp3qdbENdXdH/pcd3I7GQo9B0++yKhu9Ul6M7q9TOOEHTboXKPg63ymRvU9M1P6kKfaYfYpnmb2wL88/f9kZr+E3/1A2q6Ii1iy1RzC3f2+3q/yjj67al36uXdldPZO90xt/PYximdnZFZ0ttq7I26hbvs6LciIvGY/rfWHr2xYg6Bx8XP6UyEfNWdt0t55KlPHVLTszmHdkTXnUffwST5se/+gJr+S8+8SU1P1B0aH7lt2tYxfzY6OhOo/fS4mp7c5g3VXdPnEdmmX3l4XIxYpy+5U5sixr7HNg7R+m//TmZCYx4hF+nnvWHnTYMwhpuHrRhjZh3hEGcZri2QqS/Dworumlmzf2vssNZiWu7yx6y1v7nHWtB7exGCkeKAyS3f4YvB7+F4XLH3veOV1pT7Px58c/QChHrOHrW/S6KO1IlIrwWR79b3GeKHNVhSMS5bO2D1hRUyhnB39KemH/raXswHsBByvUT2U3Ij+q7p7LJzcHIJjBG8thn2ediKHIYORLmSTVqQbXlas9mQTTHI4WJqSMCaWd8JbYpJWOvP2HdNB6JwpgdLKUKGmgpD1tECCx/vBi2sEvkkMmhftlUG4SIrB+zzLpy1lIYGfM8bMxCBbG+J+VX3gG2B9mBoPeoKyDo0LXaBKbBo69aegEUcAnwMezjxPO671+ZF9iUZEQKrfshUgf88hURX77X9v3ChizJz4gYzYX7Lt7+xwDCQtiyhcCDMxhxzW2GoYflmmGlswGhJj7coqIfQgBBh7GdtXZq77Hii1Zr6AxQ/peWbfagO4iTHVfYCmEH7bEJyMxb6+W+FVrSfmQsMT2h/WzgN1gSeT3YVmhWdqI5GEpokgyTCeE7b55XeAJOkGWULdMaizIRQVwIhSltT1DCJjg/qeSQaRlLQhOhiXmJ7Utyym7cX5ZbITkH40yxFW4NIO+WWbd+o7rGV7TDkLrYIZGtROyFGAVW2JZ5P+W6bX/Z0Em0gkfzIQsqsbgnYV3fZh0jBSD7T+gI0Lao2nRoVHOsMX1s4B5HMHfZ7Y9arAXwtGKkDBQ8PDw8Pj6uGEbI2eHh4eHh4eFxBjNCaYaQOFBL5rky+ZvGS9PMXdGvn/HzZea9cUleAX/mQ7vft8leub7oZCom8wzfZYZjm6fEwWpP6fXorbv//0rzu9+1S9neFjvtn73mfM49fOv4mNf3NNx9R0z/86OvVdIb7uQRd9ylib8ah+u9gkjSr+nNamCg782hW9HvVF3QL6YX79U4y8YZL+6yIiBxzhC8UkZ9+8tvVdFeIzZYjROpgw90/Xeg6+m1iU2cPlL6s1+/8mxyhDsRaATRMPaMzTFJv0tODjNtaXUjrkU7KOV1kIHCkJ847xtk274nc53Sax9y36tFljj2hzzszj7rzCNWth/Arv/0tanr3bp0ilHKwDfoZdwV7Rb3d645x9q53fF5N/5Mn73HmYdaujlaCEyOm2Hw9oJ9NSPmOSanP2/mG1ro0/HRbkPBIlaGxMId5BkyFRA2+t7D80ZpdOmbTzUAkBsX7zDosgnlGe7DvKEZAaM8j1Bz0Bxqwnk0ctvNUBZY/WjXpU85Qlnx1v+MNj4mIyF/9DSJPIURtsGavzx+1+YUW4ND6LGGZRbYU0+PdIFRo72XhI79qy17fYe/VQPvR6tmcjVrpqSPA8cHoGU284uI9RrxAhITTKCtYmS2G72R4SFh4i2ei835rAn7usP53C1th48q3jYuISG7ZFmrtdoSoPB21TtK6Sc0chgiMh37z9pPzX2bVoIxoL1qr16OW9OHwk9UFWKERLrJ03FYuvmqZFL39O5AfyjNhwr5BHRxakwew9vdhsaY1OA/rP1m6TCfjoz1p67Z50NZp7DgsuaWodZrRBXKnbCfZvHVcRESyCLVIi3k9sG1Kizi1GELWrdliUZBtwvbOnmEoFfuRWY36tYfPvh29bhjNafuHwrkO8kG0gR2kJtiPxnSUnckyUhcht2h/uPoKPEcwJDqTg1B3ILvMaA8YQ2QAtKLaHgxn2B4Dg2kSY/uIvaA1Y8tCFgD7b3MGc8M4Q1aisAx8QLIHytycAPsIz539I4zgAD2QWGeL3ZNF1Jlkk/2XITERbQPRMMiSICOEZWW/3jjEstu82Ac4L5HxRHYRuoqkNqN12/Eg+iwC6lEnpXLA/qBwemvdwXadOAKGB9Y87K8Mc9uYS0bKkqpgzHPeH2KAtqbc7OAXFSO2ZhipA4VeLSkbn7s0rGPKISq25uJui8iyg+6dmNDvlV1xCCbW3E3cG3eoozk277Ki3ysSAuYiJB0bPBGRYkLfTA1EzzvW0Nvj3/7RdzjzCG7Wwx5+6MP6wUHCRd927Vu2GfOxpMO1wXHw03c8p+cd4pwiIslXOoQtz+gbzL/37k+r6b/35H1qev6U+/m1JnTqeJDSG6v0Rd21obrfPZu53HhcrgrFPbpC4HM/pR8cmDG3qGYnr9f93Dv1vG9POMZSfBuXgIHep6cndHegxkd0kdPWjGtOcGYdblSGcfpvdLeYzJ2barr5oh5OUmSLajiMxiF97JuO3uaB3tWkP6/fR0Qktqxv9uPr+oHCX5y6X7/RgjuP4kn9+VUOvTSCShpGSWDpekAvK7JxSywMq0bqcG0v/j6G+PDLdmyk4SZJ4cJkPeqGMPUUV+6gGputRSyp2KYPAbfJ6OarNY3QiljcMh78+i1plM1+b8L9IgwNCFeHxIJ9H33sQ/fa7xQoXLE3CgVcUR5S9bnhzcIVg+UhbXuQNFubCxw+1Hbb8U1aM+/BjT/vwQOWUDSwBBcEuJulV6NzzlaZJHLd2LEhqjjvB9cKbuCS3PTgk2HierlYuIFan4CrB1zS1u7kphebw3AThvQeD1xspnR75SETD5N4sJBbhEsE+kSst3UwY++L9C4PmOx9KgftacDgJhws5Vh2fGa3Nojsp/lzeB4LEskzPBQZt5/p9a2NpM3bfs49at+bPKggxZ6hTHt4D3MTWb5jAm2EfCHCmNqMznu1XXADQT5tGr0GW24WIfAseTDGMZWCa0gCthCGI+S6jyKAPbg2UDgyAUp+czYZ+R3p8O0iniNFzgOWEV8xtjdutd+TQ4ajzHIsbMct+r6gvvbaDvLIrjLkqy1Tdp19x6Z3xqOhX9twEWrvg0sK8mGfoRAlXVxo3KFIKV1Cw4MmiDDywI5inpm1QFIY38yb8xT7a6Juf9ycZ7hOtANDlmaj7cKwmu1xPHu0SY9lLdJFBX9vROcK9km6cLPO+fMd1BUhY3FIkyn3QxeQQZIHntE1QR+ioSwrP2s7o7/bhJdy3L3cuGIYpTWDdxTx8PDw8PDw8PDw8PDw8PC4bIwUQ8Hk+mLuvtSS1z2nMxGCmpsyS0GQYTT36VZVhvYZhou6LSIS3OCQZnP4PDTu1Gn8CYe4XOaY2+Vhpa23ycCRdzCp520W3Fbm/nE9j56jWDHXrRxMBIaS0hA46pHP621eX9LNuaSSaSg9qldk7S79ebzvL75OTR/s0ite3+Wu33ff+pia/uEzegjKyT/WQyF2xtyijC5x0NZOvbyVRd1aXjzuYFq8QQ/bKCJSO6sL7t18mx56c80RjnB+54YzDxdWntYZFVkHu6W3V6/H4KTbnSTtKFaiofedxm0O4VWH8KKISPNmvVzjD+vlqh7Q+5vLxSVfdD+/3lE9j9IJ/V6r36jfa3ZKZ4uIiOx59yk1fT6jM2V+2XmnFxEjZG24HhDERdqTfTGTdk4LaJVG6NHsGVgKMReSYitYHhRPITxhOmoBTDTsf2LdIHTZ66dBHWaouM2odXgTVkm6NNBSToE1ChgaMMc607ZQd91qx8HTj+4XERF6OiWGLIAUg6QVu3TM0gA643Zio5UvtFQyTFxzIPGKbZ+VV9l5uQ3hQrYH2RR0bWhPg92QgrvHkq3boE1XCJsXrb+k9adqUQZCSEOHhZzh9QzcSGI9tH+W4QwRLg9uBLVdF717SHXfCSvyVD+SngJbojeBhxiG04xHypQ/jbLDJSS3Agp4jpbwaMhEWvvZrhTLZb8YtvSSXUBGBV0DmnMDSUO8kkK51X1RdxeC38nsYB4UdaRYJVkZZCDwmffBgCQzhejkSSlnWSF8OIu6FNlX7XVxhNCk1X+QGUj2HAU+0b7oM4MU+0IQSU9XEI4TlvPc8bKIiLR32L6Y3LQ/rO2z602ORT4vWuIrexFqEUsFurRwvNFCPpixfT19Apb5VFRAMV7eYreQ1ZNEKEWGdC2dQpl2wnXngr0nGQmcC8j04DOnWwD7JIVcY0NMD45hhoEks4eim9lltgHbGHMOxle6PJBEw5a5C/ZE/qSdD9qz0bVU6GKF/phC3cMQmAyPCvZQa84mZBc5iPFBlgTbmXVm+4KZnT8PlhHYHgyXO3bcXsg+28vHJb1m0yhiGQrX4jd03ekgvGYoyEkBzv0Y6xgwvZb9QShu+lJghNYMI3Wg4OHh4eHhcXUQjNTiwMPDw8PDw+NKYbTWDCN1oDBox6V98lIraZBzWHodln0RkeYu3Se7OKX7zTfKDgu3I+SaiEiu4LBsOorVcoRci8f1+iWrbutzu6c/+nZfT4+ldHN1IuH2V24VHdcc0FkCwad1C/fAYeA2ZYdzt4jM3qQ7sLv85tuOE8nOnMM3X0Riz+tt9fr7nlXTP/uYzh4wjtCGhVNudssfPfg6NT1/Vr9m8R+X1fTEZy+foZDNO6gkz+j3Mi55g5ibgVE8oj/058d1HYOxki4o6GKqiIgESYf44rw+Ljtt3eo+NubIO+5mKFRu0xk/c5/W692q6vSIrJuEJMYxvzXm9XT6BA+j49DMqC25NWgSBT2PWF9P3/F+nS22fK9bmHR53iESUXW91v7Qea8XBYGM1OLgukBiILHptsQwF3VrdszSz5esgD6tk3hP5M7jEyH/KPqVhEWX/semP5BYy/4/AeqACRAabgqCa7Ce0XIeWh+pE0CBYWrawCo5v8PSnL78rBV8SIGREO/QkjhUV1zOMpOZwPwyi3YeG+Si79X2ZEoGU3Z8hiEQ6XeNa8mWIHuCf4+1KHa5FXJPRCTgOw8/p/WZn2lY+UNRRSBRxbsH46yPEJC0rNPSvnEjwk0im15OpL4bzwZCmhSoi0MfqjMDS3gTfuhZ+51ChqwTfcX5neuTUMehHn2vpCq20ap7bN+iFkAHluEw7CdeF9X9uG8iqrkgsUBa81RjRBr6Qvo8w52SgUDLd9R3vHAu2j87E7adGA7S9KPtSAs3hQ1p4R22oLPPdbhOHHrt8u+DfLDFwBl6PbJdM+tUHES1w3CBqMukZVsmK23Uwd6I1ukExAX5fe1WhjlEvtAcYR+MdaLW6/iSHRfdIsUJcd/KFvOB96JYKRk040eja4fiSbvW7RXB+ACToT2BEKOw6nfQz9neYShLthVFN7GmZt8lm5nMBup+DD+nBIrF0I6DuAlDvaZXoVEwngn/JiLS2Gm/d6FLkFuxeZcPRt+voT4GipRZpmip/c5wtmH7k82FoZwq2+/ZlSjbJgVmSmvS5pdbRMha6Hrkj1UkSJN1El0f9YrR/krmWAuaLmRGpdagEUI9mqFwoFccI7Zm8BoKHh4eHh4eHh4eHh4eHh4el42RYijE2yJjhzWLpG71677N7Z87mdOt6Ocf26GmD0oOloBOaBARkfGsnkfPYUXv9vV65NO6xTi55GYPLFZ1NoDLatzf1C2I/a+4TaQpR1i5+Gk9757DWO4KD8STZQ1ODYWUQ6/AwSTpNt1nbrnv1/35Hz2nK/VP719X0xttvW3rC24GRnZJLxd95YZRWdU1FCbq7tNRVwjKtKO/NV1MhLaex75xvT1ERE49oF8THJ9U082YPtByKUf4UBHZbF5eyMz8WT29mtTLlE+5++fb7n5KTf/w4A41PVPU5YcZxk3DbQt6aNinmgtqempRH2gDR5Qc+sJqYDiyYbj6wvot+txWvG3Vmcf6kq6z8RJ6P16KEQoBdT0gHh9IqdCU8oadH2lRp29yD9a67FLUipaDenu8hTBty/Z+2eeX7H96mAyDQLoH7ZrBdGGdHEOUB4ba20nmAnyTEVnCwKc4mUXoPvhd37vPaiY8/PwBEdkK10vrGv2n6ee9paEApgQsu4MUxi+sorEWdCSSbANa/2LSKdJSDV/tyag1MbkOX/l9sMjWEKYNPvRUm2/tsnXJn8Dfw0gIEkEfVtHsiv19ctWyJ2JVO8/3Z8ft9bCod0t2HiSjYctiixsGW8+0O4V22ED992Ad1oReRoVzEf3/7bdUWSJlDtXm0a5xvAATZTDWetBQmLHrHYZgpM861zUMrUh0x6gTgedQZF+SMFS2Kdi0FPz8+SC4LmDUjS5e+3msBTNLtmy9MWvRzZ2wejNBBhoUia1wp/Z6qOfjuTOcHjVF2jNgNDTouw4LOZgK6XV7X0YmMZ1YGLWB6z3qZ4ThIVvRSB1sVzJ92D/JsKEuQbps86zuYl3s/dgXQlYBGHexobXdII/7t6NzQLyBCBgIAxrviKQr0YgonPcZqplMg9RmE3kiQkE3qmPSGovqDDQQ3pP6KWzn7jQK3+PzIYMKUVOmovMUWTOZtej7lstiE4gkoYsSa9p7d6bsWp7aH6HmBxgFZGNwrDKCCPU0qJPB6GAMAduD/lpq0T4IMhN4HZkpZC8yukwbzzWzHo2IQUZFv5gOtVMyePYsY2MuGimCUTGo49DYjedAuRSUleylhFse6sXHCK0ZRupAIYhtxXi+GNVD+k4n9dS4815nD+oU4/6sQ5zQEZ4u3nZvSPMJfWMWc+zkXHT92Zx+MLLenHDmXS3rBwExl9Chg5bfPOCOszL1OX2zs/Zavd6pC44NtGPPy0WKBtfBQcLRti5mfP60O3TjybxOx84f1uu94Qg52hvXD36ya+6+k97Q71V2CB2SxjeMr2XiHMvoF7UdBwqbNzqE+Jpuynz9S3pcxZJjf7le0g+pbtq76MzjwoqDMu/C2/UDkPzHp9R0ClVp+MhDd6vpM19yHIR9ry40eGHMHTZypaEfIpmG3qeTjkO1hOP3CYemrIg7lGbuvN53LnyrQ3TyGb1tRUT2vVI/0Dv13KWhg18qjFIIqOsBg0FMavWMxPHeSy3Yd2nzrB1X2cVoCLTsGinjEJ2DIFysjU0MlVs37AWmmJdYA8JhO+w7lwv19kRUPI7ib7EiDhDqCCuJl9M9e0+LiMijJ62LA10guPHJXoguornpoZBhoh4VNUsuRQWsuQli+Wq7uFndOkio7+QmITrZhwLJCD1bmrUCb5Uk1hncCIdijDaZmz2KBWbhjsE48qkL+GHZfg7mcHg7gNhgwbY3D2noMhGGrcQU357piaCMLKvZC6p3A4VAvUl/zjAUOA9NsEmn6GLunN0J97EZ50HCgG4YNdsHeNgR60ZDWVLEkRvfzhg2NTjQ6OHgg65r8VRfen30CYS5bs/x8IGChnCjYB/YjLqS9OHOkly0/bwDYcNQ6C7Hww66z9j0+pxNp4Gsuo8b6qh7QQzipv2qzac1e2mI0x5eSxl4pbJdScePUwy0hr6A0H/9UnRdlV60hekVSiij/V0oFsgPtEVjF0KfYi0b7LBjd9CiXwEP1tB5cGAUhjlsb7kkxdt04cGYgp9yomxfin30y+4kNulwMemWbBlb4zaP9lT0AIAb3DjeI51JFB4HCZJgXFAcuJ1FWES6GNIrCoeJebQpRSCTcL+RmJH4hu2vQRIimXAnYn9tTnNMoXkomgkjFA8ZWWYeJHQLUbebYCO6ru+W8LwvREUe2dd4gJFGaM0eDgkowMj5KUjEwn7HcJGtCcwbFZRxjGVC/8YhVmod7T9NYVa6juB3DiHqK4FRWjN4lwcPDw8PDw8PDw8PDw8PD4/LxsgxFHqKUS5/Uq9mY7fbJWD+/Tod+rv+zw+r6f/5iw+o6S5hOxGRVFw36caGYwAB+0pr7pspqFTddG+p6vUbDBym+oxekcKzjlh6skXbGsbYE/ofqvtfPO6Pi4lQTOkWUpe1dTtxltxRvR7/4od08bd/8YHvUNPzJ/T+SZqghuJp/TkFG3qZYjv0epsvu0UZXcyQZEzvC6kHdPpA4gndyjyecZu4zzjCkY4d1Vkspq634UK+7Mzj8OZuNf2GP9RZNxdep9ejcfDyWC8iIumduovGZsURatXhnkHBo8vBML04hONWjQP6PJIsudlJ8dM6O6I9rc8XE5/SWRDlt7gpNOW/2KX/4eZtJt0rjatsbTDG/FsReadYIuWyiPxAEAQ6lcNDssmO3L1wVp44Y+eCxjJcH/AYu7AaZzG10ZqUqNq+3y/Z/hzrUJSQJkZYwPZMhtdQ+I5uSqFVkl1mxt4znuzj73ZO+8X77PvkJ774XTYvuCX2YU2LtaMsionDKBvCrdEtI16xYymAq0PvhHWdiOXAnNhtXTP6OVjcEVqwfCix9S7nnEbxRRpOwarordn3SbVGtb4g8plZtGVqITJv8SREBWGNTJ2E2RpsieYh+8MM2tA0QdOuwfINNkAwZctcn7f3b87Bcp7F3JztSzJj88jnbPtsnrb0hcQU2msVbIcZCNdB8G38OXsLWtBDSjhCVibXydm3jRFfBasiDqv+JizteB60otKSPky7nr/N+s+cO2PfN3R56S5nZXyPZZVsbtpnxjCnY0+zH6K/IpxhB+J0hdO2jonj1g0umJmMlN2ctumDe26w7TdNUbsoi6K2QGsyyr4LVu7jdtzkC/adXgZDIVllHSmYGA9dR7Kr6McpCgniE10rDneBeCwqxpgAs6Y/bVlEbbiQMMxgGsQbtm97Fv2/DveNon0eCYyzHsU1O1F2B8UbOa7a4/Z+k891JAUGUhduF5kTlr3YQ5kSGGu9YnQ9llm26Y0Z+57PrNo8GnNwU8KygAKtyTIYIxSHhbsG+3UPjGy6c9AyT2YKxTXTK2RSkdHSD9uT/Ty5AXZF2q41Muu2IVbuss+ycNbes3wLWUDIY6ftA90OXBKOZVA2smMEbYUQshfgSoUlAsOHJhsU34w0mbTAPio+Ydmm9dvmtuoGtk99NtoH2J7hUhU37ZfA/kKfiK1CvLVHRs4Wk+Ylg2coeHh4eHh4eIQIxIbo+dv++9vhPwZBcGcQBHeLyAdF5P/8297Qw8PDw8PD40XGtbFmeNEwUgyFWL4nmVddasU3Dot/wyHwJiJSXdDPWv7zp9+qpsdd4n1fg0KYS5Sx5VAtTDgsxkHKfV7E09pL0h0RAV2CkL373MKWB2eX1fQvP6eLFopDh0JcrImeu3Fd4pIpR1sNHPINd/6drzjzeOysLm733t/8LjXdODQU6vt0k7HZpn6Ddzv8+T+taw9k9jtCG5ptwkY60l1aHpW6bkXv7nEICjruIyJSfEZnWmzeoP/e1Z9P19w6Iq5rvvt/fEhN/+Wf+3Y1veZg1sQKboZQ7HFd+2Dyjbrmw4SDzbFRdOtAvHJaV5F88na9vOuf1AVnYzkHpeGEzkIQcfedQJ9GpPUOXSNicM6tszH5nN6vNm++Wq+14KpbG4IguLgh8+LknXiIiLR6SXl+dVa6m9bSyDkhtYFQacuwjOO1UZ+FCBiGaeL5MyIi0l+z8/EA1v7YnNXXiTe6oQ94e9K+ZDb3Q+wP3bS9z/bjoIVQcrCc/tPXfURERH7kr7/f/rA/ZO1FWWkFpsjZxo22LhTiS6zYd3SQgijaGoT47r7Vft+EL/qELXs/ybBv9PUX6SDcGqkbXO/Ed9v3Sipl54jCQtm2U9OWoXfe3pMW1ewyfZmjfum0Tnd3wyp/1q7jMk/Z9jUJ2zaDCct8qN1gP2m9DMPvYTqk/3YHEg6mnpAurJRVfI7B2l9/xr4jAoo1buIZQ9yyg6k6j2feA9NAEK4wBT0CWkuDNHzQD9j1Zapsn+/6TbZNqFXRQ9nCsHqwji49YS2wqf32uQz6EMObakvl+LgtI1gp6TWKIaKf4jFRi6J4DHMk5qXBTtsvzYChGdHut+8XEZHWtO0j1N+o7EW7Y31EnZ3OQfs+Cpbt+iFzyLZB/VnblmYH/PHBbgvWIAJ5PhYKElKUNLMBqzuYCmmI8HXnbcPHIMoYhyZF64DtIy2EXkxAvLE1CbFGhGGljk+A8J89ri/b9vl18Jlejr6UyMaZeRT34yuI0grjCUnWUKYGyjpn+2OiDF2GLNpx0WqJlG+37cLwhixjH8uvcC4AI2qQgUZFkuwNMBaWowvVUHB1lRoa9nepKuoMTYw2xnYGOgTxejd8SVNbZfWecfu9FdXFSNoqSH0X+xraqQCmzlmwZUoQnT0IViFYKmQlZVYxVtElx49CDBIsGupSkMVBTJ+x47Q3b8vHMKKtqWQYpjcHtgv7FBkGHTxLhqYkUyGgACuYVgVL1pImopIz9OWVx9VfM7yY8AwFDw8PDw+PawfTxphHL/r3w5dzsTHm3xljzojI94hnKHh4eHh4eHhsA2PM/2aMCYwx0/hujDH/1Rhz1BjzpDHmnq92j5FiKAS1hLQ/f6mfc/MW3Q937sYV572WErql1+R0C3d8XTe99ZNuK3Ojp1thBw7n6x1Z3Yp3sqYzLQZZ9+NNl/U8XJoBnSndqtmqucPWHfviQf0PNzp8svMOi66DYTI447aQJhwMhaWmbhl21fsLj9/ozMOMOaJ0OKIRFk/q6Rt36emBI7KGiMj6Yf2ZB/v0/lk/pv9+0h2Z0olmT7+o13GE/ntMb5DYHnf9+q/dVNPba3p0kszZy6+IS9/kvR/QmQjmlsu7//i4O2Zsr6EzQy4c0SOHDG7Q9SnGd+hzgojI35w7oKZnHaE0XWPAOCKEbKcP0z+gMyrSH9LnHfMFnWkR7HcJPogc/3t6f7vxPQ+r6aecd3oR8eJYG1aDILjX9UdjzIMiooWy+NkgCN4fBMHPisjPGmP+uYj8uIj8qxejUKOIQT8m1c2sJDegrJ+n5dZ+MKRf4VyAT4ZWhL/1mLVMxkk7nQYjCiEDg3hMOuN2bmpORZkJYYQkMPAYfeDth54VEZFfePLNIiKSRMjYfhf+1NVoyEVa/Bh+LQXVfFpuByU719C3P8gghB2YCZ2d47gRrabQIYDFN9YXGcyg3mTNMTIF3v87Ye0/eRziCLQGIwQi3+Hdgq08w2/S5zkMYdeA3sCENQvHNqx5tLfDtit90hM1274plJmsD6IzhfZPw4raiktuzM5JjYp9H22u2TknhldHvAJmAqy9KfihJ5tkUdjf5Y6XbRkL9j5hXwBLgO3NqA7VvfadlYZ/e2Uv2jlNH31Yl++2923U4JcP1kdtHe+8gQnbMw5LdR+vVlqRae1nNAHOR2Fkj0WUvQTmSCoe+eTvmpPoq3jOJMcO8FwHDdwflvR205ZnMMGQCrBGV9DXsFSKd7b6bTK0piMqACIhUJuC7dfLo66IUNFPsV+yrAgVisgUjK40QNSU4pTt51WEzp7badtg6ZRdE7V32vdh+ry9fwIRKVoYyl0sGaeeQejN9U4YuWWQia6xexO2oRjOtD1lH1AYEQHNQyZNGKksFv1uEB2O0TH41twKYQqNAMfrkW1EC36yyvCeF0V5qINFMmnLnF+yN2vMIBIFI1AwCAqjZnCKRBn7mDOTa2gLA+s/njn1HRgmNYV5qj5vE3JL0UoMELqUISFTCGvJdCKIidR2Qg8mE2V8ME8yO9huZKCxXZnOaBAsc8K9dHvxcQ0wFIwxCyLyjSJy+qLkt4nIIfx7tYj8d3w6MVIHCvnxptz3zkvju3/+Y7erv1/a0BfvIiKpsiNE4w06jf/c+pya3su5DxTWmvrmKHAcKKw7fl9r6Qv+4oQ75CHFYIbBkC3DaOpsaPmJV/21M48/33G3mh58Sg/rlrxfd59wuaxUB+4DhcWaO5yeBleYmOIxdxvWHUv+qft12vr5o47+5nD1SC+6h2cY0moIFPMZxuve/LSa/vjRO5x5OHQtperob9ln9E1y/dW6u8V2eO3uk2r6J2o3qempin6gcGrN7fJAMaBL8Er9MCOd1N/er9mhb1WPVfRDSRGRo3v0xp3/nF6m2oJ+cFfKuIURzy+Pq+nNc3q66yCMC4ZhGIcblIiInNP7Qmtav9fEYb1t7/rWw84sHv6sfsJz5Bcd77wf/1PnvV40vASLgyAIdAXgS/H7IvIh8QcKTqRSPdm7c01Or9sXXBb0XC4swxjp2PgyNnocNOwA4ouy026k6wewU0A3CBIim6CNhyJ0WPwmlhhs3n58xzd+VkRE/uCJ++y1CLEYg5igrNh5NwlqPDd73KRwg5ZexwYJYfUG3IhN28OPMO48QtrxAKE1CdcM0LEp+NYtBJJYhJAkDrnpEtIr2u+n4nauy0xC+PErFJ2jGJ/9XelUJ5IX6e3cyAYQMgwgFNfYs1MuBgURGZO+Dbo0nxPbtlNCmMoKBBDnuhKj0iZdKMdsOxQO24mPG8dwA8RXCl5fpsfNHjY4ELULIGLJePIMeVk+CME3ZstNDabsLrpKCyKQyedsQrDL/qC2ZNswtRYP788NEEX6UptsX+YxREuHe0ayBmHHnfZ9mFiuoF1sHWo7bGVTELtszuA+qFMLInYMUcrwnwEOwYJ12zeH3165xejGd5DYGgepCu5JEcaW/dHGzbbepRNNlMWWLQwrCNcICnASPFzh4UWA59frcddoy7x8YipSt9QKQnFiPE09hT5WiLo9XYwAbkGdcRxwoV/SnaWxYNsjXca9MKZyy8g0NiQCmOKEgTrgkIkhxRkekuEPeYDUGbef40ejoUwZ+rEfCoHyII+HBEa6u+07Ogn3iLXb0M70kkGzteGqy2ubdNHBOOljOZioRwU8GRo2/B2WBCasI+arNTtnbNzKOQMCkhVbkPZOm74V2hRzT9pIHLZiRFMNQ6/SDYwHYWyvNuzN+bXoHMpPzvss20uCa+BAQUT+i4j8MxF5/0Vp7xSR3w2CIBCRLxhjxo0xO4IguOC6yUgdKHh4eHh4eFwVUGDpKsIYcygIgiP4+k4Ree5qlsfDw8PDw8NDwYu3Zpg2xjx60fdfC4Lg117IhcaYd4rIuSAIvmxM5Ehwl4icuej7WaRdHwcKtUpWPv/RSy2unUmdm5tecVvYJl/rsDKv6dTcQU63vPE0TcNmXbfixeP6veqOUI8UPxlGJr+NaKFDfJGWmGGYvn6v3/qdb3LmUXO4NozfrwsK5tJ6oeIuUU23cVZaXb1rdzp6ej+r5/Fvf/R3nHm89/A71PTqR3QGRnCLoz3mdGZGOelmYLR368/DFZLzoVP71fSUO+qnU0Cv09Av6h7U6xdb1PvtsaTbgv9cV2f8pE463Ccc/dnF9hGR8HR7GNVVnQnUbOkN8vAHdXeSW37ALeh53CG4Ofmek2p61uFmsmubsJjnHe4Te+/TxRpPPaKH0XSJg6Y23G3bvkNnpfRT+vOr7tXb9sxTh5x5xLZxCbqO8e+NMTeJtZeeEpH3XOXyXNPo1pJy/gs7JQdLb6pKgTz793RVt6YGYVhIa/FNQoyNoSE7Y7AoZmOhWGJlP6jZsPL2i/bee2+0a433fez19t7Tdh6lC0TqWDaSNy2rebhh5FYYjhJlgh9bL28ZCek1UJuLoHS3bIFquxi+khR8e98tKz++Z4Mwb7K6mgfgolCFMB4YDJ00hB9DqyVcHWChreyxf8+t2vZsTZEmjbxI1UbI6+yinUc2D1krZW0nKfrRMnZLFHuExTwF2nwLLI/NhLSwdstWo/RmWvMpjlg6AcsprMvMi8yD+k0Q3OyQcQI2BBgMAaj3ZIwwBCP7QWsKZR2DOwao46EL2Sbm+kSUrh3rGUnR6gvLdgbhIUN2Shmie2DQdBDWsFuAFR7PurHD1qENJget/xs3RUMnMvxmHO1oMK33sF4yEFaOt+x9s8vRdwLLTjJb8XRf2mOk1tjE/AWEYIRVnf2ZbhgUCazujor68d5kljD8Zrc0wHf01c0M2gR9a9N+Zlaj1ydQt7B8QG4JbdqG0GE2Lr0MwnTCLaMxn8J3urHw2UPUks8e7hkcT12EgUyhTN0JuH9gnBWOgtKfZ1nAdFhBOEjMW3T7MAHcbdpkEeB35Whf7ZTiW+KYYPuQ5cPwmCHjg2wJfm9G3Z4SFbiLgT2RYKhQukagL6XX0Uch+ElmRH3BrrdKp+yD7YzZxmqDVZGs29/X9oJplSTrJQjdMpgX262xAFePdTJJwLJYZMhW+/vcBbrdcP7AuCpfxdDTXxu+ZjdJEfkZse4Of2uM1IGCh4eHh4fH1UEgEjj8hF6qEgSBLgDi4eHh4eHhcQ3hpVkzuNwkjTF3iMh+ESE7YbeIfMkYc5+InBORi0PZ7UaaEyN1oBBvi4wdu9RqtbzgCBXo0EkQEbl5XNdKWHvYYX12iJB1i24WRNDUrY6DtuMaR/jE3Dn99023RIQUT+udOOHQRYw3HFbKTbeVMFbTy9U+pVt0Z998Wk3vOdTiBroxXkREug6GQs+RTgGfYfyrZ/+OM4/yuoNBcIduLs+edIhwPucIX3qzO+wgfRiHUblJ7+vFh/Twe7RAqHk4DmkZYm0YO/fpwoHNjt7PKzV3yMrd02W9TL+jP7/N/Xoenbq7kxQret3n9+gMmraj7wQ6+UOycffzyyzr4+nCH+xT0zdv0su64363KGOi6gil+ZDOROhOX96pfLDN22PQ0/NuzujpjXnHS9UVMlZE0uv6vRbe+5Ca/jISZfR4iRDrWatqftH2/douaChgOmlDnG7yWYQ0g39vfbe1qjVmKX4GoUQModYU/HyzW/7jjZ2wmsO6/M2v/pKIiHzwYSueHRITwcjLHINfOq5nxOP0Bi199Ke2f+inoScADQVa+AhaJ2lxp5AZLb4dWCZjbf4eFnIjEkzCBx8NE9+IhhMkCqcYAs5e24KoZXvSfh/DdEUBPWorcJ3Eulb3ZSK/i/WiGgn0jWZ7U9shtFRuxsOyi1g/blqDs0uwfDei10w8F2UEJBESsJ2iKh3u1aeoXNTqz2VKN0erKazUs1EfdIr+mVAQwX709sJ3HCK4A8x9tAinN7ZCWCYhvElmwmBoLm5P2Xu0oKOVguW2jXamT392KNwen2emjLpg2cC1Vihmx3bt8PlE+1Log8665SmCZ8LxkIReQz8dFYQk0yaGZ1/bgb/jXhVofVM4j/oODE8Ya0ffGfEMmCBg+XUmYbWHDkgGlnPqh2XB+qC1uoHnzN+nNjvSA+NjwBCrsJonWtCgwLxBCzqt/awDxQLJ/O1CiyQBzQ+GPaXlPIMlCduOOhKZdYq/4v58hQ+9NhmSkaykfsqEfae2mywTiZSF4TO3NClIkbIfuXPUWsH3RWoc2O9ZsCjIeGDZKRbbLdhCF49Zhm533DbS2u2277JvkgoR6oJgDDQmt/QZumB7cU0Qx9rHDKJspLB/ghTMdmyPS6QNKPr6kuAqrhmCIHhKRGb53RhzUkTuDYJg1RjzlyLy48aYPxIrxri5nX6CyIgdKHh4eHh4eHh4eHh4eHh4eHxN+JCIvF1EjoqVpv3Br3bBSB0o9AqBLL/hUrXwWEo/bXrtNzzvvNdfP3Kbmp5wWLITDt/uzrw77JnZ0K2nxqjJUji5jaq6gtoB9ynb2Ak9k4GLHOGIyrf/+47ofxCRxw7vU9ODTYel/hKNYIuYQ0Oh51CfFxHpOsJZmqrDyuwIB1o5Me7M44Y7dPbPsXM6NeTetzsiLfy5HoXkPa/9lDPvvzqvX9Md6FbbxZSDBeHwjxfZOt0dRrym57H+eZ29k1nT79+/y23BvxAv6WV6rf5c6U98CdpuFpI4LtlV0KM8PPMJPYQow39dgjldq0BEJOVgR6zfp7dJvKz327QrbpSIFM7o6b23ltX0joNxY+r6pNCad88vJqbXb/MW/RpT0lk9yaQ7j2ZS7wtXLcrDNSDK6HF5MD1rCaO1dPI5+l/bz/oO28dohW7OW9M4mQnUH6jvoAXW3pcWyc7Y1jtqULB9eWGvDVf94U9Yl1cGj4l1YYl+PspMGDuBMUD9BnymN6EgD70Gvrs3D9gyJ6FfsHq3NRnSatyYg9U0G7Ui96E/wHc9ldKDZCDx5VSkTKXj9pPWR1oxY52oTzJV7WmV3Ip/Zz+oMRUf8pMP6xrfUqUX2VKcpxWVvvvh76FPkViD5Rhzc6xvpHg8yghg2WiJnnja0ic6U1nUzTZENw+1/0U7N9d3RJkJ9C1vT6KsjNgYo+o9GA07g8h3WqkTDXv/7NMIOYi2SUCZnur4yWoQRsNhu2UXrUm1M2mfD8Nysn0zG7aPNODLn0AfYHvW5+19avth4YX6fXU/LejIu0IdCZQNFvQ0LOdkMhTPgNVRQnQJPPfYGupa60uA8H/tcbBIQO6lPgYZA+wLvDet0bQiN+cYbhJ+8dDR6BeQJzQTMk8PMyGhT3AezAUyTzpRhsrYYUuBqBwsoBwMBZCS9hi0PBhVA/P+2i0IdYglBK33nfGotb2L72QkhKyYKlksKCkuS29Cd6BGRgKYDbDy58/aC1oz6ch1HTyHDhgV7KOJRiAdaEWwXWsLQaQ9tjQQyKIYIC+UmWEgwTriOOL44pgcO2YnB4aGbezKoQxgc+yyjcRwlbOP27qs3maf2+RzllbQmqROBfLLBWF7pTHeByDPMvrJ8PIoi+h2nCvbE5i/hpZ83eJLtDW+xtYMQRDsu+j/gYj82OVcP1IHCh4eHh4eHlcN3uXBw8PDw8PD44VghNYMo3WgEIhI91KramJJZw8s7So6b/XmVz2jpv/1ozpzIcjolrRkwSE/LyJmSbcIxhxW48yq3vHoXziM+t3uvAcJ3Q8+5jAaGwcZ4EtfusGZR8xxTc8RUaHnsK67lPozy27GRsthmA4cyvDO55R3W9GPn9ejFMw8qLfto8/rrILikl6mo41ZNV1EpNPX635gTKcDlM/qURPaBx2hDkQkcET2SC3q9XNIXUj+m/WIKZtH3SIf6S/qmg8upowrb6PMB1/tXkf+zMFEcOhN9Ap6R19p6XUQEWnOOcrlaPOJZ/T0tVe5I4GEMa+HcG5Rn/ey03pkhmZHj3qRP+F+fTT26OyBzFxdz8MRWSN/2K2zMfYWXbNj7cSE85orjhFaHFwPSFQ7MvmZ09Lda+eiftb2aUYbSEFhnFZq+kiHvtGYCkOr6U5YEAtbpjFTt/e860arEfTlw3tERCQGtmMS/r6lE/Qppy+3vRc1EWg1S0PHwfQR0cDYMRL6t8fpv83oA7Yctd1RZkLofwxleTNu34FBBb7miNkea8VCSzXnWfoe05d/7ATLCCX+VlRlnhESGFUgBUYIdRyoUt/LRTUXwnzx3u4uWGtlUIPFHTpN/Rk6l8My2aXyvE1OrYvkL6B9YZ3Pnbft2Nhl14dBkj74NtP8ip2rmgtFtB/8z/He4HNq8TWN6ZZRBriO6xXt/WgxZ11S9OGHtgIjVqQ37Cd9+bt5+ucHkjlrnb978DfvlqL6DvSVbyJ6BvUcWNbq3qhCfwAmGXUHmjttO6bWYNlGuyYaiBCCV0QSPuj5ZVs3PtdEHXVFtANa0HvIP7PSkdZ0VN+CluwkGBlkvdC63x1DX+AjzlA7JKr7wPZn2fmdVmm2I/t9dtX290GCLBlEHpnGc85CO6GMjEEd7uVi0imQsRFl0LAunTHUZZ/tr+kTdqLg2jdkeYbPwX6yfdPQJqPGSMhaaWB+YSQRRJXpZ+zzJjOEjAlGVIh3wGYqIWpE1oSRDwZDWglkVw122PGRfsrOLy3oHDHqQ2JINo6REbpgz6SHIiUMsozagGgZ+F0XmhkpRNRZvd3mx+e/egfaDkuEBObaWNeEzI9EHUyDFhkj0bqksSzOMiJOnpFGoiwNsotYxpcEI7RmGKkDhbF8U97xqi9fkv6pP32l+vtTH9vnvNfzs/piPLNQU9O7x/RFenHOLZrWqusbjpijL+cX9c0thWGGUSrpQpEi7vBtXff+RMX4/g3n31qPTKnproOR9Zv0TYXL5aG5y033Tm7oG+74kGAPkdqpt22t5gjVKeFcdAmqC3oehdeu6L9v6hv0T3/yTmfepJwOo/I9+oaNIbGGkc27Y28OHAc8CUfYyPrden87/7x+MEK6mob2ffo4SyT0wdH73JiazlBRGrgYGEbV4So0e4N+WLP+Zf1gpNV3T6/xe8pq+g8ceEJN/5Pjb7rsPEiLHIbJuQ/JNKQm9EOnenybmKMOTBb0Q4v6X+suLge/87DzXo89v09Nd/cqD48ogkxS2jfOi8HGN8VNJIwN3PAmQc+t7IF7AYYd3e64YUvP2/7d2uCq3Mhr77GulQ996SYR2XJtKJyORe7F8ILjx7GpQwhAbjoyF+y9BzmEZsQmIdxEzmJngKmeblWbELFjWDduaHt0x4hHNy2xks03KNv7xVtG0hvcwMCVYQVh2XAwwGtJAU9AuTx7Buufjr1n7KBdEzTmKGLJTc3QQcLQ8ouhv9MZHFyscdNH3wlsaDcpuGiTC+e2KM40vHCj00V4uuJzlu9cP2jnoNxp2we6U3Y9QpHALpYndGVo49yyn2Id8IkN78CwLjx8wcEBXlXdAt0P7PfJp6Mb38KZJupk599BNindGVuIAJvb9LL9TXs2GynblotI9ACBriJcY3bHQfuHuGJqHQcJWA/F1xm2MLr5zC3Zzw7cAMaP2DJyM567YMuVf84+/9Y+rAWD4JLNNw94WqDjVw/ZMmXPR9dwnSmbnqhGDzsy59GXMFx44EDxSwp4UiSQITI55vt5W0eG2syfsmuP+j67Pk/hQIF9tTmV3nJtwiuwMU93C4xJuLHEEU61DeHIZDnq4sBDwMIynz2ahgdp/B0FLLNwJSkj1CbDgubhLrIR3azTbYQinDy46OWC8CCRB109fOeaqfAluHfBkJI9Z9spDHmJ7QvDpfIgIYVDDJY9gUPZ9hTmrW7097xfdQ8ERHGY0hmLlpkHS52JrTbivMOxxWefGtLUZ59rzNk6FM7bzlI4acd6+WZbmdLpLn6/jaushxMjdaDg4eHh4eFxdRCMlLXBw8PDw8PD40phtNYMI3WgsFnPyl89ctcl6eO60VbiTfeDjDnCnt3yKj1qxiNl3ZI9ndMtciIiS7oR1hmOzeXaEO/olvq94272wIkxXaRvOPwQkXQQLcobbkrD3jfqooWnLujMhWz/8lweeKquX6QnD+L6H3Jp3eUh9nE3fbqlV0Nah3Srf/cZh4vEY3qZlt/pZpgk7tI7z7EVPQ9Z0O81U3QMDhFJxnVL/XpVZ9Zkcnobxp/Qaev9bQzcrQs6WyV1Vu8jtPpc8vuyu4+42DjZRZ3dUj+rMy0c3kPS6LpDVsY/Oa6m/8kX3qSm73hIf37nXuOouIjML+n9MONgKBSy+u/LTzr61LSbIeQSkSzdoLMdll6nz5PPf0B3PxERmVnWx83qK698XGcVgYgMrlLeHl8TTKsj6efOS1CA5Tdrx2yiaee++jyo4/moQByptmbOjpk4lBWT+LztlhMiInLP2Bn59Ye+zl6Uh6WzjJBzGCKFsxBcg4BdetXeky4NfTAS4pt2ro7D+tvbZ93YQvE/THXtCTtHVg6CDkxqOKynuxYs0+r8on23BbCgJyBe3aGgcXzL8h4yDzBMKahGmrjBonjii5aFFzRsGbuHdtqyQhSOYpe0OnaKDAkXFVls7oWFHC6HcVSOawEzZ+eRfgvW5TWyNux9SXUmjbs3JpI9Zts1UYHLSBv05yn7Iig+Zc2a9ZvBOGN7FummAXHF+ag1tAexutScbRyGph7A/YLuGewztACzrAVo94bikEfQpxq27i2wZVIrzXBdY/Cf6g22Q5JBQ/HFLQaN4DvZE+hTmeg8FW/Ckg0WQHIZ7dkmM8X+ji4upOLnlmwlYl17XeFYVN2us2sC1/NBDLZC9dECHbftwRDWDP/Y3AVWClxbu1NRJkgYOhttEoDpUUT0cbpzUCCUzBS6DA1SsPbDbYDuORxv6Q3b/s0ZOx7q8xRi3JoHyJDhOqOVpVsFhAxn7D0SK+yfUTHLUPQSy7ni2eg7NQtWUmwT7KQxsGaKtkxhiE1a/fNR1hPDJCaxzKsc2AqZ2UNZBjnG9gSjo2QL1YRbbRp1Y5hOjov8BfQVMhAgshnvcIzjuqotRA9MEI55oj1OAVWUkWFB0SYdiG3SNYj9pDvRl8wFsCa4ZAs4NlFvht0sY75mVcGOGCTt2nTsKMYunn1z6vIE8L9mjNiaYaQOFDw8PDw8PK4aRsja4OHh4eHh4XEFMUJrhhE7UDB6qDvHAdDkV9zsgbNfr5svn/isbjEbP61bQvM3un3U6cs1jMBh+EuWdeueaeuW5EPFZTVdROT54kH9Dw7XIZ7GDyP3rFtj4Bte8Zya/j/L96nprYYjnKSDLSIZ98lezKGh4JBjkLTDGr+yzz3YXfcSR2jKwkm9jzQcAn1zk279jZWyzhLorehsgEO36myR9jY++EmHmEfcoV8Z+7xuLa/dpffbzBF330mt68+8e19Vz/tJXcPEJdYoItJ36EoYhyiqS4fi69/6uJr+8SM3O/Me7Nf7bnZJLzBFzYbRbLpZEKnnz6vp3eMH1PTknfp86BJqFQfbR2QrJNowJtN6HvSNHkb9NrdoaPdeR8GWdHaLh8clGAQStNoiE9Z/noKGtMJRPLC2C9ZJWNEG4/YlzbdMKgX/azDdfnznJ0VE5JfOv0VkKIRqahP+/iAd0bocWisXy5HfJ5p2DARgLJgERO3itLLBak9L7ZDQG8PppcfsfdZrdnykwCiLxyGcOIhafDkPpsqxMAweyxoK6a1Gx3OQQXhJaib0GI7Q5s2wm7SoUuiutmC/UsAwWbTrpmLeXldEuy6WYa1Hezc3o6HkaE2lZZZMivR6P7SUkiXRn8jhWlhU2a6wrNKSSsZobTYq4NaZATsj27u4KpJDmcmmqFdtmUMtBWgH5RaH+kWVAom4b8OWN3Nu6z2cgpDkoGTbMc3QlWDQUER0/WZY9UtRf3YKb8YorgkBToZalKE+RIsuQ5CG46IKrYCWrTs1HUJNjEx0XdGetAPnYt903jtkCrL7MfIlhM55TRz6GAOwAsKwmxhHtMpzHFHEMdFipfB9tYp8cD+0Zbdky5iEZkULbIAwNCTq1pk0l7QrtSU4ZrpTyLwb1UwgyPTgdWQfD4bEFttTdo2UgnBkrAYhSWgnUCeJjKomBC8ZyrSfjQpXUii0PTEIQ6wG1Prgo2FXYChLLEP5XLbYD2QVgZ1yCqKuWKv08dwobhnrUG8lyqoIWdF4PmEYbpYD5WLIWOpO9DMmXJNll5HG5RBvwe9gO1BgM4722hLFpL6JLUzphJsd7OHGiB0oeHh4eHh4XCWMkLXBw8PDw8PD4wpihNYMI3WgsFBak//w1t+/JP2fBN+j/r5bcvv/l+7XrfvLR3R/4upBvVMkXLETxW356zuMjgxrNIxBSn+M5a7bUtcd08vl0lBwRUf4gx/5z848/uG//ik1vf0WB2tj0xHHz2UJ3cZC6gpzaXSju8Qdz6lfcvuJm45uNd5z05Kavry4U02neu0w2l+Yd+adduhvdG/Qy3u2rLMHZkuOG20DV9sO7t/U/3D28tkDrb06DSLp0NnoTl6exV9EpO0IX7rjc/q9Kt+nM0Y+9pm71fT+mLvvpKt6uep79WtSH9VPzIMlPTqCiEj34A41fex5/ffFe/VxueyYj4yDiSMiMsjqbTjt6LjNup5J+oSbxZJ5hc52cAfLvdIIRAajszi4HhAMBjJoNCTWsy+G/oxdE3QLtm83ZmHFRPfsFqOW3LGSdSzOQDvhX97wVyIi8s8Pf5uIiNTbKckgSkp70b6PGWIyg7CAqc0e7g1/YFrKz9lwu7E5+PQnGQ4i6pPcy2FdgIVpbQF+w8t2jqGmD636rRY0HMBIYHoKEXS6CO82aMEnur1l5SVpLXMevt0NW5nuvH2/xCs2r8Gs9Z2Pb9jfdWcKuBf9rVl2e784/Lm7CLfZxXzQTMASDGt/GmWtnrHzXnaJlnj6stvPJHz8kzXcr5DYCgsJLQpDy+lxy+RqvPaGyDUGPuQGptoKiF20fMcQmzoAKbBPzQSYcrttPM+UrUPxKNody5wGtBjGj9i/55Zh4aUVn5SH83Ytagp5ad4yj7LZ+lX223ZiiMn6HMqM50RrLiMi8K3Th67DzB6rs7Wxaft98tkc2gt9CJF5aTkvnWEEEltWA+2EeAWaGegHySX7ruznoElSt9cN0vEw8gCZNfSdTyGSSOduPJ9l27CdXZjRKRICi3piORrGMzn0OmBf5fiihby1fwplsgvw9pQtQO55W9nebPSdGkZ6gYZAdV8gfegOUMdhkIyyIEKQ4VGLhqys77Lfx45Ho6Qw3GPmgn1PBmAmDNBXG/ts2VJVRGIBA6c1Qa0XEykHI1yQYUwtDTESMhTCKC9tMAfQr9l32F+pm1E4bxuWfYChS2MphqkFk6DL6A5plBHzCZgJtZ0M14kyoqyZlaimQmcHmFQbyAd9P1GPhWyGMMrOOtpvA+Mf7cNnz36cWWMkF9vvyaBhuMjqPhTmc3KFMVprhpE6UDi7NiU/87vff0l64NicNHZsI9j2uB4KTkqOjadjczJwCAqKuDfvLpCqN4z2jE5zd1HWRUT64/rGJZbSrzHn9IX99/3CP3HmMXA0YcERzrK56FC3c2xgKR6jwTj2coHjzML1nJIl9/Zk8oN6u3/q2/9CTf/dPfph1H/4rXer6a0Z92GUcbiBxBxhEs0j+oFC7AHdhUDEHa7TdRDQe1bf3BYcwogd915Y4hn9ASZTenrX0Z/bXccDF5HBhH6it/od+jPvHtfbcM/H9LzPv96d947X6i4oqZ/VG4VCUcOgiJmGWEuvX6Ktj+XtRCQ1BMVtRBnX9PL2Bvqh6Pff+bCa/tu117vzb7vb18PjhcAkExKfn5XOrD30bI/bPkUqMUMDUjSNInVB2r579o7ZDdnvHbAHCd/w9HeKiD1IEBHpdBLSP24309lNUqcFedhPUvEZslJW7T0HDbtDCqaiB7KdPeMiItKEAB9F7pqzpD+Tmm3fHxNTdo7nXLh/xirCna/Yuaa6ZhfVMRwQUrgvhRB3mZVAxo8ghCEo193xDNoDonOgiQsPQcZw77vtoSbp0ZW9URE1bhrCDRkB94A9k7Ytji1iMXHWvnNpS+BBQnaRbh84+CDdnRTxhAk3Z0Hd1iUGV5L66w+JiEjutG2njdvtPL95EPWHgF4PopaxKRy8LkXn0ULOppfLaM8lW7k4XF5aEBXMoaylk3R1IfU8GuKRYm3d2/baulRaUp+3zzC3bCsYPmuEb+RhEje8dFEwWZT9vC2zgUjzyiLeadhMckalW2OBwnsVHEZNQyAUgpFhmQm0/yCfiXxn29d3JMONfwtjq4UQ7UES/e4YTpkQxtDg8CNAv4xD1DTRwFjEOprCzLklCkbaMqaW6rje/jC5Fn2/xyAYWrvN9rF+GgdxCLlJA0pr6qIDDZQlUUGYUhwYNPd0kQc2+AjLyY18qmJ/xxCWmTUeeOE+EGZt7LHjh4dbMQiIJhp0bUBIV7hNUxixtht9nOEh89x848CuuCXOGa/ysBQuUXAzpQhi4XQQVldkS9iQ7hl0Z6J7RgdzZwpzAg8WWpM2nyzq2phJoC0grljEgQ3mWIbgJOKbCdQdBxxpuloYKUCAs74T9YSLRxdDtHTYPvvVe217FhEWsrXbfm/Mom9RQJKHKQ53dI/tMVIHCh4eHh4eHlcFgUgQjI5is4eHh4eHh8cVwoitGUbqQCFIBdLcd6l1sTilh8artdwm0vRtOn27e9ZxjcNq2+pvYyFNOayLjv7FU7RhZFZ0i/96x+3ykJ/Qr0kldKtj7axu1Zx72B12cOlVuktJ5bxOgc/UHO3haiaHUJ2ImzHiCsnZ6jn+cMrdhpV9esF+9Nxr1PRPfOQVavrgLp26fd/eU868H374Jv0PMzptvVfR2RTbMWhqHZ0x4mLW9PbpAnrxrG4pN0+7x9/dC2fV9Kc+fUjP44Den+Mtt9XdOMqV+JLeP29+2zE1ff3Te9X0pKs/i0j1j3T3l7Uf1st042/orInMqjuPzoQ+ZqsL+riZcTFSXBGU+u68+1MOkUWHP9eHHr9fTS/ucDNoJn5Df05n3uq85MpjhOiL1wXicRmMbwnc0tpPOjbfF6QOk/5LIcMf3vkZERH53uPvEBGRFkIGNuoXjT1YJ/ugTqfgEUd6Mq396dPWGm8m4D6A930P4e3oTpBo2jxyuE9jFqwK/J7uGbTkrV+w9zNgVZwT+73dIlUZVtRUlPLM0Hf9dCCdcYgtwpqeXAd7Au6WpgkKfD7PBsK1MdQVbUFmAZq8NUNuvv2IwcVh0LYJRy/YUL0JuJS0J2l1tmWnwGFopS5FWRr9/BZNOr4OKn3ePswga99v6XVb9saeIsoG+vQGiozpkuyUPtpf4NbFWXBjFeKLiegCzmCeLOH1QZo26e0hJR8U8VC4MAU2QBMCl8sbIjKBetr2aU2SNk4XBYrLwdq8AwyS8xBFBPWdLp50a4k1o1T5NNwPuDyo77TPf/w5a0Zmnx0WYWSdYi3bpgxrSap5vB3Ixs1RcUu+dhIQXaSLQ+q8zZPuuaYRj1wXivhhrTf5DJke0b+3dlMUE20E94xB0daBgpYc+7TAU0STbFda7lMbJnQzJkOQln+TGkTSZR3MA1jXGaqe7RFa/9cQHhXMj0Ga90ffqEfXdRQPpLDh5n62v+D+9jMULQQrprEHP4gF0gfjxnRZNvunNIQbsxt0geKzA2MGbJhUGYWh+GuerhLoe2BQ0V1q7TaGjrW/b02TsWO/1/ZEn18fAq2Fo/Y+bTB8DJ7/IBVIaxICp5gLc8tR1o+AaUY2RIB25x4+u2rzaI9BzDIdZaW8JBihNcNIHSh4eHh4eHhcNYyQwJKHh4eHh4fHFcQIrRlG6kDB9Iwkly9lBAwmdItcEHM/yOqyHpbvba/+spr+pZ+/W01f3eMWfuy5jN+OYnUmdItxP6vXr1HTfb5FRGaKujiay29+Y0pnLqz+H+6wbpUlh3XYIaaYdJEdHO3R2uE+Ruw5KCPGYVXt9Bxm2L3u0KKFj+oP8MFP6EyEnkMIUzp63o+f3+3M+9Wv1pX1Pn9YDwm47wO6oOCFu9wMDBd7IZbX0wuP6SyIzrie7grDKCLy1Gd0JoKLBVHK6+mVolvUbyynszk25/Q2efKJ/Wr6zh/RBVyTf+kW1Ww6QoWKQ+hz8wa9TC6RURGRQVq/V1yvtmw29baipWAY2dNu9lVzhz5fPLmiC0Umz+pzRXLKzVA4+xYXQ2l0XtAeVxZBzEg/n5KNm+wcRQYCX4MUDOtAOJf+xm/Yf1xERH7yEauZ0IdYLC3rNFvHyglJVWCRpZgfrGe0plEwrDcTtaSaCfjiw3+6O23nAFpUN/dBqA3+w7R0dccwXsGMyIKN2Czb8d06YfPhuKYYW6JuP4dDL2bXA0lCVK9XhLBg2paBYSPbu8dQlyLaC2WbhjUTIRF72agQXxLitKFI9Bp0B1CFPkSP+mBpJNbt98xyVORuS3dAUIc+8tuynNMiHcOUUrsJwpHwWw+1gdCc1M/YCg0I6zt8ugdov6CBZTQ0AAQ+/pybyRpoTaGo1HeAYBznafY5hgfv51Nh2UVEavfulcw664X6w9e7M0ZmAvUz7O8ymFdbYCrE6hCxXKcGBvzX0Ucza1G/dmqJZFfQBxGukGH3EhVb1sYC2R2wUs/b+9MS35il0ORWO4difzUydTAeIM5N/38y4RLNYaaH/aQAH9uEIS7JuKFgH/tze2E8UrZuLuo335yI6hA0dkb1OQZJkfQaBQjtb2IMqQjhwDR0N9qTUX0APqdUFWMeeQvW8AmUuYfvZkC9iBTyJuPH3qc+RyaDvU11X1Sng32QfTm9hPEQSNjPYyA/hu2GdqG1nlJsrXHbd6hNQSHDsI8s23TOT5znuhRMXGOGErmO7CWWg3oPsg6theoQu4Bza1dk7KQtXCfPUJWoZ4PjAGsaXEPmWe6M3Wxs3kjtHI4f1kU8vgaM1IGCh4eHh4fHVUEQhEJqHh4eHh4eHh5OjNiaYaQOFIqlhjzwwOOXpH/46dvU38cdivgiIvOf161cn1zUrc+/8m9+VU3/kS/pIStFRIKCw5LmsAyv3a5b8RIN/T6VNTdD4Z49Z9T03sARPaChW9FzKUfsSxHJLayp6a5QmuXHdb9ypxU27TbPBh29DYOU3laNls7+MNuwWDZv0NNjjsAQCUd4hPmb1tX05YfdFu7PVw+q6bkjeh858b/rz2nQcE8BrpqndNd1Z1SK4nG93u1tolgETf35/YM7H1LTP3LhVjV9M+1+foW0/qA2cnq/onVnGEvruhbEdNldv83bHOVK6ddUF/TnVDzjzqN8QGcQtGb0vOOdy4uaQEVrFY5ira/obZV1RKtoPKZHRhER2f2ozoI481a3tsMVxwjRF68H9HIxWb0rF1oxqb5O3/RhP+177jkqIiKfftiuKWJ4z8TpD475hpb3WHvLOlk6jXCE9N9dtMwBWvq6BTt3p8v2dxWwG/NQ9KeifnPKzkO0Osapdk92BX2/UYZW096HgvxcXiRhAWSPpeZLAkxBhiKMtwfSmEN4QlghGXKvX7Jlry7Yv/MVl65ABR8+47RC0prcwrA28NemHzctifRBj8PHP4hH1fRp5aeVe+bLCF+J0JvUGBh/0q5BulN5aSzYQiQalo1S3WV/O37M1mX9ZkTNGAq1x/B5XC/2oZ3A90HoLw8qAxkJZKBmV6IsgvwifdGhso+pPddiZAY85x2IaIEIGc2peHgPojmH/gYCYg9ryuw5WK7xiqNlmvoauUVGCEGWjIbK8JCw/PYyYN4glCmZH3wTkpnQKUbf8bUd0EMoMT9ambcs4Cy7YI2V3GRe0TJlwUbhvcjY6IFEnFiMRiPILSH8JizgLDvB/Df3Q4ejEU1vI7oD2473vThyAteksaFXELUS+jCMF0/yYvuRwnPKrqEd24i+AZYSIyWEeijo3y1omDRnomVr7ICuQzlqWWdEETJyQ00x6lXUTcgASa+DKVCIMjn4rPvoAxmGVMRYZ/jHDLQW1m8BewVMj/qOqBaJDM0/7HssG5lA6XL0HUqdBI6jMDpOc2tsFCp2DDOCBNkqHcwHLCPHfGOqhLLaexXP2L/Xu/bmDReD9EpghNYMI3WgUKnm5GOfunTDH9uh06Fnbl1x3qt6ek5Nb8/qi9if+O/vUdNbt7rDDsYcBwrGIdKR2tQ3ZrW9+v0H644wjCIycYNO5a92HRRxR58/vzTuzEPK+uaW4YGGMdnWM3GJwpmKewMUZB3hLzN6eruh36v4hJsyX7lF31BxoTaMtENAr/oBnQbefqWDmy4imVP6s51+yrHJulkvU9DcZgpwbAq7roMwByq3O0QZHf1ARESa+vN43/F71PSJnC7K6OprIiK5pGNsOtxixm7YUNN3j22q6auDfc68pafnEXc8D+cY2KYJ67v151S6VT/oW1/WN/smq/epwpPusVG9Qb/GNBzuZ45uOP959/x5+q2uvnv1XtDBCFkbrgsEoM1jUVfdY/tnewoh7PDOze21O4HHH7OnyKRfJyukY9vbUWj5YhpxbiW6OWOIt9Y0aOegBlMUrraLuzz7UduJRXIm6i7AhTiFCXs4zEgvYTMHCnn+bDysq8jWAT03KxQs4wHCVttgI1yIhQcu/d22bPnz+EkiOp47Rc5rDBMYFa2j2B/p4708Q89RAA/55KIbJQrGcXMX0qCRfXMWmxwIxzH+fPlO62fQzZuQ0t2cgLtGzX5fvwUbSxykhO4Ym9E5miKZyVq0PfmcKFLHuZruGKkahOJQ2FQlugZJwJ2kss/2h/iMLQ/DFhKDhJEE6lCBPSF00cHmkC4MnYlo/2WZ2J5JtF8aZQwPHjax0cXhBjeH3OBSsJAuLURjDpR9imGiDTmv13dtHRhxQxkeYlCDkuGleYiH10sXBzPjh7HpRh8rncC4SkcPo1jWKvpqGu4F7XG4C+R44MMDBOQ/5F3HQzDWhePGDLYOmehiQheD/AWMbTw7Pvtw7IJyTxFAHjA0d9tMGFqxNTF0oIkycKw25jHv1KLjKzygwxqGLszhQR/HU0ukAN1rhrRkA+YXbUU3brTPePx4NLQl6xS6s0B8MbdMd5yo6GZ3yHuch1rhHFnjwY/9zhCQuSWbnlm339m3eHjLvigiUp+DgCn6Kz8pFBm6kdE7LAw1yr5AkVMczrptzS86RmnN8BI2m4eHh4eHh4eHh4eHh4eHx6hgpBgKpr910n0xEku6KNzavW7KfPdu3TpcmtAt+5WELr4YK7ubeOAQO3OJFgbLusXf5RKQXnbFexOp93QLdzbuoMZnHadoLXcecd1IKZkLepsYF/XHUb/tBOmSY/rzG/T1M7ReRW/b6kF3Jm+58ytqej6h570rXVbTf+d936Cmjz/qZphs3qKXK/VTF9T04LBDDG/D/fxcVvHemCPvSZ0J5Hqs3bLbwn3wFXrYyOU/26OmJ79dFxl1MVJERPqOY+j8ab1/1tcn1fRnChNq+uw2rLniCQfbaJ8+zlzuJIUz7kxiDo+EjeN6PSSt5xE4GBvFb1h05l09rrsqZM/pnap5kz5mTu5wn3nHHCKuh37iYTX9lPNOLxaCkaIvXg/op63rWuE0Lbs049uPe9/+tIiIPPqh20VEJEvCDGm7tKKSrgsSE611nUIsFH1j+LQWLORNTBClUwjPBqE10pqzq1FrdBJEqPYkLXb2+wB5t2chxHceFsNFCLzBwksLOi2vvD8t9RQ0o3WP1ur2WDy05mbAtqjst+9LMhdamFJYJlqk27CUc63Tz8KFAfNyahkicf0olZsMEFrg80t0v6ClkRZZ+3c+j5DdSes3NTL7Imt3wGoMVklqE4wFuICRrk5shaIEg2MlakEP6eNYEoY0d9CnaYGndToH1xWGDyVjpQ2xu9Y08ycrA1bW0pZVufwWvGMX7dogVR4SB8Scz2dO+jrrRgs3LeWF83BdSVM4FHnCGk2LLtu1CWs0X510DWKdm1PR+ToJq38H3reDVBA+U7qG0JUntMKjn5PiznFDBk/xbC9SZrZvPhQLpLuHva58A8QE4RrR2MG2sPlQdLC+C6yYzSj7oDdh88ud3GJl0NWBfaJwDkwEjIfMBpgKYEXQ6p9ZhpsT2ElNUPQ59tgXQhZHyFCgmwjSUWYKW289J/uZDJdDqGuVz9WmZtYGYb3j+FtsmS4+9g9k+bCd2WfCMKq4vgGrfms6Hvk7GR/siy3MW+yjoavPYtRFKFkny4LzUJRlcbFHOOfWdIWuI2Q+gVkGMdHKXoq7RtkQdG8KBVO7L/X7e7TWDCN1oODh4eHh4XFVEMhIxZT28PDw8PDwuEIYsTXDSB0omEAkoRhJ21OOB3bSHdKxsObwd9+jN1nM4RMdhkDRsEu3ysUcQoC1m/XbJDI6FWD8IzozQ0Sk1tWt3w2j+64nNnXLYm92G42Irt5WY8d1S2hjxhXe05GBI8SliEg+q7dt4BC8rCzr1nIz6w6L+dkH71DTY109j44jbGRRj+gotYXLn2hOPLFLTc+uO8JobuO+NXAQJAa7dNP3d9/8qJr+8Po+Nf1EfMqZdzGlt/spXdpE2j29rxVKuraCiEi1rVewOac3yre8Ua/fJ8/oIS47z4478x58XVlNz3xRv6Z3t87AGCTdc1h3tz42YymdtTHYcAiTtvS+s/K442GISMwhhuliTZh1fd7JrrgZCrnXrarpR37x1foFP/6nznt5XKeIiQwyQRjGtVeyY2NmwVINHnoIYq+YuwunoiHmaPmjFZUWrmTNvpOzKyK9bPTdma/Yv3XG7HhrF2mphgUQP2/MUuAN1k9oJtA6SmtbtwQBxE2KAtq/d8btZ+l4tIyhzkDV1jV9tmzvs8NqqAziZDbEw7qSxVDB+ofWZFoVOa6b89ALAOOA7xfDOQdhcRmqMobfscy0oIfh9WBVzl+w7/NuwebP9u2nKf7HNsb91myBytN2XmmPbzEJWtNRa213HNZNrFeok5U7Y7+TdcF1CPUcWNYEWBMZ+L9vifjBzx2vsnjL5jNIkJURtbwTPSxFaDWlBXMwKRI/kUGZo30i1MMIQ35G75mC0B2tyrTcpjZtO8WrtpCdafs+SW3Yd0d7yj7oDsJBhhZehtLEa3ftdptAXQ9aiikQ2p5kGxtJ1KL6ABThC4U2cc8UtEaYZ3Y9us7NLrdxT8uWCUMwAmRPZMDE4XgKdTfATKFeB8PIB7GtEJciItmztnHZdonGVv1Y5mSNeiUQhExExxCZH70CxUs5PpAnBCTJaCCjgxgOsR0MvaoHQ30zZHuQJcCQmhjHqfpA0hsQMoT+CMXd2X+7+ahoKMfyINSBiOaVP4c5Yj/nLZtOPZqQ0YP1RMiywDaFbBqGwZ1+YoiZcsb+oFPiuBxIEu1X35kK00S22D9sz7CdME6as5yv0Z9TrDvG7Hb7Ng8nRupAwcPDw8PD46ohGB2BJQ8PDw8PD48riBFaM4zUgcIgKVLfdenD2X/befX3px/VrbkiIt1XVfU/LOfU5Lkv6D+v7nWfdGXyuhU27girOFnUnYabjnBvqZrbB7/V1x99raNf03doKMRXde0BEZHsBb3u3b+vWxb7n5xR011aCYFDa2I7FDM6c6FZcbAKxt0aA2nHKWbjgG6GnXhMb/OGLm8gM0+467d6p265vf31R9X0M7+tx7hkqCANgYOcEc/plu/3/fGb1PTeHbp1fbKk65GIiDxxZreannYEvhg4mCcHJvSQnCIiR9d0P3/jYBu5mAi1sj4njCXcbZv68JiaXrigs41WXqmPv8E2M3h+TGdn9B06IoM1ndFExfBhdOccIikiYhxhZsdO6IP5lm/V++3Ti47BISLrZTc742ogEJFghOiL1wuCWCBt9OUHXvGMiIg8+LgNC5mABT21QcXxqNI8GQm0NqcQvixe6SC9L3w7d2Zsfx0ko+HxqHrOz9Ys/YFhPYO2SW7Wvv9bZ2yovn4evvqIwhI7A8YDLNsMJUiLbGa1i/va6xJlTPAIqxdvwMKO8jVnbcnTG73Q4kerI9dZtFr2weyIV+y9sjeWRUSktmnnFIZf5uhgWE3qOvAPtELnlmkBjkYZyCzZOS3WsO0bK9kCdUo2Hz6Pyl60xTjKlwkkVotqIHQP2PobRKNiH0igDgwbyfZjmLs0Ql9mEBY4VYnOgyHzIDM0ByJ7WoszqGsD7dwp8nr72UF5OJcGqUEYVjgOba7uBPpKM8r46CDqw9hR0iUEZYZ/PBgegxQqV7DtRYt5B2EKc6fQifZa9krH2N+XoUfBPtYHI43MhX6JbTdA2dEm2UHYV0qfi7JdQhX/Dhkftr8yFGhYZlj/4zUwFMBa6YKt0pyMji+GAGzuRN2hO0Fr9aBIagRYA3X8nWXGc6fVOtYJQtYKdRsY9pGIIRykSTMvsCNSjH5iy8q+QA0M6naQTdOcRzuy6w51KUZNYV9lKMjCadwHQ5yRGVLlrb6aXLR7nNzAdrxYFwwatCOZTGQbMfJEqIGAOpFhEH6iDLnzjEBB3QKyaTBXNqKsCYaUpQ4e2QaFMx3cB9FYwKzqp2MyyJHtgHsPrbk4lhgVozNufzcB+bPyTWTSoOwFsLbWXpqt8aitGa7pAwVjzDeJyC+IDXv7G0EQ/PuvepHiLnD81Kz60/HT7gV/eVKnwE/sKavpF76xqOfxuHvDPZnVN1TGQeVfyOt5f/q4vlmcKLsX/Oc29Q2Na7MRZFwxBN1tWHzbkp6HY/PXc2v0qYg7qNgiImNZfTfcH+jXGIfwXOkx96HM+HH94ODUAf33m69zhC+d0g+vlg7qfUpEJPeEvvlzhf1sOhQC0+vuyczlUVJ0hGjcbOt9qudwLdr3Bl14UUSk8Ql9zJo3bKjpG3W9PRKOwzkRkXZLP4hLH9B9UIKHdPFFWdA3yYyTraF2SB+b1aJ+YjJT0OeK8oQe6lFEZMERzjL+/frvj75H729BQS9rYsU9t1HIahikiA/j/M/rc1jzbdsor3b1sfwt939JTf9l951eHATBSFkbXo643DVDOtuRQ7edk2/fafvM//Ppb7bpS3ZplMUrLBSlg1sew+7lLkTHa3IZczk26dLtSXcOMc+boOmn7LgpnIPA4V6I8kF4NYENDTeLFBjutBGjfsIusJNp3K+HDQBDWeL8duKIfT/Vdti6dMbtZ/EZOy8MsIkcJBFycdWWfTBry0s3g8ZsStJYS2zcDGoxNleki9Mtqj9uf1fdsIespgGByBPYQOFVQLE+ho7jvMBN48UHMiIiQRJ1XLeVCzK2HAabIG6UuqBDN6d5GIP5JibSONAJ/y8iUsjb+tXqiUg6NxU9ULVzR1FnvL5J0R8WgozBpYGCkenT9jB7ULJtUduPjRumRoY15GYnf8FetwkRzljV1pkCld1dfYlTmJtFgAsJRRe5YRrHhol5pXGQkKhF1yxcFQxSEGHExoxhDetz9p3Xg2Ao3UR4cBO6uGDam79lWUREzp+djGQQqyRwnZH8WQp28l4sTJT+z3bMnrUHaf287f+pTbv+6I1nUHdbt+pC8uLbhH2KgqKhqwXKNJjFgcRa9D3WK9jKZC/YNuAaiYdp6UoguSXblzimm/P2j9zsJjftvTlO6ALRnkhGysbDKrr4bIUzRJ5zGOvnbBk749EDJG7q02vs7/Z6Ph+GQaSwYaJGV5aMVG+zJ490fYhVUZe5aF02bsL8gP5PwdUuDo14GLL+ahym4rCrAXttdjH6vMPQsUOvdtZ94jmsdfCcWrO2UnEcMITijHEjCQhHsr4Msbt16CHRsqKfboXdxL2QV7zNeeol2uSP2Jrhmg0baYyJi10Dvk1EbhWR7zLG3Hp1S+Xh4eHh4eFxrcGvGTw8PDw8PK4OrmWGwn0icjQIguMiIsaYPxKRd4rIs84rApHYkBiNiMj0w3o1V+51nwzt/rB+1hL/Ed2COLVPtyBufEGnbou4hedcOF3TLaRfd0CnC59d3+u8V73qoAM4DuaMwxrYz7nb8NwZXXSv9IxuGe7NX96pYG/MzcAYc7RtJqGzClYCnVpNISsNlQW9X+1a0JkZ986cVtNvzekuOf/+xLc48x7oTSjLH1jQ83jX82r6yV+/0ZmHi6GQT+ouD7o9XGT2br09Wj1HJUTk1e/+spr+iS/oQphBVrdkT8/qeYuInGrr/XPXdFn//SHdteHGA3qozpOb+rMQcY+B5mv0+eXN80fU9D8uuoURx9M6k+TIO25S01MOt5/umN7PJ27TXZdERMpP6e4kmTP6Natv092d3vWKLzrz+OSvvkZN/2D3HscVf+i814uFUaIvvgxx2WuGGzOb8tFbPihv/YplJhi4GXTHGDLNfh/jKxYCfJNfse/7eB3U+7I1dfUXrYU2loOFPpOWYPe4iIikDtswq9U32tC3zWkKsNl77rndziOnztt5qQSXpZum7T3pBjY+YS22lZplZQXrEHpjiMVFWNZPYkYOLHMsdwRjb61sy9i35TI9zJ1D4cvoEtE5mJHabtKg7d8YXnMA9lJ23P52tmTb4fRX5u29J+0F/awtK0MC0r0jtO73onnHWrZd+2NwZYCLQ/+sbaPYjfvt95y9Uea0rVPzXjuPkEbP9WAvH8jO3ZYxkEtG1wBH1zGvQygyOQEByDpCzUFocOZJW9fMYgNtYNdQqfOMPwjLa9nSL4Jxy0gwHXtdso4wnGCKdBAOsn6Q5bH59cDyoOtdh2usZlwKN1mGXnnFUgUSq/YaijDGbTNIHBT87Iq9Ny3msTO2L0nJXm9qti79nbbPxVpwn5m37ZrEK4QWXYYs7SMM6PzeNRERWX7OtnsH4sjJgn1evRU8d7gZtGf6kmiAVdGM0tTTGwwtiuewYvu52UD77rZ5mJPnRESk+zq7dukgxGV609a5PQa2DPpACyLLdJGlK9GeHbY/nK7Zd+j4gm289udtW3CNxTCTdEMw/UDidbhjjNtM8kdtGfsl+52MhOS6vWiQTkbqKgbtBC9mup5yDJPhF4eYaWcaa126DQyidYt1wD46DZYTRWJ7cAnA77sljJflhrSn8Wwgyto4ZOudvWAfOoU6uxhTpdO2zut3QKwxF3WJiCMUbIC60bWlt4nvYDN14FoShgcFA6R8ECFIT9ONAfPYObg51TAfzYPpU+9Jct3+rU+XnTkIq5LxgXmGTKg2hKoHe8D0OGXHcL+IdqtGXbteCozSmuFaPlDYJSJnLvp+VkQc8t0eHh4eHh5XGSNEX3wZwq8ZPDw8PDxePhihNYMJgmvzdMQY8y4R+aYgCP4hvn+fiLw6CIIfH/rdD4vID4uI7Nmz55WnTp16ycvq4eHh4XFtwxjzWBAE916p+5fMZPBq8/V/6/s8GPzpFS3nqMKvGTw8PDw8Xiz4NcPl4VpmKJwTkYs5w7uRFkEQBL8mIr8mImKMWTHGcHUwLSJuTu7owtf7+sP1Wndf7+sLf9t6u33AXgRUZeOjDwZ/qvt6XB6ux2f7YuBrXTPUxbf5tYDrdV671uCfw7UB/xyuPvya4TJwLTMUEiJyWES+Xuyi4BER+e4gCJ55gdc/ei2c2LzU8PW+/nC91t3X+/rC9VpvjxeGr3XN4PvVtQH/HK4N+OdwbcA/B4+XG65ZhkIQBD1jzI+LyEfFhoD6zRd6mODh4eHh4eFx/cCvGTw8PDw8PK4OrtkDBRGRIAg+JCIfutrl8PDw8PDw8Li24dcMHh4eHh4eLz30WICjgV+72gW4SvD1vv5wvdbd1/v6wvVab48rC9+vrg3453BtwD+HawP+OXi8rHDNaih4eHh4eHh4eHh4eHh4eHhcuxhlhoKHh4eHh4eHh4eHh4eHh8cVgj9Q8PDw8PDw8PDw8PDw8PDwuGz4AwUPDw8PDw8PDw8PDw8PD4/Lhj9Q8PDw8PDw8PDw8PDw8PDwuGz4AwWP6wbGmN3GmPcbY44YY44ZY37BGJMyxuwzxjx9DZRv23IYY2qXeb/L/f2/Nsb808u5Zpt7fb0x5n++CPf5R8aYwBhzy0VpXzHG7P/b3tvDw8PDw+PFhjFmyhjzBP4tGmPOXfQ9ZYx56Arle9Xe+S8W/Dvfw+PlCX+g4HFdwBhjROTPReQvgiA4JCI3ikhBRP7dlcrPGHM9j6+7ROTxF+E+d4jIEyLyDhERY0xGROZE5OSLcG8PDw8PD48XFUEQrAVBcHcQBHeLyK+IyH/h9yAIOkEQvPYqF/Fahn/ne3i8DHE9b3g8ri+8RURaQRD8lohIEAR9EfkpEfkhEcmJSMIY8/s4Cf9TY0xORMQYkzfG/JUx5svGmKeNMd+B9O81xnwRFodfNcbEwTB43hjzuyLytIj8D2PMj7EAF1sDjDF/YYx5zBjzjDHmhy8qp1qOi6HlvV3FUa6vGGN+Hfl9zBiTxd9+1hhz2BjzWRG5abs8jDGvMsY8aYzJoF2eMcbc7sj2LhF53BiTNsb8tjHm/8ahznDZssaYtxtjftEY83blPneKyM8JFhcicquIPBf4eLceHh4eHi9DGGNqeC8/h/fjYbz3HzDGfA4syvsu+v01/c43xvy5Mea9xpjPGGNOG2Me+Crl2+6979/5Hh4vQ/gDBY/rBbeJyGMXJwRBUBGR0yKSEPti/W9BENwiIhUR+VH87JtE5HwQBHcFQXC7iHwEVLzvEJHXwQLRF5Hvwe8P4T63ich/FZF3X5Tlu0Xkffj/DwVB8EoRuVdEftIYM4V0VzlEROSr5L0dDonIL6NcZRH5dmPMK0XkO0XkbhF5u4i8ars8giB4RET+UkTeKyL/QUR+LwgCl4vGnSKyLCIfFZEHgyD4GS4IjDE3GGN+whjzYRF5RETeJiIfEpFPKve5VUTeLyKzxpgxsdaLJ19AfT08PDw8PK5l3CAi/0lEbsa/7xaR14vIPxWRnxF52bzz7xCRchAEbxSR/1Ur32W89/0738PjZYjE1S6Ah8c1gjNBEHwO//89EflJEfl/ReQpEflPxpifE5EPBkHwN8aY7xORV4rIIzC6Z8Vunj8jIqeCIPiCiEgQBI8bY2aNMTtFZEZENoIgOIM8ftIY8234/4LYl//iNuUgvt6R91fDiSAInsD/HxORfSIyLSL/XxAEDRERY8xfvoA8/o3YxUALZbsExpikiBwQkT8UkX8UBMHnh37yZ2IPTn5eRH4wCIJFx30WRGQtCIKmMebjIvJWsQcVT+Hvf19EXiciXbGLmZ99Ae3g4eHh4eFxLeBEEAR8nz0jIp8IgiAwxjwl9h0tco2/88GiHBOR/4KkpNgDjGF81ff+C3jn/6CIvBrpHxWRx4Mg+NWv1hAeHh5XHv5AweN6wbMi8q6LE4wxJRHZIyI9ERmm0wUiIkEQHDbG3CP2NP+9xphPiMiGiPxOEAT/fOh++0SkPnSfP0G+8wJ2gjHmTSLygIjcHwRBwxjzKRHJXJzvcDkuzkbL+wWgfdH/+2IXDC5sl8eUWO2JpNgyD9dXROQWsQuQSeQ1jLtF5BVi2/RPcQDxMRH59SAITl/0uzsECwmxlozvEZEdIvIXxpjXicitQRD8sIiIMeZXjDE3BUHw/Db18vDw8PDwuFZw8Xt5cNH3gWytz6/1d/6tIvIY3EhF7AGAxmK4W776e9/5zhcRCYLgt4wx7xeRZBAE79mmPh4eHi8xvMuDx/WCT4hIzhjz/SIi8EH8TyLy2yLSEJE9xpj78dvvFpHP4nc7RaQRBMHvich/FJF7cK93GWNm8ZtJY8xeR77vE0sxfJfYwwURe5q/gcOEm0XkNRf9Xi3HUD1eaN5fDZ8RkW+FP2NRRL7lBeTxqyLyL0Xk98X6OWq4S0QeElvv3zLGzF38x8DiS0EQvDcIgteLpT4+I5bFcTFCy4SIfFpE3nhR2j8QkV8c+n3nhVXbw8PDw8PjZYFr/Z1PEUXiTlFcFF7ge3+7dz7xShlyX/Xw8Lj68AwFj+sCoBF+m4j8N2PMvxR7mPYhsX6KO0TkeRH5MWPMb4plM/x3XHqHiPxHY8xALLX+R4IgeNYY8y9E5GPGRnLoisiPiXVZGM73Gby4zwVBcAHJHxGR9xhjvoJ8v3DRJa5y8H6uvE99DW3yJWPM+0Tky2LpjY9sl4cx5utEpBsEwR/gQOYhY8xbgiAY9oG8S0S+CHbHT4vIHxtjHgiCoCsiYox5UCxjYxg/K9GFwh1iaZISBEHbGPOkiLwiCIIyrBvUZNgvIrNBEJy43Dbw8PDw8PC4VvEyeOffISIPX/T9dlEYCi/wve9851/0+1eKyF9fZtU9PDyuMIwXTvXw8Hi5wRhzh9iFyBmxjI9/ddGBjYeHh4eHh8eIwRjzh2JFrZtXuyweHh5b8AcKHh4eHh4eHh4eHh4eHh4elw2voeDh4eHh4eHh4eHh4eHh4XHZ8AcKHh4eHh4eHh4eHh4eHh4elw1/oODh4eHh4eHh4eHh4eHh4XHZ8AcKHh4eHh4eHh4eHh4eHh4elw1/oODh4eHh4eHh4eHh4eHh4XHZ8AcKHh4eHh4eHh4eHh4eHh4elw1/oODh4eHh4eHh4eHh4eHh4XHZ8AcKHh4eHh4eHh4eHh4eHh4el43/HwWyWFvSvqx5AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -375,7 +446,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -438,19 +509,17 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { @@ -518,7 +587,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/classic_shadows/create_quantum_program.py b/classic_shadows/create_quantum_program.py index b17c8d5..dbf5402 100644 --- a/classic_shadows/create_quantum_program.py +++ b/classic_shadows/create_quantum_program.py @@ -11,7 +11,7 @@ num_qubits = 3 noise_mode = "all_qubits" trotter_timestep = 10 -shot_per_trotter_step = 10000 +shot_per_trotter_step = 100 initialisation = [0, 0, 1] # Initialization of spins filename = "quantum_program.json" @@ -40,7 +40,7 @@ list(range(num_qubits)), 0.001 ) # Here insert the noise if needed -noise_to_use = [noise_model_con] +noise_to_use = [] # Function to create the simplified spin Hamiltonian diff --git a/classic_shadows/quantum_program.json b/classic_shadows/quantum_program.json index 5f53b26..27d6c1d 100644 --- a/classic_shadows/quantum_program.json +++ b/classic_shadows/quantum_program.json @@ -1 +1 @@ -"{\"ClassicalRegister\":{\"measurement\":{\"constant_circuit\":{\"definitions\":[],\"operations\":[{\"RotateY\":{\"qubit\":2,\"theta\":3.141592653589793}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"PragmaLoop\":{\"repetitions\":\"number_trottersteps\",\"circuit\":{\"definitions\":[],\"operations\":[{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,0],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,0],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,0],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,0],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,0],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,0],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,0],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,0],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,0],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[2,1],\"execution_time\":1.0}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"PragmaStopParallelBlock\":{\"qubits\":[2],\"execution_time\":1.0}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopParallelBlock\":{\"qubits\":[1,2],\"execution_time\":1.0}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}}}},{\"PragmaStopParallelBlock\":{\"qubits\":[0,2,1],\"execution_time\":0.0}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":1}},\"circuits\":[{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XXX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XXX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XXX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XXX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XXX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XXY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XXY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XXY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XXY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XXY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XXZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XXZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XXZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XXZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XXZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XYX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XYX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XYX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XYX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XYX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XYY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XYY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XYY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XYY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XYY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XYZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XYZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XYZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XYZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XYZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XZX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XZX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XZX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XZX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XZX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XZY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XZY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XZY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XZY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XZY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XZZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XZZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XZZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XZZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"XZZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YXX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YXX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YXX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YXX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YXX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YXY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YXY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YXY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YXY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YXY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YXZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YXZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YXZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YXZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YXZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YYX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YYX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YYX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YYX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YYX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YYY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YYY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YYY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YYY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YYY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YYZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YYZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YYZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YYZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YYZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YZX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YZX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YZX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YZX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YZX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YZY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YZY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YZY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YZY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YZY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YZZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YZZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YZZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YZZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"YZZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZXX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZXX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZXX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZXX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZXX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZXY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZXY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZXY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZXY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZXY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZXZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZXZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZXZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZXZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZXZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZYX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZYX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZYX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZYX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZYX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZYY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZYY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZYY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZYY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZYY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZYZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZYZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZYZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZYZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZYZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZZX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZZX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZZX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZZX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZZX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZZY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"PragmaGlobalPhase\":{\"phase\":-0.7853981633974483}},{\"RotateZ\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZZY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZZY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZZY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZZY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZZZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZZZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZZZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZZZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":370,\"readout\":\"ZZZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}}]},\"input_parameter_names\":[\"number_trottersteps\"]}}" \ No newline at end of file +"{\"ClassicalRegister\":{\"measurement\":{\"constant_circuit\":{\"definitions\":[],\"operations\":[{\"RotateY\":{\"qubit\":2,\"theta\":3.141592653589793}},{\"PragmaLoop\":{\"repetitions\":\"number_trottersteps\",\"circuit\":{\"definitions\":[],\"operations\":[{\"PragmaStartDecompositionBlock\":{\"qubits\":[0,1],\"reordering_dictionary\":{}}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"RotateZ\":{\"qubit\":1,\"theta\":-0.096275}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopDecompositionBlock\":{\"qubits\":[0,1]}},{\"PragmaStartDecompositionBlock\":{\"qubits\":[0,2],\"reordering_dictionary\":{}}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"PragmaStopDecompositionBlock\":{\"qubits\":[0,2]}},{\"PragmaStartDecompositionBlock\":{\"qubits\":[0,1],\"reordering_dictionary\":{}}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"RotateZ\":{\"qubit\":1,\"theta\":-0.096275}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaStopDecompositionBlock\":{\"qubits\":[0,1]}},{\"PragmaStartDecompositionBlock\":{\"qubits\":[0,2],\"reordering_dictionary\":{}}},{\"RotateX\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"PragmaStopDecompositionBlock\":{\"qubits\":[0,2]}},{\"PragmaStartDecompositionBlock\":{\"qubits\":[0,1],\"reordering_dictionary\":{}}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"RotateZ\":{\"qubit\":1,\"theta\":-0.096275}},{\"CNOT\":{\"control\":0,\"target\":1}},{\"PragmaStopDecompositionBlock\":{\"qubits\":[0,1]}},{\"PragmaStartDecompositionBlock\":{\"qubits\":[0,2],\"reordering_dictionary\":{}}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"CNOT\":{\"control\":0,\"target\":2}},{\"PragmaStopDecompositionBlock\":{\"qubits\":[0,2]}},{\"PragmaStartDecompositionBlock\":{\"qubits\":[1,2],\"reordering_dictionary\":{}}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"PragmaGlobalPhase\":{\"phase\":1.5707963267948966}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948968}},{\"RotateZ\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"PragmaStopDecompositionBlock\":{\"qubits\":[1,2]}},{\"PragmaStartDecompositionBlock\":{\"qubits\":[1,2],\"reordering_dictionary\":{}}},{\"RotateX\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"PragmaStopDecompositionBlock\":{\"qubits\":[1,2]}},{\"PragmaStartDecompositionBlock\":{\"qubits\":[1,2],\"reordering_dictionary\":{}}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"RotateZ\":{\"qubit\":2,\"theta\":-0.096275}},{\"CNOT\":{\"control\":1,\"target\":2}},{\"PragmaStopDecompositionBlock\":{\"qubits\":[1,2]}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}}}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":1}},\"circuits\":[{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XXX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateY\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateY\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XXX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XXX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XXX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"XXX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XXY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateY\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XXY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XXY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XXY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"XXY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XXZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateY\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XXZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XXZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XXZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"XXZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XYX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"RotateY\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XYX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XYX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XYX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"XYX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XYY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XYY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XYY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XYY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"XYY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XYZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XYZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XYZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XYZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"XYZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XZX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateY\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XZX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XZX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XZX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"XZX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XZY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XZY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XZY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XZY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"XZY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"XZZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":0,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"XZZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"XZZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"XZZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"XZZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YXX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateY\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateY\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YXX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YXX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YXX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"YXX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YXY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateY\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YXY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YXY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YXY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"YXY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YXZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateY\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YXZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YXZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YXZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"YXZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YYX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"RotateY\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YYX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YYX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YYX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"YYX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YYY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YYY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YYY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YYY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"YYY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YYZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YYZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YYZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YYZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"YYZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YZX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateY\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YZX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YZX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YZX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"YZX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YZY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YZY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YZY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YZY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"YZY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"YZZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":0,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"YZZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"YZZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"YZZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"YZZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZXX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateY\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZXX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZXX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZXX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"ZXX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZXY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZXY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZXY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZXY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"ZXY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZXZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":1,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZXZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZXZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZXZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"ZXZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZYX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"RotateY\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZYX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZYX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZYX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"ZYX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZYY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZYY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZYY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZYY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"ZYY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZYZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":1,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZYZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZYZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZYZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"ZYZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZZX\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateY\":{\"qubit\":2,\"theta\":1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZZX\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZZX\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZZX\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"ZZX\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZZY\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"RotateX\":{\"qubit\":2,\"theta\":-1.5707963267948966}},{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZZY\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZZY\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZZY\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"ZZY\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}},{\"definitions\":[{\"DefinitionBit\":{\"name\":\"ZZZ\",\"length\":3,\"is_output\":true}}],\"operations\":[{\"MeasureQubit\":{\"qubit\":0,\"readout\":\"ZZZ\",\"readout_index\":0}},{\"MeasureQubit\":{\"qubit\":1,\"readout\":\"ZZZ\",\"readout_index\":1}},{\"MeasureQubit\":{\"qubit\":2,\"readout\":\"ZZZ\",\"readout_index\":2}},{\"PragmaSetNumberOfMeasurements\":{\"number_measurements\":3,\"readout\":\"ZZZ\"}}],\"_roqoqo_version\":{\"major_version\":1,\"minor_version\":0}}]},\"input_parameter_names\":[\"number_trottersteps\"]}}" \ No newline at end of file From 4a7cc38119ed2e0534c55d2a5065541b83ce9dc9 Mon Sep 17 00:00:00 2001 From: gsilviHQS Date: Mon, 23 Sep 2024 13:09:53 +0200 Subject: [PATCH 13/13] update readme --- README.md | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index a22e485..ade943f 100644 --- a/README.md +++ b/README.md @@ -37,10 +37,7 @@ To install the Conda environment and our qiskit_mod library, run the following c ```bash source create_conda_env.sh ``` - -Also, keep in mind that recently Github password authentication has been deprecated and will no longer work. -Instead, token-based authentication (for example SSH Key) is required for all authenticated Git operations. - +Note: for classic shadows the example notebook provide the list of libraries to install. ## Running the code You can find the Jupyter notebook and python scripts in the **misc** folder. Use the Conda environment provided to run the code. @@ -85,6 +82,15 @@ The modification converts each circuit from Qiskit to MyQLM and takes care of th Overall, this Qiskit-QLM integration allows us to choose which type of backend to use, and when combined with the QLMaaS server, enables this code to run for larger problems and molecules, which would not be possible using a simple laptop. +## Classic Shadow + +Shadow spectroscopy is a quantum algorithm that estimates energy differences (gaps) in a system’s Hamiltonian by analyzing the time evolution of quantum states. This method complements traditional quantum phase estimation by leveraging classical shadows—a technique involving randomized measurements—to access a large set of observables that contain information about the energy spectrum. The key advantage of shadow spectroscopy is its relatively low quantum resource demands: no auxiliary qubits are required, and it is resilient to shot noise and gate errors prevalent in NISQ devices. + +In the folder `classic_shadows` a showcase implementation of this method is provided. Is based on HQS`s qoqo framework, and it is comprised of 2 parts: +- A notebook that can be run using a pre-compiled quantum program using only free opensource libraries. +- A script that create such quantum program, for which a free licences from HQS `https://cloud.quantumsimulations.de/` is needed in order to use the needed libraries: `hqs_noise_app` and `struqture`. + + ## Testing and continuous integration You can run the tests with: