diff --git a/magpy/__init__.py b/magpy/__init__.py index d187798..ca90f85 100644 --- a/magpy/__init__.py +++ b/magpy/__init__.py @@ -1,9 +1,10 @@ from .core import PauliString, X, Y, Z, Id, FunctionProduct, HamiltonianOperator, kron, frobenius, timegrid -from .solver import System +from .solver import evolve +from torch import set_default_device __all__ = [ 'PauliString', 'X', 'Y', 'Z', 'Id', 'FunctionProduct', 'HamiltonianOperator', 'kron', 'frobenius', 'timegrid', - 'System' + 'evolve' ] @@ -18,4 +19,7 @@ def set_device(device): """ from ._device import _DEVICE_CONTEXT + from .solver.gauss_legendre_quadrature import _update_device _DEVICE_CONTEXT.device = device + set_default_device(_DEVICE_CONTEXT.device) + _update_device() diff --git a/magpy/core/function_product.py b/magpy/core/function_product.py index d692e55..9232427 100644 --- a/magpy/core/function_product.py +++ b/magpy/core/function_product.py @@ -1,4 +1,6 @@ from numbers import Number +from copy import deepcopy +import torch import magpy as mp @@ -29,7 +31,6 @@ def __init__(self, *funcs): self.funcs = {} self.scale = 1 - self.__name__ = "FP" for f in funcs: try: @@ -42,7 +43,7 @@ def __init__(self, *funcs): self.scale *= f except TypeError: # Other type of function. - self.funcs = self.__add_func(f) + self.funcs = FunctionProduct.__add_func(self, f) def __eq__(self, other): return self.funcs == other.funcs and self.scale == other.scale @@ -52,17 +53,17 @@ def __mul__(self, other): return other * self out = FunctionProduct() - out.funcs = self.funcs.copy() - out.scale = self.scale + out.funcs = deepcopy(self.funcs) + out.scale = deepcopy(self.scale) - if isinstance(other, Number): + if isinstance(other, Number | torch.Tensor): out.scale *= other else: try: out.scale *= other.scale out.funcs = self.__merge_funcs(other.funcs) except AttributeError: - out.funcs = out.__add_func(other) + out.funcs = FunctionProduct.__add_func(out, other) return out @@ -74,24 +75,37 @@ def __neg__(self): def __call__(self, arg): out = 1 for f in self.funcs: - out *= f(arg) + try: + out *= f(arg.clone().detach()) + except AttributeError: + out *= f(torch.tensor(arg)) return out * self.scale + def __repr__(self): + return f"{str(self.scale)}*{str(self.funcs)}" + + def __str__(self): + return (str(self.scale) + "*" if isinstance(self.scale, torch.Tensor) or self.scale != 1 else "") \ + + '*'.join([f.__name__ + (f"^{str(n)}" if n > 1 else "") for f, n in self.funcs.items()]) + def __hash__(self): return hash(tuple(self.funcs)) + hash(self.scale) - def __repr__(self): - return str(self.scale) + "*" + str(self.funcs) + def is_empty(self): + """Return true if function product contains no functions. + """ + return not self.funcs def __merge_funcs(self, funcs): # Combine funcs dict with own funcs dict, summing values with shared keys. return {f: self.funcs.get(f, 0) + funcs.get(f, 0) for f in set(self.funcs) | set(funcs)} - def __add_func(self, f): - # Add function to own funcs dict, adding new key or incremented existing value accordingly. + @staticmethod + def __add_func(out, f): + # Add function to funcs dict, adding new key or incrementing existing value accordingly. try: - self.funcs[f] += 1 + out.funcs[f] += 1 except KeyError: - self.funcs[f] = 1 - return self.funcs + out.funcs[f] = 1 + return out.funcs diff --git a/magpy/core/hamiltonian_operator.py b/magpy/core/hamiltonian_operator.py index 9f602de..d0fd693 100644 --- a/magpy/core/hamiltonian_operator.py +++ b/magpy/core/hamiltonian_operator.py @@ -1,4 +1,3 @@ -from itertools import chain from copy import deepcopy from numbers import Number import torch @@ -46,7 +45,7 @@ def __init__(self, *pairs): except AttributeError: self.data[pair[0]] = [self.data[pair[0]], pair[1]] - HamiltonianOperator.__simplify(self.data) + self.data = HamiltonianOperator.__simplify_and_sort_data(self.data) def __eq__(self, other): return self.data == other.data @@ -55,14 +54,7 @@ def __mul__(self, other): out = HamiltonianOperator() try: - self_data = HamiltonianOperator.__expand(self.data) - other_data = HamiltonianOperator.__expand(other.data) - - for p in self_data: - for q in other_data: - out += mp.FunctionProduct() * p[0] * q[0] * p[1] * q[1] - - return out + out = sum((p[0]*p[1]*q[0]*q[1] for q in other.unpack_data() for p in self.unpack_data()), out) except AttributeError: out.data = deepcopy(self.data) @@ -80,7 +72,8 @@ def __mul__(self, other): for coeff in list(out.data): out.data[mp.FunctionProduct(coeff, other)] = out.data.pop(coeff) - return out + out.data = HamiltonianOperator.__simplify_and_sort_data(out.data) + return out __rmul__ = __mul__ @@ -91,7 +84,7 @@ def __add__(self, other): out.data = self.data | other.data except AttributeError: # other is PauliString; add it to constants. - out.data = self.data.copy() + out.data = deepcopy(self.data) try: out.data[1].append(other) @@ -114,7 +107,7 @@ def __add__(self, other): except TypeError: out.data[coeff].append(other.data[coeff]) - HamiltonianOperator.__simplify(out.data) + out.data = HamiltonianOperator.__simplify_and_sort_data(out.data) return out def __neg__(self): @@ -127,42 +120,60 @@ def __sub__(self, other): return out def __repr__(self): - return '{' + ', '.join((str(f) if isinstance(f, Number) - else f.__name__) + ': ' + str(q) for f, q in self.data.items()) + '}' + return str(self.data) + + def __str__(self): + out = "" + for f, p in self.data.items(): + try: + p_str = str(p) + scale_pos = p_str.find('*') + + if isinstance(p.scale, torch.Tensor) or p.scale != 1: + out += p_str[:scale_pos] + '*' - def __call__(self, t=None, n=None): - if n is None: - pauli_strings = chain.from_iterable(p if isinstance(p, list) else [p] for p in self.data.values()) - n = max(max(p.qubits) for p in pauli_strings) + out = HamiltonianOperator.__add_coeff_to_str(out, f) + out += p_str[scale_pos + 1:] if scale_pos > 0 else p_str + + except AttributeError: + out = HamiltonianOperator.__add_coeff_to_str(out, f) + + out += '(' if f != 1 else "" + out += " + ".join([str(q) for q in p]) + out += ')' if f != 1 else "" + + out += " + " + + return out[:-3] + + def __call__(self, t=None, n_qubits=None): + if n_qubits is None: + n_qubits = max(max(p.qubits) if p.qubits else 0 for p in self.pauli_operators()) if self.is_constant(): - try: - return sum(p(n).type(torch.complex128) for p in self.data[1]) - except TypeError: - return self.data[1](n).type(torch.complex128) + return self.__call_time_independent(n_qubits) if t is None: raise ValueError( "Hamiltonian is not constant. A value of t is required.") - out = 0 - for coeff, ps in self.data.items(): - try: - out += coeff(torch.tensor(t)) * ps(n).type(torch.complex128) - except TypeError: - if isinstance(coeff, Number): - out += coeff * ps(n).type(torch.complex128) - else: - for p in ps: - out += coeff(torch.tensor(t)) * p(n).type(torch.complex128) + # Convert input to tensor. + try: + t = t.clone().detach() + except AttributeError: + t = torch.tensor(t) - return out.to(_DEVICE_CONTEXT.device) + return self.__call_time_dependent(t, n_qubits) def is_constant(self): "Return true if the Hamiltonian is time-independent." for coeff in self.data: - if not isinstance(coeff, Number): - return False + if not isinstance(coeff, Number | torch.Tensor): + try: + if not coeff.is_empty(): + return False + except AttributeError: + return False return True def is_interacting(self): @@ -190,20 +201,84 @@ def pauli_operators(self): """All Pauli operators in H.""" return [u[1] for u in self.unpack_data()] + def __call_time_independent(self, n_qubits): + # Return matrix representation when constant. + out = 0 + for p in self.pauli_operators(): + try: + p_val = p(n_qubits) + + # If p is a batch, repeat the current value to agree with its shape. + if out.dim() == 2 and p_val.dim() == 3: + out = out.repeat(len(p_val), 1, 1) + + except AttributeError: + pass + + out += p(n_qubits) + + return out + + def __call_time_dependent(self, t, n_qubits): + out = 0 + for coeff, p in self.unpack_data(): + p_val = p(n_qubits).to(_DEVICE_CONTEXT.device) + + # Evaluate coefficient if it's a function. + try: + coeff = coeff(t).to(_DEVICE_CONTEXT.device) + except TypeError: + pass + + # Evaluate next term in data. + next_term = 0 + try: + next_term = coeff.reshape(-1,1,1) * p_val + except AttributeError: + next_term = coeff * p_val + + # If p is a batch, repeat the current value to agree with its shape. + try: + if out.dim() == 2 and next_term.dim() == 3: + out = out.repeat(len(next_term), 1, 1) + except AttributeError: + pass + + out += next_term + + return out + @staticmethod - def __simplify(arrs): + def __simplify_data(arrs): # Collect all PauliStrings in all lists in arrs. for coeff in arrs: arrs[coeff] = mp.PauliString.collect(arrs[coeff]) @staticmethod - def __expand(data): - # Expand all functions and lists of qubits into pairs of functions with single qubits. - expanded_data = [] - for pair in data.items(): + def __add_coeff_to_str(out, f): + try: + out += f.__name__ + '*' + except AttributeError: try: - for qubit in pair[1]: - expanded_data.append((pair[0], qubit)) - except TypeError: - expanded_data.append(pair) - return expanded_data + if f != 1: + out += str(f) + '*' + except (RuntimeError, AttributeError): + out += str(f) + '*' + + return out + + @staticmethod + def __sort_data(data): + # Move all constant keys to the start of the dictionary. + const_keys = [] + other_keys = [] + + for key in data: + (const_keys if isinstance(key, Number | torch.Tensor) else other_keys).append(key) + + return dict((key, data[key]) for key in const_keys + other_keys) + + @staticmethod + def __simplify_and_sort_data(data): + HamiltonianOperator.__simplify_data(data) + return HamiltonianOperator.__sort_data(data) diff --git a/magpy/core/linalg.py b/magpy/core/linalg.py index 69ce277..6a59bcf 100644 --- a/magpy/core/linalg.py +++ b/magpy/core/linalg.py @@ -1,6 +1,5 @@ import functools import torch -from .._device import _DEVICE_CONTEXT def kron(*args): """Compute the Kronecker product of the input arguments. @@ -11,11 +10,11 @@ def kron(*args): Resultant product """ - return functools.reduce(torch.kron, args).to(_DEVICE_CONTEXT.device) + return functools.reduce(torch.kron, args) def frobenius(a, b): - """Compute the Frobenius inner product of `a` and `b`. + """Compute the Frobenius inner product of `a` and `b`. If `a` is a 3D tensor and `b` is a 2D tensor, then the inner product is batched across `a`. Otherwise `a` and `b` must both be 2D tensors. @@ -34,10 +33,9 @@ def frobenius(a, b): """ try: - return torch.vmap(torch.trace)(torch.matmul(torch.conj(torch.transpose(a, 1, -1)), b)) \ - .to(_DEVICE_CONTEXT.device) + return torch.vmap(torch.trace)(torch.matmul(torch.conj(torch.transpose(a, 1, -1)), b)) except RuntimeError: - return torch.trace(torch.conj(torch.transpose(a, 0, 1)) @ b).to(_DEVICE_CONTEXT.device) + return torch.trace(torch.conj(torch.transpose(a, 0, 1)) @ b) def timegrid(start, stop, step): @@ -59,4 +57,4 @@ def timegrid(start, stop, step): Grid of values """ - return torch.arange(start, stop + step, step).to(_DEVICE_CONTEXT.device) + return torch.arange(start, stop + step, step) diff --git a/magpy/core/pauli_string.py b/magpy/core/pauli_string.py index 3bea981..ce0ffad 100644 --- a/magpy/core/pauli_string.py +++ b/magpy/core/pauli_string.py @@ -1,4 +1,5 @@ from numbers import Number +from copy import deepcopy import torch import magpy as mp from .._device import _DEVICE_CONTEXT @@ -70,61 +71,42 @@ def __eq__(self, other): return self.qubits == other.qubits and self.scale == other.scale def __mul__(self, other): + if isinstance(other, mp.PauliString): + return self.__mul_ps(other) + if isinstance(other, mp.HamiltonianOperator): - return -other * self + return self.__mul_hop(other) - s = PauliString(scale=0) + if isinstance(other, Number | torch.Tensor): + return self.__mul_num(other) try: - if other.scale == 0: - return s - - s.qubits = self.qubits | other.qubits + # other is FunctionProduct. + self *= other.scale + other.scale = 1 except AttributeError: - if isinstance(other, Number): - if other == 0: - return s - - s.scale = self.scale * other - s.qubits = self.qubits - else: - try: - # other is FunctionProduct. - self *= other.scale - other.scale = 1 - except AttributeError: - # other is other type of function. - pass - - return mp.HamiltonianOperator([other, self]) + # other is another type of function + pass - else: - # other is PauliString. - s.scale = self.scale * other.scale - - for n in list(set(self.qubits.keys() & other.qubits.keys())): - if self.qubits[n] == other.qubits[n]: - del s.qubits[n] - else: - scale, spin = PauliString.__pauli_mul(self.qubits[n], other.qubits[n]) - s.scale *= 1j * scale - s.qubits[n] = spin - - return s + return mp.HamiltonianOperator([other, self]) - __rmul__ = __mul__ + __rmul__ = __mul__ # This may have to be changed def __add__(self, other): try: - if self == other: - s = PauliString(scale=self.scale + other.scale) - s.qubits = self.qubits - return s - if self == -other: - return 0*PauliString.Id() + if self.qubits == other.qubits: + scale = self.scale + other.scale + if torch.is_tensor(scale) and torch.all(scale.eq(0)) or isinstance(scale, Number) and scale == 0: + return 0 + + out = PauliString(scale=scale) + out.qubits = self.qubits + return out + return mp.HamiltonianOperator([1, self], [1, other]) + except AttributeError: - # other is HamiltonianOperator + # other is HOp return other + self def __neg__(self): @@ -133,10 +115,20 @@ def __neg__(self): return s def __sub__(self, other): - return self + -1*other + return self + -other def __repr__(self): - return str(self.scale) + "*" + "*".join(q[1] + str(q[0]) for q in sorted(self.qubits.items())) + out = "" + + if isinstance(self.scale, torch.Tensor) or self.scale != 1: + out += str(self.scale) + "*" + + if self.qubits.items(): + out += "*".join(q[1] + str(q[0]) for q in sorted(self.qubits.items())) + else: + out += "Id" + + return out def __call__(self, n=None): if n is None: @@ -146,7 +138,36 @@ def __call__(self, n=None): for index, qubit in self.qubits.items(): qubits[index - 1] = PauliString.matrices[qubit] - return self.scale * mp.kron(*qubits).type(torch.complex128).to(_DEVICE_CONTEXT.device) + scale = self.scale.view(len(self.scale), 1, 1).to(_DEVICE_CONTEXT.device) \ + if isinstance(self.scale, torch.Tensor) else self.scale + return scale * mp.kron(*qubits).type(torch.complex128).to(_DEVICE_CONTEXT.device) + + def __mul_ps(self, other): + # Right multiply by PauliString + out = PauliString() + out.scale = self.scale * other.scale + out.qubits = self.qubits | other.qubits + + for n in list(set(self.qubits.keys() & other.qubits.keys())): + if self.qubits[n] == other.qubits[n]: + del out.qubits[n] + else: + scale, spin = PauliString.__pauli_mul(self.qubits[n], other.qubits[n]) + out.scale *= 1j * scale + out.qubits[n] = spin + + return out + + def __mul_hop(self, other): + # Right multiply by Hamiltonian + return mp.HamiltonianOperator([1, self]) * other + + def __mul_num(self, other): + # Multiply by scalar + out = deepcopy(self) + out.scale *= other + + return out @staticmethod def collect(arr): diff --git a/magpy/solver/__init__.py b/magpy/solver/__init__.py index 7f9da37..c6c897a 100644 --- a/magpy/solver/__init__.py +++ b/magpy/solver/__init__.py @@ -1,2 +1 @@ -from .system import System -from .magnus import batch_first_term, batch_second_term +from .system import evolve diff --git a/magpy/solver/_gl3_quadrature_constants.py b/magpy/solver/_gl3_quadrature_constants.py deleted file mode 100644 index b1a9e04..0000000 --- a/magpy/solver/_gl3_quadrature_constants.py +++ /dev/null @@ -1,10 +0,0 @@ -from math import sqrt -import torch -from .._device import _DEVICE_CONTEXT - -# GL quadrature, degree 3. -knots = torch.tensor([-sqrt(3/5), 0, sqrt(3/5)], dtype=torch.complex128).reshape((1, 1, 3)).to(_DEVICE_CONTEXT.device) - -weights_first_term = torch.tensor([5/9, 8/9, 5/9]).to(_DEVICE_CONTEXT.device) -weights_second_term = torch.tensor([2,1,2]).unsqueeze(-1).unsqueeze(-1).unsqueeze(-1).to(_DEVICE_CONTEXT.device) -weights_second_term_coeff = sqrt(15) / 54 diff --git a/magpy/solver/gauss_legendre_quadrature.py b/magpy/solver/gauss_legendre_quadrature.py new file mode 100644 index 0000000..8eb26a3 --- /dev/null +++ b/magpy/solver/gauss_legendre_quadrature.py @@ -0,0 +1,204 @@ +"""Gauss-Legendre quadrature methods, degree 3. + +This module implements the methods described by Iserles et al. + +References +---------- + +.. [1] Iserles, A., Munthe-Kaas, H. Z., Nørsett, S. P. & Zanna, A. (2000), + "Lie-group methods", *Acta Numerica* 9, 215-365. + +""" + +import torch +from math import sqrt +from .._device import _DEVICE_CONTEXT + +_QUADRATURE_DEGREE = 3 +_KNOTS = torch.tensor([-sqrt(3/5), 0, sqrt(3/5)], dtype=torch.complex128) + +_WEIGHTS_1 = torch.tensor([5/9, 8/9, 5/9]) + +_WEIGHTS_2 = torch.tensor([2, 1, 2]).unsqueeze(-1).unsqueeze(-1).unsqueeze(-1) +_WEIGHTS_2_COEFFICIENT = sqrt(15) / 54 + +_combinations = [(0, 1), (0, 2), (1, 2)] + + +def _update_device(): + global _KNOTS, _WEIGHTS_1, _WEIGHTS_2 + _KNOTS = _KNOTS.to(_DEVICE_CONTEXT.device) + _WEIGHTS_1 = _WEIGHTS_1.to(_DEVICE_CONTEXT.device) + _WEIGHTS_2 = _WEIGHTS_2.to(_DEVICE_CONTEXT.device) + + +def get_knots_over_interval(tlist: torch.Tensor, step: float) -> torch.Tensor: + """Translate GLQ knots to the given intervals. + + Given `n` points in time, this function returns a tensor with shape + `[n-1, 3]`. + + Parameters + ---------- + tlist : Tensor + Time grid. + step : float + Time step. + + Returns + ------- + Tensor + Knots over each grid interval + """ + midpoints = tlist[0] + step*(torch.arange(len(tlist) - 1) + 0.5) + return 0.5*step*_KNOTS + midpoints[:, None] + + +def compute_integrals(funcs: list, knots: torch.Tensor, step: float) -> torch.Tensor: + """Compute the integrals of the given functions over the intervals + determined by the given knots, using GLQ3. + + Given `m` functions and `n-1` intervals (from `n` points in time), this + function returns a tensor with shape `[m, n-1]`. + + Parameters + ---------- + funcs : list[function] + Functions. + knots : Tensor + Knots over each grid interval. + step : float + Time step. + + Returns + ------- + Tensor + Integrals of the given functions over the given intervals. + """ + weighted_functions = tuple(torch.ones(knots.shape) * _WEIGHTS_1 + if f == 1 else f(knots) * _WEIGHTS_1 for f in funcs) + return 0.5 * step * torch.sum(torch.stack(weighted_functions), 2) + + +def compute_double_integral_of_commutator(funcs: list, pauli_op_matrices: torch.Tensor, tlist: torch.Tensor, + n_qubits: int) -> torch.Tensor: + """Compute the double integral of the commutator of the Hamiltonian + specified by the given functions and Pauli operators. + + Parameters + ---------- + funcs : list[function] + Coefficient function of the Hamiltonian. + pauli_op_matrices : Tensor + Pauli operator matrices of the Hamiltonian. + tlist : Tensor + Time grid. + n_qubits : int + Number of qubits. + + Returns + ------- + Tensor + Double integral of the commutator of the Hamiltonian over the + given intervals. + """ + n = len(tlist) - 1 + step = tlist[1] - tlist[0] + dim = 2 ** n_qubits + knots = get_knots_over_interval(tlist, step) + commutators = torch.stack([_eval_commutator(i, j, n, step, dim, knots, funcs, pauli_op_matrices) + for i, j in _combinations]) + + return _WEIGHTS_2_COEFFICIENT * torch.sum(commutators * _WEIGHTS_2, 0) + + +def _eval_commutator(i: int, j: int, n: int, step: float, dim: int, knots: torch.Tensor, funcs: list, + pauli_op_matrices: torch.Tensor) -> torch.Tensor: + """Evaluate the commutator of the Hamiltonian ... + + Parameters + ---------- + i : int + Index of the first column. + j : int + Index of the second column. + n : int + Number of intervals. + step : float + Time step. + dim : int + Dimension of the system + knots : Tensor + Knots over each grid interval. + funcs : list[function] + Coefficient function of the Hamiltonian. + pauli_op_matrices : Tensor + Pauli operator matrices of the Hamiltonian. + + Returns + ------- + Tensor + Commutator of the Hamiltonian over the given intervals. + """ + slices = _slices(knots, i, j) + op_vals_outer_product = pauli_op_matrices.unsqueeze(1) @ pauli_op_matrices.unsqueeze(0) + func_vals = _evaluate_funcs(funcs, slices) + func_vals_outer_product = _compute_outer_products(func_vals) + + return (step ** 2) * torch.sum( + (func_vals_outer_product * (op_vals_outer_product - op_vals_outer_product.transpose(0, 1))) + .reshape((n, len(funcs) ** 2, dim, dim)), 1) + + +def _slices(knots: torch.Tensor, i: int, j: int) -> torch.Tensor: + """Take the `i`-th and `j`-th columns of the given knots. + + Parameters + ---------- + knots : Tensor + Knots over each grid interval. + i : int + Index of the first column. + j : int + Index of the second column. + + Returns + ------- + Tensor + Slices of the given knots. + """ + return torch.stack((knots[:, i], knots[:, j])).transpose(0, 1) + + +def _evaluate_funcs(funcs: list, slices: torch.Tensor) -> torch.Tensor: + """Evaluate the given functions along the given slices. + + Parameters + ---------- + funcs : list[function] + Functions. + slices : Tensor + Slices of the knots. + + Returns + ------- + Tensor + Evaluated functions along the given slices. + """ + return torch.tensor([[[1 if f == 1 else f(knot) for f in funcs] for knot in knots] for knots in slices]) + + +def _compute_outer_products(v: torch.Tensor) -> torch.Tensor: + """Evaluate the outer products of the given vectors with themselves. + + Parameters + ---------- + v : Tensor + Vectors. + + Returns + ------- + Tensor + Outer products of the given vectors with themselves. + """ + return torch.func.vmap(lambda x: torch.outer(x[0], x[1]))(v).unsqueeze(-1).unsqueeze(-1) diff --git a/magpy/solver/magnus.py b/magpy/solver/magnus.py index 8303240..ab82f8f 100644 --- a/magpy/solver/magnus.py +++ b/magpy/solver/magnus.py @@ -1,109 +1,63 @@ """The Magnus expansion for the solution to the Liouville-von Neumann equation. -TODO: Flesh this out with implementation details. References ---------- -.. [1] Magnus, W. (1954), "On the exponential solution of differential +.. [1] Magnus, W. (1954), "On the exponential solution of differential equations for a linear operator", *Comm. Pure Appl. Math.* 7, 649-673. -.. [2] Iserles, A., Munthe-Kaas, H. Z., Nørsett, S. P. & Zanna, A. (2000), - "Lie-group methods", *Acta Numerica* 9, 215-365. """ -from itertools import combinations import torch -from .._device import _DEVICE_CONTEXT +from .gauss_legendre_quadrature import get_knots_over_interval, compute_integrals, compute_double_integral_of_commutator -def batch_first_term(H, tlist, n_qubits): - """The first term of the Magnus expansion, evaluated across each given - time interval. - If `H` is an n-qubit Hamiltonian (shape = [2^n, 2^n]) and `tlist` contains - m intervals (m+1 points in time), then this function returns a Tensor with - shape = [m, 2^n, 2^n]. +def first_term(H, tlist, n_qubits): + """Calculate the first term of the Magnus expansion over each given + interval. Parameters ---------- H : HamiltonianOperator - System Hamiltonian + The Hamiltonian operator tlist : Tensor - Discretisation of time + Time grid n_qubits : int - Number of qubits in system + Number of qubits Returns ------- Tensor - Batch first term values + The first term of the Magnus expansion over each given interval """ - - from ._gl3_quadrature_constants import knots, weights_first_term - - t0 = tlist[0] - n = len(tlist) - 1 step = tlist[1] - tlist[0] + knots = get_knots_over_interval(tlist, step) + function_integrals = compute_integrals(H.funcs(), knots, step) + constant_operators = [op(n_qubits) for op in H.pauli_operators()] - z = 0.5*step*knots.expand(n, -1, -1) + (t0 + step*(torch.arange(n).to(_DEVICE_CONTEXT.device) + 0.5)) \ - .reshape((n, 1, 1)).expand(-1, -1, 3) - zw = tuple(torch.ones(z.shape).to(_DEVICE_CONTEXT.device)*weights_first_term if f == 1 - else f(z)*weights_first_term for f in H.funcs()) - a = 0.5 * step * torch.sum(torch.cat(zw, 1), 2) - - return torch.tensordot(a, torch.stack([p(n_qubits) for p in H.pauli_operators()]), 1) - + return torch.tensordot(function_integrals, torch.stack(constant_operators), dims=([0], [0])) -def batch_second_term(H, tlist, n_qubits): - """The second term of the Magnus expansion, evaluated across each given - time interval. - If `H` is an n-qubit Hamiltonian (shape = [2^n, 2^n]) and `tlist` contains - m intervals (m+1 points in time), then this function returns a Tensor with - shape = [m, 2^n, 2^n]. +def second_term(H, tlist, n_qubits): + """Calculate the second term of the Magnus expansion over each given + interval. Parameters ---------- H : HamiltonianOperator - System Hamiltonian + The Hamiltonian operator tlist : Tensor - Discretisation of time + Time grid n_qubits : int - Number of qubits in system + Number of qubits Returns ------- Tensor - Batch second term values + The second term of the Magnus expansion over each given interval """ - - from ._gl3_quadrature_constants import weights_second_term, weights_second_term_coeff - - n = len(tlist) - 1 - commutators = torch.stack([__eval_commutator(H, tlist, i, j, n, n_qubits) for i, j in combinations(range(3), 2)]) - - return weights_second_term_coeff * torch.sum(commutators * weights_second_term, 0) - - -def __eval_commutator(H, tlist, i, j, n, n_qubits): - # Evaluate the commutator of H at slices i and j of the GL knots over n intervals. - - from ._gl3_quadrature_constants import knots - - t0 = tlist[0] - step = tlist[1] - tlist[0] funcs = H.funcs() + pauli_operator_values = torch.stack([op(n_qubits) for op in H.pauli_operators()]) - z = (0.5*step*knots.expand(n, -1, -1) - + (t0 + step*(torch.arange(n).to(_DEVICE_CONTEXT.device) + 0.5)).reshape((n, 1, 1)).expand(-1, -1, 3)) \ - .squeeze() - z_slice = torch.stack((z[:,i],z[:,j])).transpose(0, 1) - - s = torch.stack([p(n_qubits) for p in H.pauli_operators()]).to(_DEVICE_CONTEXT.device) - f_vals = torch.tensor([[[1 if f == 1 else f(knot) for f in funcs] for knot in knots] for knots in z_slice]) \ - .to(_DEVICE_CONTEXT.device) - f_vals_outer_prod = torch.func.vmap(lambda p : torch.outer(p[0], p[1]))(f_vals).unsqueeze(-1).unsqueeze(-1) - s_outer_prod = torch.einsum('aij,bjk->abik', s, s) - - return (step**2)*torch.sum((f_vals_outer_prod * (s_outer_prod - s_outer_prod.transpose(0, 1))) - .reshape((n, len(funcs)**2, 2**n_qubits, 2**n_qubits)), 1) + return compute_double_integral_of_commutator(funcs, pauli_operator_values, tlist, n_qubits) diff --git a/magpy/solver/system.py b/magpy/solver/system.py index 3ee23d3..df0879e 100644 --- a/magpy/solver/system.py +++ b/magpy/solver/system.py @@ -1,58 +1,101 @@ +"""Evolve the density matrix under the specified Hamiltonian, starting +from the initial condition. + +""" + import torch -import magpy as mp -from .._device import _DEVICE_CONTEXT - - -class System(): - """A quantum system (pure or mixed) which evolves under the - Liouville-von Neumann equation.""" - - def __init__(self, H, rho0, tlist): - """Instantiate a quantum system. - - Parameters - ---------- - H : HamiltonianOperator - System Hamiltonian - rho0 : PauliString - Initial density matrix - tlist : list - List of points in time - """ - - self.H = H - self.rho0 = rho0 - self.tlist = tlist - self.n_qubits = max(max(p.qubits.keys()) for p in H.pauli_operators()) - self.states = torch.empty((len(self.tlist), 2**self.n_qubits, 2**self.n_qubits), dtype=torch.complex128) \ - .to(_DEVICE_CONTEXT.device) - self.states[0] = self.rho0(self.n_qubits) - - def evolve(self): - """Evolve the density matrix under the specified Hamiltonian, - starting from the initial condition.""" - - if self.H.is_constant(): - return _evolve_time_independent(self) - return _evolve_time_dependent(self) - - -def _evolve_time_independent(self): - step = self.tlist[1] - self.tlist[0] - - u = torch.matrix_exp(-1j * step * self.H()) +from ..core import PauliString, HamiltonianOperator +from .magnus import first_term, second_term + +def evolve(H: HamiltonianOperator, rho0: PauliString, tlist: torch.Tensor, n_qubits: int = None) -> torch.Tensor: + """Evolve the density matrix under the specified Hamiltonian, starting + from the initial condition. + + Parameters + ---------- + H : HamiltonianOperator + The Hamiltonian operator. + rho0 : PauliString + The initial density matrix. + tlist : Tensor + The list of times at which to return the state. + n_qubits : int + The number of qubits. + + Returns + ------- + torch.Tensor + The state at each time in tlist. + """ + + if isinstance(H, PauliString): + H = HamiltonianOperator([1, H]) + + if n_qubits is None: + n_qubits = max(max(p.qubits.keys()) for p in H.pauli_operators()) + + states = torch.empty((len(tlist), 2 ** n_qubits, 2 ** n_qubits), dtype=torch.complex128) + states[0] = rho0() + + if H.is_constant(): + return _evolve_time_independent(H, tlist, states) + return _evolve_time_dependent(H, tlist, n_qubits, states) + +def _evolve_time_independent(H: HamiltonianOperator, tlist: torch.Tensor, states: torch.Tensor) -> torch.Tensor: + """Evolve the density matrix under a time-independent Hamiltonian. + + Parameters + ---------- + H : HamiltonianOperator + The Hamiltonian operator. + tlist : Tensor + Time grid. + states : Tensor + Empty state tensor in which to store the result. + + Returns + ------- + Tensor + The evolved state at each time in `tlist`. + """ + # Calculate constant propagators. + u = torch.matrix_exp(-1j * (tlist[1] - tlist[0]) * H()) ut = torch.conj(torch.transpose(u, 0, 1)) - for i in range(len(self.tlist) - 1): - self.states[i + 1] = u @ self.states[i] @ ut + # Evolve the state in series. + for i in range(len(tlist) - 1): + states[i + 1] = u @ states[i] @ ut + + return states +def _evolve_time_dependent(H: HamiltonianOperator, tlist: torch.Tensor, n_qubits: int, states: torch.Tensor) \ + -> torch.Tensor: + """Evolve the density matrix under a time-dependent Hamiltonian. -def _evolve_time_dependent(self): - omega1 = mp.solver.batch_first_term(self.H, self.tlist, self.n_qubits) - omega2 = mp.solver.batch_second_term(self.H, self.tlist, self.n_qubits) + Parameters + ---------- + H : HamiltonianOperator + The Hamiltonian operator. + tlist : Tensor + Time grid. + n_qubits : int + The number of qubits. + states : Tensor + Empty state tensor in which to store the result. + Returns + ------- + Tensor + The evolved state at each time in `tlist`. + """ + # Calculate expansion and propagators in parallel. + omega1 = first_term(H, tlist, n_qubits) + omega2 = second_term(H, tlist, n_qubits) u = torch.matrix_exp(-1j * (omega1 + omega2)) ut = torch.conj(torch.transpose(u, 1, 2)) - for i in range(len(self.tlist) - 1): - self.states[i + 1] = u[i] @ self.states[i] @ ut[i] + # Evolve the state in series. + for i in range(len(tlist) - 1): + states[i + 1] = u[i] @ states[i] @ ut[i] + + return states diff --git a/tutorials/core/function_product.ipynb b/tutorials/core/function_product.ipynb index 7609dd8..3c6e359 100644 --- a/tutorials/core/function_product.ipynb +++ b/tutorials/core/function_product.ipynb @@ -17,13 +17,18 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:05:47.302851Z", + "start_time": "2025-01-01T15:05:47.300510Z" + } + }, "source": [ "from magpy import FunctionProduct as FP\n", "import numpy as np" - ] + ], + "outputs": [], + "execution_count": 8 }, { "cell_type": "markdown", @@ -45,24 +50,29 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:05:47.324595Z", + "start_time": "2025-01-01T15:05:47.321695Z" + } + }, + "source": [ + "f = FP(lambda t : t**2, np.sin, np.cos)\n", + "f" + ], "outputs": [ { "data": { "text/plain": [ - "1*{ at 0x7fdbbed77760>: 1, : 1, : 1}" + "1*{ at 0x7f075fd187c0>: 1, : 1, : 1}" ] }, - "execution_count": 3, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], - "source": [ - "f = FP(lambda t : t**2, np.sin, np.cos)\n", - "f" - ] + "execution_count": 9 }, { "cell_type": "markdown", @@ -73,12 +83,15 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:05:47.437889Z", + "start_time": "2025-01-01T15:05:47.435667Z" + } + }, + "source": "f = FP() * (lambda t : t**2) * np.sin * np.cos", "outputs": [], - "source": [ - "f = FP() * (lambda t : t**2) * np.sin * np.cos" - ] + "execution_count": 10 }, { "cell_type": "markdown", @@ -95,23 +108,26 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:05:56.919883Z", + "start_time": "2025-01-01T15:05:56.916375Z" + } + }, + "source": "f(2.0)", "outputs": [ { "data": { "text/plain": [ - "-1.5136049906158566" + "tensor(-1.5136)" ] }, - "execution_count": 5, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], - "source": [ - "f(2)" - ] + "execution_count": 13 }, { "cell_type": "markdown", @@ -137,8 +153,17 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:06:02.792885Z", + "start_time": "2025-01-01T15:06:02.789641Z" + } + }, + "source": [ + "g = FP() * np.sin * np.sin\n", + "h = FP() * np.cos * np.sin\n", + "2 * g * h" + ], "outputs": [ { "data": { @@ -146,16 +171,12 @@ "2*{: 1, : 3}" ] }, - "execution_count": 6, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], - "source": [ - "g = FP() * np.sin * np.sin\n", - "h = FP() * np.cos * np.sin\n", - "2 * g * h" - ] + "execution_count": 14 }, { "cell_type": "markdown", @@ -167,15 +188,22 @@ "\n", "### Equality\n", "\n", - "Two FunctionProducts are said to be equal if they share the same functions, exponents, and scalar coefficient. \n", + "Two FunctionProducts are said to be equal if they share the same functions, exponents, and scalar coefficient.\n", "\n", "N.B. different definitions of the same function won't necessary be detected as the same function. For example," ] }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:06:08.587432Z", + "start_time": "2025-01-01T15:06:08.584310Z" + } + }, + "source": [ + "FP(np.sin) == FP(lambda t : np.sin(t))" + ], "outputs": [ { "data": { @@ -183,14 +211,12 @@ "False" ] }, - "execution_count": 8, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], - "source": [ - "FP(np.sin) == FP(lambda t : np.sin(t))" - ] + "execution_count": 15 } ], "metadata": { diff --git a/tutorials/core/hamiltonian_operator.ipynb b/tutorials/core/hamiltonian_operator.ipynb index 079e218..911d7de 100644 --- a/tutorials/core/hamiltonian_operator.ipynb +++ b/tutorials/core/hamiltonian_operator.ipynb @@ -10,22 +10,27 @@ "\n", "The general form of a HamiltonianOperator is\n", "\n", - "$$\\sum_i f_i \\, \\Rho_i,$$\n", + "$$\\sum_i f_i \\, P_i,$$\n", "\n", - "where $f_i$ are functions (or constants) and $\\Rho_i$ are PauliStrings. \n", + "where $f_i$ are functions (or constants) and $P_i$ are PauliStrings.\n", "\n", "The internal structure is a dictionary of functions paired with one or more PauliStrings." ] }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:08:35.589889Z", + "start_time": "2025-01-01T15:08:34.445507Z" + } + }, "source": [ "from magpy import HamiltonianOperator as HOp, PauliString as PS, X, Y, Z\n", "import numpy as np" - ] + ], + "outputs": [], + "execution_count": 1 }, { "cell_type": "markdown", @@ -47,24 +52,29 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:08:35.599218Z", + "start_time": "2025-01-01T15:08:35.594650Z" + } + }, + "source": [ + "H = HOp([np.sin, X(1)], [np.cos, Y(2)], [2, PS(x=1, z=2)])\n", + "H" + ], "outputs": [ { "data": { "text/plain": [ - "{sin: 1*X1, cos: 1*Y2, 1: 2*X1*Z2}" + "{1: 2*X1*Z2, : X1, : Y2}" ] }, - "execution_count": 12, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], - "source": [ - "H = HOp([np.sin, X(1)], [np.cos, Y(2)], [2, PS(x=1, z=2)])\n", - "H" - ] + "execution_count": 2 }, { "cell_type": "markdown", @@ -75,12 +85,17 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:08:35.669870Z", + "start_time": "2025-01-01T15:08:35.667639Z" + } + }, "source": [ "H = np.sin*X(1) + np.cos*Y(2) + 2*X(1)*Z(2)" - ] + ], + "outputs": [], + "execution_count": 3 }, { "cell_type": "markdown", @@ -108,25 +123,30 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:08:35.715637Z", + "start_time": "2025-01-01T15:08:35.711632Z" + } + }, + "source": [ + "H = np.sin*X(1)*Y(2) + 3*X(1)*Z(2)\n", + "G = np.cos*X(1) + 2*Y(1)*Z(2)\n", + "H + G" + ], "outputs": [ { "data": { "text/plain": [ - "{sin: 1*X1*Y2, 1: [3*X1*Z2, 2*Y1*Z2], cos: 1*X1}" + "{1: [3*X1*Z2, 2*Y1*Z2], : X1*Y2, : X1}" ] }, - "execution_count": 14, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], - "source": [ - "H = np.sin*X(1)*Y(2) + 3*X(1)*Z(2)\n", - "G = np.cos*X(1) + 2*Y(1)*Z(2)\n", - "H + G" - ] + "execution_count": 4 }, { "cell_type": "markdown", @@ -149,24 +169,29 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:08:35.762982Z", + "start_time": "2025-01-01T15:08:35.759555Z" + } + }, + "source": [ + "H = np.sin*X(1)*Y(2) + 3*X(1)*Z(2)\n", + "2 * H" + ], "outputs": [ { "data": { "text/plain": [ - "{sin: 2*X1*Y2, 1: 6*X1*Z2}" + "{1: 6*X1*Z2, : 2*X1*Y2}" ] }, - "execution_count": 15, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], - "source": [ - "H = np.sin*X(1)*Y(2) + 3*X(1)*Z(2)\n", - "2 * H" - ] + "execution_count": 5 }, { "cell_type": "markdown", @@ -182,23 +207,28 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:08:35.809057Z", + "start_time": "2025-01-01T15:08:35.806081Z" + } + }, + "source": [ + "np.sin * H" + ], "outputs": [ { "data": { "text/plain": [ - "{FP: 1*X1*Y2, FP: 3*X1*Z2}" + "{1*{: 1}: 3*X1*Z2, 1*{: 2}: X1*Y2}" ] }, - "execution_count": 16, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], - "source": [ - "np.sin * H" - ] + "execution_count": 6 }, { "cell_type": "markdown", @@ -217,23 +247,28 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:08:35.857226Z", + "start_time": "2025-01-01T15:08:35.854199Z" + } + }, + "source": [ + "H * G" + ], "outputs": [ { "data": { "text/plain": [ - "{FP: 1*Y2, FP: (-2+0j)*Z1*X2, FP: 3*Z2, FP: 6j*Z1}" + "{1: 6j*Z1, : (-2+0j)*Z1*X2, : 3*Z2, 1*{: 1, : 1}: Y2}" ] }, - "execution_count": 17, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], - "source": [ - "H * G" - ] + "execution_count": 7 }, { "cell_type": "markdown", @@ -249,8 +284,15 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:08:35.905885Z", + "start_time": "2025-01-01T15:08:35.902511Z" + } + }, + "source": [ + "np.sin*X(1)*Y(2) + 3*X(1)*Z(2) == 3*Z(2)*X(1) + np.sin*X(1)*Y(2)" + ], "outputs": [ { "data": { @@ -258,14 +300,12 @@ "True" ] }, - "execution_count": 18, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], - "source": [ - "np.sin*X(1)*Y(2) + 3*X(1)*Z(2) == 3*Z(2)*X(1) + np.sin*X(1)*Y(2)" - ] + "execution_count": 8 } ], "metadata": { diff --git a/tutorials/core/quickstart_core.ipynb b/tutorials/core/quickstart.ipynb similarity index 76% rename from tutorials/core/quickstart_core.ipynb rename to tutorials/core/quickstart.ipynb index 20b2f9f..fb5dc4e 100644 --- a/tutorials/core/quickstart_core.ipynb +++ b/tutorials/core/quickstart.ipynb @@ -1,29 +1,34 @@ { "cells": [ { - "cell_type": "markdown", "metadata": {}, + "cell_type": "markdown", "source": [ "# Quickstart: core classes\n", "\n", "MagPy provides three core class structures for representing quantum operators:\n", "\n", "- PauliString\n", - "- FunctionProduct\n", "- HamiltonianOperator\n", + "- FunctionProduct\n", "\n", "The algebra of these objects has been defined such that one may construct these operators in code in a manner similar to that of mathematics." ] }, { + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:02:46.674481Z", + "start_time": "2025-01-01T15:02:45.546012Z" + } + }, "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], "source": [ - "from magpy import X, Y, Z, FunctionProduct as FP\n", + "from magpy import X, Y, FunctionProduct as FP\n", "import numpy as np" - ] + ], + "outputs": [], + "execution_count": 4 }, { "cell_type": "markdown", @@ -34,9 +39,9 @@ "\n", "## PauliString\n", "\n", - "Operators of one or more qubits formed of the Pauli operators (and identity). \n", + "Operators of one or more qubits (and identity).\n", "\n", - "The methods `PS.X()`, `PS.Y()`, `PS.Z()` construct operators formed solely of the respective Pauli operators, taking as arguments the indices at which to insert the operators. In code, the presence of identity operators and the number of qubits is inferred.\n", + "The methods `PS.X()`, `PS.Y()`, `PS.Z()` construct operators formed solely of the respective Pauli operators, taking as arguments the indices at which to insert the operators. In code, the presence of identity operators and the number of qubits is inferred. No arguments impl a single qubit.\n", "\n", "Example:\n", "\n", @@ -50,27 +55,32 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:03:49.600200Z", + "start_time": "2025-01-01T15:03:49.597319Z" + } + }, + "source": [ + "A = 3 * X() * X(3) * Y(4)\n", + "B = Y(1) * X(2)\n", + "\n", + "print(A)\n", + "print(B)\n", + "print(A*B)" + ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3*X1*X3*Y4\n", - "1*Y1*X2\n", + "Y1*X2\n", "3j*Z1*X2*X3*Y4\n" ] } ], - "source": [ - "A = 3 * X(1) * X(3) * Y(4)\n", - "B = Y(1) * X(2)\n", - "\n", - "print(A)\n", - "print(B)\n", - "print(A*B)" - ] + "execution_count": 11 }, { "cell_type": "markdown", @@ -94,25 +104,30 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:03:47.917155Z", + "start_time": "2025-01-01T15:03:47.913649Z" + } + }, + "source": [ + "f = FP() * np.sin * np.sin\n", + "g = (lambda t : t**2) * f\n", + "\n", + "print(g)\n", + "print(g(np.pi / 2))" + ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1*{: 2, at 0x7faeb494bb50>: 1}\n", - "2.4674011002723395\n" + "sin^2*\n", + "tensor(2.4674)\n" ] } ], - "source": [ - "f = FP() * np.sin * np.sin\n", - "g = (lambda t : t**2) * f\n", - "\n", - "print(g)\n", - "print(g(np.pi / 2))" - ] + "execution_count": 10 }, { "cell_type": "markdown", @@ -137,25 +152,30 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:03:34.641516Z", + "start_time": "2025-01-01T15:03:34.638780Z" + } + }, + "source": [ + "H = np.sin * X(1)\n", + "G = np.cos * Y(2)\n", + "\n", + "print(H)\n", + "print(G)" + ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{sin: 1*X1}\n", - "{cos: 1*Y2}\n" + "sin*X1\n", + "cos*Y2\n" ] } ], - "source": [ - "H = np.sin * X(1)\n", - "G = np.cos * Y(2)\n", - "\n", - "print(H)\n", - "print(G)" - ] + "execution_count": 7 }, { "cell_type": "markdown", @@ -173,22 +193,27 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:03:41.945887Z", + "start_time": "2025-01-01T15:03:41.943292Z" + } + }, + "source": [ + "print(H + G)\n", + "print(H*G)" + ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{sin: 1*X1, cos: 1*Y2}\n", - "{FP: 1*X1*Y2}\n" + "sin*X1 + cos*Y2\n", + "sin*cos*Y2\n" ] } ], - "source": [ - "print(H + G)\n", - "print(H*G)" - ] + "execution_count": 9 } ], "metadata": { diff --git a/tutorials/quickstart.ipynb b/tutorials/quickstart.ipynb new file mode 100644 index 0000000..c2084b3 --- /dev/null +++ b/tutorials/quickstart.ipynb @@ -0,0 +1,195 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MagPy quickstart guide\n", + "\n", + "MagPy provides functionality for evolving quantum systems under a magnetic field, utilising the Magnus expansion and the the highly parallelised nature of CUDA computation via PyTorch.\n", + "\n", + "Specifically, we may simulate the evolution of density matrices with respect to the Liouville-von Neumann equation,\n", + "\n", + "$$\\frac{\\partial \\rho(t)}{\\partial t} = -i\\,\\big[H(t),\\,\\rho(t)\\big],$$\n", + "\n", + "with initial condition $\\rho_0.$\n", + "\n", + "## Pauli Strings\n", + "\n", + "These objects are the fundamental building blocks of quantum objects in MagPy. The Pauli spin operators are accessed with the functions `X`, `Y`, and `Z`. These provide a symbolic representation which we may manipulate algebraically." + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:13:15.691794Z", + "start_time": "2025-01-01T15:13:15.688449Z" + } + }, + "source": [ + "from magpy import X, Y, Z\n", + "\n", + "print(3j * X(1) * Y(1, 2))\n", + "print(5 * (X() + Y()))" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(-3+0j)*Z1*Y2\n", + "5*X1 + 5*Y1\n" + ] + } + ], + "execution_count": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The matrix representation of these matrices may also be accessed:" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:13:15.719447Z", + "start_time": "2025-01-01T15:13:15.715422Z" + } + }, + "source": [ + "a = X() + 3*Y(2)\n", + "\n", + "print(a)\n", + "print(a())" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X1 + 3*Y2\n", + "tensor([[0.+0.j, 0.-3.j, 1.+0.j, 0.+0.j],\n", + " [0.+3.j, 0.+0.j, 0.+0.j, 1.+0.j],\n", + " [1.+0.j, 0.+0.j, 0.+0.j, 0.-3.j],\n", + " [0.+0.j, 1.+0.j, 0.+3.j, 0.+0.j]], dtype=torch.complex128)\n" + ] + } + ], + "execution_count": 3 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hamiltonians\n", + "\n", + "The functions `X`, `Y`, and `Z`, enable us to write Hamiltonians and density matrices mathematically:" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:13:15.763443Z", + "start_time": "2025-01-01T15:13:15.761230Z" + } + }, + "source": [ + "import torch\n", + "from magpy import X, Y\n", + "\n", + "H = torch.sin*X() + 4*Y()\n", + "rho0 = Y()" + ], + "outputs": [], + "execution_count": 4 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simulating a quantum system\n", + "\n", + "Given a Hamiltonian and initial condition, we can simulate its evolution over a specified discretisation of time using `evolve`." + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:13:16.381340Z", + "start_time": "2025-01-01T15:13:15.806652Z" + } + }, + "source": [ + "import magpy as mp\n", + "\n", + "tlist = mp.timegrid(0, 10, 0.5**6)\n", + "states = mp.evolve(H, rho0, tlist)" + ], + "outputs": [], + "execution_count": 5 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "The results of which are stored as tensors representing the density matrix each time point." + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:13:16.395398Z", + "start_time": "2025-01-01T15:13:16.390364Z" + } + }, + "source": "states[0:3]", + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[[ 0.0000e+00+0.0000e+00j, 0.0000e+00-1.0000e+00j],\n", + " [ 0.0000e+00+1.0000e+00j, 0.0000e+00+0.0000e+00j]],\n", + "\n", + " [[ 2.4350e-04+0.0000e+00j, 1.5239e-05-1.0000e+00j],\n", + " [ 1.5239e-05+1.0000e+00j, -2.4350e-04+0.0000e+00j]],\n", + "\n", + " [[ 9.7013e-04-6.9389e-18j, 9.1190e-05-1.0000e+00j],\n", + " [ 9.1190e-05+1.0000e+00j, -9.7015e-04+0.0000e+00j]]],\n", + " dtype=torch.complex128)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 6 + } + ], + "metadata": { + "kernelspec": { + "display_name": ".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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/solver/simulating.ipynb b/tutorials/solver/simulating.ipynb index 2597950..475541a 100644 --- a/tutorials/solver/simulating.ipynb +++ b/tutorials/solver/simulating.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Simulating a quantum system (WIP)\n", + "# Simulating a quantum system\n", "\n", "MagPy uses a two-term Magnus expansion to evolve solutions to the Liouville-von Neumann equation,\n", "\n", @@ -15,9 +15,12 @@ }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:11:12.831051Z", + "start_time": "2025-01-01T15:11:12.828171Z" + } + }, "source": [ "import magpy as mp\n", "from magpy import X, Y\n", @@ -26,26 +29,26 @@ "H = np.sin*X() + 4*Y()\n", "rho0 = Y()\n", "tlist = mp.timegrid(0, 10, 0.5**6)" - ] + ], + "outputs": [], + "execution_count": 20 }, { "cell_type": "markdown", "metadata": {}, - "source": [ - "The `System` class represents a quantum system defined by the above equation and initial conditions.\n", - "\n", - "The method `evolve` calculates the density matrix at each point in time and stores the result in the attribute `states`." - ] + "source": "The method `evolve` calculates the density matrix at each point in time and returns a tensor of states." }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:11:12.977953Z", + "start_time": "2025-01-01T15:11:12.846291Z" + } + }, + "source": "states = mp.evolve(H, rho0, tlist)", "outputs": [], - "source": [ - "qsys = mp.System.create(H, rho0, tlist)\n", - "qsys.evolve()" - ] + "execution_count": 21 }, { "cell_type": "markdown", @@ -57,52 +60,50 @@ "\n", "$$\\langle A, B\\rangle_\\text{F} := \\text{Tr}\\big(A^\\dagger B\\big),$$\n", "\n", - "we can measure the magnitude of a single spin component, giving us a scalar value to plot over time.\n", + "we can measure the magnitude of a single spin component, giving us a scalar value to plot over time. MagPy provides a batch function which will calculate the inner product of all state matrices with the given spin component matrix.\n", "\n", - "MagPy provides a batch function which will calculate the inner product of all state matrices with the given spin component matrix.\n", + "Note: the double parentheses indicate that we are calling the `Y` function and then calling it's matrix representation.\n", "\n", "For the $Y$ component of the system's spin," ] }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:11:13.067637Z", + "start_time": "2025-01-01T15:11:12.981626Z" + } + }, + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "y_component = mp.frobenius(states, Y()())\n", + "plt.plot(tlist, y_component)" + ], "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 6, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", "text/plain": [ "
" - ] + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB/NklEQVR4nO2deXwcdf3/X7P35tps7rtpeqa0tIVCD65Wjn4D1BY8QPlKFeXLV+tXsPr9atQKKFDRH+hXrEWotVC/WL8qVEH8KiJQsEDa0kBLj/RImjTNfexmN8me8/tj5jNJ2hx7zO7Mzryfj8c+oLuT2c8mszOveR+vN8fzPA+CIAiCIAgVY1B6AQRBEARBEFNBgoUgCIIgCNVDgoUgCIIgCNVDgoUgCIIgCNVDgoUgCIIgCNVDgoUgCIIgCNVDgoUgCIIgCNVDgoUgCIIgCNVjUnoBchEOh3Hu3DlkZmaC4zill0MQBEEQRATwPI+BgQGUlJTAYJg4jqIZwXLu3DmUl5crvQyCIAiCIGKgpaUFZWVlE76uGcGSmZkJiB84KytL6eUQBEEQBBEBbrcb5eXl0nV8IjQjWFgaKCsriwQLQRAEQaQYU5VzUNEtQRAEQRCqhwQLQRAEQRCqhwQLQRAEQRCqhwQLQRAEQRCqhwQLQRAEQRCqhwQLQRAEQRCqhwQLQRAEQRCqhwQLQRAEQRCqhwQLQRAEQRCqJyrBsnnzZlx22WXIzMxEQUEB1q1bh+PHj0/5c7/73e8wd+5c2Gw2LFiwAC+//PKY13mex3e/+10UFxfDbrfjuuuuw4kTJ6L/NARBEARBaJKoBMsbb7yBDRs24J133sErr7yCQCCAG264AV6vd8Kf2bt3Lz71qU/h85//PA4ePIh169Zh3bp1OHz4sLTND3/4Q/z0pz/Fk08+iXfffRfp6elYvXo1hoeH4/t0BEEQBEFoAo7neT7WH+7q6kJBQQHeeOMNXH311eNuc9ttt8Hr9eKll16Snlu2bBkWLVqEJ598EjzPo6SkBF/72tfw9a9/HQDgcrlQWFiIHTt24Pbbb49oLW63Gw6HAy6Xi2YJEQRBEESKEOn1O67hhy6XCwCQk5Mz4TZvv/02Nm7cOOa51atXY/fu3QCAxsZGtLe347rrrpNedzgcWLp0Kd5+++0JBYvP54PP55P+7Xa74/koE7LtzdNo7R+CxWiA2WiAM92CecVZWFLphNlIJUAEQRAEkQxiFizhcBj33XcfrrjiCsyfP3/C7drb21FYWDjmucLCQrS3t0uvs+cm2mY8Nm/ejAcffDDW5UfMnw+14WBz/wXPF2Ra8e2bqrF2UWnC10AQBEEQeidmwbJhwwYcPnwYb731lrwripDa2toxkRu3243y8nLZ3+fjl5ZheVUuAqEw/MEwOtw+7D/Ti84BH+7dVY+m7kHce90s2d+XIAiCIIgRYhIsX/7yl/HSSy9hz549KCsrm3TboqIidHR0jHmuo6MDRUVF0uvsueLi4jHbLFq0aML9Wq1WWK3WWJYfFXcsnXbBc/5gGE/84wSe+MdJ/PjvDZhRkI6bLy5J+FoIgkhdugZ8+P2BszjY3Ic21zCCYR6hcBihMA8eAM8DYZ5HmOdR7LBjzcIS3LakHBYTpZ4JAtEKFp7n8R//8R944YUX8Prrr2P69OlT/szy5cvx6quv4r777pOee+WVV7B8+XIAwPTp01FUVIRXX31VEihutxvvvvsuvvjFL0b/iZKAxWTA126Yg2CYx9bXT+E7uw/jqpn5cKSZlV4aQRAq5KUPzuGbfzgEjy8Y0fYtvUOoa+zFb/c1Y/v6y1CQZUv4GglC7UQlWDZs2IDnnnsOf/zjH5GZmSnVmDgcDtjtdgDAnXfeidLSUmzevBkAcO+99+Kaa67BY489hptuugm7du3C/v378dRTTwEAOI7Dfffdh4ceegizZs3C9OnTsWnTJpSUlGDdunXyf2IZ2Xj9bLx6tAMNHR5sfeMUvlkzV+klEQShMv5yqA3/8ZuD4HlgQakDaxeVYHpeOsxGA4wGDkYDBwPHwcAJ50MAONjchy2vncThVjf+9Zfv4vkvXYEMa1w9EgSR8kTV1sy+TOfzq1/9Cp/97GcBACtXrkRlZSV27Nghvf673/0O3/nOd9DU1IRZs2bhhz/8IW688UbpdZ7ncf/99+Opp55Cf38/rrzySvz85z/H7NmzI/4gSrU1//1IB77w7H5kWk14+1vX0kmFIAiJNtcQrn98Dzy+ID51eQUeWjcfRsP459Hzae4ZxMef3IvOAR/uWFqBh29ZkPD1EoQSRHr9jsuHRU0oJVjCYR7X/fgNnO7y4vtrL8Jnllcm7b0JglA39+06iN3157C4Ihu/u2c5TFFaIbx9qgefevodAMDLX7kK80rIY4rQHpFev6maK04MBg6fvrwCAPD8wVall0MQhEo40+PFn94/BwD43kfnRy1WAGD5jFzcfLHQjPDTV2lcCaFvSLDIwEcXlsDAAQeb+9HSO6j0cgiCUAHP7D2DMA+snJOPBWWOmPdz77WCbcLfjrSjtX9IxhUSRGpBgkUGCrJsuKxScPv9+9GOKbcnCELbBEJh/LFeiLjeufxCa4RomFWYiRUzchHmgd/WNcu0QoJIPUiwyMR11YJT76tHO5VeCkEQCvPPk93o8fqRl2HB1bPy497fbZcJpph/ev8cNFJ2SBBRQ4JFJlbNFU5KdU298AVDSi+HIAgF+dsRIdJ6w0VFMdWunM911YWwmQ1o6hnEh+cSMzeNSD0G/UH83+E27KprxqGzLs2LWerBlYkZ+RnITbegx+vHobMuLKmceCAkQRDahed5/EOMtF4/r3DK7SMh3WrC1bPy8bcjHXijoQvzS2OviSG0wd5T3fjKbw6i2+OXnrt8eg423TQvrpopNUMRFpngOA5LKp2AGGUhCEKfnOkZRLt7GBajAcurcmXb71Wz8gAAb57okm2fRGryfks/Pvurfej2+FHmtOPq2fmwmgyoa+zFup//Ez9+pQGBUFjpZcoOCRYZYYW3+xpJsBCEXmE3LBeXOWAzG2Xb71ViLcyBM33wRmjxT2iP4UAI9/22Hv5gGKvm5OPvG6/Bs3ddjte+vhI3X1yMUJjHf796Ah/buhenujxKL1dWSLDIyOXTBcGy/0wfQmFt5xIJghgfdsNy2XR508LTctNQ5rQjEOJRRzdFuuXZt5vQ2O1FQaYV//2pxZIoLsm242efvgRPfGoxHHYzPjjrwk0/fRMP//kIjrW7pWvScCCErgEfWnoHEUyxKAzVsMjIvOIspFuMGBgO4nj7ALlS6pS6xl785XAbLCYD1i4speNAZ+wTIyyXy1zHxnEcrpqVh9/UtWDPiS6smlsg6/4J9TMcCOGpPacBAF9fPQdZtgsH7q5ZWILLKnPwn79/H2+e6MbTbzbi6TcbpVlVo2+mM20mrF9eia9cOyslpoKrf4UphMlowMLybADAodZ+pZdDJBme5/Gjvx7DJ3/xNn71zyb84o3TuOmJN/GLN04pvTQiSXQODKOpZxAcB1wyzSn7/lfMEOpY9jf1yb5vQv389cN2dHv8KM2245bFpRNuV+Sw4dm7LsevPncZrpmdjzSLEWEekljhOMBs5DAwHMTPXjuJu5/dD39Q/dEWirDIzLziLOw91YOjbQNKL4VIMr+pa8GW1wRxcsviUnh9QfztSAc2/+UY0ixGmjOlAw6IQmJuURYc9gvvfuNlkXhDdLTNjeFASNYaGUL9/P7AWQDAxy4tg3mKdnmO47BqTgFWzSlAKMyjx+MDD8BuMSLDIlz6/3K4HV//3ft4o6ELP/vHCWy8YU5SPkesUIRFZqqLhfD/kTbyStATnQPD+P5LRwAA/7l6Dn582yI8decSfO16YeL49186imPtdExoHfa9X5igttIypx15GRYEwzydY3RGu2sY/zzZDQD42CUTR1fGw2jgUJBlQ2GWDVk2MwwGDgYDh5suLsYPP34xAODnr59S/WgZEiwyw+oVjra5NW/iQ4zw89dOYSgQwsLybHzxmhnS81/+yExcO7cA/lAY9+2qT4mwKxE7LLI6tygzIfvnOA4Ly4Qoy/stlHbWE7vrWxHmhdqoabnpsu335ouLccXMXATDPH6xR93paxIsMjMjP0PKDZ7to0FleuBs3yD+590zAIBvrJ4Dg4GTXuM4Dj/42MXISbfgWPsAdr5zRsGVEomGRdHmFieu0JrVydWTYNEVfxfdkz+6qETW/XIchw0rZwIAXnivFYN+9bbMk2CRGYvJgJkFwt3VUQrZ6oJn3z6DQIjHihm5WDEz74LX8zOt+M/VQm74v//egF6vf5y9EKmOezgg3aRUFyVesFCERT/0D/rxXrNQH5WI7rDlM3IxLTcNXn8I/3e4Xfb9ywUJlgQwj+pYdIM/GMYfxEK4z66YuKj2k0vKMbcoE+7hIH7y94YkrpBIFsfbhXRQicMGR5r8BbcMVh/T1DOI/kESv3rgzRPdCPPA7MIMlGbbZd8/x3FYu0ioi/nrhyRYdEV1sRBhOUadQprnlSMd6PH6UZBpxUcmufMxGjh8d808AMD/vNuMhg46NrTGsbbEp4MAIDvNIl20jrXTcaQHXjsuzKZaOSdx3js3iHOv9jR0YzigzgG+JFgSwKxCQbBozRaZuJDf7m8BAHxiSdmUU3lXzMjDDfMKEQrz+P5LR6goW2McSXDB7WjYexwnwaJ5eJ7HngahO2jlnPyEvc9FJVkozLJiKBDCgTPq9PkhwZIAqvKECu4zPYNk0a9h+rx+qc3w45eWR/Qz376pGhajAW+e6FZ16JWIHhY1m5MEwcLe4zhF6jTPqS4Puj0+WE0GXJoAM0IGx3GSMeE7p3sS9j7xQIIlAZRk22ExGeAPhXG2T9197UTsvHK0A6Ewj+riLEzPi6zNcFpuOu65pgoA8OCLR2iInYZo6vYCYqdgoplDERbdUNcoRDsWV2TDakqsUeCyKmGcBAkWHWE0cJgu9smf7vIqvRwiQfzlUBsA4Mb5RVH93JdWzkSZ044214jZHJHauIcD6BG7vyojFK/xMFfsQmpoH6DUosZJ1Gyq8bhMfI/3z7oQUOFgRBIsCaIqXzhpUR2LNnENBfCWmA6qWRCdYLFbjPjhxy4GxwG79rXg+ffOJmiVRLJg0ZW8DCsyrImfeFKVny74PfmCaO0nvyctU5eg6d/jMT0vHVk2E/zBsCqjdyRYEgQTLI3dFGHRIq8e7UAgxGNWQYbkuxMNK2bm4T9WCWZN//n7D8YVLZ0Dw3jteCf2N/WSQ67KYd/z6XlpSXk/s9EgpZ7UeGEh5KG1fwit/UMwGjhcUpG4+hUGx3EjPj9n1efzQ8MPE0RVnnAyoZSQNvmLaK5Us6A45n3ce91snO0fwvPvtWLj/76PP9afw7ySLHQN+PDemT6cHiV2y5x2/Pfti3DptMTfZRHR09Qt1KpVymiZPhWzCzNxrH0AxzsGcG11YdLel0ge+8V00PySLKQnIXIHABeXOfDmiW4cOusCliblLSOGBEuCYBGW092UEtIaXl8Qexq6AAA1UdavjMZo4PD/Pr4QBZk2PLXnFN5o6MIb4n4hjoCfVZCBrgEfzvYNYf32fdi9YUVMER0isTSK3/Nk1K8wZhUIN0WnOummSKuw8QuLkxBdYcxh9VEq7EAjwZIgqsRwbYfbB48vmJS8NpEc9jR0wRcMoyInLW7PDYOBwzdr5uKTS8rwl8Pt6BrwISfdgotKsrCkMgcOuxleXxB37diHdxt78Y0/HMLv/305OI6LYO9EsmjsESIskXaLyQE7x9BNkXb54KwLEKMeyWJ2oXBcnejwgOd5VZ1r6CqaIBx2M3LSLej1+tHcMyhNcSZSn7+JQ8humFco25e5Kj8DG8SalvNJt5rwk9sX4drH3sCBM33Yc6Ib18xOnIEUET2s6DaZKSEpitvlVd2FhYifYCiMD88xwZKdtPednpcOo0Eo6G53D6PYIf8ogFihotsEUu4U/tAt5MWiGQKhMF49KgiW1XGkg6Kl2GHH7ZdVAAB++VZj0t6XmJo+rx+uoQAAoDJJRbcQLywcJ3Ss0UBN7XGi04PhQBiZVpNkRpoMrCYjKnOF47ihQ13ROxIsCaQsR/ijt/SSYNEKdY29cA8HkZtuSUrV/mjWr5gGAHjrRBc6B4aT+t7ExDSL3++CTCvSLMkLWtvMRpSId7+nqRtRc3wgdunML3XAYEhu9Gy2OF7mhMrqWEiwJJAKEiya42+inf511YUwJvkkMi03HYvKsxHmoeoR8HqD+aCUOZMfOh9JC6nrTpiIn/cVqF9hsHl4aiu8JcGSQMqdgmBpJsGiCXieH6lfuUiZNtJ/EdNQrx/vmnJbIjm09gmCpdSZvHQQg3mxkH2C9mARlmTWrzBY4S2lhHREeQ6rYSEnSi1wuNWNNtcw0ixGXDEzT5E1XD1LKLZ9+1QPfEF1joDXGyzCUpqtXITlFAkWTTEcCEmGgEpEWFhK6GSnR1WjH6IWLHv27MGaNWtQUlICjuOwe/fuKX9my5YtqK6uht1ux5w5c/Dss8+OeT0QCOB73/seZsyYAZvNhoULF+L//u//ol2a6hidElLTH52Ijb8dEdIw18zOh82c2CFkE1FdnIm8DGEE/PstLkXWQIzlrBRhUUCw5FFrsxY51j6AQIhHTrpFkVTjtNw0cBzg8QWlGVlqIGrB4vV6sXDhQmzZsiWi7bdu3Yra2lo88MAD+PDDD/Hggw9iw4YNePHFF6VtvvOd7+AXv/gFnnjiCRw5cgT//u//jltuuQUHDx6MdnmqoiTbDgMH+IJhdA34lF4OEQc8z+PPHwjDDpVKB0G0zl4ijph/r7lPsXUQI0g1LApEWFhXUkvvIEJhuinSCiwdtKDUoUi7utVkRFGWDVBZSUPUgqWmpgYPPfQQbrnlloi237lzJ+655x7cdtttqKqqwu23345/+7d/w6OPPjpmm29961u48cYbUVVVhS9+8Yu48cYb8dhjj0W7PFVhNhrAetiptTm1+eCsC6e7vbCZDbh+XvLamcfjUlGwHDhDgkUNtIrfbSUiLMUOO8xGDoEQjzYXpZ61AoueLlQgHcQoV2HTSMJrWHw+H2w225jn7HY76urqEAgEJt3mrbfemnS/brd7zEONsDoWNalUInp217cCAK6fV6S4a/ElomA52Ky+4WR6Y2A4APdwEFCohsVo4EaK+3voHKMVDrUqV3DLYMeVrgTL6tWrsW3bNhw4cAA8z2P//v3Ytm0bAoEAuru7pW0ef/xxnDhxAuFwGK+88gqef/55tLW1TbjfzZs3w+FwSI/y8vJEf5SYGPmj091PqhIMhfHi++cAALcsLlF6OZhXnAUDB3R7fOh0kx+LkrB0UHaaOWnD6c6nQjT5OqOiCwsRO15fECc7hZokJQpuGawGU0032wkXLJs2bUJNTQ2WLVsGs9mMtWvXYv369cKbG4S3/+///m/MmjULc+fOhcViwZe//GV87nOfk14fj9raWrhcLunR0tKS6I8SEyxMfK6fBEuq8rcjHej2+JGbbsFVs5S3xLdbjNIcmQ/b1BlZ1AtSS7MC0RXGNPHCcoYiLJrgcKsLYR4oyrKhIMsWwU8khopcsZxBRTfbCRcsdrsd27dvx+DgIJqamtDc3IzKykpkZmYiP184+efn52P37t3wer04c+YMjh07hoyMDFRVVU24X6vViqysrDEPNcKcKM+56E44VWFW+J9eWgGzUR1OAPOKheP9yDkSLEqiZEszQ421BkTsHGpVzjBuNGr0EUva2ddsNqOsrAxGoxG7du3CzTfffEEExWazobS0FMFgEH/4wx+wdu3aZC0vYZRkU4QllTnY3IcDZ/pgNnL4zLJpSi9HorpYvSPg9USrgi3NjGniwMUzveTFogWYw+3CcuXqVzAqJdTmGkIgFFZ0LYyok64ejwcnT56U/t3Y2Ij6+nrk5OSgoqICtbW1aG1tlbxWGhoaUFdXh6VLl6Kvrw+PP/44Dh8+jGeeeUbax7vvvovW1lYsWrQIra2teOCBBxAOh/Ff//Vfcn1OxSjOFkJ6bf1DNFE1Bfnx308AANYsLFE0PHs+oyf1EsrRJkZOSxScaDstdyQlROeY1GfE4VbZCEt+phVWkwG+YBjn+ockYawkUQuW/fv3Y9WqVdK/N27cCABYv349duzYgba2NjQ3N0uvh0IhPPbYYzh+/DjMZjNWrVqFvXv3orKyUtpmeHgY3/nOd3D69GlkZGTgxhtvxM6dO5GdrazClAN2IvP6Q3APB+Gwm5Veku4JhMJ44h8n8af6VnAch2vnFuDfV85AXoZ1zHYvH2rDnoYumI0cvvKRWYqtdzxmjJohQxcp5WgXi54LHcqJWRa6HxgOon8wAGe6RbG1EPHRP+iXapEWlCorWDiOQ3lOGk52etDcO5iagmXlypWTurbu2LFjzL+rq6unNIC75pprcOTIkWiXkhLYLUY408zoGwygzTVEgkVheJ7Hfb+tl0zgAGDbW434TV0zvrRqJj5/5XTYzEa839KPb/z+AwDAv11dhcokjnePhIqcdBg4QQh3DvhQqKLoj57oEAVLkYK/f7vFiIJMKzoHfDjTO0iCJYVh6aDpeenITlP+71jutONkp0c1hbfKGkrohGKHHX2DAZzrH8LcInUWB+uFP9afw58/aIPZyOHhWxbAYTfjZ/84iUOtLvzor8ex7c3TqMrPwPst/QiGeVxemYN7r52t9LIvwGIyoDwnDWd6BnG6y0uCRQF4nke7S3nBAjEt1DngQ3PvIBYpXPtAxM77LUI6SEnDuNGwGsx2lZgSqqPlQeOUiHUs5/qpU0hJQmEeP31VqEn5ykdm4ZNLyrH6oiL8ccMV+Mlti1DisKFvMIADZ/oQDPNYfVEhtn12CSwmdX5NqsSoD82RUYb+wQB8QaEYsSDLOuX2iaQiRzgWmnuopimVkQSLSkQnE+JtKulypQhLEmD2/GSdrSxvnujC6W4vHHYzPnfldOl5g4HDusWluPniYrzX3I929zDmFGZiTlGmouudiqr8DLx2vIsKbxWC1a8408yKDcNkjC68JVITnufx/lnlHW5HUyTWZrWrxKCSBEsSGGltVscfXa/8SXSrXbuoZFx7fZPRgMun5yiwstioGlV4SyQfdhIvUrBDiMFaUMntNnVp7R9Ct8cPk4HDRSXqKB1gN9vtKomwqDPWrTFGUkIUYVGKQCiMVz7sAMQWZS1QlSe43TZ2U4RFCTqk+hVl00EYZc9P5nGpCxt4OLc4U/GIHUOKsJBg0Q8jKSF1/NH1yPst/RjwBZGdZsYlFU6llyMLLMLS0jeEoEqMnfTESIRF+YLnaZLJ1zCGAyGll0PEAPNfWaiSdBBGHdsDviA8vqDSyyHBkgxYhKXdNYxweOKWcCJxvHlCGLR5xYw8GA3a8CzJz7DCYjQgFOZVk2PWE6ylWQ0dWjnpFqRbhLvys30UyU1F6lVWcAsAGVYTMsX0uRqiLCRYkkBhlg0cB/hDYXR7fUovR5fsa+oFACyfkav0UmTDYOAkJ2Wqj0o+amlpxiiTL1BaKCUJhsLSDCG1taWrKS1EgiUJmI0GFGQKee42urAknVCYl9oFL52mjXQQgw3da+2ni1SyYSleJV1uR8MKb1v66FhINY62DWDQH0Km1YQZ4iR2tcAEixq6XEmwJAnWKaSGP7reONE5AK8/hDSLEbML1d2qHC3UgaYcanC5HQ2LsDRTa3PK8W5jDwBgSaVTdSlrdnx3qCDtTIIlSbCZQnRhST4fiHbXC0odqjsZxEuJFGEhIZxM/MEw+gYDgEpqWDAqwtJMKaGUo65RSFkvrVJfyrrYoR7zOBIsSYL90am1OfkcbXMDAC4qUYfdtZyUMcFChZZJpdsj1KKZjRyyVTIfjARLahIO81KNnRp9oIpU5MVCgiVJFGdTa7NSHGsbAER/A60xkhIiwZJMmGDJTbfCoJKo3eii28kG1BLq4mSXB32DAdjNRsxX4U1VkUOov1RDJyIJliRRrDKLY73A8zyOtQsRlmoNDp4cbUpIF6nk0TUgCJb8TOVN4xhlTkG8ev0hKV1FqJ93Tgv1K5dMy1bl3LKCTOEcw455JVHfb0ejqKk1TE90e/zoGwyA44BZheqqvpcDFmHx+kNwDdFFKlmoUbDYzEYUiq67lBZKHV471gkAuGJmntJLGRd2jPd4/Qgp7CNGgiVJsAhLh5vM45LJGXF6bYnDrhq7azmxmY3Iy7AAVHibVCTBkqEewQKqY0k5Bv1B/POUEGG5rrpQ6eWMS066BRwn2EP0DfoVXQsJliSRn2GFgQOCYZ7M45IIm7NTmZem9FISRgkV3iadLo/6Iiw4r46FUD97T/bAHwyjzGnHrAJ1RoDNRgNy0oSbIqXTQiRYkoTJaJBObpQWSh5nRE+Kytx0pZeSMEpoVlXSYUW3LLqlFirIiyWlePWYMJD12rkF4Dh1FG+PB7t2kWDREUV0YUk6jWJKSMuCpUCsW+gcoOMqWYzUsKjDg4VBbrfKw/N8RAXwgVAYrxwRBMtHVJoOYqhFsJgUfXedUZxlw/sqcQzUC6yGpTJPw4JFPJl0uinVmCzUWHSL0W63lBJShJc+OIeH/3wUXQM+fGRuAb6/bv6ExoJ7GrrQ7fEjN92CFSqfccZqtVgqVCkowpJEilTkGKgHeJ5HUzdLCWm3hoW1HXaqoO1QL6hVsLAIy7n+IQRCYaWXoyveOtGNr/zmINpcwwiGefztSAdu2fJPNHQMjLv9s2+fAQCsW1wKs1Hdl2K1RFjU/VvSGNTanFx6vH54fEFw3MidpxYZSQmRYEkGg/4gvP4QoMIalvwMK6wmA8I8mQkmk2AojAde/BBhHrhlcSme/9IKVOWl45xrGLc/9Q6Ot48VLYdbXXijoQsGDrhz+TTF1h0pJFh0SLGKpl7qgaZubbc0M0aMnUgIJ4PuAaG102Y2IMOqrqy6wcBRWkgB/nGsEyc7PchOM+PBtRfhkgon/vDFFVhQ6kCv1487tr2Dk52CaAmEwvjuHw8DANYsLMG0FKivI8GiQ0amXtKdcDJoEjslpmk4HYRREZYerx9BSgMknC6PIAzzM62q7OwoFx1vW3rpxihZ/P7AWQDAJy4tQ5ZNmC3lTLdg5+cvx7ziLHR7/PjY1rex5bWT+PedB/Becz/SLUZ841/mKrzyyKAaFh1SLHUJkY16MmBeFFoXLDlpFpgMHHhecPYlEotaTeMYZB6XXAb9Qbx+vAsAcOslZWNey06z4H++sBSLyrPhGgrgR389jlePdcJs5PDfty+WPJTUjloiLOqKZ2ocdic8HAjDNRRAdpq68t9ag6XemFDUKgYDh7wMK9rdw+hwD0u1UkRi6BJFYZ5KBQuZxyWXd0/3wh8KozTbjrlFFw5YdaZb8L/3LMdv97fgjeNdcNjN+NwVlZhfqr5BhxPBBItrKABfMASrSZkUOwmWJGIzG5GTbkGv14821zAJlgTDurH0cAEvyBIECxXeJh61dggxKMKSXPacEKIrV8/OnzBFaDEZ8Jll0/CZZeovsB0Ph90Ms5FDIMSjx+NXLDJEKaEkw+pYaGpz4mHdWCUaj7BgtBcLFd4mHNULllwSLMnkwJk+AMBylXupxAPHcSN1LAreFFGEJckUO2w40uam1uYkoKcIC3NcJfO4xKN2wVLuFASLaygA11AADrtZ6SVpluFACEfOuQEAl1RkK72chHL17Hy4hwOwmpWLc5BgSTKFZB6XFAaGA/D4gsCodnItMxJhIcGSaKTBhyqtYUm3mpCbbkGP14+W3kE4UqhWItU41OpCMMwjP9OK0hQpoI2VH3zsYqWXQCmhZFPMUkLkxZJQmCDMspmQrjKvjETACrrJiyXxdIuiME+lERZQ4W3SONzqAgAsLHOossVda5BgSTKS2y2F7hMKEyxa7xBikD1/cuB5XvURFlDhbdI41iaYwVUXZym9FF0QtWDZs2cP1qxZg5KSEnAch927d0/5M1u2bEF1dTXsdjvmzJmDZ5999oJtfvKTn2DOnDmw2+0oLy/HV7/6VQwPa+9ukV1AKcKSWNjvtzhb++kgjLKI7yEfloTiHg7CHxTM+dRaw4JRgoWZJxKJ4Vi7UL8yt4gESzKIOlbu9XqxcOFC3HXXXbj11lun3H7r1q2ora3F008/jcsuuwx1dXW4++674XQ6sWbNGgDAc889h29+85vYvn07VqxYgYaGBnz2s58Fx3F4/PHHY/tkKqXIIZzkqIYlsZzrZxEWvQgW4bjq9vjA8zyFpxMEK7jNtJlUPe5hujidnI2nIOQnHObR0OEBAMwtvtB/hZCfqAVLTU0NampqIt5+586duOeee3DbbbcBAKqqqrBv3z48+uijkmDZu3cvrrjiCnz6058GAFRWVuJTn/oU3n333WiXp3qKxAjLwHAQXl9QF/UVStCus5RQrhhh8QXDGPSH6LhKEN0pkA4CgEomWHpIsCSKc64hDAVCMBs5TNPwcFU1kfAaFp/PB5tt7F2u3W5HXV0dAoEAAGDFihU4cOAA6urqAACnT5/Gyy+/jBtvvDHRy0s6GVYTMsWLCXmxJI5zYkpIDy3NAJBmMcEu3vFTWihxdKVAwS0AVImCpc01jEF/UOnlaJIzYrqt3JkGk5HKQZNBwn/Lq1evxrZt23DgwAHwPI/9+/dj27ZtCAQC6O7uBgB8+tOfxve+9z1ceeWVMJvNmDFjBlauXIlvfetbE+7X5/PB7XaPeaQKUuEtpYUSxkiERR+CBQBy0oUoS7eXCm8Thdo9WBjOdAuy0wT/laZuqmNJBGd0MlxVTSRcsGzatAk1NTVYtmwZzGYz1q5di/Xr1wtvbhDe/vXXX8cjjzyCn//853jvvffw/PPP489//jO+//3vT7jfzZs3w+FwSI/y8vJEfxTZKCIvloTDumUKs/QjWKjwNvGkQocQg9WxNFIdS0I4I6bbpuWmK70U3ZBwwWK327F9+3YMDg6iqakJzc3NqKysRGZmJvLz8wFR1HzmM5/BF77wBSxYsAC33HILHnnkEWzevBnhcHjc/dbW1sLlckmPlpaWRH8U2WD2/B2UEkoIvmAIriEh3ZgKFxa5yBU/ay9FWBJGd4pEWDBGsHiUXoomoQhL8klaZZ7ZbEZZmTB6e9euXbj55pulCMvg4KD0/wyjUcjH8zw/7v6sViusVvWfNMajWIqwUGtzImARBpOB05UteS5LCVGEJWGkUoSF1bGcpghLQmAFzZUUYUkaUQsWj8eDkydPSv9ubGxEfX09cnJyUFFRgdraWrS2tkpeKw0NDairq8PSpUvR19eHxx9/HIcPH8Yzzzwj7WPNmjV4/PHHsXjxYixduhQnT57Epk2bsGbNGkm4aIkiyYuFIiyJgHVy5GVYYTDop703h1JCCSdValgAYHpeBkCtzQmB53nJlK+CIixJI2rBsn//fqxatUr698aNGwEA69evx44dO9DW1obm5mbp9VAohMceewzHjx+H2WzGqlWrsHfvXlRWVkrbfOc73wHHcfjOd76D1tZW5OfnY82aNXj44Yfj/4QqhLxYEksqXVTkJC9d+Lw9lBJKGKl0bE0fFWEhbx556fL4MOgPwcABZU59WCeogagFy8qVKydM0wDAjh07xvy7uroaBw8enHwRJhPuv/9+3H///dEuJyUpyhIOcKphSQwjERaL0ktJKsyLpddLEZZEEA7z6BF/t6kiWDgO6B8MoNvjT4k1pwqsfqUk2w6rSXtZALVCzeMKwGpYuj1++IIhpZejOVLpLlhOcqiGJaH0DfoRCgs3a+x3rWbsFqNkaNbQMaD0cjQFS7NRwW1yIcGiANlpZlhNwq++k4Ygyg67YOelQGGknLDP2+OhYyoRsILbnHQLzCliFDa7ULCMP95OgkVOzvYJDRPlThIsySQ1vnUag+O4UZ1ClBaSG71GWEanhCZL2xKxIR1XKSSE5xYJgoUiLPLC0vl6Gf2hFkiwKAQzNCN7fvnpGtUlpCdYmiIY5uEeIjt2uUlFITxbFCzHSbDICrvRZA0URHIgwaIQxZI9P3mxyE0qmXvJidVklOZUkT2//KRiMfccMSXU0D5AUTcZYRGWIoqwJBUSLArBDnRKCcmPXiMsGJUWIi8W+UnFCEtlXjrMRg5efwit/XRzJBcsMl6ko9EfaoAEi0IU0wDEhDAcCGFgWEiHpNKFRS6y0wTB0jdIgkVuUlGwmI0GzMgXDOSo8FYehgMh9A8Koz9IsCQXEiwKQTUsiYGF7S1GA7JsSZs8oRqc4oTefhIssiPZ8qeQYMGowttDrS6ll6IJ2E2m3WxEll1/5xglIcGiEBRhSQyj74L16OzpTGedQgGll6I5ugdE07iM1LqrXlzhBADUt/QrvRRNMFJwa9PlOUZJSB4qBBMsnQM+BENhmFLE10HtsNqN3BQqjJQTp5gSogiL/Ei1UZmpdWwtrsgGABxs7o/Yor+usRePv3IcoTCP+66bjStm5iVhpalBB9WvKAZdJRUiN8MKk4FDKMyTM6mM9IoX6lRwIk0ELCVENSzyEgiFpZEHqeTDAgBzi7JgMRngGgqgMYJBiHWNvbhj2zt453Qv9jX1Yf32Ohw5507KWlMBqeDWQYIl2ZBgUQijgUOBmAunOhb5YBcV3QoWSgklBBa5Mxo4KYqVKlhMBiwodQARpIW8viC++tt6BEI8rp6dj8srcxAM83joz0eStFr10+4iwaIUJFgUpIi8WGSnjwmWFLuoyAWlhBIDK+bOTbfAYEi9uoXF5SNpocl4as9ptPYPocxpx5P/egl+fPsiGDhg76kenO7yJGm16kYSLJQSSjokWBSkmLxYZIdFWJw6jbBkU0ooIbBi7oKs1EoHMVjh7b6m3gm36R/0Y/tbjQCA2ppqpFlMKM2245rZ+QCAFw62Jmm16qaNUkKKQYJFQYponpDsMMGSq1PBwlJhfYOUEpKTzgHhO5pq9SuMpVU5AIBj7QPSZzmfbW82YsAXxNyiTNTML5Kev/niEgDAGw1dSVqtuukUBUshRViSDgkWBSnJFiIsrX2UEpILVnSr1wjL6JRQOExW7HKRiqZxo8nLsGJ+aRYAYE9D9wWv93n9+NU/hejKfdfNHpP2unKW0CF0qNUlpVz1Cs/zUj1TKo1o0AokWBSk3CkIlrN9g0ovRTPoveiWpYTCPCTHXyJ+Ul2wAMBH5hQAAP7vcNsFrz35xil4/SFcVJKF1RcVjnmtMMuG2YUZ4Hng3caJU0p6wD0chD8UBnQ6+kNpSLAoSJkzDQBwliIssqF3wWI1GZFuMQKjok1E/Egutyl8kVqzcCS1MzpScrZvEL/a2wQA+NoNs8f1aVlcLtTAfHBW3+ZzrPg602qCzWxUejm6gwSLgpTlCBGWHq8fXh/dDcdLIBSWogp67RICzRNKCCMRltStW5hVmIn5pVkIhHg8V9csPf/Y3xrgD4axrCoHq8QozPksFLuMPjirb3t/vRtTKg0JFgXJspnhsAshfJqkGj/srtHAQfq96hEWXaLWZvnQQkoIAL5wZRUgti+3u4bx8qE2qfvnWzdWT+iCe3GZ4OPywVnBLVevdOt4ErwaIMGiMGVUxyIbUsFtWmp6ZcgFq2Mh8zj50IpgufniYiwodcA1FMB1j7+BLz/3HgDg7qum4+Ky7Al/bnZhJkwGDu7hoK67GnuYHw9FWBSBBIvCMMHS0ksRlnjp9ei7Q4hB5nHy4vUF4fWHAEByp05VTEYDfvqpxShz2uHxBRHmgVsWl+K//mXupD9nMRlQmZcOAGjoGEjSatVHl9QhlNrHQapCww8VplwqvKUIS7zofY4QY8SLhQSLHLA0QJrFiHRr6p8yp+el46/3XY13TvegINOGBWK6ZypmF2bgZKcHJzo8WDlBrYvWoZSQsqT+ty/FoQiLfOjdlp9BKSF50Uo6aDTpVhOurS6MYMsRZhVkAmjXdYSlRxIs+j7HKAWlhBRGam3upwhLvPTo3JafQSkheZEEi87vqmcWZABARBOftUo3pYQUhQSLwpTnCIKFIizx06dzW36Gk1JCsiJ5sGgowhILlblCDUtTj35vrqQIi86PBaUgwaIwFaJgcQ0FdG97HS+94vwcirCIAxApJSQLnW4SLABQkSucq7o9Pt36RrEIi95vipSCBIvC2C1GlIhDEE/rONQqBywFkq1jDxaMSglRhEUeKCUk4LCbpYLuMzqMsgwHQvCIQo0iLMpAgkUFTM8XQq2nuzxKLyWl6ZciLDoXLJJxXEDXJl9yQSmhEVhEuKlHfzdXrEPIYjQgUwPdYqkICRYVUJVHxWxy0D8kRBQcdn2Ha1lKyB8KS/4hROywCEtBFgkWJlj0OGG+e9SU5okcgYnEQoJFBUzPYxEWEizx4BIjLHq25QcAu9kIi0n4alNdVPyMpIRSd46QXBRnC7+Dcy79CZZeL3O5JeGqFCRYVEAVSwl1R58SevtUD772v+/j56+fRFAce65HQmEebnHwIfMh0Sscx0leNCxNRsRGOMxLqQBKCQElDsE3qq1ff/b8zNdI70X9SkKJOBXAUkJNPYMIhXkYI5yD8/rxTnxuxz6wMoXmnkH84GMXJ3KpqsU9NHJh1nuEBaJoa3cPS+6/RGz0DwUQDAtfMJofAxSJDQJtOoywsKL+HJ3fEClJ1BGWPXv2YM2aNSgpKQHHcdi9e/eUP7NlyxZUV1fDbrdjzpw5ePbZZ8e8vnLlSnAcd8HjpptuinZ5KUmp0w6L0QB/MIxzEU5tHvQH8V+//wA8D1SJKaVd+1pwvF2fLpQuUbCkW4wwGylwSOZx8sDSQTnpFjquRkVYzulwAGKvmF7N1rmTtpJE/Q30er1YuHAhtmzZEtH2W7duRW1tLR544AF8+OGHePDBB7Fhwwa8+OKL0jbPP/882trapMfhw4dhNBrxiU98ItrlpSRGA4dposdBpK3N//NOMzoHfCjPsePle6/CjQuKAAA79jYmdK1qpV8ULHQyEWCdUlTDEh/U0jwWVsPS7fHBH9RXCrqPZpUpTtQpoZqaGtTU1ES8/c6dO3HPPffgtttuAwBUVVVh3759ePTRR7FmzRoAQE5Ozpif2bVrF9LS0nQjWCDaXp/o9OB4uxvXzM6fdNtQmMev/ikIky+vmgmb2YhPXV6Blw+145UjHXhoXeRpJa3AIgmUDhLIlrxYqIYlHjrcQiSBOoQEctMtsJiEaHCHe1hy6tYDzIjRSSkhxUh4jNPn88FmG1tdb7fbUVdXh0Bg/JPpL3/5S9x+++1IT0+fdL9ut3vMI5W5qCQLAPDhuak/x+vHO3HONQxnmhlrF5UCAJZV5SLTZkK3x4/6lr6Er1dtuKQIC51MMOqk6hoiwRIP7aJgKcyiDiGIBd3FUh2LvtJCrB6Mim6VI+GCZfXq1di2bRsOHDgAnuexf/9+bNu2DYFAAN3d3RdsX1dXh8OHD+MLX/jCpPvdvHkzHA6H9CgvL0/gp0g8F5UKI94Pt7qm3Pb591oBALdeUgab2QgAMBsNuHJmHgDg3cbehK5VjbALM0VYBLLt5HYrByzCUkSCRYL9LvRWeMuiuE5KOytGwgXLpk2bUFNTg2XLlsFsNmPt2rVYv3698OaGC9/+l7/8JRYsWIDLL7980v3W1tbC5XJJj5aWloR9hmQwv0QQLKe7vZPO6RgYDuDvRzsAALcsLh3z2qXTnACAA036i7Cw9l2KsAiw3wOlhOKjXYwiFDpIsDBKssXCW521NkttzSRYFCPhgsVut2P79u0YHBxEU1MTmpubUVlZiczMTOTnj63V8Hq92LVrFz7/+c9PuV+r1YqsrKwxj1QmP9OKwiwreB442jZxWuj/DrfDFwxjRn66lEZiLKkUaoEONPfpzpK9XzKNo5MJqEtINijCciHFOmxt5nl+pK2ZUkKKkbQ+PbPZjLKyMhiNRuzatQs333zzBRGW3/3ud/D5fPjXf/3XZC1LVbAoy2RpoT+9fw4AsG5R6QX20POKs2AycOgfDOiu7ZBSQmNhXUJkHBcf7SRYLqBYhxGWAV9Q8uOhKK5yRC1YPB4P6uvrUV9fDwBobGxEfX09mpubATFVc+edd0rbNzQ04Ne//jVOnDiBuro63H777Th8+DAeeeSRC/b9y1/+EuvWrUNubm58nypFmc/qWCYovO0cGMY/Twp1P6zYdjQWkwEzCwQTumOTRGm0iGuIeSTQyQRjuoQowhIrwVBYamsudFCXEINNl2936yfCwuwB0ixGqW6QSD5RC5b9+/dj8eLFWLx4MQBg48aNWLx4Mb773e8CANra2iTxAgChUAiPPfYYFi5ciOuvvx7Dw8PYu3cvKisrx+z3+PHjeOuttyJKB2kVJljqW/rHff3F99sQ5oFLKrJRkTt+O+HcokwAwDGdGchJNSwUYQFG/R4GhoO6HtkQD10eH8I8YDJwyEsnwcJgIwqYmNMDrBaM6leUJWoflpUrV05aH7Fjx44x/66ursbBgwen3O+cOXN0V3dxPpdVOsFxwMlODzrdwygYFYbmeR6/2y8UFq9bfGF0hTG3OAuoPzdpHYwWYcZxDoqwAOelxvqHAsgj47OoYQW3BZlWGHTmazQZ7Fjq8fgRDvO6+N2wCAtLtRLKQF7TKiI7zSIV0u491TPmtUOtLhxrH4DFZMDahRMLlpn5QkpIb5OfqYZlLCajAVk24X6ECm9jgxXcUofQWNhMpWCY143PD7PlpwiLspBgURlXiF4qrHWZ8dt9QnSlZn7RpFGE6eLk58Zur24iVjzPwzVI1vznwwyuqPA2NliEhQpux2I1GSUxzCZZa50+8mBRBSRYVEbN/GIAwKtHOzHkDwFi9OCP9UJ30CeXTG6QV+5Mg9HAYSgQQodbHyeToUAIfrFOg2pYRmC/C/JiiY128ftDLrcXksfqWHQmWKilWVlIsKiMhWUOlOfYMRQI4fmDZwEAv/pnIzy+IGYXZmB51eQdVBaTAeVOoe2wMcJBiqkOiyCYDBzSLFTBz6BOofjoIFv+CWHDILs9+ji2+siYUhWQYFEZHMfhcyumAwC2/OMkXj3agZ+/fgoA8JVrZ0VU4FaZJ6SFmnr0IVhGzxE635tGz7B5QlTDEhvMGK2IWpovgEVYunXSKdRHNSyqgASLCrn98nJMy03DOdcwPv/MfviDYVw9Ox83LSiO6OfLnMzYSR8+CSMut3T3M5rsNKphiYdW8ftT5tTPROJIGYmw6EOw0OgPdUCCRYWkWUx4+s4lkgncyjn5+NmnF0ccPSh2CIKlVSeCZcQ0ju5+RkPzhGInFObRJjq5lorOrsQIeWKnkF4EC3UhqoOofViI5DC7MBOvfPVq+ILhqJ0VS7P1FWGhk8n40Dyh2OlwDyMY5mEycFTDMg55OqthoXOMOqAIi4rhOC4mG2g2TbVNJ/OEyOV2fEYiLPq4qDA6B4Zxz879uPmJN/HyobaY9nG2TxD7Jdl2GHVgjBYteTpLCY3UyVEUV0lIsGiQkmxxmmr/MMJh7XuxkMvt+Dh1WMPC8zy+8puD+OuHHTjc6saG597DgTO9Ue+ntX8QoHTQhOip6DYQCsPjCwIUYVEcEiwapDDLBo4D/KEwur3aP6GMRFjo7mc0ehQsdY29eOd0LyxGA2bkp4PngQdfPBK1ieLZXlZwS4JlPEZqWPyaN6h0j3LzZYZ5hDKQYNEgZqMBhZlClEUPI+DdUn6ZTiaj0WNK6Dd1wuDVj11aiv+9ZzmsJgM+OOvCe83jDxSdCJYSKiXBMi4sJeQPheEeDiq9nITC0kGZVhNMRrpkKgn99jXKSFpI+4W3/dQlNC5MsPiCYck1WcuEwjxeO94FALj1kjLkZljx0YUlAID/FUdbRAq1NE+OzWxEpk7s+ZlgyaJ0kOKQYNEorPBWD63Nkg8L1bCMIcNqgkksGNVDlOVwqwuuoQAyrSYsLs8GAKxdJAwKffVYB0JR1HOd7aMalqmQCm81XsfSTx1CqoEEi0YpkVqbtZ8SopbD8eE4TlfmcWzC+bIZuVLofmlVDrJsJnR7/HivuS+i/YTDvPS9oRqWiXHqxOfHPUSmcWqBBItGKXGwGhbtR1hc1NY8Idk6suc/1CrUqVw6zSk9ZzYacG11IQDgbx+2R7SfLo8P/lAYRgOHYgd5sEwEGwSo9egd3RCpBxIsGmXEi0XbgiUQCmNAbDmkGpYL0ctdMAB8cNYFALi41DHm+RvmiYLlSEdEHS2nu4QZXKXZdiqynAS9DNek0R/qgb6NGqVAdOfs1Hh+mVoOJ0cvF5U+r1/q7LnoPMFy9ex8mI0czvQM4kzP4JT7OtXlAQBpNAYxPlKExavtY8tFPk+qgQSLRsnPHHGi1LJPArUcTg6LsLiGtB1hOd4xAAAoz7FfcCecbjXhkgohTfTmia4p98UEy4z89ISsVSswn59er7aPLUoJqQc6w2uUXPHuJxDiNX2xIpfbyZEiLBq/Cz7ZKUZF8sePilw9Ox8A8OaJ7in3dUpMCc2YYF+EgFMn9VFkTKkeSLBoFJvZKKVItOyT4KKx75Oil4nNkmCZII1z1aw8AMDbp3oQDIUn3dcpcV8zKCU0KU7xpqhX44LFTREW1UCCRcOweR9dA9o9oVC4dnL0MrF5qrqTi0ocyE4zY8AXxPtnJ3a9HfKHJO8iirBMju5qWOgcozgkWDRMvmjs1KXhCAu7EFO4dnycOrHnPz1FGsdo4HDFTCHKsqdh4rTQ6W5B+DjTzNIFmRgfvXSgjThpk2BRGhIsGkYPE1WphmVyJOM4DdcxBUJhqX2/ImdiK/2rxbTQZIW3rH6FOoSmhkXvXEOBKdNsqQxFWNQDCRYNo48IC5nGTcaIcZx2BUu7axhhHrAYDZJd/HhcOUsovH3/rGvCQnRWC0PpoKlx2M3ghMkPmhXEw4EQhgOCGKNZQspDgkXD5OsgwkIFcZMzuoYlHMUsnVRi9GRlgzg7aTxKs+2oyk9HKMzjbdHG/3yOnBPM52YXZiZotdrBZDQgy6btTiF2fjFwgnUCoSwkWDSMLiIsNOdjUtjvJcwDA8NBpZeTEFiRbCSDCq8S61jeOjl+Wkhyyy1zjPs6MRZW56NVL5bRk5onE8NEciDBomHyMoWTiZbbmtmdnYOKbsfFajIizWIERhUPao1oJitfNWtiP5YO9zA6B3wwcMC8kqwErFR7sMLbXo12CtGkZnVBgkXD5GcI9vxdGk4JuSjCMiWsvker3RytYkooksnKy2bkwmQQbPqbz7PpPyhOc55VkIk0C4X/I8Gp8dEPNFhVXZBg0TAswtLj0W79AlXwT43W5wmNrmGZioxRNv1vnNct9M7pXgDA0qqchKxTizg1PrF5dEqIUB4SLBomN12oYQmGeU1W8fM8P9IlRBGWCXGma7swktWwlDknbmkezaq5BQCAvxxqG/M8K8RdVpUr+xq1itbN4yglpC5IsGgYi8kgXci1WMfi9YcQFCNHZBw3MSPzhLQnWkNhXvJgiSTCAgA3X1wMAHj7dA/aXcMAgDM9XhzvGICBI8ESDdlSDYv2ji1Qyll1RC1Y9uzZgzVr1qCkpAQcx2H37t1T/syWLVtQXV0Nu92OOXPm4Nlnn71gm/7+fmzYsAHFxcWwWq2YPXs2Xn755WiXR5wH86XQomBhJxOL0QCbmbT3RLD8uxajbJ0DwwiEeBgNHAozJ/ZgGU15Thour8wBzwP/8+4ZAMBLHwjRluUzcsnhNgrYjYJWB6ySbYK6iLqyzOv1YuHChbjrrrtw6623Trn91q1bUVtbi6effhqXXXYZ6urqcPfdd8PpdGLNmjUAAL/fj+uvvx4FBQX4/e9/j9LSUpw5cwbZ2dmxfSpCIkfy4dDeCUXqEEozg+Oo5XAitDxPiBXcFjtsMBkjF63rV1SirqkXz+xtwu2XV2Dn24Jw+ejCkoStVYuwC7lLox1oNPpDXUQtWGpqalBTUxPx9jt37sQ999yD2267DQBQVVWFffv24dFHH5UEy/bt29Hb24u9e/fCbBa+AJWVldEujRgHVr+gxbZDquCPDC1PbG53CymdoixbVD+3+qJCzCvOwpE2N674wT8AACUOG9YtLk3IOrUKO7a0GmGhon51kfA4us/ng8029mRit9tRV1eHQEA4GP70pz9h+fLl2LBhAwoLCzF//nw88sgjCIVCiV6e5pHaDrUoWCi/HBFajrCwlv2CrMjSQQyT0YAffeJi6dixGA3Y/LGLYTUZE7JOrTISYdG2YKEuIXWQcLOB1atXY9u2bVi3bh0uueQSHDhwANu2bUMgEEB3dzeKi4tx+vRp/OMf/8Add9yBl19+GSdPnsSXvvQlBAIB3H///ePu1+fzwecbqctwu92J/igpCWs77NXgxYoq+CNjpEtIexeVTiZYMqOLsADARSUO/O2+q7H3VA8Wlmdjel56Alaobdh3T4vHFshJW3UkPMKyadMm1NTUYNmyZTCbzVi7di3Wr18vvLlBePtwOIyCggI89dRTuPTSS3Hbbbfh29/+Np588skJ97t582Y4HA7pUV5enuiPkpLkaDjCwk6S5HI7Oez3o0WvDBZhyY+w4PZ8CrKENBCJldhgU9J9wTCGA9qLiFPRrbpIuGCx2+3Yvn07BgcH0dTUhObmZlRWViIzMxP5+YJNdnFxMWbPng2jcSQcW11djfb2dvj9459ka2tr4XK5pEdLS0uiP0pKMhJh0d4dELOap7ufyXFqeGJzvIKFiI8MiwlsxI7W0kI8z1MNi8pIWi+o2WxGWVkZjEYjdu3ahZtvvlmKsFxxxRU4efIkwuGwtH1DQwOKi4thsYx/92y1WpGVlTXmQVxIjpgO0GKEhe5+IoPVsHh8QfiD4Sm3TyU6SbAoisHAabaOZdAfQiAk+jzRTZEqiFqweDwe1NfXo76+HgDQ2NiI+vp6NDc3A2Lk484775S2b2howK9//WucOHECdXV1uP3223H48GE88sgj0jZf/OIX0dvbi3vvvRcNDQ3485//jEceeQQbNmyQ51PqGHax0mKXELncRkaW3QxOo3fBUtEtCRbF0KpgYZ/HbORgN1MxthqIuuh2//79WLVqlfTvjRs3AgDWr1+PHTt2oK2tTRIvABAKhfDYY4/h+PHjMJvNWLVqFfbu3Tumbbm8vBx//etf8dWvfhUXX3wxSktLce+99+Ib3/hG/J9Q5+RoeNbHSA0LCZbJMBo4ZNnMcA0F0D/o10w0IhTm0eulCIvSONIsQM+g5lKOo9NB5POkDqIWLCtXrgTPTzxIb8eOHWP+XV1djYMHD0653+XLl+Odd96JdjnEFLAalkF/CMOBEGwaulMYqeCnotupcKYJgkVLXiw9Hh/CPGDgRuZmEclHqxEWuiFSH+RnrnEyrSaYxKo4rd0BUQ1L5GhxYjOrX8nNsMJooDtgpZBGP2jo2AKZxqkSEiwah+M46WKltTqWEdtsOqFMxUinkHaOgS5xPlZ+BkVXlIRd0N0ai7CwcQMkWNQDCRYdIHUKaehiFQiF4fULvg9UdDs1Tg3OlOpyx+ZyS8iLQ6PDNV2UclYdJFh0gBY7hUbnyzNtJFimwqHBeUIUYVEHWp0nRCkh9UGCRQdosVOIRQqybCaqX4gALc4TItM4dZCl0aJbmiOkPkiw6ADJ7VZTERbmckvh2khwpsmfFnz1aAe+/rv3sfdkt2z7jAYSLOogW6PzhFxDQYAiLKoi4cMPCeXR4jwhMo2LjmyZa1j+ebIbn39mPwDgT++fwx/+fQUWlDlk2XekdIspoTxKCSmKdotuKSWkNijCogPYRV1L84ToZBId2TLOE+J5Hg/9+aj0b38wjCf3nIp7v9HCokUs5UkoA6uP0mrRLZ1j1AMJFh2gRWMnMnWKDqeMPiwfnnPjaJsbFqMBv7l7GQDg/w63Jz3lyN6PBIuyZIvTwF1DgUlNRVMN1yC1NasNEiw6gKUDNCVYhiglFA2jIyzxXlRe+qANAHD9vEIsn5GLOYWZCIV57D2VvFqWcJiXOp5IsCgLu6CHwrxkNaAFKMKiPkiw6ACp7VBDHSIsX87u7ojJYREWfyiMwTgvKm+e6AJEwQIAV87KAwC8dSJ5gsU9HEAoTJN01YDNbIDFJFxKtNKFxvM83MNUdKs2SLDoAC2mhPooXBsVaRYjzEZxREMcx0GPx4cPz7kBAFfMzBP/mwsAqGvslWWtkcDSQZlWE6wm7czHSkU4jtPcOcbjC0qCmM4x6oEEiw7IHnUyCYe1kWPuoy6hqBg9oiGebrH3mvsBALMKMqR24ovLsgEAp7u9GBhOzgWLCRYnpYNUgXSO0UhhPxNeFqMBNjNdJtUC/SV0ADM+CvOAxx9UejmywNJbTvJhiRg5vFgOtbqAUSIFYltxscMGADjaNhD3OiOBCm7VhdYiLKNN4ziOjCnVAgkWHWAzG6W7BK3cAbEIizOdIiyRkpsuRETi6eY5LAqWBaVZY56/qETwYGGCJtGQYFEXWhUsDjtZlakJEiw6QYkTyh/rW/GZX76LbW+eln3fIzUsdMGKlDwxhcMcYqOF53l8cFYULKMiLABQXZwJADjZmaQIC3mwqAqtebG4qUNIlZB81AnZdgs63L6k2We/e7oH9/22HjwPvHmiG2VOO/5lfrEs+w6GwhgQK/idVMMSMbnixb0nxghLh9uHbo8PBg6YVzw2wjIjPwMAcKrTK8NKp6aPIiyqQrsRFjq/qAmKsOiEkTug5LQdbn3jFEbbfTzxj5Oy7Xv0SZFOKJGTlyEKFk9sERaW7plVkAm7ZWxnDhMsp7s9ca8zEpjoohomdcDsBbQyT8gl+TzR8aUmSLDohGTeAXV7fHhT9OR4/ksrYDEa8OE5Nz48J099Q9+oSc0mIx3CkcJm7nR7YhOtTLCMNzOoKj9d2ncy6qRYhCWXIiyqgNV6aGWeEEVY1Amd7XVCMieqvnG8C6EwjwWlDlxS4cTKOfkAgNeOdcqyf2ZORXc/0ZErCpZYIyzH2gT/lfPTQQCQbjWhKEvoFEpGlIXamtVFsiO4iWZ0lxChHkiw6IRkTlTd1yQYiK2YIRiKXTVbECxvnZTHCVXqEKL6lajIFVNCsUZYTnUJQmRWYca4r5fn2AEAZ/uGYl5jpFDRrbpIdg1Lr9ePlt7BhO3fNUQut2qEBItOkHNa71Qwx9PLp+cAAK4UHVEPnOnDcCD+WSN9FGGJiXwpJeSLep5QIBTGmR7hAsHqVc6nNFsQLOf6kyBYPCRY1EQyBcuL75/D5Q//Hdf86DX86f1zCXkPSgmpExIsOiFZJxT3cACnu4VOkUsqnACAytw05GVYEAjxOCKmFeLBRRGWmGARFl8wHPWQujM9gwiGeaRZjJJJ3PmUOgXB0ppgwTIcCEnrJ8GiDhxJcrp1Dwdw/58+RDDMI8wDtX/4ICHuyiRY1AkJFp3gEKMRic4xH28XfDhKHDapvoDjOMkZ9YOW/rjfgyIssZFmMSFN7O6Jto7lZKeQDpqRnzGh82eJGGFpTXBKiEUJjQYOWTZyZlADrNZjwBdM6PiPP3/Qhl6vH9Pz0jEtNw1efwgvHGyV/X3Ih0WdkGDRCSMRlsRa8x8VIyhzzyvMvFjsLGHGY/FAc4RiZ6SOJTrBwupXZhaMnw7CqJRQoiMsTHRnk226amDnF56H5JGUCP76YTsA4OOXluEzy6YBAP5yqF3296EIizohwaITRoaTJTbCwmbJMOdTxnzRuv1oe/xOqP00RyhmmD1/tIW3TLDMENuXx6PMmZwIC0s70MVEPVhNo8Z/JCjtPBwIYe/JHgDADfMKcW11ISDWxg3KOCON53kSLCqFBItOyE6SdfYpMXUwu3CsYGGdJae6PNLY9ljppwhLzOSNKryNBvZ3nSzCwlJCA75gQmul2DHsoL+/qkh0ndyH51zwh8LIy7BgZkEGKnPTUJpthz8Ulgr95cDrD0nnKBIs6oIEi05gX7xBfwj+YDhh78MKbqvyxl7YypxpsJoM8AfDONsXXzsi1bDEzojbbeQRFp7ncapL+LtO1CEEsUaGFcEmslOIRViy6WKiKhItWN47I9S/La5wguM4cByHpWInYr0MtXEMtn6L0SBFjQh1QH8NnZBpM4Ol+xN1QnEPB6Q798q8tDGvGQ0cqsSL3YmO+IzF+qlLKGZyY7Dn73D74PEFYTRwmJY7cUoIo+tYEpgWonC9Okm0YGGihHUfYpTr8iEZauMYTBBnUY2U6iDBohOMBg6ZVqGjIlEnlCYxupKXYUWm7cKLySwxnXCyKz7B0kc1LDHDUkJdUQgWVr8yLScNFtPkp4ySbKHlOZGFt1LRLf39VUWiBcvRdqGgf37pSEG/VMzf6oraW2giRgQxdaCpDRIsOoKd4F0Jam1uFAXL9POiKwxW/xBPhGXIH4JPTGlRDUv0FGQKgqLDHblgYS3NVZOkgxil2cLfPqGChYpuVUlWAgXLcCAk3RDNGVUfN6/YAQMHdA34ohLhk8HOj3R8qQ8SLDoi0XdAzJK9Imf8tIEUYemMvVOI3V2bDBwyrHQHFC1FDiHC0u4ajvhnImlpZrAIS0JrWCglpEoSeX451eVBmBduUvIzrdLzdosRFTmCSI431cyg40u9kGDREYm252cXqdLs8Z1QZ0qCxRNz+LbPO9IhRPnl6CkUBxR2DgxHbPAVSUszo0Dcf9eAPHe748EuKBRhUxeJFCwNHcJNzuyCzAu+9zMLMsdsEy8kWNRL1IJlz549WLNmDUpKSsBxHHbv3j3lz2zZsgXV1dWw2+2YM2cOnn322TGv79ixQ6r6Zg+bbfyLHhE77AuYaMHC2lvPZ1puOkwGDl5/CG1R3OGPhiY1xwdLCQVCvDRAcCpOdYodQhFEWPJjqJGJFmprVyeJHLDa2DXxMThbtExooAiL5ok6pu71erFw4ULcdddduPXWW6fcfuvWraitrcXTTz+Nyy67DHV1dbj77rvhdDqxZs0aabusrCwcP35c+jfdPctPolNC5/oFETKRYLGYDCjPSUNjtxdnegYn3G4yaFJzfFhMBuRlWNDt8aPdNSwV4U6ExxdEu1v4u87Im1qwFGSJgiWKGplooQuKOknk+aVRHLxZmXthfRzzfGJeQfFCx5d6iVqw1NTUoKamJuLtd+7ciXvuuQe33XYbAKCqqgr79u3Do48+OkawcByHoqKiaJdDRAG7I03ECYXneanQcjIhUua0o7Hbi5beQSyfkRv1+1CHSPwUZtnQ7fGjwz2M+aWOSbdld7a56ZaIjNpYfcGAL4ghfwh2cXaRnLAom8NOx4CaSKRgYQW3lXkXpiWniSLmTK9Xlvdi40uySLCojoTXsPh8vgvSO3a7HXV1dQgERg5sj8eDadOmoby8HGvXrsWHH3445X7dbveYBzE5iTyhuIeD8PiEL3rJBDUsAKQCuebe2Mzj+sk0LG6KxDoTFjmZjNPdI0MPIyHTapLMthJRxxIK83CLs2ooJaQuEnV+4XkeTT2sA3E8wSI81+H2YTgQ3RTy8aAIi3pJuGBZvXo1tm3bhgMHDoDneezfvx/btm1DIBBAd3c3AGDOnDnYvn07/vjHP+LXv/41wuEwVqxYgbNnz064382bN8PhcEiP8vLyRH+UlCdbvCPtT8A8IVa/4kwzI80yceAuXsHS5xU9WNLp7jpWCh1ia3MEdUTM4bYqgoJbiJFSFmXp8sRWpzQZA8MjF0O6oKiLRAmWvsGANFCRnT9G40wzSx5TLTGeV0ZDgkW9JFywbNq0CTU1NVi2bBnMZjPWrl2L9evXC29uEN5++fLluPPOO7Fo0SJcc801eP7555Gfn49f/OIXE+63trYWLpdLerS0tCT6o6Q8ifRJmKrglhG3YKGCy7iJJsLCOoQiFSwYVdjbmYA6FhZhS7cYYTZSk6OakIpuhwMRd6BFAnNNLsi0wma+MMXIcRwqWFqoJ37B4ibBoloS/o232+3Yvn07BgcH0dTUhObmZlRWViIzMxP5+fnj/ozZbMbixYtx8uTJCfdrtVqRlZU15kFMTiJTQiMtzZMLlnJRsMQ6T4gmNcfPiGCZWlCcjmCG0PkkslOoX2pppr+/2mA3RDwv1DDJRSS1cSN1LDJGWOimSHUk7RbFbDajrKwMRqMRu3btws033yxFWM4nFArh0KFDKC4uTtbydMGIYJHvZMJonaJDiMHuhLo9fnhjOKn1SoKFTiaxEmlKKBzm0dgducstg3UKJSLCwi4mVBCpPmxmI6zi6AY5W5tbI7gZYmaVzT3xFd7yPE8pIRUTdZeQx+MZE/lobGxEfX09cnJyUFFRgdraWrS2tkpeKw0NDairq8PSpUvR19eHxx9/HIcPH8Yzzzwj7eN73/seli1bhpkzZ6K/vx8/+tGPcObMGXzhC1+Q63MSo+4Y3EMB8Dwva+t4pBGWLJsZ2Wlm9A8G0NI3iLlF0UXG2JThqdpxiYmJNCV0zjWE4UAYZiOHcmfkLehShCUBRbeSDw9dTFSJw25G54APrqEA5KoqHEk3T1zML1eExesPISSms7KpC011RC1Y9u/fj1WrVkn/3rhxIwBg/fr12LFjB9ra2tDc3Cy9HgqF8Nhjj+H48eMwm81YtWoV9u7di8rKSmmbvr4+3H333Whvb4fT6cSll16KvXv3Yt68efF/QkKC3TH4Q2EMB8Kytpyyk0rxJCcVRkVOGvoHXWjuiV6w9IpFt7kkWGKGCRbXUGDS1mOWDpqWmw5TFPUiUoRlQP6iW3K5VTejBYtcRHIzJNXGxVnDwtZtMRqkbjdCPUQtWFauXDmprfqOHTvG/Lu6uhoHDx6cdJ8//vGP8eMf/zjapRBRkm4xwmjgEAoLYU85BUuneDfNLoaTUZ6Thg/OuqIuvB0OhKTW6dwMuvuJlSy7CekWI7z+EM65hiasTznNCm7HaSWdjJEuoQSkhGjwoapJRJ1cJAX9FVJt3BBCYR5GQ2zRY3Z8Zdlp9IcaIQmpIziOG7Hnl3lic494cYok8lHuFE4u0bYg9ojRFYvRILUxEtHDcRzKIvgbnO5mLc2R168g0V1CVBCpahIhWCIpui3JtsNs5OAPhSPqfpuIkfoVOr+oERIsOkM6ocg4T2jIH4LXLxg2RRL5iLW1eUQUWejuJ05Yt1ZL38RTlaMZejgaFmHp9vikegC5GDEOpAibGpFbsAwHQugW69YmSwkZDRyKHcLr8UwKp4JbdUOCRWckwoulWxQSFlNkkY/YBQurX6GLVbyU5wgn97OT/A1OiMPkIhl6OJpc0dQvzMtvUkgXFHUj9/mFDUm1m41T1i0Vi91v8QgWGq6qbkiw6IxEhGxZqiYvPbLIx+h8czQGU0wY5aRTwW28SGm5Cfxwejw+qS5pjjhcLlJMRoN0nLEiablwSbOkSLCoEbnPL6M7hKY6t7CUERvCGgtkTKluSLDojEQIlm7xwpaXGZmQKM62wWjg4AuGoyrMHC2MiPhgonEiZ9Bj7QOA2C6aHkO9EIuyyC9YaJaUmpH7/CJ5sDgvtOQ/H9b23OaKP8JCxpTqhASLzmDFZHIaO/V4xdqSCIWE2WiQTi7RWGmPrmEh4oNNvW3s9o7b9Xe0TRgmWh1l2znDmSDB0j9IxnFqRrLnlzvC4pi6+3CkhiWeCAsZU6oZEiw6IyERFk/03iixdAr1xPA+xPhU5KTBaOAw6A+N21VxtE2IsFQXxyZYckTB0iO3YCEfFlUj9/mFpSULIrBLYDdB8dSwjKSE6KZIjZBg0RmJESxiSigWwRLFTKFuZhpHKaG4sZgMmCamhZhB3GhYhGVucXT1K4xEpISGAyH4g2GALiiqhbWby3V+YW7JBRGkm1mEhVJC2oUEi85ISNGtZJcf+Zecdam09EZ+cumJQRgRE8MmMLP2ZUYgFMbJTuG5eXFGWOQULCwdZDRwSJfR9JCQD7nPL0yw5EcgWEpEwdI3KDg4xwKLsFBKSJ2QYNEZqomw5EQfYRmx5ae7HzmYWSBET46LBbaMU10e+ENhZFhNU86GmohEpISY2WE2uZCqltE1LNF0AE5ENIKFOTgjjigLtTWrGxIsOiMRPiyx+KMwp9XJfEBGw/M81bDIzLwSIXpy+Jx7zPPvt/RLrxtitDhnx0KvVz63W7LlVz/sbxPmAY8/vqnwPM+PCJYIvvMcx6E4m6WFoi+85XleiuI50+kYUyMkWHTGSIQlvpPJaEa6hKKJsIgnFvewVJcwGQO+IPyhsPg+dPcjBxeJguVYmxvB0Mjf4MCZPgDAkmnOmPfNvHJ6vfIJY7LlVz82sxEWk3BZiddN2z008p2PJMKCUeZxrTEU3g74ggiKUSGqYVEnJFh0Bgt1uocCkw6xjJRQmJdSNXmZkX/J8zOssJkN4PnIqvqZ10uG1QSbmeoX5GB6bjrSLEb4gmGcHFXHsl8ULJfGI1jSEhdhIQ8WdSNX2rnLI0RJsmyRf+dZHUtbDK3N/aK4tpkNdI5RKSRYdAY7mfhDYQwHpo5sTEXfoB9hHuC4kYtUJHAcF1WnEGu9LciidJBcGAwcFldkAwDePd0LiC2hp7u8MHBxCpaMkaJbOYQxyJY/ZZDLi6UzivoVRkl27J1CfdQhpHpIsOiMdItRGr0uRx0LK7h1pllgMkZ3OEmFtxF0CnWIgqUoAj8GInJWzMgDALx9qgcA8PrxLgDA4gpnXIWHLG0XCPEY8MmTfpSKbumCompki7DEIFiKmRdLDDUsfVRwq3pIsOgMjuNk7RSSCmFjqCspd4qtzZFEWFzCyYsEi7wsn5ELAPjnyW4M+UP4y+E2AMDK2flx7ddmNiJN7Njo9cjTKdRPRbcpgfyCJfLvfEkcE5v7qaVZ9ZBg0SFyCpbuOOzyy6OY2swiLIURWHQTkbOoLBvlOXYM+IL4yasNePNENzgOWLe4NO59y93aTCmh1EBuwRKJaRyDRVja+oeiTkVSSkj9kGDRIXK2NndLpnHR15ZE09rc7qKUUCIwGDjcflkFAOAXb5wGAFw7t0ASk/Egt9uti2z5UwIlU0IswuL1h+Aeji4VKUXw6PhSLSRYdIi8KaHY3Wclt9u+qcO3rOi2kIpuZefzV07HonKh+LYoy4bvrZ0vy35HBiDK0ynUP0iCJRWQ64aoMwoPFobdYpRSOtEW3vbT4EPVE/3ceCLlSUQNSzS2/Ax2F9/r9cPrCyLdOvHhKKWEKMIiOzazEbv+bRkaOgYwqyATdpls70fs+eXxYqGUUGqgZIQF4kyhvsEA2vqHMTeKaeMjtvyUElIrFGHRIQ67IAzkrWGJPvKRZTNLJ7fJCm9DYV662yqiGpaEYDMbcXFZtmxiBWNSQnJFWARx7LDTBUXNyOfDwiY1RytYWKdQdBEW6hJSPyRYdIhcPgmQYYJyJEMQezw+hMI8DFx04WFCWZjbrRxFt6EwL9UkUEpI3chxfgmEwlLtU7TfeVZ42x5la3MsI0aI5EKCRYfI2iUkRj7yogzbMqblCBODz/R4J9yG1a/kZVij9nohlEPOotuB4ZFjlVJC6kaO8wsTD0YDF3WKplhqbY5SsIiRwLwoRowQyYXO/jpELsHC83zcX/LpeYJgOd09iWBhHUKUDkopcmQULKzgNt1ihJlEq6qR4/zSOcBuUixRD+BkKaF2d+QpIZ7naRp8CkDffB0il2AZ9Icke/9Yv+RV+YJgaeyaWLBQwW1qwuz5e2QwjuuXWprpYqJ2pJTQcDDmsQwjHizRf+fZjU0084Tcw0EEQsJac2i4qmohwaJD5Go7ZAW3drNx0g6fyRiJsHgm3KadbPlTkpEBiPELFnasZlE6SPUwwRIK8/DEOJYh1g4hjB6A6BqOWDAxe4ZMGq6qakiw6BC5IizdMhSpVeVlAAA63D54Jzi5tYo+LaWilT+RGrAIy1AghCF/KK59sQ4hmtSsfmxmAyxi2i7Wc0xXDB4sDBZhGQqEIn7/HkoHpQQkWHSIfIIldtM4aS1pZqk4s3GCOhZm3V8hg/sqkTwyrSaYjUL9Qe9gfFEWcrlNHTiOizuKG8ukZobNbJTSOm0Rdgr1xGHPQCQPEiw6hAkWfzCM4UDsd77xmMaNhtWxTFR42yy2PJNgSS04jpMuHH1xpoVcNPgwpYjX60mqYYnR2ZqljyN1u+2OY4grkTxIsOiQDKsJRrHyPr7WQ/GuJM42QKmOpevCOpZBf1CK5JQ7SbCkGk6Z6lhY0S3NeUkN4vViYaZxsfoulbAhiBFHWCgllAqQYNEhHMchyybcAbF20ViQUkKZ8UZYhDqW8VJCzFAuy2aii1UKIldrcz9FWFKKeNPO8RTdIoZOIWbPEO/NF5FYSLDoFDnqWEZcbuWJsJzsvDDCwkTMtNz0uN6DUAanTIKFHac05yU1iOf8wvO85MMSq2ApHtUpFAkUYUkNSLDoFFkES5wut4y5RZkAgBOdHgRD4TGvnRLTRDMLMuJ6D0IZWGtzX9xFt2yOEEVYUoF4zi8eX1Dyd4pdsERbw0JFt6lA1IJlz549WLNmDUpKSsBxHHbv3j3lz2zZsgXV1dWw2+2YM2cOnn322Qm33bVrFziOw7p166JdGhEFcnixsFbAvDgL1cqdaUi3GOEPhi8ovGVRFxIsqYncKSFqa04N4hEsLB2UYTUhzRKbvxOLsEQ6T0iucxmRWKIWLF6vFwsXLsSWLVsi2n7r1q2ora3FAw88gA8//BAPPvggNmzYgBdffPGCbZuamvD1r38dV111VbTLIqJEnnkf8tyVGAwc5ohRlqNt7jGvsQjLjHwSLKmI1CUUZ4SFim5Ti5EbouiN4+KtX8F5E5sjMY+jtubUIGr5WlNTg5qamoi337lzJ+655x7cdtttAICqqirs27cPjz76KNasWSNtFwqFcMcdd+DBBx/Em2++if7+/miXRkRBvIIlEAqjT7zrjbetGQDmlWThveZ+HG51Ye2iUkB0yqQIS2ojRw0Lz/NSWzNZ86cGcUVY4uwQwqii2+FAGK6hwKTHTXDUuYxqWNRNwmtYfD4fbLaxlup2ux11dXUIBEYO5u9973soKCjA5z//+Yj363a7xzyIyIm37ZD5ahg4eS4ii8qdAICDzSNC9XSXB4P+ENIsRqkwl0gtpBoWb+yRvKFACH6xtolSQqlBPIKl0x1/hGW0edxUU5uZqSHHUVG32km4YFm9ejW2bduGAwcOgOd57N+/H9u2bUMgEEB3dzcA4K233sIvf/lLPP300xHvd/PmzXA4HNKjvLw8gZ9Ce8QbYWFGSznpVsnTJR4WV2QDAA61uuAPChen+hZBvMwvdcjyHkTycaYLx1k8TrfsGDUbOaRZaM5LKhDPDZEUYYmzmD/Sqc0sBZWbbqHzjMpJuGDZtGkTampqsGzZMpjNZqxduxbr168X3txgwMDAAD7zmc/g6aefRl5eXsT7ra2thcvlkh4tLS0J/BTaI37Bwmz55bkjqcpLR3aaGb5gGIdaBaHywVkXAGBhmUOW9yCSz2in21gn9454sFjAcXRBSQVYrVE8RbfxCxah8LZ1iggLK8xlaSRCvSRcsNjtdmzfvh2Dg4NoampCc3MzKisrkZmZifz8fJw6dQpNTU1Ys2YNTCYTTCYTnn32WfzpT3+CyWTCqVOnxt2v1WpFVlbWmAcROfEKFsloSSbBwnEcrpgpCNbXjnUBAN48Ifz30mk5srwHkXxYiD0Y5jEQ4+TeEcESW8cIkXyy7cLf3TUUiFqoyiVYysRhqWf7Bifdjnm1FGXRcFW1kzQfFrPZjLKyMhiNRuzatQs333wzDAYD5s6di0OHDqG+vl56fPSjH8WqVatQX19PqZ4EEXeEZYDNEZKvqv7auQUAgFeOdOB0lwdNPYMwGzlcOSvyyBuhLmxmo5TG6fXElhZiHixUcJs6sCGVoTAP93B0QjWewYejkQRL7+QpoQ43i7BQh5DaifqWxePx4OTJk9K/GxsbUV9fj5ycHFRUVKC2thatra2S10pDQwPq6uqwdOlS9PX14fHHH8fhw4fxzDPPAABsNhvmz58/5j2ys4V6hvOfJ+QjXh+W7gRYWX9kbgGsJgOOdwzgC8/sBwAsq8pFhpXurFOZnHQLBv1D6B30oxLRF0+TB0vqYTMbkW4xwusPoc/rj8rwTxp8GKdgKReHpUYaYWEpJEK9RB1h2b9/PxYvXozFixcDADZu3IjFixfju9/9LgCgra0Nzc3N0vahUAiPPfYYFi5ciOuvvx7Dw8PYu3cvKisr5fwcRJTEnRJik5rjnCM0muw0Cz65RIioMQO5f7u6Srb9E8oQ78Rm8mBJTaSW9igKrkNhHr1eeSMsLX2TR1ikGpYsqmFRO1Hfuq5cuXLSnOSOHTvG/Lu6uhoHDx6M6j3O3wchP+zk7w+GMRwIwWaOrvtCKrqVeVjY126YjcPnXKhv6cf65ZW4cialg1KdeCc2j0RYKCWUSuSkW3C2byiqVGCP14cwL9glxBu9ZRGWXq8fXl8Q6RNEatvdVHSbKlCsXadkWk0wGjiEwjxcQ4GoBUuihoVlp1nwh39fgYHhIN1Ra4R43W5ZFDCbjoeUQhKqUfzdWTpIDruELJsZDrsZrqEAzvYNSW7a50NdQqkDDT/UKRzHIcsm6NVY0kIjbc3yF6oZDByJFQ0xEmGJLf1Igw9Tk1hSgZ0y1a8wpLRQ7/h1LAPDAXjE7jVKCakfEiw6JtY6Fp7naRw7ETE5onlczDUsgxRhSUVyYqhhkaulmVHunLzwlnUIZdpME6aMCPVAgkXHOMQ7X3ZBiJQBX1CySk9EhIXQFrEUX45mxIeFBEsqEUuERW7BMlXh7UiHEEVXUgESLDrGmRbbnW/3qPHv0da+EPpjZJ5QvDUsFM1LJWJJBcoeYZmitXmkfoVamlMBEiw6hp1Qoi2G7PFSOoiInHgnNveLxyf5sKQWUiowhpSQXDUs5TmCEDnTM4VgyaJIcSpAgkXHjAiW6FJCLMJC6SAiEnLjSAkFQmF4/SGAalhSDmcMkTW5Iywz8jMA0dcpFL7QjqO1X0gVkWlcakCCRcfEnBJiEZZ0irAQU8MiLK6hAIJi7VOksHQQxwGZNhIsqQSrYemJ4vzSMSBEPAoy5akpKXOmwWoywB8Mj9spxCIvlXlpsrwfkVhIsOgYZ4z+GD2spVmmuyBC27BUDs9H35HGCm6ZbxCROkQrVHmeR6dbOLcUypSiMRo4KcpystNzwetnegRH7Yqc6EdGEMmHBIuOccbYJTTicksRFmJqTEaD1OETrTimwYepy+iao/4IhOqAL4ihgJD+kyvCAgAzCwTBcuI8wTIcCKFNbGuelksRllSABIuOYSmhaGsLRjxYKMJCRIbkyRGleRx5sKQuY4RqBGkhFl3JtJlgt8jXfThLEiwDY54/2zcInhe6HSm9nRqQYNExLGTbH6NgoaJbIlIkcRxlvRR5sKQ2OVF0iHW6Wf2KvOcVFmE5dV6E5VSXkA6qzEsDx1G6MRUgwaJjRqeEJhtoeT4sJURtzUSkxDpPqJ88WFIaqbA/gr/7iC2/vCZuswpHalhGn+ca2oWIy+zC8WcMEeqDBIuOYWH2YJjHgDhPIxISOUeI0CaxTmx2kQdLSsPSxl0RTGxmNvlyFdwypuWmw2Tg4PWHcE70XQGAYx2CYJlDgiVlIMGiY2xmI9LEXHGkrc2+YAjuYUHc5FGEhYiQnIzY3G5ZVxGlhFIT5qfCvJsmQ4qwyDyE0Gw0SGmhQ2dd0vMswjLRFGdCfZBg0TnRmsexO2STgUMW+WIQEZITY4RlJCVEx1oqki9GWDojECwdCaphAYDFFU4AwMHmPgCA1xfE6W6hhqW6OEv29yMSAwkWnZMdRY4ZYzqELDCQLwYRIbEOQGRFt1kUYUlJCsT0TpeCERYAuKQiGwBw4IwgWN5r7kMozKPMaUdhAt6PSAwkWHROtBNVu1jBbTrVrxCRE+sARCakqe00NWERlq6B4Sm3ZV1ChQmIsFxWmQMAqG/ph2sogH1NfWOeJ1IDEiw6JzvKlJDU0kwut0QUxBphYSkkJwmWlIRFS6aKsPA8n9AIS2VeOmYWZCAY5vH68U68cqQDALB0OgmWVMKk9AIIZWFth5F6sZDLLRELI5G86IzjWEQmh9qaUxJWdNvl8YHn+Qn9Tjy+IAb9zOU2MTdDqy8qxMlOD+7dVQ8AsBgN+Jf5RQl5LyIxUIRF50TbbipNU6Vx7EQUMMHh8QXhC4Yi+pnhQEia1EwRltSEdRIGQvykI0A6RJfbDKsJ6dbE3Ed/ZlklbOaRS96/zC8if58UgwSLzonG2AmjCuPyyYOFiIJM28jwwkhnV7FjUuhIo2BwKmI1GaXC/sk6hc71DwEASrITVwBb5LBh860LkJNuwbziLHxv7UUJey8iMdBZQOcwY6fuCIydMKp4Lp9qWIgoMBg4ONPM6Pb40ev1R9SZMbp+hazTU5eCTCv6BwPoGvBN6HkyIljsCV3LLYvLcMvisknTU4R6oQiLzsmTBMvUbYcYnRIiwUJESbQdab1Uv6IJRupYJu4USpZgYZBYSU1IsOic/EzhYhCJEyUSOO+D0D5SvVSE6UdJsFD9SkrDzhVsGvN4tPYLYqY0SYKFSE1IsOgcFmFxD09dDDkcCGFAtOWnCAsRLdFM7sXoDiESLCmNFGGJoIaFBAsxGSRYdI7DbobZKIRHe6aoY2EnHIvJQEWQRNQ4oxQsvWJxrjOdXG5TGdamPGnRrSu5KSEiNSHBonM4jpNca6eqY2EutwWZVsoBE1ETrdttr9c35ueI1CRfEizj17CEwzzaxJRQIruEiNSHBAuBPFbHMoVgYTloSgcRscAiLD0Rp4SECAulhFIb1hHWMUENS7fHB38oDAMHmutDTAoJFmKkU2hgipSQhzxYiNhhJmJTpR4ZZMuvDVhdSmv/EHiev+D1VrF+pTDLBrORLknExNDRQUiCpWuqlJA064MECxE9+REeZwxmHEcRltSmyGEDxwH+YHhcv6dz1CFERAgJFiJiLxbJgyWDwrZE9ETSLTKaHuoS0gRmowGFYmsz6wYaTbI9WIjUJWrBsmfPHqxZswYlJSXgOA67d++e8me2bNmC6upq2O12zJkzB88+++yY159//nksWbIE2dnZSE9Px6JFi7Bz585ol0bECAvVT+V2Sy63RDyw48Y1FJiyhZ7neWpr1hClTkGMjCdYzvYNAiRYiAiIujfV6/Vi4cKFuOuuu3DrrbdOuf3WrVtRW1uLp59+Gpdddhnq6upw9913w+l0Ys2aNQCAnJwcfPvb38bcuXNhsVjw0ksv4XOf+xwKCgqwevXq2D4ZETHsQjKVeRy53BLxwFroAyEePR7/pBeoAV8QwbBQ7+CkLqGUpyTbjgNn+qR6ldE09giCpTI3TYGVEalE1IKlpqYGNTU1EW+/c+dO3HPPPbjtttsAAFVVVdi3bx8effRRSbCsXLlyzM/ce++9eOaZZ/DWW2+RYEkCkdawtLuFCEsh1bAQMcBxHPIyrGhzDaNrwDepYOkVo31pFiNsZmMSV0kkgnIxwnJGFCejaer2AgAq89KTvi4itUh4DYvP54PNNrbmwW63o66uDoHAhVNbeZ7Hq6++iuPHj+Pqq6+edL9ut3vMg4iNSGpY/MGwZPxEoVsiViKtY5E60iiapwmYGGnq8Y553h8MSymh6SRYiClIuGBZvXo1tm3bhgMHDoDneezfvx/btm1DIBBAd3e3tJ3L5UJGRgYsFgtuuukmPPHEE7j++usn3O/mzZvhcDikR3l5eaI/imZhNSz9gwEEQuFxt+lwD4PnBZfbXKopIGIk0k4h5vlTQIJFE1TmCmKksXusYGnpG0SYFyJp9LcmpiLhgmXTpk2oqanBsmXLYDabsXbtWqxfv154c8PI22dmZqK+vh779u3Dww8/jI0bN+L111+fcL+1tbVwuVzSo6WlJdEfRbM40ywwGQTn2onufKVKfoeNXG6JmIk0wsJcUWnIpjaozBPqU871D40puD7Z6RFez02n8woxJQkXLHa7Hdu3b8fg4CCamprQ3NyMyspKZGZmIj8/f2QhBgNmzpyJRYsW4Wtf+xo+/vGPY/PmzRPu12q1Iisra8yDiA2DgZMcJlmdyvnQrA9CDiJOCVGBt6bIz7Aiw2pCmAeaR9WxHG8fAADMLc5UcHVEqpA0Hxaz2YyysjIYjUbs2rULN99885gIy/mEw2H4fJH5NRDxU+QQ7bNdEwgW0dyp2EGChYidSD1/OkmwaAqO4zCzIAMAcEwUKRgtWIpIsBBTE3WXkMfjwcmTJ6V/NzY2or6+Hjk5OaioqEBtbS1aW1slr5WGhgbU1dVh6dKl6Ovrw+OPP47Dhw/jmWeekfaxefNmLFmyBDNmzIDP58PLL7+MnTt3YuvWrXJ9TmIKisQIS9uEgoWNf6cQPRE7FGHRL/NKslDf0o8jbW6sWVgCADjaLjRLzC2iCDkxNVELlv3792PVqlXSvzdu3AgAWL9+PXbs2IG2tjY0NzdLr4dCITz22GM4fvw4zGYzVq1ahb1796KyslLaxuv14ktf+hLOnj0Lu92OuXPn4te//rXUCk0kHhZhmTAlRG6UhAxIgiXCCAsVYmqHecWCKDnaJogU93BAKsKtLibBQkxN1IJl5cqV4w6wYuzYsWPMv6urq3Hw4MFJ9/nQQw/hoYceinYphIwUO6aKsIgpIRIsRBxIXUJTRljIVVlrzCsRRMmhsy7wPI/3zvSB54FpuWn0dyYigmYJEcCoCEvbOE6UGFV0SykhIh7yxAvToD8Ejy847jbBUFiaI0RdQtrhopIs2M1G9Hj9ON4xgP1NfQCAyypzlF4akSKQYCGAUZNSz/ZdKFjcwwEMDAsXFyq6JeIh3WJEhlUI7LZPEM3r8frB84DRwNEcIQ1hNRmxtEoQJ282dOOVIx0AgKXTSbAQkUGChQAAlOcIPgkdA8MXDKZrE9NBDrsZ6daos4gEIcFxHEqyJ57ci1Hpotx0C4wG8ubQEitnC1YWD798FMc7BmAxGXDDRUVKL4tIEUiwEIB4cbCbjeB5oPW8KAuzzi6l+hVCBljh9kSCRTKNo5lVmuNjl5YhyzZy03Pj/CI47GZF10SkDiRYCEC88y3PES4kLecJFlbJPz2fZn0Q8TOlYBFt+VmBLqEdMm1mPPqxi5GXYUF1cRYe+OhFSi+JSCEovk9IlDvT0NDhQUvv2Imqp0XBUkXDyQgZYJG61v7xa1i6pJZmKrjVIjULivEv84U0ENnxE9FAgoWQqMgV6liazhtQ1tgljn/PJcFCxA+rYWlzjR9hYV5AhZQS0iwkVIhYoJQQITGrQLDHPtnlGfM8GwlPKSFCDkock6eEWsmkkCCIcSDBQkiwWR8nOkYEi2soIJnJzcjPUGxthHYodYqCxTWMcPhCE0pW9M22IwiCAAkWYjSzRMHS2j8Er2jqxWy0y5x2quYnZKEwywYDB/iDIwZxDJ7naQwEQRDjQoKFkHCmW5CXIRh1NXQIU1SPnBMEC836IOTCbDSgMGt8LxbXUABev+ADRG30BEGMhgQLMYYFpQ4AwMHmfgDA4XMuYNTgMoKQg4lam5nTcl6GBTazUZG1EQShTkiwEGO4pMIJAHivuQ88z+Pd070AgMUV2QqvjNASJVJr81jBwlrqS51piqyLIAj1QoKFGMMl0wTBsq+pF2d6BtHaPwSzkcPlNO+DkJFysaCWdaAxGllHWi4JFoIgxkKChRjDpdOcyLSa0OH24aE/HwUALC53Is1Clj2EfLCOs1Od43v+TM+jjjSCIMZCgoUYg81sxGrRhfLvR4Vpqh+7tFThVRFaY4bYkXa6e3zPn8o8irAQBDEWEizEBdxzdRXSLULB47TcNKxdRIKFkJcq0YSww+3DwHBAer5RGgNBERaCIMZCcX7iAmYVZuK39yzHP09245NLyqlbg5CdLJsZ+ZlWdA34cKLTg0sqnOga8KHb4wfHjQgagiAIBkVYiHGZX+rAPdfMgDPdovRSCI1yUYnQKn+4VWidPyKaFE7PS0e6le6lCIIYCwkWgiAU4WLR8+fQWUGwfCh6/lxU4lB0XQRBqBMSLARBKMJ8UbC8f1YwKfyghQkWMikkCOJCSLAQBKEIl0xzguOAhg4PzvYN4p+nugEAy6pylV4aQRAqhAQLQRCKkJdhxaJywUH5R389joHhIJxpZmk8BEEQxGhIsBAEoRg3zBM8f/5Yfw4AcG11IYwGTuFVEQShRkiwEAShGJ9ZPg2FWVYAgNnI4T8+MlPpJREEoVKod5AgCMXIsJqw43OX4+9HOnD59BxMyyX/FYIgxocEC0EQilJdnIXqYuoMIghiciglRBAEQRCE6iHBQhAEQRCE6iHBQhAEQRCE6iHBQhAEQRCE6iHBQhAEQRCE6iHBQhAEQRCE6olasOzZswdr1qxBSUkJOI7D7t27p/yZLVu2oLq6Gna7HXPmzMGzzz475vWnn34aV111FZxOJ5xOJ6677jrU1dVFuzSCIAiCIDRK1ILF6/Vi4cKF2LJlS0Tbb926FbW1tXjggQfw4Ycf4sEHH8SGDRvw4osvStu8/vrr+NSnPoXXXnsNb7/9NsrLy3HDDTegtbU12uURBEEQBKFBOJ7n+Zh/mOPwwgsvYN26dRNus2LFClxxxRX40Y9+JD33ta99De+++y7eeuutcX8mFArB6XTiZz/7Ge68886I1uJ2u+FwOOByuZCVRSZUBEEQBJEKRHr9TrjTrc/ng81mG/Oc3W5HXV0dAoEAzGbzBT8zODiIQCCAnJycSffr8/mkf7vdbplXThAEQRCEWkh40e3q1auxbds2HDhwADzPY//+/di2bRsCgQC6u7vH/ZlvfOMbKCkpwXXXXTfhfjdv3gyHwyE9ysvLE/gpCIIgCIJQkoQLlk2bNqGmpgbLli2D2WzG2rVrsX79euHNDRe+/Q9+8APs2rULL7zwwgWRmdHU1tbC5XJJj5aWloR+DoIgCIIglCPhgsVut2P79u0YHBxEU1MTmpubUVlZiczMTOTn54/Z9v/9v/+HH/zgB/jb3/6Giy++eNL9Wq1WZGVljXkQBEEQBKFNkjat2Ww2o6ysDACwa9cu3HzzzWMiLD/84Q/x8MMP469//SuWLFkS9f5Z7TDVshAEQRBE6sCu21P1AEUtWDweD06ePCn9u7GxEfX19cjJyUFFRQVqa2vR2toqea00NDSgrq4OS5cuRV9fHx5//HEcPnwYzzzzjLSPRx99FN/97nfx3HPPobKyEu3t7QCAjIwMZGRkRLSugYEBAKBaFoIgCIJIQQYGBuBwOCZ8Peq25tdffx2rVq264Pn169djx44d+OxnP4umpia8/vrrAICjR4/i05/+NI4fPw6z2YxVq1bh0UcfxZw5c6SfraysxJkzZy7Y5/33348HHnggonWFw2GcO3cOmZmZ4Dgumo80KW63G+Xl5WhpaaG0UwKh33PyoN91cqDfc3Kg33NySOTvmed5DAwMoKSkZNzaVkZcPix6gPxdkgP9npMH/a6TA/2ekwP9npODGn7PNEuIIAiCIAjVQ4KFIAiCIAjVQ4JlCqxWK+6//35YrVall6Jp6PecPOh3nRzo95wc6PecHNTwe6YaFoIgCIIgVA9FWAiCIAiCUD0kWAiCIAiCUD0kWAiCIAiCUD0kWAiCIAiCUD0kWKZgy5YtqKyshM1mw9KlS1FXV6f0kjTF5s2bcdlllyEzMxMFBQVYt24djh8/rvSyNM8PfvADcByH++67T+mlaI7W1lb867/+K3Jzc2G327FgwQLs379f6WVpjlAohE2bNmH69Omw2+2YMWMGvv/97085j4aYnD179mDNmjUoKSkBx3HYvXv3mNd5nsd3v/tdFBcXw26347rrrsOJEyeSsjYSLJPw29/+Fhs3bsT999+P9957DwsXLsTq1avR2dmp9NI0wxtvvIENGzbgnXfewSuvvIJAIIAbbrgBXq9X6aVpln379uEXv/jFlBPRiejp6+vDFVdcAbPZjL/85S84cuQIHnvsMTidTqWXpjkeffRRbN26FT/72c9w9OhRPProo/jhD3+IJ554QumlpTRerxcLFy7Eli1bxn39hz/8IX7605/iySefxLvvvov09HSsXr0aw8PDiV8cT0zI5Zdfzm/YsEH6dygU4ktKSvjNmzcrui4t09nZyQPg33jjDaWXokkGBgb4WbNm8a+88gp/zTXX8Pfee6/SS9IU3/jGN/grr7xS6WXogptuuom/6667xjx366238nfccYdia9IaAPgXXnhB+nc4HOaLior4H/3oR9Jz/f39vNVq5X/zm98kfD0UYZkAv9+PAwcO4LrrrpOeMxgMuO666/D2228rujYt43K5AAA5OTlKL0WTbNiwATfddNOY45qQjz/96U9YsmQJPvGJT6CgoACLFy/G008/rfSyNMmKFSvw6quvoqGhAQDw/vvv46233kJNTY3SS9MsjY2NaG9vH3P+cDgcWLp0aVKui6aEv0OK0t3djVAohMLCwjHPFxYW4tixY4qtS8uEw2Hcd999uOKKKzB//nyll6M5du3ahffeew/79u1Teima5fTp09i6dSs2btyIb33rW9i3bx++8pWvwGKxYP369UovT1N885vfhNvtxty5c2E0GhEKhfDwww/jjjvuUHppmqW9vR0Qr4OjKSwslF5LJCRYCNWwYcMGHD58GG+99ZbSS9EcLS0tuPfee/HKK6/AZrMpvRzNEg6HsWTJEjzyyCMAgMWLF+Pw4cN48sknSbDIzP/+7//if/7nf/Dcc8/hoosuQn19Pe677z6UlJTQ71qjUEpoAvLy8mA0GtHR0THm+Y6ODhQVFSm2Lq3y5S9/GS+99BJee+01lJWVKb0czXHgwAF0dnbikksugclkgslkwhtvvIGf/vSnMJlMCIVCSi9RExQXF2PevHljnquurkZzc7Nia9Iq//mf/4lvfvObuP3227FgwQJ85jOfwVe/+lVs3rxZ6aVpFnbtU+q6SIJlAiwWCy699FK8+uqr0nPhcBivvvoqli9frujatATP8/jyl7+MF154Af/4xz8wffp0pZekSa699locOnQI9fX10mPJkiW44447UF9fD6PRqPQSNcEVV1xxQVt+Q0MDpk2bptiatMrg4CAMhrGXMKPRiHA4rNiatM706dNRVFQ05rrodrvx7rvvJuW6SCmhSdi4cSPWr1+PJUuW4PLLL8dPfvITeL1efO5zn1N6aZphw4YNeO655/DHP/4RmZmZUh7U4XDAbrcrvTzNkJmZeUFdUHp6OnJzc6leSEa++tWvYsWKFXjkkUfwyU9+EnV1dXjqqafw1FNPKb00zbFmzRo8/PDDqKiowEUXXYSDBw/i8ccfx1133aX00lIaj8eDkydPSv9ubGxEfX09cnJyUFFRgfvuuw8PPfQQZs2ahenTp2PTpk0oKSnBunXrEr+4hPchpThPPPEEX1FRwVssFv7yyy/n33nnHaWXpCkAjPv41a9+pfTSNA+1NSeGF198kZ8/fz5vtVr5uXPn8k899ZTSS9Ikbrebv/fee/mKigreZrPxVVVV/Le//W3e5/MpvbSU5rXXXhv3nLx+/XqeF1ubN23axBcWFvJWq5W/9tpr+ePHjydlbRxPtoAEQRAEQagcqmEhCIIgCEL1kGAhCIIgCEL1kGAhCIIgCEL1kGAhCIIgCEL1kGAhCIIgCEL1kGAhCIIgCEL1kGAhCIIgCEL1kGAhCIIgCEL1kGAhCIIgCEL1kGAhCIIgCEL1kGAhCIIgCEL1kGAhCIIgCEL1/H+VVOoGeK/f2wAAAABJRU5ErkJggg==" }, "metadata": {}, "output_type": "display_data" } ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "y_component = mp.frobenius(qsys.states, Y()())\n", - "plt.plot(tlist, y_component)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note: the double parentheses indicate that we are calling the `Y` function and then calling it's matrix representation." - ] + "execution_count": 22 }, { "cell_type": "markdown", @@ -115,15 +116,21 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:11:13.087738Z", + "start_time": "2025-01-01T15:11:13.082657Z" + } + }, "source": [ "import torch\n", "\n", "mp.set_device('cuda') # Default CUDA device\n", - "mp.set_device('cuda:0') # First available GPU" - ] + "mp.set_device('cuda:0') # First available GPU\n", + "mp.set_device('cpu') # Return to CPU" + ], + "outputs": [], + "execution_count": 23 }, { "cell_type": "markdown", @@ -134,12 +141,68 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:12:08.175739Z", + "start_time": "2025-01-01T15:12:08.173408Z" + } + }, "source": [ "H = torch.sin*X() + 4*Y()" + ], + "outputs": [], + "execution_count": 26 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multiple qubits\n", + "\n", + "MagPy provides support for multi-qubit systems. This is done by specifying the position of the qubit in each call of `X`, `Y`, or `Z`. The default value is 1, so this parameter can be omitted in single-qubit systems, as above." ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2025-01-01T15:12:15.180361Z", + "start_time": "2025-01-01T15:12:14.962068Z" + } + }, + "source": [ + "H = np.sin*X(1) + Y(2)\n", + "rho0 = Y(1) + X(2)\n", + "tlist = mp.timegrid(0, 10, 0.5**6)\n", + "\n", + "states = mp.evolve(H, rho0, tlist)\n", + "\n", + "y_component = mp.frobenius(states, Y(1)(2)) # Y in first position of two-qubit system.\n", + "plt.plot(tlist, y_component)" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGdCAYAAAAvwBgXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAABSt0lEQVR4nO3dd3xV9f0/8Ne5Ozd7D3IzgQAyZQlUBcE9am3VtlZx1C5sVWwrtFXrrypqbb/WanF8tfq1WrXWUW1FKSi42ENWAoGEhITscW/Wvbn3nt8f954bAgEy7rln3Nfz8biPNhBy3obwua/PFkRRFEFERESkAIPSBRAREVH0YhAhIiIixTCIEBERkWIYRIiIiEgxDCJERESkGAYRIiIiUgyDCBERESmGQYSIiIgUY1K6gFPx+/2ora1FfHw8BEFQuhwiIiIaBFEU4XK5kJOTA4Ph1GMeqg4itbW1cDgcSpdBREREw1BdXY3c3NxTfo6qg0h8fDwQ/A9JSEhQuhwiIiIaBKfTCYfDEXofPxVVBxFpOiYhIYFBhIiISGMGs6yCi1WJiIhIMQwiREREpBgGESIiIlIMgwgREREphkGEiIiIFMMgQkRERIphECEiIiLFMIgQERGRYhhEiIiISDERCyIPP/wwBEHAHXfcEalHEhERkcpFJIhs3rwZzzzzDCZPnhyJxxEREZFGyB5EOjo6cN111+G5555DcnKy3I8jIiIiDZH90rslS5bg0ksvxaJFi/DAAw+c8nPdbjfcbnfoY6fTKUtN5Q0dePnLShgNBhgNgMEgwCgIMBoEGAQBJoMAg0GA1WRAst2ClFgLshJtKEyLhc1slKUmItKG9q5eVLd2ocHVg0aXG64eL9xef/Dlg88nDvjnjr/7SxACbYzNbITNbESM2YiUWAtykmzISYpBaqxlUBeGEWmdrEHktddew7Zt27B58+ZBff6KFStw//33y1kSAKCmrRsvfXl4yH/OIAD5qbGYkpuIs8ekY35JOlLjrLLUSETqUNPWjY9LG7B+fyN217Sjtr0nIs9NjbVgUm4izipKxfkTMlGcHheR5xJFmiCK4sDxfYSqq6sxY8YMrF69OrQ2ZP78+Zg6dSoef/zxAf/MQCMiDocD7e3tSEhICFttFU2d+OfWI/CJInz+vpdf7P+/Pb1+tHZ50NLpQXVLF5w93n5fx2wUcMGELNwwJx+zi1LDVh8RKcvvF7F6Xz3+tuEwPj3QdMLvp8dbkZlgRUa8DfE2U2hkw2oywGg4ccZbxInNrCgC7l4funt96O71o9vjRWOHB0fbutHY4cbxLfMZOQm45WuFuGxyDiwmbngkdXM6nUhMTBzU+7dsQeSdd97BN77xDRiNfVMZPp8PgiDAYDDA7Xb3+72BDOU/RG6iKKLR5UZZvQtfHmzGJ2WN2Hu0b+rovHEZ+NUl4zA6I17ROoloZLYebsH/e28vdh5pB4JTKjPykzG/JAOzClNQkhWPBJtZ1hp6en0orXNhe1Ur1pY2YMOhZvQGp3xGJcXgV5eMxyWTsjh1Q6qliiDicrlw+HD/6Y+bbroJ48aNw913342JEyee9muoKYgMZG+tEy9vOIx/bKmG1y/CZBDw8wtL8IOzi2AwsIEg0pKeXh8e/qAUL35RCQCItRhx/ZwCXDc7D44Uu6K1tXZ68OqmKrz0RSUaXIFR4wsmZOLhb05GSqxF0dqIBqKKIDKQ003NHE/tQURyqLEDD/57H9aUNgAAFo3PxBPfmQq7Rfa1wEQUBg2uHnz/pS34KjgKcu0MB+66cCwy4m1Kl9ZPt8eHp9cdxF8+KUevT8SopBi8cONMlGRxJJbUZSjv35xoDIOi9Dj87+IZePiqSbCYDPjvvnp859kNaO/uVbo0IjqNquYufOOpL/DVkXYk2834600z8ci3JqsuhABAjMWIO88fi7d/Mg8FqXbUtHXjWyu/wNbDLUqXRjRsER0RGSqtjIgca+vhFnz/pS1o7erFFEcS/nbLLMTLPJ9MRMNT29aNq5/+EjVt3ShItePFm2ahIC1W6bIGpbXTgx++vBWbKlsQZzXhb9+fjamOJKXLIgI4IqKs6fkpePXWs5BkN2NndRt+9vft8PlVm/WIolaH24ub/roZNW3dKEyLxRs/mqOZEAIAybEWvHTzLMwuTEGH24vvv7QZR1q7lC6LaMgYRGQwPjsB/3fzLNjMBnxc1ohHV5UqXRIRHcPvF3Hn6ztQVu9CRrwVr3x/tiqnYk4nxmLECzfOxITsBDR1ePD9l7ag2+NTuiyiIWEQkcnk3CQ8dvUUAMAz6w/hk7IGpUsioqAXv6jE6r31sJgMeOb66chJilG6pGGLtZrwv4tnIC3OitI6Fx74916lSyIaEgYRGV02OQc3zi0AAPz8HzvR3OE+7Z8hInmV1bnwcHCU8p5Lx2NanvbvwMpJisH/XBvo+LyysQqr99YrXRLRoDGIyGzZxeNQkhmPpg4PHvzPPqXLIYpqfr+IZW99BY/XjwUl6fjeWflKlxQ2Z49Jxw/OKQIA3PPObrh6uGuPtIFBRGY2sxEPf3MSBAF4a1sNvjh44nHRRBQZr22uxvaqNsRajFhx1WTdnUy69PyxyE+1o87Zgz98tF/pcogGhUEkAqblJeO62XkAgPv/tZe7aIgU0N7di0c/DEzJ3HVBCbIStbc49XRsZiMeuDJwavXLGw6jvMGldElEp8UgEiG/uGAcEmwmlNW78Na2I0qXQxR1nl53EG1dvRiTEYcb5uhnSuZ4Z49Jx/kTMuHzi3j4gzKlyyE6LQaRCEm0m3HbeaMBAH/4aD96ernFjihS6tp78MJnFQCAuy8aB5NR303f3ReNg9Eg4L/76rG5kqeukrrp+1+jytwwpwA5iTbUOXvwjy3VSpdDFDWe+/QQ3F4/ZuQnY+H4DKXLkd3ojDhcMyMXAPDEmgNKl0N0SgwiEWQzG/HDc4sBAE+vO4Ren1/pkoh0r63Lg79vqgIA/HThGN0tUD2Zn8wfDaNBwKcHmrCjuk3pcohOikEkwq6d6UBanBU1bd14d0et0uUQ6d7LXx5Gl8eH8dkJOGdMmtLlRIwjxY4rp44CADz1cbnS5RCdFINIhNnMRtz8tcAhZy98VgEV3zlIpHk9vT68+EUlAOBH5xZFzWiI5MfzAyOw/91Xj6pm3kND6sQgooDvzsqDzWzA3qNObK5sVbocIt16a1sNmjs9yE2OwaWTspUuJ+JGZ8ThnLHpEEXg/76sVLocogExiCggyW7BN6YFhkxf/KJC6XKIdOvVTYcBADfOLdD9TpmTuWleYAT29S3V6HR7lS6H6ATR+S9TBRYH76D5aE89mngHDVHY7a5px+4aJyxGA646M1fpchRz7ph0FKTa4erx4j+7jipdDtEJGEQUMi4rAVNyE+H1i1y0SiSD1zYHdspcODELKbEWpctRjMEg4OoZDgDAm1t5mCKpD4OIgr41PdBLY+NAFF5dHi/e3R4I+N+e6VC6HMV9Y9ooCAKwsaKFi1ZJdRhEFHTFlFGwGA3Yd9SJ3TXtSpdDpBv/2VUHl9uLvBQ75hSlKl2O4nKSYvC10YGty29u5WGKpC4MIgpKtJtx/hmZAEdFiMLqne01AIBrZuTCYIiuLbsnI43A/nNbDfy8eJNUhEFEYVLj8O6OGp60ShQGzR1ufHGwCQBw+ZQcpctRjQvPyEK8zYSatm5sqGhWuhyiEAYRhZ09Og2psRa0dvViwyE2DkQjtWpPHfwiMGlUIvJTY5UuRzVsZiMuOiMLALBqd53S5RCFMIgozGQ04ILg9MwHbByIRuz9nYEtqpdNjr4DzE7nkuChbqt213F6hlSDQUQFLpoYaBw+2lMHHxsHomFrcPVgY3Da4ZIoPEn1dOaOTkW81YQGlxvbqniqM6kDg4gKzClKRYLNhKYOD7YeZuNANFwf7g5My0xxJMGRYle6HNWxmoxYOD4D4AgsqQiDiApYTAYsmiBNz/DkQ6Lhkt5cL52UpXQpqnXxMdMzvHST1IBBRCUuDk7PfMjGgWhYXD292FTRAgA4fwKDyMmcOzYddosRNW3d2MXzi0gFGERU4uwxaYi1GFHb3oM9tU6lyyHSnM8ONMHrF1GUFovCNO6WORmb2Yj5JekAgP/ua1C6HCIGEbWwmY2YGzz5cN3+RqXLIdKctaWBN9UF4zKULkX15pcEvkfryhhESHkMIioi9VI+YeNANCR+v4iPg/9uzmMQOa35YwNtzVc17Wjm7d+kMAYRFTlnTKBx2FbVhvbuXqXLIdKMXTXtaOrwIM5qwsyCFKXLUb2MBBsmZCdAFIH1BzgCS8qSNYisXLkSkydPRkJCAhISEjBnzhx88MEHcj5S0xwpdhSnx8LnF/F5eZPS5RBphjQt87XRabCY2L8ajHNDI7AMIqQsWf/F5ubm4uGHH8bWrVuxZcsWnHfeefj617+OPXv2yPlYTeubu2XjQDRYnwTXVXFaZvCk6Zn1+xt5kCIpStYgcvnll+OSSy7BmDFjMHbsWDz44IOIi4vDhg0b5Hyspp0bbBzW7W/kNl6iQWjv7sWuI20AgLPHpildjmacmZ+MeKsJrV29+Cr4/SNSQsTGMH0+H1577TV0dnZizpw5A36O2+2G0+ns94o2swpTYDMbUOfsQVm9S+lyiFRvU0UL/CJQlBaL7MQYpcvRDLPRgHnBnXrr93MqmJQjexDZtWsX4uLiYLVa8aMf/Qhvv/02JkyYMODnrlixAomJiaGXw+GQuzzVsZmNmFWYCgD4opy38RKdjrSeau7oVKVL0Zx5YwJBhDd/k5JkDyIlJSXYsWMHNm7ciB//+MdYvHgx9u7dO+DnLl++HO3t7aFXdXW13OWp0llFgVX/bByITu/Lg4F/J3OLOS0zVHOKAuFta1Urenp9SpdDUcok9wMsFgtGjx4NAJg+fTo2b96MP/3pT3jmmWdO+Fyr1Qqr1Sp3SaonNQ4bK1rg94swGASlSyJSpUaXOzSFeVYRR0SGqjg9FunxVjS63NhR3cbvISki4vvc/H4/3G4eoHMqE0clItZiRHt3L0rruE6E6GS+DI4aTshOQEqsRelyNEcQhFD4kEaWiCJN1iCyfPlyrF+/HpWVldi1axeWL1+OTz75BNddd52cj9U8s9GAGQWcniE6nS8PBteHFLMnP1ycCialyRpEGhoacMMNN6CkpAQLFy7E5s2b8eGHH+L888+X87G6IPVS2DgQndwX0voQLlQdNmkqeHtVG9eJkCJkXSPy/PPPy/nldU3qpXCdCNHAGpw9ONzcBUFAaASRhq4wLRYZ8VY0uNzYVtXKRb8UcTwLWaUmcZ0I0SltOdwKABiXlYAEm1npcjRLEATMCU5tbeA6EVIAg4hKmY5ZJ7Kpgo0D0fG2VAaCyIz8ZKVL0bzZwbOLpHBHFEkMIiomNbDbqnj8MtHxth5uAQDMKGAQGanpwbZmR3UbvD6/0uVQlGEQUbEzg43DVvZSiPrp8nixuzZwBQTXh4zcmIw4xFtN6PL4eLUERRyDiIpNcSTBIAA1bd2od/YoXQ6RauyoboPPLyI70YZRSbxfZqQMBgFT85IAANvY8aEIYxBRsTirCSVZCQAbB6J+tgbXh0zn+pCwmc4RWFIIg4jKTc8P9lKq2DgQSTYH3yxnclombKZzTRophEFE5c7MYy+F6Fh+v4jthzkiEm5THUkQBKCqpQsNLk4FU+QwiKicFER21zjh9vLUQ6KDjR1wub2IMRsxLite6XJ0I95mRklm4Pu57TBHRShyGERULj/VjtRYCzw+P3bXOJUuh0hxO4+0A8FD/0xGNmHhJO3U286pYIog/itWOUEQMC04KsIFq0TAzupAb32KI1HpUnRHGoHlmjSKJAYRDZgW3Fb3VU270qUQKe6rI4EgMjk3SelSdGdqMNztqXXC5xeVLoeiBIOIBkwaFWgcdh3hvC1FN7fXh71HA1OUUx0MIuFWmBaHWIsRXR4fDjZ2KF0ORQkGEQ2Qgkhlcxfau3qVLodIMfuOutDrE5FsNyM3mQeZhZvRIOCMYHvz1RGOwFJkMIhoQHKsBXkpdgDA7lo2DhS9pGmZKY4kCIKgdDm6NCVXCiIcgaXIYBDRiEm57KUQ7ajm+hC5TQp+b9nWUKQwiGjE5FHspRBJb45TuWNGNlJbs/eoE728iZcigEFEIzgiQtHO1dMbWkDJERH55KfakWAzweP1o6yON/GS/BhENGJisJdS09aN5g630uUQRdyeWidEEchJtCEtzqp0ObolCEIo6O3ikQEUAQwiGpFgM6MoLRZg40BRak9tYNuutKuD5MMRWIokBhENYeNA0WxPcMfYGTkJSpeie1yTRpHEIKIh0nkie7iFl6LQXmlEJIcjInKTpoIP1HfA4+WCVZIXg4iGTAj2BKWTJYmiRU+vDwcaAgtVOSIiv9zkGMRbTfD4/DxhlWTHIKIhE7IDDXB1Szfau3nCKkWP/fUu+PyBE1WzE21Kl6N7giBgvNTxqWXHh+TFIKIhSXYLcoKNcClHRSiKSAtVJ+Qk8ETVCJE6PhyBJbkxiGiMND2zj40DRZG+hapcHxIpEzgiQhHCIKIx7KVQNApt3eX6kIg5tq0RRVHpckjHGEQ0hgtWKdr4/CJKjwZO+GQQiZwxmXEwGQS0d/eitr1H6XJIxxhENGZCdmBoen9dB++BoKhQ0dSB7l4fYsxGFKbFKV1O1LCajBidEfh+c3qG5MQgojHcVkfRZl9wNKQkKx5GAxeqRhLXiVAkMIhojMEgYHw2GweKHtLFa+Oy4pUuJer0rRPhIYokH1mDyIoVKzBz5kzEx8cjIyMDV155JcrKyuR8ZFTgzhmKJqV1fSMiFFlck0aRIGsQWbduHZYsWYINGzZg9erV6O3txQUXXIDOzk45H6t747MDDTIbB4oG++sZRJQyPqvvEMUOt1fpckinTHJ+8VWrVvX7+MUXX0RGRga2bt2Kc845R85H61pJsHHYX881IqRvnW4vqlq6AAAlmQwikZYca0FGvBUNLjcO1LswLS9Z6ZJIhyK6RqS9PTDPmJKSMuDvu91uOJ3Ofi860ZjgSvZGlxstnR6lyyGSjTQakhZnRWqcVelyotLYYACU/i6Iwi1iQcTv9+OOO+7AvHnzMHHixAE/Z8WKFUhMTAy9HA5HpMrTlFirCY6UGICNA+mc9PPNharKkYJIWR1HYEkeEQsiS5Yswe7du/Haa6+d9HOWL1+O9vb20Ku6ujpS5WlOCXspFAW4UFV5JVmBEVi2NSQXWdeISG677Ta8//77WL9+PXJzc0/6eVarFVYrh18HY0xmPP67ryG0tZFIj8oYRBQXGhFhECGZyDoiIooibrvtNrz99ttYu3YtCgsL5XxcVJFGRA5wwSrpWCiIcKGqYsYEv/eNLjdauSaNZCBrEFmyZAn+9re/4dVXX0V8fDzq6upQV1eH7u5uOR8bFY7tpfBCKtKjpg43mjs9EIS+n3eKvDirCbnJXJNG8pE1iKxcuRLt7e2YP38+srOzQ6/XX39dzsdGhaL0WBiDF1I1uNxKl0MUdtJoSH6KHTEWo9LlRDWuSSM5ybpGhD11+djMRhSk2nGwsRNldS5kJtiULokorLhQVT3GZsVjTWkD14mQLHjXjIZJDTR7KaRH+7k+RDVCIyLcwksyYBDRsDEZDCKkX6Who90TlC4l6nFNGsmJQUTDpBGRMu6cIZ3x+0Uc4B0zqsE1aSQnBhENGxvawuuC389eCulHTVs3ujw+WIwGFKTalS4n6klr0nDMImKicGEQ0bCCVDssRgO6PD7UtHFLNOlHeUNglK8wLRYmI5spNeCaNJIL/4VrmMloQHHwAjz2UkhPpCAyOvjzTcrru3OGbQ2FF4OIxpVkBoMIeymkI1IQKWYQUQ2eJUJyYRDROOn45YMNXLBK+lHeyBERtZH+Lg42dnLnDIUVg4jGFadLjQODCOmDKIp9UzPpDCJqkZ8a2DnT4fZy5wyFFYOIxo3OiAXYSyEdaerwoL27F4IQ2DZK6mAxGZCfEtg5U84RWAojBhGNy0vp66XUO9lLIe2T3uQcyXbYzLxjRk2KOAJLMmAQ0TiLyYD8VPZSSD+4PkS9pL8TtjUUTgwiOsB1IqQn5cFdGQwi6lOcLk0Fs62h8GEQ0QEGEdKT0IgIF6qqTjFHREgGDCI6wOFS0pPQjplMBhG1kTo99U43XD29SpdDOsEgogMcLiW9cPb0hhZdc2pGfRJjzEiPtwLBnXpE4cAgogPScGm90w0neymkYdLBfBnxViTYzEqXQwOQpsx4iCKFC4OIDiTYzMgI9lIOsZdCGsY7ZtSvOHh2UTlHYClMGER0opi9FNIBbt1VP46IULgxiOhEaMEqeymkYQc5IqJ6xWxrKMwYRHQitGCVvRTSMN4xo35SSKxq7kKvz690OaQDDCI6wV4KaZ3H60d1azdwzM8zqU9Wgg2xFiO8fhGHm7uULod0gEFEJ9hLIa2rbu2Czy/CbjGGFl+T+giCwIPNKKwYRHSCvRTSuorgjq/CtFgIgqB0OXQKPM2ZwolBRCfYSyGtq2jqCyKkbjxEkcKJQURHioINuNSgE2nJoeDPbRGDiOoVpgU6PZVsaygMGER0pCAURNhLIe2Rfm4L0xlE1K6QnR4KIwYRHZEah8omrhEh7TkUWiPCHTNqV5BmBwC0dvWitdOjdDmkcQwiOlIUbMAPsZdCGtPh9qLBFbjsrjCVIyJqZ7eYkJVgAwBUNLO9oZFhENERqZfS1MEruklbpLUGqbEWJNp52Z0W9I3AMojQyDCI6Ei8zYy0uMD5C5yeIS0JLVTl+hDNkNbycJ0IjZSsQWT9+vW4/PLLkZOTA0EQ8M4778j5OAJQGBwVOcQFq6Qhx54hQtogTaFxKphGStYg0tnZiSlTpuCpp56S8zF0DC5YJS0K7ZjhQlXN4NQMhYtJzi9+8cUX4+KLL5bzEXQcqSHnFl7SEh5mpj3HTs2IosjTcGnYZA0iQ+V2u+F2u0MfO51ORevRImlqhvO2pBWiKHKNiAY5ku0wGgR0eXxocLmRGdxFQzRUqlqsumLFCiQmJoZeDodD6ZI0p29EJNBLIVK75k4PXD1eCAKQl2JXuhwaJIvJgNzkGOCYM2CIhkNVQWT58uVob28Pvaqrq5UuSXPyU+0QBMDZ40ULDxoiDZBG70YlxcBmNipdDg1BaJ0IzxKhEVBVELFarUhISOj3oqGxmY3ISQz0Ujg9Q1pwqFFaqMppGa3hUe8UDqoKIhQebBxIS3jZnXZJbQ2nZmgkZF2s2tHRgfLy8tDHFRUV2LFjB1JSUpCXlyfno6NaYVosPitvYhAhTeAZItrFqRkKB1mDyJYtW7BgwYLQx0uXLgUALF68GC+++KKcj45qBRwRIQ0Jbd1N5xkiWiMFkcPNnfD5RRgN3MJLQydrEJk/fz53biigiEGENMLnF3G4OXD4HqdmtCcnMQYWkwEerx81rd3IS+WuJxo6rhHRoWOHS/1+BkFSr9q2bnh8flhMBuQkxShdDg2RwSCgIJXXStDIMIjoUG5yDEwGAT29ftQ5e5Quh+ikpIWqBal2DutrFI96p5FiENEhk9EQOhiKjQOpWUVw625BKqdltOrYQxSJhoNBRKdC2+rYOJCKVQbXh3DHjHb13fjNtoaGh0FEp7hzhrSgqiUQRLjIUbukERFu4aXhYhDRKc7bkhZIb16cmtEuqa050toNt9endDmkQQwiOsXTVUntfH4RR1q6AfCyOy1Li7MgzmqCKAJVwak2oqFgENEpaWqmurULPm7hJRU62h7Yums2Cty6q2GCICA/OLV2mEGEhoFBRKeyE2ywmAzo9YmobetWuhyiE0i9Z0cyt+5qXSiItDCI0NAxiOiUwSDAkRzoZbKXQmok7ZjJ50JVzctP7TvqnWioGER0TFoAyNXspEaHWwI/l/lcqKp50umqlez00DAwiOiYtCWyisOlpEKHmzgiohd5KYEwWcVODw0Dg4iOhUZEuHOGVEhaT8Agon0FwUPNjrR2o9fnV7oc0hgGER3jSnZSK1EUQ+sJODWjfZnxNlhNBnj9XBxPQ8cgomOhBWQtnRBFbuEl9WjscKPL44MgBC5pJG0zGITQWTDs+NBQMYjo2KikGBiDt/A2uNxKl0MUIm3dzUmMgdVkVLocCgPunKHhYhDRMYvJgJwkG8B1IqQy3LqrP9w5Q8PFIKJzBaHpGTYOpB5VXB+iO1yTRsPFIKJzfY0DR0RIPaRecwFHRHSDUzM0XAwiOpefIjUO7KWQenDrrv5Io69VLV3w834rGgIGEZ3jcCmpEbfu6k9Okg0mgwC31496V4/S5ZCGMIjoXP4xx7xzCy+pQXtXL9q6egEgtOWTtM9kNIS2Ylc2seNDg8cgonNSQ+/q8YYafyIlSXfMpMdbEWs1KV0OhVF+aHqG60Ro8BhEdC7GYkRWQnALLxeRkQpI04T5HA3RnXxu4aVhYBCJAnlcJ0IqwvUh+sWdMzQcDCJRoIBBhFSEh5npF9saGg4GkSjAXgqpSRWDiG4du0uPi+NpsBhEokCoceDpqqQClZya0a3cZDsEAehwe9Hc6VG6HNIIBpEoUMAREVKJLo83dAEjT1XVH5vZiJzEwBZeTs/QYDGIRAFpsWpThwcdbq/S5VAUqwqOyiXYTEiyW5Quh2QgHRnAjg8NFoNIFEiwmZESG2j02TiQkqReckEap2X0qiCNW3hpaCISRJ566ikUFBTAZrNh9uzZ2LRpUyQeS8fgUe+kBty6q3+hQ83Y6aFBkj2IvP7661i6dCnuu+8+bNu2DVOmTMGFF16IhoYGuR9Nx5AOj+KhZqQkHmamf31tDTs9NDiyB5E//vGPuPXWW3HTTTdhwoQJePrpp2G32/HCCy/I/Wg6Rl8vhY0DKecwt+7qHo8LoKGSNYh4PB5s3boVixYt6nugwYBFixbhyy+/POHz3W43nE5nvxeFR9/Ry2wcSDncuqt/UlvT2tWL9m7eb0WnJ2sQaWpqgs/nQ2ZmZr9fz8zMRF1d3Qmfv2LFCiQmJoZeDodDzvKiCkdESGkerx+1bd0At+7qWqzVhLQ4K8D2hgZJVbtmli9fjvb29tCrurpa6ZJ0Q2r4a9t70NPrU7ocikJHWrvgF4EYsxHp8ValyyEZFXAEloZA1iCSlpYGo9GI+vr6fr9eX1+PrKysEz7farUiISGh34vCIyXWgrjglevVPGGVFCCd7JufaocgCEqXQzIKjcCyraFBkDWIWCwWTJ8+HWvWrAn9mt/vx5o1azBnzhw5H03HEQSBW3hJUYebAr3jPO6Y0b3QmrQmjojQ6ZnkfsDSpUuxePFizJgxA7NmzcLjjz+Ozs5O3HTTTXI/mo6Tn2rHnlonh0tJEdKICA8z0z92emgoZA8i1157LRobG3Hvvfeirq4OU6dOxapVq05YwEry69tWx8aBIk/6ueOIiP6F7rdqYaeHTk/2IAIAt912G2677bZIPIpOoYC38JKCpHMlCrh1V/ekEZF6pxvdHh9iLEalSyIVU9WuGZJXXgoPGiJl+PwiqlsCW3d5mJn+JdktSIwxA1ywSoPAIBJFpMuoalq70evzK10ORZE6Zw88Pj/MRgHZiTaly6EI4CGKNFgMIlEkM94Gi8kAr18MHSxFFAnSjhlHsh0mI5udaMCj3mmw2CJEEYNBCF1IxQWrFEnSBWh5nJaJGmxraLAYRKJM37Y69lIocqTdE1yoGj24hZcGi0EkyvQtWGXjQJFzuIlbd6ONdF4Mt/DS6TCIRBlpwSq38FIk9R1mxiASLaSpmZrWbni8XBxPJ8cgEmXyUjg1Q5ElimLo500akSP9S4+3IsZshF8Earg4nk6BQSTKFBxzGZXfLypdDkWBpg4Pujw+CALgSIlRuhyKkGPvt+IWXjoVBpEoMyo5BkaDgJ5ePxpcbqXLoSggjYbkJMbAauIJm9FECiJVXJNGp8AgEmXMRgNGJQV6pZyeoUiQFkbzRNXoI50lwhEROhUGkSjEbXUUSVLgZRCJPhwRocFgEIlCoSDCbXUUAdKOmXyeIRJ18lM4IkKnxyAShfJ5lghFkHSqaj7PEIk6UqenuqUbPi6Op5NgEIlCeZyaoQjqm5rhiEi0yUmKgdkowOPzo87Zo3Q5pFIMIlGo4JgFZKLIXgrJp72rF21dvQDXiEQlo0GAIznY8Wni9AwNjEEkCkmHmrl6vKE3CSI5SOuQ0uKsiLWalC6HFBAageVpznQSDCJRKMZiRGaCFWDjQDKTpv8KOBoStQq4hZdOg0EkSvUtWGXjQPIJHe3OIBK1uIWXTodBJErxLBGKhMrQiAgXqkarvmPe2dbQwBhEohTvgKBIqOKpqlFP2i1VxcXxdBIMIlGqr3FgL4XkU8mtu1EvNzkGggB0enxo6vAoXQ6pEINIlMrnSnaSWZfHG7pYkYtVo5fVZEROYuB+qyqe5kwDYBCJUtJi1UaXG51ur9LlkA5VBUNuYowZSXaL0uWQgkJTwU3s+NCJGESiVKLdjCS7GTjmDYMonKQ3Ha4PIWlqjrv0aCAMIlFMuvuDjQPJQRqG5/oQ4lQwnQqDSBTr66WwcaDwq+RhZhRUwC28dAoMIlGM+/tJTqHDzHjrbtTLS+nbwkt0PAaRKBbawsuV7CSD0PHuaZyaiXZSp6e1qxft3bzfivpjEIliPF2V5OL2+lDb1g1wsSoBiLWakBYXuN+KZxfR8RhEopi0WLW2rRser1/pckhHjrR2wy8CdosR6cE3IIpuBTzNmU5CtiDy4IMPYu7cubDb7UhKSpLrMTQC6fFWxJiN8IvAkVb2Uih8pF5vXoodgiAoXQ6pgHTxIY8LoOPJFkQ8Hg+uvvpq/PjHP5brETRCgiBweoZkIfV6edkdSaSfhcomjohQfya5vvD9998PAHjxxRflegSFQX6qHaV1Lp4lQmF1mJfd0XF4lgidjGxBZDjcbjfcbnfoY6fTqWg90UDaOcMtvBROh3nZHR2Hp6vSyahqseqKFSuQmJgYejkcDqVL0r18ztuSDA7zMDM6jvSzUO90o9vjU7ocUpEhBZFly5ZBEIRTvkpLS4ddzPLly9He3h56VVdXD/tr0eBIl9+xl0Lh4vOLqA4ufs5jEKGgJLsFCbbAIDw7PnSsIU3N3HXXXbjxxhtP+TlFRUXDLsZqtcJq5Va/SJJGRKpbuuHzizAauMOBRqa2rRu9PhEWowHZwevfiRA83O6rI+2obO5ESVa80uWQSgwpiKSnpyM9PV2+aijicpJiYDYK8Pj8qHP2YFQS3zhoZKRpGUdKDIMt9ZOXYsdXR9p5qBn1I9ti1aqqKrS0tKCqqgo+nw87duwAAIwePRpxcXFyPZaGyGgQkJtsR0VTJw43dTKI0Igd5q27dBKhLbycCqZjyBZE7r33Xrz00kuhj6dNmwYA+PjjjzF//ny5HkvDkJ8aDCItXZirdDGkedy6SyfDQ81oILLtmnnxxRchiuIJL4YQ9ZGOemcvhcJBOrCKh5nR8TgiQgNR1fZdUkboFl7O21IYSL1d7pih40mjZDWtvN+K+jCIEI95p7ARRZHHu9NJZcRbYTMb4BeBmuDtzEQMItTvxENRFJUuhzSsweVGT68fRoPAhc90AkEQeHYRnYBBhOBIiYEgAJ0eH5o7PUqXQxomjarlJNlgMbF5oRNxBJaOx5aCYDUZkRM8eIq9FBoJTsvQ6RSkSSMiDCIUwCBCQPCgIbBxoBHqu+yOC1VpYH1tDTs9FMAgQsAxbxy8hZdGInSGSApHRGhg3MJLx2MQIaDfFl42DjR8PMyMTuf4+62IGEQI4IgIhUG/rbtpHBGhgWUn2vrdb0XEIELAMcOlnLel4Wrr6oWrxwsAcCRzRIQGZjIakJvMdSLUh0GEAAAFaYGGobWrF63cwkvDcCh4tHt2og0xFqPS5ZCKcQsvHYtBhAAAdosJWQk2AEAFeyk0DBXBIFLIaRk6jXzu0qNjMIhQiPQGIl1aRjQUlQwiNEj5nAqmYzCIUEhheqBxqGAQoWHgiAgNljQVzLaGwCBCxyoKvoEcYuNAwyD93BSlM4jQqRWmxQHBqRk/t/BGPQYRCpF2zlQ0MojQ0Pj94jFTM3FKl0Mql5scA5NBQHevj1t4iUGE+hw7NcNbeGko6l096O71wWQQkJvMW3fp1MxGQ+iod07PEIMIhTiS7TAGeyn1TrfS5ZCGSKNoeSl2mI1sVuj0CjkVTEFsMSjEYjLAEezNHmrqULoc0hDpzYQnqtJgSWuJOBVMDCLUT98WXu7vp8HjjhkaKmktETs9xCBC/Ug92go2DjQEPEOEhqowjccFUACDCPVTxMaBhkH6eSliEKFBKg5OzVS3dMHj9StdDimIQYT66RsuZRChwen1+VHVEpjKK+QZIjRI6fFWxFqM8ItAVQvbm2jGIEL9SG8kVc1d8PrYS6HTO9LaDa9fRIzZiMx4m9LlkEYIghBqbw5xwWpUYxChfrITbLCaDPD6RRxp7Va6HNIAaT1RQVosDAZB6XJIQ4qCI7CcCo5uDCLUj8Eg9J2wygupaBCk3mxh8P4QosHiglUCgwgNJNQ4cLiUBoFbd2m4ijg1QwwiNBDewktDUdnMO2ZoeHi6KoFBhAbC4VIaiopGjojQ8Eg/M00dbjh7epUuhxTCIEIn4FkiNFjdHh9q2wO3p/IMERqqeJsZ6fFWgFPBUY1BhE4gna5a09aNnl6f0uWQiknTMkl2M5JjLUqXQxrEEViSLYhUVlbilltuQWFhIWJiYlBcXIz77rsPHo9HrkdSmKTGWhBvMwEADjfzzhk6OS5UpZGSTljlOpHoZZLrC5eWlsLv9+OZZ57B6NGjsXv3btx6663o7OzEY489JtdjKQwEQUBRWix2HmnHocYOlGTFK10SqRSDCI1UaMFqI++3ilayBZGLLroIF110UejjoqIilJWVYeXKlQwiGlCUHoedR9pxkI0DnULoDJFUBhEankIeahb1ZAsiA2lvb0dKSspJf9/tdsPtdoc+djqdEaqMjjc6I9A4HOQCMjqF8mBQLc7g1l0anqJjjgsQRRGCwNN5o03EFquWl5fjz3/+M374wx+e9HNWrFiBxMTE0MvhcESqPDpOcXrgjaW8gSMiNDBRFHEw+PMxmkGEhsmRbIfRIKDL40ODyz2IP0F6M+QgsmzZMgiCcMpXaWlpvz9TU1ODiy66CFdffTVuvfXWk37t5cuXo729PfSqrq4e3n8VjdjojEAv5WBjB/x+UelySIXqnW50uL0wHnMtANFQWUwGOJJjgGB7Q9FnyFMzd911F2688cZTfk5RUVHo/9fW1mLBggWYO3cunn322VP+OavVCqvVOtSSSAb5qbEwBXspR509GJUUo3RJpDIHGlwAgPxUOywmngRAw1ecHofK5i4cbOzE3OI0pcuhCBtyEElPT0d6evqgPrempgYLFizA9OnT8de//hUGAxsrrTAbDchPteNgYyfKGzoYROgE0rTd6HROy9DIjM6Iw5rSBpTXu5QuhRQgWzKoqanB/PnzkZeXh8ceewyNjY2oq6tDXV2dXI+kMJPm/blOhAZSzvUhFCbSz9ABtjVRSbZdM6tXr0Z5eTnKy8uRm5vb7/dEkWsOtGB0Rhw+3FPPIEIDYhChcBmTGTiriEEkOsk2InLjjTdCFMUBX6QNfVt42TjQiaSfCwYRGinpZ6jR5UZ7Fy+/izZctEEnNTo90Es5yF4KHaety4OmjsB1DcVcI0IjFGc1ITvRBgAob+Q6kWjDIEInVRzcwtvc6UFrJ+8Ioj7StExOog2x1oiei0g6FVonUs+OT7RhEKGTsltMod0y5ZyeoWNIQYQnqlK4jMkIjMByTVr0YRChUyrmzhkaABeqUrhx50z0YhChU5Ku6GYQoWOVc6EqhdmYTHZ6ohWDCJ0SzxKhgfAwMwo36Weppq0bnW6v0uVQBDGI0ClJjQO38JKk2+NDTVs3wBERCqPkWAvS4iwA25uowyBCpyS90dS0daPb41O6HFKBg40dEEUg2W5GahzvhqLw4c6Z6MQgQqeUGmdFst0MUWQvhQJ4kBnJRdo5wwWr0YVBhE5rbPD45dI6HjREwP7gxWQMIhRuXJMWnRhE6LTGZQWCSFmdU+lSSAXK6gJvEiXBgEoULmNCQYSdnmjCIEKnVZKVAHBEhILK6gOBVPq5IAqX0cEtvFUtXejp5Zq0aMEgQqdVEhoRYRCJdh1uL6pbAjtmpJ8LonBJj7MiMcYMv8jpmWjCIEKnJb3hNLjcvHMmyh0Irg9Jj7ciJdaidDmkM4IgsOMThRhE6LTirCY4UgJ3znB6JrpJbw7jOBpCMhkvBZF6tjXRgkGEBqUkM7AegAtWo5v05jCWC1VJJtLao31H2dZECwYRGpRx7KXQMSMiXB9CchmXzamZaMMgQoMivfFwaia6cWqG5CZtC29wudHCNWlRwaR0AaQN445ZQOb3izAYBKVLigi/X8SGimZ8Xt6EA/Ud6O71IcFmxtjMeCwcn4EzchIgCNHxvWjqcKO50wNB6DsBkyjcYq0m5KXYUdXShdI6J+YWpyldUsRUNHVi9d467Kl1oq2rFyaDgIK0WMwpSsXZY9NgNRmVLlEWDCI0KAVpsbAYDejy+HCktRt5qXalS5KVzy/in9uO4Ik1B3CktfuE3//3rqP4n//ux4TsBNx1wVicNy5D94FEGg3JT7EjxqLPBpHUYVxWfCCIHHVFRRDZUd2G339Yis/Lmwf8/ec/q0Cy3YwfnFOMG+cW6O7fH4MIDYrZaEBxRhz2HXWitM6p6yBS1dyFO9/Yga2HWwEA8TYTLpiQhUmjEhBvM6Ol04NtVa1YW9qAvUeduOWlLbhkUhYeuHKSrre0lnJ9CEXIuKx4fLS3XvfrRHp6fXhkVSn++nklAMAgAPNGp+GsolRkJtjg9vqw76gTq/fWo97pxiOrSvGPLdX4wzVTMC0vWenyw4ZBhAZtfFY89h11oqzOhQvOyFK6HFl8Ud6EH/5tK1w9XsRZTfjZwtG4YU4BbOYTeyCtnR48vf4gnv+0Av/ZVYevjrTjrzfOxBid7igpDe5i4NHuJLdx2dJpzvrdOdPocuP7L23GziPtAICrpo3C0gvGIjf5xE7eby8/A//aWYtHVpXiUFMnrnnmSzz4jUm4ZoZDgcrDj4tVadBCC1Z1unNm1e463PDCJrh6vJiWl4QPbj8bPzineMAQAgDJsRYsv3g83lkyDwWpdhxp7cZVK7/Ajuq2iNceCXtqA28KE3ISlS6FdE5qa/bXd8DnF5UuJ+xq27px1crPsfNIO5LtZrxw4wz88dqpA4YQADAZDbjqzFx8dMe5uGRSFnp9In755ldY+cnBiNcuBwYRGjQ9n3i4fn8jfvb37fD6RVw6ORt/v/UsOFIGN/00cVQi3vrJPMzIT4arx4vrn9+I3TXtstccSR6vHweCF5GdkcM7ZkheBamxsJoM6O71oaqlS+lywqqpw43vPb8R1S3dyEux462fzMN54zIH9WcT7WY8+Z0zsWRBMQDgkVWl+N9PD8lcsfwYRGjQxgUPGqpo6tTVhVTbq1rxg5e3wOPz45JJWXji29NOOgpyMimxFrx08yzMLAiEkVte2ox6Z49sNUfa/noXen0iEmwm5CbHKF0O6ZzRIIR26u2t1c/0TIfbi8UvbMKhxk6MSorBaz84C4VpsUP6GgaDgF9cOA53LhoLAHjg3/uwanedTBVHBoMIDVpmghWpsRb4/KJuzhNpdLnxo79tRU+vH+eOTcfj106DcZhbk2OtJrxw40yMyYhDvdONH/zfFt0Etr1HpWmZ6NmuTMo6Y1RgCnB3rT5GF0VRxN1vfoU9tU6kxVnw8i2zkJM0/FB/+6IxuGFOPgDgztd3aHoUlkGEBk0QhL7GQcM/9BKvz4+f/n0b6p1uFKfH4qnrzoTFNLJ/EvE2M55fPBPJdjN2HmnHr9/eHbZ6lST1Ss/g+hCKkIk5+mlrAOCFzyvx711HYTYKePaGGShKjxvx17z3sgk4e0waunt9+OHLW9He3RuWWiONQYSGZNKowPTMHh30Uh7/7wFsONSCWIsRz1w/HXHW8Gwiy0u14y/XTYdBAP657Qje/6o2LF9XSdLfN9eHUKRMDLU1ToiithesbqtqxYr/7AMA/ObSCTgzTFtvTUYDnvzumchLsaOmrRu/eWe3Jr9XDCI0JH29FG3P2+6sbsNfPikHADz8zckYHeaTQucUp2LJgtEAgF+9tQu1bSceiqYVfr/IERGKuLGZ8TAZBLR0enC0XbvrrXp6ffj5Gzvh9Yu4bHJ2aDolXBJjzHj821NhNAh4b2ct3tlRE9avHwkMIjQkE4NTM2V1Lni8fqXLGZaeXh/u+sdO+EXgiik5uHxKjizP+dnCMZjiSIKzx4tfvvmVJnsqAFDV0oVOjw8WkwHF6UNbWEc0XDazMXQmj5anZx77sAyHmjqRmWDFg1dOkmWN1Zl5ybh94RgAwL3v7EGdxoIbgwgNSW5yDBJjzPD4/Niv0fNEnlhzAOUNHUiLs+L+K86Q7TlmowGPXzsVVpMBn5U3abKngmPODxmXFQ+TkU0GRc7E4FTgbo3unNl6uBXPf14BAFhx1SQk2s2yPesn84sx1ZEEl9uL//f+HtmeIwdZW5UrrrgCeXl5sNlsyM7OxvXXX4/aWu3Pl0czQRCOmbvVXi/lYGMHngvuu3/oGxORLPOR7IVpsfhZsKfywPv70NalvdtEuT6ElCKNwO7R4IiIzy8G12wAV505atBnhQyXyWjAQ9+YBKNBwH921WHNvnpZnxdOsgaRBQsW4I033kBZWRn++c9/4uDBg/jWt74l5yMpArS6TkQURdz/3l70+kQsHJcRsWPqbz27CGMy4tDc6cEjq0oj8sxw2hV8E+CJqhRpUqdHi1t4/76pCvuOOpFgM+HXl4yPyDMn5CTg+18rBADc++4edHu0cXyArEHkzjvvxFlnnYX8/HzMnTsXy5Ytw4YNG9Dbq80tRhQgbeHdpbFeyuq99Vi/vxEWowH3XDYhYs+1mAx46KpJAIDXNldraiRJFEXsDB5ZPzU3SelyKMqMz06AIAD1TjcaXNpZ99Da6cFjH5UBAJaePxapcdaIPfv2RWMwKikGNW3dodFftYvYhG9LSwteeeUVzJ07F2bzwPNkbrcbTqez34vUR5q33XfUCa9PGwtWe3p9+N2/9wIAvn92IQqGeJrhSM0sSMHlU3IgisCD/96nmYWrlc1dcPZ4YTEZMC6bl91RZNktJhQHz9vYo6ER2D+u3o+2rl6UZMbje2eFd5fM6dgtJtx98TgAwNPrDqJBAyc8yx5E7r77bsTGxiI1NRVVVVV49913T/q5K1asQGJiYujlcOjjZkG9KUiNRZzVBLfXj/31HUqXMyjPf1aB6pZuZCXYQttqI+2XF5bAYjLgi4PNWFvaoEgNQ7WjuhUIhk8zF6qSAiYHR2C1cplkaZ0Tr2w8DAC474oJiizwvnxyNqblJaHL48MfPtof8ecP1ZC/Q8uWLYMgCKd8lZb2zYP/4he/wPbt2/HRRx/BaDTihhtuOGlvcPny5Whvbw+9qqurR/ZfR7IwGARMcQQah+3BNyo1a+304OngLZXLLh6H2DAdXDZUjhQ7bppXAAB46D/7NDGatLM6MI00xcFpGVLGtLzAz952jQSRR1eVwS8CF0/MwtziNEVqEAQBv7k0sC7lja3Vqr+vZ8gt8l133YUbb7zxlJ9TVFQU+v9paWlIS0vD2LFjMX78eDgcDmzYsAFz5sw54c9ZrVZYrZGbS6PhOzMvGZ+XN2N7VRuumx3ZocehWrnuIFxuL8ZnJ+AKmc4MGawlC0bjjc3VONjYib9vrsb1ER62HSqp8Z/KIEIKmRY8hXRHVSv8fhGGYd4FFQlbKluwtrQBRoOAX1xYomgt0/NTcOmkbPx711E89J99+Nv3Zytaz6kMOYikp6cjPT19WA/z+wM9QLfbPaw/T+oR6qVUqXtE5Gh7N178ohIITo0o3Ygl2My4Y9FY3PevPXhizQF868xcxFiGdtNvpLi9PuwL9qQYREgpJVnxsJkNcPZ4caipE6MzRn5HixxEUcSjqwILVK+ZkRuWu2RG6u6LxuGjvXX4rLwJXx5sxpziVKVLGpBsk1cbN27Ek08+iR07duDw4cNYu3YtvvOd76C4uHjA0RDSlqmOQC/lYGOnqs/GeGLNAXi8fswqSMH8kuEF6HD7zqw8jEqKQaPLHZpLVqN9R13w+PxIspuRl2JXuhyKUmajAZNHqb/j88n+RmyqbIHVZAidHaS0vFQ7vj0zDwDwP//dr9pF8rIFEbvdjrfeegsLFy5ESUkJbrnlFkyePBnr1q3j9IsOpMRaUBjceaLWRWSHGjvwxpYjAIBfXlSimuvrLSYDfrYwsGD26XUH0eXxKl3SgKRtu1Nyk1TzvaPopPZ1In6/iN8HR0MWzy1AdmKM0iWF/GRBMSwmAzZVtODz8malyxmQbEFk0qRJWLt2LZqbm9HT04OKigqsXLkSo0aNkuuRFGHTHFIvRZ2Nw5Nry+HzBw4vm1GQonQ5/Vx1Zi7yUuxo6vDg5S/VOSqyk+tDSCX6poLV2dZ8tLcOe486EW814cfnFitdTj/ZiTH47qzAqMgfV5epclSE+/Fo2KblB6ZntqlwuLSyqRPv7gxcJ3DHorFKl3MCs9GAn57XNyrS4VbfqMjW4N8rgwgpTVqwWlbnRKfK/q2Ioogn1gRu8r5xXoHs10YMx0/mF8NqMmBbVRvW7W9UupwTMIjQsEkjIjuq2+D3qytl/+WTwGjIgpJ0TMpV59Hk35g2CgWpdrR29eKl4IJatahr78Hh5i4IAjC9IFnpcijKZSbYkJNog18EvjqirpOJ1+xrwN6jTsRajLh5XqHS5QwoI8EW2qH3P6vVt1aEQYSGbVxWPGLMRrh6vDjYqJ6DzapbuvDWtsBNtz9VyaKxgZiMBty+KFDfc58egqtHPVcfbKpsAQBMyE5Agk2+G0OJBksaFVHTCKwoivjz2gMAgOvnqHM0RPKj+cWIMRux80i76g5UZBChYTMZDaFh+40VLUqXE7Jy3UF4/SLOHpOGM/PU3Zu/YsooFKfHoq2rF/+norUim4N/n7MK1bW2hqKX9LO44ZB6Flyu29+InUfaYTMb8P2z1TkaIkmLs+KGuYFRkSfWlqtqVIRBhEbkrKLAvvQvVdI41LZ14x9bAify/vQ89Y6GSIwGIVTnc58eUs1akU1SEFHZIl+KXlJbs6WyFR6v8qcSB0ZDAmtDvjc7H2kRvNhuuG49uwg2swE7q9vwWXmT0uWEMIjQiEgH5Gw81KyKhP3MuoPo9Yk4qyhFM735yyZnozAtMCqihh00rZ0elNW7AAAzNfI9JP0bkxGHlFgLunt92FWj/O6ZLw82Y+vhVlhMBvzgnKJB/AnlpcVZ8Z3gDpongyFKDRhEaESmOBJhNRnQ1OFBeYOy60QanD34++bAaMjPNDAaIjEZDbgteBHfc58eUvxckc3B9SHF6bGa6OVRdDAYBMwOTc8oPxX8pzWBtSHfmelARoJN6XIG7QfnFMFsFLCxoiU08qk0BhEaEavJiBnBXRVKz90+s/4QPF4/ZuQnq/Yo45P5+tQc5Kfa0dLpwSsbqhStJTQtU6it7yHpnzQ9o3Rbs6miBRsrWmA2Cvihys4NOZ3sxBh8a3rgZvsnP1bHqAiDCI3YWYXKrxNp6ug7Lv2nC8do7iRQk9GAJcFRkWfWH0S3x6dYLdKOmdmcliGVUcs6EWmnzNUzHMhJUs8pqoP143OLYTQIWL+/EV8dUX6ai0GERkwafdhwqEWxdSLPfXoIPb1+THEk4Zwxyly9PVLfmDYKuckxaOrw4NVNyoyKtHV5sLsmcE7D7CIGEVIXNawT2VbVik8PNMFkEFR3iupg5aXa8fWpgZvI1bBWhEGERmxybhJizEa0dHqwvz7y60RaO/uOSf/ZeaM1NxoiMR8zKvL0uoPo6Y38qMgXB5vhFwMNvpruyyBCcJ3IWcGA/OVBZUZg/xxcG/KNaaPg0PBlkD+ZPxqCAHy0tx6ldU5Fa2EQoRGzmAyhdSKfHoj88cEvfF6BLo8PZ+Qk4LxxGRF/fjh988zc0M28rykwKiL9/Z09Rh03FRMdb05xYMRz/f7Ibz/ddaQdH5c1wiAg1GnQqtEZcbhkYjYA4C8fH1S0FgYRCotzxwbeuCJ9j0F7dy9e/DxwPPpPNTwaIrGYDPjx/MBw78oIj4qIohhq3M8eq83pLdK/+cG2ZmtVK9q7I3sasbQ25IopOSgI3j6uZUsWjIbJIMBiMih6TQeDCIXF/JLASMTGQy0RvZTqpS8q4XJ7MTYzDhdMyIrYc+V09YxcZCfaUO904x9bj0TsuYeaOlHT1g2L0cCFqqRajhQ7itNj4fOL+DyCh3LtO+rER3vrIQjAbedpezREMiEnAV8uX4jHrp4Cg0G5ThyDCIVFcXosHCkx8Pj8EZu77XB78cLnFUAw2Sv5DymcrCZj36jIx+VweyMzKrJ2X+D+iZmFybBbTBF5JtFwSB2fT8oid2eKtNX1konZGJ0RH7Hnyi09XvmzghhEKCwEQcCCYOOwNkKNw8tfHkZbVy+K0mJx2eSciDwzUq6Z4UBGvBW17T3459aaiDxz9b56AMD54zMj8jyi4ZpfEpie+aSsMSJTCuUNLvxn11EA+hkNURMGEQobKYis2Vcve+PQ5fHifz89BAD4yYLRMOpkNERiMxvxo+DWwKc+LkevT94zE1o6PdgSPD9k0QQGEVK3WYUpiLOa0OByY0cEzsF4cm05RBG4YEImxmcnyP68aMMgQmEzd3Qq4q0m1Dvd2F4t71Xdr26sQnOnB46UmNB+eL357uw8pMVZUdPWjbe2ybtWZG1pA/wiMCE7AbnJ2t2SSNHBajJiQXCH3KrddbI+q6KpE//aWQto5CJNLWIQobCxmoxYOD7QOHywS77GocPtxV8+CWw3WzJ/NMxGff4YB0ZFApdpPSnzqMiHewJ/X+dzNIQ04uKJgcXpH+w+KutBiv+zej/8IrCgJB2TchNle04002cLToq5KLgv/YPddbI1Ds9/WoGWTg8K02Lxrem5sjxDLa6bnY+0OAuqW7rx7o5aWZ7R3tWLdWWBbdcXT9LHziPSv/kl6bCZDahu6caeWnkO5NpT2x4aDbnrghJZnkEMIhRm80vSYbcYUdPWje3V4Z+7ben04Lng2pCl54+FSaejIZIYixG3nh0cFVl7AF4ZRkVW7TkKj8+PcVnxGJfF+W/SBrvFhPljAyOw7+2UJ6Q/9mEZAOCyydmYOIqjIXLRdytOEWczG3HRGYFe9T9lOAPj6XUH0eH2YkJ2Ai6dlB32r69G3zsrHymxFlQ2d+Ht7eHfQSONtFyh07U2pF9XThsFAHh7e03YQ/rmyhZ8XNYIo0HgaIjMGEQo7KTpkn/trA3ryaB17T146YvAKaq/uKhEN+eGnE6s1YQfnhMYFfnDR/vR5QnfgXG1bd2hW5Mv19kWaNK/88ZlINluRoPLjc/CeLiZKIp4dFUpENxKX6iDU1TVjEGEwu6solSMSoqBq8eLj/bWh+3rPrKqFG6vH7MKUkLHPEeLxXMLkJscgzpnD55bXxG2r/v3TVUQReCsohRNX+BF0cliMuCKKYEA/WYYR2A/3FOHzZWtsJoMuH0hd8rIjUGEws5gEPDNMwNDpn/bcDgsX3NLZQve3l4DQQB+c9l4zd8pM1Q2sxHLLh4HBKen6p09I/6avT4/XttcDQSnf4i06OoZDiAYHsLx76Lb48Pv3t8HAPjBOUXISrSN+GvSqTGIkCy+OzsfJoOATRUt2HWkfURfy+cX8dv39gAArp3hwOTcpDBVqS2XTsrGmXlJ6O714cF/7xvx1/twTx0aXW6kxVl1c08PRZ+JoxIxsyAZvT4xLB2fZ9YfRE1bN3ISbfjJfJ6iGgkMIiSLrEQbLpscWEz6/GeHRvS1Xt14GLtrnIi3mfDzC6N30ZggCLj/iokwCIH1Nx+P4Ch9URTx9LrAWSzfneWAxcSmgLTr5nmFAIBXNlaNaF3a4eZOrAyeUfTrSycgxmIMW410cmx9SDa3fC2wwPK9r46ioqlzWF+jqrkLKz4ILBq76/yxSItT/oImJU3KTQw1ur95e/ewbzr+uKwBu2ucsFuMuDH49Yi06vwJmchNjkFLp2fYoyI+v4hf/OMruL1+zC1OxSU8UydiGERINpNyE7GgJB0+v4jHPiob8p/3+0X8/M2d6PL4MLswBTfMKZClTq1ZesFY5CbHoKatGw8HQ9pQ+P0i/vTfAwCA64Nbg4m0zGQ04KfBy+ie+rgcrp7eIX+NFz6rwKbKFsRajHjkm5Ojbh2akhhESFa/vGgcBAH491dHsb1qaPfPPPfpIWyqaIHdYsTvvzUlarbrno7dYsKKqyYBAF7ecDh0PPtgvbn1CHYeaYfdYsT3g4elEWndN8/MRVF6LFq7ekPTK4NVWufE74OdpXsum8AdZBHGIEKyGp+dgKumBc4V+eWbXw16/vazA014JLiP/zeXTkBeKhuGY509Jh0/CJ4t8ot/7ER5Q8eg/lxrpwcPB7+vdy4ai/T46J7qIv0wGQ24+6LAzrJn1h/C7prBLZJv7fTg1v/bAo/XjwUl6bh2pkPmSul4EQkibrcbU6dOhSAI2LFjRyQeSSrym0vHIy3OigMNHXh01emnaPbUtuMnr2yFXwwcjvadWWwYBvLzC0owPT8Zzh4vbnpxExpcp9666POL+Nlr29HS6cHYzDjcOI9TXaQvF56RhUsnZcPnF7H0jR3oOM0aqi6PFz98eSuqW7rhSInBH6+ZyikZBUQkiPzyl79ETg5PbYxWybGW0FTCC59X4MXPT34g187qNlz//CY4e7yYnp+MB66cyIbhJCwmA569fjryUuyobunGtc9sQHVL14Cf6/eL+N37e/HpgSbYzAb86dvTdHtrMUW3//f1M5AWZ8H++g78+G9b4fEOfPR7e1cvbn5xMzZVtiDeasJzN8xAMtdLKUL2luiDDz7ARx99hMcee0zuR5GKnT8hEz+/YCwA4Lfv7cVD/9kHt7dvmsbj9eP5zypw9TNfoqXTg8m5ifjrTTNhM3P73Kmkxlnx8i2zMCopBhVNnbj8yc/w7o4a+P19Nx+3dHpwx+s78GLwePxHvjkZ47N5uR3pU2qcFf+7eCZizEZ8eqAJ331uA2rauvt9zhcHm3D5k59hw6EWxFlNeOmWWbzwUUGCKNdd7QDq6+sxffp0vPPOO0hLS0NhYSG2b9+OqVOnDvj5brcbbrc79LHT6YTD4UB7ezsSEvhDonWiKOKRVWWh8ytSYi342ug0AMCGQ81ocAX+7heNz8Qfr52CBJtZ0Xq1pK69B7e8tDl0HXp+qh3T85LhE0Ws3dcAl9sLo0HAI9+cHLoLiEjP1u9vxJJXtsHl9sJkEPC1MWlIi7Nib60Te48G/p3kJsfg6e9N5826MnA6nUhMTBzU+7dsQUQURVxyySWYN28efvOb36CysvK0QeS3v/0t7r///hN+nUFEXz7cU4ff/msPjrb3X9OQEW/F7YvG4Dsz87hDZhg8Xj/+8kk5nv+0Aq7j5sbPyEnAvZdNwOyiVMXqI4q0w82d+OWbX2FjRUu/XzcbBXxnVh6Wnj8WSXZOx8hB1iCybNkyPPLII6f8nH379uGjjz7CG2+8gXXr1sFoNA4qiHBEJHp4fX58Wt6E8voOeHx+TM5NxMyCFE7FhEGXx4tPyhpxuLkLflHEVEcS5hSlMtxR1Np31InNlS1o6+pFQVoszipKQUY875CRk6xBpLGxEc3Nzaf8nKKiIlxzzTV47733+i009Pl8MBqNuO666/DSSy+d9llD+Q8hIiIidVDF1ExVVRWcTmfo49raWlx44YV48803MXv2bOTmnn6emkGEiIhIe4by/m2Sq4i8vLx+H8fFxQEAiouLBxVCiIiISP94kAAREREpRrYRkeMVFBRAxp3CREREpEEcESEiIiLFMIgQERGRYhhEiIiISDEMIkRERKQYBhEiIiJSDIMIERERKYZBhIiIiBTDIEJERESKYRAhIiIixUTsZNXhkE5iPfbyPCIiIlI36X17MCeqqzqIuFwuAIDD4VC6FCIiIhoil8uFxMTEU36OIKr4Ahi/34/a2lrEx8dDEISwfm2n0wmHw4Hq6urTXlFMw8fvc2Tw+xwZ/D5HBr/PkSPX91oURbhcLuTk5MBgOPUqEFWPiBgMBuTm5sr6jISEBP6gRwC/z5HB73Nk8PscGfw+R44c3+vTjYRIuFiViIiIFMMgQkRERIqJ2iBitVpx3333wWq1Kl2KrvH7HBn8PkcGv8+Rwe9z5Kjhe63qxapERESkb1E7IkJERETKYxAhIiIixTCIEBERkWIYRIiIiEgxURlEnnrqKRQUFMBms2H27NnYtGmT0iXpzooVKzBz5kzEx8cjIyMDV155JcrKypQuS9cefvhhCIKAO+64Q+lSdKmmpgbf+973kJqaipiYGEyaNAlbtmxRuixd8fl8uOeee1BYWIiYmBgUFxfjd7/73aDuK6GTW79+PS6//HLk5ORAEAS88847/X5fFEXce++9yM7ORkxMDBYtWoQDBw5ErL6oCyKvv/46li5divvuuw/btm3DlClTcOGFF6KhoUHp0nRl3bp1WLJkCTZs2IDVq1ejt7cXF1xwATo7O5UuTZc2b96MZ555BpMnT1a6FF1qbW3FvHnzYDab8cEHH2Dv3r34wx/+gOTkZKVL05VHHnkEK1euxJNPPol9+/bhkUcewaOPPoo///nPSpemaZ2dnZgyZQqeeuqpAX//0UcfxRNPPIGnn34aGzduRGxsLC688EL09PREpkAxysyaNUtcsmRJ6GOfzyfm5OSIK1asULQuvWtoaBABiOvWrVO6FN1xuVzimDFjxNWrV4vnnnuuePvttytdku7cfffd4te+9jWly9C9Sy+9VLz55pv7/dpVV10lXnfddYrVpDcAxLfffjv0sd/vF7OyssTf//73oV9ra2sTrVar+Pe//z0iNUXViIjH48HWrVuxaNGi0K8ZDAYsWrQIX375paK16V17ezsAICUlRelSdGfJkiW49NJL+/1cU3j961//wowZM3D11VcjIyMD06ZNw3PPPad0Wbozd+5crFmzBvv37wcA7Ny5E5999hkuvvhipUvTrYqKCtTV1fVrPxITEzF79uyIvS+q+tK7cGtqaoLP50NmZma/X8/MzERpaalidemd3+/HHXfcgXnz5mHixIlKl6Mrr732GrZt24bNmzcrXYquHTp0CCtXrsTSpUvxq1/9Cps3b8bPfvYzWCwWLF68WOnydGPZsmVwOp0YN24cjEYjfD4fHnzwQVx33XVKl6ZbdXV1QPB98FiZmZmh35NbVAURUsaSJUuwe/dufPbZZ0qXoivV1dW4/fbbsXr1athsNqXL0TW/348ZM2bgoYceAgBMmzYNu3fvxtNPP80gEkZvvPEGXnnlFbz66qs444wzsGPHDtxxxx3Iycnh91nHompqJi0tDUajEfX19f1+vb6+HllZWYrVpWe33XYb3n//fXz88cfIzc1Vuhxd2bp1KxoaGnDmmWfCZDLBZDJh3bp1eOKJJ2AymeDz+ZQuUTeys7MxYcKEfr82fvx4VFVVKVaTHv3iF7/AsmXL8O1vfxuTJk3C9ddfjzvvvBMrVqxQujTdkt77lHxfjKogYrFYMH36dKxZsyb0a36/H2vWrMGcOXMUrU1vRFHEbbfdhrfffhtr165FYWGh0iXpzsKFC7Fr1y7s2LEj9JoxYwauu+467NixA0ajUekSdWPevHknbD/fv38/8vPzFatJj7q6umAw9H9bMhqN8Pv9itWkd4WFhcjKyur3vuh0OrFx48aIvS9G3dTM0qVLsXjxYsyYMQOzZs3C448/js7OTtx0001Kl6YrS5Yswauvvop3330X8fHxobnGxMRExMTEKF2eLsTHx5+w5iY2NhapqalcixNmd955J+bOnYuHHnoI11xzDTZt2oRnn30Wzz77rNKl6crll1+OBx98EHl5eTjjjDOwfft2/PGPf8TNN9+sdGma1tHRgfLy8tDHFRUV2LFjB1JSUpCXl4c77rgDDzzwAMaMGYPCwkLcc889yMnJwZVXXhmZAiOyN0dl/vznP4t5eXmixWIRZ82aJW7YsEHpknQHwICvv/71r0qXpmvcviuf9957T5w4caJotVrFcePGic8++6zSJemO0+kUb7/9djEvL0+02WxiUVGR+Otf/1p0u91Kl6ZpH3/88YDt8eLFi0UxuIX3nnvuETMzM0Wr1SouXLhQLCsri1h9gsgj64iIiEghUbVGhIiIiNSFQYSIiIgUwyBCREREimEQISIiIsUwiBAREZFiGESIiIhIMQwiREREpBgGESIiIlIMgwgREREphkGEiIiIFMMgQkRERIphECEiIiLF/H8sQNR4eS6cIwAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 27 } ], "metadata": {