From 44694f5ba69a0aeb3c44f7a705eb85981c2fcaef Mon Sep 17 00:00:00 2001 From: malfarhan7 Date: Sat, 26 Oct 2024 12:23:45 +0300 Subject: [PATCH 1/9] Implement snapshotting for the acoustic wave equation --- examples/seismic/acoustic/operators.py | 89 +++++++++++++++++++------ examples/seismic/acoustic/wavesolver.py | 66 +++++++++++++----- examples/seismic/utils.py | 2 + 3 files changed, 122 insertions(+), 35 deletions(-) diff --git a/examples/seismic/acoustic/operators.py b/examples/seismic/acoustic/operators.py index c8a2fdec5c..ac3210a6f3 100644 --- a/examples/seismic/acoustic/operators.py +++ b/examples/seismic/acoustic/operators.py @@ -1,4 +1,4 @@ -from devito import Eq, Operator, Function, TimeFunction, Inc, solve, sign +from devito import Eq, Operator, Function, TimeFunction, Inc, solve, sign, ConditionalDimension from devito.symbolics import retrieve_functions, INT, retrieve_derivatives @@ -108,7 +108,7 @@ def iso_stencil(field, model, kernel, **kwargs): def ForwardOperator(model, geometry, space_order=4, - save=False, kernel='OT2', **kwargs): + save=False, kernel='OT2', factor=None, **kwargs): """ Construct a forward modelling operator in an acoustic medium. @@ -126,6 +126,8 @@ def ForwardOperator(model, geometry, space_order=4, Defaults to False. kernel : str, optional Type of discretization, 'OT2' or 'OT4'. + factor : int, optional + Downsampling factor to save snapshots of the wavefield. """ m = model.m @@ -144,10 +146,28 @@ def ForwardOperator(model, geometry, space_order=4, # Create interpolation expression for receivers rec_term = rec.interpolate(expr=u) - + # Build operator equations + equations = eqn + src_term + rec_term + + if factor: + # Implement snapshotting + nsnaps = (geometry.nt + factor - 1) // factor + time_subsampled = ConditionalDimension( + 't_sub', parent=model.grid.time_dim, factor=factor) + usnaps = TimeFunction(name='usnaps', grid=model.grid, + time_order=2, space_order=space_order, + save=nsnaps, time_dim=time_subsampled) + # Add equation to save snapshots + snapshot_eq = Eq(usnaps, u) + equations += [snapshot_eq] + else: + usnaps = None # Substitute spacing terms to reduce flops - return Operator(eqn + src_term + rec_term, subs=model.spacing_map, - name='Forward', **kwargs) + op = Operator(equations, subs=model.spacing_map, name='Forward', **kwargs) + if usnaps is not None: + return op, usnaps + else: + return op def AdjointOperator(model, geometry, space_order=4, @@ -189,8 +209,8 @@ def AdjointOperator(model, geometry, space_order=4, def GradientOperator(model, geometry, space_order=4, save=True, - kernel='OT2', **kwargs): - """ + kernel='OT2', factor=None, **kwargs): + """ Construct a gradient operator in an acoustic media. Parameters @@ -206,30 +226,59 @@ def GradientOperator(model, geometry, space_order=4, save=True, Option to store the entire (unrolled) wavefield. kernel : str, optional Type of discretization, centered or shifted. + factor : int, optional + Downsampling factor to save snapshots of the wavefield. """ m = model.m - # Gradient symbol and wavefield symbols + # Gradient symbol grad = Function(name='grad', grid=model.grid) - u = TimeFunction(name='u', grid=model.grid, save=geometry.nt if save - else None, time_order=2, space_order=space_order) - v = TimeFunction(name='v', grid=model.grid, save=None, - time_order=2, space_order=space_order) - rec = geometry.rec + + # Create the adjoint wavefield + v = TimeFunction(name='v', grid=model.grid, time_order=2, space_order=space_order) s = model.grid.stepping_dim.spacing eqn = iso_stencil(v, model, kernel, forward=False) - if kernel == 'OT2': - gradient_update = Inc(grad, - u * v.dt2) - elif kernel == 'OT4': - gradient_update = Inc(grad, - u * v.dt2 - s**2 / 12.0 * u.biharmonic(m**(-2)) * v) # Add expression for receiver injection + rec = geometry.rec receivers = rec.inject(field=v.backward, expr=rec * s**2 / m) + time = model.grid.time_dim + + if factor is not None: + # Condition to apply gradient update only at snapshot times + condition = Eq(time % factor, 0) + # Create the ConditionalDimension for subsampling + time_subsampled = ConditionalDimension('t_sub', parent=time, factor=factor) + # Define usnaps with time_subsampled as its time dimension + nsnaps = (geometry.nt + factor - 1) // factor + usnaps = TimeFunction(name='usnaps', grid=model.grid, + time_order=2, space_order=space_order, + save=nsnaps, time_dim=time_subsampled) + # Gradient update without indexing usnaps + if kernel == 'OT2': + gradient_update = Inc(grad, - usnaps * v.dt2, implicit_dims=[time_subsampled], + condition=condition) + elif kernel == 'OT4': + gradient_update = Inc(grad, - usnaps * v.dt2 + - s**2 / 12.0 * usnaps.biharmonic(m**(-2)) * v, + implicit_dims=[time_subsampled], + condition=condition) + else: + u = TimeFunction(name='u', grid=model.grid, + save=geometry.nt if save else None, + time_order=2, space_order=space_order) + if kernel == 'OT2': + gradient_update = Inc(grad, - u * v.dt2) + elif kernel == 'OT4': + gradient_update = Inc(grad, - u * v.dt2 + - s**2 / 12.0 * u.biharmonic(m**(-2)) * v) + # Substitute spacing terms to reduce flops - return Operator(eqn + receivers + [gradient_update], subs=model.spacing_map, - name='Gradient', **kwargs) + op = Operator(eqn + receivers + [gradient_update], subs=model.spacing_map, + name='Gradient', **kwargs) + return op def BornOperator(model, geometry, space_order=4, @@ -274,4 +323,4 @@ def BornOperator(model, geometry, space_order=4, # Substitute spacing terms to reduce flops return Operator(eqn1 + source + eqn2 + receivers, subs=model.spacing_map, - name='Born', **kwargs) + name='Born', **kwargs) \ No newline at end of file diff --git a/examples/seismic/acoustic/wavesolver.py b/examples/seismic/acoustic/wavesolver.py index e191b34972..b1feaef9de 100644 --- a/examples/seismic/acoustic/wavesolver.py +++ b/examples/seismic/acoustic/wavesolver.py @@ -1,6 +1,6 @@ from devito import Function, TimeFunction, DevitoCheckpoint, CheckpointOperator, Revolver from devito.tools import memoized_meth -from examples.seismic.acoustic.operators import ( +from devitofwi.devito.acoustic.operators import ( ForwardOperator, AdjointOperator, GradientOperator, BornOperator ) @@ -23,6 +23,7 @@ class AcousticWaveSolver: space_order: int, optional Order of the spatial stencil discretisation. Defaults to 4. """ + def __init__(self, model, geometry, kernel='OT2', space_order=4, **kwargs): self.model = model self.model._initialize_bcs(bcs="damp") @@ -44,11 +45,11 @@ def dt(self): return self.model.critical_dt @memoized_meth - def op_fwd(self, save=None): + def op_fwd(self, save=None, factor=None): """Cached operator for forward runs with buffered wavefield""" return ForwardOperator(self.model, save=save, geometry=self.geometry, kernel=self.kernel, space_order=self.space_order, - **self._kwargs) + factor=factor, **self._kwargs) @memoized_meth def op_adj(self): @@ -58,11 +59,11 @@ def op_adj(self): **self._kwargs) @memoized_meth - def op_grad(self, save=True): + def op_grad(self, save=True, factor=None): """Cached operator for gradient runs""" return GradientOperator(self.model, save=save, geometry=self.geometry, kernel=self.kernel, space_order=self.space_order, - **self._kwargs) + factor=factor, **self._kwargs) @memoized_meth def op_born(self): @@ -71,7 +72,7 @@ def op_born(self): kernel=self.kernel, space_order=self.space_order, **self._kwargs) - def forward(self, src=None, rec=None, u=None, model=None, save=None, **kwargs): + def forward(self, src=None, rec=None, u=None, model=None, save=None, factor=None, **kwargs): """ Forward modelling function that creates the necessary data objects for running a forward modelling operator. @@ -90,6 +91,8 @@ def forward(self, src=None, rec=None, u=None, model=None, save=None, **kwargs): The time-constant velocity. save : bool, optional Whether or not to save the entire (unrolled) wavefield. + factor : int, optional + Downsampling factor to save snapshots of the wavefield. Returns ------- @@ -108,12 +111,24 @@ def forward(self, src=None, rec=None, u=None, model=None, save=None, **kwargs): model = model or self.model # Pick vp from model unless explicitly provided kwargs.update(model.physical_params(**kwargs)) + # Get the operator + op_fwd = self.op_fwd(save=save, factor=factor) + # Prepare parameters for operator apply + op_args = {'src': src, 'rec': rec, 'u': u, 'dt': kwargs.pop('dt', self.dt)} + op_args.update(kwargs) # Execute operator and return wavefield and receiver data - summary = self.op_fwd(save).apply(src=src, rec=rec, u=u, - dt=kwargs.pop('dt', self.dt), **kwargs) - - return rec, u, summary + if factor: + # Operator returned is op, usnaps + op, usnaps = op_fwd + op_args['usnaps'] = usnaps + summary = op.apply(**op_args) + + else: + op = op_fwd + usnaps = None + summary = op.apply(**op_args) + return rec, u, usnaps, summary def adjoint(self, rec, srca=None, v=None, model=None, **kwargs): """ @@ -155,8 +170,8 @@ def adjoint(self, rec, srca=None, v=None, model=None, **kwargs): dt=kwargs.pop('dt', self.dt), **kwargs) return srca, v, summary - def jacobian_adjoint(self, rec, u, src=None, v=None, grad=None, model=None, - checkpointing=False, **kwargs): + def jacobian_adjoint(self, rec, u=None, usnaps=None, src=None, v=None, grad=None, model=None, + factor=None, checkpointing=False, **kwargs): """ Gradient modelling function for computing the adjoint of the Linearized Born modelling function, ie. the action of the @@ -168,6 +183,8 @@ def jacobian_adjoint(self, rec, u, src=None, v=None, grad=None, model=None, Receiver data. u : TimeFunction Full wavefield `u` (created with save=True). + usnaps : TimeFunction + Snapshots of the wavefield `u`. v : TimeFunction, optional Stores the computed wavefield. grad : Function, optional @@ -176,12 +193,22 @@ def jacobian_adjoint(self, rec, u, src=None, v=None, grad=None, model=None, Object containing the physical parameters. vp : Function or float, optional The time-constant velocity. + checkpointing : boolean, optional + Flag to enable checkpointing (default False). + Cannot be used with snapshotting. + factor : int, optional + Downsampling factor for the saved snapshots of the wavefield `u`. + Cannot be used with checkpointing. Returns ------- Gradient field and performance summary. """ dt = kwargs.pop('dt', self.dt) + # Check that snapshotting and checkpointing are not used together + if factor is not None and checkpointing: + raise ValueError("Cannot use snapshotting (factor) and checkpointing simultaneously.") + # Gradient symbol grad = grad or Function(name='grad', grid=self.model.grid) @@ -209,8 +236,17 @@ def jacobian_adjoint(self, rec, u, src=None, v=None, grad=None, model=None, wrp.apply_forward() summary = wrp.apply_reverse() else: - summary = self.op_grad().apply(rec=rec, grad=grad, v=v, u=u, dt=dt, - **kwargs) + if factor is not None: + # Get the gradient operator + op = self.op_grad(save=False, factor=factor) + op_args = {'rec': rec, 'grad': grad, 'v': v, 'dt': dt, 'usnaps': usnaps} + else: + op = self.op_grad(save=True, factor=None) + op_args = {'rec': rec, 'grad': grad, 'v': v, 'dt': dt, 'u': u} + + op_args.update(kwargs) + summary = op.apply(**op_args) + return grad, summary def jacobian(self, dmin, src=None, rec=None, u=None, U=None, model=None, **kwargs): @@ -255,4 +291,4 @@ def jacobian(self, dmin, src=None, rec=None, u=None, U=None, model=None, **kwarg # Backward compatibility born = jacobian - gradient = jacobian_adjoint + gradient = jacobian_adjoint \ No newline at end of file diff --git a/examples/seismic/utils.py b/examples/seismic/utils.py index 6491d9ca5a..b9911381e8 100644 --- a/examples/seismic/utils.py +++ b/examples/seismic/utils.py @@ -264,4 +264,6 @@ def __call__(self, parser, args, values, option_string=None): choices=['float32', 'float64']) parser.add_argument("-interp", dest="interp", default="linear", choices=['linear', 'sinc']) + parser.add_argument("--factor", type=int, default=None, + help="Downsampling factor to use snapshotting, default is None") return parser From 02be5b330253074d9ee604776cbf041f1b474a48 Mon Sep 17 00:00:00 2001 From: malfarhan7 Date: Tue, 5 Nov 2024 10:08:00 +0300 Subject: [PATCH 2/9] Clean up snapshotting code --- examples/seismic/acoustic/operators.py | 96 ++++++++++--------------- examples/seismic/acoustic/wavesolver.py | 56 ++++++--------- 2 files changed, 58 insertions(+), 94 deletions(-) diff --git a/examples/seismic/acoustic/operators.py b/examples/seismic/acoustic/operators.py index ac3210a6f3..eb927fdfb6 100644 --- a/examples/seismic/acoustic/operators.py +++ b/examples/seismic/acoustic/operators.py @@ -106,6 +106,14 @@ def iso_stencil(field, model, kernel, **kwargs): eqns.append(freesurface(model, Eq(unext, eq_time))) return eqns +def create_snapshot_time_function(model, name, geometry, space_order, factor, save=True): + nsnaps = (geometry.nt + factor - 1) // factor + time_subsampled = ConditionalDimension('t_sub', + parent=model.grid.time_dim, factor=factor) + u_ = TimeFunction(name=name, grid=model.grid, + time_order=2, space_order=space_order, + save=nsnaps if save else None, time_dim=time_subsampled) + return u_ def ForwardOperator(model, geometry, space_order=4, save=False, kernel='OT2', factor=None, **kwargs): @@ -133,8 +141,9 @@ def ForwardOperator(model, geometry, space_order=4, # Create symbols for forward wavefield, source and receivers u = TimeFunction(name='u', grid=model.grid, - save=geometry.nt if save else None, + save=geometry.nt if save and factor is None else None, time_order=2, space_order=space_order) + src = geometry.src rec = geometry.rec @@ -146,28 +155,18 @@ def ForwardOperator(model, geometry, space_order=4, # Create interpolation expression for receivers rec_term = rec.interpolate(expr=u) + # Build operator equations equations = eqn + src_term + rec_term if factor: - # Implement snapshotting - nsnaps = (geometry.nt + factor - 1) // factor - time_subsampled = ConditionalDimension( - 't_sub', parent=model.grid.time_dim, factor=factor) - usnaps = TimeFunction(name='usnaps', grid=model.grid, - time_order=2, space_order=space_order, - save=nsnaps, time_dim=time_subsampled) # Add equation to save snapshots + usnaps = create_snapshot_time_function(model, 'usnaps', geometry, space_order, factor) snapshot_eq = Eq(usnaps, u) equations += [snapshot_eq] - else: - usnaps = None + # Substitute spacing terms to reduce flops - op = Operator(equations, subs=model.spacing_map, name='Forward', **kwargs) - if usnaps is not None: - return op, usnaps - else: - return op + return Operator(equations, subs=model.spacing_map, name='Forward', **kwargs) def AdjointOperator(model, geometry, space_order=4, @@ -210,8 +209,8 @@ def AdjointOperator(model, geometry, space_order=4, def GradientOperator(model, geometry, space_order=4, save=True, kernel='OT2', factor=None, **kwargs): - """ - Construct a gradient operator in an acoustic media. + """ + Construct a gradient operator in an acoustic medium. Parameters ---------- @@ -231,54 +230,33 @@ def GradientOperator(model, geometry, space_order=4, save=True, """ m = model.m - # Gradient symbol + # Gradient symbol and wavefield symbols grad = Function(name='grad', grid=model.grid) - - # Create the adjoint wavefield - v = TimeFunction(name='v', grid=model.grid, time_order=2, space_order=space_order) + if factor: # Apply the imaging condition at the snapshots of the full wavefield + u = create_snapshot_time_function(model, 'u', geometry, space_order, factor) + else:# Apply the imaging condition at every time step of the full wavefield + u = TimeFunction(name='u', grid=model.grid, + save=geometry.nt if save else None, + time_order=2, space_order=space_order) + v = TimeFunction(name='v', grid=model.grid, save=None, + time_order=2, space_order=space_order) + rec = geometry.rec s = model.grid.stepping_dim.spacing eqn = iso_stencil(v, model, kernel, forward=False) - - # Add expression for receiver injection - rec = geometry.rec + + if kernel == 'OT2': + gradient_update = Inc(grad, - u * v.dt2) + elif kernel == 'OT4': + gradient_update = Inc(grad, - u * v.dt2 + - s**2 / 12.0 * u.biharmonic(m**(-2)) * v) + + # Add expression for receiver injection receivers = rec.inject(field=v.backward, expr=rec * s**2 / m) - - time = model.grid.time_dim - - if factor is not None: - # Condition to apply gradient update only at snapshot times - condition = Eq(time % factor, 0) - # Create the ConditionalDimension for subsampling - time_subsampled = ConditionalDimension('t_sub', parent=time, factor=factor) - # Define usnaps with time_subsampled as its time dimension - nsnaps = (geometry.nt + factor - 1) // factor - usnaps = TimeFunction(name='usnaps', grid=model.grid, - time_order=2, space_order=space_order, - save=nsnaps, time_dim=time_subsampled) - # Gradient update without indexing usnaps - if kernel == 'OT2': - gradient_update = Inc(grad, - usnaps * v.dt2, implicit_dims=[time_subsampled], - condition=condition) - elif kernel == 'OT4': - gradient_update = Inc(grad, - usnaps * v.dt2 - - s**2 / 12.0 * usnaps.biharmonic(m**(-2)) * v, - implicit_dims=[time_subsampled], - condition=condition) - else: - u = TimeFunction(name='u', grid=model.grid, - save=geometry.nt if save else None, - time_order=2, space_order=space_order) - if kernel == 'OT2': - gradient_update = Inc(grad, - u * v.dt2) - elif kernel == 'OT4': - gradient_update = Inc(grad, - u * v.dt2 - - s**2 / 12.0 * u.biharmonic(m**(-2)) * v) - + # Substitute spacing terms to reduce flops - op = Operator(eqn + receivers + [gradient_update], subs=model.spacing_map, + return Operator(eqn + receivers + [gradient_update], subs=model.spacing_map, name='Gradient', **kwargs) - return op def BornOperator(model, geometry, space_order=4, @@ -323,4 +301,4 @@ def BornOperator(model, geometry, space_order=4, # Substitute spacing terms to reduce flops return Operator(eqn1 + source + eqn2 + receivers, subs=model.spacing_map, - name='Born', **kwargs) \ No newline at end of file + name='Born', **kwargs) diff --git a/examples/seismic/acoustic/wavesolver.py b/examples/seismic/acoustic/wavesolver.py index b1feaef9de..3f77e12611 100644 --- a/examples/seismic/acoustic/wavesolver.py +++ b/examples/seismic/acoustic/wavesolver.py @@ -1,7 +1,7 @@ from devito import Function, TimeFunction, DevitoCheckpoint, CheckpointOperator, Revolver from devito.tools import memoized_meth -from devitofwi.devito.acoustic.operators import ( - ForwardOperator, AdjointOperator, GradientOperator, BornOperator +from examples.seismic.acoustic.operators import ( + ForwardOperator, AdjointOperator, GradientOperator, BornOperator, create_snapshot_time_function ) @@ -100,35 +100,29 @@ def forward(self, src=None, rec=None, u=None, model=None, save=None, factor=None """ # Source term is read-only, so re-use the default src = src or self.geometry.src - # Create a new receiver object to store the result + # Create a new receiver object to store the result rec = rec or self.geometry.rec # Create the forward wavefield if not provided u = u or TimeFunction(name='u', grid=self.model.grid, - save=self.geometry.nt if save else None, - time_order=2, space_order=self.space_order) - + save=self.geometry.nt if save and factor is None else None, + time_order=2, space_order=self.space_order) + if factor: # Create snapshots of the forward wavefield + usnaps = create_snapshot_time_function(self.model, 'usnaps', self.geometry, self.space_order, factor) + model = model or self.model # Pick vp from model unless explicitly provided kwargs.update(model.physical_params(**kwargs)) - # Get the operator - op_fwd = self.op_fwd(save=save, factor=factor) - # Prepare parameters for operator apply - op_args = {'src': src, 'rec': rec, 'u': u, 'dt': kwargs.pop('dt', self.dt)} - op_args.update(kwargs) # Execute operator and return wavefield and receiver data - if factor: - # Operator returned is op, usnaps - op, usnaps = op_fwd - op_args['usnaps'] = usnaps - summary = op.apply(**op_args) - - else: - op = op_fwd - usnaps = None - summary = op.apply(**op_args) - return rec, u, usnaps, summary + if factor: # Return snapshots of the forward wavefield + summary = self.op_fwd(save, factor).apply(src=src, rec=rec, u=u, usnaps=usnaps, + dt=kwargs.pop('dt', self.dt), **kwargs) + return rec, usnaps, summary + else:# Return the full forward wavefield + summary = self.op_fwd(save, factor).apply(src=src, rec=rec, u=u, + dt=kwargs.pop('dt', self.dt), **kwargs) + return rec, u, summary def adjoint(self, rec, srca=None, v=None, model=None, **kwargs): """ @@ -160,7 +154,7 @@ def adjoint(self, rec, srca=None, v=None, model=None, **kwargs): # Create the adjoint wavefield if not provided v = v or TimeFunction(name='v', grid=self.model.grid, time_order=2, space_order=self.space_order) - + model = model or self.model # Pick vp from model unless explicitly provided kwargs.update(model.physical_params(**kwargs)) @@ -170,7 +164,7 @@ def adjoint(self, rec, srca=None, v=None, model=None, **kwargs): dt=kwargs.pop('dt', self.dt), **kwargs) return srca, v, summary - def jacobian_adjoint(self, rec, u=None, usnaps=None, src=None, v=None, grad=None, model=None, + def jacobian_adjoint(self, rec, u, src=None, v=None, grad=None, model=None, factor=None, checkpointing=False, **kwargs): """ Gradient modelling function for computing the adjoint of the @@ -236,16 +230,8 @@ def jacobian_adjoint(self, rec, u=None, usnaps=None, src=None, v=None, grad=None wrp.apply_forward() summary = wrp.apply_reverse() else: - if factor is not None: - # Get the gradient operator - op = self.op_grad(save=False, factor=factor) - op_args = {'rec': rec, 'grad': grad, 'v': v, 'dt': dt, 'usnaps': usnaps} - else: - op = self.op_grad(save=True, factor=None) - op_args = {'rec': rec, 'grad': grad, 'v': v, 'dt': dt, 'u': u} - - op_args.update(kwargs) - summary = op.apply(**op_args) + summary = self.op_grad(factor=factor).apply(rec=rec, grad=grad, v=v, u=u, dt=dt, + **kwargs) return grad, summary @@ -291,4 +277,4 @@ def jacobian(self, dmin, src=None, rec=None, u=None, U=None, model=None, **kwarg # Backward compatibility born = jacobian - gradient = jacobian_adjoint \ No newline at end of file + gradient = jacobian_adjoint From d9091558344ccb76d4850c5d20e582a1e43eedfe Mon Sep 17 00:00:00 2001 From: malfarhan7 Date: Tue, 5 Nov 2024 11:35:51 +0300 Subject: [PATCH 3/9] Add script to compute memory usage for full gradient. --- .../tutorials/Gradient_full_marmousi.py | 163 ++++++++++++++++++ 1 file changed, 163 insertions(+) create mode 100644 examples/seismic/tutorials/Gradient_full_marmousi.py diff --git a/examples/seismic/tutorials/Gradient_full_marmousi.py b/examples/seismic/tutorials/Gradient_full_marmousi.py new file mode 100644 index 0000000000..55fb6dab3f --- /dev/null +++ b/examples/seismic/tutorials/Gradient_full_marmousi.py @@ -0,0 +1,163 @@ +r''' +Memory profiling is performed to compute the memory usage when computing the gradient computation +using the full time axis. + +Memory-profiler run as: mprof run Gradient_full_marmousi.py; mprof plot +''' + +import numpy as np +import matplotlib.pyplot as plt +from scipy.ndimage import gaussian_filter +import scipy +from memory_profiler import memory_usage +from examples.seismic import plot_velocity, plot_perturbation, Model, AcquisitionGeometry, plot_shotrecord, Receiver, plot_image +from examples.seismic.acoustic import AcousticWaveSolver +from devito import configuration, Eq, Operator, Function, TimeFunction, norm, mmax + +configuration['log-level'] = 'WARNING' + +nshots = 30 # Number of shots to create gradient from +nreceivers = 300 # Number of receiver locations per shot + +# function to get water layer mask +def mask(model,value): + """ + Return a mask for the model (m) using the (value) + """ + mask = model > value + mask = mask.astype(int) + # mask[:21] = 0 + return mask + +# Define true and initial model +shape = (601, 221) # Number of grid point (nx, nz) +spacing = (15., 15.) # Grid spacing in m. The domain size is now 1km by 1km +origin = (0., 0.) # Need origin to define relative source and receiver locations +vel_path = '../../../devito/data/Marm.bin' +# Load the true model +model_true = (np.fromfile(vel_path, np.float32).reshape(221, 601)) +msk = mask(model_true, 1.5) +model_init = gaussian_filter(model_true, sigma=[10, 15]) +model_init = model_init * msk +model_init[model_init==0] = 1.5 # km/s + +model = Model(vp=model_true.T, origin=origin, shape=shape, spacing=spacing, + space_order=2, nbl=20, bcs="damp") +model0 = Model(vp=model_init.T, origin=origin, shape=shape, spacing=spacing, + space_order=2, nbl=20, bcs="damp", grid = model.grid) + +# plot_velocity(model) +# plot_velocity(model0) +# plot_perturbation(model0, model) + +assert model.grid == model0.grid +assert model.vp.grid == model0.vp.grid + +# Define acquisition geometry: source +t0 = 0. +tn = 4000. +f0 = 0.005 +# First, position source centrally in all dimensions, then set depth +src_coordinates = np.empty((1, 2)) +src_coordinates[0, :] = np.array(model.domain_size) * .5 +src_coordinates[0, -1] = 20. # Depth is 20m + +# Define acquisition geometry: receivers +# Initialize receivers for synthetic and imaging data +rec_coordinates = np.empty((nreceivers, 2)) +rec_coordinates[:, 0] = np.linspace(0, model.domain_size[0], num=nreceivers) +rec_coordinates[:, 1] = 20. + +# Geometry +geometry = AcquisitionGeometry(model, rec_coordinates, src_coordinates, t0, tn, f0=f0, src_type='Ricker') +# We can plot the time signature to see the wavelet +# geometry.src.show() + +# Plot acquisition geometry +# plot_velocity(model, source=geometry.src_positions, +# receiver=geometry.rec_positions[::4, :]) + +solver = AcousticWaveSolver(model, geometry, space_order=4) +true_d, u0, _ = solver.forward(vp=model.vp) + +# Compute initial data with forward operator +smooth_d, _, _ = solver.forward(vp=model0.vp) + +# Plot shot record for true and smooth velocity model and the difference +# plot_shotrecord(true_d.data, model, t0, tn) +# plot_shotrecord(smooth_d.data, model, t0, tn) +# plot_shotrecord(smooth_d.data - true_d.data, model, t0, tn) + +# Prepare the varying source locations sources +source_locations = np.empty((nshots, 2), dtype=np.float32) +source_locations[:, 0] = np.linspace(0., model.domain_size[0], num=nshots) +source_locations[:, 1] = 0 + +# plot_velocity(model, source=source_locations) + +# Computes the residual between observed and synthetic data into the residual +def compute_residual(residual, dobs, dsyn): + if residual.grid.distributor.is_parallel: + # If we run with MPI, we have to compute the residual via an operator + # First make sure we can take the difference and that receivers are at the + # same position + assert np.allclose(dobs.coordinates.data[:], dsyn.coordinates.data) + assert np.allclose(residual.coordinates.data[:], dsyn.coordinates.data) + # Create a difference operator + diff_eq = Eq(residual, dsyn.subs({dsyn.dimensions[-1]: residual.dimensions[-1]}) - + dobs.subs({dobs.dimensions[-1]: residual.dimensions[-1]})) + Operator(diff_eq)() + else: + # A simple data difference is enough in serial + residual.data[:] = dsyn.data[:] - dobs.data[:] + + return residual + +# Create FWI gradient kernel +def fwi_gradient(vp_in): + # Create symbols to hold the gradient + grad = Function(name="grad", grid=model.grid) + # Create placeholders for the data residual and data + residual = Receiver(name='residual', grid=model.grid, + time_range=geometry.time_axis, + coordinates=geometry.rec_positions) + d_obs = Receiver(name='d_obs', grid=model.grid, + time_range=geometry.time_axis, + coordinates=geometry.rec_positions) + d_syn = Receiver(name='d_syn', grid=model.grid, + time_range=geometry.time_axis, + coordinates=geometry.rec_positions) + objective = 0. + for i in range(nshots): + # Update source location + geometry.src_positions[0, :] = source_locations[i, :] + + # Generate synthetic data from true model + _, _, _ = solver.forward(vp=model.vp, rec=d_obs) + + # Compute smooth data and full forward wavefield u0 + _, u0, _ = solver.forward(vp=vp_in, save=True, rec=d_syn) + + # Compute gradient from data residual and update objective function + compute_residual(residual, d_obs, d_syn) + + objective += .5*norm(residual)**2 + solver.gradient(rec=residual, u=u0, vp=vp_in, grad=grad) + + return objective, grad + +# Compute gradient of initial model +ff, update = fwi_gradient(model0.vp) +mem_grad = memory_usage()[0] +print(f"Memory usage at the end of full gradient: {mem_grad} MiB") + +# # Plot the FWI gradient +# plot_image(-update.data, vmin=-1e4, vmax=1e4, cmap="jet") + +# # Plot the difference between the true and initial model. +# # This is not known in practice as only the initial model is provided. +# plot_image(model0.vp.data - model.vp.data, vmin=-1e-1, vmax=1e-1, cmap="jet") + +# # Show what the update does to the model +# alpha = .5 / mmax(update) +# plot_image(model0.vp.data + alpha*update.data, vmin=2.5, vmax=3.0, cmap="jet") \ No newline at end of file From c0791d91696afcc4ed2591d683a92ca41c0c7685 Mon Sep 17 00:00:00 2001 From: malfarhan7 Date: Tue, 5 Nov 2024 11:40:08 +0300 Subject: [PATCH 4/9] Add script to compute memory usage for snapshotted gradient. --- .../tutorials/Gradient_snap_marmousi.py | 162 ++++++++++++++++++ 1 file changed, 162 insertions(+) create mode 100644 examples/seismic/tutorials/Gradient_snap_marmousi.py diff --git a/examples/seismic/tutorials/Gradient_snap_marmousi.py b/examples/seismic/tutorials/Gradient_snap_marmousi.py new file mode 100644 index 0000000000..59109d024b --- /dev/null +++ b/examples/seismic/tutorials/Gradient_snap_marmousi.py @@ -0,0 +1,162 @@ +r''' +Memory profiling is performed to compute the memory usage when computing the gradient computation +using snapshots of the wavefields. + +Memory-profiler run as: mprof run Gradient_snap_marmousi.py; mprof plot +''' +import numpy as np +import matplotlib.pyplot as plt +from scipy.ndimage import gaussian_filter +import scipy +from memory_profiler import memory_usage +from examples.seismic import plot_velocity, plot_perturbation, Model, AcquisitionGeometry, plot_shotrecord, Receiver, plot_image +from examples.seismic.acoustic import AcousticWaveSolver +from devito import configuration, Eq, Operator, Function, TimeFunction, norm, mmax + +configuration['log-level'] = 'WARNING' + +nshots = 30 # Number of shots to create gradient from +nreceivers = 300 # Number of receiver locations per shot + +# function to get water layer mask +def mask(model,value): + """ + Return a mask for the model (m) using the (value) + """ + mask = model > value + mask = mask.astype(int) + # mask[:21] = 0 + return mask + +# Define true and initial model +shape = (601, 221) # Number of grid point (nx, nz) +spacing = (15., 15.) # Grid spacing in m. The domain size is now 1km by 1km +origin = (0., 0.) # Need origin to define relative source and receiver locations +vel_path = '../../../devito/data/Marm.bin' +# Load the true model +model_true = (np.fromfile(vel_path, np.float32).reshape(221, 601)) +msk = mask(model_true, 1.5) +model_init = gaussian_filter(model_true, sigma=[10, 15]) +model_init = model_init * msk +model_init[model_init==0] = 1.5 # km/s + +model = Model(vp=model_true.T, origin=origin, shape=shape, spacing=spacing, + space_order=2, nbl=20, bcs="damp") +model0 = Model(vp=model_init.T, origin=origin, shape=shape, spacing=spacing, + space_order=2, nbl=20, bcs="damp", grid = model.grid) + +# plot_velocity(model) +# plot_velocity(model0) +# plot_perturbation(model0, model) + +assert model.grid == model0.grid +assert model.vp.grid == model0.vp.grid + +# Define acquisition geometry: source +t0 = 0. +tn = 4000. +f0 = 0.005 +# First, position source centrally in all dimensions, then set depth +src_coordinates = np.empty((1, 2)) +src_coordinates[0, :] = np.array(model.domain_size) * .5 +src_coordinates[0, -1] = 20. # Depth is 20m + +# Define acquisition geometry: receivers +# Initialize receivers for synthetic and imaging data +rec_coordinates = np.empty((nreceivers, 2)) +rec_coordinates[:, 0] = np.linspace(0, model.domain_size[0], num=nreceivers) +rec_coordinates[:, 1] = 20. + +# Geometry +geometry = AcquisitionGeometry(model, rec_coordinates, src_coordinates, t0, tn, f0=f0, src_type='Ricker') +# We can plot the time signature to see the wavelet +# geometry.src.show() + +# Plot acquisition geometry +# plot_velocity(model, source=geometry.src_positions, +# receiver=geometry.rec_positions[::4, :]) + +solver = AcousticWaveSolver(model, geometry, space_order=4) +true_d, u0, _ = solver.forward(vp=model.vp) + +# Compute initial data with forward operator +smooth_d, _, _ = solver.forward(vp=model0.vp) + +# Plot shot record for true and smooth velocity model and the difference +# plot_shotrecord(true_d.data, model, t0, tn) +# plot_shotrecord(smooth_d.data, model, t0, tn) +# plot_shotrecord(smooth_d.data - true_d.data, model, t0, tn) + +# Prepare the varying source locations sources +source_locations = np.empty((nshots, 2), dtype=np.float32) +source_locations[:, 0] = np.linspace(0., model.domain_size[0], num=nshots) +source_locations[:, 1] = 0 + +# plot_velocity(model, source=source_locations) + +# Computes the residual between observed and synthetic data into the residual +def compute_residual(residual, dobs, dsyn): + if residual.grid.distributor.is_parallel: + # If we run with MPI, we have to compute the residual via an operator + # First make sure we can take the difference and that receivers are at the + # same position + assert np.allclose(dobs.coordinates.data[:], dsyn.coordinates.data) + assert np.allclose(residual.coordinates.data[:], dsyn.coordinates.data) + # Create a difference operator + diff_eq = Eq(residual, dsyn.subs({dsyn.dimensions[-1]: residual.dimensions[-1]}) - + dobs.subs({dobs.dimensions[-1]: residual.dimensions[-1]})) + Operator(diff_eq)() + else: + # A simple data difference is enough in serial + residual.data[:] = dsyn.data[:] - dobs.data[:] + + return residual + +# Create FWI gradient kernel +def fwi_gradient(vp_in): + # Create symbols to hold the gradient + grad = Function(name="grad", grid=model.grid) + # Create placeholders for the data residual and data + residual = Receiver(name='residual', grid=model.grid, + time_range=geometry.time_axis, + coordinates=geometry.rec_positions) + d_obs = Receiver(name='d_obs', grid=model.grid, + time_range=geometry.time_axis, + coordinates=geometry.rec_positions) + d_syn = Receiver(name='d_syn', grid=model.grid, + time_range=geometry.time_axis, + coordinates=geometry.rec_positions) + objective = 0. + for i in range(nshots): + # Update source location + geometry.src_positions[0, :] = source_locations[i, :] + + # Generate synthetic data from true model + _, _, _ = solver.forward(vp=model.vp, rec=d_obs) + + # Compute smooth data and full forward wavefield u0 + _, u0, _ = solver.forward(vp=vp_in, save=False, rec=d_syn, factor=5) + + # Compute gradient from data residual and update objective function + compute_residual(residual, d_obs, d_syn) + + objective += .5*norm(residual)**2 + solver.gradient(rec=residual, u=u0, vp=vp_in, grad=grad, factor=5) + + return objective, grad + +# Compute gradient of initial model +ff, update = fwi_gradient(model0.vp) +mem_grad = memory_usage()[0] +print(f"Memory usage at the end of gradient with snapshots: {mem_grad} MiB") + +# # Plot the FWI gradient +# plot_image(-update.data, vmin=-1e4, vmax=1e4, cmap="jet") + +# # Plot the difference between the true and initial model. +# # This is not known in practice as only the initial model is provided. +# plot_image(model0.vp.data - model.vp.data, vmin=-1e-1, vmax=1e-1, cmap="jet") + +# # Show what the update does to the model +# alpha = .5 / mmax(update) +# plot_image(model0.vp.data + alpha*update.data, vmin=2.5, vmax=3.0, cmap="jet") \ No newline at end of file From 71a99cc12f26f943eed54c788f259d7da62e7266 Mon Sep 17 00:00:00 2001 From: malfarhan7 Date: Tue, 5 Nov 2024 11:41:08 +0300 Subject: [PATCH 5/9] Add notebook to compare full gradient with snapshotted gradient. --- .../17_fwi_gradient_snapshotting.ipynb | 641 ++++++++++++++++++ 1 file changed, 641 insertions(+) create mode 100644 examples/seismic/tutorials/17_fwi_gradient_snapshotting.ipynb diff --git a/examples/seismic/tutorials/17_fwi_gradient_snapshotting.ipynb b/examples/seismic/tutorials/17_fwi_gradient_snapshotting.ipynb new file mode 100644 index 0000000000..ddea47acb0 --- /dev/null +++ b/examples/seismic/tutorials/17_fwi_gradient_snapshotting.ipynb @@ -0,0 +1,641 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Snapshotting for computing the FWI gradient\n", + "In forward modeling, ensuring stability requires a sufficiently small time step (`dt`). However, for applying the imaging condition, this restriction can be relaxed, allowing the use of a subsampled time axis. This approach reduces the memory footprint by saving fewer snapshots of the forward wavefield, determined by a `factor`, and applying the imaging condition only at these selected snapshots. Here, we demonstrate snapshotting in Devito, utilizing the `ConditionalDimension` class to compute the FWI gradient efficiently. This notebook follows the `03_fwi.ipynb` notebook in the seismic tutorials." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "from devito import configuration\n", + "configuration['log-level'] = 'WARNING'" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "nshots = 30 # Number of shots to create gradient from\n", + "nreceivers = 300 # Number of receiver locations per shot \n", + "fwi_iterations = 5 # Number of outer FWI iterations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# True and smooth velocity models\n", + "\n", + "We will use the Marmousi model. We will again use the \"true\" model to generate our synthetic shot data and use a \"smooth\" model as our initial guess. In this case the smooth model is a smoothed version of the true model." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# function to get water layer mask\n", + "def mask(model,value):\n", + " \"\"\"\n", + " Return a mask for the model (m) using the (value)\n", + " \"\"\"\n", + " mask = model > value\n", + " mask = mask.astype(int)\n", + " # mask[:21] = 0\n", + " return mask" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAugAAAExCAYAAAAug1fqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9e5wcVZn//550zzU9SZOZJEOYwEASE24SIRCQIKhRFKK4CwLihYuurpffelsviKsguO663xVd2fXrrn5XvHBTFAUREDRcVJCLQSKCBAgkxCRMQmdmMumZ6c78/qh+up46fU5VdU9PZyD1eb361XXqcs5Tp07V+TzPec5zmsbHx8dJkCBBggQJEiRIkCDBlMC0PS1AggQJEiRIkCBBggQJfCQEPUGCBAkSJEiQIEGCKYSEoCdIkCBBggQJEiRIMIWQEPQECRIkSJAgQYIECaYQEoKeIEGCBAkSJEiQIMEUQkLQEyRIkCBBggQJEiSYQkgIeoIECRIkSJAgQYIEUwgJQU+QIEGCBAkSJEiQYAohIegJEiRIkCBBggQJEkwhJAQ9QYIECRIkSJAgQYIphBcVQb/55ptZuXIls2bNYvr06Rx55JF8/etfZ/fu3XtatAQJEiRIkCBBggQJ6oKm8fHx8T0tRBz8y7/8CxdeeCEABx10EJlMhrVr17J7927e/OY385Of/IRp015U+kaCBAkSJEiQIEGCBBV4UTDa3/3ud3zmM59h2rRpXHXVVTz55JM8/PDDPPTQQ8ydO5ef/exnfOUrX9nTYiZIkCBBggQJEiRIMGG8KCzop556KjfffDPvfe97+eY3vxk4dtVVV/H2t7+drq4u/vrXv9Lc3LyHpEyQIEGCBAkSJEiQYOKY8gR9YGCA2bNnMzo6yn333ccxxxwTOD42NkZ3dzcDAwPceuutvP71r99DkiZIkCBBggQJEiRIMHFMeReXP/zhD4yOjtLW1saRRx5Zcby5uZmjjz4agPvuu6/R4iVIkCBBggQJEiRIUFdMeYL+xBNPALD//vuTTqet5xx00EGBcxMkSJAgQYIECRIkeLHCzninEF544QUA9tlnH+c5ckzONTEyMsLIyEg5vXv3brZv305XVxdNTU11lDZBggQJEiRIkODFjfHxcQYHB5k3b14gQl4+n2d0dLShsrS0tNDW1tbQMqcCpjxBz+fzgPeAXGhtbQVg165d1uNf+tKXuOSSS+ovXIIECRIkSJAgwUsUGzZsoLe3F/D42Oz2doYaLENPTw9PP/30XkfSpzxBlwcSprGJdby9vd16/MILL+RjH/tYOb1jxw72339/4KNAa91kTZAgQYIECRIkePFjBLiczs7O8p7R0VGGgE/QOOY0Avzb5s3luYh7E6Y8QY9yX9HHXG4wra2tZSu7cYSEoCdIkCBBggQJElTC5gacBRpFlfMNKmcqYsoT9EWLFgHw7LPPUigUrBNFn3rqqcC5CRIkSJAgQYIECeqPNNCoFWcKDSpnKmLKR3F5xSteQXNzM/l8noceeqji+NjYGPfffz8Ay5cvb7R4CRIkSJAgQYIEew3SDf7trZjyBH3GjBmsXLkSgG9/+9sVx3/4wx8yMDBAV1cXJ510UoOlS5AgQYIECRIk2HvQ3ODf3oopT9ABLrroIpqamvjWt77F1VdfXd7/8MMPlyd/fvKTnwyN9JIgQYIECRIkSJBgYkgs6I3Bi4KgH3/88Vx66aXs3r2bc845hwULFnDEEUdw5JFHsmXLFk499VQ+/vGP72kxEyRIkCBBggQJXtIQH/RG/PZmgv6iufeLLrqII444gssvv5wHH3yQzZs3c/jhh3P++efzoQ99iFQqtadFTJAgQYIECRIkeEmjvfRrBMYbVM5UxIuGoAOsWrWKVatW7WkxEiRIkCBBggQJ9ko00jd8b/ZBf1ER9AQJEiRIkCBBggR7Do30Dd+bSerefO8JEiRIkCBBggQJqkAj46DvzSR1b773BAkSJEiQIEGCBFUgsaA3BnvzvSdIkCBBggQJEiSoAo2cJLq7QeVMRSQEPUGCBAkSJEiQIEEsJC4ujcHefO8JEiRIkCBBggQJqkDi4tIY7M33niBBggQJEiRIkKAKJGEWG4OEoCdIkCBBggQJEiSIhcSC3hjszfeeIEGCBAkSJEiQoAq0Ax0NKqvYoHKmIhKCniBBggQJEiRIkCAWEgt6Y7A333uCBAkSJEiQIEGCKpBOQXNTg8oaZ681oycEPUGCBFMEc0OOjZX+JxJ9t6Dy2VVKg/8ZbCb8k6inK21X2+2O68JkHSzJosssqONjpbTOd5Yhwy61bcvDxJhxDaX8Okv/UqZGGv8+CqXrd2G/513Gtq5fvR31DGeVzt+O/7yknmYBB0dcL/ci2+DXNSoN4fXlQqejLN2+BLuALcBzVZSln72+xtU2zXbsQjswI6LMsGvN52jKFjc9EdoxSGUbfrEhzjtgwnbPBct+17fIBWkPaZWXfNvcTizpNKQTgj7p2MsJ+mwaF25/b8eeqmf5GE50LrgQE7Ojn2zUI+LsdibWqWkCO1nXDeB34pqMt5f2dVL7cxTysUulJQ6BkFPZL9DlyH20A1tL5+l9plzSSZqyjuERjAHLtZogmaRUiJUmVybZTuN1qBtL52lCZCPmkv8c/I54mEpSpcvchdeW2vFJqpa9WZ1XUMf1v17ixPYuzS2VK+Xoem4G+oCjLPcyUYwDTY602k4Dbeq0PDF496N4dTLoOG6SY11nUUqjDfL8zfyIyEsTaDNOR5QMWlEx0/r9GiAIm1IThmoJaKNge06ub5Xru2h7R3UdSjvR9dWO/x6FfXf0M5ihzpP3ahv+eyv73WhuoAW9ebwx5UxFTMWW3kDsg985RVkA6omJWB9ejLI1upnJM9UkoloIqZGPZqM6hlo7ZY0CHtkSQlCLxUaumwgpj3MPQlwKBAmMJglCEmt5jsP4z1F3bkL4BYXSz6wnqbtdeORctwdNzLUiaMopxHcXQXIu92gjKLoDnaXkknvQSoJGrypT3kUbYe7Eq1fJV+5LPz/TurbLuE+oJA2agJkEz1Rk9LbI04xncR6gknj0Asdb7tkoJqrZyaMOwGQbTcHtNiCDX6X50i8WXO+etrybQke9e/p7ZBIq3aZcIweo/ea7aparj5my6rRWsLUyrEeb6mH9brSBxFZ+XDJuvt96e8ByXGDWk6TNvlaMDFEyyPvXgd9W0njf3C0E+zoxWrifVXsrtE9zHq4rxnbjfc72QuzlBF1/zc3GbUvHsRBEnRu3rGrTe4tsrg4GKj9Uetjf1anoD55YyPWHyZS1GtmqqWezE4+qJ53WnaLuGGtR4mzvQxylTK6xdVxmByTyipuHabkT8iGErVoIgd1FsE4kbyGK8rz1fWhC04lPzEVOTazTap/NdUAshkKStUuL/JudoB49mIXXoeq2Kvdmtg+5J/1sNqrr9D22E3QnMmWQTjytjou7iXTyUr+6Dcq9mjAt8Wb7maWOb8R/Zvp5HQy83JK3ylL/uxCbVJeQodJiPlTajv16yQiWy1Icpjxrom66gNlu1laOHjECu4U0zF3Jlp9rRNH2rjcK1dKZaEtx+LVh0AqS69mb36cw2L6RUZBztcVcZJL32TRC6b5zf3fWKaBBBL1Cd96LsJcTdNPaVU9yOhlEN5EtmI7TYdn2a8IjPqLmB0zKmqx6sxFyE7Z9Yv4bwG6BqbZDdBFy13m268KsbxpCVLTMJrFNA11GOu6IjSbE0vlo8tpunGeDWJtnKZnFxcZU/CDoF65l2Vb6l2eFKl/k0TKYrj1z1XmmldpUTE2XBm2t1p2/5Kst9/q4tHftYy3kXOc5bFynRyhMCDl3tZ+uUnkF7OS8E1gO9Fbq2DqbOD1ZNeQ8S9B+UxMxF4jP/CP476wN+iZ6LfvN75MI4yL+Qs40tPVUvzfi4lANCsZ/NYjzwOrhmhiFieZvm3Ngex56ToHNzccF3cBNJTcMXdhJ/BaCxhGB5N0O7Ic3UuVyySoV3yiCvrtB5UxB7OUEPcGLA+bkOEEtzbeA95ECn6SYw8n17hRM3+E4+cvHUwiS7bh1rB63hVug3SVqqUNzON0GsdLsImjBkfM1UYCgtdxF5mxp6fCkvqSutPVV/Nj16IK+3lTItEuHkHVbPXVZ9mslQciY3Ku2ntvIeTOeT7iuizDLq3ZB0RCyq4+JlVrytSko2j8cvA56G8Goxy5ybpNDW/VtECUEfHKufWA7gZOArvAmEOXWEstPXKHbyC+H/XWKnaduh2ZdtWNvR+Z7NUA4gTYVqzDIczVRq7XbVvk2d6aJjDBOJeh3wDZCaIPLIADhjbcaUq7nqehz9QiOkG7tPibntwOn+8mwyZkJQW8IEoLecIgFq55+3mba9Pt7scAk4vVonlGTs6C+nUGU1Sfs2HrLvrCPf1j9yAc3DHHqt5phYPGxFrcPk/C5SG5cWTSkfWtrkB7O1RZk/fxt1mh5JrMIWnu3YCc9zditwjJsbEZ4MbdNgisyzCE4eiDuLDbMMtJCFNYTdIkQtxTd7myRXEyf5gE8EtdMPHJuwlY/Gr3q+HMEn5H4o78R0s2VnzdBFDGH6sh5j8oXoL/0b15fNY9twp8cLAqYhvlNcI1GaJjPX/KxucGZSr6rTUVVpiirtXwvq1G6TQ1oov1hGDmeKGx1qb9H1cL2XMMgCh4ER8Z0YADbe6rfzwLwdqCp8jEkBL0ChUKBhx56iGeeeYbnn3+eXbt20d3dzezZsznyyCPp6emJziQm9nKCvi+ek2GjMdkuI2m8YaqJwtVJ6PBnUdCWTBNRza8aK4t8lGwyx5W1WoSR1zArtkzKMWWtRs4wy2StiDukrN0jNFGWPKIseS6CGwXd0WjCIYTcjBBikhKTmMsz2g/7vffiDwkLbNZO7Wcu8gkJk7ow5wfIPrF8mkPSrjkEpj+plmG7OgeCDFZCI5oWeSlfW+yfI+hqJCMKeqJpmEU3imT04t/reoLPScj5myCtCEOY15V+1bRLSpzBJfB8zLPq2hx2vjchd+oxvHqxuW+55iFo2BQyF7ZQabCJCz1a4kKt3x1NCOP6XtcDE/3+2xSfMCVqzPgPQ7WEXPoc/f3UMmlruSmjfDf083uzl5ep7IoFfcQhRgueH3ojMAVCLA4NDXH11Vdz7bXXcu+997Jrl7vtHnTQQZx88smcf/75HHXUxCJONY2Pj+91QWwGBgaYOXMm8Bv2DEF/saOWD149fP1ksp7k5zKt1RNmebW42qwv/WufzziIS8K1tcxUWszjknYpFrb7G8N3CwK736u2wpodmp5cWE3nLrJsw96pyz1ogqknKpokV5dtunyYbjOa0A/gdkMQ2Wxx0WdQOXFS5yvkeC5B1xpXm3YpuuIegiGnLjuNnXiZ5FyesyYApnLhIlcm2bdZEbVby3r8etNK1t9CW8TMsDDreVyreQHPah7mziL51YI0fuSXfoCn8ZSfOOTOfNau7+cugvMddB4u2HzTtdC1wGalrve3OcoqLe29Wgt7rbJUC3MSJtjJP5Z9MnJhI+XyDZK0+d2zRSALIebyPz4AO2ayY8cOZszw2otwpx2HwIwGEfSBIsx8lIAcjcLmzZu59NJL+d73vsfOnTsZHx+nqamJRYsWse+++zJr1iza29vZvn0727dv5/HHH2fHjh0ANDU1ccQRR/DZz36Wv/3bv62p/L3cgp6gNkyWf6AZr1tiK8nHRvvy6v2TASGato9bFITkmP5+YR91k4zXUse2kRWtVMS1kGvraFgoMCnDFuZLlznLcjyODNoaZLYBXaY5SVGfr+t0BpUdnYYm5vo+hECbkHCAWjYhmra5A+Z9zCDo8hY20dL27Lbj+9+bkWTM0HZStj5HW+9k0jFUDn9ri7/2vdXQyhmWc9IEJz6uV+WJMpMG3hxOzqPcWuJ+EjL45BnsxLwWq7km5Tr6SzfQPwNYF5KpfldckNFL3ZbC3k1z/sNEYEbtaTRMtx2XHFE+SfWQPexbZk6AN0l1nLya8b9VplIuirR+/mZ9aBdH/f0+Hjgw2Dbl9GqaR4rGWdD3ED73uc9x+eWXs3PnTubNm8e73/1uVq1axdFHHx2qKDz22GP85je/4ZprrmH16tW89a1vZfny5XzjG9/giCOOqEqGhKAnmETYwq7twh3UtBpyUi+YpKKWV0J8Dl1+/83G/0SJuA36PqrNU0ie6att25b8Xc9FLLWu0YYwCAHYrtKSp1gUJX8dW9xGVPRwbhfhipaNmJvHbe5UUraWrxl7OzDvRaKX6Dxd7d/WGQihHqMynrnL91SisZgKh+keo+tJW/xtRDDO+2mGdVxP5VyFNPA6yES0mTAioQl12GssLi1yjc3iLnnFMb6KTJlS3ray28DtchDmJifPJWxOkVaG9X+t0EpZ2HsRF2GuLHG/EzaXjakE/b2p9ZuuvyHmM9QTz6HSZU/nYcrQBxxJeT6Hy2KukbdkrZGmcQR9D4VZvOyyy3jVq17FZz7zGV73utfR1BRPkCVLlrBkyRLe/e53s3XrVv7zP/+Tr3/96/z0pz+tmqAnLi57nYtLWFQI03dxT8I1JD+R/GBiliT9QaymrqIsKNXAlL2WOtIWuC3YXWBsvv+u+QTyrGohBuJCYlrBTQvQDMLdK3YR7JiEmEf5w0d1+tqiKZNgtXVc8p8RIZvIZJLzMOVAW5ZR57tcUUyfe3NytOS3MCIvGZUQMmAbNtf3E4ecC7N9gmAdySjC4ZDpqrzcLC6MnEe5omhiLtfkjHOqdWdpw1/EKA7WbwH+TFBh1G1entkWwqG/KTZLqe2dNtP6mZqryMaB/kaEhOSLDf3Ow9Qj5KZhZSJkXPKTNQXmqn1yz1pxBjcpF3nMCflzgRX2tul6lwrqNz4AIw4Xl2Uwo0Hm3YECzHyg8S4ud999NyeccEJd8hoYGOCZZ57h8MMPr+q6vdyC/lfqSwKrhYRvcxGiuGkNVwitKOhOohr/vYmkbc2vw3GuKy2ym3mZxMF0M4kipVLONmrrfGyW+WrrSaOZIPnUMtrSpt8z+JNTXW4IYe4JJlkUeSZCykVGsexC0Id5FsHnoOXRVnMth7h6aGJtPmNt+dZIG/tt7gYDeO1Bk9MZSj79LDQxF1egXiWPJudmW7YpQgU8f3M5R3zodZhJuV8bOZf7kTawXh03rfCanNuUDjMuvK0ty+Rb8J6xtD9d5izInhTOw1xWPkEcVxQ9EVSIub6mWneWNjy3laphTqI2laQw6Gfugs3NTaDbnTm66XoXTExmdLAC9SH6cRFGf1zvny2Pavoo+VbZvi2iCD+n9mn3FZeMZt7HQ7bDrk/rfxN6JEk+F886zm2ki8seMiHXi5wDzJgxo2pyDns9QU+xZ6tgssI/TVTLNOWyfbwnmhaCF1X/YXlVc5829w9NaoRA1Io4MYjj1lPcyZSu6+Uru5HKr3Q1Fh9N6uTaaqMOiDzatUkP1YKdlJsTUzWEIGulpR1vKNcGPaFKnrltnFe2Xfcoz3iW8W/KKferlbR2fB9sURRcsrgi3GhyLtZmk5zrSZfy7DsJkg09+mOSPnlOaXxyHkd5MOXtU/ts5LzkX5t9nf1yV9ZmE5ftMF2128gjZ5w7FFK2iTa8iaWmfheWDhwTpc6cv2CDtJ+JfM/FHctWwVHfI1OZnWxDTVQ6DlwTqesBlxxR9djruFbqdZ2xP4yU6zk/km4GjoRsb/BU871x2XGEmMs5PcBmYIdDBHC7ck0GptIgSoOxlxP0BHY0dqa0G/WWYwx7rHFB3NehHhOuBPW8xy24LVCuxXbCUCshh0pSDpXxygVCSAdwk3LpsLQFshk3KReEdXYmwkI/bsW7F3n2MxyyinKhZdyPSsXQFQXF5isvk0Eh6MutyblJpsGtbEi9rcdOzrUCFVd50Hnvp7bFpUVPLi2tHJo9PSSfEszJbFoUGzHHSHerPPqxE/s4r4VpMa/GJqG3lzTDY+3YjTNyU7XGGgf76Gm17725yqTL9DrRdJyQrC82mKN3Nqwn2HDTBBdYM0fLXWsxHAzZRe5iNCk390NQMRViXsB7T0Q/rzbvvRjPPvssV199NZs2beLII4/kne98J9OmTSxYfFLFCfYQanWPCIN0cGk8P88wV6C4mKpkvIC/PLdenGeidTo3+hQnhIjZon6YccpFZh2JxJYfVLYV8VsOQzXEXE/OMjtH8EhmwShzo0NeTbBtCoRr1Mwk51L2c/hKjm4/ttVTTdiIQgfeYjmm3HpeQpxVRm0wlZH1+AqjQTSyZ/nbLuOqi5xD0FfWhiy+lU+7tFRrNc8Q9FufKArgK0VjSkBbe46yOmtXpIliInHJa1XiX+ywzXExFav1VH7btPubDS73mrmQOclLuoh3VFdlToiW0aU8/jsSZx7GNBrn4jKFFir6xje+wUUXXcTFF1/MP/zDP5T333vvvZx88skMDQ2VQzF+//vf59Zbb50QSU8IegUmgzhGodrhwUaikbLErQfdbAfxLJk2lb8acl5PIh7HRSVMebBF2BDrpb5mooTcXDSlWpiduhkv2wz9py3lJrGQiYlyLVTeWx/2qDG6jZh5hMG26I+LGJvtoxffgq6VEJ1Pn1FemC+pqbxtx7eGygTcNF57F7lMS6fAZTWXyZrPEVSiIHwCbpx2JsP4zfh1Z64O2gzpNwfDGwrMdJtxzByWN63fuglk8SfG5Yxr48ZIF8t7LZ4YkZ4aswgqqoGDBvR+c1EwE3HnLmmCGPWeuEZ1pjImMofLRAfB90nauIwEamg3LjP/sAmvpsuKDtNYcgHLquJNmAMcZnvTbV7emSxe+84RJOVyXg/+AJgNjbSgT6EwJj/72c8YGBioiGv+sY99jMHBQY4//niOPvporrvuOn71q19xzTXXcM4559Rc3l4exWU1e18UlxcjCgRXLw2LRBMHJtmYyEx8ud60fFYD099avpK2kFm1QhOBWiclSydjPgfZZ0Y20FZpPUHNhH6eJsmdSzRBqDbag6texSKp44GHEdNd+BO69PPXkyOlblzyieIlEJ9hmwxCyG3PQvvw2yBuJ+KqI/Jr/2LznRJyFlYHoly0K9n1ega6rt8cb2JllOXcZeHL4JP/ISrJeJjFXaM3+pQJ47GNhLvbQXAdBQ2t3JptoBZiar639frmNBqma5BJol3paowcMgFb6jFsRV2obHBSlq2Ol1MeSQl7T1weRxpm229TP3k3RDzToi7vX3EAnnBEcXkTzGhQExkYg5k37pmFikwceOCB5PN5/vrXv5b3Pf300yxYsICDDz6YtWvX0tTUxNq1a3n5y1/OSSedxK9+9auay3sxqcUJXpIQa47uOKImT0H8DkQ38T1NxLV/qM1aqQlRLfnrcGtRnWxYtActIwTjkptkU0wpOka5YAx3+DYzH33P0tFONESiljGsTiQyi7ZcRRFzqZtOggqVto5CeAhF8znLaMkYQau5lCnkXFum5Xo90daEuJ1swX8eWiGyjYrZ5DMxQ5VrLiwleUseb6ycrGkOhmniYasyFzlP44c6FCt5Xh2LM2yfxndnqedcSJFbWzCBoJuLYJfxD8H2EzZx0LZtS+tn2uiRYhfiKIET+R7GTYM9ApJEnZL6D/vmmP2NqQDouj/S2+yeUXmpK9uwAWxzZEneB21Jz1FpLYfgqJOgGCJPK43T4Sbmxl1XPP/88xx88MGBfb/+9a8BOPvss8ux0g877DAWLlzIunXrJlTeXk7Qh5ic8RNZejduSL9q0ra8Jjs92bJNFPUk4bZ8qu3INEkRq6Itf034wywDut70NbV2XC5IBzRgpDUxkC++7ni0TGG+rDZyL/IL2Yuq6yj/TY0wkimxzMWaLM/DpRTI+6zrRFxO5D72s1wTh5xLvkIMbORc/0y4yHkznr+5kHMh0Pr5yT3PxbPoPkc8wiRKlLb466XWxZLfBz0vt2ejX1vbyoYaQrptPZYm59o6CNFWcyH33ca+MFmi0oJQdxpxr7L5kcu3Y6IhB8OstROFLb+wNiPzHkytTI/g1II4o6nVRueyucwJTN+OZuNYs9on5/X52z0HxhMhrguJ2b6lPYt7lh5Jcp2bVWXJOXlgNKTcRgbAm0I+6MVikXw+qO3ffffdNDU1ceKJJwb2z5o1i4cffnhC5e3lBH0rkxsHPcyaEWXpmErpyS4rLvSHvB7WH1OOWjoy/QHfQrhio8uxEUfzHNk3GZYuW2g+GzHQFnKRT2QKm1SoyzF7BU3sxbob1cnGsZbrOjNjTesJlQP49yLvvya5Y8a2tq7bLGwFgv78LiVC2pe5SNGgkklb73XZLnLucmmRuh3DI90yqVT7u7cDB0DvgZ4omxcB1+N+B0QR0+RcXGbMycAAc6HbQc4FcYiI6W+urxW3lgLhsc1dvrs9EWVXA01uotAHrJeRB4GtbcWFvsGJuAHYvokmzFGiMNgmCtiGGFww39u4Zervji6/Wspj6xP098s8R74jndB9oEeAoxTEAuFuXRDeruUnFvA8/iRosy3q8003mkLpOvkf2uqWp5Fx0BtVTgz09fWxbt06crkc2WyWYrHILbfcQltbG8cdd1zg3O3btzNr1sQmUO/lBD1BfcZw6ymLhrZGTEZZcToZfa/a79DVkdoUG7mvsJUStdXRVnZYvVfzjGw+k2bHZ7PISqcvZFGHTzTLk85RW/o1edaRPlD79fXgW6d1OS7YrN8ik7kin7aWu9qXJgZYtk2ZxH1pDpXhDl0y6gVqbJFkxDpoc/lK4160Jo1XxwU8Ai2yteMrJHOg5yj/0QlZ3fy3wI2WfKU8eWf0hDiRTeQpPe/u5T4ZMJun/g+DjfC6XFq0MTbMci7kpJ69n7nIiw0Vcs3FU562Ud031bTgToSQm8JWS75tEAVXK7UQXIBH768W5jviQtRQh+vdD6tPW6Sl5fZ5C1HKoUssE0K29XnaHUsIdU6Va/tcgLvd59R1/dvw7i1Ea4hr4a8HppAF/dRTT+UrX/kK55xzDh/4wAf4yU9+wpYtWzjjjDNobvbb044dO3jqqac45phjJlReQtDLCCM5pgUgbnoqY6Lkdzj6lIbIEQdxyThUftmqWUnUfO5zqbTaRMWRDssv7DrdXvU96Mm1YB8SNjsk07q/jfDVabWFWuchlqUxvB4szjNwLSZkQxgp1+RXny+yhcliTgIT2OQxla7tlrwVaQ2UsV0d09fo0QIhIGbZLmVPk/P1+JZ5eaal472HBC8p/zfhtQdNfNrx61lbMvU5Qs47Ibui0p9Vix9lLYQgMTdvXazmELQWmsP05j5tOZzoJ1ryHwo9KyjLZvBj6YOnzMVt6xphir6GLU8ZQYmrHYVhfUw5bNDuYmGw9Q2FiOOCuIpL2FwXPZLWB5ne+GE3pYqrsY5DZbuX6zNqO48Xr1znYdIX6RKyBBcW0u9Gfym9Gfw5LvKtCHH/3UsJ+mc+8xluuOEGbrnlFm699VbGx8eZOXMml156aeC866+/nt27d/PqV796QuW9GJjkJMJsZVGEqNp0I8jnnsJkugbFhU2pmoj1Zxc+EY1j0XKRJpFjsidhmTKabhC6E9QE2uy4dFryiBpOtpFyIYDS5mdZynIhrDxzPoDtsyXyyLCsOc9BnonrfTRDREbJ47ov6SnFBcgk5+ISJKMDZgQXTc5t8eHDytbk/M9G+c14z2OO59LiQh+w/iTgHvy47u14xFw/c00slZtQxkLONaol5yZc5FxfK2Jp1JucR4Vr1KS8IESnCejwRwAAhmYQ/a7VQshFeY0zp8MGPeE3jguaRtgclDDXSRO6bblguqZJvnHnObV7cyRstrlqSWg150t5NiVU8skQ/Gzk8Nt7mJUcfFJuw5C6diP4RFzxlSww1gQ7HXm04E0U3cswa9YsHnroIb71rW/xxBNPMH/+fM4//3z23XffwHlPPfUUp512GqefHmMxthDs5WEWv0v0B2AqENG9Ga4vXjXk1/ySabcB0x0jbFxcIES0Qx2LimdcD0QRcghGTRlTculOy1zwBnW+ea5ZngntI69D7kVB6t3V8euO1YwTrK8XbMH+7GyKki5bX+NaMEnKjSIMogRIvPpdBN2WZGKqEHgdAcYMWWkb6XCRc1GK5pSuf0Ll2+4f6z7K77RtA4R6/3qAPyqZBWJlk3tQIwDp5Z6bzERdWmzWQPDJuRBz7dKC5Tp9fT2Jedhx091AQybvoY9vwVeG9AhPXMOOdreYZdkH7khCpque2d5qXbgoDGH3FqZE2x7eDEgvCl9t1qYsutpnHNTahlztRmTppnKwNVf6N8m8TR4dRtFVviiVGx3nZEvXSzm5AcARZvFDMKNBBH1gBGZesWfCLBaLRVKpPecEv5db0Duwd7i6Wsy3xkyHIeraiab3JBohu5AinYZKS4yGdDL6C2yGNzRhG0WxTQwSeXQn4ron2yTRatICk8DpfZosiSzNBCwhAXIqvYGN/I1ZtguWY6aVXA+Z24i5fg62Z+OalBbWkcs963jb5vXacq1Jr1m+GXbQhMig3QJsbVkIMlSSWrGaS/mzQuSyyaOt4PoeBbK8+C78ZcTlGZVGMbpfHu52oq1/QmyGwE7OpUxKch0M6bk+OTfzjms11//m9WJNNEMo6utNPTttXFvt58ck/lEWcyHm+jxRKsQCmjMvnIs3bCEjP9p8qzO3tTdw+4zrb4OMiJntbSKwVaZrxNgcKRKYcs/1fmbWWSa+XEnUYHecY1GDqmHHNZHW2/qavPHveif0f5ZKec08RaEdIkjy5T3PECwrF3If+tpGUZGwcI+TjNmzZ/OGN7yBU089lTe+8Y0TnvRZLSZUxZs2beKee+7hmWee4fnnn2fXrl10d3cze/ZsjjzySJYtW0Y6PVUIpQ1xYgVV82ZXe62Ztvmu2tJ7sk7lTXbJ5vKp1KTO3G/LJwwmmTWtoBAvZrBLJpOEpi374iBsIqQJTbR3WfZpcqTzayZoydflyDVhHbKrHs1yNPkXq7SLlOv8bKRcw5TZRTZ0nqblz0bK5VxTIdH1qevF1Tb1CIFZnkBIUgHPIipkqB3flUVbnNNULjQkMtnerzCfYXEjkkWTZIKqjGQcD31Njmtxd7S9wLqXQ0HHZhe55B5mAYu8OM4u8l+NLcM2ZC8kBOwuLbYyZVvIRy2fS5OU2zizQJMfUQq09da0qOu6SQP5o6BwH/63y9VPaAOBqcDq9q1dpeJOQA1TPsFuyLL5bpuLBVGStbeyuF61HVe0OOfXA7Yqs1ndXZb4Nsu2SZxNwmwScslTv6NRyqYexZERH1fbzKhz8uo6kTmF28VlL4ni0tnZyTXXXMO1117LtGnTOO6441i1ahWnnnoqhx566KSXX3VTf+qpp/j2t7/Ntddey9NPP13eL54yEqgdoK2tjVe/+tVccMEFvPnNb57iZL0eCCNgce79xeCvHsdvsNZrXbAN0WpypaNUoLZNC3yYXDZLfbWEPA5MH3GBa9VAkxjZ7skcyo5LyCEecdYEMWqCmSbAcfKO4w6jybhYdG2kRcMkwHo7TuSHOLIJUZpRkkuH2ZT9++FZBiVO+FYqXZNcls00HjFy1beQcCHnA0qmg71y+5rCjbFhj7KbUujFh0ryiSyl0YL0IR7JsnE7swyTdIRZpzUZESujGQfdvF5DkxDTShkmi0DKwzjPhJyXw1ckdJlCzEXuNJX3A8Rbi0O3NQ39zo8RDJlq03j06IoNZgx+sEddkv0Gepqqt3bHpQUuBSnqmdqecRhs55qkOCxtEm1NgG1l2CzkLmJuk0+/Q9pirvPN4sc8Fwhxz6nzpP3mif5MNorO7UEL+jPPPMMf//hHbrzxRm666SZ++9vfcs8993DhhRey//7786Y3vYlTTz2VV7/61bS0tNS9/Ng+6A8//DCf+cxnuPXWW9m925tWO2vWLJYtW8a+++7LrFmzaG9vZ/v27Wzfvp1HH32UP//5zxSLRZqampg9ezaf/OQn+dCHPjQpN1INfB/0nwDTY1wR1yfuxUCwpzLCFp0QK17YKENcv3RXlI16wkVQTZcB27aWyTYBShBnkQ5zkleUGUqXKx35rJBy9D1GkfIwtxtTZk2oxW/bHNUA399by2OSXdsKqC754rQDOU98vgfwCLLIISTnSOib4d/ievD8w9cb8tpWWw0j51L+LLy6kQWXRJk6HJZ0Rd9uVAdbwJvkmHsaWFfauR/QC9kZ9uXIq+m4XRMtNcG2kRuRzUZyhITEcauxyaP/wyBWc5SsWXx5c6Xjuj6kHVhHAZ4GniHYlvV7OAv7CJvpTmWG+LSN4um2PoegddwyCbuvw16fUfq3nOMaEAjLK6ztVkO2TYS1C1e7FcVKl22TIaB0WeBq62b5evTFloeWQS9CpMvX/uiadOvzdTvMGsfz4H3XHD7on4MZtbxjNWAgDzO/sGd80E1s27aNm266iZtuuolf/vKXDAwM0NTUREdHB6973etYtWoVp5xyCj099VlgIRZBf9e73sVVV13F7t27Wb58OWeffTarVq1iwYIFodcNDw/zu9/9jmuuuYYf//jHvPDCCxxwwAF85zvfqVh1qZHwCfotxCPotSzKUI+0hHtz+ScLbLPWzQgStZSlJ9jVci8QJJEm2TShVyLU52vYfJO1T7ouy9VRyT1Va1pxwebG4VpYxnRV0W4jJsz6rMYyLjKY+ehyNbRl3Gap02WY96nrMazOzfZmy7uZyigytpERE3qFT9M1KMoUFKUM6fdBEybwyJEs1qOf5fGwpDlYLQW8CVp5IbyuNmKLia7vuRPv+QzgkX3tJ38kLJkxcXIOfme/HiiURqkyXZ7V3GbxjkvMtWXRhBBdCJJgWx42y3m2CjnM/IRQS9r2OdPkRk/MS+NbJPupJHW5KAHGgUcIvrPSDvS7L1Zy3b5tbUQT8U5gEcHvZCn/7ib7gjW1WkfDrosi3a6RkHpA2lq2hmtthDjqXBOue+muIj9NxPW2WYa2hA+pc2RbW+W1pV1vA6EE/ZIGE/TPTw2CrlEoFLjrrru48cYbufnmm3niiSdoamqiqamJV7ziFWXr+lFHHVVzGbEIektLC+eccw4XXnghixcvrqmgQqHA9773Pb70pS/xjne8g8997nM15VMP+AR9NROffVIPmDPppWO2LVBSDdL48YldpEOO2RZhkSH0uJMbbQTctbhL2GhDNVEMwpSnsPi21UJbdDX0Eu0mXFZxE7Yvd9jKmTY5hJTGIeO2yCZzY5TlqgNdTtqybbsXMz67CS1f2EfZRsyFlJtjwjblIU5b0/72IpcotOsJEvNZwMEeOdeQjrOAR+A2P4HnOqJPELnCZNLk/Dkl335AHyyJiDplkvMwIpp3XGPL07Zty9u0AOrjGXyrOdjJuZmHli9LdZbzAvb8bDCt66JIpPFJeU7JIs86R4RFXrrfQSoXANNub5qUyznS7gTSRhdR8f4sCZOB8FclyiKOcVzOMetU+0HHgRDOethQpC3VkldU+4ijSGRjnGNrJ5qMC/R7oS3lMiFaW9JzBJ+p/ISM94cJFELQv9hggn7R1CPoJp544gl+9rOflV1hxsbGaGpqoqenh1NPPZX//u//rjrPWAT96aef5sADQ2LnVoHdu3fz3HPPMX/+/LrkVwsaS9BNa6NAk9pqV5KbKKII8mSjWpeSMHklVF29TC0uEiqEzGQGUaEH9bkuhC2EFBZtxQZbPZl+4y4LuZl/NYRc8hWY8byrzSvqQ6yJuWzHWTxL+/HHJeZm/ZlWcyHUR1JBhlzW5Y1A/x/xXF4ErpVBJQNRmE1y3gfpRbAw5FbiWLlN8izni0XOtCBWYzkPI8IZfOIWNhHUJZ9YC6sl51HWUPNcLWu2lM7hW/q1xVz2WfPXEVZMbFT7txvnSfs2J4XPwHv4JQVS/MBdJJsY++PWi85Hno/5HMwyMrjbgpl/3GcUF7b2I2lNYF2wHdMEPW43pJVfc0TJptjo8tvUtn435b3JEewS9bwHqXc5JxQhBP1fG0zQPzX1CbrGwMAAv/jFL7jpppu45ZZb2L59O8Vi9c70sZpTvcg5wLRp0/YoOa8v4nw5TFJeMNKTEWtWwyQicclJoxAmi80aG3ZetbCRRhlO1u4caXVus/rXFizX2LiGOTHQhjiE3OZXKpD61PXaaTnPlbfEY3aRaU3Cbc9FiLnLfcOWj6Rdcz30c5J60xbzehLzdnWOGX9dQiUKORZf8wPwJmR2VPqUuppCN1B4OeQ6gcci5JKY6c34k1HlXhZC5kD7UuNx5NCwWaaF/EKQ1MR95UzyoSHEJotPIFzWZvN10cP0JhmtRh7Xa2sSOXGfkbJyBCfYZUv7N+MgP2PGvy68Q8nRhzeyYht10sT85fgLETV5kRpt/syutHl/JmwEWhNRXV+2f008TSu4KC5m/jZZaiHnQlhtiPJBN632cT7rYXDdU8GybZ4vZWZLae1TLhBFUE+iFmVVTxjV59QD02hcdJVpDSqnjpgxYwZnnXUWZ511FuPj49x777015VMvs+NLAGGkJC6ZknNt44UFgiShgE9SbNaUKEtpFAxfw4r9E4GWV+4lDum3Nbco8l0vmIoRBCN92J6bhpCkqLwl37jtqVqLuGtSbLv6Txvn6h7HtJBr2FxybHnptOlWYhILMwqN9v+PevbSe5nuK/peoqzyJil39b7t6me2ZZmIJ24GkmfJtaT7wEr3CheJ1dbYHqDtQNjchb/yp/leiUtLGs9qL+S8pBgIOY+ykMa1nGurm/w0eRYLadQra1rM9WdC0lmV1uQhDpkUIpK1nO+SR8tlwkZoRV5RUjL4pDxXOp4tnZ/DvUBRhUug+u8m+PzyHbBWC6zb4sLSf6/XdrTyZLsPkxjrbF0KjyBjpG2WcdfzspHAOAqBliWs3UZZbkV2m4IQV7mMUnAEUUpF1H2byOK3O+26IjLoSZz6HTMV3Rx+GzUt8HExjjuCSrUjVhPBi3wpzaamJo477riark0IesUbNFFibH4hodJXEOxESxOuehF0m1w22ExIrrTraxN2vU0mF/RkprhpE7YwdgIdm9qESepsE1AlT11+mOVb6sJF3MPqxSSX0kZshNn2fMKG003oPE0Cbda3XnjHRpzlGnOF1ai46QIzCoueJBc1J0L+XUqAvidNyE3ZxPdX/IMhmOcKj2DpCfthxMJGDnvx4oivPQb4vXEfM/CVwq0lWUSJsJRtolbLubZK5wmSc+nwXSTdtA7a5MkQlE2se1Gy6fK0jHHgIuamfBqiAOhJoP34ZLVN7dP3UC7HxiyavTy7CU6I1eWvlYgtopyV4oh3l473GOeb21K+lsdGUqMULbO+zGfkqtMwMqwVwDCl0qVHy7Vx4KqfOIijSISdFyaL3ifvg0AUYjlm+pLrd6tNnVPAH9XR7+tkYS+Jg+7Crbfeyi233MJTTz3F0NAQLk/xpqYm7rjjjprLmRBBf/755/nKV74SENSFpqYmCoXJbDG1oEh8ImwjAnH9qM0vjCvtso42AmEKhJmOQ7QnYqmPkgX8Z+Hy37ZNTgW7eUY/SyGaNpNbNUqT7UtuWM8qZBBlwFytzEbCTdhCLlbTe9jy1oqJnkjsIuRyjZ5MGbcdmxOlxXKu95lymWnznXTVlZbRVIoL+MqHyDCG74JTCk3XdqDnax7XMmeSNyFIQjQXNsG6w/EieYDvvgA+OU/jEbblcJiRfy1WQpHLJpPkZ1rqUNsuy6mr2UneQrCGVBku2WyohpybshNynd7fjU+e8niuKwW1r4A/MVR3e1ZyngaafIUqS/iS7MyF9CE+AWsjqIjZrNnla43z0uqXMY4F5KXy+YbBtG9kqzi/3lbsahDXxcOmFNrqJEomU6m0jXiYdKDfkZfpaqbbpc19pdb6kvzDXKar+cZMFFPIjDwwMMBb3vIW7rzzTicp19DrAtWCmm/98ccf58QTT+T555+PJWjMcOtWPP3009x+++38/ve/5/e//z1/+tOfKBaLXHrppXz2s5+tOV+v45WY7KYPbJyqqZaExiGeCYIQ1wnTDAThYepsZFPvdxFAbW2vlZDH6Vn2w94LQPzVOV3lx4G2xoO9LW4x8nfFXddEN47Lkknwwa5wxa1/PXEorGwdvtCsY5mQJ9byMYJEvlRfmaO8jrJXFWfqe7qp2sihtiKDR/AyQE8H9C/HW71TVvCUVVNFjhI5d1nkTJlMIq1lM10UTHIuBNplJdV5a3JnKztryKUtzi6ib4OQ8zhWVK1chEG7EIBv3QbfVUD8e7tL+a0lOAk0ILP0daXOuRffat5G8LWX7ce0nF2e8uf6jOj9YUqMfg6m8hSmGNmUr6xDFkEt7g7me2EqC5Nhz4uTp8u6H2efvEO24yapXU/l+6PfRUnLsc1Utjm3TbQ2WNuxBXEWYa8XppAF/VOf+hSrV69m1qxZvPe97+UVr3gFs2fPnjARd6HmKv74xz/O1q1bOeaYY/jCF75QFnQy8LWvfY2vfe1rk5DzPvhv01QkywPRp+wxTGQ2ddTkWO3H7HLPkPCPNiu4yUhc7hEY5wlcbcEmi+41C0Z6P0c+EB5FRazpLjJuyitfflvPL2nTNcbcBi+ChIYrDr9p5RcLvAsmsdf3JZMvqx2lcD1vmwuRhD+U43KOdtMxo/QYCl3bCq/T7DOytlmSdKdray5ZghFL5Lxs6Tc0AzbuwlOQCpRXBm2b67khh1mAo3RDkxDIPk3OtVxheeUt+0xCImRaE7gc8azmNvKTtey3wUXw9KthypWmNC+glF6PT/J7Sv9CpIUYWcsprd7ah/9MzXoBrx42E5xsKnLlCZLsKFLebaT1yIjpomRDlNJTKwE324hNqdPKrHm9Pi7E2fZ5qzVtk8U830QWd31ocl/At3DbUMAeRC6DV2+PGefGeSdrgZPkh5DOvdSC/uMf/5jm5mbuvPNODj300Ekvr+Zbv+uuu5g+fTq33XbbpIe+6e7uZtWqVRxzzDEcffTRfOtb3+L666+vQ85mFI6JvNUmpMOPA9OaK5iIH3o1stoQFR+6FuXBZYW1EUtbj2abZAi+5TPK8h3HfOJSCFxMZK7lmCDue2G6i0RNMrXJo2F7dmZ6GH/CoTlp1gYdJ91FyF1KhZmnVtCior2Y0D7trvYp7URHr7GRct0edbtTowDpFV6H2UfwVYrqoEwfUJMEFwiSJskzQ8nSOhfWHYy3oNGR0DPD7uuuyWZcmG4t2ZD7ibJkCsmwnddt5KtJhqnPhlnNzbqLgmkdtl2TNWSTus1QWpiplIcQX7Ga51QeNmLThmf9DlMmNhP0W7fVbz920i2yYMiWN84zrdHyL0pJlAU8rPuLa902zzMty2b+cVBPspYmWMe6PUZdJ/Ulz1Fgkmh5FtJ2df6iFD1A5fPSSqBZdj3gyj8u9lIf9J07d7J48eKGkHOYwONubm7moIMOakhcStON5ZprrqlTzuY4TZg5qBoSraODhMFGXIRcRE2Ec6Vtfs5hcOUlC/DUU3FxTejTKzTK9SYBMxUCG7GrloC7eglTbj1ZT8st51Yz+mLK7GojcZWzOGQc/Fj7piuPLerKXIKTY2336BoFcT0DM3SlKa9r4q/pmhRV17OUvJKv+M5r33ZTFk3MZwAvr4ywITBdIjR0p2d2xkJQCgStyNLcs/jkqQ+v8M29nhxZR3lpKjt+F0xiDj6JFtgUhzAIcdY+sEJGNOkT4mL7dISVI0pLXHIeZ3Jct5Ito34FSiu94lvN24B7CVq5c9iRwXM/Mom1wCTmArP+UcfTBO9JEz3dfnS7M+u4W23Lf5RyGaYwaaJvIixfU5ZquxFXtzIR0hrXVapfpXV7tSkhOs9s6V/qXJNxqeMc0W22HtDv9kThev6Tgd0NKicGlixZwo4dOxpWXs1N++ijj+bhhx+upyx7GK6lxwVxCHoUUTLPdU0KraeZYCIQ8lbNBFKdFmKlTRPmua7Y4CYBlzyirK1R1luzd5JtvXiPSUirJeGCeo6KuCKquCzZuwiS6II6Bn7oPiGxpj+66aPt8td3QbsVRZ0rZWrEsZQLxH1FlBWxlIsSYv5reTT57wN6S5FVsBMB16sZRjKzBCdGmp1kG/YwjSVxnJ2qS5+0wWbRzxK8J5trS1je2kosbhk2hSGHe5XEqHKyxF/yPYrsS16anGdLeYt/b16dtxlvACOn8tDbOt8+fOJvytqPR/xNJUUTT5cVXZQ6kTNN5SJI5rVyrkuRFKKm0xqmMmSre61wmjDdPKLymiji2pDkOaOOm6MStnZqUywzRlpvp/HcU2wE3Hy/bHnUE/LehylctWAvjYP+wQ9+kHe/+92sXr2ak046adLLq7lZXHTRRbz2ta/la1/7Gh/+8IfrKVMD8QJ2Vw2TWJkEwfbFiTM5LuqciSxaVOu1YRMSbcds+6LK1l/ridyjbcRB9rvMLDaCp10fXJZxSZsjE2PGsWoip8QJD5g29tnIqWlyEyJuswxr33Pb4kDyL3nqPFzPynaPLgJcDdLYJ2vbGOMM4x88tx1z9UWX240Or7gQuruCBCuOlU4TW1enKxZD6SRN66QmuaYVUadtHaz5GYpjnRZyYRJJTc7jWM6z+CRF8rHlKXVjNtmo/KXubPWCJW0bHTDlzaq8Mip/8QMHf8RkHZ5LiyZW5jNoA5biViKG8NxlctiJOZb9NnuCyClWfF2npmVdy6GP2yzzbZZrbC4wmrDrZ2naXvrVOeZ/XBIt2xhpW/3XAle7azP+tVyub4EodVjSpgIUZv2PWy9Raf3OuxSBesFWL5NZ1hTB+eefz5o1a/jbv/1bLrnkEs4//3wyGZemOnHUfOsnnHACP/jBD3jf+97HXXfdxQUXXMCCBQvo6OhwXrP//vvXWtwk4QVgemlbE6So6Ba2KCFQ+UaY/taTvWpoLahWpsm6Bxf5DjvP7CE0oTXdIszQhahjcWA+x1rqwSSeIp/5zrheSyGapi+1HJPrXCTXZkoT2MJS2piVwEZ8a+kRxJ3LjJduMgHwFdwuQw5XCEizDcn1zcB+kO31o7GEWWldnZHNMqWJTra0bZJfOc/mp2xWt1ilewiPfOLaZyPnQrg0aRsyrnMRpjRBcu4qP0dlc9D3H0U6enDXi5kOUyrknrvVNb34Fv9+vHvXz+sWgs+rnyDSpTwOwx3ucCOVEwRthNm8F73dXyonp/KVa6VNyvM0r5e2Yyp83QRXptR52J63aWHux/2ax339ayV3ca/J1pC3QJ63WRc5/EnD5vm2bRNx23K1ad32zWc1mdhLCTrAl7/8ZTZs2MBHPvIRPvKRjzB79mwn721qauLJJ5+suawJ3fphhx3G0qVLueGGG7jhhhtCz92TcdBHRkYYGRkppwcGxGo+A5+gu1aJFBTwre0TmbzZSNhI2Z6AqeLXEr5QkzXTNUjSYVFTooj4mLFd77bqUhBckPLFKqz36x5Ux8sOg74mKoqO7RqwjzaZ5jGb+cvGRrRvua2d6vPAn6Qq+3cBzxn52+5LSLmEKezzwhmKf3EYwo7byLmI163OGbKcK6QoG5K/Jlc9+CRsM24f6DDZtFwuIm2SXNsjyeJ2bYiSKSpv+e+pMt+wEYw+gq4e8twL+ARaCGo/sJog0ckZ+XUDy/AVLC2H5Lle7TNlte3X+du2bZb7LJXtU9qbPk8TcslXK2lanhzREwdtr2o39nvS8lRrCYbKT0jacq4tHWVpvyXiuA0uBdBENfdZS1rLYj6rendZKdyx0PfSSaJbtmxh5cqVPProo+XQ4Vu3bnWev8fioD/44IO89rWvZXBwkPHxcTo6Ouju7p60eJATwZe+9CUuueQSy5EMXqxPMwoIREfRmEoII1tT6R6qkcU2aVSjj6DbSTU+4mJ1nQyFUXy7q0WByjCH+lia6km+RjVRhcC90JMJ08pt7tfbrrqx7StZua1Yr7a14mxGZRLl7WBY0hx0yQh7RFFEYEjloY9nCU4EdZFzbTl3WS1lfx8+werFC7N4D3ZfcU0ANanJYidzOePaqNdB7i+MRGhCJuVUQ27Ech6HtOh8bc+zjyA57VXnrSdYN0LOpc5MK6oQ2xWWskxibpPT3G/CpQyuI6hYaeVFt0edTx/BNi5tTiuOOdwL4thk7DbS+r7ywA0x8zI/5aa9gYh03LzC0rV+9uN+1sM+hbWkIfxZhV1XK9qA1wI/dRxvpXGTRCejm64Rn/rUp/jTn/7EwoUL+cQnPsHSpUunZhz0T3/60wwMDHDaaafx5S9/mUWLFtVTrrriwgsv5GMf+1g5PTAwwPz58/G+bNMJRj4ZC0ljpMP8k81zq01P5RjoE0EcX33BDDxS6iLf8rV1hcoErx5tPepEYZJlW1sxsZ5okiwhFudYjsVVQmwuOGHlxiXjtaBahaVPbev73UgwZjmW80y3psNhWVP84VjbeWYHnzf2ybYmltKZmu4oNuuwrWlK81xIkJxLh9hHMEaylk2j11KOyGez0EYpLaZ/s4bLih1GoE3Y5HWlpUwb+giSWiGnaTzCq0cm0niv5Wp1fr/alv9VDjmG8CJzmAgbLbDtD6ufHJ6vu4bp328ebyNYn+DJqm0AtjK7cROvH1FbaD7XSEIt6XrkVU8iOxnYbNnXCJkXElwgKyx6Stxvaj0whZ7XLbfcQltbG6tXr2bevHmTXl7Nt/773/+ebDbLddddR3NzLREuGofW1lZaW1tjnl1NxBLbMXORnV0ECbsZ49okUnvSTz3usuz1xiyCfsU2uEwjwoqGQ641x0p1fq607Oug8jWxtfeNVPYGYaRYnvNEyTgEF/qxla0ty9sd59QLelVRG2wjU9q0aSqsz+GPcNlguqb1wrK5biJpQ1Rn4yKfEJzIOIRPGk3yGEZ8BELO03gks6eUFheXPF7nncaz5D6A2yfY9OEW5FRZNjltcFnhBS4/fNmO0oczVOc3rJUR87VdSNDfXPIWIi4Qhec7BEcjzPpcQpC0yH8ed/zqMNRCbPT5QpALePfQq84RBVCfn8NO+NqwL4T0AMFVTfX91GOS5t4O/T5oq3g1iuxEId+YlYQr3WEEfS91cdm5cydLlixpCDmHCTSHlpYWDjzwwClPzusDF2l2WdBd5+l0I8iwVhRM2KKG1AqxdFeDsMg4LriWmg+DzRSnex0boXS16W0EwxaGyWI7bvpRV/vu2MImhsG28JBY+auJsx8FXYdh9ySuRe14Clnacb6somlTPCBIygteeuEh9lCFUYiyGmvyZh4Ta3hOnWNaGNPYo5FgpEUJENIlcvXiEakh/A5d/KjXU0n4XMRcT1TVJDMKromsko+uH1OHXlqSfV3pZ0OWSp/2sHqykXPZ7iV4/xn8ul+vZBaF51sEn5dpOT8Mj5xrFPCiu5jtIopgmfYEvS8srZW2XGl7GZUTQ/WcigL+/ernbSPlQsi1Rd6FKWTJnPLIEW3N14g7mlItpMw+/PkYQsqjyhkNObaXWtAPP/xwnnvuuYaVV/Otv/KVr+See+6hUCiQTk+hGqwKQnhs1tM4MN016lUPYZMdbbBZeV+s0MS2XhZeczGtKGK8C9/FSJQCk7Ta2soYQZccFwGNA+3iFJeMx/Grbzb+zf2utAkdqjIOOvGeQ5TyM4hdITbLS0PvIb5HTC1WySiruYsIZvA7uRyVpFFIkSbm+npbWULO+/BJsZApIeeS5+14hFfcbcSFwyRfIoe2CtvIuUmsdR5Z3AvSuAjdEoJE+dhSPg8Q/NRmcVvObXq1fiYmdN2Bbzlvwx/cknpqwyfnkq9pzVxB5SJVebxFi0zrskuBiyLrYelegnWzBngLlcqSOelVKxzSNqS9glcXawj6oMf5vIQpTVFp2TaVubDr61V2vdPmv0up2pPowzceSHuHoKyud16noyzojaIcU8iC/olPfILTTz+d6667jjPPPHPSy6u5ii+99FKOO+44PvOZz/DlL3+5njI1EAW82Q6uL6ygGpLVGXJ+mvjLv4fBJu+e/irEbUo2i+5EibiEOJKvoxkG0/wC6f2aiNsW40Ed19BWXCGe5oiK5BNnnkG1rk3mAjyTjXbjPwpp/MWf2rH3AhIq0gwZqRUbo7y20gqfC9Wp1Vgko5qpJtsmsviWyyHcVkeTFEWVBx4hW4Jv4RJyP4RHpoQs30vQOiokS3fEAtNPuaB+AhdZFILrgs5XXytEWRQZqYc+/AV7IDjVIA6pMa3BGj147UGeTbfa3lySVU+S/BbBVUHNeQVnWMp5jKCriKsO05Z9UUjjKzSiFPTjx1EX3AD8PcGY7qJc5Ixys/jEvR/Px96ct2CTP0pODdt7MmTZZ0M11uWocxudhnAlq1HENYP3HhXw2rY5v8WFOApiFFpLv0YgzJLfYPzN3/wN//Ef/8F73vMe7rvvvnJ48ba2yZkxW3NTyuVyfP7zn+ef/umf+PWvf815550XGQf9Va96Va3FTTKiyLhJ+GSI3oY4LgQQrrKH+VO78qsXqnV/aIQsZptyxaEPQwHfymxOigyzjGvXjU6LLBouxUw/T5cvdRzUGn+9WpgEOa5ZSBRQ28RQvbrpduyToHWccskP4BBvWD8bUmxUWpNzF4F3kdc0wQgYYs02yYiQ6IzaF1aWEMcl+KQ2i3+fQs4plb+m9BNybFpLhcDmLcds92eDvgeX7C6lZAXBBV+EMAjRXGbIqvO2yYradilNPXj1l1FpkV0syjIiUaCSnGs5evGs/brcIYKTQAtEyx4FUVpEIdPoxxsdcRHdhaqcjQSJeRpfORQf+dWGfNUoszot9z2EvQ3V00odZZXek+lGyqbbkyjgGTzXq0YgmSRagVTKN+d/9atf5atf/Wro+RMNL940LsEcq8S0adNoamoqx4KMCjMzEUF/85vfcNppp5XTQ0NDjIyM0NHRQXu7b2H7wx/+UIrOEo6BgQFmzpwJ3IEfBx18MiZf6zC4SKm5xDm4V42Miuqyt6LWUIUCTWLXU1mnNquzEENZNKfakQ79fIV82r60NkuyLS3Xhk2QrBek/Kh6t5kwJZ75LOM8k4jbFAtb9BXw3r0Z8AaVXS2I04nYrMr6+m6VHiK4dLYmxWIFjYKUJeS8D38Sorb8FvAIWL607wE867mUn1Myr8AjoPfg/nRpUu0iY9rK7IKNoC3BJ47aCpyn0u2iBy8OddwJh6YiotGLv1iQWX9CXoUM9wPfV+X2G/fRh69ACNYQnFTraiNxPlUi40LciuY9jjI0Livltc6Sf7Z0/Trgmphy2aBl6K8xjwTxoD/1WbU/S6Wy2GiMDsD/m8mOHTuYMcPrD4U77XgSZkQtHVMnDAzCzAUE5NhTmDZtWtXX7N4dpumEo2YW9KpXvaphMc/HxsbYtm1bxf7h4WGGh33rZLHoiqrvwsuIR8RcKxOGIY5Pb7V+vy8VREX6qBby9VpvOSZ1qucaUNoOGwmJwjDR1mzb6xXH3FvAnyA5WaYKGRGoBqLEpPEnvApE5u2Evy/yPCw+5X0HemRPW+1c1RMmov4PQ9ikOO1DrQmx6Zeu3VHiQIjeQnxCmCHoW1zAI0ZCulbjRwwRWUSGkwiSc/Begz5Vps2XXqfFah41SmtzazkMn5yL1Vye0cbSf5v6iWV3YYzyhJjrepHtXrxJqJJHNz5BFcVGrI6P4SkFcr24qkhefQTJeR6PnEv5Lot5m3FczrEpPguxKz+igKy1HLNZV/+x9NOfhR58V5f/a8gWB1LGEJV1Xs9Pjy3PKHuFCZeiNJVhu+8MXhQVQdQ9NdqKHPEcxqfBeIN8w8er58SThomQ7VpQ82NfvXp1HcUIx0knnUSNhv4YqCUyyFSF+PxCvBjtkpbtahezsUETv2rixUfJpvEclW4puseyEed2vMm3YeOLNsQh4vWC6XpTr69yLRF29DPow/4c9GqetogxWuEUK7mxb0WvPYpHNWnZVy1JtuUlpFggFkTT4uuyVIeVOYRP1jQ57zbOE3LeBtyE3a0ljdfBZwnG8BY5Nxr52sie/Me1/OvrKN1Dn5JVKyrrCI4sFICLVR4P4BHsrKMsm9VcE+pjVTqLT877CZLzB/DqR/LTFuE0fhhFjXstZetrotqjkOMMbou51Oca7O5IrnQGT0Hrwa/X9XjhIk3ZbM9cp6We88Y51cB1/mH4ynajySV47T/sOdYbx+KOoGSDazRGH29UvdlkuQf3KqJAMe39GoFGlTMV0bBbHx8fn4KrjA5SvRUxDibipx1FpqImINrOi0rLti57IossmQgre8yxDUGLbBhcE01tDMpFynUIw0YqbGJ5rgdqGZkw22af5Rx5trsIrnRSwK28mIsGCRb5/uQT/fpUOy8nzJ0lQ1BRyBG0mAuEBNmsoa4yJY8ePFIt922S8/7ST9wybsAjcDbLuZDze9Q+c7JjjmA9m+Stm3jPQCab6muX4VvO9QjAOnxyIfnfg2fBlldPSPIaPCJnKihh7i99BFfzzOIm5/fgr7oKlWEUl+JPNi5QWZcY58dpb90E3X1c2Eww9GNcpPHaxcWl9L8YeUQRfCHlNmWtWvQQnFfgUpz3BHrxJvtOVdRihKgXTGX7MSrDQqaBELo20trESGtj+NxI6zjeiu97Hg8//DBHHHFE7PP/67/+iw984AM1l1dzM/je977HO9/5zljnFotF3vnOd3LVVVfVWlwDYIvCUa1PeNTkxXq7sEymi0y1YfiiyrZZxZvxlKQBy3lRkK+JnN+r0iZJtfWCUmaUtb4esPmQT6Qsk4jHnchrPiMZUZC8zLoo4MUj18dslnIIur/If+m87kW+r3C1MPWpWvIII31ZlWcaP6oHlmuExFfz1RRfcyG0ko8mx0K+h/CtrT/Cc3vQ7jUi4wr8iC7aHUhDCNMQnnVPyH81xFzylddH/pfh+81nlcyiuwlpz+ARyFxpf7/K4yR13Tp8kq3dcczXNo1vrYdwcn4DnvVc++xrrCLYlh4w7leXqf9tkDpdSKW8kqdgPX5kmbiwlf1/iI5brpHHPcEzbrmiGGUd54ZZ63XarJd6pOOWvTfJZsMQvhId1n4KRFjQ0xTTjSHoxfQ4U8XL4eSTT+buu+9m0aJFkedefvnl/OM//uOECHrNk0RbWlr44Q9/GJi8aUOhUOCss87ihhtuqMFHfHLgTxJ9gmgLuu343uIrPhHoaDY6+oi2VFcD+ZLoMJZmHHoXzEmbJkxZa5UtDuIqfZqAC+mdKCRGu83KLpM6bf7jtsWR0gQj3KTVdq9H4LqpboVIG2yER0RxpbWYecf5psV8CL/D0iRNk804TU2uk3IzePGrhQyariDiOyxE/gE8l4xc6XiOIGldhh/RxaVISDkQXNRmyHGu6z7MDjyNp2gtpTJW+0Z8S3UW3zVHyszhKw2r8F0z5N7FCu9CDx5B7C6lRcmR+htSslxTKhsqiWkab/Kx1M9mJXtYPbqQIRhFxoWCKivOM6iHBVXacVxibpZ5GMGQjgleHJBnvRl7xKKw6/Q5xQH4s32S6PodbcyY0RiCPjAwTt/M/JSZJLr//vtz9913hwYk+Zd/+Rc+85nPkMlkGBiofYS85teutbWVs88+m5tuuonXvva11nPGxsY4/fTTuemmm1iyxHT0mwoQkqGrQYd4q4Z4TRQ2i6fLWvliwAD2kJNxoUlftS/lLuPfhI7i0qg44gLXIkb1nDRr1put/vS8A/AWCoLKetHvhvYjl//SRNtuPBLVVyfRze2w88y0zaqcVr8MfoxoITB54xo5txprs76+G98PV5ebVe/CULNPntrwLOb34HeqckyuF8K0xrhHUz4hlX1URoYwLfKue9DkXMpfiO833g1kxrx72Fg6N1s6bzX+pFYhyG34E0rzeNdsJui+I3VkWg2FnIuvfAboHoO8qr/u0v81ePWYJuiaI5b3kwjGBxdroq0e5b5NC6UgLjnPl8rZjL19u8quBVpBNJ9hGNrwQ1SKYp2Q8qkJ892V9yyH/y7liGdRN4/rZx7Cv3eTohh2Qh2xu07uLZ/97Gf54he/CHjr+Hz2s5+tOo8vf/nLfPKTn2TlypXcfffdzJkzp+Kciy++mC984Qt0dnZy8803T0jmml/BG2+8kVNOOYW3vOUt3HbbbRx33HGB4yMjI5x22mncdtttHHbYYfzyl7+ckKCTg30IEnRXS44atzIRFYLRxBbH/rhwuefETU9mXHNX/HdTKZJ0B0Gy6pKlYJwTh4xP9mRP83WaLALuKlNitM+iso1qy7heKVUTclve5qTf0sJDbc2+D6ppeTGziBrCtW3XAumozPLlXxNzbVk15U9TOVk0TtlCUhfiEUrJsw3oHmNa2yi7C6XQB/1t/mRQ8CzOD6i8hozrZURirUNm834z2JUlUTr6HdfbSJ3c0xK8Z949Dm0jkG/1/bqzpX8ZAbCR8z4q44pr9BMk6TZynoVp3TvZnW/x6yhTKutH+NFQ9PMV5UKUJSEzj5XONetBytZpDbH2L3Tch0YOb6QgR7AtmuXZ9ruwBH/UIUdwWojcdxyI0pLFjzLzYrUHvZShv2lCwAVDBBfQErjaUp2eb4EUhQYR9EIdCPqf//xn/u3f/m3C+fzjP/4jAwMDXHbZZbz+9a9n9erVZLPZ8vELL7yQf/3Xf2XmzJnceuutHHPMMRMqr+Yu8aSTTuK6667j9NNPZ9WqVfz617/m5S9/OQC7du0q71u6dCm33XYb3d3dExJ08hD2JRY2IcRGINu21i5LlttQ69the0wT9RG3TRI10/Uk6totRXyoXW4broWDhomuQ33tZMUPdxHxduN4FDOtNq3L0uEKbT73plvKFoLt1jah2IxL3ozvFtPsdearjGzjWOjCrINCUE0rYli6YOzXFlDzdW4jGFvcRczTxvlxZRFCK5bHs/Ena5YIUHO3P8S5u5CCXJvXybbh/d9D0CVDu7S04ZOnx7A3CTOdxfM7D3tVevDdSwSmS4uQt2X4i6N0j9Gc2cVYvgX6m/zywCPeNxEcmcjgWd17S/f6AOFKWg7/vg/Dj4WPl1dz94BX9lCzrxCtLZW7UeUh+XfjrzQq5HwNwRGTsPZpWtCzpfuJgljo12MPF2krJwxy/DA4/fLvs4l5HMUD3MypPHXCoX6d54mXVxavTvoIb1N7AmEKaDWIGtmYCrApU6ahwXzv4yDK1hgHIfx7lBZGaUz8w9HQFZOiMT4+zvve9z6am5tZsWIFv/rVryaU3xe+8AV27NjB17/+dd74xjdy++23M336dD72sY/x1a9+lVmzZnHbbbdx5JFHTqgcmODruGrVKq688kre8Y538PrXv5677rqLefPmccopp3DPPfewbNkybr31VvbZZ58JCzo52EW0b2+B4FLkcX2I475RcSyrslz6SxWmIhAW+tI2euFazKcaEhzWe0JQaYm7kFJYzx8nbU4ETeOO8qNJ9y4qo99opbFEuMsQC/lcVU6T18EJQTIJeVxE3WLc82zX5S3H0+qXJdjZ56ns/ERByODu0F16u8jQh+c60Vfa3wZkxsn0eOblQslqnh/qgKE2n0Tdix+fWwitli2LR1KHCHbSYRbfLJUrdtqatsiZc+SZKeWzjLLCMi27k47MMCP5Vk/JAN/qei8eSZY6FuKxjEpyLjLYRjv08RUopSlPW2aYfP8+nmIgitQavDoUK6IoXxn8yblZfMvjWlUnZvsJa5tZfKUh6pORJ+hv7mrLcUn5CspK0Lkf/gYd7GIOWymSZiW389/HHurVfRSkznrxQ0tG3UuctL6PISrbUrXfjCEqF7iqBUsneL2JOJ/8au91zQTLroci48o/5H6LpCg2iKBP1JXm29/+NnfffTf/+q//yqOPPloXmb72ta8xMDDAlVdeyZve9CYWL17MN7/5TWbPns3tt9/O4YcfXpdyJqwvn3322QwODvK+972PlStXsu+++3L//fdz7LHHcsstt+xxp/5wbKU6K6vprxwWVjDupD5zwZeXCqqxvocRctvXxzbpYiLMzzaaIPsbZVLqMNJhZBwq62ULQRKu69RFyPtK/03AOJzU5A4fWGs1hJHbOGkN009cXyM/GbaX80xfXNNinlHnu4isCcm3F6++zlPXZsYgXWRmd84/vZBiNN/qubWATxRvUfclMpbzwSODOSpXc7TVqcu667LS5vBJv9SB1EcW300nDWTyZLKDpNJFioUUY7lOf1JrAW8E4Hb85yPESqzXQ3hEROpZ7tmULY3vuw8e6T8J6PbKH+rPwlCT52JTaPLL7Vd5ilX9MPy41EP40SvAroNr2TD2C9F36e46LZbzjdit87ZrbCjg1X8bfOhTX6aoLiiSogNvgb4utrHq337ITTe91Z2nEPMeKmO+12pD0Iqu3GcBr02ZipcLUd+BsGNhdStYG1OOPYlqvof1sIq7yra1/xDi/2Ih6M8//zyf+tSnOOSQQ/joRz/K3/3d39VNrm9/+9sMDg7y4x//mDvvvJOenh7uuOMODj744LqVURf28Xd/93cMDAzwiU98gueee44TTjiBm2++menTp9cj+0lEnuos05ro6EWBJopqWYtOmxMxo3zOq0XcEH4mql0AyvY1qDWqigs2pSlN40YnTBKuZQgj4yUCXbaSm6M6YK8n3Vb78F/30gfvLfiW1Hr5E8axDkaRAA1bZ2+WIeRUoC3SBWNf2SJLPIu5JiSSV3fp2jOAtpJ/ZLoA6SKzevwVj0fzLRQKKfIbZ/mv7Fq8iYz6/rQCIXL1leTPqfJtMsp/Fo+cx/mi5wla5IUs9+AR0WOBNk/RaG4bpTM7WL6fof6sR44zpetuxyPK8pxy+CT5pNL2GqN881MmMouFWtf5vcDSNoZ6WyHf5B3rb/LyvEnlNYRP8MVXXtrAY1SuCipl638TYm3uiThPIJbz9dg/Z3GV1aVAFs686Eqy5BilFYAURVJ43r9dbCNVioO3kHXeSNftlvxFSVoYQ/4wmJbxzfijFpqgx4V+L00SKumwYy812O4Vy3YYFYh6vrbjNbYJryVOfYL+0Y9+lO3bt/PjH/+Y5ubqIqE9++yzked86UtfYv369Tz55JN897vfZfr06RXX7b///lWVqxHr8Xz3u9+NPGf27NkceeSRPPnkk5x99tlcf/31Fee8613vql7CSUUb4RZsm6oeR3WPA9cbKGmT3NrStmglJlGzETcbwY66z4mkzS+Ieb/myEQ9VjM10Sgi7ho9SVPpGhP24dGEHPyJnZqk67ylrYr/+NzSdqmMY/EJada4tFa4rLO1QN9OmAXOJOVmpyZkV/8EYil2EfMwufL4FshjKVvKp6WLpNJFOjLDtLd6Vs0iaUZHSmQWPBK/vmTxvdeQVYijWK8X4pGqzdijrej7F2XDJLZR95Mz8hL04pHDkjtJ58whUhQokmbXznaGcp1QSDMtu5PdQx2wusm7H13nQgqPLeW5TpWln4d5H6IgmDIN4bnGbG7ylJb1eDHOhTAKCW/Deza9pTzyeFbsfuwRenTZNmTxR0jiQMrbaJShEbVvGdADiz74MK/ibloYpUiqTMzTFMmSK6WLDNLJKC0USLHi8l9yz9+9zp+AKxbzuO3CBv0+rVPpOPel8whDmLIepci/lIh6rfVgbteDmsRAkXQDLei1+aDfcccd/OAHP+Ad73gHJ554YtXX9/X1VbW45sknn1yxr6mpiUKh9oYa63Ged955sQUdHx/nQx/6kPXY1CPoc6he7XSRTBvCFj6Ksgy7/IfjXBuVHwRZTaNDDZqIG1HGltZIq/1pxzn1gKtcqBxVCSvfnJ2uJ3buwp8U64qwIvnPKpWrylqK30nX+6MdZgm06WRhFiA519X8dFmaXJuWbRcx10Q2U6Wskk8WjzifBNP6dpYPt7SN0DlziFZGytbMYToYHWlhMNcJ6aLnq70Oz2ouZNwk5kLOe0v/64le7VGIeR/BxZbCUMAj/uss+RVK5QKL9nvcUzJoYYRWBndkPP95oDk7yNjGGV6kFiHnck/i9rO0tG8dvmXbZuXThMLmfmHKth6fcMvzzuMrNmLpHsK38NqUAr2t24BuJ0uI/94M4YeNDLNouvJbAiyFg9/+EMdwH62Mlkm5tK1OBmlhlGHaGSy5qG1iHsMlo0MX/cz+n2d5/o37e/fQi30h5TiQ9ikjAkPG8Wqs2A0ijHsNqv32xk1XaYMsMo0iqVgiTxSyeo4ZT7y1tZXW1lbrNfl8nr//+79n5syZ/J//839qKnf//feviqBPBmK9Pu9617v2uKB7BkKObEvTR32hXAR7MkP9uUi4eWyqmR7iRJTRaRsRt51bL5nSEWlXueYSxeazHyToouRa0ED7xXfgR25p8km4/GcdWdSCuAQj6lyTTGP5t10rhEnSsm0S8TAf8zb1iyOrzkOI3xJoXjpAKu0dSKeLtLSN0pEapoVRwBvyHaaDwR0ZRvOt7O6f7hHKBwiGTxRyiSqjB99SuxH3CIJZL31UKmCuzlYsvOuxP5sssApec8RNHMh6+uliA/N5dMchFAtp2jLDjOZbGVs3wwtn+JjKXyzYvQT95nMh96GfaTd2NxLbvWRKskrefaVfpiRHPz6Jt40+uNpwG/5zyMaUBYIx3XU5tm0TfcBK6DntKU7mVjrU96GVEdrZRSsjFEqOLTnm8AJZhkoEvYVRsuRIU6SFUU7mVr5/2d95cxt0ew8jYPq9EVIu9ehqh6YSa4O8pxMh6JNF7vdE91cNCa72vqO+ZxNNWzBCC80NIugjJYpuLgz0+c9/nosvvth6zWWXXca6deu44oormDu3tnl+69evr+m6eiJWU/jOd74zyWLsKeQJJ3VRC97sCYRZu21Ltb8YYRJgvb9A/VxVXKTbtL6nifbRHjbSpuW7QCUBt7kWmZNUJRzlDH/lxgw+Icqq7GuF2ZnWo3PVsBHzMFna1LZYzOU6sSwL2cU4rom5ziuujGn8SYa90LZsO+m010Gk0kXaW4dpZbQ8Sa9AynM1KLYymOsklS6wOzfdI0mrCRIhTc6lnIWlexSXFpc7hr63NHZybp4v6QJ2cq7lOBtOPPkWFvMXABbzF+azgfTMIpuYx8Y/LfIUjXtLeaXxn0UvPrntx/fBtilN+j4o3YfL0mvKKhbdAr7S1Vs6byP+iqK6TLM8W5sW0r/QIYftOq30bLYcd10n5b0F2lZu529m3kCWXNka2YGn9LUyAsAW5pat5NvopoPhMnEXFxhBJ4OcedSVXPfAuUGrd1QbyeErVUPqHG2ddcF2f666nizCXS3iylHP7jOOAWOqIYR/7ybdMAv67lLfu2HDhkDQEZf1XGKeH3nkkbz//e9viIyThanaNBqEXVRfBVOB+EYpDHtavjC4yLccQx23TUCtxkpunttpOS75K39tJ8Zwj0TIyqlRypOg3fgXeWZA2wzfv1oIZjfVEYi4sHWmLpLnSttgWtnCLG0QtJRnjHO0NXQIO9kXMq9JrCmraTW0ybYC6IPM0udpaRst7xZreYdSxHJkKZBiaGcnqXSR1rYRhm6a7ZG2ewguiqTvIYtHLOWeN+K2Novcup7EfcGmSNnSG/FJtc5TZPl7eP3yn7KAJwFK5G+ELDleyx08wuFsXL/I8/2WPPP4y8D34S+YY7qViDymAgh+HO4w2eVayb9f5SH3BkFCalMIXOjDXxlVI6pe83iKiIuc296hNN7E4mPznLbfT5jHXwHKfuadDNJZiiq2iXkUSbGB+eVjWXJ0MmglRnpf29nbyX9HTTp3Wf9z2Im5PkfXpe0bEOfeX6x4qdxHHMi9amU5pDsslpywGgFxcZkxY0asqIAf+MAHKBQKfOMb32DatMb4yU8W9qYmaEEzPtmNwzoEE7Wo27527cTrbdNUEs0XG1zRTGyohpDbCHhUXuY+0xKuIS4pYJ+oaVrNBXq1WkGHt6+vK9gJymS3LPGbYxhq7UDjWGYFNgJucy8wkTG2NTnQ1vGcI18h5ea2CZfCoX8rgF6YedJmWlo9Yp6iQAe7SFEoEyfwJkjlyDI40kl76zCZ6YNsfvAg39dcyJiQHrkXcefow3u+66kknKbMmpz34i+IFMdKmS6VEUbO/xFOW3x1mSy2MkKGwYC7RSeD9J76BBvXLvJGBfSEWQiGFTRh3oek+6hc6dR1Lzl8v3zzHD0iIeWHuTMJevDdhGyIau+iLMR5v7J4C3wty/PG/W6mT5z9ody2hIRvYl9GaWUT82gtKUlyzL+mGMh+E/O46ckzvES+yVcI9UiURh7fFUgTc5fia267/hO8uCBKPgTfS6EZITRnTxD0uPjDH/5AU1MTb37zmyuO7dixA4B//dd/5YorrmD+/Pncf//91nw2btxIb69reK96bNq0iXnz5lV1TaxX67rrruPMM8+sSSgTGzZsYMOGDbzyla+sS34TwzB+FVQTOURXW73cLaohrXsjOokm63HJvIuEF7C7objONVeXtRFxJZe87JqsHEvQUuhCnOPV7J8o4lrITWgibhLqIWPbRhggSMZdpNwFBzHPrHie7PRc+TQhTWIxT1FkuORgMEorw3SQbc3xzB1LPAIprh9t+AqFVjLa8Nxm2vCtrzl13LT6mtu9eJ1nXJed9QQtzGa+GeDiPG/b7yqyJUFMcj5IJ+vpY5BOlnMf7Z8a5okzXg63NPmxxTcSbr027yWNZzmP0+8V8Bf8MS28JqRecpZ71XKB71YTty61PBvxXW3MvE2yUwBWQeaM53nl9N+WRyjAIzidDNKO5zK1hTlso4stzKGVUToZLLu7mEhR4EbezDOPL/HdbL5vnNSDPzdFMIQ/NyAXcp9xRwTCRtV02lVPk5lOZAvCbAsQJOgaMfqMxk4SNYMpxLimWGTLli3O40NDQwwNDdHW5v4ILFiwgAsuuIBPf/rTHHDAAVXLALB7926uueYavvjFL3LWWWfxuc99rqrrY3XfZ599Nl/4whf49Kc/zemnn057e/WkdO3atfzHf/wH3/3ud/nMZz4zRQi6hACA2halqWZBogRBpPEjnpjRbmznxp2kLG4orvjvBYKmgTHHefp8M3KMaQ7Ux4Ce3uApctpStR1mmTL329LyIXd9YON2AnHT5oQxTcptcmmIK0eaoCsLVLqvoNI6n6xRlrYORnVYWt48vmK0ENqWbmfuzK3l04SUC0EHyuHsRmhlmHY62EUngzx156GexTxv5K/rSghpFt/XvJ9w6DaTLf3E4qvPcT2z9QQt2mb7ysC0y3ZyztyrygqI7Z7X00eOLB0Mk2GQV7Oa4oI0T6UPrbTAupQ0fS99+JMxzXNs7U3IuTwzfVxQAFZ6bh3FQtpzM/rWbM/FSEPKlX9dJ3HeBSHnG6m8T9v7uxBYBUcuv4dlPFjeLYsMtZRIuLixbGEORdJlYi6hFDUJSlHkf3ecR379LC8G/GMWWQRi3c/it8uNpf3m+xVH8Y9L2qdKeirJ0kjZ0vjrNOj93UQrpOa3dJP71BFaSVfNl2rDSJWKQC6Xcx4777zzuPLKK7n00kv57Gc/G5rPaaedxje/+U3+53/+hxNPPJG3ve1tnHLKKZFW8LGxMe6//36uvfZarrvuOrZu3cq+++7LCSecUNV9QExGesUVV3DppZdy7rnn8v73v5/TTjuNU045hWOOOYaFCxdarxkaGuKhhx7innvu4dprr2Xt2rWMj4/zlre8hXe+851VCzo56CToFpGQ7XBEudZUo+Rowl1NvUt8cIFJrM2VYbXfuGtRJRezkH+bQtoMbXN9/U6TjiXq8mqtdC4xXKLFva7aNAQ78LAqsm1rUm7qMpqU2yKwiOKRJViPrvsNuxdtLc/iEfMlMPOwzXS1biNVKjRNsWzNTJUHcAueKwudFEnRwgj7kOPPDx7pLTh0L5VhBkX2NL4rS5agJdimxNjqsht/InBcgrSeoNVcyyP7PjvGWXOvVaMDhXIYv2Jp0quQ85aSVX2UVn7LK3nqykO9+y6ovKOs5nIP3Y77sF0L7tU4RelZASzJc9x+v2Upa8qRT+7+8Anck36dPw9ACEsW+/sY9S7k8UNGumTV+/ug+SMDnNL1c7rxF66SiZ0dDDNScmMZpLOsBLUwFJjjAL47yygtXDtyFvnLZgVJtuu9FUIuyk2e8Kg6YfvM92ki6clEvWXTx+NYretZT7ayNUTRLKi0nhgf9r0Mg8whyRNK0Hc30MVldw0W9Hrguuuu4/777+fTn/40v/71r1m9ejUA++67L0cddRT77rsvs2bNorW1lVwux/bt2/nzn//MI488wujoKOPj4+yzzz5cdtllfOQjH6nJsB3rEX7gAx/g3HPP5Stf+Qrf/OY3ueqqq7j66qsB6OzspKenp0LQ5557jvHxccbHx5k2bRpveMMbuOiii6aI5VzQTuNWkZxqCCPTuk5kFUvZngyYISnD3I1Mx7go16SCZdu8b7MNmNFdurwOvoAf0g2CQ4Tm8KHtQx7WqZrXNRLSgQvMDiHMwqbzMIm57C+E/HT+ZsfSRrDeiJE2ZRZivhRYOs7sBRvI8gLpEgkHVJzpEdIUKZBilFZyZBmlpRyLup8uNj98kGc171f5m9FZ0nhtYwm+G0jOcr+2+pNt7aIQt02sJxjuD4IjDQth0UUP8wrWlN1aADoZqiDnw3SULee76OAn2/6GsW/NKMdKJ40fls+07GsFI0ul9T8KBSpX49R10Ae8x/PnnsMW5vFXWhlhhFa20cU8NnHwBx/iz91H+m5HppIYF+uJDhmpt1fAYe++n0N4lC5FzrXLyiCdbGJfcmSRxYfEam5iK3O4i1fx/M/39xQjIec2MqfborxfQwS/Ta53x0XIw+63lvRkot6yiVI3FZCl8hlljHStdS3tWytxeUKdvxvrg75nCDrA0UcfzR133MFjjz3GN7/5TX74wx+yadMmNm3ytBcJPz4+7svY3NzMiSeeyLvf/W7OOOMMZ7SZOIj9SKdPn84//dM/cdFFF3HjjTdy7bXXcs8997Bx48aKAPIALS0tLFu2jNe//vWcf/75FTEsE8SFJo9x1e56u95US8xNQi/pArDdONe2QmocRgjRzbcZt2+/XGss8NONZ53ThEKTpAzVkQ1bx+eyWDXK2qSrVyxscYa5bfs1KdfnSn5D2Em5ziNb2nZNaoubNsvJAiugbYXnxqJdOCAYa1ovNDRIpry8uljVf3fna7zl5Tfik/OccU9pfP/mNJ7V1XR5sd2/rrsMPjmP2xZk0p9pcdbXL4EVn/olh/NI4NIu+mkt+TkP0smTLGCE1vIExWE6+NmONzH21Rm+ZR58ci6kUCtXGXxFtlriUMAbnchhf3e6gXfA6fv9iPlsIMMgaYpsYS7b6GKEFgCWsob5Z23gUQ5h408XRbsVmcgRVKyirMw9wNleHPmFPFluT9LGPKt5C5tKIxMjtJR9zVNKWQTKbi+3b1vJ2E0z/EWabOVSki+ntk2bhDwD001N5zURgrenkaFywqNLuasWEx0BrRfqJYe8rwV8a7n+RgvSELaAZ4FpFBpE0As1riRaTyxZsoTLL7+cyy+/nCeffJLf/va3PPPMM/T395PP55k1axZz5sxh6dKlLF++vCZruQ1N45r614ANGzZYBT344IMnpDlMJgYGBpg5cybwNPWJiBJFhqNDA01tmAqYzYfbBXORpziTceMqGLYvrwovZioWb8Dtl6v/szGKrlY0TSIb2RFq65ptMKEaSCdus9xIfiYh1S4s+pqscf1EIR2PIAOcBItOfrgcASOtLOZCvFtK8aaLpNlGF8N0lCfwyXLqD3/7WI806o7M7NQyeO4zUhfrsU8CdVksxeou1uZqyPla7L7vIksvnHjpLRzCo+WQfjpCSIoio7SwiXlsYD4dDJMlR4EUNxbfzPaL96sk53L/gsNKcmfxY/VXizyeEjRk3If8Z/DI+VHfryDnEv1EW6O9ib3t3M2reOo3h3oKUxjkea7Ff8Y2mN8MURoO/T5z2BoImyiyjNDCX5lHP10USZfl1BCf8/++78NezPmN+CMiph0GgkqSSa4y+CMYafzVVau1mL8YYH6TzGNLCB85mCokfDIg7UOs5Lqt2L7NGqMDcN1MduzYUQ5vKNzpOzveQMeMxrgEDw+Mcd7MWwJy7C2Y8Ks5f/78l5h13LVAzospyoprRUoXosJG2qKeSH1IeEiBa9xU0lGaZYQf+8qO8A+qzRJdwPdFtUGfb4qu0/Xo3BplIbeR8WpJuSYgtv3grzxoWuVtZWniVq96MMvqBk6C3hOfKMeOFoj/r7iyCCHqp7tE1VvKFs9RWrjnytd5HdtjKn/JTspsA5bhr2SpfTjlHk3iLP+ynSXc1zwMj1HpG63/2yrJeYoCWXLlCCFCzrcwhw6Gy64Zt7OS7ZftVxnr23wPuvH9y/uJVnBNC6fkuQb3hNAscIZHzvtYTyeDDNPBeuaVRzwkTrg8V29C5i5O4C4OOf5Rbsq/NUhSNYbwn7NZnzb55X8ZvP7dP6WTQebgTTaWeOZiFd/EPLYyh0JJHq1AgB/DfJBOvn/933m+82Ey5Kh8p9PqdxjBtifnt1HpivVSgUuZAk/hqhVZ7KE461V3tndhIpBvv4z+CFzf5LA2HhJCfJQW0g2aszc6aa61Ux8vpVe0Bsxiz1q3x/AXS3KRXFs6Tr5h0H7eromTMxzbgrCl7h0vbtsMz4o9EZgRIOqBMMKt3S7qNWxaL7jcRlyIK7NJyNuoJOCm24bLfUVIuR5qrwekQ5Yyu4H35Fm03+MlguT32K2MWF0JtMVcomoA3Hbtaf7KmyK36SKRBlaWtrN4Fk+zEwzTUzW5XUj1Vrw1+FZeR/s95ht3kmGwvDqoWM672BaYfLiB+fTTRZpi+djdnMAzX1xSGU5QlDG9r7ck/8ZSHQjRXWq5d4ucgF9/trrKAu+AMw+9knlsKlv+c2TJlbQBTc7lXgUeKd7Aaa+9mp/++9uCk1Vl8q4egYkr80JY9e4fMp8NABWjEoN0spU5FVZzaxzzn77Vk+Mx3KNsYk03v0NpvLoWtOH7FMt7mcH7dsq9ToXvV6Ngc+2Ji36CBoiweivgKUfVjh7V+iz6Cbo+aTlc3+NqZAjxLPHU/Eb5oO95F5c9hb3pNZ0Axom3OJHN/FrN6pKTDVk6HoKW7Cr9pd7Q5W45YUSjjdqGvicbcYnjnnxbbB/celleNCG31UWByklypkuJRgb7ZNGJQhNg+c9Cz6VPsQ85uthWdlkBaGW0TJjAi1YySiuDdJbjmQthamGEB1nGxmsX+dFZ0lQOC8v9HYtXbw9Q6Q7hei6m1VyIud5v+4SYIxZiNQ9RGFd845ccwqOBfXPZUqoHn5w/wuGM0Fq2qgPczQms/eLRQbcW8F1b9H0ehlcP/UqeXnyFNo9vUbeNbKUJ1reGpBfC2w79f8xlS1mB2EYXT5dMm2aISPBX5wR4lEO489Y3eC4uGwkS3bB2bJMF734PuPQxDuHRMjkXtyApcxtdrKePkVIb6yzJLdZ9Gcm44r5Peve/nsp2llb7+rG3qyx+GE+5p43GuVn8Z5K2HN+TmMh3oRH3YL7bUViLux2HlXGskX7Acp3t+1+L8hGmgNoMDBYUSVNsUIe4JyeJ7mns5QTd9InWZLraaCFhZUwWarH+G0vVHza3kqAVqAyJpjvXbEj21QwG2EhJNQMJcdP1tNxOFjShcaEeHZKQZylT/wu0hVwTYpMcC7TiVe+6TlNJRkvD9b3/9gRz2FIOZaetpx5ZKpBWpE1C2hVIlSfotTLKzTtPYeiG2X7EDm0pNtvmytK9PoY/CVTLZcqut2VEQYi5TZkN69yHsLu0GNtHfv2eADkvkmIemyoI7CMczjAdtDBSrsPbWclTlxwaXCVTFLS8se8wPKusbi9yj7ZvhynvOrxybORc0Oe5kHTRXybA2+hiHQsYpZUWRmgvueBpUg6eQnbFMx+FG5qDUWHkX8qNaq/6nrNwxKX3spQ/lCfXanLuR8HxjB5ZcuVJyLp93s5reeLWI7yVWYcsZQk0MTe/lzLnQUa4pC51O+wmOOFYvvWm8jWZmKxvbxSB3ROwGVLi4F4jHZd4x63bKMu//FbAwec+RIoiPQOPc/t37Zc0dqGiatcSfelgqtOWScZW4lnGXTAX2HG5jdjScWKGu3y8TNIv+Xf5K1NqiP+1zXrtsmhPpGVEWRDC0nHOjXu+TRmYKjA/5NVa8eJAE6UwS7YQBJOMuyz2Qgomw0quyzKVhBIy//I8S6evqbCaihVYiJMfmaWdHFl2leZNiB9wC6N8/+G/gx8RrAObQrAMzwq5EY9Y2pQVm4Ko60ais5gENg7W4Vl+zXai8z8MDnj3YyzjwbKlVtwq9IqUYjkfpoMURbrZRoEUd7CSjf+0KBir3VYflOqim+DoShq7u46Qx95S+jGCLhgm5J564KBP/YkFPFma0CshCueVyXknQ+XnrdHCCFc8+Qn4flPQZztdKluedxb7s9D1WgAycMCXHmMZD5TJuCg25uJOg3SWYstXxjUHWM1JPPHtIyoXGjKVsRz2+lmI71aUJ9gu5Pw2/IWhzG+iPLfNTA5c9RmHuMYlt7bvvPnMJpJ/ozERNxyo/ntSqoe2f9lO58whFrKOOWwpGy48uOeyNTbMYmPKmYqYarTlRQIh16ZrSLs6Xg0MJrkwZEJqG8HhMNtxgtnFLnoy0/XQ9GvBnm7hJtGbrA5Cd8Tamm1CyJdJjsIswYIsvoV0smAbRZA29Pfw+sU/pZ3hgGVclqdPGYKLO8tgKVKTTIzcRTv3sZxnrl3iT0yUcs16WYhnKR7Cj5YC7jrSJEG226j0TTWtoa70Zjzrr8jlUk6PhXec9T+BkJGmX7a5aqUQzApyrmFax8EjeH2ldL+6xz4qY9dLWxsiWNdh3ydpY+8YYyW3lyddDtPOJvYtEeAiraVJv6ZPd4qCT87N0QbbJNGFBOO7m7IcBrPf/Swnc2u5LB3XfJj2QIQW091F4xuPf8yLo6+VHpvV3OUPfyz+N16Iub6fNvxFoUxFSZ5LG/5cnn4mjmq+7Rm8eUh9eSiUiFfaq6ee/TaxnPvoiGE0u3nkFHZs7vIS32mudMFzyRRlSX4xoNY+7WygN08mO8hJ01eX2zBQMT8HoKVi0T8fo7QwrRTSdLJRqX7vPdjT9GUPQ4fz0z2kbGsC3hE//J5JUt9AdaH74pBqCCe+UXnYLA7VpF1lmRbuOLK40CjlYaKQujGtqvWURT8D+bncJASa6GriZVrKXRCylXXI4kpXc64QOJsFKY3nUpKH0069mrTRibQzTDfbyhYWsRqPlIl5hrRahGiITm/yoxBzkWPIKD+NR2CWUelWgkV+m9w6n4WO82zXS3oIz2qeM47pNiCyvAHecfL/lJeOh0q/7CIp1tPHFuYiq6LOZSsjtHA3r2LjhYuC77hWWDSy+ES8X8mzkMoFiyhdv57wNme7ryyce8C3SrF1RkpV0sm2ko+GnpAp9yfbV/zpk/B9VY60MZOMZvCVL9t7tArefeIV5aTkL3ULkCPLFuaU5bKFTxRr47cf/pBHzl3EXGTUx6VedDsaImj91vlkCcYEN6GV+Ax+24+jMNrafdi3PQ2souwadO4R3yjtdrssmNFtbEoOwBmtP4IDSonPg0xYvLH4Zrbfu59X5k0hsrnktaEay3+ceqvGgFVL3ykGgR444sR7OZxHKtz9TEKeolBeRVna9pg1epuHxvqgJ5NE91LMoezH/ZEYp9dK5iarlieSbxSJlnQYAWwE4spZr7QN5nO3kQxb25iILHpb+3iHwUWqIGhpc3US8qzFulZNxxHVUZtpTY5tHf8SOPfcbzBKq5pUVyx3NHqVRj3p8QWyDJUsrOJiMEgnt3Iym795UOUKlTmC9dUGnFTaXmMcixqGNghmILJGNXgMt/uBoQCvuPyXLObx8kqgKYrliYvgDw9rcp6iyDz+WnZ1eerCQyvbr1i9pUzw/eczBH3HTXIuWEelYqPTetRHrk8DJ3kKRwe76GYbLYyyjS4eZzFAyb2k0q5WJMU2uionQeapVHTa8BQw89wMnPv5b9Baqk9dr62MlOOcg0fORSYgYJHUMq1jAb/6+SrP39yFAkFXIV1HK9Q567F/a9rw4n1XA3nP9ahCnG9S2Dehz5Ol99wnOIWbA+4Jtgg7XtresbYyUh4dA78tm+Ept9FVJuhnpa6leLz3pUidGCznv3/z4WAs/MeMAqNGxcIQ91seJx1Xhiz+MzwW3rj4x+V336wrPVFeMJetZaOGnCPbw3QwEuJakri4NAZ7N0F/P1DNWkovpdra08R7qsLmYjHZkHbVTXQb052IafkVuOR3dRq9Mc6vF6R+TUJQIk1tH9nOWTOvLVtnxHoqS6K3M0yRdKCjGaWVTcwrf8gzJfv5KK3cysk8c8mSyjrJGTIIuVhCkJincbsboPbr+ziJ2pT5HP5E1TDLPEAW3vap/1cRWlCTc8FveWUgesh8NrCVOVz/xXdUknB5PkMErXsZvPrJUknOTeWxgD+BVlvSdVrOE7IsMiyF9578tbL7TQujjNJSdlNKUQxYsDVyZLn+N+/wiLCUM4R9NdBlVBLiEsm98tr3c+JZt7CYx8tlCjkHj7ysYWm53vUxCBKKx1nMnXe8wYtt7mo/2rqv67wPPwZ3AX9ip5mPKE61oLeUtzm6YCKs7Zee//s/9ZUKQm4j4/P4qzWrWomYVpqkXJ2nuHS99/ivwfFYz9tGF9ddf26QwJsKZT0QZlHPOq7pgfee+zXraILrvvW2Gd7TJO86L1GEUxQjLOiNnCQaEpC9wfjUpz7F+eefz5Il1WrDtWHCK4m+GFFeSfT/2wGtL4GVqQyrWgIL6kW8zY6+2nQcEm5CWzPN/XGIoNkp9BIkAo2AaSk3cMyX7iwNxVZ2QvPYVN7WVp5CyadaIFFZBunkZk7xfKo1pB5NOQ7DI0I5gpFZtFuGi1hqkt+HfVGTKPTjEXNXHRnv9+mXfj9ACIGKRZkEv+WV5W1ZhGgbXVz3T+dWliOExMymD58Abi6d04t9gmWBysmPOdykpFvtPxbee+rXyu43ssKp5zc/N3APJoqk+O/HPwzfUTLlsNfpCoJ+3mC1QB9z+p0cxYNlpWeYdtbwivJxmQhqUxYAHuFw7vn56yojdGiIH7mJJQQn1bre06UheceFWOY1SQ+zAJfw3ku/FkibpNBVLzboEZJaUSTFK/mt0y1GQ3839PVhSFHkqpFz2HFZT+h5FcjDmf92pfX9jIs49wTV1zvAgxzFiMVSOTYwzK0zz7OuJHrRjg/RNqMxK8XnB0b44swrpsRKotOmTaOpqYmjjz6a8847j7PPPptsNjtp5U24e77tttv4xS9+wVNPPcXQ0BAuvt/U1MQdd9wx0eJeOkhIdX1QbwtHFFzuGibpiHq2NoIcZskKc6tJW9L6XN2fxOh46wKR16UU5YEsvPHz3rCszdImJA2C/qjDdLCVOYBvWZeFa7657e8Z+9aMYLuwEfMCnhV1IR45eYAgIdewWSw1llHdHBNBP+GRPMx0AV7zpZsCBFVCKJouHykK3M2ryqQjW1rWZ5h2rvuihZyDH+dct6defHLej0/Ouyuu9u7FnPfgcp3IlvZJXm3A0jwtjJQtrKO08ADLypdocm5aAb+15T2ef7f5PpllH4v3/EwXItMgtg5+f8mJ/L77RL76wfexhbk8wuHlslMUne0zRYEbebO30FOYUaAf+zdgBf5iQzns76nrGdQCGQkBu5sN/rE3fv3H5WgfGnrkxmaZfYCjVNr+4XG5sGilPCp9H8uteesRt/lssLqBAYzQwtaSMmjmXyTFWa3XwqXWIiLhitNvpm31IMdtcxxs+bvgRW9qL+WbrihPtuezgdGQxttYH/SpE2bxAx/4ANdeey2///3vuf/++/noRz/KaaedxnnnncfJJ59MU1N9Vz2t2YI+PDzM3/7t3/LLX/4SwEnMywU1NVEsTo2KLlvQP/ESsaC/FBDWkdXiLjBZyGCPVKFJjeu7lSOcZMt2rZb+Ah7xEfkarQAWjB8E76u0/7DL7+eV/JYWRkhTRK9IJxZJm1/qNroZpDNAOlsYIUeWKx78JOWY0rq8HJV1vqT020ilBdMlO1S6hR1L0D0jLnJ4EWFsSpfAJG1vgNNOvJq5Jcu5dKYS39zs7O9jebme5JwHOIqHLllRqVCC3XLeg1dPojhqcq7lyxGMKJLGHSIQ/DB/S6iIbNN87ACXdH2eRzi8/KzFrcWcFCr18CPO4Pl/3T+oXIi8Gkvx3o+NBJ/5YQSf7TqCRDULLIPTjr+aImnmsiXgVqRleZCj+P21J9pDceo6C5MvXTqeI1iH8syWMjnvtkzo1XIV4Mgv3UM329iXTQFiLiNbNleWTezLVuaWI+5ApTuGy2ItUXviQOZVhMFG6DWE8LYwWrF+gCk3EIgMVW/Y7t3luuKCRGuSVXZHaKkg45KXpOewBXMSfnFgJ9+eeZHVgv7xHZ+ktUEW9JGBEf595penhAUdYGxsjBtvvJErr7ySW265hbGxMZqamujp6eGd73wn5557LgcffHBdyqqZoH/84x/n8ssvZ8aMGbznPe/h6KOPZs6cOUyb5vYXOvHEE2sWtJ6wEvQw37CodJQFc0+mJ1M2l8VxKsgWJ23CNhkzLtE1LbRpwq3HGrUoIKIoQCVxnMx6NfOG6NCDBeA8bxLTAtZZ41YL2ZZj2qK0hbkMqgfjxb4eYQtz+caDH4NbjLJdxLwXP2rHekPusGdgtoHDqM16mcePAR4GXVYeDvrSn3g1vy5PWAToYps1xKAQWwj6nn7jwY/Zo1pIXZltUsi5TLAconLRmzQeMdeTDF2TlCEY/32p45zSeT2vfYpXsIYURbrop4NdFVbGFEVu5WSe+s9DgyNPMhJgtuFlVCoiPVSOMD2g0gWCMdPPgPcf+hWrBfRRDvFcWvT1JmyygVfXUrfrLMdltCEbkvdEIArDkFfGrL9/jsWpx3kZj5eje7ji6gse52XkyEaSQVG4JFxqi3rn5bgrbda5mbeZ9mL9F5B5K1uZG3q+jtTTXprrYPOZr0XWatK28jYxj2Hay/UrRgwJJ2ue7xqJEEu8RG7RcutrRwfyToL+kR2fpnVGYyayjQzk+erMf5kyBF2jv7+fH/zgB1x55ZWsWbMG8IzRy5Yt4/zzz5+wC0zNBH3//ffnr3/9K7/5zW845phjahZgT6BM0D+9A9qm1gPfIwizGqaJJjBTGSbhBt9/2EW8tRXctAiD3fc7jJzWCpFT0MbUmNwr9WEjYpq8rYLZRzzLSm6nrxxoOgjTYiSdaZEUObLljqeFUVpLE0YfZzFXP3cOfMeoDCFTplxZfCvpOoKLElVDzPuozce8gL/QUBR0eW+AE4+6hYWsK5MY0/VH4C3gs6813N9/X2tEr9BymTK14bk7dBMk51k8AilVnqPSCuwi52n891As8DakS2V0e5lksoO8afqNVt/d9fTxi2feBLc0B8m5yGyOfCy1HMsSfJ4FvJGNqPvphdkffpa/4ScAbGIeNz34Vk8BClPmw2TTLi3m8W7q584i0IqZvDPyPgzBcZf/iqWsKZ8u76lud8O0s5W5bGB+pGVXnqFNqdyTKJJimA5F6H0CbINtroc5CVPyjUrb6k1/8+oBLZcYQOLWfxhB/9COixpK0K+Y+cUpSdA1HnnkEb7zne9w1VVXsWXLFpqammhpaeG0007j/PPP5+STT646z5oHyp5//nkWLVr0oiPnAeykegK1J1wHakUtxDou8WwEzLq2KQ+6848LGwHXx8yhZ31M/9cDpouEtjJOJWhSbrOoy7NYArNWPcfJqVtZzOMB9xWg3EFkeQEdl1fO89b47CBHlhRF2hmmg12M0sLtrOSeS14XLBfsPubSLhbikb71BMlo2Luh2524OByGvf2FpYUA28ixWZ7eLpG21xx1Ewt5styhtjJCl1q5EigrMjLBTvy0h0uLMT18ybH29mRakqW+evBdUMSialrOhwiSc9c7I/ciynAW3z3GrLc2mLZkZ1DEXCc/yp/B/K4NHMKjzGcDEmniF8+8Cb5vWRDObAcZfOVss3HMJL1rjbStfbQBeXj+B/tz7RlnseOBHrid6H6hn0qy341nOU9TuXJoGj9qTr1GwsBXEvoJvtPGdb/76WvoPG2w5IrmW7i30YUXOnJhheuHJqGyYJY5oVdfE8cKHZWeiJVa0mIgkBEC8OY/+C4iviuHuLdoWdbXpLVTvj6uf73rvr1jhcDIpLf2Q+VoZNy0/rehsT7oU7FDrMThhx/Ou9/9bsbHx7niiisoFAqMjIxw3XXX8cMf/pAFCxZw2WWXceaZZ8bOs+Y77+3tJZ1+cVRcLMT92NXDmlxPl4NGlF1LGXHOqTcZDbNi56rIY6JW77C0GQCgls5XKxfVXhsnrWUzSYVJyDNAFmaf+yzn879kyQU+8HoI1RYnGjwfSYAN7F86txCwqj/Oy7jykvcHRxTkOeUssgkx78XzNzajaJj1qK83FaXDjPOinq/knyNI+FztXO8vEfMTT7yFw/ljYCi7g10BIgHe8L1MXJRzOhgmR5arL7mgcgRGnme/5Z66S/cq52ly3otPIjdiXwBL2pDOV+pQnoftvtNe/tOyO7FhrH8GTz1wKJuO3ZePzvwqG5jPrTtPhmuag2Vpi7DI0oZPzjca5S4kqNgPGbLnjPP1PZWs2jtW93jlZQh/f4aUXOCvuioKwkaCbbKN4KTVatqfrZ0JKd9s7NPPUX9T0sC9cFvhNPY9fRMLeZJhOniUgxktkVWbX7QOjQnBWNmaaEa5c9hgI/Y6LzPviaZFuTDlHKadITorDA8TQSXZ9tOtjATKSpfretQZFcZGrOPcd5FUycbewhbmUsD+TgLsVs92srG7QeXUiu3bt3P11Vdz5ZVX8uCDDwKQSqV405vexPnnn8+WLVv41re+xYMPPsjb3vY2crkc733ve2PlXTM9evvb385ll13Gk08+yYIFC2rNZs/CtHrU8vGbSNnVlDNRWSZynyapjMJkWN37o0+JhCbfYfVXa90WcMcUj1NWtc+lXtdq2Nx39DUZ/5dZ9Txfmn4ho6XBU4H36fYy2Ycc7cbS3bpT0PHLWxmhnWF2lSzoX73wQt8CaxJNaQ+aGArRXEaQmGvl2lYH+l+7HFQDyV9bzMNIuW4zbUAWFp37MCdza8A6ZQ6fj9JCgRSPcDijtKJ9tHNkeYBlPPzFY+2kUYiaqWRlS/csxHwzfl3Ku7+RSj9vW31qxbtEvst+0yaBTwN9YzRnjPZRSLE73wKPNXux8Y/dzvkzv8MZ/IhbOZnvP/B3nlwip8itSbAoVxkqCbCWUeSK88yy+C5AWpFbiq+8aFKu60hGERbiE/McwRjtaXyLuoZZb2FpbUTaTKVhYkhth/UzaWANXNn/fs5835WMlJzMNOQ91z7aNuuvOaHWNsHWlraVKe1fo8P4vrjyNdcMqEY2uTdPCQ6W1wi4rNyu4y7Sr+9LRgKkTm/edipj/1fNycsPOOUZoYXxkmFlsjE6BVcSLRaL/PznP+fKK6/k5z//OWNjY4yPj7NkyRLOP/983vWudzF3rh8N6H3vex/XX389Z555Jv/+7/8em6DX7IM+OjrK61//erZt28Z3v/tdXvGKV0RfNEWwx6K4dFNfkl8NqvnITyQtlqyw4/WAayJarYjzXLIEXVLqabWOSodhInkNOfaDTx6FUPTCmSdfyXLuc14i1idviDUYpUUmau2ioxzX2r+uUCacn/n3y+2Z56h87vp5rMCPzKLvIUzh0GR5KRVRRSLrVeR5jHhKpG5nonisgFWLf2iEqiuUyLlPBmTlzxFaEV/9eWwqE5mr//2CyvK0ZdlEhmAEE03Os3gkOIdvfRby6arPrLpHTTTNemvz0s2HeQQglS5QLHgnj+VbYF1bOb+eI57iZ5xGCm+Bpdl3DkERvv+a03nnD37k1Xk/lcRTiPBmKi3Fpmz9UDFFImekTUVG30s3NHcPkEoXyK+d5U1alnqScpbg1adcu5mg1X6JXy+BMuOk9b4ClStkunzpXZBRApU+8t33BIi4bUGsWjBKC8N0WI9d/dw58P22uvWZx338V9a5MJqcTzUf+XpgmPbyt1X72v/0B28LnxeTH4DPzrT6oL9zx7/RMqO9AdLD6MAuvjfzE1PCB/0Pf/gDV155JVdffTX9/f2Mj4/T2dnJmWeeyQUXXMBxxx0Xev2yZcv44x//yOho5SRrG2I1/QsusHz4gfnz5/O73/2Oo48+mqVLl7JgwQKmT59uPbepqYlvf/vbsYRqGOYAjWljew5izZkoqrXimNfKv82KrdP1tL7H/bCXLJix8tL3mW5w2iw/zrUQrNOotpAl2DkvgUuP/0dnx6V9TjMMUhGqixRpivTTxa5SR1wgRYoC+5DjhVLFf+rJ/4Dbmyp93MG+gEqa4DLoD+CtAGq7Z1vd6P8luJVnc5+khfCsIUjGXOXqZ9aGR4JOGuNtB3zPsOxVLn5TxFsN8a/MK49UiCvBIJ18/5nzvMmSZjsB39dYyyS/ZfhKRg6fMGZL8j1G8J21uURA0Bot5NgcgVB10LzEI7MmxobaYb3nV55Z9jxfm/5hXsbj5YWLZv9mqJzPO7Zez6a3/3986vGvww0EXW0W4lvYzeduylag0v0lZ7nPLEFlUP57xmnrfqF8etth2ykuSTO2ZgasLsnRq8rSyoS4urRR2SbN8nVat/Gckh91TE/6dMGmLEr+up7S8NB9K5i7/McVxDxuNJIiKevkx0c4nLXfPNov16WA1wLj2/m7r72G35nnyHcEoBuOPO0eFvMXZ5YtjMSyoNfLP96VNiGjmKZlPUWR7z/+d95KtmCdb1CG2Va2OIsLuC9NNhpVThwcddRRNDU1MT4+zgknnMAFF1zAW9/6Vjo67EqmiUwmQ6EQn+TEsqCHhU6MXdBUjIP+bzugPUQjyxlpc6i9GgxRHfmsJ1GNU1Yjy5MybQTdPFYNTIKUwR3F5aUKkyjm1X4bhDyU6uS4t/+K5dxHhkEVc7uA9ocWq3ir8oN0TTIyYwZ3MkiOLIXSscv+9M+eK4qpOOiRGIEmSMeWth8j2KnHtZin8f2Aq2kPkv8a4lkl08Z2FlgGZy6+sqLudEQbsXbJhDyZsNZFf3m1VICrr72gcsQA3MQ8g0++5F42Y6+zMMurkDl5JhmCUV7MOkhD80KPmKfTRQoF5UdcSDP2WOk73DPOzN4tfKP171nIk3QyyIIdz9D8BDBSyms+/GneQQzTwSbm8TG+wlNfOzQ4odVmVe+j8nuwmUorYs5IZ6mM+JIGesdoy7rjdef794GNTZWTainJmSV+f6KfzzopwHJO2AiHCU3K00om1/tQgNNee3U5ilDYZEax2mp3il/c8be+fBv9PKcUTKXFcO+c9YbnWJm63Xqpi0Cb0W/iwKXQ6OMa61jAQw+v8N2s+on+9pvH+o19IwPwdbsF/awdX2uoBf3amR+eEhb03t5ezj33XC644IKGuHbH6pr+93//d7Ll2DPYRnWEe4jGr1ypEfdjtic/enHJjklczGNxlaGJWFheasgb/xpC2nvwO2Pg3FO/QZE0y7mvTL5NeJ3LaHkIWIc8FBRIIeERB+kshyuTCZ8jtJTo5zz+g3/g+T/t7xFzk1CIIiv7MvhW58PwieV6KhZUCdyrua0Jajf+6pVxIPL047sm6LxtCqWZ7gaWwOuP+CkLeDJwqKMUb1nHOZcQdtvookCqHJd5lFa2MpdfPPk3sLop+KxltMxUauR59+ATVLMTl/ZhjnKZ96JJHSrPEGI+rXcnHZnKycHFQpqxXCdsboI2mLX0OS5JfZ7l3EcLI3QyyEFPbKakJ0IrjC2CNTMP864vjcR8ji/w6IcP4SrOYeNvFnkEVvujC9HKGgJsJjhhtoA/iiDPVEY7FhrXZiDTnbPctDqlp59Cd4r8mlleWTJSl3XUlw3yLDZS2feInLY+yfUd1t9WURhtSqrDon/jljfzN3N/Up5AqS27Eq5wkE7WsJSNDy7yZFsbcn9x+4vJ6NOiys5T4fq0/f/ux3VYVuKVUTgLXnPETXSwC734mnwbbekiaUZp4bYHT3PL2E+lK1M1yJX+zb7CNGI4sLdOEn322WfrYrCOi5p90F/MqGmhIlTa1jGnjeNheYXlXe31YVbosHS1iHudzWJtyysh1tXD1mYKjmPgd8BQXhFyxYm/pIUR3sX3nMVodwvwLEA6hJc5+3+E1rLFbJSWsh/6aGkSUT/drOYkbnv8tEpSroe1NVkEry31lvb34ZEcsbzZ6sBGMuSXJZxM2iCyCZGLsk7aFIMssBCOPOoelvP78mEJiyZhJMGPyZwjyza6GKGFVkbpZJACKbYyl7t3nsDQj2YHXRjyVFq7hYD1EnSxAJ/I5yz7zfvTdahJnRDXEGJOdoxMd45UWo2uFFKM5Fs9Yt7vLYvdtmQ7y2f+nq/wMcAbJThg6/PwtJJnJuxcNI1HWw8p11U/XWyjO0AUHuUQLt/yUXbfMt27nyx2y76QL21ltNVhN1796e9aBjJ9zwfuKwo7NndBrjneaKWcI88oR+V3XO4hahTHJFxCzrNUWsv1OZk809JFOjLDFfdZLKQ4Zvp9HMj6slK5nj7u2nGCp3T9aEZQ1qg+yYS5v5pRgbhw9UEuRWWi/W0YdzDTteaNI62/FbbvpbzXGXx3tR5g5wCcZregv3nHf9M8I55bx0QxNjDMz2a+d0pY0F/zmtfw8pe/nK9+9auR5370ox/lj3/8I3fccUfN5dVK13j22Wdpa2tjzpw5kedu3bqVfD7P/vvvX2txk4+oRg7hVrKCY7seedvScYiwC7U89ewEyktQO8x2ZevgTQLVQ8l9I8/B+z1KC6P8A/9BO8NlS425Gp0O3yWWdFf0FdnWxNzLy7tmF+1sYD4PsIxtdPG737zGcwnRHYomIXIPWXzyIPeRwyPID4TUi8tiLiSyh+oWetHkaGNIWTj2S2d3GPQe+gRv4sbyIZOYSxQFTczFfai7FEN6A/N5nMU8c+0S3+IrnW7OKDdb2s4SdMnQ1nW5JsxabiN1QlhdxKbs7jLGzJ5tFacMD3V4fuabS/HLM3DQoX/iH/k3lvN7JCLI7DuHgnLMgacO7CmvAjlSilG91ZhoDLCUNXxg7n9y7bln8/zP93crEeuxu0bp52gj51mY2Wf6xIRjJN/iRarJ7PIUk1yTm3AO4bc9U2HVsrqOYezXz07aR9Y4tw3IjEO6QFt2kNa28AlsqXSRB0eWQatv7f3df76muj7MRhjNe5uoUSkKOYLfJHlvBaYV2bVd73Scc3U9QbAeRXGzXZdR+7Olf5sCWwBjkDSAIimm7YU+6KtXr47tQ75mzRruuuuuCZVXc9Pv6+vjhBNO4M4774w896yzzuLuu++uyjm+IWilsZbcen1obB+SarTuKfYYEmB/JvIRdlmGZXsZ0JtnVs82OlLDvJLf8iZupIPhio+bXlobfILuiqkrkAmeQsxzZGkpfcE7GWQbXTzOYvrp4s8cwu/vO9Ej1a5OWToXcbkR8pfB72DWOIQJI+dCytMEwwRGQSsMeezLrWu4nkk3sGScngVPcwY/KitCsnCLScwH6SRHln66SueNkimNWKynj03MY+2tR/tD7VJ3QrbBJ6FtBONn63M2q22zc9f3Yyp7Up9Zwol52vMdr7SWt1AspL3Qieunl88/+IiH2JdNfIWPlWO8d+3YQfMaJUvJpWXDzJ7yCqkjtLCVuWWffI0WRpnLFhbzF87gR3yj92OegiVyS779BL+HpiVavq99GOR8nFl9myyVYMdovoXhoQ5290+v9IfPqnL1c9IKof5Wy7/Ox4RNOZWyTAVVPbe27hfoyFQfOvDBkWV+LHip47B+xiTeuYgCTIIsbbyeEIVXk16XAU2TW1OZiwuzXqLSGgV1XBs39LWCLMF2L8f6CNahbl/m9nPOu9hrCXo1GB0dJZWamOwToozVeMdMSU+aubx0orhMRENP0BiYVjr9IXYNVetn1Qccm6ctM0xr2yipdJGO1DDv4VscxQPoFdd02DAT5up+Noi7hWxrAgkeoc+R5T6WUyTFb3kla68/OujTqzsbISMm2evDJ0mbCRJRLNuSr9metXWwr/StKTRF3ifgk/J+KsmbC+axk8aZlhlm8dzHeS23I7HMhZhrH/Nh2sux3rcwN2BV38pc1rGAImke/s2xwUmwQuYEotz0lu47ZxzfqLZN4pG2/OuhbvD99W3IECB3qVSRYrHkPz/kfVSLhTRj/TN8mbrHOXLBb+hkiK/wsXL89tlPD8GzBJ/r/jA2I+hv7s1t6LCS80c4nBfIkqbIt+/7EPxIysQn2t347Uzu2VSCpT7L91jazo4x+wAvzKDcJxC471SqFKt+pIWRfIs3STTX5OcL9Bz1FHPZyly2MEIrT7KAjdcvskeOEcS1mGtirhVe/dzbgDavrXZmB2lpHaVYTJVl1/fiuk99r7NPfhaA5+/c3ytnvSGTJuX6Hm33IrK7jvcQPom1WhRw+3Hr75a03zDlaE8gg7u+9KihjfDblCWX0m5BgRRNDSLO9VwUqlHYtWsXf/nLX+jq6ppQPg2hagMDA7S2tkafmCDBixlRIxNCkmwEXVtGMsCxkFnyPOANKafSRZan7uMcriLLC5hoZZSUZcEOL4KAV5Dp1qInJpkRA4RApiiWJ+yN0sqjHFLyj27lPo7hoW+vqLRyyYdeLINZ/IloWYJD7GKpjmutlnoSgi+dUBuw0DACpCOMAkOlSZYbCSdItv0i78oxAN57wH+VffeLpMthKSWCQxF/mfQXyLKNbrzVP4cZKa3cN0iGh/60wvPT19YsqUex0AsZW0iwrjUhF3Kk25up2IDfwWdV2kbK00Cb5wYBMLNnGy2tnrK2a2d7OSpLsZBmbPOM8jPtOeop9mcDLYwyj038I/+H+WwgRZHZa4Zgh6WcA+GhOQcH5jmIvznAJuaVFUM5ftt9p8E1lvvL4ZGwNrxJxjlVjouc9xr5dOeZvd/WclLIqS1dLKbY0Z+FXJtf92nP1Wk+GziHq1jGA2Xl+QWyfPX0j3L9fe8IkkVNEEU2G2S/KL5pfMVN0AZkvHbanNlFtiuHhpbftR2Vnn3is6QosPnOg7wda0sHXAq7ViYEWYvsk4k0/uq5LgxRGSN/qiBL9MJ4thEBUZbM/eZ7X2nbKWM36YBBaDKxew9aFH/605/y05/+NLDviSeecIYeB4+c33///Wzfvp0zzjhjQuVP6p2PjIxw55138sc//pFFixbVlMf4+Di/+c1v+OlPf8rdd9/NY489xvDwMN3d3Rx33HF86EMf4tWvfvXEha1mqGmyy5rIMFgiW/3SWNJhiJqwZcuzBzJveb6czEz3Yp28mRt5Jb8FPKItUVNShouKt68QiBJgi8Qi+72lnHW8XG8ip5AfHcklS45hOliN935tYD7XPXMOrGmu9HPUFhmxlEtnm8XviKXDM/0nzXrxha7cFrcVKykvQCFtT6cLMNTsE97NhA+zS3uosJaPMa3kp/vOud8tjyrIaIWNmA/TwQbml457xHyYDtYxn/XFA9l+z35+hBgh5XrEQSzb2qo7RNDib2t/pnuHaSUX0m5zBWoD2sYgXWRauli2uI6OtFAspBjMe5nk+/eBfFO5rg479P5yvOgz+BFLWUMng8xnA63FEWbcMwYj8MPXr6oocpBOHuUQRtQqhaO0sol5DJeGO3+/czlDXzUmytruUbalzjYSfJamW0svQb/9zDi0jZTJeZiiWyymGM23MJTrhH6v0mcu2cwhrY/SxTZO5lZWcnu5XaQo0r19iKZnYUXhnXxp+YP87/LzeOIHR8Rbu0JbzLNKfn28pFBZSXnIvUSlw6KRzD7xWYrFFNtz+1Uu3CUEUGTPYlcGCwSf62RCG0ukPnU/kCGaxO8pmG3Z9h2V74i5P2vJwyT7If3ZKM3sbtBKogXGGlKODWvWrOE73/lOOd3U1MSWLVsC+1xYtGgR//zP/zyh8mNHcbnkkkv4whe+UE6Pj4/T1BRvCHl8fJyLL76Yz33uc1ULeMcdd7By5UrAi8e+cOFCpk+fzhNPPMHQkPcV++xnP8ull14aO89yFJdvRMRBT/DiRpwPfNg5ZudfTYdhDCs3n+0vm9zV1V+Odz2fDeWIKimKzC2tDiGTNb2ifcItIQ7D4uoKMdQr9Pnh+zoYpSUQs1gvA52iwB2spECKDcxnG93cdN9bfUuzvj9NDDWZBN+NJY0fA9rsdKPqUzpyscILsezFs45bFruxIq9IeT/xVvyU8kXOhUBfnkx2kDdNv7H8/PQCTlly5brPkWWEFoqk2cS+ZXeXfrrZyhwKpPjrznkMrZ7tDy9ri66QBW0xz+NbvuTcMLkhSFD1r9tybpoAIW9pG6Ejs4tiIUWxZCEvFFLkc51enRZg5sLNzGvdRCeDZMnRzjBncS2dpTj6P+NNjJZcOQ7m0XLEmlZG+Pi1/xWU23VPorBsVvv0vZj3nbEcs0G/2z347lZQnuja3hpiRixhaGen52uemw4FmNa9k6Vz/8DJ3MbJ3Mo8vPrp2bDDC+07Uip7DjAdxtugkIK7Zx7H57mEe65/XaUyYd6jEPM2Kq3OGU+BFIUqVdWHKz52jbijeIzkW8hvnOVZ0qVNCwHUz0Y/c/N7Iue2EfxWVGtocSk7tvrNYG9TWpZGQ8uv703fo64z83HLd1jXezfR78jQABxrj+Jy7I6fkJ5hX5Sy3igM7OTemX+zR6K4PPzww6xZswbweOwFF1zAy172Mi688ELr+U1NTbS3t3PQQQdx5JFHxubILsS2oI+Pjwf8yGU1pTCIoGeddRaf/vSnaxJwfHychQsX8rGPfYyzzz6bffbZB/Ac8C+++GK+9KUvcdlll7F8+XJWraq0yCR4ESEOYbOdY1o5C+rcuCQ9zptgs6gW8D6AJ+GRm5K19sgFv0FHRjmLa8uX9PE0WXLl46mK/0JFWENXJysRVIAyIQQqCLrsk4mKgt+zvEzSf8srKZLyrOSFNNzbVFkvBeMnZE9bZqXT3aiusSGMgMi2kH7pUDIxhynyrb5VV0h5WHswZZH0Qph52GYWtz7OgtLCOWIpb2G0TNAlrGSOLMN0sJU5jNBKKyOkKbKeA9nCHLZt6/ZWmRR5TDIi96pJyZA6T9c7jv9saTuj/oVYmASjRMib20bLiwjJRM+RfAuDuU7G8i0egwRmH/BX5s/cwIGsJ0uOl/E4B7K+5IbSXQq5d2C5Lf3iztLiNKstdR72bppy6vuStLaUQxW9mXF+L8w+9Vk6GeSpxw+FtjFm9W6lI+Um5xL3f9fOdoY2d0OhiebuAV7R9QeO4T5WcgdL+QPdI9uYvnW3tyrjTqALmAdjrbBp5mx20VH2rU9R5DI+yxdOH2Erc1n7zFK4qdmXVe5ZRlKknQgy3vyUjswuWlIjzpG0KIzQGvA3H823BBaWAkiniwz1Z8MzyozBsrTnSqZJpW73NoIO/v3qtlsN5DsE4aNkQ1SSXlNR1O+WaWHXaVsfFJY2/119mE3BsL07erRMk2+bgh4HIZ/aImmaqn7hakOjXGlsOOKIIzjiiCPK6YsvvpgjjjiCc8+1xMKfBNQcB33atGmsWLFiwmFkojAwMEBHRwfptP0hnXLKKfziF7/gzW9+c4WvUFieM2fOhP/eAS0zqn+xtPaPka41r3qUXUu63qg132qvmyz5NdJ4VrWeYHm9Rz3By3i8TKJbGGEZD9LCSPljspLby9ZUPVlT0kK69RBxK6MUSJU7Vpkco2exe/bz4PC/nGNOpmktTUqU8h7lEIqkeJzFrGEpAHfvPKFMyHbcYPg5mBYa2ScdZ3cpnSEYi9vW4cYhxroDFFGyBEj5tHSR3YosmGmG2oJh6lwdnK18SfdAz/FP0coofaxncWm5eYAOdgUIOviLCo3Qwi46yvHLNzGPx1nsDfmv3c/zMTYJgCh4WXwyIjILMTeJi/kvddZd2tem9pevG4dCU1mJbC6tgNnaNsLwUActbSOe/3i+pWw9z87MAbCYv7CYx0lRZB6bGKSTLDke5RD+wssYoZVtdLHxT4v8+7oBewevZZKRERtspKwWohZHSe8BjvVWBc2vncXMZZvpbA2u6CqQ9AitbNvSxe58CxTSHLDgcc7iWpZzH0fxAPN2PE/zVmA75Whh43Ngy6yZbGEOu+igQIohOktuZ/47PUgn7Qzze5bzc07hifuO8P2g2/BDP8ozTfuuOHoBsbDVPkXBAH9Sq2A03xp8p/KtVEy4lrLjpsEfARoiegRIfrZn57KYB0YRLNeZ1nHUdWY58s3Q59tcj+R91f1rNdb9KHuDq82b/vv63GqJOASNLnKPWwfgTLsF/agdN5NqkAW9OLCTB2eeMiXioDcaNasmn//85xsS1zzqgbzuda/jF7/4BX/5y19qK8BWA+ZLa0ub59u24+YVlY7Kv9b0ZJDcRhDnKLhadRrnpJq2Y7dzxszrK/Z30x8IQVggxSE8ykKeLJM2QYeapOmR9ZT1mA363EE6rR2pnGd2uqIYtOBZ37fRzSgt7KLI5Xy0bElfTx9FUmx8ciE8oDtTgs9NPtBmp5emvOCRqpDKZcxdnaprn3QsvZTJ5bTunZYLPEwzF4jJt3qrUWrLnK2DjZLhsDEOOuAvzGULh/BomYD7fsOFcojEIimeZEHpdlNso5tWRhimg9u3raQjM8yOjXNhTVOw89OEW5QckUG7sOiO27QUa0KuO+JshK3FMml2eKiD3fkWWrODpNK7WJx6nOXcRzu7aGWEHFn2ZRN/YTG3cjIAW3bM8dxcVjd7Lgym8m+z5mMcE9iIVByYbSyHbw2V42nizQvZCDzQTD49C7KwY2MPwys76MgMk23NBdzJiqTo39HlkdihDpqzg5zQdRdv5kZO4tfMZSs9T+zwiDnAfNg8b2Y5drtMvpZVN+XfxC46WMoaXsbjPLh8GcPLO7j6vgtKdVp6jukC0zK+K4stYpNWKAZ3eJVdLI3yidvS7kLKe4cU2rpfiIyHXi2KhVS5vdHf7Ckd5rekXv1Hv9qW74uNoNsIcAb7nAyXUhFX5ryjvDC4+rI2vDkG1UAUJj2yYPIMTdBDvLu8NpuEWZxsTIigTwXk894b095eQ7zEEcC1amsU0a0G9SDV1WjlOm2zoNsscrVaAGwWyMmC2ZnbZMnD+8/9CkDZQi3wlp23m1MP5GlO4O6Abzb4lul0yTVE9tuGj4XQmROsTAySCbimSDmCETWJU08QNTGi8vgW7+FBjgL8JbcLpHji50e4yWpObZtWHSF+S0v7CvixtOUjXoul3Pzvo9xpTeveSSpdLBMHoCIt2F1Iwbo2v8wc7nbp2i5dPusNz9GXepq5bC1HGAHxKS+UIuT4vuVb8BZn20Y3WXIUSXHzllNoaRshP9QB97SxI61WUxSLoVjL+wh29tpSLvegSbk8ix5jX0Z10FGTY0vwJreO0pEZ5j2t3yrPdWhllBFamMtWttHFf/JBRke8ON7FQordq6fDPYY8ggzBSacYxzSiDBKCjYTDPF+P3EwE/cA6GNs8gx2ZGexo64GF0Lv8CU8R29btLTaULpDp6eeU6TdzBj/iKB7goE2bYQDPz7wLdh44jQ2t88thIYWYawVcI0WRLvpJq3khAAtLrlULlq/jqzs/ylB/llm9W0mlfKVRoL8bHjFvYdu2bu8ZDpVc3tIFppXCtL6669ccw32la/2Hp+dW1A2tQMnoOnxAO7896pX86tpVwXY/WUYj/b6ZSpxJmkVRNmG27SzBdxD8d02/e4W0959v9kaw5LieQxOWLpgFx0CuKdo1ZojKb7f8XKMXJYzQTKpBk0SL1FdRjIvvfve7AMycOZPTTjstsK8avOtd76pZhrrQqfXr13Pbbbfxl7/8hcHBQTo7O3nZy17G6173Og488MB6FGHF+Pg4P/zhDwE4/vjjq8+gnhr7ZCOKCFeTDrMk1pBX81sG+Ieu/7BkWl/YopeYBHyUVs7nf52di3RgOi61DZqgSzpFgXSx5CdeKFJMKyJZSr+QyjJKa4VsGsO0B6IjeBFYghNBtfuLuNLcysl8k/eVz9ME/eGHj/VCFoLdSpSzCOLqFFeobW1NF2t5GCGPakdZAr6zzd0DmDCXFtfpsccU8d0cUV7I/plv8PzKARbwJFlytDJCu4qGI8RnA/PLEUTAJzI3bzmFjswwhUKK3fdOJy/sQys/ImtP6Z7FyiukXCtPGfzOUSzkmuBmI6IZmJNmS+nTD7iWw3kE8Nt1B8O8jMf5LF9kQ3F+YFGhsTUz4CYll0CIuM0/3GUZ3Ej131hRuOqBWgwOBfwwgXjbGx9bVD6v7YztnD/zO/TxNC/nEZayxrOayxpGc2HzEs+VZZRWvLhMneUJ2hpz2FJ+v8UVzvXt+htuoHP6ILumd/BbXsnT9FV8Y/R3a9vOLkbyrd7qrQDpAocdsIYz+FHZ7W0xj9PniCM4mZbLFEWWcx+Lz/oLv+WVPHzlsX47Mgk0VaQh+ExNFzGo/H6Zip2ZdrXvAn6c+zKajWubS++/IufgfFet6Y0ho50umOTbNYHUhO4TQqz9xap9aGrHnvJBP++882hqamLx4sVlgi77qsEeI+j9/f188IMf5Prrry9PGNXRXZqamjj99NP5+te/zpw5cyZSlBX/8z//wx/+8AdaWlr4yEc+4jxvZGSEkRHfCjkwUEkKYqEKQn/Eh+/lBO4qW0NcvoC1poHAZL89hTRF+lhfDgk4WRBrpknIbek4UQtaR0ZJFXbHLj83faZH0uQxlP7LBD7lPaNd5YmZLWQYLPuAa7SUJg7K/hZG2EY3H+ZrDNJZft6jtKD9yp8cWciO29XYq62DspHntHHMHGFZprY3ErTm9ht52fI20+ZXpRff1aFtjObMLlIxI7DkH5sVzH+zOhj29bId6/XmD8xjE32sp4ttFEmVlTXPu98jS+IOVChZzWVS7w92nEM6XfRI+QPTGdKkXNeVjEIsxCObbfj1KiMRQsrlevFFL/uQlyLVmC49Aj2yULKyzerbxAdS/wlQDr35CtaQJcfrRn5ZXphmeKjdc1O5ptke1SaD3T/cdLfJYY+prI832giifXEF5rtiIoz85fFWxS25KOQLs7jxfW/ih7yVY5942BuJlXju8+CpRT3k2Icc2bLVXBPzLraV3VHEfcoG87sP8OrSbNuX8ThbmcsjHM6veXVg1G7bSJcXRWXInyS+6IBHeTtXMZ8NZWXNOz9Vlm0BT3qhHyfyvKq49kj+zKr0r3huziw+f+4lfPvnH/IVU5viHZegC9bjfubauhxHZtvoTBwfesFmPLJeLWQEziy3FqVX/5swR7qAMMP13uDi8q53vYumpib23Xffin2NQs2TRF944QWOPfZY1q1bx/j4OCtWrODggw9m7ty5bN26lT//+c/cfffdNDU1sWDBAu69915mzZpVN8Efeughjj/+ePL5PF/+8pf5xCc+4Tz34osv5pJLLqnYf96Of6FlRnynsA6G2ZdNZRLo0uykU9TD5UAFWasmbSPoUUTUm3o0eWG2bEgXixTU8rZicRZoy3OqULo3lbZZpQHah6qPhZouBjnMtpkzQ8/XEy3NiZo6dng7wxUuLmaoQq98b9/ZqWsqOmHpvAUjtPDEnUfYhxwx9rmsIWEKpOzvw+8ApemLtUU6g2pcVwT6VWgrlZEF0t6qhS1tdjedQBYlIjr02OxKBSEuzFeyACyBwxbfzxy2MI+/0sEwnQyWFdxWRhmkkxxZ31+XTMmqPsqPimcwmm/xrJEPKAs+BAlonuCKlUOlOtCjEGbnLUS4TMrH3IS8fE9eOzz3gG/RXVoVdg5byhNYF/Ak53IlKYps2Dbfj8Lyf5uDpFOQVfLo/zZ1rtkubBbKen5m4n6Wqxg1mRDMe+sGzh7ngAWPcwY/4ks7/oldmWb6U11sYh7b6GaQzgAxz5Irtzs9wVzwXv6HfufSrZUQK/nQWu99mblss+/nXWoj09JFls19gA/wX+WJvkVS7Msm9t/+PE35cmaekiFTP2wKeBxrdq1tYBHcNOc13Myp/IgzeP6ZfaPfgyjkSo3INFBAZdhYE1rJrgWTafStpY5thhPTUJMlGB89PwDL7JNED9xxL9Nm2Fh9/bF7YIinZx67V04SrZmgf+hDH+K//uu/OOKII/jud7/L4YcfXnHO2rVrede73sXDDz/MBz7wAb7+9a9PWGCAp59+muOPP56//vWvnHPOOXz/+98P1WpsFvT58+dz/475ZGa4nNAr4Vo6PQwtjNJaDJKTMCJqS7cPjVFM6+sJTev9E/3GNRVgPF17Wu+vBwa6mssKgKkMmH7dAiHWI8bwsuff7TYTmG4tAIVUitaRUe5rXc7NnBJYgTNFkdWchBlN5YnfHFH5cXT5zJpDri6SboO5X/yd5eNbIsu7N5esvkLMh4zrw/J3uZQI0cwAmXwgbF8UhjbODro1yL+t07elsRzvhYOO+BMdDNPHeuayhXaG6WBXeQRD3A6GaWeIzpIy64VLfIBlrN/SB8Dux6b7zyFP8Nnl8Se3Sl3aRix0BykKjFjJS8qLOfm1HEmjkGLVATeU7+FA1tPOMIv5C//FB1jHQjoY5nd/eo1fb+Kiooe6xWJvDtmn1bmahJuEvBqFTcNGtqMIzJ4Z1a4eabyJ0yd5cdPPar2Wldxengcii1bJTwwmX+cfeJRDuG/Lci9+OsAtREccCqv3ZcBh3kNrywyzfObvOYG7eDmPlN1YOhlk8fZnaNqER8areY4x3sfxw2GkxkXDR9ua2ZSaxwMsYzUncSsns/G5+ZWTwmvEbnMuy5AQ+FLEGVE29ftr80eP+h7VYuGOgh4VquZ7aO7XoxPmd8AwDjTteoHxRfOsBH3+jvsbStA3zDw6IejVoLe3l+eff54nn3yS3t5e53kbN27koIMOYs6cOWzcGKayxsPmzZtZsWIFTz75JKeeeio/+clPaG6ubuhIGtmTO6bTOSNI7FMUyu4PxbRP3lOF3WXC6yKb4+ngsXJ6oi9rkeBoUlha3q9q0mZeQL5+gx2RGG1rZiQV76uuLVISwURgG9HQypFNEQLPgv94ajG3s7Li+tWcxB+pVD6Hdnb6xFJjs5HW5MjW+QqhM8+35RGGHhRJHvOHD/Kld0NborULi410uToB0wojRLPN8yXXcbSLhVTAd1ynR/ItnnvFxuZKeaIQRtzagIV5DtrvSV7BH8gwSCujZMmV28kuOuini12luNOihP2VefTTxZotr/Am0/WrSVb6X2TsUWWahF32i7zyK9UVbf5KpAJdV4d3/ZEDWc/hPMJ8NgAwj01sYh63cjJFUlz/p3f4y9iLfPrzmi39Fwhaxcwhc90uqm0PAptPelj6pYoMnkJ80hhHHPAgJ3AXp3IzGQZZzat5hMO5eecpDK2Z7T83cXeqV/m9sOjdD/MuvsdS/kC25GyzL5vo3JGneQMeMbdNmASYBzgGGp+ZMzvS3UDCR04ERdLkyLKB+fyWV3IrJ7Np27zyZHF5V2xp1zfHlZbrbRPRoUTqbccK6WB898Cx+PcaG7W8QxmCfu+ALEKm0ZkdLNdLS2qkPPdm98AQ6w3LtXCneTseYtqMThqB3QODbJp5ZELQq0F7ezuHHHIIDz74YOS5Rx11FH/+858ZHp6Yz/T27ds58cQTWbt2LSeeeCK/+MUvaoreIo1sx2NQbmM2kmvDZLx89UAaHAbkMsbTMDx9GiOt0bOvq52YoS3N2sIdN10kTcfIcNkvXCtHoeWWFKmftb6pwu1EI0eWj+38ivP4SL7Vi84goagkJF2/YzY8uH0QXedPtO2Ij7Js93gW8VS66LsxpIuwsa3STcX1Hwfa4pIROcZp636hbCE3J3aaGB7qYGzzjOBKmNXWR4h1KLPseZZO99zKOhgu+/kWSvMCBulkG13K73+05B/c7i0dv262T1619VjkBd8VpRuf2GqrG1T6P2eB7rFAx5gq/xfIzsyxPxvK8zjEVaWVER7lEF4gyz9vuYjd904PhmHcqOQS9xh5PiKXIEelK4pt2N9RtxWIIuSTjSyl1WQbUFaB4ITROJD3NAuZs5/3vi03zPCeQT/hVnJzZMMcUYtCGk957IHmlQP8put4jl671sujSPB5z/R+z8/PsI0uIBi1yiTathFKPYJYb0gYylFauJWTeZzFdc37gW3LynNhipZIKal0wRpqUiZTu0j9VIF8Z1rbRiq+z12t23xXTIe7ZnFgiD/PfI2VoHfvWNtQgt4/87ApQdB/9rOf8ZGPfIQPfvCDfPzjH3ee9+///u/853/+J1dccQWnnHJKzeXVTNAXL15MU1MTjz32WOS5S5YsYXx8nMcff7yWogAYGhpi5cqV3HfffRx99NHccccddHbW1kDKBP0hqGqURlsQC45tR3rnPI8Ym+4S9Uqbft8uN5A46NyRL13rcb447jUpo6MfbZvGptZ5VX3Ata/8N/l7ri2eRS5qtboSducjlI5CGtZHTO6wkZVawrdNhHjqSXhZaDvMC6hsdgjlWMK2zt7lFuOyiJqymG4sJZnalmyvIOSmNUtQjgiycUbQZaUWxcC2Lw305XnbfldRJEULo2R5gU6GyvNDBsnwV+Z5cuKFyRwtLapz38hydjxWMoPnlFzmkHYazyqawbd2mqQ8Y5xfqrNpvZ5DbypdLBOBjswuulL9vII1vJPvluez5NiHQTL8K5/mmW8v8YfKwZ+4a9ZJD8H6HKLSIm7b1rBZu+VXMM4x07VCRhNs+XRD79ufCL287uH/IqCtxsPFDrZfsZ+XKFA5YmYiQyXJ1u4G8adARa/Ma6INOAwOPush/rT9KJqe8vaNzYe/zDyolJVnHNFugHqifZE0m9i3bLAxwzg2AimKDJKhg13laEv1gETBkvfvn/lMaf5JZzlmvKC1bTQQEz9FIdQgNBWhn5mMHoJ77ltxYCdrZ660EvR9XvhzQwn6C/scPCUI+hlnnMFPfvITnnjiCQ466CDneevWreNlL3sZZ555Jtdcc03N5dX8qT3nnHP4whe+wF133cWrXvUq53l33XUXf/nLX6yTNONiZGSE0047jfvuu49DDz2UW265pWZyHkCRsrV854HxfdGrhWflTVVMmJxIWsj5jG0yhGVOohwLbO+cGc9yni4W2ZVpLsldZJ+hFxjLtesTgkN+ZjqYWWR5TvS3BYkdhA+129xEzOOSzlHpT+kiIbVYvcPeKvNYt2f9FciS2sVCmrHNM8ivmeVfZyPdLtiOmcRbYLOIpr1JZxphVvJUukiuP8vujdPDIyRUUzcmMt457zjif8q7srxQnigJXgz4RzkYoNyhF0jxIMtY+/DRfl7aXSVHJYE6DM8/fGOTR3r7CbaNrEXu7mDYyNaSb3lL2yhdqX7O4HpexV1ly2Qro/wvb+fqb17g57W5JI9ZFz34fu7ghdQU24huq1FE3DRImMYE2zWutAtmGSvhgON9Q04YuROfbYg/ad68fjIiZknZ2VSOzg8PBsp85rk++L+ll8hU5l0KdPf/z96Zx0lRnev/O1TTPVszDTPOwMjIwLAogiKgGBARRUnUEI0mJu5JTIxZNTfJzeLvJl6Tm+3exCQ3ZtEkJm4x6lUx0ZC4oygJCAqOLAMMjg7MOAM9+3TTRf/+qHqrT1VX9XTPrtTz+fBhqru66tR26jnved7nJfciTZMdy1Ey21Ga7jOvb5vPmOlJJl62mz9yleVeBMZxNVFhS1h3wu1cD6ezho5m5QpFiVBFAxGizN/5eso9B/qUYr2ycIZjuwHrulbQzI/5kvVdrCTEWpbyR65E1zXivUHrHDmDEeVFzVZuWq6Dx0xmE0MBt/Y5P8vmGPSElq7pHyIkR9FMxaZNmygvL89IzgGmT59ORUUFGzZsGND++h1BTyQSXHjhhTz//PPcdNNNfOITn6CoKFX6tbu7m9/+9rd861vf4rTTTuOhhx5CyzGSC6DrOhdffDEPP/wwNTU1rF271mZ70x/IKLDlDZABmUSF9cCYNPu9/DYyy16GEW9XFVP+VorQZZtA0++HqT6/76SUbEizW7LNuxGn9lJSFs35Z20bJqZ/KISrr8FDtnIFgRvxSkDJaQYht6LjWt/3VmtTKYfrlJLPTglNX9HXLN5NH13yO9tLI8JBKmi2lnU0tjCXhPkil+JBtcxOJU6qMyEySHMm484z26PKEOS8FuM6wJEZDsCWEFta1Mqv+LS1rKHTTSE/4/M89evzU9uJku5U4yRvLaTbFTqvt/rcRRgeJIAv9zLl6Hrbx84XvGpfqWIgrlZ9YaDbztVhS+xRd++aDXfk9T3rpkqivGYTsoHzmX/T5TNBMUy48S1u0z5JFQ3ECNJMhWfhpGwwm9p+/c4NUSI0mjNemaChU0Mdp219GWVs3ve7KVNl+mL417FzrO1LkSexzZXr/RAXcmfXFfb29PEOrg7VM5xOaoMFvb2LV0re6xpBL9q3m7xhiqAn2zvomjRtVETQCwoKOOGEE1i/fn2f655yyim89tprdHV5V8XuC/0m6GeeeSbJZJIXXngBXdcJBoNMnjyZ8vJy3n77bRoaGojH4wQCARYvXuzqspKXl8eTTz6ZcT/33nsvl156KQAzZszw9FOfNGmSVbSoL1gSlxcViUsmmUoCqIQfl1/Hf8b+wzPxJNckFYAD+0uzanOqXRrsH9t39DSa22aHHCPdPzkj5pA+mJgMxXNSgx+3jtftMz2h0bZ5ov2e6etlAemEKxfkQsg9ptFLTnUn5G7+8gBxPcSBuqPTZzb6OzAQKNu56Ky7zOTfFKErpJtKswqMvDw3Mc+aYi4139KtlPLgrsuwOTKoyZsSNVfbO91sV1T5Tr6XvkFp99hjjQi5SFaElCcSGrNKdnAT30KKT0WI0kw579v1NLyUlyL+UWX/ToImsgl1gKD+74RLGwcMdZ9zYOzF7ZSWGqMIqaoqEPI92FHrXJZVDPe+ncti06mjsXdvDfxlrDHbkc3MkZonMIfMUjQvyPq9uMtv8qH4a2/zy6LrqGYP+7DLEEtptWpOGE3LTD4HU27kdU2dWviomfqqkWAWO3Iiv84qrWE6OPpZc5Cdj5GHZs4gJith/YQTgdRxCmmPmZUTAH7BZ1jbero1Y+aE+s7oi8wPNzJVbR7THeXghONcCXp+Qz15w0SWk+3t9FZVjwqCXlZWxrhx49i9e3ef606bNo1oNMqBAwf6XNcL/SboY8YMXBKSl5eHrme+Ye+44w4+9rGP9bmtKVOmUF9fn9V+5SZjSwuEc7jgnYrmV174bsiVnA0FhkK6MRI4tZf84uySi6WAjHM5ENApKEqVw47HgrTVT3S/fs5BmpvbgZucxvl3LjMNzmXnNcr2Wsl6HoR8zLFdFJpJpcFQ3/74PbHClE7baR3W17E4/3b+tgxOO/4fhOmwCDYYZDxIzCoMJER9OzOJE6KbAkLECdNBjBD3tV5iTLe2FKUT8qhj3/J/tdkulbCrpFxtf7XdMlIdjCcSGvHeEL+q+LThkkEnYTqIEuGsZ9cZ23mJ9OqrxaS8x4VIJUhvixNqfkJ/CLnbtsug+Mtv2z4qKOqxZCZqJVsfuSNGkCjjefsPxxjFjkRq5wWVYAvU5/nYHHbuvO9lcGgGI8Z+pJ3vl36NxawjRsjSdg+3xr8/ULXUA4XqBBY2nZ+Obj4AOzHOVQgr+n5gRj47lGRVmRkzpELl9FDIdmbxR64g2hZx3V/AQdi9SPJIk/lkewft5TNdCXrezkbycuFOA2lHR3ua3eNIYfny5Tz33HOsX7+ehQsXeq63YcMGTjnlFE477TSee+65fu+v3wT92Wef7fdOVSxbtmxQtpMLLIJ+TxsUmhc8Fz1yfyIbg4l8YE7vgP1hC4u7KSjqSSNq+3dNxXIz6Q8CSSbW7OlztZ5YIW0tkZQfrce2skIiL7dZg5G4ftnssz/t8iJtARhT3UUwP0a4pNMWFXMWZAJ4860q6A1Bb156BDfbNrghYWiQpYKnU69pROx0mxRiOzMBaDULt0hUL0Sch7iQnq6ClPOKtFMIt3MwUYwRpVbJj0pWVReUfKDMeLbCEbvWGAxiXl7UzDXczlKeQydAmA6+xU2sjS2lbetEw886ir2fEA05pOz1nE47KnIl427buD7dYu24o2vTIpIDJeAjGTF/p7RN3FH2dVXSecdRmLbkmSH3tEC9DyLm/9VZbMdtu+pAYcUhpk3ZAcDH+D1n8PQ7clDWRLlnLQzAsizNBtI3iSNUpK2TsTsxqsYGMCLtpUAR7C6fSCtllgxGZlG8sI7FWbWhlVJ+3XVt1m0ebCTbO+iqrHEl6Gxrzi24ORB0tMOx5aOCoN92221ce+21zJgxg8cff9xVi75nzx7e+973UldXxy9+8Qs+/elPu2wpO/SboL+TYd1km6KpmyyQANVqqa9lYGykg4rSJms52hWhWymvPBpwuDcI0bG5O5EcKRgq0jxU6Iu0TTQ8tssrmvqcnm5sMvSeh+sziTMztMEDxce+TVWRUUV3FtttEXIpbS5Fv+RF2Ey55aAQJWJFcCNEWctSgFSSp1yPqPm/20xIMfaiPM4otnwekHWN3AEvCdMlofsIEuMy7rE+/wo/QkPn2Zvem65nLzP/jpjLLcr/ONYNOP71hQDwXlKEPwHHLXnZIgd9RRX7q+vuC0Ot+343tE3I/Na98+BPY7OrlCv5E175PWAMAAOQQyHSFBzbGntBO58t/QXv51HrOXynoJVSmqjwHEQ5r2GQOGW0INaSUjtBhfpcFdJNOU1M2NZr178DVMKhCUY+W3dRPg1UZRwwZIPhTMZ1oqtdZ0XJVneCvrV1eAn6nNJRQdB1XWfZsmWsW7eO/Px8PvjBD7Jo0SIikQjRaJSXXnqJhx9+mJ6eHhYvXsyzzz7br9xLwZFN0J9sg6JxMLnX8I728e6EKlPpr8xkIJKVbPflhUzfR4D8Q0yY3ExYy/wybe0y8h06t7kUWMpl37ZI3iGOmrIPgOnUMY/NQMqGTOwNpfgFGC8d1TWijhpzs8bLs4UyokR4ZeOpqf2oBNiN1ARI+ZRP7DVmZVpIlyjlq/8OUVwWtcmfBBoJFrKRz/ILm+vFH7mS7czkqRvOt58HIftifSjRfGfSnjrA6qvLmY5FuCZetNuWGAt4kpDBWM4FQ+Wc4kSEKBUYAREn4cplOZt9u3luqxFSr9/nAg2dV549FZ4g+wCKOhh1e4blHhQv9oGgl8xJpx6/+dQvf2o7705SXEorq1idcTMDGZh1EKa+X1MLqX2rlV8zVQ+voY4JjebFa8dwlXGRAvYuhGiRRwUoB7opsGYORxKd7TpnlrzuTtA3R4eXoM+LjAqCDhCNRvnYxz7GI488AmDLrxQ6feGFF/Lb3/6WSCQyoH0NCkF/4YUXePbZZ3nrrbfo7e3lt7/9rfVdfX098XicmTNnDnQ3g4Y0gg6jK0rq452NbCOhA9h2cfXblBc1u5IDdYpV1zUObD06FYHLdh9en0eMSPPsUC0L2GDuz/BNFgcVlbSIrzIYUXKJbmnoRIlQSgsh4vz5tavsZFr+ViPfznaZEfL8OQeI94YMi0c12qicL1XGkj/xAOESe9hdI0GYDsYT5TvcSCmtxAmyxawi+6n/d6fRlmLlR2J7WE1KNuNWFkLaUuzyuRApk1iVnL+fmlCddV5HMoI2HFCJWKk58grTwYU8bNMGQ+7F0wbWLvsLYR+V/BWj4IiQp8G6Nho6r9x9qlEQKdf3kAwE3ZCPMciTv/uLN+n/DKwzZ0c+89peAopveZvvFN1ofST9SRUNlJOaGVRlepkIvdofSTBAvZfU6tRuKKCbCpoJEsso/XHeDxo6JzdsNSq3gnGtcrFwHwRO0rsQGoom5/SbGc++CUB7F5SchztB39gGxcNEljvbYUHJqCHogg0bNvDII4/w+uuv097eTjgc5vjjj+eCCy5g/vz5g7KPARH0uro6LrvsMsvrMZlMpiV+fuYzn+HXv/41zzzzDEuXLh14iwcBrgR9NMCtMxvM9XPZ1mAvD2fbBgNC7IYjgp5p2TyuMRO7qKposEWm1Kjg3r01RuEir2PJFL33OnfFhoY5P9LBNSW3m/sNmPtMOZWo7ekgTANVlnWbvBwTaIwnyurWVUbxIlXaoUpWnHKVgOPv6iTFE1uM6oxvjkv9Tl1HZCsKxpR1UV7RZPtMTUL9D/6T2dTSTSFRIlzwP2sM9w1VC261QWnzZo/2Osm42rZ84DSYv+z5NNI5WtxJckG223a6vwC8n0epITUgGSoMpmRFI0EnYZ5gBfVUpwbDOZ4/53kKEuPl355m3He5kjO33AsVEVLJ0f2FRNOHK5jlHJhnOL5bf3k1leyzDazUgksAYTpdo+HOgMIua1Tjfk1LabVmcnKJ9Od6f4Tp4PgNfbuFDBjqoCEA0sz2TihZ7kHQXxhmgr5k9BH04UC/CXpTUxPz589n3759nHzyyZx//vnceeed7Nq1y0bQ//nPf3LqqafyhS98gVtuuWWw2j0g2Ah66ZF1wX28Q5APxZONKHlUjxhR8MGA28BDwZmz/sIsdrj+VCNBJfus5VZKqWW27QWn2iDuf22ad0K1qsvOgAkr3rJcDdrqJronAquEXBnYjIl0UVnR6JoQ+3l+xgqeJE4QDZ0v8lNe/OmZqWqNKiZjkOr9pBxX1H2Bu5xAvp8Ic/7tXwOatheMFi11f/DvfH9Yo+C7qMm5FP28tBFX9vt6gIv7dS6d10Ajwcs3nZaZcGeCRNXdBubFDJyog5Hk+g6cdf7Uj37KNdye02+iRGigyvN7KZz0bkNGicuzw0zQl/kEPSd88Ytf5Oc//zmf/exn+dnPfkZeXh5Lly5l3bp1adaJJSUlzJo1i3/+85+D0uiBwrrJnjdvMq9obCY98mAt9zcq7bft3d82J3LdN47vndsKwCdm/S9S4AdS+ss4QerMSJLqi66WANfRaKDKSHgDSARwdf9pIfMUufKiLz7tbctqrPPNo9yn8OU4ix3HFjCi68VFHRYZVyP4q3iUS7iPQrqJEeIj3Mv+n05Lb18Ag5QHMGQHzra7ROitdhXDjJtfQSeQFq0bbTrv/kTQnQRU/U2EKBfykJVYGFTuqYEOBDooZhfT0wYX2WIgAxX5PEjMGry6rS/t2cw8nmCFbbbLa7uZrkE3hey+4fj+kWmJdLs9d3L/TiT3aqbOfdQx+LOXQ40ymPLv2/g/PmiTt/R1f+podFNo2Sm6IZd7fDCLPA0FMhL04VQfdLXDWaOPoD/zzDP8/e9/Z8eOHXR0dBAOh5k5cyYrV64cNHfCfhP0mpoampubaWlpIRQypvi8CPpJJ53E/v372bdvn9umhh3WTfbSMI4CffgYKni9IMWi0iTN75n1lKXhPI5aeii0JWh2my8dlVjECLK29XRrk3pC43BnoTsRd/Me98CYOYb9I0BhcY9RsKszP90CUaBGyFXkG0mqTg9nHY15bOYS7iNMB5U08t98mT+vucrQiUsRF9mXJNYlsGtupR0yGHBEJYu//TbBfIOIVmqNmQ/6HYJMJHwpa5luSlIAK5HO67decEvMlEGhDAid2mCVFA9lkmg2DiCSPFhNveu+4gTZw1TWcwrNVGR1Tryw9a25cEu+92xUJvRF1PMx7v3IgJqYSih9J6EMo3owwGR48fh5tgF9Jm27rKMToJnynGdqRhs0dILEbDNcsfYeril5zJ2g/32YCfo5o4eg19fXc+mll1rVRFUKLQmj73nPe7jrrruorq4e0L76PfZ96623mD17tkXOMyEUCnHw4MH+7mroEEpC/igysUnkYfP9VpeFEOW67OOdD69rbFsngdMG9H01RjRT7MTA6IhbKeXvrKROn562mWhLxCDgXnD6zXtpUqUpk5OMMQtNhSMd6AmN7s5CDic0elvGQ28evW7kISLbsR9rftlBCot70DQ9zU89TAeLWM8i1lPDLp7gLK5q+gOH64rgGezR+AgpN5cW3N1WhMAoGHO9kfE1uyI9+jWYUevhiJjb92ccfAXNLGK9JQsaT9Rmk9kfza3bvhuosj4zUu9UMh60fp9psDASy4IeCogTZDPzLLIuntnGEcSZTS2zqaWZcp5muU0mkY0jjCzPOXoL+o80tjfN4vAtRbmRdHkO80kn6QmMZ6IOe0S9P6xAElJlgO1WxXS0oQXDQcfEewKbrfyQMXO6WFyxjh/xFWKEcBbs0izyHqfaNLWX6qI6Gk1UWPK54coFGQh0tLRZgV4ycIiRyEUYBTh48CDLly9n7969BINBLrroIo4//ngqKipoamritdde48EHH2TdunWceeaZbNy4kfHjx/d7f/2OoJeVlVFQUEBDQ8r83yuCXllZSV5eHm+99Va/GzqY6HclUR+Dg0QfbwC3gQq4E1V1IJJpOduBjXP/mQZN2Sxni0D/eyGnxaJbp7/7rRpIaMa5dyHzNnQq5zBT9M2UdFCWWiG/uJtwSSc9XQXEekOpiHtvXmp7TggJDiTt58H0JC8piwJQGmo1j8dYp5AeQsRYyloAFrCBJ1nBcyxl52snwh2O9uab7RVi0ondOUYl5PL/e43Pj1vwsjXIGU7d92Bt21m6PUiceWwCjPM4ly1Ztaevtqpootz6O07IZq2Z67bAkHyokco4QToI4yy8NBgYT9S63kFijDdHpV4RdUHQrHIr/5zr7KKG9SyiiXIrWpnLNX3lNdOWsS/ZmBe8KgLL8xzBLNZF6pkYbEQd7XHWEBhtOA0+/IE/cAEPWW4ufTnHZIMmyumrVkV/kMBI1h+oB3tP+yGuK3nIPYL+f8McQf/g6Iigf+1rX+OHP/whp512Gn/605+orKxMW6exsZGPfOQjvPDCC3z1q1/le9/7Xr/312+CfvbZZ/PUU0+xefNm5s41rMjcCPqzzz7L8uXLufDCC3nwwQf73dDBhE/Q30HIpXhUFsWlbBgAKR6VEPKtLjvR64iKtJBBIqP8HzG7iUDC8g7XdY14rxHtTCQ0ejsLUzIVr+1ZET2zymVANwYOJhkfmx8nlB9DC+iUhlqxuzB0WPKcADrv51E6CPN7ruapn56f0sOq7RYXFpHfuBFy+T8fo5R6PsxY+Yo5+xCwEbLR7JQiULXvVTRYRLOSRouIq3kF2UI344YCiRgK1Ki4s+3yezcNuSorEBguQMa5byT9JZjadionwu24BnNZI0EVDYg7iNyPbscJUEAPEQ4SpoNCeqzvNRL8k0W8ylyiRKxzmIsbziu7FsGfcqyeLJBBd1/dnxD1CAOzacwWvdgrGDujtCPZXUtbPg2fOP5/mcsWZlNr5VsMV6L1UEK9P8HQoJ9WstudoN+vVGEfanS3w4dGB0E/7rjjqK+vZ+/evZSXl3uu19TUxJQpU6iurmbbNjfv3ezQ7/HxJz7xCZ588kk+/vGPs3r1aiZNmpS2zq5du/j4xz9OXl4en/zkJ/vdyGGBEAX5G4Z2OaG8yNTv1UqGA1l22/dgbXso2ur1nYPADXh5MNs2HOdFjkFddoMkaCbGpmYOonjLT+RzIabqsrnOxFm7DZKka+gJ419nNEzn/jI6e/Ps0Tfn9uX//EP24wPGKMuiQ68ssVukAVZhHvHHvoT7ANjIQjawkAs+ucZOrhWvcwKkNLFq+2QKP4LNg/yoq96gijdshNwZgRoquUQ2cCPjaoS2VKnedBn3WGTXi4S7fa7uQ7d+n9La6mi0UEqnQ2+bzUDEyGcQIpquMe8gTJOHVjvTYCLdpnLoMhZ1AtQz1dauMlot73+nDCJOkGYq2Ecl5TQT4SBi7bmAjZzCetawknqmus4ueN0/OhpzajagfVPnlV+fagyyozkciDwzXrNjAtGVv0nK+UWes6FAX9uOkp4b4kXaB5vMS59yB/w28TlIwJSfb+NS7qGSRsJ0UEWDrTryaIY6mKyhjoAZVB3Xegj2GOu0d3n9miNW4rJ3717mzJmTkZwDVFRUMGfOHGprB5YIPCAf9A9/+MM88MADlJSUsHLlSl588UXefPNNvvnNb7J161Yee+wx4vE4V1xxBX/4wx8G1NDBhB9BHwa4lEz3QWaSnQ16x2YuTiJwRpIxfyOfK5HkicfvtohNtDXCoc6C1HY6FW/1DMmoY4q70VyuueaYpQiXdFpERZBAo4xWK9IrEeBLuQcwChxp6Fz/+V+nZDVOJ5sysHIXbc4upF78xanf5n/kALNLaoc0Qj5YGvRCuikwK7GGFNPiC3hI8aHPnZjGCabtX6bH9ylRa68IuBMqmVc/k2Nxq85pbD+3KLax3eyXhyqi7lyOcNDy4vaSQOhoTKLRktDIOg9wEVHGEyWS0/0I0Eglb//iGEwpdG7wSsr2QgKYg30gPBrRV8LqYEbmzcj/Ob9/hJWssQbOM9mesbDRcKGSRiKxKFriMAD5bWDdmiHYWGHvOkWJ3gZ8FA8f9DuHOYJ+xeiIoI8fP56ysjJ27tzZ57ozZ87k7bffHlD+5YAIeiKR4P/9v//HLbfcQiyWenHk5eWRTCYJBoNcf/31fPe730XThj/xwQuuLi7ODPlcl2F4R5WjHWXpkVMfQEv+wO8RNQImcG4zYnc3MVZJPYP733LIBjqV0JWLln9McbcV7XZDuKSTMiWKmwlBq+JowiLq13A7GrpFUGKE+Pznb7dHxcF4GcrUey8pP2Y3Ul5MKtl0Dkw+ayeltNoIEAy9t3imZZVwBYlZUgh1NuEkNjObWptbSi6IK0mXggQa9UztV1RfrQ7r3E8DVUOiCX8nIUwHFTRb19GLrFdTTyHdtuv6MBdwkAidhG0FkPq6n7opZPcvjjeeiVwTNFW5i1OTToblYgw7UhXDIYUZTKgJrdKPDMZ7PABf/95/MFXC0SbmsTnjwDwbOPuvCFGq21IjEudrN+8aWP8QHHBs5xAwNsNyRoL+u2Em6B8fHQR92bJlPP/88/zjH//gzDPP9FzvqaeeYsWKFZx++uk888wz/d7fgAi6oKWlhccee4wtW7bQ1tZGcXExs2fP5rzzznOVvow05CYrb9vMmHGDZ4+0/61Kg4A5I5YM0fJAoxdOgjcYbRvMiEpfOsmBDqqyGXQNBor7+Tt5UTiixWMnt1NaapBhnYAtIbMvZHRoASsSLpHvgNnbiyY85FKr2uuFU0qrqxd4NfWsYjUF9LCLGovwfaXth/TePsGeONaL4S4hqMMdEiWXdQPAPDhuyctZTzkPV4Q8SMy1sMl4osxjM5U0Ii4R2SaU6mieJcvFz96tLV7bVyUpzs+bPGzlRiJqPZIR82zaFiJOKa2E6SBEzJOoh4hZsyRxgqxjMXuopkdJjM3m/ooS4c2fzuhfEmmu0XQVcgqq8Sbpo528q4MUdZAzENIuAxlzGz/45ufNQbh9AO6Ehs7CA1uN5jjUsHkJSAaU/++EV683CDZAj/nP7dByQTdwMR4E/VdtUDBMZLmnHT49Ogj6XXfdxZVXXsm4ceO4+eabueaaaygoSM04d3d3c/vtt/Otb32L9vZ2/vjHP3LZZZf1e3+DQtDfaZCbLLCngbwcJS7OKfuRQiCgEymKWsvOqWUn1GiloFsvJN4bJDFQ2YVHmwDXl3y2eHvvJEPSMVjoj7uKin5aVx41642s15XrlEAj2haxfacnAhlJ+OHeIK5Jsi7Js2Py41ZEPKCEXLSATjjUQYFJrLOZoi2k2yKcQiw1EpzOWmayHTDKbEeJ0EopMYIW8fj2sz8wtKWbsQ9I5KVWb+7E+dhJZH2yslwGky/aadneDTX6ioRp6DYiLte23LQylM8KHa9TL0LuRsIlWt1BmCgpOy91PVVm4ty+k4jLOt0U0kqptaz2LyNNgnPBaGlbiBjlNFsaZSdZNwaueyyNOmB5qa9jMa2UZn3MHYTZ+9dj7X7/2SLh+NdfOOV16rM62uUxAvX4O7FLC3ORyFwDRIzR0lizZsKs0u3W11saTyHtkW+F1oUw1jxHgQAkEtAeg9f7aOpgISNB/99hJuifGx0EHeCyyy7j3nvvJS8vj/z8fI455hjKy8tpbm7mjTfeoLe3l2QyyWWXXcadd945oH0d0QQ9b2cjeeFxlnZWyM9oWM71twPFYLZNPsumbVogQSh/eHR64VDHgH7frRdmFaV2Qk9oxHpzH6io+zqc0OxJo5naYZ73MQHdJksJBHSrqA5AqZaSpIQUPawXVFmKkGANnUoarRLpZbRQSiuNVBIlgoZOI5PoIMzfWck/d50OdXmwgVSSWkTZiVrsSI0ASvQtQoq8T4Ti843Ko1WhBiBzlNEpKxnsCLnIZzR0K2IqU9ri+hG2bCq84STXQsLFqlCKqORSHMWpD1cTDiU5M07QJk8ZDbrv/ux7tLctU1S9gG4qTCIvRL2eataxmG4Ks9ao62jsaaum964JRjS979vOjsEi6k6I/ExkavKZ/D+aSft0yF94AD0RMPJ0zKDHjJpXqcS7COMzq98HG/E8j//4r9TfLhOmI4aMBP2WYSbo148egg7wv//7v/zoRz+y2YwLjjnmGL7yla/w2c9+dsD76TdBf+utt/j73//Ov/71L5qbm+no6GDcuHGUl5dzyimncM4554xKeQtkmSQ6VK4uQ+3wkY3jx3BCab+4dxw226a6eQzWQGM04lBvkDEBPe243c6DjYgLMriguMlRCopSEVkjYSlFKpzLkCIOghBxCuhGJ0CImGXVN506Cui2osAVNFmRVg2j+EwdNegEWM8pbGk9gVB+jM4HjrKXBJcp43zs7hNR5Xv1f3mRH4sRhZvcS3Gkg5qiXUC6JnOol+U8AlTQZH12nFm6u5AeqkjvuFWoloVOpxTVvrCbQk/pihtiyrpq4RF1O5IIauw7kHb9+wvntga67IQ6m5OyMuwmRHxQrrF6fZ2DH6cN5EDPm06ACAeJEDWJuv3YImaBKJWob2cmu5hOA1XK9cs8+GzUKznw/NHwDLmTdPAm6oMlJ5RcEflM/pYZMicGQuCdvw0AK+w6oPzibpaXPMM8NtvuCR2N97Oa01a/bES75VbQgf+Af2ztH6HuSwc+ksioQf/vYSboXx5dBF3w+uuvs2PHDjo7OykuLmbmzJkcd9xxg7b9nAl6R0cH119/PXfddReJhHFLupU6HTt2LFdddRX/8z//Q3Fxf0W4QwNnBN0N7ybC2J+oby44nOv2c7GfHKnl/rZtAPfNGMdvNRsRT5HwgiK7htEZ/RYS3hdUacVsaq1Ir5AGWWcR69HRLCu4JipYw0rz73LLem73+uPhT+YGVdtDFfI+bMGelKVOe8tvF5rrVhv/nXj8S0C65eBAEq4yQbYthUmENIFBzDV05rLFdu6dcFoXqsRKpCVxgmlEvC9iqeKgMgWhkvIWSm0DMfux9V+6MRQyEcAmwXNq9DV0V9lSmA6KGdjMmBuaqbCd6wSpSovyHLhZWfbnvJXRYnmmO33VhaSrVo4bWUgjlWxnps0K1OtZiBLhzfUzYCuG7KU/GKqIuheKSc/dcUbYZSbNqW0vw563AtALP192DZA674V08/GGe1NkOwC8AVwPD76Q+ql0T2MZPeR5OJAxgv6DNsgfJrLc2w7/PjoJ+lAjJ4J+4MABli5dyrZt20gmk1RWVvKe97yHqqoqioqK6Ozs5I033uDFF19k//795OXlcfzxx/Pcc88RiUSG8DByg9xk45p3kNePJFEtoBPWOrKaahzp5WwiSDoaHbH+JcvqCc1Vw673VS3UhwUh3yL1cbu/1GtqFD5JJytCGOQlL1II9ZovZp21HFaIzUrWWPuJEyRGiB4K+AWftV5ojRgzYrti02m7fqKdVMuLUo2UqX87k9bcXrYAZ2BF1eYveB4gKxIyGHAmZRrOKTFrAFRFg2tk3KnxlsGMfKZKVFQtcS7ymw6Hq4cKt0I+w6n77i8hh5TXPRjJs4A1Q5NLhDobmclgRPPV50BmPOIEbYOk/p63CpqsSqQifZFrPYlGQpb7kXGvPMMZNFHhWSDKvi+dBr2KAw8cbRD1/lQhBbsP+XAQdfVUJrAXTTKJ+C2XXGsWkDLOQRUNTKLRtpkeCnktb68t22MsMI7RFbUeTchI0L87zAT9m0cmQc+JRV177bW8/vrrTJo0iVtvvZVVq1ZZEXMVyWSShx56iM9//vO89tprXHfdddx7772D1ujBwoTQAcaEctc/h0wXhuHStg42QXdb92AokvWLxYYM0monccmmbV7LHXp4UGYChPwOpvwh27ZFQtFUO1zOQ+o7owBKrkRUiPkkGpnOLmu7Qnx0Aqxita1kvdqeG/kOkKoQ2UGYV647NdVLqJGqCClS7bRpS2AvKmI0zv57+XsFtkj7iUtSUfI4obRz48Rg3V8As9huK/6zmHUEiWV8LtRESuPwNYuIOwm/uk+3ZYmwuyVtGsm16kAlXQttrJ8ilrKO17K6rWyWvUiwsz3OZdHnyrlQv6t22ND1F/09pmyX1c+dg7QeCilQiiz1UOBK2Ps6bzLjIRH1QrqtQXSzuf0YQWsAcwbP0Ew5rzKXjSzs871QpTUQvCTG/sg0eIn+SV7kue0l1S/I35kkLf3BdHjfv/+fVQ9BR6OUFpscqJRW8vNeN+vjGngLUJ2nhYAXAm4eVj457wf6O8Ab7ftS8Nxzzw3Kdk4//fR+/zbrCPrrr7/O8ccfz1FHHcWGDRuoqqrq8zd79+7l5JNPprW1ldraWmbNci9UMdyQUeDJbasJjCvKmQj1B6W0ZvQyfpKzhrwN2aAvQjRSaDEjj4MxlT5eiUINZ9vKTHlEf6Hep8V0MJ1dluRCJRRTqfcskiEE6et83/qsm0I0Ejz19fMzv1RlShns60lip/O3apRc5bhnYFXwnLHkFVs7h2O2SP6uZo/tmixgQ8YkTicZB/fodV/oVqzzpH0yc9FB2LoexneDq+vOZTnbREsj+TU1sHFisEi4E05XquFANh7vnYRpMRMn+ntNwSh8FKbTludgfK9RRQNhOiigx7JljBFiM/OAzM9CC6Xsf20aPI8heRnoZKdKoLKJrMsjFoGx32nnd6UfN9toJFLLda2mnmM/uJfHHxpg+3z0Cxk16F8f5gj694Y/gj5mzBjXAHQuyMvLs6Tg/UHWj+Y999xDXl4eN954Y1bkHGDKlCnceOONXH/99dxzzz3cdNNN/W7oUGAx6wiRb2lMhxIpgu5e7MXNX3ok0O0aY4BnOANwJ0jDgYGS26HEYLZNzm2QOJU0Uq2UB9TQrfskTAc17LJKvDuLoah//4Qb6DDD3RKJe/EmpchCpkhaRPlb1aB2evzOi5QvxEjwzIfJi3ZmJHT9hZM8O/Xf5TRRRQPiQjOdOkXba2+LSFHUpMtWylwH884ouXzWYmW32tvSTYGDoKeTYvVv+X44l+3HYiQLS/VLsN9fToLuJY/JdjCQTV+c2ld2SZ+ZlnMZELpBEnzlWAqUJGGRO8n1jhIx06wzXwPAPKthq60qUW+k0jrvQeKcwTP0UEAh3USJUMtsWxvVYyijlbLjW9k+cRaHXhrXPztGFerMmCqBkb8Xws+/aOi/Q8SYyQ6LjJ94/05qP2ys1gN0kPLzbjD/+RgYDpn/VIcYPJY/WAJjTZrW3gt8zWOjOsNnMzNCMcPTTz99wAR9oMiaoK9fb/j25mq6ftlll3H99dfz0ksv5dayYcBZPEkRAUtnCtl15LksZ0tCzuWxnF4qg902+T5GyPWFlPK5To8M95j2X144SIQdLmW+I0SppNGmhR4qdFPIFuYO+X6yhYbOQjakfSYRcfFNrlS0lELQvWQSGgke4GLqmUoHxValyK1/ODlFpt80//fqXEVuok5ly/+duEfI3Eh5PjAdw3klHybMe4tSrSUtqj+UmvIIUdOBJmZVd5TkTicp76CYOCGraJLcz9kQ8oPWugFb1U4hZW7WhWB/lvolLxtEyP5FvgfGtVF14UIG5TuBW2TYS04jMCiqblsWBBVXFnVfmfrTTNKhvpazWTclz/Ei9am8D/XYNRKU0mpZcEaIWoS9mwL6gqF5ryREDB0jYVkCAkLgg8SJE6ScZhazzsp/aKAqY788q3Q7HeeF2Tv5WPgbZFkIOIWE4/9O+Prv/wONBAvZyDw2ATCl+W0ORSCgQU8MXugyVu8B/sHw8bzRjEPK316uLrLO0cCCY7ET1yJgAjDD/CffJYBTwTbRpzl+m8AIlwPtp47lVu1jAPS2x+Frd7g3OGFuZzgwQjfIQCqADhayfits27aNKVOmMGHChJx2UFpaSnV1Ndu29Td9fOhQTCfFjrtsoB15puW+MNQvmWyWvQq8rOAJr2YTI0hnBk/mbgppcKmWVkg35TQPy+xBjBCzTRu84UA20ozpjrKYGvbCNpmwmXnUMhsNnfUsop5qNHT2PnusQcI7Mf7PRr+nWpvlkyLiapTcK8FT/T+CESWfDkw+RMnEVipDja73aa5RSjc472Gp0DmeKMV0MJV6Smm1VWlU0WNGsmOE6KbARrDdIAWWwG7DpzqzuEkgctGF57LuQJfLTEYm951BAI0kRSGkXjN+bnDTcTtJuFufOJDPIN2/XaBbe+x/Pk+Boz+U2ZdMJN7Yt52wG+skKDUHizKLokbXZR23a5bAqOAaQKeTMBGiVl8RJ0gTFSTQCNNBhCiLWUcjlWxkAY1Upj13shymgyknbqNhYhWHHy7yrtTrgot+chcaOvc1XA0hs6rlyUACWrfAy+Yp2sGRScILgDPOBUqUD73C2NcCFRgn6zmwRPXq+iHz71JgDvaTWoxB0BfC21OLaaDKyoNZw0p2UePZTg2dArqtCqfyzMYyvTwOAWO8vx5UHOp7lXcrsibobW1t/daQl5WVsX379r5XHGasZSn55gtZqjcKAui0UMadXEFLW6nXJkYVZpfUchn3ZKWTzAaz2JGmf3R7oYkFndf3EinvC0Mtl8mmDcMJN2KgY9jvNVBluUUAbOEEHo29n1ivcb/21k9IRcNznaKWKLlKzIWMR0klfUr/rJJwJzkvxrA0mwxjT20nHOkgokWtgZ4bIc8kRckFElEU94t5bKLQTK4zouadaeurmmBJhvVqjyRlNlMOpBJAIaXb94qIu0lWslmWz/qjG3fKJaQdIdOXB4yETSGSMjCWF3R/ofadmSrP9vf5dpLsmHlE6vdeBH2giDkGbM5BRtCcd5G/nZDnWm1fkJh1f44nSgdhWih1lT05r2mMkDmgNGYtpTqpjkYzFUQZTyHdVNBkJT3voobtzPIsbBWmg7kVW2i4pooDfzvaKCImj475vB918xvWwGLf1hpoBlYZq6x+dHQnWmZzF4wDFs3BINOZtCBzgE/D2/OKra9Deoxgr8EiNfOx1AOgB8bwfGiezfrUC+tZRDeFlB3bQtUqwy3q1BdeMfa91XEgmvl3CHs7Q8AeOCrWSWhGHaVaC3FCXMhDdFNoWXN2EqaRSuu+TKBZwQeZJQrTQZwM6YnDU1tw+Pc1ypB1D9bZ2Ul+vtNwNDuEQiE6O/uTMj60+NbzP4KiDEkHvRiJNP1tutfZ7SvjXV3OIfTw8uTTePnU0wYvXFEGFA/v8PVTU261WQG+WxEnyCd23Q0Bl4uVCEA0z37fvQlsxm5hmC1k3TJlWb3H6kkRcjf5Sr5jWYj5PMg/7QCh/DjhUIdr9L8vMt7fyLlYTS5lrZVDUq5Y9qnbF7mJVOGMmwRPHTwIgRK5llp1U4iNl7baDdkmAma7nM06sn0hyVU0mEefioo5PcOzTQpV4RYJ95olcZPRuc2YOJed0gwnAZeBUn8kfrlqzu2DS3uicYwgHRRb51etsKvuXyXq6nktNhM9w3SQQGMHs7K6x2SAGSNkzkQ2ESJODwXECWI4nrRSQZOZbNphkUDngEeOsUproPC8bt6MzDD6m+mQLMoz3oGfwyKqz/wC2kmR8sEk5+qRO6Ud6vKSIiiUyHQmQj0Bnt1ySp/77ULjb1kUBGuigi3MtYwBAAKaDkVY5FaVIeb6HmuhjCYq2MRJ7FlSDUDlsn0sW/1PY1AUM48vZv4Dg5gXKZ/1wrjGQ4zjbdBgxjFvkiyBlgnFLGSDbSbwPi6xyLo6GI0T5JDLrKOFBMMXQR+F0y9btmzhZz/7Gc8++yxvvfUWsVjMlgz661//mr179/K1r31tQImtWb/m+1lwdHTjb8AU828vklwGSq7X4KCvGy7bq5LAbme3H3i4f03y3sfwxkZ+s/CL/Kb6i8O6zxHDn4CAx/nNNLjLFhMd6wvRbsHuuuIcgLqRcvn9RCi++m3DrjLUYWnm+xsFz0XeEiTGXLYwy0wy8yLl0p4OwjSZ0W81Uu78v5FKKzlaXlRuSXuDjUzbz2bfKnGuoNlKGAaDRBdgL2gF6QMFr+3JspcTULZwXlvVB94J8e0He7K6eo8MxsA9G1Luti+3fae80A2IXEqOQ+wS5feiV3cOOGTgNJta6pielT4dsLTsMYJMNRPK5d6PESJMB5U0MptaJtHILqazgQVWu6VdEaKEiPFCbAlFfz9svFNehI0/NcbvziI98ncuT8fRyt9OTi2fnfBFeOWWGYDxzBpJtal7Qdr8f+ZAww3q9YwT5I9cmVX7ZGBluOMY10ytKaEuuyUypzJbUu1yK7iVzb2no7GZkwBj9rRx1SRCxKmhjhNv32msJGRdCDukbI+7lI11QV4+HEUnR43rhGPgkLlepCRqzQb+hBvosQZ+QQ5lIiqHgOHKnxxlEpdf/OIX3HDDDTZC7kwmjcVi/OAHP+D444/POW9TRdY2i2PGjGHmzJl84xvfyHkn3/3ud6mrq0PXR0dU1LIK+ngbjBvXd2pzf9/RzmhntiNBdbDQV9vcIu1uv1eXJ5JepW2o0UvuSUg+skcZ6RX1nMt1pO6ZTB7l8pkgAsXXG6Q8GIpbUqHBTlL2WtbRuJR7EOeHTFaIPRTwBlXm79w15TGCtFJmRca9NMyptgxuyfrBgDpIASNym4teXMVgy1Lc7CgFqpf7kQD1GkVMFxx1gOh23/WY5LOJCpooz/p+Ew3xdHYp+9ctP/VymumhgMWso4EqvmZarW468B7yrjDWb38SXoilR62dkOTF95XDy02p0uaZnmN5zlRy61zeziw2sMA6Lq9nM4CRBBsjlDaY9bLXzfY8OmeIpJJrf+B8ftSARrb9nyyDIUeahSEXPoX1TPnp2/YdqhLEItLrlATMzwXzoLfIkObsKJlmzfB8i5sY0x5ldcmn3G0WL2uD4DBZHsbb4e7RUajo6aefZsWKFYTDYb773e+yatUqPvrRj/Liiy/a+O3+/fuprKzkgx/8IA888EC/95cTQe+v5UwymSQvL2/0EfQrh/EmG01wK8E+EGSzLTf3D/X3ZRhJhtlKf3JBpkGXMxlyNCKfvmdx1I5ZUI/9vDuPUR2kOX8bgOIb3yaR0Cgs7qFSs7vJeEWBBktSECHKuTxm0057QUczX9ZBT1LeTSGtlFpT/Op0brZ+3wNZzlZG4rbvavZYTkdqZDabQYAX6VDR36h0lIjtXAvZUiue5kpCMi0PBIPdlv60Ta6DEHXZjhdRj5vR+B4KqWN62v3ltY8wHZTRaslmwBiEieRlEeup6drN9qIZhIhz7Na92Cr9gEHiZOAurh9qE83l+5edz9Msdz1OZ05XtstuUWu3dWVWzCsKXcd0z3OU63Pq5j7lVdE5E5xSMCH+/ekvI0SpZg8BdBawgWn374c3SM8ZAneyDobmXtaphK6pY9ASh9leNIPe9kOcWlLvTtAvGWaCft/oIOjnn38+jz/+OKtXr+a8884DYOnSpaxbty6N306ZMoWioiJqa/tvTpE1TTvmmGNG3BNy0OF10w4VRgsJHMrKXP0h1QEMeU62EfYE6WXlvfYNUN3H9rIhwOq+c5lxGeiywPlZlNT5cs6SyP9umnJ1cOY2x3w+cGwvRx3dnJYgLMis0c1Nc65GExewkSoaKKPFenl5kSAdzXKu6abQlZR3EKaVUhJo9FBoveQzkZyhkrRkq0GvoMlWfMrbNcSd0KfLUjJLVPqSFwlBVNf1Oo8i9VBJhJNADXR5IJrzwW5LX21zQs6P4bbSmUbuVNmJbM9Ieu7han6fVbKh/M7IP3BKlnRT+mTsd1aXIZU4VAXmpFOqLQH53xAaa4nD1t/q8jw2M4/NNpIr3u3qscQIcR+X2I411a6EjYA7Bytey33NGE2nLu1ed1qe6mi2YmNez2W3g7CDMSMgTimyH5EKecHZV4rkS/19togSYQsnAMbMQ8WHmiinmSoamP/C60a1WCHpbeb/kmAqUXTTXpEA0AlFbxyGIjgxsJN90zLwvV7IcXzaf4wiictLL73ExIkTLXKeCZMmTeL1118f0P6yfhvV19cPaEejEl24X3y3Kf/BwHDLSrLFYM/GB7AXrMhm/7m2IeH4OxPJ3aq0a7gSTrIZPAykLZl+6/adEHM3Ug5wNRx1ouHU4PRaz1Y32R8sZS0aCaZSb/lsZ4pMdlBMK2WepDxGkGYqrEQolUy6aaxH0n88TIdVulz0r+rLXpBpWl51YhEynmuk10mo3GYX3JBJFy73iDNJMttldTsDhdf9259tZzM4raSReWy2CLjbYEFDN/3RW9IkHwI1clwWa0UPZP/MiatIVseU4RHQEodd/5blqsSbLtsbo/ytoSV09IBGtWavKCtaeSmepqKW2Ww3a2d4SVQEXhF2VUeeScKm1uHQ0Wya9zhBR8GxgO1v5+BC7ZNk/xGiuGnWZX/q/0LYZfCRSc6nbkOcqd6gis3MY+2SpcxbspllL/wTq9yGvBclmVQjZQGpatlN/XpRQwZxhc7wJYmODuEFYJilTJkype8VgXg8PmDVyMi9nUYB2v5Vwjh5tlRSNw/u/eUHhnTfl979MC7W4CODobgLhmKAkwvcSH9/BgGqdj8Xwj2Uy255Bc513aY5nTgfpizbho5mVYL0InfZECqnbtwtUltOE5Xs4yQ2UUC3Fe11s6gTiM1hi1nJ040kHSRCnJAVMXdCfbF7/T1Uy2oya4iYFSE3vtddf+eFTJZ+blD1v6r0RE1C7O8gpS8yPZDlody2c7mcpqxqJBTSwyKMgn2Z7n0NnZDedz6AltDTSG/m9bNfdyThRuq1xGEqeDttXT3QzNRAvUXiBQu0DZZTjwrDfrbSRoQ3sBAc+nYh5V7LkJJkBUwiLctOy1E1EV3IsPRD4qajblMgOS7qzIcEIbykMdK3yW/ihCyXKqnlkOle1s0jaqKCZziDjUsWEFwSZy5bmE0tR93babjBSHcjt6lImkLKd5nUOwmGL0l0uIJqWWDSpEns2rWrz/V6e3vZtm0bU6dOHdD+jmiC/o/XcZ00DGyFhXc9MqT7bgvlERhFZ7/wTPh/q7/OLqZnjJYOZFk6kjX6Sg58W83pHyDcyHgmYnokoxoog2mXvIbIIQZ72t+JCpoooJtF/NOSzbhFilVEiSDTz27blM8OEmEflWlT18Y++q/7znVZ1apKNLzadNWQ41V/lwtS5Xb6jvzq2PX1rX1ot3LRWueybn+Xwb0PyRWVNBIhyiy2M5tapQKq+z0QyDLSlUtk2kff0BKHbSReEOQQhS5azHCgg1kBe02Vs7QngFREu5bZvM5sm4a9ltmuMxVCyr2WwRgUJ6x70yg2pUInYLrNGINeg8Cn7i81MVrdboVJ/DPp2HU0W3E00b4b29Zxe7+mZsJCVmXwJsp5hjMIfjROBU187MC95P0fKYKuur6U0Lf09wgl6MuXL+cPf/gDv/vd7/j4xz/uud5Pf/pTent7Wbly5YD2l3WS6LsJkujwAEaBglF0/UcMAVI2WF6lhgdjWT4bzHN+wocg/Ht3u73+oLPuKHiGoXedGcpcACcmQ8mn91MearII31DA0M12U0A3i1nHdHbZXiCZNOXGi6QizYrPSdDFyq5BcWsZnLb3j6AX0k019S6WaulT817e4oDtumTSVqt/y/fdFLoWoslEevsaSA/GshsBd4NEI42ql6nBjiEFabHJENwQQKeYDgrpYSVrmK7XGW3JMUrt450PPTAmoxwooWncymdt96mzzxmMYn/1TLUGzG5BALUPKKOVAro9pTBuUCPxufTnGqkiZTFC/NfWm40k4QP29dp7oOQruCeJntEGgWFK2Ey0wzOjI0l0+/btnHjiiWiaxg9/+EOuuuoq3ve+91lJotFolJ/97GfcfPPN5OfnU1tbS1VVVd8b9sART9CzS7vxMRrgRf5lcDFY+ZkJjEIcQ4lqoOr25NDnJRTDsvP+5iieMjRuJLOpZR6bkOQrgz6660edpHUXNWl+x+oLNEaQBqoyVlvsT9v7ex5CxDiF9Wnfux2rE5L46XasmaASXLHfc1snVw26IESMCFFbxE/2qUpkAJzFeDKRfy/vcyFBDY4MRfF79oIqV9DQqaSRs3iC6bFdluZ5NJByVYs92jAazs9IIp6fepNoidTz0R0q5BnOMGUz5rqOXJdc3GlU7KOSDsI4i1U5+4sqGqxtZQuJrPcnd0hNtr353u8Zmu82aO+Ekq95EPT3DDNBf3F0EHSAP//5z1x11VXE43E0TUPTNOLxOEcffTT79u3j8OHDBINB/vSnP/GBDwxMKu0TdPOz/kSCs8VgR6H9tg39slv1ur6Wc91X9QDalsu+MtSDG3R4CQDGOr5zW/bCbcmfs6dPK57hwXiizGQHkJtUpXAAV6GDMB0UD2im4NbV/2b/QAdFCm8sa8rfgnPgd1M/Sp0ifcuG8GfyQgeDlKtExqkBz0ROEmgsZCMX6g9Z5GqkCKceGENLqJRmKvo9KzXU0qGRwOyugblXjDTcBlfbQ7NYw0orJyZXOIn7Fk7ocyAvZD0XpGYxc+9z1KTzL/zgf7wJ+snDTND/NXoIOhiVRL/97W/z+OOP09ubmgofO3YsK1eu5Oabb+bEE08c8H58gj7SjfHhw0dGTBji7R8NjMvCbvWQ+S6VgFu2A6VDuM/IzP4q/PIHVxFlPABfv+sW+Dc4tAN+XnKdtV6MEKtYTTnNNvJVGOu2TeWPazpkJJ67vfNV2awkiTmTjVGWV8EPZ3zOpqftSyPeFymPEaKRSea2AjZ/dxVuUcgAOvPYzPtZTShm6smHgJRrCburSW3RcWnrZDpGHwZyzVWSz7xQRQPhLsPRxHmNhgsqaY+FUrKVB7jIsjt0Eu5sIuwyg+hVdEn9bSmtOXuvq+5YuVyTMe0H+X7JT90J+kltoA0TWdbbYdPIEPS5c+dy5ZVXcumll3L00el5c4cOHWLHjh20tbVRXFzMjBkzKCjIrgpwNjjiCbpTgz6anfj8tvWvLX7b+teWd3vbnIS6lRRvHevyvSqpOik5MWMFTsF2ZtFNAetYkvZdB8WWJWSYTqrZQ4VJwsGwOzydtcxkO4Vd7gkLemAMRTsPGwVKpPS3Fw4o3zsJegI4FX635KN0U0gT5a4uGk6I9MXN8lIgib4xQlYVRHVa3Yu0hOngWn5leIbHTK3tIJPyXUXTgFR0M5tj9jHyEPmcWtRoemyXmXQ6vAReiHtHKEw3BdQzlTWsNJM6M/dS6r0vhZe8CixBOmEP05G1d7pTBtMXQU+0d/Pjkh+6E/QThpmgvzoyBF0KdObl5bF8+XKuuOIKPvjBD1JcPNTaVANHPEH3I+g+fIweZBOVBnfZjts7+aJ5wJ/TV+yqHENHKKVnb6CKG/kO3RRyLo9xEptsZdkhlcioJn25oYcCGqkkSsT1+5hpByluKxGiTGcXYTqsCPlctjCXLVbU0A35rwONQCZHvy4M8t2Fe8S8BPZefRSPcS4NHJOm/Qf3JNAeCqyqrG5oodSKvkc4aCXBgbdON0ScS7gPDZ3pet2gasnj+WNp0UrRCVg2eQOFOsjoq4y8Cq+iVdfxS5vnthP/x4VZ7SuXZefsyLsFMmyUe7cy1jisMihJVK3TDGnYfVxic1cSeEXYDfPHAnQCthwNr7yYEDGCxLOubirrqsiJoM8eZoJeOzIE/cc//jF33303mzZtAiAvL4+CggIuuOACLr/8cs455xzGjBm6XBOfoJufDaaWeiS107nCb5vftuFsm8AZAe8GLvorqcIZXiHzALyyaAaf4xdEiSCOBHPZYnlUe0GIcSOV1suymQrqqWYSjSznGeayJa0SoLjG9KUBl4i4FzFPoBFlPB0UI77G1eyhzBSDixvMXLYQ6Wpz3QZA/h5gJ5mj5W3YrdNUlMBbV0+ggzB/5MqMx6RCRyNO0JOYJ9DoJMxB8/jLaKWcpj6T3c7iCSrZN6i65WhRCTGCRE1//IGigzA/4N+t5N5WSnnxvjPf+RZgEZhy3jbmsgXI7MRzLb+ijNYR17cPFGE6bIPF0q4DffxicFBbdBzNlNNIJVuYm/XvpN+QZ0+tYZAJhfQQIkaB+b8b5DwU0pN2XWPtMW+CPq0NxgwTWT7cDrtHVoO+bds2/vjHP3Lvvfeyd+9ewCDr5eXlXHrppVx++eWcdNJJg75fn6CPdGN8+BgmZCMTKaDvZNkCYAZQMdXcSBXg1jdp8NQP3sMfuYK4SXJlGje1Sipq4ywQ4oRElaTyYJAYs3mdxbyQkQQako0Kmim3fIE7CFNPNaW0sorVzGR72jZihFytC+1tMrbVSCU9Hi/OhLmOEPdCeqiigUoarXUiRFnEeqq79nruKxSDvGZgB+5R84T5uVq+G+XvKug6aww3hr6TVugo03S3zBx0U2A7R+Kk0k2hOSMQIsJBqmiwRQadf2vozGI77+dRStvaBkWO0F2UTw+Fph91/3p1GbQF0HmAi9HR+BOXsP+3hgxmxIuvjTTUehOOwmn/dtV30lbX0LmQh1zzCUYbydfRCBK3nkkNPePs1WDgzqLL0TA82g3BTroHu9uySNCkPzTa727lqgYVymghaIrS3PrLIHErEg99RNCnDDNB35sbQU8mk7zwwgs88sgjrF27lm3bttHd3U1ZWRnvec97+NznPsfy5cv71Zy1a9dy55138uCDD3Lw4EHy8gxD+OOOO87Sq0+ePLlf23biiCfoI+mDPpo0wE74besfBqqldrz3IMNyGGyU0ItUn7AEo/BEF4ZDh6o/7gWaobsLEgkY97zyXRcpsudEACiHl+adyO1c4/nCFQLrNr2bC+KEaKDK0p5Wso+LecDSPrtVCTQq6pXTQBVi/RglQgNVdFPINdzOQjbYp3XN32Ui5qr1YC2zM7ZbXqZgSDjKaWI6qUp0QWKcxGbmdb3iuY38Lgwpyx7cb+wEWMUO1ZukyPz7OLhhyX+h+tB7Wa7Z215gq4KoIkbIKs4iWthyml1lHULIymmikB4+e+C3xAYQ1Bb5QELTaKXMsnHMhfTJ/dhKGY1MQifA539xe4qET8YvdpYLvDpcZ+rERLh+wfdYzDrbxwV0W1rqgHKPjiTk+XDe25KkDIOTE6ElIKDDTyZcRwKNZio8CbsKOU8dhGmigrhZTTUbt6cKmszE0YRtW6BUVG3fz/+WfNedoB89zAT9rdwI+pNPPsmKFSsAQ0c+ffp0ioqK2LlzJ52dxsDrxhtv5Oabb+53sw4dOsRf/vIX7rzzTh5//HFisZilV1+2bBlXXnklF1100YD06kc8Qfcj6D6GC0fjbUMoGAtUAAUOAhMIwFiz3z2UMP6uj07mcu4iSJxWSj0jh6W0cDprbbZbGgkK6eEabueoFzrTEwabsX+m9vlFsP+cEr7G99IqkTr1yh2Es56ShfSIkU6AeqotYh6mkyv5oye5lBdUK6XUMd2KIjWbRD2BRhmtXMwDzGWLtZ0Emhnlz9wjyIBjOzM9o/ayLSHmAXQiRC0ZgRzLLHawuOtF121oJuEZuxG7HWJqJ/akT0EAg5iXwE0XfpUokawcHARxghwk4nps6rkVgjuVesJ0uEb9jNRRgwT8R9v3BhQpl0S8aChiJZ32C6XNOQAAZfFJREFUh5DLgOMXfIZ6pqImGkLqvLhF/92WBxPZRE/768H9TmibDKJrqDOKTZkDWSeRHGniDkY/MIlGymKtlvc+DB5hbyiZyO/5GGDcs9lE2OU+VvNf3DzXrf2Yy1U0pD0HAPH2Hu4s+ao7Qa8YZoLelBtBf+KJJ7juuuv40pe+xEc+8hHGjzecsuLxON/+9rf53ve+B8Cjjz7K+eefP+AmtrW1cd9993HXXXfxwgsvWJ8XFBRYA4L+wCfo5mdHqib4SG1bNr7mFRhRarfgkNtxZeIfPcAtyd9wCX8CYJdLpr6QPydBFd202/qANa3vJC3S6Z7BM1ZCm7zgqqlnlb6acS85hgyqdtktvD8V/jLvTB7jPM9jjRO0ouaqy4Ls32vZ6WjQSKVVZvtiHqQsQ2lXIcWNVFrEWF5GzZSzh2qms4v3s5qp1Nt+a7TVO6Qr57mJcva5XAfntlootc5zkDizqaWQboLEqGQf57b93ZWsCikP6JC3hVRU3DjAFNyIeRHG9ZkD31j4/zK20e3YvKLlcl0k6ROMazaJRsJ0uEbeZIr8Y/w+o2QnY7tMQq4HNJo0b12/5++VAaOOxnf5pmuk3TlQySVZMl0mNDLzdn1FTNWKs17fu8lQRuNgYQVPspynKabDJusYLVH3auotxyEYHMLeUVTM77maVjOBWAq3ZVPISMh6NtdiPFGKzcTRAHpmgj5hmAn6gdwIent7O4WFhQQC7s/Gueeey+OPP86qVat45JFHBq2piUSCX//613zlK1+ht7eXvLw8dL3/96Q/gWfCSbb6Wh7KbQ90ORe8k9vmBm+DKjsklpxJRlLTO4b3hv7GQjZkLBjRZE5JbmGujSjL/0FifIGfcwl/ooEqW9Ka+uI8qJAQQ2ZRTD1TXdcVuYYQS1UvLOXRT2ALBfSgZvovZh1ntD3P2J2Q1r+rhDDg+L8IOAZuOPa/LB03pEfMuymkhwLrheB8MWRalmQoI/kzgUaCK7jTNbqj/iZOyLIzlHMn56eeamaynW/yX5TSYiMOPRRmRczrqLGiWG77B4gy3jpuIakL2WCRuAhRVumrCfYeSiPnVrR8D4aMxdiwHe0un0lCbQx+es2naDK1+er9Z+3DJWIu58jteMA4Py1KFdAKmil1DJJkfZlJKaCba7idslhrzuREJeV7tGrrOmb1W+V+bKKcDsK2fIcLeci6Vxex3nKwUI83Toi1LPU8bzLg0tEopJszeIaj9pjRsS4Mq0vI3Kmo136wlkPAMR4nJgD7q0p4jHNdyWs3BaxnETuYBdjPo3N9t2X1XDkr5A5M1OaOdSxmHYuVfRiBhwt5mAhRKmhy9dZX2zyUqKca6VI0dKYH6myVSvtD2MNdnXw2cCtgzCBtYCFrWWqdfy/5YABDVlZOk/FbxtNMeVoASHCQCAeJWFK8jKT+MDBcod1+7KcvIn/22Wfz+OOPs2PHjn42yo6XXnqJu+66iz//+c+0trYice+5c7NPBnaDT9B9jBjCGDkAXrIPt/dRpqI1AeCh5HWWVZlX0YdOwjzHUuKEaKHUNQIVImaVrgesCLaTmIrl3i5qbPZt8jKPcJALeRiNBLvMaowqqZUEQmPZaEcPBZZOOtV2pRy1mQznVehjEespNXURQm5DxLmYBzh2296UrlwIRCt2sh6wNgjFwAT44bzPUc/UtCi96tnd6Yj+54J9VNJNoWmPFuMCHibCwbQIu/ytEyBOkO3MstkexgnSglHZsYY6vsF/EeGgeVgGOc9EzNVzWkcNnX0kiYqPuUTMNYyCOmJ3dgZPU0gP4VhH2stZS8DYAxjEro30xM8uUt7m6sNgasv/dvUyNrDQuk/6ipLK/142g3Ju1OnxQnqooMk1gVe1sbuYB5ilb8/JGlEt/NIRCmftva4eDxgzSG6zIKoN4kI2mmmu3ebvjejrOhbbpE1CMI2kQXsyXZgO3tvwbEpyFMO4dgnSB7tuyDa5JFtCr0KNH6inoRQmtrbxce5NfSYyKHO9T+f/gfUTTrRV6/VKTnRCqlYKFrPOkwQP1gyDPPsJNDay0EZQWyi1BpXSJ6gOJpkK/Qw2edfR2K7NAi0laysLtRKJRVP7zPJZkfVKEwdYEXiCpaHniBJhF9N5ghXW/tRz4eyLIyYFl4Gr4WZlJ+lG4qlYO3oPdOgF8rJq+sAxBAMBqf45kKJCO3fu5K677uKee+5h9+7dgJGcOnHiRC699FKuuOKKAVcT9Qm6j35BItVeMpKKPt6zPTGouAa4BmgilcAoEP9mMCKFi6DrmDHcHrqGNaxMIxhCLtTkPq8oopCUbr0QPaF8H9DRNJ0KmpjLFpvLhroNSJHreqZaU+eyryBx5rKFk9hEKa20UmpJWtQ2pctZjE7Tray7OGnId87j0kgwnV1U0WCzEAvTwSms57TGl42XuPqOFFLofPFr5jk/Dm4rv5xNpkWLm+43RtAkvLnHy0S+000hhibeiEpWsyctYq76A3cQNgcwRucaN9XOTVTQQZhKGvkCP7NmPeR32RDzbgpopcx1ACSQayZyl5Dp/hAhaiVCLuU5Krv2u/7eIuY7sd/nkHJikc9FZlSEkcBYBc8vm8+TrHCdyfCClz2iKikyZmSMwUYB3Z7e5aItP4lNLGADFbHmnEm5SFfkWezzd0q71QGqXE+ZcZH7ppp6IkSJECWkx0hoMkAJsIW5luuME2qp83lsoqptP2MlSVc3/4eUDMxZ8MmJGAaZccv+diZQ6mC7POosltoXOuGVFS/3krRZw+5EowGlkBeCU3e/wqkoicrHQK85ENQDY9ASh3mmaJmNpKuDPuNQQxZZ1EhY9qFg9IlSpCqVqGxvdCBLKYARcDCu0wqesD4Xn3vAmj0zTkPqpDqlgoV0W+2JEE2zIxws0i7vnUYqaQxVWgObKhpy1rBricMUJnopZD+V7Gde0WaaKaeW2bzKXKs/BPuxyzMsA9ca6ugxHa7UQmPG+yVAMlOw5RDvWIKeTCa5//77AViyJL2AXCa8/fbb3Hvvvdx9991s2LDB2l5hYSEXXHABV155JStWrBg0b/R3hAb94Ycf5vHHH2fDhg00NjbS2tpKYWEhs2fP5pJLLuG6664jGMyeIPRHgz6YGGkfaqf7hxMnlMDYIowO3PnSEGzw/v3b5cX8J//PptdVO7pymjiJzcxlC1U0UKhLlUCdYO9hxgppNPfdWwJNRUfxb/zYJgMBu5zBzbtXlgUxgrTqZegJDS2gWwQ9GDJI1iy2U06TZ5VIIebNVNBIJXGCygvHIMTz2Mwi1pv0wNneVLEb9RiEYEZtMhd7dFoImfqCU51BVDJVSSPHUcuSAy+Tp3pmS9EaZ+EamSovh/0LjSnxDSz0PAeqO4tbopLXMhhk0JAgBCmgBx3Nmq3wSk4UfXk3BVYBHB3Dl9sY1IQpp4kVPMlJ5qyHce5CVrVLL4hmXiKxmYi5RFvjBAkSp4Imoww5HVTSSDnNrn7eWgLjvj6AQZhabRs2iJQaLRcUAaWw/8IStjCX9SzKmMjqbHtfTiwdFFvfGzM+BklxK2Ii9/cstnMK66noetuzHWntMp1XWjRjMNuaoSCPeiypQVmxaxJviBjiEBOmgwqarf4koWnWfSIzUuLYYhxTwpr5EKI2j83oaExcb04zNWH0Q86BlEAdRKnXLxdeJ/1sf5adpBuMe8Y5GMCx7BW9L8HoB+S4JNqurqsBlfB2ZbHtftvMPNuunAMv9RkspNuSXoAxOyGE3pYUmgVp1xI6ekDzXN6jVVt/N1Nh3UNq8rpzpjXVa8Rt/epQSWREOlamt1rH0B85THdRPvVMZSMLaDKPNU7Qdp3cHK+MPJMyW/4Q7R08VXKpuwadNsgbJg16sh0ooaGhwSZdCYVChEK520H95je/4dprryUYDFJbW0tNTU3G9bu7u3nooYe4++67eeKJJ9B1nWQyyZgxY6zqohdddBFFRUUZt9MfvCMI+mmnncYLL7xAKBSisrKS0tJS9u3bx1tvvQXAggULeOKJJ4hEIlltbzS7uHjZ7Kn97DjHsvP744qgcJFjYwdISRuWANMwOmJnBx6Cu754ERtZYOtQhZRJsZcgzvl4t2Oxd2YF9FBGC7Op5RTWG37JukQOdIraDqclJXaVjOGB0MXcxyWuxERe3JDZyzlmurxGY5HU9wFj34VaNzXsYqE56nDKUATii91Alc3zOkicUlqoZB8reIIYQcurW92G/F71q+2hgINEbOun9mcQc6fURdxMIhxkKvVWYg8YiT5VNLBSX8O4DYfsxFwHOkknDyFgBuydcRT3cYktgdV5HmSAkYszixyr2vmH6aSKBk8Pc1Un3kHYKn8tsqUOimmljCbKqWQfJ7GJlayxfiv7yxQxl0FGExWeHuaQIvnyspP7uIZdlu51NrWuBU+0BEYEVoi5Ki8Sy0sZNEGKFFUBRZCcC7+Y8AlbNUHjPLi7sMg0txcpl0GGuLWITCVClDJabAMreXEX08FU6ik3Z5ayIeZ6YAyxUMo5RbzSMxEc9TkRPX+U8WnriVezkDyVlAN0a4XWs9NEhSWdkWcHjOeknGaD1OtNjNt0KDVzAal8DGeEXJ4nOYxe7H2WV0DDmdPh3La67Iyse8G5L7d9B7ATeOfjkKs+PgG2ILQM7FWYyzsXTlaaptnuYWcfos4KGlfMuABhOqx3jZBma9f9TL4TAv+qNtfqe1RZjFtRMsk7CNNhDValSBoMrjwmSMw2exWKxftF1rUEbCw5kS3MNZPXyyyy3pcjTDMVHGrv4aGS67wJOsNVNMgg6E5861vf4tvf/nZOW3r55ZdZsmQJvb29/PCHP+QrX/lKxvWvuOIKHn74Ybq7uy1d+Zw5c7jiiiu47LLLqKzMbBowULwjCPodd9xBdXU1S5YsYezYVOz4pZde4kMf+hBvvvkmn/nMZ/jFL36R1fZyIegD9a0e67Gu2/LRwIxzMF7m8tyIO4MgBGmBzXwMcba53stXH8eZsacAKAh1U0Ez72c1J5nRIQ09bbpbyEq9okMUiHxETRjrC86sekP28SqL+CeVNFKhp6Inwd5DhtezI0K1rXIKa1nKalZZxFbVGgvpFnglwsUI0Rqzt10L6IS1DkppoYoGy9LLLflRIt4NVFmaZPleCIJMtUrCqPzWWbZZbZdMw0pnnzaYUKLpKjGXqK2qCxbCsZynObrhQGpaWyJ7bn7mGnBqasbDa6CjnscOcvN0FaIsCa2ltDCeKGfwjG06WY3qSOXOHgotYi6QiO8eqplKPVU0cAn32c61kGmvl6aUqc+GmOtotFJKAo0IUQrpYTa1VjLa0tha15enloCx7RjnXQ2oyz3unMUQTAXmwl1VxiBZJQNeg0/1fzeLRFXGIjMQUmWwnGbrOqjkXAYhQeIsYj3z2rb2aZMo8pVYKGjZTPZkuA4CySEQ8tCiuFXIbyWqL9HyqXq9bRsdWth6buqosSL06myT4ZhuRCjnb309FRWXyHcz3oTcaJBxPTOlWchvS0kRWZGMZVvoSKL2XiR5J6mBQSZ5jRNOAp+PO2FXo+deyETg1YRVzdFGU6p1YE6+lQAvA2mZEVPzCdR7vooGK9Fbku8F4qEO/SPuIjHpDhVahYPE49+tYJm0y+gTupXnNJH27usvjDwIY2ZXtl3Yle3ozQ4tAU+WLLNmG43aEHb3njSL2/Yuflnyn6OGoA80gr5nzx6WLFnCvn37uPTSS7nrrrusIkNeEKnKxIkT+ehHP8oVV1zBvHnz+nMQ/cI7gqBnwv3338+HP/xhKisrrYh6X+iLoBcAZ8zAIjVJpfNLOJ65sRMwOiS32Q3pmJ0k26tzOw6u/uytnMRmK9K4z3ygnMmHkCLVHYTZRfo0TSmtLGQDS1lLKS2uRFGIbg+Flr+wQDrJbgosspiNvVbq8I2/w3Qwly0sZp0hBdDNam1OSYuJ/ZUlNFHOT7jB5mKikbBIZCqx0p20GO03jqsjZpJqU9ISDMWp4g1mscNVZy7b7TYjf41MSksWFH3rJdwHkHbupPOLMh5VaymJlFHG22zfJPIpumz1WArppticvq+iwfZiGk/UIIqs5dide+0WfBKldZLzBLDMmJ34bOh/KTQ9bdykQanjiFifZ+tpLMS8m0JKaTXb+RzjlZepioNEUDXm6nlrpQwdjSbKqaCZauq5kIdsUVe5Zl4Q4t5EecbkTzdiHkC38hKCxD2tEvMliN4FbCL1nMsl6yUVpRWUYpRmnQCPzDiHtSy1PeOQPpOhoVuE1k1bLpDzIZIiqRZYRYPrcxym05J6Le16Hi1BVsQ8FgpaUVDns5CpXdKHqRI1gUaC8USRCP/sWK25P/Oaa6nqtLuooYmKtG3IQCpMB8dv221Ii5yziurxqfxHknQzRal1jODIDHPZJOH7F5XYcmXcXFG8IHpgr0HZxxvvJc1UStXEC4FX26pKYvpa1jGIez7egxEngc8UgVcjVvaJIPuAIARUGoEZsQZUNeVeJBlgIRtsJNk4FJ3xetTjAPqGkPaWUCk7mGVF/b1sLXU0615Tr7fIsAYCIeuSVzMQsg7wQNFF9FBAzCwA56ZZH20EPRebRSf279/Paaedxq5duzjvvPN46KGHbMFeL1x22WVceeWVnH322YOmK88F73iCvmXLFk444QQikQgHDx7M6jdyk7WdD+PkGkknYSb1HPo/GLuNVOciyT4qmSyHbcumcB+XWBZnAnnxZErWEBTSQ5gOS2JxkAg7mOVJgmSKv4dCtpv2WCpED7uAjSzmBVdiDkYkscWMKzlfqFIpULLlvdquToWDnUhIhzKL7SxmHVWxVEKMljhslC5X+xjdsAT7NdeynkVpiYeiXXYjknaXEyMqKlpzgRbQqdCaLELrhRhBSz7RSdh2TKW0EiFKDXXMYgcaCYs8yjoiI3C2v9Mknk7pkFrV0HksIWJUU89MM8FKPe8RopzB00yP7aJoz+GUrllNNJRlwXGQrITPTvgfz+MHrOseNSOyfRXHUKO0cu93U2hFmBax3nMwJMmyzqqcqk7ZiPp2s5h11nMi++2r8qcMQtWqk25QiTlgSYdmU8tU6tHQObfrcdff5h/A6B82Kx+qMha3GYxyYC68NWcCD3Ghp9e9ej+oyVyZvMGFADdSaRIGozCVRCBTTTSeXZF7VLOHlW1PZVVUqLso3+qLoozPmpQb7UppwZ2ooAkdjQJ6OEnfZPsupqVmcVopS3M7AqOkuVy70/a8bMwmyTPQgJ08Ovof6zo5dd8on5+ELTKcPA7+OOHDAyZhg4EwHXxg59/tlqlg7wOaSdl59gUv/XsI96CUCnXGwIuwy3IRmOULUhDSHoD980qop9rWD4llrdd5L6SbuWxBZl6FuIfpJKSnghxOzboXDmoRU95YaPVxmXJbBBU02Qi7aNwHAkPe1WxtbyBk/bGi99FEudWPNjIJ6IugtzC8BL2s3wT9wIEDLFu2jK1bt7Js2TIef/zxAbm3DCfe8S4uL75oVOKbP39+zr/9zt1fIjTOeMDEw3U2taw68HfGbsUe/XJqdyvhX0vmsJr32woIyEsqU3lztZMpo5VJNHIMDRwkQpwQ9VTbHnxV2iGkuY7ptgRFGb1XU29Ev1iLhu7qXCEj50Yq06b4ndHDTG0XuGmIy2mmgiZWsoZSWqnQmyxy7hY1B9hdNZHb+aSlf5fjlvOqRgqFuDiXjWj/eOKx1LlXifkprLe1V41wScRdbPqcEoJJNHI6a5lEoyVBcYvYO31mRU8rNoWyPzkmIVrqtkTvWEor1WZhHZ0AhWZJbGMAtoEpO982IoEo57ONdHJxKhwaB/eVXMR6Tkk7doFKzAV9eZerem8hT2E6Lc1yJY2usgsh1buYbs0eqAOeWmYzi+1o6FzG3UwytyP7zBQxl2g5GM9ic9rb34DqhCLHXEwHIeJUU285ypzFE7aXoDhbWBHzDaTPXKjackEAQ/pwHOw8djL3cKnrdL7z3nZ7BpxQv5PzKaRbhTq4mmq6ncxjM7Ni29EShzOS83j+WGKa0d5myvusvCrtkMi6F0TCEiRuWZuKVCGhaVYfGyVCHTWu5F6I+aK2l1PBlTbSnwdVuuIl/VKxyPw/HyiCv8w503rOUwmnI0/OwbjX75pxUSqij50Q6mjMYzMz1r+ZWsEp5dlG6rxIFF6NxmvYA1VucJPzJDy+l8CYc1ZAw5hdCsHEZ9uYGDBdZkJAMbxybAcdhC0ZCmC5Qsmzst66eCnXmEr2UamlggWaWYggQjSjPGa8blRpkOTjBqrSHLxiLkEkNXgn10IkOZKgnCu6KbTkqIV0U1rUiswe5KpZXxlbg5Y4TDx/LHu0ast6NK5Unk6H86YZSvR/P52dnZx77rls3bqVk08+mUcfffQdQ87hHRpB13Wdffv2sXr1ar72ta9x+PBhnnrqKU455ZSsfi+jwK+0fYnAOCMMUMUbTGcXKw48b3e9cOp3JxiJW09PeA8PcLHtQVQTyfqSABhuCXGr/LfokRPWS9meVS6aTiF56ku6gG6mmlHW01lLkLhrgpwQ81azKqC6DXnZqGW8+4IbMdfQzeS/dVTRQDX1VrQi2Hso5WbhkLTUUcN9XGLq/+xabS9nDaduWyeQpjUvCHVzDA0sYKNN86wObFT/Z6fllIZuRc0XsZ4Kmmih1JLaqDo+cReRF0HUHHBJdMIZZXezhZQp0koaKSXV6Qo5n02tQcwb3k7pzIU3ypS8/STRexbcXvQJdlHjSQblns3Fy1wl5lEihIgRIUoprdRQR4Wibxao+nLDZaDAOmdyvuqooYoGxhNN80Pvy5UlFb0vsA2ynBBirko/giZJrGSf5cyykA1EYlHbCy9ftafcqfwth6omgsqtLLkjJfDK1Bk8xnkZHWNUCYt63G4QQhIlYjlgVLLP3I7phoHdJtHQ87Ya97TeRLDXqxpBSsIig9JMgwRnm+RauCXdgeFeUUgPETO5WfqKhKZZ90M3heyixkaIVQ1wqTkPOOvAXqPvbiLliiNQ+YSa7+ImWQHjWhUZ//42ZxmApY1/t0E8+6VfWtn2lFE0SyCyObmEu0kFBVRkkgKBPRzoFX3PpH2X7RVh1GeQ5QCWlHTv1KOshHvpWzV0i8y6DaREQ17NHmsgo0plQsQJ6x0ejTIQ00LWMyjvELlHW1xmRlOHZORGDEaEXZJWi+mgkB4KY939Si7VA2OIhiJ0tyeYWdLuEUFvYHgj6FU5R9BjsRjnnnsuTz31FMcffzzPPfccEyZkqqQy+vCOIui33HILN9xwg+2zCy64gJtvvpk5c+Z4/i4WixGLpXrr9vZ2qqqq+EqbEUGfSj2LWcexjXvtU3+SyAVGB1UKu8+cyJ1caRsVq9GtviQt4r5RyT5CxCxyIyRO1d2qCW+tlJq6XLvGu5o9zGIHi1hPhCiqllltn2rj5yZn8RpcZNKYSxsEkjA5j03MZYtRClzXU1FzRzTxUBE0lhzFo6ziCc5KK9jjTAR102SmIrdhdF2zJC2RUNRy2JBBkBM6RlKdseZ4W6cquleJolbQbBEO9fdy7pwVGLsppJnyNCIpumyRwaj7kvtCdS6AlM/2TLazsOtl8l8nRT4kSuskIyXADHhr6gR+xhdcJSCqxlz1Ms+mbLccoyRSldJKJY2W/7QXMZdKoaqDQ6c5LGmk0jrnp/OcrXqrV7KteiySANlquhW4QbVK7KHAcgMppZUKmphEIxU0U0NdWjXM/DaMd4UUFpJzDe7e5WBECufB24uKeYxzaTXppNpuSNeYp0ze3I9D/U69bqW0IgV2nNdwEo0WOV/Ahj7dWPTAGLpDhdaAqi9irrrHiMTJDREOEqYTgGr22HTCB7WIZSkqXvfO6y3XK8JBpur1hgNLI96kXCc1iPXSlOdjJOiakeeXZpxo+ernCuc58lp29uWZtpftukOBKhpsicQn6FsYt1sZ0OnADuzEuhm7lWgmPTzKb1WCrrl8ZjTCvixyoxLl8yJSSboheKV8htks473d7QiOqJBET0nCF2mY03IxSNwmlVGR0DTrWWigyjYr6eZMJPsVVyUZNEgvkCsk2CA1C0J6LOMg3A3t7VBRiQdB38PwEvSpORF0Xde5+OKLefjhh6mpqWHt2rVMmjRpaJs5BHhHSVyOPvpolixZwqFDh9i7dy9NTU08/fTT3Hvvvfznf/4nmub+8vje977HTTfd5PrdLHawmBeY1rA/VaoZ7ORcA2bA83Pms5bT08i5s1iLW2TZaVemE6CeapsUxlm4oZlyk7ZFbFo7Dd2ydpvHZqrZYzk0OF9mQgglmdQZNVc9qZ3+qG7HIFBfEkHilNHCYtYxm1oiRK2IQ7D3kKE1d8xS9ZbAuqL38AQrqOU4K5lS9bfuS98nhKwnZnSEYpsYCUWZxyYqTF2tEzKYaqWUg0RsOnMw7CCraGA2tVTSmBbF99KZS4RRzrWsqw4kZBZDzqHh3WzYikWI2u4BIeazqWVubAtFOw/bZ3OceRFy6Y+B1xZNYz2L2MS8DIQ25ZGbbdRcJbcJNCth04j4t6TdPzJ4Ek94OV8y+Gyh1HpxLWADJ7CF2dRav5fzLIMhN4hVZQdhz+RPp4c5GEnUQsyraKCSRibRaCPm+artnko6JGKuJn8KAsAcOLAsHykfL8WejGNPj6Y5iblzlkyOQSRTso4hheq0dOZuqKCZuWxhOnVGXkjXm67rQSpaLv2Z0Td4P4fqILUv0iNe1+U0WX7PYNgiSoEo5wBGIBKYYjqYxQ6O2tlpcAS1nzZOUup/eT7SG22TT7DMCBbsKJlmu06ZoF4b5yBKLZ5krBtIu5Yq1MiprC/LzplUnUDa4FcQ9CByAyX0TovPem1qmoTmhGPtQZBJNDKhUTn5MYz8DHVA24T9e43UgErR+FsEXT5zathj5m9Ua8wSUjOMRXAiOw3b0uN2AnBwQr41wyYEOlVfwfgn1zHKeBqptDkJgWkBqRnVolUiDIY8S9490p9JDQAZJDRiFCxSA1Pd5kHJZwbJjiHmENkmnMYJ0Wq2v5BuCrRuQkXGACOg6zmT9XT0MHz0MZPUxh1//vOfefjhhwHDieVDH/qQ63qTJk2yihaNRryjIuhOrF+/nmuvvZZXXnmFT3/60/zyl790Xc8rgn5n2wqWjnvFkAsIOVdt6aRTOA7unfEBnmE5kOrw1ChXJllIAN2KLIbpoIVSS+ssUXNnxLuBKssKSSLHhtyihdNZSznNVmU2N/IipNJLzuIkWtlA1OBqBKiAbk5iM5U0cgrrrWiYl9Y8mQ/bJ0xhHYtZx+I0Gz2vioeyP1UvHCNk05oXhLqZxQ4iHLRsE+VcpJxSDImPWxEhsbSayXYqaaSQHmvwIr93EnO1UJJa4VBtq5x/lbwU0k019YTpYJKSPCn3QxmtBmHVtzDu9UOp+1ElHvIyExTBW+dMYAtzeYIVtileOQ+Qkh9k62UuyUPqwKmUFssFp8L2pjUQUwYrcm4EkpwsdoeLWM8kGlmk5Af0RcylLQeJ2MrTu0HceGQwIpKlShotKU4ljTYpi5aAsQ2kBkRqfqtEyp02iUXABNi5ajK7qOFps78QOGeA1GNRrQadUL3Lpb+JECVI3CLmzsTdYjrQCViyrAVtr2TUluuBMXSEwrZoeSbI/SwzXF7rS5KzNRg17VVFxy5BCiHoTvIhsqm5bKG0rc2QXuzBLimCVLTcOWBySi1MO+XkB6FpQgkxgmn9utuxCpyzZeo1G6zItnMAl+2yV20Kt6CLG5kfjParbVPPW5AYC9mIKhspbzN0MmMbMHI41H7NvtEUOVfvYacHu5p06hZxl+J7kNLAB6BriVFE66Bm9N1ivpApKKAea4SDFNJjzVxJFd5MEXaABq3KRtBF4uqVPC1RdSHpMgDI5bqlHGYSlOmtGQsiZY6gvwr9mF3qHzqAE3KKoN9xxx187GMf63O9KVOmUF9fP7DmDSHe0QQdoLGxkWnTpnHo0CF2797NlClT+vyN3GRb2kqZ09makrU45QIl8MqZM6hlttWJC9QXVCZU0GxN/0uilMhZBGrkuJ5qa73U90bneyEPW7pYIVluHYi4KnQQTksCVclKNlrzTJKWBWwgTAcreJIgMRs5L+w6bHdoMTbGa+XTuJ1rqGW2re1CntSkPTdYZDeW6hyCIaPsuJSTdnuBJdDYR6UridYwKm/OZYuloVYLIEHKm9xZAVRkLE7pkCSsis5c3Zf4+VbRYBFyQSE9LGQDNdQxbdt+94qTYqGW2hlvryqmltmsYWWaTaOakJorMZfjkpeIRZZo4Zi0rC4QC0kZAKnELfWZMdOzmHWU0mIj5qpkKJOURSRJmYi5qnePEbR8sEvNYlmW1ryrM3UqhZh3YZ9RU6OxqrzIJAmHPgS1JTPoIMyDXGxqwb29y1PHUohbtFzOpbQ9Tshm3xbB7liluiitZA0FdBsEveufnucHjKRPKZEuloVecPZ5EnF0QiPBVOotPbzqWZ7QNHYwy3r2pQ6AE+L8U0C3EYndQMplxWmLqF4Pp4QFrDoRh86F1hKDoT/BirR+Qj1OSEXGnVVw3SQqzkH5YMD5DDv31Z/lvsi8QHXnct7LAyHybgRe+l4N3SK04146lIq4exF2SE82FUeYbC0gIaXUkM/K4e2FRrK73ANNVLCdmebuvW0WISXBEjKdQLMcv7ySULWETn0oRdC7KTADdO59YJAYhfQgshg1sp8t1BnbilhzGlHPTNBfhhxrYvQfncD8AdksvlPxjpK4uKGyspJ58+axfv16XnnllawIuuCYN1ux3nNOp5YSeOrM9/AY56YVPbGVwyXdak46tyozDh5At8rCS7Ef53T0LmosYq4mjADMZQvz2MTprLWmnb1G9h0U00hl2lS/mpSoksy+LPTcHvoFbCCAzhk8Q4SDtvLEhV3GQ66S82Q+1E6YxtMsp55qXmWuRUzVyKATzo68gzAdetjSmWsBnYgWZTa1zKbW8wUielbVyUPWKaeZRawnTAcRosQJ2qz4MunMJSFIXjoqCRe3HZWgzqYWKQ8vWkY1orSI9QYx37PfICLOqXsZPKpTvBq8tWoCf+RKaypalUKp8hwh5tlozMVJRQYXhXSzgI2E6WA6dWnXCgx70FbKLImPMSxK0GzmPkSJMIlGS340ly226XopCOX1AhSHhm4KMvqYyyBUjll07eLHL3KW0rY2W1Q5XyQTqi2fs5iNA7s/O5Eo41nHYuv8C6EBbPcEpKLlxt/uEXMnCTa87lttybIC9bq9n0fR0Fnc9s8+o+VNoXKrDZkGOdJmaZObK5RAouWFdBuOOwoZ6dDC7KEacb8QqM9qiJhlf1qodzNuzSH7fa9aI2Yi5bLJJdA7DzqKiumgmI0stLXdrW9TZxS9pCn2a5meJ+A1I5lNDYm+7EzdoEZT3Y7LTb+eaSBmfJ/638u5y9nWgiykCG5tMaq9GrIP3ZSpzlqynZoluyxSm9A0JqzuNZKyIUXS1WCFZv7tJOCQTtpVHHB81wVHNXbaVjn6mANUzWuw7oduCtjFdIdDSyrIoAbYdJN0ayQIaLql41ehBzSq9AbL8jGmhaxrGidks1M2+pSUtaxGwuQoCWv2LBvduuoepocCaCHT5aZrf5+/fae4uLzT8Y4n6ACJRML2f9Z4E+PBdZLzCfCPZaexmvfbyIIqv3BKRlRMohEp+GHE60o9tZlCXqS4h9r5r2QN5TQzlT1MotF6oNxekD0U0EQFUuJahXOKvy+4VUKTthkkchez2E4prVbEI9xmaNqcUfO3K4u5h0upo8byubbrzO1JoE7YCKZeaJHzmpAhTRCpgttxRYlYjivOqHIB3ZzOWmt2o1XRQgvcouYi21CT5tR2y3lWZTrzTHPsKhrSBmYBdBazjplsZ8qet42IuXPqXkiienrK4a1lE6hlNutZlGZhp0Zns3EVkrbIC0cKx5zB04iDzCyHF7scr+xbcgIAGzFvoZTZ1NqdfRzEPNN0ciOTbLkSXpCBq9xXYTqZxQ4K6aaKBmrYxXTqKO0yptb1AOQ3krLhE/cPsBNzsL8jyuG1j04jRoiHuMAziRlSg0sZLGSSsUi0vIdCU/zTYzmcuFX7TKCxmHVU0Gw8m2a0PBM5byyamBUpB+P+j5rFozIl59ZQZyWkldNkJYYDbAnNRdyB3LTl8vup1BvR8vW9qWJC7dbJMaAm5qouLOr/50D7XMMKchc1aXUHnHBK/LyIq1Oi5vT9H2nECLqSZjdIYnS2cDsnTvrnReTVtuRC4OuYnpI/asb5n7fKGNgX6kbbx7Uegvuxz6popA+mvcY2Intxwi3pvguOeqNTibK3UXncfjqKii0+sIdqV292DT1Nxy+nSq6ZEHbxYw/pMaaa9roJTbNmPGTWVi3K5UbWZX1xi8sECShZMM9Jh36YdEN9wSHz33BguPYz+vCOl7jU19czY8YMEokEdXV11NTU9Pkbq1DRk+bslkrOq+DehR+wvEAh9eJVk9y8UMk+plNnJUzJb5ySFoAdzPK0LbuCO5nLq4SIIxINtxekuLO4RRVjCqnpj5xFPfZTWE8hPSznaSMKbGpJLetEh0NLbwmsLTqNdSzmOZZabZeoubzwM73chGSqUXM9obG4aJ1lg+dsKxjJN1YCqePcBomzkA1MopEqGmwSgtR5C1ovXvWl00qZzZnFKV9QPXjB0PsZevZ91jVXz8NCNlJBE6c2vpLuAawSc+fLYgk8UnkOm5mXViBL1Sk72++FADotpvOJdPRS9bXGjJY77w0h5nKe1eOS83SQCLOpZRY7mE5dWln5vpI/JQfDzXlIhVQgFTlXsZmMqNYFEGlLYVcvemAMRY2HU0mf6gvdGTFXo7bLYNvCKTRQZd3TmSQsxnky2uRFzMU7Xkhw2Ex1LaTbU4agE2AFT1BKK7PYTjjWkdFOLVpUYj1vuRBzL225HKNItSpoNvS3ZsS8Tptu3UdeBYniBDmDpymkh4nNbXY5Q7uyopoE7SZ1MJ+HrlMNx5ktzE2TEDqhknLVLtUZIJBzJev2KOfCTaqRzfJAyHxfkimnjCXTdtzuLbf+P1fpRKZ9Z9LIG23Kzq1E+tJCeqx3ZCQWBaBozWHDxz1BSp/uzENQ4ZTIQMrVJxOKlO3L746DA1X5VlBHR2M9i2zvlvTZDUPealQojllyFam2rSKhpWaS5fmUqstu2wasfkT6lFzQ2a5zZsnrHhKXJ+m7UtVgoQs4y5e4jEZs3LiR1atXc9VVVzFt2jTbd3/729+44YYbSCQSnHvuuVmRcxu6gCSpjn4u3Hbs5WmZ/KLNzERyxXGjigZiGN7Xdo/rVCLoPirT5BFgdIZLWUsVDcxjk/Kgu0euxIXESUIlI10+z5akGe20d/qltDKXV1nEP00/mVQxh4LOQ+kFh3RIFsF9RR+29NBq+8Vnu68pVpEyxPUQekJDC+jM0rZTHmqyZENuL6QGqmylxuX/oCkhqaTRIvbSyanntNvlnEnUXOzf+oqai92kGDg6yflU9nAK6znhwE7yWrH7DAs5dBbGSgDHwUtzTmQDC9nOTNsA0jm7k801l8iLarG5gI3WfSxTpirk3naW3tZI0GlaJUaJUEUDZ/GkSY5T7i5qkq0XiWo2n51MPuGA5W6kurJIIrbYa4pjiCRD5R8Amkxyrg4qVUccFb3Q9bkxbAgtpIEqdlFjkdZMxCVTtFzOo+Q5xAgSIm65DnkRmQhRa7BTw64+fY5biyZY0pRsBsOqv78XMRcrSiES4grRrRVSrxnX3qil4J7Yu5h11jMyYX2vcQ3c5FzSrzjzWJRACmfBW+UT2EM1+6jMGMRQnwm3vkeiiBq61c/3Rcid51Nm87KBkeSbWQeuQs0HUdusLutoyiyluzRH+gf1GDLdx1IwTm2H6iTifH9l2pZXnx832+aUXgpUyZi0AQyiuo4lAIRCRpuqVjVQuqoFgGmNilTjLusk2Al7L+kEXgonyd/yO5W0O92DNGADTNjUC8W9BnkvhYqpj6IHNFq01LMlxZNEqgLi6JIaeDRqhtRVrEQhVbhrPFHCmvEO66GQUlosyaXTc11mz2VWTipQDySPwIAvcRkOjPoI+jPPPMPy5UaC5sSJE5k8eTLxeJw33niDaDQKwMknn8xjjz1GWVl2hSSsCPpdMM7sg1+60CA+arlx0YtKZNqrvHkFzVZEt4VSWilzTcRrNg313KzLVrLGsvXzKjQkbVIT8NwsvkT/rNomerXdyzpRXqYiCxBNqRCdUMyUsyidWzIf1kxYxhOsoI4am32UOsUv23eLMKX0/SF0XSOoxTjG1PJLBNatcxFiqLquyDbnsYnZ1FJGKwk0S1+tHquXzryFUouYOyGzFmpEfR6bKaOFAjOBR8VU6qmmnsVdL6b0zuoqXraJlYZt4nMsZRfTbeTJLWLel7ZViLlq+TidOmaygwqaXCMtCTSaqbAciJznqYkKWim1CjrNptaQQLlEzL2IlJA7t/tahXhsyzrlNCsFbw4ym9ctf22xE8uXpM9m5fyqkVnnQDMfOAeemvoeMyprt1b1ShDM5EIEdmIOWCRXhDlgfyYTaFSyj9nUGvIcWjNGzKNFJda5zKagkDioZBo0iZNKOU3GzIRStKVFK6WBY+gxZ1K8ZkNmU8vsrtfJb8Ag5I2kJ92qDixOCYsGVAALIVkOGybMsfrSvki51+BEjle1RFX/dyJInCozcziATjnNtmclF+mIOH7kAmcCvVtEXk2AF0jgocmlmm5zP73e3Qi6XdaRsIIo6uf9qZopIQc1KJNNtF1NpBa5yPFbdxsfNIKpPFR3lJZ8b0NA+aeR7igDqX5bJfRmESWJuveaasTaouMA2M5Mz2CFVJsIErdqZagWpYBV2VTenSKZdQ6y1XwnySuSiqZuyBxB/wvDG0E//4iMoI96gn7w4EHuvPNOnnzySV577TWampqIx+OUlpYyb948PvzhD3P55ZcTCGQ/GeAk6P+48DTWsDJNUywEzI30AJbm0ijkEKeRSloptSUZiaRDCg11O6IyNeziYh6ggiaCxG1T4k7IAygJpyqcjhXZwCsKXUqr6SRiaM1l+jrYeyjlC+0Y1B6ozOfrfN+aGYDUrIHq26y+VNR9i8ZTiLme0CgPNXESm4kQtSymnIgSYQ/VFvlTt13DLpbztBU5EGtGJznvdpwz8TOXSKBzMJFqa9DSGxrRze1m9r795FTSyCL+SQVNHL3zQCpinrp46RFzgAmwe9lEHuZCWiizyROkHdkWl5JlKeIjkbFK9rGI9aaftl0yBClXFkNbGbTd2yKvaqbcmqGQglnqi7iv5E9JbFaj4W5QB59g3KdVNFiOBtXs4SQ2G/rtLoP9hWKQ14jxQpYBkVdxpwAwD5hqSIicszFeEgN15sWN3KVsTQusqGxqdiVFPmRdSBUdWsR6qqk3CqV4lPCO548loRkuRW7yKyekvdJXeV2XEDHKTQtKiewHdN1K+JQZKK9rK7MYFQfajJmiRowBkjOfohfv6p4BYKpRDXdD0XxrQOxVeMsZBHB+L/ez+r3buSqnCSnuVGHqcIXUSH/QH5I9UlAHyKAmNNrlfYJWSmmk0uoXnQmrzpwXL2RKWA2Zezc+z756pnOb0tc4BwNOyAyQrCdVm499aq9x7+3Ee8bG7XGSWz4fO2F3OsY4pTBmdF2Ie9K0/qydMM2yn/WqBSD3YDFGtWm3KqcxLRVs2kelZx6G9Dsy6+g8d5kJ+sMML0G/wCfoRwosgr4WVp92ERtZkEbcJBLhJRUQSUs19cQIso9KSwurShriBKmjhijjrRe4huFnfiEPWzpOr0gQpIoNCfF1khh52ULmRB2BM2ouxx0hylLWEqaDBWwgRNxKyNESOkVth9NnmwLwl/IzuY+PpCXCCJGVv70g7ixgaMwLQobFmuiI1bbKthIY07mq9li+jxDlEu6zIpKtZmfnfCE7iblMIxvE3P3F5cwpKKSbeWy2ohxGOxLWea6kkXNYw5TNZtVGZ9KhBEPUvjEEXWeN4WehL1he9up1krZlm/wpxyb6eXHbmMdmpPiG0aTUjIuQICmR7Yzay2DUmKHYzHKetl54si3A0/VDos1vmElVmYi5RO/l+AvosYp/hOmwagMEiVuWiVoCxu7DKEuu6vhVJxzVDaccnvrQe9jOTHPmpCztns0UsfSC+mwabe+2kjrdCgvJC/MMnmE6dUZ0PQMxb9RSJCob2Vgjkyyy5dXfyMBtOnUWEQXM+2Gq9Xx4/T7CQVZ0PWXIiVpJOW8IMXfq/V36FMqBCnj2zFOswIQ4CgnkvDvdktTvIHUvq8+/U5oBcBZPKE1IRWq9CgMNFpwF4gZ7ub9t6iFd5qR+D6kglOCfLEobPDmrL4PdaUqFah8I3kEkddkt6JONR7iOkXxZZnbCMgNy8p6thq1nF3ab20xwRtOLPL5TrFmtvytJVUINpb7vLYInis50rTyqDmiMQMUbhOlM810Xsi72zm48Qw0QiHwN+iLoD0CG+2Nw0Q1c7BP0IwVyk/1H23UcGFdtRUGl45ZS7G6Qqc1ZbEcSAyXS4KwAt4OZlk5W7UC+zH9btn6ZIubG50JE06NzUnQnW82xVxIopMj5cp42RukmMbd05pD2Ij1UBB8v+Y3luy7Hnm0SqFWp0NSZB0NGAqdE7Nw6Zh2N7cxKc6WRJKMr+aM5HXjQ8pFVJS/qfgVy7o2pQXtSm2xfpAByTBq6FXl2ylkC6Eb1T7Zw7M69dr2i6My7SPczBzgOvnfs9XRTYFWck3tTHD6kTdnqzJspt9ZdxD+pZo8x+PKQsjRSaRFiibTLQEgkYDPZzsU8iI6WFn1POZK4E3OZBRKS7gUh5pByqVjARgDr+VnJGmPZJOZWxPwN7MRcio85EYB/XTuHDSywoviCTBHzTANPIb9i6xkjhBSmMrbjTswn0chi1jGVesJ6h2u1Pz0wBsDyTO6LlOtoNlmS02FCRYgYk2hkOrvQMDypE5pGvSnOMo7FnZhrJBhPlJUHniWvDeNc7yR1DVQJQCv2ipASMTfJylMfeo91nlW3ChUqKXfOiEFKBuX83mircR3fz6M28u02g5QN7Pkq463k5oHC6/7zWu4LEaKuTlIqBkrsM8lluilkHYs9Z5tUwu1EmA5bpDwXyHkSOYfX72X/6r7AcOE66o7OVJ+dCeq9DKl7vFRZxy3Crj4PJRgD1EDqd8kieGHCfNssWer4UmRdEuNLabHZnMa01AzzBhZ6ujKpA6MJ7fWsKNnqQdDvZHgJ+hU+QT9SIDfZJ9q+S3BcKvPDS9KidlqTaGQWOwgRo4UydlGTRpR2Md3S0qoopYWPcQfTqaPD3E8mtwEh5m4+u07ikqvGXFBNvakXbuEkNtumy8a1HnJ3TtDg/1V+nXqm0sgkx9fuThFO6VCU8ei60cagFuMkNlNFg6eURbCFua4vgc/zM8BIoNljkgmvCLhTjx0lYpFY5/WQAZv6sq+hzsw56Ex72S3nGUpp4cRtO1NT9yraSC90kwAq4XtLrrdkIyokgigDsWzyCpwShvez2nzx9GSMCG5gYdqAL06IzcwjgcZ4onyGW10lMX0VGRJnl74i5lJMClKzJYswLATDdFBFA4tZh0aCcFsvesAk5q9jkD81SqsSc/VSFcFr1xi6/mYqcNY6cINUPpV2ebVdnc2SKsIauut5T6CxkI2s4AlrYOxVhru7KN+WDNkXOeurMqEgTAeLWA9gEfMmrcIWGMhkVTiL7Sw8sNUg5puxV/GUc54gdR1U2YAOhOAfXzzNIlLO+1/gRcplORMplwR8lXhJECAXkiszd+pAx/n7TPf2SEIlv275P7LsFqUGmMur/Sbwcp6deREJjKrZG1nY5++dELlKLm1QkUl/rUJyMGQblTRy7LN7MR8Zr51569nzMUi42h+pBD2grG9KvKyovBld31050UqQte/Wrv2fTa3luCYe691aipesZanns623d3J1yRoPgv47hpegf9wn6EcKVIKujStCQ7eRc0jX8UaIcgJbLJ14PVNtWl4wiEw91ZY7i9oRfYZbqWYPYToyylkge2LeFzJFzGMEOZ21LGAj1ewxiJtUcWs9JDtMRwyumPobSy6hVkF1iyo6pRlCzMU2cW5oi1nAJ+apQYwRtKoPqlHzBBpf4OcEiVnE3I24SORZfiPooZA6anBGzDVSyarqC19Hs1xOVAcG+f0qVnPqzlfSI+ZgeGwbK9vP7Tz48Yzr6CCc5uqjVsrMVsridJu5gIcYT9TS4btBQ7eIuXpfdRK2Kr6GiHEDP6GYDsY7XmyS/+B1Tzcyyar8mYkMqY5EQm7nsdkit4tZRzX1xjS4qTHXEjB2I/bkWkiPmJtSiq7PjeGPoSusPANV2uYWoYSUjCVT29UotThdCDFXo1LqdZzFjtTAqcs7NNdaNME1f8INQsoD6BlJtUaCRaw3n6i4FS1vpoLtzPJMUhfECXIWTzCl4W3j3L+Occ8LKZdboRVPe8S93ziKBqqsJGMvqDksKqwZOIfuXu6f01lrJLebVy8bzbiGzibmpfUJzmM/EpG9DWL6OQ4Rs2RpTsiMmzqYrOU4apltXS95NjNp2mF4SLtGwvL9l2q5p219GdaQmi2SW0bNp1CXVUKu3vpuRZZUsh4CppEi7JpB1tdyuud5l+u2kA1EYlHLax2gWzP621pmpz2DPe2H+FTJag+C/huGl6B/yifoRwrkJru67fsUjBtrTUW7kaAQcWrYZSZxxogynnqq0yQt+6i0khUh1akvYr1lnZhJtwlY+le3l7BEFXNJAPXCXLZQwy7m8iqV7LMVG8rzck/S4fNVPzCdaOwPsvg496XF7SBMPBZET2hUF9WzgA2E6bB1wsauUtU4G6lM04/GCHElfzSna3XL91hdRyVXzusqAymnzlwdqDmT7WaxnSoarGIbMjAppJvFrGP5gRfJewP36LhEdUl99/aHjAJOcnzqvqTd2UqXjPXH267DGTxtOQupEXb1vug2Byhqop/cy5LQHKaDa7idcpps24K+ibkU1Oib3JbZXDfCdDKdOkv/+34eNQpu6DFbdDl/PfbkWjX5U43cJoBV8IcZH6aBqqxdK/oqjARGFUR11kAsHuXF7UQl+1jFaoLEMyZ+AjQVHWUVCsp0/kRS0Ve0XJ6Lxbxg06t2a4VsZl6f11NHMwqVte016h7swUj6dJNqtZGuLzeJ+SvfmGHL2XGDOoOiwhrkK/eU/C9VYmUwmmlQCinnJ1VvLYNzJwai8/YK+gzFcq5ty6btg6V/V6P3hXRbM3Ii/VKvtQzIpL+PE2QDC60cCrftqhIZlaxWmNGRTLMDbtsLEcuquBLY/cYjHOTE23caz4ZK1o2dZk44Bbscxg1C8IWkHwOMM1zUNkyYwxbmpp0DOR459wvYSGGs2yLrMc1430WJsJalBIn3QdBvBRenuqFBD/AZn6AfKVAj6NFxx3iSoAA6M9lhWWs1U2HJJyCVIKOSc3noYwRZwZOsZA0hYhmjUQ1UWVpyN6gkoC9k6rxmssMsHLOdShotD2PPBFDjh+yumsiX+LHNNhHE4i+d5KrHIcTc6cwiLglukRFxBnHTKp7DGk5gCzFCNsmBE2q5dLlOUmbc6YYi7ZaItbpNowJlnSVnkWOvpNGojtn1Ivk7SffPFr2iQ7//8oeO4xnOsGyw1GOXWQghCLlEzaNm9HkBG5nLq2lkWsVBIuwzBwbqPlRpVjX1rGQNs9ieplVPoGWcBZKBVU8fHbhEzOU6VbKPCpoooJvxRDmF9UzV6y1rT0H+ZtIrrjp9ieVeXgiPLDmHLcxNkz+4RcxVT/hMkOJgxvaM8yBJnQKVQIXp5GIeMPT/GUi5HhhDNBRJuw/T928MSjMRamubaFSZVqUy0EloKalGpsI+OhqltBj+6wfeNPT9aoEnFV0YAyYnYsAc2LlqMrXM9myzIYEocJWmWQN865k2zmsVDcxku+VE4XXPG+XXjfySbGZEnHCTlvWFWWZ/OxzoIMwTnJX1+plkcsPtTCP9nyRpGkbFLWnrCWmXYFUHYbYw1/asehFuHc16NsuyzvxM/V6kI7kQdg3D4jeAztH3HzAGtKmNGsgUYZdHpKSPnYXMf/kY2vUS6C2HdUXv8SxiJMdTSqvRRodevZlyOtsPc2pJvQdB/xnDS9C/4BP0IwVyk61q+w1544pdO6sgcUvnGidk8/UW9FBoSVpUzGMTK1lDBc0ZI1tGbcNSz6i5EC9n29yWBW4dVJA41exhCesMxxEzATTYeyjlZy5QOox/Vc5hNe9nIwvTIvetDhsoJ8mOEzScMEydeUSLchKbqDJLZrq1s4VSiziqKKCbk9jMYtaZL+pi15c4pAoc2dtmJOy1OIomSbvd9KtuVUDBIOZz2cJ0djGxsc2wjlOJilgmqolxwGsXTuNuLrOi3M42GMUk7O3OdM2FJEu0v5o9LGSjrSiQE02mD7/Tx7yeqVYUdh6bOJ211LDL6sTTz286cRRrsL7Ij0Qr1UFSuVlHIESMBWxkYWwDQBqJzd9JyhHE2Fh6xByMF9U8eHbRKTzDGRkHxwJ1sJmJuEXNcl0CnYB5VpvSzpVUrY0QZZG+3lNbDtkRc7lP3e5jN0w3q8DOZLv1Au7WCmmgKk3a5YYyWljARo7a02nc51JQSPXpl0GoqjtX8VF4pOqcjLkJUtnTq2iYsz+IEGUuWyypmdf9LjMzkpAsfVQuxByMvmox66zlIDGmbdtv1wyD+/Jw1lhRbf5c2pKshLoJk/s8/i3Mzari7FBBjbSLZavTuhXsAyUZbDoDMF7bl3tB8mhySRCWe85ZQMl9X3Y3mlls5/jm3XBH2orpmnU1VyOflMQF3K+xoAiD1I8zfndgTj7rWOzqBiNtlMJ60/U66/P29iRVExIeBP1/GF6C/m8+QT9SIDfZuW23M9asVCSkJ4BOFQ3MppYERlGbOmqAVKRMoubbmZW27RrqLPtEr0hRlIjlK+0GNcFPbZsX3BJBpROuYRcL2WBF0CQJNNx2yE7MHXi58ji+xU1px6Cj2TpAtxdeN4W0xox5uoJQN7Op5SQ2p5F4gdj5qVIP6ZxnU2slsIlcwgmZBlUjmhLtjhKhnuq08wLGdHmnQszBiHxU0UA19bZoaAXNljf8UQ0mYRGolomq3CIEB1YZ/vBBYqgOMNIWGXD0dY1Txxowk2wjVrsWsZ5ycxrXSVaEyO9iepqlZCulbGEuQeLM5VUu5GFPgu9FzCWpNdMMEKSs7tQy62W0GuTRfOZW6mtcSWx+MymNc2qDKQs0JdK0//ISfsINtvvMLRFOlrONmKuFXuT+CtNhG8DJNQwRZwEbuLDrEct1xStiHs8fS5NWkZFUdFNo5Xz0BXnZLtQ32D5v1CppoZR6pmb8fZgOFrKBozcfSDmwtALtykpqcSe3SoynAgH4v0XvyzgLIHkeArku3Y4BnBCpGuo4gS2e25PBXzYkLRNmsgONBIvaXmasRD1VQuQFp73ecEIGq33BOZgYAJ6fN996FgROm+EeCtLsdweCSTQa8ixiaRIm5yzHMxgFDr327/Y+kjoW2XqyA1b+lJusJBM0Enx0wyPGNXmWlA1pX5KYfFIRczfNuooJWEWSDs2A2pIZVj6XFxayAQ2dgoP7MxD072IvrTqU6AW+6RP0IwVuBB1SVmezqSVOyJYspCZDNlLJLpO0G98ZCUiXcQ+LWO+prZQp3F1MdyUzktGeC1SZiNoeDZ2FbOAMnqGSxr79zI2N8Vb5BD7Nryxirh63lML2ImIxgjTHTGvAgE6l1shK1ngSpASGhZvkAMg64rgw13wZ1yuyIvm9muwaZbztpQDGy1+tCivbVklAq0PsFyTGVOqtF7Sc36WstWw1J+5sSxUakpd2AuOz1I5gJlxz7M8JEk+L3Akxd6s2mwlRxpvXwPCpFktKgfMF1UMhtcxOi1z2UMB6FqGZxPg/+E/LDUiF/M6rKEwT5TRQlXFKXAa5cqwSeZrHJkIY1fEu1B9Kk7EA5LcBL6Rt0CCGasGsIuAs+Pep3846QirXoC9iHiNkS4gGIy9lFtvTBlTi2PKFA7+hu2hMRhkLQEuo1Er6Tt9v0HKXyQZhOliuP237rEMzrtsTrLA9e27T3VKt9KgNpkblAJj1eewQNxZn/1EMTIJHVp3jqfFXZ6uc/ZUMQmRZjqmUVlbwRIY+J2Tadk4iSsRTquEm3Sg2XY0APrDh76kvnF13wPGZBu3TxtpWSWi5ReUHAlWO0B8Eew8Zg96+7N37shTMFm7vmnx4a84ENijuLZL/470Z92t6HLVIzgGky3XUiPkDXAyQNoBze0cVmJWJvQJgzudIjcqrswBucJtxBvj46nuNvk0KevUF8U/ve0LN6CfLscj983PmW1bEbuhsP8x1JQ95EPSbGF6C/i2foB8pcCPoIeKsZI3lDLCFE6z1VZeWRiotwigPWZAYF/IwS3nOU5srkVyvF41MXcPAIuZBkzwsYj2TaGSqXm+tmylqnsyHCyfc4zoNpka63AiQjkZjzKgspwV0IlqUFTxhmzZUSWoTFdYMgtp5BomzitXMZDuAuY6HBRSaJTVQozZxQuyixrLNc9MYSxU8dd9VNDCPTbZ9SNS8mnqDmEvSD6SIomrhZ05Bfv7cH1j3gDNiDoZ+ONuIORj3hhC5GupYzLo0JxUVCTQ2c5JF7lTt/FqWAgb5+Slf9CSoQqzdXkIdhNnOzJyIORj37Tw2E6aDcppYyRpX95JQDPLWkP7SOYDRV6tT+cfCl5fdbHshOq+5837NJvlTBsvqsyxOFE7pkUx139R2M3ofL8p4/lgOapFBIeYaCeNe0KOpdptlvx/j3IzRPPEtf2/DsymHIUn8NA4uBbX6qjPKVwyca8hYMiXf9lDgWmhIZCgqIkR5P6td7y85962UZexP3SDX6fKdDxrPrde1Mj8/VAU9xWPTvk5o2ohKQLygSjaExMvAQV0eKMEXjHtdme1SI7kDic6bv929MOVM0pf7U+qnqbyESvYBeFrKSr/QQZjVrALS3XmcfbeTsGcbLe/Lf90JGchW0sh7f/2sPa8jk2ZdbBizIeszUtt5aeGJlgOaisxJojcyvAT9Oz5BP1LQ1tZGJBLhfQ0/JW9cEQEOW1XkokTY5iJdaaOEzcxPe8hm8xrv5y+UEPWsvLaT6XRS7Nmet5gMQIIxBEhF3byWvR70Y9jLGTzDBA4wTd9tfR5uS5An/ZTLA75l8jT+h6/QyoS0bR4wBw06Y9CUtugYUcBOwrTFUlksxaFOPsiDru1rZQJ1zEj7PEwnZ/Eks9gGwH4mZTxfbu0EeFUZVDlxiKAVoVOPpZxmFmCXA0zmTRawgVIOUvnmQXjTZYMHSOnMzZfKdy78knW+3PA2R2W8xgnznKrLnYQ5QCk6YzieWpbynOf2AbZxLFGXrKL1LOKQqa/+CddnfFl4HUOcIK85ZiXcEKWENrMNAQ6TMNteak4zfIBHmNB10PW3+buAXcoHCeAg6frMU+GmE77aZ1tU9JCf8b4SvMVk2+BJR+N4XnM9Z1/lBxR29V1pUg/k0Rw6yvPctlHC28pMUiYEibGU5wkqVQO1hM5bocls4qSMvy2gm1UbnoAxGPduHNhHSsLi1LZ2YZe3CBKw68uVtgioGw54PKtvcrTjmA7xUe71JGIJxvA25bzBMRn358RctrBg1+v2GRfn4MNcbj8+YHlFq2jVUsfQHw17f9HXYDObwWh/UEgvBbpd7+08L7ksB3sT5G8ns1a/r2Xzvnx2/sns6UOm5YYFbLD1u17opoAtzGWny3vKDRM4YM3CZIsJtunW7HAUzZz585fSczzcMA6DrKvn0ctzHeC41Gf3zV9lfdzTfogvVj1ONBo1SblK0G+ALCR3g4MY8BOfoB8p2L17NzU1NX2v6MOHDx8+fPjwcYSioaGByZONIGJvby9Tp05l//79w9qGiRMnsmfPHvLzhytqPzpwRBL0aDTK+PHjeeONN6yRoY8jE+3t7VRVVdHQ0HDEjc59pODfBz7Avw98GPDvA0gmk3R0dFBZWcmYMWOsz3t7e4nHs0+iHQwEg8EjjpxDdmqldx3kZispKTliHz4fdowbN86/F3z494EPwL8PfBg40u8DtwBmfn7+EUmWRwJj+l7Fhw8fPnz48OHDhw8fwwWfoPvw4cOHDx8+fPjwMYpwRBL0UCjEt771LUKh4cpC9jFa4d8LPsC/D3wY8O8DH+DfBz5GB47IJFEfPnz48OHDhw8fPkYrjsgIug8fPnz48OHDhw8foxU+Qffhw4cPHz58+PDhYxTBJ+g+fPjw4cOHDx8+fIwiHHEE/bHHHmPFihVMmDCBoqIi5s+fz89//nMOH+67DLCPdzaSySTPP/88X/nKVzj11FOJRCIEg0EqKyu56KKLePrpp0e6iT5GEDfeeCN5eXnk5eXxne98Z6Sb42MYoes6t912G8uWLaOsrIz8/HymTJnCBRdcwCOPPDLSzfMxDGhububLX/4yxx9/PIWFheTn51NTU8OnPvUp6urqRrp5Po5AHFFJot///vf5+te/DsC0adMoLi5m69atHD58mFWrVvHQQw/ZKmb5eHfhySefZMWKFYBRrGr69OkUFRWxc+dOOjs7AYOk3XzzzSPZTB8jgNdff5158+ZZFfJuvvlmbrzxxhFulY/hwMGDBzn33HN56aWXyMvLY+bMmRQXF9PY2Mi+ffu46KKLeOCBB0a6mT6GENu3b+f000+nubmZsWPHMm3aNMaOHUtdXR29vb0UFhby2GOPsWzZspFuqo8jCEcMG33xxRf5xje+wZgxY7jnnnvYtWsXr7zyCi+//DIVFRWsXr2aH//4xyPdTB9DiGQyyfTp07n11ltpaWlh+/btvPzyy7S2tloDt+985zv85S9/GeGW+hhOJJNJrr32WsaOHcuZZ5450s3xMYyQ4MxLL73EBz/4Qd544w22bdvGhg0baGxspKGhgS984Qsj3UwfQ4zPfvazNDc3s2TJEnbv3s22bdvYsmULb775JqtWraK7u5uPfexjHEHxTB+jAckjBOeee24SSH7qU59K++7uu+9OAsnS0tJkPB4fgdb5GA60tbUlDx065Pn9+973viSQXLVq1TC2ysdI47bbbksCyR/84AfJq666Kgkkb7755pFulo9hwC9/+cskkFy+fHlS1/WRbo6PEUBXV1dyzJgxSSD56quvpn1/4MCBZF5eXhJI1tbWjkALfRypOCIi6O3t7TzxxBMAfOITn0j7/kMf+hDjxo2jtbXV1yG/izFu3DgCgYDn92effTYAO3bsGK4m+RhhvP322/z7v/87s2fP5oYbbhjp5vgYZvz0pz8FDEmTL288MhGPx60ctGnTpqV9P378eCZMmABAIpEY1rb5OLJxRPRImzZtIh6Pk5+fz/z589O+Hzt2LCeffDIA69evH+7m+Rgl6O3tBaCgoGCEW+JjuHDDDTdw4MABbr31VsaOHTvSzfExjNi5cyfbtm1jwoQJLF68mEceeYTLL7+cs846i4985CPcfvvtxGKxkW6mjyFGJBKhqqoKgHXr1qV9v337dlpbW4lEIsyYMWO4m+fjCMYRQdB37twJwDHHHOMZQZWRs6zr48hCMpnk/vvvB2DJkiUj3Bofw4Enn3ySu+++m8svv9xP/joCsXHjRgCOPfZYrrjiCi644ALuvvtunnrqKe677z4++clPMm/ePPbu3TvCLfUx1BDXpo9//OM8+OCDtLa20tbWxpo1a7jgggvIy8vjhz/8Ifn5+SPcUh9HEo4Ign7w4EHAmKrygnwn6/o4snDbbbexadMmgsEg119//Ug3x8cQo7e3l09/+tOUlJTw3//93yPdHB8jgH379gHwr3/9i7vvvptrrrmG+vp6ent7eeKJJ5g2bRrbtm3joosu8m143+W48sorefDBBykrK+Piiy+mrKyMSCTCe9/7XoLBII899hif/OQnR7qZPo4wHBEEXaQLwWDQc51QKARAT0/PsLTJx+jByy+/zBe/+EXAiKTU1NSMcIt8DDW+853vUFdXx3e/+10qKipGujk+RgBdXV0AHDp0iKVLl3LbbbcxZcoUQqEQZ511Fv/3f/9HXl4eGzdu5K9//esIt9bHUCKZTLJ7925aW1vRNI3p06cze/ZsgsEgW7du5Te/+Q0HDhwY6Wb6OMJwRBB0mZYSj2M3iNbQ1x8fWdizZw/nn38+vb29XHrppXz5y18e6Sb5GGK8/vrr/OhHP2L+/Plcd911I90cHyMEVa4gA3QVJ554IsuXLwfgb3/727C1y8fw49Of/jRf+cpXqKqqoq6ujp07d/Laa6/R0NDAueeey0MPPcTy5cvRdX2km+rjCMIRQdCzka9kI4Px8e7C/v37Ofvss9m3bx/nnXced9xxB3l5eSPdLB9DjM985jMkEgl++ctf+s4dRzDUvv7YY491Xee4444DoL6+fjia5GME8Morr3DbbbcxduxY/vSnP1FdXW19V15ezt13301ZWRmvvvoqf/7zn0euoT6OOBwRbyfJvH7jjTc8bZJ2795tW9fHuxsHDhzg7LPPZteuXSxbtoz777/fd/E4QrBp0yby8vJYtWoVEydOtP277777APjBD37AxIkTLXcnH+8+zJo1y/pbJI5OyOd+5PTdixdeeIFkMsnMmTMtNxcV48aN45RTTgFgw4YNw908H0cwvE2h30U46aSTGDt2LL29vbz88svWwyY4dOgQ//rXvwBYtGjRSDTRxzCis7OTc889l61bt3LyySfz6KOP+tKmIwy6rtPU1OT5fWdnJ52dnb5rw7sYJ510Evn5+fT29rJ7926mT5+eto4Ebo4++ujhbp6PYUJHR0ef6yTNCqKSz+bDx3DgiIigjxs3jhUrVgDw29/+Nu37+++/n/b2dkpLSznjjDOGuXU+hhOxWIwPfOADrF+/nuOPP56//e1vhMPhkW6Wj2FENBolmUy6/rvqqqsAo3BNMpn0pQ3vYhQVFXHuuecC8Ic//CHt+/3797NmzRoAzjzzzGFtm4/hg8ya79ixg4aGhrTv29vbrQDezJkzh7VtPo5sHBEEHeCb3/wmeXl53H777dx7773W56+88gpf+tKXAPjqV7+a0enFxzsbuq7zkY98hKeeeoqamhr+8Y9/WBXifPjwceThP/7jP9A0jT/96U82kh6NRrn66qvp6elh2rRpfOhDHxrBVvoYSpxzzjmUlZVx6NAhPvKRj9gG5c3NzVx22WW0tLSQn5/PxRdfPHIN9XHEIS8pczdHAL773e9y4403AkZhouLiYrZu3crhw4c577zzeOSRR9A0bYRb6WOocO+993LppZcCRtSkvLzcdb1JkyZZRYt8HFm4+uqr+cMf/sDNN99s9RU+3t341a9+xWc+8xmSySTHHHMM5eXl1NbW0t3dTVlZGf/4xz+YN2/eSDfTxxDi8ccf54Mf/CC9vb1omsa0adMYO3YsdXV1xONxAoEAt99+uzXD5sPHcOCI0KALvvnNb3LiiSfyk5/8hI0bN7J//37mzp3Lxz72MT73uc/55PxdDrVs986dOz2rxk6ZMmW4muTDh48Rxqc//WmOP/54fvSjH/Hiiy/y6quvUllZyXnnncfXv/51X39+BOB973sfr7zyCv/zP//DU089xRtvvEEymWTSpEmcfvrpXH/99cyfP3+km+njCMMRFUH34cOHDx8+fPjw4WO044jRoPvw4cOHDx8+fPjw8U6AT9B9+PDhw4cPHz58+BhF8Am6Dx8+fPjw4cOHDx+jCD5B9+HDhw8fPnz48OFjFMEn6D58+PDhw4cPHz58jCL4BN2HDx8+fPjw4cOHj1EEn6D78OHDhw8fPnz48DGK4BN0Hz58+PDhw4cPHz5GEXyC7sOHDx8+fPjw4cPHKIJP0H348OHDhw8fPnz4GEXwCboPHz585Ij6+nry8vKorq4e1t+OBG699Vby8vL405/+ZPv86quvJi8vjzvuuGNkGmZi9+7djB07lssvv3xE2+HDhw8fgwmfoPvw4aPfWLNmDXl5eYTDYRoaGjzXu+mmm8jLy+O4444jHo8PYwuHH7fccgvf/va3iUajI92UAaOzs5P//M//5Nhjj+XDH/7wSDfHFdOmTePSSy/lnnvuYdOmTSPdHB8+fPgYFPgE3YcPH/3GypUrufzyy+ns7OS6665zXef111/nv/7rv8jLy+O2224jGAwOcysHH2PHjmXWrFnU1NSkfXfLLbdw0003eRL0TL8dbfjJT35CU1MTX/va1xgzZvS+Lr7+9a+TTCb5xje+MdJN8eHDh49BwejtcX348PGOwE9+8hPKysr461//miaDSCaTfPKTnyQej3Pttddy2mmnjVArBxdHH30027Zt48knnxzW3w4ndF3nV7/6FYWFhVx88cUj3ZyMOPbYY1m0aBFr1qyhrq5upJvjw4cPHwOGT9B9+PAxIJSVlfHjH/8YgC9+8YscOHDA+u7WW2/lhRdeoLKykh/84Acj1UQf/cBf/vIXGhsbWbVqFUVFRSPdnD7xkY98hGQyyW9/+9uRbooPHz58DBg+Qffhw8eAccUVV3D22WfT3NzMv/3bvwHw5ptv8vWvfx2AX/ziF4wbNy6nbapJiDt27OCSSy6hvLycgoICTjrpJH73u99l/P1f//pX3vve91JWVkYoFGLq1Kl85jOf8dTKt7a28uUvf5ljjz2W/Px8ioqKqK6u5r3vfS+33nqrbV23RM877riDvLw89u7dC8DUqVPJy8uz/j3zzDOev3W246tf/SqzZs2ioKCA8ePHc8YZZ3D33XeTTCbT1pf9Xn311cRiMb797W8zffp08vPzqaqq4ktf+hJdXV0Zz5Ub7rvvPgDOO++8nH/7zDPPEA6HCQQC/OEPf7A+P+OMM6xz8eqrr/KBD3yAsrIyxo0bx4oVK9iwYYO17tq1a3nve9/LhAkTCIfDnHfeeWzbts1zn+eff76t3T58+PDxjkbShw8fPgYBu3fvThYWFiaB5BNPPJF8//vfnwSSF110Ub+2d9VVVyWB5De+8Y1kSUlJMhQKJefPn5+cMmVKEkgCyc9//vOuv/3a175mrTN58uTkggULrLaNHz8++a9//cu2fjQaTdbU1CSBZDAYTM6ePTs5f/78ZHl5eTIvLy9ZUlJiW3/Pnj1JIDllyhTrs8ceeyy5ZMmSZCgUSgLJhQsXJpcsWWL9e/nllz1/K9i5c2eyqqrKasf8+fOT06ZNs47lyiuvTB4+fNj2m9///vdJIHnppZcmTz/99GReXl7y+OOPT86aNSs5ZsyYJJA8++yzcz7/kydPTgLJ7du3u34v1+f3v/+97fNHH300mZ+fnwwGg8kHH3zQ9t2yZcuSQPL73/9+sqCgIBmJRJILFixIlpSUJIFkOBxObt26NfnnP/85GQgEkuXl5cn58+db1+6oo45K7t+/37PNEyZMSALJhoaGnI/Xhw8fPkYTfILuw4ePQcOPfvSjJJCMRCLW/42Njf3alhDAQCCQXL58ebK5udn67v7770+OHTs2CST/8pe/2H736KOPWr+76667rM/b2tqSF154YRJIVldXJ7u7u63v/vu//zsJ/P/27j8m6jqO4/jzKDhDCSMwTTlNQUOnREJZ5+RsC1bT0XRNG9FAEc2VbU6Kli7rDyvTZdla3WKGbbJM5qqVBm2IxWiNlTrM2XRKTUytWXEOTjk+/cG+l+fdyfFLz/V6/Of38/l8v+/P4R+v74cPnzN5eXnmzz//DLhfa2ureeuttwKuXS1kWy8QJ06cCDmvcGO7u7tNdna2AUxubm5AEN2zZ48ZPny4Acx7770XMM4K6LGxsWbq1KkBgbqpqcnceuutBjB79uwJWU8ora2t/sB85QuBJVRAr66uNrGxsSY+Pt58/fXXQWOsgB4bG2tWr15tvF6vMcaYzs5OU1BQYADjcrnMyJEjzebNm43P5zPGGHP+/Hlz3333GcA8//zzYevOy8szgKmuro54riIi0UgBXUQGTVdXl8nKyvKv+Lrd7n7fywqAdrvdnD59Oqh99erVBjBz5swJuO50Og1gnnvuuaAxFy5cMMnJyQYwlZWV/uvLly83gPnss88iqm0oAnpdXd1V57tx40b/uMtDsxXQbTZb0G8GjPnvc1q1alVEczPGmP379xvApKenh+1zZUB3u90mJibGJCYmmm+//TbkGCugZ2VlBQX/o0eP+v/fFBQUBI3du3evAcyMGTN6ren111/vfZIiIlFMe9BFZNB0dnZy/vx5/7+zs7MHfM8FCxYwevTooOsrV64EoLGx0b/H2uPx0NTUBMCzzz4bNCY+Pp5ly5YBUFtb67+empoKwO7du+nq6hpwzf1h1fP444+HnO+KFSuw2+20trZy9OjRoPZ77rkn5Oedk5MD9HyhT6T++OMPAJKSkiLqv3nzZsrKykhKSqK+vr7X03pKSkqw2WwB1yZPnkx8fDwAS5cuDRqTlZUFXH0eVr3nzp2LqG4RkWilgC4ig2bdunWcPHmSYcOGAVBWVkZ3d/eA7pmRkRHy+sSJE7Hb7fh8Po4fPw7AsWPH6O7uxm63M3HixJDjpk2bBsAvv/ziv1ZSUkJiYiIfffQR48aNo7i4mMrKyj6F2oGy6pk6dWrI9oSEBP+LxOW1W8Kdqz5q1Cig5+UlUp2dnQDY7fZe+27dupU1a9YwduxY9u/f7w/SVxOu1uTk5LDtKSkpwNXnccsttwDQ0dHRaw0iItFMAV1EBkVzczPvvPMOsbGx1NfXM2HCBJqbm9m6deuA7msFzCvZbDZ/aGtvbwf+C28pKSlBK7SWO+64I2AMwJ133klTUxMLFy7k77//pqqqitLSUiZNmsQDDzzgX5UfSlbt4eYLoWu3hDsK0fqCIRPiBJhwrJXoSL4N1Tp3fMyYMYwdOzai+1sr5Veyfmah2sP9PC9nHfFpBX0RkRuVArqIDFhXVxelpaX4fD7Ky8uZNWuW/2jCtWvXhj3aMBLhtisYY/xtCQkJAIwYMcI/JlwgPXPmTMAYS0ZGBrt27eKvv/6ivr6e9evXc/fdd/P999+Tl5fHyZMn+z2HSFi1nz17NmyfcLUPNusl4fIz7cPZsGEDs2fPprm5mUcffbRfRzoOFqte68VNRORGpYAuIgP25ptvcvDgQdLS0li3bh0AjzzyCIsWLcLj8fDMM8/0+95HjhwJef3EiRN4vV5iYmL8WyLS0tKIiYnB6/WG3Z5y+PBhoGfPcyh2ux2Xy8XLL79MS0sLTqcTj8dDdXV1RPVGstIbilXPzz//HLK9vb3d/6ITrvbBkpGRQVxcHKdOneKff/65at/hw4fz1VdfMWvWLBobG5k3b95122JifXb33nvvdXm+iMhgUUAXkQE5duwYr776KgBut9u//xxgy5YtjBw5ks8//5yampp+3b+mpsa/cnw5a4Xe6XT6t3eMGDGCBx98ECDk1pqOjg4+/PBDAPLz83t99k033eT/I8u2traI6u3vPmirnk8//ZTff/89qP2DDz7A6/Uyfvx4pkyZ0qd799WwYcPIzs7GGMOPP/7Ya/+EhAT27t3LzJkz2bdvHwUFBXi93iGt8UoXLlzgyJEj/tpFRG5kCugiMiBlZWV0dnZSUlLC3LlzA9pGjx7NG2+8AcCqVat6XY0NxefzUVhY6D9ZBHpOW7ECeHl5eUD/F154AegJ8Dt27PBfb29v56mnnuLcuXNMmDCBxYsX+9teeuklKisrg/Zct7S0sHPnTiDyVVnrj1MbGhoinGGPhx56iJycHLxeL0888UTAVpfa2lpeeeUVACoqKvq9St8XeXl5AHz33XcR9U9MTKS2tpbMzEzq6upYuHAhFy9eHMoSAzQ1NeHz+XC5XMTFxV2z54qIDAUFdBHpt8rKSurr6xk1ahSbNm0K2WfZsmU4nU7a2tp48cUX+/yM8vJympubSU1NJTs7m7vuuosFCxZw8eJFVq5cyfz58wP6z5s3j4qKCi5dukRhYSEOh4OcnBzGjBnDrl27uO2229i5c6d/pRt6tr2UlpZy++23k56ezv333096ejrTp0+nra2NuXPnUlRUFFG9ixYtAuDpp59m+vTpuFwuXC4XBw4cuOo4m83Gjh07GDduHPv27cPhcDBz5kzS09PJz8/H4/FQVFTE8uXL+/YB9lNJSQkxMTF88sknEY9JSkqirq6OadOm8eWXX7J48eJrdmylVeeSJUuuyfNERIaSArqI9MuZM2f8q9dbtmwJe2a2zWbD7XYTFxfH+++/3+cTUSZPnswPP/zA/Pnz+fXXXzl9+jSZmZm43W7efffdkGNee+01vvjiCx5++GE8Hg+HDh0iOTmZFStWcPDgQf+2FcvatWupqKggJycHj8fDgQMH6OjoIDc3l+3bt1NbW8vNN98cUb1FRUW8/fbbzJgxg+PHj9PQ0EBDQ0NEJ6KkpaXx008/sWbNGhwOB4cPH+bs2bPMmTOHjz/+mKqqqmuyeg7gcDjIz8+npaWFQ4cORTwuJSWFb775hilTprB7926efPJJfD7fEFYKly5doqamhpSUFAoKCob0WSIi14LN9OXsLRGRa6S4uJiqqiq2bdtGcXHx9S7nf6mxsZHZs2ezdOlS/979aLRt2zaWLFnCxo0bg7Y8iYjciLSCLiIiITmdTh577DG2b99Oa2vr9S4nJJ/Px4YNG0hNTQ357bEiIjeiyH5nKyIi/0ubNm0iMzOT3377jfHjx1/vcoKcOnWKwsJCcnNzA04QEhG5kSmgi4hIWJMmTWL9+vXXu4ywHA5HVNcnItIf2uIiIiIiIhJF9EeiIiIiIiJRRCvoIiIiIiJRRAFdRERERCSKKKCLiIiIiEQRBXQRERERkSiigC4iIiIiEkUU0EVEREREoogCuoiIiIhIFFFAFxERERGJIgroIiIiIiJR5F/ypSogeErdSAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#NBVAL_IGNORE_OUTPUT\n", + "from examples.seismic import demo_model, plot_velocity, plot_perturbation, Model\n", + "from devito import gaussian_smooth\n", + "from scipy.ndimage import gaussian_filter\n", + "\n", + "# Define true and initial model\n", + "shape = (601, 221) # Number of grid point (nx, nz)\n", + "spacing = (15., 15.) # Grid spacing in m. The domain size is now 1km by 1km\n", + "origin = (0., 0.) # Need origin to define relative source and receiver locations\n", + "vel_path = '../../../devito/data/Marm.bin'\n", + "# Load the true model\n", + "model_true = (np.fromfile(vel_path, np.float32).reshape(221, 601))\n", + "msk = mask(model_true, 1.5)\n", + "model_init = gaussian_filter(model_true, sigma=[10, 15])\n", + "model_init = model_init * msk\n", + "model_init[model_init==0] = 1.5 # km/s\n", + "\n", + "model = Model(vp=model_true.T, origin=origin, shape=shape, spacing=spacing,\n", + " space_order=2, nbl=20, bcs=\"damp\")\n", + "model0 = Model(vp=model_init.T, origin=origin, shape=shape, spacing=spacing,\n", + " space_order=2, nbl=20, bcs=\"damp\", grid = model.grid)\n", + "\n", + "plot_velocity(model)\n", + "plot_velocity(model0)\n", + "plot_perturbation(model0, model)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "assert model.grid == model0.grid\n", + "assert model.vp.grid == model0.vp.grid" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Acquisition geometry\n", + "\n", + "In this tutorial, the sources and receiversare are located on the top of the model. This configurations mimic a seismic survey in practice." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#NBVAL_IGNORE_OUTPUT\n", + "# Define acquisition geometry: source\n", + "from examples.seismic import AcquisitionGeometry\n", + "\n", + "t0 = 0.\n", + "tn = 4000. \n", + "f0 = 0.005\n", + "# First, position source centrally in all dimensions, then set depth\n", + "src_coordinates = np.empty((1, 2))\n", + "src_coordinates[0, :] = np.array(model.domain_size) * .5\n", + "src_coordinates[0, -1] = 20. # Depth is 20m\n", + "\n", + "\n", + "# Define acquisition geometry: receivers\n", + "\n", + "# Initialize receivers for synthetic and imaging data\n", + "rec_coordinates = np.empty((nreceivers, 2))\n", + "rec_coordinates[:, 0] = np.linspace(0, model.domain_size[0], num=nreceivers)\n", + "rec_coordinates[:, 1] = 20.\n", + "\n", + "# Geometry\n", + "\n", + "geometry = AcquisitionGeometry(model, rec_coordinates, src_coordinates, t0, tn, f0=f0, src_type='Ricker')\n", + "# We can plot the time signature to see the wavelet\n", + "geometry.src.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#NBVAL_IGNORE_OUTPUT\n", + "# Plot acquisition geometry\n", + "plot_velocity(model, source=geometry.src_positions,\n", + " receiver=geometry.rec_positions[::4, :])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## True and smooth data\n", + "\n", + "We can generate shot records for the true and smoothed initial velocity models, since the difference between them will again form the basis of our imaging procedure." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute synthetic data with forward operator \n", + "from examples.seismic.acoustic import AcousticWaveSolver\n", + "\n", + "solver = AcousticWaveSolver(model, geometry, space_order=4)\n", + "true_d, u0, _ = solver.forward(vp=model.vp)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute initial data with forward operator \n", + "smooth_d, _, _ = solver.forward(vp=model0.vp)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#NBVAL_IGNORE_OUTPUT\n", + "from examples.seismic import plot_shotrecord\n", + "\n", + "# Plot shot record for true and smooth velocity model and the difference\n", + "plot_shotrecord(true_d.data, model, t0, tn)\n", + "plot_shotrecord(smooth_d.data, model, t0, tn)\n", + "plot_shotrecord(smooth_d.data - true_d.data, model, t0, tn)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## FWI gradient operator\n", + "\n", + "To compute a single gradient $\\nabla\\Phi_s(\\mathbf{m})$ in our optimization workflow we again use `solver.forward` to compute the entire forward wavefield $\\mathbf{u}$ and a similar pre-defined gradient operator to compute the adjoint wavefield `v`. The gradient operator provided by our `solver` utility also computes the correlation between the wavefields, allowing us to encode a similar procedure to the previous imaging tutorial as our gradient calculation:\n", + "\n", + "- Simulate the forward wavefield with the background velocity model to get the synthetic data and save the full wavefield $\\mathbf{u}$\n", + "- Compute the data residual\n", + "- Back-propagate the data residual and compute on the fly the gradient contribution at each time step. \n", + "\n", + "This procedure is applied to multiple source positions and summed to obtain a gradient image of the subsurface. We again prepare the source locations for each shot and visualize them, before defining a single gradient computation over a number of shots as a single function." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#NBVAL_IGNORE_OUTPUT\n", + "\n", + "# Prepare the varying source locations sources\n", + "source_locations = np.empty((nshots, 2), dtype=np.float32)\n", + "source_locations[:, 0] = np.linspace(0., model.domain_size[0], num=nshots)\n", + "source_locations[:, 1] = 0\n", + "\n", + "plot_velocity(model, source=source_locations)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from devito import Eq, Operator\n", + "\n", + "# Computes the residual between observed and synthetic data into the residual\n", + "def compute_residual(residual, dobs, dsyn):\n", + " if residual.grid.distributor.is_parallel:\n", + " # If we run with MPI, we have to compute the residual via an operator\n", + " # First make sure we can take the difference and that receivers are at the \n", + " # same position\n", + " assert np.allclose(dobs.coordinates.data[:], dsyn.coordinates.data)\n", + " assert np.allclose(residual.coordinates.data[:], dsyn.coordinates.data)\n", + " # Create a difference operator\n", + " diff_eq = Eq(residual, dsyn.subs({dsyn.dimensions[-1]: residual.dimensions[-1]}) -\n", + " dobs.subs({dobs.dimensions[-1]: residual.dimensions[-1]}))\n", + " Operator(diff_eq)()\n", + " else:\n", + " # A simple data difference is enough in serial\n", + " residual.data[:] = dsyn.data[:] - dobs.data[:]\n", + " \n", + " return residual" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Create FWI gradient kernel \n", + "from devito import Function, TimeFunction, norm\n", + "from examples.seismic import Receiver\n", + "\n", + "import scipy\n", + "def fwi_gradient(vp_in): \n", + " # Create symbols to hold the gradient\n", + " grad = Function(name=\"grad\", grid=model.grid)\n", + " # Create placeholders for the data residual and data\n", + " residual = Receiver(name='residual', grid=model.grid,\n", + " time_range=geometry.time_axis, \n", + " coordinates=geometry.rec_positions)\n", + " d_obs = Receiver(name='d_obs', grid=model.grid,\n", + " time_range=geometry.time_axis, \n", + " coordinates=geometry.rec_positions)\n", + " d_syn = Receiver(name='d_syn', grid=model.grid,\n", + " time_range=geometry.time_axis, \n", + " coordinates=geometry.rec_positions)\n", + " objective = 0.\n", + " for i in range(nshots):\n", + " # Update source location\n", + " geometry.src_positions[0, :] = source_locations[i, :]\n", + " \n", + " # Generate synthetic data from true model\n", + " _, _, _ = solver.forward(vp=model.vp, rec=d_obs)\n", + " \n", + " # Compute smooth data and full forward wavefield u0\n", + " _, u0, _ = solver.forward(vp=vp_in, save=True, rec=d_syn)\n", + " \n", + " # Compute gradient from data residual and update objective function \n", + " compute_residual(residual, d_obs, d_syn)\n", + " \n", + " objective += .5*norm(residual)**2\n", + " solver.gradient(rec=residual, u=u0, vp=vp_in, grad=grad)\n", + " \n", + " return objective, grad" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Having defined our FWI gradient procedure we can compute the initial iteration from our starting model and visualize it." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4199791.287499404\n", + "17665.625\n" + ] + } + ], + "source": [ + "# Compute gradient of initial model\n", + "ff, update = fwi_gradient(model0.vp)\n", + "print(ff)\n", + "print(update.data[:].max())" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#NBVAL_IGNORE_OUTPUT\n", + "from devito import mmax\n", + "from examples.seismic import plot_image\n", + "\n", + "# Plot the FWI gradient\n", + "plot_image(update.data/update.data[:].max(), vmin=-1, vmax=1, cmap=\"jet\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we compute the gradient using snapshotting with a `factor` of `5`. The only difference is we pass `factor=5` to `solver.forward` and `solver.gradient` to tell Devito to save snapshots of the wavefield every `5dt` time step instead of every `dt` time step. Also, we pass `save=False` to avoid saving the full wavefield as well. The, the imaging condition will be applied only at those snapshots." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "model0_snap = Model(vp=model_init.T, origin=origin, shape=shape, spacing=spacing,\n", + " space_order=2, nbl=20, bcs=\"damp\", grid = model.grid)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def fwi_gradient(vp_in): \n", + " # Create symbols to hold the gradient\n", + " grad = Function(name=\"grad\", grid=model.grid)\n", + " # Create placeholders for the data residual and data\n", + " residual = Receiver(name='residual', grid=model.grid,\n", + " time_range=geometry.time_axis, \n", + " coordinates=geometry.rec_positions)\n", + " d_obs = Receiver(name='d_obs', grid=model.grid,\n", + " time_range=geometry.time_axis, \n", + " coordinates=geometry.rec_positions)\n", + " d_syn = Receiver(name='d_syn', grid=model.grid,\n", + " time_range=geometry.time_axis, \n", + " coordinates=geometry.rec_positions)\n", + " objective = 0.\n", + " for i in range(nshots):\n", + " # Update source location\n", + " geometry.src_positions[0, :] = source_locations[i, :]\n", + " \n", + " # Generate synthetic data from true model\n", + " _, _, _ = solver.forward(vp=model.vp, rec=d_obs)\n", + " \n", + " # Compute smooth data and full forward wavefield u0\n", + " _, usnaps, _ = solver.forward(vp=vp_in, save=False, rec=d_syn, factor=5)\n", + " \n", + " # Compute gradient from data residual and update objective function \n", + " compute_residual(residual, d_obs, d_syn)\n", + " \n", + " objective += .5*norm(residual)**2\n", + " solver.gradient(rec=residual, u=usnaps, vp=vp_in, grad=grad, factor=5)\n", + " \n", + " return objective, grad" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Unrecognized argument factor=5", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[18], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m ff_snap, update_snap \u001b[38;5;241m=\u001b[39m fwi_gradient(model0_snap\u001b[38;5;241m.\u001b[39mvp)\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(ff_snap)\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(update_snap\u001b[38;5;241m.\u001b[39mdata[:]\u001b[38;5;241m.\u001b[39mmax())\n", + "Cell \u001b[0;32mIn[17], line 23\u001b[0m, in \u001b[0;36mfwi_gradient\u001b[0;34m(vp_in)\u001b[0m\n\u001b[1;32m 20\u001b[0m _, _, _ \u001b[38;5;241m=\u001b[39m solver\u001b[38;5;241m.\u001b[39mforward(vp\u001b[38;5;241m=\u001b[39mmodel\u001b[38;5;241m.\u001b[39mvp, rec\u001b[38;5;241m=\u001b[39md_obs)\n\u001b[1;32m 22\u001b[0m \u001b[38;5;66;03m# Compute smooth data and full forward wavefield u0\u001b[39;00m\n\u001b[0;32m---> 23\u001b[0m _, usnaps, _ \u001b[38;5;241m=\u001b[39m solver\u001b[38;5;241m.\u001b[39mforward(vp\u001b[38;5;241m=\u001b[39mvp_in, save\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, rec\u001b[38;5;241m=\u001b[39md_syn, factor\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m)\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# Compute gradient from data residual and update objective function \u001b[39;00m\n\u001b[1;32m 26\u001b[0m compute_residual(residual, d_obs, d_syn)\n", + "File \u001b[0;32m~/miniconda3/envs/devitofwi_gpu/lib/python3.12/site-packages/examples/seismic/acoustic/wavesolver.py:113\u001b[0m, in \u001b[0;36mAcousticWaveSolver.forward\u001b[0;34m(self, src, rec, u, model, save, **kwargs)\u001b[0m\n\u001b[1;32m 110\u001b[0m kwargs\u001b[38;5;241m.\u001b[39mupdate(model\u001b[38;5;241m.\u001b[39mphysical_params(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs))\n\u001b[1;32m 112\u001b[0m \u001b[38;5;66;03m# Execute operator and return wavefield and receiver data\u001b[39;00m\n\u001b[0;32m--> 113\u001b[0m summary \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mop_fwd(save)\u001b[38;5;241m.\u001b[39mapply(src\u001b[38;5;241m=\u001b[39msrc, rec\u001b[38;5;241m=\u001b[39mrec, u\u001b[38;5;241m=\u001b[39mu,\n\u001b[1;32m 114\u001b[0m dt\u001b[38;5;241m=\u001b[39mkwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdt\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdt), \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 116\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m rec, u, summary\n", + "File \u001b[0;32m~/miniconda3/envs/devitofwi_gpu/lib/python3.12/site-packages/devito/operator/operator.py:865\u001b[0m, in \u001b[0;36mOperator.apply\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 863\u001b[0m \u001b[38;5;66;03m# Build the arguments list to invoke the kernel function\u001b[39;00m\n\u001b[1;32m 864\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_profiler\u001b[38;5;241m.\u001b[39mtimer_on(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124marguments\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[0;32m--> 865\u001b[0m args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39marguments(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 867\u001b[0m \u001b[38;5;66;03m# Invoke kernel function with args\u001b[39;00m\n\u001b[1;32m 868\u001b[0m arg_values \u001b[38;5;241m=\u001b[39m [args[p\u001b[38;5;241m.\u001b[39mname] \u001b[38;5;28;01mfor\u001b[39;00m p \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparameters]\n", + "File \u001b[0;32m~/miniconda3/envs/devitofwi_gpu/lib/python3.12/site-packages/devito/operator/operator.py:707\u001b[0m, in \u001b[0;36mOperator.arguments\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 705\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21marguments\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 706\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Arguments to run the Operator.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 707\u001b[0m args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_prepare_arguments(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 708\u001b[0m \u001b[38;5;66;03m# Check all arguments are present\u001b[39;00m\n\u001b[1;32m 709\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m p \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparameters:\n", + "File \u001b[0;32m~/miniconda3/envs/devitofwi_gpu/lib/python3.12/site-packages/devito/operator/operator.py:546\u001b[0m, in \u001b[0;36mOperator._prepare_arguments\u001b[0;34m(self, autotune, **kwargs)\u001b[0m\n\u001b[1;32m 544\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m kwargs\u001b[38;5;241m.\u001b[39mitems():\n\u001b[1;32m 545\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m k \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_known_arguments:\n\u001b[0;32m--> 546\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUnrecognized argument \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m=\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m (k, v))\n\u001b[1;32m 548\u001b[0m \u001b[38;5;66;03m# Pre-process Dimension overrides. This may help ruling out ambiguities\u001b[39;00m\n\u001b[1;32m 549\u001b[0m \u001b[38;5;66;03m# when processing the `defaults` arguments. A topological sorting is used\u001b[39;00m\n\u001b[1;32m 550\u001b[0m \u001b[38;5;66;03m# as DerivedDimensions may depend on their parents\u001b[39;00m\n\u001b[1;32m 551\u001b[0m nodes \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdimensions\n", + "\u001b[0;31mValueError\u001b[0m: Unrecognized argument factor=5" + ] + } + ], + "source": [ + "ff_snap, update_snap = fwi_gradient(model0_snap.vp)\n", + "print(ff_snap)\n", + "print(update_snap.data[:].max())\n", + "print(ff - ff_snap)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#NBVAL_IGNORE_OUTPUT\n", + "\n", + "# Plot the FWI gradient\n", + "plot_image(update_snap.data/update_snap.data[:].max(), vmin=-1, vmax=1, cmap=\"jet\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compare the full gradient with the snapshotted gradient" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the FWI gradient\n", + "plot_image((update.data/update.data[:].max()) - (update_snap.data/update_snap.data[:].max()), vmin=-1e-3, vmax=1e-3, cmap=\"jet\")" + ] + } + ], + "metadata": { + "@webio": { + "lastCommId": null, + "lastKernelId": null + }, + "hide_input": false, + "kernelspec": { + "display_name": "devitofwi_gpu", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "widgets": { + "state": {}, + "version": "1.1.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 46bbf560aeb0b939f4fe466c918bb36f0522c332 Mon Sep 17 00:00:00 2001 From: malfarhan7 Date: Tue, 5 Nov 2024 11:42:24 +0300 Subject: [PATCH 6/9] Add Marm.bin to data folder --- devito/data/Marm.bin | Bin 0 -> 531284 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 devito/data/Marm.bin diff --git a/devito/data/Marm.bin b/devito/data/Marm.bin new file mode 100644 index 0000000000000000000000000000000000000000..018e5e5467273bc7fb607d86db5c159ead2eef96 GIT binary patch literal 531284 zcmeFab(mDg);&B9gS#dW+?^00z^Y)uAxLm{4elBog1fuB`wTEMJ?%Q}Jw1xMJAA9B zGhyHYN#1*N-}m=D=MSF6p6)(fUA3ytuG)LANF0zjAaOwAfW!fb0}=-$4oDo3I3RIA;(){fi31V`Bo0U%kT@W5K;nSJ0f_?= z2P6(i9FRC5aX{jL!~ux|5(gv>NF0zjAaOwAfW!fb0}=-$4oDo3I3RIA;(){fi31V` zBo0U%kT@W5K;nSJ0f_?=2P6(i9FRC5aX{jL!~ux|5(gv>NF0zjAaOwAfW!fb0}=-$ z4oDo3I3RIA;(){fi31V`Bo0U%kT@W5K;nSJ0f_?=2P6(i9FRC5aX{jL!~ux|5(gv> zNF0zjAaOwAfW!fb0}=-$4oDo3I3RIA;(){fi31V`Bo0U%kT@W5K;nSJ0f_?=2P6(i z9FRC5aX{jL!~ux|5(gv>NF0zjAaOwAfW!fb0}=-$4oDo3I3RIA;(){fi31V`Bo0U% zkT@W5K;nSJ0f_?=2P6(i9FRC5aX{jL!~ux|5(gv>NF0zjAaOwAfW!fb0}=-$4oDo3 zI3RIA;(){fi31V`{vi(d^1A0Phoaiv&?J;>sXrt>Nb^Bj52W?bvkpl21L=Ms-4Fi# z`@!6qp~y5i6!VCl{*-K~KO{c<-=h_$0G8Eazc)#B{*8BbXVWAjwDik%w zheFmp6b*@<_LXD%e(V{FLlZ&~b2=1H`h?+tiQ>rLTx$A9$sHMF<(3dO-Kp_oN%)r9^D+db=eD0U4B zMblQHxI8cvclrIX#HbYg_i#!m7W10HzxQ`)qQ|byzo+cqkNbP^NbmQ#*tX?eLQ!}k z`{i6HcCfuYc>SL2-|1{azwblwykIE$5>wipX_w?RGJh9}E%~_S5kF_I;_EKHf53!L zG^@qmP{fOW#a>e`6pyoqqI=m;jOB0lV3N(hr)*Dh`&u>(#j@t1xXSTOIo_Ue|CC*Y ze;>&)|G59&vHv`L@Qhzo_K^oY_BrC&6#X5*eoOiK$M1jE??XO$c;(^OL}D`EQ_ja^ zKE-p+Ci5Xn6E83Rx9ql!Ls5Y9$-~EX#8~pB?f;|pP|nYqDdtl+IhAsLeQclM>ytbF z>-w{w>y>ByNS<%W{MpBO^Qraix0Grl7@@AK^ATpJXMdgSA;lfCn|`TS6n zC11{e>qW`_=li2R$K&a*A$Ywd1lQbN+&cHaXD?b80%!LSm z_P`<`C^jMlBUB-nb}0law*Gg1k8EQIT22YUWww3NrV#Az5rWo@y!dzQqrF1#?b#5F zOC5@puR`FHjeY`s6A%6s`)*dQ`Me)2P8W*uh7h!g3qdR1i#&K={$*Ro*GF4JAm?|D zWWRlB{A0I-pyJ~TD8EsMjcxVV+)mB}^_c>XGn=qlYs9W& z#w7eJ_AI`CT&NMp8ki8NRpOfyN<Tq?D2CHgb#)kQqvGcpj_(miDDAB&P63f3= ze$d`IY{$ynCN%Rg!Thrc-2;>eTpk9?a5)-el4Iyr4c4BBM9ip2OzISg!DAwmUXQF4 zhC>ZynA%l_&95SG=UX%8hDG5{OcYA=Fk|3l9USX)czjrg(Fcs!n8}3odvs`YQkT@; zUc`%hz3U|%hE&%hQ>+>{>&c)TEJMWuGW7XH2IHOxJm7Ug3!2gVRuty-(ZTaM&+n~x ziWsCrZ@UF^Dp~Q(JqyAt7R*YeK)zE7#C&bQ*?k6#l^IYolMz>}2FxkJK4iZYaHho}uQe zM<_h{A;OA3gelmIpR?!k_0(A&V$;nBShD&xa(91&!PDL#yYmfBEPVsrj5p}`?VAtU zlia=xjvL6)ISL`KWq*u!PmZ^nEA|g;KP=>-!Oo;L`BV#^u5}!Qiu~TO;|G}TTnTz=w-6NgC2hTUHj!73rx2x*p|wQc1^6Z}RVYGL?gb<@TDzN@*1#WgzV8=HKJPcA` zC(&a+Nvp=T(+14qd|DK2Ou{OhUuR4P+{$5uo0#d00kfkFXy3yKMKL3~T~px_*DcR{ ztG-@|Gdd-vwe+qpp7~a?W*G7|3d8r`hhfK=f1PhB=bwt#8Qe*UCWDn&T1AOV_stk$ zw4h)XD<0bPm^jmbpNoWJU&rvI`CD+D28+Ja;ODP3SV)xYf4)D)HPRqgnkc-EH{oc} zD7+!wjx_ya_OJvK>YOuSy48d<(I%8!V8Pz((I`A87R6Pu7%)8+XZv{ZOZKZ@V=>$v ziyw}~;*d5L`=Vk{s+A2_e>CFG1_QG4+W*Aw31IurT{htdUO&b+3R$a~VaaGiaD4~v zjCG)LB?nsNbl_X!m+XR`*QYs9k)K;c?6lX8kPTYodoD-0L2_tj$`Kdg#V^@eX2{XC z2YrU2a%3%`M$lCiP88KZwp4@BQ5r-Lr;YtrTg|`2puwB@8o0V^aQm?VBYDql@BZ}o z7vS&i|6LR&G>pQdCrT74s6dWgGJLZq41Qa9|0tlq(cF3%PiRo!t`R2{Rw%!PJ>h#~=@|M8U^CV!7Wtq;BvIi=Mv4EAv|{CVt9R zJ$Q@luD4j(GC*Wr9VD7g2@(@V1_{NEAR&(m5JwLBiM#duL?)e&@U*7@+ZS=nN1P1z z5zae4qUL)6-YIp+Ma_N(_pU<9HVt>PLj5OV$XS3JXWy4dK|n zJse*xBlmueMEhBC>|Vz4bIUP^<9LhMxlAxs3bnsD;0%eT)$O?qcE^^6pmjvVN$pW z@lUN-+SGxJ0ZycHx?p+iO5%e^7Y)DrE_l$xk5Ab*?zzx{yjjyT8V|mThB0F_{UGo7 zt~N%aMIQPI>5Z7&!i&eR>+xWn8siew$gx$8`?J0HIXir=8uLb|(eAh!{=_To)Cl+o z?Mu9V_kL>n!D@sMw>0yj$IkK{|K(GoWK}f=jZ@?Ca}{L%Ce-?l>j&qH2X7TKA^ScH zW*97Z{F?=nhgooQDQ$-Z=QdfO;lK6K7Gx`E#bDxzw-&6_>2b%$fL0-TB<$DY^hG`1 zeyxSkp+Q@#20Jrpljhrvh)85R5ROH$oNw>Kv3gB7CWvr!TBbzJcnwCJ{cyf{=HDT% zcl!=$Q2w?CXD4xOFKxrOwQcBDEE>CWM5A?hG%ijx;?^QLE|ihMrj)_Aqbh0so}o{E z!V!fTTpN!QCHwz>{qbaT6b`3zqDCGkX5EUzz-@6@H7gE-h=0f4=ZM4YpKO?wXh!!% z2HpeyJABD*jl$H{R*ZXTMgEyiWP%eJ3VHEw*$teim4^5A5=LCSDo3663ankjb(=UB zioa}s%e~86t{Fd!)1uXBEjoS%?pi!&w&>fDv zg~Cy$MmXZfha>CL2xMfN?;g@3E&b*WO>8hPw_(O%8^WG=@vqp0cG!|WzbZzHl_5$T z$f3mI%MnN`=Y6Sx0<~A^lhy-O0iKnaby$BynbcqFSAY0>(>FCh7Gy@8QJvJj(ro9G zuOsk%nBtHAY1dkdKHOLK?L+_m#E0!|ango_@jSPvtmo&|DAhXxWwOYi*Q@ZfxEf`% z>v3+n3iCEA(I8HVhHI4A);$v4_eLbOXJBdtDs$g@xQH`}AHG$bP*!ly>g+CsN z#(GUOCT4S^7uVW$c{G^qHX{2$D@1=Q@{PBmUJlbA{b3ra!J{@2N&P)ydIYKrh`?~7 zr~g%1B9U&<=lOKIrv=^LM5Ar4Xl&C)FwLEFU7L~8qKGavV`O#Mx zs`!f5#ALfvbzf1vou4St$zRm0=r6_=@E0|RpRyBWzGCIgcgW=9Bc2xb5gCd7Vm@z2 zm-7`*3I~WZ=~9Wxl~Re|f~iFRngL=`^Y`DMvOV$!zG6UGACY|he8F#UQEx}P&ff9f zc1nqEzVwB@k^j+Ow}(dH;FL)AZzPUa`t$i)rlJC_`nsg?EZM|}2K0-nH1zVtvz~<2 zcA`XX+b75O;EY3 zmnv5>L37WDPA?2-FznOo@1Fiz96hPPmDk*d)l{M-_hs&J@8?(Ye9P^ONP7Kvz7N;4 zPp#*(TWC>uzA0(_(!Tg`yywK2ae9jq*WHo4zeFOSfE*WRzn{ND+nCWIvl#`Ra=%BE z?EiQBV;;{2j*K&-=MUUx53!@vNIP_W<8ib=JhZYnRMd|udzeOd>~9x}r{){JQbRj6HB zfnRtIQ}|Z}W{+23QDA>v6{)UW|XO2Y3W;JRx)uA#u)OoA{ZDW-fsa7JI@xvAl zC9GeofORT7T&Bg9M_SYyZ^j_TDt$}J5HLC%O{d6kxsehp^;$Hi|LN(EJ^QrCbkYFh zZ5#TQx8pk7XI0oR@1hN3Pnl8GSBKr%)fl@v5_NyB2*k94rRS2LD zID+T=S-(?a=7UJ&xfg+&Mg=yybuiy?V9Y=#dW?2r;d%$U>aAGKcwUbb{8ZnM!dF?X zXvz0YE9pi=Vl>+LxN)(A4Y}Vc(5a^aqkiW@k>!kA@Hf9*qK8K1M8>gB)ZV~;?rlM} zmfT8NIak#kJPs|(ZD|&4675?LW#n}E{^w=9G`HFUJ z{DkQ1FB&fN7fpNliy5u_MKfZuE&s`1-2K5{9Bt?$_R#-1Q;=s%m3+ikoqR-5Vt5KW zBkfHAxMHL2(;u&Hr_Y?G`FEeHv8W4$f4I>e8T7m70 z6i}~Jz-d(=mg5%9`FScrfr~*(tO!wI%sd@tGKPEm8yEIDoX8sLMEk8=FF2m_rf@xL z<;32qPW-aOj_+%mQC=T~WogVw&u7CuyA>TmtVx(`A7+1T-(^MJyL@er73u|6 zbR>Fg$416Cr*jXq$%QGoDkJce*lS}1d`@zHJ&C}f6A{?FJp$jDz4L3E zRSs)_4h^`s%+9%X<`e68wG~pF zDr_oDUq6QN=fFtFC#sP-iuZ@ZS~OXvhk0u(Y{$*mHq?x6^tHAVCHwz=e-s>MM(A|r zg>0Zt5@*J^lUDSJwBqP?E5csJqrj1PY%UUydG+IQXF@!7REo#N9A5mC{eZ7eh>e5W zFCKl@#-gUqjn%wIE_hsR+v$=1N|!APybW=I7q%-o^3{Dl^KhcSzTm_PrxV?CxlqXHM7ons6eK3w6;C+PdkOcSb|=~#cH&ZN8|wGAVc=fI z%5E{vQ$m4Xn<-E%j}mk33JftT@bhEF8!9u_M4adNSNq;01;XkpQJL%X%UnuaW4_C& zaw?Ros>9pjI@HUl!`E$e$eU4zgO9Z+L~Qz#E(tw$I@*&u>9C}T4i}h@v9*mJbsw7% ze}ukoS2J8A-uK_~)@IDCY{oJ6X`Ky59I_a(esVY(PK|)(tPJJ0$nZ2yh6v{Tv>d5J z`SJ8a*p6+@47lR3<3MFQD%YhSJmy)`z)LjLp5Apu*geDlE;U!dvD6S!XksA&(3_ z@5rGaY{tr&Mm%Po)~(QRbeN&WzWL0>%B909_D5`H9kP$o;lMi^-d3~Y#_#PtP}Pnt z3v77Omg`$V9ej8We>J-dD@-!{>Zd^k#ywKsSL5OVGk(pXLjG#}S4f4syOhYnysNd$ zuUXJniBS3+xhuKwW0Vv14>|G8IS0BdHe=oZ=0~Jh&x%bUch6aHW2hSq4!AM7s~ZLD zxKXvE8-{UibZn}HgYl@G!qq< z#j&Sutli1E(%p?xHQd;m$ULhwI+R<<-+R-FbqB1N{#=WFK3=|5N~^;>#=HuoXMRvB z8ESqb!+hqDq;yXq_I^Lq{a{`gQ|v1OmHQ2pj3+&SJt(Vy|gGjC!3T?mOldEot$d@w9JvNX4r(xrSRoC4=ilw7#B5(_(TwpZ7jp_q5ucaQ zqU7)P5yqAi-{~;@0%O`+z4$3RwS{?L8*J#&lQDbt zW%NlcChVmz<;R@1IyzM4y6QA*k@|%eKdsf^={oL7&PSj+W8>vo%8;M)=T^}B`Q({b z9(!v+<|R&+VfrcN?hTK`j+V^1-W9%I=q~vLznV;bjfbS|9_z9upr9%q#Sg|O;iv3*m*TNEo2Hpih+|SGj|F!hno&Bv1^)>?3}M^1Jf$y@&4RUyEqFcMf<==o zh_t)#`nn4@M$oTn<-)f^U8s4;1zkTEb~bTAPxRQC>oTvQunWEoT-epZi9KnYICa#4 ze$3anR7?pGufQ(GOGYvey9m!)%Fb27!JObT%&i`#P~tQ(rERCZYrGOUmMdY5QsUJW zB`iiIb3XXqY|JY%>X3^0(F*28x4f-Gwe9q6<}&|(V-9X zTeIfXqwGi%TGqFqKwb+*r0BoSH? zcYYO4W>TY?T!jpb72Z22!@%qcX#1$JWmPohkM{Cod2bhfVot{FxAbRItY@8qEhzVr zc^q5Zn0v*I-SmkRHDh>Y@5ZG=ZcO^cg|CCP$jtr3>IlZ$2B|Rqd=zfXb1|38gI{d)7bx7{ACL6<#R3`%du;AJ+HEpCH>{+5R? zG31M54*Tav1s2?uq4aT{$*h&30CDpp8JeG>-&jS9798)C{7UBAX7cdiau-g%b7STl zH!xd+<*U?K$Md`*2089-*5UOy9qN{Of{p{2TUEhNR4?EsoW#)`{e+8HiFS^Pexmar ze~~wTfT)``KotKfKy`Nt1yM4v!ul+>A@83VTw4dnt%2zDv<|AxV z-eG0kcQ{h)9qKc;%eLkn>JoQ-WDjWk6y4`VL#0t-$^j+RoU3^!tB{JZ_`=j z%)!x^6XwFQNiH1b`cb!|3$yyW(DD{@0?slof_p>H_^nZ!F~QEW+bq1#w6&oAaq?oV z1;2FWIr+jEtoktqrysa+z$XUx`2Q9h*JnmIh8WyX=ZeAgW6^k4k-qt3O%h**(I+oh zUWhPRfqitT4b$n5wwY?f{$4h;CjK4!)nvA_B=Z=rSh0w?q8{|v>AA1E$NgfO);e@^ z(dSvK!;C39XxDi8Z&}0|67J3JE!3gTY6B2!v9I)A6f@niI6>F+YbqY5tXV>TuK3)&M;gJTl?N0DqCbs-HOf zJO4fTDH|i0-?!I-4aEPJeVuhTM&Cr{gV0A13|L@yl-1@&fU*24{pa##5`u33_M_tx1F(>oSzCU2Bp7}=( z3|{BJROWFHA^s(MvI8aKbbnlb=hw{TZ_Raqah8eMw8+JM@iRZ`AM?Eu`?u*ZHHOWn zpTqpG`#kS1QZN!7hj{Z{(!Nk8^>+!zZ{nFZ_2TU zdVlPXdgNrySn~BJh4bA1w1zqR%;8|ZhPi_Y!9Cu$XO=M%#kgi(e6C0u|6EJF-=EAU zD{HnsHQ#QGv{K(G7Bf!A;O@GZB=p!l=f+@L2Q6Ob)}bWN9edZbMt9`uYy zvi*cU`j`0U|C>9h{q=IiCbd_ySdN$LIHrviN&T6-2z~HEuee|L6Aj}0ga`FIy_jr2 z+U6%tzV;Uyb$}SOH9(AA;>DD<`FMa>yT(`4Vh-1F#`0g*Z z0MDNp2ibf=&U{xnwh(J)<2h>o_xFz(y0Z3$4!Nrf4M&%vHvvr65(S>z}?dvJADG0_DsZbF_(VC zTGkZbFxn8MaiP}@7sjuQ#?j`{cv_1-Rp)3N-yV(U#3w)S-|%SoF!y-p<7n)E9gWmG zSU1D^)>Sq&HcU}r-wqXXja0ZjRfV{oD#T7w;Tm%-^u*}SDr6t4LY^}!80j-z{+91; zuEO!fDokNs`9YosHTssh+N|#?Gn;2qBlLK_K#z5LJ#sA6BmWdV+OE;#jZ=>{#6y$c z+xMA=GlHM1!S~hL%DnG(dfcsI#_Gwe&kf@lA8Yep8+abYT5M1MrA}|f>xUN1Ol!pi zixq2@Ska61YqM5FqSLiVjM*T=>%KB%<9W}{ta?~y>9Him_xI%Yw;H9#;zfF_=HGv2 zZsql_=vSSkuav_H=pAUtScf2f%I@NHV0}g>2A+(az0wIGbO?HO3V z#yCd$b|&mxZ^5#LR>(RrPCHVA^940%u2AD@Y7P42l%q>}IYuvGUKIVZ8AVk%m`#P7 zLWu`En3KdYRW6RkH(jEUrA{=Q{i5-Xxd}!0>5-c4KJt6}M@)3!$yNv2{odY}2@Z@Z zZNjQB_J6z@g>%tA=o^U#YQ|LVYIr_n#?o0942jTVA^ok#IyEYsR-?;O)=fR;nOpxz z{KQ=M$TAkhOpL}Oet&dJa)&jfe8k_&4_NCyItChd3{WW+$8N=7r6vYtddI?K zu%T-=o=?`KmO~yp3ZAwj!(!%Fzq6w^&jvN&R%k+;_}2V<_2D7fjVA;)B++kjRHrBPP84FMS zf;FZq>8JBO_b$9aKl(RkZ}^EtS^dQsqL2N(UHYn@=vq5Kd}pL@^)^7HVr^fBumBN6 z^w^K=0peUgKM}guS2R}pikPjwqWMxUrnKuYmuvoR=2Y$V7c*C;7JK)k7Fq{=EE(gB zFZ_i2_wT=P+fSSy%X75Zj5W^l5$T!3wYIU3@F51w^x~)NV7|U@s*l*v(nmbwSy#16 za>#l|V_XN;*)@npwqDT~;f`j`v=c$hfv!4~b$lHEjyxwA%Ju6$*P%*`;r_J8f-wgy zNHZ@6kEh3AlqCj3&&FUp$IZis^bcd;7axQ9sbkSY5sM?sVzFhe2_dVQZ`x3g`lEF) zGAE!ZV@oG_{xOC)gy$}PKQcFm=h^Y~dG7R;4pEHHw&dSWZ_uLcbQ_vnvSCpWeWy39 zwQg(2uHjyO*@xNDV6YwC=h|^aOO6m%(;iDqYqw+OGCNL<@uJ7>u+NTTA$H{FdGz`G zjwEbE`$9a=w9IB!HW;w4i~;=`Fz