diff --git a/desc/coils.py b/desc/coils.py index 7faa805e53..d00024dfa3 100644 --- a/desc/coils.py +++ b/desc/coils.py @@ -949,6 +949,33 @@ def from_values(cls, current, coords, N=10, s=None, basis="xyz", name=""): name=name, ) + @classmethod + def from_simsopt(coil_simsopt, name=""): + """Load a simsopt coil as a FourierXYZCoil. + + Parameters + ---------- + coil_simsopt : simsopt.field.Coil + A simsopt coil + name : str + Name for this coil. + + Returns + ------- + coil : FourierXYZCoil + A FourierXYZCoil. + """ + current = coil_simsopt.current.get_value() + curve = FourierXYZCurve.from_simsopt(coil_simsopt.curve) + return FourierXYZCoil( + current=current, + X_n=curve.X_n, + Y_n=curve.Y_n, + Z_n=curve.Z_n, + modes=curve.X_basis.modes[:, 2], + name=name, + ) + class FourierPlanarCoil(_Coil, FourierPlanarCurve): """Coil that lies in a plane. diff --git a/desc/geometry/curve.py b/desc/geometry/curve.py index 01af58bb0b..44620919e1 100644 --- a/desc/geometry/curve.py +++ b/desc/geometry/curve.py @@ -631,6 +631,50 @@ def from_values(cls, coords, N=10, s=None, basis="xyz", name=""): X_n=X_n, Y_n=Y_n, Z_n=Z_n, modes=basis.modes[:, 2], name=name ) + @classmethod + def from_simsopt(curve_simsopt, name=""): + """Load a simsopt CurveXYZFourier as a FourierXYZCurve. + + Parameters + ---------- + coil_simsopt : simsopt.geo.CurveXYZFourier + A simsopt curve + name : str + Name for this curve. + + Returns + ------- + coil : FourierXYZCurve + A FourierXYZCurve. + """ + try: + from simsopt.geo import CurveXYZFourier + except ModuleNotFoundError: + raise ModuleNotFoundError( + "desc.geometry.from_simsopt requires simsopt package." + ) + if not isinstance(curve_simsopt, CurveXYZFourier): + raise AttributeError("The imput curve must be a Simsopt CurveXYZFourier") + dofs = curve_simsopt.get_dofs() + order = curve_simsopt.order + # [xc0, xs1, xc1, ....] + x = dofs[: 2 * order + 1] + y = dofs[2 * order + 1 : 4 * order + 2] + z = dofs[4 * order + 2 :] + + def convert_x(x): + xc = x[::2] + xs = x[1:][::2] + xn = np.concatenate((np.flip(xs), xc)) + return xn + + xn = convert_x(x) + yn = convert_x(y) + zn = convert_x(z) + modes = np.arange(-order, order + 1) + curve_desc = FourierXYZCurve(xn, yn, zn, modes=modes, name=name) + return curve_desc + def _get_ess_scale(self, alpha=1.2, order=np.inf, min_value=1e-7): """Create x_scale using exponential spectral scaling. diff --git a/desc/io/optimizable_io.py b/desc/io/optimizable_io.py index da0beebb43..e24b95c7b5 100644 --- a/desc/io/optimizable_io.py +++ b/desc/io/optimizable_io.py @@ -92,7 +92,7 @@ def _make_hashable(x): def _unmake_hashable(x): # turn tuple of ints and shape to ndarray - if isinstance(x, tuple) and x[0] == "ndarray": + if isinstance(x, tuple) and len(x) and x[0] == "ndarray": return np.array(x[2]).reshape(x[1]) if isinstance(x, list): return [_unmake_hashable(y) for y in x] diff --git a/desc/objectives/__init__.py b/desc/objectives/__init__.py index ad4fdc563a..5efcfdc5d0 100644 --- a/desc/objectives/__init__.py +++ b/desc/objectives/__init__.py @@ -55,6 +55,7 @@ ) from ._power_balance import FusionPower, HeatingPowerISS04 from ._profiles import Pressure, RotationalTransform, Shear, ToroidalCurrent +from ._quadcoil import QuadcoilProxy from ._stability import BallooningStability, MagneticWell, MercierStability from .getters import ( get_equilibrium_objective, diff --git a/desc/objectives/_quadcoil.py b/desc/objectives/_quadcoil.py new file mode 100644 index 0000000000..ffc1bcc7d3 --- /dev/null +++ b/desc/objectives/_quadcoil.py @@ -0,0 +1,882 @@ +import warnings + +from jax import jit + +from desc.backend import jnp +from desc.compute import get_profiles, get_transforms +from desc.grid import LinearGrid +from desc.objectives.normalization import compute_scaling_factors +from desc.objectives.objective_funs import _Objective, collect_docs +from desc.utils import Timer + +from ._quadcoil_utils import ( + _BCOIL_DATA_KEYS, + _BPLASMA_DATA_KEYS, + _compute_Bnormal, + _compute_Bnormal_ext, + _compute_Bnormal_plasma, + _compute_eval_data_coils, + _compute_G, + _create_source, + _ptolemy_identity_rev_compute, + _ptolemy_identity_rev_precompute, + _quadcoil_kwargs_to_field_kwargs, +) + +# ----- A QUADCOIL wrapper ----- +# A list of all inputs of quadoil.quadcoil +# that can be extracted from DESC. The +# rest cannot. These variables should not +# show up in quadcoil_kwargs. If they do, they will be ignored. +_DESC_DERIVED_ARGNAMES = [ + "nfp", + "stellsym", + "plasma_mpol", + "plasma_ntor", + "plasma_quadpoints_phi", + "plasma_quadpoints_theta", + "plasma_dofs", + "net_poloidal_current_amperes", + "Bnormal_plasma", + "metric_name", + "value_only", +] + +# A list of argnames that must be user-provided, +# but are considered differentiable by JAX. +# Variables here will be excluded when constructing +# nondiff_args, the non-differentiable argument of +# quadcoil.io.quadcoil_for_diff +_DIFF_USER_ARGNAMES = [ + "net_toroidal_current_amperes" + "plasma_coil_distance" + "objective_weight" + "constraint_value" +] + +_normalize_target_detail = ( + "Normalization options for a typical DESC Objective. Disabled by default. " + "When enabled, overrides the ``_unit`` in " + "``quadcoil_kwargs`` with scaling constants calculated from the parameteres " + "of the DESC equilibrium. Note that QUADCOIL usually works the best " + "when ``_unit`` are the same quantities measured from another " + "winding surface solution (either the solution of the same problem with " + "``_unit=1``, or the solution of a REGCOIL problem). This is " + "because coil metrics at a QUADCOIL optimum can differ by orders of " + "magnitudes from the DESC auto-calculated values. Setting " + "this to ``True`` may impact QUADCOIL's accuracy." +) + + +class QuadcoilProxy(_Objective): + """ + A QUADCOIL-based coil complexity proxy. + + Parameters + ---------- + eq : Equilibrium + Equilibrium that will be optimized to satisfy the Objective. + quadcoil_kwargs : dict + A dictionary containing all inputs for + ``quadcoil.quadcoil`` (see the [QUADCOIL documentation]( + https://quadcoil.readthedocs.io/en/latest/tutorial_outputs.html) + )). The following quantities are automatically extracted from DESC and + will be ignored: + .. code-block:: python + nfp, + stellsym, + plasma_mpol, plasma_ntor, + plasma_quadpoints_phi, plasma_quadpoints_theta, + plasma_dofs, + net_poloidal_current_amperes, + Bnormal_plasma, + metric_name, + value_only, + verbose, + plasma_M_theta : int, optional + The plasma poloidal quadrature resolution. Determines the + resolution of QUADCOIL plasma surface integrals and point-wise + functions. + Unlike the winding surface quadrature points, which is a required input, + the plasma surface quadpoints is evaluated from a linear grid to make + sure that the grid points in DESC B calculations line up exactly + with the QUADCOIL grids. + Values lower than eq.M_grid will trigger interpolation truncation + warnings. Default = eq.M_grid. + plasma_N_phi : int, optional + The plasma toroidal quadrature resolution. Default = eq.N_grid. + metric_name : str or tuple of str + The coil property(ies) to measure as the value of the proxy. + We strongly advise using the default value to ensure accurate adjoint + differentiation. Default = "f_obj", which uses the normalized QUADCOIL + objective. + metric_target : scalar or ndarray + In addition to target, bounds and weight, + The QUADCOIL proxy objective allows the user to set weights and + targets for each objective terms individually besides using ``target`` + and ``bounds`` that comes with other DESC objectives. + Targets of each property. Default = 0.0. + metric_weight : scalar or ndarray + Weights of each property. Default = 1.0. + vacuum : bool, optional + Whether to enable Bnormal contributions from plasma current. + Default = False. + verbose : int, optional + Whether to enable verbose output. Default = 0. + source_grid : Grid, optional + Grid for evaluating vacuum casing and the required net poloidal coil + current. Default = None, which uses a + ``LinearGrid(M=eq.M_grid, N=eq.N_grid)``. + field : list or CoilSet, optional + Other coils to use in combinations with the winding surface. + Can be optimized. For combined filament-dipole modeling/optimization. + Default = []. + field_grid : Grid, optional + The grid for ``field``. Default = None. + enable_net_current_plasma : bool, optional + Whether to enable a net poloidal current in the winding surface. + Default = True. + eq_fixed : bool, optional + Whether to fix ``eq``, or make it optimizable degrees of freedom. + Default = False for quasi-single-stage optimization. + field_fixed : bool, optional + Whether to fix ``field``, or make it optimizable degrees of freedom. + Default = False for quasi-single-stage dipole/PM optimization with known + filament coils. + B_plasma_chunk_size : int or None + Size to split singular integral computation for B_plasma into chunks. + If no chunking should be done or the chunk size is the full input + then supply ``None``. Default = ``bs_chunk_size``. + bs_chunk_size : int, optional + Size to split Biot-Savart computation into chunks of evaluation points. + Default = None. + """ + + # ----- Setting and registering keyword arguments ----- + _static_attrs = _Objective._static_attrs + [ + # External-coils related + "_enable_net_current_plasma", + "_eq_fixed", + "_field_fixed", + "_bs_chunk_size", + # Basics + "_deriv_mode", + "_verbose", + # Free-boundary-related + "_bplasma_chunk_size", + "_vacuum", + # QUADCOIL-related + "metric_name", + "nfp", + "stellsym", + "_plasma_M_theta", + "_plasma_N_phi", + "_quadcoil_for_diff", + "_quadcoil_values", + "_Bnormal_shape", + # VMEC <=> DESC + "_surf_R_A", + "_surf_R_c_indices", + "_surf_R_s_indices", + "_surf_Z_A", + "_surf_Z_c_indices", + "_surf_Z_s_indices", + ] + + # Most of the documentation is shared among all objectives, so we just + # inherit the docstring from the base class and add a few details specific + # to this objective. + # See the documentation of `collect_docs` for more details. + __doc__ = __doc__.rstrip() + collect_docs( + target_default="``target=0``.", + bounds_default="``bound=None``.", + normalize_target_detail=_normalize_target_detail, + ) + + _coordinates = "" # What coordinates is this objective a function of, with + # r=rho, t=theta, z=zeta? i.e. if only a profile, it is "r" , while if all + # 3 coordinates it is "rtz" + _units = "N/A" # units of the output + # string with python string formatting for printing the value + _print_value_fmt = "QUADCOIL subproblem: " + + def __init__( # noqa: C901 + self, + eq, + quadcoil_kwargs, + plasma_M_theta=None, + plasma_N_phi=None, + target=None, + bounds=None, + weight=1, + metric_name="f_obj", + metric_weight=1.0, + metric_target=0.0, + vacuum: bool = False, + normalize=False, + normalize_target=False, + verbose=0, + name="QUADCOIL Proxy", + source_grid=None, + # External coils - no external coils by default + field=None, + field_grid=None, + enable_net_current_plasma=True, + eq_fixed=False, # Whether the equilibrium are fixed + field_fixed=False, # Whether the external fields are fixed + # misc + B_plasma_chunk_size=None, + jac_chunk_size=None, + bs_chunk_size=None, + ): + # Importing QUADCOIL + try: + from quadcoil.io import gen_quadcoil_for_diff + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + + self._enable_net_current_plasma = enable_net_current_plasma + self._eq_fixed = eq_fixed + self._eq = eq + if field: # To be also tolerant on `False` and `None` as an input + self._field = [field] if not isinstance(field, list) else field + self._field_fixed = field_fixed + else: + self._field = [] + self._field_fixed = True + # Things initialization + things = [] + if not (self._eq_fixed or self._field_fixed): + warnings.warn( + "Both eq_fixed and field_fixed are True. things will be empty." + ) + if not self._eq_fixed: + things += [eq] + if not self._field_fixed: + things += [field] + + if not (enable_net_current_plasma or field): + warnings.warn( + "enable_net_current_plasma is false and field is empty. " + "The problem may be trivial." + ) + + if enable_net_current_plasma and field: + warnings.warn( + "There are both external coils and net current. " + "This is very uncommon (windowpane filaments + " + "winding surface with net current)." + ) + + quadcoil_kwargs = quadcoil_kwargs.copy() + if target is None and bounds is None: + target = 0 # default target value + # Uses LSE to smooth non-smooth problems rather than slack variables + # by default. + quadcoil_kwargs.setdefault("smoothing", "approx") + + # ----- Checking inputs ----- + # Checking whether all metrics have a weight and a target provided. + # By default, the metric is the quadcoil objective. This choice + # empirically has the most accurate adjoint gradients. + if isinstance(metric_name, str): + if (not jnp.isscalar(metric_target)) or (not jnp.isscalar(metric_weight)): + raise ValueError( + "When metric_name is a str, metric_target and " + "metric_target must both be scalar." + ) + # Makign them into iterables will make things easier when + # scaling in the end. + metric_name = (metric_name,) + metric_weight = jnp.array( + [ + metric_weight, + ] + ) + metric_target = jnp.array( + [ + metric_target, + ] + ) + elif isinstance(metric_name, tuple): + if len(metric_target) != len(metric_name): + raise KeyError( + "metric_name and metric_target have mismatching lengths!." + ) + if len(metric_weight) != len(metric_name): + raise KeyError( + "metric_name and metric_weight have mismatching lengths!." + ) + else: + raise ValueError("metric_name must be a tuple or a str.") + # Detect if the user has provided any arguments + # that will also-be extracted from DESC. + # If there are, these objectives will be discarded. + if normalize: + # When normalize is set to true, we + # use quantities from DESC to perform + # normalization instead. + overridden_argnames = _DESC_DERIVED_ARGNAMES + [ + "objective_unit", + "constraint_unit", + ] + else: + overridden_argnames = _DESC_DERIVED_ARGNAMES + redundant_arg_names = set(overridden_argnames) & quadcoil_kwargs.keys() + if redundant_arg_names: + warnings.warn( + f"Redundant arguments detected: {redundant_arg_names}. " + "These arguments are extracted from the equilibrium, " + "or specified by other parameters. The provided values " + "will be discarded." + ) + + # ----- Storing equilibrium-independent, differentiable variables ----- + # These are differentiable quantities that are not equilibrium-dependent. + # They can be user-provided, but they also all have default values, so + # we set them here. This is necessary because we are calling quadcoil + # through quadcoil.io.quadcoil_for_diff, which cannot see their default + # values in quadcoil.quadcoil. + self.net_toroidal_current_amperes = quadcoil_kwargs.pop( + "net_toroidal_current_amperes", 0.0 + ) + # A sign flip is necessary here since simsopt and DESC surfaces + # have different handedness. QUADCOIL uses the simsopt convention. + _plasma_coil_distance = quadcoil_kwargs.pop("plasma_coil_distance", None) + self.plasma_coil_distance = ( + -_plasma_coil_distance if _plasma_coil_distance is not None else None + ) + self.winding_dofs = quadcoil_kwargs.pop("winding_dofs", None) + self.objective_weight = quadcoil_kwargs.pop("objective_weight", None) + self.constraint_value = quadcoil_kwargs.pop("constraint_value", jnp.array([])) + + # ----- Setting attributes ----- + self.metric_name = metric_name + self.metric_target = metric_target + self.metric_weight = metric_weight + self._verbose = verbose + self._bplasma_chunk_size = B_plasma_chunk_size + self._bs_chunk_size = bs_chunk_size + self._vacuum = vacuum + if not plasma_M_theta: + plasma_M_theta = eq.M_grid + elif plasma_M_theta <= eq.M_grid: + warnings.warn( + f"plasma_M_theta = {plasma_M_theta} <= eq.M_grid = {eq.M_grid}. " + "An interpolation truncation warning may appear." + ) + if not plasma_N_phi: + plasma_N_phi = eq.N_grid + elif plasma_N_phi <= eq.N_grid: + warnings.warn( + f"plasma_N_phi = {plasma_N_phi} <= eq.N_grid = {eq.N_grid}. " + "An interpolation truncation warning may appear." + ) + self._plasma_M_theta = plasma_M_theta + self._plasma_N_phi = plasma_N_phi + self._constants = {} + # B_normal and G source grids + if source_grid is None: + self._constants["source_grid"] = LinearGrid( + M=eq.M_grid, + N=eq.N_grid, + # for axisymmetry we still need to know about toroidal effects, so its + # cheapest to pretend there are extra field periods + NFP=eq.NFP if eq.N > 0 else 64, + sym=False, + ) + else: + self._constants["source_grid"] = source_grid + self._constants["field_grid"] = field_grid + # These are differentiable quantities that are not equilibrium-dependent. + # They can be user-provided, but they also all have default values, so + # we set them here. This is necessary because we are calling quadcoil through + # quadcoil.io.quadcoil_for_diff, which cannot see their default value in + # quadcoil.quadcoil. + + # ----- Calculating DESC-derived, non-differentiable attrs ----- + # eval_grid is used to generate quadrature points. + # It is the same as "eval_grid" in desc.integrals.compute_B_plasma + # it is also used to calculate surface Bnormal_plasma + # when vacuum=False, along with surface_grid. + # because we the quadrature points must be calculated before generating + # quadcoil callable, it will be constructed here, instead of in the build(). + eval_grid = LinearGrid( + NFP=eq.NFP, + # If we set this to sym it will only evaluate + # theta from 0 to pi. + sym=False, + M=self._plasma_M_theta, # Poloidal grid resolution. + N=self._plasma_N_phi, + rho=1.0, + ) + eval_data_keys = [] + if self._field: + eval_data_keys = eval_data_keys + _BCOIL_DATA_KEYS + if not self._vacuum: + eval_data_keys = eval_data_keys + _BPLASMA_DATA_KEYS + eval_profiles = get_profiles(eval_data_keys, obj=eq, grid=eval_grid) + eval_transforms = get_transforms(eval_data_keys, obj=eq, grid=eval_grid) + self._constants["eval_grid"] = eval_grid + self._constants["eval_profiles"] = eval_profiles + self._constants["eval_transforms"] = eval_transforms + self.nfp = eq.NFP + self.stellsym = eq.sym + quadcoil_kwargs["metric_name"] = metric_name + quadcoil_kwargs["nfp"] = eq.NFP + quadcoil_kwargs["stellsym"] = eq.sym + quadcoil_kwargs["plasma_mpol"] = eq.surface.M + quadcoil_kwargs["plasma_ntor"] = eq.surface.N + quadcoil_kwargs["plasma_quadpoints_phi"] = ( + eval_grid.nodes[eval_grid.unique_zeta_idx, 2] / jnp.pi / 2 + ) + quadcoil_kwargs["plasma_quadpoints_theta"] = ( + eval_grid.nodes[eval_grid.unique_theta_idx, 1] / jnp.pi / 2 + ) + self._Bnormal_shape = ( + len(quadcoil_kwargs["plasma_quadpoints_phi"]), + len(quadcoil_kwargs["plasma_quadpoints_theta"]), + ) + # ----- Generating quadcoil partial and its jvp rule ----- + # quadcoil_kwargs is a mixture of static and traced arguments. + # Because we likely will not adjust quadcoil settings dynamically, + # here we treat all of them like staic using + # partial(quadcoil, **quadcoil_kwargs), implemented in gen_quadcoil_for_diff. + # The function also generates the custom_jvp rule based on the static arguments. + # We store the resulting function as a static attribute. + _quadcoil_values, _quadcoil_for_diff = gen_quadcoil_for_diff(**quadcoil_kwargs) + # Used later for Bnormal_plasma also + self._quadcoil_for_diff = jit(_quadcoil_for_diff) + self._quadcoil_values = jit(_quadcoil_values) + + # ----- Superclass ----- + super().__init__( + things=things, + target=target, + bounds=bounds, + weight=weight, + normalize=normalize, + normalize_target=normalize_target, + name=name, + jac_chunk_size=jac_chunk_size, + ) + + def build(self, use_jit=True, verbose=1): + """Build constant arrays. + + Parameters + ---------- + use_jit : bool, optional + Whether to just-in-time compile the objective and derivatives. + verbose : int, optional + Level of output. + + """ + # Importing QUADCOIL + try: + from quadcoil.io import generate_desc_scaling + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + + # ----- Starting and timing----- + # things is the list of things that will be optimized, + # we assigned things to be just eq in the init, so we know that the + # first (and only) element of things is the equilibrium + eq = self._eq + # dim_f = size of the output vector returned by self.compute. + # This is a scalar objective. + self._dim_f = 1 + # some helper code for profiling and logging + timer = Timer() + if verbose > 0: + print("Precomputing transforms") + timer.start("Precomputing transforms") + + # ----- Building the desc surf -> quadcoil (simsopt) surf map ----- + ( + self._surf_R_A, + self._surf_R_c_indices, + self._surf_R_s_indices, + ) = _ptolemy_identity_rev_precompute( + eq.surface.R_basis.modes[:, 1], eq.surface.R_basis.modes[:, 2] + ) + ( + self._surf_Z_A, + self._surf_Z_c_indices, + self._surf_Z_s_indices, + ) = _ptolemy_identity_rev_precompute( + eq.surface.Z_basis.modes[:, 1], eq.surface.Z_basis.modes[:, 2] + ) + + # ----- Building grids and transforms ----- + # source_grid for Bnormal_plasma, and eval_grid. + # Eval grid has a special role, in that it helps + # generate plasma_quadpoint_phi and theta. Therefore, + # it will be generated in init instead. + if self._enable_net_current_plasma: + net_poloidal_current_profiles = get_profiles( + ["G"], obj=eq, grid=self._constants["source_grid"] + ) + net_poloidal_current_transforms = get_transforms( + ["G"], obj=eq, grid=self._constants["source_grid"] + ) + # Storing transforms + # Attributes inside and outside _constants are not really treated + # differently, except that self._constants is traced. Because + # quadcoil_arg is a mixture of traced and static inputs, we want to + # individually register all the static inputs. Moreover, dicts are + # not hashable, so the static arguments in quadcoil_kwargs must all + # be stored as individual attributes. We might as well store + # everything in quadcoil_kwargs as individual attributes, + # and only store the transforms and profiles here in self._constants. + self._constants["net_poloidal_current_profiles"] = ( + net_poloidal_current_profiles + ) + self._constants["net_poloidal_current_transforms"] = ( + net_poloidal_current_transforms + ) + + # Mose DESC objectives are fields, so they + # hard-coded the superclass to ask for a weight + # to integrate the field over a quadrature... + + # source_grid will only be generated when self.vacuum == False. + # Here, eval_grid is not only used to define Bnormal_plasma, + # but also used to generate plasma_quadpoints_phi and theta. + # Therefore, it will be greated regardless self.vacuum == True. + if not self._vacuum: + ( + source_profiles, + source_transforms, + interpolator, + ) = _create_source( + eq=eq, + source_grid=self._constants["source_grid"], + eval_grid=self._constants["eval_grid"], + ) + self._constants["source_profiles"] = source_profiles + self._constants["source_transforms"] = source_transforms + self._constants["interpolator"] = interpolator + + if self._field: + from desc.magnetic_fields import SumMagneticField + + self._constants["sum_field"] = SumMagneticField(self._field) + + # ----- Precomputing quantities ----- + + # Now that all transforms are calculated, time to + # precompute quantities where applicable. + if self._eq_fixed: + # Plasma dofs + self._constants["plasma_dofs"] = self.compute_plasma_surface_dofs_simsopt( + eq.params_dict + ) + + # Net plasma current + if self._enable_net_current_plasma: + self._constants["G"] = _compute_G(eq.params_dict, self._constants) + + # B plasma + if not self._vacuum: + self._constants["Bnormal_plasma"] = _compute_Bnormal_plasma( + self._constants, eq.params_dict, self._bplasma_chunk_size + ) + + # Part of external field + if self._field: + coils_x, coils_n_rho = _compute_eval_data_coils( + self._constants, eq.params_dict + ) + self._constants["coils_x"] = coils_x + self._constants["coils_n_rho"] = coils_n_rho + if self._field_fixed: + self._constants["Bnormal_ext"] = _compute_Bnormal_ext( + self._constants, + self._constants["sum_field"].params_dict, + self._bs_chunk_size, + ) + + # ----- Normalization scales ----- + # We try to normalize things to order(1) by dividing things by some + # characteristic scale for a given quantity. + # See ``desc.objectives.compute_scaling_factors`` for examples. + # The unit for each objective is implemented as the attribute ``desc_unit`` + # of the corresponding function. These attributes are lambda functions + # that act on self.scales and returns a number. Example: + # K.desc_unit = lambda scales: scales["B"] / mu_0 # noqa: E800 + if self._normalize: + self.scales = compute_scaling_factors(eq) + obj_unit_new, cons_unit_new = generate_desc_scaling( + self.objective_name, self.constraint_name, self.scales + ) + self.objective_unit = obj_unit_new + self.constraint_unit = cons_unit_new + + # ----- Wrapping up and timing ----- + timer.stop("Precomputing transforms") + if verbose > 1: + timer.disp("Precomputing transforms") + # finally, call ``super.build()`` + super().build(use_jit=use_jit, verbose=verbose) + + def compute(self, *all_params, constants=None): + """Computes the scalar value of the QUADCOIL proxy. + + Computes the scalar value of the QUADCOIL proxy. A wrapper for + ``solve_quadcoil``. + + Parameters + ---------- + *all_params : dict + Dictionaries of equilibrium/coils degrees of freedom, depending on + ``eq_fixed`` and ``field_fixed``. + constants : dict + (Dummy for now) Dictionary of constant data, eg transforms, + profiles etc. Defaults to self.constants + + Returns + ------- + The scalar quadcoil proxy. + + """ + # We prohibit the user from providing constants + return self.solve_quadcoil(*all_params, full_mode=False) + + def solve_quadcoil(self, *all_params, full_mode=True): + """Calls QUADCOIL. + + Takes the same parameters as compute, but can either output the + full quadcoil results, or do what compute() is supposed to do. + compute() is a wrapper for solve_quadcoil. + + Parameters + ---------- + *all_params : dict + Dictionaries of equilibrium/coils degrees of freedom, depending on + ``eq_fixed`` and ``field_fixed``. + constants : dict + Dictionary of constant data, eg transforms, + profiles etc. Defaults to self.constants + full_mode : bool + When ``True``, returns the QUADCOIL standard outputs (see the + [QUADCOIL documentation]( + https://quadcoil.readthedocs.io/en/latest/tutorial_outputs.html) + ). When ``False``, returns the scalar QUADCOIL proxy. + + Returns + ------- + f : scalar + + """ + # Importing QUADCOIL + try: + from quadcoil import get_quantity + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + + # Loading constants + constants = self._constants + + # Load fixed params + if self._eq_fixed: + params_eq = self._eq.params_dict + params_field = all_params + else: + params_eq = all_params[0] + if self._field: + if self._field_fixed: + params_field = constants["sum_field"].params_dict + else: + params_field = all_params[1:] + else: + params_field = {} + + # ----- Quantities with pre-computation ----- + + # Plasma dofs + if self._eq_fixed: + plasma_dofs = constants["plasma_dofs"] + else: + plasma_dofs = self.compute_plasma_surface_dofs_simsopt(params_eq) + + Bnormal = _compute_Bnormal( + field=self._field, + constants=constants, + Bnormal_shape=self._Bnormal_shape, + vacuum=self._vacuum, + eq_fixed=self._eq_fixed, + field_fixed=self._field_fixed, + params_eq=params_eq, + params_field=params_field, + bs_chunk_size=self._bs_chunk_size, + bplasma_chunk_size=self._bplasma_chunk_size, + ) + + # ----- Calling the net poloidal current ----- + if self._enable_net_current_plasma: + if self._eq_fixed: + net_poloidal_current_amperes = constants["G"] + else: + net_poloidal_current_amperes = _compute_G(params_eq, constants) + else: + net_poloidal_current_amperes = 0.0 + + # ----- Calling the quadcoil wrapper with custom_vjp ----- + if full_mode: + out_dict, qp, cp_mn, solve_results = self._quadcoil_values( + plasma_dofs=plasma_dofs, + net_poloidal_current_amperes=net_poloidal_current_amperes, + net_toroidal_current_amperes=self.net_toroidal_current_amperes, + Bnormal_plasma=Bnormal, # Because DESC plasma surface is flipped. + plasma_coil_distance=self.plasma_coil_distance, + winding_dofs=self.winding_dofs, + objective_weight=self.objective_weight, + constraint_value=self.constraint_value, + ) + return out_dict, qp, cp_mn, solve_results + # ----- Calling the quadcoil wrapper with custom_vjp ----- + # If this can't show then the error is before this + metric_dict = self._quadcoil_for_diff( + plasma_dofs=plasma_dofs, + net_poloidal_current_amperes=net_poloidal_current_amperes, + net_toroidal_current_amperes=self.net_toroidal_current_amperes, + Bnormal_plasma=Bnormal, + plasma_coil_distance=self.plasma_coil_distance, + winding_dofs=self.winding_dofs, + objective_weight=self.objective_weight, + constraint_value=self.constraint_value, + ) + + # ----- Thresholding and weighing ----- + f_out = 0.0 + for i in range(len(self.metric_name)): + # Set during the loop through quadcoil_kwargs + f_name = self.metric_name[i] + f_weight = self.metric_weight[i] + f_target_eff = self.metric_target[i] + f_val_eff = metric_dict[f_name] + # MEY NOT BE LOWERABLE? + if self._normalize or self._normalize_target: + f_unit = get_quantity(f_name + "_desc_unit")(self.scales) + if self._normalize: + f_val_eff = f_val_eff / f_unit + if self._normalize_target: + f_target_eff = f_target_eff / f_unit + f_out = f_out + f_weight * jnp.where( + f_val_eff > f_target_eff, f_val_eff - f_target_eff, 0.0 + ) + + return f_out + + def compute_plasma_surface_dofs_simsopt(self, params_eq): + """Computes the plasma surface dofs in the Simsopt convention. + + Computes the plasma surface dofs in the Simsopt convention. + + Parameters + ---------- + *all_params : dict + Dictionaries of equilibrium/coils degrees of freedom, depending on + ``eq_fixed`` and ``field_fixed``. + + Returns + ------- + plasma_dofs : ndarray + The plasma surface dofs in the Simsopt SurfaceRZFourier convention. + """ + rs_raw, rc_raw = _ptolemy_identity_rev_compute( + self._surf_R_A, + self._surf_R_c_indices, + self._surf_R_s_indices, + params_eq["Rb_lmn"], + ) + zs_raw, zc_raw = _ptolemy_identity_rev_compute( + self._surf_Z_A, + self._surf_Z_c_indices, + self._surf_Z_s_indices, + params_eq["Zb_lmn"], + ) + # Stellsym SurfaceRZFourier dofs consists of + # [rc, zs] # noqa: E800 + # Non-stellsym SurfaceRZFourier dofs consists of + # [rc, rs, zc, zs] # noqa: E800 + # Because rs, zs from ptolemy_identity_rev shares the same m, n + # arrays as rc, zc, they both have a zero as the first element + # that need to be removed. + rc = rc_raw.flatten() + rs = rs_raw.flatten()[1:] + zc = zc_raw.flatten() + zs = zs_raw.flatten()[1:] + if self.stellsym: + plasma_dofs = jnp.concatenate([rc, zs]) + else: + plasma_dofs = jnp.concatenate([rc, rs, zc, zs]) + return plasma_dofs + + def solve_quadcoil_surface_current(self, *all_params): + """Calls QUADCOIL and returns the solution as a FourierCurrentPotentialField. + + Calls QUADCOIL and returns the solution as a FourierCurrentPotentialField. + For use with DESC's built-in REGCOIL and coil-cutting features. + + Parameters + ---------- + params_eq : dict + Dictionary of equilibrium degrees of freedom, eg + Equilibrium.params_dict. + + Returns + ------- + A FourierCurrentPotentialField containing the QUADCOIL solution. + """ + # Prevents circular import + from desc.magnetic_fields import FourierCurrentPotentialField + + _, quadcoil_qp, quadcoil_dofs, _ = self.solve_quadcoil( + *all_params, full_mode=True + ) + quadcoil_kwargs_temp = { + "winding_stellsym": quadcoil_qp.winding_surface.stellsym, + "winding_mpol": quadcoil_qp.winding_surface.mpol, + "winding_ntor": quadcoil_qp.winding_surface.ntor, + "stellsym": quadcoil_qp.stellsym, + "mpol": quadcoil_qp.mpol, + "ntor": quadcoil_qp.ntor, + "net_poloidal_current_amperes": quadcoil_qp.net_poloidal_current_amperes, + "net_toroidal_current_amperes": quadcoil_qp.net_toroidal_current_amperes, + } + # This helper function converts information in a quadcoil object into + # a kwargs for DESC FourierCurrentPotentialField. + filtered = _quadcoil_kwargs_to_field_kwargs( + quadcoil_kwargs_temp, + quadcoil_dofs, + self._eq.sym, + FourierCurrentPotentialField, + self._verbose, + ) + winding_surface = quadcoil_qp.winding_surface.to_desc() + R_lmn = winding_surface.R_lmn + Z_lmn = winding_surface.Z_lmn + modes_R = winding_surface._R_basis.modes[:, 1:] + modes_Z = winding_surface._Z_basis.modes[:, 1:] + return FourierCurrentPotentialField( + # Phi_mn is already in filtered + # modes_Phi is already in filtered + # I is already in filtered + # G is already in filtered + # sym_Phi is already in filtered + # M_Phi is already in filtered + # N_Phi is already in filtered + R_lmn=R_lmn, + Z_lmn=Z_lmn, + modes_R=modes_R, + modes_Z=modes_Z, + NFP=self.nfp, + sym=self._eq.sym, # Symmetry of the plasma + # M is already in filtered + # N is already in filtered + name="QUADCOIL Proxy Output", + check_orientation=True, + **filtered, + ) diff --git a/desc/objectives/_quadcoil_utils.py b/desc/objectives/_quadcoil_utils.py new file mode 100644 index 0000000000..655ff83dde --- /dev/null +++ b/desc/objectives/_quadcoil_utils.py @@ -0,0 +1,437 @@ +import inspect +from functools import partial + +import numpy as np +from jax import jit +from scipy.constants import mu_0 + +from desc.backend import jnp +from desc.compute import get_profiles, get_transforms +from desc.compute.utils import _compute as compute_fun +from desc.integrals import DFTInterpolator, FFTInterpolator, virtual_casing_biot_savart +from desc.utils import warnif +from desc.vmec_utils import ptolemy_identity_fwd, ptolemy_linear_transform + +# Used in create_source_grid only +from ..integrals.singularities import best_params, best_ratio + +# Data keys needed to calculate Bnormal_plasma. +_BPLASMA_DATA_KEYS = [ + "K_vc", + "B", + "R", + "phi", + "Z", + "e^rho", + "n_rho", + "|e_theta x e_zeta|", +] +# Data keys needed to calculate Bnormal from external coils. +_BCOIL_DATA_KEYS = ["R", "Z", "n_rho", "phi", "|e_theta x e_zeta|"] + + +# ----- Helper functions ----- +def _compute_Bnormal_plasma(constants, params_eq, _bplasma_chunk_size): + # Using the stored transforms to calculate B_normal_plasma + source_data = compute_fun( + "desc.equilibrium.equilibrium.Equilibrium", + _BPLASMA_DATA_KEYS, + params=params_eq, + transforms=constants["source_transforms"], + profiles=constants["source_profiles"], + ) + eval_data = compute_fun( + "desc.equilibrium.equilibrium.Equilibrium", + _BPLASMA_DATA_KEYS, + params=params_eq, + transforms=constants["eval_transforms"], + profiles=constants["eval_profiles"], + ) + Bplasma = virtual_casing_biot_savart( + eval_data, + source_data, + constants["interpolator"], + chunk_size=_bplasma_chunk_size, + ) + # need extra factor of B/2 bc we're evaluating on plasma surface + Bplasma = Bplasma + eval_data["B"] / 2 + Bnormal_plasma = jnp.sum(Bplasma * eval_data["n_rho"], axis=1) + return Bnormal_plasma + + +def _compute_eval_data_coils(constants, params_eq): + eval_data_coils = compute_fun( + "desc.equilibrium.equilibrium.Equilibrium", + _BCOIL_DATA_KEYS, + params=params_eq, + transforms=constants["eval_transforms"], + profiles=constants["eval_profiles"], + ) + coils_x = jnp.array( + [eval_data_coils["R"], eval_data_coils["phi"], eval_data_coils["Z"]] + ).T + coils_n_rho = eval_data_coils["n_rho"] + return coils_x, coils_n_rho + + +def _compute_Bnormal_ext(constants, params_field, _bs_chunk_size): + # Computes the magnetic field from a coilset using magnetic field parameters. + coils_nrho = constants["coils_n_rho"] + coils_x = constants["coils_x"] + B_ext = constants["sum_field"].compute_magnetic_field( + coils_x, + source_grid=constants["field_grid"], + basis="rpz", + params=params_field, + chunk_size=_bs_chunk_size, + ) + B_ext = jnp.sum(B_ext * coils_nrho, axis=-1) + return B_ext + + +def _compute_G(params_eq, constants): + # Computes the net poloidal current G using equilibrium parameters. + G_data = compute_fun( + "desc.equilibrium.equilibrium.Equilibrium", + ["G"], + params=params_eq, + transforms=constants["net_poloidal_current_transforms"], + profiles=constants["net_poloidal_current_profiles"], + ) + net_poloidal_current_amperes = -G_data["G"][0] / mu_0 * 2 * jnp.pi + return net_poloidal_current_amperes + + +def _ptolemy_identity_rev_precompute(m_1, n_1): + """First half of ``ptolemy_identity_rev``. + + We have split ``ptolemy_identity_rev`` into two parts: + ``ptolemy_identity_rev_precompute`` and + ``ptolemy_identity_rev_compute``. The original ``ptolemy_identity_rev`` + relies on numpy boolean indexing. Even when we set m_1, n_1 to static, + they will still be converted to traced arrays once jit happens, and the + numpy boolean indexing will break. Because of that, we perform all numpy + operations in ``ptolemy_identity_rev_precompute`` during ``build()``, + store the results as static, and then perform all jaxable operations in + ``ptolemy_identity_rev_compute`` during ``compute()``. + + .. code-block:: python + + desc_to_vmec_surf_R = ptolemy_identity_rev_jit_precomputation( + tuple(eq.surface.R_basis.modes[:,1]), + tuple(eq.surface.R_basis.modes[:,2]) + ) + desc_to_vmec_surf_Z = ptolemy_identity_rev_jit_precomputation( + tuple(eq.surface.Z_basis.modes[:,1]), + tuple(eq.surface.Z_basis.modes[:,2]) + ) + rs_raw, rc_raw = desc_to_vmec_surf_R(eq.surface.R_lmn) + # Stellsym SurfaceRZFourier's dofs consists of + zs_raw, zc_raw = desc_to_vmec_surf_Z(eq.surface.Z_lmn) + # [rc, zs] # noqa: E800 + # Non-stellsym SurfaceRZFourier's dofs consists of + # [rc, rs, zc, zs] # noqa: E800 + # Because rs, zs from ptolemy_identity_rev shares the same m, n + # arrays as rc, zc, they both have a zero as the first element + # that need to be removed. + rc = rc_raw.flatten() + rs = rs_raw.flatten()[1:] + zc = zc_raw.flatten() + zs = zs_raw.flatten()[1:] + if eq.sym: + dofs = jnp.concatenate([rc, zs]) + else: + dofs = jnp.concatenate([rc, rs, zc, zs]) + + Converts from a double Fourier series of the form: + ss * sin(m𝛉) * sin(nπ›Ÿ) + sc * sin(m𝛉) * cos(nπ›Ÿ) + + cs * cos(m𝛉) * sin(nπ›Ÿ) + cc * cos(m𝛉) * cos(nπ›Ÿ) + to the double-angle form: + s * sin(m𝛉-nπ›Ÿ) + c * cos(m𝛉-nπ›Ÿ) + using Ptolemy's sum and difference formulas. + + Parameters + ---------- + m_1 : ndarray, shape(num_modes,) + n_1 : ndarray, shape(num_modes,) + ``R_basis_modes[:,1], R_basis_modes[:,2]`` + or ``Z_basis_modes[:,1], Z_basis_modes[:,2]`` + + Returns + ------- + A, c_indices, s_indices : tuples + .. code-block:: python + + # For calculating rs_raw, rc_raw, + x = np.atleast_2d(desc_surf.R_lmn) + y = (A @ x.T).T + rs_raw, rc_raw = _modes_x_to_mnsc(vmec_modes, y) + + """ + # Precomputing linear operators + m_1, n_1 = map(np.atleast_1d, (m_1, n_1)) + desc_modes = np.vstack([np.zeros_like(m_1), m_1, n_1]).T + A, vmec_modes = ptolemy_linear_transform(desc_modes) + cmask = vmec_modes[:, 0] == 1 + smask = vmec_modes[:, 0] == -1 + c_indices = np.where(cmask)[0] + s_indices = np.where(smask)[0] + # A is 2d, and this converts 2d arr to tuple. + A = tuple(map(tuple, A.tolist())) + c_indices = tuple(c_indices.tolist()) + s_indices = tuple(s_indices.tolist()) + return A, c_indices, s_indices + + +@partial( + jit, + static_argnames=[ + "A", + "c_indices", + "s_indices", + ], +) +def _ptolemy_identity_rev_compute(A, c_indices, s_indices, x): + # Second half of ptolemy_identity_rev + A = jnp.array(A) + y = (A @ x.T).T + if len(c_indices): + c = (y.T[jnp.array(c_indices)]).T + if len(s_indices): + s = (y.T[jnp.array(s_indices)]).T + # if there are sin terms, add a zero for the m=n=0 mode + s = jnp.concatenate([jnp.zeros_like(s.T[:1]), s.T]).T + + if not len(s_indices): + s = jnp.zeros_like(c) + if not len(c_indices): + c = jnp.zeros_like(s) + assert len(s.T) == len(c.T) + return s, c + + +# For interpolating quadpoints_theta and quadpoints_phi +def _interpolate_array(x, k: int, period): + x_roll = jnp.append(x, period + x[0]) + # differences between adjacent values + dx = jnp.diff(x_roll) + # interpolation weights: 0, 1/k, 2/k, ..., (k-1)/k + w = jnp.linspace(0, 1, k, endpoint=False) + # broadcast and add + blocks = x[:, None] + dx[:, None] * w[None, :] + # flatten and append the last element + return blocks.ravel() + + +def _compute_Bnormal( + field, + constants, + Bnormal_shape, + vacuum, + eq_fixed, + field_fixed, + params_eq, + params_field, + bs_chunk_size, + bplasma_chunk_size, +): + + Bnormal = jnp.zeros(Bnormal_shape) + + if field: + if eq_fixed: + if field_fixed: + Bnormal += constants["Bnormal_ext"].reshape( + Bnormal.shape + ) # eq and field fixed + else: + Bnormal += _compute_Bnormal_ext( + constants, params_field, bs_chunk_size + ).reshape( + Bnormal.shape + ) # neither fixed, field fixed only. + else: + coils_x, coils_n_rho = _compute_eval_data_coils(constants, params_eq) + constants["coils_x"] = coils_x + constants["coils_n_rho"] = coils_n_rho + Bnormal += _compute_Bnormal_ext( + constants, params_field, bs_chunk_size + ).reshape( + Bnormal.shape + ) # neither fixed, field fixed only. + + # Plasma fields + if not vacuum: + if eq_fixed: + Bnormal += constants["Bnormal_plasma"].reshape(Bnormal.shape) + else: + Bnormal += _compute_Bnormal_plasma( + constants, params_eq, bplasma_chunk_size + ).reshape(Bnormal.shape) + + return Bnormal + + +# Flipping the current potential of a quadcoil +# phi Fourier array in the toroidal direction +def _toroidal_flip(phi, m, n): + m = np.array(m) + n = np.array(n) + phi_swapped = np.array(phi) + index_map = {(mi, ni): i for i, (mi, ni) in enumerate(zip(m, n))} + for i, (mi, ni) in enumerate(zip(m, n)): + # skip n=0 (it’s its own opposite) + if ni == 0: + continue + if mi != 0: + j = index_map.get((mi, -ni)) + if j is not None: + phi_swapped[i] = phi[j] + else: + phi_swapped[i] = -phi[i] + return phi_swapped + + +def _quadcoil_phi_to_desc_phi(phi_mn_quadcoil, stellsym, mpol, ntor): + # Importing QUADCOIL + try: + from quadcoil import make_rzfourier_mc_ms_nc_ns + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + + # Converts quadcoil phi to desc phi. + if stellsym: + # The dofs contain rc, zs, and rc has one more element than zs. + phis = phi_mn_quadcoil + phic = jnp.zeros(len(phis) + 1) + else: + # The dofs contain rc, zs, and rc has one more element than zs. + len_sin = len(phi_mn_quadcoil) // 2 + phis = phi_mn_quadcoil[-len_sin:] + phic = phi_mn_quadcoil[:-len_sin] + + phis = jnp.insert(phis, 0, 0.0) + mc, _, nc, _ = make_rzfourier_mc_ms_nc_ns(mpol, ntor) + modes_M, modes_N, Phi_mn = ptolemy_identity_fwd(mc, nc, phis, phic) + Phi_mn = Phi_mn.flatten() + return Phi_mn, modes_M, modes_N + + +def _create_source(eq, source_grid, eval_grid): + # Creating interpolator for Bnormal_plasma + ratio_data = eq.compute( + ["|e_theta x e_zeta|", "e_theta", "e_zeta"], grid=source_grid + ) + st, sz, q = best_params(source_grid, best_ratio(ratio_data)) + try: + interpolator = FFTInterpolator(eval_grid, source_grid, st, sz, q) + except AssertionError as e: + warnif( + True, + msg="Could not build fft interpolator, switching to dft which is slow." + "\nReason: " + str(e), + ) + interpolator = DFTInterpolator(eval_grid, source_grid, st, sz, q) + # Creating source grids + source_profiles = get_profiles(_BPLASMA_DATA_KEYS, obj=eq, grid=source_grid) + source_transforms = get_transforms(_BPLASMA_DATA_KEYS, obj=eq, grid=source_grid) + return (source_profiles, source_transforms, interpolator) + + +def _quadcoil_kwargs_to_field_kwargs( # noqa: C901 + quadcoil_kwargs, quadcoil_dofs, sym_default, target_type, verbose, flip_phi=False +): + # Importing QUADCOIL + try: + from quadcoil import QuadcoilParams + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + # Converts a kwargs for quadcoil into a kwargs for QuadcoilField or + # FourierCurrentPotentialField + filtered = {} + source_kwargs = quadcoil_kwargs.copy() + winding_stellsym = source_kwargs.get("winding_stellsym", sym_default) + + # Importing QUADCOIL + try: + from quadcoil import SurfaceRZFourierJAX + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + + # Reading winding surface information. + if "winding_dofs" in source_kwargs.keys(): + winding_dofs = source_kwargs.pop("winding_dofs") + quadcoil_winding_surface = SurfaceRZFourierJAX( + nfp=source_kwargs["nfp"], + stellsym=winding_stellsym, + mpol=source_kwargs["winding_mpol"], + ntor=source_kwargs["winding_ntor"], + quadpoints_phi=source_kwargs["winding_quadpoints_phi"], + quadpoints_theta=source_kwargs["winding_quadpoints_theta"], + dofs=winding_dofs, + ) + filtered["winding_surface"] = quadcoil_winding_surface.to_desc() + + stellsym = source_kwargs.get("stellsym", sym_default and winding_stellsym) + if stellsym: + filtered["sym_Phi"] = "sin" + else: + filtered["sym_Phi"] = False + filtered["smoothing"] = "approx" + filtered["smoothing_params"] = {"lse_epsilon": 1e-3} + # Initialize using a Quadcoil initial guess + if quadcoil_dofs is not None: + try: + aux_dofs_vals = quadcoil_dofs.copy() + phi_pre_flip = aux_dofs_vals.pop("phi") + mpol = quadcoil_kwargs["mpol"] + ntor = quadcoil_kwargs["ntor"] + # TODO: This seems necessary when loading some winding surfaces + # from simsopt, but not necessary if the winding surface is + # auto-generated. Make this more robust later. + if flip_phi: + m, n = QuadcoilParams.make_mn_helper(mpol, ntor, stellsym) + phi_flipped = _toroidal_flip(phi_pre_flip, m, n) + else: + phi_flipped = phi_pre_flip + Phi_mn, modes_M, modes_N = _quadcoil_phi_to_desc_phi( + phi_mn_quadcoil=phi_flipped, stellsym=stellsym, mpol=mpol, ntor=ntor + ) + modes_Phi = np.stack((modes_M, modes_N)).T.astype(np.int32) + filtered["aux_dofs_vals"] = aux_dofs_vals + filtered["Phi_mn"] = Phi_mn + filtered["modes_Phi"] = modes_Phi + + except KeyError: + raise KeyError( + "When an initial guess is provided via quadcoil_dofs, " + "mpol and ntor (mode numbers of the current potential) " + "must also be provided." + ) + + # Renaming arguments (quadcoil and FourierCurrentPotential + # have some different naming conventions) + rename_map = { + "winding_mpol": "M", + "winding_ntor": "N", + "mpol": "M_Phi", + "ntor": "N_Phi", + "net_poloidal_current_amperes": "G", + "net_toroidal_current_amperes": "I", + } + + # Rename keys as needed + source_kwargs = {rename_map.get(k, k): v for k, v in source_kwargs.items()} + + # Filter only parameters accepted by target_func + target_params = inspect.signature(target_type).parameters + filtered = filtered | source_kwargs + filtered = {k: v for k, v in filtered.items() if k in target_params.keys()} + discarded_kwargs = [k for k, v in filtered.items() if k not in target_params.keys()] + if discarded_kwargs and verbose > 1: + print( + "The following items in quadcoil_kwargs will be ignored " + "because they will be automatically calculated by or has alternative " + "definitions in " + str(target_type) + ": " + str(discarded_kwargs) + ) + return filtered diff --git a/desc/objectives/objective_funs.py b/desc/objectives/objective_funs.py index 8c3638d571..dccc07038f 100644 --- a/desc/objectives/objective_funs.py +++ b/desc/objectives/objective_funs.py @@ -270,6 +270,7 @@ class ObjectiveFunction(IOAble): "_use_jit", ] _static_attrs = [ + "_static_attrs", # A bug as of Oct 10 2025 "_built", "_compile_mode", "_compiled", @@ -1254,11 +1255,12 @@ def build(self, use_jit=True, verbose=1): # set quadrature weights if they haven't been if hasattr(self, "_constants") and ("quad_weights" not in self._constants): - grid = self._constants["transforms"]["grid"] if self._coordinates == "rtz": + grid = self._constants["transforms"]["grid"] w = grid.weights w *= jnp.sqrt(grid.num_nodes) elif self._coordinates == "r": + grid = self._constants["transforms"]["grid"] w = grid.compress(grid.spacing[:, 0], surface_label="rho") w = jnp.sqrt(w) else: diff --git a/desc/plotting.py b/desc/plotting.py index e48f675073..5dde34da9d 100644 --- a/desc/plotting.py +++ b/desc/plotting.py @@ -974,6 +974,7 @@ def plot_2d( # noqa : C901 else: im = ax.contourf(xx, yy, data, **contourf_kwargs) cax = divider.append_axes("right", **cax_kwargs) + _set_tight_layout(fig) cbar = fig.colorbar(im, cax=cax) cbar.update_ticks() xlabel = _AXIS_LABELS_RTZ[plot_axes[1]] @@ -989,7 +990,6 @@ def plot_2d( # noqa : C901 "$" + data_index[parameterization][normalize]["label"] + "$", ) ) - _set_tight_layout(fig) plot_data = { xlabel.strip("$").strip("\\"): xx, ylabel.strip("$").strip("\\"): yy, diff --git a/devtools/dev-requirements.txt b/devtools/dev-requirements.txt index 65178490b8..3718ca208d 100644 --- a/devtools/dev-requirements.txt +++ b/devtools/dev-requirements.txt @@ -37,6 +37,7 @@ pytest-split >= 0.8.2, <= 0.11.0 qicna @ git+https://github.com/rogeriojorge/pyQIC/ qsc <= 0.1.3 shapely >= 1.8.2, <= 2.1.2 +quadcoil >= 0.1.0 # building build diff --git a/docs/api_objectives.rst b/docs/api_objectives.rst index 687db8fbd6..d7633e03e9 100644 --- a/docs/api_objectives.rst +++ b/docs/api_objectives.rst @@ -133,6 +133,7 @@ Coil Optimization desc.objectives.ToroidalFlux desc.objectives.SurfaceCurrentRegularization desc.objectives.LinkingCurrentConsistency + desc.objectives.QuadcoilProxy Profiles diff --git a/docs/index.rst b/docs/index.rst index d648ae5be4..2b89c9f908 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -44,6 +44,7 @@ notebooks/tutorials/basic_optimization.ipynb notebooks/tutorials/advanced_optimization.ipynb notebooks/tutorials/coil_optimization_REGCOIL.ipynb + notebooks/tutorials/coil_optimization_QUADCOIL.ipynb notebooks/tutorials/omnigenity.ipynb notebooks/tutorials/bootstrap_current.ipynb notebooks/tutorials/coil_stage_two_optimization.ipynb diff --git a/docs/notebooks/tutorials/coil_optimization_QUADCOIL.ipynb b/docs/notebooks/tutorials/coil_optimization_QUADCOIL.ipynb new file mode 100644 index 0000000000..64744ddba5 --- /dev/null +++ b/docs/notebooks/tutorials/coil_optimization_QUADCOIL.ipynb @@ -0,0 +1,1753 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1d92f237", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# QUADCOIL coil and equilibrium optimization\n", + "\n", + "## What is QUADCOIL\n", + "QUADCOIL [1] is a new differentiable winding surface code. Unlike REGCOIL, QUADCOIL can solve a general QCQP:\n", + "\n", + "$$\\min f(\\Phi_{sv})$$\n", + "$$g_i(\\Phi_{sv})\\leq 0$$\n", + "$$h_j(\\Phi_{sv}) =0 $$\n", + "\n", + "where $f$, $g_i$, and $h_j$ can be any quadratic functions. It also includes a winding surface generator that automatically removes self-intersections. QUADCOIL is a standalone code built on the same numerical tools as DESC. To use the QUADCOIL integrations, please first [install QUADCOIL here](https://quadcoil.readthedocs.io/en/latest/index.html).\n", + "\n", + "Compared to REGCOIL, it can:\n", + "\n", + "1) Models more realistic quantites, such as:\n", + " - Magnetic field errors (including $\\chi^2_B$, which REGCOIL uses).\n", + " - Sheet current density and topology (including $\\chi^2_K$, which REGCOIL uses).\n", + " - Dipole density and sparsity.\n", + " - Lorentz force.\n", + " - Filament coil curvature.\n", + "2) Generate better-behaved winding surfaces.\n", + "3) Supports inequality and equality constraints.\n", + "4) (Using constraints) directly specify target values instead of scanning\n", + "a regularization weight $\\lambda_{regularization}$.\n", + "5) Serve as a coil complexity metric in DESC equilibrium optimization. " + ] + }, + { + "cell_type": "markdown", + "id": "87a71626-adab-4c66-8357-cc1ad9744d99", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-27T19:02:05.483793Z", + "iopub.status.busy": "2026-02-27T19:02:05.483611Z", + "iopub.status.idle": "2026-02-27T19:02:05.487748Z", + "shell.execute_reply": "2026-02-27T19:02:05.487294Z", + "shell.execute_reply.started": "2026-02-27T19:02:05.483780Z" + } + }, + "source": [ + "## Outline\n", + "\n", + "This tutorial shows how to use QUADCOIL for the following:\n", + "\n", + "1) Solving a NESCOIL problem.\n", + "2) Solving a REGCOIL-like constrained problem.\n", + "3) Solving a force minimization problem.\n", + "4) Performing equilibrium optimization using QUADCOIL as a coil complexity proxy. We will reproduce the numerical example in [2] and show how to use QUADCOIL to create a ARIES-CS-like equilibrium with low coil forces." + ] + }, + { + "cell_type": "markdown", + "id": "656f3b3a", + "metadata": {}, + "source": [ + "If you have access to a GPU, uncomment the following two lines before any DESC or JAX related imports. You should see about an order of magnitude speed improvement with only these two lines of code!" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "80d07827", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:09.764011Z", + "iopub.status.busy": "2026-04-24T13:01:09.763941Z", + "iopub.status.idle": "2026-04-24T13:01:10.041008Z", + "shell.execute_reply": "2026-04-24T13:01:10.040403Z", + "shell.execute_reply.started": "2026-04-24T13:01:09.764002Z" + } + }, + "outputs": [], + "source": [ + "from desc import set_device\n", + "\n", + "set_device(\"gpu\")" + ] + }, + { + "cell_type": "markdown", + "id": "ec75629c-2486-4a4d-ad73-2abc797fb20a", + "metadata": {}, + "source": [ + "Importing libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d6bcd497-0c81-480d-a7b5-315d2a32706e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:10.041589Z", + "iopub.status.busy": "2026-04-24T13:01:10.041455Z", + "iopub.status.idle": "2026-04-24T13:01:15.878976Z", + "shell.execute_reply": "2026-04-24T13:01:15.878555Z", + "shell.execute_reply.started": "2026-04-24T13:01:10.041573Z" + } + }, + "outputs": [], + "source": [ + "import desc\n", + "import time\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from desc.backend import jnp\n", + "from desc.grid import LinearGrid\n", + "from desc.plotting import plot_2d, plot_comparison\n", + "from desc.objectives import (\n", + " QuadcoilProxy,\n", + " QuadraticFlux,\n", + " SurfaceCurrentRegularization,\n", + " QuasisymmetryTripleProduct,\n", + " Volume,\n", + " ForceBalance,\n", + " FixBoundaryR,\n", + " FixBoundaryZ,\n", + " FixPsi,\n", + " FixPressure,\n", + " FixIota,\n", + " ObjectiveFunction,\n", + ")\n", + "from desc.optimize import Optimizer\n", + "from desc.magnetic_fields import solve_regularized_surface_current\n", + "from desc.equilibrium import EquilibriaFamily\n", + "from quadcoil.quantity import f_B, f_K, Phi_with_net_current, K, f_l1_force_cyl" + ] + }, + { + "cell_type": "markdown", + "id": "397e841d", + "metadata": {}, + "source": [ + "As mentioned in [DESC Documentation on performance tips](https://desc-docs.readthedocs.io/en/latest/performance_tips.html), one can use compilation cache directory to reduce the compilation overhead time. Note: One needs to create `jax-caches` folder manually." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fa8f61eb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:15.879453Z", + "iopub.status.busy": "2026-04-24T13:01:15.879309Z", + "iopub.status.idle": "2026-04-24T13:01:15.881261Z", + "shell.execute_reply": "2026-04-24T13:01:15.880918Z", + "shell.execute_reply.started": "2026-04-24T13:01:15.879444Z" + } + }, + "outputs": [], + "source": [ + "# import jax\n", + "# jax.config.update(\"jax_compilation_cache_dir\", \"../jax-caches\")\n", + "# jax.config.update(\"jax_persistent_cache_min_entry_size_bytes\", -1)\n", + "# jax.config.update(\"jax_persistent_cache_min_compile_time_secs\", 0)\n", + "\n", + "import sys\n", + "import os\n", + "\n", + "sys.path.insert(0, os.path.abspath(\".\"))\n", + "sys.path.append(os.path.abspath(\"../../../\"))" + ] + }, + { + "cell_type": "markdown", + "id": "18df206f", + "metadata": {}, + "source": [ + "We use the AREIS-CS equilibrium for this example. ARIES-CS is used as the initial state in the second numerical example in [2]." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "06611983", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:15.881557Z", + "iopub.status.busy": "2026-04-24T13:01:15.881489Z", + "iopub.status.idle": "2026-04-24T13:01:16.736795Z", + "shell.execute_reply": "2026-04-24T13:01:16.736267Z", + "shell.execute_reply.started": "2026-04-24T13:01:15.881550Z" + } + }, + "outputs": [], + "source": [ + "aries_eq = desc.examples.get(\"ARIES-CS\")" + ] + }, + { + "cell_type": "markdown", + "id": "f11c97f7", + "metadata": {}, + "source": [ + "## General settings\n", + "First, define some QUADCOIL settings." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "754dd316", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:16.737296Z", + "iopub.status.busy": "2026-04-24T13:01:16.737200Z", + "iopub.status.idle": "2026-04-24T13:01:16.790622Z", + "shell.execute_reply": "2026-04-24T13:01:16.790207Z", + "shell.execute_reply.started": "2026-04-24T13:01:16.737287Z" + } + }, + "outputs": [], + "source": [ + "# Settings\n", + "mpol = 8 # Num. poloidal modes in the current potential\n", + "ntor = 8 # Num. toroidal modes in the current potential\n", + "# Controls the resolution of the plasma surface integration.\n", + "# Integration in quadcoil is naively performed using summation\n", + "# so we recommend at least 16 here.\n", + "# This corresponds to a (33 x 33) grid.\n", + "plasma_coil_distance = (\n", + " 1.3 # 1.64 is the Wiedman value # 1.5 m is a common rule-of-thumb value\n", + ")\n", + "coil_coil_distance = 0.77 # 1.10 is the Wiedman value\n", + "coil_per_half_fp = 3 # 3 is the Wiedman value\n", + "curvature_target = 0.88 # 0.88 is the Wiedman value\n", + "# f_B_target_norm = 1e-4\n", + "# radius_of_curvature = 0.5 # 0.5m is the infinity two value\n", + "# Resolution for sampling objectives\n", + "quadpoints_phi = jnp.linspace(0, 1 / aries_eq.NFP, 33, endpoint=False)\n", + "quadpoints_theta = jnp.linspace(0, 1, 33, endpoint=False)" + ] + }, + { + "cell_type": "markdown", + "id": "fbce3873", + "metadata": {}, + "source": [ + "The QUADCOIL objective is mostly controlled using a dictionary, `quadcoil_kwargs`\n", + "that contains arguments that would otherwise be passed into a call of `quadcoil.quadcoil()`.\n", + "For a tutorial on `quadcoil.quadcoil()`, \n", + "[see here](https://quadcoil.readthedocs.io/en/latest/tutorial_inputs.html). \n", + "\n", + "\n", + "If your `quadcoil_kwargs` is good for directly calling `quadcoil.quadcoil(**quadcoil_kwargs)`, it will also work here.\n", + "\n", + "\n", + "Because a `QuadcoilProxy` is attached to an `Equilibrium`, the following arguments\n", + "will instead be calculated from the `Equilibrium`. Their values will be ignored if provided.\n", + "\n", + "```\n", + "\"nfp\" # Num. field period\n", + "\"stellsym\", # Stellarator symmetry\n", + "\"plasma_mpol\", # Plasma poloidal Fourier mode number \n", + "\"plasma_ntor\", # Plasma toroidal Fourier mode number \n", + "\"plasma_quadpoints_phi\", # Plasma integral quadrature points. Will be \n", + "\"plasma_quadpoints_theta\", # auto-generated from plasma_M_theta and plasma_N_phi.\n", + "\"plasma_dofs\", # Plasma surface Fourier coefficients\n", + "\"net_poloidal_current_amperes\", # Net poloidal current required on the winding surface\n", + "\"Bnormal_plasma\", # B normal on the plasma boundary \n", + "\"metric_name\", # What coil properties to output. Will be controlled \n", + " # by an identically named argument to QuadcoilProxy\n", + "\"value_only\" # Controls whether to skip adjoint differentiation.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "113b1b28", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:16.791029Z", + "iopub.status.busy": "2026-04-24T13:01:16.790942Z", + "iopub.status.idle": "2026-04-24T13:01:16.792853Z", + "shell.execute_reply": "2026-04-24T13:01:16.792492Z", + "shell.execute_reply.started": "2026-04-24T13:01:16.791020Z" + } + }, + "outputs": [], + "source": [ + "quadcoil_kwargs_basic = {\n", + " \"mpol\": mpol,\n", + " \"ntor\": ntor,\n", + " # Resolutions for evaluating winding-surface\n", + " # pointwise objectives and plotting.\n", + " # Note that this does not control the resolution\n", + " # for evaluating winding surface integrals.\n", + " # The integral resolution is controlled using\n", + " # winding_quadpoints_phi and winding_quadpoints_theta.\n", + " # Here, we use the default value of 33x(32xnfp), which\n", + " # is often good enough.\n", + " \"quadpoints_phi\": quadpoints_phi,\n", + " \"quadpoints_theta\": quadpoints_theta,\n", + " \"plasma_coil_distance\": plasma_coil_distance,\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "69392936", + "metadata": {}, + "source": [ + "If you have access to a GPU, uncomment the following two lines before any DESC or JAX related imports. You should see about an order of magnitude speed improvement with only these two lines of code!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "262a4c05", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:16.793142Z", + "iopub.status.busy": "2026-04-24T13:01:16.793071Z", + "iopub.status.idle": "2026-04-24T13:01:16.804290Z", + "shell.execute_reply": "2026-04-24T13:01:16.803991Z", + "shell.execute_reply.started": "2026-04-24T13:01:16.793134Z" + } + }, + "outputs": [], + "source": [ + "# import jax\n", + "\n", + "# jax.config.update(\"jax_compilation_cache_dir\", \"../jax-caches\")\n", + "# jax.config.update(\"jax_persistent_cache_min_entry_size_bytes\", -1)\n", + "# jax.config.update(\"jax_persistent_cache_min_compile_time_secs\", 0)\n", + "\n", + "import sys\n", + "import os\n", + "import desc\n", + "\n", + "sys.path.insert(0, os.path.abspath(\".\"))\n", + "sys.path.append(os.path.abspath(\"../../../\"))" + ] + }, + { + "cell_type": "markdown", + "id": "5976655d", + "metadata": {}, + "source": [ + "We\"ll first load the AREIS-CS equilibrium that [2] uses as the initial state." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f5460293", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:16.804624Z", + "iopub.status.busy": "2026-04-24T13:01:16.804547Z", + "iopub.status.idle": "2026-04-24T13:01:16.990380Z", + "shell.execute_reply": "2026-04-24T13:01:16.989836Z", + "shell.execute_reply.started": "2026-04-24T13:01:16.804616Z" + } + }, + "outputs": [], + "source": [ + "aries_eq = desc.examples.get(\"ARIES-CS\")" + ] + }, + { + "cell_type": "markdown", + "id": "4bd8b5be", + "metadata": {}, + "source": [ + "## 1. Solving the NESCOIL problem\n", + "As a first example, we solve the NESCOIL problem:\n", + "$$\\min_{\\Phi'} \\chi^2_B.$$\n", + "Here $\\chi^2_B$ is the squared flux at the plasma boundary." + ] + }, + { + "cell_type": "markdown", + "id": "c6bfc903-edc6-4ed0-af2f-26fea7a2b231", + "metadata": {}, + "source": [ + "The objectives and constraints in quadcoil are chosen\n", + "by feeding strings representing the name of the \n", + "quantities as arguments. The first example, the NESCOIL\n", + "problem, has one objective term (the squared flux \n", + "`\"f_B\"`) and no constraints." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e3c81118", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:16.990819Z", + "iopub.status.busy": "2026-04-24T13:01:16.990736Z", + "iopub.status.idle": "2026-04-24T13:01:16.992402Z", + "shell.execute_reply": "2026-04-24T13:01:16.992092Z", + "shell.execute_reply.started": "2026-04-24T13:01:16.990810Z" + } + }, + "outputs": [], + "source": [ + "quadcoil_kwargs_nescoil = quadcoil_kwargs_basic | {\n", + " # The NESCOIL problem only contains the squared\n", + " # flux objective. In QUADCOIL, this quantity is called\n", + " # f_B.\n", + " \"objective_name\": \"f_B\",\n", + " # The NESCOIL problem is simple enough to need no normalization\n", + " # constants. In the next example we will discuss how to choose\n", + " # this constant.\n", + " \"objective_unit\": None,\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "c6991fc7", + "metadata": {}, + "source": [ + "QUADCOIL is integrated into DESC as an objective function. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "eee7ebea", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:16.992695Z", + "iopub.status.busy": "2026-04-24T13:01:16.992627Z", + "iopub.status.idle": "2026-04-24T13:01:19.677001Z", + "shell.execute_reply": "2026-04-24T13:01:19.676356Z", + "shell.execute_reply.started": "2026-04-24T13:01:16.992688Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "# Define a QuadcoilProxy with the simplest possible\n", + "# signature.\n", + "objective_nescoil = QuadcoilProxy(\n", + " eq=aries_eq,\n", + " quadcoil_kwargs=quadcoil_kwargs_nescoil,\n", + " vacuum=False,\n", + " # If you have additional filament/planar coils, put the CoilSet here.\n", + " # field=[],\n", + ")\n", + "objective_nescoil.build()" + ] + }, + { + "cell_type": "markdown", + "id": "f6336b32", + "metadata": {}, + "source": [ + "### Calling QUADCOIL (outputting QUADCOIL types)\n", + "To call QUADCOIL, use `QuadcoilProxy.solve_quadcoil()`. The signature of this function is the same as `Objective.compute()` or `Objective.compute_scalar()`. The output is the same as `quadcoil.quadcoil()`. See [here](https://quadcoil.readthedocs.io/en/latest/tutorial_outputs.html) for a tutorial for interpreting QUADCOIL outputs.\n", + "\n", + "Note that calling `QuadcoilProxy` in DESC is slightly more costly than directly calling `quadcoil.quadcoil()`. This is because `QuadcoilProxy` also calculates $B_\\text{normal}$ and the net poloidal current." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d66c7642", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:19.677291Z", + "iopub.status.busy": "2026-04-24T13:01:19.677216Z", + "iopub.status.idle": "2026-04-24T13:01:32.416769Z", + "shell.execute_reply": "2026-04-24T13:01:32.416378Z", + "shell.execute_reply.started": "2026-04-24T13:01:19.677284Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lf2869/Documents/Codes/quadcoil/src/quadcoil/wrapper.py:37: UserWarning: Bnormal_plasma provided, inputs for plasma_quadpoints_phi and plasma_quadpoints_theta will be ignored.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The squared flux is 1.0540637910635586 T^2m^2\n" + ] + } + ], + "source": [ + "# The outputs are:\n", + "# - out_dict: a dictionary storing the value and gradients of the\n", + "# metrics chosen in metric_name. By default the chosen metric\n", + "# f_obj, the exact same function that QUADCOIL uses as the\n", + "# objective function.\n", + "# - qp: a quadcoil container for the winding surface, plasma surface\n", + "# and plasma B normal. One of the 2 arguments required to evaluate\n", + "# any quantity in QUADCOIL\n", + "# - dofs: a dict containing the current potential's Fourier coefficients\n", + "# and additional slack variables (if any). The other one of the 2\n", + "# arguments required to evaluate any quantity in QUADCOIL\n", + "# - status: a dict containing some status of the optimizer.\n", + "(out_dict_nescoil, qp_nescoil, dofs_nescoil, status_nescoil) = (\n", + " objective_nescoil.solve_quadcoil(\n", + " # Like Objective.compute(), the xs of the equilibrium\n", + " # must be passed in as the *arg.\n", + " *objective_nescoil.xs(aries_eq)\n", + " )\n", + ")\n", + "print(\"The squared flux is\", f_B(qp_nescoil, dofs_nescoil), \"T^2m^2\")" + ] + }, + { + "cell_type": "markdown", + "id": "11db0a61-aad9-443b-a1bf-66843abc474b", + "metadata": {}, + "source": [ + "Plotting the current contours using QUADCOIL.\n", + "The full Phi (with both single-valued and secular\n", + "components) is called Phi_with_net_current.\n", + "Physical quantities in QUADCOIL are all stored \n", + "in `quadcoil.quantity`. All quantities take the following\n", + "two arguments:\n", + "- `qp` This is an object storing the plasma surface, winding \n", + "surface, and $B_\\text{norm}$.\n", + "- `dofs` (a dictionary\n", + "storing $\\Phi$ and any slack variables)\n", + "\n", + "These are the second and third outputs of `quadcoil.quadcoil()`\n", + "or `QuadcoilProxy.solve_quadcoil()`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c1724458", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:32.417135Z", + "iopub.status.busy": "2026-04-24T13:01:32.417055Z", + "iopub.status.idle": "2026-04-24T13:01:32.591412Z", + "shell.execute_reply": "2026-04-24T13:01:32.590968Z", + "shell.execute_reply.started": "2026-04-24T13:01:32.417126Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAF2CAYAAAB6XrNlAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAOxAAADsQBlSsOGwABAABJREFUeJzsnXVYVFsXh9+hu0FCUFBRDLALsbtbsbuurdfua3d3d3did2OAiCLd3TAwcb4/UJQrKiiK3o/3eXhm5sQ++wxnfmedtddeSyQIgkABBRRQQAH/GRTyuwMFFFBAAQXkLQXCXkABBRTwH6NA2AsooIAC/mMUCHsBBRRQwH+MAmEvoIACCviPUSDsBRRQQAH/MQqEvYACCijgP0a+CbsgCKSmplIQRl9AAQUUkLfkm7CLxWI0NDQQi8X51YXfnvDQOAZ2Xsf6pRfyuyu5ZtVqF2bNOZHf3cgTho3YRZdu67jk4oZc/mVD5PZVD1rWnMuhnXeQSeWfrRcEgbGd1zGqwxpC/KNz1YeVo3fTsdhoTmy8giRdmutzkKRLWTJsO/2qTPuu/f8EHl7zoFuNOWxZeDa/u5LvFLhifkMEQeDaRTeG99yMoqICnXo65neXcsWLFwGcOuNKzRol8rsrecKcme2pUtmGJcvOM3joDp489c12u5p1StFzUF32bL7BmAHbCfCNzLJeJBIxZkEnpBIZw9us4OrJpznuw8B/OtG8T222zznOEKfZPLz0MkdPuzKpjJjweKZ3Xc29c88YtrAryipKOT7un0BKkphVU48ya/BOKjja4jysQX53Kd8R5VdKgdTUVDQ0NEhJSUFdXT0/uvBbEhWRwJqF53hw+y0tO1Sm/4iGaGiq5ne3coxYLGHA4G1YWRoy75+OiESi/O5SnuHrG8nmrTd4+MibKpWtGTSwHsVsTD7bzu9dBEvnnMTPO4LeQ+rTvlt1FBU/2lDpaVJ2LD3PyZ13qNe6An/NaoemtlqO+hDqF8m2Oce4c9qVcjVtMTLXR5wsJjU5DXFyGqnv/z4sk6RlWOf6Jjr8c3Akxe2t8ubL+E1wf+zLsgmHSEkWM3x2e5ya2ed3l34LCoT9N0EQBFzOPGfTikvo6GowZnprHCoVze9u5ZoNG69y/sJLtm/tj7GxTn5356fg+syPTVuu8+5dOE0al2Ng/7ro62tm2UYqlXF41132bb1JCTtzxs9sS+Eihlm2eXTjNcsnHkZdU5WJy7tRqnzORdft3luOb7iMXC6grqmGuqYqapqqqL//U9PKuqy4vRW6htp5cv6/A+lpUvascuHY1ptUrl2S0fM7YmDy37zevocCYf8XcrlAVEQC4SFxhAbHEhWZgHEhXYpYG2NZ1Ah1DZU8P2ZEWDwr553B9aE3bbtWo8/Q+qip5/1xfjYeHsGMGL2HsaOb0aK5Q35356cilwtcu+7B5q03EIvT6d+3Di1blM9imQP4eIWzdNZJAv2jGD6hOU1aV8iyPiYigaV/H+LlI296jW5Cx4F1UFAo8JB+ifQ0Ca53vNi98hKhAdEMnNySZl2q/aeeDPOC/0thTxNLCPKPJjQ4ltDgWMKCYwkLiSMsOJbw0DgkEhkAKqpKGBhqER2ZmLnMxFQXK2tjrKyN3r9mvNfWyf05yOUC5088ZevqyxgaaTN2RmvKOPyZj8rp6VIGD92BkZE2ixd2+b/5oaWkpLF7712OHX+CjY0xo0c0wc7OPMs2UqmMnRuucWT3PVp1qsKQsU1QUlLMXC+Xyzm+7RY7l1+kbBUb/l7SBcNCur/6VH5bEuNTeHzDk3uXX/H09hvEKek41CjOyH86YP6vp6ACMvjPC7sgCESExfPaLYjXLwPxeBmE99swZLKMqAUjE21MLfQxNdfHzEIPUwt9zN5/1jfUQkFBhEwqJzQ4lgDfSPx9IwnwiSTAL4pA30jS3vswDQy1sLQ2wsLKkMJWhlhYGWJZxJBC5npZfsQfCA2KZcW807i5+tOhRw16DqyLqpryT/sefjZbt93k+MknbN/SH1NTvfzuzi/H1y+SVatdcHMPpHkzBwb0r4vuv272Ny+/YtmcU9jamTNtYSf0DLK6b968DGTRmP2kJqcxbV0vyvyBrri8IjI0jvtXXnH/yivcHvkAYF+tGDUblaFa/dIYm+nlbwd/c/Jd2EOCI1FWUkEqkSGRyJBKZR/fS2RIpDIQQE1dGTV1FdQ1VFB//6qqpvyZZZieLuWdZygeLwMzxNwtiOjIRBQURdgUL4SdvSWlyxWmeCkzTM31UVH9/ggBuVwgIjQuQ+x9IwnyjyYoIJpg/2hiY5IBUFRUwMxCHwsrQyysDLAsYkRSkpi9W25iaq7HuBltKFnG4oe+y/zm7dswho3YxfBhDWnbplJ+dyffEASBK1dfsXHzdWQyOQP716VZU3sUFD5eoz5e4cwefxCpVM6spV0o8S/rPjlRzOJxB3C985bhs9vTpFOVX30a+Ya/Vzj3Lrtz/8orvNyCUNNQoUqdUtRoWIYqdUuh9R1Pxf+v5LuwN6g4FUWF77NURSIyxF5dBTUNFZSVFQkJjEEikaGjq45dOUtK2xfGzt6SkqXNf6nfOilRTHBANMEB78U+IIYg/yiCAqKRpMvo0qcWzv2cUPnDQ8/S06UMG7ELTU1VViztnkXE/l9JShazc+dtTp52pVRJM0aNbEyJ4qaZ6xPiUpg/9Rjuz/0ZNaUVjVpkHY+QyeTsWXmJQxuv06Z3LQZOaoFiNk99/wWCfCK4ee4Fty+8xN8rHD1DLao3KE2NhmUoX7M4Kqp/7lNsfpLvwn7/tgfa2pooKSmipKyIsnLGq5LSx/cA4lQJ4tR0xKnppKakk/r+9dPPaWIJhYsYUbpcYcwtDX5LP68gCEjSZT/0pPA7sWqNCy6X3dm8oS8WFvr53Z3finfvwlm5xgVPzxBatazAwP510NDICF2VSeVsW3uFY/vu0865GgNHNkZRKeug6Y0zz1gx+QhlKlkzeVV3tPU08uM08pwQ/yhunX/JrfMv8PUMRc9Qi1pNy+HUzJ4yla0/G4AuIPfku7D/blExBeSM9HQpO3ff4eChB0yf2oZ6de3yrG1XtwAmLTpJkcIGVHUoSlWHopSxNct2rCKvCY9KYNnmKwSExCIIwvuZphmvggByQUCQCwjvlxkZaDGsZx2qli+abXtyucAll5ds2nIDAwNN5s/thOknA6PXLrqxYu5pyjhYMX1RJzS1ssazv3ULZM7Q3aiqKTFnaz8sihr/xLP/eaSJJdw6/4LzBx7g+TwAHX0NHBuXo3YLB8pVtfljxFwQBNyfBxATlURSYipJiWKSEsQkJWW8JieJSUxIJTlJTFKiGHV1lYxxtyKGWFgaZI7BGZvq5vqc08QS0tKk6Oh+Wy8LhL2AXPPKI5glS88TEZnA0MH1adWywrd3yiESiYw+43ahoa5CCWsTHj33IywyAQ11FSqWtaTKe6EvbKaX509kdx57M3/tBfR1NWjkZIeCggiRSJTxCogURCiIsi578jKA24/fUbd6CUb0rUcho+xjqcMj4pky9SjxCSnMn9sJ2xIfXTNer0OYMeYAOnoa/LOyGyamWSNiYiISmDV4B+HBsczY0OePGlSNi07i0MZrXDn+lNSUNGo2KkuTTlVwqF4882n8T0EslrB8ziluXn4FgKaWKlo66mhpqaGlo5b5qqmlhpZ2xl9yUhpBAdGEBMYQ6B9FUkJGChVlZUXMCutnCr2hsTapKekkJqSSmJBxc0hKTCUxPvX9ezHpaVJK2Jmxdvegb/a1QNgLyDFisYTtO29x7PhjKlYoyrgxTfM8Aubg6Sds3n+bPSv7YmGqhyAIBIXG8eiFH49f+PHULYBUsQRTY50MkS9fhGrlrdH4gfETiUTGxn23OHTmKc3qlmHswAaoq+W8vftPfVi5/RrRsUn06VSDLi0ro5yNaCUli5k95ySvPIKZMa0N1asVz1wXHhrHtFH7SUpM5Z+V3She0izLvuKUdBaO2YfrHS/GL+lC7T9gnkCQTwTTB2wnPU1Cqx6ONO5YBQPjP3OSVGR4ArP/PkhoUCyT53Wgwnc+ZSTEpWSMuQXGfBx/848mJjoJDU1VtHXU0dJWQ1tXHW0ddbTfv9fSzvhsaKyNbWnzbx6nQNgLyBEvXgSwZPl54uNSGTqkPs2a2ue5xRwdm4zziG10bF6RQd1qZbuNVCrjlVcoj5/78eiFP57eYWhqqNK5RUU6tqiItmbOpuZ/ICQ8jpkrzuIbEMW4gQ1pVq/sd/U9LV3K/pOP2HPiEWbGOowd2JBK5T6fkyCRyFi+8iKXr7gzcnhjWrf6+LSTlChmzoRDvPUIYeaSLlSoapNlX5lMzuZ5Zzi95y79/m5Ox4F1fstxJMiY6j9n2C7MrQyZuakP+kZ/pqADeLwMZM7fh9DSUWf2sq5YWP3+sfMFwl7AV0lJSWPLtpucOu1KtarFGDu6yU9LFTB/7QWevAxg3+q+ObaYY+NTOH7hGUfOuSIg0LF5RTq3rISu9revqZsP3rJg3SVMjLSZM64VRQv/+A82OCyOVduvce+pDw0cSzG8dx2M/zWVXxAE9uy9y87dd+jauRoD+tfNjCZKT5eydNZJ7l5/zYQ57anTqMxnxzix4zZbFpylWZeqDJne5rdL6nXz3HOW/n2IKnVKMWG58x85i/oDl88+Z9X8s1SoasOkue0/GwP5bRHyiZSUFAEQUlJS8qsLBXyDx098hK7d1wmt260QXC67CXK5/Kcdy/1NiODYfolw5c7r79o/ISlV2HHkntCs1xqhYbeVwvrdN4WYuKRstxWnSYTlW64Iju2XCAvXXxLE4vQf6Xq23H70Tug4ZJPQsNtKYf+pR4JEIv1sm4uXXgoNmywS5sw9KaSlSTKXy2RyYf2S80KTKrOEkwcfZNv+nUtuQpuyU4ThbVYKfm/D8rz/34NcLhcObbwmNC3+t7BhzklBKpXld5e+G6lEJmxcflFoXHmWsGW1yx93LgUW+/8Rqanp7Nt/n5DQWCTvJ4GlS6RI0mWZnyUSKenv38fGJuNUy5ZRIxpjYKD10/ollwsMnrwPVVUl1sz+sXQEKanpHL/4jIOnn5AqltC2sQPObatgpJ/R/6DQWGYsO0NgaCwThjSmkVPeRfP8G3GahL3HH7Lv5GMKm+kxY3QLShTNmg3S1dWPmbNPYGNjzJzZHTJnqwqCwOFdd9m+7irO/ZzoPaTeZ99LkE8ES/8+hI9nKH3HN6VN71r5lmdGJpWxbtZJLh5+xKAprWjbJ3tX2p9AUqKY+VOO8tLVjzFTW9Og+Z+XMbJA2P9P8POPYvY/J4mJSaK8gxXKykooKyuiovxx/oCyshIqme8VsbQ0pEpl65/uxz171Y3FG13YvqQXxfMonC9VnM4pl5ccOPWYxGQxrRraU6yIMWt33cDCVI85Y1thaf5r4u6DQmNZsO4Sb33DmT22JTUrFcuy3tc3kslTj6CiqsSCeZ2w+KRfl04/Y+X8MzRuWZ6Rk1p+Fusuk8o4tPE6+9ddoXTFooxb3IVCv3g+QUqSmAWj9uH2yIcJy52p2ej7xil+BwL9opg17iApKWnMXNqVUn/orPAcC3tqairOzs7UqFGDN2/e4OjoSP/+/Vm1ahUxMTGEhIQwZswYSpcunaMDFwj7r+OSixur1rhgY23M9GltKGTy+ySYSkwW4zx8G/VrlmTswIZ53n5amoQzV93Yd+IRkTFJtGtanuG966L6i/3SEomMJZsvc/HGK0b0qUfH5hWy3DCjohKZMv0oUVGJzJvTMUsisQe33jBvylEqVivG5HkdUMsmp9Bbt0CW/n2IqLB4hk5vQ8P2lX7JwGp0eDwzBu4gOjyeWZv65ir18O/Gk/vvmD/lKBZWhsxc0gWjPzkNcE59NklJScL27dsFQcjwj+vr6wvv3r0TGjVqJAiCIPj5+Ql16tTJsQ+owMf+80lNTRcWLTkr1Gu4QFi/8aqQnv65nze/Wb39mtC891ohPuHnXgdp6RIhKDT2px7jW8jlcmH3sQeCY/slwtLNlwXJv/y2KSlpwsTJh4SmLZYI9x94ZVnn/jxAaF9/oTCm/zYhIT7770qcmi5snHtKaFr8b2H2kJ1CbFTiTzsXQRAEH88QoUetucKAxouFEP+on3qsn4VUKhNeuvoJaxefE5pWnS0smHpMEKfm/ZjLr+a7XDGvX7+mT58+DBgwAB8fHxYsWACAqakpAQEBqKh8PgoukUiQSj/WWkxNTcXQ0LDAYv9JBAfHMn3WMaKiEpn4d0sca/5+Zep8A6PoM243YwY0oG3j3z8uO6+4fv8N/6y+QIUyhZk1pmWWEE2pVMayFRnhkH+Pa06TxuUy1/n7RDJlxF40tVSZt7oHxoWytyhfPHjHsgmHSU+TMHp+J6o3yNlTdG54fNOThaP3Y2Nnxoz1vf+YdAfJSWmEBGbEj7986se9m2+Ii0mmsJUhrTtXoXXnqr9tCGluyLWwb926lV27drFw4UJu3bqFXC5n6tSpABQvXpzbt29jZmb22X6zZs1i9uzZny0vEPa8RyaTM3T4LgS5wD+z2/+2aXR3H3vAsQvPOL5p8B8zpTyv8PAKZfLCk6ioKPHPuFaU+iRJmCAIbNt+i/0H7zNoYD26dq6WuS4iLJ6pI/eSmpLO/LU9sSpqlG37yYmpbJhziqsnXek2vCHdRzTMk4HVV0/92LfmMs/uelG3ZXnGLOz8y/MepadJ8feJID39/cB/ujQjECBdmvE+/X0QQLqM9DQJYSFxmROC4t5nXf2Q7dWxnh2O9eywsjb6Twj6B77LYk9JSaFSpUr06dOHuLi4Aov9N+P4iSds3HyNLRv7UaRI9j/834Fth+5y/d4b9q7ql99dyReiY5OZs+ocL14HMaxnHTq1qJhFXI4df8y6DVfp1LEqgwfWy4x1T4hLYcbYAwQHRDN7uTOl7S2/eIxz+++z4Z9T2NiZ07hDZZyaOaD7rzzwOeHlQ2/2r7vKi/vvKF2pKN2HN6SCY4lfKoaCIHDrigfb1lwmPDQ+222UVTKCAD68qqgqUchM732eFgPMLTOm8Bcy18t2dvB/hRzfaj08PEhOTqZKlSpoaGigpaVF06ZN+fvvvwHw9/enVKlS2Yo6gLKyMsrKBSk4fzaRUYls33mLLp2q/daiDhlhjv/PZeAM9TVZPr0je44/ZO2uGzx7Fcjkv5qi834STIf2VdDT02Dh4nPExiYzYXxzlJQU0dHTYOG6nsyfcoyJw3YzeV4HatYple0xWnSrQfGyhTm16w5bF51j49zTVK5dkvptKlKtfumvFncRBIEXD7zZv/YKbo98KFfVhgW7B+FQvdgvt269XoewYfklXj0PoGELB+b0qImWjhrKKhnRXcoqSigpKfynrO4fIccWu7e3NzNnzqRs2bKEhYWhoaHB/PnzWbVqFREREYSFhTFu3LiCqJh8ZvY/J3n7NpRtWwZkGz3xO7Fp323uu/qwc1nv/O7KT0MQBPxDY3kTEEGlUpYY6WVvLbu6BzB75TmUlRSZM64VpUt8dGc+fuLLzNnHsS9nyczpbVF/P5NTJpWzdvE5Lp56xtBxTWnduepX+5KanMb9K6+4dsqVZ3e9UFVXoVaTctRrUwH7asUy3WGCIPDsrhf7113h1RM/HGoUp9tfDbCvVuyr7f8MYqKS2LH+KpfPPqdU2cIMGdf0jw1B/JUUxLH/AIIg4OcXxc3bnty585b4hFRMC+liZqZHoUK6mJnqYlpIl0KmuhQy0fnpaWcfPvJm8tQjzJ/bier58CPMLev33OTJywC2L+mZ313JM6RSGW8DInn2Npjnb4N44RVCXGIqAJpqKvRvU50ujSqgnM21EBufzD+rLvD8dRBzxraiVpWP/8PXniFMnnoEC3N95s/rlGUi04Edt9m14TqdeznS968GOSp2EhOZyM2zz7l+2hUv92AMC+lQt2V5ipctzOndd3n9zJ8KjiXoNrwhZStb59G3k3PS06Qc33+fgzvvoKmlRv8RDanXpGyBRZ5DCoQ9lwiCgNe7cG7ffsPN228ICorBwEATp1olKVRIl/DweMLC4gkLjyc8PB6xWAKAgoIII0NtCpnqUNjCgArli1ClsjW6unkTTSAWS+g/cCslSpgya0a7PGnzZ7Nm53VeegazZWGP/O7Kd5OaJsHNO5QXb4N5/jYYd+9QUtMk6GiqUd7WgvK2FjiUMKeomQEHXFzZfe4xpkY6jHGug6ODzWftSWVylm66zIXr7vw9pDEtG3yMigkIjGbCpEOoqSqzaGHnLPMRLp99zoq5Z6jdsAxjZ7TOVWWugHfhXD/9jGunnxERHEvlOiXp9ldD7CoU+bEv5zsQBIE711+zddVlYqOT6NzbkY49HX/7p8/fjf+EsMtkclLF6aSJpejqque5ZSwIAp6eody684ZbtzwJDYvHxFgHJydb6jiVonRpi2ytJEEQiItLyRT50NAMwffzj8TDIwS5XE6pkuZUq2pD1arFsC1h+t2l5bZtv8nxk0/ZuX0gxn9IJr1V26/x+l0YG+d3y++ufBcX7nkwZ5sLMpkcM0OdDBF/L+ZFzQyy/V+GRMaz+tAtrj3xwtHBmjHOdbEyzTpTVBAEthy4y+5jDxjc3Yke7T6G4EVGJTJp8mGSksUsWtCFop+Mozx96M3ciYcpYWfOjMVd0NLOXcIquVxOfExyvmVi9H4bxsZlF3np6k+9JuXoN7zBZ7npC8gZv7WwJyaKuXP3Da9eBZOSmk7K+xJ4KSnppIozSuKlpKaTlvYx2kZRUQFzcz0sCxtgZWmIpaUBloUNsbQy/Kxq/Od9Sic6OinjLybjNSQkjvsP3hERmYCZmR61nUpS26kkpUqa/dBjYVKyGFdXPx498uHhIx+iY5LQ09OgSmVrqlUtRuVK1uj8q7+CIJCQKCYmJonYmGRiYpOJiUkiOiaZEyefMHhgPTq0/3OKH6/YehUvvwjWz3XO767kmrikVDpO3EHtCsUY3K4mhQxzJ4aPPQJYtu86AWGxODepSL9W1dH8VxbEo+ddWbX9Gh2bV2REn49RMYmJYqZOP4p/QBTz5nSkbNnCmft4vwlj2uh96OhmX7Tjd+XNq2DGD95J0WImDB3X9KuRPgV8m99O2JOT07h7z4sbN1/z5KkvIpGI0nbm6Oioo/6+cLWGhgoa799/+KyuroKqqhJRUYkEBEQTGBRDQGA0QUGxpKdnCL+Ojnqm2GtpqhIdk0x0dOL71yRSU9Mz+6GgIEJfXxMjI20qV7KmtpMtxYsV+ik+PkEQ8PGJ4OEjHx4+9ubVq2AASpUyR0dHLVPEY2OTkUrlmfspKiqgr6+Jgb4mJW1NGTmi8R8VD75082X8g2JYM6dLfncl1yzafZXrT7w4urAvWu/rmOYWqUzO8esv2HT8HirKSgzv7ESzGnZZLP0rdzyZu+Y89WqUZMpfTTND9NLSJMydf5pHj32YOrkVtZ0+RsV8iHVPSU5j7qruWBcv9GMn+5OJikhgRO8tWBcvxD8run2WD+e/jiAIpKVJ89Td9FsIOyhy7/47btx6zaNHPsjlApUqFqV+PTtq1iyBVi6LJ3yKXC4QERFPYGBMptgHBsaQkpKGoaEWhgZaGBpqYWCohZGhFgYGGa+6uhr5JpJJSWKePPXjyRMf0iUyDAwyxNvAQCtTyA0MNNHWVv9u183vwOKNLhn5y2d1zu+u5Io3/hH0mrWX6f2b0LLW5/nSc0tcYiobj9/lxI2XlLE2ZUKvBpQq+lGMH7/wY8riU5QracHcv1tnVouSyeSsWXeZM2efMWxIgyxPa4kJqcwefwjvt2HMXNKF8lV+/QBoThCLJYwftIPUlHRW7RiQa/fRn4hMJsfbJwL3V0G4uwfh/iqYqKhE9PU0KPzBw2BpgGVhAywtDTEz1c21eznfhX3ilH28eBGCRCKjQvki1Ktrh6Oj7TfdJgX8+cxacZaEJDHLp3fM767kGIlUxqD5hxCJRGyd2jVPb6xv/SNYsu86r33CmDO4GfWr2Gau83wXxvh5xzA11mHR5PYY6meETQqCwMFDD9my7Qa9e9Wid8+P6XLT06QsmXWSezdeM21hZ2rUKZlnfc0rFs88wcM7b1m9Y8AfUZnoRwgLj+fAwQdcufqK1NR0NDVVKVPagrJlCmNlZUh4RDxB7w3QwMAYomOSgIwnczMzPQpb6FOqpBm9en47JXK+C/vY8XuoU7sMtZ1KoveH5Jso4McJj0rAefg2hr6fcfmnsHj3Vc7d9WD7DGeKWeT9BDCZXM7Svdc5fv0FIzrXpnvTj1kaA0Ji+HvecWQyOUumtsfa8uPxz5x9xopVlxg/thnNm33MuyOXC6yaf4ar518ybWEnqtf+fcT95uVXzJ9ylH9WdqOq4++XyyivCA6OZf/B+7hcdsfISIv27SpTqWJRihYx/qphkJycRlBQhtAHBcUQHBKLhoYqY0Y1+eYx813Y/7RwxwLyhoXrL/HkpT/71/RDRfn3Ku32Jc7efsWcbZeYN6wFjar+PIEUBIH9F5+y+vAt2tdzYFz3eii9dwvGxqcwedFJ/AKjmTehTZa6qtt23OLAwfvMn9uJqlU+hlLKZPJMcZ+6oBM162Y/S/VXEh2ZyKCu66ndsAyjJrfM7+78FAICotm7/x7XrntgaqpLd+caNGpY9qfPZ4ECYS8gHwgIjqHH6B1MGtqE5vX/jKIMr/3CGTj3IJ0bVWBkl9q/5JjXHr9l5uYLVLazYu7QFplRM2lpEuauucDtx++YP6FNZuEOQRBYuPgsd+56sXJ5N0p8klhMLhdYs/Asl04/Z/K8Djj9hIyPOUUQBKaN2k9wYDQb9g1BXePPrYmaHf7+UezZd4/rNzwoXNiAHt1qUr9e6V86Zlcg7AX8cqYvPY1vYDS7lvf+I6J4YhNS6D17H5aF9Fk1rn2m9fwrcHsXwvhVpzDW12L5mLaY6GeEVcrlAgs3XOLqHU9WzepM2ZIZhTkkEhmTphzGPyCKtat7YVroY7ijXC6wfsl5zp14ysQ57anbOH9uqmePPWHd4vMs3dyXMg7/nbBGX79I9u67x42br7GyNKRnD0fq1C6VL9f47/+rKuA/had3GNfvv2Vgt1p/hKhLZXKmbTwPwLyhLX6pqAOUK27O9unOpKVL6TfnAG8DIoGMcNwJQxpTqZwVE+Yfxy8oGgBlZUVmz2qHro4Gk6ceITFRnNmWgoKIvyY0p3XHKiyafpxrF91+6bkABAdEs3mlC516Of5nRN3XN5I5c08yYNA2fHwjmTalDVs39//lVvqnFFjsBfxSxs45SmKKmM0Luv8ReT9WH7rF4cvP2DKtK3ZFf248uCAIxKeIUVNWRu1fKQHik1KZuOYMnv7hLBjWkhr2GeGL4jQJo2cfISI6kY3zu2HyfqJUREQCf43cTWELfRYt6JIlxYAgCGxe6cLJgw8ZO6MNjVr8miInMqmccYN2kCaWsHrXwHxNmysIAskpaSQliklIFJOUKEakIMLERAdjI+0cpWTw9Y1k99673LzlSdGiRvTqUYvaTiV/ixDkAmEv4LtJl0i5+cCLK3c8kcpkqKsqo6amjJpKxqu6qjKqqkqZyxOSxKzbdZOVMztR2f7X5SGJS0rl9C13nr0JonwJC2o6WFO88LcLK1x+9Iap688xo38TWjr9WLx6YmoaQVFxRMYnE5WQ8ffp+6j4ZKISU5BIZRjpaLB8QGvsrbMWrEmXSJm3/TIuDz2Z0KsB7eraA5CQmMqwaQcAEevndkVHO+P35O0dzqix+6herThTJrXKIjiCILB97VWO7LnLmGmtadK6wg+dX07Yv/0W+7feYu3uQRQtbvLTj5eams7+A/cJDYsnKUlMQmLqRyFPEiOXf1n6DAw0MTHRwcRYJ+P1/ftCJjrIBYFDhx9y6/YbrIsa06unI061fg9B/0CBsBeQa4LD4jh9+SXnrrmRkCSmWvmi6OloIE6TIE6TkJomIS1NSqpYQlq6hFSx5P06KXVr2DJ3fOtf0s83/hEcvvIMlweeKCkqUsnOkpfvMrItmhho4WhvjaODDVVKW6GumnXWn3dQFP3+OUALx9JM6NXgh/oREZ9Ex/m7SUhJA0BdRRkjXU2MdTQx0tHM8t5QR5N9N1x5/DaQGc4NaVk16yCnIAhsOXmfrace0LN5Zf7q6ISCgojwqASGTjlAIWMdVs7oiOr783n8xJcp047Qvm0lhgyun+VmJggCuzZe58D224ya3JLm7Sv90Hl+jXdvQhnZeyt9/2pAp541f9pxPhARkcDU6UeJjEygXDlLtLXV0NZSQ0tbDR1tdbS01NDRzvisraWGto46MqmMiMhEIiLiCY9IICIigcjIxMz3sbHJme3b2BjTq4cjtRx/L0H/QIGwF5AjpDI595/6cOLScx4998PIQItWDcvRqqF95uP/t/hwqf1MF4xUKuPaEy+OXH3OC68QrM0N6NSgPM1qlkZTXQWZXM5r33DuvfTlzgtfPP3CUVZSpGKpwtRysKamvTV6Wur0mbMffW0NNkzqlG2K3dwwa58LD94EsGFYe0z0tNBU+3oUiEwuZ9WpO+y+9pQ+DSszopUjiv8qSHLurgdzt7vg3KgCI7vWAcAnIIq/ph/Ewc6CuX+3yRwPuHL1FQsXn6VDu8rZivu+rTfZs/kmwyc0p1WnvM81lJ4m5a+em9HV02DRhl4/3e/82jOE6TOPoa2tzrx/OmJuppcn7aanS4mMTCQ5OY3ixQv9loL+gQJhL+CrJCaLOXrOlTNX3IiITqSKQxHaNimPYyWbXxKPm1NS0yTsu/iE49dfEhOfglMFGzo1rEAVO8uv3kii4pK57+bL3Re+PHT3J1mcjqa6Cmoqyuye1R1jfa0f6teboEi6Lt7L3J5NaVHFLlf7nn74in8OXqV6SSvm926GtnrWnDQX771mxuYLjOxSmx7NKgPg5hnM6NlHaORkx8ShjTPP/eq1VyxYdJa2rSvy17CGn30n+7fdYtfG6wwd15S2XauRVwiCwMZlF7l05jkb9w/B1EL/2zv9ALduezJ/4Vkc7C2ZPq3ND6Uj+aMR8omUlBQBEFJSUvKrCwV8gxevg4QOgzcJzXqtEdbtuiEEhsTkd5e+yMzNF4S6g9cIaw7dEoIj4r6rjXSJVHjs4S+sO3JbeOUTmif9Wn36jtBi1jZBJpN/1/7PvIOF+pM3Ck1nbBWeegV+tn7vhSdCld7LhGtP3mYuu/3oneDUcamw98TDLNtev+Eh1G+0QDhz9lm2xzqw/ZbQuPIsYcbYA4KPV9h39fdTXj71E8YM2C40rjxLcDmT/THzkvR0qdCi9TJh4eKzglQq++nH+50pEPYCsuXMlZeCU8elwvi5R4WYuKT87s5XufLojVCl9zLhpuu7/O7KZyw5dkPoufTAD7URFZ8kDN9wQqgwYoWw+vQdIV0qzVwnl8uFedtdhNqDVgtvAyIylx88/Vio1WGJcOdx1u9ky9YbQtMWSwR//6hsj/Xg9hthiPMGoUmVWcLCaceE4MDoXPfX0z1ImDx8j9C48ixh/OCdgvvzgFy38T08dfUV6jVcIASHxP6S4/3OFLhiCvgMV7cAxvxzlK6tKjOkh9NvHZYYFZdE16m7qVepOFP7Nc7v7nzG/MPX8A6NYtuoH8tgKQgCR+68ZPmJW9iYGbKgdzOKmGS4NSRSGX8tPkp4dCI7Z3ZDX0cDQRBYsO4iNx54sXF+N2ysMvLKSKUyRozei0wqY+3qXtmG9cnlAreuvGLXxuuEh8TRtG0Fuvevg6Hx18dSfN+Fs2vjde7ffEPJMhb0GVqfClWtf9n1s3HzNe7df8fuHYN+yfF+Z37/GSIF/FKCw+KYtvQ0TlWKMbj77y3qACsP3ERbQ5Ux3ermd1eyRSKVoaT442MRIpGIzk4O7J/QDblcoMuivRy9+xJBEFBWUmTR8FYATFp3BolUhkgkYvzgRthYGTFp4Qni39ddVVJSZNrk1gQFx7Jt+81sj6WgIKJu47JsOTyM4ROa8/D2W/q2W83WNZdJiE/9bPsg/2gWTD3G0G4bCQuJY/ayrqza0Z+K1Wx+6fXz6LEP1ap+Xm7w/5ECi/0Xk5Ym4al7ADKZgEgkQkEh40erIBKhoCDKfC9SyHi1tjJCR+vXDAAlp6QxePI+VJSVWDe3K+rfiN7Ib9LSpTQavp5RXevQof6vmWSTW6btuUh8spg1Q9rmWZsSqYz15+6x8+oTxrSpTa8GGWGKXoGRDJh7kKY1SjGpd8YAaXRsMgMn7sXSXJ9l0ztmRspccnFj0ZJzLJrfmSpVvi6GaWIJZ44+5tDOO0ilcjr1rEk75+okxKewb+tNLp97gXlhA3oNrodTg9L5Ei0SHhGPc/cNLFrQhSr5UHz7d+PPSKuXRwiCQHBYHB5eoYjTpJQuYYa1peEvmfabkprOiUvPOXj6CbHxKTneT01Vica1S9OxeQVsrIx/Wv9kMnlmfvQti3r89qIO8PxtMOJ0KTXtf98fskQqQzkPLPZPUVZSZFQbJ3Q01Vh56jY2pgbUKmNNCUtjZg1qysQ1Zyhe2JhODctjqK/J/IltGDbtIBv23GREn3oANG5UlkePfVi45BxbN/VD/31+9+xQVVOmY4+aNGtbieP773N4911OHHhASnIahiY6jJnamgbN7PO18tGjRz6oqSnjUFBSD/iPC3tsfDIeXmG89grF410Yr9+FkZgkRlFRAWUlBcRpUjTUVbArbkrZkuaUtTWnjK1Z5sy9vCAhScyx864cPueKVCqjXZPydG5VCV0tdeQZg9fI5e9f37//8DldIuP2o3ccO+/K6csvqVTOig7NKuBYuVie34w27r3FU7cAVs/pQiEjnTxt+2dxz80Xa3MDzH7j/kqkcpRzIXh33/pz750/TcqWoJyl6VddGX0aVMY7JJpJO8+ze1xXbEwNqVepBIPb1WT5/usUMTegamkrShUzZcLgRsxdc4GSxUxp7GSHSCRizKgmDByyncVLzzN/bsdvuk00tVTpOagurTpV4fThRxgYadOkdYV8TQ3wgYePvClf3ipHqQD+H/jPuGJkMjmv34Xh9iaY115hvH4XSmhEAgAWpnqULmGGXXFTSpcwo0RRYxSVFPHxj8T9bQiv3oTi/jaE4LA4AKzMDShb0owytuaULWlOkcKGuU7+FBufwuGzTzl24RkKIhGdWlSkY4uK6H7HTUMuF3j43Jej5115+MwPMxMd2jUpT8sG5fLkJnT+mjvz111k2ohmNK3746XefhWdJ++kpr01o53r5HdXvsiIjSfR1VBjbq+m39w2OimF1it2IZXJSUpLx8pQjxYOJWlRvhTWxgbZ7pMmkTJg9RHiksXsHeeMrqYagiAwZf05Hnv4s3Nmdwqb6AGwesd1Trq8YOM8Z2xtMvLeuLkHMmbcfoYNbUD7tpXz7Lx/JenpUtp2WMXggfVo0/rPKdryM8l3YU9OTkZD4/sqJ0llcl54BHH9/htuP3xHdFwyejrqmSJu9/41p2IaG5/Mq7ehuL8Jwf1tCJ7vwhCnSVFRVqRoYUOKFTHO/Cte1Ah93c8fX6Nikjhw6jEnXV6grqZMl1aVadekPFqa31fw+N8EBMdw/OIzzl1zRy4XMt00xYp8n5vmpWcwo2YepnPLSgzt+WvyjOcFIZHxtP17G2vGd6Ba2V+Xdya3DF57DHMDHWZ2a/TNbccfOMcz/1BOje6Jb2Qs5154cuHlG6ISUyhjYUKL8nY0s7fFRCfrpKnI+CS6Lz2AdSED1g1th5KiAuI0CQPnHyJdImXbdGe01FWRyuSMnXOE4LA4ti7uib5uxu9u5+7bHDj4gA3remNj/fNzuOQ1rq5+jJ94kH27h2CWR7NMf0fcPIN58tKfvp2/nZIh34W9cbdl2NlaUtKmELY2JpQqZop5Id0vPhZKJDKeugdw88Fbbj96R1xCKsWsjKhTw5a61Utgbfnt5E45RSqV4RMQhbd/JO/8I/H2j+KdXwRxCRmRAQZ6Gh/F3sqIV16hnLvqjo62Gt3aVKF1I/uf5qtOTknjwo1XHD3/jKDQWMqVsqByOSvs7QpTxtYss+Dx1wiLiGfAxL2UsTVnwcS2v/UU6X9z9NoLVh+8yZV1w37rCkz9Vx2mmJkRUzrX/+p21zy8GbHnNBv7tMWp5McxA5lczkPvQM698OSy+ztS0tOpZmNJy/J2NCxbHG21DIPhVUAY/VYepn3NckzsmOFHD49OpPfsfdhZF2LpqDYoKigQG5/CgAl7sDDVY/mMTigpKiCTyRk9dh/JKWlsWNs7M8/Mn8KGjVd5+MiHndsH5ndXfgpxCSls3Hubs1fdqGxfhJUzO31zn3wX9j1H7+AbHM9bn3D8g2OQywW0NFSxtTHB1qYQJW0Koaejgad3GB5vQ3nmEUhScholixWibnVb6lQvgZV59o+pP4uYuORPxD5D8P0CozHQ06BHu2o0r18W1V/k65PLBR698OPy7de8fB1EaEQCigoibIsVonK5IlRxKELZkuafiZ+bZzAL119CUVGBjfO75ehG8Dsxed1Z4pJS2TDx2xd5fiGRyeg4fw9OZawZ3/7L7iKZXE7DRVupXsyKBZ2/7LIRS6Tc9PTh3HNPbr3xQ1FBxMrurXAqWRSAS0/fMHHneSZ3qk+X2hlRQi+9Qhi66Ajdm1ZiWMeMIshvfMIZOvUAHZtVYFivjH6FhcUxcPAOGjUqw8jhv998gC8hFkvoP3Arjo62DBvyY8nafkcePPNlzspzKCspMqJvPRo4lsyR4Zrvpk6H5hUzfeyp4nS8/aN44x3GG59wHj/348jZp8jkAkYGWpQuYUbfTjVwqloc80J6+dZnAz1NDPQ0qeJQNHOZVCpDQUHhl1u9CgoiqlewpnqFDCsvIjqRl6+DcXUP4OpdT/Ycf4iqihIOpQtTxaEIpUuYccrlBS63XlOpnBWT/2r6x4k6QMWShVm27zovvIJxKGGR3935DJlczvTdl4iIS6J55W/XGI1ISKau3dfDDtWUlWhSzpYm5WyJTxUz99Q1xuw7w5b+HahQxJwmlUoSEBXHwqPX0FJXoUUVO+xLmDOhZ33m7bhMeVsLatpbU9KmEGP7N2DRxkvUqGRDhTKWmJrqMWpkY+YvPEN5BytqO+V/XdRvIZcLLFh0hqTktP+cb10QBI6cc2Xtrhs0qmXHmAENcuXOzXeL/VuDp2lpEhJT0jD6wWRM/68Eh8Xx5KU/T17689QtgIQkMWYmOgzvXZfa1Ur89hOQvoQgCIxdeRLvoCj2zumJzm+U7EkQBOYdusqphx6sGdyG6qW+PQZQbdY6xjV3onNV+xwfRyKTMWrvGZ75hbBrcGdsTY0QBIGVp26z97orS/q1pL5DcQRBYNbmi9x392PvnB6Y6GsjCAITF5zANzCKXcv7ZN7cV66+hMtld9as6kkxm9/b375py3WOHX/MkkVdcbC3+vYOeYBUJic4NBYLU72flgRPKpWxYts1Trm8YHB3J3q0q5rr3+lvL+wF5B0ymZyAkBjMTXT/OD9qdsQmpNB9xh5q2lsz7TdKJ7Dq1G12X3uaKaw5odGibXSpbs+AOrlLmyuWSBm0/TgB0XHsHdKFwga6CILA/MPXOHHfndWD21DTrijJqen0nr0PAx0N1k/M8K1HxybTa8xOalcrwcShGd+fRCLj74kHiYhMYMPa3ujqfl9gw8/m7PnnLF9xkUkTWtC4UbmfeqyExFQePPfj3hNvHjzzJSk5DU0NFSqWsaJK+SJUsS9KYTO9PDGSEpLETF96mldvQ5g+sjl1qtt+VzsFwl7AH83ZO6+Yt92Fwwv6YFno56aEzQnbXB6x5sxd5vZs8lmRjK/Rcc0+apawYmxTp1wfMyFVTJ8tR0lJS2fvkC4YaWsilwvM2HuJK8+9WD+sHRWLF+ZtQCT95uynR7PKDOngCMC1e2+YsewMS6a0p0alDFdQbGwyQ4fvwtxcj8ULuvxW6ZljYpJwufKKrdtu0N25Bn375H0klyAI+AVFc++pD/ee+OD2JhgR4FC6MDUrFaNsSXM8vcN4/MIfV/cAUsUSzEx0qOJQlCoORahU1uq7wpADQ2KZsOA4YrGEhZPbUdLm+0sxFgh7AX80UpmcLlN2Uq64ObMGfjtWPCdEJSSjqaryWVWlb3Ho1gsWHLnGpI716FqnfK727bf1KJYGusxu/+2wyOyITEym58ZDaKiqsHNgR3TU1ZDK5EzYfo6HbwPYPKIDZaxMOXbtBYv3XGXN+A5ULZPhIpq98hyu7gHsWdEnU5DevQtnxOg9NGtqn++DqcnJady+84ar1zx49twfNTVlWrYoz+CB9fI0Au7Zq0DuPvHh3lNvQsLj0dFSo0ZFG2pWtqFq+aJoZ+Puk0hkeHiF8uiFH49f+OPpHQZAyWKFqOpQlCKFDdFQU0btfXnID+/VPyxTVUYkEvHULYBpS09jUUiXhZPaYWTwY67nAmEv4I/nwj0PZm+5xKEFfShi+mNWu1dIFH1XHEIql1O7jA1NK5XEsXRRVL8RUnnu8Wum7r7IXy1rMrBJ7gtVjN53BhEiVnRv+b1dJygmnh4bD2FlqMfmfu1RU1YiXSJl5OZT+ITFcGhiD/Q01Zi64RyunkHsndMTIz1NEpLE9BqzEwe7wswe+/H4N26+Zs7cU4wb04wWzX9tLh6JRMajx95cuerB/QfvkMvlVKtajAb1S1OjevE8dyUu3ujC6csvsbEyomYlG2pWLkaZEma5nuGdkCTG1S0gU+jDoxK+WltVJAI1VWXS0qXUqVaCqSOaoZYH51Yg7AX88cjkcrpO2YWddSHmDG7+3e2ExybSc/lBChvq0rRSSS65vsXVOwgNVRXq2RejScWSVC9l9Vnul+svvRm/7Qw96lVkdJvvy4g58/hlgmLi2Tag43f3H+BtWBS9Nx2morUFK7u3RFlRkfhkMV0W7aWEuRGrBrUhRZxOz5l7MTPSYc3fHVBUUODBM1/Gzz3G7LEtaeD4MSJm2/abHDrykOVLu1G2TOEf6tu3kMsF3NwCuXrdg5u3PElMFGNfzpKGDcpQ26kkOjo/RydSxem07r+B/l0c6do6b2fffkgNIk6TkJqaTuqHusCpko/vxRLU1ZSpVyPv6qcWCHsB/wkuPfBkxqbzHJzXG2tzw1zvn5iaRt8Vh5ALAjtGd0H3/WN3eFwSl5+95ZLrG9z8wtDVUKNB+eI0rViSSiUK88QriOEbT9Kqqh3Tu35eci6nLLtwm/vvAjg6ovt37f8pz/xDGLDtGI3LlmBexyYoKIh47hNC/1WHGdm6Fr0bVOa1Xzj9/zlAv9bVGNCmBgBLNl3m+r03bF/SE1MTXSBDbKfPPIbnm1A2rO2NicnPycsTFh7P5KlH8PePwsbamAb1y1C/vh2F3vfjZ3Lljif/rDrHiS1DMND7cjK0P4kCYS/gP4FMLqfbtN2UsDRm7tAWudpXIpUxfMMJvMOi2T3OGXOD7MUrOCoel2dvuej6hjdBkRhqa5CSJqF2WWvm9272WcHp3LDlxiOOPHLDZUL/727jU26/8WP47lM413BgYos6iEQidlx+zLqz99g+ujP21mYcuuzKiv03WTehI5XsLElJTWfIlP0oKiqw/pO0zcnJaQwfuRtVVWVWreie526Q4JBYxv19AE0NVaZMakmxYt8/aPg9TJh/HKlMzvLpP/a09DtRUGijgP8EigoKDGhbg8uP3vAuMDLH+wmCwOz9l3HzD2PtkHZfFHUACyNd+jaqwqGJPTgxtTedatnTtkYZ5vZs+kOiDqCrrkZCalqOt7/u5UO9tdu4+tY72/VOJYsyv1MT9t57xuYbjwDo3aAy1UpaMXHneRJSxHRuWIHaFYsxfdN5YhJS0FBXYcHEtoRHJjB/7UU+2Hyamqr8M7sDIaGxLF1+gby0BQMCoxk9dh86OuosX+r8y0U9PjGVh8/9aOSUu0LjvzsFwl7Af4YGlW0paWXC8CXHuP/SN0f7xCSmcPbxawY1rU4py5xPyLE2NWBI8xpM7FgP5TwIBzTU0iBRnEZyWnqOtp998RrB8QkMP3qGHQ9dsxXbFuVLMbVVfVa73GOVy10UFET807MJUpmM6XsuIQgwrV9jlBUVmbnpAjK5HAtTPeaMa8WNB285d809s63ChQ2YPqUNV695cOfu2x8+3w9s3nIdXV11li9x/uUx83K5wPItV1BXVaZOtRK/9Ng/mwJhL+CnIggCYdEJXH/ixfqjd7j6OO9E4d8oKIhYN6Ejle0sGbX8BMv33yBdIv3qPoY6mtQtZ4PLs7d5aonmFjvzjJvK65CIHG2fIpEwo0k9RtetyaKrtxh94jzJ6Z/fFJxrODCzXQM2X3/E3bf+GGhrsKhPc+54+LLr2hN0NNVY8FdLnnoGsu3UAwAq2xehY/OKrNt9k5i45My2qlSxoW6dUmzdfhOZTP7D5yyTyXnxIpDmzRzQ+kVVwj5l3e4b3HzoxbwJbf7ItBpfo0DYC8gzBEEgPDqRG0/fseHYXUYtO06TkRtpPW4rk9ad4dIDT6asP8utZ9m7D/ICbU01/hnSnJkDm3L6lht95xzANyT6q/sMbFoNj4Bw7r32/2n9+hZmetroa6rjHhSeo+3lgoCSggKDa1Zlm3M77vsF0GnHAXyiYz7btlOVcjQpV4KpRy8Rl5xKxeKFGdm6FmvP3OXpuyBK25gyxrku204/4IG7HwADnWuhrqbMqu3Xs7TVv28dQkLiuHDx5Q+f87t34SSnpFHB4denXT589imHzjxlyvBmVCr3a9IR/EoKhL2AH0Iml7P7/GNGLz9Os1GbaDVuCxPWnOba47foaKrRp2VVNk7uzLX1wzm5pD+tnMoyY9P5XPnBc4tIJKKFY2n2zO6BspICvWbt4/j1l1+0yMtYmeJoV5TNFx/km9UuEokoa1Eox8Iuk8sz/fqO1kU42b87asrKdNh+ABfPd5+1PaNtQxREImaeuIIgCPSqXwmnMjZM3HGOqIRkOjZwoFHVkkzfeJ6I2EQ01FUYP6ghV+96cv+pT2ZbFhb6tGxRnl2775CamjO30Zd4/jIAXV11ihQx+qF2csu1e29Ys/M6Q3vWpvF/zLf+gQJh/woxCSlceuCJ65sgEpLF+d2d35JVB2+x6fg9tNRV6dmsMhsmduLa+r84srAv/wxpTrcmlahYsjCa6iqIRCIm9mqArZUJ41aeIiYh57VfvwfLQvpsndoV58YVWbT7CpPXnUUilWW77cCm1XjhG8rjt4E/tU9fo0zhQrwKzpmwS+VyFD+JeTbX1eFAr860KG3L8GNnWHr9DlL5R3eJnoYa8zs14cqrd5x86oFIJGJOj8aoKisxeecFZHKByX0aoaOpxpytl5DLBWpWKkYDx5Is3XyZlE9EvGcPR1JS09m6/eYP3QhfvAjAwd7ql2ZEff4qkH9Wnad90wp0a5O7vDx/EgXC/i+SUtI4e/sVI5Yeo8XoTUzfeJ4hCw7T8K/1tBy7mdHLj7P28G0u3nvNu8DILwrF/wPHrr3goIsrMwY0Ye7QFnRvVplKdpZoaXw5vaiykiKLhrcCEUxcc/qbPvAfRUlJkWEda7FuQkfuu/mx8sDNbLcrb2NOVVtLNl96+FP78zXKFi5EQHQc8anfNiLkcgFFUdafr6qSEnNbNGJei0bsfOhK/wPHiUn+ePOsXtyKPk6VmH/mOgHRcehoqLG0f0te+Iaw4fx9NNVVmD2oGU9fB3LwsisAI/vWJzk1na0H72a2Y6CvydjRTTh56ul3i7tMJuelWyDlHX6dG8QnIIpJi05So5INI/vmXTqC35F8z8f+OyBOl3DnuS8uDz2598IXuSBQ096a2YOa4VShGAlJYrwCI/EOisIrKJI7L3zYd+kpMpkcJUUFipoZUKywEZVKFaZhtZJoqedNGbycIJXJefTKH6+ASKqUscKuaKFfcsE+cPdj6d5rDGxbgybVc5e7W19Hg+Wj29J/7gEW7b7KtH6Nf3qfK9tZMa1/Y6auP0cZG1OaO36eoGtg02oMXH2UZ97BVCj263O8l7XICPXzCA6nRvGv+52ln7hi/k2n8mWxK2TMiGNnabd9P6vbt8TBwhSAUY1rcs/Ln0mHLrJ7cGfsLAsxsWM9/jl4BQdrM2qXtWFA2xqsO3KHynZW2FoZM7xXXRZvcqGRUynsipsB0KB+GaRSOYuXnkNJUSHXybi83oWTkpKOwy8S9sjoRMbPO4a1pREzRzXP82Lwvxu/7QSl6Phkrj99x9VHb/ANiaFYYSNKWBpja5XxV9TM4IeyzkmlMh55BHDpgSe3XL1JSUunUilLGlcvRf3KJb6Z3ztdIsUvNBbvoEi8AqPwCozE1TMIRQURDarY0rp2WcrbWvw0wXobEMn5ux5cvP+amIQUdLXUiE8SY6yniVOFYtSpUIxKdpY/pWycd3AUA+YepJaDDXMGN/vuc7z93Ifxq04ysnNtujf7NYWUVx28ydGrz9k6zZmSRbKGNwqCQL+Vh1FTUWbDX+1/SX/+Tf0FW3Cu4cDAulW/uI1cECg1fyWr27egqd2X07rGpqQy7tQFHvoHsahVY1qWybgBe4VF0XndfgbWqcKwhjUQBIHpey5x65UPByf2oJCeFkMWHCYxJY2dM7uhqqzEyJmHSUwWs3VRjyy/uwsXX7Bk2QX69KpFr561cnyeBw8/5PCRhxw7POKn39STktP4a/pBJBIZG+Y7f1dB+T+NHAu7t7c3M2fOpHz58nh4eNC5c2eaNm1K9erVUVPLEMFatWoxd+7cHB04O2GPTUjh+tN3XHn0BlfPIJSVFanlYIOddSH8QmJ4GxCBT3A0UpkcZSVFilkYUuK90JewMqF44YxCA/FJYhKSxcQnpb5//fg5/v1nT79w4pPElLUxpXH1UjSsaouR3o9lVItPSuXifU9O33LHKzASK1N9WjmVoYVj6R9uGyAqLolL9z05d8+Dd4FRmBvr0rymHc0dS2NhrMsb/whuPfPm1jNv3gZEoqmmQvVyRaldwQZHB5s8KUYRk5BC3zn7MdbTYt2Ejj9cAnDP+cesPXKbZaPaUqv81ysI/RtBEFi94zriNCm9O1TLnAb/NaQyOSOWHCU0OpFdM7uhq5X1R37vtT/D1h9nz7iulCtqlqv+5AUj9pxGQSRiVY9WX9xGIpNRZuFq1nZoReNSX8/3LpPLmXf5Jkeeu3Gif3eKG2WkW9hz15Ul52+xZ3AXHKzMSE2T0GPZAdSUldg5pguRsUl0n7GHFo6lGd+jPgEhMfQZu4t+XWrSo13WJGdnzz1n+cqL9OtTmx7dv11oGWDSlMOoq6swc3rbHG3/KSmp6bzxCUdHSw1dHXX0tNW/aORJJDLGzzuGX2A0Gxd0w+wXpCgQBIHXvuFcuP8aTTUV2tQph5nRz0nF8CVyLOyPHz8mNjaWxo0bExkZSZUqVfDz82PWrFnMmjUr1wf+IOwh4dE89AjiyuO3PH0diJKiAo4ONjSoakstB5vPUqdKpDJ834v824BIvAIj8QqIICE5+1l7iooK6Gqqoaulho6WeuZ7y0L6NKxqS2ETvVz3/VsIgsAb/whO33Ln4n1PUtPSqWlvTevaZXG0t87Vk4Y4TcLNZ96cv+vBQ3d/NNRUaFjVluaOpXEoYf5Fayc0KiFT5F3fBIEgUL5kYWqXL0adisUwN879BZ6WLmXY4iNEx6ewY7oz+jo/PqFEEATmbL3Ejafv2Dq9K8Usch4hsfvYA7YevIuRgRYxccm0aeRAzw7VvlltKyYhhV4z92JjYciKse2yuDQEQaDLon2UsSrEzG7fl0L3R9h47SHHHrtzeeKXUwuIJVLsF69hY6fW1Lct9s02JTIZzrsPI5XJOdy3KyqKisjlAoN3niAwOo5jI3ugqaqCb1gMzkv24Vy7PKPaOHHx3mtmbL7AyrHtqGlvza6jD9h17AG7l/emsFnWLJqnzriyarULA/vXxblr9a/2RyaT07rdSgYNqJvrknbBYXGMn3eMwJDYLMu1NFQzRF5HHV3tj69+QdE89whi3T9dsf2B/OY5ISYhhQv3XnP2jjveQdFYmeqTlJJGbGIKNe2taV/PgZr2RX94lnJO+C5XTHh4OPXr1+fVq1d06NCBatWqkZSUhLOzM3Z22YcPSSQSpNKPA2WpqakYGhpStedClFXUqOlgTcMqttQqb4OGWu4mCwiCQHhMIt5BUSgpKmaIuKYaulrqaKgp5+sgiThdwo0n7zh1252nrwMx0NGgYVVbNNRUkMrkSGVyZB9e5Vk/i9MlPH8TjDhdQo1y1jR3LI1TeZtcW8mJyWLuuflxy9Wbe26+JKemU6qICU1q2NGkeimMcpD4KD4plTlbL/HsTTBbp3XFxiL3iba+RLpEyrBFR4mMS2LZqDYUtzT+5j4eXqEMmrSPkX3r0a5Jec5cfcmuow9ISk6jWb0ytGpo/9VCBe7eoQxecDhLkecPbLn4kP03n3FpzoCvurLOPvdk+YXbWBvrY2NimPFqbIC1sQEmOpq5vu7kcoGzz18z+cgl7s0Yiq569k9YyenpVFiyjk2d21CvRM6ecvxiYmmzdS9dKpRjSqO6AEQkJNFu1R6cbIuyoHNTRCIRx+66MffQFbaM6ETlEoWZtvEcTzwCOTivN5pqKvSfsAd9XQ1Wzuz02fkdP/mEteuuMH5sM5o3+3KaX3f3IEaO2cuOrQNyFeoYGZ1I3/G7MTHSYcao5hlP5wmpxCemEpuQmvk+LiGFuPfv09KkjOpXL0t94p/B2sO32XfpKWrKSjSsaksrp7KUK26GVCbnpqs3x6+/4MnrQEwNtWlZK+Mp3uInGJUf+C5hnzZtGtWqVaNVq1Y8efKEypUrExsbi6OjI66urpmumU+ZNWsWs2fP/mz5yWuuNKxeBs3/2Myv7AiOiOP07VfcfeGDIICSkgKKCgooKSqgqJjxqqTwyXtFBUrbmNKkeikMdfMm65xEKuPJ60CuPn7L1cdvSRVLqF6uCM1rlqZ2xWKoqXye4OnOcx/m7biMSATzhragQsm8T98ak5DChNWn8fQLZ2TX2nRqUP6rwvjqbSiDJ+9j/Txn7EtlDHSmpUk46fKCE5deEBQai621CS0alKORkx062cxsPH3LnbnbXZjStxFt63wsrxYWm0ibf3YwrEVNejf4su9/6YVb7Lj1lLaVSuMXGYtPRAwJ4ownRw0VZayNDbA21sfa2IAiRnpIZXJik1OJTUkl7v1rbHLGX1yKmLiUVGRygcL6Opwd1+ez9MAfEASBOmu20s6+NGPqOubo+wU47f6a8acuMqtpfbpVyhDeW56+/LX7FMMaVGdog+oIgsCo9/nbj0zqiVQqw3nabsrbWjB3aAtevQ1l6NT9jBvYkDaNPxfv1WtduH37Lfv2DEHlCwbIxMmHiI9PZcO63rm6+Z275sayLVc5u33YbzVTNCgijg4TtzOoXU26Nan0xQIt/qExnLzpxoV7GeNiFUsWpmWtMtSvUiLXxuy3yLWw79u3j/j4eIYNG/bZuho1arBlyxbKli372bovWewF2R3zD3G6hNvPfDh39xUP3PxRV1OmYZUPbh4LUtLSWbH/Bmduv6JpjVKM617vM590XiKVydl++gHbTz+kpr018/9qke2NBjLEbcDEvRQ21WP22FafrXvhEcTZa25cv/cWAahbvQRtm5TPvAl8YMOxu+w+94jlY9pRo1zRzOVrz97l4M3nnJ7RFwPt7F1OW28+5vDDl5kZGQVBICY5Fd/IGHwiY/CNiMU3MgbfyBiC4xJQFCmgp6mGvoY6+poa6Guqoaehjr6m+vtlGX925iboa379e57ncoNb3n5cHJI7cVx7+wFrbz9gQ6fWmdb+gfsvmHv6Ggs6NaF1xdKExyXRYf5uWlcrzYQOdbn7wocxK06yaHgr6lUuwfrdNzlx6Tl7VvT5bFwjMiqR7j03MOKvRrRqWeGz4z956suESYdYtsSZCuVzN+N02ZYrePlGsHF+t1zt97NZuvcat555c3xxf5RyEG0jlcq47+7PuTuvuPXMGyVFBepXsaVlrdJULGmZN3H9Qi44dOiQsGbNGkEQBOHixYuCh4eHsGPHDkEQBEEqlQpFixYVYmJictRWSkqKAAgpKSm56UIBP4nI2CRh74UnQrdpu4UqvZcJbcZvFVqO2Sw0Hr5euPb47S/ty7M3QULdwWuEdUduf3W789fchNqdlgmR0Ylf3CYxSSycuPhM6Pf3bsGx/RLh5oOs5yKXy4UZG88LdQavFt74hWcuT0pNExpM2SjMPXjli20ffvhSqDJzbY7OKV0qFeRyeY62zQlPAoKEEnOXCx5hEbnaTy6XCxNPXxTsF60W3ELCMpcvOX9TsJ+6Urj/zl8QBEE4cd9dKD9iueDqHSQIgiDM3nJRaDJigxCbmCKIxelCtxHbhCGT9wnp6dLPjrF0+XmhW88NglQqy7JcJpMLAwdvEyZNOZzb0xUEQRAGTNgjrNj65f9HfpCQlCrUHrRa2HP+8XftH5uYIhy+/EzoOXOvUKX3MqH12C3CxmN3hICwnOnol8ixsD9+/FjQ1dUV6tSpI9SpU0ewtrYWgoODhXbt2glz584VBg8eLOzevTvHBy4Q9t+XN/4Rwor9N4T5Oy4L0fHJ+dKHgy6uQvV+K4R3gZFf3EacJhFa9FkrbD1w55vtyeVyYeH6S0LDbiuFt77hWdalS6TCkAWHhOajNgphUQmZy4/fcxMqjFgheIVk3wcXt7dC6UnLhXTp5+L2s5HJ5UK9tVuFfy5dy/W+6VKp0HvfUaHmio1CUFx8RnsyuTB231mh2qx1QnBMvCCXy4Wh644JrefsEFLTJEJ8UqrQfNRGYdqGc4IgCIK3f4TQwHmFsGLr1c/aDwqKERo0XihcueqeZfklFzehQeOFgo9P7m5GgiAI6elSoW7n5cL56+7f3vgXsuf8Y6H2oNVCQlLqD7f1LjBSWHXghtB05EahSu9lwoB5B4UTN14KiSniXLeVK4s9LykQ9gK+hlQmE3rP2iv0/+eAIJN92dJdt/uG0G7Qxs+sw+xIT5cKf00/ILQbtFGIjk3Ksi4+KVXoPHmH4Dx1l5CYLM7sQ+eFe4Rh645n295D7wCh9KTlQmRCUrbrfzbr7zwUKi9dJ4glklzvm5AqFlpu3i003bhTiEvJEKXUdInQYtkOYcDWo4JcLhdCYxKEmuPXCstP3BQEQRBuP/MWqvReJlx/4iUIgiC43PIQHNsvES7d8vis/TlzTwr9BmzN/N+lpUmELs7rhCVLz33XuXp6hwmO7ZcIPgFfvtH/aiRSmdBq7GZh6d7c31y/1e6d597C5HVnhJr9Vwq1Bq4Spm04Jzxw8xOksm9f54IgCP/t6VcF/LEoKigwpU8jXvmEcvKm2xe3a1GvLBFRiTx1C/hmm8rKisz7uw1KigpMWXyKtPSPYz46mmqsGNOOmIQUJq87i1QqQ1FBgfHt6nD3tR93Pfw+a09PI8MPHpeSP3mEOtiXJiktnUueXrneV1tNlc1d2pIoTmP4sTOkS6WoKSvxT4fG3PcO4MTTV5jqazOmrRN7rrni5hdKrfI2NHcszcJdV4hPSqWRkx2dWlRk8YZLePtnTerWzbkGvn6RPHiYkZDs+MmnxCek0Lu303edq+e7MNTVlLEyN/iu/X8G1596ER6TSJdGn48l/AgfQr7nD2vJ+ZWDGNW1DsERcYxYeoyeM/fmqI0CYS/gt8W2iAldG1dk7eHbRMUlZbtNkcKGlCtpzrlrXxb/T9HVVmfR5Hb4BkaxeKNLljwn5sa6rBjbjhdewWw6cQ+AKraW1C1XjGUnbiL9Vw5yPY2MSJuc5Hb5GZhoa1G3hA2Hn7l/e+NsMNPRZnOXtriHhjPl3GUEQaBCEXN61KzA4nO3CI9PokPNclQuUZiZ+1xIl0gZ260uCgoilu+7AcBfvepga1OIqYtPkfTJXJJiNiZUr1aM/QfuE5+Qyr799+jYoSrGRtrf1VdP73BsrQv9VqkADlxypXaFYj9lLswHdLXU6Vjfge0zunFofm8Gtc3ZBLDf51sqoIBsGNSuJloaKqzYn33yLoAW9ctx6+E74hNTc9SmtaURs8a05PLt1+w7+SjLOruihfirkxP7Lj7FPzQjt/mYtk4ERMRx7G7Wm8eHOPP4fLLYATqXL8ujgCB8o2O/vXE2lDY1YXX7lpx79YZVN+8DMKqxI3oaasw+eQWAmc6NCI1JZNPFh+hoqjG5d0Mu3H/NjafvUFJSZM64VqSKJcxdcx65/OONsptzDTxehzBj1jGUlBTo2rlatn3ICW+8wyhV/NeWzfsabu9CcPcOxblJpV92TGtzQ+pW+vpM4w8UCHsBvzXqqspM6NmAy4/ecO8L5e7qO5ZEUVHE5duvc9xujYo2/NWrDpv23ebO46z5yzvUd6CouQFL911HEASKmOjTpbYDG87fI+ETEVdVVkJdWSlfhd2pWFEKaWtx9MX3We0f2pjdrAHr7z7k6HN31FWUmdOhETc9fTn34g0WRrqMal2LnVce4xEQjlOFYrRyKsM/2y4RFBGHkb4Wc8a34r6rL3tPfMyOWbZMYRzsLXFzC6JXj1poan5fcry0dCneAVGUKmb63eeY1xxwcaVUERMq2P76ZHE5oUDYC/jtqVXehgZVbFm06yqpaZLP1muoq1C/ZsksNTpzQueWlWjZoByzV57jnd9HH7GSogJ/96jPQ3d/brhmiP7gZtURBNjqktXC19VQIy7l208Kz4JCCIlPyFX/coKSggIdHcpw/KUH6bLvTyHduUI5htSsyowLV3EPDaeqjSVdqtkz//R1ohKT6ezkgIO1OTP3uSCRyvi7R31MDXWYuOYM4jQJDnaF+atXHbYcuMOj536Z7Q4aWI+GDcrQqmX57+7bO79IZDL5byPsoVEJXHvsRbcmlX7b1L8Fwl7AH8G47nVJSk1j8PxDBIR97nZo3cgBL98I1u++mcUd8DVEIhFjBzSkpE0hpi05Rar4YzGJCiUL06R6KdYcuoVUJkdHQ40hzauz/8YzAiPjMrcz1dXG4xt1SiMSk+iy6xB1126j176jnHjpkW190u+ldrGiRCenfLc75gOj69akvIUZMy5cRS4IjGvmhKaqCtOPXQZgZrdGBEbGsfbsXdRUlVk8ohVh0QmsO3oHgE4tKlK/ZinmrblAckqGv92ulDlTJrX6oUysoRHxAJga5y6RliAIXH74Bnfv0BxfEznhyJVnGOpq0KDqlzNr5jcFwl7AH4GRnhbbZ3RDAHrN2svFe1ndLmVLmjNtRDMOnX3K3DXnkUhyZr0qKysyc3QL4pPErN2V1Y8/uH1NQqMSMo/VsZY9Foa6rD5zJ3ObLtXsueT2loDouC8eI/q9RT+uniOaKipMPXcZx5WbmXjmEg/8ApH/YObsRwFB6KmrUczoxyJGFEQipjepx6vQcM64e6KpqsKiLk256+XH7ruuFDHRZ2Kneuy6+pQ7r3yxMNFjtHMdDl95hrt3aMaNcmADJFIZO47c/6G+fIq1ZUZeIr+gr9eu/TfP3gYzdcM5+v1zgOajNzF3uwu3nnkjzuap71vI5QK+IdGcvuXOyZvudGpYAeUfuFn9bAqEvYDfDkEQ8AyK+MzKKmKqz7ZpXTPqpm6+wJytl0j5xMpuWrcMS6a05/ajd4yfdyzTavwWxobajB/UkFMuL7j75GOh7cImejR3LM32Mw8yUkUrKjK6jROXn3nxwjcEgOYOpTDX02HrzcdfbD/xff6YDvZl2NCpNXdGDmRsPUe8IqLote8o9dduY8WNu/jFfJ/FffmNNw1KFEMpD7IG2hUypoNDWZZdv0OqRELFohaMaFSTFRfv8DIglLbVy9C8cimm771EeFwSLWuVoVIpS+bvuIxEKkNXW51B3Wpx5JwrvoFRP9wfgKKFDVFXU8bDKzRX+x249JSyxczYO6cnnRqW511gJONXnaLR8PWMXXGSkzdefjHaKj4plfsvfdl84h4jlh6j4V/r6TJlF4t3X6WMjSnt69nnxan9NH7bQht/EnK5wA03b6ISkrGzNMHWwhjVn1Dg4v8BmVzOvENXOX7PnbJFTJnQoS721p/nRb/1zJs5Wy+hr63Ogr9aZskI+dYnnPHzjmGgp8nSaR2+mcb3A/+sOs+jF37sXtEHfd2M/DDBEXF0nLSDqX0b09KpTEaOmtVHkchk7BrTBZFIxNHHbvxz6hoXxvfFXO9zd8GVN94MO3oat4kjUFXKel28jYjipJsHp909iUhKpoKFGV0r2tO6bKkcpXcNS0ii9potOU7hmxMiEpNovGEng2pWYVitapkpfv0iYzk6sjtKIgWcF+/DzECHjX+1Jygijm7TdtO3VXX6ta6GTCZn4MS9aGupZZsF8nv4a9pBrCz0mTi0SY62DwyPpeOkHcwb2pKGn7hMouKSuPPch9vPfXj0yp80iYzS1oVwKl8MPW113L1DcfcOxf+9u8/CWJeyxcwoW8yMcsXMKGFl/Ftb6h/4zwi7XC5w65UPOuqqlCli+kuEVS4XuPLCi00XHuATFo26ijIpaRIUFUQUMzOitKUJdpaFKG1lQglzY9R+sCjFf510iZQpuy9yy92H0W2cuPbyHU+8gmhRpRQjWztR6F/FSsJjEpm24RzeQdGsGNsWhxIfIxRCwuMYN/cYEomMZdM6UKTwt9MMJyWn0XvsTmytCzF/YptMQfpn2yVcPYM4sqAPSkqKvAoIo/uSAyzu14LGFWxJl8potnQ79UsXZ2rrep+1e/zlK2acv4r7pJFfPLZULue+bwDHX3pw8fVbihsbMqlhbRytv54oa9+TFyy5dpsHY4aglofX/Po7D9l87zEuQ/tgoq1FdFIK7VfvobyVOSu7t8TNL4w+Kw4xqVM9Ojs5sPv8YzYdv8e+OT0pam7AS89ghk09wD/jW1GvRskf7s/aXTd4/MKfXct752j7pXuvcfuZD8cW9/tiYi5xmoTHHgHceubNnRe+pIjTKW1jSrn3Ql62mBkGeVBz4Fs88PTn9EMPmlS0xamMTZ4kAftPCLt3aDSzD1zmpW/Go5qykiKlLU0ob2NOhWIWOFibo5+HWQnlcoHLz9+y+eJDfMKiaVzBloFNq2FTyJDAqDg8AsJ5HRjBq4BwPIMiSBanZ4i9qSF2VoVwsDajVdXSf8Sd/1eRkpbOmC1ncPcPY+XA1lSxtUQQBK6+eMfyE7eISUqhf6Oq9KxfKcsNMi1dytQN53j0yp/FI1tTvWzRzHVxCSlMXHCCwJBYFk1uR7lS3w5Nc3UPYNSsw0wf2ZzGtTPqogZHxNFx8k6m9GlIK6eMzKVTd1/ghW8ox6f0QkVZiX33nrP0wi1c/u6HsU7WG9Dux8/YePcR90YPztF38S4ymkVXb3PT25e6xa2Z0MAps/LRv+m7/xhaqiqs6fDlikvfQ6pEQpMNO6llU5T5LTMKjjz0DqT/tqNMblmP7jXLs/r0HQ7cfM7hST0wM9Chz+x9aKipsHFSZxQURMxdcx5X90D2reqL+g+mpb1615M5K89xcc+Ib7aVmCym5dgtDGpbI8clFwVBQBDIm8yKOUQQBHZfe8qqU3ewMtbDLyIWG1MDetWvRPPKpX6orOUfLewSqYztlx+z1eURJcwMmdGtEVpqKjzzDuGZTzDPfULwCcuYZGJjaoCDtTkViplTwcaCwka6uX5ElMnlXHnmxeZLWQW9uNmXiwXI5UIWsfcIDOelbyhWxnrM7NaYckV/jxCu/CQ2KZURG08SHB3P+mHtsLPMOhElTSJlzzVXtrk8Qk9LnTFtnWhUvkTm/08qlTFn2yWuPvZi7pDm1KtcInNfcZqEmcvP8vilP7NGt6B2tRJ8i39Wn+eNdzh7VvbJPMbc7S48fR2YabWHxiTQdu5Ohrd0pGf9SoglUpos2UbL8nb83TxrYee1tx9w5pUnl4b0ydX3ctfHn4VXb/EuMpouFe0Z6VQdA82PFmR8qpgaKzexsFVjWpfNvsDNj3DK7TUTTl/k5IAe2BXKcHWtu3KfLTces39oF4qbGNJtyX50NNTYOrITbwIi6Dt7PxN7N6BdXXuiY5NxHrGNjs0rMqhbzuuhZkdIeBydh21l3dyuONh9vR7A3gtP2HrqPmeXD0JL49cVls8NqekSZu+/jIvrW0a0dqRPg8p4h0az6+pTLjz1RF9THec65elYyx4djdyXtPxjhf2lbyizD1wmOCqeoS1q0L1uxWwfueKSU3nhE8JznxCe+YTwKiA8Y5BHQw0bUwOsTQ2wLmRIMTMDrAsZYKqv/ZngfxD0TRcf4BseQ5MKJRnYtBrFzL6vilBgZBz/HLzCE68gutetwLAWNb+YnD+v8QyMICUtHSNdLYx1NH/Zcb9EWGwiQ9cdR5wuYePwDhQx0f/ithHxSaw+fYezj15TqbgFf3eoS6nCGQWp5XKBJXuvceL6S6b1b0zLWmUy95PK5CzfcoUzV17SpVVlBjrX+moVKi+/CPqO282yaR2oVsEagODIeDpO2sHk3g1pXTvDal99+g5H777k7Mx+6GiosfP2U9ZevofLhP4YaH0U4PmXb/IsKIQjfZ1z/f3I5HKOvXjFqpv3SJVKGepYlV5VKqCqpMRp99dMOuPC/dGDv1ht6UeQCwIddxxAS1WFXd06IBKJkMnl9N92jPD4JI4M70ZgZBw9lx5kVBsnetavyOqDNzlx043D8/tgrK/F4bNPWbf7Jv+Ma5Wjm+qXEASBVv3W06NdNbq2/rIVLpXJaff3NupWKs647p+7xX4HgqPjGbv1DCHRCSzq25yadkWzrA+PTWTfzWccu+uGIAh0qFmO7vUqYqqf83QMf5ywp6Sls+bMXQ7eek7VEpZM69oQS2O9HO+fJpFmWs++4TH4hEXjExZDbFJGSJq6ijLWhfSxMTXE2tQAbXVVDt56nieC/imCIHDivjvLT9xCT0udGV0bUrWk1Q+3+yXE6VJWnLzFodsvsizXUlPBSEcTY10tjHQ1MdbRxFhXEyMdTUoWNsbGNO9K4P0bv/AYhqw7joaqMhuGtadQDi9cN79QFh+7gbt/GO1qlGV4S0cMtDUQBIH1R++w69xjxnWvS5dGH+tpCoLA+evurNx2DTMTXaaPbE4Ja5MvHmPUrMMoKIhYMaNT5rJ52114/DqQo++t9oQUMS1mbadr7fL81bImKekSGi3aSueq9oxq8rGy0eQzLoQnJbHduf13fEsZJKens/X+E7Y9eIqhpgbj6tXi4uu3JKens6Nbh+9u91s8Dgii+54jWcrwRSQk0WH1Xmq9L6m34fx9dl55zKGJPTDV06brtN3YWhmzeERr5HKBpZsvc/66O/P+boNj5e8f4B0/9xiaGqrMHtvyi9tcfviGaRvPcWxRv5+aw+V7efQmgAk7zmGko8mKga2/ql2JqWkcu+vGvhuuxCam0qSSLb0bVMbW4tulI/8oYb/r4cfcg1dIEqczrn0d2lQrnWczv2KTUvENi8YnPAbfsJj3oh9DZHwSjSrYMrBJ3gj6vwmPS2LB4avccPOhXY2yjGnr9F2PXl/DMyiCKbsuEBGXxJQuDahcojCR8UlExScTmZBMZHwyUQnJGZ/jk4hMSCYmMQVBgG51K/DXT3ii8AgI568NJyhspMuaIW3R+0bFoH8jlwtceOrJylO3UVFSZNPwDhQ20gNg19lHrDt6h8HtatKvdbUs10hIeBxz11zAwyuUAV0dcW5dJdvEUvef+vD3/OPsWt6bYkUyfkghkfF0+JfVvs3lEVsvPeLcrH4YaGuw+fojtt58zOWJ/TOt6L+OnkFJQYFV7Vt8z1eVhbCERJbfuMtJt4zY+k/L3P0sRhw7w9vIaM4O7JlZru/qq3eM3HuGNT1b41SyKD2XHkRZSYEdo7vw9HUgI5Yey6y4JJcLLNpwCZdbr1kwqS3V3z8F5ZZth+5y6aYHh9cP/OI2/ebsx1BPkyUj23zXMX4WgiCw78YzVpy8RT374szp0RgN1ZyNO0ikMs4/8WT3taekpkk4P/vLhc4/PWC+kJt87DKZXJhz4LLgMHy5MH7bGSEy/tflv85p/uMfQS6XCxefegp1J20QGk7ZJNz18M2ztk89cBcqjVop9F1xSAiOjs/xflKZTDh296Xg+Pc6ofnMrYJHQNi3d8ohgZGxQo1xa4TBa48KyeK0H2orOiFZ6Lxwj9Bw6ibhiVdg5vIjV58LVfssExbsvCykitOz7COVyoQ9xx8IdTovE4ZM2S+88f783GQyudDlr63Cko0uWZbP2+4itBm/VZC8z/+eIk4X6k3eKCw7npGzPCFVLFSftU5Yf+V+5j499x4RppzN2s6P4hYSJsy8cDUzl/rPxD8mVii9YJWw4+HTLMsnHbogOM3dKMSnpApvgyOFSqNWCtsvPxIEQRBmbb4gNBu18WNue6lMmLPqnFCvy3Lh5eug7+rHvSfegmP7JULsF4q/vPIOFar0XiY89QzMdn1+svDINaH8iOXC1ksPv7uSlkwmF0Jy+Bv+IyYorTlzh1P3X7GkXwuW9GuJkU7eFHbOCTmJJf5RRCIRTSqW5MS03lQsbsGw9SdYeeo2kh/I/QFw77Ufs/dfxrl2ebaM7Ii5Qc6nZCsqKNC+ZjmOT+1FYUNd+q08wp1X2Sfhyi2R8cmkpEmY2KFejq2WL2GgrcGWER0pVdiE/quOsOjodVLTJHSs78DcoS1wefCGbtN34/omKHMfRUUFerSrxpaFPZDKZPSfsIf56y4SFfNxsso7vwjCIxMo9K9p7D2bVyYkMp777xOSqasq07W2A2cfv0Yqk6OtpkqHqmU59sQ9c4JVEX09XgSHZkkR/KOUNSvErKb1f4pv/d9Y6esxqEZlll2/g1fkx0lHk1rVRSKVsefuM0qYGzGwSTU2XXhAeGwio5zrkC6RsfXUAyDjO5/yV1PKl7Zk4fpLOZ4Z/CmlbTPmM7i/yX6iUlR8MpCRofN3wj8iloO3njPTuRH9G1f9bi+DgoIIsxz+hn9bYY9PFnPmoQejN59ix5UnTHduSKMKv29uhrxAT1OdhX2aM7NbIw7efE6/lYfxj/i+2YheIVH8vf0cjSuWZGy72t99gzLR1WLt0HY0LF+CUZtPcfTuy+9q51PKWBVCTVmJZz7BP9wWgI6GGqsHt+GfHk04++g1nRbu4bFXII2qluTAvF4UMTVgyILDLNt3PUtxjRLWJmya350Zo1rw9KU/XYdvZcfhe0THJjNj2RnKljSnW5sqWY5lWUifynaWWYp/NK5gS0xiCq7vMm4ebSuWJjQukUe+gQC0ty/N28ho3ELD8+R884NhtapRysSYsScvkPa+KL2uuhq9alVk9x1X4lPF9GlYGUNtDVacvI2eljpDOjhy6MozfEMyUgEoKiowfnBDQiMTOHD6yzN1v4SutjpFCxvw0jMo2/VGuhkGX/R7gf9d2HfjGeYGOrSqVvqXHfO3Evaw2EQO3HzGoDVHqT9lI7MPXCZdKmNRn+a0qV7m2w38BxCJRLSrUZZ9f3dDnC6lw7zdzDt0lYj47Kc+Z0dkfBIjNp7E1tyI2d0a/fA4hLKSInN6NKZ/46rMPXiVNWfu/pD1qaKshIONOY/eBv5Qvz5FJBLRqlppjk3thY2pAQNXH2X+4Wtoa6qyfExbZgxowtk7rxgw7yBBEXGZ+ykoiGjkZMf+1f3o3bEG+089psOQTSSlpDFzdIts/e/t6tpz94Uv4TGJABQtZICthTGXnr0FoHghI8pYmHDqqQcA5S3MKGlixLYHT/PsfH81yoqKLGvbjKC4BJZe+5grp6djBRQUROy67YqqshLj2tXhousbnngF0a5uOWzMDVm693rm9WJeSI++nWqw8+gDgsPict0Pe7vCvHydvUFgqJch7FFxv4+wxyWncvrBK7rXrfhLnv4/kO/C7h0axZZLD+m2eB9NZ2xlzZm76GmqM7dnU64vGML6Ye1pUunHZ679aRQzM+TAhO5M6VKfm+4+tJ69g9Wn72TJB54dqWkSRm06hYqSIisGtf6hSQ6fIhKJGNaiJrO6NWLnlcdM3X0RifT7XUVVSljyxCvwh90THsHhvAn9mHLXRFeLVYPaMK9XUy4+9aTj/D08fhtIy1pl2D2rO3K5QK+Z+7j+NGs5OVVVZXq2r8ahdQPo1Lwi8ya0wcgg+1QEdSoWQ1tTlbO3X2Uua1LRlqvPvTKrLLWpWJrLr96RnJaOSCRicM2qXHz9Fp/omB863/zESl+PWU3rs+vxM268y3BFaamp0sepEnvuuhKXnEo9+2LUKFWExUevIwgwsXcDnr4O5ICLa2Y7XVtVxtxEhxVbr+b6/29fygJP7zDSsknkZaijgUj0ewn7kTsvUVJS/OWGab4Le7cl+zlw8zmlLE1YM6QtNxYMYXG/FjSrXApt9d9zcsGvQkkxw899enpfhraowdG7L2k5ezs7rjwmNf3zC1smlzN51wWCoxO+K9IkJ7StUTbj/+TmzbD1J755o/kSVW0tiUpIwS/8+1PNnnz6Cuf1B2m/ei/Dd5/iVXCGq0MkEtGiih3HpvTC1sKYQWuPMe/QVQx0Ndk2vSsNqpRg4pozrDxwE+m/bk4Gepr81bvuVyfBqCgr0cKxDKduuSGTZwh5owq2xCWLM59CmjuUQiKTcdk94wbSzK4ERQz02Hzv6y6IU29eM+D0Ce4FBuSpTz6vaFPOjtZlSzH5rAtRSRkC2qNmBZQVFdl55ykikYgJHeriExbD0bsvsS9uzqB2NVl7+DavfN7PDFdWZPygRjx45svNB7mr12pvZ4FUKuf1u7DP1ikpKaKnpU50Lp5ufybpEikHbz6no2M5NH9w5m1uyXdh3zS8A5fnDmSGcyOcyljnmYX5X0JNRYneDSpzdmY/OtVyYNOFB7Ses4Ojd19mGWBdcfI2d1/7sWJgq69O9PlRatoVZfvozvhFxNBnxSFCY3JfQMLOygQNVeXvcscIgsCay/eYetSF3k4VWdOzNREJSXReu59hO0/yMjDjR2+sq8WKga1Y0LsZLq5v6bhgD+9Co5narzEzBzbl+PUXDF54mPDoxFz3oW2dcoRFJ/LI3R8AK2M97CxNuPzeHaOvqU6dktaccs0IS1RUUGBQjSqcdvck+CsFN454uPMoOIgeJ47Q8cgBrvp4/3YCP6tpfdSUlFh2/S4Amqoq9K1dib33nhObnIq1qQHd6lZg/bl7xCal0qdlVSqVsmTK+nMkJmcYAuXLWNK8XhlWbr9GSmrOc9ObmehiZKDFi6+4Y34Xi/38E0/ik8U41y7/y4+d78Je3sbil/qe/mR0NNQY0cqRMzP6Us++OAsPX6fDvN1ccn3DwZvP2XvdldndG1Ox+NenXOcFpQqbsGecMwoiET2XHcAvPHcuBmVFRSoUs+CxV+6EPV0qZdLhi2y58YhZ7RoytqkT9UsX49Bf3Vjfuw3RySk4rz/A4B0neO4fgkgkolnlUhyf2osiJnr0XXmYo3df0rymHTtmdiMxOY0eM/dw380vV/0oam5AeVsLTnw6iFrRlqsvvDJvtm0qluaRTyAhsRlC3rqcHcZammy5/yTbNiUyGc9CQ5jsVIejnZzRU1Nn4NmTtDiwh7NvPTOfDvIbLVVVhjhW5bT7a8ITM6zjbjXKo6asxPZbGec2qGk1VJQUWXf2LgoKImYNakq6RMY/2z8WEB/asw7p6VK2Hryb42OLRCIc7Cx48frLA6jfI+xhsYm8C8mbNMMAz3yCWXHyNs0ql8rxxLu8pEBR/0CMdbWY0rk+J6b1prRVISbuOM/Co9cZ1qIGzSuX+mX9MNXXZseYLpjq6zBi0ynik3PnlqlSwpKn74JyXN0mLkXMwO3Huf7ah/W929KparnMdSKRiDqlbDg4zJmNfdqRmJpG942HGLDtGE/9gjHU0WTd0Hb0blCJuQevMnOfCxbGeuyc2Y1qZYswevlxNh2/myvxbO1UljvPfTKt0MblbUlISeOhZwAATiWt0dNQ4/SzDKtdRVGRAdUrc/S5OxGJn7sLXkVGkCqVUtXcgopm5mxr3Y6zzj0ppq/PqIvnaLR3J4dfuf1QCby8om05O3TU1djz5Dnw3mp3qsSB+8+JTkpBS12VUa2dOHbPjdeB4RjqavLPkGbcdH3H4SsZ++jrajCsZx2OnnflrU/OI4ZKlzD74vZGelqZYY85JSQmgZ7LDtBxwR5GbTqFR8CPRS9devqGwWuOUd7GnCmd6/9QW99LgbD/wVga67GwT3MOTuzODOeGDGzy/VXgvxdtdVVWDmqNRCpj/LazuYq9r2prSWxSKu9Cv20pBUTH0X3DQYJi4tkzuDO1bItmu51IJMKpZFH2De3C1v7tSZNK6bXpMH23HOWZfwjDWzqyalBrrr30pveKg8QkpfDP4OZM6NmA3eefMHLp8RyHy9WuWAwBuPsiYyDRwkiXMlaFcHnvjlFRUqSFQylOu3pkWqmdypdFR02VHY9cP2vvcUgQhurq2Oh/rIRU2tiENc1acblnXyqbmzPt+hXq7drGrheuiKW5rwSUV6gqKdGzcnkOur4kKS3DleJcozzqKsqZVnuLKnaUK2LGgiPXkcnlVLazon/r6qw+dIvXfhni2bx+WcrYmrNk02VkspzdVG2sjIhLSCU2m/+TkZ4m0bmw2GMSUxi67jh6muos7teCyPgkui3Z/10CLwgCOy4/ZuLO83RwLMfyga3yLRdTgbD/ByhV2IT2NcvlW2FdIx1NVg5qjZt/KAuPXM+xT7hkYWO01VW/6Y557h9Ctw0HUVdR5sAwZ0qafcyVkZSWliksnyISiahRvAi7B3Vm+4COCAj03nyEZRdu41jamv1/d0OQCzgv3s8dDz861Hdg67SuBEfG03PmXnaff8yT1wEkfaUKk46mGpXtLLn2SYRN44q2XHvpnRkx1KZSafyj43gekDFwqKasRN9qFTnw9CWx/yqC/Sg4iErmFtn+H230DVjcsCnXe/WnkU0xFt65jdOOrZx96/nV7+5n4lzRHolMxtEXGUXENVSU6V+nCgcfvCAyMRkFBRFTutTHIyCcbe+LgPdvUx37EuZMXX+WpNQ0FBREjB/UkLe+EZy+nLM5EtZWGdlUfQI+L5VnqKuZY4s9WZzO8I0nkUhlrBvWjsYVbNn3dzdWD25DZEIy3ZbsZ+Smk7wK+Hyg9t9IpDLmHrrK6jN3+LtDHSZ2rJevLuYCYS8gTyhV2IT5vZpx7K4bdzz8crSPooIC1UpacvL+K9Il0i9uN/PEFQrr67JrUCdM/pXr/MJrL1yDQr64r0gkoloxS3YO7MTcDo3Ze+8Zw3efwkBbnV3julKnnA0jN51k19UnlCpiwp5Z3aletij7Lz5l2KKj1B+2jo6TdjB943n2X3rK87fBWcrxWRXSx9Pvo2VnY2pIUmoaAe8LXpc2N8HaWJ+rHu8yt3Gu6IBIBOc83mTp65voKEobfTkxGYCFjg6z6jbgVt8BNC5WnJEXz7H47u18GWDV11CnTVk7Trz0yFzWpZo9mqoq7LqdEbNfqrAJY9vWZuP5B3gGRaCooMA/g5uRIpawYv8NAIoVMaZLq0ps3HeLC9fdufPYmxceQXj7RxIelUBKanqW89NUV0FBQZRlpvAHdLXUiE9KzdH3ceK+O75hMWz4qz0muhnXlUgkonZZG/aNd2b14DZEJ6TQfckBZu1zISYx5bM2YhJT2HzxAc1nbuPco9cs69+K7nUrfrZdXhCTlMLrbxRO/0BBCEoBeUZ9h+LUKm3NlksPqVW6aI6eIEa2dqLLwr2sOXOXce3rZLtNVRtL7nn5o6Hy+WNtQ9tiKH+hQs6/aVe5DMVMDBi+5zQ9Nx1mXe+M2aq25sasOHUL/4hYJneuz4wBTRAEgYiYJF77hWf8+Yax48xD4pPEKIhEFDU3oGQRE648esuwDhmZHKUyOWvO3KWqrSU2phnuFJFIRPFChgTFxGf2Q0tVhZImRryLzGpxWmjrEJqUswgdYw1N5tVvRAVTMyZfdSE8OYkFDRqjovhri7eUNjXhzKs3CIKASCRCXUWZno4V2HLjMYPqVUVHXY2utctz/oknS47dZOvIjhjpafF3z/pMXneWJtVLUbVMEfp1ronb62AWbXRBKv3cJaOgIEJLQxUtTVUUFBRQUBBRtXzRz7ZLEUvQVFPN0bUnCAI6GqrZRpB9EHinMta4uL5l6YmbXHv5jhGtHGlfsxxewVHsu/GMi65vUFdRon3NcnRxcsjxlP+cEBKXgKtvME/8gnnqF4xPRAzWxvqcHdvnm/sWCHsB2eIfFYtnaCRNyuUujcOAJlXps+IQT7yCqGJr+c3trYz1mNy5HjP2ulDDrshnuakBWlWwY//957gFhWNvmbUwib5G7mL17a3MODjMmaG7TtJ13QHW9mpDrwaVKGyky5TdFwiOimdJ/5boaKhRyFCbQoba1K1UHMgQgtCohPdCnyH4le0s6dKoAgCHb7/AJyyaI5N6ZhEWcz0dnvhmDc+zMTTA51/Fq4sbGOIZFUlu6Fi6LMYamvx14QyRycmsb9EaLZVfFzNdWE+X5PR04sVp6L3PW9Olmj2brz/i8CM3BtSpgoJCRmx7r+UHufzci8YVbKlfuQR1KhZj/s4rHJjbC3VVZTbM74YgCKSnS0lMSSMpOeMvMVmc+T7p/fIiFgaZdWk/JT4pFV2tnOXPUVNRynY+yKeIRCKaVCpJrTLWbDx/n4VHrrPpwgOiElKwMTVgYoe6tKhi98O+dEEQ8I2M5YlfUKaYh8YloqSgQBmLQtQpZc24pk5UKGqeo/b+74Q9NjmVrTcfExAdR327YtQrXQy9PE6T+yVkcjkP3gXiHhxGm4qlMdX99WFQOSFNImX4ntP4RMSwsLOMVhVyXp2nvI05lUsUZuulhzkSdoBWVUtz18OP6XsucWRyTwy0s/5gyxUuRFEjfc48e/2ZsH8P5vo67B3ShXH7z9Fn82EWdG5KEwdbto/qzKhNp+i9/BAL+zSnZOGsea9FIhHmxrqYG+vSoErWG15kfBLrz92jV/1KWJsaZFlnoa+TGRnzARtDA255+2VZVsLAkLNvP1q/OaVOUWv2t+9M/9MncD52iO2t22Os+WsS5VnoZliowXHxmcKuo65G52r27LnrSi/HCqgoKWFvbUbLKnasOHGL2mVsUFNRYkLPBnSZsotNx+8x2jnjaU0kEqGqqoyqqnKOi5B/SkKyGJ2cCruyMuL0L7sAP0VTTYVx7evQunoZTj94hWPpolQraZUn41pugWEM33OKqMQU1JWVcLAyo32lMlS0tsDe0izbJ9Vv8X/jY09Jl7D5+iOaLtnOaVcP0qUyZp+8Sp15mxi0/ThHH7sRm5z67Ya+A8/QSJacv0WDhVsZtOM4O249pcWynay9fI/kbAb+8pu1V+4TFpdI20qlmX7sMk99s48Z/hIDGlfl4dvAzBq030IkEjG1SwNUlBSZuc/lM/+oSCSiVQU7Lrx880MZL+WftKutpsr63m1pV7ksY/efY8uNR9hZmrB3vDPqqsp0WbSX0ZtP52jgDDImh2mpq2YbmWSmp0Nsciopn1iH1ob6RCQlZxn4LW5gSHyamKiUz32538K+kCnHOjuTlJ5OhyP78Yn9NakLzN8bJ0H/mnTV07ECcSlizjz7OLg7sk0t4pLF7LqaETVjrK/FyC5OHHRxxcMnZ9/zt4hPEqOrmXOLPV0qy1WIawlzI8a1r0P1UkXyRNQFQWDhuRtY6OlyYGhX7s8cxrYBHRnWsAbVi1l9l6jD/4GwS2VyDj96SfOlO9h84xG9alXk4t/92NS3HbenDWZex8aoKSsx7/R16szfRP+tRzn08AVRiT82ey0iIYntt57QbtUeOqzey2V3L9pXLsvZsb25OWUQQxtUZ/fdZ7RYtpMTT179NpNPnvuHsPP2U/5uUZs57RtRu2RRRu49g39UXI7bqFbSinJFTdnq8jDH++hoqDG/dzPuevhx6NaLz9a3qlCK2ORU7rz1y3GbH5DJ5Sy6eotKS9dz+Jlb5o1DSVGBaa3rMbllXVa73GPaMRf0tTXYO86Z5QNaER6XSPclB/hr/YmvZqJ84hXE+See/N2+TraP5Bb6GVbth4lKkGGxA/h+kjumhEFGIRevmM+jPXKCla4eRzs5Y6iuQacjB3AN/fKgcl6hqqSEiZbmZ7NpTXW1aVm+FDtuP8mcp2Ciq8XAJlXZcfkxYbEZYwlt6pSjQkkL5m53+Sy9w/eQK4v9vWimfWXg/mdzzcOb5/6hTG5VF3srs8xCJj/Kf1bYBUHgsrsXbVftZt6p6zQsU5yL4/vyV8MaaL7PAa6tpkrLCnas7tmaO9OGsKhLM7TVVVl87hb1Fmyhz5Yj7LnrytVX73joHcir4HD8o+KITkohXfr5xZCcls4pVw8GbDtG/YVb2Hz9EfaWpuwe1ImL4/sxsnFNrI0NUFVWYkCdKlwY35f6pYsx4/hlOq/dzwPvgF/9NWVBLJEy9agL1YtZ0qlKORQVFFjYpRnmejoM23WS+NScTUASiUQMaFyVW+6+vAnKuc+4QjELBjSpyvKTt/D61yxAC31dKhW14My/XBrfIj5VzKBDJ9nz+Dl1ihdl2vkrjD5xjgSxOLOvPRwrsKZnay65eTFo+3ESxGnUdyjO/r+7sXZIWxLFafRdcZgBq4/w6E3WHC4SmYwFR67haFeU+g7Fs+2DeTbCXlhPB2UFBXyiP/rZjTQ00FVV4913CjuAoYYG+9p3poKpOd2PH+GKz7tv7/SDWOjqEBz3eZqEvk6V8I2M5YanT+ay7vUqYqSrycqTt4GM739yn0YEhsey+3z2M3JzQ3xy7ix2IMfumLxGKpOz8tJdmpQrQbk8cDF+yn/Sx/7EN4hlF27zMjCMZva2rOvVliLvy6Z9CU1VFZrZl6SZfUlS0iXcfuPLZXcv1l6+n22cNGRMi9dWU0FTVQUtNVX8ImOQyOQ4lSzKMucW1C1lg+pXct8Yamkwo20DutVwYMn52/Tfeox6djaMa+aEtbHBF/f7Wax2uUtkYjJb+rfPfMzUUFFmXe82dF13gNF7z7KpbztUlL5tVdQua4OtuRHbXB6xuF/OS8INalqdB28CmLTzPAf+7pYld1CrCnbMP3OdhFQxOjkoMOEdFcPQI6dISZewr2cnHCzM6ORQlgmnL9J6y16WtW1GJUsLAOra2bBncGeG7z5Ft/UHWNG9JSXNjKlVxhrH0kV54hXElksPGbT2GPbWZgxsUo1apYuy/8YzAiPjWDGw9RcfzbXVVNFVVyMwJi5zmbKiIpb6evh+IuwikYjiBgbfbbF/QENZmY0t2zDj+hWGnDvNnLoN6Fbu55XPs9DTyTb/TfFCRtQpZc22m4+pZ2eT4T9/n9p3zJbTdHayp2LxwliZ6jOgbQ02n7hPJbvCOJSw+O6+JCSloquVswF1NeUMi/1bA6g/i5Our/CPjmVtr9Z53na+C7urfzCOpbK3dHKLV1gUKy7e4eYbX6oVs+TQX86ULZz7O6GGijJNytlmRoSkS6Ukp0lIFKeRnJZOojiNJHE6SeKMyTFJ4oxlHSqXpam9Lfq5zKpYvJARm/q2485bP5acv0XblXvoWt2eofWr/5QMjdnh6hfM7ruuzG7XCHO9rCFbJjparOvdhp6bDvPPqavMaf/tHO8ikYj+jasyadd5/MJrULRQzm5USooKzO/VlLb/7OKS69ssxQmalCvB/DPXueTmlSWdQHZc9/Jh3KkL2BgasKdHJwppZwzEOdoU4fTAnkw640L3PUcY7lSdoY5VUVRQwM7chAPDnBm19wwd1+yjfeUyDG9UE2NtTarYWlLF1pLnPiFsufSQERtPYmdpgl94LH0aVsbqGwXVixrpf+bOsjHU/yyNbwkDQ15H5ixW+WsoKSgwr34jTLW0mXb9Cv7xcYyvUSvPHvU/xUJXJzON778ZVLcq3Tce4oanD/XsMgpZ1y1nQ7WSViw+dpN9fzujqKBA96aVefI6kIHzDtHcsTR/dayF8XcMnsYnidHJocWuno8We2q6hHVX7tOxSjmKGOV9wr58d8UM2HqMnpsOcfuN7w9Nsjjl6kHHtfsIT0hic9/2bOvf4btEPTtUlJTQ11THylAPO3MTqtpYUr90MVpXLE23GuUZVK8q45o54VzDIdei/im1bItybEQPprapx4WXb2m2dAdHHrn99MknqekSph51wbFEUdpXzj5vtJ25CUu7NufkUw+23crZI3PDCiWwMtZn++XcVcspbKRHPYdiHL6T1deuo65G3VI2X3XHCILApnuPGHL4FA1ti7Gv50dR/4Chpgabu7RhcsPabLj7iF77jhKakOHzNdHRYt+Qrszt2Jjbb/xotnQH668+yBz4LG9jzrqh7dj/dzdM9bWxNjWgX6Oq3zynIkZ6+EfHZVlmY2SA779CHusVtcE1LJSA+Kzbfg8ikYiR1WqwuGET9rx8TuejB/Ok3X9joatDUFxCttdp+SLmNCpbnOUX7mTmqheJRPzdoQ5eIZGcepCR015JUYHV49ozb2gLXD0D6ThpB9tPP0ScC2taEIQMV0wuwh0hfyz2vff+x95ZhsV1bQ34xd0dgksIEAgkxN3d3bXudmu3t97U0rRp06ZxJS4QN+IhIQSCu7u7zsz5fhBISZAZINJ+fZ9nnoEz2+bMOevsvfaSYMqqanhxRN/H0v5TF+wbV0xHXVmZF7YdZea63VyIiJdakEkkAiEpmXx25DwfHjjDogGeHHhlAQOcOmfH+mmgqCDP7N7unHx7KdO93fjs6Hne3HOc3NLHF2P6p9PXKKqo4rPpI1s9b0O72fHehMH8dPoaFyMT2mxXQV6eZaO8OREY1eiJKS1zBvUgLDmbqLSm8TomeXYjKDmD5Lzm47h/dsafny7d4P2RQ/h20hhUFJtflMrJybGktxcHls4lv6KSyRt3Ephab/0jLy/HFC8XTry9lJVDvNly5Q4TftzKqdCYxmvTxcqEn1ZNZs+78xsFRGt00dchJb/pmK3vq2L+aq0z1MYWQ3V1DkVFPNxEu5np4saxOQupFomYuGcnV1OTO61teGDLXtzCHsybYwaRWlDM4TvhjccczAyZPciDdX7XG2P6y8nJMapPV/Z/s5TF473ZdvwWcz7YzpXgtq81gKjkHMRiidQz9obN0yct2Isqqth8+Q5LBvXESOvxmKU+dcHe06YLG5ZN4+CrC7A00OG1XX7MXe/DjbiUZgW8IAiEpmbx3YnLjPpuMwv+2EdAQhqfTx/FO+MGIy//9xToD6OpqsK74wezcfl0ItJzmfDjNrZdDepwguuH8Y9KYPfNED6cNFQqu/qF/T2Z7NmNz49eoLy65TgqDUzwdsbWRJ+Pd5yWaew9HSww0tHgRlRKk+ODutrgaGLAe/tONmvNIAgCCnJyGGlqSPVwdzE15sjyBXh2Meeto6caN1UB1JSVeGF4H069s4yBTja843OS13f5kSflQ7a4spqz4XF8fvQCPgH3cDI1bPysViRiT9A9HI0M+OsolRQUsNLWobhatkiZbeFoYMDROQsYZG3Dm6dPklvReROF6vu/Q0sewNaGukzp6cKuG8FN7ukXx/dDXk6ONUeuNCmvqqzEiil9ObB6Gd0dzXjn52O8/6sf+cXNjzkzr4T/bTjFss/30M3WBHcH6Zx4xPetdRSe8CTwl7PXUVZUYNmgno+tj6cu2BvoZm7M2gWTOPDKfPTU1Vi15TDLNtVH5BMEgdC0bH44eYVR321m3u97uRiZwCRPZw6+uoCTby9lhrfb0/4Kj4V+Dtb4vrmYRQO8WHvmOjPX7SYwUTa78pbIKi7jowNnmeLlwmQv6RLtysnJ8d6EIdSKxPx6/mab5ZUUFFi9bDyxGXn8fqLt8n/tp7u1GWHJTe2blRQUWLtgEin5xXzt5/9Ivf+NHc6CXh68dfQk25qJoNgc6spKrJ44GpFEwpdnLz3yuZGWBl/MGM2mFdOJzspj8k87OBoU8cjEo6ZOREBCKmvPXGPOb3sY+OXvvLXnOBEZOczy7s7nM0Y3lv3u4lWSC4tYM3V8kweQIAjEFxVir9f5m+cqiop8O3IMmsrKvHvudJOVQkeIyc2ji642miotZzyb5d2dhNxCglMemGBqq6vywezhHA2IeOQBDmCir8WXL0xg7VvTiErKYfYH2zlyKbTRfLK4vIqffC4x64NthMZn8uULE9j63/loSTljL7u/wtB+Qg6KABEZORwIDOOdcYPQVH18GeKe+ubpw7hYmPDHsmkEJaWz9ux1Fv6xDwNNdQrKK7HU12GChzNjujvSzdz4b6tukRU1ZSVeG92fKV7d+MbvEks3HmCChzPvjB/0SFAsaRGJJby37yT6mmp8NHmYTHX1NNR4c+xAPj96gSleLnQzbz1wlYOZIe/MGMJX+y7Q28mSvs7WUvXT3caU3ZfuPuKJaWOkx1ezxvD6Lj96WJkz7S/7AvJycnwwcggmWpp8fe4yuWXlvDN8EPJtXCv6Gup8OX4kLx7wZVRXB0Z1fXRDv5+DNUdeX8TPZ67z0cGznAqNZcWQXoSn53AzPpW7yRlU14mwMtCln4MVK4d4421n+Yhn87mYeHYEhvDjlHHYGjTdOMurrKC0pqbRpr2z0VRWZu3YCcw64MPWkLus8Oz4rDEmN5+uxkatlnHrYoKzmREHA8Pxsnlg9TKyhyMjezjwxd7zHPxgUbMp5Pq727L36yVsOHyDb7df4PTNKHp1s2LPmSCUFRV4fe5gpg11R0kKa62/UlZVv+J8Uik4JRKBr47508PKXCZv7nYhPCUqKysFQKisrGyxjEQiEa5EJwm/nb8phKdnCxKJ5AmO8NlEIpEIFyLihZGrNwm9PlknbL1yR6gViWRuZ+2Za0KPj38WojNz2zUOsVgizP1tjzB/vY8gFrf9u0gkEuHdzceFPm/9Ipy6Ey1VH7djUgWPV9YI2YWlzX7+w8krgufHPwsR6dnNfn4kNELo9vVa4Z1jp6Q+R//xPS30WfO7kFXSfJ8N3ElME8Z9v0VweX+NMOCL34W39xwXDtwOFdILi1utl15cIvT84TfhA7+zzX5+PTVFsP35ByG3olyq8baXdbduCl3X/SRE5uZ0uK3R67cKay9db7Pcnhshgtd/fxFKKquaHM8rKRcGvfeb8PW+C222EZGYJSz47w5h8HO/CBsOXxfKKqvbPe7LYQmCxytrhIrqmna3IQuHA8MFtw9+EiIzOn7O2+KZFuz/0jKVNbXCL2evCx4f/SxM/mm74B+ZIBSUVUj18LsRlyy4frBG8LkZ0qExRGbkCG4f/CQcCgyTqnytSCSsPnBR8HhljfDDoUtCnUjcavmyymqhx6trhHPBsc1+XicSC8s2HhD6fbZeCE7OaLbM5fgkwePbdcLyPYeE8pq2b+DSqmph2K+bhG5frxVe2H9MOBMVJ9S08FCorq0TEnIKpHqwCUL995+11UcY98c2obK2ttky20PuCj3++PWxT2JEYrEw64CPMHrnVqGqrvmxSENFTa3g9OUa4XRU87/RXymtqha8/vuLsOfGo9ed360IweOVNcKRG2FtfnexWCLU1sk+mXmY47cjBa/XfnoiE8aSyiph4Be/C58fbfvh1Rk8Mzr2f5ENNWUlXh3Vn2NvLMZMR4uXdxxj0Fcb6P/F78xb78MH+0+zwf8WZ8Jiic7Ka9z5zy+r4D/7TjPK1ZE5fdw7NIZu5sbM7evBj6euUlzZ9mafkoIC/5k5jK8Wj2X/tXu8tP5wszGuG9BUU8HO1IDwlObjiCgqyPPb4in0sDJjxeZDXIpKfKTMYHsbdiycSUR2Lot2HiCzlUTSUO9M5LdqEV9NGEVFbS2vHPJj4M9/8vkZf8Iys5vo1VWUFLEz1pd6w37t5RtE5+Tx8/QJqCk1HwMkOj8PRwODx65mVJCXZ83ocWSVl/HNtSttV2iBuLwCBKCrsWGbZbVUVRjT3YkDgY+a8E7w7sb8oZ585nOOZWv3E53esi2/vLyczGqX5iirqkFLTboQvx3lt/M3kQgCr47q/9j7ApATHj7DT4iqqirU1dWprKxETe3JOOH8k8ksLiU5r4ikvCJS8otIvv/KLC6l4Rc21dFCXk4OOTk4+OoCqbw326K0qpox329h0QAvXpLBJjcqLYe3Nh0HQeDHlZNwsTJpttz/dp8lo6CETa/NarGtOrGYT4+cxy84is+mjWqic28gubCIFw/4UlBRyfeTxzLEwVaqcWaUlHIsLIojoZGkFBXjYKjPNHcXJrt1e8Q+vjUuxyexat9Rvpowilk9Wt7oH79nBwMtrfhw0FCp2+4IvjFRvHHmJBsnTWWErb3M9fcHh/HVuUvcfedlqTIG3U3OYNGG/ex9aV6zbvQRqdmsPuBPREoOMwe68/KE/lKHCJCVjWdu4RsQgd//lj+W9huIycpj5rrdfDJ1RJuOdZ2F1II9ISGB//3vf/To0YPIyEhmz57N2LFj2b9/P7dv36ayspK5c+cyePBgqTr+V7A/GWrqRKQVFpOUVy/os4rLmNvXo4npXUdZc/oqR4MiOf+fFSi3YDfeHEXlVby/9QTBiZl8NGcEU/o+KpAPXLvHT0evcvW7l1oVHIIg8PPZ62y8FMgbYwawcoj3IzOxitpa/nfqAr7h0bzQvzevDemHopTpywRBIDgjiyOhkZyMjKWitpYBtlYMsrehRiSirKa23gv5fqq+8ppayu7/XVZTQ2l1DRNcuvLDlLEtzhDLa2vpseFXfhk7kfGOssXB7whvnTnJ1dRkTs5fInO43y/O+HMvM5uDy+ZJVV4QBCav3YGXtTmfTR/VbBmJRMDvdiQ/+15DIpHwyqQBTOvn1ump5tYcvcKd2DT2vLegU9v9K4IgsHTjAarrRPi8OK9D5tiCIJBcWPzIhntzSH0XFhYWsnjxYkaPHk1eXh7e3t6EhoayevVqgoKCqK6ubjwm/xRz/f1LU1SUFHEwMcTBpPME+cPM79eD7VfvcvJeDFN7Nu+52hx6mmr89tJ01vld43+7zxKZmsM704c0WWZ3tzajsqaOpOxCHMxb/g5ycnK8MWYghpoarD5xqV7lNGFokxtJQ1mZ7yePpZelBV+evURwRiZrpo7HSLNtYSYnJ4dXF3O8upjz0aihXIhL4EhoJL9fv42GshKayipoqSqjqayMlqoKplqaaKqq1P+vUh8rZqSTfavL/rCcbCSCgKepmZRnsHP4bOgIJvrs5L3zp9k8eXqbFkR/pd4iRvprS05Ojpne3fn13A3emzCkMSDfX5GXl2NKX1eGudvzx6kAvtl/kcPXw3h/1nDcbTvv3JRV1jx2i5iT92K4k5SBz0sdF+qrL1xhf3A4we++3GZ5qQW7t7d3498SiQQNDQ1u3bpF165d61NiqamhoaFBQkICjo6O7Rv9v/wtMdXRYnR3R3ZeD2aKl4tMOktFBXnenDoYFysT/rf7LLEZeXy3fAJG93NQ2psboKKkQHhKdquCvYGFAzwx0FLn/f2nKSiv4utZo5usIuTk5Jjr5Y67uSmvHT7OlE27WDN1PH1tpEsKAvUJqSe4dGWCS1ep60hDcHYWphqamGk92QQsWioqrBkzjrkH97H9XjDLekiXs1MQBKJz8xjjLNv9PsWzGz+dvsap0BhmeresmtBWV+W9GUOZ3s+N1Qf9WbxmL5P7uPD65IEYaHfcY7OsqgYt9ccn2Ctqavnh1BVm9HLrUIIYQRD4wf8a228H8/3ksVLVadfUet26daxevZr8/Hw0NR/oGbW0tMjPz2+2Tl1dHVVVVU1eAP89cb7NDa1/efYZ79GV6Kw8MpsJ3yoNY7y6svPteeSXVjDtqx38fOwqn+w6w6yvd1JTJyYtv6TtRu4zzr0rfyydyuXoRJ7beqTZcMMNHqdeXcxZsvsgX5+71CQRxpMks6yUb65d5o+g2/TpIv0DpjPpaWbBK7378u31K2RLmXe1QcVkLmMmMF0NNUa7ObLl8h2pEs04mBuy8dWZfLt0PAExqUz5Yhvr/K5zISSOxOwCmTyac0vK2X/1Hi/+dphLoQkYPCaXfoDDd8KpqKnj9TEDOtTO2Zh4Nt28w+pJo5nk5ixVHZk3T3fv3k1JSQkvvfQS586dY8uWLfj4+ADQp08fdu3a1eyM/dNPP+Wzzz575PjgH9eTX1vHfC93XhjQGwONR/MY/suzz/8OnyMoOQO/N5d0yMqgvKqG7ReCOBoQjpWRHh62ZnjYmtGnq7VUMVn+SlRmLi9vP4aGijLrl07BUl/3kTKCIHDoXgSrL1xBW0WFL8aPZICddA5UHSUsN4fNwXc4GReLvpoai909WejeA+1WPDgfJzUiEYO3bWKaczfeH9h8YvGHGbl+C2OcHXl3+CCZ+souKWP6z7sY5mLHVzPHSF2vsqaWLecCORkYTWZh/SRCUV4eK2Nd7Ez1sTM1wNak/t3aWA9VZUVScou4GBqP/70EQpOzUFVWbIyfP8zdHvVm1EGdwfv7TlFYUcWfy6e3uw1BEJixZQ8WutqsmzFJ6noyCfb9+/eTm5vLK6+8wpkzZ+jbty/Dhg2TSsdeV1eH6C/JKaqqqjAwMKC4rAy/6HjWX7tFZW0dS3t7saJvT7Qeo7vtv3QuxZXVjFi9kbfGDmJB/x5PezhNyCkp56XtR8ktLWfdosn0sG4+jkhuWTlfnPXnTHQ8091d+HDUELRVO98aQyII+Cclsin4Drcy0nE2NGKlZ08mOjmj/BhC6srKH3dusz7wFteWPyfVA+bzM/4Epqbjt2qRzH35RyXwyg5fVs8e2y5PzKqaOpJzC0nMrn8lZReSmF1AWn4xYomAnBzoa6pTUFaJroYqg93sGO7hQN92TBLaw4QftzHKzYE3xgxsdxvXk1JYtucwB5fNw91cenWO1IL9zp07jBw5kh49egCQmprK3bt3OXv2LDdv3qSyspL58+czZIh0T/qHrWIqa+vYERjMpoA7yMvJ8Vw/bxb26oFqK4kqHjflNbXsCw5DSUEeEy1NTLU0MdHSxFBTQ2priv8PbLsaxG/nb+L/warHGv+ivVTU1PKuz0luxKeyaqg3q4Z6t2i9cyY6jk9PX8RaT4ftC2a2GB1SVqrq6jgcHcmW4CCSiosYYm3LCs+eDLDsnITInUVpTTUDt2zk5d59eL5n2+GIL8Un8dy+o1x5dSWm2rLvDXzjd4nDd8I5+OqCTotLXicSk5JXRFJ2IRkFpbham+BpZ4FiC0HKHgcF5ZUM/moDfyydyqCu0pnWNseS3QcB2L5gpkz1njk79pKqajYG3GHH7WC0VVV4eWAfZvZweywJAlojMjuXN4+cJLe8AhVFBQorHyS6lpeTw1BDHeP7gr7h5W5uQj8bK5msCv7u1IrETP5pO4O62socc+ZJIpZI2Hk9mF/P3cBUV4v/TR2Jt12XZsvG5eUzd/t+BtpZ89O08R3+PYOzMnnxpC/FVdVMde7Gcs+eOBl0zEqpsq6W2znpdNMzwkSjczdbv7l2mWMxUVxesrLNB1tVXR3eP/7OJ2OGMdtTdhvtWpGI+b/vQw7Y/eIcmcxln2XOR8Tzxm4/bvz3xXb7i4RmZjNzqw9b502XWT34zAn2BnLLyvn9+m32B4dhqq3F8/29meru8tiXq4Ig4HM3lK/PXcbDwpQfp4zHVFuTWpGI3PIKcsrK77/++nc52WVlpBeXYq2ny1yv7kx3d0VP/Z9vn//50Qv4Bkdx+LWFWBnoPu3htElGUQlfHvPnSkwS03q68s64Qc1mqbqZnMoKnyMs6+Mls/74rxyPjeadc6fp18WK70aNwUi9Y5t14fk5+MTc41hCJGV19RuPrgbGDLe0Z1gXO3oYmXXY3jurrIyh2zfxxbCRzHZtW1iv8DmMmpISv86UXgf8V1Lyi5i5bjczvN14f+LQdrXxrPHdicvcjE/lyOuyq6gaePWQH+nFpRxePl/mVd0zK9gbSC0qZsONQI6GRmKgoc6qft7M6uH2WFQ0ZdU1fHzyPKejYnlxQB9eGdxXJpVLTG4+e++GcjQsijqxmLHdHJnf0wNPC7NnarndWey/HcpnRy6wdsFERrn9fUxcBUHgbHgcX/v5I5YI/GfCECb2cH7kNzocGsH7fmf5fNwI5nrJFn5BEATW37nFjzevs8TDk48GDW23+q6stgbfxCh8Yu4Rlp+DnY4ec5zcmWjrTExRPhfTEvBPSySjohR9VTWGWNgy3NKewV1s0FVp3+Ti3XOnCcnO4szCpW2uWLbfvsvPV25y680X2r2y9guO4v39p5nUw5l+jtb0sbeUKj/As8rc33xw7WLCf6cMb1f9xIJCxv2xnbXTJzCum+zOas+8YG8gs6SUTQFB7A8OQ1tVheV9ejLXyx3NTtrRDs/K4Y0jJ6isreP7KWMZYNt+y4iK2lqOR8TgExRKZE4uXY0NmeflzmQ351ZjVv+dCE7JZOnGA6wY7M1ro6WPfyE8FIL3aVJaVc3aM9fZfzuUvvZW/HfKiEeSnv9y5Sa/X7vFhjlTGWxvI1W7NSIRH108x9GYKD4ZPIzFHp4yj00QBILzsvCJuYdfYjQSQcI4m67M6+pOH1PLR86hIAjEFuXjn57IxbQE7uRkIAA9jS0YbmnHTEc3jNWlD4EQW5DP2N3b+XPiFEbatZ6TOKmgiDF/bGP3oll4WzWv3pIGn5v3OB0WQ0hqFiKxBGsDXfrYW9LH3hJvO0sMNP8eFnOVtXX0+2w9X88aw4Qe0pknPsyHx88RmJrO6ReWtGsF9rcR7A3klVew9VYQe4JCUVZUYIm3J4u8e7TbgkEQBHbeCeHbC1fpaWnOj1PGSeWJKG3boZnZ+NwN5URkDIry8kxydWaulzvdTIyeGQEnK7ml5cz6dTeuFib8umhKmx51tSIRJ0Ji2Hr1DqkFJZjpamGhp425rjbmetqY3//fTE8bE23NTncdb4uQlEw+PXKelIJiXhjeh2WDeqF83/tVEATe8zvD+Zh49iyeQzeT1uOOF1VV8cKJY0Tm5fLLuIkMs7GTaSy5leWcSIrBJ+YeMUX5dNUzZF5XD6Y5uMg0+y6pqeZKRhL+aYlcSEvA1cCEPePmyDSWFb5HKK2p5sCs1sMFCILAyPVbGefixDvD2m8B0kBVbR3BKZncTkzjVkIa4ek5SAQBJ1NDetvVC/pethadEuvocXArIY3lmw5y/j8rMdOVfdWRXVrOiN8288nY4cxpx74F/A0FewNFlVXsCAxmR2AIEkFgYS8PlvX2Ql8GO/jS6mo+PH6O87EJTbLVPw6Kq6o5GhaJz91QkgqKsNDRZqiDLUMdbOlrY9lp1hePm1qRiCV/HqC0qoa9L89r1Sy1vLqG/bfD2Hn9LoXlVYz36EpvO0uySsrIKi4lo6iUzKJSskrKGhMdK8rLY6KjibWhHiuG9KKvvdUT+l5itl8L4vcLAVga6PL93PGN8XRqxWJW+BwmubCYA0vntmj9kVhUyArfI9SKxWyaPI1uhq0/BKBekN/KTiMgK42bWakklBSipqjERFtn5jt74GnUcTXeyaQYXrp4jFtzX5Rpo/V2RjpzD+1j/8y59DK3aLXsZ6cvEpSWie+qhR0aa3OUVdcQlJTBrYQ0biWmEZOVh5wcOJoY0tPGgp62FvS0sWh30pnO5vcLARy6E875/6xsV/1vL1zBNyyKi6+saLdc+NsK9gbKqmvYHXSPrbfvUlVbh7W+Lnrqauirq6Gvro6RhjoGGuoYaWo8eFdXIzA1g/+ePE+NSMSaaePpY/1kPP4EQSAkIwv/uCQuxScRnZuHmpIi/WysGGxvw0A7a6z0dKVqq7pORHZZGdml5YglEnpbd3ns1kNf+/pz9G4kPi/Nxd645Sw/e26G8POZ64gFgVne3Vk00BNzXe1my4olEvLKKsi8L+gzi8sITEzjRnwqI10dWNjfk162Fu0WcHViMa/+cZSA6FSOfLQEW9OW086lFhTzwf7TZBSVsvfleY163pKqauZs34eyggJ7Fs96RKUWlZfL/MMHsNbVZePEqW0G0/rp7jX8EqNJKClEXk4Od0NT+ppa0tfMCm8TCzSVO09lVy2qo+ee33jTawAr3bzbrnAfQRCYsd8HQ3V1/pw0tdWy/nGJPL//GJdfXYlZO8weZaGoooo7SekEJWdwNzmDqMw8JIKApb4OPW0tGOBoQ38Hq2Y3xR83DUG/TLS1+G7uOJnrl1XXMHjdRl4a2IdV/aT/rR7mby/YG6isreN4RDRpxSUUVVZReP+VX1FBQUUlFc24i49wtOPLCaOeqrdrVmkZl+OT8I9L5FZKOpV1dVjp6TDQ1poBdtZoqiiTXVpOdmkZ2WX171ml9VY4D2eFN9BQZ4pbN2Z4uOBo9HiCfi38Yx+W+jp8M7v1mBUf7D/NmbBYTr6zrN2bYJejE1l37iZRmblY6uswrZcrU7xcZG6vtk7E5C+2kV1Uxp5357cYIriB0qpqFvy+DzVlRXY8P6dxoz6tuITZ2/biYmLEH7OnNHmIXk1JZsmxQ2yaNI3htm2rXzx3r8NV34QVbr3oZWKBVicK8uZ4/9ppbmSmcnHmSpk2cc8mxPHCCV9OzF/c6gqkuk7EyPVbGGhnzepJ0nuSdgYVNbWEpGQRlJzB7cQ0QtOykAgC3buYMsjJhlFujjh2YjTTlpBIBL70vcjBwDB+XzKNAU6y79OFZWYzY6sPZ19cio1+++36/zGCvS0qa+sahXxeeSVGmup4dpEum/mTolYsJjg9k2uJKVxLTCEiuz7ZgJKCAqZamphqa2KmrYWJVv27qZZW47HKujqOhkZyODSSjJJS3M1NmeHuwgTXrp3qQfnT6WucC4/j5DvLWi2XV1rO5J92MKWnS4dN2KIyczkaFIFfcDRl1TX0d7Rmei9XhnWze2x2zyn5Rcz9zYeBXW34bs64xtXCvYxsFu06wGQ3Z74YP7LJKmKV3xGSios4MW9xm0voqb67cDcy5fN+Ix/L+B8msaSQ4Qc3sW7YJCbZSe/lKREEJvrsxE5Xj1/Ht27OeDoqltcOn+jwJmpHKa2qJiAhjWuxyVyNSSK3tAJHEwPGezgzzsOp2dASHUUskfDJ4XMcD4nmx3kTGOna+oZzSzTYrl94eTmWujrtHs//G8H+d6SosgqJIKCvria1GkIiCNxKSePQvQjORMcBMMbZkenurvS1seyws8212GSe33oE/w9WtanTPBQYzv+OnGPPC3Nxt+p4uNVakQj/qEQO34ngelwy2qqqTPJ0Zm5fD2yNWlavtJfrsSm8sO0Ir9+P797AuZh4Xjnox1vDBvB8/wfememlJYzetY2XvfvysnefVtt+8/IJCqoq2TG25QQinc2LF46RXFrEyamyxfM5GRfLq6f8OLVgSauOVYIgsHLvUbJKSzm6cuEzESJBIhG4m5LByXsxnA2Po6iiiu5dTBnv0ZWx7k6dopevE4v5YP8ZLkTG8/OCSQx2br+n6b2MbGZt8+Hiy8vp0gHB/q9f/DOMnroaBhrqMt2E8nJy9LOx4ocp47j++nN8NGooyYXFLN1ziBG/beGXKzcprW47jV1LeFqboyAvR2Bieptlp/dypbedJZ8cPketSPoIfC2hrKjImO5ObFg2jXPvrWTJIC8uRycxZe0OPj1ynrzS8g738VcGOFnz9rhBrD1zjcvRD9LujerqwIejhvCj/3WOR0Q3Hu+ircMr3n359XYAaSWtR6O00dYjqbSoU8fbFi959CGyMJcrGcky1Rvr4IiDvgG/Bga0Wk5OTo7/jR1GWnEJW28FdWCknYe8vBy9bLvwydQR+H+wij+WTsPWSI9fz99k+OqNLNt4kP23QymuqGq7sWaoFYl4x+ck/lEJrF8ypUNCvZ76eXZHN8z/Fez/YLRVVZnr5c7BZfM48dwixjg7sutOCM/tO0p1najtBppBQ0UZNwtTApPaFuxycnJ8Om0kaYUlbLoc2K7+WsJMV4vnh/XhxNtL+XTaSK5EJzHuh638cvYG5dU1ndbPkoFeTOrRjff2niIht+DB8d5eLOrVgw+OnyU290Go6pVeveiirc2nly8+ktfzr9ho65JeXkKtDCFnO0p3Q1MGmduwPrR1Af0w8nJyvNK7LydiY0goLGi1rJWeLi8N6MNvV2+RVix9qOUngZKCAoO62vDN7LFc/eh5fpo/EV11VVb7XWLI13/y/NYj7L8dSl5ZhVTt1dSJeH3XcW7EpfDnsmn0c+h4VNCGK6ajhtD/Cvb/JzgaGfL+yMHsXjSLuLxC3jl2CrFE0q62etlZcEcKwQ5gZaDLKyP7scH/FvE5rQuF9qAgL8/0Xm6ceHspL4zoy56bIYz9YSu7bwR3yiqh4eFkZ6zPqzt8m8R2f3/kYLqZGPPm0ZOND0plBQU+HzoC/+REzicmtNiurbYeEkEgvfzJCr8XPfoQkJXG3dxMmeqNd3DCVk+P3wJvtVl2Rd+emOto88UZ/1Yfbk8TFSVFRrk58tOCiVz56Hm+mDEKFUUFvj1+mWHf/MmC3/ey+XIgyXnNr6oqa+t4aftRglMy2bRiBj1tO2dPoeF8dXTG/tR17B+ePgFKSogkEsQSCXUSCSKJBJFETN39Y7qqaizo7oG3eftN3v7lAbdS0ljuc4R5Xt35aNRQmc/p1ZhkXth2hEsfrMJICh2lSCxh/u8+KCkosOP52Y/VAam4ooo/L91mz817mOpo8troAYzt7tShtGRQ75Q1+9c9OJka8vvSqY3fIa24hCmbdjHZ1ZlPx41oLP/mmZMEZqZzduEy1JWUHmmvtLaG7jt/ZsuoGYywkj2JdHsRBIEpvjsx1dDiz5HTZKp7NDqSd86d5tyiZdjqtm6xEZCcxuLdB/l1xiRGO7dvI/FpUFVbx834VC5ExnMpKpHiymrsjPUZ4WLPcBcH3CxMqKyt5aXtx0jILWDj8um4WLRuZSULwemZzNm+r93RMht46jP26Px8kouLyC4vo6i6mhqRCDlAVVEJfVU1zDS1yCgtYe6hfUzZt5tjMVEyZUz5l0fpY23Jt5PGsCMwhK2378pc38vmvp49KUOq8ooK8nw2fRRh6dnsDQiVuT9Z0NVQ470JQzjx9hJ6WJnx3r6TzF2/h4CE1A61a6ytyS+LJhOYlM6a09caj1vq6vDF+JHsuRvKuZj4xuMfDhxCaU0N627fbLY9bWUVDFTVSX7CenY5OTle9OjLmZQ44oplW0FNdHLGUluH9VLM2vvaWDKleze+POtPRW3bWZKeFdSUlRjuYs9XM8dw+cPn2bZqFgMcrTkREsO89T6M+HYjc9f7kJxfxLZVszpVqMMDVUxHeeozdmmtYoKzMtkcHMTphDiM1TVY0sOTua7u6DyGZAj/X9gccIdvL1zlp2njZc7fOW+9D93Mjflk6oi2C9/nk0PniMnOY9/L82UdaiM1IhFJBUXE5xeSkF9AQn4hXY0NWdG3V7OB4aIyc/np9DWux6UwuKstX8wYhWEH0qH53o3kgwNn+HrWGKZ4uTQe//D4Wc7FxOO7alGjg86Oe8F8efUSJ+YtxtHgUWeu6X67cTEw5sv+o9o9nvYgEQRGHtqMl7E5PwweL1Pdg5HhfHDhLBcWL8dKR7fVsgUVlYz5YxvT3V35cJR0eRqeVQRBICY7n4sR8cRk5/P66AHYGXe+JVZQWgbzduznyqurMO2Axc7fw48d8DQz51czc9JLS9gWEsxvt2+x7nYAs1zcWOrhhbWu7tMe4t+O5X16kllSxnu+ZzDW1JDJ9riXbRcuRSW2XfAvuHUx4XRYrFSBwGrFYuLzCojLKyA+v6BRkKcWlSARBBTk5LDS18VGT5eNN+9w6F4EH44ayggnuyZtdzM35s/l07kZn8Knh88z+9c9rF04qd3JhSd7uRCTnc+nR85ja6Tf2M7Ho4cRlJ7JO8dOsWPBTBTk5VnQ3YODkeF8cuk8e6bPfuQ72+rokVzyZGfsUL8Z+oJ7Hz64doY3vQZiodm8R3BzTOnajV9vB7A+8BarR7buiGSgoc5/RgzmoxPnqKit5cNRQ9BQfjxp6B43cnJyOJsZ4WzWdpiIjtC4edpBjfNTV8XIShdtHT4ePJTry5/jzb4DOJ+YwPAdm1nhe4TLyUlIntHNmmcROTk5Phw1hKEOtrx4wJfonDyp6/axtyQxr5DY7OaTlzeHvYkBFTW1ZBS1nfD6fb8zTN28mw+Pn+ViXCLKCvJMdHVmzdRxHF+1iHvvvcKZF5ayYc5UTr+wlB5dzHjpoC8ztuzhSGgktaKmVj/9HKzZ98oC7E0MWPjHXt7xOUFoWrbUY28gv6wCHTVV6sRi1py62nhcXVmJn6aOJyQjmw036i2AFOTl+WL4KG5npLMvIuzR86GjT1hBNiU17Tc/bS9T7V0wUtfg15DmVUUtoaSgwIvefTgcHUlGadu/46webqybMZGz0XGM37CDY2FR/96jT4C/jSqmJUQSCWcT4tkVGkJARhqO+gas8urF5K7dngkHib8D1XUiVuw9TFJBEXuXzJEqVo1YImHeeh/UVZTZunKmVBuwNXUi+n2+no8mD2eGt1urZT89dYGQjGwOLJsrdfybexlZbLsdzJnoOHTUVJnr2Z25Xu6YaD1Y0oolEk7ei2H7tbtEZebiaW3OkoFeDHexb3FTVyIRCEhI5cDtMC5GJqCmrMQkz24s6NcDG6Omm4hbb93luwtX2LtkDh4W9U5Zq69fYee9YPzmLcJO78HyvbC6klGHtjDM0k5mlUhncCgunLevnMR38iLcjaR3IKsVixm+YzNeZub8MnaiVHVyy8pZe/kmh+6F42pqzPsjh9DbuvO9U/PKKwjNzOZeRjb3MrOIzyugp6UF0z1cGWhn/cyntLyXkcWsbXvxf2UFFjrSr6Qe5m8v2P9KVH4eG4MC8YuNxkhdg+WePZnr5o7m33T59yQpq65h8e6DlFRX47N4ThNh2BL3UrOY//tefpg3nnHu0unoV24+hK66Gj/Ma12Q7QsO4+tzl7j7zssyW9Fkl5bjc/cee4PDKKuuYVw3JxZ792gUtFCvM72TlMH2a0Fcik7EQlebhQM8md7LDY37Mf7zyio4GhTBwdthpBeV0sPajFne3RnT3Qk15UctXaBef71y7xFSCos5tnIhmirK1IrFzDrgQ51EwuHZ81BVfFD3dHIsz184+sStY6D+HMw8sQexRMLhSQtl8kr2T05khe8Rfh47gUlO0sccj87J49sLV7ielMoIJ3veGz4IW4P2xUSprK0jIjunUZCHZmaTWVoGgK2+Hu4WptgZ6HMlIYmgtEyMNTWY0r0b091dsTfsfP14ZxCZncvUzbs588LSdp8X+IcJ9gYySkvZHBLEvvBQFOUVWOjuwdIeXh1OS/ZPp7Ciknk796MoL8/uRbPRlSLe9ccHz3IjLgW/t5Y0CsTW2Hw5kK1Xg7jy4fOtmiA2xMw4/cIS7AzadxPWiEQcj4hh++1gonPz8DA35aWBfRjqYNtkhZGcV8TOG8EcC4pAQV6eab1cySou41JUIurKSkz26sZM7+5SB5LKLStn4sadDHe0awyIlVZSwkSfnUxwdOLrEaOblH/V349b2Wmcm74cHZUnawwQWZDLhGPbWT1wDHOcZMsS9bH/eY7HRnN6wRJMNaU3zRMEgauJKXx74QpJBUXM83Ln5UF90W8hlWRpdTXJhcWkFBaTXFhESlExsbkFxOXlIxYE9NTV8DA3rX9ZmNHdzASdh67dlMJiDodGcCQ0kuyycnpYmDHd3YUJLl1bDT39pInPL2D8hh34rVpEV+P2By77Rwr2BoqqqtgVFsL2kGDK62qZ0c2VlV692rTB/f9MZkkp83bsx0RLk63zp7e52VVQXsnkn7bT08aCtQsmtWkvHpmRw6xf93Dw1QV0MzdusVx1nQjP73/l+ynjmOgqm8XOwwiCwJ20DDbevMOl+CS6m5nw6uB+DLG3aSLgiyurOXA7lAO3wzDR0WSWd3dGd3dqVxrGC7EJvHjAl7XTxjP+vsXRmYQ4Xjzhy5rR45nq/CAQ19NWyXxy8zx+iVFcmrlKpgdLZV0dE/bswFJbh21TZ8gch0gkkXAwJJyfr9ykViTm+f7emOtok1JYRHJRvSBPKSqm6H4ieQU5OSx0tbHW08PeUB93c1M8LEzpoqMttS+GWCLhZnJ9LKVzMfHIycHoro5Md3ehr43lE0/y8jCpRcWMXL+Vw8vn42bWflPKf7Rgb+yrro5DURFsunuHtNISxtg7stKrF56mTzYXaUl1NfdyskkpKcbVyBg3Y5Nnch8gsaCQeTv2425myp9zprR5ju4kpbNi8yGWDuzJm2Nbz6AjkQgM+uoPVgzxZvngXq2WnfDnDoY62HYomfTDhGZm8+vVAC7FJ+Fubsqrg/oy+CEB31n879QFTkTG4LtyIeb39aWfX/Fnf0QYx+YswF7/gQnk01TJlNRUM+zgJibYduULGU0vQ7KzmHXAh48GDWVpD6929V9eU8vGm4FsuRVEnViChY42Nvq6WOvrYaOvi5WeLjb6uljoaHdqvoHS6mpORMRwKDSS0MxsLHS0mevVnZkebk8tlHd2aRmD121i75I5eHUg+uz/C8HegEgi4Ux8HBuCbhOel4utrh7Tu7kw1dkFC632b1Q0R41IRHR+HiE5WdzLziYkJ5vk4nrTNnUlJSrr6lBVVKSHiRneFhb0MrfAy9T8mTEHu5ueybzt+/hqwihm9mh9oxPgSFAEHx88y5czRzOtp2urZd/ec4LSqmo2rpjRarl3jp2isLKKLfOmyzR2abiXUS/gLyck4WFuymuD+zHQzrpTBXxVXR3TNu/BQEOt0QSyVixm9sG9VItEHJk9H7W/eKU+TZXM/tgw/nPtNMenLMbVQLaZ4tqAG2wICsR37sJm7fWlpbK2DkUF+acy2YnPK2BfcBiHQyOprqtjbDcn5vd0x6uL+ROd/BVWVNJ37QZ2LJhJX5v2J//5fyXYGxAEgbDcHA5HReAXG01xdTV9u1gyvZsrY+0dZRaudWIxycXFROTlEJKdxb2cbKLy8qiViNFSVsHdxIQepmZ4mJjiYWKGobo6ScVFBGakE5iZQWBmBmmlJSjIyeFiZExviy54m9cLe321p5cE5Otzlzl0L4KTzy+WajP1p9PX2HYtiM0rZtCrldgZBwPD+NrXn5ufvIRKK2qOLbeC+PNGIDffeL7Fm2tfRBgXkxIQBBAQaLiaBZr+DwJaKiqs8OyFh8kDG/Z7GVmsuxrAlYRkPC3MeHVwPwbYWnXazRyZncusrT68OrgfLwyoD/GbXlqvbx9r79jEFrxBJTOkiy1rhkxotd2y2mqWXvZhgKkty5x6o6fSsetEIghM99uNvJwchybOl+n714nFzDq4F4lEwsHZ85/JVai0VNbWcSIyht137jUmop/v5c4kt25oSrGH1FHKa2rw+mE9m+ZOkzp5enP8vxTsf6VWLOZSciKHoyLxT05EUV6esQ5OTO/mQl+Lpjo3sURCWmkJsQX5xBUWEFOQT1xBAYlFhdRJJCjKy9PN0AgPE9NGQW6rpy+V7jG7vKxeyN8X9rEF+QiAm5Exo+wdGGXnQFcDwyc6e6isrWPixh04Gxvx28xJbfYtkQi8uec4gYnp+Lw0D2tD3WbLZRSVMPq7LWxeMYO+Di3nNL2ZnMqS3Ye4+tqqZh8sMQX5TNyzg/6WVuipqSF3PyaeHPU2+g2jbRh3XGEBoTnZjLV35O1+A5qoQkIyslh3JYCricl4dTHj3eGD6GnZep5PadkccIcf/a/js3gOHhb1D5VzCfE8f+IYP44ax7RuDzxYz6XEsfL8EdYPn8wE25atTa5lJ7Lksg/aSqqIBDELHHqywqkPRmrt91YMzctiku9Oto2eyTBL2ZJwJxYVMtFnJys8e/J2v44ntH7aNCSi33M3lBMRMSgpKDC1ezfm93R/bNnJoH6l3/3bdfw+azIjnNqvkvt/L9j/SmFVJcdjYzgUFUFYbg5mmpqMcXCitLqa2IJ84osKqb7v+GKhpY2TgSGOBgZ01a9/d9Q36LSk1CXV1dzJzOBiciLnEuPJr6zEWkeXUXb2jLJ3wMvU/Ils9NxISmXpnkP8Mn0CY7s5tVm+sraOxRv2U11Xx+4X5z5indDAuB+2MtrNsVWdfHFVNb3X/M6G2VMY5thU0AiCwMIjByirqeHInAVSnQtBEDifmMAPN6+RUFTIzG6uvNanH+Z/UcMFp2fy0+UbBCSnMdPDjXeHD0SvBWsNaWkwgUwqKOLoigWN5+TLK5fwCb/HsbkLcfjLQ+bD62fwS4zm9LRlLXqFboi6wfa4QM6Oe4E9CXfZFH2LclENc+x68JxzP8zU26daXHBqHwKwZ9wcmevuDA3hs8sX2TdzDj3NOueh+CxQVFnF4dBIfO7eI7WohF6WFszs4cpYZyfUWzB7bS8SQcD567X8PH0C46S431riX8HeAnEFBRyOjsA/OQkTDQ0c9Q1xMjDAycAQB32DJ2obLxEEgrMzOZcQz5mEeFJKijFQU2eknT3Dbezob2n1WHXzHx4/h398IiefWyyVkMspKWfu+j3YGxuwYdm0ZoXu50cvEJ6ezf5XFrTa1rBfNzPTw5WXB/VtcrwhF+eBWXNlFiJiiYSjMVH8FHCd/MpKFrv34MVefdC7fx0KgsDJqFi+PnuJOomEt4YOYIaHa4c27goqKpmyaRdeXcz5ZUa9U0+tWMzcg/uorKvl6NwFjfbtVaI6JhzdjqGaOnvHz2t2xffqjcNUi+vYOKheAFeL6vBJDOansMvUSkTMs/fiv56jZbZUuZyexOIzBzg+ZTHdDWULuyAIAsuOHSa5uAjfeYvQVnl2zAg7A4kgcD0xhb3BYfjHJaKiqMBYZydmebrhadE5hhiCIOC6+he+mTiaKd2lT2H4MP8K9r8ZgiAQV1jAucR4ziUmEJqTjbK8An27WDK5qzOj7R07/aFTWl3N+A076G9rxXeTW09i3UB4ejYLft/HO+MHsWjAo9YS/9l3isTcQg682rpg/8DvLHfTMzn5/OImD4jdYff44oo/l5esxESzfeqHGpGI3WH3WB94i1qJmOe8vFnWw6vxIVlWXcPPV26wJygUcx0tXhvcjwkuXdu9Uvr+4lVORcZy8ZUVjcfSS0sYuWMrnwwZxvzuHo3Hw/KzmXhsBxtGTGWszaMzt7cDfIktyeV1t8GEFGRwrzCT0IJMykW1KMsr0NvIii2D56IgL09mRQnIyWEuxSxeEAQm+e5ATUGJfROaf6i0Rk55OZP37sJB34CtU6b/rfXtrVFYUcnxyBgOhkQQnZuHo5EBs3u4MaW7i1T+Hy2x/tot1l25ycFl83D919zx/y95lRVcTUnmTEIcl5KTUJCXZ7S9A1O7ujDQqvNcqM/FxPPyQT82zpnKEAfp0n+tO3eD7VeDOPrGYrroP8jfmF1SxpjvtvDptJFM69W6BU1CfiHjN2znx6njm9izV4vqGLFjC0Nt7PhqeMeiI5bX1rI5+A6b7t5BVVGJV3v3Za6be6NQSi0q5terAfiGR2NvqM/rg/szqqu9zDO0KZt24Wlh1iRuO8B/zp/hTmYG5xYtayJIX7hwlJTSYk5MXfKIgA0pyGDG+W0A2Grp46FvQQ8DczwMzHHWeWBGKwgC405vpEpcy8kxz6Gh1PZDPyw/m8m+O9vltAQQkZvD3EP7GGFnz5rR4zucZ/dZRhAEwrJy2BccxomIGEQSCWO7OTK7R3e8rWTLH3EmOo5XDx3nkzHDWNirR4fG9a9g/wdRVFXFibgYjsVEEZSViYGaOpO6OjPN2QU3I+MOLxVfP3yCkIwsTjy3CE0pltm1IhEz1u3GRFuTjcunN/a/5vRVjgZFcv4/K1CWYk/ijSMniMsrwG/VoiZC4kBkOB9eOMuZhUubxGBpLwWVlay/c4vdofcw0tDgtT79mObs0vhwjM8r4JcrNzkdHYebqTFvDB3AIClNJDNLShn66+ZmrR1iC/IZu3s7f06cwki7B0kpogpzGXtkW4uz9pjiXEzUtNBVafn+uZqdyNLLPqgrKjHbtgf/9RrdYtm/8lnABQ7FRXBx5goM1WT32L6amswK3yMs7+HF+wP/3iF7paW8ppbjEdHsDwknPCsHWwM9BthaY6qliclDr4d185HZuczbsY+p3V34dOzwv38GpX8F++MhpbiYYzFRHImOJKWkGHs9faY6uzClqzNdtNuX/bygopJxG7Yz3qUrn44dLlWdkJRMFm7YxxfTRzOtlysVNbWMXL2JJYN68sLwPlK1EZubz8SNO1k3YyJjnB0bj4slEsbv2YGzoRE/j23dPDCltIivbl/C1cCE/mZWeBiZtagmyCgrZd2tmxyKisBaV5c3+wxgnKNT40MlIiuHtZdvcjkhCWdjI1xMjbA10MPOQB9bAz2s9HQfaXvXnRB+9L/GrTdfaPZhttz3MBW1teybObfJ8ecvHCW1hVm7NCy97INIImGKtSsfBJ5g/4gleBm2HXyrvLaGEYc209/cmp/aML1siSNRkbx97hQfDBzMCs9e/+iZ+8NEZudyICScqJxcskvLyS2vQPSXVJTaqioPBL2mJjeSU7HS02HLvOmd4oT1jxHsBVWVvOzvixzgamCCm6EJrgYm2GnrPXU34aeJIAjcy8nmSHQkx2OjKaqu5r3+g3ihV+92tXcsLIp3fU+ze9EsqeO3f+N3Cd+7kfi+tYSzYbH8eOoqF95fhZ6G9L/7Kwf9SCsu4eiKBU1mM0eiInnv/GkuLV3ZqpPZj0FX2RoRhIaSMtmV5agqKNLLxIJ+Zlb0M7PC3cgUJfmmN1RiUSE/37rJ8dhonA2NeKvfAIbbPIj3HpSWwYnIWBILCkkqKCLrfgAqBTk5rPR07wt7PWwN9DkYEo6xlgbrZkxqdnw30lJZeOQAR2bPx8P0QbCyyIJcxh3dxp8jpjHGxrHZui0RU5zL+DMb2TRoNkPNHFh8eQ95VeUcG70CFYW2V0oN3rC7x81hoHn7EjVvCLrNt9evYq2jy4LuHsx0cUVX9f/fRE4iCBRWVJJTVk5OWTnZ998bXkoKCnw7aUyHLbAa+EcI9lqxmAWn9pFZUUo/M2siCnKILcpHJEhQU1Sim74Rbgb1gt7NwAQnPcN/7KZOa9SKxWwNCeLb61f5YdRYpndrXb/dHIIg8Ny+Y6QUFeG7cpFUcVQqamqZunYnLhbGxGTl0c/Biv9NGylTvw1R7/6YNZnhf7HvrRWLGbptExOcuvLRoKEt1h93ZBs9TSz4ot9IkkuLuJmVys2sNG5mpZJXVYG6ohLeJl3qBb25Fe6Gpo0zzOj8PH4KuM65xAQ8Tc14u99A+ls+an9fWVtHcmERiQWFJBbcf88vIrmwiGqRiDUP7RP8FUEQmLx3Fza6uqwb11T4N8zaT05dItMS/f3bx7mbn87pcc8jLydHankR409vZKVzH95wa1s9IggCq84fIa44nzPTlqPaTlPemIJ8doeGcCQ6ErEgMMnJmUXuPXAz7ty0cv/ygL+9YBcEgf9cO41fYjSHJy2gm359YKkasYjYonzC83MIL8ghoiCHqMI8qsUilOTl8TQyZ25Xd8bbdkVNsXNtUZ91vr1+hc3BQWyeNI1B1jYy188qLWP8hh3M7+kudRyX67EpPLf1MAB+by5pV1qxF/YfI6+8goPL5jURcBuCbvPr7QCuL38O7WZc8dPLShiwfwM7x8xicJemG7+CIJBQUkhAVio3s1IJyEojv7oSJ11D3u45kDHWjo19hWRn8ePNa1xPS6VfFyve7jcAL7O243k0zNYMNNRbFczHYqJ4++wp/BevwFLngbqsPbP2/OpyBvn9yideo5ln/8AqaWvMbVbfu8Cx0ctx1m1bsGaUlzLy0GZWuvXi7Z4di9lTVlPDkehIdoWGEF9UiKepGYvcezDOwanT/D/+pZ6/vWDfEn6Hz29d5M+R0xht3fpFL5JISCwpJDw/h3Op8ZxNiUNdSYlpDq7M6+re+FD4pyMRBN4+e4rzifH4zJjTrpmTT9A9Pjvjz4Glc+luLp2987fHL1NeU8MXM6TbwHuYhlC+D29AltZUM2DLn7zaux/P9fR+pN62yLt8f+cKdxe80qYKQhAEIgpy+e1eACeTY3A3NOWdnoMYbPEgUFhAeho/3rxGUFYmw23seLv/QLoZdjxlWp1YzNDtmxlj78AnQ5ruYcg6a18bfpldcUFcm/Rqk/jvYomE2Re2IxYEDo5cKpXV1KbwQFYHXubUtGU46rY/FkwDgiAQkJ7GztAQziXGo6OiymzX7izo7oGFdufGbPr/yt9asF9JT2LJ2YO803MQL3v0bbvCQ+RVVXAoLhyfmHsklxbjaWTG3K4eTLJzlsos7O9MrVjMct/DxBUUcHDWvCYzRGmQCAKLd9Un5ji0/MnFB1nhU7/J6LN4ThMB9+WVS5yMi+HS0pWPjGXhqf1oq6iwfvgUmfoKy8/mx6Br+Kcn0tukC+/2GkRv0/rATIIgcCkliR9vXCMqP4/JXbvxZt/+bSZ4boutIXf57vpVLi5ejpnWgxjnsszaq0V1DDr+K/PtvXiz+6Mql9iSPCaf3cQ73Yex0rnt+0YkkTDZdweaSsrsGz+vU8NaZJeX4RMeyt7wMAqqKvEyM2eYjS1DbexwfsIhNP5JPHXBXlZejqaG7OZUCcUFTPXbxTBLO34eMrFDF4BEELiZlcremHucTo5DWUGBKfbdmNfVQ2bvu78TZTU1zD20jxqxiAMz5zV6XkpLSmExkzbu5Ln+3rwySPYHa0tIJALFlVXoaz4a2OpueiZzt+9j+4IZ9LN5oOfOKC1l6PZNfD9qLFOdH8ReKa2twWv3Or4bNI7pDtLtKUgEoYkFR2BOOj/cuUpAdhpDLGx5p+fAxlRyEkHgRFwMa25eJ7OslLlu7rzi3RejdlzTUO80NXLnVgZYWj2SLPq580dIKytpc9a+NyGYz+6e4crEV1qMHbMu4ip/RN3gxJhV2Gi1rRYLzctiit8uvh04ltlO3WX7UlJQKxZzISmBC4kJXE5JoqCqCjNNTYba2DHU2vaxe1fXiETkVJRTIxJTIxbVvxr+bnwXUSMWIweMsLVv8uB91njqgv1eWiruXWQPTzn/1D5Ka6s5OGF+k6VmRymsruRQXAQ+MfdIKCnERd+YeV09mObggpbyP8tFGuo9BWcc2IO1ji47p82S2SRtc0AQa/yvcfrFpVjqts+M8mG+8bvErhvBnH53GZb6uo98vnj3QSpqatm7ZE4T07DXT58gPDcHv3mLUL8fDvdaZgoLTu3j5NQlUoejHei3jhVOfVjW9YHlkCAIXMtM4fs7V7iXn80MB1c+7D200ca7Tixmf2Q4v9y6SXltDcs9e7LKy7tdbvWb7t5h9fUrhL/YVI0Snp/DhGPbOTBhXuPKoTnmXNiBiZoWv/Sf1mKZWrGYKec2o6GozO5hC6Wykvn05gWOJERwfsYKjNph2y4tEkEgLCebi8mJXEpOIiw3B2UFBQZYWjPazp7hdvadkg2tsq6OS8lJnE6I5VJSEuV1tS2WVZSXR0VBARUFRWrEIqpEIobZ2DK/uweDrWyeOcu7py7YbyYm0NdWtkhyANP8duFhaMan/Ua0XbgdCIJAYE46+2LD8EuMRlFejqn2Lix09sTF4J+liw/LzWHG/j28138QK71aT37xMHViMeM37MDZxLBFUz5ZySgqYW9AKK+N7t+sTW9cXj7Tt+xhZd9evD6k/4N6ZaVM3LOTkXb2fD+qPvRBlaiOycd2oq6kxIEJ0qmM7Pd9hbGqJjenvP7IZ4IgcDI5hs8DLlIlEvFur0HM7ereaCpZVVfHtnt32RAUiLycHC/26s0i9x5STz7EEgmT9+7CQE2d7VNnNJmZl9XW4LbzZ7aPmcnQLi3fM+/d8iOlvIh9Ixa32ldcSR4zL2xnhLkjP/aZ3Oaqt7y2hlGHt+BlbM5vMqq1OkJeZQUXkxI5nxjP1dQU6sRiupuY4m5sgpuxCd2NTXDQN5DK/ru0poaLSQmcjo/jckoydRIx3uYWjHVwpIepOWqKiqgoKKKiqHD/XRFlBYUmexE1IhFnE+PxCQslICMNCy1t5rq5M9vFrd0rtc7mqQv2awlxDPiLt520LDlzEANVtTbjVncGxTVVHIwLZ3d0CIklRXgZm7PI2ZPxtl3bbQL2rPFbYADrbgVwdO4CnGXcCLwUn8Rz+46ydd50Bti1z95ZVnbdCeHLs5fYuXBmE3v6C0kJrPI7yrcjxzDLpT5BSGxRPpN9dzK/qzuf9G17ImC/7yv0VdQJnPpmi2XKa2tYc/c62yPvYqapxes9+jPNwbVRAJRUV7MhKJBt9+6ip6rKK737YaurR0VtLeV1tZTX1lJRW0tFXS1l9/8ur60lt6KceznZnJy/uEnER4Ci6ip67F7HnnFzGNCKXfnx1EjeCjjKnalvoa3cetySK1kJrLi6j9ddB/OKa9vhdv3TEll69mC77Oo7g4raWq6kJhOQnkZ4bg6ReXnUiEWoKCjSzdAIN2NjupuY4mZsgqO+AYry8hRUVnL+vjC/kZaCAPTrYslYBydG2TlgqN7+WPbxhQX4hIdyKCqCyro6xtg7MN/Ng75dLJ/q/sBTF+yX42IZ7CD7BfKqvx/Vojo2jur87DotIQgC17NS2RUVzNmUOLSUVZjl2J0Fzh7Y6jybWc+lRSSRMPfgXirvZ/aR1fzsxf3HSCwswm/VoieykSoIAi/sP0ZMbj6+qxairfpAgK2+dpkdoSEcmbOArgb1sbMPx0Xw5pUTbBk1nRFWrU8k7Pd9hY6yKnenvd3mOFLLilkXcpNDceFYaenyumd/Jtt1a1ya55SXsy4wgH3hoYjv32oKcnJoKqugoayEppIymsrKaCgro6FU/z7E2oaJTo/GYs+pLKe3z3oOTpiPt2nLzmFFNZX0PraWdf2mM9ay5ZjuDeyMu8Ond8+wrv90xlu2HVHwzcsnuJaZzPnpK554pqeHqROLiS8qJCwnm/DcHMJzc4nMz6VWLEZFQRFrHR3iiwpRlJdnkJU1Yx2cGGFr1+lOUlV1dZyIi2FPWCghOVnY6uoxv7sHM7u5oqP65M/RUxfs/rExDHWUPe7wR9fPEl9cwL4J8x7D6Nomp6KMvbGh7Im+R3ZlOQPNrZnt1J3hlvaPTRdfKxZTVFNFUXUVhdWVFNVUU1RdSWF1FSqKiszr6oF2B/pOKS5mgs8OFrr34P0Bg2Wqm1ZcwvgN23ltcD9W9XvU5PBxUFBRyaSNO+lva8UPU8Y1Hq8Ti5l/eD/F1dUcnbOgcdPt9UvHuZqRzOlpSzFWbzkipP2+r3DRNcFvzEqpx5JcWsQvwTc4khCJrbYeb3oNYIKtc+OeRXF1FSKJgKayEioKiu2azTXY4x+dtBBP49bt52ec24qTrjHfeEu3ov006Az7k0LYO2wR7gatt11UXcWIQ5vxNDZjw4hpnRZorrOoE4uJLywgLDeH+MICupuYMszG7omF2o7IzWFPeCjHYqIAmOPaneWePTs9/WZrPHXBfj4mmhFOsmeh/+7OFfzTEjk1bWnnD04GRBIJF9MS2BUVwtXMZBTl5Blgbs0YG0dGWTnIHEBJIgjEFeUTkJ3Grew00stKKLwvzJvb3NFWVkFPRY3C6kqUFRR5w3MA85092n2z7QsP5cOL5/CZMYfeFtKFDGhg3ZWbbA4I4vQLSzDVfjIWA/5xiTy//9gjGWcyy0qZ6LOToda2/Dh6HHJycpTW1jDuyDbsdfXZPnpmi8I1pCADSw1dDFTbZ631c8gNfBOicNQ15E2vAYy1ceqUOClJJYUMPbiJE1OW4GbY+kbwz+FX2J8YwrVJr0r1EBFJJKy8uo/o4hxOjn0O/TZS7QVmp7Pw9H4m2jnz/aBx/6/iwEhLWU0NeyNC2Rp8l7zKCiY5ObOqp3en+Dy0xVMX7GeiIhntLHtA+d/v3WJXdDDX57zwGEbXPgqrKzmfmsCZlFiuZiRTJ5HgbWLBWGsnRls70kXrUasRiSAQU5RHQFZavTDPSqOopgpNJWW8TbrgoGuAnqoa+ipq6KmqoXf/XV9VDV0VtUYBXlxTxS/BN9gRFYyVli4f9R7KcEvZQ8sKgsBzx48SnZ/PyfmL0ZLBqqO6TsT4P7fjbm7K2mmPf++jgfd8T3M9MYUTzy9pEgvbPzmRFb5H+Gb4KOa41YefDcxJZ/YJHz7pM5xlrj3b3WdFXS0n0iJJKS9ipq0Htg+ZDMYW5fNz8HWOJ8Xgom/Mm14DGGXl0CG9a2xRPqMOb+Hc9OU46bWeni04P4OZF7ZxauxzOOlIJ0hKa6sZfeoPRlo48WWv8W2Wv5iWwKpzR1ji4sl/+3Q8IuE/lVqxGL/YaP4MCiSusIAh1jY85+X9WPXwT12wn4yMYNxfcj5Ky+7oEFYHXiZs0aOWC88C5bU1XM5I4nRyHBfTEiivq8XNwISxNk54m1gQUZBLQFYqt3PSKa6pRltZBW+TLvQ1s6SvqSUuBibtmnUnlxbxTeBlTifH0t/Mio96D2tzdvcweZUVjN+9neG29nz7kC11W1yMTeCFA74dzrIuCyVV1Uz4cwd9bSybqGSgPnzCtpBgDs+Z3zhT+unuNX4PvYXv5MU468s2e4ooymZvQjC+KeHUSsToq6iTU1XGCHNHlnftQ2+jpomwowpzWRt8g9PJsdjr6LPUpSczHF3b5QAXUZDD+KPb8Z+5Ers29nTEEgnex37ipW4DpHJCauBIchjv3vLlyKjldNc3a7P8sYRIXr90nLe8BvKaZ/82y/9/RiIIXEpO4s+gQG5npuNmbMLzXt6McXDsdHWWTII9IiKCl19+mbFjx/L+++8D0LdvX1Tvbw4MHDiQL7/8Uqq2GgS7X3gYE13dZB64X2IUr/r7kbj83Wd+GVgjFnEjM5UzKbGcTYmnoLoSbWUV+pha0tfMkj6mlrjoG3eqLezt7DS+vOVPaH42MxzdeLfnIEw1pFeP+MZE8eaZk5xZuPQR64y2eG7fUdKLSzi2cmGnhCCVhpZUMiKJhHmH9lFYVcWxuQvRVFZGJJEw68QeKupq8Z28qE1TxPK6Go6nRrI3IZiwoizstAyYa+/JNJvu6Cipci4jls0xt7hbkI6rninLnXoz3tKlySZyVGEuWyOCOJoQhYqCArOdurOkmxdW2rpSf8eQvCym+O7k2uznsWxm9fcwr904QnFtFTuGzpe6D0EQmHNxB2KJhAMjl0p1b+2MCubjG+f4ot8oFrt4St3X/2dCsrP4MyiQMwlxWGrrsNyzJzO6uXaaE5ZMgn3fvn2Eh4ejoaHRKNg//fRTPv30U5k7bhDsR8NCmeImuydbQ27G0IWvPfWdeVkQSyRklJdioan92J0aJIKAX2IU3wZeoaC6kue6e/OCex+pZotiiYSxu7fjbmLKj6PHtVn+r6QWFTNuww7eHjaA5X3ar+6QlZZUMlllZUzy2ckAK2vWjhmPnJwcqaXFjDu6jVmO3Vv0hQgrzGJvQjB+qRHUScSMs+zGXDtPvI2aX0KHFGSwJeY2p9OjMFTVYLGjN3PtPJskwiisrmRvTCg7ooLJrihjpJUDS117MsDMqs1leWBOOjOP7+H23BcxkeIhfTDpHv+9c4qgaW+hrii9wIgsymbKuS1802sCM+082q4ArAu5yY9BV1k7dCJT7WVfgf9/Jam4iE1373A4KhIlBXlmdHNlkXuPDieOkUmyzJkzB4WHZmBhYWF89913fPLJJ0RFRbVYt66ujqqqqiYvqBcg7aHB+qOstqZd9Z8WCvLyWGnrPhFPNXk5OabYu3Bx5kre8BzA1ogghhzYSGB2ulTjfKlXH3xjokgpLpapXys9XVb17cW6KwHklpW3c/Sy89GoocjJyfHVuUtNjptpafHj6HH4xUZzODqyfozaunzRbxRbI4PwT0tsUv5SVjyTz25m6rkt3MlP4023IdyY/Bpr+k6ht3HLAriHgQW/9J+G/4SXmWjlyu9RNxjot45Pg05TWlsNgL6qOi959OXa7Of5bfhkimuqWXBqH6MPb+VgXDiSZuZZFXW1hOZlcTk9CQBFeelWQYNN7aiViAnITZGqfAMueqYssPfi29CLjeNui1c8+rLCrRdvXz7JxbQEmfr7/4ytrh5fDR/FjeXP8Yp3Xy4kJTBy51YWHTnAhcSEZq8HaZBZx/7pp5+iqqraOGO/c+cOvXr1oqioiAEDBnD37t1G1czD9T777LNHjt9KSqS3jXQ5NP9KQ9qw8zNWdErEueYoqqlkU8wtXPVMGWHuKJXb9bNMQVUlb1w+TlJpEeemL28zXLFIImHEji0Msrbhy2GyxU+vqqtj1PqtjHdx4sNRQzswatn480Yg227f5cYbzz/y2WeXL3IsJoqLi5ejq6qGIAi8duk4NzJTOPUXE8iP75zEJyGYb70nMsPWvd0bXOV1NRxIuseGqBtoKKrwfZ9JzWYvCsvPZmtEEEcSIvEwNGWmoxvJpcXEFRcQX5xPenkpAMryCrgbmbJ3/NxHkoK0xKiTfzCmS1fecR8m09hLaqsYfPw3XurWn+e7Sac7FwSBd6+e4nhSDPvGz8XDqG0d/b80RSyRcCk5iR2hwVxNTcFWV49lPbyY0c0VNSXpQ6d0eNrYq1e9C7qenh46OjrEx8c3W+6jjz6isrKy8VVQUABAd5P2BdlqSDOl9JhmvvnV5Szw383u+CBev3mEAb6/8GXwOWKKcx9Lf08CAzV1vh80jqLqKtaF3GyzvKK8PCu9enEwMpy8igqZ+lJTUmJ5357sCw6jsLKqvUOWmYraWgw0mjfVe7PvABTk5Pkp4AZA/ex+wGjUlJR4+8rJxtnRBx4jcdUz5feoGxTXtn/smkoqLHPqje/oFZhraDPrwnZeu3GE9IriJuW6G5qyZsgETkxZgpK8Al/c8udGVgq6KqrMd+7BxpHTuDRzJVFL3uTQxAVSC3UARx1DEkoLZB67jrIas2092BF3hzqJWKo6cnJyfDNwDL1NurDs7CFSSotk7vf/Owry8oyws2f71JmcXrAEb3MLvrx6iQFb/+THm9fIrZBuBdwhqRgdHc22bdsAEIvFZGdnY2Fh0WxZJSUl1NTUmrw6Qt19wa4o1/mCPbuylPkXd1ElquXEmFVcmfgKS516cz4jlvFnNjL93FZ8Eu5SVvf3UgMBmGpo8bbXQP4Mu01ccds3/CwXV7SUldl2767Mfc3x7I6yggK77oS0Y6TtI6+8EsMWBLu2igrv9h/I7rB7ROXn1R9TVmHd0EncyExlY3ggABpKymwaNJsaiYgXrh2kRizq0JiM1bTYMWQ+vw+YSXhRFqNO/sH3of6PXD8uBsYcmDif6CVvcnLqUn4eOpGXPfoy2toRWx39dllOOGgbEl+a365xL3b0Jre6nDPpMVLXUZJXYP3wyZioa7LkzEEKqyvb1fe/gJOBIatHjuHqslUsdvdkb3go0/fvkaquTFfKoUOHuHLlCv7+/hw7dgxtbW18fX356quvePnll/n888/R09Nr15eQFfFjmrFnVJQwz38XAuAzfBEWGjqYqWvziutALk54iZ1DF2Ctqcfnd8/S99ha3rnly+3cVJ6S1Wi7WOzihZOeIR9fP9vmuFUVlVji4cWu0HuU1cj2INNQVmZhrx7sDAymorblyHmdSX5FBYaaLTsWzXRxw9XImM8vX2z87p7G5rzdcyDfBV7hXl4WUC+MNw+aQ3RJLv+5fbzdus4G5OTkGN2lK6fHPs+77sPYE3+XESd+Z29C8CP7TJ1p2+ygbURKeSG1Yulm3X/FUlOXkeZObIu9LVM9TWUVto2ZWR/z/+xhqkR1Mvf9Lw8wUtfgjb79ubpsFX9OnCpdJeEpUVlZKQBCZWVlu+pfz0gWrDZ9K+RVlnfamJLLCoWBvr8I4079KeRVlbVatrimUtgRGyhMOr1RsNv7pTD8+Hrht4hrQmpZUaeN53ESnJspWG/6VjgYG9Zm2aKqSsF1/c/Cn0G3Ze6noKJScP/2F2FzwJ32DFNmpm3aJaw+f7nVMnczMwTbn38QTsRGNx4TSyTCvJN7hUH7NghlNdWNx69mJQhO+74Wfgj179RxFlZXCJ8GnRYc930ljDv1p3AtK7FT228gsjBbsNv7pRBTnNuu+rdyUgS7vV8Kd/PSZa4bW5QvuO1YKyw4uU8IyEwVRGJxu8bwL7LzbAV5kIEHOvbOsZNOKM1n3sUd6Kmos3vYAgxVW44lAvU6yEWOvfAdsxLf0SsYZGrLlphbDD3xGzPPb2NHXCD51bLppZ8kPYzMWNjNky9v+1Nc07oeWVdVjbmu7mwJvkuNSDa1hL66GrN7dGdLQBC1MtZtD3kVlRi2ETrV08yc6c4ufHX1MlV19bNJeTk5fho8nrK6Gv5783xj2YGmdnzRaxzrI69zIDGk08app6LO/7zGcGrsc5ira7P48h5WXd1HQjvVJi1hq6WPHLS7XW8jS1x1TdgWJ9usHcBR14Ato2eQVVnG7JM+9Nn7Ox/fOMfNrNR2W8P9i3T8fQW7cF/H3gmqmJjiXOZd3IW5ug67hi5Ar404GQ/jqmfKpz3HcnPK62waNAcrTT2+D/Wnv+/PLL3sw+Gk0GdSH/9uz0EoyMmzOvBym2WXe3pRUFXZGNhIFpb37UlRZRXHwqPbM0ypkQgCBRWVGDWTeelh3hswiNKa+tC6DZhoaPHDoHEcjo9gX2xo4/HZdj14sVt/Pr5ziuvZSZ06ZnttQzYNnsP2IfPIqChl3Ok/+SDwBKEFmZ2i3lNVVMJSU6/denY5OTmWOvXmVFoUWZWlMtf3NunChRkrODd9OQude3ArK425J/fSZ+/vfHT9LDcyU/4V8o+Bpx5SoL05T8+mxLHq/BFilrzVoZjo4YVZLLnsg5OOERsHzUZTqXMiM1aKarmYGY9fSjiXsxOQl5NnhLkjk6xcGWJm/8yYTh697xJ+aOICepk0v/HdwLvnThOcncnZhctk9vb9wO8sd9MzOfn84sdmw19YWUXfn/5g2/wZ9Le1arP8hqDbrA24yblFS+mi/cCTc3XgZTaGBbJ97CwG3o97LhEE3rh5lMvZCRwYsUTq+CuyIJZIOJB0jy0xt0goK8BJx4hZth5MsXZrV0CyBl64doCC6kr2jVjcLi/tGrGIwcd/ZaatB+/KaDbZHHHFBZxMiuZEUgwxRfkYqqoz1saJcTZOaCmrUHg/emnDe0F1JUXVVRRUV1FUU0lBVVV9RiVza4ZY2DKoi81jzejUXkpqqqkS1WGsrvnEveP/toL9ZFIML148RuKyd9otKILzM1h2xQd3fXM2DJzVpl13eymuqeJ0ejS+qRHczk1BQ0mFgSa2DDa1Y7CZPWbqTy8zuyAILDi9n4KqSo5PXdyqaiuuoIAxu7fx+4TJjLGXLYZ+Qn4h4zdsZ8208UxwkT2apzTE5uYzceNOTjy3CEej1oNkQX0mnHF7duBsYMj6CZMbj0sEgVf8fbmakcyhiQsaA27ViEUsurSbrMpSDo9c1mI+0Y4iCALBBRkcTLrHidRIqsUiRlg4MsvWg0Gm9jKvUkMLMplxYRtf9BzHXPv2ufyvi7jKtthArk16tVPvk/jiAk4kxXAyKYboorzG48ryCuipqmGgqn7/XQ19VXX077+X1tZwJSOJoJwM6iQSXPSNGdLFlsEWNvQy6fLEkqs3R5Wojo1hgfwRdouKurr6uPBautho62KtrYe1ti4299/NNbQfS9jjv61g902I4rVLfiSveK9d/d/OTWXl1X30NrLitwEzntgMOquylDPpMVzJTiAgN4UasQgnHSMGm9oz2MyOXoaWT3w2n1hSyJjDW3m31yCe69671bKr/I5QUFnFodmyZ6t/48gJTkbG0tXYkP62VvS3scLbqgvqyp0jKK4npbBsz2FuvfkCeurSXVMXkxJZ6XeEXdNm0d/ywSy/WiRi/ql9ZFeUcXTywkbnpcKaSmae34a2kip7hi+UylX/Rl48qyOOY6muz+Qungw1cUZFQbrvXCmq5XRaNAeT7nErLxVjVU2m27oz09YdWy3pHfO+Dj7P/qQQzox7HhM12UMq51dXMMhvHZ94jWaevZfM9aUhrawEQRDQU1VDU0lZquurvLaGgOw0LqcncSUjieTSYtQVlehnZsUgCxuGdrF9YklwxBIJh+Mj+D7oKmW1Nbzo3oc+ppaklBWTXFpESmlR/d8lRZTdD8GtJC9PF00duuobscK1Z6u5bGXhbyvYt0fe5avb/sQubTvLzcPkV1cw9PhvDDazY23faU/t6V4tquN2XipXshO5nJVAYlkBagpK9DCwwNvIkl5Glrjrm6PVSeqh1lhz9xobwwIJmPtiq7F37mRmMPvgXnymz6aPjEnIa0QibiSlcj0phRtJqcTnF6KkoMAAWytGd3VghJO91AIZ6m+k/IpKIrJyuJWazuX4ZNKLSwj9z6tSL31rxWJG7tyCpbYOu6fPbvJZYXUl0/x2oaWswv7x81C/H2MnqayQmee30cuwC+sHzGx1xRhTmsWcq+sxUtGiuK6SOokYO00jDg95Terv2UByWSGHkkM5nBRKdlUZw80dcNMzQ11RGQ1Fpfp3JeX7/9e/ayoqo6aoxNn0GD68c5Iljt584jVa5r4Bllzag0iQsHvYwnbVfxKklhZzOSOJK+lJ3MhKpbyull4mFix37cUY686PothAWlkJr/r7cS8/i3ld3XnDc0CLyVwEQaCopork0uJ6YV9azNXMZO7kZNDPzIrXPfvT17RjIX3/loJdLJEw6vAW3AxN+GWo7AmUT6ZF8frNI9yd9vYTEZrSklZezPWcJALz0gjMSyWjsgQASw1duuoa003XGGcdE5x1jbHS1OtUvV1xTRVeu39lzZAJbQZxmnXAB20VVTZPntahPrNLy7mWmMzZmHiuJ6UikUjobd2FMc6ODLa3obpORE55OTll5eSUVZBb1vB3ObnlFeSXVzSmm+tqbIi3VRdGOtlLpV+H+rykL5305V5ONuvGTWSYzaMJopNKCpnmt5ueJub8OWJaoxC/k5fGoku7mWnrwX89R7c4OaiTiFgTdYa9ybfQUFRmkHFXJnXxpL+R7Hl+GxBLJFzMimNrzG0KaiqpENVSKarPn9pgVPAw8nJyjOvSjTe7D3kkdrw0nE6L5uUbh/i613jmtFOd86Spk4gJyEpjR+RdzqXGY66hzWIXT+Z19ejUwIGnk2N59+opzDS0+GXoJJlDQUO9sL+ZlcovITe5mZVKb5MuvO7ZnwHm1u0S8H9LwX40IZI3L5/g3PTlOLQjTsyXwee4lZsiU+qzp0FmZSkRRVlEF+c2vlLKCxEAdUUluuoY46xrjLOOMb2NrTu8oTf/1D50lFX5fUTrGejPJ8bz3PFjnFqwpDGnaEcpr6nhUnwSZ6LjuJKQTFXdA9NIJQUFTDQ1MNbSxKTxpdH4t72BPvoteJu2RHJxESt8j9TnzZ00DRcj4xbLBuaks+DUPuZ29eCzviMab7STaVG8c8sXKw09vvIeT89m4sA0UFBTjraSKkryj1fNVisW1wv5+68GgW+tpUcXDd12tRlTnMvMC9uYat2dL3rJFunzWSGltIhtkXfZHxuGWBCY4eDKMtee7ZIfDdSIRXx9+xLbIu8y18mdT/uN6JT9h9vZafwSfJOrmcl4Gpnzumd/hnaxlUnA/+0Ee8NsvbuhKT8Pndiuvuf778JaQ5dverev/tOkoq6W2JI8oktyHgj8klyqRXXsHb4YT8PWLVtaY1vkXb4NvEzwgldbtTSSCAJjdm2jh6kZ348a2+7+WqKqro6wzBy0VFUw0dJET021U70xb2ek88KJY3TR1mHjxKmYaLa9CXo8MZqX/X35pM9wVrj1ajyeUl7Ef++c4kZOEvPtvXjXfRhayn+fMNJtUVJbxdRzWzFS1WDX0IVPdVOyMyirreFAbBhbI++SWlbM0C52rHDtySALG5musZTSIl729yWxpJCvB4x5LKGK7+Zm8kvwDfzTE3E3NOV1z/6MkDIr2t9OsB+Jj+CtKyc5P3059u142gqCgNeRNbzZfTCLHZ9M0uXHjUQQWH5lL0llBfiNXol2OwVLZnkp/fb9wZZR0xlh1bqqYH9EGB/7n+fykpWYaT2Z/KadwZGoSN6/cIZhtnasGT0edRki5v1+7xbf3rnMHyOmMtbmQQJ2QRA4lhLOVyHnUZST539eYxjTpevfPlWcWCJhxdV9xJXkcXTU8sdmBfQ0EEskXEhLYEtEEDezUnHQNWCUlQNqikqoKSqiqnD/XVERNUUlVBUUUVFURE1BidjifD65cQ5LLV1+Gz65zWxWHSU0L4tfQm5yLjUeTyMzjk5e1Gadv5VgF0kkjDq8GQ9DM9a2c7aeUVHC4OO/sm/4YnoZPZnUbU+C/OpyJpzZRG8jK37pN63dQmXSsR100zfiu0GtL7lrRCKGbN/EZCdnPhw0tF19PUnEEgk/37rJr4EBPNfTm/f6D5J5j0IQBD68frbegWnCPHo8FJa2sKaSb0IucDg5lJHmjvyv51jMn6Ipa0f57t5FtsbeZu/wRXgYtH8l+KwTWZDL1sggwvKzqRaJqBaLqBaJqBLVUd1CALiFzj34b5/hHfKhkZXw/BzC8rOZ59x28pNnw0tGSnwTo0guLWbzqBntbiOyOBuArrot61T/jhiqarKmzxSWXN7DXhObdpukjbF2ZEtEEGKJpFVrDxVFRZb18OLX2wG80rsv2s9oFqvKujoORoazNeQuGWWlfDNiNHNcZc/YBfVemF/0H0VGRSkrzh7iyOSFWGnpNn6ur6LO930mMdXGjf/eOcXYUxt4q/tQFjn0fCKJVTqT46mRbIi+ybfeE//RQh3qo2p+38JERhAEasRNhb2CvHyT3/1J4WZoInX+4r/N1SaSSFgXcoOp9i4dWvpEF+dipaH7VKxhxIKEOwVJbE24ytmscBLKcqWOdS0NA0xteaFbf77oQNz40daOFFRXEpSb0WbZeW4eyCHH7rB77errcZJdXsZ3168yYMuffHPtCv0trTi9YEm7hXoDivLyrB82GWN1TZaeOUhJzaMZhgaY2HJyzCqWOHnzTch5Zl7YRlRRTof6fZJEFeXwn9t+LHbsJXVqvH8qcnJyqCoqoauihqmGFrY6+k9FqMvK30YVczgugrevnuTCjBUdEuwvXjuInBysHzCz3W3IQo24joD8BC5mR3ElN5qi2koMVDQpqqlAgoCinALWGgbYaxnjoGWMvaYx9lrGdFHXlzoF2l+pk4iZd3En5XW1HBm1TOZdekEQGH5oE8Mt7flvn+Ftll997TJHoqO4snQlKk9wWdoSEbk5bA4O4nhcDLqqqix292R+d3f01WSzmmmLrIoypvruxFxTm1+GTmoxuXRMcS4f3TlJaGEmH3iMZKmT9zOtey+qqWTquS1YqOuwfej8Tguy9y9Plqcu2LOLizDR0W21rEgiYeShzXgZm7NmyIQO9Tv0+G/MsHXnVddBHWqnNUrrqriaG4t/dhTX8+KoEtfiptuFYSbODDd1wVbTiGpxHcnl+SSU5ZBQnktCWS4J5blkVBYjIKAsr4iNhgFjzLuz0La/1J6KAOkVxUw6s5nxlt34ynu8zOP/5vYlTiTHcHXWc20KoezyMoZu28y7AwaxwvPJJa7+KxJBwD85kc13gwjISMPJwJAVnj2Z7OT8WB82MYV5vHjxGFkVZbzXazCLu3k2q3KRCAIbom7wQ9glFjn05GPP0e1ylKkS1xJZnElocSr3itJILs9nvIU7i2wHoCZDsuqWEEkkLLviQ1JZIUdHLcewA/Fp/uXp8tQFe5f1X6KvpYWVli5WWjpYaelir2tAN30jHHUNUVZQ4EBsGP+5dpoLM1Z0yD24rLaaHkd+ZMPAWYy0cGq7goycywrncGoQgQX1yZF7GtgyzKQbw0ycMVFrfkb3MFWiWhLL80gozyWqJJMjaUEYqmjyjss4hhg7Sz3ba3AoWdd/OuMtu8n0Pe7mZjLNbxenpy2lm37bexHf37jKztAQLixejpH6kxUGZxLi+O76VZKKixhsZcMKr54MtGyfU0d7qBaJWBdykz9Cb+FuZMr64VMw02jeSuhUWhRv3/Kln7E1v/SbjoZS28I4viyHgymBhBanEVuajUiQYKCiibuuJSaq2vimB6OuqMxLTiOYZtmzQ9/7aHIY793249DIZXTX/zdf6d+Zpy7YT8aGk1NXQ2ppMWllxaSUFZNUUkStRIySvDyOuoYklRYxw8GVrwa0zxW6gU3RAfwYdomrk15pM956exh74Qf0VTSZb9OXwSZd0VbqWPo/gOyqEn6KOs2ZrHAGGDnynst4rDWlcwp6O8CXiKIsTo97NLFza5TUVOO+6xc2jpzGaOu2g31V1NYyetc2nAwM2Dx5+hONZNdv8wbs9PT4ZMjwTnOWag8+Mfd4/9oZfhs2mYl2zi2WC87P4Llr++miocOmQXPajNq4PuYCf8ZfYqaVN1761njoWWGuptsowAtrytkYf5m9ybcYa96dT9ynoKbQvtn7uoir7Ii7w7VJr3ZavCKJIJBRUUIXDZ1nWgX1T+OpC/bmdOx1EjGJxYVEFOYSVZiLioIir3v275C+L6+qnJEnf2epU2/e7D6ko8NvlllXfmWQcVdecx7V6W0HFiTxbcRxkssLWGzXn5UOQ1BXbH0D+HZuKvP8d3Jq7HMyeaVezUhm4en93J77IiYtzD4f5m5WJnMP7eP1Pv152buP1H11hNKaanps+I1Nk6Yx3PbRcAAPk1xaRElNNZWiOqpEdVSJRFT/5e+q+39Xi0U46how3NIeUym+f0lNNeOPbsNR15Cto2e0KcCSygpZdtkHBTl5tg2Zh6WmbotlMyqLmHxpLZ+5T2Nilx4tlrueG8cHIQcwVdPhp57zsVCXPUVlVmUpI0/+zksuA3jZZaDM9Zvj65DzbI65haGqBn2NrelnbEM/ExusNHT/FfSPkae/29UMSvIKdNU3oqu+EeDaKW1+H+qPppIKz3fr1yntNYeusjoldY8nea+3gS17B77E/pTbrI+9wPGMe7zdbSyjzdxavEF6GnbBWFWTU2lRMgn2u7kZdNHUllqoA3iZmfNe/0Gsvn6FXmbmMgcIaw/xhYUAOOq37aj2R+gtvmkmoYiKggKqCkqoKz1wTFFWUGBP9D0+uH4WF31jRljZM8LSHg8js0dWI4Ig8NH1s9SIxfwweJxUwspWS58DI5aw7IoPsy5sY+vgeXTTa96MzUJdj9FmbmxLvMoEC48W2x9g7MiegS/w1p09zL/2O994zpY5Ho2Zujavug7il4irTLZya/WBIw3+mXFsjrnF292HIi8nx82cZL4IPku1WIS5unajkO9rbP1UQ1f/E3kmZ+ydTUhBBjPOb+PnftOYaNX5rr8NvBO0FxD4oee8x9YH1Mcd+SX6HMfS79JL35b33SbgoNW8YPjs7hlu5CRzemzbG6ENLD5zAB1lFdYNm9x24b8gCAIvnDhGSHY2x+cveuz69v0RYXx6+SLhL77WqvrnTk4Gs0/s4bUe/Znu6Iq6olKjN2FL9uXVojpuZKVyITWBi2kJZFaUYaiqzlBLO4Zb2jPYwgYtZRUOxIbxztVT7BgziyFdbGUaf1ltNc9fP0hEUTYbBs6ir7F1s+WiS7KYe209v3ovYqBx63tDVaJaPgs7ytnMcF7pOpJl9oNkmhnXisVMPLMRGy19/hw0u+0KLZBVWcqkM5sYau7AD30eXEc1YhH3CjK5mZvMzdxkQgrq46nbaunTz9iGBQ5eOOtKZ6v9Ly3zjxfsEkFgxvmtqCoosWfYwse6/PsqzJfE8jw291vx2Pr4K6FFaayOOE5MaTaLbPvzuvPoR77fnbw05lzcwckxq6RyypIIAh67fuEtr4Esc5XdyqWkuprJe3fRRVuHHVNnPFbHnK+vXuJGWirH5y9usUxxTRXjj2zHUa9eTdIe/b8gCMQU5XMhLYELqQkE52Uijxy9TbsQkpfFfGePNk1DU8uKm02qUCMW8XbAMS5kxvFT36mMtWxeP//ire3UScRs6rdcqvHuSrrBT1FnGG7qwmce09BoQ233V27kJLPo0u52GxmIJBIWXtpFQXUlR0ctb3WTuFJUS1B+OjdzkrmYGU9CWT7z7Dx5s/sQmVNU/ssD/jYOSu3lcFIo4UXZfOL5qNDrbHQeoyqmOdz1LNk54HnecxnPtsRrnMh41FHIy7ALpmpanEyTLldpfHEBpbU1eBmbt2tMOqqqrBs3kaDMDH65fbNdbUhLfFEhDgYtq2EEQeC9q6cRCRLWDB7f7k1dOTk5nPWNeNmjL4cnLSBo/st8P3gcBqrqDDC35r1eg1usKxEEfgm+weD9f7Li3GEq7ydYaEBFQZGf+01jtl0PXrlxiN3xQc22s9R+IHcKkwgrTpdqvIvsBvBHn6UEFSax6PoGUioKpP6+/U1smGTlyud3z1IlqpO6XgPrIq5yryCTX/pNa9PyR11RmUGmdrznMZyTY1fxTa8JnMmIYcTJ39kZd6cxaf2/yMY/WrCX1VbzXag/8+29WtRhdia6yuoU13ZcsEsECRdzglhxezUfhf5JVlXLN6WCnDxzbPowx7oP30WeJL+6rMnn8nJyjLPsxsm0KKmSI9/NzURVQREXg/aHXHA3MeWjwUP59XYAV1OS291OWyQUFuKg17Jg33Y/DvcvQydi0IaDUlFNJWfSo/n87lmmnt3CNyEXWhRq+qrqTHdw5dfhk9k0anqLFiTltTW8cOEoa4Ov84J7H+7lZTHv1D4Kq5teIwry8nzqNYbX3QbzSdBpfou89khbvQ3s6KZtzvaERz9rid6Gduwe8CLK8oq8cnsH5XWPesm2xIc9RlBSW9XsWFrjRk4yv0Ve42PPUTLfc/Jycsy08+D8+BeZZduDL4PPMfnsZm7mJMvUzj+NwppKfFMiePeWH2/ePCpVnX+0YF8XcQ2xIOENt5ZnVJ2JrpI6xbVVHcouf6cwmpeC1rA6ajeOml3Iqi7gucDvOJDmj7iV8AOvOY9CQ1GZ1RHHH/lsvGU3EssKiClpO8zA3dwM3A1NO+xxuLC7BxMcu/LW2ZNkl5e1XUFGqurqSC8twaGFjdOw/Gy+vn2JNzz709fs0cQbfxXkE05vpNfRn3j5+iHu5KXSTc+EvYnBTDizkdu5qe0aX2JJIVP8dnEnJ4M94+bwvvcQDk2cT35VJTOO7ya1rLhJeTk5OV51HcT/vEazJuwyZ9KjH/l8qf1ALmRHkirD7NtcXZd13osoF9Xwdbif1NemsZoWb3YfyqaYABJK86Wqk19dzlsBRxnTxZn5HUifp6Wkwgc9RnBq7HOYqmux8NJuXr5+iPSK4na3+XeiVizmVm4KP4T6M+XsZnof/Yl3bh0jtbxI6v2Hf6yOPb40nwmnN/Jfz1EsdOzVdoVO4FpuLK8E7uTa6I/QVJItKFZcWRqbEo9ztyiW3vrdWGk3EVtNc2olIvamnMcn9Ty2Gma81XUODlrNJ3S4kRfPS7e3873XHEaZuTUelwgCg4//yjSb7rzdfWir4xhxaDMjLe35oHfr5aShvLaWKXt3YaCuzp7pszs1LVlEbg6T9u7i7MKljwj3stoaJhzdjrmmNrvHzkZBXr4x69DNnBRu5aYQXZKLHOCia0IfY2v6GFvjbWSJjnL9tZhVWcrHd05yKSuBRQ49edd9uFQORQAXUhN44/JxbLT12DBiKuaaDyw+cirLWXrmIHlVFewYM6vZldEHgSc4mRrJ0dHLm+Q1FUnETLn0M/2NHPiou2wb21dzY3k1cCefe0xnchfpMiCJJBKmnduCjrIaO4fOb1WV2Vmho5vDPzOOL4PPk1VVynPOfXneuf9jSzz/tEgpL+JKVgJXsxMJyE2hQlSLpYYug0ztGGRqRz9ja9ni/AtPicrKSgEQKisrO71tiUQiLLm0Rxh/6k+hTizu9PZbIrQoTfA4/rGQXlEodZ3Myjzhq4gdwkj/N4RX7qwRQgrjmi2XXJ4lvB70szDa/y3hz3hfoUpU02y5T0IOC8POfiMU1VQ0Of7V3XPC8OPrBYlE0uJYiqurBKtN3wpnkmOlHn9bROblCs6/rhVWX7vcaW0KgiAciYoUHNetEWpFoibHJRKJ8PKFY4LnrnVCdkVZ4/HVIRcE+71fCpNObxS+vHtWOJceIxTXtH7tSSQS4UhSqOB5+AdhkO864VpWYqvlxRKJ8PPd64L1pm+Fty6fEKrqapstV1JTLcw54SO4bv9JuJ6R/Mjn1aI6YfKZTcLYUxuEirqmv7NPUoDgffJTIb+67JF6bfF9xEmh76nPheSyPKnrBOWlCXZ7vxR8U8JbLfdH5HXBad/XQnB+uszjkoZqUZ3wR+QNofvB74QBvr8Ih5NChZqHfvu/I2KJRFgdckGw2/ul0P3gd8KqK/uEHbGBQlJpQav3alv8IwX7hYxYwW7vl0JAzqM3zeMktbxA8Dj+sRBWlCZV+YSyDGHspbeFJQFfCZdzgtv8IcUSseCbfk2YfOV9YeHNz4UrufceqVNSWymMOLda+G/IoSbHg/PTBbu9Xwp381q+8a6mJwlWm74VcipkFxqtsTc8VLD9+Qfhjzu3BHEHLta/sjbgujB468ZHjvunJQhWm74VLqU9EMLRRTmC3d4vhX0Jwe3qK7eyTHjx2gHBbu+Xwhs3jgjp5cXNlvv9XoBgtelb4bvAK23+ltWiOmHW8d2Cw5YfhIyykkc+TysvEjwP/yB8GnS6yfFKUY0w5MzXwm/R52X+HjWiOmHulfXC/Ku/C2KJ9BOe92/5Cb2P/iRkV5Y2+3lIfrrguO8r4c+omzKPSVZyKkuFdwJ8BYd9Xwm9j/4kbIoOECpbeIA+66SUFQrLLvsITvu+FvbG3+3UB9U/Tsculkj47t5FRlt0pU8LdsGPC+X7m2jShuJNrcxBJIjZ5P0fBhv3aNNqR15OnkkWA9jc+z+4aNvwecRW3r23noTyByF2tZXUeMdlHL7pwUQUPzjuoW+Op4EF34debFHP2tB/Z4cEmO3ixvsDBvPjzeus8jtKRW1t25XawNXImLTSElJLipscF9+3ovirVU9DgmevVnKSNiAIAl+F+fFrzHlK7m+EG6lpsn7ATNYPmEFIQQYjT/7Od/cuUlbbdDNyuKU9ttp67I4O4XxqfKt97Im+x52cDEZZOzSbzb6Lhi7PO/fnaHI4NX9J9qCmoMwMq14cSrtDnaT5JBAtoaygyKceU4koyeBcVoTU9d7vMQItJRVWXd1Ppajpb1cjFvHuLT96G1mzouvj9zg2VtPi+z6TuDzhZaZYufFj2CWGnfiNbbGBTc6TtAiCQGhhJt+H+vPOLV9+CPVnT3wQ/plxRBfnUNLBPbPmqBbV8Uv4Fcac2kBGRQm7hi1gjr1np6YdfOqC/cPbJx65QTrCkeQwEssKeNd9WKe1KS0K1AtEiZQXgliQoCAnL3N4XkMVXT5wWcTPnq9TLa7lpTs/8lvc4cYLcIxZdzz0rPg+8mTjMTk5OT7oMZJbean4ZzUvdAxV6y1HCqo612RTTk6O53p64zNjNveys5h/eD/5lR3rY6iNHUbqGhyMbCqgGkI6J5YUNh6z0aw/llxWSFuczAzlYGog+5JvMcF/DX/EXqTsvjXJmC7OnB73PO+6D2NvYjDDT/7O3oTgxnPspGfIialLGGllz8rzR/jvjXNUP2RZUyMW8d6103wWcIG3vAby27DJLe49TLJ2payumksP/V4zrb0pqqngQnZkm9/nYbpqmzHWvDvrYy8gknICoqOsxqZBc8ioKOHNgGOND0+An8Ivk11Vxre9Jz7RGEHmGjp86DmSyxNeZqKVK9/eu8CwE7+xM+5OmwJeIggE52fwdch5hhz/jWnntuKXEkF+dQXnM+L4LtSflVf3M+HMJryOrMH98PeMOvkHiy/t4T+3/VgXcZU7eWntMsW8mBnH2NN/sjEmgDe7D8Fv9Eq8jR7d3O8oTz2kwJXsBMaf2ci3vSfR38SmQ21Vi+r4Kfwys2x7YKfd/uzj7UVerv4GlQjS/eBiQYyCXPuf0i46Nvzi9TpnswNZE7MPe00Lxpr1QU5OjnddxrHw+gbOZoUzxrw+uURPwy4MM3Pg98gbDDd/NLiXoVq9p2h+dSVd2z2qlulpZsGB2fNYdvQQsw74sHXKdGx0ZY9pAvUJL6Z1c+FQVDiv9+nX6AhlqaWLkrw8CSWFeNxPXaehpIyxqiZJbQj2srpq1kSdZpplT97qNoY9yTfZkXiD3Uk3WWw3gPm2/dBQVGF51z5Mt3Hn18hrfHw/1vpnPceiJK+AhpIyPwwezyALGz66fpbb2emsGzYJJz1DcivLef7CUWKL8tk0ajoj28gra66uTW8jK/xSIhjT5YHjkpmaLoNNurIv+TZjzd1lPncvOY1g+uVf8E0PZrqVdIYFNlr6/DFwJosu7ea7UH8+6DGCoPx0NkUH8GWv8VhoSBe9tLMxUtPkY89RrHLuy++RN/g65Dx/RN3gZZcBzLTt0TgLFksk3C1I53RaNKfTo8muKsNKU49J1q6M7eKMm55pkxVzWV0N2ZWlZDW8qkrJriwjq7KUGznJrA2/gq6yGoNN7Rhm7sBgU3t0VVo2AkkrL+aL4LNcyIxjvGU3Puwx8rGGUXjqgv3o6BV8HXGJRZd2s8TRm3fdh7V7x3tH/B2Ka6t4ze3xxVpvjYYZiwTZZuwd61OesWZ9SCjPYEPCMbz1nTFQ0cFNtwsTLXqwNvoMQ0ycUb0fz/35bv2Ye3End/LSHsn5qquiirycHPlVFR0aU2vY6upxYPY8VvgeYeZ+HzZPnoaHaftCxM52cePPoECupaYwxKbenV9RXh4bbT0SipsKcVst/TZn7OtjLyCWSHjNeRSaSqo85ziMuTZ92ZV0g22J19iddJMl9gOYa90XXRU1PvYcRW8jK94KOEZaRTG/9Z/RaA0yxd4FT2NzXvM/zsRjO3jJvQ97Y0NRllfgyKSFOOlJF4lysrUbn909Q1ltdROriDnWfXjx9naCC1Pw1JdN5WilYcBUy55siPNngoWH1LH+vY2s+MZ7Iu/c8sVUXYvd8UEMNLVjjl0Pmfp/HJioafFpzzE8160ff0Re5/Pgs/wRdZNlTr1JKS/kdHo0edUV2GkZMMPWnXFduuGsa9yi+lNLSQUtHSMcm4mxJAgCCWUF+GfG458Zxzu3fBEATwMLhps7MszMAScdI+Tk5KgRi/gz+ia/R93AQl2HHUPmM8BUttAT7eGpq2IMVTVYP2AG3/eexKHkUCad3URIQdtp2RqoFtVxJj2aV28c5qewyyxz6o2JmvTBqzqTBsEullEV0xkst52AhoIqv8UfaTz2mvMoimor2Zl4vfFYL0NLPA0s2Bj9qFeogrw8Bqrqna6KeRgjdQ18ps+mu4kp8w/v50JSQrvasdPTp4eJGafiY5sct9c1IKGkqa23tZY+SeUtC/bokiz2Jd/iNedR6Co/cGbSVlLjJacRnBj2FtOtevFn3GXG+69hZ+J1qsS1jO7Slb3DF5FQms/M89tILS9qrGulpcuBifNY6daLtcHXcdAxwHfKIqmFOsDYLs4ICJxJj2lyvK+hPQOMHPko5GCjqkgWVjkOpbi2kv0pt2WqN82mO6+4DOTL4HPkVVfwtfeEZypKo7m6Np/3GseF8S8x0NSW1fcucCsvlfn2Xpwa+xxnxz3PW92H0k3PpN3jlpOTw0HbkFXOfdkzfBF3pr7F2r5TsdLUY3PMLcaf2cig47/yYeAJxp7awIaom7zuOogTY1Y9EaEOz4Bgh/oTNd3WnVNjn8NcXYdZF7bzY9glasXN6xAyBowAAIXZSURBVABrxCLOZcTw5s2j9D62lpevH6KguoKPeozkNdfOc0bKrirhYErgI96cLaEgsyqm8wS7mqIKr3edzdW8e1zPCwPAWFWbFfaD2ZJwldzqUqD+XK9y7sv5zDjim3E8MVBVJ7/68YdF0FBW5s+JU5jg1JXnjx9jb3hou9pxNzEhrrCpELfX0W92xp7SwoxdIkj4OtwPN90uTLVs3rFGV1md15xHcWLYW0zq0oPfYi4wyf8nDqYE4qpnyqGRy1BRUGTG+W0E5T9w+1eSV+C9XoO5PucFto+Z2epyvdl+VdQYYuaAb2rTvQQ5OTk+95hOtbiOb8L9ZGoTwERVm7k2fdkcf0Umj1SAN9wG82K3/vzQZxLmz2hURgsNHb72nkDYjPc4NfY5XnMb3DiL7my0lVWZYOXCD30mEzD5dQ6OWMp0m+5EFuXgbmDO2fEv8Hy3/p26OdoWz4Rgb8BcXZttQ+bxiedotsTcYsb5rY1JmWvFYvwz43g7wJfex9bywrWDZFaW8nb3odyY/Bp7hi9ioWOvDp88QRAILkzhnaC9TPBfw9fhfky9/DN7km62udnUqIqResYublWwV4oqKa0rlXpX3lvfmZEmvfgl7iDldVUALLIbgK6yGutizjeWG2nuhK2WfrOzdgO1xz9jb0BJQYFvR4zhZe8+fHjxHGsDbshsgeCgb0BcYUGTevY6+iSXFjXZ5LPR1Ce7qqzZMAG+6cGEF6fzodvExn2SltBX0eCtbmM5PuxNRpt156twPz4NPYqhqjp7hy/G08CChf678E1pKogtNLXbHRBtirUbN3OTya1qOsEwUNHkM4/pnMwM5UR6iMztLrMfhEgQszPphkz15OTkeMd9GKMsHsdOTOfyJIUp1K96PQ0teKv7UI6OXs7P/aY9lYffU9exP4y8nByLHHsx0NSWd2/5MfXcFoaaORCQm0JpXTWeBha84TqYsZbOnbr5UCsWcTorDJ+kAKJKM3HVseBzj+kMMnZiW8I11kSd4Vj6XT50m4SHXvO72PINVjHIMmNv/sITBIEvor4hsyoTVXkVjFWNMVYxwljFGGPVB+/6yvpN2njRYSorbq9mY6Ivb3adg6qCEm84j+E/wfuZa90HV10LFOTlWdm1L5/ePc2bbkMw/ct5NFRTJ7/68enYH0ZOTo43+w7AVFOL//qfJ7u8jC+Hj5LaS9VR34Dy2lpyKsox1axXwdnrGlArEZNeXoK1dv3mrKWGLgAZlSU4aD9QhZTUVvJz9FlmW/fGWafeRHJb0ikqRFU4a1vTVcsKCzXDR2Z6hqpavOc6nj6GdrwffICMyiJ+7DmX3wfMZPW9C7wZcJTksgJedZUtbG5zDDdzQF1BieOpkSx/yKRwkLET82z68nXEcTz0reiiLn3qSF1ldZbYDWRrwlXmWPdBX+XfHKf/FJ45wd6ArZYBe4cvZlNMAFezE3nJZQDjLbt1+u57XnUZB1JuczA1kNK6KkaaufKB20S663ZpvCFfcx7FpC49+Cb8OEtubGRqFy9ecx79yI3wwCpGulmnpBVVTExZLJlVmaywXYZYEJNbk0tudR7hpRHk5uZRLalfPivIKWCobICTliNLbRajraTBSw7T+DpqJ8ONe+Kh58BoMzd8kgP4PvIkW/utRE5Ojmk23fkp/DLb4gJ532NEY7+GquqklhbLeho7zDw3d4zVNXj19HFyKyv4ddwk1JXa3tRrCCcQV1jQKNgbTB7jiwsbBXvDdZNR0VSwr4s5j7ycPC91rT8HN/PD2Z1yFjsNc/wyryMWJGgqquGkZYmzljVdta1w1rJCX6X+YTjExJmt/Vby+p1dLL7xJ794L+Ijz/9j77zDo6i6OPxu32TTe09IJY3eO4ICogIWQBEBGyqiWLH3gh0pKqKiiIqAoCgoRXrvEBKSkN7Lpmyyvc33RyCajwAJBAKY93n22TIzd+7s7J65c+45v3M9Yc4evH5oHTnaKt7tPvKiSs0ppTJuCGrPb7nHzzDsADPa38CBimyeP7ycb3rf3yydnwntevNTzh6+ydzG03EjLriPbVxZXLGGHeoiHB6K7cNDsX1avO1sbTlfntzChuLjOMuU3BbSnTtCe+CrbPwuoJ2TNwt6TmZdcRIfpfzFptITPBozlDHBXev/SJL6ydOmj9jPduu/pXwbYY6hDPA+s0SZIAjUWrWUGUspNZVTaixlTfGf+Cv9GBlwI4N8OrOp7CAfp//Ml92eQSGR80zcjUzY+QXripMYHtABhUTK5KjudaFhsX3rIy68HFSXxcfeGEPCI/jx1rHcv3oV41cs5YGu3bkhPBKF9Ow/U09HRzyUDmRUVtI/JAwAF7kCH0cVmZoKhhBx6jMlTjIFhf8SkjpeXcAveQd4s+OtuMgcMNnMfJaxikHenXkx/h7MNgsZ2kLSa/NIrc1jW/kRfszbAIC3wo32ziF084hluH8Pvu87lRkHfuCenQv4qOudTIjsSrDKjem7VzFxyw981vd2vM5T3/RcjAqNZ9LWY2TVVJwRyquQyHi38x1M2PEFX57czLSYoU1u11Gq4P7IgcxOXc+Edr3xd3C74D5eLFm1Zfg5uJ635GMb5+eK8rFfLg5X5jJx5wLSa0p4KXEUf133NI/GDD2rUT+NSCRieEAHVg18jFuCOvN+8hpGbZnNqryDWOw2lmTX+ax9lU27qxAjOutEa44uh3jXxssCikQiXGTORDpH0terN7cGjWZU4M2sKlxNqbEUkUjEY1F3oDFr+TzjVwDi3QIZHdSF95LX1k+kToisK6SxOONAfdthLu4UamvIr9U06Rhamk5+/iwfeycuSiVPrltL32++5L2d28jXnL0/jnIZNaaGE4AdvPz4O79htE2UixeH/hVxdaAiBweJjBGBdbHgxcYKSoyV3BRYN5CQS2TEuYYxOmgAz8XezaKeL7Cy79vM6vAQIwP6YBGsfJq+nNePL0IllfF1r/vo6hHG1L3fsiR7F/39wlk+ZBKlhlpGrf+aNXkpDfz+TcVmt/N30UkAyozaRteJdPbloejBfJ+1q9kZqbeHdMdX6cJzh5djvoDszZZgd3kGd2yfz23b5rK9LP38G7RxTv5zhl0QBD5I+ZN410B+6vcwo4O7NDmO9zROMiVPx43gt0Ez6OUVydvHVzNy88d8fOIvnowdTgf3ptX7dJM7U21u/I/qq/Sl3FTe5D7d6DccX6Uv3+YsRhAEvJVuPBkzjjXFu9lSdhiAp+NGoJLK+SBlLVA3ir0nujvfpO1DazEB1KW4O6hYlHzgrPu61LRzc2fJmDvYPuUBJnbsxK+pJxj03Vfcu3olm7KzGhjHMp2WgpoaOvs1LAxyX3w39hTnc6D0H0N+c0g86wpS0Z0qdtHPJwq9zcyRyjpp3hBHX7zkrhyuOnnWvjnLHOnqEcOE0Ot5M/EBPuj0CCdqcnnk4MeUGNV82HU8j0Rfx8cpf/Hc4WUEqVz49fp76eoVzOO7V3HDnwtYlnXkrBFf/4/eauaRnStYmnmYT3uPOWv5PIDBvrEY7RZSNEVNavs0comU2d0mkFlbyhtJvzY5qqulyKgt5ZlDS7nOL5aO7iFM3/89zx1eRqWp8f9GG+fnP2fYD1XmkqIp5JGYIfXaLhdKoKM7r3QYxW+DZjDQpz2PxVzPPeF9m7y9u9wJo92MwWo6Y1mQQyAFhqbH80vFUu5tN4kTNWlsV9fFrQ/w6cTNAX35JO1nCvXlOMmUPBs3kg3FyexXZwFwb3QPLHYb35+sM+QysYR7E7rxU9oxNKaWk3q4EPycnHm8Zx+2Tb6feTfejNlm4/7fVzHou6/5/MBe1Ho9+wsLEYtEdPFvaNh7+4fQxSeAeUf+ify5OTQei93GnwV11aQinX2JcPJhXXFdeKhYJKavdyI7ys+sRHU2OrhF8Fm3p3CXOTP90Gw2lx3mvsiBfNZzEvsqsrh75wKqLTrm9BnDuhFT6eoVxMsH/mTwmvksStt3hvbKvykz1HLnpu85qC7g+0ETzluvN1TlhYdcxaHK3Cb3/zQRzj7M6jyWv4qSeOHIiss2clcba5m+fwlRzn681fE2ZnUey5xud3O4Mpcxp7JjW1qr5b/Af86wf5+9kw5uwWeNbLkQAh3deTHxZu6NbF4Mvbu8zvVTaa45s02HQEqNpVibcVsd4RTO9b5DWJr3M9XmOtfFQxGj8Hfw4q2U7zDbLAzwjaGfdzTvpazBarfhrnDknqhufJ22t34ke2dMR8QiET+kHmnW8VwqZBIJIyKjWTLmDjbcPZnrIyL54sB++n3zJe/t2kactw9O8oZa6SKRiEc79mZzQRbH1aUAeCgcGewfxcqcpPr1hgUksKE4uT6Utb9XR3L1peTpSpvcPy+FKx92msaN/r2ZdWIJ807+QlePUH7s9zAOEjkTdnzBxuJkIly8eL/nzWwe+QjDgtrzYdJmBvw+j7nJ29GYDQ3aTKsu47aN36K1mFkxdPIZWcKNIRKJ6OwRyuELMOwA/Xyimdt9ItvL0nl433fUWAzn3+giMNjMPH7gB6QiMR93u7P+znmAbwwrBz7GiIAOvHp0FQ/t+44C/fl1ftr4h1Y37HvKLyzr8ELI1arZWprWrFH1pcRdVhfFUWU5MwEqyDEQm2CjxFjSrDZvCxqDUqLkh7yfgDo/8Utxkyg0qFmQuRqAZ+JGkKOtYHnufgDujemJyW5lySlfu4tcwYT2nViQtI9SXctXP7oYIjw8eWXAYHbfN5XXB12Hl4OKUTGxja57XXA4cR4+zD+6p/6z29p1YG9ZLvnaaqBOMK3KrONAZQ4ACa7tcJWp2Fp+pFn9koolPBI1hhdiJ7KueB9PH5mPTAyLet/PyMCOPH1oKW8lrUZrMRKgcuWVLjew7aZHuTOyC1+n7aX/7/OYdfRvygy17CjJYuymxQQ4urJi6CTCnJsewtjJPZQjVXkX7E7p7R3Jot73k6+vZPKuhRTqq86/0QVgF+y8eHgFBfpK5vW4B3d5w4lllVTBcwk38W2f+yk31nD71nksztrZZOGy/zqtbtgfP7CEl4+ubJFaoedjSfYuAh3dGOzXuCG43LjJ6+Raqxrxs/sp/RAhotDQPH+pUqJkUtg97Kvcz+GqIwAEOXrzRPRYVhftYHv5UUKdvJgY3ofP0v+m0qTDQ+HIxMhufPWvUftjnXrjKlfyxLa1TQ7fvJw4ymSMS+jAynF3cV/nro2uIxKJeLRTL/7MSeNkdV126kD/CDwUjqzKqct0DXXyIsbFj3VFdaN4iVjCEN+urCvee0HGcbBvF+Z2nUGtRc/DBz4ipSabFxNv4b3OY9lYnMwd2+exu7xOrdFTqeKpxEFsv3k60+L6sioniYF/zOe+bT8z2D+SxYPuwl1x7lqt/08Xj1BqLAaytE2fn/l/ol38+L7Pg0hEYibt+pIUTdNdgk1ldup6tpen80m3uwhVnV2wr6N7CD/3f4Qpkf2Zm7aBe3Z9SWoz5xD+i7S6YZ/V6Q72lGcwZusc/io6dsn8aVVmHasLDjMhrE+LpfFfLDKxFGepI9XmM0fFcrEMP6Uv+frzV6X/fzq6JdLbsyeLc5dgsNXdTg/27cJI/958lLqUYkMFD0QORCmRMe9URup9MT0xWC0syTgIgJNcwZzBN7O3OJ+Fx/dfxFG2LsNDowl39eDzU6N2mVjC6NAEVuYk1V+whvknsqkkpV5H/0b/3pSaqjhYde7ojApTBdvKd2CxN8xmDVP5M7frEyS4hjPz6Ocsy9vEDf4J/DJwOvGugTy87zveOPZbvcaLs0zB1Ng+bB05jZc6X8/Mjtfxca9RFxT7HuPih6NEfkF+9n/j6+DKN73vJ8LZl/t2f9OikSrLc/exOGsnr3UYQxePsPOuLxNLmRo1mJ/7PYJcLGXCzgXMSd3Q5LoH1wqpmiIe3LOoSeu2uoUb7B/HLwOnc51fLM8dXs7jB36gxNDyoXbLc/chF0sZFdy0eo+XCze5U6M+doBwVTgZ2gtzVd0VMh6Tzczy/JX1nz0cORpPhSvzT67EUapgRuwwVuUfJLm6EE+lirujuvJV2p76Cb1O3v481bUfHxzYRpK6eS6hKwWJWMwjHXvxa2ZKfQHp29p1IF9XzYHyfABuCEhAYzGwV133XYeq/Ih3acefRWdKLpzGbLcw++Rcvs5exPNJL7O/8kCDQYlKquSV+MncF34TX2f9wRvJ36KUSPiw652832Ucm0tTuH3bXHaW/ROBo5TKmBDZlXtjel6wtrlULKGDezCHTrmWLgZnmZJ53e9mqH88Mw78wIq8i7/A7yw7yazkNTwcfR0jAzs2a9twZx++6X0fz8bdyI85u7l391eXzFV0pVFq0DB9/xKEJirHNsuwJycnM2jQIGbNmlX/2bJly3j66ad55JFH2LZtW/N6ewoXmQMvJ47iq173kqNTc+vWOSzNubBb4cYw2SwszdnLHaHdr7jkB3eZM1WNjNgBop0jydRlNWsC9TQuMhfuCh3PprLNnKytu/VXSOQ8GnUbeytT2FuRzI0BHejoHsx7yWuwC3buj+mFwWrhh4xD9e1MTexBV99Apm/+vd5Nc7UxKiIWf5ULC47VKRm2d/Mlzs2XX3Lqol+CHD2Idw1kXfHx+m1uDOjFrorjZz03P+UtpcxYznPtnyHSKYJ5GZ/zzon3yNJm168jEokYG3Id73d8hGRNNvfve4+9FSl1o/cBj9HRPYRp+xfz2tFVLTpR2eXUBGpL3P3KxFLe6DCG+yMH8lbSauambrjgdtNrSnj28M+MCEjkwchBF9SGWCRmXFhPfuz7EEabhXHb57P+X+ftWkRnNTH9wBKcpAo+6npnk7ZplmE/fvw4/fv/o3VeU1PDrFmz+OCDD/joo4945JFHsF9AAsZpunm2Y1n/aYwP68UHKWuZsvtrMmvLLri906wtPEaNxcj4sF4X3VZL4yF3odrSeLxutHMUZruZXH3eOduw2E0UGbLO+LyvZ2/iXGL5Jue7endBZ/co+nt35LOMX7EINp6LH0lSdQFrCo/ipVRxV2QXFqbuqRfLkojFzB54E5VGA6/v+fsij/b82Ox2ktQlrMlOvaBSZ40hE0t4qEMPlqUnUXkqq/bWdh1Ym3+i/mI1LCCRzSUn6sP8Bnh3QimWs67kTFnbfZX72VS2hXvbTSbWpT0PRTzAK3EvIiDwespbfJG5kArTP4qTHd0jWdj9WRLcwnkpaSEfpP6ETCzi/S7j+LDLeLaVpXH7tnkt5u7o7BFGqbGGIkN1i7QnEol4OPo6Xuswhu+ydlxQOGSZsYbp+7+nvYs/rySOvmj9nHBnH77vO5URAR159tDPvJn0GwbbpR94GG0WdpVnNFnx9WKx2m3MPLSMcmMt83rcg4usaeqgzTLs48aNQ/IvtbS9e/cSExODSCTCwcEBlUpFZmbjrgOLxYLBYGjwaAylRMZj7a/nx34PYbHbGLf9M95PXnvBt1yF+iq+ytjK8IAEfM6TWdoaqKTKsyYp+Sv9cZY6kV579oQZgF8LvmD+yaepMBU3+FwkEjE57B7UJjXL8lfUj7QeihhFhUnD8vzNtHcN4PaQbsxOXU+NxcCD7Xuhs5r4Nv0fg+avcua9/sP5OT2JDbnn7svFsKUgi45L5tQVpti0mlt++54j5cXn37AJ3BoZj0QsZm12na75LSHxmG3/xLTf4J+A1mpka1kqAEqJnCG+3VhbtBvbv3y5VruVb7K/Y6D3AHp6dq//PMIpnBdjn+PRyIfJ0GYw89iLrC3+q/6u01XuxItx9/Bq/BT2V5zggf3vk1FbyFD/eH4ZOJ0uHqFM3/99/d3TxeDvUJf53NKTnqODuzCn+0S2laVx/55vWF1wmE0lKexTZ5FcXUiuVk2FSYvRZmkwqs/WlvPIvu9QSmR83PXOi84fOY1SIuPFxJv5oMs41hUdZ8KOL0iqbv6cVFMw2Swsyd7FjZs+4pF93zH07/e5descXj/2KyvzDpBRW9pkKZGmUmnSMfPwMvZXZDGn2wQCHZtebeyivmG1Wo2T0z+FeJ2dnVGr1URFnVl27e233+b1119vctsxLv4s7vMAy3P3syhrO0tz9nCdXywT2vWhk3tIk674e9WZPHvoZ3yULjwac32T9325sNpt7K1IYaBP435/kUhEhFMEmefxs5eb6n7MRtuZkUU+Sm/uDZvEgqyvUIgV3BY0Bh+lO3eH3sDinHUM8O7IozFD2Vx6gveS1/B2p9t5JK4vc5K3MzQwur6CzIiwaEa2i+Hd/VsZHBzRZPXF5rCtIBsfRyeWX3cLSomU53euZ/Tq77knrgvPdO2Ps/zC3WgqmRxXuQL9qTsRT6WKYUHtWZy+n9vCOuDn4Mog3/YsPLmFIX5xiEVixgQN4I+iXWwqO8T1fnVGXCwS4yRVIW1ElVMkEtHdoxud3DqytvgvVhSs5Gj1MR4IvxcvRZ3wWD/vDnRwi+DN5G95+sg83u7wIPGu7ZjVeSwDfdrz8tGVFBuqeTpuRLOUGk+Tp6vg4b3fEarybNLEZHPp4x3Jt73v5/Wk33graTXms7gJpSIxKqkCJ6kStamWCGdfPu12N67y5kX5NIXr/ROIcw3k9WO/Mmnnl0xo15tHYobgIJGff+PzYLXbWF1wmAUnN1Nt1jMutCdjw3qQrVVzoCKbpOp8/iw8htFuQSVVkOAWRAe3IBLdgkl0DzojjLMpCILAmsKjfJjyJwqJlDnd7yaxidnsp7kow+7l5YVW+89os7a2Fi+vxqvDvPjii8ycObP+vcFgwNPz3HVJpWIJd7brxe2h3dlYnMyS7F1M2f0V8a6BTAzvwxC/+EaV7ARBYEn2Lj45sY4h/nG80eFWHKQXf5Jbmm3lR6g01zA68Oyl/CKdIvi7dPM525GI6k6jStr4HUlvr15YBCtfZy9CIpIwJmgUtwcPZmv5ET5OW8pHnR7llcTRPHZgCUP84pjavg8bCtJ5au9qlg+ZVB+d8UzX/gz55WuWn0zizpjmTXw1hUxNFYlefsR6+ADw04hx/JKRzFt7N/NXTjqv9x7K8NCoC76NrzYZGxS6uC+mB7du/JZ95Xn09AllWvQQxm7/jA3FyQwLSCTI0Zuhft1YkrOewT5dkIoliEVibvAdyvKCldwaNBonqdMZ+5GJZYwKvJmObh1YkLmQF5NeZWLYBPp69j6l86Pi7cQHeTPlO547+gWvJ9xLF48YRgR2wEOh4q2k1Yze8im3hnTjgchBeCubVhEsraaYR/Ytxkfhwvwe91wyGd4oFz+W9J0K1Mlda60mdFYTOqux/rXWakJrMaKzmlBJFdwa0q1ZqpPNJdDRnQU9J7Mq/yAfn/iLzaUneCVxND28wi+oPbtgZ0NxMvPT/6ZIX8WY4K7cHzWoXk8qyNGD/j7RAFjsNjJqSzlWlU9SdT5/FSWxMGMrUFeGsJN7CB3dQ+jkHkI7J69zav4X6qt4K2k1e9SZjA3twfSYoTjJlGdd/2xclGHv2bMnM2fORBAEjEYjOp2OiIiIRteVyWTImiDD2ui2YgkjAjswPCCRI1V5/JC9ixcOr8BbuY7xYb24LaRbve/JYDPz5rHf+LMoicfaD2Vy+MXrYV8KBEFgRf4W+np3wM/h7COzCKdwVhSspNJciYe88fUkorrv1fEshh1ggHc/7IKNRTmL8VR4MMC7P0/FjGfawU9YU7SbmwP7MiqoC28mreaXAaF83GsUozZ8zQfHNvNS57q7nXauHtwZ05HZh3YyOiLugmvTno1MTQVjoxLr34tEIm6PSuC64HDe3reFh/7+laEhEbzR+3oCnZrnVjNarRhtVlz/VTe0o2cgXTyD+CZtLz19Qoly8WNYQAKfpf/NEL84pGIJd4dez5TSd9lYeoDh/nWSuf29+7Gq8Dc2l23l5oCRZ91nmCqU1xNeYXn+ShZmfU1GbQYTwyYgEUmQS2S8Gj+FD1J/5KWkhbwQdw/9vDvQ0yuClQMf47eCQyxI38zq/MPc1a43kyP6ndO/eqgyh8f2/0B7F39md7vrgozBhSCXSPGQSK8ILXeRSMStId3o6xPNu8d/58G9ixgd1IWh/vEEqzwJcHA778VFEAS2l6UzL30jJ2tKGRGQyLzuEwk5R6y9TCwh1jWAWNcAxlH3G6ky60iqKuBoVR5Hq/JZX3Qco92Ci8zhVOZ7MJ3cQ0hwC8JBKscm2PkpZw/z0jYS4ODGN73va3Yt23/TLMP+yy+/sG3bNmQyGbGxsYwaNYrnnnuOJ598Er1ez/z58xFfglv005xOme7sEUqhvoofc3bzVcZWFpzczKigLlzvH8+HKX9SqK9iXveJ9PU50yV0pXBck8VJbQHTom4953rtVGGIEJGpzcLDo3HDPtDnVioLSpCLz+2qGOQzkEJDEUvzltPFrTORzkGMDRnMwqzf6ekZx9NxI9irzuSd47/zQZdxvNF1BE/vXU0vn1CGBtaNTh7r3IdfMpL5NvkQD3c8Uxv8QjFarRTUaohwO/MP5KF05KMBN3JbZDwv7FzP0F++5qmu/Zgc17XJLiGNuS5m3E3R0ODdG9OD6btWklNbSZizBw9HD+HWrXP4o/AIo4O74u/gxTC/HizJWccQ367IxFIcJA4M8h7IxtK/GeE3DKn47H8juVjOhNDxtHeJ5vOML6m2aHg44kEUEgVSsYSZsRNwlCp5M/k7nm4/nuv9uiMTS7g9pDs3BXZiac5evsncxvLcfUyJ6M+d7Xqd4WLYVprGM4eW0sc7ilmd72i2qN21hq/ShU+63sX64uN8cmIdvxbURXlJRGICHNwIVnkQ4uhJsMqTYEcPQlQeBDq6c7Qqn7lpGzlalccg3/a83fE2olz8LqgP7nIVA3xjGOBbV2XKYreRXlPCkao8jlblsTxvP/PT/0YiEhPj4odNsJNZW869kf25P2LgRc9DiIRWUtgxGAw4Ojqi1+txcGheHch/o7UYWZV/iJ9ydlNkqCbCyYdPut11zivsxSIIAka7GaPNjMFmQm81YbSZcJM7EejQtLqKrx3/hgpTDXO6PH7e9V9KepV41zjuDBl30X3XW/XMPPYi3Ty6MClsIiabmakHPiTIwZs3E+9njzqTh/d9x6zOdzA8oAPP7v2djUXp/HHD/QScKlbxwYHtLD5xiB1jp+KqaJmRYWplOcNWLWLdmCm09zizMvxpjFYr84/u5vNje4lx92ZWv2Ekep3/z5depeb6ld+wfswUYv7VvtVu57o1n3FdQBSvdR0GwFtJq9lamsrqQTNwkMopNVYyee87TIu6lZsC6iR9K0yVPH10JveFT6GfV9PqBaTXnmR2+hz8Hfx5IuoxnGR1bhxBEPg66w9+zt/Eo1G3MSqwoQZ/jcXA4qydLMnehZNUwYNRgxkT3AWZWMqagiO8cmwVNwd24qXEW5BeQnfH1UqNxUC+rpJ8fQV5ugrydJXk6SrI11dSZa6rFiZGhB2BHp7hTI8Z2myfdnMRBIESo4YjlXWGvsKsZWrUYCKdfVuk/avesJ/GardxvLqQaBffFotV11uNfJi2lGKDGsMpI260mTDYzGdNFPBWuNHFPZrO7tF0douqr7Tzb4oNaibtfYcX4iYy6CwTp/9mUfZiCgyFvBz3/EUfE8D28h18nf0tr8e/TKgqlGPVmTx1ZB7Px97Ndb5deTtpNeuKj/PLgOmopApGr/8GV7kDP153NzKxhBqziQHLvmRcdCLP9xjUIn1ak53KtE2rSZ30JMpzFNY4zcnqCl7YsY4DZYV08vbHTaHERa7ERa7AWa7ARa7AVa7ERaHARa6koFbDczvXsW/8w/iqGvqsv07by+zjW9l582O4yJVUmLTcvPkTJkf048GowQDMSV/Bnopkvu3xAvJTI+LPM74k35DPG/GvnnPU/m+KDEV8mPYJcrGcp2Jm4K345yKzNHcjX2evYWLoMO4Ou+EMX2yFSctXGVtZnrsfPwcX+nlHszR3L5PC+zGj/Q1XpMvxSqfWYqw3+N4KF7p6hrV2l1qEa8awXwpWFmxlUdZabgnsh6NEgYNEgVKiwFGqwEEir3td/7mcEkMlh6vTOVSVzomaXGyCnTBHPzq7R9PFPZoObhE4SpV8dnIVO9TH+L7nS0iaMMLaVr6DxTnf80XX+U02IOfCLth5K+VdRCIxL8U+h0gk4tP05WwvP8rX3Z9DJpZxx7b5tHPyZm73u0nXlDNm4yKmRPfgmQ51hm5h0n4+OLidrXc8gL+qaZN752LO4V0sP3mc7WMfbMZxCPyamcLR8mJqzCZqzEZqTCZqzCZqT72v/VdSlUIi5djdj51x4ag1G+n7+1weje/Hg+171x3fyS18k7md1YNm4K10ptxYzaS9b/NgxC2MDqqb7C4yFPPK8de50X84twaNbnK/q8xVfJz+KRpLDU9FP06o6h9f6h9Fu5h38hc6ukUys/2ERgcGhfoqPk/fxJ9Fx3g0ZghTIpqnKtrGtU+bYT8LNsHOlL3v0M2jPY9F397s7fVWI0maLA5X1Rn6bF0xYsS0dwkhS1vExLBhjA25rkltFRmKeD7pZV6Ne4lwp3bN7ktjZOtyeD35LR4Iv5e+Xn3QWY3cv28WHd0ieS6uTg/7vt1f82TccO5u14elmYd58cBaFg0YzwD/CIxWK4NXLGRAYDve6z/8ovvz+JY/qDYZ+W5Y87/rc2Gz29FazGjMRhRiyRmj9dO8eWg9fxWksuWmacjEEgw2M6O3fEpf72he6TAKgPknV7Kt/CiLe76I4pSfe0PJ3/yQ9xMvxT1PpFPjgQONYbAZmHNyPlnaLKZHTSPhX9WyUmtyeSfleww2E8/GTqC7R/tG2zDaLCj/4/70Nhqn1bVirlT2qJMpNlYwJujCRkOOUiU9PeN4KHI0X3Z/lmV93mBm7ARCHH1p7xLCjf69m9yWn9IPR4kjmdozs0svlHaqMAZ5D+Dn/OUYbAZUUiWPRd/O32UH2VuRTGePUB6Ovo7ZJ9ZzvLqAceGduCkkjqf2rqbUUItSKuWprv1ZdjKpXjnxYsjSVBLh2vy47fMhEYtxVSgJcXY7q1EHmBTdnTKjlr8K6hKUHCRyHo0Zyq/5B8mordNmvzNkKDqrgT+KdtVvN8R3MPEucSzI/AqjremFSRwkDjwVPYPO7p34OP1Tdqr/abO9Syifd3uKTm5RvHBsAQszf29UrrbNqLdxNtoM+1lYWbCVHh6xBDv6tEh77nJnrvPtwlPtx/NBp2k4NTE1GOqSYiKcwsnUXZggmMlm4EjVVnaW/87m0uXUWOqKFtwedCtWu41VBb8B0NsrgUE+nfk0fQU6q5F7IwfQ1TOMmYeWobWaeKvbjTjLFDyx5zdsdjtjIuKIcvPkgwMXphF0GkEQyNRUEOnW8oa9qYQ4uXN9YDSL0vbVZ02ODOxItIsfn5xYB4CHwoWbA/qyNO9vDLa6qldikZj7w6egs+r4Me/nZu1TKpbyYPj9DPO9ni+zvmZN8Z/1y1RSB16Im8iTMeP4rXA7TxyeQ6mxrdhEG02jzbA3wqHKNI5pMrk9eHBrd6Ued5kbFeYL+2PvUK9mRf5ctpWvYmPpT6wu/BIAJ5kTdwTfxvrSjSRrUgCYFnkrZruFT9J+RoyItzvehsFm5sOUP3GWKZjTewyH1Pl8e3I/ErGYmd0Gsi73JGuyUy/42Mx2GxabvYm6dZcGvdVMrcVEZo0a86nRsVgk5qnY4ewsP8m+U6UEx4Zch8luYVnepvpt3eXuTGl3D1vLt7GtfEez9isWiRkXcgfjgu9gWf6KBvr7IpGIEf69mN/1SfQ2E68fX9TiaettXJu0Gfb/w2q3MT9jFb084+nsfuXEwafVniTKKbLZ2wmCQFL1Dnp5Duf5uG+4K/RZTtTso8SQA8Ag7wF08+jK55kLqDBV4CZ34oW4e9hefpRfCrbipXTmxYSb+a3gEDvLTpLg4c+0uH58lLSF7NpKhoREMCmuC09sXdOgcHRzUEikDAuNYnl666j0VZsM3LPlR1Kry/h+8IQGOujdvcLp7RXJ3LQ6VUN3uTMTQ4fxc94mig3qf9bz6MZI/xv5NmcxabXNF/Ma7ncDnnIPtjdyYQhV+fFy/CSydEWsLmzehaON/yZXvGGvMGlIq8m7bAVtfy3cTrGhgocjR1+W/TWFClMlpaZS4lyaX/mp1JhLuamQRLe6coCxLj3wVYaypWwFUDcqvK/dZJylzszN+ByL3UIX92gmtRvB11l/kK0tYoh/PDf4J/BG0q9oLUYeiu1DuLMHz+//A7sg8GrP6+gfGMb9G1aSrbmwu4rx7TtyuLyItMoLr/xzIZToaxi/aTElhlqWXjeRDh4BZ6zzaMxQkqoL6gXCRgf1x8/Bg88yfm2w3u1BY+jomsjck/MpNzXvOMQiMf28+rJTvbtRmeYwlT9jg69jUfZayoz/DQ3yNi6cK9KwV5lr+b1wJ08dnsedu1/n0UOf8MD+91hduAO9tekTVM2l0lTD9zl/cUfwYAIcGte8aQ1O1JxAKpJe0Ij9WPUOXGVeBDvWZcCJRWIG+9zOcc1uyox14mEOEgemR02j2FDMD7l1tVLHhQwhyjmID1J/wmqvk/c1263MTl2PTCxhVvebOKQu4IeMg0jEYuYOuplgZ1cmr19RL43bHPr4hxDi7MZPaceave2Fkl1bwdi/F2MXBJYNmUSES+PnPN4tkCF+ccxL24hdsCMTS5kWeSt7KpLZW5Fcv55YJGZqxAO4ydyYnT63vnpVU+nv3Zcaaw3HNEmNLp8Qej3uMmc+y1jVrHbb+O9xxRj2GouOtUW7efbIZ4zf9SoLMn/DXe7My/GTmNNlBrEuYSzIXM2du19jbvov5OpavqLPV1l/oJI6MD50SIu3fTGk1KQS6RSBQtK8xCtBEDim2Umia58GyS7xrr3wUgTWj9oBAhz8eSD8XjaXb2Vb+Q4kIjFPxdxJjq6EZfmb8FA4MTN+JCvy9rNPnUWChz8Ptu/N+8c2UaCrxlEm5+vrb8Vqt3PfhpUYrZbGunRWxCIR46ITWZmRjNHaMjrs5yKpspixfy/GU+nI0iH3EOB4bu2ZR6KHkFlbzl+naqN29Yihv1cH5p1cieZfsstKiZIZ0dOpsdTyRebCZknweiu8iXNpz9by7Y0uV0jkPB59OzvVSewsb9z4t9EGXAGGfUPxfl44toCxu15h3smVOEqVPB83keV93+Sl+En09+5IrEsoT7Ufz0+9X+Xu0GHsrzzB/fvf45kj89lefrSBXvaFkqLJYUPpfqZGjMKhmQb0UiIIAik1J4h1aTyW+VwUGjKoMpeS6NYwRV0skjDI5zaOVe9Abfpnsq6bR1du9B/O4pzvydHlEqryZVK74Xyfs45sbTHD/BMZ7BvLa8dWobeamB7fnwBHV17YvxZBEPBxdOLbYXeQUV3BjK1rml0E+47oRLQWE3/mpDX7WJvD7tIc7t68hFg3X74fNAGPJhSMjnD2YWRgRz5P31Rfa/PRqNuwCwKvHP8a07+KPHgpvHgsahrHNcksz/+lWX0b5D2Qo9XHKDepG13exSOGIb5dmZ+x8pLevZ4LrcXA5xmr+DJzNTm6ltHLb6NlaXXDPi/jFyQiMU/H3Mnyvm/yWsK9DPLp3KhxdZGpuCNkMN/2fIG3Eh9ALpbxZvJ3TNz7Fj/krD9rGbPzYRPszDv5C53cIhng3fJytBdDqbGUKkvVBfnXj1XvwEPuR6DDmYkziW798JD7srWsoeG5PehWIp0imXvyM7QWLbcHDybSKYgP037CLth5IeFmtFYTc1I3oJBIea/HTewuy+GLE3Vx2FFuniwcOoaNeRm8s29Ls/rr6+jEkOAIll5Cd8y6glTu3baUAf4RLOw/FidZ0y/iD0dfR7FBw2/5daJSHgoX3u7wALm6Et478UOD0XmUcyRT2k1ibclfjU6Ino2u7l1wlbmy6RxSzVMjRmG0mfk2+8+zrnOp2F+ZygP732NT6SG2lh3hgf3vM/3gJ/xRtAudteXK+7VxcbS6YV/S6xXeTHyAoX7dUEmbJiglFonp6RnH2x0e5NueLzDIpzO/FGzlrt2v88bxRexRJzdrFL+ueC+Z2iKmRd16xeltJNecQCFWEK5qXsapXbBzXLOLRLe+jR6TRCRhkM/tHKnaSqWppMHnj0ROxY6NBVlfIUbE0+3vJFtbzPL8zXgrnXkmbgRLc/dyqDKHTp6BvNjpej5M2sLq3Dp/cy//ED7oP4KFx/fzbcqhM/Z9LsbHdGBPST5ZFzgJezYEQWBZ1hEe3bWS29p1YHav0Q2iX5pCoKM7t4V0Y8HJzRhtda6mMJU/ryXcy+6KZBZm/t5g/X5efRjpP4Jvc74/bxWs00jFUq7zGcTW8m2YTsXK/z/ucmcejLiF3wq383vhzssSWKC3GpmdtowXji0g3rUdX3Wfyfe9XuK9Dg8R4ODF5xm/MnbXq8xKWcLhqpMtVq+4MYw2M9naItSmasy25rn8/itcM5ICRpuZrWVHWFeyjyRNJu4yZ4b6deN63+60c/I/63Y1Fh1T9r7LEN+uPBI15qL70dLMO/kZJruZp2JmNGu7HN0JFma+yPSoT/BzaFzX2SZY+SRtOhFOiYwJeqTBsvTak7xz4j2mtJvEQO/+LM37m8XZf/J5t6cJcfRl+v4l5OrULBswDQeJnLcOb+CHjIN8N/AueviEADD3yG4+PrSDL4eM5vrQpoWOWu12+v78BaMj4pokMPbhsc2szT+BTbBjtduxCnZsp5//9dlpt9C0uL48kTDwgi/g5cZabt78CY/EDOGe8L71n28sOcB7qT+coc5oF+zMOTmfDG0mD4TfS6JrwjkLLQBoLBqePPIsE0MnMMin8cxnQRD4NvtPfsrbSG/PeJ6MGYer/MyiHy3B0eoMPkz9CZ3VyGPRtzcqXKe1GNhcdoh1JftIq83DT+nBDX7ducGvB77Klkk8q7XoWV24g1WF29BYdPWfK8VyXGQqXGUqnGWOuMqccJE54ipT4SZzpqdnHD7KppeVuxa4Zgz7vykyqNlQsp8NJfspNVUR7RzMDX49GOzTGRdZw4IAc9N/YVv5ERb1eKFZ2aAXgtFmpNhQQoW5EpXUEVeZCy4yF1QSVaOGxi7YmX74CUb6j+BG/+bpsfxeuJBMbRKPR396TiO2v2IDvxct5ImYebjLG2bZ/pT3M1vLt/N2whu4yVx5/PAcRMDszo+hNmm5bdtcxgR35am4Edjsdh7dtZK95bksPxVhIggCz+1Yx6+ZKSwbeScdvc9+gf03Hx3czo+pR9k9/mHkkrOLpCVVFjN6wzdMjOyKv6MrUrEYiUiMVCRCKpYgFYmRnP5MLMZbqaK7d0iT+nAuPk1dz6q8g/wx+IkGBS1+yFnP4py/eC3hXnp7JdR/brAZmJ/xBUma43jI3env1Y/+3v3wVpw98mpB5kLy9QW8mfDaOc/f0aoM3kv9Absg8GzsXXRxj77o4zuNyWbmm+w1rCzYRi/POJ6IHteoKNn/k60tZl3JPv4uPYDGoiPRNZwu7tF0dIskxiUEWTOF7CpMGlYWbD0l5SDilsB+DPLphMFqQmPRUWPVobHoqLXUPddY9GgsWmotetRmDUabme4e7RkZ0IeeHrFNEt67lAiCgF2wY0NAODXokIjE9aqhLcE1adhPYxfsHKvOZH3JPraXH8Mm2OjjlcjIgD54K1xZV7KfZXl/80TMuPrqOJeC/ZUH+Cnv57NmjkpEElykLrjKXHCTu+Emc8NN7orFbmVN8VreiH+lgQLg+bALNt478QA9PYdzne/Yc65rtVv4JG0aIY7tuSNkRoPRpNlu5uXjr+Gt8Oap6Bnk6kt45MBH3BM2nPGhQ1mVd5A3kn6rr/ZisFq4e/MSKkx6frvhXlzlDljsNu5bv5LkilLWjp50Tr2W0+TVVtN/2ZcsHnYHA4PO7oJ6aMdySg21rBw65bK60DRmPSM3f8yk8H48EDWo/nNBEPg47We2lB3mk87TiXQOarBdsaGEbert7CjfRa21lg6uCYwOHNWosNuJmlRmpX7A6/GvEHaec19j0fFJ2jJ2qpN4KGIUtwYPvOhjrDLX8vSR+ahNGh6JHMMNft2b/R2frum7vfwoR6szUJs1KMQyEl0j6OkZR0/POPwdGq+bYBPsHK3OYEPJfraWHUElVXJb0EBuDuyLStp0e2GxW9mlPs6aol0crj6Jl9yVYf49GObXA/9LFNKssxr4u/Qgfxbvocigxi4I2AQ7duqM+NkkvwMcvIh0CiTKOZhopyAinYPOGIg2lWvasP8bvdXItvKjrC3ezYmaXAA85a6MDOjFhNAzta9bikpzFS8kvUyCazy9PXsSoAzAU+GJ3qqnxlpDjaUGjeX0s4Zqi4ZqczVVlio0lhq6unfh/nbNM1y5ulS+zHyBx6I/wVd5/gtCWs1BluTMopvnUG4JeLDBvk67ZO5vN4V+3n35Oe9vvs3+k0+7PE6UUxCP7v+ebG05P/efhrNMidqo46Z1C+npE8rsXqMRiUTUmk2M/PU7QpzdWDz8DsTnORZBEAhf9CGzB45kVETcWde7b9tSnGQKPu19+V1o7yWvYa86k5UDH2vwudVu4/ljX1BirGR+1ycb/WNa7VaOVB9jTfFasnTZdHHvzG2BowlyrLsQ2AQbH6XNptBQxFsJr+EsO//FUBAElub9zaLstbyWcC99/nXH0FxMNjNPH/kMjUXLh52mtYgbQxAEigxqjlZncKAqjYOVqehtJsIc/ejpGUcvz3hiXUIpMJSzsfQAf5cepNxUTbRzMMP9enKDX/d6Rc0LpVBfzp/Fe9hQup9Kcy2d3KIY7t+Tfl6JF912XfRaDmuKdrOt/AgAA7w7keDaDrFIjFgkQowYsUiMRCSq+4xTn4vEmGxmsnXFZGgLSK8toNJcA4Cf0oMopyCinIOJcg4iyimoSS63/4xh/zcZtYXUWHV0dItEcokMOtSd7Nkn51JkKOathNeaHYd+oawvXsKx6h081f7zJl8QkjV7WJr7IT08h3FTwP0NtluS+yO71Lt5J/EtnGXOzDz6OZWmGj7r9hRai4mx2+fTxSOMD7qMQyQSsbU4k3u3LeXjnqMYFVZnYA6XFXHbHz/wQEJ3pnfqjZP87N+FxW4jctFHLBgymuFhZ3ctfJy0hbX5J9h448NN+2JakP3qLB7Yu4jfBj5OqFPDkV+VuZZpBz8mxNGXtzs8eNbfmCAIHKk+yi8FqygwFNLTowdjgkbxd+lmNpdt4YXYmc2SaT59x7C1/Aifdn6Mdk5nZtGeD7tg592UJeyvPMGcLjMIUbVMRZ//x2K3klSdyZ6KFPZU1CmpKsVyjHYz3go3hvh2ZahvN0JVF1aa7lxY7Tb2VZ7gr+K97K1IwVGqYLBPF/p6JRLs6IOXwrXJA70ai46NJQdYW7ybXH0p4aoAbgzozRCfrhfl2q0waeqN/MnaAk7W5qM2awhx9OXrHs+dd/v/pGG/XOxW7+GLrIU81/6ZC4pDv1DmpM8gXJXATYH3N2u7pOpdLMv7mF5eI7jR/9564260GXkx6RXCVGFMj3qEMmMVUw98wCCfzjwefQd71Zk8tPc7no4bwYR2dXLErx9ax8qcJNYMu58glRsAi5IP8u7+rcjEYu6ISmRSXGfaNSLVqzWbiP/+U7694XYGB5+9yvy6glQe2fkLR259GudmhC22BFa7jSEb32NKxAAmR/Q7Y3lqTS5PHp7LHcHXMSX8xnO2ZRfs7K88wMrCXyk1liEg8FDEg/T2bL570GK3MvPo55QZq5jb9Qnc5c0rgvJt9lqW5v3NOx2mtqi//lwIgkC+voxDVemEqHwv+YDr31SYNGwsPcBfxXspMNTJQMjFMgIcvAh08CLIwZtAR28CHbwJcvCu/z6PaTJZW7Sb7eXHkIjEDPbtwo3+vYhxDrlkbsEqcy1V5lrCm3DBbjPsl4gaSw3PJ71Md49uTA6beNn2W2Uu48PUh5jS7hUinTs1e/tj1TtYljebvl43Mdx/Uv2PNElznA/TPuHRyIfp7tGNrWWHeStlMa8n3EcfrwQWntzCgpOb+br3fXR0D8FotTB6wze4KRz4YdDdSE4Vna4yGvg5/RjfnzhMgbaGgUHtmBLXlYFB7epdNBUGPV1+nMdPI8bRJ+DsrqQinYb+f8xj6XUTW2RStLm8fHQluVo1i/s2XvVpbdFuPklfxusJ99LHK/G87dkEG7sr9mIXbAzw7n/B/ao2a5l+6BM85a683+kR5OeZrFSbqtlWdpTNZYdJrc3lieix3BjQ9HoB1wKCIFBt0VKoL6fAUE6hobz+dZFBjcleF1ZZVzFNSYVZQ7RzMDf692KwTxccmxiqfbm4+DprbTTK97k/IhfLGRfcshWBzkdqzX7kYiVhqvjzr9wIHdz6YRdsrMifg0ysYKjfnQAkuibQ36sv3+f+QKxLewb6dGZvxQk+TltKe+dnuS9yAEeq8nj20M8s7f8I7nIVH/caxa0bF/Fl6m4ejqsLDXRXOvBQh548kNCdjXmZfJtykMnrV9DOxZ17Yjtze3QiJludpMD54sz9HV1wlztwvKqkVQz7jQEdeHjfdyRVF5DoFtTI8t6k1ubx3okfmNf1yfNq+0tEkiYXxj4XbnIn3ki4n8cPf8qn6ct5Omb8GaPIarOW7eVH2VJ2mCRNFg4SOX29EpnSbgRdPGIuug9XGyKRCHe5M+5yZxLcGt4l2gU7apOGQoOaQkM5VeYaennGE+V8aQteXwxtI/ZLwIHKQ8zNmM+T0TPo6Hb+kVpLsijrdRQSB+4Kffai2tmj/pM/ir5mevTH+CrrjKbOquP5pJdJcInnwYj70FmNPHTgA4IcfHi7wwNoLAbu3P454c7ezOs+EbFIzMLUPXx4bDPLh05qVDkRIK2ynO9OHGJlRgpiEQwKCmdNdhprRk0iwevcPt5JW37ES6nio16jLup4LwRBELh75wI8FU7M6X53o+uYbRaeODIXk83Mp10eb1ZEx8WyR53MK8e/5oGIm7kjeDBai4Gd6iS2lB3mUFU6MrGEXp7xDPLpTA+P2BYNt2ujdWn1zNNrDZ1Vx+LcJfT17HPZjbrRpidbl0x75+4X3VYPz2H4KkNYX7yk/jOVVMWksLvZWbGLo9VJqKRKno+dyKGqdH7J34q7XMX7XcaxT53NVxlbAbgvpifdvIN5cs9v6K3mRvcV4+HNO32HsXf8wzzRuR9J6rpSdK6K89/eJnr4k1TZOnolIpGIB6MGsa0sjVRNUaPryCUyXo2fQo1FzyMHPib1VETW5aCXVzwPhN/Mwszfee7oF4zd9TKz05chE0uZGTuB5X3q9Jj6eXdoM+rXGG2GvYWpK48mcFfouMu+7wztUeyCjRiXLhfdllgkZpj/3aTWHiBHl1L/eVf3LvTw6M63OYsx2AzEuYYxJfxGvsr6g+PVWXRwD+bJ2GF8nr6ZPepMxCIRH/S8hQqjnneP/H3OfboqlDyQ2J0tt9/PtjseINjZ9bz9TPTwJ6u2glpL4+n3l5oBPjHEuPjx5cktZ13HR+nOZ92ews/BgxmH5/BT7sbLVgnp9uBBjAnqjwgRj0XfwbI+b/BG4n1c59sFB+mVI3bXRsvSZthbkGPVSexQ7+Se0Ltxkl6a9O5zkVpzgGDHaFTS8xvEphDl1Jlwp0T+Kl7cQI9kYuhdmO1mluXXyf6ODR5MD8/2vJWymCpzLXeG9WKofxzPH15OqbGGAEcX3uo2gh8zD7Gx8PzVhSRiMaEuTYudTvQIQACSq1pexrkpiEQiHowcxKbSE5ysOXsfvBSuvNthKveF38TinL+YefRzyo3Vl6V/D0eO4d2OUxnu3xNn2fmVLNu4+mkz7C2EwWZgUc5iurt3pZtH18u+f7tgI63mIO1dLt4NcxqRSMQwv7vJ16eTUrO3/nMXmQsTQu5kU9kWUmvSEIvEPNP+LmRiCe+mfI8dgVcTR+MsUzLz0M9Y7DZGhsRxe7sOTN+1kp8ymycMdi78HZzxUqo4Vtm4K+RC0FlNGM7iNmqMwX6xRDr71LufzoZYJOaO4MHM6fI4FSYNUw980Kar3sYloc2wtxDrSzZisBmYGDbhsu/bLthZU/QNBpuWOJeWlUYIcoyig1t/fi9cSI3lH0mE3p496eTWkQVZC9FYNLjIVLwUN4njmix+zF2Pk0zJR13Gk6opZn7aRgDe6TaSB9r34qUDf/Jt+v4W6Z9IJCLWzZd0TcuU1DuhKWLY3x8weMMsnj74E38VHUNnPb+bx9/BjX0V2U1SWoxyDuazbk/R2yuBN5IXka8va4mut9FGPW2G/SIpMhTxSfocVhb+yhCfwbjKWsYNcj7sgp08XRprir7hg9QH2VexnvEhT+KtDGzxfd0S+CBysZIfc9/DYq8byYpEIh4IvxeJSMrck59hsVuIcQnhwYhRfJ+zniNVJ4ly8WNm/Ei+zdrBjrJ0JGIxTyYO4pkOg3nz8HpW57ZM8WpPhSPVpovXAs+qLeORfd8R7xbE03EjqLWaePHILwzeMIsZB35gTcERai1nFrf4NHUDu8szmNX5jiYnpzhIFDwZPZZAB29+yFl/0X1vo41/c82EO6bWpPF55peIEOHv4Ie/0h9/Bz8CTj27y9xbNCOsxlLDqsLf2FK2jQCHAMYH30Gi24XrczQFQRAoMGRwvHonSZpdaCxqPOX+JLr1paPbAHyUZ8ZStxTlxgI+z3iOONee3Bb0aP13WaAv4PWUt7nedwhjg29HEATeSP6WlJocvuj2NG4yJ148soLd6gyW9p+Gr9IFQRB458hGFp88wJf9xzLQ/8xCIM3hzUPrOVpZxIqhky+4jUJ9FVN2f4Wf0pUFPSfjIK3TDqky69hSksrGkmT2qjMBEb29IxjqF88g3/b8WZTErOQ/eKvjbdwU1KnZ+91UepBZJ35gYfeZhF6i9P02/ntcE4Z9W/l2vs35no6uiUQ6R1JsKKbYWEKRoRi9ra6wskKswF/ph7+DP/5KP0Icg4lxjsZR2rzJJLPdzLqSDfxRtBaFRMFtQWPo79X3komICYJAoSGT45pdJFXvpNpSjofcj0TXPiS69cVPGXbZlA1Taw6wJOddRvhPpq/3zfWfbyrbwuKcJbwY+xxRzpFoLQYePvghgQ7evNPhQQw2C3ft+BxPhRNf9pyCVCzBLgg8s3c16wrSWDJ4Ap08L/xOY27ydlbnJrPhxocuaPtyYy337v4KB6mcr3rdi8tZND5qLAY2l5xgY0kyu8szAQGbIPBI9HUNVB6bg02w8+D+9wlXBfBi/D0X1EYbbfw/V7Vhtwt2luWv4M+SddzsP5Jbg0Y3MLCCIFBrraXolKEvNhRTYiyhyFhMuUmNGDHtVGHEu8YR5xJLpFMEMnHj8bx2wc7uir2sKFiJ1qrlRr/hjPAfhlJy6VKJd6vXskv9O5XmUtzlviS69iHBtQ8BDuGtVulpa9lKNpT8yOR2LxPpXFdGUBAEPkqfTamxrF7s7ERNLk8cnsOksBHcGTqUtJpiJu78krvCejEjdhhQJ/Y1dcdyjlYU8fOQe4h0uTAZ1cUn9zM3eQf7Rz/R7G01Zj337fkas93Got7346loWjRTrcXIttJUaq0mxoX2uKjzsaXsMO+kfM+Cbs+csyhMG200lavWsBtsBr7IXMhxTTL3tptE32amYtdYajhRk0pyTQrJmhOozWrkYjkxztHEucQS7xJLsGMwYpGY1Jo0fsr7mVx9Hv29+jImaDQe8ktbkWV/xQZ+LfycXp4j6Ow+iECHyCuibJ8gCPyc9zEZ2qM8HPkenoo6Q1RpruLFpFfo7dmTe8LqsjBX5G9hYebvfNRpGglu4fyaf4jXjq3iydjh9dWH9FYz92z5kWJ9DcuHTibA8fyFHP6f1bnJPLX3N9LueP68ksD/Rmc1MXXvt6iNtSzqcz/+Dm7N3ndLYBfsTN3/AcEqX16Jn9wqfWjj2uKqNOxqk5pP0ueisWh4LGoa0c5NK7t2LsqM5XVGviaFEzWpaK1anKRO+Cp8yNRlEe8Sx/iQsYQ4Xnp9iIzao3yX/SYDfW6r12q5kjDbTXyZ8QI2wcpDkbNQSOrO32k1y2diniTBNR5BEHjl+Fdk1BbyRbencZU7sThrJx+f+IuXEm/h9pC60Mxqk4HxmxYjAEuvm4i7onnusW3FmUzZtpQjY57CWd60OyiTzcL0/Us4WVvKot73Eebk3ax9tjTbyo7wZsp3LOj2TJPU+9po41xcdYY9ozaDT0/Ox1nmxBPRj5+zvNiFYhfs5OvzSa45QZ4+j96evengmnBZRsxlxnwWZDxPtEtXxgbPuCJG6Y1RbS7ns5PPEKJqz12hzyIWiREEgfkZn5OhzeLtxDdQSR2pseh46MCHhKsCeCPxPsQiMZ+nb+LLk1t4q9NtjAysc+cU62sY+/d3+Cid+H7wBBylTS98cKyiiDEbF7Fl5DSCndzOu77FbuOZQ0s5UJHDV73upb1r67s/7IKdhw98hL+DJ68l3Nva3WkRKs1VLMtfzrHqJKKco0hwiSfeNQ5/pd8V+7u+Vriqwh13qfcwK/UD2qlCeTnuhUti1KEukSRUFcqN/sN5KOJBOrolXpYfotZSzeLst/FVhnBr0LQr+sfvJvfmrrBnSas5yKbSZUBdCOSksInYsbEk90cAXGQqXoibyP7KVH7Jr0vgeShqMHe3680rR1eyqaROrsDf0YXvBt5Fnq6aR3b+gtlma3pfFHUDgyqz/rzr2gU7rx1bxR51JnO7331FGHWo+81NDBvGTnUSGbUFrd2di8Jst/B70RqeO/YiJ2szGe4/DLFIzC+Fq3g+6SWePPosX2d/y96K/Wgt2tbu7hWPxqLhUNURluf/Up/tfT6uCtleu2BnVeFvrC76gxt8r+fOkLGXLAqltbDYTSzJfReRSMSEsJnIxBdXqutyEKaK4+bA+/mtcAFBjpG0d+mGs8yZKWGTmH1yLl3dO9PNoysJruFMaTeCr7P/IN61HXGuYTwZOxyd1czMw8uY0+1uentHEu7iydf9xzFhyxKe3ruaZzoMJkjlet4LnJu8zrBrzGfGmP8bQRCYlbyGdUXHmdP9bjp7NL2O7OWgr1cikU6BfJ21hnc6PHhFX9gbQxAEDlUf5qe8ZWgsGm7yv5ER/sOQn/otW+1WsnTZJGtSOF6TzPbyHQCEqUJJcIknwTWeKOdIJKLLU2xaEARy9LkcrjrCoarD6G16wlRhtFOFEaYKpZ1jGE6yyysNYrFbyNXnkanNqn+ozWoA/JX+JLo2TY671V0xHyXNRuWgQiaWIRfLkIlkyMSnHiIpMrGMJE0yxzRJTAydwGCfiy/UeyXyS/48Umr28lDEu3hfwnj0S8GyvNlkao/xWPQn9To1X2ct4nD1Ed5MeA13uTt2wc5LSQvJqC1kTpcZ+Dl4YBPsvHTkFzaXnGBhrykkutfNX+woyeLhnSvQWy34O7ow0C+CG0Ni6eUdWl+w49+YbTZiV8xidu/R3Bxy9h/+D9m7+SjlT97vMo6h/hemV3+pOVadydNH5jMzdgJDfC+/NMWFYrFbmJfxOUeqj9LTowfjgu/AU3Fmdax/o7PqOVFzguOaZJI0yajNalxlrgzw7sdg70Hn3f5C0Vq1bCj9m23l26k0V+Euc6eLe2dcZS7k6HPJ0eVQaa4CwEvuRZgqlDBVKCGOIYSpQlo0CdEu2MnT53O0+hhHq4+Rq8/DKlhRSVREOoUT7hROhFM44ap2qKRNL2zd+ob92CeIFGIsdkvdQ7DUvzafeu8ideaesLsva3m5y4nRpuOdlCncEvgg3TyGtnZ3mo3BqmXeySfxUYYwMewFxCIxBpuB15LfRCVR8Xzss8jEMnRWI08cnoMIEbM7P4aDVIHFbmPGgR9Iqynmh74P4etQ96cxWi0crSxib1ku6wvTOFFdhqdCxYjg9owMjqObd3B9BMz8lB3MT9nJn8MfJNTp7NFKzx1ehsFq5tOzaKdfCZjtVm7b8SIPRtzCzYF9W7s7TUIQBL7OXsT+ygPMiH7sgv6ngiBQYixlp3oXW8u3o7Vq6eLeiaG+Q2jvHNMidy8ai4a/StazqXQzYpGEwT4D6e7RjTDH0DPa11g05OhyydJlk6vLI1efR6W5TlLDTeZGuFM7IlXhRDhF0E4V1qx6xuWmcpI1KSTXnCCl5gRaqxYXqQud3TsS4xxNhFMEvgqfizrmVjfs12KhjeZytGo7K/I/5fm4RThKm1ej8kohV5fKV5kvcYP/3fT3Hg3UyS28nvw2PT27MyWsrsxesaGC6Yc+IcE1nFfiJyMWiamxGLhn55c4SuV80/t+lI1og2fVVLAmP4U1eSc4WVOOj9KJEcGxdPEK4pm9q5mRMJCpsecu53ZakOzjbnddiq+gRThUmcbMY1/wfc+X8XO4NCPWluav4nUszV/O41GP0tm900W3Z7FbOFB5kI1lm8jQZhLgEMBQn8H08eqNg6T5tqLCVMGa4r/YVr4dB4kDw/2u5zrfwc1uq9ZSS64+r97gZ2gz0Vg0iBAR7BhEhKpudB3hFI6f0q/eXay1autCq08Z8zJTWYPQ6gTXeIIcAlvUvdxm2K8Afsr9AINNx73hr7V2VwCotZRwtPJ7dFY13b0exEPRtJT/bWUr2VDyEw9Gvk2wY10h5ENVh/n05DwmhU3kOp9BABytzmDm0c8ZHzKUye1GAJCrq+DuHV/Q1yeKdzudW3MlXVPOmrwU1uSnkF1bSYK7H78MnYK0ETfNv3n20M/YBDsfdb3yQkhP827K95zUFvBNj+dbuytN4mj1MT5Jn8Mdwbcx0n9Ei7efo8vl79JN7K7YW186cIjvdQQ41E162wU7BpsBrVWL1qo79ayl9tRzmbGcA1UHcZW5cKPfCAZ492vW6PpcCIJApbmSDG0WWbosMrRZ5OpysAhWHCUOtFO1Q2/Tk6OrK67SThVGvEsc8a5x50yGbAnaDHsrY7GbeDt5MiMCJtHTc3ir9kVrKeVI5feka9bgKPVCKXGlwpRBovt4unhORio+d4y4XbCzOPst1KYipkV/hIOkzie4quA3fi9ew3Ptn6nPOfijaBefpi/npbh7GOjTGYDd5RlM27eYaTFDuC/y/HMpgiCQrinHS6nCU3l+/+Mzh5YiCAIfXqGGfXv5Md5IXsRr8ffS1/vyVt+6EAoNRbyZ8g5d3DrzQPi9l3SyV2vRsk29g01lmyk3qfFR+GCwGdBZddhpWLREIpLgJHXCWeqEi8yZXp696OvZG+l5inq3BFa7lTx9Ppm6LLK0WSgkShJc4oh1ad8sH/nFclVExVzLnKw9ilUwE+vSo9X6oLOUcaTye9I0f+Ao9aSPzxNEuY5AhJhUzW/sVy8gW7uJPj5PEaw6uyywWCTm9pDHmJv+JKsK5nNnyDOIRCJGBd5Mrj6PeRmf8Vr8y3jIPbgpoA/Z2mI+SP2JAAcvopyD6e0dyVNxI/gw5U8inH0Y5Bt7zn6LRCJi3M5dIPrf1A1hrsxIkwqThtlpyxju1/OqMOpai5bZ6XMJdAhgcrt7LnkEj5PMiRv9hzPc7waOVSeRrcvBSeqEk1R16tkJJ1nde6VY2WoRRVKxlHCndoQ7tQPfIa3SB7jK4tivRVJq9hLsGI2L7PL7U3VWNbvKPuHnnPHk6XbR2+dx7gj7kfZutyARyRCLJMS53crtoUvwVESzrvBpNhW/ht5acdY2naRujA15ghTNXvZVrgPqDP7UiPtxlDgy5+RnmE9J/z4cOZpYlzBePf4NlaYaAO4K68Xo4C68cHgFfxcnt/ARC1yJEYSCIPBR2s84ShU8HDm6tbtzXipMFXyc/ilWwcr0yGnIL6FL4f8Ri8R0cu/ImKBRXO83hN5evUh0S6CdUxjeCi8cJA5XXZjopaDNsLciNsFKas1+4lxbtjjG+dBb1ewu+5Rl2ePIqd1GL+9HGRv2E7Fuo5E0Ej+vknkzNOAtrg+YRZnhOCty7uZE9W8IZ6nbGeGUyCCf21lbtIgiQzYADhIHZkRNp9RYwjfZ3yIIAlKxhJfjJyETSXk9eRFmuxWRSMQLCTcxLCCRpw4t5bWjq9A3odBFUxAA0RU4Yv+jaBcHK1OZGTsBR+mlE5VrCfZXHuCl46+htxl4OuYJ3OSXp/5AG82jRQx7r169GDRoEIMGDeKll15qiSb/E2Rrk09VPep1WfZnsRvYWz6fn7PHkV27mR5eDzO23VLi3G5t1KD/P6FOfbktbDExrjexq+xjfs+fRqUpq9F1B/uOJcgxip9zP8JkqyuC4efgxyMRD7GnYh9ri/8E6jJT30i8jxxdMZ+mL0cQBGRiKa92GM3HXe9kS2kq47Z/RlJV/kUffytNJ52TAn0ZCzJ/Y2zIEBJcw1u7O2fFZDPxTfZ3zMv4nB4e3Xk9/mUCHdo0ba5UWsSwDx8+nC1btrBlyxbeeuutlmjyP0FyzR78lGF4Kvwu+b5KDMdYlTuFNM0fdPeayth2PxPvfjtScfMiBGRiR3p6T2NUyELsgpVVufeyX70Am2BpsJ5EJGFs8Az0tlp+L1pY/3miWwLjQ8ayvGAlh6uOABCq8uOFuIlsKNnPLwX/1A29zi+OZQOmEejozuTdX7Hg5Gas9qZLDTRGS47Xayw6MmoLsZ/lzuV8WO02Zp34gWBHH+4JG9aCPWtZ8vT5vJr8JvsrD/Bo5MNMaXdPi0WWtHFpaJHJ06SkJN5//320Wi133nknsbFnTnpZLBasVmv9e4Ph4kuZXc3YBTspmr2XPBLGajdxQP0lx6uXE+TYk5FBc1HJLl7J0EsZzS0hX3CiehX71F9gF6z09J7WYB1XuRe3BU/n+5x3CFcl0sVjMADDfK+nQF/AF5lf8nLciwQ5BtLTM577wkeyMHM1oY6+dPes+w35KF34rMc9/JizhzmpG9hVnsHbnW4jyLH5cxICXLT/1Wgzs6n0ENvKj3Ck+iQ2wY6bzIkennH08oyjq3tMk9wpgiCwJHcdWdoiPu/2FLJLGLFxsOoQ5SY1Eapwgh2DmlxDwCbY+Lt0Ez/nryDcqR3PxDyBp8LzkvWzjZajRcIdDxw4QLdu3aiqqqJv374cOnQIpbLhj+e1117j9ddfP2PbKznc0SZYKdRn4ixzx03m3WKTMla7hd+LFnKw8m8ei56Nj/LSSQHvKpvNSc1aevk8TrTLjZdkYilN8wfbS9+jr89TxLqNPmP5n0XfsqfiT+4KnUmMSxegLgllVuqHVJureCnuedzl7giCwPupP7JLncRHnR4l0rmhtMLJmhKeP7KcMmMt73cZRy+vppfUs9htjNs+n84eobycOOqCj/WN44vYU5FCd4/2DPDpRLCjDwcqU9lbkcKJmlykIjEd3aLo5RVPb894fJQNM2FNNjObyw6zunAHJ7UFTIscw+igARfcn/ORrEnh/bSPkIvl9ZPWPgofgh2DCHYIqnt2DMZb4VWfIFNprmJr+Ta2lm2n2lLNqMCbuSXgpsum4dLGxdPicey9e/dm4cKFJCQ0rP/Z2Ijd09PzijTsJYZcDlVt4kj1NnRWDQAKsQO+ypBTj1D8lKH4KkPOmylqE2xordXUWiqpsVRRa60kqXonBfoMxobMuKQTp1WmHFbmTqavz5O0d7vlku0H4FDFIg5VfENv7xnEu9/WYJldsLGyYD7HqndwV+iztHfpBtRl8r19YhYSkZQXYmeikjpitlt56diX5OhKmNXxoTO0yQ02M68dXcXGkhSeiRvBuNCeZ1ysrHYbWdpyUjRFnDj1SKspxiYI/Nz/ESKcmx4i+W/2VqTwUtJC3kl8sP6O4t9UmWvZV3GCPRXJHKhMxWg3E64KoLdXAp3cIjlYlcbaoj3obAYGeHdiVGA/4l3bXVBfmoIgCLx1YhYKsZxnYp6kzFROvr6AfEM+BfoC8vQFlJnKgLrSkUEOgThKHUnWpKCSOtLfux+DvAfiq7yw76uN1uOiDXtqaip79uxh8uTJ2Gw2IiMjOXToEO7u564wdKUlKOmttRyt3s6hqs0UGTJxl/nQ2X0QCW59MNh0lBpzKTHmUmrIo9SYi9FeJxHrLHU/ZehDkImV1ForqbVUUWOppNZahc6qQeCfr1gpUeEp92N00MMEOFzaybJ1hc+gtZQxJvQbxJdhtHWk8nsOqL+kl/d0EtzHNlhmF2ysKvicY9U7uC/8dUJUMUBd0ZQ3U97FV+nD0zFPIj+lKfNy0ldkagt4KX4y3T0aao8IgsBXGVuZn/43t4V0Y1xoT05oiuoNeXpNCUa7BblYSoyLH7GuAcS5BtDFI4wQ1YW5Eow2Mw/sf48o5+AmVTky2ywcrc5gd0UyeyqSKTdV4yF35qaAPtzo3xtPxaWPJkmqPs6H6Z/wcuzzRDpHNrqO0WakwFBYZ/D1BVRbqunu3pVuHl0vaWZkG5eWizbsRUVFPProo3Tt2pX8/Hz69u3LxIkTz7vdlWDYbYKV9NrDHK7cTGrtAcRISHDrQxf3wYSp4s6q3SAIAjWWCkqMeZQZ8+oMvjEPq2DGWeaBi9QDZ5k7zlJ3XGQeOMs8cJa64yxzR97MycoLpUC3j78Kn2JE0CcEOna7LPsEOFb5I/vUn9PD6xE6eDTM8LQJNn7ImUW+Pp2pke/ipagbjefrC3jnxCxiXWJ5NPJhxCIxZruVj1OXsrnsMI9F38bIgDNLH24qSeHFI79gsJmRi6VEu/gRd8qIx7oGEO7kg0zcMhe0RVlrWVW4jW96PIeXwq1Z2wqCQJFBjY/S/ZL60v9/n2+kvI2T1ImnYmZcln22ceXwn5QUqDAVs7fir3pXSztVPF3cBxPv2ru+zNvVzOloFWdZADcEzrrs+0+q+pm95fPo7jWVjh4NlRRNNgNfZb2C0abjoch362V+U2vS+DDtY/p69WVy2EREIhGCIPBdzl/8kLueccHXcW/4yDMutqUGDdUWfYsa8f8nT1fK1AMfcH/4TdwWPOiS7KOlOVJ9lE/S5/Bq3Et1WZBt/Kf4T0kKVJpK2Fy2giNVW3CRedLTYxid3QfhcRnCDS8naZo/qDbnMTSgdUJPE93HIUbC7vJPsQs2OntOql+mkDhwT9gLLMh4nu9z3uHe8DeQixW0d4nh4cipzD35GW4yV8YEjUIkEjG53Qj8lZ58kv4zJcZKnml/JwrJPzH3vg6u9VK/lwJBEJh7cgUhjr6MDux/yfbTkgiCwKqC3+jk1rHNqP9H+U9knlaby1lV8DmfpE0nR5fMrcHTeLL9ZwzxG3/NGXWzTcvBiq+Jc7sVV3lIq/Uj3v12+vg8ycGKrzio/qZBcpCzzJ1J7V5CbSpmWd4n2IW62PSu7l2YFDaRX4tWs6lsS/36w/x78G6HhzhQmcqzRz+n2nz5yqn9XXqQI9UZPB59B5JLdEfQ0hyuPkqOPpdbAy88+qeNq5tWN+yn/9SXAo2lgtWFX/Jx2jQyao8wKmgqM2Lm0tl98DUbunW4cjGCYKOz5+TW7gpxbmPo5/MMhysXcbDiqwbG3VsZxN1hz3Gy9jBrixbVLxvsM5AxgaNYnLOEDaV/16/f2T2KT7s8ToVJw+OHPqVAX3bJ+19r0bMg8zdG+vcmzjXsku+vJagrI/krXd27EKq6skr/tXH5aHVXzBvH78bJ0QkHiRNKiQoHiepfr+ueVVIXPOS+uMt9cZN7IRGdu9u1liq2la9kX8V6VFIXbgq4jy7u1yG9xmf5a8xFJFevoIfXIyglLq3dHQDau92CSCRhe+l72AUb3b2m1ocnhqniuD34MZbmfYSb3Id+3nUhmaMCbkaEiCW5P1JuLGf8qRq3oSo/5nSZwSvHv+axQ5/yesK9JLo1PZa9uSzKXgvAveEjL9k+WppDVYfJ0+fzQPh9rd2VNlqRVjfstwc/hiC3YLTpMNh0GGxajDYdGouaEmMORpserbUak70uU1WEGDeZF+4KXzzkvvUG313ui6PEiX0V69hb8RdKiYrh/pPo5jH0qigM3RLsU3+Gs9SfuEaShFqTGNeRiEUStpW8C0AP74fqlyW69UVjUfNn8be4yrxIdOtTL/Xro/Dmq+xFqM0VTA2/H4VEgYfChQ87TWPWiSXMPPo5T7e/k+suQW3Q1Jpc/ijaxdPtx+Miu3w62hfD6aLv3T26EeJ46ZLeLgU2wcbeij8x2HQ4Sd1wkrriLHXHSeqK02WMJrtWaHXDnuDW+7xRMYIgYLBpqTSXUGkupcpcSuWpR2btMaotaoRTYvsqqSvX+02gh+cNyP5DP4ZC/QFytFu5IWAW4vPc0bQGUS510glbS95GIXGmo8eE+mV9vW6hylzGivxPcZA4EuncCYDeXr1wl7sz5+Q8ZqV+wBPRj+Mic0YpkfNy/GQWZq7m3RNLSNbkcE/YMFzlLVNR3ibYmZO+ggTXcK737d4ibV4ODlUdptBQxMMRU1u7K83CJtj4PvttsnUpuMm90VqrMdp0DdaRi5U4Sd1wlrrheOoOPs61JyGOMZclR+M0VruFXH0qBpsWi92I2W7CbDNiPv3abqx/WAQzjhLn+sRGH2UwbjLvFi2BdzauiXBHm2Cl2qymxlJBoGME8vNU+rnWqDBlsDZ/Bv6OnRji/+YVrUd9vGoZe8rnkuA2lp7e0xCd+pHbBRsr8ueQVL2LW4On0dl9UP02xYYSPkz7BKlYwtMxT+Kt8Kpf9lfxXr7O+gOL3cqdoUMZEzgAeSM1U5vD74U7mXdyJQu6P02Yyv+i2rqcrC76g+3lO/mg47ut3ZVmsUv9B38VL+aBiLcJdqyrsGWxm9FZNXVZ29ZqtJZqtNa6h85aQ7ExB7WpECepG7EuPYh37UW4U8J53bQXgiAI5OvTOVy1hSTNTgy2usl7qUiGTKxALlaeeiiQix1OPSuQihVordWUGfPRWNRA3QXKRxH8ryz2YHyUIThL3THbjaeOue5x+vj//ZmLzIOxITPO2+drwrD/V7HaTRyu/I5jlT/i65DAsMD3kYkdW7tb5yWzZiNbS94m1Kk/A/1erFeYtAt21pcsYXv5r9zgN4EB3rfWX6SqzFV8lDabWmstT8U80cDVoLcaWZa/iRX5W3CVOXFv+EgG+3Ru1sjIYreyS53EH0W7OVJ9ktuDBjE18uqKKllTtJZNZVv5qNN7rd2VJqOxVDA7bTp9vG7ier/mFRkvM+aTrNlDsmYPxcZslBIVsS7diXfpRaRzx4u+Y682l3O4aitHqragNhfhrQiks/tgOrj1w0Xm2awADINNR5kxn9JTSY2lprrXpyVLJCIpNsHaYBuF2AEnqRsqqQsqqStOUjd8lEH08brpvPtrM+xXKcX6w+wo/QC9VU03r6nEuo2+rLek/0YQhGbfJRTpD7Gx6EXcFeFcH/Bug8ne3eo1rCn6hh6ew7kp4L56A62z6vn05Fzy9fnMiH6MGOfoBm2qTdV8m/0n60v2E+kUyNSIUXR0bzyVvr4fBjVri3azrmQfNRYd3T1iGRnQmx6ecUguwy1zS/JX8Tr+KtnA7M4ftnZXmsyPue9TbMjmsejZF2WIK00lJNfsIUWzlzx9GnKxkhjnLsS69MRLEXDKOLqcdx8mm4FkzR4OV20mW5eMUqKig1t/urgPItAhssXvhk+P6KvNahylzjhJXU8ZcdeL+j7aDPtVhslWy371F6RqVhOs6kVfn6dxkvle9n4Igo0Kww6KtStQ6zfjpuxOsMtkPB3617tXzkelKZN1hc8iEzswLPBDnGX/5BQcr97FsvzZxLn04Pbgx+sjmsx2C59nLiCpOomHI6fS1b3LGe1magv5MnM1h6rS6eUZz/3hNxOq+uc7stpt7FInsaZ4N4eq0vGUuzLCvycj/HudocZ4NbGh5G9WF/3B3C6ftHZXmkRqzQG+z3mHSe1eItr5zPN4oWgsFZzQ7CNZs5tsXUr9/BuATKSoN/IqqWvds6TufZmpgGTNHqx2CzEuXensPogY565XZTRdm2G/isip3causo+xY6O39+OEOw+57P50gyWfIu0KSrSrMNlKcVV0w8fxetSGrVQZd+EoCyfYZRJ+qlFIxOc/rzpLGX8VPoPRVs2wwA/wUv4zCs/UJvFDziyCHKOYEDqzXu7BJtj4LmcJ28q3MznsHgb5NC57u78ylS8zV5OnK+XGgF4M9+vJDnUS64r3Um3R0s2jPTcF9KanR9xVk3x0LjaVbWFF/i981nVua3flvJjtJuakPU6QYyTjQ5++ZPsx2Qz1fnmdrQadtQa9VdPgve7UeyepG53cB9LBrR8q6ZURLnyhtBn2qwCdVc3ustnkaLcS5TKcnt6PopRcvlqTNruRcv16irQrqDbuRS7xxk81mgDn23CU/ZOyrjWnkV/zHSXa1UjFKgKcxxPkPAGF9Nyyr2ablo1FL1JuPMGQgLcIUvWoX1aoz+S7nLdwlXkyqd1LOEndgDr3z8rCX1ld9Ae3BNzEmMBRjfrUbYKdDSX7WZS9lkpzDR5yZ4b79WKEfy/8HC5/AfFLyZaybfyU9zMLus1v7a6cl3XFS9hb8RczYua0SiH3a502w34FIwh20jR/sE/9OQqJM319niFIdfnC72pNKRRpV1Cq+x2bXYenw0D8nW/D02EgYtHZb0/NNjUFNT9RWPsjVnstvqobCXaZjLMi7qzb2AQL20reJat2E/19nyXa9cb6ZRWmYr7NfgMRYiaHv4KH/B+3yuayLSzJ/Ykop0geingAN7lbo+0bbCYyawtp7xKK9BoYnTfGjvKdfJvzPV91/6K1u3JOSo15zEt/ihsDptDb68bzb9BGs2kz7JcJm2BBZylHay1GaynDYtdjFQyY7XqsdgOWUw+roK9/bbJp0FnLSXAfSxfPe5E1wbXRUpysnEV+zSIcpGH4O92Gv9Po8468/x+b3USpbjX5Nd+hs5zETdmDdq6P4u7QeHERQRA4oF7A0aof6Op5H508JtW7mmotVXyb/SZaazWT272Mv8M/dwo5ulzmZ3yB0WZkasT9JLjGX/iBX8XsVu/hy6yvWdRj4flXbiXsgp2vMl/GIph5OHJWq034X+u0GfYWwi7Y0FpK0VqLqbWUoLWceraWUGspRm/9J4lKLJIhF6uQiR2QihyQiR2Rif/1LHJEKnZAJnYgWNULL2XMZT2WwtqlpFW8SnvPt/F3uu2i/fiCIFBp3Eme5muqjHuIcH+SEJf7z9puSvUqdpfNJsb1Zvr4PFH/5zfadCzJeY8iQxYTw56nndM/Blxv1bMoZzH7Kw9wc8BIRgfecs3qAZ2NfZX7mZ/xBd92/+qKzWU4UPk3vxZ8zsOR7xHoeOnkIP7rXHkpilchedpd7CmfS42lAACJSIGzzA8nqT/u8nYEq3rjLPPHSeqHs8wfpcTtiv3jVRp2k17xJmGu0whwvr1F2hSJRHg69MND2Zf8mkVkVH1ArfkEsZ5vNzrBGuc2BgeJB1tK3sBoq2aQ38tIxQqUEhWT2r3E8rzZfJv9BmNDniDetRcAjlJHHomYymaX9vyY+xNptek8HPEg7vIrI8pFY9HgLHW+pFmHYuouZDbBhvQKzD7WWWv4q/g7enmOaDPql5i2EftFYBds7Cv/jOPVy2jnNJgE97G4yAKvaMN9LioM2zle9hieDgOI9/6kyWGLzd/PDpLLn0Qu8STO631cFImNrlesP8z6oufxUkRzfcA7yCV1kgF2wcbvhV+xv3IDtwQ+SA/PGxpsl6vLq3PN2I08EfUY7ZzCLslxNAWbYOP3ojX8Vvg7wY7BTAgdf0b8fUvxV8l6luWv4MuunyG9TJWamoraVMRPuR+is9YwI2YOSsmVn0h3NdNm2C8Qs03H5pLXKdIfpL/vTCJdbjj/RlcwRbXLSat4FR/VSGK93kYsurTCaUZrESnq59AYDxDm9gihrlMbnZCtMGXwV8FTOEg9GB74AY7SOjkBQRDYVLaMTaU/c53vOK7zGdvgYqq36pmX8TkntRlMDb+fbh4tLxR2PspNahZkLiRbl8MtATeRVptOck0KPTy6Mzb49gbSCBdLraWWmcdeYIB3f8aHjD3/BpcJQRBI0uxkVcFneCkCGB/yNJ7XWA2EK5E2w34B1FqKWV/4HAZbFdcHvIOvQ0Jrd+mCEQSBrOrZ5Gq+IMz1Edq5PXbZ7jYEwU5BzWIyqz5CJY8hzus9VPIzb9FrLUX8WfAUdsHGiKCPcJX/Iyewr2IdqwsX0tl9IKMCH2qQTGK1W1mS+yOby7cyNvh2bvQbftmObZd6D4tzl+Ahd+ehiAcJcQxGEASOVB/lp7yfqTRXMtx/GDf534hScvHaRouyF3O4+gjvdXgbh0tc3tFsN7JHvZYyU0Gd2JXdjMVuwmw3YTn1MAv/vBYQ6Ok5ghv9J1+VyT5XI22GvZmUGpLYUPQCDhIPbgh8r0G25NWGXTBzQv08Zbq/iPF8vcV86s1FZ84gRf0sOksGEe5PE+R89xluIIO1inWFz6K1ljAs8AO8le3rl6XVHGRp3kcEO0ZzV+gzKCX/yOwKgsC6kvUszV9OP68+3BkyHpX00rkB9FY9i3N/YHfFHq73HcLY4NuR/59stNVuZUPp3/xW9DsKsZw7gm6jj1fvC/a/Z+tyeD35LR4Iv5e+XmcW/W4p7IKdo9VbWVf8A2a7gVBVLHKx8pQQlgKZSHHqtRyZWIHslDCWm8ybENXlDQD4r9Nm2JvByZp1bC99j0DH7gz2fxX5VSC4dTYstmqSyh6l1pxCos9cPBz6tmp/7IKFnOrPyNUswE3Zg1ivd1FKGyorWux6Nha9RKnhOEMD3m4Q01+oz2Rxzts4SpyZ1O4l3OTeDbY9VHWYr7K+QSQSMzrgFgb7DGxxP3R67UkWZH6F2W7m/vApdHTrcM71ayw1rCz4lS3l2whThTEhZDxRzufWtvl/7IKdt1LeRSwS82Lsc5fsjiRHl8KaokUUG7Lp5jGEob534iRzuyT7auPiaTPsTUAQ7Byo+Iqjld+T6D6e7l4PXdXxtwZLPkdLH8AmGOjo+yVO8itnNKUxHeVE+bOYbRXE+8zG06Ffg+WnE5myazcz0O9FIlyG1i+rNpfzXfZbGGxa7mn3IgEO4Q221Vl1rC76g42lm/CUezI2+Ha6une+aGNoE2z8Vvg7q4v+oINrAveFT8FV1vTM4Dx9Pj/mLuVEbSq9PHoyOvAW/JS+TerXjvKdfJW9iNfjX74kpfAqTSX8VbKYZM0eIpw6cKP/ZPwcwlp8P220LG2G/TxY7Aa2lrxNrnYH/XyfJsb1/JKZVzI1pmMcLX0IhdSHjj4LUEgvv4DY+bDZDaRWvHRWF5Eg2NlbPp/j1cvo5f0YCe531C8z2HT8mPs+BfqTjA95ihiXMydNy4zlrCj4hb2V+4l2imJ8yFginMLPWK8plBnL+SLzS/L0eYwLGctQn+su6EIhCAIHqw6zNH8Z5aZynKROtFOFEa5qR5gqjHBV2BlZtXqrnueSXqwvAt6SGG06tpT9wi71H7jLfRnhP4kY565XZbTXf5Er3rDXWopQG9OwCiZsdjNWwYxNMGETzFjtdc+n39sEM44ST1zkQbjIAnGRBeEk821yRSFBsKOzllNjKaTGXIDGUkCBbi96q5qhAW/h79i5pQ7/smIXrFQYtlJUu5QKw3Y8HPqR4D0bqbhlKg5dCgTBTlb1p+RqviDU9SHC3WY0MCqCIJBU9RP71J/Twf2uU7VU63zUVruFXws/52jVNm4OfIAensMa3UeGNpOlecs4qc2gp0cP7gi+FW+Fd6PrnsZkM5GnzydXn0euPo99FfvxUnjxcMSDBDkGXvRxW+1WsnTZZOmyydbmkK3LptRUV7jbXeZOO6c6Y99OFcahqsPsqdjH+x3ewUnWUtWjbByo3MjfJT9hx84Q33H08Bx2SQpYtHHpuOIMu12wUW5MIU+7kzzdLqrM2QBIRPJ/PRRIxHKkp1+L5EjFcsRI0Vsr0FjyMdvrqpyIkOAs8z9l6ANxkdc9S0QKaiwF9Ua8xlJIjaUQm2AGQCpywFUehKs8hK6e9+MqD7r8X9JFYrKWUqRdTlHtcky2EtyVfQl0Hoe341BEV4kr6Z8wzBHEer17RhjmyZq/2FYyi3bOAxng+0J90Q5BENhU+jObypYxwHsM1/tNaHRysm6kfIhl+SuoMFdyve8Qbg4YiUqqQmvVkqurM+B5+jxydHmUGEsQEHCUOBDiGEKsS3tu9B+B/BJGe+isOnJ0uXXGXldn7CvNVQBMCpvIdT6DWmQ/Wks132S/RrmxkF5eIxjscweOUucWabuNy8sVYdglCoFC3T7ydDvJ1+3GaNPgLPMnRNWXEFVf/Bw7IjmH6FRjGG019Qa79pTR1px6b7TV/SlkYkdcZEG4yIJwPT3KP/XsIPG4Km87BcFOpXEXRbVLUes3IRU74+90GwHO43CUtbwP9nJQYdjB8bLHcJbHkegzD5nErcHyIv1BNha9dKpoxzsNlC8PVW5iVcHnJLj25tbgR89a2Nxqt7KpbAu/Fq4GBBwkDqjNFQC4SF0IVYUQ5hhKqCqEUMdQvBVerfr7qDZXU2oqI9opqsX6sbl0ObvUfzA18l28FAEt0mYbrUOrG/ZV6dOp5Dh2wYqPMp5Qpzpj7iYPu2R/HLNNh00wX7UZoo2ht2RTqltLsXYVRms+ropuBDqPx9vxBiTXQFHvWnMqx0ofRCJypIPvgjMuUlWmbNYVPoNEJOeGwFm4ykPql2XUHuXH3A/wVQZzW/D0cxotnVXPxtK/AU4Z8RDcZNfO7+Rs2AQrs9Om096lGyMD7mvt7rQINsFCrnYHDhI3vJQxV1zZSL1VTbkxFbUxlRpLEQqxMwqJK8r6hxtKqRtKcd17yVkGJY3R6ob9j4xnifIaRLCqFw7SK0PX42pAEOzUmI6hNmxCrf8bnSUDmdgTX9WNBDiPw0ke1dpdbHFM1lKOlj2E0VpIgvdsPBwaxmzrrWrWFz6PxpLPYL9XCHH6Z3mpMZeluR9TYS6mn9ctDPK9/T9X9PxcbCj5kR3lq5ke/fFVP1oXBIFc3Xb2lX9er98kQoybPBRvZSxeyvb4KONwV4Q32xNwoRhtNaiNqacM+QnKTWnoreUApzwGwVjseoy2aow2DSZbTYPKTwAykQO+DokMD/rovPtrdcN+pUfFXEnY7AaqjLsp1/9NhX4LZrsapTQQL4fr8HIcgpuye5Mniq9WbHYDJ9TPU65fT6THcwQ5T2wwmrbaTews+5CTNevo5nk/HT3+WW4TrOxR/8nfpT+jlDgwwn8KCa69r/nR+PnI1ibzddYr3Bz4ID3PMtF8tVBhymBP2VyKDYeIcB5KN6+piBBRbkyh3JhKufEEamMqFsGARCTHQxGJt7I93spYPBVRuMiC6udpLgRBENDbKqgyZVJpykRtSqPcmEqtpQgAldQHL2V7vJXt8VLUPSskZ85j2AUbZrsWo02D0VaNyabBaNMgESmIdLn+vP1oM+xXOGabGrV+M2r9JiqNu7ALRlzkHfByvA4vx+tQyaL/c4ZJEARyNQvIqv4Ef6fbifF8tcGkqiAIJFf/wt7yeYQ69WOg3wsNbsNrLVWsK/mew1VbiHDqwE0B9+OjvPomx1sCvbWWeSefJMAhggmhM6/a35LeWsnBiq9I0/yBt7I9vbyn4+vQuLicXbChMec1MPQVppPYsQIinKS+uMqD6x6yEFzlIbjKg3GS+jTIiLbYDVSZsqkyZ1F5ypBXmrIw2TUAOEg88FRE1xnxU8bcUep5Ob6ONsN+pWK0FpFW8SoVhu2IkeHu0KfOmDsMbnbBi2uVcv3fpJQ/jUoWSZz3RzjKQhosL9IfYlPxKzhIPLk+4B1c5A3DEXN1J/i98CtKjXn08bqJ63zH1tdV/S8gCAI/5X5Anj6d6dEfX5V1Pq12E8nVKzhSuRiZWEV3r6lEOl/fbGVSm92MxpKPxpyPxpzX4LXJXgvURea5yIJQSX3qI+pAQCJS4C5vh4ciAg9FOB6KCNzl4a3qWm4z7FcYgiBQovuN9Io3UUh9CHd7Ak+HfkiusImf5iIIVqo0b2E07UIqDUUmDUMqDUMqaYdMGopE4n9BMsE6cybJ5U9isOYT4/kqfk6jGiyvtZSwsegFtJYSBvu/SpCqYfUmu2BjX8V6NpT+iEwkZ4T/JDq49b9qR67NYV/FelYXLmBK+GtEODU+ur1SEQSBHO0W9qk/R2+tpKPHBBLdx1+SKmNGW/U/Bt+cj9ZahosssN6QO8sCr7hM9DbDfgVhtlWSVvEq5fr1BDlPJML9aSTXwASf3a6jvPIhjMYdOKnGY7OVYLHlYrXmIAiGU2spkElDkErDkEnDkEmjUDneilisOmfbUFeCL7PqAwpqv8dXdQsxnq82SL6y2o1sL32fzNqNJLjdQTevB5D+3/eqs2pYV7yEg1V/E6aKY2TAfQT8q/zetUaZsYDPTj5Nb6+bGOZ/d2t3p1lUmXLYWfYhJYajRDrfQHevqahkbXex/6bNsF8hqPWbSVW/hEgkJdZrFh4OvVu7Sy2CzVZOqXoiVlsePp6LUSq61S8TBAGbvQyrNQeLNQfrqYfFmoPFmopY5Iq76wuoHG9v0mherd/CCfVzSMXOxHt/hIviHxEuQRA4WbOW3eVzcZR4MMDvhUbllvP16fxeuJAiQxad3Acy1Pcu3OQtp5t+JWC1W/g8YyYSkZSpke9cVVmlRfrDbCx6ARdZIH18nsTH4ewF0v/LtBn2VsZq13KychbF2uX4qm4h2uNlZJKrz9fZGBZLBqXqCYAYX68fkMmarsdis5VTVfM+Wt2PyGWJeLi9jlLReBHsf2OylpGinkm1cR/h7o+fqq36z0VBaylle+l7FOkPkuA+jq6e950RBWEX7CRV72RDyQ/UWqvp43UTA33GNJADvppZU/QNByo38mjUR3gq/M+/wRVCZs1Gtpa+Q4iqT325xDYap82wtyLVxgOkqGdis2uJ8XwdH9Xw1u5Si2E07aOsYjJSSRi+XouRSC5s1Gs2p1CpeRWjaQeODrfg7voSMmnwObcRBDt5NV+TVTUbN2V34rzeayB2JggCaZrf2Vs+D0eZDwN9X2h05Ge1W9hTsZbNZSsQI2aw71h6eNxwVReLSKs5xOKct7g9eDqd3Qe3dneaRJ0u0FL2qT8j3u0OenpPu+J82lcabYa9FbALZrKq5pBX8xWeDgNo7/nWNRXpotP/QXnlozgoB+Ht8Rnii5z4FQQBg3E9lZrXsVqLcHV+EFfnxxCfR8SsxnSM5PKnsNprifV6Fy/Hhoas1lLC9pJ3KTYcoYPHXXTxmNJodp/eWsvWsl/YXbEWN5k3N/hNIP4qjH/XWqqZc/IJIp06cEfwjKui/3bBxp7yuaRU/0JP70dJdB/X2l26Kmgz7JcZu2DmWOnDaEyHiPR4ngCnO66KP1hTMJuTqa75EL3xL5xVk/Fwe6tFxcYEwUyNdhHVNR8D4Kwaj7PTFGTSsLNuY7VrSa94kxLdr/iqbiHK4znkkn9iiQXBzgnNb+wr/wwnmS/9fWeeNf650lzKhpIfOVa9nWDHaEb4TyJUFdtix3epsAt2jlVvZ0PJD4gQ82j0R1eFW0lnVbO15C1KDMcY5PcS4c7XtXaXrhraDPtlxGgt4XjZdHSWLDr7fYuL4uoKMTsbZktqnUE3rEEuS8DN5WkclDdcsguWzVZJrW4JtbrvsNmKcXQYibvrC8ikZ49iKddtIL3yTWyCiSj3mfg5jWnQv1pLETtKP6RQf4A41zF085561gpZBfoM/ipeTLbuONHOXejg1pcY526troQoCAK11irKjQWUmQooM+VTbiyg1JiPwaali/tghvrdiYvMo1X72RTytLvYVvoOcrETg/1fxVt55V9AryTaDPtlosq4n+NljyOTuJLoPa/Ros1XG1ZrEdU176PVL0Mma4+by9M4KodfUDz6hSAIVvSGv6iqmYXVmoeL02RcnWcgkTRuuKx2LVlVsymoXYKbsgftPd/AURb2r/YEMmrXsadsLhKRnJ7e0wh3HtLoBUoQBNJqD7JbvZZs3XEEwU6YKo5Y157EunTHXX7pXGuCIKCxVFBuyqfMWGfAy4z5lJkKMNp0ADhInPBRBOGtDMZHEUSUcyd8lOeem7gSsNnN7FN/QXL1cqJchtPb54mrugRla9Fm2C8xgiBQULuEjMpZeDoOIs7rvSu6wEVTsNu1aGrnUaNdgFjsibvr86gcxlw2g/7/CIKFWt2PVNd8AIIVV5cZuDhNQSRqPGpCYzpKqvolDJYcwtweIcT1vgaSBAZrFfvVC0ivWYO/Qxf6+MzAXXH2uwGjTUd67WFSNHtJrz2EyW7AX9mOONeexLn0wFcZekF3L3bBjsairjPaxvxTBryAclMBJntd/L9K6oqPIhgfZVCDZ5XU9apz8VWZstlc8ga15kL6+D5FlMvVrVvTmrQZ9kuIzW4kreJVSnS/Ee72OKGuU1vN+LUEgmClVvcD1TUfIghm3Fwex9npXsSiKyOJym6vrbvg1H6JROKDu+sLODrc0qiBswsW8msWkV09DwdpCO0938RV2bBCVqnhOLvKPqbSlEWC+1g6e04+7+jRareQpUsiRbOPEzX70FqrcZf50N6lO04yVwRBwI4dQRAQsCMgIAgNn3XWGspMBZQbC7AIJgCcpR4NjbcyGG9F0FUpA3Aaq91EieEYhfp9FOoPUGnKwFsRy2D/V8+Qf2ijebQZ9kuEwVrI8bLpGCx5xHl/hJfjwNbu0gVzOiqlSvMWFmsOzk6TcHN+Aonk8ggaNRertYCqmvfQ6Vcgl3fBw/WVs8bA6y15pFW8SpVxN4HOdxLh/iRS8T++crtgI1WzmgPqL5GKHercM05Nq2tqF+wUGjJI0ewjvfYQFrsJESJEInHDZ0SIRWJEiBGJRCjFjvWG20cZjI8yGIerYLLzfAiCQJU5iwLdfgr1+ygxHMUmmHGVhxLk2J1Ax24EqXpe8wqll4P/hGG3C1bMtnJM1lJMthJM1hIAVPJonOTRyC8wxvpsVBp2k1w+A7nEh0SfeVdt5SIAk/kIldWvYzLvqZukdHmhWYlGrYnJfIwqzRsYTTtxdLgRd5cXG+37aX2ejMpZiEQyYjxewVvVUBq1zj3zBek1awlw7Eofnydwk1+95/VyYbWbyNFupVC/n0LdfvS2ChRiFwIcuxGk6k6gY3ecZFdeQfWrnWvGsJttFVQb92Gw5p8y4KUYrSWYbCWYbRXwL9F6udgLARsW++kSeR44yWNwkkejkkWfeo5C0kxBIUEQyK9ZREbVB/g43kB7r3eQNkHr5ErEas2nSvMuOsMqFPJuuLu+glLRvbW71Wzq7jY2UqV547x3G2ZbJRmV71OiW4WX41BiPF49I7+g1JDErrJPqDJlk+A+js6e91xxlXmuFEoMx9heMosaSxG+DgkEOvYgSNUdT0V0W4LRJaZFDPuyZcvYt28fer2e8ePHM2DAgPNuc7GG3WY3ojEdpNKwk0rjLrTmE4AYhcQPpdQXhcQPRYNnXxRSPxQS7/qJMrNNjdachtacjtaSjs6chs6SgV0wASIcpCGoZJHIJB5IxU6nHs5IRHXP//5MLFKSUfUBZbo/iXB/ihCX+666ySuoE+zS1M5FU/sFUokf7q4v4egw8qo8ln/TnPmBSsMuUitewmqvJdL9Ofydbm1w/HbByonq3zhY8RVSsQM9vB4iwvn6q/47aiksdgMH1AtJrl5BkGN3+vk+2zYqv8xctGGvqalh0KBBHDx4EKPRSPfu3Tl27Bhi8bknCZtr2AXBjtacRqVxB5WGXWhMB7ELJhyl7fBw6Iu7Qx/clT0vOuJEEGwYrHl1xt6cjt6SgcVeg9Vei82uxSposdq12OtVCf9BKnYjwftjPBz6XlQfWgNBsKPVL6Na8y52wYCby5PnjCy5WqmL6JlPjfYLxGKvOpExh1FnTGpb7Tqyqj6hoHYJHsq+xHi9gYO04YSe3lrJAfWXpNesxUcZRy/vx/7zolRF+sNsL52FyVZDL+9HiXK5se2C1wpctGHfsGED33zzDT/99BMAPXv2ZMmSJURFNay5abFYsFqt9e/1ej1eXl5UVFSc17Dnab4mv+Z7LPZKZGI33BS9cHfohYdDL5TS1qnPaBcs2Ow6rPY6Q28ValHJ2rW4v/5yIAgCpeqJmEy7cVLdiZvLjAvWdrlaqIvB/wSd/heUiv74en/X6HrVxkOkqV/DbC+ji98PjeYfqI3p7FV/RpkhiR5e04h3v/VSd/+KJKNmPdtL3yPIsRd9fGagknm3dpeuOYzWIpTSAJRK5bkvmMJF8uOPPwr3339//fshQ4YIu3btOmO9V199VQDaHm2Ptkfbo+1xkQ+9Xn9Ou3zRcUVeXl5otdr697W1tXh5nTnae/HFF5k5c2b9e51Oh7e3N2q1GkfHq3/yyWAw4Onp2aQ7kKuBtuO58rnWjqnteJqOUnnu3JGLNuw9e/Zk5syZCIKA0WhEp9MREXHm7apMJkMmO1Pu1NHR8Zo4iadxcHBoO54rmGvteODaO6a247l4Ltqwu7i48Nxzz/Hkk0+i1+uZP3/+eSdO22ijjTbauHS0SIrX2LFjGTt2bEs01UYbbbTRxkXSakNrqVTKq6++ilR6baQPtx3Plc21djxw7R1T2/G0HK2WedpGG2200caloc0Z3kYbbbRxjdFm2Ntoo402rjHaDHsbbbTRxjVGq8xSXIho2JVOr1696pMG+vXrx1tvvdXKPWoeycnJTJs2jeHDh/Pcc88BV/95auyYrtbzlJmZyauvvkqnTp1ISUlh7NixDB8+/Ko9R2c7nqv1/EBdQtKdd95J7969SUtLo2/fvtx33318+umnVFZWUlRUxBNPPEFc3GXQE7pYSYHmotFohM6dOwt2u13Q6/VCfHy8YLPZLnc3WpxXX321tbtwUSxdulR46aWXhHfffVcQhGvjPP3/MQnC1Xue9u3bJ6xbt04QBEEoKysTQkNDr+pz1NjxCMLVe34EQRC0Wq3wzTffCIIgCHq9XnB3dxcyMjKE66+/XhAEQcjJyREGDhx4Wfpy2Ufse/fuJSYmBpFIhIODAyqViszMzDNEw642kpKSeP/999Fqtdx5553Exl5dVdXHjRvHiRMn6t9fC+fp/48Jrt7z1L37P1r4drsdlUp1VZ+jxo4Hrt7zA6BSqZgyZQoAOTk5REVFsWnTJrp27QpAaGgoqampmM1m5HL5uZq6aC67YVer1Tg5/SOt6+zsjFqtvip+jOfi+eefp1u3blRVVdG3b18OHTp0Xj2HK5m283TlMnfuXGbNmnXNnKPTxwPXxvn56quv+O677/j4f+3dO4oiURjF8T+CmBRK0ZH2BhQEDXysQBBE3ERh4BbMDAw7NDYxEU3MKi3MfIQ+wERFqERMhI6ECTqZbmagh0Htezm/FXyXA6fgFnz37Y0gCD5l5DgO5/OZZDJ51xke/vP0u0vDTFMoFABwXZdEIsFut3vyRP9HOf1Mg8GAVCpFvV63IqPfzwPm5wPgeR6+7+N5HpFI5FNG1+uVl5f7vxX88GIvl8tst9uPJ8ve3/+6NMwkm82Gfr8PwO12IwxDXl/NfmVdOf08w+GQy+VCq9XC931KpZLRGX09z3q9Njqf1WrFbDYDPpYbOo5DtVplsVgAsN/vSafTd7+GgSdcxdi4NCwejzOZTDidThyPRzqdDq7rPnusfzIejwmCgGg0SiaTodFoGJ/T1zMVi0Vjc5rP5zSbTfL5PKPRiMPhwHK5NDajP51nOp0amw9ALBaj2+2SzWYJw5BKpUIul6NWq9FutwnDkF6v95BZtFJARMQyZnzeRUTk21TsIiKWUbGLiFhGxS4iYhkVu4iIZVTsIiKWUbGLiFhGxS4iYhkVu4iIZVTsIiKW+QVm/92ai2iu7QAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(4, 4))\n", + "# Phi_with_net_current is imported from quadcoil.quantity\n", + "plt.contour(Phi_with_net_current(qp_nescoil, dofs_nescoil), levels=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2e41c1ec", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:32.591797Z", + "iopub.status.busy": "2026-04-24T13:01:32.591720Z", + "iopub.status.idle": "2026-04-24T13:01:36.994925Z", + "shell.execute_reply": "2026-04-24T13:01:36.994340Z", + "shell.execute_reply.started": "2026-04-24T13:01:32.591788Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Extracting and plotting the winding surface\n", + "aries_ws = qp_nescoil.winding_surface.to_desc()\n", + "plot_comparison(\n", + " [aries_ws, aries_eq],\n", + " labels=[\"Winding surface\", \"Plasma surface\"],\n", + " theta=0,\n", + " rho=np.array(1.0),\n", + ");" + ] + }, + { + "cell_type": "markdown", + "id": "ac499a4b", + "metadata": {}, + "source": [ + "### Calling QUADCOIL (outputting DESC REGCOIL types)\n", + "Alternatively, one can also run\n", + "```QuadcoilProxy.solve_quadcoil_surface_current()``` \n", + "to call QUADCOIL and output the result as a DESC object (see the DESC REGCOIL tutorial)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4efeb443", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:36.995209Z", + "iopub.status.busy": "2026-04-24T13:01:36.995136Z", + "iopub.status.idle": "2026-04-24T13:01:41.774635Z", + "shell.execute_reply": "2026-04-24T13:01:41.774306Z", + "shell.execute_reply.started": "2026-04-24T13:01:36.995201Z" + } + }, + "outputs": [], + "source": [ + "scf_nescoil = objective_nescoil.solve_quadcoil_surface_current(\n", + " # Like Objective.compute(), the xs of the equilibrium\n", + " # must be passed in as the *arg.\n", + " *objective_nescoil.xs(aries_eq)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "fdafc3ab-d1d8-41cd-a8b6-90a498db4d2c", + "metadata": {}, + "source": [ + "### Consistency with DESC's built-in REGCOIL\n", + "We now demonstrate the consistency between QUADCOIL and DESC's built-in REGCOIL." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a4c3dcf1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:01:41.775107Z", + "iopub.status.busy": "2026-04-24T13:01:41.774977Z", + "iopub.status.idle": "2026-04-24T13:02:08.748152Z", + "shell.execute_reply": "2026-04-24T13:02:08.747889Z", + "shell.execute_reply.started": "2026-04-24T13:01:41.775099Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##########################################################\n", + "Calculating Phi_SV for lambda_regularization = 0.00000e+00\n", + "##########################################################\n", + "chi^2 B = 2.10990e+00\n", + "min Bnormal = 7.58584e-15 (T)\n", + "Max Bnormal = 2.18612e-01 (T)\n", + "Avg Bnormal = 3.00948e-02 (T)\n", + "min Bnormal = 1.24158e-15 (unitless)\n", + "Max Bnormal = 3.57805e-02 (unitless)\n", + "Avg Bnormal = 4.92564e-03 (unitless)\n" + ] + } + ], + "source": [ + "# Solving the NESCOIL problem using DESC's built in REGCOIL.\n", + "# Please see the REGCOIL-like coil optimization tutorial\n", + "fields, data = solve_regularized_surface_current(\n", + " scf_nescoil, # the surface current field whose geometry and Phi resolution will be used\n", + " eq=aries_eq, # the Equilibrium object to minimize Bn on the surface of\n", + " source_grid=objective_nescoil.constants[\"source_grid\"], # source grid\n", + " eval_grid=objective_nescoil.constants[\"eval_grid\"], # evaluation grid\n", + " current_helicity=(\n", + " 1,\n", + " 0,\n", + " ),\n", + " lambda_regularization=jnp.array([0]),\n", + " vacuum=False,\n", + " regularization_type=\"regcoil\",\n", + " chunk_size=40,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3509c4aa", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:08.748619Z", + "iopub.status.busy": "2026-04-24T13:02:08.748533Z", + "iopub.status.idle": "2026-04-24T13:02:09.795496Z", + "shell.execute_reply": "2026-04-24T13:02:09.794965Z", + "shell.execute_reply.started": "2026-04-24T13:02:08.748608Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Difference between Phi coefficients of DESC REGCOIL and QUADCOIL Fourier coefficients\n", + "Maximum absolute: 29413.851731878647\n", + "Mininum absolute: 4.44800912658684\n", + "Average absolute: 3807.8703983615937\n", + "Maximum normalized (by max Phi): 0.006661441697821326\n", + "Mininum normalized (by max Phi): 1.0073537372197437e-06\n", + "Average normalized (by max Phi): 0.0008623796326563354\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 3, figsize=(12, 4))\n", + "plot_2d(scf_nescoil, \"Phi\", levels=10, filled=False, ax=axs[0])\n", + "axs[0].set_title(\"The QuadcoilProxy sln\")\n", + "plot_2d(fields[0], \"Phi\", levels=10, filled=False, ax=axs[1])\n", + "axs[1].set_title(\"The DESC-REGCOIL sln\")\n", + "axs[2].plot(scf_nescoil.Phi_mn, label=\"QuadcoilProxy\")\n", + "axs[2].plot(fields[0].Phi_mn, label=\"DESC-REGCOIL\", linestyle=\"dashed\")\n", + "axs[2].legend()\n", + "axs[2].set_title(\"Phi Fourier coefficients\")\n", + "norm = jnp.max(jnp.abs(fields[0].Phi_mn))\n", + "err_phi = jnp.abs(scf_nescoil.Phi_mn - fields[0].Phi_mn)\n", + "print(\n", + " \"Difference between Phi coefficients of DESC \"\n", + " \"REGCOIL and QUADCOIL Fourier coefficients\"\n", + ")\n", + "print(\"Maximum absolute: \", jnp.max(err_phi))\n", + "print(\"Mininum absolute: \", jnp.min(err_phi))\n", + "print(\"Average absolute: \", jnp.average(err_phi))\n", + "print(\"Maximum normalized (by max Phi): \", jnp.max(err_phi) / norm)\n", + "print(\"Mininum normalized (by max Phi): \", jnp.min(err_phi) / norm)\n", + "print(\"Average normalized (by max Phi): \", jnp.average(err_phi) / norm)" + ] + }, + { + "cell_type": "markdown", + "id": "9a72e54b-d8a4-4011-a674-c80a6ca90cbf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-28T01:05:48.750553Z", + "iopub.status.busy": "2026-02-28T01:05:48.750429Z", + "iopub.status.idle": "2026-02-28T01:05:48.753208Z", + "shell.execute_reply": "2026-02-28T01:05:48.752935Z", + "shell.execute_reply.started": "2026-02-28T01:05:48.750544Z" + } + }, + "source": [ + "## 2. Solving a simple REGCOIL-like constrained problem\n", + "As a second example, we solve a REGCOIL-like constrained problem:\n", + "$$\\min_{\\Phi'} \\chi^2_K,$$\n", + "$$\\chi^2_B\\leq C_B.$$\n", + "Compared to the REGCOIL problem:\n", + "$$\\min_{\\Phi'} \\chi^2_B+ \\lambda \\chi^2_K,$$\n", + "One can specify a $\\chi^2_B$ target rather than sweeping the regularization\n", + "parameter $\\lambda$. This saves times and makes it easier to construct coil complexity\n", + "proxies." + ] + }, + { + "cell_type": "markdown", + "id": "69905d60-e8de-4cf1-a30d-3b51b86da165", + "metadata": {}, + "source": [ + "First, let's solve a REGCOIL problem in DESC to obtain a threshold \n", + "value $C_B$. In a real study, the threshold values\n", + "can be based on real engineering requirements." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3d2a6280-2472-4c13-849b-68b1f8882ad3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:09.795864Z", + "iopub.status.busy": "2026-04-24T13:02:09.795780Z", + "iopub.status.idle": "2026-04-24T13:02:15.281227Z", + "shell.execute_reply": "2026-04-24T13:02:15.280832Z", + "shell.execute_reply.started": "2026-04-24T13:02:09.795856Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##########################################################\n", + "Calculating Phi_SV for lambda_regularization = 1.00000e-15\n", + "##########################################################\n", + "chi^2 B = 4.88488e+00\n", + "min Bnormal = 7.42333e-15 (T)\n", + "Max Bnormal = 3.13784e-01 (T)\n", + "Avg Bnormal = 4.43411e-02 (T)\n", + "min Bnormal = 1.21498e-15 (unitless)\n", + "Max Bnormal = 5.13572e-02 (unitless)\n", + "Avg Bnormal = 7.25735e-03 (unitless)\n" + ] + } + ], + "source": [ + "# Solving the NESCOIL problem using DESC's built in REGCOIL.\n", + "# Please see the REGCOIL-like coil optimization tutorial\n", + "fields_regcoil, data_regcoil = solve_regularized_surface_current(\n", + " scf_nescoil, # the surface current field whose geometry and Phi resolution will be used\n", + " eq=aries_eq, # the Equilibrium object to minimize Bn on the surface of\n", + " source_grid=objective_nescoil.constants[\"source_grid\"], # source grid\n", + " eval_grid=objective_nescoil.constants[\"eval_grid\"], # evaluation grid\n", + " current_helicity=(\n", + " 1,\n", + " 0,\n", + " ),\n", + " lambda_regularization=jnp.array([1e-15]),\n", + " vacuum=False,\n", + " regularization_type=\"regcoil\",\n", + " chunk_size=40,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9d547391-964d-46a6-97db-9550c56df312", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:15.281634Z", + "iopub.status.busy": "2026-04-24T13:02:15.281553Z", + "iopub.status.idle": "2026-04-24T13:02:17.595776Z", + "shell.execute_reply": "2026-04-24T13:02:17.595346Z", + "shell.execute_reply.started": "2026-04-24T13:02:15.281626Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "obj_flux = QuadraticFlux(\n", + " field=fields[0], # the field to be optimized\n", + " eq=aries_eq, # the equilibrium upon which the quadratic flux is being evaluated\n", + " eval_grid=objective_nescoil.constants[\"eval_grid\"],\n", + " field_grid=objective_nescoil.constants[\"source_grid\"],\n", + " vacuum=False,\n", + " bs_chunk_size=10,\n", + " normalize=False,\n", + " normalize_target=False, # don't use normalizations, to match the REGCOIL problem exactly\n", + ")\n", + "obj_flux.build()\n", + "chi_2_B_regcoil = obj_flux.compute_scalar(*obj_flux.xs(fields_regcoil[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "da68dcae-4248-4baf-9660-3bc06d79313e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:17.596205Z", + "iopub.status.busy": "2026-04-24T13:02:17.596118Z", + "iopub.status.idle": "2026-04-24T13:02:17.904446Z", + "shell.execute_reply": "2026-04-24T13:02:17.904140Z", + "shell.execute_reply.started": "2026-04-24T13:02:17.596197Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "obj_regularization = SurfaceCurrentRegularization(\n", + " surface_current_field=fields[0],\n", + " source_grid=objective_nescoil.constants[\"source_grid\"],\n", + " weight=1,\n", + " normalize=False,\n", + " normalize_target=False, # don't use normalizations, to match the REGCOIL problem exactly\n", + ") # we will set it to the sqrt of optimal weight from above,\n", + "# since DESC will square the weight when making the overall cost fxn\n", + "obj_regularization.build()\n", + "chi_2_K_regcoil = obj_regularization.compute_scalar(\n", + " *obj_regularization.xs(fields_regcoil[0])\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "c448087b-d5ba-448f-ac70-ad58c6732f75", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:17.904910Z", + "iopub.status.busy": "2026-04-24T13:02:17.904830Z", + "iopub.status.idle": "2026-04-24T13:02:17.909579Z", + "shell.execute_reply": "2026-04-24T13:02:17.909222Z", + "shell.execute_reply.started": "2026-04-24T13:02:17.904902Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target f_B is: 2.442441636833631 T^2m^2\n", + "Target f_K is: 1.992594631747012e+16 T^2m^2\n" + ] + } + ], + "source": [ + "# There is a factor of 4pi difference between\n", + "# QUADCOIL and DESC as of Mar. 2026, since\n", + "# QUADCOIL is calibrated against simsopt's REGCOIL\n", + "# implementation. This may change with later versions.\n", + "C_B = chi_2_B_regcoil / (4 * jnp.pi**2)\n", + "C_K = chi_2_K_regcoil / (4 * jnp.pi**2)\n", + "print(\"Target f_B is:\", C_B, \"T^2m^2\")\n", + "print(\"Target f_K is:\", C_K, \"T^2m^2\")" + ] + }, + { + "cell_type": "markdown", + "id": "08dd0af9-a104-4824-a740-bc46ab0ff293", + "metadata": {}, + "source": [ + "### Calling QUADCOIL (outputting DESC REGCOIL types)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "3a45cc85-cb73-4450-880d-8e9caaccee5c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:17.909888Z", + "iopub.status.busy": "2026-04-24T13:02:17.909818Z", + "iopub.status.idle": "2026-04-24T13:02:17.928581Z", + "shell.execute_reply": "2026-04-24T13:02:17.928244Z", + "shell.execute_reply.started": "2026-04-24T13:02:17.909881Z" + } + }, + "outputs": [], + "source": [ + "quadcoil_kwargs_regcoil = quadcoil_kwargs_basic | {\n", + " # The NESCOIL problem only contains the squared\n", + " # flux objective. In QUADCOIL, this quantity is called\n", + " # f_B.\n", + " \"objective_name\": \"f_K\",\n", + " # For a constrained REGCOIL problem, we advise\n", + " # normaizing the objectives and constraints using\n", + " # values measured from known QUADCOIL solution.\n", + " # Empirically this gives much better accuracy than\n", + " # normalizing using equilibrium parameters.\n", + " \"objective_unit\": C_K,\n", + " # Quantities to constrain. Must be a tuple.\n", + " \"constraint_name\": (\"f_B\",),\n", + " # Types of constraints. Must be a tuple.\n", + " # Here, we define a \"<=\" inequality constraint.\n", + " \"constraint_type\": (\"<=\",),\n", + " # Threshold of the constraints. Must be an ndarray.\n", + " \"constraint_value\": jnp.array([C_B]),\n", + " # Normalizing constants of the constraints.\n", + " # We advise directly using the constraint thresholds\n", + " # if they are non-zero for best numerical behavior.\n", + " # A good alternative choice is f_K(qp_nescoil, dofs_nescoil).\n", + " \"constraint_unit\": jnp.array([C_B]),\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "85fb4b08-8129-41d5-b9da-709cab127b59", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:17.928919Z", + "iopub.status.busy": "2026-04-24T13:02:17.928842Z", + "iopub.status.idle": "2026-04-24T13:02:18.073093Z", + "shell.execute_reply": "2026-04-24T13:02:18.072596Z", + "shell.execute_reply.started": "2026-04-24T13:02:17.928912Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "# Define a QuadcoilProxy with the simplest possible\n", + "# signature.\n", + "objective_regcoil = QuadcoilProxy(\n", + " eq=aries_eq,\n", + " quadcoil_kwargs=quadcoil_kwargs_regcoil,\n", + " vacuum=False,\n", + " # If you have additional filament/planar coils, put the CoilSet here.\n", + " # field=[],\n", + ")\n", + "objective_regcoil.build()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "da5d50cc-2cc3-4622-b49c-e20f9a6af417", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:18.073487Z", + "iopub.status.busy": "2026-04-24T13:02:18.073412Z", + "iopub.status.idle": "2026-04-24T13:02:28.393289Z", + "shell.execute_reply": "2026-04-24T13:02:28.392853Z", + "shell.execute_reply.started": "2026-04-24T13:02:18.073479Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lf2869/Documents/Codes/quadcoil/src/quadcoil/wrapper.py:37: UserWarning: Bnormal_plasma provided, inputs for plasma_quadpoints_phi and plasma_quadpoints_theta will be ignored.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "scf_regcoil = objective_regcoil.solve_quadcoil_surface_current(\n", + " # Like Objective.compute(), the xs of the equilibrium\n", + " # must be passed in as the *arg.\n", + " *objective_regcoil.xs(aries_eq)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ca9a2be1-26cb-44ad-9b74-79e4fb64159d", + "metadata": {}, + "source": [ + "### Consistency with DESC's built-in REGCOIL\n", + "Here, we show that the QUADCOIL solution is a close reproduction\n", + "of the REGCOIL solution. This is achieved by directly targeting \n", + "its $\\chi^2_B$ value with an inequality constraint." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "905e13b0-f2bc-414c-bca0-d51e8ca49054", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:28.393895Z", + "iopub.status.busy": "2026-04-24T13:02:28.393805Z", + "iopub.status.idle": "2026-04-24T13:02:28.944853Z", + "shell.execute_reply": "2026-04-24T13:02:28.944347Z", + "shell.execute_reply.started": "2026-04-24T13:02:28.393886Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Difference between Phi coefficients of DESC REGCOIL and QUADCOIL Fourier coefficients\n", + "Maximum absolute: 462.28786185069475\n", + "Mininum absolute: 4.215652696475445\n", + "Average absolute: 115.91969075831103\n", + "Maximum normalized (by max Phi): 0.00010156886815130285\n", + "Mininum normalized (by max Phi): 9.262174247574944e-07\n", + "Average normalized (by max Phi): 2.5468615463179286e-05\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 3, figsize=(12, 4))\n", + "plot_2d(scf_regcoil, \"Phi\", levels=10, filled=False, ax=axs[0])\n", + "axs[0].set_title(\"The QuadcoilProxy sln\")\n", + "plot_2d(fields_regcoil[0], \"Phi\", levels=10, filled=False, ax=axs[1])\n", + "axs[1].set_title(\"The DESC-REGCOIL sln\")\n", + "axs[2].plot(scf_regcoil.Phi_mn, label=\"QuadcoilProxy\")\n", + "axs[2].plot(fields_regcoil[0].Phi_mn, label=\"DESC-REGCOIL\", linestyle=\"dashed\")\n", + "axs[2].legend()\n", + "axs[2].set_title(\"Phi Fourier coefficients\")\n", + "norm = jnp.max(jnp.abs(fields_regcoil[0].Phi_mn))\n", + "err_phi = jnp.abs(scf_regcoil.Phi_mn - fields_regcoil[0].Phi_mn)\n", + "print(\n", + " \"Difference between Phi coefficients of DESC \"\n", + " \"REGCOIL and QUADCOIL Fourier coefficients\"\n", + ")\n", + "print(\"Maximum absolute: \", jnp.max(err_phi))\n", + "print(\"Mininum absolute: \", jnp.min(err_phi))\n", + "print(\"Average absolute: \", jnp.average(err_phi))\n", + "print(\"Maximum normalized (by max Phi): \", jnp.max(err_phi) / norm)\n", + "print(\"Mininum normalized (by max Phi): \", jnp.min(err_phi) / norm)\n", + "print(\"Average normalized (by max Phi): \", jnp.average(err_phi) / norm)" + ] + }, + { + "cell_type": "markdown", + "id": "4cf4f2f9-394b-4b05-8629-17e21a950e56", + "metadata": {}, + "source": [ + "## 3. A force minimization problem\n", + "This section solves a QUADCOIL problem that minimizes the Lorentz force that\n", + "the coilset experiences satisfying some required field accuracy $\\chi^2_B$." + ] + }, + { + "cell_type": "markdown", + "id": "7232c1a4-f817-44e6-9780-edaa403aa670", + "metadata": {}, + "source": [ + "First, we calculate `K_target`, a target value for current density $|K|$ \n", + "based on the net poloidal currents and coil-coil distance:\n", + "$$K_\\text{target}\\equiv\\frac{G}{(\\text{coil count})d_{cc}}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "420bee1e-f2b8-4fe1-b5c3-badbdf49a67b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:28.945356Z", + "iopub.status.busy": "2026-04-24T13:02:28.945264Z", + "iopub.status.idle": "2026-04-24T13:02:28.947290Z", + "shell.execute_reply": "2026-04-24T13:02:28.946961Z", + "shell.execute_reply.started": "2026-04-24T13:02:28.945347Z" + } + }, + "outputs": [], + "source": [ + "net_poloidal_current_amperes = qp_nescoil.net_poloidal_current_amperes\n", + "coil_count = coil_per_half_fp * 2 * aries_eq.NFP\n", + "K_target = net_poloidal_current_amperes / coil_count / coil_coil_distance" + ] + }, + { + "cell_type": "markdown", + "id": "5f09a2c9-c30c-49a5-88d6-bacd8b283041", + "metadata": {}, + "source": [ + "### Defining QUADCOIL problems\n", + "To perform force optimization, we define two problems.\n", + "1. A problem finding the best achievable field\n", + "error for a filament coil set with maximum current density\n", + "squared $K^2_\\text{target}$.\n", + "$$\\min_{\\Phi'} \\chi^2_B$$\n", + "$$K_\\theta\\leq0$$\n", + "$$|K|^2\\leq K^2_\\text{target}$$\n", + "This problem will be used to calculate normalization constants\n", + "and a target value for $\\chi^2_B$, $C_{B0}$\n", + "3. A filament coil force minimization problem\n", + "$$\\min_{\\Phi'} \\int_\\text{winding surface}\\|L\\|_1 dA$$\n", + "$$\\chi^2_B\\leq C_{B0}$$\n", + "$$K_\\theta\\leq0$$\n", + "$$|K|^2\\leq K^2_\\text{target}$$\n", + "This problem will be used to calculate normalization constants.\n", + "Here, $L$ is the Lorentz force. We used the L-1 norm of forces\n", + "as a proxy of its L-2 norm, since the L-1 norm is quadratic and\n", + "bounds the L-2 norm via norm equivalence." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "c6474674-f938-413f-b9f6-53b4a8de00f2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:28.947640Z", + "iopub.status.busy": "2026-04-24T13:02:28.947564Z", + "iopub.status.idle": "2026-04-24T13:02:29.143822Z", + "shell.execute_reply": "2026-04-24T13:02:29.143399Z", + "shell.execute_reply.started": "2026-04-24T13:02:28.947632Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "# Defining problem 1\n", + "quadcoil_kwargs_best_case = quadcoil_kwargs_basic | {\n", + " \"objective_name\": \"f_B\",\n", + " \"objective_unit\": f_B(qp_nescoil, dofs_nescoil),\n", + " \"constraint_name\": (\"K_theta\", \"f_max_K2\"),\n", + " \"constraint_type\": (\"<=\", \"<=\"),\n", + " \"constraint_unit\": (K_target, K_target**2),\n", + " \"constraint_value\": jnp.array([0, K_target**2]),\n", + "}\n", + "quadcoil_objective_best_case = QuadcoilProxy(\n", + " eq=aries_eq,\n", + " quadcoil_kwargs=quadcoil_kwargs_best_case,\n", + " metric_name=(\"f_max_force_cyl\",),\n", + " metric_target=jnp.array(\n", + " [\n", + " 0.0,\n", + " ]\n", + " ),\n", + " metric_weight=jnp.array(\n", + " [\n", + " 1.0,\n", + " ]\n", + " ),\n", + " enable_net_current_plasma=True,\n", + " vacuum=False,\n", + ")\n", + "quadcoil_objective_best_case.build()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "5a1158cf-2e0d-426e-9214-e5705c7978b2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:02:29.144234Z", + "iopub.status.busy": "2026-04-24T13:02:29.144156Z", + "iopub.status.idle": "2026-04-24T13:03:11.870515Z", + "shell.execute_reply": "2026-04-24T13:03:11.870004Z", + "shell.execute_reply.started": "2026-04-24T13:02:29.144225Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lf2869/Documents/Codes/quadcoil/src/quadcoil/wrapper.py:37: UserWarning: Bnormal_plasma provided, inputs for plasma_quadpoints_phi and plasma_quadpoints_theta will be ignored.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# Solving problem 1\n", + "(out_dict_best_case, qp_best_case, dofs_best_case, status_best_case) = (\n", + " quadcoil_objective_best_case.solve_quadcoil(\n", + " *quadcoil_objective_best_case.xs(aries_eq)\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "ded3e89c-d72e-4ca3-98f4-07b52e0d6ce9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:03:11.870826Z", + "iopub.status.busy": "2026-04-24T13:03:11.870748Z", + "iopub.status.idle": "2026-04-24T13:03:13.897256Z", + "shell.execute_reply": "2026-04-24T13:03:13.896592Z", + "shell.execute_reply.started": "2026-04-24T13:03:11.870818Z" + } + }, + "outputs": [], + "source": [ + "# Calculating normalization constants.\n", + "f_l1_force_cyl_unit = f_l1_force_cyl(qp_best_case, dofs_best_case)\n", + "# Defining chi^2_B target. Here, we relax it to be\n", + "# 2x the best-achievable value.\n", + "f_B_target = f_B(qp_best_case, dofs_best_case) * 2.0" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "e09dcad7-f083-463a-97d2-d372d79f0076", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:03:13.897626Z", + "iopub.status.busy": "2026-04-24T13:03:13.897549Z", + "iopub.status.idle": "2026-04-24T13:03:13.900076Z", + "shell.execute_reply": "2026-04-24T13:03:13.899845Z", + "shell.execute_reply.started": "2026-04-24T13:03:13.897618Z" + } + }, + "outputs": [], + "source": [ + "# Defining problem 2\n", + "quadcoil_kwargs_force_l1 = quadcoil_kwargs_basic | {\n", + " \"objective_name\": \"f_l1_force_cyl\",\n", + " \"objective_unit\": f_l1_force_cyl_unit,\n", + " \"constraint_name\": (\"f_B\", \"K_theta\", \"f_max_K2\"),\n", + " \"constraint_type\": (\"<=\", \"<=\", \"<=\"),\n", + " \"constraint_unit\": (f_B_target, K_target, K_target**2),\n", + " \"constraint_value\": jnp.array([f_B_target, 0, K_target**2]),\n", + " # We increase the L-BFGS linesearch steps in QUADCOIL\n", + " # since force optimization is tricker\n", + " \"max_linesearch_steps\": 80,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "11968dcc-76f8-4954-9e05-5291efe457b8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:03:13.900375Z", + "iopub.status.busy": "2026-04-24T13:03:13.900304Z", + "iopub.status.idle": "2026-04-24T13:03:14.045576Z", + "shell.execute_reply": "2026-04-24T13:03:14.045117Z", + "shell.execute_reply.started": "2026-04-24T13:03:13.900368Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "quadcoil_objective_force_l1 = QuadcoilProxy(\n", + " eq=aries_eq,\n", + " quadcoil_kwargs=quadcoil_kwargs_force_l1,\n", + " metric_name=(\"f_l1_force_cyl\",),\n", + " metric_target=jnp.array(\n", + " [\n", + " 0.0,\n", + " ]\n", + " ),\n", + " metric_weight=jnp.array(\n", + " [\n", + " 1.0,\n", + " ]\n", + " ),\n", + " enable_net_current_plasma=True,\n", + " vacuum=False,\n", + ")\n", + "quadcoil_objective_force_l1.build()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8980f93-4526-4d6f-83a9-c51528a30d98", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-24T13:03:14.045865Z", + "iopub.status.busy": "2026-04-24T13:03:14.045788Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lf2869/Documents/Codes/quadcoil/src/quadcoil/wrapper.py:37: UserWarning: Bnormal_plasma provided, inputs for plasma_quadpoints_phi and plasma_quadpoints_theta will be ignored.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# Solving problem 2\n", + "(out_dict_force_l1, qp_force_l1, dofs_force_l1, status_force_l1) = (\n", + " quadcoil_objective_force_l1.solve_quadcoil(\n", + " *quadcoil_objective_force_l1.xs(aries_eq)\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ebd2e599-d8ba-477a-b1d8-3f5763afec85", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axs = plt.subplots(1, 2, figsize=(8, 4))\n", + "axs[0].contour(Phi_with_net_current(qp_best_case, dofs_best_case), levels=20)\n", + "axs[0].set_title(r\"Lowest $\\chi^2_B$ filament\")\n", + "axs[1].contour(Phi_with_net_current(qp_force_l1, dofs_force_l1), levels=20)\n", + "axs[1].set_title(r\"Low force filament\")\n", + "print(\"Reference case chi^2_B: \", f_B(qp_best_case, dofs_best_case))\n", + "print(\"Low-force filament chi^2_B:\", f_B(qp_force_l1, dofs_force_l1))\n", + "print(\"Reference case L-1 force: \", f_l1_force_cyl(qp_best_case, dofs_best_case))\n", + "print(\"Low-force filament L-1 force:\", f_l1_force_cyl(qp_force_l1, dofs_force_l1))" + ] + }, + { + "cell_type": "markdown", + "id": "be00683e-24ec-43e9-8071-ef4ae5acfc95", + "metadata": {}, + "source": [ + "## 4. Quasi-single-stage optimization\n", + "This is a reproduction of the quasi-single-stage force optimization\n", + "in [2]." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb749359-3ae3-4bed-a5e7-4e53d04dfe1a", + "metadata": {}, + "outputs": [], + "source": [ + "aries_eq.iota = aries_eq.get_profile(\"iota\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce98a4e4-f26d-45bc-90a7-810bb492547c", + "metadata": {}, + "outputs": [], + "source": [ + "# Quasi-single-stage with continuation\n", + "def quasi_single_stage(\n", + " init_eq,\n", + " file_name,\n", + " quadcoil_kwargs_obj,\n", + " quadcoil_unit, # unit of metric\n", + " metric_name,\n", + " quadcoil_weight=0.0,\n", + " vol_weight=0.0,\n", + " qs_weight=1.0,\n", + " maxiter=30, # Maximum iteration per Fourier continuation\n", + " max_k=None, # Maximum continuation boundary mode number\n", + " printout=False, # Whether to run dummy optimization even when data exists for printout.\n", + "):\n", + "\n", + " # ----- Calculating targets -----\n", + " # Equilibrium optimization targets in this examples are\n", + " # calculated from the initial state, so that the QUADCOIL\n", + " # proxy is minimized while maintaining other plasma parameters.\n", + " # Building grids\n", + " # Volume\n", + " vol = init_eq.compute([\"V\"])[\"V\"]\n", + " eqfam = EquilibriaFamily(init_eq)\n", + " # # Triple product QS\n", + " qs_objective_init = QuasisymmetryTripleProduct(\n", + " init_eq,\n", + " )\n", + " qs_objective_init.build()\n", + " qs_bound = jnp.abs(\n", + " qs_objective_init.compute(*qs_objective_init.xs(init_eq))\n", + " / qs_objective_init.normalization\n", + " )\n", + "\n", + " out_list = []\n", + "\n", + " # ----- Fourier continuation -----\n", + " if not max_k:\n", + " max_k = init_eq.M + 1\n", + " else:\n", + " max_k = min(max_k, init_eq.M + 1)\n", + " k_list = range(3, init_eq.M + 1)\n", + " print(\"Boundary mode steps:\", k_list)\n", + " for i in range(len(k_list)):\n", + " k = k_list[i]\n", + " filename_eq = file_name + \"_eq_\" + str(k) + \".h5\"\n", + " filename_qf = file_name + \"_qf_\" + str(k) + \".h5\"\n", + " filename_time = file_name + \"_time_\" + str(k) + \".npy\"\n", + " filename_history = file_name + \"_history_\" + str(k) + \".pickle\"\n", + " filename_log = file_name + \"_log_\" + str(k) + \".txt\"\n", + "\n", + " # ----- Objectives -----\n", + " init_eq_k = eqfam[-1].copy()\n", + " qs_objective = QuasisymmetryTripleProduct(\n", + " eq=init_eq_k,\n", + " bounds=(-qs_bound, qs_bound),\n", + " normalize_target=False,\n", + " weight=qs_weight,\n", + " )\n", + " qs_objective.build()\n", + " obj_list_base = [\n", + " Volume(\n", + " eq=init_eq_k,\n", + " target=vol,\n", + " weight=vol_weight,\n", + " ),\n", + " qs_objective,\n", + " ]\n", + " # ----- Constraints -----\n", + " # as opposed to SIMSOPT and STELLOPT where variables are assumed fixed, in DESC\n", + " # we assume variables are free. Here we decide which ones to fix, starting with\n", + " # the major radius (R mode = [0,0,0]) and all modes with m,n > k\n", + " R_modes = np.vstack(\n", + " (\n", + " [0, 0, 0],\n", + " init_eq.surface.R_basis.modes[\n", + " np.max(np.abs(init_eq.surface.R_basis.modes), 1) > k, :\n", + " ],\n", + " )\n", + " )\n", + " Z_modes = init_eq.surface.Z_basis.modes[\n", + " np.max(np.abs(init_eq.surface.Z_basis.modes), 1) > k, :\n", + " ]\n", + " # next we create the constraints, using the mode number arrays just created\n", + " # if we didn't pass those in, it would fix all the modes (like for the profiles)\n", + " constraints_base = [\n", + " ForceBalance(eq=init_eq_k),\n", + " FixBoundaryR(eq=init_eq_k, modes=R_modes),\n", + " FixBoundaryZ(eq=init_eq_k, modes=Z_modes),\n", + " FixPsi(init_eq_k),\n", + " FixPressure(init_eq_k),\n", + " # Equilibrium is now loaded with fixed iota because we don't\n", + " # care about enforcing vacuum field any more.\n", + " FixIota(init_eq_k),\n", + " ]\n", + " # QS objective\n", + " # Mostly used in quasi-single-stage but also\n", + " # used to get single-stage init guess\n", + " quadcoil_objective_new = QuadcoilProxy(\n", + " eq=init_eq_k,\n", + " quadcoil_kwargs=quadcoil_kwargs_obj,\n", + " metric_name=(metric_name,),\n", + " metric_target=np.array(\n", + " [\n", + " 0.0,\n", + " ]\n", + " ),\n", + " metric_weight=np.array(\n", + " [\n", + " quadcoil_weight / quadcoil_unit,\n", + " ]\n", + " ),\n", + " normalize=False,\n", + " normalize_target=False,\n", + " name=\"QUADCOIL Proxy\",\n", + " enable_net_current_plasma=True,\n", + " vacuum=False,\n", + " )\n", + " quadcoil_objective_new.build()\n", + " objective = ObjectiveFunction(obj_list_base + [quadcoil_objective_new])\n", + " constraints = constraints_base\n", + " # ----- Performing optimization -----\n", + " try:\n", + " # Run continuation step if the save file does not exist\n", + " if not (os.path.exists(filename_history) and os.path.exists(filename_eq)):\n", + " print(\"\\n==================================\")\n", + " print(\"Optimizing boundary modes M,N <= {}\".format(k))\n", + " print(\"====================================\")\n", + " time1 = time.time()\n", + " optimizer = Optimizer(\"proximal-lsq-auglag\")\n", + " eq_new, out = init_eq_k.optimize(\n", + " objective=objective,\n", + " constraints=constraints,\n", + " optimizer=optimizer,\n", + " maxiter=maxiter,\n", + " verbose=3,\n", + " ftol=1e-5,\n", + " copy=True,\n", + " )\n", + " # Printing continuation stage result\n", + " qs_objective1 = qs_objective.compute_scalar(*qs_objective.xs(init_eq_k))\n", + " quadcoil_objective_new1 = quadcoil_objective_new.compute_scalar(\n", + " *quadcoil_objective_new.xs(init_eq_k)\n", + " )\n", + " qs_objective2 = qs_objective.compute_scalar(*qs_objective.xs(eq_new))\n", + " quadcoil_objective_new2 = quadcoil_objective_new.compute_scalar(\n", + " *quadcoil_objective_new.xs(eq_new)\n", + " )\n", + " print(\"Pre-optimization QS value:\", qs_objective1)\n", + " print(\"Pre-optimization quadcoil value:\", quadcoil_objective_new1)\n", + " print(\"Post-optimization QS value:\", qs_objective2)\n", + " print(\"Post-optimization quadcoil value:\", quadcoil_objective_new2)\n", + " time2 = time.time()\n", + " jnp.save(filename_time, time2 - time1)\n", + " eq_new.save(filename_eq)\n", + " # Its important to use binary mode\n", + " with open(filename_history, \"wb\") as dbfile: # 'wb' = write binary\n", + " pickle.dump(out, dbfile)\n", + " with open(filename_log, \"w\") as f:\n", + " f.write(\"Pre-optimization QS value:\" + str(qs_objective1))\n", + " f.write(\n", + " \"Pre-optimization quadcoil value:\"\n", + " + str(quadcoil_objective_new1)\n", + " )\n", + " f.write(\"Post-optimization QS value:\" + str(qs_objective2))\n", + " f.write(\n", + " \"Post-optimization quadcoil value:\"\n", + " + str(quadcoil_objective_new2)\n", + " )\n", + " f.write(\"=== Optimization Result ===\\n\")\n", + " f.write(pformat(dict(out), indent=2))\n", + " f.write(\"\\n\")\n", + " # Load continuation step if the save file exists\n", + " else:\n", + " print(\"Step\", k, \"exists.\")\n", + " if printout and i == len(k_list) - 1:\n", + " print(\"Still running a dummy optimization to print out stuff.\")\n", + " optimizer = Optimizer(\"proximal-lsq-auglag\")\n", + " eq_new, out = init_eq_k.optimize(\n", + " objective=objective,\n", + " constraints=constraints,\n", + " optimizer=optimizer,\n", + " maxiter=1,\n", + " verbose=3,\n", + " ftol=1e-5,\n", + " copy=True,\n", + " )\n", + " eq_new = desc.io.load(filename_eq, file_format=\"hdf5\")\n", + " with open(filename_history, \"rb\") as dbfile: # 'wb' = write binary\n", + " out = pickle.load(dbfile)\n", + "\n", + " eqfam.append(eq_new)\n", + " out_list.append(out)\n", + " eqfam.save(file_name + \"_eqfam_\" + \".h5\")\n", + " except KeyboardInterrupt:\n", + " break\n", + " (_, _, dofs_init, status_init) = quadcoil_objective_new.solve_quadcoil(\n", + " *quadcoil_objective_new.xs(eq_new)\n", + " )\n", + "\n", + " return eqfam, out_list, quadcoil_objective_new" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "20aa06ba-14dc-4d95-8470-424e8cedcd3f", + "metadata": {}, + "outputs": [], + "source": [ + "# Directory for saving data\n", + "data_dir = \"data_aries_force\"\n", + "os.makedirs(data_dir, exist_ok=True)\n", + "init_eq = aries_eq.copy()\n", + "\n", + "# Weights\n", + "quadcoil_weight = 10.0 # 5. # 50. -> 90% improvement, 10x degradation in QS\n", + "qs_weight = 500 # Good for muse: 5000.\n", + "vol_weight = 30.0\n", + "\n", + "# Running fourier continuation\n", + "eqfam_force_l1, out_list_force_l1, quadcoil_objective_force_l1 = quasi_single_stage(\n", + " init_eq=init_eq,\n", + " file_name=data_dir + \"/\" + \"f_force_l1\",\n", + " quadcoil_kwargs_obj=quadcoil_kwargs_force_l1,\n", + " quadcoil_unit=f_l1_force_cyl_unit, # unit of metric\n", + " metric_name=\"f_l1_force_cyl\",\n", + " quadcoil_weight=quadcoil_weight,\n", + " qs_weight=qs_weight,\n", + " vol_weight=vol_weight,\n", + ")\n", + "new_eq = eqfam_force_l1[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ce1214e-f4ed-4b81-9b6b-a00b1ab8c2f3", + "metadata": {}, + "outputs": [], + "source": [ + "# Compute quadcoil solution and compare with\n", + "(out_dict_aries_l1, qp_aries_l1, dofs_aries_l1, status_aries_l1) = (\n", + " quadcoil_objective_force_l1.solve_quadcoil(\n", + " *quadcoil_objective_force_l1.xs(aries_eq)\n", + " )\n", + ")\n", + "(out_dict_d, qp_d, dofs_d, status_d) = quadcoil_objective_force_l1.solve_quadcoil(\n", + " *quadcoil_objective_force_l1.xs(new_eq)\n", + ")\n", + "print(\"ARIES-CS L1 force: \", out_dict_aries_l1[\"f_l1_force_cyl\"])\n", + "print(\"New equilibrium L1 force:\", out_dict_d[\"f_l1_force_cyl\"])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "desc", + "language": "python", + "name": "desc" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/test_objective_funs.py b/tests/test_objective_funs.py index 58078349bb..0eb957ff19 100644 --- a/tests/test_objective_funs.py +++ b/tests/test_objective_funs.py @@ -40,6 +40,7 @@ SplineMagneticField, ToroidalMagneticField, VerticalMagneticField, + solve_regularized_surface_current, ) from desc.objectives import ( AspectRatio, @@ -80,6 +81,7 @@ PlasmaVesselDistance, Pressure, PrincipalCurvature, + QuadcoilProxy, QuadraticFlux, QuasisymmetryBoozer, QuasisymmetryTripleProduct, @@ -494,6 +496,163 @@ def test(eq): test(Equilibrium(iota=PowerSeriesProfile(0))) test(Equilibrium(current=PowerSeriesProfile(0))) + @pytest.mark.unit + def test_quadcoil(self): + """Test the QUADCOIL proxy.""" + # Setting testing thresholds + # 5% normalized error in Phi Fourier coefficients + thres_phi = 0.01 + thres_G = 0.001 # to be decreased + + # ----- Test 1: NESCOIL, value only ----- + def run_regcoil(vacuum): + # Loading equilibrium and resolutions + # ARIES-CS + if not vacuum: + quadcoil_test_eq = desc.examples.get("ARIES-CS") + else: + quadcoil_test_eq = desc.examples.get("precise_QA") + + # Settings + mpol = 8 # Num. poloidal modes in the current potential + ntor = 8 # Num. toroidal modes in the current potential + # Controls the resolution of the plasma surface integration. + # Integration in quadcoil is naively performed using summation + # so we recommend at least 16 here. + # This corresponds to a (33 x 33) grid. + minor_radius = quadcoil_test_eq.compute("a")["a"] + plasma_coil_distance = minor_radius * 0.75 + # Resolution for sampling objectives + quadpoints_phi = jnp.linspace( + 0, 1 / quadcoil_test_eq.NFP, 33, endpoint=False + ) + quadpoints_theta = jnp.linspace(0, 1, 33, endpoint=False) + quadcoil_kwargs_basic = { + "mpol": mpol, + "ntor": ntor, + "quadpoints_phi": quadpoints_phi, + "quadpoints_theta": quadpoints_theta, + "plasma_coil_distance": plasma_coil_distance, + } + quadcoil_kwargs_nescoil = quadcoil_kwargs_basic | { + "objective_name": "f_B", # The NESCOIL problem only contains + # The NESCOIL problem is simple enough to need no normalization + # constants. In the next example we will discuss how to choose + # this constant. + "objective_unit": None, + } + from desc.objectives import QuadcoilProxy + + # Define a QuadcoilProxy with the simplest possible + # signature + objective_nescoil = QuadcoilProxy( + eq=quadcoil_test_eq, + quadcoil_kwargs=quadcoil_kwargs_nescoil, + vacuum=vacuum, + ) + objective_nescoil.build() + scf_nescoil = objective_nescoil.solve_quadcoil_surface_current_field( + # Like Objective.compute(), the xs of the equilibrium + # must be passed in as the *arg. + *objective_nescoil.xs(quadcoil_test_eq) + ) + source_grid = objective_nescoil.constants["source_grid"] + eval_grid = objective_nescoil.constants["eval_grid"] + fields, data = solve_regularized_surface_current( + scf_nescoil, + eq=quadcoil_test_eq, + source_grid=source_grid, + eval_grid=eval_grid, + current_helicity=( + 1, + 0, + ), + lambda_regularization=jnp.array([0]), + vacuum=vacuum, + regularization_type="regcoil", + chunk_size=40, + ) + # Comparing Phi coefficients + phi1 = fields[0].compute("Phi")["Phi"] + phi2 = scf_nescoil.compute("Phi")["Phi"] + norm_error = jnp.average(jnp.abs(phi1 - phi2)) / jnp.max(jnp.abs(phi1)) + assert norm_error <= thres_phi + # Testing net poloidal current + assert np.abs(scf_nescoil.G - fields[0].G) <= np.abs(thres_G * fields[0].G) + # Solving the NESCOIL problem using DESC's built in REGCOIL. + # Please see the REGCOIL-like coil optimization tutorial + fields_regcoil, data_regcoil = solve_regularized_surface_current( + scf_nescoil, + eq=quadcoil_test_eq, + source_grid=objective_nescoil.constants["source_grid"], + eval_grid=objective_nescoil.constants["eval_grid"], + current_helicity=( + 1, + 0, + ), + lambda_regularization=jnp.array([1e-15]), + vacuum=vacuum, + regularization_type="regcoil", + chunk_size=40, + ) + obj_flux = QuadraticFlux( + field=fields[0], + eq=quadcoil_test_eq, + eval_grid=objective_nescoil.constants["eval_grid"], + field_grid=objective_nescoil.constants["source_grid"], + vacuum=False, + bs_chunk_size=10, + normalize=False, + normalize_target=False, + ) + obj_flux.build() + chi_2_B_regcoil = obj_flux.compute_scalar(*obj_flux.xs(fields_regcoil[0])) + obj_regularization = SurfaceCurrentRegularization( + surface_current_field=fields[0], + source_grid=objective_nescoil.constants["source_grid"], + weight=1, + normalize=False, + # don't use normalizations, to match the REGCOIL problem exactly + normalize_target=False, + ) # we will set it to the sqrt of optimal weight from above, + # since DESC will square the weight when making the overall cost fxn + obj_regularization.build() + chi_2_K_regcoil = obj_regularization.compute_scalar( + *obj_regularization.xs(fields_regcoil[0]) + ) + C_B = chi_2_B_regcoil / (4 * jnp.pi**2) + C_K = chi_2_K_regcoil / (4 * jnp.pi**2) + quadcoil_kwargs_regcoil = quadcoil_kwargs_basic | { + "objective_name": "f_K", + "objective_unit": C_K, + "constraint_name": ("f_B",), + "constraint_type": ("<=",), + "constraint_value": jnp.array([C_B]), + "constraint_unit": jnp.array([C_B]), + } + # Define a QuadcoilProxy with the simplest possible + # signature. + objective_regcoil = QuadcoilProxy( + eq=quadcoil_test_eq, + quadcoil_kwargs=quadcoil_kwargs_regcoil, + vacuum=vacuum, + ) + objective_regcoil.build() + scf_regcoil = objective_regcoil.solve_quadcoil_surface_current_field( + # Like Objective.compute(), the xs of the equilibrium + # must be passed in as the *arg. + *objective_regcoil.xs(quadcoil_test_eq) + ) + phi1_regcoil = fields_regcoil[0].compute("Phi")["Phi"] + phi2_regcoil = scf_regcoil.compute("Phi")["Phi"] + norm_error = jnp.average(jnp.abs(phi1_regcoil - phi2_regcoil)) / jnp.max( + jnp.abs(phi1_regcoil) + ) + assert norm_error <= thres_phi + + run_regcoil(True) + run_regcoil(False) + @pytest.mark.unit def test_isodynamicity(self): """Test calculation of isodynamicity metric.""" @@ -3273,6 +3432,7 @@ class TestComputeScalarResolution: PlasmaCoilSetMinDistance, PlasmaVesselDistance, QuadraticFlux, + QuadcoilProxy, SurfaceQuadraticFlux, ToroidalFlux, SurfaceCurrentRegularization, @@ -3766,6 +3926,7 @@ class TestObjectiveNaNGrad: PlasmaCoilSetMinDistance, PlasmaVesselDistance, QuadraticFlux, + QuadcoilProxy, SurfaceCurrentRegularization, SurfaceQuadraticFlux, ToroidalFlux,