diff --git a/mosaic/comms/comms.py b/mosaic/comms/comms.py index 8fec0d9c..7b26350c 100644 --- a/mosaic/comms/comms.py +++ b/mosaic/comms/comms.py @@ -1883,7 +1883,7 @@ async def process_msg(self, sender_id, msg): sender_id, method, msg.reply, **msg.kwargs) - if comms_method is not False: + if comms_method is not False and future is not None: try: await future except asyncio.CancelledError: diff --git a/mosaic/comms/compression.py b/mosaic/comms/compression.py index 604584bc..e75a7af4 100644 --- a/mosaic/comms/compression.py +++ b/mosaic/comms/compression.py @@ -216,7 +216,6 @@ def maybe_compress(payload, min_size=1e4, sample_size=1e4, nsamples=5): 4. We return the compressed result """ - if isinstance(payload, pickle.PickleBuffer): payload = memoryview(payload) diff --git a/mosaic/core/task.py b/mosaic/core/task.py index c59b9c42..7533702c 100644 --- a/mosaic/core/task.py +++ b/mosaic/core/task.py @@ -184,7 +184,7 @@ async def set_result(self, result): if not isinstance(result, (tuple, dict)): result = (result,) - min_size = 1024**2 + min_size = 1024**1 if isinstance(result, tuple): async def store(_value): return await self.runtime.put(_value, reply=True) @@ -272,91 +272,6 @@ def add_profile(self, profile, **kwargs): kwargs['tessera_id'] = self.tessera_id return super().add_profile(profile, **kwargs) - async def __prepare_args(self): - """ - Prepare the arguments of the task for execution. - - Returns - ------- - Future - - """ - - awaitable_args = [] - - for index in range(len(self.args)): - arg = self.args[index] - - if type(arg) in types.awaitable_types: - self._args_state[index] = arg.state - - if arg.state != 'done': - if not isinstance(arg, TaskDone): - self._args_value[index] = None - self._args_pending.add(arg) - - def callback(_index, _arg): - def _callback(fut): - self.loop.run(self._set_arg_done, fut, _index, _arg) - - return _callback - - arg.add_done_callback(callback(index, arg)) - - else: - async def _await_arg(_index, _arg): - _result = await _arg.result() - _attr = self._args_value if not isinstance(_arg, TaskDone) else None - return _attr, _index, _result - - awaitable_args.append( - _await_arg(index, arg) - ) - - else: - self._args_state[index] = 'ready' - self._args_value[index] = arg - - for key, value in self.kwargs.items(): - if type(value) in types.awaitable_types: - self._kwargs_state[key] = value.state - - if value.state != 'done': - if not isinstance(value, TaskDone): - self._kwargs_value[key] = None - self._kwargs_pending.add(value) - - def callback(_key, _arg): - def _callback(fut): - self.loop.run(self._set_kwarg_done, fut, _key, _arg) - - return _callback - - value.add_done_callback(callback(key, value)) - - else: - async def _await_kwarg(_key, _arg): - _result = await _arg.result() - _attr = self._kwargs_value if not isinstance(_arg, TaskDone) else None - return _attr, _key, _result - - awaitable_args.append( - _await_kwarg(key, value) - ) - - else: - self._kwargs_state[key] = 'ready' - self._kwargs_value[key] = value - - for task in asyncio.as_completed(awaitable_args): - attr, key, result = await task - if attr is not None: - attr[key] = result - - await self._check_ready() - - return self._ready_future - async def prepare_args(self): """ Prepare the arguments of the task for execution. @@ -973,7 +888,6 @@ def _deserialisation_helper(cls, state): if instance.state == 'done': instance.set_done() - # TODO Unsure about the need for this # Synchronise the task state, in case something has happened between # the moment when it was pickled until it has been re-registered on # this side diff --git a/mosaic/file_manipulation/h5.py b/mosaic/file_manipulation/h5.py index a55cad8b..235409fe 100644 --- a/mosaic/file_manipulation/h5.py +++ b/mosaic/file_manipulation/h5.py @@ -123,7 +123,7 @@ def _write_dataset(name, obj, group): dataset.attrs['is_str'] = isinstance(flat_obj[0], str) -def read(obj, lazy=True, filter=None): +def read(obj, lazy=True, filter=None, only=None): if isinstance(obj, h5py.Group): if filter is None: filter = {} @@ -137,6 +137,8 @@ def read(obj, lazy=True, filter=None): if obj.attrs.get('is_array'): data = [] for key in sorted(obj.keys()): + if only is not None and key not in only: + continue try: value = read(obj[key], lazy=lazy, filter=filter) except FilterException: @@ -145,6 +147,8 @@ def read(obj, lazy=True, filter=None): else: data = {} for key in obj.keys(): + if only is not None and key not in only: + continue try: value = read(obj[key], lazy=lazy, filter=filter) except FilterException: @@ -212,7 +216,7 @@ class on its own, or as a context manager, >>> with HDF5(...) as file: - >>> file.write(...) + >>> file.dump(...) If a particular version is given, the filename will be generated without checks. If no version is given, the ``path`` will be checked for the latest available version of the file. @@ -258,11 +262,15 @@ def __init__(self, *args, **kwargs): file_parameter = camel_case(parameter) version = kwargs.pop('version', None) + version_start = kwargs.pop('version_start', 0) extension = kwargs.pop('extension', '.h5') if version is None or version < 0: - version = 0 - filename = _abs_filename('%s-%s%s' % (project_name, file_parameter, extension), path) + version = version_start + if version > 0: + filename = _abs_filename('%s-%s-%05d%s' % (project_name, file_parameter, version, extension), path) + else: + filename = _abs_filename('%s-%s%s' % (project_name, file_parameter, extension), path) while os.path.exists(filename): version += 1 filename = _abs_filename('%s-%s-%05d%s' % (project_name, file_parameter, version, extension), path) @@ -297,9 +305,9 @@ def file(self): def close(self): self._file.close() - def load(self, lazy=True, filter=None): + def load(self, lazy=True, filter=None, only=None): group = self._file['/'] - description = read(group, lazy=lazy, filter=filter) + description = read(group, lazy=lazy, filter=filter, only=only) return Struct(description) def dump(self, description): diff --git a/mosaic/runtime/monitor.py b/mosaic/runtime/monitor.py index 0e2b77f7..3c771325 100644 --- a/mosaic/runtime/monitor.py +++ b/mosaic/runtime/monitor.py @@ -145,7 +145,7 @@ def start_node(*args, **extra_kwargs): self._comms.start_heartbeat(node_proxy.uid) - self.logger.info('Listening at ' % num_workers) + self.logger.info('Listening at ' % num_workers) async def init_cluster(self, **kwargs): """ @@ -233,8 +233,8 @@ async def wait_for(proxy): self.logger.debug('Started heartbeat with node %s' % node_uid) self.logger.info('Listening at ' % (0, num_nodes, num_nodes, num_workers, - ', '.join(node_list))) + 'WORKER:0-%d address=%s>' % (0, num_nodes, num_workers, + ', '.join(node_list))) def init_file(self, runtime_config): runtime_id = self.uid diff --git a/mosaic/runtime/node.py b/mosaic/runtime/node.py index 80553524..5764c5bd 100644 --- a/mosaic/runtime/node.py +++ b/mosaic/runtime/node.py @@ -99,15 +99,15 @@ async def init_workers(self, **kwargs): for worker_index in range(self._num_workers)} allowed_cpus = sum([len(c) for c in available_cpus.values()]) + # Eliminate cores corresponding to hyperthreading + for node_index, node_cpus in available_cpus.items(): + node_cpus = [each for each in node_cpus if each < num_cpus] + available_cpus[node_index] = node_cpus + total_cpus = sum([len(c) for c in available_cpus.values()]) worker_cpus = {} worker_nodes = {} if total_cpus <= allowed_cpus: - # Eliminate cores corresponding to hyperthreading - for node_index, node_cpus in available_cpus.items(): - node_cpus = [each for each in node_cpus if each < num_cpus] - available_cpus[node_index] = node_cpus - node_ids = list(available_cpus.keys()) num_nodes = len(available_cpus) num_cpus_per_node = min([len(cpus) for cpus in available_cpus.values()]) diff --git a/mosaic/runtime/runtime.py b/mosaic/runtime/runtime.py index 4ec57d8c..f4b43444 100644 --- a/mosaic/runtime/runtime.py +++ b/mosaic/runtime/runtime.py @@ -1,6 +1,5 @@ import os -import gc import zmq import zmq.asyncio import psutil @@ -216,9 +215,6 @@ async def init(self, **kwargs): else: self._local_warehouse = self._remote_warehouse - # Start maintenance loop - self._loop.interval(self.maintenance, interval=0.5) - # Connect to monitor monitor_address = kwargs.get('monitor_address', None) monitor_port = kwargs.get('monitor_port', None) @@ -235,6 +231,13 @@ async def init(self, **kwargs): if profile: self.set_profiler() + # Start maintenance loop + if self.uid == 'head' or 'worker' in self.uid: + maintenance_interval = max(0.5, min(len(self._workers)*0.5, 60)) + else: + maintenance_interval = 0.5 + self._loop.interval(self.maintenance, interval=maintenance_interval) + async def init_warehouse(self, **kwargs): """ Init warehouse process. @@ -1025,7 +1028,8 @@ async def put(self, obj, publish=False, reply=False): else: warehouse = self._local_warehouse warehouse_obj = WarehouseObject(obj) - self._warehouse_cache[warehouse_obj.uid] = obj + if self.uid != 'head': + self._warehouse_cache[warehouse_obj.uid] = obj await warehouse.put_remote(obj=obj, uid=warehouse_obj.uid, publish=publish, reply=reply or publish) @@ -1045,7 +1049,7 @@ async def get(self, uid, cache=True): ------- """ - if not cache: + if self.uid == 'head' or not cache: return await self._local_warehouse.get_remote(uid=uid, reply=True) obj_uid = uid.uid if hasattr(uid, 'uid') else uid @@ -1198,7 +1202,6 @@ async def maintenance(self): self._maintenance_msgs = {} await asyncio.gather(*tasks) - gc.collect() def maintenance_queue(self, fun): """ diff --git a/mosaic/utils/utils.py b/mosaic/utils/utils.py index 60fd3438..2901ab76 100644 --- a/mosaic/utils/utils.py +++ b/mosaic/utils/utils.py @@ -32,7 +32,7 @@ def sizeof(obj, seen=None): return 0 try: if hasattr(obj, 'nbytes') and isinstance(obj.nbytes, int): - size = obj.nbytes + return obj.nbytes else: size = sys.getsizeof(obj) except Exception: @@ -84,18 +84,17 @@ async def remote_sizeof(obj, seen=None, pending=False): if isinstance(obj, asyncio.Future): return 0 if isinstance(obj, mosaic.types.awaitable_types): - size = await obj.size(pending=pending) + return await obj.size(pending=pending) else: + try: + if hasattr(obj, 'nbytes') and isinstance(obj.nbytes, int): + return obj.nbytes if not pending else 0 + else: + size = sys.getsizeof(obj) + except Exception: + size = sys.getsizeof(obj) if pending: size = 0 - else: - try: - if hasattr(obj, 'nbytes') and isinstance(obj.nbytes, int): - size = obj.nbytes - else: - size = sys.getsizeof(obj) - except Exception: - size = sys.getsizeof(obj) if seen is None: seen = set() obj_id = id(obj) diff --git a/setup.py b/setup.py index d081b820..31d189d0 100644 --- a/setup.py +++ b/setup.py @@ -58,6 +58,7 @@ 'mscript=mosaic.cli.mscript:go', 'mprof=mosaic.cli.mprof:go', 'findomp=mosaic.cli.findomp:go', + 'plot=stride.cli.plot:go', ] }, zip_safe=False, diff --git a/stride/__init__.py b/stride/__init__.py index 044f0563..f8e4178c 100644 --- a/stride/__init__.py +++ b/stride/__init__.py @@ -101,6 +101,8 @@ async def forward(problem, pde, *args, **kwargs): if not isinstance(shot_ids, list): shot_ids = [shot_ids] + num_shots = len(shot_ids) + submitted_shots = [] published_args = [runtime.put(each, publish=True) for each in args] published_args = await asyncio.gather(*published_args) @@ -116,10 +118,15 @@ async def forward(problem, pde, *args, **kwargs): async def loop(worker, shot_id): _kwargs = kwargs.copy() + num_submitted = len(submitted_shots) + logger.perf('\n') - logger.perf('Giving shot %d to %s' % (shot_id, worker.uid)) + logger.perf('Giving shot %d to %s (%d out of %d)' + % (shot_id, worker.uid, + num_submitted, num_shots)) sub_problem = problem.sub_problem(shot_id) + submitted_shots.append(shot_id) wavelets = sub_problem.shot.wavelets if using_gpu: @@ -143,6 +150,8 @@ async def loop(worker, shot_id): # save data shot = problem.acquisitions.get(shot_id) shot.observed.data[:] = traces.data + if np.any(np.isnan(shot.observed.data)) or np.any(np.isinf(shot.observed.data)): + raise ValueError('Nan or inf detected in shot %d' % shot_id) if dump is True: shot.append_observed(path=problem.output_folder, @@ -213,10 +222,12 @@ async def adjoint(problem, pde, loss, optimisation_loop, optimiser, *args, **kwa f_min = kwargs.pop('f_min', None) f_max = kwargs.pop('f_max', None) - filter_wavelets = kwargs.pop('filter_wavelets', True) filter_traces = kwargs.pop('filter_traces', True) + filter_wavelets = kwargs.pop('filter_wavelets', filter_traces) - filter_wavelets_relaxation = kwargs.pop('filter_wavelets_relaxation', 0.75) + fw3d_mode = kwargs.get('fw3d_mode', False) + filter_wavelets_relaxation = kwargs.pop('filter_wavelets_relaxation', + 0.75 if not fw3d_mode else 0.725) filter_traces_relaxation = kwargs.pop('filter_traces_relaxation', 0.75 if filter_wavelets else 1.00) @@ -236,6 +247,9 @@ async def adjoint(problem, pde, loss, optimisation_loop, optimiser, *args, **kwa filter_relaxation=filter_traces_relaxation, len=runtime.num_workers, **kwargs) + step_size = kwargs.pop('step_size', optimiser.step_size) + keep_residual = isinstance(step_size, LineSearch) + platform = kwargs.get('platform', 'cpu') using_gpu = platform in ['nvidia-acc', 'gpu'] if using_gpu: @@ -340,10 +354,11 @@ async def loop(worker, shot_id): # calculate loss fun = await loss(modelled, observed, + keep_residual=keep_residual, iteration=iteration, problem=sub_problem, runtime=worker, **_kwargs).result() - iteration.add_fun(fun) + iteration.add_loss(fun) logger.perf('Functional value for shot %d: %s' % (shot_id, fun)) # run adjoint @@ -356,9 +371,98 @@ async def loop(worker, shot_id): await loop + async def step_loop(): + iteration.next_run() + + published_args = [runtime.put(each, publish=True) for each in args] + published_args = await asyncio.gather(*published_args) + + @runtime.async_for(shot_ids, safe=safe) + async def loop(worker, shot_id): + _kwargs = kwargs.copy() + + logger.perf('\n') + logger.perf('Giving shot %d to %s (%d out of %d)' + % (shot_id, worker.uid, + iteration.num_submitted, num_shots)) + + sub_problem = problem.sub_problem(shot_id) + iteration.add_submitted(sub_problem.shot) + wavelets = sub_problem.shot.wavelets + observed = sub_problem.shot.observed + + if wavelets is None: + raise RuntimeError('Shot %d has no wavelet data' % shot_id) + + if observed is None: + raise RuntimeError('Shot %d has no observed data' % shot_id) + + if using_gpu: + deviceid = devices[worker.indices[1] % num_gpus] + if platform == 'nvidia-acc': + devito_args = _kwargs.get('devito_args', {}) + devito_args['deviceid'] = deviceid + _kwargs['devito_args'] = devito_args + elif platform == 'gpu': + _kwargs['deviceid'] = deviceid + else: + raise ValueError('Unknown platform %s' % platform) + + # pre-process wavelets and observed traces + wavelets = process_wavelets(wavelets, + iteration=iteration, problem=sub_problem, + runtime=worker, **_kwargs) + await wavelets.init_future + observed = process_observed(observed, + iteration=iteration, problem=sub_problem, + runtime=worker, **_kwargs) + await observed.init_future + processed = process_wavelets_observed(wavelets, observed, + iteration=iteration, problem=sub_problem, + runtime=worker, **_kwargs) + await processed.init_future + wavelets = processed.outputs[0] + observed = processed.outputs[1] + + # run PDE + modelled = pde(wavelets, *published_args, + iteration=iteration, problem=sub_problem, + runtime=worker, **_kwargs) + await modelled.init_future + + # post-process modelled and observed traces + traces = process_traces(modelled, observed, + scale_to=sub_problem.shot.observed, + iteration=iteration, problem=sub_problem, + runtime=worker, **_kwargs) + await traces.init_future + modelled = traces.outputs[0] + observed = traces.outputs[1] + + # calculate loss + fun = await loss(modelled, observed, + keep_residual=keep_residual, + iteration=iteration, problem=sub_problem, + runtime=worker, **_kwargs).result() + + # clear up + # await pde.deallocate_wavefield(deallocate=True, runtime=worker, **_kwargs) + fun.clear_graph() + + iteration.add_loss(fun) + iteration.add_completed(sub_problem.shot) + logger.perf('Functional value for shot %d: %s' % (shot_id, fun)) + + logger.perf('Retrieved test step for shot %d (%d out of %d)' + % (sub_problem.shot_id, + iteration.num_completed, num_shots)) + + await loop + await optimiser.step(iteration=iteration, problem=problem, f_min=f_min, f_max=f_max, filter_relaxation=min(filter_wavelets_relaxation, filter_traces_relaxation), + step_loop=step_loop, **kwargs) if dump: @@ -366,8 +470,16 @@ async def loop(worker, shot_id): project_name=problem.name, version=iteration.abs_id+1) + if iteration.prev_run is not None: + prev_loss = iteration.prev_run.total_loss + prev_loss = ' [previous loss %e]' % prev_loss + else: + prev_loss = '' + logger.perf('Done iteration %d (out of %d), ' - 'block %d (out of %d) - Total loss %e' % + 'block %d (out of %d) - Total loss %e%s' % (iteration.id, block.num_iterations, block.id, - optimisation_loop.num_blocks, iteration.fun_value)) + optimisation_loop.num_blocks, iteration.total_loss, prev_loss)) logger.perf('====================================================================') + + iteration.clear_run() diff --git a/stride/cli/plot.py b/stride/cli/plot.py new file mode 100644 index 00000000..fa6ed15e --- /dev/null +++ b/stride/cli/plot.py @@ -0,0 +1,62 @@ + +import click + +from stride import plotting +from stride.problem.data import * +from stride.problem import Acquisitions, Geometry + + +def _intantiate(filename): + try: + return ScalarField(name=filename) + except AttributeError: + pass + try: + return VectorField(name=filename) + except AttributeError: + pass + try: + return Traces(name=filename) + except AttributeError: + pass + try: + return SparseField(name=filename) + except AttributeError: + pass + try: + return SparseCoordinates(name=filename) + except AttributeError: + pass + try: + return Acquisitions(name=filename) + except AttributeError: + pass + try: + return Geometry(name=filename) + except AttributeError: + pass + + +@click.command() +@click.argument('filenames', required=True, nargs=-1) +@click.option('--range', nargs=2, type=int, + help='range of values to use for plotting') +@click.option('--cmap', type=str, + help='colourmap to use for plotting') +@click.version_option() +def go(filenames=None, **kwargs): + axis = None + data_range = kwargs.pop('range') or (None, None) + colourmap = kwargs.pop('cmap') or 'viridis' + for filename in filenames: + field = _intantiate(filename) + field.load(filename=filename) + + axis = field.plot(data_range=data_range, palette=colourmap, + axis=axis, plot=False) + + plotting.show(axis) + + +if __name__ == '__main__': + go() diff --git a/stride/core.py b/stride/core.py index 927cfb08..2f667b02 100644 --- a/stride/core.py +++ b/stride/core.py @@ -2,6 +2,7 @@ import uuid import asyncio import inspect +import numpy as np from abc import abstractmethod from collections import OrderedDict @@ -502,6 +503,21 @@ async def __call_adjoint__(self, grad, **kwargs): if grad is None or not self.needs_grad or self.grad is None: return + grad_data = grad.data if hasattr(grad, 'data') else grad + is_nan = np.any(np.isnan(grad_data)) + is_inf = np.any(np.isinf(grad_data)) + + if is_nan or is_inf: + msg = 'Nan or inf detected in %s' % self.name + + problem = kwargs.pop('problem', None) + shot_id = problem.shot.id if problem is not None else kwargs.pop('shot_id', None) + if shot_id is not None: + msg = '(ShotID %d) ' % shot_id + msg + + mosaic.logger().warn(msg) + return + self.grad += grad def __repr__(self): diff --git a/stride/optimisation/__init__.py b/stride/optimisation/__init__.py index f990c007..8cb9831a 100644 --- a/stride/optimisation/__init__.py +++ b/stride/optimisation/__init__.py @@ -5,3 +5,4 @@ from .optimisers import * from .optimisation_loop import * from .pipelines import * +from .step_length import * diff --git a/stride/optimisation/constraints/chambolle_TV1.py b/stride/optimisation/constraints/chambolle_TV1.py index b79bef9d..f0d6b3f5 100644 --- a/stride/optimisation/constraints/chambolle_TV1.py +++ b/stride/optimisation/constraints/chambolle_TV1.py @@ -84,7 +84,7 @@ def _project(self, variable_data, **kwargs): norm_before = np.sqrt(np.sum(variable_data**2)) + 1e-31 variable_data = denoise_tv_chambolle(variable_data, weight, - eps=tol, n_iter_max=max_iter) + eps=tol, max_num_iter=max_iter) norm_after = np.sqrt(np.sum(variable_data ** 2)) + 1e-31 diff --git a/stride/optimisation/constraints/dykstra.py b/stride/optimisation/constraints/dykstra.py index 7c077023..3094eb5a 100644 --- a/stride/optimisation/constraints/dykstra.py +++ b/stride/optimisation/constraints/dykstra.py @@ -31,6 +31,7 @@ def __init__(self, *constraints, **kwargs): self.min_iter = max(1, kwargs.pop('min_iter', 1)) self.max_iter = kwargs.pop('max_iter', 1000) self.tol = kwargs.pop('tol', 1e-6) + self.max_tol = kwargs.pop('max_tol', 1e6) def step(self, variable, **kwargs): """ diff --git a/stride/optimisation/loss/functional.py b/stride/optimisation/loss/functional.py index b7723a5b..ff20eccb 100644 --- a/stride/optimisation/loss/functional.py +++ b/stride/optimisation/loss/functional.py @@ -11,7 +11,7 @@ class FunctionalValue(Scalar): Parameters ---------- - fun_value : float + value : float Scalar value of the functional. shot_id : int ID of the shot for which the value has been calculated. @@ -20,14 +20,14 @@ class FunctionalValue(Scalar): """ - def __init__(self, fun_value, shot_id, residuals=None, **kwargs): + def __init__(self, value, shot_id, residuals=None, **kwargs): super().__init__(**kwargs) - self.data[:] = fun_value + self.data[:] = value self.shot_id = shot_id - self.fun_value = fun_value + self.value = value if kwargs.pop('keep_residual', False): self.residuals = residuals def __repr__(self): - return 'loss %e for shot %d' % (self.fun_value, self.shot_id) + return 'loss %e for shot %d' % (self.value, self.shot_id) diff --git a/stride/optimisation/optimisation_loop.py b/stride/optimisation/optimisation_loop.py index 602a7010..da084a24 100644 --- a/stride/optimisation/optimisation_loop.py +++ b/stride/optimisation/optimisation_loop.py @@ -1,6 +1,4 @@ -from collections import OrderedDict - from ..problem.base import Saved from .loss.functional import FunctionalValue @@ -8,6 +6,75 @@ __all__ = ['Iteration', 'Block', 'OptimisationLoop'] +class IterationRun: + """ + Objects of this class contain information about a specific repetition of the iteration. + + """ + + def __init__(self, id, iteration): + self.id = id + + self._iteration = iteration + self.submitted_shots = [] + self.completed_shots = [] + self.losses = dict() + + @property + def iteration(self): + """ + Corresponding iteration. + + """ + return self._iteration + + @property + def total_loss(self): + """ + Functional value for this iteration across all shots. + + """ + return sum([each.value for each in self.losses.values()]) + + def clear(self): + """ + Clear memory. + + Returns + ------- + + """ + self.submitted_shots = [] + self.completed_shots = [] + for shot_id, loss in self.losses.items(): + self.losses[shot_id] = FunctionalValue(loss.value, shot_id) + + def __get_desc__(self, **kwargs): + description = { + 'id': self.id, + 'submitted_shots': self.submitted_shots, + 'completed_shots': self.completed_shots, + 'losses': [], + } + + for loss in self.losses.values(): + description['losses'].append({ + 'shot_id': loss.shot_id, + 'value': loss.value, + }) + + return description + + def __set_desc__(self, description): + self.id = description.id + self.submitted_shots = description.submitted_shots + self.completed_shots = description.completed_shots + + for loss_desc in description.losses: + loss = FunctionalValue(loss_desc.value, loss_desc.shot_id) + self.losses[loss.shot_id] = loss + + class Iteration: """ Objects of this class contain information about the iteration, such as the value of the functional. @@ -31,27 +98,66 @@ def __init__(self, id, abs_id, block, opt_loop): self._block = block self._optimisation_loop = opt_loop - self._submitted_shots = [] - self._completed_shots = [] - self._fun = OrderedDict() - self._step_fun = OrderedDict() + self._runs = { + 0: IterationRun(0, self), + } + self._curr_run_idx = 0 + + @property + def curr_run(self): + return self._runs[self._curr_run_idx] + + @property + def prev_run(self): + if self._curr_run_idx <= 0: + return None + return self._runs[self._curr_run_idx-1] + + @property + def block(self): + """ + Block of the iteration. + + """ + return self._block + + @property + def block_id(self): + """ + ID of the iteration block. + + """ + return self._block.id + + @property + def loop(self): + """ + Optimisation loop. + + """ + return self._optimisation_loop @property - def fun_value(self): + def total_loss(self): """ Functional value for this iteration across all shots. """ - return sum([each.fun_value for each in self._fun.values()]) + return self.curr_run.total_loss @property - def step_fun_value(self): + def total_loss_change(self): """ - Functional value for this iteration across all shots - after step. + Functional value change between last two runs """ - return sum([each.fun_value for each in self._step_fun.values()]) + if self._curr_run_idx <= 0: + return 0. + + curr_loss = self.curr_run.total_loss + prev_loss = self.prev_run.total_loss + + return (curr_loss - prev_loss) / (prev_loss + 1e-6) @property def num_submitted(self): @@ -59,7 +165,7 @@ def num_submitted(self): Number of shots submitted in this iteration. """ - return len(self._submitted_shots) + return len(self.curr_run.submitted_shots) @property def num_completed(self): @@ -67,25 +173,34 @@ def num_completed(self): Number of shots completed in this iteration """ - return len(self._completed_shots) + return len(self.curr_run.completed_shots) - def add_fun(self, fun): + def next_run(self): """ - Add a functional value for a particular shot to the iteration. + Set up next iteration run. - Parameters - ---------- - fun : FunctionalValue + Returns + ------- + + """ + self._curr_run_idx += 1 + self._runs[self._curr_run_idx] = IterationRun(self._curr_run_idx, self) + return self.curr_run + + def clear_run(self): + """ + Clear run memory. Returns ------- """ - self._fun[fun.shot_id] = fun + for run in self._runs.values(): + run.clear() - def add_step_fun(self, fun): + def add_loss(self, fun): """ - Add a functional value, after step, for a particular shot to the iteration. + Add a functional value for a particular shot to the iteration. Parameters ---------- @@ -95,7 +210,7 @@ def add_step_fun(self, fun): ------- """ - self._step_fun[fun.shot_id] = fun + self.curr_run.losses[fun.shot_id] = fun def add_submitted(self, shot): """ @@ -109,7 +224,7 @@ def add_submitted(self, shot): ------- """ - self._submitted_shots.append(shot.id) + self.curr_run.submitted_shots.append(shot.id) def add_completed(self, shot): """ @@ -123,36 +238,32 @@ def add_completed(self, shot): ------- """ - self._completed_shots.append(shot.id) + self.curr_run.completed_shots.append(shot.id) def __get_desc__(self, **kwargs): description = { 'id': self.id, 'abs_id': self.abs_id, - 'submitted_shots': self._submitted_shots, - 'completed_shots': self._completed_shots, - 'functional_values': [], + 'runs': [], } - for fun in self._fun.values(): - description['functional_values'].append({ - 'shot_id': fun.shot_id, - 'fun_value': fun.fun_value, - }) + for run in self._runs.values(): + description['runs'].append(run.__get_desc__(**kwargs)) return description def __set_desc__(self, description): self.id = description.id self.abs_id = description.abs_id - self._submitted_shots = description.submitted_shots - self._completed_shots = description.completed_shots - for fun_desc in description.functional_values: - fun = FunctionalValue(fun_desc.fun_value, fun_desc.shot_id) - self._fun[fun.shot_id] = fun + self._curr_run_idx = -1 + for run_desc in description.runs: + self._curr_run_idx += 1 + run = IterationRun(self._curr_run_idx, self) + run.__set_desc__(run_desc) + self._runs[self._curr_run_idx] = run - _serialisation_attrs = ['id', 'abs_id', '_submitted_shots', '_completed_shots', '_fun'] + _serialisation_attrs = ['id', 'abs_id'] def _serialisation_helper(self): state = {} @@ -160,14 +271,22 @@ def _serialisation_helper(self): for attr in self._serialisation_attrs: state[attr] = getattr(self, attr) + state['_runs'] = dict() + return state @classmethod def _deserialisation_helper(cls, state): instance = cls.__new__(cls) + instance._curr_run_idx = 0 for attr, value in state.items(): - setattr(instance, attr, value) + if attr == '_runs': + setattr(instance, '_runs', { + 0: IterationRun(0, instance), + }) + else: + setattr(instance, attr, value) return instance @@ -200,7 +319,7 @@ def __init__(self, id, opt_loop, **kwargs): self._optimisation_loop = opt_loop self._num_iterations = None - self._iterations = OrderedDict() + self._iterations = dict() self._current_iteration = None self.restart = False @@ -221,12 +340,12 @@ def current_iteration(self): return self._current_iteration @property - def fun_value(self): + def total_loss(self): """ Functional value for this block across all iterations. """ - return sum([each.fun_value for each in self._iterations.values()]) + return sum([each.value for each in self._iterations.values()]) def clear(self): """ @@ -237,7 +356,7 @@ def clear(self): """ self._num_iterations = None - self._iterations = OrderedDict() + self._iterations = dict() self._current_iteration = None def iterations(self, num, *iters, restart=None, restart_id=-1): @@ -272,10 +391,11 @@ def iterations(self, num, *iters, restart=None, restart_id=-1): self.clear() else: if type(restart_id) is int and restart_id < 0: - iteration = Iteration(self._current_iteration.id+1, self._optimisation_loop.running_id, + curr_iter_id = self._current_iteration.id if self._current_iteration is not None else -1 + iteration = Iteration(curr_iter_id+1, self._optimisation_loop.running_id, self, self._optimisation_loop) - self._iterations[self._current_iteration.id+1] = iteration + self._iterations[curr_iter_id+1] = iteration self._optimisation_loop.running_id += 1 self._current_iteration = iteration @@ -386,7 +506,7 @@ def __init__(self, name='optimisation_loop', **kwargs): super().__init__(name=name, **kwargs) self._num_blocks = None - self._blocks = OrderedDict() + self._blocks = dict() self._current_block = None self.restart = False self.running_id = 0 @@ -428,7 +548,7 @@ def clear(self): """ self._num_blocks = None - self._blocks = OrderedDict() + self._blocks = dict() self._current_block = None self.running_id = 0 diff --git a/stride/optimisation/optimisers/gradient_descent.py b/stride/optimisation/optimisers/gradient_descent.py index 76c62b2c..d91cc781 100644 --- a/stride/optimisation/optimisers/gradient_descent.py +++ b/stride/optimisation/optimisers/gradient_descent.py @@ -14,7 +14,7 @@ class GradientDescent(LocalOptimiser): ---------- variable : Variable Variable to which the optimiser refers. - step : float, optional + step_size : float, optional Step size for the update, defaults to 1. kwargs Extra parameters to be used by the class. @@ -24,53 +24,12 @@ class GradientDescent(LocalOptimiser): def __init__(self, variable, **kwargs): super().__init__(variable, **kwargs) - self.step_size = kwargs.pop('step_size', 1.) - - async def step(self, step_size=None, grad=None, processed_grad=None, **kwargs): - """ - Apply the optimiser. - - Parameters - ---------- - step_size : float, optional - Step size to use for this application, defaults to instance step. - grad : Data, optional - Gradient to use for the step, defaults to variable gradient. - processed_grad : Data, optional - Processed gradient to use for the step, defaults to processed variable gradient. - kwargs - Extra parameters to be used by the method. - - Returns - ------- - Variable - Updated variable. - - """ - step_size = self.step_size if step_size is None else step_size - - processed_grad = await self.pre_process(grad=grad, - processed_grad=processed_grad, - **kwargs) - direction = processed_grad - - self.variable.data[:] -= step_size*direction.data - - await self.post_process(**kwargs) + async def pre_process(self, grad=None, processed_grad=None, **kwargs): + processed_grad = await super().pre_process(grad=grad, + processed_grad=processed_grad, + **kwargs) + return processed_grad + async def update_variable(self, step_size, direction): + self.variable.data[:] -= step_size * direction.data return self.variable - - def reset(self, **kwargs): - """ - Reset optimiser state along with any stored buffers. - - Parameters - ---------- - kwargs - Extra parameters to be used by the method. - - Returns - ------- - - """ - pass diff --git a/stride/optimisation/optimisers/optimiser.py b/stride/optimisation/optimisers/optimiser.py index 57f26164..9d313406 100644 --- a/stride/optimisation/optimisers/optimiser.py +++ b/stride/optimisation/optimisers/optimiser.py @@ -4,6 +4,7 @@ import mosaic +from ..step_length import LineSearch from ..pipelines import ProcessGlobalGradient, ProcessModelIteration @@ -19,6 +20,8 @@ class LocalOptimiser(ABC): ---------- variable : Variable Variable to which the optimiser refers. + step_size : float or LineSearch, optional + Step size for the update, defaults to constant 1. process_grad : callable, optional Optional processing function to apply on the gradient prior to applying it. process_model : callable, optional @@ -33,6 +36,8 @@ def __init__(self, variable, **kwargs): raise ValueError('To be optimised, a variable needs to be set with "needs_grad=True"') self.variable = variable + self.step_size = kwargs.pop('step_size', 1.) + self.test_step_size = kwargs.pop('test_step_size', 1.) self.dump_grad = kwargs.pop('dump_grad', False) self.dump_prec = kwargs.pop('dump_prec', False) self._process_grad = kwargs.pop('process_grad', ProcessGlobalGradient(**kwargs)) @@ -50,70 +55,6 @@ def clear_grad(self): """ self.variable.clear_grad() - @abstractmethod - def step(self, **kwargs): - """ - Apply the optimiser. - - Parameters - ---------- - kwargs - Extra parameters to be used by the method. - - Returns - ------- - Variable - Updated variable. - - """ - pass - - @abstractmethod - def reset(self, **kwargs): - """ - Reset optimiser state along with any stored buffers. - - Parameters - ---------- - kwargs - Extra parameters to be used by the method. - - Returns - ------- - - """ - pass - - def dump(self, *args, **kwargs): - """ - Dump latest version of the optimiser. - - Parameters - ---------- - kwargs - Extra parameters to be used by the method - - Returns - ------- - - """ - self.variable.dump(*args, **kwargs) - - def load(self, *args, **kwargs): - """ - Load latest version of the optimiser. - - Parameters - ---------- - kwargs - Extra parameters to be used by the method - - Returns - ------- - - """ - self.variable.load(*args, **kwargs) - async def pre_process(self, grad=None, processed_grad=None, **kwargs): """ Pre-process the variable gradient before using it to take the step. @@ -171,6 +112,9 @@ async def pre_process(self, grad=None, processed_grad=None, **kwargs): processed_grad = await self._process_grad(grad, variable=self.variable, **kwargs) + test_step_size = kwargs.pop('test_step_size', self.test_step_size) + processed_grad.data[:] *= test_step_size + min_dir = np.min(processed_grad.data) max_dir = np.max(processed_grad.data) @@ -184,6 +128,108 @@ async def pre_process(self, grad=None, processed_grad=None, **kwargs): return processed_grad + async def step(self, step_size=None, grad=None, processed_grad=None, **kwargs): + """ + Apply the optimiser. + + Parameters + ---------- + step_size : float, optional + Step size to use for this application, defaults to instance step. + grad : Data, optional + Gradient to use for the step, defaults to variable gradient. + processed_grad : Data, optional + Processed gradient to use for the step, defaults to processed variable gradient. + kwargs + Extra parameters to be used by the method. + + Returns + ------- + Variable + Updated variable. + + """ + logger = mosaic.logger() + + # make copy of variable + variable_before = self.variable.copy() + + # pre-process gradient to get update direction + direction = await self.pre_process(grad=grad, + processed_grad=processed_grad, + **kwargs) + + # select test step size + step_size = self.step_size if step_size is None else step_size + step_loop = kwargs.pop('step_loop', None) + if isinstance(step_size, LineSearch): + await step_size.init_search( + variable=self.variable, + direction=direction, + **kwargs + ) + + # optimal step size search + while True: + # find optimal step + if isinstance(step_size, LineSearch): + if step_loop is None: + next_step = 1. + done_search = True + else: + next_step, done_search = await step_size.next_step( + variable=self.variable, + direction=direction, + **kwargs + ) + else: + next_step = step_size + done_search = True + + if done_search: + # cap the step if needed + max_step = kwargs.pop('max_step', None) + max_step = np.inf if not isinstance(max_step, (int, float)) else max_step + + unclipped_step = next_step + + if next_step > -0.2: # if bit -ve, still assume grad is right dirn + next_step = max(0.1, min(next_step, max_step)) + elif max_step < np.inf and next_step < -max_step * 0.75: # in general, prevent -ve steps + next_step = -max_step * 0.75 + elif next_step < -0.2: + next_step = next_step * 0.25 + + logger.perf('\t taking final update step of %e [unclipped step of %e]' % (next_step, unclipped_step)) + else: + logger.perf('\t taking test step of %e in line search' % next_step) + + # restore variable + self.variable.data[:] = variable_before.data.copy() + + # update variable + await self.update_variable(next_step, direction) + + # post-process variable after update + await self.post_process(**kwargs) + + # if done, stop search + if done_search: + break + + # calculate loss change + self.variable.needs_grad = False + if hasattr(self.variable, 'push'): + await self.variable.push(attr='needs_grad') + try: + await step_loop() + finally: + self.variable.needs_grad = True + if hasattr(self.variable, 'push'): + await self.variable.push(attr='needs_grad') + + return self.variable + async def post_process(self, **kwargs): """ Perform any necessary post-processing of the variable. @@ -206,3 +252,67 @@ async def post_process(self, **kwargs): (min_var, max_var)) self.variable.release_grad() + + @abstractmethod + async def update_variable(self, step_size, direction): + """ + + Parameters + ---------- + step_size : float + Step size to use for updating the variable. + direction : Data + Direction in which to update the variable. + + Returns + ------- + Variable + Updated variable. + + """ + pass + + def reset(self, **kwargs): + """ + Reset optimiser state along with any stored buffers. + + Parameters + ---------- + kwargs + Extra parameters to be used by the method. + + Returns + ------- + + """ + pass + + def dump(self, *args, **kwargs): + """ + Dump latest version of the optimiser. + + Parameters + ---------- + kwargs + Extra parameters to be used by the method + + Returns + ------- + + """ + self.variable.dump(*args, **kwargs) + + def load(self, *args, **kwargs): + """ + Load latest version of the optimiser. + + Parameters + ---------- + kwargs + Extra parameters to be used by the method + + Returns + ------- + + """ + self.variable.load(*args, **kwargs) diff --git a/stride/optimisation/pipelines/default_pipelines.py b/stride/optimisation/pipelines/default_pipelines.py index 3f4088bc..f7a37b8e 100644 --- a/stride/optimisation/pipelines/default_pipelines.py +++ b/stride/optimisation/pipelines/default_pipelines.py @@ -31,6 +31,9 @@ def __init__(self, steps=None, **kwargs): if kwargs.pop('filter_traces', True): steps.append('filter_traces') + if kwargs.pop('fw3d_mode', False): + steps.append('shift_traces') + if kwargs.pop('resonance_filter', False): steps.append(('resonance_filter', False)) @@ -154,15 +157,15 @@ class ProcessGlobalGradient(Pipeline): def __init__(self, steps=None, **kwargs): steps = steps or [] - mask = kwargs.pop('mask', True) + mask = kwargs.pop('mask_grad', True) if mask: - steps.append('mask') + steps.append('mask_field') - smooth = kwargs.pop('smooth', True) + smooth = kwargs.pop('smooth_grad', True) if smooth: steps.append('smooth_field') - norm = kwargs.pop('norm', True) + norm = kwargs.pop('norm_grad', True) if norm: steps.append('norm_field') diff --git a/stride/optimisation/pipelines/steps/__init__.py b/stride/optimisation/pipelines/steps/__init__.py index 5d16abd8..5214a29f 100644 --- a/stride/optimisation/pipelines/steps/__init__.py +++ b/stride/optimisation/pipelines/steps/__init__.py @@ -4,11 +4,12 @@ from .scale_traces import ScalePerShot, ScalePerTrace from .norm_field import NormField from .smooth_field import SmoothField -from .mask import Mask +from .mask_field import MaskField from .mute_traces import MuteTraces from .clip import Clip from .check_traces import CheckTraces from .dump import Dump +from .shift_traces import ShiftTraces steps_registry = { @@ -19,9 +20,10 @@ 'scale_per_trace': ScalePerTrace, 'norm_field': NormField, 'smooth_field': SmoothField, - 'mask': Mask, + 'mask_field': MaskField, 'mute_traces': MuteTraces, 'clip': Clip, 'check_traces': CheckTraces, 'dump': Dump, + 'shift_traces': ShiftTraces, } diff --git a/stride/optimisation/pipelines/steps/mask.py b/stride/optimisation/pipelines/steps/mask_field.py similarity index 74% rename from stride/optimisation/pipelines/steps/mask.py rename to stride/optimisation/pipelines/steps/mask_field.py index 6fe04f53..f09f416b 100644 --- a/stride/optimisation/pipelines/steps/mask.py +++ b/stride/optimisation/pipelines/steps/mask_field.py @@ -5,7 +5,7 @@ from ....core import Operator -class Mask(Operator): +class MaskField(Operator): """ Mask a StructuredData object to remove values outside inner domain. @@ -20,14 +20,14 @@ def __init__(self, **kwargs): self._mask = kwargs.pop('mask', None) def forward(self, field, **kwargs): - if self._mask is None: - self._mask = np.zeros(field.extended_shape) - self._mask[field.inner] = 1 - mask = self._mask + mask = kwargs.pop('mask', self._mask) + if mask is None: + mask = np.zeros(field.extended_shape) + mask[field.inner] = 1 out_field = field.alike(name=name_from_op_name(self, field)) out_field.extended_data[:] = field.extended_data - out_field *= mask + out_field.extended_data[:] *= mask return out_field diff --git a/stride/optimisation/pipelines/steps/shift_traces.py b/stride/optimisation/pipelines/steps/shift_traces.py new file mode 100644 index 00000000..58a8eb9a --- /dev/null +++ b/stride/optimisation/pipelines/steps/shift_traces.py @@ -0,0 +1,69 @@ + +from .utils import name_from_op_name +from ....core import Operator + + +class ShiftTraces(Operator): + """ + Shift a set of time traces. + + Parameters + ---------- + f_max : float, optional + Upper value for the frequency filter, defaults to None (no upper filtering). + filter_relaxation : float, optional + Relaxation factor for the filter in range (0, 1], defaults to 1 (no dilation). + + """ + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + self.f_max = kwargs.pop('f_max', None) + self.relaxation = kwargs.pop('filter_relaxation', 1.0) + + self._num_traces = None + + def forward(self, *traces, **kwargs): + self._num_traces = len(traces) + + shifted = [] + for each in traces: + shifted.append(self._apply(each, **kwargs)) + + if len(traces) > 1: + return tuple(shifted) + + else: + return shifted[0] + + def adjoint(self, *d_traces, **kwargs): + d_traces = d_traces[:self._num_traces] + + if len(d_traces) > 1: + return tuple(d_traces) + + else: + return d_traces[0] + + def _apply(self, traces, **kwargs): + time = traces.time + + f_max = kwargs.pop('f_max', self.f_max) + relaxation = kwargs.pop('filter_relaxation', self.relaxation) + + if f_max is None: + return traces + + f_max_dim_less = 1/relaxation*f_max*time.step if f_max is not None else 0 + period = int(1 / f_max_dim_less) + shift = period//4 + + out_data = traces.extended_data.copy() + out_traces = traces.alike(name=name_from_op_name(self, traces)) + + out_data[:, :-shift] = out_data[:, shift:] + + out_traces.extended_data[:] = out_data + + return out_traces diff --git a/stride/optimisation/step_length/__init__.py b/stride/optimisation/step_length/__init__.py new file mode 100644 index 00000000..04f29ae5 --- /dev/null +++ b/stride/optimisation/step_length/__init__.py @@ -0,0 +1,2 @@ + +from .line_search import * diff --git a/stride/optimisation/step_length/line_search.py b/stride/optimisation/step_length/line_search.py new file mode 100644 index 00000000..65a47d9e --- /dev/null +++ b/stride/optimisation/step_length/line_search.py @@ -0,0 +1,19 @@ + +from abc import abstractmethod + + +__all__ = ['LineSearch'] + + +class LineSearch: + + @abstractmethod + async def init_search(self, variable, direction, **kwargs): + pass + + @abstractmethod + async def next_step(self, variable, direction, **kwargs): + pass + + async def forward_test(self, variable, direction, **kwargs): + pass diff --git a/stride/physics/boundaries/boundary.py b/stride/physics/boundaries/boundary.py index 1c966531..142db981 100644 --- a/stride/physics/boundaries/boundary.py +++ b/stride/physics/boundaries/boundary.py @@ -58,7 +58,7 @@ def deallocate(self): def damping(self, dimensions=None, damping_coefficient=None, mask=False, damping_type='sine', velocity=1.0, power_degree=2, reflection_coefficient=1e-3, - assign=False): + assign=False, **kwargs): """ Create a damping field based on the dimensions of the grid. @@ -120,21 +120,21 @@ def damping(self, dimensions=None, damping_coefficient=None, mask=False, if damping_type == 'sine': pos = pos - np.sin(2 * np.pi * pos) / (2 * np.pi) if mask: - pos = 1 - pos + pos = - pos val = dimension_coefficient * pos elif damping_type == 'cosine': pos = np.cos(np.pi / 2 * (1 - pos)) if mask: - pos = 1 - pos + pos = - pos val = pos elif damping_type == 'power': pos = pos**power_degree if mask: - pos = 1 - pos + pos = - pos val = dimension_coefficient * pos diff --git a/stride/physics/boundaries/devito.py b/stride/physics/boundaries/devito.py index b2694961..fae7afc6 100644 --- a/stride/physics/boundaries/devito.py +++ b/stride/physics/boundaries/devito.py @@ -24,7 +24,9 @@ def apply(self, field, velocity, direction='forward', **kwargs): if np.max(space.extra) > 0: damp = self._grid.function('damp') - damp.data[:] = self.damping(velocity=velocity, reflection_coefficient=reflection_coefficient, mask=True) * time.step + damp.data[:] = self.damping(velocity=velocity, + reflection_coefficient=reflection_coefficient, + mask=True, **kwargs) * time.step else: damp = 0 @@ -53,7 +55,8 @@ def apply(self, field, velocity, direction='forward', **kwargs): if np.max(space.extra) > 0: damp = self._grid.function('damp') - damp.data[:] = 7 * self.damping(velocity=velocity, reflection_coefficient=reflection_coefficient) * time.step + damp.data[:] = 7 * self.damping(velocity=velocity, + reflection_coefficient=reflection_coefficient, **kwargs) * time.step else: damp = 0 diff --git a/stride/physics/iso_acoustic/devito.py b/stride/physics/iso_acoustic/devito.py index 4dae2c26..0136f1d9 100644 --- a/stride/physics/iso_acoustic/devito.py +++ b/stride/physics/iso_acoustic/devito.py @@ -67,10 +67,22 @@ class IsoAcousticDevito(ProblemTypeBase): it is calculated given the bandwidth. save_compression : str, optional Compression applied to saved wavefield, only available with DevitoPRO. Defaults to no - compression in 2D and `bitcomp` in 3D. + compression in 2D and ``bitcomp`` in 3D. save_interpolation : bool, optional Whether to interpolate the saved wavefield using natural cubic splines (only - available in some versions of Stride). Defaults to True. + available in some versions of Stride). Defaults to False. + dump_forward_wavefield : bool or int, optional + If True or a positive integer, the forward wavefield will be dumped after running the + forward kernel. If True, the wavefield will be sampled every ``save_undersampling`` + timesteps. If an integer, the wavefield will be sampled every ``dump_forward_wavefield`` + timesteps. Defaults to False. + dump_adjoint_wavefield : bool or int, optional + If True or a positive integer, the adjoint wavefield will be dumped after running the + adjoint kernel. If True, the wavefield will be sampled every ``save_undersampling`` + timesteps. If an integer, the wavefield will be sampled every ``dump_adjoint_wavefield`` + timesteps. Defaults to False. + dump_wavefield_id : int, optional + ID of the shot to dump wavefields. If not provided, all IDs are dumped. boundary_type : str, optional Type of boundary for the wave equation (``sponge_boundary_2`` or ``complex_frequency_shift_PML_2``), defaults to ``sponge_boundary_2``. @@ -94,6 +106,9 @@ class IsoAcousticDevito(ProblemTypeBase): adaptive_boxes : bool, optional Whether to activate adaptive boxes (requires DevitoPRO and only available in some versions of Stride). Defaults to False. + local_prec : bool, optional + Whether to apply local preconditioning. Only available in some versions of Stride. Defaults to + True. platform : str, optional Platform on which to run the operator, ``None`` to run on the CPU or ``nvidia-acc`` to run on the GPU with OpenACC. Defaults to ``None``. @@ -141,6 +156,10 @@ def __init__(self, **kwargs): name='acoustic_iso_state', grid=self.dev_grid, **kwargs) + self.state_operator_save = OperatorDevito(self.space_order, self.time_order, + name='acoustic_iso_state_save', + grid=self.dev_grid, + **kwargs) self.adjoint_operator = OperatorDevito(self.space_order, self.time_order, name='acoustic_iso_adjoint', grid=self.dev_grid, @@ -149,11 +168,13 @@ def __init__(self, **kwargs): if self._cached_operator: warehouse['%s_dev_grid' % cached_name] = self.dev_grid warehouse['%s_state_operator' % cached_name] = self.state_operator + warehouse['%s_state_operator_save' % cached_name] = self.state_operator_save warehouse['%s_adjoint_operator' % cached_name] = self.adjoint_operator else: self.dev_grid = warehouse['%s_dev_grid' % cached_name] self.state_operator = warehouse['%s_state_operator' % cached_name] + self.state_operator_save = warehouse['%s_state_operator_save' % cached_name] self.adjoint_operator = warehouse['%s_adjoint_operator' % cached_name] self.boundary = None @@ -163,11 +184,20 @@ def __init__(self, **kwargs): self._sub_ops = [] self._cached_subdomains = None + self._last_dumped_shot_id = None def clear_operators(self): self.state_operator.devito_operator = None + self.state_operator_save.devito_operator = None self.adjoint_operator.devito_operator = None + def deallocate_wavefield(self, platform='cpu', deallocate=False, **kwargs): + if (platform and 'nvidia' in platform) \ + or (devito.pro_available and isinstance(self._wavefield, devito.CompressedTimeFunction)) \ + or deallocate: + self._wavefield = None + devito.clear_cache(force=True) + def add_sub_op(self, sub_op): sub_op = sub_op(grid=self.grid, parent_grid=self.dev_grid.devito_grid, dtype=self.dev_grid.dtype) self._sub_ops.append(sub_op) @@ -217,7 +247,22 @@ async def before_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): it is calculated given the bandwidth. save_compression : str, optional Compression applied to saved wavefield, only available with DevitoPRO. Defaults to no - compression in 2D and `bitcomp` in 3D. + compression in 2D and ``bitcomp`` in 3D. + save_interpolation : bool, optional + Whether to interpolate the saved wavefield using natural cubic splines (only + available in some versions of Stride). Defaults to True. + dump_forward_wavefield : bool or int, optional + If True or a positive integer, the forward wavefield will be dumped after running the + forward kernel. If True, the wavefield will be sampled every ``save_undersampling`` + timesteps. If an integer, the wavefield will be sampled every ``dump_forward_wavefield`` + timesteps. Defaults to False. + dump_adjoint_wavefield : bool or int, optional + If True or a positive integer, the adjoint wavefield will be dumped after running the + adjoint kernel. If True, the wavefield will be sampled every ``save_undersampling`` + timesteps. If an integer, the wavefield will be sampled every ``dump_adjoint_wavefield`` + timesteps. Defaults to False. + dump_wavefield_id : int, optional + ID of the shot to dump wavefields. If not provided, all IDs are dumped. boundary_type : str, optional Type of boundary for the wave equation (``sponge_boundary_2`` or ``complex_frequency_shift_PML_2``), defaults to ``sponge_boundary_2``. @@ -263,7 +308,8 @@ async def before_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): num_receivers = shot.num_points_receivers dump_forward_wavefield = kwargs.pop('dump_forward_wavefield', False) - save_wavefield = kwargs.pop('save_wavefield', bool(dump_forward_wavefield)) + dump_wavefield_id = kwargs.pop('dump_wavefield_id', shot.id) + save_wavefield = kwargs.pop('save_wavefield', bool(dump_forward_wavefield) and dump_wavefield_id == shot.id) if save_wavefield is False: save_wavefield = vp.needs_grad if rho is not None: @@ -277,6 +323,7 @@ async def before_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): time_bounds = kwargs.get('time_bounds', (0, self.time.extended_num)) diff_source = kwargs.pop('diff_source', False) + fw3d_mode = kwargs.pop('fw3d_mode', False) save_compression = kwargs.get('save_compression', 'bitcomp' if self.space.dim > 2 else None) save_compression = save_compression if (is_nvidia or is_nvc) and devito.pro_available else None @@ -310,7 +357,10 @@ async def before_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): src_scale /= self.time.step src_term = src.inject(field=p.forward, expr=src * src_scale) - rec_term = rec.interpolate(expr=p) + if not fw3d_mode: + rec_term = rec.interpolate(expr=p) + else: + rec_term = rec.interpolate(expr=p.forward) # Define the saving of the wavefield if save_wavefield is True: @@ -340,17 +390,18 @@ async def before_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): devicecreate = (self.dev_grid.vars.p, self.dev_grid.vars.p_saved,) if dump_forward_wavefield: - factor = dump_forward_wavefield \ - if isinstance(dump_forward_wavefield, int) else self.undersampling_factor - layers = devito.Host if is_nvidia else devito.NoLayers - p_dump = self.dev_grid.undersampled_time_function('p_dump', - time_bounds=time_bounds, - factor=factor, - space_order=0, - layers=layers, - compression=None) - update_saved += [devito.Eq(p_dump, p, subdomain=abox)] - devicecreate += (self.dev_grid.vars.p_dump,) + if dump_wavefield_id == shot.id: + factor = dump_forward_wavefield \ + if isinstance(dump_forward_wavefield, int) else self.undersampling_factor + layers = devito.Host if is_nvidia else devito.NoLayers + p_dump = self.dev_grid.undersampled_time_function('p_dump', + time_bounds=time_bounds, + factor=factor, + space_order=0, + layers=layers, + compression=None) + update_saved += [devito.Eq(p_dump, p, subdomain=abox)] + devicecreate += (self.dev_grid.vars.p_dump,) else: update_saved = [] @@ -363,19 +414,32 @@ async def before_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): if self.attenuation_power == 2: kwargs['devito_config']['opt'] = 'noop' - self.state_operator.set_operator(stencil + src_term + rec_term + update_saved, + self.state_operator.set_operator(stencil + src_term + rec_term, **kwargs) self.state_operator.compile() + if save_wavefield is True: + self.state_operator_save.set_operator(stencil + src_term + rec_term + update_saved, + **kwargs) + self.state_operator_save.compile() else: # If the source/receiver size has changed, then create new functions for them - if num_sources != self.dev_grid.vars.src.npoint: - self.dev_grid.sparse_time_function('src', num=num_sources, cached=False) - - if num_receivers != self.dev_grid.vars.rec.npoint: - self.dev_grid.sparse_time_function('rec', num=num_receivers, cached=False) + if num_sources != self.dev_grid.vars.src.npoint or self.interpolation_type != 'linear': + self.dev_grid.sparse_time_function('src', num=num_sources, + coordinates=shot.source_coordinates, + interpolation_type=self.interpolation_type, + smooth=True, + cached=False) + + if num_receivers != self.dev_grid.vars.rec.npoint or self.interpolation_type != 'linear': + self.dev_grid.sparse_time_function('rec', num=num_receivers, + coordinates=shot.receiver_coordinates, + interpolation_type=self.interpolation_type, + smooth=False, + cached=False) # Clear all buffers + self.dev_grid.deallocate('rec') self.dev_grid.vars.rec.data_with_halo.fill(0.) self.dev_grid.vars.p.data_with_halo.fill(0.) self.boundary.clear() @@ -402,6 +466,9 @@ async def before_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): # Set geometry and wavelet wavelets = wavelets.data + if fw3d_mode: + wavelets[:, 1:] = wavelets[:, :-1] + if diff_source: wavelets = np.gradient(wavelets, self.time.step, axis=-1) @@ -436,6 +503,19 @@ async def run_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): ------- """ + problem = kwargs.get('problem') + shot = problem.shot + + dump_forward_wavefield = kwargs.pop('dump_forward_wavefield', False) + dump_wavefield_id = kwargs.pop('dump_wavefield_id', shot.id) + save_wavefield = kwargs.pop('save_wavefield', bool(dump_forward_wavefield) and dump_wavefield_id == shot.id) + if save_wavefield is False: + save_wavefield = vp.needs_grad + if rho is not None: + save_wavefield |= rho.needs_grad + if alpha is not None: + save_wavefield |= alpha.needs_grad + functions = dict( vp=self.dev_grid.vars.vp, src=self.dev_grid.vars.src, @@ -444,7 +524,7 @@ async def run_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): devito_args = kwargs.get('devito_args', {}) - if 'p_saved' in self.dev_grid.vars: + if 'p_saved' in self.dev_grid.vars and save_wavefield: if self._wavefield is None: self._wavefield = self.dev_grid.func('p_saved') @@ -454,12 +534,21 @@ async def run_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): devito_args['nbits'] = kwargs.get('nbits_compression', devito_args.get('nbits', 9)) + op = self.state_operator_save + else: + op = self.state_operator + + if np.linalg.norm(wavelets.data) < 1e-31: + problem = kwargs.pop('problem') + self.logger.warn('(ShotID %d) Empty wavelets, not running forward' % problem.shot_id) + return + time_bounds = kwargs.get('time_bounds', (0, self.time.extended_num)) - self.state_operator.run(dt=self.time.step, - time_m=1, - time_M=time_bounds[1]-1, - **functions, - **devito_args) + op.run(dt=self.time.step, + time_m=1, + time_M=time_bounds[1]-1, + **functions, + **devito_args) async def after_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): """ @@ -488,7 +577,8 @@ async def after_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): shot = problem.shot dump_forward_wavefield = kwargs.pop('dump_forward_wavefield', False) - save_wavefield = kwargs.get('save_wavefield', dump_forward_wavefield) + dump_wavefield_id = kwargs.pop('dump_wavefield_id', shot.id) + save_wavefield = kwargs.pop('save_wavefield', bool(dump_forward_wavefield) and dump_wavefield_id == shot.id) if save_wavefield is False: save_wavefield = vp.needs_grad if rho is not None: @@ -501,12 +591,13 @@ async def after_forward(self, wavelets, vp, rho=None, alpha=None, **kwargs): self.logger.perf('(ShotID %d) Dumping forward wavefield' % problem.shot_id) iteration = kwargs.pop('iteration', None) + version = iteration.abs_id+1 if iteration is not None else 0 p_dump_data = np.asarray(self.dev_grid.vars.p_dump.data, dtype=np.float32) p_dump = StructuredData(name='forward_wavefield-Shot%05d' % shot.id, data=p_dump_data, shape=None, extended_shape=None, inner=None, grid=self.grid) p_dump.dump(path=problem.output_folder, project_name=problem.name, - version=iteration.abs_id+1) + version=version) cache_forward = kwargs.pop('cache_forward', False) cache_location = kwargs.pop('cache_location', None) @@ -546,9 +637,6 @@ def _rm_tmpdir(): self.dev_grid.deallocate('p_saved') - else: - self._wavefield = None - traces_data = np.asarray(self.dev_grid.vars.rec.data, dtype=np.float32).T traces = shot.observed.alike(name='modelled', data=traces_data, shape=None, extended_shape=None, inner=None) @@ -599,6 +687,7 @@ async def before_adjoint(self, adjoint_source, wavelets, vp, rho=None, alpha=Non time_bounds = kwargs.get('time_bounds', (0, self.time.extended_num)) + fw3d_mode = kwargs.pop('fw3d_mode', False) platform = kwargs.get('platform', 'cpu') is_nvidia = platform is not None and 'nvidia' in platform @@ -623,7 +712,10 @@ async def before_adjoint(self, adjoint_source, wavelets, vp, rho=None, alpha=Non # Define the source injection function to generate the corresponding code t = rec.time_dim vp2 = self.dev_grid.vars.vp**2 - rec_term = rec.inject(field=p_a.backward, expr=-rec.subs({t: t-1}) * self.time.step**2 * vp2) + if not fw3d_mode: + rec_term = rec.inject(field=p_a.backward, expr=-rec.subs({t: t-1}) * self.time.step**2 * vp2) + else: + rec_term = rec.inject(field=p_a.backward, expr=-rec * self.time.step ** 2 * vp2) if wavelets.needs_grad: src_term = src.interpolate(expr=p_a) @@ -635,7 +727,8 @@ async def before_adjoint(self, adjoint_source, wavelets, vp, rho=None, alpha=Non # Maybe save wavefield dump_adjoint_wavefield = kwargs.pop('dump_adjoint_wavefield', False) - if dump_adjoint_wavefield: + dump_wavefield_id = kwargs.pop('dump_wavefield_id', shot.id) + if dump_adjoint_wavefield and dump_wavefield_id == shot.id: factor = dump_adjoint_wavefield \ if isinstance(dump_adjoint_wavefield, int) else self.undersampling_factor layers = devito.Host if is_nvidia else devito.NoLayers @@ -664,9 +757,20 @@ async def before_adjoint(self, adjoint_source, wavelets, vp, rho=None, alpha=Non self.adjoint_operator.compile() else: - # If the receiver size has changed, then create new functions for it - if num_receivers != self.dev_grid.vars.rec.npoint: - self.dev_grid.sparse_time_function('rec', num=num_receivers, cached=False) + # If the source or receiver size has changed, then create new functions for them + if num_sources != self.dev_grid.vars.src.npoint or self.interpolation_type != 'linear': + self.dev_grid.sparse_time_function('src', num=num_sources, + coordinates=shot.source_coordinates, + interpolation_type=self.interpolation_type, + smooth=True, + cached=False) + + if num_receivers != self.dev_grid.vars.rec.npoint or self.interpolation_type != 'linear': + self.dev_grid.sparse_time_function('rec', num=num_receivers, + coordinates=shot.receiver_coordinates, + interpolation_type=self.interpolation_type, + smooth=False, + cached=False) # Clear all buffers self.dev_grid.vars.src.data_with_halo.fill(0.) @@ -716,6 +820,9 @@ async def before_adjoint(self, adjoint_source, wavelets, vp, rho=None, alpha=Non # Set geometry and adjoint source adjoint_source = adjoint_source.data + if fw3d_mode: + adjoint_source[:, 1:] = adjoint_source[:, :-1] + window = scipy.signal.get_window(('tukey', 0.001), time_bounds[1]-time_bounds[0], False) window = np.pad(window, ((time_bounds[0], self.time.num-time_bounds[1]),), mode='constant', constant_values=0.) window = window.reshape((self.time.num, 1)) @@ -760,6 +867,11 @@ async def run_adjoint(self, adjoint_source, wavelets, vp, rho=None, alpha=None, if wavelets.needs_grad: functions['src'] = self.dev_grid.vars.src + if np.linalg.norm(adjoint_source.data) < 1e-31: + problem = kwargs.pop('problem') + self.logger.warn('(ShotID %d) Empty adjoint source, not running adjoint' % problem.shot_id) + return + time_bounds = kwargs.get('time_bounds', (0, self.time.extended_num)) self.adjoint_operator.run(dt=self.time.step, time_m=time_bounds[0]+1, @@ -796,25 +908,23 @@ async def after_adjoint(self, adjoint_source, wavelets, vp, rho=None, alpha=None shot = problem.shot dump_adjoint_wavefield = kwargs.pop('dump_adjoint_wavefield', False) + dump_wavefield_id = kwargs.pop('dump_wavefield_id', shot.id) platform = kwargs.get('platform', 'cpu') deallocate = kwargs.get('deallocate', False) - if dump_adjoint_wavefield: + if dump_adjoint_wavefield and dump_wavefield_id == shot.id: self.logger.perf('(ShotID %d) Dumping adjoint wavefield' % problem.shot_id) iteration = kwargs.pop('iteration', None) + version = iteration.abs_id+1 if iteration is not None else 0 p_dump_data = np.asarray(self.dev_grid.vars.p_a_dump.data, dtype=np.float32) p_dump = StructuredData(name='adjoint_wavefield-Shot%05d' % shot.id, data=p_dump_data, shape=None, extended_shape=None, inner=None, grid=self.grid) p_dump.dump(path=problem.output_folder, project_name=problem.name, - version=iteration.abs_id+1) + version=version) - if platform and 'nvidia' in platform \ - or devito.pro_available and isinstance(self._wavefield, devito.CompressedTimeFunction) \ - or deallocate: - self._wavefield = None - devito.clear_cache(force=True) + self.deallocate_wavefield(platform=platform, deallocate=deallocate) if deallocate: self.boundary.deallocate() @@ -1090,8 +1200,25 @@ def _check_problem(self, wavelets, vp, rho=None, alpha=None, **kwargs): preferred_kernel, preferred_undersampling, **kwargs) - # Recompile every time if using hicks or if there are sub ops - if self.interpolation_type == 'hicks' or len(self._sub_ops) or recompile: + # Recompile if need to save the wavefield for this shot + dump_wavefield_id = kwargs.pop('dump_wavefield_id', None) + if dump_wavefield_id is not None: + # recompile if need to dump this wavefield and last shot ran a different operator + if dump_wavefield_id == problem.shot_id and self._last_dumped_shot_id != dump_wavefield_id: + self._last_dumped_shot_id = problem.shot_id + recompile = True + # or if we dumped the last shot but don't need to dump this one + elif dump_wavefield_id != problem.shot_id and self._last_dumped_shot_id == dump_wavefield_id: + self._last_dumped_shot_id = None + recompile = True + + if 'p_saved' in self.dev_grid.vars: + self._wavefield = None + self.dev_grid.delete('p_saved') + devito.clear_cache(force=True) + + # Recompile every time if there are sub ops + if len(self._sub_ops) or recompile: self.state_operator.devito_operator = None self.adjoint_operator.devito_operator = None diff --git a/stride/physics/iso_elastic/devito.py b/stride/physics/iso_elastic/devito.py index babf2693..bf8c8f03 100644 --- a/stride/physics/iso_elastic/devito.py +++ b/stride/physics/iso_elastic/devito.py @@ -48,7 +48,7 @@ class IsoElasticDevito(ProblemTypeBase): """ space_order = 10 - time_order = 2 + time_order = 1 def __init__(self, **kwargs): super().__init__(**kwargs) @@ -130,15 +130,13 @@ async def before_forward(self, wavelets, vp, vs, rho, **kwargs): # Absorbing boundaries self.boundary = boundaries_registry[self.boundary_type](self.dev_grid) - _, _, _ = self.boundary.apply(vel, vp.extended_data) + _, _, _ = self.boundary.apply(vel, vp.extended_data, damping_coefficient=1/step) # Define the source injection function using a pressure disturbance - src_xx = src.inject(field=tau.forward[0, 0], expr=step * src) - src_zz = src.inject(field=tau.forward[1, 1], expr=step * src) + src_term = src.inject(field=tau.forward.diagonal(), expr=step * src) rec_term = rec_tau.interpolate(expr=tau[0, 0] + tau[1, 1]) - # rec_term += rec_v1.interpolate(expr=v[1]) # Placeholder for vel_x receiver - # rec_term += rec_v2.interpolate(expr=v[0]) # Placeholder for vel_y receiver + # rec_term += rec_vel.interpolate(expr=devito.div(vel)) # Placeholder for vel receiver # Set up parameters as functions lam_fun = self.dev_grid.function('lam_fun') @@ -152,12 +150,13 @@ async def before_forward(self, wavelets, vp, vs, rho, **kwargs): # stress (first derivative tau w.r.t. time, first order euler method) u_tau = devito.Eq(tau.forward, - self.boundary.damp * - (tau + step * (lam_fun * devito.diag(devito.div(vel.forward)) - + mu_fun * (devito.grad(vel.forward) + devito.grad(vel.forward).T)) - )) + self.boundary.damp * ( + tau + step * (lam_fun * devito.diag(devito.div(vel.forward)) + + mu_fun * (devito.grad(vel.forward) + + devito.grad(vel.forward).transpose(inner=False)))) + ) - self.state_operator.set_operator([u_v] + [u_tau] + src_xx + src_zz + rec_term, + self.state_operator.set_operator([u_v] + [u_tau] + src_term + rec_term, **kwargs) self.state_operator.compile() @@ -196,13 +195,10 @@ async def before_forward(self, wavelets, vp, vs, rho, **kwargs): # Set geometry and wavelet wavelets = wavelets.data - self._src_scale = 1000 - self._max_wavelet = np.max(np.abs(wavelets)) + 1e-31 - window = scipy.signal.get_window(('tukey', 0.01), self.time.num, False) window = window.reshape((self.time.num, 1)) - self.dev_grid.vars.src.data[:] = wavelets.T * self._src_scale / self._max_wavelet * window + self.dev_grid.vars.src.data[:] = wavelets.T * window if self.interpolation_type == 'linear': self.dev_grid.vars.src.coordinates.data[:] = shot.source_coordinates @@ -267,7 +263,6 @@ async def after_forward(self, wavelets, vp, vs, rho, **kwargs): self.wavefield = None traces_data = np.asarray(self.dev_grid.vars.rec_tau.data, dtype=np.float32).T - traces_data *= self._max_wavelet / self._src_scale traces = shot.observed.alike(name='modelled', data=traces_data) self.dev_grid.deallocate('p') diff --git a/stride/physics/marmottant/devito.py b/stride/physics/marmottant/devito.py index 4fc45740..4eb19556 100644 --- a/stride/physics/marmottant/devito.py +++ b/stride/physics/marmottant/devito.py @@ -34,7 +34,7 @@ class MarmottantDevito(ProblemTypeBase): For forward execution of the PDE, the following parameters can be used: - x_0 : ParticleField + x_0 : SparseCoordinates Spatial location of the bubble population, in [m]. r_0 : SparseField Initial radius of the bubble population, in [m]. @@ -110,7 +110,7 @@ async def before_forward(self, r_0, x_0=None, Parameters ---------- - x_0 : ParticleField + x_0 : SparseCoordinates Spatial location of the bubble population, in [m]. r_0 : SparseField Initial radius of the bubble population, in [m]. diff --git a/stride/plotting/volume_slicer.py b/stride/plotting/volume_slicer.py index 91e5ebbc..66c74c9d 100644 --- a/stride/plotting/volume_slicer.py +++ b/stride/plotting/volume_slicer.py @@ -1,5 +1,6 @@ import os +import numpy as np def volume_slicer(*args, **kwargs): @@ -57,22 +58,24 @@ def __init__(self, is_vector, data_range, colourmap, **traits): # Default values def _data_source_default(self): + colourmap = self.colourmap if self.colourmap != 'brain' else 'viridis' if self.is_vector: return mlab.pipeline.vector_field(self.data, figure=self.scene3d.mayavi_scene, - colormap=self.colourmap, + colormap=colourmap, vmin=self.data_range[0], vmax=self.data_range[1]) else: return mlab.pipeline.scalar_field(self.data, figure=self.scene3d.mayavi_scene, - colormap=self.colourmap, + colormap=colourmap, vmin=self.data_range[0], vmax=self.data_range[1]) def make_plane_widget_3d(self, axis_name): + colourmap = self.colourmap if self.colourmap != 'brain' else 'viridis' plane_widget = mlab.pipeline.image_plane_widget(self.data_source, figure=self.scene3d.mayavi_scene, - colormap=self.colourmap, + colormap=colourmap, plane_orientation='%s_axes' % axis_name) return plane_widget @@ -89,9 +92,10 @@ def _plane_widget_3d_z_default(self): # Scene activation callbaks @on_trait_change('scene3d.activated') def display_scene3d(self): + colourmap = self.colourmap if self.colourmap != 'brain' else 'viridis' outline = mlab.pipeline.outline(self.data_source, figure=self.scene3d.mayavi_scene, - colormap=self.colourmap, + colormap=colourmap, vmin=self.data_range[0], vmax=self.data_range[1]) vmin = self.data_range[0] or self.data.min() @@ -130,6 +134,7 @@ def display_scene3d(self): self.scene3d.scene.interactor.interactor_style = tvtk.InteractorStyleTerrain() def make_side_view(self, axis_name): + colourmap = self.colourmap if self.colourmap != 'brain' else 'viridis' scene = getattr(self, 'scene_%s' % axis_name) # To avoid copying the data, we take a reference to the @@ -139,15 +144,32 @@ def make_side_view(self, axis_name): # added on the figure we are interested in. outline = mlab.pipeline.outline(self.data_source.mlab_source.dataset, figure=scene.mayavi_scene, - colormap=self.colourmap, + colormap=colourmap, vmin=self.data_range[0], vmax=self.data_range[1]) plane_widget = mlab.pipeline.image_plane_widget(outline, plane_orientation='%s_axes' % axis_name, - colormap=self.colourmap, + colormap=colourmap, vmin=self.data_range[0], vmax=self.data_range[1]) setattr(self, 'plane_widget_%s' % axis_name, plane_widget) + # set colour map + if self.colourmap == 'brain': + try: + import stride_private + cmap_filename = os.path.join(os.path.dirname(stride_private.__file__), + 'plotting/cmaps/' + self.colourmap + '.txt') + cmap_ = np.genfromtxt(cmap_filename, delimiter=',', dtype=np.float32) + + lut = plane_widget.module_manager.scalar_lut_manager.lut + lut.number_of_colors = cmap_.shape[0] + lut.build() + + for i, v in enumerate(np.linspace(0, 1, cmap_.shape[0])): + lut.set_table_value(i, cmap_[i, 0], cmap_[i, 1], cmap_[i, 2]) + except ImportError: + pass + # Synchronize positions between the corresponding image plane # widgets on different views. plane_widget.ipw.sync_trait('slice_position', getattr(self, 'plane_widget_3d_%s' % axis_name).ipw) diff --git a/stride/problem/acquisitions.py b/stride/problem/acquisitions.py index 06e116ce..a6ec933d 100644 --- a/stride/problem/acquisitions.py +++ b/stride/problem/acquisitions.py @@ -1187,7 +1187,11 @@ def __get_desc__(self, **kwargs): return description def __set_desc__(self, description): - for shot_desc in description.shots: + if 'shots' in description: + shots = description.shots + else: + shots = description.values() + for shot_desc in shots: if shot_desc.id not in self._shots: shot = Shot(shot_desc.id, geometry=self._geometry, diff --git a/stride/problem/base.py b/stride/problem/base.py index 1829b427..c6ef3199 100644 --- a/stride/problem/base.py +++ b/stride/problem/base.py @@ -146,7 +146,7 @@ def load(self, *args, **kwargs): """ kwargs['parameter'] = self.name with h5.HDF5(*args, **kwargs, mode='r') as file: - description = file.load(filter=kwargs.pop('filter', None)) + description = file.load(filter=kwargs.pop('filter', None), only=kwargs.pop('only', None)) self.__set_desc__(description) @@ -241,7 +241,7 @@ def load(self, *args, **kwargs): """ kwargs['parameter'] = self.name with h5.HDF5(*args, **kwargs, mode='r') as file: - description = file.load(filter=kwargs.pop('filter', None)) + description = file.load(filter=kwargs.pop('filter', None), only=kwargs.pop('only', None)) # TODO If there's already a grid and they don't match, resample instead if 'space' in description and self._grid.space is None: diff --git a/stride/problem/data.py b/stride/problem/data.py index 63e50e06..037089ae 100644 --- a/stride/problem/data.py +++ b/stride/problem/data.py @@ -24,7 +24,7 @@ __all__ = ['Data', 'StructuredData', 'Scalar', 'ScalarField', 'VectorField', 'Traces', - 'SparseField', 'ParticleField'] + 'SparseField', 'SparseCoordinates'] @mosaic.tessera @@ -343,12 +343,14 @@ def release_grad(self): """ self.grad = None - def process_grad(self, **kwargs): + def process_grad(self, global_prec=True, **kwargs): """ Process the gradient by applying the pre-conditioner to it. Parameters ---------- + global_prec : bool, optional + Whether to apply preconditioner. Defaults to True. prec_scale : float, optional Condition scaling for the preconditioner. @@ -359,7 +361,8 @@ def process_grad(self, **kwargs): if not self.needs_grad: return - self.grad.apply_prec(**kwargs) + if global_prec: + self.grad.apply_prec(**kwargs) return self.grad def apply_prec(self, prec_scale=0.25, prec_op=None, prec=None, **kwargs): @@ -1691,7 +1694,7 @@ def alike(self, *args, **kwargs): Returns ------- - ParticleField + SparseCoordinates Newly created ScalarField. """ @@ -1709,7 +1712,7 @@ def detach(self, *args, **kwargs): Returns ------- - ParticleField + SparseCoordinates Detached variable. """ @@ -1800,9 +1803,9 @@ def __set_desc__(self, description): @mosaic.tessera -class ParticleField(SparseField): +class SparseCoordinates(SparseField): """ - Objects of this type describe a sparse particle field defined over the spatial grid. Particle fields + Objects of this type describe a sparse set of coordinates defined over the spatial grid. Coordinates can also be time-dependent. Parameters @@ -1856,20 +1859,23 @@ def plot(self, **kwargs): """ plot = kwargs.pop('plot', True) - if self.slow_time_dependent and self.space.dim == 2: - def update(figure, axis, step): - axis.clear() + if self.slow_time_dependent: + if self.space.dim == 2: + def update(figure, axis, step): + axis.clear() - self._plot(self.data[int(step)], axis=axis, **kwargs) - axis.set_title(axis.get_title() + ' - slow time step %d' % step) + self._plot(self.data[int(step)], axis=axis, **kwargs) + axis.set_title(axis.get_title() + ' - slow time step %d' % step) - figure.canvas.draw_idle() + figure.canvas.draw_idle() - axis = self._plot_time(update) + axis = self._plot_time(update) + else: + slow_t = kwargs.pop('slow_t', 0) + axis = self._plot(self.data[slow_t], **kwargs) else: - slow_t = kwargs.pop('slow_t', 0) - axis = self._plot(self.data[slow_t]/np.array(self.space.spacing), **kwargs) + axis = self._plot(self.data, **kwargs) if plot is True: plotting.show(axis) diff --git a/stride/problem/problem.py b/stride/problem/problem.py index e1bb0094..398a07bd 100644 --- a/stride/problem/problem.py +++ b/stride/problem/problem.py @@ -161,10 +161,14 @@ def dump(self, *args, **kwargs): kwargs['project_name'] = kwargs.get('project_name', self.name) kwargs['path'] = kwargs.get('path', self.output_folder) - self.medium.dump(*args, **kwargs) - self.transducers.dump(*args, **kwargs) - self.geometry.dump(*args, **kwargs) - self.acquisitions.dump(*args, **kwargs) + if kwargs.pop('dump_medium', True): + self.medium.dump(*args, **kwargs) + if kwargs.pop('dump_transducers', True): + self.transducers.dump(*args, **kwargs) + if kwargs.pop('dump_geometry', True): + self.geometry.dump(*args, **kwargs) + if kwargs.pop('dump_acquisitions', True): + self.acquisitions.dump(*args, **kwargs) def plot(self, **kwargs): """ diff --git a/stride_examples/tutorials/06_imaging.ipynb b/stride_examples/tutorials/06_imaging.ipynb index 4d387462..7154238e 100644 --- a/stride_examples/tutorials/06_imaging.ipynb +++ b/stride_examples/tutorials/06_imaging.ipynb @@ -50,12425 +50,1840 @@ "name": "stdout", "output_type": "stream", "text": [ - "Listening at HEAD Listening at \n" - ] - } - ], - "source": [ - "import mosaic\n", - "\n", - "await mosaic.interactive('on', num_workers=2)\n", - "runtime = mosaic.runtime()" - ] - }, - { - "cell_type": "markdown", - "id": "announced-cambridge", - "metadata": {}, - "source": [ - "## Problem definition\n", - "\n", - "Let's start by defining out problem as usual, starting with the spatiotemporal grid." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "broad-pilot", - "metadata": {}, - "outputs": [], - "source": [ - "from stride import Space, Time, Grid\n", - "%matplotlib widget\n", - "\n", - "space = Space(shape=(356, 385), extra=(50, 50), absorbing=(40, 40), spacing=0.5e-3)\n", - "time = Time(start=0.0e-6, step=0.08e-6, num=2500)\n", - "\n", - "grid = Grid(space, time)" - ] - }, - { - "cell_type": "markdown", - "id": "magnetic-origin", - "metadata": {}, - "source": [ - "We create the problem object." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "therapeutic-ridge", - "metadata": {}, - "outputs": [], - "source": [ - "from stride import Problem\n", - "\n", - "problem = Problem(name='breast2D', space=space, time=time)" - ] - }, - { - "cell_type": "markdown", - "id": "breathing-guarantee", - "metadata": {}, - "source": [ - "And we start filling it up we our transducers and geometry." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "unsigned-elephant", - "metadata": {}, - "outputs": [], - "source": [ - "# Create transducers\n", - "# the default option will create a single point transducer\n", - "problem.transducers.default()\n", - "\n", - "# Create geometry\n", - "# a default elliptical geometry will be generated in this case\n", - "num_locations = 120\n", - "problem.geometry.default('elliptical', num_locations)" - ] - }, - { - "cell_type": "markdown", - "id": "constitutional-daniel", - "metadata": {}, - "source": [ - "We are going to populate our acquisition sequence with 120 shots (one for each location in the geoemtry). During each shot, a different location is going to act as the source and the rest of them are going to act as receivers.\n", - "\n", - "We can easily do this in Stride by calling the `default()` method of the `stride.Acquisitions` object." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "incorporated-pressing", - "metadata": {}, - "outputs": [], - "source": [ - "from stride.utils import wavelets\n", - "\n", - "# Populate acquisitions with default shots\n", - "problem.acquisitions.default()\n", - "\n", - "# Create wavelets\n", - "f_centre = 0.50e6\n", - "n_cycles = 3\n", - "\n", - "for shot in problem.acquisitions.shots:\n", - " shot.wavelets.data[0, :] = wavelets.tone_burst(f_centre, n_cycles, time.num, time.step)" - ] - }, - { - "cell_type": "markdown", - "id": "legitimate-linux", - "metadata": {}, - "source": [ - "Now, let's load our breast model." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "impressive-tribe", - "metadata": {}, - "outputs": [], - "source": [ - "from stride import ScalarField\n", - "\n", - "# Create medium\n", - "vp_true = ScalarField(name='vp', grid=grid)\n", - "vp_true.load('../examples/breast2D/data/anastasio2D-TrueModel.h5')\n", - "\n", - "problem.medium.add(vp_true)" - ] - }, - { - "cell_type": "markdown", - "id": "adjustable-label", - "metadata": {}, - "source": [ - "To get a plot of all components of the problem together, we can call the utility function `plot()` on the problem object." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "handled-economy", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "62612f4f80b9419f94caf7555ff78e84", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7750b412a62343d5bb3b78147090e587", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot all components of the problem\n", - "problem.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "decent-report", - "metadata": {}, - "source": [ - "## Modelling operator\n", - "\n", - "Once we have generated our problem, we can create a PDE on which to run our forward problem. In this case, we choose the isotropic acoustic wave equation.\n", - "\n", - "We instantiate our PDE using `remote(len=)` so that instances of the PDE are created in the workers for remote execution. We choose `len=runtime.num_workers` so that one instance is created in each available worker." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "anonymous-tolerance", - "metadata": {}, - "outputs": [], - "source": [ - "from stride import IsoAcousticDevito\n", - "\n", - "pde = IsoAcousticDevito.remote(grid=problem.grid, len=runtime.num_workers)" - ] - }, - { - "cell_type": "markdown", - "id": "sporting-platform", - "metadata": {}, - "source": [ - "## Forward problem - Generating observed data\n", - "\n", - "Before we can proceed with the imaging bit, we need to simulate the acquisition of some observed data.\n", - "\n", - "Here, we will exploit the parallelisation capabilities of Mosaic to run different shots in parallel in each available worker. We do this with an asynchronous for loop using `@runtime.async_for()`. In the previous code section, the async function `loop()` is called as many times as there are shots in the acquisitions and, for each shot, it is assigned a worker." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "unusual-springfield", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "HEAD Giving shot 0 to worker:0:0\n", - "HEAD Giving shot 1 to worker:0:1\n", - "MONITOR Listening at \n", - "WORKER:0:1 Default Devito configuration:\n", - "WORKER:0:1 \t * autotuning=['aggressive', 'runtime']\n", - "WORKER:0:1 \t * develop-mode=False\n", - "WORKER:0:1 \t * mpi=False\n", - "WORKER:0:1 \t * log-level=DEBUG\n", - "WORKER:0:1 \t * language=openmp\n", - "WORKER:0:0 Default Devito configuration:\n", - "WORKER:0:0 \t * autotuning=['aggressive', 'runtime']\n", - "WORKER:0:0 \t * develop-mode=False\n", - "WORKER:0:0 \t * mpi=False\n", - "WORKER:0:0 \t * log-level=DEBUG\n", - "WORKER:0:0 \t * language=openmp\n", + "Listening at HEAD Listening at \n", + "MONITOR Listening at \n", "WORKER:0:1 (ShotID 1) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 gcc -march=native -O3 -g -fPIC -Wall -std=c99 -Wno-unused-result -Wno-unused-variable -Wno-unused-but-set-variable -ffast-math -shared -fopenmp /tmp/devito-jitcache-uid1000/7b28505e483f600df7684c75761349468315bee6.c -lm -o /tmp/devito-jitcache-uid1000/7b28505e483f600df7684c75761349468315bee6.so\n", - "WORKER:0:1 (ShotID 1) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 1) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 1) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 1) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 1) Selected time stepping scheme OT2\n", - "WORKER:0:1 Operator `acoustic_iso_state` instance configuration:\n", - "WORKER:0:1 \t * name=acoustic_iso_state\n", - "WORKER:0:1 \t * subs={h_x: 0.0005, h_y: 0.0005, dt: 8e-08}\n", - "WORKER:0:1 \t * opt=advanced-fsg\n", - "WORKER:0:1 \t * devicecreate=(p(t, x, y),)\n", - "WORKER:0:1 Operator `acoustic_iso_state` generated in 1.59 s\n", - "WORKER:0:1 * lowering.Clusters: 0.93 s (58.7 %)\n", - "WORKER:0:1 * specializing.Clusters: 0.51 s (32.2 %)\n", - "WORKER:0:1 Flops reduction after symbolic optimization: [99 --> 55]\n", - "WORKER:0:1 Operator `acoustic_iso_state` jit-compiled `/tmp/devito-jitcache-uid1000/7b28505e483f600df7684c75761349468315bee6.c` in 0.30 s with `GNUCompiler`\n", - "WORKER:0:1 (ShotID 1) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.29 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 82.00 GFlops/s, 1.91 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.28 s [OI=2.63, 85.16 GFlops/s, 1.99 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 3.10 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 1) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 0) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 0) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 0) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 0) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 0) Selected time stepping scheme OT2\n", - "WORKER:0:0 Operator `acoustic_iso_state` instance configuration:\n", - "WORKER:0:0 \t * name=acoustic_iso_state\n", - "WORKER:0:0 \t * subs={h_x: 0.0005, h_y: 0.0005, dt: 8e-08}\n", - "WORKER:0:0 \t * opt=advanced-fsg\n", - "WORKER:0:0 \t * devicecreate=(p(t, x, y),)\n", - "WORKER:0:0 Operator `acoustic_iso_state` generated in 1.50 s\n", - "WORKER:0:0 * lowering.Clusters: 0.86 s (57.7 %)\n", - "WORKER:0:0 * specializing.Clusters: 0.49 s (32.9 %)\n", - "WORKER:0:0 Flops reduction after symbolic optimization: [99 --> 55]\n", - "WORKER:0:0 Operator `acoustic_iso_state` fetched `/tmp/devito-jitcache-uid1000/7b28505e483f600df7684c75761349468315bee6.c` in 1.06 s from jit-cache\n", - "WORKER:0:0 (ShotID 0) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.42 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 56.62 GFlops/s, 1.32 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.38 s [OI=2.63, 63.74 GFlops/s, 1.49 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.38 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 0) Completed state equation run for shot\n", "WORKER:0:0 (ShotID 0) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 0 retrieved\n", - "HEAD Retrieved traces for shot 0\n", - "HEAD Giving shot 2 to worker:0:0\n", - "HEAD Shot 1 retrieved\n", - "HEAD Retrieved traces for shot 1\n", - "HEAD Giving shot 3 to worker:0:1\n", - "WORKER:0:0 (ShotID 2) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 2) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 2) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 2) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 2) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 2) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 2) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.41 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 58.00 GFlops/s, 1.35 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.39 s [OI=2.63, 61.07 GFlops/s, 1.43 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.62 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 2) Completed state equation run for shot\n", - "HEAD Shot 2 retrieved\n", - "HEAD Retrieved traces for shot 2\n", - "HEAD Giving shot 4 to worker:0:0\n", - "WORKER:0:1 (ShotID 3) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 3) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 3) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 3) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 3) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 3) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 3) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.85 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 27.98 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.73 s [OI=2.63, 32.94 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.08 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.48 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 3) Completed state equation run for shot\n", - "HEAD Shot 3 retrieved\n", - "HEAD Retrieved traces for shot 3\n", - "HEAD Giving shot 5 to worker:0:1\n", - "WORKER:0:0 (ShotID 4) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 4) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 4) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 4) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 4) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 4) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 4) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.24 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 19.18 GFlops/s, 0.45 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.19 s [OI=2.63, 20.11 GFlops/s, 0.47 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.75 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 4) Completed state equation run for shot\n", - "HEAD Shot 4 retrieved\n", - "HEAD Retrieved traces for shot 4\n", - "HEAD Giving shot 6 to worker:0:0\n", + "WORKER:0:1 (ShotID 2) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 4) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 5) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 5) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 5) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 5) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 5) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 5) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 5) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.21 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 19.66 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.15 s [OI=2.63, 20.80 GFlops/s, 0.49 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.68 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 5) Completed state equation run for shot\n", - "HEAD Shot 5 retrieved\n", - "HEAD Retrieved traces for shot 5\n", - "HEAD Giving shot 7 to worker:0:1\n", - "WORKER:0:0 (ShotID 6) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 6) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 6) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 6) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 6) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 6) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 6) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.01 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 23.55 GFlops/s, 0.55 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.96 s [OI=2.63, 24.83 GFlops/s, 0.58 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.90 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 6) Completed state equation run for shot\n", - "HEAD Shot 6 retrieved\n", - "HEAD Retrieved traces for shot 6\n", - "HEAD Giving shot 8 to worker:0:0\n", + "WORKER:0:1 (ShotID 6) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 7) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 7) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 7) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 7) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 7) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 7) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 7) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.68 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 34.97 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.64 s [OI=2.63, 37.65 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 7) Completed state equation run for shot\n", - "HEAD Shot 7 retrieved\n", - "HEAD Retrieved traces for shot 7\n", - "HEAD Giving shot 9 to worker:0:1\n", + "WORKER:0:1 (ShotID 8) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 9) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 9) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 9) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 9) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 9) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 9) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 9) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.99 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 24.02 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.95 s [OI=2.63, 25.27 GFlops/s, 0.59 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.83 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 9) Completed state equation run for shot\n", - "HEAD Shot 9 retrieved\n", - "HEAD Retrieved traces for shot 9\n", - "HEAD Giving shot 10 to worker:0:1\n", - "WORKER:0:0 (ShotID 8) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 8) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 8) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 8) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 8) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 8) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 8) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.28 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 18.58 GFlops/s, 0.44 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.23 s [OI=2.63, 19.36 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.73 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 8) Completed state equation run for shot\n", - "HEAD Shot 8 retrieved\n", - "HEAD Retrieved traces for shot 8\n", - "HEAD Giving shot 11 to worker:0:0\n", "WORKER:0:1 (ShotID 10) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 10) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 10) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 10) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 10) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 10) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 10) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.24 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 19.18 GFlops/s, 0.45 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.19 s [OI=2.63, 20.04 GFlops/s, 0.47 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.69 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 10) Completed state equation run for shot\n", - "HEAD Shot 10 retrieved\n", - "HEAD Retrieved traces for shot 10\n", - "HEAD Giving shot 12 to worker:0:1\n", - "WORKER:0:0 (ShotID 11) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:0 (ShotID 3) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 11) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 11) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 11) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 11) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 11) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 11) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.17 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 20.33 GFlops/s, 0.48 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.13 s [OI=2.63, 21.14 GFlops/s, 0.50 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.78 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 11) Completed state equation run for shot\n", - "HEAD Shot 11 retrieved\n", - "HEAD Retrieved traces for shot 11\n", - "HEAD Giving shot 13 to worker:0:0\n", - "WORKER:0:1 (ShotID 12) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 (ShotID 11) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 13) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 12) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 12) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 12) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 12) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 12) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 12) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.78 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 30.49 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.74 s [OI=2.63, 32.54 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 12) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 13) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 13) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 13) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 13) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 13) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 13) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 13) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.79 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 30.10 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.75 s [OI=2.63, 31.97 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.09 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 13) Completed state equation run for shot\n", - "HEAD Shot 12 retrieved\n", - "HEAD Retrieved traces for shot 12\n", - "HEAD Giving shot 14 to worker:0:1\n", - "HEAD Shot 13 retrieved\n", - "HEAD Retrieved traces for shot 13\n", - "HEAD Giving shot 15 to worker:0:0\n", "WORKER:0:1 (ShotID 14) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 14) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 14) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 14) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 14) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 14) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 14) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.71 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 33.50 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.69 s [OI=2.63, 34.92 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 14) Completed state equation run for shot\n", - "HEAD Shot 14 retrieved\n", - "HEAD Retrieved traces for shot 14\n", - "HEAD Giving shot 16 to worker:0:1\n", - "WORKER:0:0 (ShotID 15) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 15) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 15) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 15) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 15) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 15) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 15) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.97 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 24.52 GFlops/s, 0.57 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.92 s [OI=2.63, 25.99 GFlops/s, 0.61 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.68 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 15) Completed state equation run for shot\n", - "HEAD Shot 15 retrieved\n", - "HEAD Retrieved traces for shot 15\n", - "HEAD Giving shot 17 to worker:0:0\n", + "WORKER:0:1 (ShotID 15) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 16) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 16) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 16) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 16) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 16) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 16) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 16) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.65 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 36.59 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.62 s [OI=2.63, 38.62 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.29 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 16) Completed state equation run for shot\n", - "HEAD Shot 16 retrieved\n", - "HEAD Retrieved traces for shot 16\n", - "HEAD Giving shot 18 to worker:0:1\n", + "WORKER:0:1 (ShotID 17) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 18) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 18) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 18) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 18) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 18) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 18) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 18) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.52 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 45.73 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.50 s [OI=2.63, 48.20 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.07 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.07 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 18) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 17) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 17) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 17) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 17) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 17) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 17) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 17) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.96 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 24.77 GFlops/s, 0.58 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.03 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.91 s [OI=2.63, 26.20 GFlops/s, 0.61 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.89 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 17) Completed state equation run for shot\n", - "HEAD Shot 18 retrieved\n", - "HEAD Retrieved traces for shot 18\n", - "HEAD Shot 17 retrieved\n", - "HEAD Retrieved traces for shot 17\n", - "HEAD Giving shot 19 to worker:0:1\n", - "HEAD Giving shot 20 to worker:0:0\n", - "WORKER:0:0 (ShotID 20) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 20) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 20) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 20) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 20) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 20) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 20) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.58 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 41.00 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.54 s [OI=2.63, 44.58 GFlops/s, 1.04 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.70 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 20) Completed state equation run for shot\n", - "HEAD Shot 20 retrieved\n", - "HEAD Retrieved traces for shot 20\n", - "HEAD Giving shot 21 to worker:0:0\n", "WORKER:0:1 (ShotID 19) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 19) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 19) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 19) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 19) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 19) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 19) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.72 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 33.03 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.64 s [OI=2.63, 37.17 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.07 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.99 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 19) Completed state equation run for shot\n", - "HEAD Shot 19 retrieved\n", - "HEAD Retrieved traces for shot 19\n", - "HEAD Giving shot 22 to worker:0:1\n", - "WORKER:0:0 (ShotID 21) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 (ShotID 20) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 12) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 21) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 21) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 21) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 21) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 21) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 21) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.77 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 30.89 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.70 s [OI=2.63, 34.16 GFlops/s, 0.80 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.04 s [OI=1.32, 0.37 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 21) Completed state equation run for shot\n", - "HEAD Shot 21 retrieved\n", - "HEAD Retrieved traces for shot 21\n", - "HEAD Giving shot 23 to worker:0:0\n", - "WORKER:0:1 (ShotID 22) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 22) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 22) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 22) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 22) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 22) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 22) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.99 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 24.02 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.93 s [OI=2.63, 25.59 GFlops/s, 0.60 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.89 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 22) Completed state equation run for shot\n", - "HEAD Shot 22 retrieved\n", - "HEAD Retrieved traces for shot 22\n", - "HEAD Giving shot 24 to worker:0:1\n", + "WORKER:0:1 (ShotID 21) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 23) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 24) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 24) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 24) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 24) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 24) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 24) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 24) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.48 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 49.54 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.47 s [OI=2.63, 51.49 GFlops/s, 1.20 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.07 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.54 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 24) Completed state equation run for shot\n", - "HEAD Shot 24 retrieved\n", - "HEAD Retrieved traces for shot 24\n", - "HEAD Giving shot 25 to worker:0:1\n", - "WORKER:0:0 (ShotID 23) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 23) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 23) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 23) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 23) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 23) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 23) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.00 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 23.78 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.94 s [OI=2.63, 25.46 GFlops/s, 0.60 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.93 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 23) Completed state equation run for shot\n", - "HEAD Shot 23 retrieved\n", - "HEAD Retrieved traces for shot 23\n", - "HEAD Giving shot 26 to worker:0:0\n", "WORKER:0:1 (ShotID 25) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 25) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 25) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 25) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 25) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 25) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 25) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.98 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 24.27 GFlops/s, 0.57 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.92 s [OI=2.63, 25.89 GFlops/s, 0.61 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.70 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 25) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 26) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 26) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 26) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 26) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 26) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 26) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 26) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.89 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 26.72 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.84 s [OI=2.63, 28.38 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.08 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 26) Completed state equation run for shot\n", - "HEAD Shot 25 retrieved\n", - "HEAD Retrieved traces for shot 25\n", - "HEAD Giving shot 27 to worker:0:1\n", - "HEAD Shot 26 retrieved\n", - "HEAD Retrieved traces for shot 26\n", - "HEAD Giving shot 28 to worker:0:0\n", - "WORKER:0:0 (ShotID 28) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 28) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 28) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 28) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 28) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 28) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 28) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 38.36 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.57 s [OI=2.63, 42.43 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.66 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 28) Completed state equation run for shot\n", - "HEAD Shot 28 retrieved\n", - "HEAD Retrieved traces for shot 28\n", - "HEAD Giving shot 29 to worker:0:0\n", + "WORKER:0:1 (ShotID 26) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 27) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 27) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 27) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 27) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 27) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 27) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 27) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.81 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 29.36 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.77 s [OI=2.63, 31.17 GFlops/s, 0.73 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.07 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 27) Completed state equation run for shot\n", - "HEAD Shot 27 retrieved\n", - "HEAD Retrieved traces for shot 27\n", - "HEAD Giving shot 30 to worker:0:1\n", - "WORKER:0:0 (ShotID 29) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 (ShotID 28) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 29) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 22) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 29) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 29) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 29) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 29) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 29) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 29) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.51 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 46.63 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.47 s [OI=2.63, 51.26 GFlops/s, 1.20 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.49 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 29) Completed state equation run for shot\n", - "HEAD Shot 29 retrieved\n", - "HEAD Retrieved traces for shot 29\n", - "HEAD Giving shot 31 to worker:0:0\n", "WORKER:0:1 (ShotID 30) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 30) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 30) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 30) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 30) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 30) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 30) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.69 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 34.47 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.65 s [OI=2.63, 36.82 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.67 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 30) Completed state equation run for shot\n", - "HEAD Shot 30 retrieved\n", - "HEAD Retrieved traces for shot 30\n", - "HEAD Giving shot 32 to worker:0:1\n", - "WORKER:0:0 (ShotID 31) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 31) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 31) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 31) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 31) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 31) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 31) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.49 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 48.53 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.45 s [OI=2.63, 52.96 GFlops/s, 1.24 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.07 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 31) Completed state equation run for shot\n", - "HEAD Shot 31 retrieved\n", - "HEAD Retrieved traces for shot 31\n", - "HEAD Giving shot 33 to worker:0:0\n", "WORKER:0:1 (ShotID 32) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 32) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 32) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 32) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 32) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 32) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 32) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.89 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 26.72 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.83 s [OI=2.63, 28.65 GFlops/s, 0.67 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.95 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 32) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 33) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 33) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 33) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 33) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 33) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 33) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 33) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 41.72 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.54 s [OI=2.63, 44.83 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.59 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 33) Completed state equation run for shot\n", - "HEAD Shot 32 retrieved\n", - "HEAD Retrieved traces for shot 32\n", - "HEAD Giving shot 34 to worker:0:1\n", - "HEAD Shot 33 retrieved\n", - "HEAD Retrieved traces for shot 33\n", - "HEAD Giving shot 35 to worker:0:0\n", - "WORKER:0:0 (ShotID 35) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 35) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 35) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 35) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 35) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 35) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 35) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.56 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 42.47 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.54 s [OI=2.63, 44.17 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.47 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 35) Completed state equation run for shot\n", - "HEAD Shot 35 retrieved\n", - "HEAD Retrieved traces for shot 35\n", - "HEAD Giving shot 36 to worker:0:0\n", + "WORKER:0:1 (ShotID 33) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 34) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 34) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 34) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 34) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 34) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 34) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 34) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.89 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 26.72 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.84 s [OI=2.63, 28.31 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.95 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 34) Completed state equation run for shot\n", - "HEAD Shot 34 retrieved\n", - "HEAD Retrieved traces for shot 34\n", - "HEAD Giving shot 37 to worker:0:1\n", - "WORKER:0:0 (ShotID 36) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 36) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 36) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 36) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 36) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 36) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 36) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.48 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 49.54 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.45 s [OI=2.63, 53.52 GFlops/s, 1.25 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.89 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 36) Completed state equation run for shot\n", - "HEAD Shot 36 retrieved\n", - "HEAD Retrieved traces for shot 36\n", - "HEAD Giving shot 38 to worker:0:0\n", - "WORKER:0:0 (ShotID 38) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 38) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 38) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 38) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 38) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 38) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 38) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 41.72 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.53 s [OI=2.63, 45.01 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.69 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 38) Completed state equation run for shot\n", - "HEAD Shot 38 retrieved\n", - "HEAD Retrieved traces for shot 38\n", - "HEAD Giving shot 39 to worker:0:0\n", + "WORKER:0:1 (ShotID 35) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 36) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 37) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 37) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 37) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 37) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 37) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 37) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 37) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.05 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 22.65 GFlops/s, 0.53 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.00 s [OI=2.63, 23.90 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.76 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 37) Completed state equation run for shot\n", - "HEAD Shot 37 retrieved\n", - "HEAD Retrieved traces for shot 37\n", - "HEAD Giving shot 40 to worker:0:1\n", + "WORKER:0:0 (ShotID 31) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:0 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 38) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 40) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 40) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 40) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 40) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 40) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 40) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 40) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 38.36 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.60 s [OI=2.63, 40.16 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.36 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 40) Completed state equation run for shot\n", - "HEAD Shot 40 retrieved\n", - "HEAD Retrieved traces for shot 40\n", - "HEAD Giving shot 41 to worker:0:1\n", - "WORKER:0:0 (ShotID 39) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 39) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 39) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 39) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 39) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 39) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 39) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.24 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 19.18 GFlops/s, 0.45 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.18 s [OI=2.63, 20.15 GFlops/s, 0.47 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.71 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 39) Completed state equation run for shot\n", - "HEAD Shot 39 retrieved\n", - "HEAD Retrieved traces for shot 39\n", - "HEAD Giving shot 42 to worker:0:0\n", - "WORKER:0:0 (ShotID 42) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 42) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 42) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 42) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 42) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 42) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 42) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.46 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 51.70 GFlops/s, 1.21 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.42 s [OI=2.63, 56.97 GFlops/s, 1.33 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.70 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 42) Completed state equation run for shot\n", - "HEAD Shot 42 retrieved\n", - "HEAD Retrieved traces for shot 42\n", - "HEAD Giving shot 43 to worker:0:0\n", "WORKER:0:1 (ShotID 41) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 41) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 41) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 41) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 41) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 41) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 41) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.24 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 19.18 GFlops/s, 0.45 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.17 s [OI=2.63, 20.42 GFlops/s, 0.48 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.69 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 41) Completed state equation run for shot\n", - "HEAD Shot 41 retrieved\n", - "HEAD Retrieved traces for shot 41\n", - "HEAD Giving shot 44 to worker:0:1\n", - "WORKER:0:0 (ShotID 43) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 43) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 43) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 43) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 43) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 43) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 43) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.74 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 32.14 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.71 s [OI=2.63, 33.57 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.33 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 43) Completed state equation run for shot\n", + "WORKER:0:1 (ShotID 42) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 43) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 44) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 44) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 44) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 44) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 44) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 44) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 44) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.51 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 46.63 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.49 s [OI=2.63, 48.82 GFlops/s, 1.14 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.07 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.54 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 44) Completed state equation run for shot\n", - "HEAD Shot 43 retrieved\n", - "HEAD Retrieved traces for shot 43\n", - "HEAD Giving shot 45 to worker:0:0\n", - "HEAD Shot 44 retrieved\n", - "HEAD Retrieved traces for shot 44\n", - "HEAD Giving shot 46 to worker:0:1\n", - "WORKER:0:0 (ShotID 45) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 45) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 45) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 45) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 45) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 45) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 45) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.69 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 34.47 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.65 s [OI=2.63, 36.61 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.52 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 45) Completed state equation run for shot\n", - "HEAD Shot 45 retrieved\n", - "HEAD Retrieved traces for shot 45\n", - "HEAD Giving shot 47 to worker:0:0\n", - "WORKER:0:1 (ShotID 46) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 46) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 46) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 46) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 46) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 46) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 46) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.77 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 30.89 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.74 s [OI=2.63, 32.33 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.26 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 46) Completed state equation run for shot\n", - "HEAD Shot 46 retrieved\n", - "HEAD Retrieved traces for shot 46\n", - "HEAD Giving shot 48 to worker:0:1\n", - "WORKER:0:0 (ShotID 47) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:0 (ShotID 39) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 47) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 47) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 47) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 47) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 47) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 47) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 41.72 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.53 s [OI=2.63, 45.10 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.95 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 47) Completed state equation run for shot\n", - "HEAD Shot 47 retrieved\n", - "HEAD Retrieved traces for shot 47\n", - "HEAD Giving shot 49 to worker:0:0\n", + "WORKER:0:1 (ShotID 45) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 47) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 48) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 48) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 48) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 48) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 48) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 48) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 48) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.05 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 22.65 GFlops/s, 0.53 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.93 s [OI=2.63, 25.63 GFlops/s, 0.60 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.10 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.57 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 48) Completed state equation run for shot\n", - "HEAD Shot 48 retrieved\n", - "HEAD Retrieved traces for shot 48\n", - "HEAD Giving shot 50 to worker:0:1\n", - "WORKER:0:0 (ShotID 49) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 49) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 49) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 49) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 49) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 49) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 49) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.12 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 21.24 GFlops/s, 0.50 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.09 s [OI=2.63, 21.97 GFlops/s, 0.52 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.74 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 49) Completed state equation run for shot\n", - "HEAD Shot 49 retrieved\n", - "HEAD Retrieved traces for shot 49\n", - "HEAD Giving shot 51 to worker:0:0\n", + "WORKER:0:1 (ShotID 49) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 50) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 50) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 50) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 50) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 50) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 50) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 50) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.61 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 38.99 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.59 s [OI=2.63, 40.93 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.38 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 50) Completed state equation run for shot\n", - "HEAD Shot 50 retrieved\n", - "HEAD Retrieved traces for shot 50\n", - "HEAD Giving shot 52 to worker:0:1\n", + "WORKER:0:1 (ShotID 51) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 52) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 52) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 52) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 52) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 52) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 52) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 52) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.93 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 25.57 GFlops/s, 0.60 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.89 s [OI=2.63, 26.77 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.86 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 52) Completed state equation run for shot\n", - "HEAD Shot 52 retrieved\n", - "HEAD Retrieved traces for shot 52\n", - "HEAD Giving shot 53 to worker:0:1\n", - "WORKER:0:0 (ShotID 51) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:0 (ShotID 46) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 51) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 51) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 51) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 51) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 51) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 51) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.19 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 19.99 GFlops/s, 0.47 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.14 s [OI=2.63, 20.94 GFlops/s, 0.49 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.71 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 51) Completed state equation run for shot\n", - "HEAD Shot 51 retrieved\n", - "HEAD Retrieved traces for shot 51\n", - "HEAD Giving shot 54 to worker:0:0\n", "WORKER:0:1 (ShotID 53) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 53) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 53) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 53) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 53) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 53) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 53) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.54 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 44.04 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.52 s [OI=2.63, 45.84 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.39 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 53) Completed state equation run for shot\n", - "HEAD Shot 53 retrieved\n", - "HEAD Retrieved traces for shot 53\n", - "HEAD Giving shot 55 to worker:0:1\n", - "WORKER:0:0 (ShotID 54) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 54) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 54) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 54) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 54) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 54) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 54) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.74 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 32.14 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.70 s [OI=2.63, 34.27 GFlops/s, 0.80 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.68 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 54) Completed state equation run for shot\n", - "HEAD Shot 54 retrieved\n", - "HEAD Retrieved traces for shot 54\n", - "HEAD Giving shot 56 to worker:0:0\n", "WORKER:0:1 (ShotID 55) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 55) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 55) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 55) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 55) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 55) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 55) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.85 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 27.98 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.79 s [OI=2.63, 30.39 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.06 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.09 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 55) Completed state equation run for shot\n", - "HEAD Shot 55 retrieved\n", - "HEAD Retrieved traces for shot 55\n", - "HEAD Giving shot 57 to worker:0:1\n", - "WORKER:0:0 (ShotID 56) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 56) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 56) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 56) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 56) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 56) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 56) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.66 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 36.03 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.62 s [OI=2.63, 38.38 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.55 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 56) Completed state equation run for shot\n", - "HEAD Shot 56 retrieved\n", - "HEAD Retrieved traces for shot 56\n", - "HEAD Giving shot 58 to worker:0:0\n", + "WORKER:0:1 (ShotID 56) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 57) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 57) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 57) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 57) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 57) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 57) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 57) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.40 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 59.45 GFlops/s, 1.39 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.37 s [OI=2.63, 65.18 GFlops/s, 1.52 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.60 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 57) Completed state equation run for shot\n", - "HEAD Shot 57 retrieved\n", - "HEAD Retrieved traces for shot 57\n", - "HEAD Giving shot 59 to worker:0:1\n", + "WORKER:0:1 (ShotID 58) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 59) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 59) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 59) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 59) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 59) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 59) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 59) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.52 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 45.73 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.48 s [OI=2.63, 49.97 GFlops/s, 1.17 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.83 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 59) Completed state equation run for shot\n", - "HEAD Shot 59 retrieved\n", - "HEAD Retrieved traces for shot 59\n", - "HEAD Giving shot 60 to worker:0:1\n", - "WORKER:0:0 (ShotID 58) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 58) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 58) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 58) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 58) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 58) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 58) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.14 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 20.86 GFlops/s, 0.49 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.08 s [OI=2.63, 22.10 GFlops/s, 0.52 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.76 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 58) Completed state equation run for shot\n", - "HEAD Shot 58 retrieved\n", - "HEAD Retrieved traces for shot 58\n", - "HEAD Giving shot 61 to worker:0:0\n", "WORKER:0:1 (ShotID 60) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 60) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 60) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 60) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 60) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 60) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 60) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.88 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 27.03 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.83 s [OI=2.63, 28.85 GFlops/s, 0.68 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.99 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 60) Completed state equation run for shot\n", - "HEAD Shot 60 retrieved\n", - "HEAD Retrieved traces for shot 60\n", - "HEAD Giving shot 62 to worker:0:1\n", - "WORKER:0:0 (ShotID 61) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 (ShotID 61) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 54) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 61) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 61) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 61) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 61) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 61) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 61) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.86 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 27.65 GFlops/s, 0.65 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.83 s [OI=2.63, 28.86 GFlops/s, 0.68 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.93 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 61) Completed state equation run for shot\n", - "HEAD Shot 61 retrieved\n", - "HEAD Retrieved traces for shot 61\n", - "HEAD Giving shot 63 to worker:0:0\n", "WORKER:0:1 (ShotID 62) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 62) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 62) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 62) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 62) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 62) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 62) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.84 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 28.31 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.80 s [OI=2.63, 29.76 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.95 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 62) Completed state equation run for shot\n", - "HEAD Shot 62 retrieved\n", - "HEAD Retrieved traces for shot 62\n", - "HEAD Giving shot 64 to worker:0:1\n", - "WORKER:0:0 (ShotID 63) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 63) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 63) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 63) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 63) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 63) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 63) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.56 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 42.47 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.54 s [OI=2.63, 44.27 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.34 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 63) Completed state equation run for shot\n", - "HEAD Shot 63 retrieved\n", - "HEAD Retrieved traces for shot 63\n", - "HEAD Giving shot 65 to worker:0:0\n", - "WORKER:0:0 (ShotID 65) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 65) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 65) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 65) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 65) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 65) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 65) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.64 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 37.16 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.62 s [OI=2.63, 38.59 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.23 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 65) Completed state equation run for shot\n", - "HEAD Shot 65 retrieved\n", - "HEAD Retrieved traces for shot 65\n", - "HEAD Giving shot 66 to worker:0:0\n", "WORKER:0:1 (ShotID 64) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 64) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 64) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 64) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 64) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 64) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 64) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.00 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 23.78 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.94 s [OI=2.63, 25.39 GFlops/s, 0.60 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.47 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 64) Completed state equation run for shot\n", - "HEAD Shot 64 retrieved\n", - "HEAD Retrieved traces for shot 64\n", - "HEAD Giving shot 67 to worker:0:1\n", - "WORKER:0:0 (ShotID 66) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 66) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 66) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 66) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 66) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 66) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 66) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.63 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 37.75 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.62 s [OI=2.63, 38.92 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.07 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.62 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 66) Completed state equation run for shot\n", - "HEAD Shot 66 retrieved\n", - "HEAD Retrieved traces for shot 66\n", - "HEAD Giving shot 68 to worker:0:0\n", + "WORKER:0:1 (ShotID 65) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 66) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 67) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 67) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 67) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 67) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 67) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 67) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 67) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.80 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 29.73 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.03 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.67 s [OI=2.63, 35.70 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.08 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.04 s [OI=1.32, 0.42 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 67) Completed state equation run for shot\n", - "HEAD Shot 67 retrieved\n", - "HEAD Retrieved traces for shot 67\n", - "HEAD Giving shot 69 to worker:0:1\n", - "WORKER:0:0 (ShotID 68) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 68) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 68) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 68) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 68) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 68) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 68) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.50 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 47.56 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.47 s [OI=2.63, 51.51 GFlops/s, 1.20 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.10 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 68) Completed state equation run for shot\n", - "HEAD Shot 68 retrieved\n", - "HEAD Retrieved traces for shot 68\n", - "HEAD Giving shot 70 to worker:0:0\n", + "WORKER:0:1 (ShotID 68) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 69) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 69) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 69) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 69) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 69) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 69) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 69) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.86 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 27.65 GFlops/s, 0.65 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.78 s [OI=2.63, 30.57 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.52 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 69) Completed state equation run for shot\n", - "HEAD Shot 69 retrieved\n", - "HEAD Retrieved traces for shot 69\n", - "HEAD Giving shot 71 to worker:0:1\n", - "WORKER:0:0 (ShotID 70) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 70) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 70) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 70) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 70) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 70) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 70) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.74 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 32.14 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.68 s [OI=2.63, 35.09 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.56 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 70) Completed state equation run for shot\n", - "HEAD Shot 70 retrieved\n", - "HEAD Retrieved traces for shot 70\n", - "HEAD Giving shot 72 to worker:0:0\n", - "WORKER:0:0 (ShotID 72) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 72) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 72) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 72) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 72) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 72) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 72) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.52 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 45.73 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.48 s [OI=2.63, 49.69 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.24 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 72) Completed state equation run for shot\n", - "HEAD Shot 72 retrieved\n", - "HEAD Retrieved traces for shot 72\n", - "HEAD Giving shot 73 to worker:0:0\n", + "WORKER:0:1 (ShotID 70) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 71) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 71) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 71) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 71) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 71) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 71) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 71) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.91 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 26.14 GFlops/s, 0.61 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.84 s [OI=2.63, 28.50 GFlops/s, 0.67 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.15 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 71) Completed state equation run for shot\n", - "HEAD Shot 71 retrieved\n", - "HEAD Retrieved traces for shot 71\n", - "HEAD Giving shot 74 to worker:0:1\n", - "WORKER:0:0 (ShotID 73) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 73) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 73) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 73) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 73) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 73) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 73) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.48 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 49.54 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.45 s [OI=2.63, 53.93 GFlops/s, 1.26 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.71 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 73) Completed state equation run for shot\n", - "HEAD Shot 73 retrieved\n", - "HEAD Retrieved traces for shot 73\n", - "HEAD Giving shot 75 to worker:0:0\n", - "WORKER:0:0 (ShotID 75) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 (ShotID 72) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 73) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 63) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 75) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 75) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 75) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 75) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 75) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 75) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.47 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 50.60 GFlops/s, 1.18 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.42 s [OI=2.63, 56.64 GFlops/s, 1.32 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.92 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 75) Completed state equation run for shot\n", - "HEAD Shot 75 retrieved\n", - "HEAD Retrieved traces for shot 75\n", - "HEAD Giving shot 76 to worker:0:0\n", "WORKER:0:1 (ShotID 74) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 74) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 74) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 74) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 74) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 74) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 74) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.10 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 21.62 GFlops/s, 0.51 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.03 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.98 s [OI=2.63, 24.29 GFlops/s, 0.57 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.08 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.89 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 74) Completed state equation run for shot\n", - "HEAD Shot 74 retrieved\n", - "HEAD Retrieved traces for shot 74\n", - "HEAD Giving shot 77 to worker:0:1\n", + "WORKER:0:1 (ShotID 76) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 77) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 77) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 77) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 77) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 77) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 77) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 77) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.77 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 30.89 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.73 s [OI=2.63, 32.92 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.10 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 77) Completed state equation run for shot\n", - "HEAD Shot 77 retrieved\n", - "HEAD Retrieved traces for shot 77\n", - "HEAD Giving shot 78 to worker:0:1\n", - "WORKER:0:0 (ShotID 76) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 76) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 76) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 76) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 76) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 76) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 76) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.23 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 19.34 GFlops/s, 0.45 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.18 s [OI=2.63, 20.18 GFlops/s, 0.47 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.71 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 76) Completed state equation run for shot\n", - "HEAD Shot 76 retrieved\n", - "HEAD Retrieved traces for shot 76\n", - "HEAD Giving shot 79 to worker:0:0\n", "WORKER:0:1 (ShotID 78) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 78) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 78) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 78) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 78) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 78) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 78) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.85 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 27.98 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.78 s [OI=2.63, 30.59 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.63 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 78) Completed state equation run for shot\n", - "HEAD Shot 78 retrieved\n", - "HEAD Retrieved traces for shot 78\n", - "HEAD Giving shot 80 to worker:0:1\n", - "WORKER:0:0 (ShotID 79) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 79) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 79) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 79) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 79) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 79) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 79) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.19 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 19.99 GFlops/s, 0.47 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.15 s [OI=2.63, 20.81 GFlops/s, 0.49 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.71 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 79) Completed state equation run for shot\n", - "HEAD Shot 79 retrieved\n", - "HEAD Retrieved traces for shot 79\n", - "HEAD Giving shot 81 to worker:0:0\n", + "WORKER:0:1 (ShotID 79) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 80) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 80) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 80) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 80) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 80) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 80) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 80) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.61 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 38.99 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.58 s [OI=2.63, 41.63 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.48 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 80) Completed state equation run for shot\n", - "HEAD Shot 80 retrieved\n", - "HEAD Retrieved traces for shot 80\n", - "HEAD Giving shot 82 to worker:0:1\n", - "WORKER:0:0 (ShotID 81) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 (ShotID 81) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 75) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 81) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 81) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 81) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 81) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 81) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 81) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.94 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 25.30 GFlops/s, 0.59 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.91 s [OI=2.63, 26.39 GFlops/s, 0.62 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.94 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 81) Completed state equation run for shot\n", - "HEAD Shot 81 retrieved\n", - "HEAD Retrieved traces for shot 81\n", - "HEAD Giving shot 83 to worker:0:0\n", "WORKER:0:1 (ShotID 82) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 82) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 82) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 82) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 82) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 82) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 82) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.95 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 25.03 GFlops/s, 0.59 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.91 s [OI=2.63, 26.33 GFlops/s, 0.62 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.86 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 82) Completed state equation run for shot\n", - "HEAD Shot 82 retrieved\n", - "HEAD Retrieved traces for shot 82\n", - "HEAD Giving shot 84 to worker:0:1\n", "WORKER:0:1 (ShotID 84) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 84) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 84) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 84) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 84) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 84) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 84) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.76 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 31.29 GFlops/s, 0.73 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.72 s [OI=2.63, 33.29 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.07 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 84) Completed state equation run for shot\n", - "HEAD Shot 84 retrieved\n", - "HEAD Retrieved traces for shot 84\n", - "HEAD Giving shot 85 to worker:0:1\n", - "WORKER:0:0 (ShotID 83) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 83) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 83) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 83) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 83) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 83) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 83) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.21 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 19.66 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.17 s [OI=2.63, 20.36 GFlops/s, 0.48 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.72 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 83) Completed state equation run for shot\n", - "HEAD Shot 83 retrieved\n", - "HEAD Retrieved traces for shot 83\n", - "HEAD Giving shot 86 to worker:0:0\n", "WORKER:0:1 (ShotID 85) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 85) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 85) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 85) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 85) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 85) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 85) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.73 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 32.58 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.70 s [OI=2.63, 34.33 GFlops/s, 0.80 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.29 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 85) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 86) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 86) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 86) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 86) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 86) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 86) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 86) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.52 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 45.73 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.47 s [OI=2.63, 50.90 GFlops/s, 1.19 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 86) Completed state equation run for shot\n", - "HEAD Shot 85 retrieved\n", - "HEAD Retrieved traces for shot 85\n", - "HEAD Giving shot 87 to worker:0:1\n", - "HEAD Shot 86 retrieved\n", - "HEAD Retrieved traces for shot 86\n", - "HEAD Giving shot 88 to worker:0:0\n", + "WORKER:0:1 (ShotID 86) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 87) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 87) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 87) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 87) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 87) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 87) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 87) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.50 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 47.56 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.48 s [OI=2.63, 49.79 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.07 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.64 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 87) Completed state equation run for shot\n", - "HEAD Shot 87 retrieved\n", - "HEAD Retrieved traces for shot 87\n", - "HEAD Giving shot 89 to worker:0:1\n", - "WORKER:0:0 (ShotID 88) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 88) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 88) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 88) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 88) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 88) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 88) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.79 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 30.10 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.73 s [OI=2.63, 32.66 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.57 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 88) Completed state equation run for shot\n", - "HEAD Shot 88 retrieved\n", - "HEAD Retrieved traces for shot 88\n", - "HEAD Giving shot 90 to worker:0:0\n", + "WORKER:0:1 (ShotID 88) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 89) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 89) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 89) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 89) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 89) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 89) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 89) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.88 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 27.03 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.76 s [OI=2.63, 31.58 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.12 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.23 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 89) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 90) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 (ShotID 90) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 83) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 90) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 90) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 90) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 90) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 90) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 90) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.55 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 43.24 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.50 s [OI=2.63, 47.59 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.58 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 90) Completed state equation run for shot\n", - "HEAD Shot 89 retrieved\n", - "HEAD Retrieved traces for shot 89\n", - "HEAD Giving shot 91 to worker:0:1\n", - "HEAD Shot 90 retrieved\n", - "HEAD Retrieved traces for shot 90\n", - "HEAD Giving shot 92 to worker:0:0\n", "WORKER:0:1 (ShotID 91) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 91) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 91) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 91) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 91) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 91) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 91) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.95 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 25.03 GFlops/s, 0.59 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.91 s [OI=2.63, 26.40 GFlops/s, 0.62 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.85 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 91) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 92) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 92) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 92) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 92) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 92) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 92) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 92) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.87 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 27.34 GFlops/s, 0.64 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.82 s [OI=2.63, 29.30 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.25 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 92) Completed state equation run for shot\n", - "HEAD Shot 91 retrieved\n", - "HEAD Retrieved traces for shot 91\n", - "HEAD Giving shot 93 to worker:0:1\n", - "HEAD Shot 92 retrieved\n", - "HEAD Retrieved traces for shot 92\n", - "HEAD Giving shot 94 to worker:0:0\n", - "WORKER:0:0 (ShotID 94) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 94) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 94) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 94) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 94) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 94) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 94) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 41.72 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.54 s [OI=2.63, 44.79 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.95 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 94) Completed state equation run for shot\n", "WORKER:0:1 (ShotID 93) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 93) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 93) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 93) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 93) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 93) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 93) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.61 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 38.99 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.57 s [OI=2.63, 42.27 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.39 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 93) Completed state equation run for shot\n", - "HEAD Shot 94 retrieved\n", - "HEAD Retrieved traces for shot 94\n", - "HEAD Giving shot 95 to worker:0:0\n", - "HEAD Shot 93 retrieved\n", - "HEAD Retrieved traces for shot 93\n", - "HEAD Giving shot 96 to worker:0:1\n", - "WORKER:0:0 (ShotID 95) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 94) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 95) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 96) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 95) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 95) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 95) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 95) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 95) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 95) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.84 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 28.31 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.82 s [OI=2.63, 29.33 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.97 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 95) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 96) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 96) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 96) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 96) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 96) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 96) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.84 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 28.31 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.78 s [OI=2.63, 30.69 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.18 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 96) Completed state equation run for shot\n", - "HEAD Shot 95 retrieved\n", - "HEAD Retrieved traces for shot 95\n", - "HEAD Giving shot 97 to worker:0:0\n", - "HEAD Shot 96 retrieved\n", - "HEAD Retrieved traces for shot 96\n", - "HEAD Giving shot 98 to worker:0:1\n", + "WORKER:0:1 (ShotID 97) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 98) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 98) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 98) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 98) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 98) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 98) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 98) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.79 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 30.10 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.76 s [OI=2.63, 31.58 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 98) Completed state equation run for shot\n", - "HEAD Shot 98 retrieved\n", - "HEAD Retrieved traces for shot 98\n", - "HEAD Giving shot 99 to worker:0:1\n", - "WORKER:0:0 (ShotID 97) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 97) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 97) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 97) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 97) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 97) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 97) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.06 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 22.44 GFlops/s, 0.53 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.00 s [OI=2.63, 23.87 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.85 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 97) Completed state equation run for shot\n", - "HEAD Shot 97 retrieved\n", - "HEAD Retrieved traces for shot 97\n", - "HEAD Giving shot 100 to worker:0:0\n", "WORKER:0:1 (ShotID 99) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 99) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 99) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 99) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 99) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 99) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 99) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.84 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 28.31 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.79 s [OI=2.63, 30.30 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.06 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 99) Completed state equation run for shot\n", - "HEAD Shot 99 retrieved\n", - "HEAD Retrieved traces for shot 99\n", - "HEAD Giving shot 101 to worker:0:1\n", - "WORKER:0:0 (ShotID 100) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 (ShotID 100) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 92) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 100) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 100) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 100) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 100) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 100) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 100) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.73 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 32.58 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.71 s [OI=2.63, 33.81 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.13 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 100) Completed state equation run for shot\n", - "HEAD Shot 100 retrieved\n", - "HEAD Retrieved traces for shot 100\n", - "HEAD Giving shot 102 to worker:0:0\n", "WORKER:0:1 (ShotID 101) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 101) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 101) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 101) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 101) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 101) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 101) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.54 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 44.04 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.51 s [OI=2.63, 46.98 GFlops/s, 1.10 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.53 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 101) Completed state equation run for shot\n", - "HEAD Shot 101 retrieved\n", - "HEAD Retrieved traces for shot 101\n", - "HEAD Giving shot 103 to worker:0:1\n", - "WORKER:0:0 (ShotID 102) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 102) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 102) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 102) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 102) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 102) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 40.31 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.57 s [OI=2.63, 41.88 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.42 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 102) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 102) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 102 retrieved\n", - "HEAD Retrieved traces for shot 102\n", - "HEAD Giving shot 104 to worker:0:0\n", "WORKER:0:1 (ShotID 103) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 103) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 103) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 103) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 103) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 103) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 103) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.73 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 32.58 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.70 s [OI=2.63, 34.00 GFlops/s, 0.80 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 103) Completed state equation run for shot\n", - "HEAD Shot 103 retrieved\n", - "HEAD Retrieved traces for shot 103\n", - "HEAD Giving shot 105 to worker:0:1\n", - "WORKER:0:0 (ShotID 104) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 104) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 104) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 104) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 104) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 104) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.08 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 22.02 GFlops/s, 0.52 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.05 s [OI=2.63, 22.73 GFlops/s, 0.53 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.80 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 104) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 104) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 104 retrieved\n", - "HEAD Retrieved traces for shot 104\n", - "HEAD Giving shot 106 to worker:0:0\n", + "WORKER:0:1 (ShotID 104) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 105) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 105) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 105) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 105) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 105) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 105) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 105) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.83 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 28.65 GFlops/s, 0.67 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.78 s [OI=2.63, 30.70 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.09 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 105) Completed state equation run for shot\n", - "HEAD Shot 105 retrieved\n", - "HEAD Retrieved traces for shot 105\n", - "HEAD Giving shot 107 to worker:0:1\n", - "WORKER:0:0 (ShotID 106) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 106) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 106) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 106) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 106) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 106) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.73 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 32.58 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.67 s [OI=2.63, 35.52 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.60 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 106) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 106) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 106 retrieved\n", - "HEAD Retrieved traces for shot 106\n", - "HEAD Giving shot 108 to worker:0:0\n", + "WORKER:0:1 (ShotID 106) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 107) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 107) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 107) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 107) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 107) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 107) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 107) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 41.72 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.50 s [OI=2.63, 47.73 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.06 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.56 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 107) Completed state equation run for shot\n", - "HEAD Shot 107 retrieved\n", - "HEAD Retrieved traces for shot 107\n", - "HEAD Giving shot 109 to worker:0:1\n", - "WORKER:0:0 (ShotID 108) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 108) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 108) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 108) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 108) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 108) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.63 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 37.75 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.60 s [OI=2.63, 39.80 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.59 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 108) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 108) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 108 retrieved\n", - "HEAD Retrieved traces for shot 108\n", - "HEAD Giving shot 110 to worker:0:0\n", + "WORKER:0:1 (ShotID 108) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 109) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 109) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 109) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 109) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 109) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 109) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 109) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.76 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 31.29 GFlops/s, 0.73 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.71 s [OI=2.63, 33.82 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.17 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 109) Completed state equation run for shot\n", - "HEAD Shot 109 retrieved\n", - "HEAD Retrieved traces for shot 109\n", - "HEAD Giving shot 111 to worker:0:1\n", - "WORKER:0:0 (ShotID 110) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 110) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 110) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 110) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 110) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 110) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.04 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 22.87 GFlops/s, 0.54 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.03 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.95 s [OI=2.63, 25.14 GFlops/s, 0.59 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.06 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.91 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 110) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 110) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 110 retrieved\n", - "HEAD Retrieved traces for shot 110\n", - "HEAD Giving shot 112 to worker:0:0\n", + "WORKER:0:1 (ShotID 110) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 111) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 111) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 111) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 111) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 111) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 111) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 111) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.23 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 19.34 GFlops/s, 0.45 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.17 s [OI=2.63, 20.39 GFlops/s, 0.48 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.71 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 111) Completed state equation run for shot\n", - "HEAD Shot 111 retrieved\n", - "HEAD Retrieved traces for shot 111\n", - "HEAD Giving shot 113 to worker:0:1\n", - "WORKER:0:0 (ShotID 112) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 112) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 112) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 112) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 112) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 112) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.01 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 23.55 GFlops/s, 0.55 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.98 s [OI=2.63, 24.46 GFlops/s, 0.57 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.89 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 112) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 112) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 112 retrieved\n", - "HEAD Retrieved traces for shot 112\n", - "HEAD Giving shot 114 to worker:0:0\n", - "WORKER:0:1 (ShotID 113) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 113) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 113) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 113) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 113) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 113) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 113) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.90 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 26.43 GFlops/s, 0.62 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.84 s [OI=2.63, 28.50 GFlops/s, 0.67 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.06 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.18 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 113) Completed state equation run for shot\n", - "HEAD Shot 113 retrieved\n", - "HEAD Retrieved traces for shot 113\n", - "HEAD Giving shot 115 to worker:0:1\n", - "WORKER:0:0 (ShotID 114) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 114) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 114) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 114) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 114) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 114) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.87 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 27.34 GFlops/s, 0.64 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.80 s [OI=2.63, 29.87 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.06 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.32 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 114) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 114) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:0 (ShotID 102) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 114 retrieved\n", - "HEAD Retrieved traces for shot 114\n", - "HEAD Giving shot 116 to worker:0:0\n", + "WORKER:0:1 (ShotID 112) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 114) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 115) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 115) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 115) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 115) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 115) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 115) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 115) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.29 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 18.44 GFlops/s, 0.43 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.23 s [OI=2.63, 19.39 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.72 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 115) Completed state equation run for shot\n", - "HEAD Shot 115 retrieved\n", - "HEAD Retrieved traces for shot 115\n", - "HEAD Giving shot 117 to worker:0:1\n", - "WORKER:0:0 (ShotID 116) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 116) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 116) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 116) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 116) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 116) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.81 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 29.36 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.78 s [OI=2.63, 30.75 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.99 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 116) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 116) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 116 retrieved\n", - "HEAD Retrieved traces for shot 116\n", - "HEAD Giving shot 118 to worker:0:0\n", + "WORKER:0:1 (ShotID 116) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 117) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 117) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 117) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 117) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 117) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 117) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 117) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 41.72 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.55 s [OI=2.63, 43.68 GFlops/s, 1.02 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.07 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 117) Completed state equation run for shot\n", - "HEAD Shot 117 retrieved\n", - "HEAD Retrieved traces for shot 117\n", - "HEAD Giving shot 119 to worker:0:1\n", - "WORKER:0:0 (ShotID 118) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 118) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 118) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 118) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 118) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 118) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.65 s\n", - "WORKER:0:0 Global performance: [OI=2.63, 36.59 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.59 s [OI=2.63, 40.70 GFlops/s, 0.95 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.06 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.45 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 118) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 118) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 118 retrieved\n", - "HEAD Retrieved traces for shot 118\n", + "WORKER:0:1 (ShotID 118) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 (ShotID 119) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 119) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 119) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 119) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 119) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 119) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 119) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.60 s\n", - "WORKER:0:1 Global performance: [OI=2.63, 39.64 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.57 s [OI=2.63, 42.43 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.43 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 119) Completed state equation run for shot\n", - "HEAD Shot 119 retrieved\n", - "HEAD Retrieved traces for shot 119\n", - "MONITOR Pending barrier tasks 2\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "68ed5af4dd864132961ef6aa2ac03adf", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "efaf76591fa64b9db766a4bfb73313f9", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 (ShotID 58) Running state equation for shot\n", + "WORKER:0:0 (ShotID 113) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 57 retrieved\n", - "HEAD Retrieved traces for shot 57\n", - "HEAD Giving shot 59 to worker:0:1\n", - "WORKER:0:1 (ShotID 59) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 59) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 59) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 59) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 59) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 59) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 59) Running state equation for shot\n", + "MONITOR Pending barrier tasks 1\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.50 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 50.88 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.49 s [OI=2.82, 52.79 GFlops/s, 1.15 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.98 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 58) Completed state equation run for shot\n", - "HEAD Shot 58 retrieved\n", - "HEAD Retrieved traces for shot 58\n", - "HEAD Giving shot 60 to worker:0:0\n", - "WORKER:0:0 (ShotID 60) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 60) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 60) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 60) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 60) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 60) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 60) Running state equation for shot\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.60 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 42.40 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.47 GFlops/s, 0.95 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.60 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 59) Completed state equation run for shot\n", - "HEAD Shot 59 retrieved\n", - "HEAD Retrieved traces for shot 59\n", - "HEAD Giving shot 61 to worker:0:1\n", - "WORKER:0:1 (ShotID 61) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 61) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 61) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 61) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 61) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 61) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 61) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.52 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 48.92 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.51 s [OI=2.82, 50.69 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.92 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 60) Completed state equation run for shot\n", - "HEAD Shot 60 retrieved\n", - "HEAD Retrieved traces for shot 60\n", - "HEAD Giving shot 62 to worker:0:0\n", - "WORKER:0:0 (ShotID 62) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 62) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 62) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 62) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 62) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 62) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 62) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 44.63 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 45.41 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.85 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 61) Completed state equation run for shot\n", - "HEAD Shot 61 retrieved\n", - "HEAD Retrieved traces for shot 61\n", - "HEAD Giving shot 63 to worker:0:1\n", - "WORKER:0:1 (ShotID 63) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 63) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 63) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 63) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 63) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 63) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 63) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 43.12 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.10 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.68 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 62) Completed state equation run for shot\n", - "HEAD Shot 62 retrieved\n", - "HEAD Retrieved traces for shot 62\n", - "HEAD Giving shot 64 to worker:0:0\n", - "WORKER:0:0 (ShotID 64) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 64) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 64) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 64) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 64) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 64) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 64) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.45 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 56.53 GFlops/s, 1.23 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.44 s [OI=2.82, 58.13 GFlops/s, 1.27 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.15 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.12 GFlops/s, 0.00 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 63) Completed state equation run for shot\n", - "HEAD Shot 63 retrieved\n", - "HEAD Retrieved traces for shot 63\n", - "HEAD Giving shot 65 to worker:0:1\n", - "WORKER:0:1 (ShotID 65) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 65) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 65) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 65) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 65) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 65) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 65) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 44.63 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 46.01 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.89 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 64) Completed state equation run for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 43.12 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 43.94 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.20 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 65) Completed state equation run for shot\n", - "HEAD Shot 64 retrieved\n", - "HEAD Retrieved traces for shot 64\n", - "HEAD Giving shot 66 to worker:0:0\n", - "WORKER:0:0 (ShotID 66) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 66) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 66) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 66) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 66) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 66) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 66) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 65 retrieved\n", - "HEAD Retrieved traces for shot 65\n", - "HEAD Giving shot 67 to worker:0:1\n", - "WORKER:0:1 (ShotID 67) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 67) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 67) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 67) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 67) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 67) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 67) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.52 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 48.92 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.51 s [OI=2.82, 50.68 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 66) Completed state equation run for shot\n", - "HEAD Shot 66 retrieved\n", - "HEAD Retrieved traces for shot 66\n", - "HEAD Giving shot 68 to worker:0:0\n", - "WORKER:0:0 (ShotID 68) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 68) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 68) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 68) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 68) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 68) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 68) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.55 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 46.25 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 47.00 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.18 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 67) Completed state equation run for shot\n", - "HEAD Shot 67 retrieved\n", - "HEAD Retrieved traces for shot 67\n", - "HEAD Giving shot 69 to worker:0:1\n", - "WORKER:0:1 (ShotID 69) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 69) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 69) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 69) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 69) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 69) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 69) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 43.12 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.14 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.79 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 68) Completed state equation run for shot\n", - "HEAD Shot 68 retrieved\n", - "HEAD Retrieved traces for shot 68\n", - "HEAD Giving shot 70 to worker:0:0\n", - "WORKER:0:0 (ShotID 70) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 70) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 70) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 70) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 70) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 70) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 70) Running state equation for shot\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.70 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 36.34 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.69 s [OI=2.82, 37.25 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.72 GFlops/s, 0.00 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 69) Completed state equation run for shot\n", - "HEAD Shot 69 retrieved\n", - "HEAD Retrieved traces for shot 69\n", - "HEAD Giving shot 71 to worker:0:1\n", - "WORKER:0:1 (ShotID 71) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 71) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 71) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 71) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 71) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 71) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 71) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.72 s\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.51 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 35.33 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.71 s [OI=2.82, 36.12 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.22 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 70) Completed state equation run for shot\n", - "WORKER:0:1 Global performance: [OI=2.82, 49.88 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.50 s [OI=2.82, 51.00 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.56 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 71) Completed state equation run for shot\n", - "HEAD Shot 71 retrieved\n", - "HEAD Retrieved traces for shot 71\n", - "HEAD Giving shot 72 to worker:0:1\n", - "WORKER:0:1 (ShotID 72) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 72) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 72) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 72) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 72) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 72) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 72) Running state equation for shot\n", + "WORKER:0:0 AutoTuner: could not perform any runs\n", + "MONITOR Pending barrier tasks 2\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Shot 70 retrieved\n", - "HEAD Retrieved traces for shot 70\n", - "HEAD Giving shot 73 to worker:0:0\n", - "WORKER:0:0 (ShotID 73) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 73) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 73) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 73) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 73) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 73) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 73) Running state equation for shot\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.51 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 49.88 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.50 s [OI=2.82, 51.15 GFlops/s, 1.12 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.75 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 72) Completed state equation run for shot\n", - "HEAD Shot 72 retrieved\n", - "HEAD Retrieved traces for shot 72\n", - "HEAD Giving shot 74 to worker:0:1\n", - "WORKER:0:1 (ShotID 74) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 74) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 74) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 74) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 74) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 74) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 74) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.64 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 39.75 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.62 s [OI=2.82, 41.03 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.43 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 73) Completed state equation run for shot\n", - "HEAD Shot 73 retrieved\n", - "HEAD Retrieved traces for shot 73\n", - "HEAD Giving shot 75 to worker:0:0\n", - "WORKER:0:0 (ShotID 75) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 75) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 75) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 75) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 75) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 75) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 75) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.47 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 54.13 GFlops/s, 1.18 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.46 s [OI=2.82, 56.25 GFlops/s, 1.23 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.15 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 74) Completed state equation run for shot\n", - "HEAD Shot 74 retrieved\n", - "HEAD Retrieved traces for shot 74\n", - "HEAD Giving shot 76 to worker:0:1\n", - "WORKER:0:1 (ShotID 76) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 76) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 76) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 76) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 76) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 76) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 76) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 43.12 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.12 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.68 GFlops/s, 0.00 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 75) Completed state equation run for shot\n", - "HEAD Shot 75 retrieved\n", - "HEAD Retrieved traces for shot 75\n", - "HEAD Giving shot 77 to worker:0:0\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.45 s\n", - "WORKER:0:0 (ShotID 77) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 77) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 77) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 77) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 77) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 77) Selected time stepping scheme OT2\n", - "WORKER:0:1 Global performance: [OI=2.82, 56.53 GFlops/s, 1.23 GPts/s]\n", - "WORKER:0:0 (ShotID 77) Running state equation for shot\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.44 s [OI=2.82, 58.64 GFlops/s, 1.28 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.10 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 76) Completed state equation run for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 76 retrieved\n", - "HEAD Retrieved traces for shot 76\n", - "HEAD Giving shot 78 to worker:0:1\n", - "WORKER:0:1 (ShotID 78) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 78) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 78) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 78) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 78) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 78) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 78) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.43 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 59.16 GFlops/s, 1.29 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.42 s [OI=2.82, 61.32 GFlops/s, 1.34 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.09 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 77) Completed state equation run for shot\n", - "HEAD Shot 77 retrieved\n", - "HEAD Retrieved traces for shot 77\n", - "HEAD Giving shot 79 to worker:0:0\n", - "WORKER:0:0 (ShotID 79) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 79) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 79) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 79) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 79) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 79) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 79) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 43.12 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.18 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.65 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 78) Completed state equation run for shot\n", - "HEAD Shot 78 retrieved\n", - "HEAD Retrieved traces for shot 78\n", - "HEAD Giving shot 80 to worker:0:1\n", - "WORKER:0:1 (ShotID 80) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 80) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 80) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 80) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 80) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 80) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 80) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.58 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 43.86 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 44.67 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.10 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 79) Completed state equation run for shot\n", - "HEAD Shot 79 retrieved\n", - "HEAD Retrieved traces for shot 79\n", - "HEAD Giving shot 81 to worker:0:0\n", - "WORKER:0:0 (ShotID 81) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 81) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 81) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 81) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 81) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 81) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 81) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.50 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 50.88 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.49 s [OI=2.82, 52.50 GFlops/s, 1.15 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.15 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.12 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 80) Completed state equation run for shot\n", - "HEAD Shot 80 retrieved\n", - "HEAD Retrieved traces for shot 80\n", - "HEAD Giving shot 82 to worker:0:1\n", - "WORKER:0:1 (ShotID 82) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 82) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 82) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 82) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 82) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 82) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 82) Running state equation for shot\n", + "MONITOR Pending barrier tasks 2\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.55 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 46.25 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.54 s [OI=2.82, 47.33 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.07 GFlops/s, 0.00 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 81) Completed state equation run for shot\n", - "HEAD Shot 81 retrieved\n", - "HEAD Retrieved traces for shot 81\n", - "HEAD Giving shot 83 to worker:0:0\n", - "WORKER:0:0 (ShotID 83) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 83) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 83) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 83) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 83) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 83) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 83) Running state equation for shot\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.56 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 45.43 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 46.91 GFlops/s, 1.02 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.15 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 82) Completed state equation run for shot\n", - "HEAD Shot 82 retrieved\n", - "HEAD Retrieved traces for shot 82\n", - "HEAD Giving shot 84 to worker:0:1\n", - "WORKER:0:1 (ShotID 84) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 84) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 84) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 84) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 84) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 84) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 84) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.60 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 42.40 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.60 s [OI=2.82, 43.07 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.07 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 83) Completed state equation run for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.51 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 49.88 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.50 s [OI=2.82, 51.62 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.15 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.20 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 84) Completed state equation run for shot\n", - "HEAD Shot 83 retrieved\n", - "HEAD Retrieved traces for shot 83\n", - "HEAD Giving shot 85 to worker:0:0\n", - "WORKER:0:0 (ShotID 85) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 85) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 85) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 85) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 85) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 85) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 85) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 84 retrieved\n", - "HEAD Retrieved traces for shot 84\n", - "HEAD Giving shot 86 to worker:0:1\n", - "WORKER:0:1 (ShotID 86) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 86) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 86) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 86) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 86) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 86) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 86) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.49 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 51.92 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.48 s [OI=2.82, 53.51 GFlops/s, 1.17 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.91 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 85) Completed state equation run for shot\n", - "HEAD Shot 85 retrieved\n", - "HEAD Retrieved traces for shot 85\n", - "HEAD Giving shot 87 to worker:0:0\n", - "WORKER:0:0 (ShotID 87) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 87) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 87) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 87) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 87) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 87) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 87) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 44.63 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 45.93 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.90 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 86) Completed state equation run for shot\n", - "HEAD Shot 86 retrieved\n", - "HEAD Retrieved traces for shot 86\n", - "HEAD Giving shot 88 to worker:0:1\n", - "WORKER:0:1 (ShotID 88) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 88) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 88) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 88) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 88) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 88) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 88) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.56 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 45.43 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 46.56 GFlops/s, 1.02 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.74 GFlops/s, 0.00 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 87) Completed state equation run for shot\n", - "HEAD Shot 87 retrieved\n", - "HEAD Retrieved traces for shot 87\n", - "HEAD Giving shot 89 to worker:0:0\n", - "WORKER:0:0 (ShotID 89) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 89) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 89) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 89) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 89) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 89) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 89) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 44.63 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 45.85 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 88) Completed state equation run for shot\n", - "HEAD Shot 88 retrieved\n", - "HEAD Retrieved traces for shot 88\n", - "HEAD Giving shot 90 to worker:0:1\n", - "WORKER:0:1 (ShotID 90) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 90) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 90) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 90) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 90) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 90) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 90) Running state equation for shot\n", + "MONITOR Pending barrier tasks 2\n", + "WORKER:0:1 (ShotID 15) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.49 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 51.92 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.48 s [OI=2.82, 53.66 GFlops/s, 1.17 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.83 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 89) Completed state equation run for shot\n", - "HEAD Shot 89 retrieved\n", - "HEAD Retrieved traces for shot 89\n", - "HEAD Giving shot 91 to worker:0:0\n", - "WORKER:0:0 (ShotID 91) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 91) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 91) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 91) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 91) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 91) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 91) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 20) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 22) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 28) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 7) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 41.03 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.61 s [OI=2.82, 42.27 GFlops/s, 0.92 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.58 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 90) Completed state equation run for shot\n", - "HEAD Shot 90 retrieved\n", - "HEAD Retrieved traces for shot 90\n", - "HEAD Giving shot 92 to worker:0:1\n", - "WORKER:0:1 (ShotID 92) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 92) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 92) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 92) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 92) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 92) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 92) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.55 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 46.25 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.54 s [OI=2.82, 47.92 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.66 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 91) Completed state equation run for shot\n", - "HEAD Shot 91 retrieved\n", - "HEAD Retrieved traces for shot 91\n", - "HEAD Giving shot 93 to worker:0:0\n", - "WORKER:0:0 (ShotID 93) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 93) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 93) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 93) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 93) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 93) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 93) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 62) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 77) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 79) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.56 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 45.43 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 46.93 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.81 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 92) Completed state equation run for shot\n", - "HEAD Shot 92 retrieved\n", - "HEAD Retrieved traces for shot 92\n", - "HEAD Giving shot 94 to worker:0:1\n", - "WORKER:0:1 (ShotID 94) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 94) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 94) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 94) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 94) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 94) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 94) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.69 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 36.87 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.68 s [OI=2.82, 37.47 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.71 GFlops/s, 0.00 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 93) Completed state equation run for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.50 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 50.88 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.49 s [OI=2.82, 52.27 GFlops/s, 1.14 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.96 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "HEAD Shot 93 retrieved\n", - "HEAD Retrieved traces for shot 93\n", - "HEAD Giving shot 95 to worker:0:0\n", - "WORKER:0:1 (ShotID 94) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 95) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 95) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 95) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 95) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 95) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 95) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 95) Running state equation for shot\n", + "WORKER:0:1 (ShotID 81) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 89) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 93) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 80) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 94 retrieved\n", - "HEAD Retrieved traces for shot 94\n", - "HEAD Giving shot 96 to worker:0:1\n", - "WORKER:0:1 (ShotID 96) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 96) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 96) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 96) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 96) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 96) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 96) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.58 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 43.86 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 44.95 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.15 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 95) Completed state equation run for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.51 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 49.88 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.50 s [OI=2.82, 51.17 GFlops/s, 1.12 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.15 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.15 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 96) Completed state equation run for shot\n", - "HEAD Shot 95 retrieved\n", - "HEAD Retrieved traces for shot 95\n", - "HEAD Giving shot 97 to worker:0:0\n", - "HEAD Shot 96 retrieved\n", - "HEAD Retrieved traces for shot 96\n", - "HEAD Giving shot 98 to worker:0:1\n", - "WORKER:0:0 (ShotID 97) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 97) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 97) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 97) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 97) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 97) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 97) Running state equation for shot\n", + "WORKER:0:1 (ShotID 99) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 103) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 117) Spatial grid spacing (0.500 mm | 5.000 PPW) is higher than dispersion limit (0.500 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 98) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 98) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 98) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 98) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 98) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 98) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 98) Running state equation for shot\n", + "MONITOR Pending barrier tasks 4\n", + "WORKER:0:1 (ShotID 3) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.60 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 42.40 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.52 GFlops/s, 0.95 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.66 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 98) Completed state equation run for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.63 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 40.38 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.62 s [OI=2.82, 41.59 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.47 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 97) Completed state equation run for shot\n", - "HEAD Shot 98 retrieved\n", - "HEAD Retrieved traces for shot 98\n", - "HEAD Giving shot 99 to worker:0:1\n", - "WORKER:0:1 (ShotID 99) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 99) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 99) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 99) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 99) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 99) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 99) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Shot 97 retrieved\n", - "HEAD Retrieved traces for shot 97\n", - "HEAD Giving shot 100 to worker:0:0\n", - "WORKER:0:0 (ShotID 100) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 100) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 100) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 100) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 100) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 100) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 100) Running state equation for shot\n", + "WORKER:0:1 (ShotID 6) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 9) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 31) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 41) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 2) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.50 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 50.88 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.49 s [OI=2.82, 52.44 GFlops/s, 1.14 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.84 GFlops/s, 0.00 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 99) Completed state equation run for shot\n", - "HEAD Shot 99 retrieved\n", - "HEAD Retrieved traces for shot 99\n", - "HEAD Giving shot 101 to worker:0:1\n", - "WORKER:0:1 (ShotID 101) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 101) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 101) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 101) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 101) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 101) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 101) Running state equation for shot\n", + "WORKER:0:1 (ShotID 42) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 43) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 52) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 55) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 60) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.64 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 39.75 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.63 s [OI=2.82, 40.76 GFlops/s, 0.89 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.83 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 100) Completed state equation run for shot\n", - "HEAD Shot 100 retrieved\n", - "HEAD Retrieved traces for shot 100\n", - "HEAD Giving shot 102 to worker:0:0\n", - "WORKER:0:0 (ShotID 102) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 102) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 102) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 102) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 102) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 102) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 102) Running state equation for shot\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.58 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 43.86 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 44.89 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.67 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 101) Completed state equation run for shot\n", - "HEAD Shot 101 retrieved\n", - "HEAD Retrieved traces for shot 101\n", - "HEAD Giving shot 103 to worker:0:1\n", - "WORKER:0:1 (ShotID 103) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 103) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 103) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 103) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 103) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 103) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 103) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.56 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 45.43 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 46.33 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.68 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 102) Completed state equation run for shot\n", - "HEAD Shot 102 retrieved\n", - "HEAD Retrieved traces for shot 102\n", - "HEAD Giving shot 104 to worker:0:0\n", - "WORKER:0:0 (ShotID 104) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 104) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 104) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 104) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 104) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 104) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 104) Running state equation for shot\n", + "WORKER:0:1 (ShotID 82) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 87) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 107) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 78) Spatial grid spacing (0.500 mm | 4.535 PPW) is higher than dispersion limit (0.454 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.53 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 48.00 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.52 s [OI=2.82, 48.92 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.79 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 103) Completed state equation run for shot\n", - "HEAD Shot 103 retrieved\n", - "HEAD Retrieved traces for shot 103\n", - "HEAD Giving shot 105 to worker:0:1\n", - "WORKER:0:1 (ShotID 105) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 105) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 105) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 105) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 105) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 105) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 105) Running state equation for shot\n", + "WORKER:0:0 AutoTuner: could not perform any runs\n", + "MONITOR Pending barrier tasks 2\n", + "WORKER:0:1 (ShotID 11) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.67 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 37.97 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.66 s [OI=2.82, 38.96 GFlops/s, 0.85 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.53 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 104) Completed state equation run for shot\n", - "HEAD Shot 104 retrieved\n", - "HEAD Retrieved traces for shot 104\n", - "HEAD Giving shot 106 to worker:0:0\n", - "WORKER:0:0 (ShotID 106) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 106) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 106) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 106) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 106) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 106) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 106) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 29) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 33) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 5) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.61 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 41.71 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.60 s [OI=2.82, 42.44 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.58 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 105) Completed state equation run for shot\n", - "HEAD Shot 105 retrieved\n", - "HEAD Retrieved traces for shot 105\n", - "HEAD Giving shot 107 to worker:0:1\n", - "WORKER:0:1 (ShotID 107) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 107) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 107) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 107) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 107) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 107) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 107) Running state equation for shot\n", + "WORKER:0:1 (ShotID 34) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 44) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.56 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 45.43 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 46.43 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.99 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 106) Completed state equation run for shot\n", - "HEAD Shot 106 retrieved\n", - "HEAD Retrieved traces for shot 106\n", - "HEAD Giving shot 108 to worker:0:0\n", - "WORKER:0:0 (ShotID 108) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 108) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 108) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 108) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 108) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 108) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 108) Running state equation for shot\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.68 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 37.41 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.67 s [OI=2.82, 38.06 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.76 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 107) Completed state equation run for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.48 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 53.00 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.47 s [OI=2.82, 54.56 GFlops/s, 1.19 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.77 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 108) Completed state equation run for shot\n", - "HEAD Shot 107 retrieved\n", - "HEAD Retrieved traces for shot 107\n", - "HEAD Giving shot 109 to worker:0:1\n", - "HEAD Shot 108 retrieved\n", - "HEAD Retrieved traces for shot 108\n", - "HEAD Giving shot 110 to worker:0:0\n", - "WORKER:0:1 (ShotID 109) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 109) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 109) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 109) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 109) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 109) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 109) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 110) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 110) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 110) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 110) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 110) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 110) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 110) Running state equation for shot\n", + "WORKER:0:1 (ShotID 47) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 63) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 65) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 72) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 49) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.58 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 44.63 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 Global performance: [OI=2.82, 43.86 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 45.80 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.56 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.78 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.21 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 109) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 110) Completed state equation run for shot\n", - "HEAD Shot 110 retrieved\n", - "HEAD Retrieved traces for shot 110\n", - "HEAD Giving shot 111 to worker:0:0\n", - "WORKER:0:0 (ShotID 111) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 111) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 111) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 111) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 111) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 111) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 111) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 96) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 108) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 114) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 118) Spatial grid spacing (0.500 mm | 4.524 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 109 retrieved\n", - "HEAD Retrieved traces for shot 109\n", - "HEAD Giving shot 112 to worker:0:1\n", - "WORKER:0:1 (ShotID 112) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 112) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 112) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 112) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 112) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 112) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 112) Running state equation for shot\n", + "MONITOR Pending barrier tasks 2\n", + "WORKER:0:1 (ShotID 4) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.49 s\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.56 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 51.92 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:1 Global performance: [OI=2.82, 45.43 GFlops/s, 0.99 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 Local performance:\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.48 s [OI=2.82, 53.14 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 46.35 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.93 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.68 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 111) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 112) Completed state equation run for shot\n", - "HEAD Shot 111 retrieved\n", - "HEAD Retrieved traces for shot 111\n", - "HEAD Giving shot 113 to worker:0:0\n", - "WORKER:0:0 (ShotID 113) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 113) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 113) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 113) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 113) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 113) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 113) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 8) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 18) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 0) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Shot 112 retrieved\n", - "HEAD Retrieved traces for shot 112\n", - "HEAD Giving shot 114 to worker:0:1\n", - "WORKER:0:1 (ShotID 114) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 114) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 114) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 114) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 114) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 114) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 114) Running state equation for shot\n", + "WORKER:0:1 (ShotID 19) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 21) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 24) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 38) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 54) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 56) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.50 s\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 50.88 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:0 Global performance: [OI=2.82, 43.12 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.49 s [OI=2.82, 52.82 GFlops/s, 1.15 GPts/s]\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 43.94 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.81 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.08 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 114) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 113) Completed state equation run for shot\n", - "HEAD Shot 114 retrieved\n", - "HEAD Retrieved traces for shot 114\n", - "HEAD Giving shot 115 to worker:0:1\n", - "WORKER:0:1 (ShotID 115) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 115) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 115) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 115) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 115) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 115) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 115) Running state equation for shot\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Shot 113 retrieved\n", - "HEAD Retrieved traces for shot 113\n", - "HEAD Giving shot 116 to worker:0:0\n", - "WORKER:0:0 (ShotID 116) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 116) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 116) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 116) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 116) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 116) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 116) Running state equation for shot\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.48 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 53.00 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.48 s [OI=2.82, 54.04 GFlops/s, 1.18 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.15 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.09 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 115) Completed state equation run for shot\n", - "HEAD Shot 115 retrieved\n", - "HEAD Retrieved traces for shot 115\n", - "HEAD Giving shot 117 to worker:0:1\n", - "WORKER:0:1 (ShotID 117) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 117) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 117) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 117) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 117) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 117) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 117) Running state equation for shot\n", + "WORKER:0:1 (ShotID 64) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 43.12 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.24 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.10 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 116) Completed state equation run for shot\n", - "HEAD Shot 116 retrieved\n", - "HEAD Retrieved traces for shot 116\n", - "HEAD Giving shot 118 to worker:0:0\n", - "WORKER:0:0 (ShotID 118) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 118) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:0 (ShotID 118) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 118) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:0 (ShotID 118) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 118) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 118) Running state equation for shot\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 85) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 104) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 119) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 68) Spatial grid spacing (0.500 mm | 4.523 PPW) is higher than dispersion limit (0.452 mm | 5.000 PPW)\n", "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 44.63 GFlops/s, 0.97 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 46.00 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.57 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 117) Completed state equation run for shot\n", - "HEAD Shot 117 retrieved\n", - "HEAD Retrieved traces for shot 117\n", - "HEAD Giving shot 119 to worker:0:1\n", - "WORKER:0:1 (ShotID 119) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 119) Estimated bandwidth for the propagated wavelet 0.255-0.735 MHz\n", - "WORKER:0:1 (ShotID 119) Spatial grid spacing (0.500 mm | 3.973 PPW) is higher than dispersion limit (0.397 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 119) Time grid spacing (0.080 μs | 26%) is below OT2 limit (0.136 μs)\n", - "WORKER:0:1 (ShotID 119) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 119) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 119) Running state equation for shot\n", + "WORKER:0:0 AutoTuner: could not perform any runs\n", + "MONITOR Pending barrier tasks 2\n", + "WORKER:0:1 (ShotID 32) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.66 s\n", - "WORKER:0:0 Global performance: [OI=2.82, 38.55 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.65 s [OI=2.82, 39.41 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 118) Completed state equation run for shot\n", - "HEAD Shot 118 retrieved\n", - "HEAD Retrieved traces for shot 118\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.48 s\n", - "WORKER:0:1 Global performance: [OI=2.82, 53.00 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.47 s [OI=2.82, 55.01 GFlops/s, 1.20 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.15 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 3.06 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 119) Completed state equation run for shot\n", - "HEAD Shot 119 retrieved\n", - "HEAD Retrieved traces for shot 119\n", - "MONITOR Pending barrier tasks 0\n" + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 36) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 37) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 39) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 12) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:0 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 46) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 50) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 66) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 75) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 67) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:0 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 76) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 86) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 101) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 (ShotID 111) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:1 AutoTuner: could not perform any runs\n", + "WORKER:0:0 (ShotID 95) Spatial grid spacing (0.500 mm | 4.509 PPW) is higher than dispersion limit (0.451 mm | 5.000 PPW)\n", + "WORKER:0:0 AutoTuner: could not perform any runs\n", + "WORKER:0:0 AutoTuner: could not perform any runs\n", + "MONITOR Pending barrier tasks 2\n" ] - }, - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_device_pixel_ratio', {\n", - " device_pixel_ratio: fig.ratio,\n", - " });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'dblclick',\n", - " on_mouse_event_closure('dblclick')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " fig.rubberband_canvas.style.cursor = msg['cursor'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " var img = evt.data;\n", - " if (img.type !== 'image/png') {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " img.type = 'image/png';\n", - " }\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " img\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * https://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.key === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.key;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.key !== 'Control') {\n", - " value += 'ctrl+';\n", - " }\n", - " else if (event.altKey && event.key !== 'Alt') {\n", - " value += 'alt+';\n", - " }\n", - " else if (event.shiftKey && event.key !== 'Shift') {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k' + event.key;\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.binaryType = comm.kernel.ws.binaryType;\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " function updateReadyState(_event) {\n", - " if (comm.kernel.ws) {\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " } else {\n", - " ws.readyState = 3; // Closed state.\n", - " }\n", - " }\n", - " comm.kernel.ws.addEventListener('open', updateReadyState);\n", - " comm.kernel.ws.addEventListener('close', updateReadyState);\n", - " comm.kernel.ws.addEventListener('error', updateReadyState);\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " var data = msg['content']['data'];\n", - " if (data['blob'] !== undefined) {\n", - " data = {\n", - " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", - " };\n", - " }\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(data);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_device_pixel_ratio', {\n", - " device_pixel_ratio: fig.ratio,\n", - " });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'dblclick',\n", - " on_mouse_event_closure('dblclick')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " fig.rubberband_canvas.style.cursor = msg['cursor'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " var img = evt.data;\n", - " if (img.type !== 'image/png') {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " img.type = 'image/png';\n", - " }\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " img\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from https://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * https://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.key === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.key;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.key !== 'Control') {\n", - " value += 'ctrl+';\n", - " }\n", - " else if (event.altKey && event.key !== 'Alt') {\n", - " value += 'alt+';\n", - " }\n", - " else if (event.shiftKey && event.key !== 'Shift') {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k' + event.key;\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.binaryType = comm.kernel.ws.binaryType;\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " function updateReadyState(_event) {\n", - " if (comm.kernel.ws) {\n", - " ws.readyState = comm.kernel.ws.readyState;\n", - " } else {\n", - " ws.readyState = 3; // Closed state.\n", - " }\n", - " }\n", - " comm.kernel.ws.addEventListener('open', updateReadyState);\n", - " comm.kernel.ws.addEventListener('close', updateReadyState);\n", - " comm.kernel.ws.addEventListener('error', updateReadyState);\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " var data = msg['content']['data'];\n", - " if (data['blob'] !== undefined) {\n", - " data = {\n", - " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", - " };\n", - " }\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(data);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Get all remaining shot IDs\n", - "shot_ids = problem.acquisitions.remaining_shot_ids\n", - "\n", - "# Run an asynchronous loop across all shot IDs\n", - "@runtime.async_for(shot_ids)\n", - "async def loop(worker, shot_id):\n", - " runtime.logger.info('Giving shot %d to %s' % (shot_id, worker.uid))\n", - "\n", - " # Fetch one sub-problem corresponding to a shot ID\n", - " sub_problem = problem.sub_problem(shot_id)\n", - " \n", - " # Access the source wavelets of this shot\n", - " wavelets = sub_problem.shot.wavelets\n", - " \n", - " # Execute the PDE forward\n", - " traces = await pde(wavelets, vp_true,\n", - " problem=sub_problem,\n", - " runtime=worker).result()\n", - "\n", - " runtime.logger.info('Shot %d retrieved' % sub_problem.shot_id)\n", - "\n", - " # Store the retrieved traces into the shot\n", - " shot = problem.acquisitions.get(shot_id)\n", - " shot.observed.data[:] = traces.data\n", - "\n", - " runtime.logger.info('Retrieved traces for shot %d' % sub_problem.shot_id)\n", - "\n", - "# Because this is an asynchronous loop, it needs to be awaited \n", - "_ = await loop\n", - "\n", - "# Plot the result\n", - "_ = problem.acquisitions.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "continuing-portsmouth", - "metadata": {}, - "source": [ - "Because the loop we just ran is a very common piece of code, we can obtain the same result by running the utility function `forward()`:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "internal-ability", - "metadata": {}, - "outputs": [], - "source": [ - "from stride import forward\n", - "\n", - "# Run default forward workflow\n", - "# await forward(problem, pde, vp_true, dump=False) # uncomment to run using utility function" - ] - }, - { - "cell_type": "markdown", - "id": "vietnamese-favor", - "metadata": {}, - "source": [ - "## Starting model\n", - "\n", - "Before we can proceed with the imaging process, we need to determine a starting point for our inversion, a starting model." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "secret-metadata", - "metadata": {}, - "outputs": [], - "source": [ - "vp = ScalarField.parameter(name='vp', grid=grid, needs_grad=True)\n", - "vp.fill(1500.)\n", - "\n", - "problem.medium.add(vp)" - ] - }, - { - "cell_type": "markdown", - "id": "drawn-vietnam", - "metadata": {}, - "source": [ - "Unlike our forward example, the speed-of-sound field is unknown to us at this point. So, we define our starting guess for the speed of sound to be homogeneous with a value of 1500 m/s. Because we are going to run our inversion with respect to `vp`, we also define the field with `needs_grad=True`. That will instruct Stride to calculate the gradient of this variable when running the optimisation loop.\n", - "\n", - "You can also see that the field has now been instantiated using `parameter()`. This will turn `vp` into a remotely addressable object. What this means is that, as `vp` travels through our Mosaic network, it will always keep a reference to its original object here in our code. This will effectively allow us to accumulate the gradients calculated across different workers into a single local buffer.\n", - "\n", - "## Imaging operators\n", - "\n", - "Apart from our PDE operator, which we have already defined above, we will need to define an operator for our loss function:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "sophisticated-minute", - "metadata": {}, - "outputs": [], - "source": [ - "from stride import L2DistanceLoss \n", - "\n", - "loss = L2DistanceLoss.remote(len=runtime.num_workers)" - ] - }, - { - "cell_type": "markdown", - "id": "statistical-making", - "metadata": {}, - "source": [ - "We will also need some operators to proprocess the source wavelents and the modelled and observed data traces:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "departmental-apple", - "metadata": {}, - "outputs": [], - "source": [ - "from stride import ProcessWavelets, ProcessObserved, ProcessTraces\n", - "\n", - "process_wavelets = ProcessWavelets.remote(len=runtime.num_workers)\n", - "process_observed = ProcessObserved.remote(len=runtime.num_workers)\n", - "process_traces = ProcessTraces.remote(len=runtime.num_workers)" - ] - }, - { - "cell_type": "markdown", - "id": "damaged-translation", - "metadata": {}, - "source": [ - "Finally, we will need an optimiser to update the speed of sound model after each iteration. In this case, we use gradient descent." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "timely-consideration", - "metadata": {}, - "outputs": [], - "source": [ - "from stride import GradientDescent, ProcessGlobalGradient, ProcessModelIteration\n", - "\n", - "step_size = 10\n", - "process_grad = ProcessGlobalGradient()\n", - "process_model = ProcessModelIteration(min=1400., max=1700.)\n", - "\n", - "optimiser = GradientDescent(vp, step_size=step_size,\n", - " process_grad=process_grad,\n", - " process_model=process_model)" - ] - }, - { - "cell_type": "markdown", - "id": "understanding-theorem", - "metadata": {}, - "source": [ - "You can see that we have also provided to the optimiser some pre-defined processing steps. These will be used to prepare the gradient before updating the variable, and to process the variable after the update. \n", - "\n", - "Among other things, these processing steps will normalise and smooth the gradient, and will clip the speed of sound of the updated model between 1400 m/s and 1700 m/s.\n", - "\n", - "## Inverse problem - Estimating speed of sound\n", - "\n", - "We can now proceed to solve the inverse problem, that is finding the speed of sound that explains the data that we have generated above.\n", - "\n", - "To obtain a better posed optimisation, we use a multi-scale approach. We will start our inversion by using only low frequencies to construct our model. As the inversion progresses, we will add higher frequencies until we reach the maximum desired level of detail.\n", - "\n", - "We can do this by dividing our optimisation in `Block`s and specifying a maximum frequency. Each `Block` will run for a number of specified iterations.\n", - "\n", - "During each iteration, only a subset of the shots will be used by defining the `select_shots` field. In this case, 15 shots will be used for each iteration, and they will be selected randomly without replacement." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "automotive-dayton", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "HEAD Starting iteration 1 (out of 4), block 1 (out of 2)\n", - "HEAD Giving shot 12 to worker:0:0\n", - "HEAD Giving shot 20 to worker:0:1\n", - "WORKER:0:1 (ShotID 20) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 gcc -march=native -O3 -g -fPIC -Wall -std=c99 -Wno-unused-result -Wno-unused-variable -Wno-unused-but-set-variable -ffast-math -shared -fopenmp /tmp/devito-jitcache-uid1000/5fbdc4140dbd11c63759b13050cbff7ce8ae11c5.c -lm -o /tmp/devito-jitcache-uid1000/5fbdc4140dbd11c63759b13050cbff7ce8ae11c5.so\n", - "WORKER:0:1 (ShotID 20) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 20) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 20) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:1 (ShotID 20) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 20) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 20) Expected wavefield size 0.5158 GB\n", - "WORKER:0:1 Operator `acoustic_iso_state` instance configuration:\n", - "WORKER:0:1 \t * name=acoustic_iso_state\n", - "WORKER:0:1 \t * subs={h_x: 0.0005, h_y: 0.0005, dt: 8e-08}\n", - "WORKER:0:1 \t * opt=advanced-fsg\n", - "WORKER:0:1 \t * devicecreate=(p(t, x, y), p_saved(time_under, x, y))\n", - "WORKER:0:1 Operator `acoustic_iso_state` generated in 1.81 s\n", - "WORKER:0:1 * lowering.Clusters: 0.98 s (54.2 %)\n", - "WORKER:0:1 * specializing.Clusters: 0.55 s (30.4 %)\n", - "WORKER:0:1 * lowering.IET: 0.46 s (25.5 %)\n", - "WORKER:0:1 Flops reduction after symbolic optimization: [104 --> 59]\n", - "WORKER:0:1 Operator `acoustic_iso_state` jit-compiled `/tmp/devito-jitcache-uid1000/5fbdc4140dbd11c63759b13050cbff7ce8ae11c5.c` in 0.31 s with `GNUCompiler`\n", - "WORKER:0:1 (ShotID 20) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.58 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 44.81 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.49 s [OI=2.63, 48.81 GFlops/s, 1.14 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.07 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 47.93 GFlops/s, 11.99 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 20) Completed state equation run for shot\n", - "HEAD Functional value for shot 20: loss 1.946267e+00 for shot 20\n", - "WORKER:0:0 (ShotID 12) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 12) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 12) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:0 (ShotID 12) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 12) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 12) Expected wavefield size 0.5158 GB\n", - "WORKER:0:0 Operator `acoustic_iso_state` instance configuration:\n", - "WORKER:0:0 \t * name=acoustic_iso_state\n", - "WORKER:0:0 \t * subs={h_x: 0.0005, h_y: 0.0005, dt: 8e-08}\n", - "WORKER:0:0 \t * opt=advanced-fsg\n", - "WORKER:0:0 \t * devicecreate=(p(t, x, y), p_saved(time_under, x, y))\n", - "WORKER:0:0 Operator `acoustic_iso_state` generated in 1.86 s\n", - "WORKER:0:0 * lowering.Clusters: 1.09 s (58.7 %)\n", - "WORKER:0:0 * specializing.Clusters: 0.54 s (29.1 %)\n", - "WORKER:0:0 * lowering.Expressions: 0.39 s (21.0 %)\n", - "WORKER:0:0 Flops reduction after symbolic optimization: [104 --> 59]\n", - "WORKER:0:0 Operator `acoustic_iso_state` fetched `/tmp/devito-jitcache-uid1000/5fbdc4140dbd11c63759b13050cbff7ce8ae11c5.c` in 1.04 s from jit-cache\n", - "WORKER:0:0 (ShotID 12) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.60 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 43.32 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.53 s [OI=2.63, 44.85 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.08 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.20 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 52.10 GFlops/s, 13.03 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 12) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 12) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 12: loss 1.523072e+00 for shot 12\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 gcc -march=native -O3 -g -fPIC -Wall -std=c99 -Wno-unused-result -Wno-unused-variable -Wno-unused-but-set-variable -ffast-math -shared -fopenmp /tmp/devito-jitcache-uid1000/9060b3840c89a6c5c9a96a8b9110f428af33ab06.c -lm -o /tmp/devito-jitcache-uid1000/9060b3840c89a6c5c9a96a8b9110f428af33ab06.so\n", - "WORKER:0:1 (ShotID 20) Preparing to run adjoint for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` instance configuration:\n", - "WORKER:0:1 \t * name=acoustic_iso_adjoint\n", - "WORKER:0:1 \t * subs={h_x: 0.0005, h_y: 0.0005, dt: 8e-08}\n", - "WORKER:0:1 \t * opt=advanced-fsg\n", - "WORKER:0:1 \t * devicecreate=(p_a(t, x, y),)\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` generated in 1.13 s\n", - "WORKER:0:1 * lowering.Clusters: 0.61 s (54.3 %)\n", - "WORKER:0:1 * specializing.Clusters: 0.30 s (26.7 %)\n", - "WORKER:0:1 * lowering.Expressions: 0.25 s (22.3 %)\n", - "WORKER:0:1 Flops reduction after symbolic optimization: [85 --> 47]\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` jit-compiled `/tmp/devito-jitcache-uid1000/9060b3840c89a6c5c9a96a8b9110f428af33ab06.c` in 0.27 s with `GNUCompiler`\n", - "WORKER:0:1 (ShotID 20) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.77 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 32.94 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.64 s [OI=2.63, 37.56 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.07 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 24.64 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 20) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 20\n", - "HEAD Giving shot 31 to worker:0:1\n", - "WORKER:0:0 (ShotID 12) Preparing to run adjoint for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` instance configuration:\n", - "WORKER:0:0 \t * name=acoustic_iso_adjoint\n", - "WORKER:0:0 \t * subs={h_x: 0.0005, h_y: 0.0005, dt: 8e-08}\n", - "WORKER:0:0 \t * opt=advanced-fsg\n", - "WORKER:0:0 \t * devicecreate=(p_a(t, x, y),)\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` generated in 1.13 s\n", - "WORKER:0:0 * lowering.Clusters: 0.56 s (50.0 %)\n", - "WORKER:0:0 * specializing.Clusters: 0.26 s (23.3 %)\n", - "WORKER:0:0 * lowering.IET: 0.24 s (21.5 %)\n", - "WORKER:0:0 * lowering.Expressions: 0.23 s (20.6 %)\n", - "WORKER:0:0 Flops reduction after symbolic optimization: [85 --> 47]\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` fetched `/tmp/devito-jitcache-uid1000/9060b3840c89a6c5c9a96a8b9110f428af33ab06.c` in 0.03 s from jit-cache\n", - "WORKER:0:0 (ShotID 12) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.10 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 23.06 GFlops/s, 0.51 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.95 s [OI=2.63, 25.22 GFlops/s, 0.59 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.84 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 13.95 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 12) Completed adjoint equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 31) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 31) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 31) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 31) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:1 (ShotID 31) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 31) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 31) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.79 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 32.90 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.67 s [OI=2.63, 35.97 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 35.21 GFlops/s, 8.81 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 31) Completed state equation run for shot\n", - "HEAD Retrieved gradient for shot 12\n", - "HEAD Giving shot 34 to worker:0:0\n", - "HEAD Functional value for shot 31: loss 2.192256e+00 for shot 31\n", - "WORKER:0:0 (ShotID 34) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 34) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 34) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:0 (ShotID 34) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 34) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 34) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.40 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 64.98 GFlops/s, 1.39 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.35 s [OI=2.63, 69.84 GFlops/s, 1.63 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.98 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 60.09 GFlops/s, 15.03 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 34) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 34) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 31) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 31) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.47 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 53.96 GFlops/s, 1.18 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.39 s [OI=2.63, 61.26 GFlops/s, 1.43 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.08 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.06 s [OI=0.25, 27.92 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 31) Completed adjoint equation run for shot\n", - "HEAD Functional value for shot 34: loss 2.359570e+00 for shot 34\n", - "HEAD Retrieved gradient for shot 31\n", - "HEAD Giving shot 39 to worker:0:1\n", - "WORKER:0:0 (ShotID 34) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 34) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.54 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 46.97 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.45 s [OI=2.63, 53.72 GFlops/s, 1.25 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.71 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 24.84 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 34) Completed adjoint equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 34\n", - "HEAD Giving shot 45 to worker:0:0\n", - "WORKER:0:1 (ShotID 39) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 39) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 39) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 39) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:1 (ShotID 39) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 39) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 39) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.91 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 28.56 GFlops/s, 0.61 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.77 s [OI=2.63, 30.95 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.06 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.78 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 33.97 GFlops/s, 8.50 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 39) Completed state equation run for shot\n", - "HEAD Functional value for shot 39: loss 1.959321e+00 for shot 39\n", - "WORKER:0:0 (ShotID 45) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 45) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 45) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:0 (ShotID 45) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 45) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 45) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.40 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 64.98 GFlops/s, 1.39 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.35 s [OI=2.63, 68.63 GFlops/s, 1.60 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 59.70 GFlops/s, 14.93 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 45) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 45) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 45: loss 1.496486e+00 for shot 45\n", - "WORKER:0:1 (ShotID 39) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 39) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.80 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 31.70 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.68 s [OI=2.63, 35.37 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.58 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 15.81 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 39) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 39\n", - "HEAD Giving shot 48 to worker:0:1\n", - "WORKER:0:0 (ShotID 45) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 45) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.62 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 40.91 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.52 s [OI=2.63, 46.52 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 3.67 GFlops/s, 0.07 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 45) Completed adjoint equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 45\n", - "HEAD Giving shot 58 to worker:0:0\n", - "WORKER:0:0 (ShotID 58) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 58) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 58) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:0 (ShotID 58) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 58) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 58) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.53 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 49.04 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.45 s [OI=2.63, 53.60 GFlops/s, 1.25 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.07 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.12 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 39.04 GFlops/s, 9.76 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 58) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 58) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 48) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 48) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 48) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:1 (ShotID 48) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 48) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 48) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.99 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 26.26 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.88 s [OI=2.63, 27.26 GFlops/s, 0.64 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.59 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 28.20 GFlops/s, 7.05 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 48) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 48) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 58: loss 1.289033e+00 for shot 58\n", - "HEAD Functional value for shot 48: loss 1.115091e+00 for shot 48\n", - "WORKER:0:0 (ShotID 58) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 58) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.65 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 39.02 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.53 s [OI=2.63, 45.04 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.19 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.31 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 58) Completed adjoint equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 58\n", - "HEAD Giving shot 59 to worker:0:0\n", - "WORKER:0:1 (ShotID 48) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 48) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.38 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 18.38 GFlops/s, 0.41 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 1.21 s [OI=2.63, 19.67 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.23 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.12 s [OI=0.25, 13.63 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 48) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 48\n", - "HEAD Giving shot 68 to worker:0:1\n", - "WORKER:0:0 (ShotID 59) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 59) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 59) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:0 (ShotID 59) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 59) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 59) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.78 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 33.32 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.68 s [OI=2.63, 35.21 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.83 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 36.49 GFlops/s, 9.13 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 59) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 59) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 59: loss 1.324072e+00 for shot 59\n", - "WORKER:0:1 (ShotID 68) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 68) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 68) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:1 (ShotID 68) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 68) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 68) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.52 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 49.98 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.44 s [OI=2.63, 54.79 GFlops/s, 1.28 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.49 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 48.05 GFlops/s, 12.02 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 68) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 68) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 68: loss 1.355873e+00 for shot 68\n", - "WORKER:0:0 (ShotID 59) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 59) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.88 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 28.82 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.73 s [OI=2.63, 32.74 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.15 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 18.56 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 59) Completed adjoint equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 59\n", - "HEAD Giving shot 77 to worker:0:0\n", - "WORKER:0:1 (ShotID 68) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 68) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.55 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 46.11 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.46 s [OI=2.63, 51.83 GFlops/s, 1.21 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.38 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.06 s [OI=0.25, 27.07 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 68) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 68\n", - "HEAD Giving shot 97 to worker:0:1\n", - "WORKER:0:0 (ShotID 77) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 77) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 77) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:0 (ShotID 77) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 77) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 77) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.72 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 36.10 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.58 s [OI=2.63, 41.06 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.55 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 32.89 GFlops/s, 8.23 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 77) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 77) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 97) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 97) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 97) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:1 (ShotID 97) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 97) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 97) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 44.05 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.49 s [OI=2.63, 49.43 GFlops/s, 1.15 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.09 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.62 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 38.84 GFlops/s, 9.71 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 97) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 97) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 77: loss 1.654528e+00 for shot 77\n", - "HEAD Functional value for shot 97: loss 1.617715e+00 for shot 97\n", - "WORKER:0:0 (ShotID 77) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 77) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.69 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 36.76 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.56 s [OI=2.63, 42.64 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.41 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.96 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 77) Completed adjoint equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 77\n", - "HEAD Giving shot 109 to worker:0:0\n", - "WORKER:0:1 (ShotID 97) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 97) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.89 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 28.50 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.73 s [OI=2.63, 32.90 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.42 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.27 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 97) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 97\n", - "HEAD Giving shot 110 to worker:0:1\n", - "WORKER:0:0 (ShotID 109) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 109) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 109) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:0 (ShotID 109) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 109) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 109) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 41.92 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.53 s [OI=2.63, 45.40 GFlops/s, 1.06 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 34.29 GFlops/s, 8.58 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 109) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 109) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 109: loss 1.518434e+00 for shot 109\n", - "WORKER:0:1 (ShotID 110) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 110) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 110) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:1 (ShotID 110) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 110) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 110) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.68 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 38.22 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.58 s [OI=2.63, 41.36 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.89 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 31.94 GFlops/s, 7.99 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 110) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 110) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 110: loss 1.544929e+00 for shot 110\n", - "WORKER:0:1 (ShotID 110) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 110) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.71 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 35.72 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.63, 42.45 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.93 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.61 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 110) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 110\n", - "HEAD Giving shot 117 to worker:0:1\n", - "WORKER:0:0 (ShotID 109) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 109) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.16 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 21.87 GFlops/s, 0.48 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.99 s [OI=2.63, 24.09 GFlops/s, 0.57 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.04 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 15.83 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 109) Completed adjoint equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 109\n", - "WORKER:0:1 (ShotID 117) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 117) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 117) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.150 μs)\n", - "WORKER:0:1 (ShotID 117) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 117) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 117) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.48 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 54.15 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.42 s [OI=2.63, 57.40 GFlops/s, 1.34 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.09 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.52 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 62.46 GFlops/s, 15.62 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 117) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 117) Spatial grid spacing (0.500 mm | 4.317 PPW) is higher than dispersion limit (0.432 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 117: loss 1.120244e+00 for shot 117\n", - "WORKER:0:1 (ShotID 117) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 117) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.43 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 58.98 GFlops/s, 1.29 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.37 s [OI=2.63, 64.57 GFlops/s, 1.51 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.92 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.05 s [OI=0.25, 34.71 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 117) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 117\n", - "MONITOR Pending barrier tasks 2\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-4.951813e-06, 4.739960e-06]\n", - "HEAD \t grad after processing in range [-1.000000e+00, 9.567541e-01]\n", - "HEAD \t variable range before update [1.500000e+03, 1.500000e+03]\n", - "HEAD \t variable range after update [1.490432e+03, 1.510000e+03]\n", - "HEAD Done iteration 1 (out of 4), block 1 (out of 2) - Total loss_freq 2.401689e+01\n", - "HEAD ====================================================================\n", - "HEAD Starting iteration 2 (out of 4), block 1 (out of 2)\n", - "HEAD Giving shot 0 to worker:0:0\n", - "HEAD Giving shot 1 to worker:0:1\n", - "WORKER:0:1 (ShotID 1) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 1) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 1) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 1) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 1) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 1) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.90 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 28.88 GFlops/s, 0.62 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.80 s [OI=2.63, 29.84 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.86 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 39.20 GFlops/s, 9.80 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 1) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 1) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 0) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 0) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 0) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 0) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 0) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 0) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 0) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.99 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 26.26 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.04 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.82 s [OI=2.63, 29.25 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.07 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.78 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 36.94 GFlops/s, 9.24 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 0) Completed state equation run for shot\n", - "HEAD Functional value for shot 1: loss 1.234129e+00 for shot 1\n", - "HEAD Functional value for shot 0: loss 1.485469e+00 for shot 0\n", - "WORKER:0:1 (ShotID 1) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 1) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.54 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 46.97 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.43 s [OI=2.63, 55.51 GFlops/s, 1.30 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.53 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.06 s [OI=0.25, 25.97 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 1) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 1\n", - "HEAD Giving shot 7 to worker:0:1\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 0) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 0) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.22 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 20.79 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 1.03 s [OI=2.63, 23.13 GFlops/s, 0.54 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.21 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.13 s [OI=0.25, 11.72 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 0) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 0\n", - "HEAD Giving shot 11 to worker:0:0\n", - "WORKER:0:1 (ShotID 7) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 7) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 7) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 7) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 7) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 7) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.85 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 30.58 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.73 s [OI=2.63, 33.00 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.48 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 34.53 GFlops/s, 8.64 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 7) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 7) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 7: loss 1.138809e+00 for shot 7\n", - "WORKER:0:0 (ShotID 11) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 11) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 11) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 11) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 11) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 11) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 11) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.58 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 44.81 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.50 s [OI=2.63, 48.17 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 39.56 GFlops/s, 9.89 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 11) Completed state equation run for shot\n", - "HEAD Functional value for shot 11: loss 1.347613e+00 for shot 11\n", - "WORKER:0:1 (ShotID 7) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 7) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.70 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 36.23 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.61 s [OI=2.63, 39.58 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.95 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 22.30 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 7) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 7\n", - "HEAD Giving shot 13 to worker:0:1\n", - "WORKER:0:1 (ShotID 13) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 13) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 13) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 13) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 13) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 13) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.54 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 48.13 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.47 s [OI=2.63, 51.18 GFlops/s, 1.20 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.65 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 49.04 GFlops/s, 12.26 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 13) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 13) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 11) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 11) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.03 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 24.63 GFlops/s, 0.54 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.86 s [OI=2.63, 27.67 GFlops/s, 0.65 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.08 s [OI=6.00, 0.97 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 11) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 11\n", - "HEAD Giving shot 19 to worker:0:0\n", - "HEAD Functional value for shot 13: loss 1.329176e+00 for shot 13\n", - "WORKER:0:0 (ShotID 19) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 19) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 19) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 19) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 19) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 19) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 19) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.80 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 32.49 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.69 s [OI=2.63, 34.84 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.89 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 33.29 GFlops/s, 8.33 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 19) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 13) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 13) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.83 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 30.56 GFlops/s, 0.67 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.69 s [OI=2.63, 34.46 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.67 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 13) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 13\n", - "HEAD Giving shot 78 to worker:0:1\n", - "HEAD Functional value for shot 19: loss 1.285756e+00 for shot 19\n", - "WORKER:0:1 (ShotID 78) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 78) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 78) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 78) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 78) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 78) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.53 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 49.04 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.47 s [OI=2.63, 51.46 GFlops/s, 1.20 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.92 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 61.22 GFlops/s, 15.31 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 78) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 78) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 78: loss 1.078353e+00 for shot 78\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 19) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 19) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.97 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 26.15 GFlops/s, 0.57 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.84 s [OI=2.63, 28.46 GFlops/s, 0.67 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.93 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.21 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 19) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 19\n", - "HEAD Giving shot 79 to worker:0:0\n", - "WORKER:0:0 (ShotID 79) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 79) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 79) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 79) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 79) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 79) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 79) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.68 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 38.22 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.58 s [OI=2.63, 41.27 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.95 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 32.73 GFlops/s, 8.19 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 79) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 78) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 78) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.69 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 36.76 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.58 s [OI=2.63, 41.48 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.28 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 18.34 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 78) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 78\n", - "HEAD Giving shot 82 to worker:0:1\n", - "HEAD Functional value for shot 79: loss 1.062664e+00 for shot 79\n", - "WORKER:0:1 (ShotID 82) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 82) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 82) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 82) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 82) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 82) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.41 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 63.39 GFlops/s, 1.35 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.03 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.34 s [OI=2.63, 71.37 GFlops/s, 1.66 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 62.18 GFlops/s, 15.55 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 82) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 82) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 82: loss 1.638023e+00 for shot 82\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 79) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 79) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.48 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 52.84 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.41 s [OI=2.63, 58.33 GFlops/s, 1.36 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.72 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.06 s [OI=0.25, 27.38 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 79) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 79\n", - "HEAD Giving shot 84 to worker:0:0\n", - "WORKER:0:1 (ShotID 82) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 82) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.78 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 32.52 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.63 s [OI=2.63, 37.99 GFlops/s, 0.89 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.15 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.65 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 82) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 82\n", - "HEAD Giving shot 87 to worker:0:1\n", - "WORKER:0:0 (ShotID 84) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 84) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 84) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 84) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 84) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 84) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 84) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.02 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 25.48 GFlops/s, 0.55 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.88 s [OI=2.63, 27.26 GFlops/s, 0.64 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.44 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 28.37 GFlops/s, 7.10 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 84) Completed state equation run for shot\n", - "HEAD Functional value for shot 84: loss 1.688484e+00 for shot 84\n", - "WORKER:0:1 (ShotID 87) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 87) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 87) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 87) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 87) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 87) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.39 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 66.64 GFlops/s, 1.42 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.35 s [OI=2.63, 69.75 GFlops/s, 1.63 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 60.08 GFlops/s, 15.02 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 87) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 87) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 87: loss 1.437833e+00 for shot 87\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 84) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 84) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.16 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 21.87 GFlops/s, 0.48 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 1.01 s [OI=2.63, 23.73 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.34 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.93 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 84) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 84\n", - "HEAD Giving shot 95 to worker:0:0\n", - "WORKER:0:1 (ShotID 87) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 87) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.85 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 29.84 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.71 s [OI=2.63, 33.77 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.15 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.37 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 87) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 87\n", - "HEAD Giving shot 103 to worker:0:1\n", - "WORKER:0:0 (ShotID 95) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 95) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 95) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 95) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 95) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 95) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 95) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.12 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 23.21 GFlops/s, 0.50 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.00 s [OI=2.63, 23.97 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.54 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 28.09 GFlops/s, 7.03 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 95) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 103) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 103) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 103) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 103) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 103) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 103) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.83 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 31.32 GFlops/s, 0.67 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.72 s [OI=2.63, 33.12 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.86 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 33.77 GFlops/s, 8.45 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 103) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 103) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 95: loss 1.354384e+00 for shot 95\n", - "HEAD Functional value for shot 103: loss 1.093024e+00 for shot 103\n", - "WORKER:0:1 (ShotID 103) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 103) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.62 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 40.91 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.50 s [OI=2.63, 48.46 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.70 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 18.61 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 103) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 103\n", - "HEAD Giving shot 111 to worker:0:1\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 95) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 95) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.98 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 25.88 GFlops/s, 0.57 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.85 s [OI=2.63, 28.00 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.83 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.94 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 95) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 95\n", - "HEAD Giving shot 115 to worker:0:0\n", - "WORKER:0:1 (ShotID 111) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 111) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 111) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 111) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 111) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 111) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.72 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 36.10 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.62 s [OI=2.63, 38.54 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.89 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 33.82 GFlops/s, 8.46 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 111) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 111) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 115) Spatial grid spacing (0.500 mm | 4.289 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 115) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 115) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 115) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 115) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 115) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 115) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.78 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 33.32 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.66 s [OI=2.63, 36.31 GFlops/s, 0.85 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.85 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 36.51 GFlops/s, 9.13 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 115) Completed state equation run for shot\n", - "HEAD Functional value for shot 111: loss 1.170157e+00 for shot 111\n", - "HEAD Functional value for shot 115: loss 1.260692e+00 for shot 115\n", - "WORKER:0:1 (ShotID 111) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 111) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.62 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 40.91 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.50 s [OI=2.63, 47.58 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.26 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.70 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 111) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 111\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 115) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 115) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.84 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 30.19 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.71 s [OI=2.63, 33.66 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.36 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.32 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 115) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 115\n", - "MONITOR Pending barrier tasks 3\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-7.922218e-06, 3.535966e-06]\n", - "HEAD \t grad after processing in range [-1.000000e+00, 4.461613e-01]\n", - "HEAD \t variable range before update [1.490432e+03, 1.510000e+03]\n", - "HEAD \t variable range after update [1.489276e+03, 1.514527e+03]\n", - "HEAD Done iteration 2 (out of 4), block 1 (out of 2) - Total loss_freq 1.960456e+01\n", - "HEAD ====================================================================\n", - "HEAD Starting iteration 3 (out of 4), block 1 (out of 2)\n", - "HEAD Giving shot 5 to worker:0:0\n", - "HEAD Giving shot 10 to worker:0:1\n", - "WORKER:0:1 (ShotID 10) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 10) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 10) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 10) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 10) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 10) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 10) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.03 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 25.24 GFlops/s, 0.54 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.89 s [OI=2.63, 27.00 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.44 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 32.10 GFlops/s, 8.03 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 10) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 5) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 5) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 5) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 5) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 5) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 5) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 5) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.09 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 23.85 GFlops/s, 0.51 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.93 s [OI=2.63, 25.63 GFlops/s, 0.60 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.08 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.65 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 32.29 GFlops/s, 8.08 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 5) Completed state equation run for shot\n", - "HEAD Functional value for shot 10: loss 1.052294e+00 for shot 10\n", - "HEAD Functional value for shot 5: loss 1.044606e+00 for shot 5\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 10) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 10) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.81 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 31.31 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.67 s [OI=2.63, 35.48 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.10 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 15.53 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 10) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 10\n", - "HEAD Giving shot 21 to worker:0:1\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 5) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 5) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.14 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 22.25 GFlops/s, 0.49 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.97 s [OI=2.63, 24.60 GFlops/s, 0.58 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.08 s [OI=6.00, 0.91 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.29 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 5) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 5\n", - "HEAD Giving shot 24 to worker:0:0\n", - "WORKER:0:1 (ShotID 21) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 21) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 21) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 21) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 21) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 21) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 21) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.74 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 35.13 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.65 s [OI=2.63, 36.95 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.81 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 33.30 GFlops/s, 8.33 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 21) Completed state equation run for shot\n", - "HEAD Functional value for shot 21: loss 1.443231e+00 for shot 21\n", - "WORKER:0:0 (ShotID 24) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 24) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 24) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 24) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 24) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 24) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 24) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.26 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 20.63 GFlops/s, 0.44 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.13 s [OI=2.63, 21.05 GFlops/s, 0.49 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.51 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.09 s [OI=0.50, 26.43 GFlops/s, 6.61 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 24) Completed state equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 21) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 21) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.59 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 42.99 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.47 s [OI=2.63, 50.85 GFlops/s, 1.19 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.29 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 18.85 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 21) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 21\n", - "HEAD Giving shot 40 to worker:0:1\n", - "HEAD Functional value for shot 24: loss 1.615799e+00 for shot 24\n", - "WORKER:0:1 (ShotID 40) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 40) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 40) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 40) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 40) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 40) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 40) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.61 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 42.61 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.51 s [OI=2.63, 47.05 GFlops/s, 1.10 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.50 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 38.83 GFlops/s, 9.71 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 40) Completed state equation run for shot\n", - "HEAD Functional value for shot 40: loss 9.867871e-01 for shot 40\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 24) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 24) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.29 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 19.66 GFlops/s, 0.43 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 1.13 s [OI=2.63, 21.06 GFlops/s, 0.49 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.48 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.12 s [OI=0.25, 13.62 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 24) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 24\n", - "HEAD Giving shot 57 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 40) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 40) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.62 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 40.91 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.51 s [OI=2.63, 47.05 GFlops/s, 1.10 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.18 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.31 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 40) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 40\n", - "HEAD Giving shot 60 to worker:0:1\n", - "WORKER:0:1 (ShotID 60) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 60) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 60) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 60) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 60) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 60) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 60) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.66 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 39.38 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.54 s [OI=2.63, 44.26 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 37.96 GFlops/s, 9.49 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 60) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 57) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 57) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 57) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 57) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 57) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 57) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 57) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.92 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 28.25 GFlops/s, 0.61 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.81 s [OI=2.63, 29.44 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.65 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 29.87 GFlops/s, 7.47 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 57) Completed state equation run for shot\n", - "HEAD Functional value for shot 57: loss 6.731951e-01 for shot 57\n", - "HEAD Functional value for shot 60: loss 1.211993e+00 for shot 60\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 57) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 57) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.57 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 44.50 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.48 s [OI=2.63, 50.28 GFlops/s, 1.17 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.35 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 23.25 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 57) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 57\n", - "HEAD Giving shot 63 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 60) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 60) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.84 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 30.19 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.69 s [OI=2.63, 34.65 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.46 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 15.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 60) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 60\n", - "HEAD Giving shot 64 to worker:0:1\n", - "WORKER:0:0 (ShotID 63) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 63) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 63) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 63) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 63) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 63) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 63) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.50 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 51.98 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.44 s [OI=2.63, 54.82 GFlops/s, 1.28 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.10 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.53 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 51.67 GFlops/s, 12.92 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 63) Completed state equation run for shot\n", - "HEAD Functional value for shot 63: loss 6.177325e-01 for shot 63\n", - "WORKER:0:1 (ShotID 64) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 64) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 64) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 64) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 64) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 64) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 64) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.85 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 30.58 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.03 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.70 s [OI=2.63, 34.07 GFlops/s, 0.80 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.44 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 33.84 GFlops/s, 8.46 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 64) Completed state equation run for shot\n", - "HEAD Functional value for shot 64: loss 8.919188e-01 for shot 64\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 63) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 63) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.50 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 50.72 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.41 s [OI=2.63, 57.99 GFlops/s, 1.35 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.75 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.06 s [OI=0.25, 26.91 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 63) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 63\n", - "HEAD Giving shot 67 to worker:0:0\n", - "WORKER:0:0 (ShotID 67) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 67) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 67) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 67) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 67) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 67) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 67) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.49 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 53.04 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.41 s [OI=2.63, 58.86 GFlops/s, 1.37 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 60.71 GFlops/s, 15.18 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 67) Completed state equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 64) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 64) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.17 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 21.68 GFlops/s, 0.48 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.95 s [OI=2.63, 25.20 GFlops/s, 0.59 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.12 s [OI=6.00, 0.65 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.12 s [OI=0.25, 13.58 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 64) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 64\n", - "HEAD Giving shot 90 to worker:0:1\n", - "HEAD Functional value for shot 67: loss 9.410507e-01 for shot 67\n", - "WORKER:0:1 (ShotID 90) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 90) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 90) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 90) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 90) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 90) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 90) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.55 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 47.26 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.46 s [OI=2.63, 52.22 GFlops/s, 1.22 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.24 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 45.84 GFlops/s, 11.46 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 90) Completed state equation run for shot\n", - "HEAD Functional value for shot 90: loss 1.220387e+00 for shot 90\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 67) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 67) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.73 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 34.74 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.62 s [OI=2.63, 38.82 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.11 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 67) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 67\n", - "HEAD Giving shot 102 to worker:0:0\n", - "WORKER:0:0 (ShotID 102) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 102) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 102) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 102) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 102) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 102) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 102) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.66 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 39.38 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.57 s [OI=2.63, 41.95 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.95 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 33.44 GFlops/s, 8.36 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 102) Completed state equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 90) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 90) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.34 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 18.93 GFlops/s, 0.42 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 1.17 s [OI=2.63, 20.44 GFlops/s, 0.48 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.35 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.12 s [OI=0.25, 12.90 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 90) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 90\n", - "HEAD Giving shot 105 to worker:0:1\n", - "HEAD Functional value for shot 102: loss 8.162838e-01 for shot 102\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 102) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 102) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.75 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 33.82 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.62 s [OI=2.63, 38.85 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.06 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 15.36 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 102) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 102\n", - "HEAD Giving shot 108 to worker:0:0\n", - "WORKER:0:1 (ShotID 105) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 105) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 105) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 105) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 105) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 105) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 105) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.11 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 23.42 GFlops/s, 0.50 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.98 s [OI=2.63, 24.48 GFlops/s, 0.57 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.54 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.09 s [OI=0.50, 25.89 GFlops/s, 6.48 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 105) Completed state equation run for shot\n", - "HEAD Functional value for shot 105: loss 1.023904e+00 for shot 105\n", - "WORKER:0:0 (ShotID 108) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 108) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 108) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 108) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 108) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 108) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 108) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.72 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 36.10 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.62 s [OI=2.63, 38.75 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.97 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 32.73 GFlops/s, 8.19 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 108) Completed state equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 105) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 105) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.58 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 43.73 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.48 s [OI=2.63, 49.70 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.25 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 23.16 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 105) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 105\n", - "HEAD Giving shot 114 to worker:0:1\n", - "HEAD Functional value for shot 108: loss 8.095331e-01 for shot 108\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 108) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 108) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.78 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 32.52 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.64 s [OI=2.63, 37.70 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.96 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.35 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 108) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 108\n", - "WORKER:0:1 (ShotID 114) Spatial grid spacing (0.500 mm | 4.286 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 114) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 114) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 114) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 114) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 114) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 114) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.28 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 20.31 GFlops/s, 0.44 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.12 s [OI=2.63, 21.33 GFlops/s, 0.50 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.46 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.10 s [OI=0.50, 22.26 GFlops/s, 5.57 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 114) Completed state equation run for shot\n", - "HEAD Functional value for shot 114: loss 9.077051e-01 for shot 114\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 114) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 114) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.37 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 68.54 GFlops/s, 1.50 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.32 s [OI=2.63, 75.38 GFlops/s, 1.76 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.62 GFlops/s, 0.10 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.04 s [OI=0.25, 38.25 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 114) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 114\n", - "MONITOR Pending barrier tasks 2\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-4.327476e-06, 5.192824e-06]\n", - "HEAD \t grad after processing in range [-8.336912e-01, 1.000000e+00]\n", - "HEAD \t variable range before update [1.489276e+03, 1.514527e+03]\n", - "HEAD \t variable range after update [1.485060e+03, 1.517948e+03]\n", - "HEAD Done iteration 3 (out of 4), block 1 (out of 2) - Total loss_freq 1.525642e+01\n", - "HEAD ====================================================================\n", - "HEAD Starting iteration 4 (out of 4), block 1 (out of 2)\n", - "HEAD Giving shot 2 to worker:0:0\n", - "HEAD Giving shot 23 to worker:0:1\n", - "WORKER:0:0 (ShotID 2) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 2) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 2) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 2) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 2) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 2) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 2) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.68 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 38.22 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.59 s [OI=2.63, 40.70 GFlops/s, 0.95 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.92 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 34.31 GFlops/s, 8.58 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 2) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 23) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 23) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 23) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 23) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 23) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 23) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 23) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.83 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 31.32 GFlops/s, 0.67 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.73 s [OI=2.63, 32.70 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.83 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 35.98 GFlops/s, 9.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 23) Completed state equation run for shot\n", - "HEAD Functional value for shot 2: loss 8.408039e-01 for shot 2\n", - "HEAD Functional value for shot 23: loss 1.180892e+00 for shot 23\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 2) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 2) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.78 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 32.52 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.61 s [OI=2.63, 39.04 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.08 s [OI=6.00, 0.93 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.85 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 2) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 2\n", - "HEAD Giving shot 32 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 23) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 23) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.32 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 19.22 GFlops/s, 0.42 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 1.14 s [OI=2.63, 20.87 GFlops/s, 0.49 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.24 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.13 s [OI=0.25, 12.50 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 23) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 23\n", - "HEAD Giving shot 33 to worker:0:1\n", - "WORKER:0:0 (ShotID 32) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 32) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 32) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 32) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 32) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 32) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 32) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 41.92 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.55 s [OI=2.63, 43.59 GFlops/s, 1.02 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.08 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.35 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 50.39 GFlops/s, 12.60 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 32) Completed state equation run for shot\n", - "HEAD Functional value for shot 32: loss 1.428600e+00 for shot 32\n", - "WORKER:0:1 (ShotID 33) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 33) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 33) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 33) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 33) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 33) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 33) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.52 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 49.98 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.45 s [OI=2.63, 53.48 GFlops/s, 1.25 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.41 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 48.50 GFlops/s, 12.13 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 33) Completed state equation run for shot\n", - "HEAD Functional value for shot 33: loss 1.282188e+00 for shot 33\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 32) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 32) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.58 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 43.73 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.48 s [OI=2.63, 49.80 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.94 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 23.93 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 32) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 32\n", - "HEAD Giving shot 50 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 33) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 33) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.83 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 30.56 GFlops/s, 0.67 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.68 s [OI=2.63, 35.23 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.20 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.34 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 33) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 33\n", - "HEAD Giving shot 51 to worker:0:1\n", - "WORKER:0:0 (ShotID 50) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 50) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 50) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 50) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 50) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 50) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 50) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.86 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 30.22 GFlops/s, 0.65 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.75 s [OI=2.63, 31.69 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.72 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 29.25 GFlops/s, 7.32 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 50) Completed state equation run for shot\n", - "HEAD Functional value for shot 50: loss 8.628743e-01 for shot 50\n", - "WORKER:0:1 (ShotID 51) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 51) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 51) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 51) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 51) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 51) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 51) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.82 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 31.70 GFlops/s, 0.68 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.70 s [OI=2.63, 34.35 GFlops/s, 0.80 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.79 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 33.10 GFlops/s, 8.28 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 51) Completed state equation run for shot\n", - "HEAD Functional value for shot 51: loss 8.376154e-01 for shot 51\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 50) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 50) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.84 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 30.19 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.66 s [OI=2.63, 36.15 GFlops/s, 0.85 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.10 s [OI=6.00, 0.77 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.31 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 50) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 50\n", - "HEAD Giving shot 52 to worker:0:0\n", - "WORKER:0:0 (ShotID 52) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 52) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 52) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 52) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 52) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 52) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 52) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.74 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 35.13 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.64 s [OI=2.63, 37.51 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.24 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 34.80 GFlops/s, 8.70 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 52) Completed state equation run for shot\n", - "HEAD Functional value for shot 52: loss 7.519278e-01 for shot 52\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 51) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 51) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.12 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 22.65 GFlops/s, 0.50 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.93 s [OI=2.63, 25.80 GFlops/s, 0.60 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.09 s [OI=6.00, 0.86 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 13.89 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 51) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 51\n", - "HEAD Giving shot 54 to worker:0:1\n", - "WORKER:0:1 (ShotID 54) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 54) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 54) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 54) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 54) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 54) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 54) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.65 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 39.99 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.54 s [OI=2.63, 44.41 GFlops/s, 1.04 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.06 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 35.25 GFlops/s, 8.82 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 54) Completed state equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 52) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 52) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.99 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 25.62 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.82 s [OI=2.63, 29.25 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.09 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.22 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 52) Completed adjoint equation run for shot\n", - "HEAD Functional value for shot 54: loss 8.270466e-01 for shot 54\n", - "HEAD Retrieved gradient for shot 52\n", - "HEAD Giving shot 72 to worker:0:0\n", - "WORKER:0:0 (ShotID 72) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 72) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 72) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 72) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 72) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 72) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 72) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.41 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 63.39 GFlops/s, 1.35 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.36 s [OI=2.63, 67.35 GFlops/s, 1.57 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 58.97 GFlops/s, 14.75 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 72) Completed state equation run for shot\n", - "HEAD Functional value for shot 72: loss 8.288234e-01 for shot 72\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 54) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 54) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.00 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 25.36 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.85 s [OI=2.63, 28.30 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.46 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 15.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 54) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 54\n", - "HEAD Giving shot 89 to worker:0:1\n", - "WORKER:0:1 (ShotID 89) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 89) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 89) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 89) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 89) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 89) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 89) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.39 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 18.70 GFlops/s, 0.40 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.23 s [OI=2.63, 19.41 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.44 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.11 s [OI=0.50, 21.85 GFlops/s, 5.47 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 89) Completed state equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 72) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 72) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.65 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 15.37 GFlops/s, 0.34 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 1.45 s [OI=2.63, 16.48 GFlops/s, 0.39 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.10 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.14 s [OI=0.25, 11.30 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 72) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 72\n", - "HEAD Giving shot 93 to worker:0:0\n", - "HEAD Functional value for shot 89: loss 9.078940e-01 for shot 89\n", - "WORKER:0:1 (ShotID 89) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 89) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.91 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 27.87 GFlops/s, 0.61 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.76 s [OI=2.63, 31.56 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.48 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.15 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 89) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 89\n", - "HEAD Giving shot 94 to worker:0:1\n", - "WORKER:0:0 (ShotID 93) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 93) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 93) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 93) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 93) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 93) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 93) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.34 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 19.40 GFlops/s, 0.42 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.19 s [OI=2.63, 20.14 GFlops/s, 0.47 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.51 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.09 s [OI=0.50, 24.75 GFlops/s, 6.19 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 93) Completed state equation run for shot\n", - "HEAD Functional value for shot 93: loss 1.018066e+00 for shot 93\n", - "WORKER:0:1 (ShotID 94) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 94) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 94) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 94) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 94) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 94) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.81 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 32.09 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.69 s [OI=2.63, 34.71 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.85 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 34.73 GFlops/s, 8.69 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 94) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 94) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 93) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 93) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.63 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 40.26 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.51 s [OI=2.63, 46.97 GFlops/s, 1.10 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.88 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 18.08 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 93) Completed adjoint equation run for shot\n", - "HEAD Functional value for shot 94: loss 1.051884e+00 for shot 94\n", - "HEAD Retrieved gradient for shot 93\n", - "HEAD Giving shot 98 to worker:0:0\n", - "WORKER:0:0 (ShotID 98) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 98) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 98) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 98) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 98) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 98) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 98) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.39 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 66.64 GFlops/s, 1.42 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.34 s [OI=2.63, 70.33 GFlops/s, 1.64 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 2.19 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 64.22 GFlops/s, 16.06 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 98) Completed state equation run for shot\n", - "HEAD Functional value for shot 98: loss 9.767208e-01 for shot 98\n", - "WORKER:0:1 (ShotID 94) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 94) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.69 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 15.01 GFlops/s, 0.33 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 1.44 s [OI=2.63, 16.61 GFlops/s, 0.39 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.11 s [OI=6.00, 0.68 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.15 s [OI=0.25, 10.54 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 94) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 94\n", - "HEAD Giving shot 100 to worker:0:1\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 98) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 98) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.00 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 25.36 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.86 s [OI=2.63, 27.78 GFlops/s, 0.65 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.07 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.61 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 98) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 98\n", - "HEAD Giving shot 118 to worker:0:0\n", - "WORKER:0:0 (ShotID 118) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 118) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 118) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 118) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 118) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 118) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 118) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.25 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 20.80 GFlops/s, 0.45 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.09 s [OI=2.63, 21.97 GFlops/s, 0.52 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.56 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.12 s [OI=0.50, 18.69 GFlops/s, 4.68 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 118) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 100) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 100) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 100) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 100) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 100) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 100) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.47 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 17.68 GFlops/s, 0.38 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.28 s [OI=2.63, 18.63 GFlops/s, 0.44 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.04 s [OI=1.32, 0.35 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.11 s [OI=0.50, 21.76 GFlops/s, 5.44 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 100) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 100) Spatial grid spacing (0.500 mm | 4.274 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 118: loss 8.474549e-01 for shot 118\n", - "HEAD Functional value for shot 100: loss 8.085635e-01 for shot 100\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 118) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 118) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.06 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 23.93 GFlops/s, 0.53 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.86 s [OI=2.63, 27.82 GFlops/s, 0.65 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.10 s [OI=6.00, 0.79 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.09 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 118) Completed adjoint equation run for shot\n", - "WORKER:0:1 (ShotID 100) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 100) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.74 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 34.27 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.63, 42.46 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.07 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.12 s [OI=0.25, 13.73 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 100) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 118\n", - "HEAD Retrieved gradient for shot 100\n", - "MONITOR Pending barrier tasks 2\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-5.911557e-06, 2.368513e-06]\n", - "HEAD \t grad after processing in range [-1.000000e+00, 4.006352e-01]\n", - "HEAD \t variable range before update [1.485060e+03, 1.517948e+03]\n", - "HEAD \t variable range after update [1.483172e+03, 1.522786e+03]\n", - "HEAD Done iteration 4 (out of 4), block 1 (out of 2) - Total loss_freq 1.445136e+01\n", - "HEAD ====================================================================\n", - "HEAD Starting iteration 1 (out of 4), block 2 (out of 2)\n", - "HEAD Giving shot 4 to worker:0:0\n", - "HEAD Giving shot 6 to worker:0:1\n", - "WORKER:0:0 (ShotID 4) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 4) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 4) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 4) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 4) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 4) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 4) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.88 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 29.54 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.03 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.73 s [OI=2.63, 32.98 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.81 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 33.79 GFlops/s, 8.45 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 4) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 6) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 6) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 6) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 6) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 6) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 6) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.78 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 33.32 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.64 s [OI=2.63, 37.17 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.62 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 27.91 GFlops/s, 6.98 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 6) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 6) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 6: loss 8.967083e-01 for shot 6\n", - "HEAD Functional value for shot 4: loss 9.750446e-01 for shot 4\n", - "WORKER:0:1 (ShotID 6) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 6) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.40 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 18.12 GFlops/s, 0.40 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 1.22 s [OI=2.63, 19.57 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.54 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.14 s [OI=0.25, 11.61 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 6) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 6\n", - "HEAD Giving shot 16 to worker:0:1\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 4) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 4) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.48 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 17.14 GFlops/s, 0.38 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 1.26 s [OI=2.63, 18.92 GFlops/s, 0.44 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.09 s [OI=6.00, 0.88 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.14 s [OI=0.25, 11.53 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 4) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 4\n", - "HEAD Giving shot 26 to worker:0:0\n", - "WORKER:0:0 (ShotID 26) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 26) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 26) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 26) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 26) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 26) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 26) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.70 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 37.13 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.60 s [OI=2.63, 39.67 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.91 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 31.46 GFlops/s, 7.87 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 26) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 16) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 16) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 16) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 16) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 16) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 16) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.36 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 19.11 GFlops/s, 0.41 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.21 s [OI=2.63, 19.78 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.46 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.10 s [OI=0.50, 22.78 GFlops/s, 5.70 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 16) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 16) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 26: loss 1.607067e+00 for shot 26\n", - "HEAD Functional value for shot 16: loss 1.076450e+00 for shot 16\n", - "WORKER:0:1 (ShotID 16) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 16) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.76 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 33.37 GFlops/s, 0.73 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.64 s [OI=2.63, 37.52 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.01 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 15.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 16) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 26) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 26) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.02 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 24.87 GFlops/s, 0.55 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.87 s [OI=2.63, 27.51 GFlops/s, 0.64 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.30 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 15.64 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 26) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 16\n", - "HEAD Giving shot 38 to worker:0:1\n", - "HEAD Retrieved gradient for shot 26\n", - "HEAD Giving shot 42 to worker:0:0\n", - "WORKER:0:1 (ShotID 38) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 38) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 38) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 38) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 38) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 38) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.80 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 32.49 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.69 s [OI=2.63, 34.49 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.75 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 32.86 GFlops/s, 8.22 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 38) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 38) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 38: loss 1.393568e+00 for shot 38\n", - "WORKER:0:0 (ShotID 42) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 42) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 42) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 42) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 42) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 42) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 42) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.36 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 19.11 GFlops/s, 0.41 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.21 s [OI=2.63, 19.73 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.48 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.10 s [OI=0.50, 24.53 GFlops/s, 6.14 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 42) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 38) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 38) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.52 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 48.77 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.42 s [OI=2.63, 57.10 GFlops/s, 1.33 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.55 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 23.20 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 38) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 42: loss 9.380719e-01 for shot 42\n", - "HEAD Retrieved gradient for shot 38\n", - "HEAD Giving shot 49 to worker:0:1\n", - "WORKER:0:1 (ShotID 49) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 49) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 49) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 49) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 49) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 49) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.89 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 29.21 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.78 s [OI=2.63, 30.65 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.71 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 30.84 GFlops/s, 7.71 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 49) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 49) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 42) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 42) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.80 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 31.70 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.66 s [OI=2.63, 36.20 GFlops/s, 0.85 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.05 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.66 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 42) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 42\n", - "HEAD Giving shot 53 to worker:0:0\n", - "HEAD Functional value for shot 49: loss 9.144747e-01 for shot 49\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 49) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 49) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.75 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 33.82 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.58 s [OI=2.63, 41.25 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.19 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.61 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 49) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 49\n", - "HEAD Giving shot 56 to worker:0:1\n", - "WORKER:0:0 (ShotID 53) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 53) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 53) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 53) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 53) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 53) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 53) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.14 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 22.80 GFlops/s, 0.49 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.98 s [OI=2.63, 24.26 GFlops/s, 0.57 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.61 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.09 s [OI=0.50, 27.34 GFlops/s, 6.84 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 53) Completed state equation run for shot\n", - "HEAD Functional value for shot 53: loss 8.178948e-01 for shot 53\n", - "WORKER:0:1 (ShotID 56) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 56) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 56) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 56) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 56) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 56) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 56) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.46 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 56.50 GFlops/s, 1.21 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.39 s [OI=2.63, 61.94 GFlops/s, 1.45 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.70 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 53.12 GFlops/s, 13.28 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 56) Completed state equation run for shot\n", - "HEAD Functional value for shot 56: loss 8.874173e-01 for shot 56\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 53) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 53) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.66 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 38.43 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.53 s [OI=2.63, 45.14 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.26 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.73 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 53) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 53\n", - "HEAD Giving shot 70 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 56) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 56) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.09 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 23.27 GFlops/s, 0.51 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.92 s [OI=2.63, 25.91 GFlops/s, 0.61 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.08 s [OI=6.00, 1.02 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 56) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 56\n", - "HEAD Giving shot 74 to worker:0:1\n", - "WORKER:0:0 (ShotID 70) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 70) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 70) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 70) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 70) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 70) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 70) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.94 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 27.65 GFlops/s, 0.59 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.82 s [OI=2.63, 29.06 GFlops/s, 0.68 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.81 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 36.73 GFlops/s, 9.19 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 70) Completed state equation run for shot\n", - "HEAD Functional value for shot 70: loss 1.064770e+00 for shot 70\n", - "WORKER:0:1 (ShotID 74) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 74) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 74) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 74) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 74) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 74) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 74) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.71 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 36.61 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.58 s [OI=2.63, 41.03 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 35.60 GFlops/s, 8.90 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 74) Completed state equation run for shot\n", - "HEAD Functional value for shot 74: loss 1.161542e+00 for shot 74\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 70) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 70) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 37.85 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.55 s [OI=2.63, 43.48 GFlops/s, 1.02 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.23 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 15.26 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 70) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 70\n", - "HEAD Giving shot 85 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 74) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 74) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.71 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 35.72 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.57 s [OI=2.63, 41.73 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.09 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 15.62 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 74) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 74\n", - "HEAD Giving shot 88 to worker:0:1\n", - "WORKER:0:0 (ShotID 85) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 85) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 85) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 85) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 85) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 85) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 85) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.76 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 34.20 GFlops/s, 0.73 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.67 s [OI=2.63, 35.72 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.98 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 36.26 GFlops/s, 9.07 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 85) Completed state equation run for shot\n", - "HEAD Functional value for shot 85: loss 1.481090e+00 for shot 85\n", - "WORKER:0:1 (ShotID 88) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 88) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 88) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 88) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 88) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 88) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 88) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.86 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 30.22 GFlops/s, 0.65 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.74 s [OI=2.63, 32.27 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.82 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 33.84 GFlops/s, 8.46 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 88) Completed state equation run for shot\n", - "HEAD Functional value for shot 88: loss 1.304745e+00 for shot 88\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 85) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 85) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.70 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 36.23 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.57 s [OI=2.63, 42.04 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.91 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.71 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 85) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 85\n", - "HEAD Giving shot 106 to worker:0:0\n", - "WORKER:0:0 (ShotID 106) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 106) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 106) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 106) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 106) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 106) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 106) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.63 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 41.26 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.54 s [OI=2.63, 44.65 GFlops/s, 1.04 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.95 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 34.55 GFlops/s, 8.64 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 106) Completed state equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 88) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 88) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.29 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 19.66 GFlops/s, 0.43 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 1.12 s [OI=2.63, 21.30 GFlops/s, 0.50 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.44 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.12 s [OI=0.25, 12.72 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 88) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 88\n", - "HEAD Giving shot 113 to worker:0:1\n", - "HEAD Functional value for shot 106: loss 9.091188e-01 for shot 106\n", - "WORKER:0:1 (ShotID 113) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 113) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 113) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 113) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 113) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 113) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 113) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.69 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 37.67 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.52 s [OI=2.63, 45.81 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.12 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.78 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 53.62 GFlops/s, 13.41 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 113) Completed state equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 106) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 106) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.68 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 37.30 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.63, 41.61 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.41 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.43 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 106) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 106\n", - "HEAD Functional value for shot 113: loss 8.574824e-01 for shot 113\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 113) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 113) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.73 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 34.74 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.63 s [OI=2.63, 37.96 GFlops/s, 0.89 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.93 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.62 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 113) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 113\n", - "MONITOR Pending barrier tasks 2\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-9.599932e-06, 9.604260e-06]\n", - "HEAD \t grad after processing in range [-1.000000e+00, 9.999275e-01]\n", - "HEAD \t variable range before update [1.483172e+03, 1.522786e+03]\n", - "HEAD \t variable range after update [1.479342e+03, 1.527958e+03]\n", - "HEAD Done iteration 1 (out of 4), block 2 (out of 2) - Total loss_freq 1.628544e+01\n", - "HEAD ====================================================================\n", - "HEAD Starting iteration 2 (out of 4), block 2 (out of 2)\n", - "HEAD Giving shot 15 to worker:0:0\n", - "HEAD Giving shot 18 to worker:0:1\n", - "WORKER:0:0 (ShotID 15) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 15) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 15) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 15) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 15) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 15) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 15) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.49 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 53.04 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.44 s [OI=2.63, 55.09 GFlops/s, 1.29 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.72 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 60.19 GFlops/s, 15.05 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 15) Completed state equation run for shot\n", - "HEAD Functional value for shot 15: loss 1.131446e+00 for shot 15\n", - "WORKER:0:1 (ShotID 18) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 18) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 18) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 18) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 18) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 18) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.22 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 21.31 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.03 s [OI=2.63, 23.16 GFlops/s, 0.54 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.08 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.65 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 29.14 GFlops/s, 7.29 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 18) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 18) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 18: loss 9.235082e-01 for shot 18\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 15) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 15) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.50 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 50.72 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.42 s [OI=2.63, 57.95 GFlops/s, 1.35 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.77 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 22.64 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 15) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 15\n", - "HEAD Giving shot 22 to worker:0:0\n", - "WORKER:0:1 (ShotID 18) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 18) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.81 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 31.31 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.67 s [OI=2.63, 35.75 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.93 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.64 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 18) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 18\n", - "HEAD Giving shot 35 to worker:0:1\n", - "WORKER:0:0 (ShotID 22) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 22) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 22) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 22) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 22) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 22) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 22) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.79 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 14.52 GFlops/s, 0.31 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.54 s [OI=2.63, 15.52 GFlops/s, 0.37 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.04 s [OI=1.32, 0.34 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.17 s [OI=0.50, 13.59 GFlops/s, 3.40 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 22) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 35) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 35) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 35) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 35) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 35) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 35) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.21 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 21.48 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.03 s [OI=2.63, 23.29 GFlops/s, 0.55 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.06 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.63 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.12 s [OI=0.50, 18.99 GFlops/s, 4.75 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 35) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 35) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 22: loss 1.258175e+00 for shot 22\n", - "HEAD Functional value for shot 35: loss 1.480431e+00 for shot 35\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 22) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 22) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.85 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 29.84 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.71 s [OI=2.63, 33.77 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.66 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.00 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 22) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 22\n", - "HEAD Giving shot 37 to worker:0:0\n", - "WORKER:0:1 (ShotID 35) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 35) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.18 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 21.50 GFlops/s, 0.47 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 1.00 s [OI=2.63, 23.90 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.72 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.14 s [OI=0.25, 10.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 35) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 35\n", - "HEAD Giving shot 41 to worker:0:1\n", - "WORKER:0:0 (ShotID 37) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 37) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 37) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 37) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 37) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 37) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 37) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.75 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 34.66 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.64 s [OI=2.63, 37.44 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.91 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.09 s [OI=0.50, 25.63 GFlops/s, 6.41 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 37) Completed state equation run for shot\n", - "HEAD Functional value for shot 37: loss 1.235992e+00 for shot 37\n", - "WORKER:0:1 (ShotID 41) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 41) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 41) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 41) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 41) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 41) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.78 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 33.32 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.66 s [OI=2.63, 36.22 GFlops/s, 0.85 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.84 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.09 s [OI=0.50, 26.41 GFlops/s, 6.61 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 41) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 41) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 41: loss 8.219580e-01 for shot 41\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 37) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 37) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.65 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 39.02 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.54 s [OI=2.63, 44.57 GFlops/s, 1.04 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.31 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.18 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 37) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 37\n", - "HEAD Giving shot 55 to worker:0:0\n", - "WORKER:0:1 (ShotID 41) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 41) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.77 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 32.94 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.63 s [OI=2.63, 37.76 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.02 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.22 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 41) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 41\n", - "HEAD Giving shot 62 to worker:0:1\n", - "WORKER:0:0 (ShotID 55) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 55) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 55) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 55) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 55) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 55) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 55) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.23 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 21.13 GFlops/s, 0.45 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.08 s [OI=2.63, 22.06 GFlops/s, 0.52 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.51 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.11 s [OI=0.50, 21.99 GFlops/s, 5.50 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 55) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 62) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 62) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 62) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 62) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 62) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 62) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.64 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 40.61 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.54 s [OI=2.63, 44.03 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.07 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 38.04 GFlops/s, 9.51 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 62) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 62) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 55: loss 8.927285e-01 for shot 55\n", - "HEAD Functional value for shot 62: loss 7.699997e-01 for shot 62\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 62) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 62) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.91 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 27.87 GFlops/s, 0.61 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.75 s [OI=2.63, 31.90 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.70 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.14 s [OI=0.25, 11.43 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 62) Completed adjoint equation run for shot\n", - "WORKER:0:0 (ShotID 55) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 55) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.90 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 28.18 GFlops/s, 0.62 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.76 s [OI=2.63, 31.42 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.58 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.60 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 55) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 62\n", - "HEAD Giving shot 69 to worker:0:1\n", - "HEAD Retrieved gradient for shot 55\n", - "HEAD Giving shot 71 to worker:0:0\n", - "WORKER:0:0 (ShotID 71) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 71) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 71) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 71) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 71) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 71) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 71) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.75 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 34.66 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.68 s [OI=2.63, 35.23 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.84 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 54.39 GFlops/s, 13.60 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 71) Completed state equation run for shot\n", - "HEAD Functional value for shot 71: loss 1.004933e+00 for shot 71\n", - "WORKER:0:1 (ShotID 69) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 69) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 69) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 69) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 69) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 69) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.39 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 18.70 GFlops/s, 0.40 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.24 s [OI=2.63, 19.23 GFlops/s, 0.45 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.47 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.10 s [OI=0.50, 22.94 GFlops/s, 5.74 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 69) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 69) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 69: loss 9.949073e-01 for shot 69\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 71) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 71) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 37.85 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.63, 41.62 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.29 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.46 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 71) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 71\n", - "HEAD Giving shot 73 to worker:0:0\n", - "WORKER:0:0 (ShotID 73) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 73) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 73) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 73) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 73) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 73) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 73) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 41.92 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.55 s [OI=2.63, 43.53 GFlops/s, 1.02 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.77 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 54.48 GFlops/s, 13.62 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 73) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 69) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 69) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.56 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 16.26 GFlops/s, 0.36 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 1.33 s [OI=2.63, 17.93 GFlops/s, 0.42 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.10 s [OI=6.00, 0.74 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.13 s [OI=0.25, 11.76 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 69) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 73: loss 1.036271e+00 for shot 73\n", - "HEAD Retrieved gradient for shot 69\n", - "HEAD Giving shot 76 to worker:0:1\n", - "WORKER:0:1 (ShotID 76) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 76) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 76) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 76) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 76) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 76) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.03 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 25.24 GFlops/s, 0.54 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.87 s [OI=2.63, 27.46 GFlops/s, 0.64 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.06 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.80 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.09 s [OI=0.50, 25.34 GFlops/s, 6.34 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 76) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 76) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 76: loss 9.728077e-01 for shot 76\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 73) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 73) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.44 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 17.62 GFlops/s, 0.39 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 1.26 s [OI=2.63, 18.99 GFlops/s, 0.45 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.32 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.13 s [OI=0.25, 11.77 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 73) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 73\n", - "HEAD Giving shot 80 to worker:0:0\n", - "WORKER:0:1 (ShotID 76) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 76) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.85 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 29.84 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.71 s [OI=2.63, 33.61 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.46 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.12 s [OI=0.25, 13.59 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 76) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 76\n", - "HEAD Giving shot 104 to worker:0:1\n", - "WORKER:0:0 (ShotID 80) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 80) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 80) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 80) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 80) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 80) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 80) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.99 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 26.26 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.81 s [OI=2.63, 29.60 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.09 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.95 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 27.66 GFlops/s, 6.92 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 80) Completed state equation run for shot\n", - "HEAD Functional value for shot 80: loss 1.008627e+00 for shot 80\n", - "WORKER:0:1 (ShotID 104) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 104) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 104) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 104) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 104) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 104) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.71 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 36.61 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.62 s [OI=2.63, 38.93 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.05 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.84 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 34.33 GFlops/s, 8.59 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 104) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 104) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 104: loss 7.571902e-01 for shot 104\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 80) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 80) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.52 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 48.77 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.43 s [OI=2.63, 56.44 GFlops/s, 1.32 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.09 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 80) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 80\n", - "HEAD Giving shot 112 to worker:0:0\n", - "WORKER:0:1 (ShotID 104) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 104) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.79 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 32.11 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.64 s [OI=2.63, 37.21 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.81 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.13 s [OI=0.25, 12.64 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 104) Completed adjoint equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 104\n", - "WORKER:0:0 (ShotID 112) Spatial grid spacing (0.500 mm | 4.138 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 112) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 112) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 112) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 112) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 112) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 112) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.57 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 16.56 GFlops/s, 0.36 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.38 s [OI=2.63, 17.25 GFlops/s, 0.41 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.43 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.12 s [OI=0.50, 20.01 GFlops/s, 5.01 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 112) Completed state equation run for shot\n", - "HEAD Functional value for shot 112: loss 7.941182e-01 for shot 112\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 112) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 112) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.49 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 51.76 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.41 s [OI=2.63, 59.16 GFlops/s, 1.38 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.95 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 22.71 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 112) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 112\n", - "MONITOR Pending barrier tasks 2\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-1.401939e-05, 6.488457e-06]\n", - "HEAD \t grad after processing in range [-1.000000e+00, 4.626409e-01]\n", - "HEAD \t variable range before update [1.479342e+03, 1.527958e+03]\n", - "HEAD \t variable range after update [1.478884e+03, 1.536660e+03]\n", - "HEAD Done iteration 2 (out of 4), block 2 (out of 2) - Total loss_freq 1.508309e+01\n", - "HEAD ====================================================================\n", - "HEAD Starting iteration 3 (out of 4), block 2 (out of 2)\n", - "HEAD Giving shot 3 to worker:0:0\n", - "HEAD Giving shot 14 to worker:0:1\n", - "WORKER:0:1 (ShotID 14) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 14) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 14) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 14) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 14) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 14) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 14) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.63 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 15.95 GFlops/s, 0.34 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.03 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.35 s [OI=2.63, 17.66 GFlops/s, 0.42 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.13 s [OI=5.80, 0.01 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.48 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.10 s [OI=0.50, 22.33 GFlops/s, 5.59 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 14) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 3) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 3) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 3) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 3) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 3) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 3) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.94 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 13.40 GFlops/s, 0.29 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.73 s [OI=2.63, 13.75 GFlops/s, 0.32 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.05 s [OI=1.32, 0.27 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.13 s [OI=0.50, 17.10 GFlops/s, 4.28 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 3) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 3) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 14: loss 9.333594e-01 for shot 14\n", - "HEAD Functional value for shot 3: loss 5.235272e-01 for shot 3\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 14) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 14) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.53 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 47.85 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.44 s [OI=2.63, 54.64 GFlops/s, 1.28 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.57 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 22.99 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 14) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 14\n", - "HEAD Giving shot 28 to worker:0:1\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 3) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 3) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.65 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 15.37 GFlops/s, 0.34 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 1.45 s [OI=2.63, 16.40 GFlops/s, 0.39 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.08 s [OI=6.00, 0.99 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.13 s [OI=0.25, 12.23 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 3) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 3\n", - "HEAD Giving shot 30 to worker:0:0\n", - "WORKER:0:1 (ShotID 28) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 28) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 28) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 28) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 28) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 28) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 28) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.08 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 24.07 GFlops/s, 0.52 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.94 s [OI=2.63, 25.39 GFlops/s, 0.60 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.69 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 30.19 GFlops/s, 7.55 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 28) Completed state equation run for shot\n", - "HEAD Functional value for shot 28: loss 1.493753e+00 for shot 28\n", - "WORKER:0:0 (ShotID 30) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 30) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 30) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 30) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 30) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 30) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 30) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.85 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 30.58 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.70 s [OI=2.63, 34.07 GFlops/s, 0.80 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.06 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.54 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 37.76 GFlops/s, 9.44 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 30) Completed state equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 28) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 28) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.64 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 39.63 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.54 s [OI=2.63, 44.65 GFlops/s, 1.04 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.52 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.87 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 28) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 28\n", - "HEAD Giving shot 36 to worker:0:1\n", - "HEAD Functional value for shot 30: loss 1.461961e+00 for shot 30\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 30) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 30) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.87 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 29.15 GFlops/s, 0.64 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.72 s [OI=2.63, 33.17 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.95 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.12 s [OI=0.25, 13.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 30) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 30\n", - "HEAD Giving shot 43 to worker:0:0\n", - "WORKER:0:1 (ShotID 36) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 36) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 36) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 36) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 36) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 36) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 36) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.12 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 23.21 GFlops/s, 0.50 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.96 s [OI=2.63, 24.79 GFlops/s, 0.58 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.56 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.10 s [OI=0.50, 23.02 GFlops/s, 5.76 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 36) Completed state equation run for shot\n", - "HEAD Functional value for shot 36: loss 1.318288e+00 for shot 36\n", - "WORKER:0:0 (ShotID 43) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 43) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 43) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 43) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 43) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 43) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 43) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 41.92 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.53 s [OI=2.63, 45.63 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.12 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 39.43 GFlops/s, 9.86 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 43) Completed state equation run for shot\n", - "HEAD Functional value for shot 43: loss 8.781539e-01 for shot 43\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 36) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 36) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.66 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 38.43 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.63, 42.98 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.11 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 19.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 36) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 36\n", - "HEAD Giving shot 44 to worker:0:1\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 43) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 43) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.72 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 35.23 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.59 s [OI=2.63, 40.56 GFlops/s, 0.95 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.87 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.12 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 43) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 43\n", - "HEAD Giving shot 47 to worker:0:0\n", - "WORKER:0:1 (ShotID 44) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 44) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 44) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 44) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 44) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 44) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 44) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.27 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 20.47 GFlops/s, 0.44 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.12 s [OI=2.63, 21.28 GFlops/s, 0.50 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.55 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.10 s [OI=0.50, 23.22 GFlops/s, 5.81 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 44) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 47) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 47) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 47) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 47) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 47) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 47) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 47) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.78 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 33.32 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.68 s [OI=2.63, 35.43 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 37.57 GFlops/s, 9.40 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 47) Completed state equation run for shot\n", - "HEAD Functional value for shot 44: loss 8.359061e-01 for shot 44\n", - "HEAD Functional value for shot 47: loss 9.200231e-01 for shot 47\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 44) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 44) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.83 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 30.56 GFlops/s, 0.67 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.69 s [OI=2.63, 34.70 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.79 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.12 s [OI=0.25, 13.15 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 44) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 44\n", - "HEAD Giving shot 61 to worker:0:1\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 47) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 47) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.70 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 36.23 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.57 s [OI=2.63, 42.07 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 3.29 GFlops/s, 0.06 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.62 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 47) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 47\n", - "HEAD Giving shot 66 to worker:0:0\n", - "WORKER:0:1 (ShotID 61) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 61) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 61) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 61) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 61) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 61) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 61) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.67 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 38.79 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.03 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.53 s [OI=2.63, 44.86 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.26 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 39.18 GFlops/s, 9.80 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 61) Completed state equation run for shot\n", - "HEAD Functional value for shot 61: loss 7.898947e-01 for shot 61\n", - "WORKER:0:0 (ShotID 66) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 66) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 66) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 66) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 66) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 66) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 66) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.92 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 28.25 GFlops/s, 0.61 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.80 s [OI=2.63, 29.87 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.66 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 29.48 GFlops/s, 7.37 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 66) Completed state equation run for shot\n", - "HEAD Functional value for shot 66: loss 8.352350e-01 for shot 66\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 61) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 61) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.58 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 43.73 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.47 s [OI=2.63, 50.73 GFlops/s, 1.18 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.18 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.29 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 61) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 61\n", - "HEAD Giving shot 86 to worker:0:1\n", - "WORKER:0:1 (ShotID 86) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 86) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 86) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 86) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 86) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 86) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 86) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.73 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 35.61 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.64 s [OI=2.63, 37.26 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.82 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 54.91 GFlops/s, 13.73 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 86) Completed state equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 66) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 66) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.22 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 20.79 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 1.06 s [OI=2.63, 22.58 GFlops/s, 0.53 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.07 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 15.37 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 66) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 66\n", - "HEAD Giving shot 91 to worker:0:0\n", - "HEAD Functional value for shot 86: loss 1.180445e+00 for shot 86\n", - "WORKER:0:0 (ShotID 91) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 91) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 91) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 91) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 91) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 91) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 91) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.89 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 29.21 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.73 s [OI=2.63, 32.79 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.43 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 27.89 GFlops/s, 6.98 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 91) Completed state equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 86) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 86) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.74 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 34.27 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.63 s [OI=2.63, 38.28 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.79 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.62 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 86) Completed adjoint equation run for shot\n", - "HEAD Functional value for shot 91: loss 9.374047e-01 for shot 91\n", - "HEAD Retrieved gradient for shot 86\n", - "HEAD Giving shot 92 to worker:0:1\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 91) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 91) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.22 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 20.79 GFlops/s, 0.46 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 1.06 s [OI=2.63, 22.64 GFlops/s, 0.53 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.14 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 15.03 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 91) Completed adjoint equation run for shot\n", - "WORKER:0:1 (ShotID 92) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 92) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 92) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 92) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 92) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 92) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 92) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.26 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 20.63 GFlops/s, 0.44 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.12 s [OI=2.63, 21.24 GFlops/s, 0.50 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.56 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 29.16 GFlops/s, 7.29 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 92) Completed state equation run for shot\n", - "HEAD Retrieved gradient for shot 91\n", - "HEAD Giving shot 99 to worker:0:0\n", - "HEAD Functional value for shot 92: loss 1.072309e+00 for shot 92\n", - "WORKER:0:0 (ShotID 99) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 99) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 99) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 99) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 99) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 99) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 99) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.48 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 54.15 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.43 s [OI=2.63, 56.09 GFlops/s, 1.31 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.10 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.67 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 59.66 GFlops/s, 14.92 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 99) Completed state equation run for shot\n", - "HEAD Functional value for shot 99: loss 8.530506e-01 for shot 99\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 92) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 92) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.48 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 52.84 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.41 s [OI=2.63, 58.78 GFlops/s, 1.37 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.59 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.06 s [OI=0.25, 26.55 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 92) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 92\n", - "HEAD Giving shot 119 to worker:0:1\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 99) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 99) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.85 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 29.84 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.72 s [OI=2.63, 33.42 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.74 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.74 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 99) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 99\n", - "WORKER:0:1 (ShotID 119) Spatial grid spacing (0.500 mm | 4.137 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 119) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 119) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 119) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 119) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 119) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 119) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.12 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 23.21 GFlops/s, 0.50 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.01 s [OI=2.63, 23.68 GFlops/s, 0.56 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.58 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 29.14 GFlops/s, 7.29 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 119) Completed state equation run for shot\n", - "HEAD Functional value for shot 119: loss 7.981235e-01 for shot 119\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 119) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 119) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.43 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 58.98 GFlops/s, 1.29 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.37 s [OI=2.63, 65.62 GFlops/s, 1.53 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.93 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.06 s [OI=0.25, 30.41 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 119) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 119\n", - "MONITOR Pending barrier tasks 2\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-9.135183e-06, 1.273635e-05]\n", - "HEAD \t grad after processing in range [-7.176374e-01, 1.000000e+00]\n", - "HEAD \t variable range before update [1.478884e+03, 1.536660e+03]\n", - "HEAD \t variable range after update [1.476284e+03, 1.537669e+03]\n", - "HEAD Done iteration 3 (out of 4), block 2 (out of 2) - Total loss_freq 1.483143e+01\n", - "HEAD ====================================================================\n", - "HEAD Starting iteration 4 (out of 4), block 2 (out of 2)\n", - "HEAD Giving shot 8 to worker:0:0\n", - "HEAD Giving shot 9 to worker:0:1\n", - "WORKER:0:0 (ShotID 8) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 8) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 8) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 8) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 8) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 8) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 8) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.65 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 39.99 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.56 s [OI=2.63, 42.86 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.98 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 34.32 GFlops/s, 8.58 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 8) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 9) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 9) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 9) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 9) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 9) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 9) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 9) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.82 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 31.70 GFlops/s, 0.68 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.72 s [OI=2.63, 33.29 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.90 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 30.49 GFlops/s, 7.63 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 9) Completed state equation run for shot\n", - "HEAD Functional value for shot 8: loss 7.206318e-01 for shot 8\n", - "HEAD Functional value for shot 9: loss 8.290170e-01 for shot 9\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 8) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 8) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.62 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 40.91 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.50 s [OI=2.63, 47.82 GFlops/s, 1.12 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 2.16 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 18.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 8) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 8\n", - "HEAD Giving shot 17 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 9) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 9) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.89 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 28.50 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.76 s [OI=2.63, 31.48 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.03 s [OI=6.00, 2.57 GFlops/s, 0.05 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.75 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 9) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 9\n", - "HEAD Giving shot 25 to worker:0:1\n", - "WORKER:0:0 (ShotID 17) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 17) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 17) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 17) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 17) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 17) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 17) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.87 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 29.88 GFlops/s, 0.64 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.75 s [OI=2.63, 32.01 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.77 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.09 s [OI=0.50, 26.51 GFlops/s, 6.63 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 17) Completed state equation run for shot\n", - "HEAD Functional value for shot 17: loss 8.305575e-01 for shot 17\n", - "WORKER:0:1 (ShotID 25) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 25) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 25) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 25) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 25) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 25) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 25) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.84 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 30.94 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.74 s [OI=2.63, 32.32 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.53 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.06 s [OI=0.50, 37.32 GFlops/s, 9.33 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 25) Completed state equation run for shot\n", - "HEAD Functional value for shot 25: loss 1.253885e+00 for shot 25\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 17) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 17) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.06 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 23.93 GFlops/s, 0.53 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.89 s [OI=2.63, 26.93 GFlops/s, 0.63 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.08 s [OI=6.00, 1.00 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 15.29 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 17) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 17\n", - "HEAD Giving shot 27 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 25) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 25) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.77 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 32.94 GFlops/s, 0.72 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.62 s [OI=2.63, 38.55 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.05 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.37 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 25) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 25\n", - "HEAD Giving shot 29 to worker:0:1\n", - "WORKER:0:0 (ShotID 27) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 27) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 27) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 27) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 27) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 27) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 27) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 45.60 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.49 s [OI=2.63, 48.95 GFlops/s, 1.14 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.07 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 1.08 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 35.85 GFlops/s, 8.97 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 27) Completed state equation run for shot\n", - "HEAD Functional value for shot 27: loss 1.142029e+00 for shot 27\n", - "WORKER:0:1 (ShotID 29) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 29) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 29) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 29) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 29) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 29) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 29) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.86 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 30.22 GFlops/s, 0.65 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.72 s [OI=2.63, 33.29 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.06 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.66 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 31.73 GFlops/s, 7.94 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 29) Completed state equation run for shot\n", - "HEAD Functional value for shot 29: loss 1.122254e+00 for shot 29\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 27) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 27) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.71 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 35.72 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.56 s [OI=2.63, 42.95 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.08 s [OI=6.00, 0.94 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 27) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 27\n", - "HEAD Giving shot 46 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 29) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 29) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.84 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 30.19 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.70 s [OI=2.63, 34.39 GFlops/s, 0.80 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.30 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.27 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 29) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 29\n", - "HEAD Giving shot 65 to worker:0:1\n", - "WORKER:0:0 (ShotID 46) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 46) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 46) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 46) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 46) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 46) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 46) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.50 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 51.98 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.44 s [OI=2.63, 54.47 GFlops/s, 1.27 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.04 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.90 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 59.97 GFlops/s, 15.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 46) Completed state equation run for shot\n", - "HEAD Functional value for shot 46: loss 9.296777e-01 for shot 46\n", - "WORKER:0:1 (ShotID 65) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 65) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 65) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 65) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 65) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 65) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 65) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.50 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 51.98 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.44 s [OI=2.63, 55.27 GFlops/s, 1.29 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.08 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.40 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 46.04 GFlops/s, 11.51 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 65) Completed state equation run for shot\n", - "HEAD Functional value for shot 65: loss 7.687517e-01 for shot 65\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 46) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 46) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.62 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 40.91 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.52 s [OI=2.63, 46.50 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.84 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 23.77 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 46) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 46\n", - "HEAD Giving shot 75 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 65) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 65) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.79 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 32.11 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.67 s [OI=2.63, 35.97 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.70 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.30 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 65) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 65\n", - "HEAD Giving shot 81 to worker:0:1\n", - "WORKER:0:0 (ShotID 75) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 75) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 75) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 75) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 75) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 75) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 75) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.49 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 53.04 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.42 s [OI=2.63, 56.88 GFlops/s, 1.33 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.03 s [OI=5.80, 0.03 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.04 s [OI=0.50, 59.29 GFlops/s, 14.83 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 75) Completed state equation run for shot\n", - "HEAD Functional value for shot 75: loss 9.542434e-01 for shot 75\n", - "WORKER:0:1 (ShotID 81) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 81) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 81) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 81) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 81) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 81) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 81) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.94 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 27.65 GFlops/s, 0.59 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.79 s [OI=2.63, 30.11 GFlops/s, 0.71 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.03 s [OI=1.32, 0.45 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.08 s [OI=0.50, 27.87 GFlops/s, 6.97 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 81) Completed state equation run for shot\n", - "HEAD Functional value for shot 81: loss 1.097703e+00 for shot 81\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 75) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 75) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.04 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 24.39 GFlops/s, 0.54 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.88 s [OI=2.63, 27.17 GFlops/s, 0.64 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.07 s [OI=6.00, 1.17 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 15.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 75) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 75\n", - "HEAD Giving shot 83 to worker:0:0\n", - "WORKER:0:0 (ShotID 83) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 83) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 83) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 83) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 83) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 83) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 83) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.61 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 42.61 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.53 s [OI=2.63, 45.59 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.02 s [OI=5.80, 0.06 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.97 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 36.51 GFlops/s, 9.13 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 83) Completed state equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 81) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 81) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.43 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 17.74 GFlops/s, 0.39 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 1.25 s [OI=2.63, 19.13 GFlops/s, 0.45 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.30 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.13 s [OI=0.25, 12.23 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 81) Completed adjoint equation run for shot\n", - "HEAD Functional value for shot 83: loss 1.162536e+00 for shot 83\n", - "HEAD Retrieved gradient for shot 81\n", - "HEAD Giving shot 96 to worker:0:1\n", - "WORKER:0:1 (ShotID 96) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 96) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 96) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 96) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 96) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 96) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 96) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.64 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 40.61 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 0.58 s [OI=2.63, 41.39 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.10 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.32, 1.44 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.05 s [OI=0.50, 45.92 GFlops/s, 11.48 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 96) Completed state equation run for shot\n", - "HEAD Functional value for shot 96: loss 9.068089e-01 for shot 96\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 83) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 83) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.59 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 15.95 GFlops/s, 0.35 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 1.31 s [OI=2.63, 18.15 GFlops/s, 0.43 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.14 s [OI=6.00, 0.53 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.14 s [OI=0.25, 10.92 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 83) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 83\n", - "HEAD Giving shot 101 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 96) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 96) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 1.54 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 16.47 GFlops/s, 0.36 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 1.35 s [OI=2.63, 17.73 GFlops/s, 0.42 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.08 s [OI=6.00, 0.92 GFlops/s, 0.02 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.12 s [OI=0.25, 13.59 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 96) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 96\n", - "HEAD Giving shot 107 to worker:0:1\n", - "WORKER:0:0 (ShotID 101) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 101) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 101) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 101) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 101) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 101) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 101) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 1.20 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 21.66 GFlops/s, 0.47 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.01 s [OI=0.50, 0.04 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 1.05 s [OI=2.63, 22.75 GFlops/s, 0.53 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.04 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.04 s [OI=1.32, 0.36 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.09 s [OI=0.50, 27.13 GFlops/s, 6.79 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 101) Completed state equation run for shot\n", - "HEAD Functional value for shot 101: loss 5.932735e-01 for shot 101\n", - "WORKER:0:1 (ShotID 107) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 107) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 107) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 107) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 107) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 107) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 107) Running state equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 1.52 s\n", - "WORKER:0:1 Global performance: [OI=1.93, 17.10 GFlops/s, 0.37 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<120> ran in 0.01 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section1<2499,456,485> ran in 1.35 s [OI=2.63, 17.70 GFlops/s, 0.42 GPts/s]\n", - "WORKER:0:1 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section3<<2499,120>,<2499,120,2,2>> ran in 0.04 s [OI=1.32, 0.42 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section4<2499,456,485> ran in 0.10 s [OI=0.50, 23.78 GFlops/s, 5.95 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 107) Completed state equation run for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 101) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 101) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 1.47 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 17.26 GFlops/s, 0.38 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 1.29 s [OI=2.63, 18.46 GFlops/s, 0.43 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.06 s [OI=6.00, 1.21 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.12 s [OI=0.25, 12.81 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 101) Completed adjoint equation run for shot\n", - "HEAD Functional value for shot 107: loss 7.493217e-01 for shot 107\n", - "HEAD Retrieved gradient for shot 101\n", - "HEAD Giving shot 116 to worker:0:0\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 116) Spatial grid spacing (0.500 mm | 4.129 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 107) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 107) Running adjoint equation for shot\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.81 s\n", - "WORKER:0:1 Global performance: [OI=1.68, 31.31 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.68 s [OI=2.63, 35.02 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.04 s [OI=6.00, 1.91 GFlops/s, 0.04 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.73 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 107) Completed adjoint equation run for shot\n", - "WORKER:0:0 (ShotID 116) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 116) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 116) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 116) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 116) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 116) Running state equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.95 s\n", - "WORKER:0:0 Global performance: [OI=1.93, 27.36 GFlops/s, 0.59 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<120> ran in 0.02 s [OI=0.50, 0.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section1<2499,456,485> ran in 0.81 s [OI=2.63, 29.41 GFlops/s, 0.69 GPts/s]\n", - "WORKER:0:0 * section2<<2499,1,2,2>,<2499,1,2,2>> ran in 0.05 s [OI=5.80, 0.02 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section3<<2499,120>,<2499,120,2,2>> ran in 0.02 s [OI=1.32, 0.73 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section4<2499,456,485> ran in 0.07 s [OI=0.50, 34.68 GFlops/s, 8.67 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 116) Completed state equation run for shot\n", - "HEAD Retrieved gradient for shot 107\n", - "HEAD Functional value for shot 116: loss 7.557741e-01 for shot 116\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 116) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 116) Running adjoint equation for shot\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.66 s\n", - "WORKER:0:0 Global performance: [OI=1.68, 38.43 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.56 s [OI=2.63, 42.71 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.05 s [OI=6.00, 1.56 GFlops/s, 0.03 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.06 s [OI=0.25, 26.94 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 116) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 116\n", - "MONITOR Pending barrier tasks 2\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-1.473754e-05, 6.402976e-06]\n", - "HEAD \t grad after processing in range [-1.000000e+00, 4.342713e-01]\n", - "HEAD \t variable range before update [1.476284e+03, 1.537669e+03]\n", - "HEAD \t variable range after update [1.477268e+03, 1.543448e+03]\n", - "HEAD Done iteration 4 (out of 4), block 2 (out of 2) - Total loss_freq 1.381647e+01\n", - "HEAD ====================================================================\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "426b84a0a648498e98549b14664cfb2e", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9e7B1SVkfAP+eXmvtvc/9vNd5Z4ZhgJGoEeQLeAFNFDQSxoCUUmqUUEIM5B9jJWKlgilLzKdl5WI00QplWQZiICVlqkJiTLCIxugnXiIJRgi3gQHm9t4v5773Xqv7+6P76X66V699zjvvmXeYefup2ufsvVavvq/uXz9XMsYYFCpUqFChQoUKFbpjSD3dFShUqFChQoUKFSp0e6kAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFChUqVKhQoTuMCgAsVKhQoUKFChW6w6gAwEKFCt0UfeADHwAR4bd/+7d79971rneBiPB//+//xZvf/Gasrq7i4x//OL71W78VKysrOHPmDH7oh34Ie3t7T0PNCxUqVKgQUwGAhQoVuil67Wtfi7Nnz+Ld735379573vMevPSlL8VXf/VXAwDm8zm+/du/Hd/6rd+KD3zgA/ihH/oh/NIv/RK+93u/93ZXu1ChQoUKCaqf7goUKlTomUV1XeNv/s2/iXe96124ceMGNjY2AACf+MQn8Cd/8if4hV/4BZ92Npvh7W9/O374h38YAPBt3/ZtaJoG/+gf/SP8wR/8Ab7xG7/xaWlDoUKFCt3pVDiAhQoVumn6W3/rb2F/fx/vf//7/bV3v/vdGI/H+P7v//4o7Rvf+MboN9//H//jfzz1FS1UqFChQlkqALBQoUI3TV/1VV+Fr/3ar/Vi4K7r8N73vhevf/3rcfLkSZ+urmucOnUqevbcuXMAgCtXrty+ChcqVKhQoYgKACxUqNCTore85S34oz/6I3ziE5/ABz/4QTzxxBN4y1veEqVp27YH9M6fPw8APWBYqFChQoVuHxUAWKhQoSdF3/d934fJZIL3vOc9eM973oN7770Xr371q3vp3ve+90W///2///cAgFe+8pW3o5qFChUqVChDxQikUKFCT4o2Nzfxnd/5nXjPe96D69ev40d/9EehVHymHI1G+Nmf/Vns7Ozga7/2a/HhD38YP/VTP4UHH3wQf/kv/+WnqeaFChUqVKhwAAsVKvSk6S1veQsuXryI2WyGN7/5zb37TdPgv/yX/4IPfehDeP3rX49/9a/+Fd761rfi13/9129/ZQsVKlSokKfCASxUqNCTpm/7tm+DMWZhmhe/+MXF4rdQoUKFvsSocAALFSpUqFChQoXuMCoAsFChQoUKFSpU6A4jMofJbwoVKlSoUKFChQo9q6hwAAsVKlSoUKFChe4wKgCwUKFChQoVKlToDqMCAAsVKlSoUKFChe4wKgCwUKFChQoVKlToDqPiB/AWSGuNxx9/HGtrayCip7s6hQoVKlToS5iMMdje3sY999zTi5pznHRwcIDZbHbL+YxGI0wmk2OoUaEvRSoA8Bbo8ccfx3333fd0V6NQoUKFCj2D6JFHHsFznvOcpyTvg4MDPP/+VZy/2N1yXufOncPDDz9cQOCzlAoAvAVaW1sDAHzlm34c1WgCEGAcJ5DYu450spMyCQ1ABjCUvxdRjsHongdCHr3yB/IyRDZP49Iuqmem3B4dlQG6qF1DDolcGkOU71eZNOmPNK1Rrn+0uJj2W9IXvlwj8nB5kzbZcczmN9TWgfEYGlufr6QkPaW3ub4muUZpuuSC6ENZpk+X5mEy6c1wG6MyEsq9S9n6m9A2k1bfyPIXlJepY1R2kjY3NnLcDNl5ctPvVlKfofJ8GmR+L2ojMnkdto7knhsqF+EdA+z7QRqh/w+r6yKnZAvGrXftKCTGeWFZuboeso5lxwtANzvAJ371/+v3jqeCZrMZzl/s8PBH7sf62pPnMm5tazz/ZV/AbDYrAPBZSgUA3gKx2LcaTVCNJ71FM9qQjrhA9O7xs5mFauFmnmyW/rK6ycX9MDpssc3UKdqkj7qoi7J6/XoTC34K5nJ1HEovN3Zbjz74S0Gq79eBfpdgEsZtmIeA2KGDRA/oiLQpsMuCucw9f3/RJqsEwNTxPd/Wo8zxtEzk+zhX74WAcqDvhto9eIhbAMKj63y4uElgtvCdy60ZSb1SwJ3NPzdXBuq58DCbq2/6jnB56ZxelEeOMuXe1Hu8iJK2L1qzh55ZVH7uUALgtqgMrazaz5Ol7qh9WOgZSwUAHgcliyXp+J6nIy4yh52wUxriQgylydazl+lA+UdZZIcAylEoArWZRR4LNq1FdYDYpFMgGgGWfl+l5S7i0C0E1RCbqbzGgCHJM+KkmLCJIrOpGIIDYtQHJmI+Gd8FFIBACtiQzqV+nVMgkZJJGQ9JH0d5UGYvTUGoEm1h8LNgTkVjl/a/L9fk308kQBDGl0cw/vqiPuK+MUrUl8sYeocWAYpMH8nnZL18fdNDkgR9uXcyqSeZ0D+GKOSbFp+US9o+y2NmFAGZ9/jIlNTXIIxRrm95ngwCYmCwrz1W5uqSaHuuXvKhtM8zxTzpPihU6CmgAgCPiXixYVC1CJQtFPkOHQyHgGIGqPh7yXNDYs6FHLncgpUDOAPlRBwhyXFYkG/YRA/pt6ENLMe9yOQny+L8fJ+mouIjgJ8epzACXgmY5TYydyTTRxEIkvmlAFZseiDARIhT5C0AV0pp3eV8HjwoyH6QlxVASoBAWV/i/Llc0Y8DBw5dUe++FOEHkDFQz6QfuMyhach5yu8eAAwAYglO4oxE23KF5d53k/xftCZEczEDaIcAjOyuQ4CgvRQDLg9wKYBP+86Ed96Kfg2MokwfBiA6SAMAWIKzXH0lcO3dz4HigbwW9muujnwvt54+DcBPw0DfQsG38myhZwYVAHhclAKqBeAvEiHKZ4+yyCTXB8Vg4rkcQJT1PBIlC1lOtBnVQ9aVMn1yFDoO8JeApUN1JmWfpuAmArmuyBSYDDStNw/89ZB32kYPninuZ4IJ+50UIQMAg7VeXhkwndbBJHsdAyWRJ4O3vqhX9IsBjAZ8N1LI15ADhwIMRmVw3UUVVGeig0MKmKFMAMAOAPQ4oSAxtga9d06OmwR5Ik2PCybAnRFp7JcUFYd+isCLLJsyZUgS7fd5OGBEWsxHTm64igvetyGAkh42kjpH80CMgQV78AcbMgC0id99rrOJ69ujHDiDeFbWNX0HOe9FAC0FuuK6bYP7uQhw5n7n1ozDwO5TQBoai4Q8R3m+0LObCgA8DjoC+FukXJ3Lx1OyUSzKa0jPJjUIidKlJ9YcZTaJqA5i400BIqeV4kzOc6HO5BDwS+uUubaoPxZy5WRW2oCkER3jBplXRr86q5uYyz/tywVtMkPzprfxDbSFgZwATgQM9lH6bBY0OgBoFIPTuAwl7sOliYCjAkyVAZQJEFYdkG6o/r4Aj0ZxJXkeBSTruVQgV65DIH6umqif0nGQm/9RRKFDJLmePs/kGnPTjgoCjbJpuX9tn7t30oGwCCgNVi7k68fV1aMH1iQQc1/s+Bn/nrPY14qDOXG4Lw8xUd1ybc4AQa6Tv039+kaVHGq7LNfPP558yRgMgcfc76FnChX6EqICAI+bMiBEbmiHWbGm+XDanNhySN+vRykoSze5dIFNrw9sRB6U6Ew9Mpu5rzP6v3vPinJumlLQkm4uGYDu07r28MZ1U1xSUV8p8pLgrdeVQ31OAWAOgT9D5DbfWD8wr9vXB6cMvLLcTFEdU7nyKlcnA+ja5SlEvdQlc4y/M0iUfe2Bo62MqRC4lwysnfiZOjfH3EFCV65ODGwdtzHi8sp3zvensapoOUt5BhVc/aOOedTHJgsM/CFJjpO4z9n0OHacl++zPjDx3E6IuWyESFZau2fArQQ9EXji64pA2s1b8Xw4+AmRLxBx+wyRryuldctxUw+jBEz5V0H0m+zr6Lkc5cbYiHw4TQ4E5tbSoXeZf3ox+e2hzhh0R5W2DDxf6NlNBQAeF+UAFTKb6lHeqQHwNyi25HvpszK/FAAsWocW1TF5LgJR6QKdA3/phokMgD0KN+AQGjLM6AFxDPQdAVoleWQLyl+W1q89/VApNhdtTXWXDnNNA1jxqAVIor8XHQqExS6MBVK6Qt4ametbAboh6NoBr7TeHaBagDivOgBF1QHUxvXxOoA8r2tCO+JyRdkEdJUDDx35NjIg5fJlv4AAo8M9yV30YFWZmBMsDUyGjBUEMJCGNb2DXgq6RV8xIEsPYj1Om2yPyCsSpTJ4EnmATNDZ7InFRXdlgErKebRjL+ZjAkajvuiBPFth1v2T4Jf1AnugKR3HpH7RdwGq+VCVBYGHrRVD940A4Ud5LpdUvIuyz24nFR3AQodRAYDHQYsAXrqYHZI26yqEjnA/5dykbiGG6pPSTZyWexzIBPQNicRS3R+vN5YCXGTqn3k+K8ZMNugsJaBQXotBQQLYeEGXgM3E/7O6fglAjtNLQBqPcU/nze145MCX57wxuFOiOg7g5DZVA8BU5EWxcT3toJiK0I0t6FJzoNq36boxoBuRV2W5giyKVK0oW8GL03ms1dxAuUAFegS0S7Ye1AFqTjDK5qdH8Nw+NXefVliwu7YaFu0CoE6AV1cXBslk7LUesFEx+M4B6AhguGctqEPgOIkDAwMTCdwk54oz9fMovSfrhxjkRPXUDmyxEUYKtAihLgN527zsD+YI90TVMr3J9IWo01C70zpk33U5Ppl6pmA8Bc8RBxXxc732566ntGjNXlDHHhlg8CBZqNDTQAUAHifdCtCKNp8YWB2qPzgEznLlyGuHLZBD+Q+kW2SVPGiBu6iNXFayUKdi3ay4Lt2w0nYctlgj088ybZpvro7yMW5fymnLlDHEGU0tcqWiuheLChBuKgr6eS4/K1IVAEKbAKw6m1bXgKkt168bW3BV7wHjaxqjHQ3SQDshzFYV2mUHIB1nsN4Hmh2DZt9y2dolQjfittumqxlQTw1Ua8GcrgjUAu2yABOuDWoOoBVgUNkEam5CGynkDwJQUxBLGvusagOnFMbpKIo+DG504Pus1/8GVixNBpFe69ABDELkL0DLoDUs55NZGxjgRAYOkGMrxL49K/9YRDwk3s4ZGQ2+Qya0CUlaOd8kaM5xOXNcsZzRibzHxafP9tqVA5J8Xd4/KhBM6/RkAOVtxH8aBt0tFFg4gM9+KgDwuOgmX/qcUjUA797iyOAvl39uE0nTHvV0PPR8elnUs3fK5QN5DsCJ8gaNQoYW8tzvtH3iXlb3i5OldRsEhXEZvU0nBcC5uvLmmbqAkenlAYCBjQTMNdA1FLh+vOkmlsPUAfXMWC6V6ve9mgHNnkE1Nb4sXRPmywH8VVNgfF2jnhocbFqkN7neYelqh9lMYb5K6MZkwV1r0C4B8xWFZs+gPrCV6Uaufg6EtRPCfIVQTQ0m1wzG27Yv2oltE2mg3jM2j6mBruABJwM/7qdqZkEs4DiTIwp6jQBQA21DnmOqWmPF0iJCBRkAXegbb6DS9UGTt7jVpsddzXK908OduJ6dZmKO+N8CBGZJgLEhI5JI9O7KkO/YoSLK9D0cqrtL6zn77nrOSGMR0ItAaBhuD4SjZ+U7K5uRW+/StEN5LFpXDssnrcfTQEUEXOgwKgDwOEgsqNG1RY/kQJBJ7gOLgVFKQwvpIvCU1vWwRU+mywLbDEDFAPhL8s9F0Bgsf4g8Z6QPRBeJxHtAMzM2Q6LuKFlO/0i2V+i4ZcGk4Er4vYV/KwC1BWh6ZDlbciOHdlazjlNYHRiMdiy4s5wwC8TaMVnxLcFZ0AL7pxVm62QB4Y7xenykgXrfcusONhR27rfXuy9WmFyz3EBqAeWscHVNmG4C7YpBs02YXLFt0A33i4EeAbN1wsFpBm6E8Y3Y6prFvNMNwkGlML6uMd7SIGMBp26saLc6MKj3LUhUcyuynq4ptEuh33Vj03vdQUOoZhb8+gOXMzbx75c8tDDgYw4rAgiRQM1bG0sfgokz7+wBZQh0CMoaNwiSnMGe1f8hi1GqrtBPkNRR1j+3RiTroRQHh/b0gVyPa5rkl9XTzPVZDoAtWssWgcBc25Ck5+uL7vGlgqkKfQlRAYDHQUcBY1nQEQO7XB6pEcOQCHWRuGRhPdM0hy1QyaKW6u71/KdJ4DeU10DZWbCYS59pZ160KtJTpk7J75RjmHN9I+/77zqU1eMcyY1ClBkD/n5dAFh9vJEVhVILNNsWnLGYsxs5YOc4f2pu89o/paAbQr1ngRwAL4rWjUE3IuyfIcxOaqgpYXyN7LOVLYecPp8ewe/c8zUCaeW5aJxvN2JgZvO36eBFrcoQtAr6g6YC2hWyz3O7Xf+0S4SD00C7bNAuKSxfsJxAXTsrZMexm60R9s8ojLYMli91GO1oGKXQje196qwIW3VW3NxNHKewBtSM/LiQErqFPC4OBPP4yXkTzR8GM4IjuFAHVpQRD7LoB/7tH0SIL5w+I/Lu1U0+z48kxhmHvmsDB77s9RyYytyXQFqCwPT9TUXJi/wxLqwb5e8t5CYC+TbcDJBf1K9PIRUr4EKH0ZOPFF0opqGFJr0nkxmTd6Ei8pBcP16oewAhU15vI8jVKVMvknXJLarJc4N6f0PlDnA4suDvMFqU14K1y6Si0KG+0Cbm1kG008TjJ8tmXT1yHDnVBgMGEgYJzNVj/T1dE3RNMLVwFyHy43KqA2D5osHGF+ZYe2SGlSfmWH28teBn2xlXGMDUltO2dzdh5z6D/bsIs3UrrmWXLl3jxLfGgiEQ0C7Zj6lc/R3QUnNgtAXUO1bE2i6TN96A46Cp1qCaWrExjAWE3Rieo8gAyYIyQnVgn7e6gg5wOx1FUzkwObVpZmuEbkLB/yI5kHiGsPscjd17CAebletDy/kzilAdGEyua0yuGaxc6LDyhMb4WgDDcmz5/TJETgcy9JfntnYLPlrOG/GRjsaFdbk33shxmfw8DHlmicKc9utDQuEww20W9aEknV978sVlqff+kmvfcH3YaTSXJftJ1sPXxQC9A2b6Di9693NrrGx/ysUbOrTK/hla9wcP9AN1ewpIH8PnZuj3fu/38LrXvQ733HMPiAgf+MAHovtvfvObQUTR5+Uvf3k2L2MMHnzwwWw+165dw5ve9CZsbGxgY2MDb3rTm3D9+vWbrG0hoHAAj4Uin3GSEq7dkEuYIX3AKKujAqoF4G+RO5OFOoeZtgymHeLK5eoq6ty7P7SIH6H92fumX9+QJFOYSRZ492xPTJ2pe9r/hHiOeOfIAsyzwQZgLWTrfXhDh25kOX9GAdUMaLYNJlc76Jqwc/cIpgImVzWqmdWZMxQAlwdVsKDO5u8AJQNbClw7XRuY2thwck6czBujaq0VMHP0dA1rLNw5bMTtdaCX6+xBrJgb1Qxe/AwDb0QiLXyttXDoY82uYowF0jCBk0edBQzzVaCbB2BKU1vOfIkw27SczckVjdG2zbQbk9eVVK3x9eoag07ZfqcKABFUa3xbovHnawQrnZTxfymMeWoAJCagfTfFYdBPKyPKIjG5xJyTETYiEnmllsNGPJ9ek+uEHyNZHyx43lct8aUn6iTvS9c4Q5w+4/IP+ouZtqZ0GAhMD9DJIa53gM2sK1yVqC9kXjIfWdZtog63ZgRys8/u7u7iJS95Cd7ylrfgDW94QzbNa17zGrz73e/2v0ejUTbdz//8z4MGOOjf//3fj0cffRQf/OAHAQBve9vb8KY3vQm/8Ru/cVP1LVQA4LHRELjz94DBlz91nTLoKmDhyV5sHqK8rBgqh3cyz/T99uXrnNPdO9JJ9wiL9E354BtabJP8ojofVh8J0gYcCKd5hPTwoEAB3lWKbiznw/rIM5EPPzUPenuABYbsp083lrNWTy03aLpR4eCU029TyurRaQuutANVqrMcQ6egZi18yXEkHVhhYwfrlkVw2AwirpPlaBqYloA6mdfstDp6NulbE/JBG8oP4BoxaOJ6JWMTWfO69qnW6i92YweWK05ndQ7nK4TpCQM1J6g5od5zZThjD8UgVdsxqKZA2wJYJe+KRrvBjgw/jEs/W9BewLFT8iDNu0nheMaRSxlE71X6bHooya0Rck2Q1s09J9Kujh6oRu97H4x54CPq6csDfL6hE8J9GETh42I/gTaRjCHM5cr8s6BLXl+EX9K+yoHAXBkJODwSCEza/2ylBx98EA8++ODCNOPxGOfOnVuY5s/+7M/wL/7Fv8D/+l//C3fffXd07xOf+AQ++MEP4o/+6I/w9V//9QCAX/7lX8YrXvEKfOpTn8KXf/mX31oj7jAqAPAYyJ/uIRZjuQgc8eUf9N3nE8R5pelTXZ4ep2tRyLjkmZwO3SBIPAoNgOO4gKNlxWmPYlWct/gNbUs31lgcFvKJOYluU8r0c+SfUbgJ6Sqr98auTEgDmFudOAsC7QZYTS1wmW4oTE/YHaY+CGJiFqPqxuquNbvsk48wX3bcPWPzsADKoJraenijEcCiKhLtZQDEodckGJPRPhxIimP9ko2yQaHN1AGK4ueiMfAbfQJO3KYquWVSBO7F605MrOaEGrZ/QEG3kHUgSVvRulFAtW/7rHNWwrpxzwEwtdVXnDYAdYTxNcdNrYBZTcEBNs8LFZ5XHUHvW2vkkCienzwm/nnfERYo6YrEmPQXDAMBxgfWBm8IIkTkEaYZMCTxTqQFsGMHzyHKxyEh6lx5uepF3EXpDFvk68EUtwVAGjXEiPxyxiPZA2EKDFOQd9jafIQ1PBIhD4HSm1nbjok6Yz+38vxx0+/+7u/i7Nmz2NzcxDd/8zfjp3/6p3H27Fl/f29vD9/3fd+HX/zFX8wCxT/8wz/ExsaGB38A8PKXvxwbGxv48Ic/XADgTVIBgMdAhxpz9B6AS8/P8+8MmFtAh4WCS60BZZkhkUhylHbkNqgFICotY2H/ZEDzojjBvqwB8Gc3lRgELuqzHKc20omS+n4DbTSMYNK8KzY6cFa1zshCV7CbP8GDQF2TBSMnbEZ6OxhJsN5e5QBgvWutZ62BiNvIReQNBnX++bQPRf+FsGsIfa6sWJiMAHat3em8A2kVuGM+HwcSfVQQCODrypfiRaMAVIAxFPwUmiQ9f0SUEnTG6hOpwN0kbYG06kLUDdUBcK5ivEUwQj/pxgLpdsn5J5yTN6KB09OsOqCaWu4g+y+crxHaZaCb2L7i2MWkTaxEJXQ4KYnGQgZQMLYPpfg4nUOOQzhkAJGCvYWSBAHw+VqI1yxi+lIfbEmw6A876XuYAKGIK5h5RaJD1dCaJg4KMs8eCFwExNL5PwQChwBc7r0fSpeU5Tmct4mejB5f+jwAbG1tRdfH4zHG4/FN5/fggw/iu7/7u3H//ffj4Ycfxo//+I/jW77lW/CRj3zE5/f3//7fxzd8wzfg9a9/fTaP8+fPR4CR6ezZszh//vxN1+lOpwIAj4G8McAQ8SIjkizkXg0W1M93SCybK3dR2hw30afLlD8EEhe5R1nILcyAL9+GgXwjjtOASDcLgoWlp9RvknXt1YU5FmJFDX1kHHeOfJkeTDOoA6GZGYy3rG+8zoVW60aEdsnpsWkHtgiAtsYPunEuWQwCB8mBRjJANbebtR65/7UTNyc+7thdCwkRrZMKR1w6NYfLwKVRFsRpZ9BCHUDkAAs5Y4s6gD7v5sbYOnp9RxXys771nJ4hjy0DQQasnYvbayg7r33fmzCOEZfS1RW9ee4AGILLHB+XmMPOtbbe3SREN5H5ch3GWxqjXeDghMJ8xbXFg7tgXQwH8KSbGwm6vdsebSL1AfkOHimGbPSuy0MPPHBMD2cM9lJn0cx9izlvfWfTEVBLwJR/j0Ts4kUHQLlGeJCH8C5F6WRdBWAdAre9azk6DCxm2hilk2kFEGTL7QVN/5Km++67L/r9Ez/xE3jnO9950/l87/d+r//+ohe9CF/zNV+D+++/H7/5m7+J7/qu78J//s//Gb/zO7+D//N//s/CfHK6gcaYQZ3BQsNUAOBx0KI3e2BODgK/FHgdcU5n9dQiwJbkm1YzcUDdTyDzCgv6EKcyBXyHcRXtQ/2y+hn3n8vp5B3GHbV1RLS5LNILTK2B/T0DgLlJnfFiR6NMFLNWddawo943mK0q7J+xvuiqA2f5SORi7tr9spoZ1HvWEtUDTx5DBivOoli1ABTQNfDi2B4HxunSGQZ+DJxSkAj4WLrkAJuuCKQM4LiDqgU0wa4exGJQW44yxn4H7DMULI6z3A8H/jxAFPWlDtDGADJcHSXTg9sgdQ+7MJ/5nq7iNDJGsa4CuFOGglPphkIYOqen2S4T5it2U1++YDC5ptHsOvc0ztchifHisdI1RTqf6btABrZ/3fgyIPbGH5BcuTiaSK8/0/7hfHhMKf7ugZ3g7nlO4wBlffJFCQJ4i+rL90T1cwYs0f2krcHhNQQnMlkDDgN8KdiT10PB+bRpvgNpcxzK22sFTOiOzF3IPw8AjzzyCNbX1/31J8P9y9Hdd9+N+++/H5/5zGcAAL/zO7+Dz372s9jc3IzSveENb8Bf+St/Bb/7u7+Lc+fO4cKFC728Ll26hLvuuutY6nUnUQGAx0GLToTog6HBdzJdpI8IhBYaKWTSDdUrC+ZooA0DeYa8+htUlgNp4jTZ03TudwL0omdFP8rFOQLVC8Bf5HpHbtZGPhs2a11bC856H2j2LMphly66gY+CAcCDIcBdFx0u86LOhlXTrQAuMl1FPuatai04UGQiTphts5sT3I4KAXDJ/jIIVsHyngNobLWsOM4uOe4kA1dy4dVcPrK/vKEJxHWEfpT3yQROIwDLrRPgT3L0PIBPDE+GAJbhMXXgj616lXEWwxU8mPcxjI3jijKQbOB9LbbLhPbAARwuu7MGIRyzWNdWRNwuOe6sQ7j+XeM5lZlj3MbQhgxiyXGpknccittu4vcB4h1RiS5eguu8CNeBtb5+sWhPJr2vC+C5il6XT7af3y95X1zvtVP2W9L2Xr/4RifXc4AuvX7UZ5J6Sg6l557eJtJm0G/4kZ8HgPX19QgAHhdduXIFjzzyiDf0+If/8B/ib//tvx2lefGLX4yf+7mfw+te9zoAwCte8QrcuHEDf/Inf4Kv+7qvAwD88R//MW7cuIFv+IZvOPY6PtupAMCngpLFocf9yp1MU3B0WP4ybQ78JS9+DqilaReBziHHygvrOrD4DD7DJ+UhsGzidACC6F1shBGXjpLy+NkofR9EWlEgPDcrBVbMzTIOUKk5UB/YjX22orwPO+Ya6prQNQaqse5Eml1njCDDvBGcuNXGulUzA+jAQfNiUtYndEDJ6rfZScX6bda/XGgLR7OQfcI6XwycmIvHZaRiSJ+XBFqEqA2pnpP0uRht9IjBX9Svri6+fkAArYDjKuUnlzcS4Xoy4HOia59GtMEYC9R8P8msud+cKBwk3OgYG1WF68bgz+pkWg5KPTWonP/HbuIAVhX8DfqyDDzwT41H/JzOzOWo7RkQBgpWvQYJJ06m1bAgUNkDiEnSROUa9Lh7PZyVeW8jTh8NLg/R/QgkZtosuYBH5q7JLhgAoNznHnwCUX/5fOSaaeJrsv5pJJRnI+3s7OChhx7yvx9++GF89KMfxcmTJ3Hy5Em8853vxBve8Abcfffd+PznP48f+7Efw+nTp/Gd3/mdAIBz585lDT+e+9zn4vnPfz4A4Cu/8ivxmte8Bm9961vxS7/0SwCsG5jXvva1xQDkSVABgMdBuZVMgrz0/pNdCOTpOlkQhww+sgunXOyG6o5+mqMAvkVpsptXyq3I1SGps48WkLFmlFyOHMczOqEL8CdFTtEzjgPFcXctQIg3auZ6GQXsbyjsn7UZjLasyNeLIUdA11oAqGaAURZ4MBjwIJMBWWt1/LR2oMGBMlNZ7lunCZUTuVqxpQGI0CnEgNWBGNtfARhGPvp0aBuLbUN/iz7x6cUEp7jfJAfbi2cJgasnATeDJ948WddQ5M/GMhwjWJYjSYK6yHK4MqDOGor4OnF7HOBTHaC7eI4asiJt22zy7VfCmbcR7nCUe75dI8zWbbuWLgKT61bv0wgxcSTydvVRHXnjERbHR/PeNT2uozsIoQ/awrwW4CM56HjRvAmf1KrWRx9JwM9gZI5FJNdFJN+5DnxdgqjEH+EibmJUH9nudF1atJ5JgCqfTddDJPcyeUQg/zZG1+hwayLgm332T//0T/GqV73K//6RH/kRAMAP/MAP4F3vehf+/M//HL/6q7+K69ev4+6778arXvUqvP/978fa2tpNlfO+970PP/zDP4xXv/rVAIDv+I7vwC/+4i/eVB6FLBUAeNx0xHcmF+JtcDGSJ3ocAdSJtAvrdBj4k8+LzYrTSe4jK/6nabL1JLGAp6JXIHDXUm4GQtulJWjuGpc75AexF4ElKYc5Ll0DaOc2RM2d0QU5UMLiNffbhmJzQK0yzjDA7gKcvhtbgOU5UxKoMVAEQNr1aev0z7SBNmRjAVcARnb+kHHptPVxx3XxkTd837hNsjOAIi/eMQTBGeP+MyBFHtyQAEyR9afMQ44vf2XxrIqf7ekCunEmE+rAvhE9MK7FWIs6EFuByLFtnS6m48RFRj9Op88wGGVAKTmHCADa++bjLBikOkfUvl8c99TUQDsJTqv1iNCOBQh280658VetHc/OiYgBAlEcK9rr6qk+pvFAia3Po5shnyE9XQDe3Ys0/oj6M1kUYj3CjJ5fuoYsWhNTcCWej3wAijmRHuoiP4ECmPbqcxj4dP+9YZkEtRkQaChzL9dEEn12+/DfbQeAr3zlK2EWANzf+q3fuuk65PI7efIk3vve9950XoX6VADgcdFNvmdHMVKI09v/RwF//jL1r/l0RvzP5Zc5zQ7XzUTpIjHuwCI7uFkM1RUMCAInJuVkRlwA3rx5c5fiboPsxpizaDSVTdDsWgteGINubCNNWP97cBwsB8i0Qb1L3k8fW8iy2JaNNFQbAI/qyHoJYQ5fzXUkVE4siA5QZKBVsLwFyPpU6ziyhs1XtwRwrF1hXQvA66mR5h28DxQBgJxFLHNAbV9yH8YTRALCoFMGD47Tfk/HPPXxF3G9pA6gL884lIwg6uY5wKH3Wtsv2s0Xb4zBBisQc4DzhLA4dpbXbJXs6w45f4KbGQkcyQBqGkCitfK2c5HrxeVXM4NmbjBvFeZr1um3AlknbIlRjhdHuzraewaSS2v4Bv/OWLn7NiBv/IGor2Og2eN+oQ8Qo3UF/TyjyCUmD+x6QE6840aFMlMOpB/PoYVlAVjz73/GMrr3bK6Nsv1JX0QqFIUKfYlQAYDHQcnJ9UhpBQ3pt8hnDA5P08tzKK1J/udAGgLYyhpa5LKV4E8sxnLx9nU7hPonfXEyFxsvZDoGLApez4o36oiLw25CHFCxrj4koPG7CIyykR6aPQvuDk4otBMKHCoWEY9tZagz1nHzHNFm4bmGCoAiGPZTpwEYY40DBEjRDdBpAE7MyyJaNrBgwwvqLOBTrc2PY/eqzvmVI9EnxKDTghPD3ERCZPjhHS078bQHc5yHNJ6RItdO1E+OsRTJCuAdAUdxD0Cw3K3Ju2KRunucRgJEH3e5DeDLp5NthQCahttGQWzO7fRAzbm1MRRxbD1wSkAttUDt2mOUNQCBcvm1tr7tso1YUu8Rli5rNPvGx0TmgwdzK5lj7Y1jhBjct4fBnrQA5/spPhNnoRx3L+cCRlLv/V0AqmSa8M4yaI25d36tSPJlQyPV9dcV6XIp0geUeWX6oAfYCL4ePZ09+fxQW5ODTpbTaDJ99xSSNmSlBrfwfKFnNxUAeBzELz3TECAcAn9HXDyz7+PQKTRNswik8v3eRhF2iqj8ofoQ0ONsZoBpBLbkCVukSfPt1RfwnB8GnRagUNjA3cbpN+hMXXRtw4d5/T4NsL6XBwPacma6VcLBScv5Y0vPICq0eaoZWY5cJ6wqlcueQQ1zZWZOH7CD4+TYchhk6FEATgxobHso6MWNLOhUHUCGANZP1BSscZN2R37yhNWr5/IZAdh4zCSXiXisEUXckMBMgihS8XwIAApRWR6YVHYMdJP44TMIbUrAHwDvpJrjCfdAJAMqyWl0wNxzaIWuoXcNwy5uYDxHUVcWdCH1n8kGLO798MAT1pG0riwHt12yTqd1TaimhMY59FZzE9QIeDgIgCJ0OlgXD4Lo5LAYGTwBg6AuIiOA4SFrUyTa5PJcOZGKRgKwGKD1gGZmDTKCixupD7gypbRBqgj0AOVh7Rmoo39OgsCU0vUl9/s20+0WARd65tGQgOBLmn7v934Pr3vd63DPPfeAiPCBD3wguk9E2c8/+2f/zKd55Stf2bv/N/7G37i1ii0CcwMgJksm/mTFBinoHAKbctHidVKCsyRdT7FeJ4tukmaR4QYDMgmEohBf0t3KIWCZQR5zYzhNT8cv4WLl6g/Acv5GVvfKuAgdoy2D8Q2D0bZV2letK9tx+HQtgJ8DDlLEY+P8whtQqM4EQNIicMcUIvExHJCi1njLYZDTDRtbgBryRIjWwQBjZKOAcMxgBkqprl7coTG4Cf0p/idA0NaJAsfUwOoozhgEGs/FDFElQhmeC1qRj35i54HoQ8EB1SPWiwt5RSJ+F+KNTOD6eV085uzWop8Fh4g3aF1bAx+fRhrGOCMcahGBWwaMMsoJj4nn1Lp5wy5jPOBUAYiquQtNNybMV+zBQrrnUa01Imp2ndFQZZ1TdxNCN7ZqBlF4v9wYD7mOEe8+uyeJLLKH1qfMIUr2aXDkHIybojLEmEdGXEdoA+d5KCXz6tB2mPi6GXqeMp9F+T7N1EHd8qfQs5uekRzA3d1dvOQlL8Fb3vIWvOENb+jdf+KJJ6Lf/+2//Tf84A/+YC/tW9/6Vvzjf/yP/e+lpaUnV6HcYpAuHLnr8tqChWNQRDy0WOeuixPsIq7jkBFHTiQbcRYSjmBPZ0u20S3qQ5y5IfAXcTkkt0FsEFJk1nPcLNpkwZUFTc2uwdIVg2qq3aZKMDMLADoNa3VbO6vcfeNds3A9SIV2mAo+ggVcG330DCF2NQTQCNbYozMejJm50xsUQEM3gO4Iygi/fxXZ0GkqAE/dWvcxflPmPJlTxNw3HjuXJuICVohEjF4nkEFpba1VGbhyxA4mXYm5wPkTIhc2koNMBuF5cn2NENVEgmwOp2aU5U9FVs4OsFnOH0FTiLbi2yx0Dbku3rdfHcqh1gL9ama8KyBdB+4dc/Q86BPugjrRTgaIPp0J7eCYzTAu4khD/XSu/5pdA7NrMF8ltOxKxuFndolDEG2T7w8BLHIdAkOD1rzi3Yx8ZsqMRFpfhARIvUMhRc7pIt3coTqaUMeIw5lJF+qbvPuc99DhV65DrozUQCzKK803ly7J8+ngAhYqtIiekQDwwQcfxIMPPjh4P/Ul9J/+03/Cq171KrzgBS+Iri8vL2f9Dt0yCY5WdGIVGx+AxQBuCEBy+ps5fQ4ByLRssdhHIZmASP9OWv9m6y+zTPQBoxBO4Hz65ftnkzy4TlEIONcf0orYh91iblGyIbCOlWqB0bZBs9thtlZh/5QCO3VWHYApoJvwIHO6dB388xl2IOz6hQGCAoHmDrR1BqajALgccKMGoM7q+dkN31nzct4MUCTnz4TvHsRUNowcd6YXy2l4K1/bZybqaw+suF+rmEsjY9gaZeuuxTySHDfwuHgTY5GHICMAs9yUre88gNhPngR/4lnPBRQg1YeXU8FAxnJjKRILeo4nOUCXcvJaoJq7WMIz4QfSpZP6iHBgvGKnz8zVVIGT6TmXnR1b7zTaTVvP4XSgsJq5LqmAbgloVywamdzQ3t1PN3JGJYrnkXUC7v0dcl8x8PbvKw+aGBvfHSJ8oQBE4TWNrYOjcIniMGeBqIERi01Pp87fEGtNDigdApqGxLyDuoUp4JPXB0BglobW38PoyTxzC2RuUQfQ3MKzhZ4Z9Kzn8V64cAG/+Zu/iR/8wR/s3Xvf+96H06dP46u+6qvwoz/6o9je3l6Y13Q6xdbWVvSJSC4sQB8oSRoCf+5aVixqMukHno8WuByleaXgbwiAJuX1DDIGyhjiOvrrEvwtWneS9L16yTIVi/coAAEHLLTgzqjWApf5MmG+BszWCfNV8hE8PPACvD5eNTOoZsZv2ux2BAaBa9fYzdlzy5x7EiXSdSMrimYg4A0ZRH6A4xqyYQBCXTzHSIV26RrB9UrPqlaI4ijOpzceJr7H4t+IqybGJQIFyWbL9WBQkn3egd1uFIvSAXgOZvosiXfFRyUZscg+iIgj8Sz3R1aH0FnwzpwDZx1AZaST6MAk6+R5wCREz75vBXjnA5Tvxzq0k5K5yyoA7TJZh9OI56LvryVgvkqeQygBb3TYEuOUimOZ7L1+/3quuj+MmWHRrLvfI1EfDxgX+cUz8fecZ4Ehq1rPLaSkX9mHaHSgFGvO0Lq3qG4Da1sv3WF5HjOxDuCtfAo9u+kZyQG8Gfq3//bfYm1tDd/1Xd8VXX/jG9+I5z//+Th37hw+9rGP4R3veAf+7M/+DB/60IcG8/qZn/kZ/ORP/uSRyo02WAGoBsWvQ6dKsTB57uEh4DFfoSTbTH16FrzRQmt6z/XaleQvOQ5p3vxMzFmkADwylsdSn6iXBiKtB3nk3bBUM+PFkZHbEMObNon4u4570yDoAfIeIYARjDP2cECSQ7954wPPWSBvmOANRyhs/roBqA0h4FjEy4CO26Vr7rR+PQA4FyKuvhnDiWisUwAmgYLkvMj+ZSMbKVJ0/el1O00GCIp9m/X3ekQDc9sVJcuKDi/yeg10FcV5Ch1LwOlQ8jMyqQPSag5UU+Pd6hhyoFfq27l+V3MZ+9lx/djgJAWVznDDcx2F4RDrSXJsYn6umoU+ma9QKIcPC3MDzGzfdxNrWEITQO+TjUrDnFeeJ+69SLlckuNnr5G1Jua6JEBM/o9Eswp9QEZiClF4NDK0SO6nz/fGOhFVezcy3NaEW8ltiNYPOlrMYznPs4dvyqRdQFlmQKFCTxM96wHgv/k3/wZvfOMbMZlMoutvfetb/fcXvehFeOELX4iv+Zqvwf/+3/8bL33pS7N5veMd7/DezQFga2sL9913n/0hFssjWfZKGkjLem6RODa5NphHsrlz3UK+cbocQIuezyxu3vp2UVspv+j1xLjuvwEbe0As+AN5J3X1+wT3k7Iba71r3biYyobuosptzO4hXVnffJUzBGknoW5SXMn9Frk+4T5VdpPvtN0MPRBs3AblrXmNV7jXFIADi4KVFwU78Elxe3Qt5piKG26U1Z/j7z1QlfaPBGimf58y1zhvSjlpKXgbGrPceHLfqvhazoiF2y3Ll1zFHEeI9SGRyY/vgy1+U24uc/7ceBoSnL9Z4P55VzOREZADda3xAEweQLhc5vgq4eKFNIDOtsseSChYJbcGam45lJYLrdGNCAenFGZrQLsMmIosiG2F+xhXpq5MZIkf+iEW3QZAH4+L7fR+P0dgT84BCbzgAFoyVj1Rrcx/AATmQGqshyyAIoNglR40M+XKug/VI63zIpIHq9tInVHoBh1BHuX5Y6xMoS9JelYDwN///d/Hpz71Kbz//e8/NO1LX/pSNE2Dz3zmM4MAcDweYzwe928cBv7SBSWzOB6JmKuwSESbLrYCKOaMSVJff1ndRcj08XP2WQRul0xHcf6RNW6uLSR+Z+oRlLJFm1QAoqkrEstFMRjtGsAY7J+q0C0h+JxjsaQTr1Jndf9IW306uXZ6XT/OOxXtOR9v4FBqBOtMmEGbJqBNjDhU0Bf0FqOgYB3JwCQxMkEyz7xBBYNqAfB6678AIZ5LBTh3NyFPv5mb5DlRZjSX03u+40R+OSAh8o6uJxttjzwYRcTVMg6US+6Xn9cJWPDcUTd3mVOnvD5hn/tnucnMJTQ+ZrGunSV2E9KpOYuIEUCi0/8E4OegB5zC2lq6F/KHjpm1SlYzm6xrgHZCaPaAyZUO9dRg96zCfJUCZ5ls45TrE6OdobMJxkLcF3YoMwdLBkr8jidgaSi+cHoQkC5dgHgO94Y4BYHylswnB8rS9U2JA6UEkI4LeCQgJ9stKtx7VvZRWn8Tr8dPNWkQ9C1oeemhASj0rKFnNQD8lV/5FbzsZS/DS17ykkPTfvzjH8d8Psfdd9/9pMqS4C/rQBkYXNCyHAn/3QymswnEvWSx7QE6Ad4iA4sk7zzXqB9fM42EMGStnPaDEc8PEsX9GXFBJaionM6SJge+QputGxb7fb6sMNsA2mWDakZQM46eEfTOqqkQ1flQauQ3bk2WEwNn6UvO6a7l3nBf2AoYReh4I6+tDrwSlSfHHVKiP70RhA4gzo+N7D+pBye5G9wnKvlP8TyQfvo4/541s9zkk3xDRfLzKwVcvcMKIZmP8ZjHagbxNUmRSxaXhwIs50z0S8+aM8Ur3N3CXQ2LaiX3D8aBvwNj54qzsO4a8rqcnvvn3OOw6gGDRFYvYFCnWjsPSIBO2S4QPGeyPjCoDgDSNhrNfJXQLVlr9tGORrPTYam2RibeWljB+xVkf5EAIo5k3KmZa9xXAiynOn+DlIChyL+gPEAMlS+AVyTqjSrmknHW2v1wa4cHe5yGI304g6XsASMFuvJWYmSSBYHy/1H2gEKFngZ6RgLAnZ0dPPTQQ/73ww8/jI9+9KM4efIknvvc5wKw4tlf//Vfx8/+7M/2nv/sZz+L973vffj2b/92nD59Gv/v//0/vP3tb8df+kt/Cd/4jd/4pOrU14ELoEfquqQnVL4m8xgCUj1KF5gFQLIHDjl9ssANgb/4Qh+8ZfX9EKcbFDtn2tnToQR63CwfBsxYfShyIlMZ2YNqY405CKgPLGBkTppuRGFuM6rmAIyBalmx3dZPVy7dyIVjY6MMJ0cmTc6Pn91clBOzMUfIc3/E4EuXNr59DsemIEkq9EuRMNfb9w1/F9wjnyfCc/wh4+4Jgws5RnIsIgBo4vklAWMquo3AoB875AEIXH24rVLMbRAiXhgGVaGvGCD4aSZ9GPq6JIcRkOWIiffA90/lwJPg+Hrr4NbFhK6dr8aJ4BIK8McHEM3GKQ4kst5f5EMRcfkgeJcx9YFBvW987GAeu2pqy7G6h1bXtJo6n5CVWFucfqJx/iazvjFDp0TvqB3XzDM5gMO3kjUtBXw9lzMZoNWrE/LrJz8vQWCoh+ndz4HAoXb06iDXLgECo+fT+sn34jZScQRd6DB6RgLAP/3TP8WrXvUq/5v18n7gB34A73nPewAAv/ZrvwZjDL7v+76v9/xoNMJv//Zv41/+y3+JnZ0d3Hffffjrf/2v4yd+4idQVelOeBOUABb7Pb4fnRSB/qJz1HduKJ1YlFNQFtUtAxZ7C2t6ak85PkieEeVEZWQBXiYdMhuHietmyIlIua87y5GxodqAbmRv8EbbjWynkwbqPZuRHgVwpGuEQSFAzxz3xjv2tZsUh47rjPW7ZkZBmZ8Rlrc2ZcviVmzmrg3EgCYFUrI/JQeP+8cASoqxJPfEi5nFOAiQ1+t7ITYd3JM8ADVBx46SzW5ofCXwc42Sxiihfsl7wulcHgYIojupc+j6yXMzBXjIGSFI8JdaRcMYGMOuWYzvTzs3hEVtx9w6E7mG6UbslBle7cDq9IWYv9oBSc8hdHlKkGjcoSTl7no/gxIoOkMXEtzDbkQwpMShxIEdZ3kOFfxeElGwXPZ9H+ZhJOrl8QJFOnfRQS957yMHz+lwLFhnFpIAkKzLl0szlFUKZG2bY33AQ8t2dU39JvYelX2XZnUbQeCt6wDeZsRa6LbTMxIAvvKVr4Q5ZHK+7W1vw9ve9rbsvfvuuw//83/+z+Ot1ALgFokyF600t3rgGjoZD4mkF+WRAK8c+FvEAbDlLbzd55JKECQ5X/IZJ7Ix7ruaA+NtqxQ/d/FVLXfEKrSb2p5k2alvvW+gWxH5ARCcJIKuLPdPzZ2+1dwCL2uhaRyQs0ioYzHhyIFDTZ7j4yN7qBDTlTlaEUeNSYISgo9bG4lEWb/NwHP0GDiQivs5K+qlkKcHdjkunNzkEwMPz7BdAO6jbNxGm3IBuW6c0Bges4Q0oDqyYl0t+kzW24R+SesO32cmBq3cR6lvOzKxUQvBA4bIBUvlwgOOYt+A3oWPd50j3NIIkW41c6Bu5saztnmyZXjEdZwbOxdbW/kA2BwQqazIVznAKiOgUGNBWr0HUGfQLpO3Vo4OOPJAwfMEDuwkgxzE8jEg9HNkkWiVxyucLhcsEP3x8jU5wvxLy4vEwaK9WaO6tAwG5Eb0i9RDlOn5uzy05oBioUJPMz0jAeCXHOUWIRPfP4wzFnG4Mi5QBhfK3EKYLEQpBy+nv5MTq0Ti4EXcohzJDUWSB3Zi4wGy4E+euiMxigAhVoHegr+9cwrdGF6/DwibKYg8V0a5eLm6pngMFCxnrwaME+FWBGAWLCkrV7hxwI4Bp64JNBIbNAOHDqKAuD9zYFuqC3jdNjZWSaxk/UatGMzE+feAnrwu8kjHNep+5tTJ5+SzDFCluFVeN4Dn7PXeCfeV2zfQL1oZoIIVsyfztxfqT/QDJeC2x2lNDzJw4KXnkkj8h+hvB9qi8HHO4TMZeDc+nZtTIFhuXhtEt2xEEvmOFA6k2drYcgqd9a5/Z9wBhGydIeqnG2sN3E0Mqn3C8nmrt1hNDTCWPjFZxG08lzuAnD7YkRza2LBGxOK+WRp63/14urKRiFzTtPxIWO7iuYTcuA5wAeVvCYwTEJhtjnguPfxnxddPEVkjkCdf4K08W+iZQQUAHjeJNaG3WQ342Dvu8qWeWFqvLMDyFVxwGnb3s2tecn0o/miOE9kDFclmKzmEcV7wHLVuTNZZ7hLQLRnLCXFRPmKwY0EgjANz2kT3vQI+K86TgQ+jwSDQ+X+rKvIgUUbjoNoEa1reMDRiQKTg9dxSENYDcoLYgpS5e5ERRGVirpp/SLQ/uRQAJINa97syrhzjxNEGqOyHKgNVGSiloSqLvLq2Qtcq6DZlQ3KDxHcNkLymqQfigpEQYDSBGXOe62/kfcchFM96xkxGbOyJ56Psbx4rUNQfaT8yEGddPB5bBm1AGB9duwMFwVuNW+5fEBF7n5Ucks7NTzb8qA8sh1u1xoJJHnfmFqYHjXR+OKfTzZ4Bprah1lch+fkDIi/iTnVTJUXvCw4HY4sot9bkwJvndB6Fk5bWK0kcHa7FO9jTSeTyk+flWMs6SumOnyq8jum8252nmvQtxvMtVsDPfioA8CkgBmCSY7MI/A1t+HEiWcAhScWp05d92LNiseU2+GJ7AI+BConHTXjeoA/YeAEUAK8HRhOuQtjI5Kk9XqR1A7TOUreawu/+0mEuAGgV6sxOmaO4qw4IeeMOAlATOr5JAGaw3B1txXLG+Q/UDXkwZXWs4nHw/cnAJeGUyf73xP3B6TwnEx7oaQZqjlNoKhOBYwtoKO5PspXx4uHK2OdqAxpp1OMWo3GLpuqglEalDJqqw6jqsFTPsVzPsFzPsFrPUFMHbRR2uxGuTZex244w7yoffkqbmEcy7yq0nbL/2wpdR+jaCnpWAXMCOgr15f8sknUAMuKuGICU5RCSAqgi746HDwfsPDns1KK/Bfhj8aI3jBkA4rGOJsX3k36WkVvIHx6EU3Kw82hE1sEqMfyop9oZnQi3NE1QY+C4wjJaDQNIaslbu0udUo5KghZel1HXgAJ5d0VeJ9C3iblYbl1B35+fb38S8ze6bXiOpugsDLnkhGf7mK/Lg1SSTy9vUe/oYCkBZubwynUxatj6N7fGSiCai2LyVFPRASx0GBUAeJzEoEkAsCEXKDK9/84LSXr9kPJSkZksZxB4ps8m+Q6mzSz2rEfUowwXIRs6Tmxe6casa5vIckAQAJAEgW4W1/uO6yf13gTHDLWzQyCyOn0UuHrsCNh0FhRxrFXjQCCHu6rmAQRah7y2U0zVB1oRQJDAVv42iPtp6HDg8zQ9TqB1botYXJv0q3FiVOM4eag1VK1RNx1Gow6rkylOLu3hrqVtnB7tYLWaoiKNzihM1Byr1QHW1D5W1AwTNcOE5qhgMDMVrutlXG1Xsa0n0MmGo0ijgkEHgjYKB7rBnh5hv2uw245xYz7BlYMVXN9bwt7BCO2sspzEVsG0BOrIx1AmY4I1s9cZcGCCxZgKzveds1kwCL7+EkoBHhs/eMAjjCn8fWXRtfUvF8B2VC12Ii7GXiXGIQxQrdhXAEUGiR78Wd1Vo8gbnHRj4XKGwZwMV+g4jayPytFn2jG5d8rmV82tWJi0QetCzukKUJq8rm0AV3y44IUFYKftCLdjbtcisMP5Roc9W64EWCFpRlSbWT9T6h1kfRtE/OKMg+hcfsyJzIqih5op58dtBH+FCh2FCgA8DhpYCHp6biqTPgUIvCkNLS408D0Bf36h5gUuAaWDgHCoLAhAG10UZQswE4mKMqHbjGgjcxu8aFNyFjurtzTaNWETk45/5UbdGSjhQ8/rVgnAhNoyl0gB1NnVWRln4emiL2jHHekaAQId0LJi5NBexeHlEse6oe2ZrqT0Qr7vg4hXcOxI/JZgWTlOXmPBHTkrSQOAlEFda4wnc6yMZ1hq5hhXreXkNVOcHO3hdLODs80WztXXsVntoYLGrh5jz4zRGYWGWkxojhF1UEJeq431pTNRczTUoaE2AokNdRihS1uHGSoc6AbX9TIuzDfx6OwEnjhYx+WDVWxNJ9ibNdifjjCb1tAHFcxcgeYWEPq5BAfwiDzIsyJgO07chwy4fIcgAXWHHIxsH4pXxCQAD2E+yPHz3F8GaK3xQM3rEHLoOMdJI6cfWB/YeU+d8e5o2omNV91OyLswoi4cjojBV7JGmMqqSXhH5k7sax1cG4y2gdGOrfx8lbxDctUFTiD7MrQ/LPjz+XNTBQhM+1CmTckDJIOemDfWSRT5muT5TFkSKJJDbLy2RA6ifd0z+XP7RB1662AGzMp8IhB4BNB4XKShiiPoQgupAMCnkgZAmQRgWTEtkF9QFpTDZaTpJSCRoJDvZXURD9kQQ94mlCE3WHnSlgBX1KenTA4GPK4/ePNp4V287J9WmK9YTh+5DY/rlrqh8JtsRTYiRw0vutO1A4AVHLfCrs6VdiDSkOM0WRBoKgAV+8WyG4DiOEkMsLmLuIulNyG5SUIA5BR8JMDV1E5Xizl3DHYJntPnv9cG1UqLlZUDnFjex6SeQ7mOHakO66N9nBnt4FSzi7XqAA21UGQwcsDOArgWDTrLpTNjXGzXcXG+jmvzZUx1A0Xa5wkAra4w1TWmukKrK9Sqw2o9w2a9hxPNLk5Wu1ir9jFywLBBh4maY4VmWKMZlNrDvdjCA80lbE8muLKyikvtGq62q7gyX8HV+Qou7K/h6v4ybuwuYbrfQO9XIOYOimguFoQ7oEaAJuePsUVkoMKi0lQH05Ocy7nD2YLfOc42X4/CBhKcCJ8in35wfgarAxtlxIptLUBsJwrtMtAuOdEvOWMSGbrOzTtvBcyxiyvPlLSOz53vQj0CQFacvHxBo9k31p+h4y5qEBTEIVYAHW9Vy0YpOT+Bi/BDsp70RLGeFZvkJ9aVrK9Vcchlgx5/ANA2E6/7aTPJ6vT1QHSm/keCR2LJPQrH8DipM4TuFpTNb+XZQs8MKgDwOCk5dQIBYKVxb336IUoWi0WuCiIgNwAqU39pXLeFRh8JDaXz+lOyrbyx8iaYcwuRgD+/uTj3Ll6sRZbz107sxkUGUFPkrUINYIxb+A2AzkDBAjrmBpIwniBnIQzY9BW7xgC5s7MVX7LY1fsNJIHqBAj0FqhS54rbZ8L9SJ9PAEJDYROX4M/rACrjdffAwG/cYWl5ins3buCrNp7AC5cu4GS9AwDQRkGR9iAMAA70CAemwa4e43q3jJ1ugr1uhKmuMTcV9ruRF81eY9FsK8JtCCRjNGC0m2+VQVVbkfLyeIa18RRrzRSjqsVIdViq5ths9nCi3sPJegeb1R7Wqn2s0AwNtThTb2FN7eNccwOzieUQbq8v4fJ8DY8enMAXd07g4s4qdnYnaA9qmJnjCrYAOoAYuBMs6K+MBf7azRUGglL/E8n8kZFDeG4bBy41YgMeIPsOS05wpGfK6QneUTMY/Dn3MTbEXJg/HGLOgz92c8SRZGbuXTFWDaEbwYekY+MT75pIHrRqQI8s1zpECnFWwoJj7+elaF8Ag4HjyGAqJBpYW9KDYnqP15AMJzAk6RuFREVHzucp+C/kMZT1Fi5rslKRhJsXcQpz7cq1Y8gvbKFCTzMVAHgcNATkImAiOEbJIjgErOSClHPgnFW+JuqnzZ22hygBkNQvduCZ/DUb8cDEnBoGSWJD0hX5RdY73XViJ+bC1Qcuaxb3SX9tsp4GIOX0xrTxgI43f1PBioKdhaR90LGQjNWNImOshWoLKDLWJYLrG1MZF7ItPNrrEgdkQYnoTXL5lACJAvxZ8ZyJwV9lgg7fSKOatFhammF96QCnlvbwvJUreMnKI/iq8WN4Tr2PFedxeg6DbW1wqVvCF9uTeHR2Ck/MNnB5topr02Vcny5h62CM6bxG21YwmqC1gp4rmIMK6kBBTSk4oQYsCOKvEvy69hxUBnsNcKnRwXq4NlCNRt20GI9arE2mWB8f4OR4DydHu1ivD9A4NlZFGqvVAc7U23hgdBEvHJ3H9tISHlk9ic/tn8Gje5u4sLeGrf0JDvZHaKcVcFBBTR0g1AjcIHbRwpws7+CbfOi3iIuk4muSe+vnLQ9y8iyn90BfXkcYa68fynPVWwcb7+yZ3wndWJ2/diLAnw5gkcMQGiJ0jXP2PBbRQhzY5ffJv3cGoJa8e6OuISglXiK5loj6kjbetyLLfYcsXPvRghZb2rLFrH/PpN9UOUYIIDAuLwHzRnL7BJZz5fQOqqLtodLJ76hAxG2JGgu/tj9dfgC7W7QC7ooI+FlPBQAeB8kNA5mTJOL76SJ1U+XInyTKkgu2OM16rpzUw/OFH6G89BSMTNuSZwgiuoKO9Z6kyC1ylcEbW5sYiQigVwmFeDBYEoAyapPmDZAC+DTWwtKwCBDBChMAyDB4phAzlQEpTCTWjVyEDBBzjmCQGG0kADDiCJoQh1iIgk1jgHGHZmmOjdUD3LW6jeeuXMP9kyt4zugq7muu4JTaxzJ1mBvgutGoCDgwhMfbdXx8ei8+vnsvPrd9Cpd2V7C9O8F8v/HASc3IbuywoK7SgGLuWjq3Rb2lr8PAhWawrML4OSDbKWC3MthugMfGGjTpUI9bVLWGUhpEwKhusbF0gOetXcVXrJzH88cXsa4O8MLxeZyrb+DK8iouztdxabaGy9MVXDlYweWdFezsTNDtNFAHAQgCtr81A7IKDsAYfyBQnW07cwZ7e35uo1/w2krjEdZ1JQXLKRXRNKTIVEX6gcEljJYcPT5Qed+A1hodBo6j5z6OcxxFEWEdQa9i4exZ3CGrXbbvClsXA+45B5J14wyjnM9BEu+Hf5lSIMX3eW4MvC8epItnZYQR5kSmB9dsOMrk0JsLBWfXKFtvg9g5dFaiwPkJLmCPM5htGDwIjOp4m0gb1TPKurnnCwB8tlMBgE8BLQJkEWW4bQsXiHSxSQEeXzb9BTflCvY4i+in7xs0hLr2TvEibxbjwoSQagyCtHOzwuk4NFY1Y4vEkK32Yk+XZwdUHWDIKcYbCjM46gu7IXK/80boOYIGVkws6sBuY6wbEpPhTMRlpOWlRga+j9OPBH/sw08JUZu81xjosQYmHcYrM5xY28N9a9fxZSuX8BeWzuO+5grOVLtYoRYHpsL5bhWPzE/hwnwDc1NBwWBqapyfruOR3RM4v72G7Z0ltLsN1G6FZp+gZhTE7QlHy3PIBED1/csgR/qgk3tNyvmK9E+dL7taQdc1TDWCJqBzfTCtgOvLGl/cPIlPnLwLL9i4guctX8HZ0RZOVjs4V9/Avc01zJYq7OkxrrareGy6ic/unMEXb2zixo1ldLsN1L5ybXADRM4AyAFz0uQ4ws5BeOs4Qg4MMuVUF/h6Ckwiq22XNvVHaIEzzzHy/ch9zTp8XRNEuUDg4qlZ4P5ZnT4n+h1TiDVs7JyvHFAkp7MaHTrcfNQjoIXjiLp3FIAzlLJl6ZYwX4F3FaMR1ofc4U52VdD7DZ2Q07kbxFEDOoEL1Vd6KD6U4ef5EJAz8C5fDgN32ZjGfD+tx20Ef4UKHYUKADwGyoliB+/37qWrWkgzaKGYycfntejQloC/+OHhfHIcy5z+VFrXVOnd+9iT7iucY2U29JgvUViMBSAC4MVVDBIVrGiWFf+JgYkEUS4vpSznBK1zcdFaYw8YZ7To+lpXAGr7UG/jjvfsqM2e0yOTC8fSvQ+LetmXn9iUTW2sftZSh9HaDKc3dnD/2jV8+eoFfPnkCdzXXMFJdYAJaRwYhUfadfz5wX346PZ9+MyNM7i+P0HXKWscqwnzWY1urmDmCpgpVPsK9S6hOgh6cRyhIo1cwoY2Ulzmx8QBfA+OJVdUjr9I7y2+RV94x9AIfaPrCu31CS5eG+HS5ho+vnYO59a28dzVa3j+0mXcM7qGzWoPK/UWztRbuH90GS9YuoTPrZ7Bp9bvwiPXN7G9tQS9V4NmwXrYjxVZ4E0GMJqglDUcoc4ajhjEh5Ehyr77CUAeJAMEfTYLuLTLQ+oI+oNU51wPuVjVQAB/ehTHuFZepxAgF0LOWxx758/xOCjWpSTnX3PFvq/jaw4Ecrg6Bcs+ZN05xzmO3C8JcGTEb/s16O1FIHCwk4Ehg42ceHXoIJ0zHonv98GqtODldyCNdRx5VjikKbcTBBYRcKHDqADA46QcuDsMkB1hQZAn3Whxi5h3MTA7lAMpT7yZ/KJ0YvEOdZIAzy3sqZ4j55eIepmbxw6ZmZMxXyEcnHRxeA8Qu7UgKz5UynjOFIuMjXLgj8iH/9LO3QtbQnqxFgDiWK3OQMRzIrm9KvyOrB/Fxh4D5Hhji/JJQR+F7zlHzroBzFhDrcxxYnMXD5y4gq9ae8IDvzVlY9xd1RNc6tbxuelZ/PnOvfjE1btw6coazNYINLWAx7vwMLAh7ZyYvTog27/COIAdD6u5bZu3TPVALmyIaaxaQLRPcgZ1yKvHGRJ97OenCgDDghxCNa3Qbk+wszzGp1dX8MjmJh7aOI17V27g9HgHp5sdnKh3cabeshzRegv3jq/jcytn8ND6aVzYXsP27gTdXg2aVs6VTKgXG9ZoBRARFAX1BX5H+ABDYh4gfZ/EuEvVC59EvCuRWJIomlsk8vF9oxkAmgikM5jzImI+KAnwx5Fv2ADK1Ak41cKaeGZPMKayQLFbMmiXLJe4PrAcel0bmDo0joEYA0HJ/ZRuVdKYyzmduN6h0tg1RfoVNCKd1/Hj/jJxXlH+Yqw8Q9gAcPkb9Dl+6borw8ZJPdOoL76EyC5xTx5xHuH8U+gZTgUAHgNJkS8QA6Eojf+eGGqIRdMTJWkP4d7JPFNLtkUcyKgOnETWW2Xa5cuUz4Q6RsBBbrQMGrXVXaI2lKVr2wGVM/QAl8sbqoIzgghB7GXkA1slIUbXYWPQHmAhWK2yiFsbKwrkjZ37jwhExndNAHK2nn6ziLg45MWgAVxkQGAC/jSLeycatNxiZXWKu9a38ZUbF/DVq4/ggdEFrKkDzE2Fz81P43PTs/jc/hl8fvckHruxgRvXl4HrI8vVmxFo7gCDiIjhfc3p4DqE22qvhVixqnOb4sDeEVtsiz6uwjNen1PHz3AfptxtriNgwOHhWBSr5gS9T2j3Gkx3anz+6hK+uHwS48kcq0tTnFvdxgtWL+OBySXPDTxZ7+C+yVU8snYSX9w7gfM7a7i+tYz5bgPar4KOoJxftTP2Me5g4LibHkwIHdBe16TvmACJadrIPZIK1yLrUoOIe0hdOPiwioM/VImxZZ+WHD+YDT+0M0byahV8COusRb1yoQ61aKNqyR2WjBMrG6iOYv9wFPLz778AgrZtiNoWgTZuu9Dz63FVWVwuu9gEkJlG+EjnbU+PTx545UGV6yryjkCnCe3wB2DN78oCkXF60C5U6EuECgA8DkrBX7IIpGKRhVnxAp/kd6jIFeiV6xWph+o5UL6sd887flq2AEOxEjfCEZICOKDOgT/hnNcGtLff631n9SrAX3TKrl01TOrWw3hnzt4Clx8U3BHe7Em0yRtryD4ksRmopC+AwDGAuE4hrRSvSZG0ZvckfK0x6JY0aLnDyvoB7lq3Ys4Hli/hy8YXcKbeQgWDz89P49MHd+Nj2/fgs9dO49qNFXTbDartCqN9QE0pcIpaofdlEMR2gOe8+jF0gMG6HzEiTJkJYkLZbgn6BbgjTcCcB9R4HUIuy8e7rWyh0njAKGd4YAjGlQ0FUGW5gLpx49oRqinBbBF0XWPWTHB5eQWXV9fwhY0TeGjzDJ67cg33jK/jRL2L0/U2Tqzu4v6lyzi/uoEvrJ/EF7dO4NqNFbQ7Fgha7jMjDzs22g08EXmfgR6QyrnBB49kzsj33afl+QZxj8mIdcNNW6+nmAEpwSF4+C7fBdUGoxLm/hnJ/SMeG2fo4RybWw5hMMiiqU1jKqv/x5bJduzD2DG32INUhHozAJYGGlk3KtwVsu9662g+FFvkFmZRSDZp9KFCOEhg2JI5LdPIfP1hx/j3pKcPKNsw3OynhG7dEfSTf7bQM4MKADwGyrpeOfShAPbkb0nZuLpA9iSZc7mQu55zR5NbdL2rCq+7JRy9UljQI1Fvru3K+hnrRvBcIUiuEP/nxdTAWfq6aBcgLxozEKAKIr0GqLUp1Nxa+oLLYs//KqT3/UNxX0TV51u+jhQ2W58kcDLyFr32P+tzpT799NhAL3cYbx7g3OY2Hli/jAeWL+Ge0TWsKcsKfWR+Cg9Pz+AT2+fw0NXTuHZ5DdW1GvUuYTSlSCTI7j7ULBYVcuPYJY/lytqGqNYBv6nVi4z8NfImX5Fov5hXYj6AENyDeAAYOlU3BBopUGP7VjlXO2zxCsd58wNNDjDWjlPcEahmziX5ftW7Fbpthe3rI3z8ygo+s3oGG6v7OLe6jecuWzB4utnGyeVdPG9yBV9cOYmH10/hCzdOWhC9xcYiPKFhdTCJQBwpQriNIacjpxCAV876NKL0WgL+egAP8bqQAkevRsBjISyYvdW960Mf8WMEHxHHc//m8G5ndEXeeTQDQJ7D7TLQTQKaIseVte+yjYXd1faajV6S6YMhIEQC/Kb9swAEBu676CvOT45JCrQRxLhezQFiXaQAGBlcyuu+/nJ8FlEyNw5jABwn3Xos4AIAn+1UAOAxkl94DksnLGyPpDjsKCtqzm0cSR0Ezskuqv70yo5fOd0AOB08pYtF11sYVm6DJ8ttqPcR6ZH5PqDwPHOPrDNc4zc7rySPGFwBALn4pmFXYHBooFrqAUfZL3D++iDq0+MkkOz/uE8iy88KEQD0ba1Zf8r+1xMDrLbYPLGLB05exl9YvYjnTS5js9oFAFxq1/DZg7P4zPZZPHztJLauLUNdazC5oVDvBb3JYM2N2JdcJw4QbGwT+WO0Y61ag+pAo5pqB9gCaLbRHexvo8gaEVTkDQBsfg4IKgD8m7tNW4AARdBNhc7AG2OoubZcp9pNFMA7LGYxsQUzFuTqNgBnFrXrBui05X42WwR9dYRu3ODK8jIurW7goc3TuPfEDbxw/RKev3QJZ+ptfNXyY7h7dAP3LN3A51ZP44srm9i+tgzaqa0rHA+cXLsJ1lm45CjD2b0YAZbSg1rmvSTVv87cPy/6FPOsRwxC+OxiDIwmP1wcPQdgUa8DdQ28dXAK/qwPQQaKiH1VuqGR+p5eFNpZlQHVGsw7YL5mQaZ1zt4/uGYNM+RaJjln3NXyHXPpbR/YDqA0vexrWR5luj3VQ/R9n+f4SeB5ZOMV2dSbWOePizTIqjTcwvOFnt1UAOBxUe4Em7m2yMI2BXg2ff5ez7gjU6b3dZaSW1xz5UWgjhd7afXG2MDvOjl3MUDwtA+r8ze18UZ1ZTcLAJH4FmAAB89t9JuOBgxZIKiMiz6hLKjyIJCsOwvARTXgPDlixwAnxXMwtVjPud2y7wX1xFq+zfHHc2BqWK5S5bh+SxrNxhT3nLqBv3jiPL5s6SJO11vQUPjC7DQem57AQ9tn8MXrm9i+vILqeo3xrkJ14EKFzeCRMIsWVWuBX+V0uaSeZPDFGP57PcdWo5pr0ExDtRo2ELKclMYXZBSBRhVM4wDbTIPmnQeJ0Nq7G4n7i6C0BZeqVhH30HLWDFSrwqGhcdaqxoJA4wBLmFO2L6mD1R0QOmiGnSdPRphda/DQtSU8fnIdnztxCi9Yu4K7RltYqw7wgqVLONXs4u6lLXxq6SzOX13H/MYYNFUBiDrQ5vyDg8jYkGpEXj+Qx580YDTid0HMNc9Z4vkFnmOZ9YDfyQEQGBInv0nOO9uH7E+Q60ga3odgcA1DQjc1Kc5bHyPi7OkRYV4Bk6sGS1ftCWC+5gCnsWPq+8f46i0+IOfuCWAMMhHXXaZnbnIW2KXFpIe7HlgfFvumdYu+L2qb4SbcbhhYqNAwFQB4DBT5zDts0RaUO+n3uHvJwpL158cn1Ei8Gy80vbIW5OnzSFfGHHeCF1DZ/sDUsZwNB0wMAe0KYbbBvszcpiLFtO6Eb8FfEGd5oNaFGKmGGUxGPOusf60/v0y9JTfAkBdzRu0fAOiSqyCtPGXechP2Ljdqa93bTTTMSoflzX08cPoKvnrjMXzZ5AIa6nCpXcOn987hUzfO4onr69i/PkF1vcZkS6E+CJtv4DaFMWOLz2pmgmV1m4h03X/VaoBBWkUegFOngVaDui5w9ODGxgE2UjatNrUFg52GmnUBNHYGNHfoqVIwSlldPiLQzJVBFMabAEwBVSmAOYw1I2jb4ZExCv9WFqh02gFEyVkjQM/JOUsmdHsNpltr+NTVZXxh8yROre3intUbuH/5Ku4e3cBXrz6KM6NtfHLpLnx26TS2t5acxbCyFuZ+TlhAZruGUR88yPF6fp5FjYik1Tzfjzhl8kCmMunkXJSHMPE++ri8zqCG5x/PG6/3N4edG+69keDP6/NpISLmuNvkxPKNDcloaqCaEuorBs2uCQYpZOeWFZGLQ6jJ4df8gSFwAGMwFxuTJGuDyscSjg5yuYM6BvKQEhEge42ftXURSFc+Ixt+G/FfEQEXOowKADwOynGKhl70BLjlSIruBtMK7lP0jAApOdHHovr1RJounV8cxfVFcYG90YFB4Dg5kR11BvUu+byZS+a/C1FtpHclyzPwRh4K8BxBz9kU330/UPgfbcQdRWlkWyPDD/8bQRfQwAMEL+4VnD8oC/66EdCtdFBr1rXLC09exl9afwTPGV1FZwgPHdyFP7txLz59+Sx2Ly2jvlFjskeo9tmVR1w/1RpfR+uoF2j2NdTceOV/NdcB7EnxdmtAc8HKEf7crBjX9TUn4bApnXbPuzwryz2kWQuPxLtOAMAKGDcOjVsQ6aeUUvZ5wHegqRxncWyXJNVSxEnmMdI1WUtwF+nCzOHDCHrDCBZjk01TTRW6XcL8+ioeW1vC+fV1PHJiEy/cvISvWLmAe8fXsFpNcWq8h8+vncSF7VXsOCCoDpwzaScyh+HQfgIEGkQ+M1Ir+MPWguiSnHM8L5ExOBJzNhQsrku9Wgn+WvsOWs459eNOuzlgDYOsPqmPS9wEYyLVAuQOcLq2ba1mBtodzsDGT6xrm4Ax/h51QWaNS8F92nfynSUNC+CkW5d8N4v+jnUKU5DZE10n665sl0muxUBdiPlvE926H8ACAJ/tVADgMVD25X/SeQmuABgQUbiXEi9G6eKScAuOQhFwFM5NJSDy2aeiZd5QJNfBgQkW4WgXnaM6iOsX6f9FbkXgN3q7M8Jb+TLnRfoEXASqJWeFgZxX5E/Gj4AQKSTtQwYaqr95yYgizPnrxgbdqsb45D7uO3UdX75+EV+2fAEnqx1sdxP8v7178NErz8FjlzaBS2NMblhRL3Ne1Fy4U+H261Bn1RnUBwb1nnbgz37UXFuOm9PBs0BKgD0hrjVEzlEgAGXda0PDcgPbzuZjHNqdt1CzOaCsbDS9Z2bWvwyNGpDWNj+nzwfYuUxKAVWyuWgu3iFPYXzD898QAK38vFAtzxXjDx26svNEpjEuykd1AHR7NbrrFc5fH+HqqRVcOL2Or9w8j3vH1/BVq4/h/qUreGTtBD6/dgqPXt/A3vUl0F4Fap3bGB53/uPmZSSS1APTUCSV7200xwhxXo5SNY0c8Es5hPL98BF5fJ8iGH2w6JcPGJ2LIOJDL8JzCvnQYTmJ9mWZL6tEp9e4sHdh/fLvrDQygnj3ZJ3ZGMj380Bfcp9oE4NtXq9AcV4+f9FfCcAeor4LLLcmC05jTwzswKSMR1yo0JcSFQB4DNQzijgq6MoBNnlPbgaSkyD3goTDkAVBhwHDiFNG8XWZdwpE3WLK3AF2tsxh1zhqAW/I8C4ojMgTlgsl6uEdCLP/vlrcY5AogJCvi/svDSN8GWJj8G1NOIUsIpJcBxrod/9bANhInNbYaB7dqsbk1D5eePYSvnrjMTx3fAUVNB6dncL/3b4XH794DjsXVtFcq1DvkOW6OP0ydudh9bWcEUcXLHk9h+tAo97vQHPtRG7Gcuqkrp0CvG5fZy1waW7FtwRYoCZ1T7W24G/eWu4fj3nXWQDnRcOMKgxM23pOoYEDkEQhfV2BOH5L2zlOkQWDluvYWZEwzzXmnBCDCbId0zmjFLKDripyrnXI+RIkqxcAijmyDhBVB4Rmt8Z8ewWf3h7h0tkVfMWpi/jy1Qt4zugqnjO6ivsnV/GxyT34ZHMW16+uwuzWwFy84DWcHqA7sDGEYIChEHQCeV6RWCIE8JCvZ1b3rwcG0aMe+ANiUMRpBJjzBxV+XzruH6A6MFAzm0enEPt4dP1oiNCNTTxvjJujrl90Y/UFtbJDMsQB6wEqXlsG1in53wJMYeDk3L14NZoUsEkxvegbjzlTPWvZv7wuILQ7Z9wi8+e09n++/U8FaUPWpdEtPF/o2U0FAB4X5YBVSpnT52H5DRqEpFkfBvwW1ClbvIlP6h4sEXxQe7sJWLFcN7bpmu0Q1k3mzyGroggb7j5zh2Q8VHL+xyLRFIMsFi9r8Uyv/uG65xI6cCf1+CQTBgRoobsIIPbFhtAHvi8UYgDoxL56ZNCtdVg6tY/nnbqKr1w/j7tH17GnR/jc/hn8+bV78MULJ0Hnx5hsKWdRCW/0YsW4xnMAWXRnRXNa9K+x6aad1cdz4I65ct6ytxMsWwZXDPBay3Ujd93UlQVunbbPMcjTDCrtf9M5ywfJHVEEKDvIZj73HEhqGlumUs46WIMMCS6ODr72FEBKhfFxOoJQQCWMe+z8cL76Wrg5aRE5GXKGI/DRMvw8BoCZc2Uya3D9YBMf2R/j+tklzE9U+AsTG3llo97DSj3Dx5pzuHR1Hd12A5qRY05SAAdO9Oh1G+XhgQLgyx3EoggUQ++vPJOlh02XLsInFOZstFY47mXEpVZyvgXOn5rBOwTvzXmCdYptXP0Z6LDREXMQZ9Zye7Zm4xTzs5H1rq+v071jR+va9Nrak0aIPutxEV2fRrp9LBqmBCwucs0ydIvLyFxHOkYCBB6ZOXAMpG9RBFz8AD77qQDA46DcKTW9fzPgj7OKTvMmuRc2jiEL4V7dMvVLT9mpQUiqUyjb40WqjotQ7wPjG/bB2apd7OoD4zlZpiJ0IhJBtIEZeK4eAFTOF6BiP2YSCHpjkVBH2V+smxe559BibU43i7SNIm+YGN/ITdCDUuasOM5fNzHoNlqsnd7F805cwwtWL2NZzfD5g9P47M5pfObKGexcWMXocoXRFsFFd/Og1sd7nTsQ2AbuXzWzLlvULAAv6gzUQWstcv34uYq3Hah1hhoMAitldfS0BqYzmLZzKAYAKVBdASMGbNw4nhAWxKFzz7Rt6JuqAuoaRGTBYdfBzFubHrCcPMDm2WlbD6MikOktzlXn05tawTSOhaxt24jIiekVDDn9QkWB42mCGoGNMmM3fR+O0GHgeo9ARmE+X8anZndhv20wP13hq5cfwfNGl7CyMcV6vY+PNs/Bo/UmZltjaFJ2zFgtwc8NC3a9TqvXZQ3zzYj5moLAyOk6xH+IeSaeS4FR70DDSZJnIz1bEQ2kmvKBw3GZEQC0FwFzph2gNLwxCVw5uiHoCdDN7VpQHxhUzg+oruAirJjAvZd9oUQfRKA3cbDMfS45fbKPcmurKCdNM2iZm6wDUafmrgNBr5GSa7cR+BUqdFQqAPApoEVAbyH4k5yDzPVF5VlwE8BbbLGa981lcgumrEO0aIodLF244ZTGD6xvuOmawvSUXT3NlgWGnsvn6qWF5312C+IP9S5/5TAGdQaqdhaIknMhuQEQ/xGAZC9mJ3s5SdpMiBfpnEjN31PiPxt/VLBcvyUDsznHyVPbeOHJy7hv6Rq0IXx8+248fP0Urlxeg7pi/fk1O86li9jYvJi3hY/MYS16bT9UM+25feRcq1DnxLltF4Aa6+c5PT4rnnWcvroG6toBtHkPxJnWjUld+7w894/IPte2gNP3sxOAvCGIAYBOexAIY2BmANiK0hmNUF058W5A2ZKBAhYRA4hc0zBINMo6/XbGBkY5zMUi89o6OGbRpp6TFc03di6RAzRqTqh3gNaM8QVzygLLM8DLVh7G85rLWFs7wHp9gI80z8XnmlPYvbYEjcqJNCm4O4E9tPgWtPH8kRzu9HxmfduFeRCJL92NdI5GHK7cfRr+7d8P5vxNraoBu8DxBiKN5d4x954MrG5ql+gI1lbU2y5bC2HiWM4z5y+yo1C+EycrGM/xjrh6CGtWELMSwEAfvHblF9I0NneO4zjoExQJIBw4KPo1dWDt7AE+v1bdPiSojYK+BUveW3m20DODCgA8ThIAy1swAl6cehTw538OpO3pxPB+Q2JREs/3wJ8ETekpmzlKOZAoLF9JKl0D3rMHafhQUSx+0zWha2wM0UiPhvNUboMTnDrSJoA//riIBSkXJ3vqTxf4HIDmOsh2aNG/Mu+kTwBE3D/j/Pu1qxrqxAznTt3AAxuXcdd4G7vdGJ+6cRZfuHAK5sIY4xsK9T6siK11HBRuY8fK+sztM6gPNNRU2020taBOzZ3LFq0dN0V78EetA4I6cNWMdpw6Z6FrWCRsNDCbwziOGpraim8Vc/Bm8JxB6SC60zCzmQV3VQWqKgfKOg8yDev0AbYeVWWBIFsMty2M0VY/sKkBIivqZd1CNwh+w+wMyHB+PF4GIO30RBVMo6zvwM6Jh130EA6Rp1tAd9Z9DIwVCZILLag6Qr0PtFdHeESdAJFBBY2vW/0cztXXsbIyxVp1gOX6efh/6i5s0wq0Y32r1CBKwtguvuxFwdRLGdIIfTYbBacvpvQ6a7m5nczdKG/+L4yomOvH899bBo+sXq9ugn9AmgvAOHVNVME9jE/n9XjtGKrWhKlUkWXmEnkQ6OskWKqpbmH0vmbWrvCuxp0ydD1dM9O+AsQaLkTKdh0Mh22fD0x2OGzZAHLlPIXUgdDdgsz5Vp4t9MygAgCfKmJQIrllklIWAGLw2DstyjwMArePQcjAybLH+csBJmQWRwEUbQQIkZZ1tVx+MqRXN7Kn/tENhBiu4kRMTnQEZbzCvq4AuHjAdqEkaO+AVurruGtu82YACQkGU7cREnTKtimRhi8nfZLlCAI9zl83NmjXO4xOHeA5p67jeatXsdYc4MJ0DZ+8ehcuPbaJ8RMNRjccxw/cFuNdc0hRL3MCrW6fRnXQQbU6Muwg7X4z2GOOX9tZcNa2Fmixta1m8MVGH110zSjlxahEbitrWwsAnR6ftSQBTOusfY0TK1cWCEKpIOYF7DV2AeNOCdYgxMAYJ1buOmuAMm4st48BIIuaa2ucQlqHWMNM7BuRCKZTMLqCqZRzbEygiiwXwzgca3jABfpni1iCNbw5IHTXLQhUZKDI4OtWPotz9Q28dOnzaJxDxk/gLmyrZegdC15VS5ErGLBMlt9/1lv1AELMv5T7JA8lJuaWy7nI73HMFZN5xXlHnEd/2ArgikPFdRw6TjiRhmGutFXrqKYWgDOnMHIPM7eGJNQB7VhEAnJAT8P4mMNGIdLR9ZJeeRAzMVDzFsUCLPbe80VY62ZxWDJG0eFxUTGJQ2nP2S1U6EuECgA8ZpIiAn+aHzwWiq8D4G8wHrA/oQ6DP7lAZUEl+guS3DQswKEAsoCwaXQuvwoh6kBNMMqgPiDvRHaoHEMEpazOHDXOx5hzSwHAun/pYAGJCHHl89O8UVJYkEmAzcwCneoKelAq+sdzJV3bJIj3RiSuP3RtoEdAu95h+cwunn/qKu5dvo6KDD6/cwoPXTmNvcdXsfREhfF1pxTPm56GFZO1QDW3YI//h6gdxgK/znj/e97AozPBiIPFs53j9DlunzEGZJQHbkRkQRngxah8zTg3LpYTx7JRijlYLOb1nEUDmDlgKpBSINYt9OOjnTi4c3Uxlhsp50HbgqoK1Gk7N7V1X2Mq5yrGPUccpcRW2s9FDxYZGNfGOZO2g0mkoaCgQVDOatgoG16O9ThrON/YimAaA3SEbq/GE9fX8X+be7GsZhgtdzhTbePFk0eATWCpmuOT47O4NFpDtzWC2VNQcwo6YAjzRs5DJ7G2zCAJCF36SLQo5nKkdpA51GRVOQx660qOrPW0M8Ko4MEfvwfsFLqaOp1ep7bAYR49R97AhygkbfPpxuTBr/dfidD31sjEvd8OCPqDXQLuDLNPGRxL3Upun+DG9QCaANXx4U4i8rjfskYiybptl58ATnNWwdGcuE1URMCFDqMCAI+LkpM2IE7zyfXDng1B3hNL3CGOliirlz6Tb69uuTyJF2dxz1jRT7NrUM1tfNF2ySYILlDsZlDvW0Dj44e6PFiEDFiRjRUdWXcS3TiIkVjszIrji0S6JHCB4R1W1Ducvg/bCGPw58t0m6A3/HDgrxsD3XqLlTN7+LJTl/Gc5euY6hoPbZ3CFy6cAh6fYPkyYbRlvKEHAcIpb7CaVGz1OxX+/JyOn62bc5w8117fj1oncmWDC+107hzggrYAjHgAmItnnH4eEDh2nHYGYASbTjHbl0WvnI8De0bDdBYIEtwzUoTLYJEB4wzONYyClwe64SStrW4iWy87tzQk85KGKJI4oglpmNYOv4blNCoCtLNYB8gzFk1lQMaKJnlC6NqN/1hDjTsoZbA7H+Hx6SZO1qehRhrr6gAvnjyCtWofJ5tdfGx0D77YnMBBNYHZq6CclbABXH3FKcN9NAWQxEAwOmTA9aER72DyLoeOS15bCTjl+82Ai7873BzAJfn3zdTIgj/W+SODICZ28YORADZdwVqVi/ePOfik4fULtTsMKc1rgxxYE9YtrrtHxvFaFxvCGF+PHkkQiIG0GZDmQeUApRzKKG+Z/9Ae8BRQh1sT43aHJyn0DKcCAI+DMutCz6GzOMWm+iPRaR9wgCNxwiw4fUM6K2n6tG6p/z4p5o0rHz8vFcbrfWC8pdGNCO2SwnxFbFAE7wsQRDAHVmSkhNUf+e+2LqoFdGugWgK1ToFcRBwYAm2RWJnb4gw8ela9EgS6Nkn97Zh7gJj7IPok9I3l/HVrHZZP7+EFp6548Pep62fxyGOnMHqsweQyodkzkWhQcv2oC2NsXaM40e+ss1E2XIxdzVawnQN/89aCP9anM8Za8kqRbRdEw6ZyxhakHBfPQiQW/XoyBqbrLAh0Fr3etYmz5iVyImKn0+dBIYNPV76R1sh8H4DpvNw23GdfgyMdiZBpNvd6iz49uwrhayw29vPFchmZQ23ZzMaCEW3F7NZKN4AT1RmYzv7WtQEtt1hf38fJlT2cmuwCAC63a2iow7nmOk6pXfzF8WM4We3gVLOL/z26D59uzmD7mhMJTwnUuvfCRd2AJmfQBK8vKz8REHTpw3xL5rOckwa9uepFzPxuM7CrRFpjr8v4xekBU/FBhV3DOPDHILFrguP3dA3x4Qh5uB34U3M797spMN0kdEuurSa2DPb9omCtg0HOlyW8Y/GcQUzEgRVrLs+NFDDn+m9IvJtyDXPrcCTelwD8aaDCASx0GBUAeNw09LJTWIgGH2XgkmwGHvyJez1RA2XSA0EUYkKaVB8wC0plnm4PI20cxwSYrivs3k1olw2qqY2yoDrBHRjBbta1AbUUQA+RM+YgDyxt8AeDGgBpgm5N0D1yxNELwm/R/h7n4BASXBLpKJijIUQiqBTAV5bz1653WDq9h+efuornLl+DBuGhrdN45LFTmHxhhMklWPCHoFvFnL96agSXj8fERe+Ya/ffWc/WyodJo5ZAU3em11qAP2fdkIKvXrs1vKNDJq2tEQeLgdnC1xjL5SP3YaDoleIrRJw+OHDXM6+k8CzXm387wOmTKoKpa6snCFgrY2c4wjqEqGtbL6WCWLRXBkDQFqyQtfY1xs45wFqkqoCP4/dIAfWoxdnVHTx39Ro2mz001GFuKlxu1zA3FbpG4Vx9A89rrmKz2sNGvYe1ZoqP1XfjSrUKvd1AHQBoBYgjbgMsayU51ERhH8U7mDNwkuR1XjMg0L/flQBpEgCyRTwzwZxINbIQdvqprKfn/So6x+8MKr2BmAeNxlsU+zjDDcGsAKMtYLSr7cGmtn1ianKum4JRVMw9dNFFJDgzCBxSA3BEEA9ofZeZME/4t3xFMkDNAzmxVvRIgEkJBhe6fBnKq1Chp4EKADwG8idPceKUun/SSCMbszebKbKn/b5YmAs9QkUzJ33pZiFexMinIY484cBdN3ZK4mPn9qSywE3tw28UAIvUyOr4tTZYvLU2JL/QW8Vwy+miDqhgRXNex5A3ssr4mK8AnHWk7PMM9qZw3XAfyv/cVuaQsHEHA8DoGau/x2Lf5dN7eOD0Fbxg9TIqaHxm5yweuXgSo8cbTC4Dza51f6ErpxfGot6WQ7VZq17VGd+/aq5RTTvQdA7qnO6Re0N1ZTlvVe04XoDl4LHOX9dFen3GgTrrZsVyv0yngziYSangv4+tgtktjDFWvOoMQ6Ao6BCS46p1TuevUrHbGAZ20ghFWg1XledSmgRI+rZ5rqKzrlSVHQ7VgN3feOxjqvCOKViQpYzDn9YxNBuHgCznk10L+fljeP4SKqWxXu/jdLMDRRpzXXsQuKfH2NZLuK+5gnWa4mWTz2NFTTFSLf5M3YtLtIaOGqgDqxfI04gjl4BibqDqYsBBBpH0uMddSwEL9dP460KtQYI/Vj1InalH6hoakf6tD3XYUGwggpCf9105D89Y103kuZDsJ7GeGui98K6FsH9ujZRtMRa4eUcwDPR0nDDbD9y2nu5IfD8HpCPr3ehAnFxL8/0SAHqdUehugYt3K88WemZQGeHjJAH0YsWcJ5cPW/XlDErkgr7w9GkQnYqDqJMgdfw47561sNsI2E1ENyK0EwvQmi1Cs2W5f9Taj5pZsS8JtxLsUqIbE7oJ0E2s7mC7RJgvEdqJQsfcBIQymZvAftykbpwUn0VcTeZsmOT6QD97cXf6PUoXg7+VM3t44enLeMHqZYxVi8cONvHQpdPA4xNMrhCqqQHHpSXN7lwM6qkz9HDtqGYa1X6H6qBDddBCTVvQrA06fi5er28vu7ogsq5YEvBnTOD+UaWsTp0DbJK7F3HdiGwotroK6YW4Nej9EbyOn3sGzQg0mUCtLINWV0GrK/YzmQDNKIiR6xpoalBTW/DXiGujkS2XOXhdB9Paj93cBeAVeoNeV7DtrKh4OgNNZ6DZ3DrE7ow3KFHT1vlOtA601VQHv3ddeD+svhthflBjZzbG1OkzTKjFcjVFQx32OhvJ5Q+3vgz/v50vx2fnZwAALxydxzeufwZfc+YRnD29BbU+h17S0I3x7zHPLxu7GF58KoFR9FscTPyhhEEdxZ/cgbF3XXLo2OEzh230LojC++bjN5OtK/sE9EYiwql7pNfqGMGmtuuFrp3fvw6o9+x9vk6iLl7vNSXJCUzb5+5LAJuudTKfIY4eZcrwfZtbQ2TaFEjm0op63y4ylg/+pD/mJiv7e7/3e3jd616He+65B0SED3zgA9H9N7/5zV6FhD8vf/nLozR/5+/8HTzwwANYWlrCmTNn8PrXvx6f/OQnozTXrl3Dm970JmxsbGBjYwNvetObcP369SfTRXc8FQ7gMVGPyyeuD6XP/c6FfgvOfcVz/uSdLyurJyjLiLgBGc/84E1RGHKw4rbjmlhHxm5xF6Ii5m5acZEQ3SorkvPlMjdUw4vlImOLqIMQxLyW5QMfZJ6vmZCv0VZnKIhooqxC8pRDknJC3Cagm6Dz9xdOX8TzV65AkcHDu6fwiUt34eCxVaxcItS7btOsAbAzZ98v7n9nXLQP68pFOfcu1DrRr4i9S/MOaj8AMuJ7kstGCqgA6jqYrrMuXbQdLwCR5a4nFsX6OMwOPBphHGIcmgacm5cqpAesqFbE+TW14wYa65vQhmdzrl/YmpKjkSgCVO3yEQCvgy2Tw9VV7CPIhLI5iojrE4DfAw5dRkEnsNVBB9NdJ01Qc21DwbWWowVjDy3VAaHdq3F1dxnnl9ewXu9jPJpjQnNoUpjqGo/ubeLy/go+1ZzFo+sn8P9Z/SIeGF3A80aXgTVb1EfpXpynDXSmAWkFmlPEYTKKOVc8tvDRa1IOINK5Kycw+mlCQoT3C+K7RnRIAuL5H4qlcChSiJywR5FEPIhz3EJvTELBql+HOnUTCySlmkWqv2dUqKOvp4KfR0aMsVxLwm/EIDjtG/56iP++Xn+K+vqscmu8SJdb25+NtLu7i5e85CV4y1vegje84Q3ZNK95zWvw7ne/2/8ejUbR/Ze97GV44xvfiOc+97m4evUq3vnOd+LVr341Hn74YVTuMPv93//9ePTRR/HBD34QAPC2t70Nb3rTm/Abv/EbT1HLnr1UAOAxUJbrFrkoEMDwkJWGjFN4Zjcni9aMXF7piTepn4k2TERcNC5PV2HhVppgKlsX5mpJp9BqDrtft8KrP+xeawhAZ2LrQ7boU/AnTDYOMWlUgKhfFrQ/AcWRmCjbcRKghv89IniDj3atw/jkPh44fQXPXbmGDgqf2T6NT184g/ljK1i+oDC6brwDbBiEaB5Twbl0bbXROxz4azWo64KBB4P6TsN0HdS8Bc0bmKayVrQpuGf3LOk1wHLU+JlEV84bhrAeoeceVj1OoI8eAoTy5YbGfgilrl5dW6BGZDmaAIyZ2/xcOsN5MphlAMeWwhxLuFJRWR4EKuWBp29jZS2I2VccwVoTaEJw7Mt+FudWRYFDFaopUO0o7F5bwsPNSYxUB0UGdzVbUKTRQeHGbIJLN1bRdQqXd1Zw8eQqXrqxhr+49BjO1tv4S6tfgCKNj5LB49iENiOrf5hwpwwQQAwhAFUH2LIGBQi/F3G3+VnJwZLgj9NEXDJOm3DVWY9Q16G+kkPPPizD+hHAX6S3S7AqBQlJgxGlmQPqIrtIF1B+XTVhLeG+dFIStp6WRl89kNY7fMfh5PoVDH3oD8+JKs6hZNAXQT/FdLtFwA8++CAefPDBhWnG4zHOnTs3eP9tb3ub//685z0PP/VTP4WXvOQl+PznP48HHngAn/jEJ/DBD34Qf/RHf4Sv//qvBwD88i//Ml7xilfgU5/6FL78y7/8pup8p1MBgMdA/kQORGJaALGScrKo5vKxWYXFaFBPUHCqFrk24XxsmbGxh3e7IMCfd88wQohBa1gUJcCbci4cjN0INKxXf98f4kRPJmAFo4zFDy4cVNgIbScFMRf1wKwHxb6/QuxQI0BpdPLOcVEY+Enwl6x1xoE/0wDtqkZz8gDPO20NPma6xqdunMXDj59G/fjYu3phJ88srrbREozjNhmoTjtffrAbSCfA38HcijI7x/3i+LlTZ5AxncGMGoDBjnLGGV2w/DXGIHLGbCyAZGfL0T0WzzJ4NNpy+Bwg80YXDKpGjfAhKIAe/wZCJI9KASOyXEGl7JybzcE+DL0/QhLhvthCmYEj4IxbhAEIE0cWIQr+Apm7mHIAOxPjZd6IDXlObDWDNzJStY0PbK7XuFat4SFlMK5aNNRhouZodYV5V2F+UMPs1ri+NcKf7U5weX8V50+u40Urj2Gz2sVfXH7cWWESnjAb6MwI1a4CtaEe/LKEaBNimhpgCC9IvVZK2uZJznux/kSHJrm+JJytCPypOL9I34/DFJo4bSyNiOufrjtknIVxG9J2LB4nCpxF8byBHVsP/uQBUwDBbN/I/gF60pJc7OEe0eDw3Fyap5C0IeiFiuaHP3/c9Lu/+7s4e/YsNjc38c3f/M346Z/+aZw9ezabdnd3F+9+97vx/Oc/H/fddx8A4A//8A+xsbHhwR8AvPzlL8fGxgY+/OEPFwB4k1QA4FNBvHiKhZPFrINiiXSxyIG/HJiRTJgMwOM0kWhZnKhlPb3I1oXPanasz792TFacyJw8sZHoGlb8WAOmpSDiFMYgsqywkBu3WYv7ySk7MsYwiCyH5UYWbTzuXk8CLjkiDvR5w49MX3vwt2zDu9176gZesHYFijQ+cf1ufO7zZ7H0hRHGV6zPQ86bATFHTFBzjWqmPbfPGnw4UKU1OA6yF+uy7I/BlzE2Xu/UAkazNAaLXKlSMC28Tz8PxJQC5uwmRntDD8+RA8JvIsd9c+DPOV+O+44Cp43nkYzT630VKgvsXQQP3dioHNQZVLu2PSRFt8YAxhp2mEoAQycyZiAICUb5dyXEz0xCnA3tDisVhb7urFzR1A5cGzhRPKGa2zqohqBmQL2jMFcNrjar+OL4BFaqGdbrfex2I8y6CqZT1sijJej9Cb6wdxpX95Zw8cwavnrtMZxutvFlyxe8A+rHaRMdRsCucs6S/YmxBwIZe3iQhz7J+5zNIB0FhTCwS41CZBk6zG8S+n4e/Hk9xiRUo3tWdfCujtg9jLQqVmTQ7FkrbaMMuhFl18ue+xcE45BcuDefzkSPuTVBHFrB/Wr66RkgHxXSDQHOpxMRPkna2tqKfo/HY4zH45vO58EHH8R3f/d34/7778fDDz+MH//xH8e3fMu34CMf+UiU37/+1/8a/+Af/APs7u7iK77iK/ChD33Ii4rPnz+fBYxnz57F+fPnb7pOdzoVAHgMlC5IPV27xNeWjBEcrfBDB67cyT753XPlkqE0zBQQQBYv2oYcgHEOnw0B05OOOzJH/yRuAOlA1i7wBM3GGwOiEmLQQ/J3qKdxK3S0+A8AZ7/RZLiAsj84Lwn8ovL9ZmN8iDez1uL0iW28YO0KNus9fG7vNL548STGj42wdMFgtGMz75rAlrGgwln5zp2od9aB5hbwmcqBGdcHxIAww1XzpDuY+RxUVzCjBqauQE0DtC3IKMvFqyrL8ZvPhTGIMO5gFyos3pXcwEpZDqNSQNd5ca7n6jHokvpXzlmz/16xz0IL/nRj01Yzy5mrJDBlH4KuLErbywOT+Cns1anHHbSDT3CAVIq8O8vljF6nzgISG3qQvFgTU8DsEmZbDS6trGBjtI7puMb2fIy2U35+UQfUc4KZNtjZX8f/3h/h+l1LePHm47h3fA3PX7oEnAQUGTxKm+jMGLSjgl6tETGyef4peIDE85aBYcwmHKAc943fB/ffyKTiek8ikACoYD3sclDOjZ+CDxnpjUPYQITXPwZ/wqq4GznDsBFQzW0EoWbPAmK2mk6tniMPCuJwK1Vsejp6DETFfSPyTHWrZfpFlsW935m+fwoYaUeiDgrdLdh58rPMfWP6iZ/4Cbzzne+86fy+93u/139/0YtehK/5mq/B/fffj9/8zd/Ed33Xd/l7b3zjG/Ft3/ZteOKJJ/DP//k/x/d8z/fgD/7gDzCZTAAg8hXK5F1FFbopevKz42mk47A2mk6n+Lt/9+/i9OnTWFlZwXd8x3fg0UcffdJ1ygVrt1/ihSkFHbwoe8VmXnzlB8haqfXEGPI+c8bEhpELacThmDid6uJA73YTF0CRuXJiMWaAGyz/rAjZWgvaSB+6dh8BNLl/0g1I6ip5y8Rc20UbU0vLKKoHc/nYJYVUZu8BSuP8GBro1Q7rJ/bwvI2ruGu8hT09wiPbm+iujTHastERZCB71mVSrbF+0OYaqnOWvJ0V9Vr/fTz+Lp4vO3ZmA4/W6gJiKmL6skUuRwAxBt4tC38kV47dwjBXTXLelLKi5Npdr93z/LtyMXUrBTS1BZxNDeNAnnUNY7+bcYVuqUG72mC+PsJ8vcFso8Z0o8JsrcJ8VWG2VmG20WC+OUG7MUG3PkG3sYRuYwn6xCr0xgrM6jLMZBw4gFUFMx6FsqW+H6ch8iJfD/ZUOqAQ+oDyIjz4llawqrV6nGoGVPuEervCztYSLuyt4dLBKvbaETrnS1EaMagpYXRNQT+2hE8/chf++NLz8NDeXdBG4f7JFbzoxBO459QNYGOObmK8Xq2f9/K9FXO3d+AZ4izlKHm3etbx7lr0W+YrP7Jsd4j1/gDZwn8M6LG1lvcRfZhJ7ICtrsg5kSe0y4R2GWiXrEspaWRCBt4RdQDL8O8arwuxNCR4NuD3Wj6Xrg1ZKQyvwynlxmKo2109ni7gx8Qi4Fv5AMAjjzyCGzdu+M873vGOY6nf3Xffjfvvvx+f+cxnousbGxt44QtfiG/6pm/Cf/gP/wGf/OQn8R//438EAJw7dw4XLlzo5XXp0iXcddddx1KvO4mekRzA47A2+nt/7+/hN37jN/Brv/ZrOHXqFN7+9rfjta99LT7ykY94a6Mjk19swrHTnqydaCI9HRrERh4pLks4VkM6KJ7SU688zQquWkqR5bJbTL14xjhXDRVQ7yFE+JDlOw6I5bbY/Thd8F03xOIUQ5EDZM6Pu0P2kQHlRWCyjel30Q98SzuOROTvL9ngGCzqBuhWNSabB7hv8zrOTbZsiLftM3ji4iZGlytU++4Z3qxa45TW4d1hqM64ILMLiEOldZIzpkNkD8CDMgD+GgHCcKKyA9gBRMaCIcqc7YwzDa4rmCZE+eAyjPMxGPQEwzX7vAlgqyKYWkGPK7STCt1EeaDfNRRFh1AjF+5volBNKws6xLtg3eG0qPbmtq1Ol49jErPhi3HA04M8afiiAENuULV8FwWH1ThOgdMds+5KyFu6qxaopmSfcRxdfQC0uzWu7y5hVHWuWHFQ4zmgrUFJs0Vo2zEemZ/C7qzB9VNLeGDlEs6MtvHCjUvYnze4PF9H11pfhqpLJj6J9gDeICQH/HpcvDQJX8s9m3KqkndGHqbStcYacwAGFOnTsl9ArwrhuYWhn3yYOeHyBoCwyAbmKxSAoMvDO63m9pBotzaQIfP8mpvoDOe4dHw94gjm1lyTPEfimlh/fR5APp9nIK2vr2N9ff3Y871y5QoeeeQR3H333QvTGWMwnVqOxCte8QrcuHEDf/Inf4Kv+7qvAwD88R//MW7cuIFv+IZvOPY6PtvpGQkAb9Xa6MaNG/iVX/kV/Lt/9+/wV//qXwUAvPe978V9992H//7f/zv+2l/7a0+uYinQEVZqWRTjOVe0eLGg5NZh4C+LmPrlpqf7CIxVARDx5pZth2zvwpN1XBYv7uDNFIKDKRZbdukiOX49sU2ujZk+8XVLuSueO2C5EN2yRrU+w10b27h7aQvaED6/ewaffuIs6sfGmFx2en8OyDAIhnNqTdq5dGmF+FspQDmAJ7EZizCZc+fj53aRM2WOjmG0tpxB+8ODMjgXLoadajPHjwETKe+s2TQ1zKSJxKMeXAEwSoMa51hZiqsBoHacv8qKebtJhfmKQjuxnB1TI0RUcX2r3WFCtfYTqRFoQM0VmsYCTUVkraGB0E86HWjXT0YAbLLRUlwgYAeqBbJRBmhtnF4rJSYo2DExHUWGDTx5dGdDutFMYTZtsD9vUCsNrQnQBOoYbIZqqTkw2iKoeYNr0xP4yMEYW2cneOHqRZwe7+CBE5cxayts6VXgeg0cCBAoyLhp4d99isvJgTIJBId0Anuizgwoktx0CehS6YI3CKviMfccOsm9Q1gfosgkCGkMAe1yDIi9L9BW6BUnwJSNqpgz6euthDcF2Scm0w9830h9wrTzkt8ZoMd5yL7MPnMbSEPZmNi38PzN0M7ODh566CH/++GHH8ZHP/pRnDx5EidPnsQ73/lOvOENb8Ddd9+Nz3/+8/ixH/sxnD59Gt/5nd8JAPjc5z6H97///Xj1q1+NM2fO4LHHHsM/+Sf/BEtLS/j2b/92AMBXfuVX4jWveQ3e+ta34pd+6ZcAWMvh1772tcUA5EnQMxIAHoUWWRt95CMfwXw+x6tf/Wqf/p577sGLXvQifPjDHx4EgNPp1J9EgKAcG0X+yCxQQxy86LQoAZhMwxy6IXToFp/cgiYfiU75LBIV4dW8ewjZBrEReJ2fJP/exqAEoIXIJ7eWiLXex/cURYT+FCd8LjoDRrP6OpyhbE+mfxj06okB1uc4c2Ibz127ivV6H08cbOChK6ehH1vC6hOE8XXL3ZNt4o3Gu7TQcJwlHUAdW8HOOwscOuvw2YM4IgvitLDqBYNgh5qYU8iWu0yc3hl9EIuEWffPOVs248aJVasA+Agu5JzybeFrAHxcYqMIelTZsF3KcvXaCWG+rKzYrw6cGzkmPE86Id73uljOYAZQIF2jhhWnUhv6yyZ0AyetfFmPVBuQA9feBRARoBy3D7B+IWH7TmltRdwua+uw2/qh9HPN1dlbuXeEeWcbprVVfLNufmLAAljAMtomVLMK0+kKPtkqtOcU/sL6Rdw7uY72lMKnAWybVZCpgamJgHGqE9iz9KX4f5QmORxlQWNmXYrei1z5aVoJ5ni8ub9a5oIjHBxSdQtX/zSEo6nEM27d0HXQK04tgn2Vmavs9Ipzrl18F4mDuseEfo2IE/cOigvIHCXdIXkcJ3WG0N2CHPpmn/3TP/1TvOpVr/K/f+RHfgQA8AM/8AN417vehT//8z/Hr/7qr+L69eu4++678apXvQrvf//7sbZmnWdOJhP8/u//Pn7+538e165dw1133YVv+qZvwoc//OHI8ON973sffviHf9jv39/xHd+BX/zFX3zS7byT6VkJAA+zNjp//jxGoxFOnDgRPXfXXXcttCT6mZ/5GfzkT/5k77p1fIsI/PmA9RmuVkRGgDuD/qkzSRsX3P89FKS8l5UKm7Wau2DvcwGiKIhnsly9tGje6DW88jYAz8kY1M2RdaLglNUrpPt2hoDwuXWJA8ezI+nsppXWF7Ktxur9rbc4fXIHD2xcwd2TLVyfL+HhrZPYPb+C1YsKoxsG1cyIcbb9pAxQsdFHa4J1YWeCq5dWWxSktdXja7vYpQqHdpvNYWYzD37MTABw9o2XEEf6ABFo1FgDEWnsUTn9uaa2XD1yup2VM94YVxbAuXlrKgvwALvpwjiAXJMP66VrQjdy0SEaBFCQclUQ5gac+N/Ply5YwAIVdEWoD5SN3DG3bnKs1bPq6fEROUMVBoTG9n3MgeHDmeMkQ4OcmBiKgZ+BmYd30IryyfqsdnXVhqC1gmY3Rho+8g0/E9Wts6oT0ApTLOEhOg1FBl+2dgnPWb6OVlf4TKewp1dQX6/iqDZyvlLycXVcJDEYNFoQB6FI55DLiRrQB2zp2jRoIMJcO8F9i6QhjlQnnteIuH3ykGDI6RKPgK52vhrnJtvvUnLQ424ywMt4SvDtEeC6171DfZ6Wk7t2G4Ef0+12A/PKV75yOA45gN/6rd9a+Pw999yD//pf/+uh5Zw8eRLvfe97b6puhfL0rASAR7U2SukwS6J3vOMd/lQDWA7gfffdFwAeBPgzAhgOUMSxyi1GUeUy98WiHvJMjrZAWMw5DwYv7rRd71uLXy1io5IOEsugnB2DOG6DDbsVAFvKFZQnc/+oicFmFJPYiYON4xAQAHbqy9EJcmux5wKkG2bmWsRlqayz525VY/XEHp6/eQXPXbqKqa7xue3TOP/ECSw9UWN8zYE/WR73gZGbnwQgss0WpNG8BdoOZjaP9fwAoG1h5ja8m+cAApYDqNLdDj5GL5Ew9KhrYDLu6/mxqNmBQlMpmJGKdfhcvGXpjFe2xetPKjjDHgS9LnFQYJBh5FizsZAHgwAxF9odEnTtdAUPKlRTDTXXzkrY+PBudq5pb/hhnHNhmjuQ7dpq2Gm5FociDcsZNAZGu3nbGijSzjWLsmA24VQCdkM07mOBI0XWujwXuP2qA+p9gC4rHGAZn6EzUGTwvJUreO7KVcx0hc91CrNu2UYL6Sg20nB9x/lFYmCTlJkCFvmCHAY+kjUkbYt8t316xIBVgji2rPZ1Z/GwmCPS2Ms/42IIV3PjD3KAdaZOBtg/qTBfs4eNSngkkHrH8uAdSU0MV91EUhU+bEYHddlnQ9tB5kCZBdKI17SFB/xChW4zPSsBYEqptdG5c+cwm81w7dq1iAt48eLFhYqkh/o/EkBGcgVTlyNMqdglXcBzoeX8cwOn/CHXA0HP0IVScpyaas76bAbTzQrtkt20qqnx8X+p4/oI4Cg5CZUL49aFNh/GyfQ+xcCgwkQgECro2EXd4ny8GZUcuMWGJzkoAWBmQLVrj26s3l+zMcV9m9dx//JVH+bt4fOnMX60wdJFC5I96NOBM8YgWM2NjTXbOf0/B1zsA5kBk9E6GAiyQQjQO4ww2EujZKAZWZ+ALA5l/3518KkHwFrxNhXMuIJuKuiRQjdWaJcV2rGz1uax9daS5MV3kW83MRc8SEz6uLe5Uua7z5ecDqa1KK3GhGqqUB1oCwRnHRRz72B8fxrmcLIuoBQZexcxzkDGhDnm+1Q7B91QIUwhT6KEDILqIV9gECMNH2y97H3VAbQLTIzCAS3jM+oM6rs6PH/lCl6wegVzXeHhtkLbTpw4nPoWy7JOlICx9L6sLNdxYE3IUvreinfVk5B2AGGM7VoR4nRLaYiWuqGsI8j+BDvjQaDl5FvOcjuxLmJGNwxWn2gxrqz1MOscKnngdHU1ol7e3ZZ0RcWTkgIwE4/EnEOfPtMvGVoEAn12RxmDYyJjFPQtRAIxt/BsoWcG3REAMLU2etnLXoamafChD30I3/M93wMAeOKJJ/Cxj30M//Sf/tPjKVRudLzYuMXlUGeich/iZzLcMgCgjDgwyocX56RMXtRZp8ZU5F23dGycgeAiw3JtjFVng1X29xu+27OIKPgISzgXafxhwMQbnegr+5P8Qi37JIBisSYPgOGU2yd9/ZHXYTLoxgZYa3HmxDaet3oVy9UMj+6fwGeunAEen2DpImG0baN5+NizHM/XcStsTF8TOFY+rm9mfJQCajc8PH5tG8K2AVaHz+u9qeAkuVIBALIDaGMBDClnkix843mApADTWJct3XKNbqSs6w7nwsPGeEbE5Y0chAvOX6qjJkGhHGPm9lnkBL/5e9DvDkek4cO06coCgq4h1DUivUSwXqBsFxD0Be0kjOZJmA+un4ULG9LG9aECeaXEAN4in3jG6v7pRNHUiy4Z9PCQVOK+AZpdwFxWOKiW8Zn6DCZVi3uXruMFa5exP2/w+KxCN28sZ3Eu+o/nKwS44IOXRC5RW13ZkqOFkD6nfuHvp4c3/i3UMTzgE8ly8cQjLrE36EEcO7iN28Ic5W5EaFesSxnq7OGkmlsOfDe23F2T+hg1jvMI128Vz2Vy4gwE/T8BBBdyT4F+X+UOkkk/ymmSFUffBupA6G6hwFt5ttAzg56RAPBWrY02Njbwgz/4g3j729+OU6dO4eTJk/jRH/1RvPjFL/ZWwbdMEswIxWJefHpcPHlSd88v0uWTwNCWgXghSt9d5rawTtTclaHtZkWdPWmrGYWyuY7aWUfOAaoBVdsNmkV/EUhTDrwJJ9cyVBOns9eShTHtk/R30ja/yIrNqNf+TNoAcIwFPisd1jf3cP/aNZxsdnFtvoxPXj+L3cfXsHKBvN6f5U4Yv9HYGKjs8FkAP20NPWju9Pz8GJgYsDtrXaOt6xUDOC6fspE6vDuWAPyInSAbBYPW+w706gvOn593lqxgAU9ToZvUmK/WluM3cRy/BsFti+DsAog5fpILmIDACGjLCSk4Q4YQxKUSgFAol39rRSBl0CY+2cgYKFjwbQ0RyJkYW46rBajKu4ExHezG70WFyrqWqVlmyEYiGsTuYLS1yq3mgKntd9IEowlaEzrWkVTWl58hsuCPnZ5zhAvHyeJ609wahoAq7FZr+FTdYnymxUazj3tWb2Brc4ztgzVnDEIhZBz3kQAlXpyOYyQxVj2jEyPWogHwmBqbRODPjS+rSai5FeuyY3nPTWaLYmdMRC3QzGxEIlNZ90JeIsHliLI9UHXrEHQiVSD4dSkVpUvAxmlTbmDWyEy0mfNLDXKK6LfQlyo9IwHgrVobAcDP/dzPoa5rfM/3fA/29/fxrd/6rXjPe95z8z4Aj0ARkONTuwBjNk3/uSGDjhT82Yvif7LBRs9q40MycT3aCflFmXQw/vCK3Rreg79q4RdnyzWi2K2JWFh7VrxJfbxuDBBt9J7jwSAxbWPUF5lFWYIW5mJl0rDLl2Z9hns3buDepeuYmwqf3jqLxx8/ieXHKkyuGDT72uv1eRE3O6jujHP2HMAf2P8fG3wwp8430ICjYBgXcQNVFZrHFrxMqgoRPJJmmsrVSymr+8c+/urKWfZakW83qdEuV2iXFeZLKjjrrQP4k645uIAUDMY+FAO3pTc+3jE5hX5z/9UcXq1AOv+VZRIbqSjr19BmU6MmZyHsdPyosy53lHJcwM5Y45DWgITTbduPCDGoARBcGZKrOzdQlQWY1JAfZ3SErhOcwio4Lk4HJYgyg6U4GaA6MBh3BKDC1WoTH1cGX7Z5GSv1DHet7eDgoEHbLoE6hUpTZOQdHZ5UfHbySeQ7v4jLl6OUOybSputXeuj033nIRcxwvzYw+Gsd+JsJXdmKYtGpibmEqgXmS87NkBLlC6Ovo4IsKfb1a7AW7zbBq6PkdPeyYl6T/BZl2flgBtM8laTNzRtypM8XenbTMxIA3qq1EWBNzn/hF34Bv/ALv3A8lcqBDLmQUpzOx7sFRVwhr8jcY2n1KasLOHCi9aBRiKn8BtwQVGN9/VFn9QKlta6MMqK04z5o6yeta0zYwOVCzGVxFckE8WG6eCJsMkaRleJJroOkpL2RzpkH1qKcAfBnnNWvWelwanPHi34f3juFz18+idETDZYuGYy3NaqpCfXxHBHYSB+tBs00lAtx5q1+56019mDXLOlqym5hAICU5UrV+dcxAn/sDqaqgKYBcSQMjpBRKXAsXuM+3aRGu1JhvlJZvaoxPAfXA7AkMkq0yYtxs6Da+L4dGosg/nWTnx9xANCK0wHSVt9LgkDP7CLLDbTlhZtq5gpycYaVsumsOxir7wfAgkHZz05UD+fc2hBsH0nDAWfEY1QITUZzAK1C1yko5fJSiIxfWHcNxvh29kSBHVC3tj+MqnGJNmEM4b71a9gY7ePMZoPzbYW2HQOanVIn89b1e0+l1Ax8F9dI3joMF4j3L6eLHOaD6DuYsK5x/s6YzB+W5tbtj1c9UX1A5VVI3HO6tlbA3hANoWwpZvXGRbIf0gOw4OqFmONu7sh1KwGB7hybp9xY0IL7t4n0LeoA3sqzhZ4Z9IwEgF+KJAFH/r4DddK3Gyi7qIYLcGn7eaWcM6noHBk8iIWZ3C7AIhkpotGaoBo4NybwoiC7OJOznEQAeG5Br0AWyyTOfyMOoCNiDhIlbZVpjMmLWQSnJuoviHwo/gwZfZgqGH4srR/gvrXr2Kz3cKNdwudunMbs4jLWLhJGWxrVgQV15MEMgtFHq6GmHWjaWZ9+cKf9tgPN5ujH801+k3DYzKIqrUP4N0WAqqLnjdZxpA7m9jm/fuwSxVRW7KtHCu2SBX/zZReuq3FK+TIkXiraTbg8dtxMDxAOUaRHR2JHNHauqtaV4QwzNAQAVeFVYW5gCwPAgrVqphyAMBYAG0Bp7QBO6E8iDdPCg0DS7rcx1sdhJTY4duCtDagjz6mqDoDqgEBTBT1X6JSGcRYfg2ocPP9dG9L3tzowmFwlgBpcVhuolMZz16/hruVtzDZrXHb6gOxMOZ4zrigVQGYq0swClRSQuPdD6t8xEPOHvgUUqVQgACsLlhznVBw6fbi91gSuKh/WhG5p1KdiveC2SQt7P0crROub7H8YE4FUWX8fQUSUFfVj9ECCqxOQl5PW8BrPzxcq9KVGBQAeB4lFK/hrW5A+4XoBGbDiFmHpXzCXT87VQQpE2ecfNDm9NYTQbi6t9twMAlUBUIaYvOT8owlLWMflidwx8MafbkyifoY5GHLBjxbepE8Y/B0COiLKgEDebHRj0E0MaLXF2fUdnB3vAAC+uHsCj1/cxOSJCpOrBs2ei+ObA9cCkJLW3uGw5/ixmJd18eDEkRzdgwEfpxMWwZi3MF1nDUFGBFAAgSSsW01defBnGhe/13G0TKOsocdEoZ0ozJetBaVu0BP5SgMP32dyWhEsF04Cv3RDTLq+9yMB/N79h3EX4HRKea926RloaCK0ZKArspw5JxqsZs6Iwxhgbuwho1K2vysCJebfrBtIUjZcOcTZWl1A5dzEkCHoWqHdI8z3Ce1yhY5j+LYqRKbwcz0YQqTiT+4D7tvqwGB8laDrGhfH61hq5rh7eQt3rW5jf9Zgd6ag2gqViSOn+Hzcf5L558CfGCcpIo5CNg68pz1KDnXWRVN/vSN3cmTQ5/UjhX6h1PdL1QBSjqOsm2+3cyBO2lhDplFIFIFaCt+9xEVy9LRYcOScTt4BP39FX3FdImmOd0TNdTHRunc7SYOgbwF53sqzhZ4ZVADgcVJm8fVfc/75ZBqzIG0COno6hWleApwwx88ou+k0u1ZkO19RNnYnwmncn+prWC4Hwn3d2Q3XtMLSV4CBHvfN1S3HAUnbLzf7/P0++OvpH3G5KTeB0zPIqayls17psL6+j3MrWxirOR492MSnL9tQb8sXDMbbXRzKLSXFcVBdvNwuOH8O4d36C2gP8EluHxHYoMMbdgDWKMR/HPhraqCpvZ6fvVahm1Toxta9C1v4dmM4i1/EHD/qf2fOlt8gkd4PG19vk/RtjEEg63TGiQIo4Iy0C/nnuUIMCtwGrkEewNuwcoCuldW1I7eYzZ0epnKZkIshrMkCMv9ekOViO3a2tzb2hjoEpQ0aZTDfNaj3Cd1UQVeVrfucrB4b+6NzgCd1kRI1WRyQVAv7Ll4h6NEYj402MK5abI73cdf6Nh6Z1mhnE5BWNgyjBE/8rkhwM/Du+P/8bnPfSkDjxiMrRpZAhsdNAM6s/i2DPx8TO9TTOk6nSPWAfU9G3DuhbmFIgMWRPbxSB4yvGox23QFBWhqLNtj5xaBMADUHAqO2ijZI/T+fRqxtrC/pji6B05fmYUxYV28znrrdkUAKPfOoAMBjplj3TtzIAbXcvfRWAuoGgaRIH4lK3Vc1t/796qnBdE1hvupA4QyBG5NsMn6zqACqWAfH+QfsbMZZFyGyeC1AYFLnVIQrQcfR+gMx8KPhevjNpzHoljRGG1Pcu3EDp0e72GqX8OlrZ7H32CrWnyBMrnWoDhx65To5zq6KOCAhTaiguKZdYi9mcta+Cva/MAYBLDcPBNAIQOcsgZvGRu9QTldNKcv1Yz0/F9VDNxW6cYV22cbmtVwR605Dj/rGFrExB39MFlj3uH6LVINSEJEcYoJfOMthY8vZagbLRXXldA1Z1zBsmQzbRUbBOo+uAF1bjqBh618CKiKoWWcfqFxDO7LfZb11vh02jrOxKg+KYGYGzZ5BvUdodxVapwOopgQ1Iw9ypB87b42avEu9sjqg2TaYjAi7y0t4YrKO5ZMznJrsYm+zwYV5hbYbod4D1Jxiy18BxCMO2dCeTWFtisAfj5EJoIbTS/JrjwCb2UMY0PPfye+lrpy7IWl8JN5nGQ3FP+sckusGLuoMLPdeW9F8fRDeUSPmpwflqXQi0y82gegLQvBLSoilOsnaHoFAue5m0nI/Fir0pUIFAB4nkVi7xMLSSyNFHAbRCfFIodzkM+iDNl++24hIs3d943WHqgMnBubFX7qy4MVUkd90DQGonFiAjNXJl6diJZ5x31kURtr0QGBUZ4QTtwSBkYUvob/hiOsRR2sonbJtNqstTm/s4L6Va6hVh4e2T+PC+U0sP15h6bJGvc+oleBjzTKW67QzLjDB3cu0iww+fJi3rnOOmCmIgh0IhFJWJ61SgNFO34+sNa9RMBy/d2Rj97K+WgT8nD87jtHbLSnMV6y4txvBu3kxwgnvIOeU70k9QIT74KHLHWpMnFzOUf+TYN0X1oAeA1AUcfJgOLoD62UZG3PYgQRCv14+lrUDlZHYDdY8lKPy+Otu3MDGHE7Uy34EDeC4gvaaag2qqUGzY6wTYlXBVAbUhk5h1yYc2szXN+kUDww5DTlO4LbB+HKFraUVXJhMcd/addy9soVZW+Fqu45O13butQEEBsMT0SUJeEqpB1oE8IvGiRBztLip7HZHxem90ZocfPfuczQZr3c7EmoIArx6a14/1hQ49jX8M3B9Rq1NyJGLeA2LDJmEIY5n5mXmrJcwiPc84uJS5jnqZROl7YmX+fZha/sxUjECKXQYFQB4TCTDv9kL6J84B8Afi2EGOYZpNinTKQJDduHk56WXfZBdgAErftINYis+4SJGGVjRGotoBLDSFUFB6CfySZts5Ywh3x5ezFOP+zn9PhunE+j5EBRl98CJ+N/rvxQk1gZ6SWNpbYp7V29gs9nHxekavnj1hLX6vWjQ7Nod2ocXi+KVGgv+OhflY66hZi0wby3o09q6fmlba8zBVeDIHDAWEHJYt7qK9hbvA5C/NzXM0hhmVPv6eNAnLBj1uHKGHk7XbxI4LdLCt8eVkX1KpgcQo/RISIL5NFGSWIJ9XQEY202dOvJxqJkDqFrAOF0/6mBXKFkvA8vN4+8EdEQwZGB1Ae31ishF+HC103DgT+hg+nfVwMcGNvDifKOsy5lqRmh2nVNiY6NT2PkEdBMLzNQ8GAuxmJMPHX7+sPEDAlCx7mGA8TWgmzS4sLyOtdEUZ5e2ce/6FmZtjZ3ZKqitLCCFAIH8fqUgMDNW6YErx2mX+Q2vMeT6kX8jtJPHxPlUNMrhXbJzUHKjfdro8InIQ0E0d1071MzWgd9L6yg65JNre+gDEw4EovzAAY/bHoG16EXNlOP7yQ6qFBEvSv9UksYtxgJ+uipe6LZRAYDHQLGzWgTwIhP5hTcAxEgpO/OuRYu2ASKdlCTf3G+veO0WV10RwNwgOOfOqTUjL8juOdMBVBv7jDjps26WNxRhhpmGdZAr9a2ivorrmnUSLTuPwduQCGdR/hJYM/dvpcXptV2cm2xBG8IXd05g/+Iy1i8SJjc65wLE1snqOTKgHkDk3s2L9n7/DIdzI+V8zznunyIHNJS9phQwdmBZW992/lNXMKMGeqmBnjTQjYr7CwxCFLoJYb6srK+0SdhkvV6U0PPLiWV9v8mNMB6mMD1S4JeAvoXGBDwOsF3Dti2kKVh3ujHzoQVN4iNOzAfm+FiDomAp7MuaIojvSH7PTCShr+k51toCcTWzBkFGKaiWMF+xepWsT9qNrQgbswBCSCHmsulwGONDlKnsfTU3oC3Lsd1dmuDCyhpOT3Zx12Qb++sNvnDQoJ1PQEZBQ4BAiWUccJFctUWUTcfzwcDrHMqDlzTmzmea5B8dGhMwzGsMi9AFeGM1Afkuk07aZxyQnJCPxhPN7aRe3i0RgDQ+tNQ35LpnOd0D+fpngOj9iTmrFN7f20QGt2YE0tNrLPSsowIAj4ECNy8BaEPvT7poLKCc/lD2OXmqZbApTtRS+V86p+35zUqINIBWcAQlEBN1kxudZi4N+4vrZcrtEFySBW2KwElSVzN0H+G+FRXZkG/jlRnOLm9jqZrj4nQNj13dwORijclV4/T+4nxk3uyXmg0FyOn79aJ7EMGw3zrFSnfG6xF6K17lrFSryoVxIwsMqwpm3EBPRuiWR2hX6uAHzekQcj/qmtCOLVcqDumGiPMnfezFYxEAkt/sM0PB/ULiN8+vngoCz0MxTrI/SQUgGc1Lsj7/7Ly04mHdInIfFB2WRDkaABoLAg05S+iKbGzmliN+wBrviHGI1QzcF22gHLdIIZQLANQpqDnQLpHjCDqRpLN4jcThDHKkRb0vOkw00tblzOgG0C4r3NhcwaXVVTywfhl3LW3jxvoEl/Yb6BlBaas7SiYMhiEBhmEPYUcBgRGlEyOdBwJscpn2v2uDHG8GXK6KEdeRw+YZC/6quYieQogca3tRtXAZE1XTpdeG+t4SjDNA4XmG/jxK15PUeti3TUo7xL1ovXcH9BQ0eTF9wVKFvgSpAMDjIAZ/QLQo2/+Cs5ACRJE+SsPZDoCaoWcBeG4Pu3tRrTt9V1IPjLjaIBUrL5M2cP5so4Xc1g1WT4oxDdeP9Xl0nC5dSBdxKyVFG/yCdIcSAwanR2SWOqwtT7HRHGCqa3xx5wSml5ewcQXW5YvQ2ZHxjL341sACvlbG+k3cibj/xDqAgIjZKwCgMTaNvMZ+/UYN9LiBXqrRLVVol6xRRwBLzhq2gtWpa4RyPY+x5PolgLa/iYs0JjS3Rym46QBqKWzQlTgkcF6ZA5HnjmQ2ZKPg9VZtNAhbIW/EIupqZD3JGvrCgUgbV1ihPiBUBxpqbq0+LKALFtt+/2aRsAGUiy1MRFbljUG+eydUR6imToztwFs1deJrBXQcVo7BoQDIUucNkPMNqA8MRtcJ84sjPLK6iY3xPjaaA5xc2sONlSXMDhSorWyEEAk8BKeODyopB8oPQf+MczSSIF/Fzuv9/cwhOJpbDPzAAB8hagohGHB5w544fyXbLfPUgYuoK7hYwQBmzlG4czekyXJhrX/JoEbh66+N52p7Z9CKwxEKLqUDe7lDZz5yEwD2+3obw2toc4si4Ft4ttAzgwoAPEbioOM5XZQjKf8elmSIu5guuMZZ/R646Btj6w7Eb0A61IfBROAKuhBULo1c9KIyGdiRCaf03AKdfs+QV9IWOHFw7RnoI88JTK8pZy06NqhWWmwu7WNctbg8XcUT19cxvlxhfMPG+pWiX6tXZMFHEKWLwtnXH5E15PB6T3YHpqqyANCJhUNjCR5h82bgxMGmUlbvb1TDjCuYRnlRoRXphrBtFvxRAIEiLrNXGTD54Uj7qMcJ6QDqBLBzuqDRQcAApCnSa4MGUFv0Ybzj8IGSU46OrCjP4dagmjmr6QQQpCI3zkgDzleiCUYiThRvVRPIgsFOh81YG7uhu8gi4BByzuLdGMs15MVSdYT6wL5PqjNQs8BhNDVZUa0Xb7v6KoA8cjUgdnkjxkC1Nu7t+Aphd3UZD09O4YETl7HaTLG6fICruyPoA2WfZS4g913aH8yBM+G3FN0bYHhScFYM+tKk8lCHcFiKuICSGOdKx8sCUBpnoR1H/IjnW0/E6/4r4WNQzYC6M2g7YLZmD0Xs1N7Xgw+pcO6OqjAJ04ggNn2ICGJF9iaqR0+XGS4NdzLJdixwK/UUUDECKXQYFQB4DJQ9aXuRjERnMTeArx1KQ9yYHuBxAMb54CINzFcIByedE+c5PFeQdWBYz83AcVhE/UlTtPBGoaHcRqNZjKbCQhzVlxfLAcAqSXZJFgQu6KsURKbcP72ksbZygI3RPua6whN769i/uoS164R6v/MLvQdArTPiMMaFsHKAzwBeTw9wumNWpmnI9qUPx6YIRIlFMOv+GWPV1ZSyDp1detNUwZkzG8AoiqO21M5pMnM2xYZJBpHfNS3dn/DcU+Ga5x6Z0IfKhUBTnb3HHEZU8VxmcS5zYcjA6oDWCJah6fiJcnhjl6JSXz+/AVuQpQ31x5izdUMg54cmigCEIeX0O40HW0ZacxsArY78ORpNALQFEQqO82tgDqhnPEUuoomZk01T2zGLwJJAVGSMrWMSS7iaGYyvA91SjSvLa1gZzXBysou18QzbS3PMDxSoq1BpWFFwF4NABnYRFzcHzMT9nmFIAriI36Uct0uMY+6AKtc5y10T4eJYP9UBsdTa1x9ivIGZLBts6A09IszX7Pq2dMlabHeNVYvQjVvnOtEGAYQ9KE0BNMIBKjh3zscH7s/HwOkLOpRH8O5QqNBtpgIAj4sM/MLQuyVe/p4V6xCLZug0nUvDz/Oi6U7kLA7RI0R6f+zJwStCa/tbA35DkrpjvEFLxWm/mEaLqv0SbR5AfPIfaoc4MUd6WYv6ID2gCqDJ3D9TWe4fLbfYXDrAWjPFbjvCha011FdrjG4Y1Adug1AmbOjMKdAGatY5ESKXY8KnE8YbTJEj4oQdLB0Rk4jmUVVART5+r+VeORcvtXSF4YAgA0DW82MApO1GSJ0rnjmDvElTUAmAi60qxVJsmcuHhUg0m4IAYifLAszBgUCFCGhGY2SS71oACIL37QcEcJs+nx4QPAj0deP7NpH1eenEwxWBOuUMMDSqgw406yzoF5bBBABzwMcTVgpq2jpwj9gi25dkY/jqkY3EYurgBkVyiGy/wxtKSKOq6gAYXQPmKyNcWFnDuGqx3MywtrqPa/MKurP1V2wIkgI+AWL8K5EcwnrvGJMcCz70GbeGyTVGRCmK3K3wWKSgkqvHQFWJMXb94+e1WwNIzJVUnYGNYNi4qxu79a4hNHP7TsMZkrDXgrgioY2937INEhRLD+cU0oelK/EFKPo5q/7zFFMRARc6jAoAPAaKuHniFJ6KSjwNvFe5EEg9fTifeOBZXsBhF1k1M6h3nThEnNLlpsGAURny8VcjdlxSLoNGOJ9/UZ0GFjkSJ/9eG5LTfW7dWeT6ZnBjI7exjDWWlmfYnOxDweDSwSp2ry1h9SphtKOdFaFYoHVY1f3CzeHe2PCjc0ia/QWy/l/nwEKX6QjWvZQxaBk8VgQzqtGNLQcQBM9F0jXr+FG8USaGHnB6edy3pAG4eLIy/qryImXE3DoT0imhm0Wt816jKPjP4zFQBqjJ64yq1ulqIegoLtRl5TGqbYbsLy5wzxCFrcvmw6BAcjpdn2hO4ECWqgHVkB1DY8Eag3wP6vldarXl3mohLlYUwvHVbqxcDGY2CjJKgeYK1Nboxg7Qd7IdXGE3WdkAxr+P1k3T+Cphb20JV5emuHftBu5a3UHbVdhqFXRLoMQgxIRh9AeCyPpVgLReF5pwP4j4hciSMjF1DwF/XgSdvufCOljq/nGdFaug6PBcpNOKCH/ZYZkB1dSNudPNVPOgjxrpX8q6QuRpgviXDxjc5kj0K9snO9EIECjBY9LHt4tKKLhCh1EBgMdB6XuS/O6x/k0/zWDWAtAM6ZjIfFl/zXP8OqDec051xSIoT7+S26UNBfcNog5ga0Zp9emAUlZVRCySC4GwPJj3+i25JjeSI5BR7CpCY335AOvNAXa7Ec5vraG+3GB8zXjjD1tPErsl14lAHIGjbQOXSEb8gH3WiodgQQMQ7hMBVWVFwyzuFY6hTeXCuI1tKDdT2w61YIjQNeg5dWbwZzfPUA7vmYpFiwzKWgSxVEcWFDZAB3hn35w+0oFyz5vKAkHUQrQqZGlGwfubVDM7RxVzKxVisCqJHAfHWMfQHPXB+4pbQFkuFgMKyc0xQAfL/VM+lCH5uNZWz9IBOx4vMcY+4ovWoLmBD9vXdjZ6S6VCVbWLINJVrh8rF74scHTTd8tAABxY8F3NgPF1g3a5wtWVFaxPDnDX0jb0OqHtFPZmK1AzaxDigTqFJcEfQiXo4Pd4CISItBIMcVZsyODTij735SEGar4+HsQlBh4UxpA6hxH5IOMejtLm6q2dw4HOzRswgIf3Gck6wj2dZnlYZB9+7r43BElEv4vWLF9npw++6FBcqNDTTQUAHheli604VaYn76z+nxEbqtyEo83C9J+T9/g55pqI+JjUhYUtrl9cloK1kpMizUjXx20iPgsKG1CWizcE/hDuZynaeOI68maTgsNo4/PiX41meYaTS3toVIcLu2vYubKM1SuE0ZbT6WLwl5RvwbQAe/Ljw0MZZzTAUTzEdeYm1S5WL+v/OR1B01ixLwAL+hwQ4Q20Gyu04xD/NHXsbNNJP46O46EIWidj1dlBYZ1Gyyl01sQJJ4TzY7084wwWQC4tb/DSCEH0GwMr0xm7CTtOStQGEgCuttHauD6p818gwz2R78aiAxUDCBnFhpx+o5TqOyDuOajynhPX+nHtjAXwbMnddrGKg4+VTd69oFEV0Ij3hAEG93MyBtQZNDuEpUuEnaUxLqys4cR4DyfHe9hZGWN/d2wNQjrqc6JkN4n30hv1pF0kwL7vT3mPL/EaJdcCJsFpizh1OoCvIBVJ2srzlPPl/nN9L9O6IfRGZ6kFtOUcB9cyoU6JDp6cO2JNtCoNiXhbgEBbvhkGdYvm4aL7TwEVEXChw6gAwOOiDMhLo37YH4gWsx5XKz1ZJ8AqFbdIcUPQ10FwqSAVnHVYwGU9eVGNuIEwWVGsV/xPwas/+Sbtc+0PYq8kwwjghs2htxnJ/5SkTwGA24R0DZixxuryFJvO+OPi9qrl/l2xUT+8s2cGRgz8XExY6oLLFw8GfbvZB6BoH3OLvIUwwYuInajQgtPKWvpWKuLwMkdIN33/fl5U6rh+ub4GAVqFMbabvp0DagbHAQsOwlULb4Ep9T6l42jqbOgzqhxQScW66Sbq5pP0i2ecdTxzgBjY23YDJon4IUFC5LpkaOMVefn5LOcGvxPGzl/2lcdjDn8ISMaYKC7AjXtctvFGQ/6ec/3jGZ5Ov9NzS52eJFstK29oEOpPrUGzDYyvKOxuLOPy6iruWbmB1dEU46U5Dia14wJyOLukf1KAzGMjmiO5vdlu5bowSPNrjXiGQtpofRPPhwuh7bIOAXD1fe5FzzqAyI7CAYRDk2yzLIs55ca+5xLc8xyQa6VxVvp+CmpOiCwQHDIG6VHanqeYCgAsdBgVAHhMlOXw9RLFwNBekg8mi0kKIjP5sT6Nmhur/P//Z+/Pg27Lzrpw/POstc953/fe7r6dTuik4y9EShGBMBohgEoSMQOEWBATMNAypAKKRRIGFbBIAl+GEixQoRikhIgBoRSlGFIhUaZCJglghaGogA0GSQh0um933/u+7zl7r+f3xzOsZ629z3vv7dx+02nPqjr3vufsvde8n/V5Zg4HuBFpIzwZYNCMIBtx68EWdUTY+9SPOYJfWu77Uv/7+IDXRW/CIeOhIsLhZr9xZpQ1I10c8bgLxzjKW/zZ6S148PIRLr6bcPDAhLwp2n32YMEe6kWlfLSdasy/OIYkDVYJBTW/N84eWe3AcpX4mUSwrJIfPGLrl1DWks5te0QecNi9fTXWXn/QxvVpfssAq/1Wyurcsa35dy12nav9zSB/pQeteYvrYWp2hQhSngb8JTmQoXHZmsM8o9qnBmCxk8npgOA1QSDmYGM2NxonkAAHwYux2RLgqKJYqKOAHCy2o6mLDfhb7Mecfc8nAEiE7I5BMqhGHU4VHJdB1NLEEsNu9RCQ7x/w54+/iNsPjnGYR9xydIrTw3WVAhYWKbS9n9RULb+lAKYjiAt/V/ojCzRTF/cMWTe/u97hChhbbs3NS4JTSZ2Puuf7sDq1j0ZTDUhyjYJgWf8mYDqw3NI6rsbRpQ4uShwjnasaiBYIRrUwoY5/7/G7L+8LZQ8Ab1JpVFo9EYy/RcJ8hko3AqjaSCVE0Z6GRmguVUhqqlWNUm+BT5HIVW8zrrpQa+e3JBGI/SF/1Ln2XgITDcbPDIFAC3PGkZDO7632RPNDFECNKXZUcMvFUzzu4Cq2nPCuK7eA7luL5+8xu7cuaTgQD/Vi1U1FpAUGCheBgqp0c3ZXaoq2hESi7jWJX+8NTRCP0QPCtA6fA2A6VPBnalOz9wvqtmbccV1iWQFTZjEJUIeSvBEwOFOvV8wDGvQQ1VAjbptlaxR9WbiuSy8ZNAnwWQ4IfrYaaKT24J8/1D4/U1vGuTA8HkHKwkHNiYAhtd7ASVFTMocLFtu/cQRGoDEdYAa7A5f+n0bJ+TyJRDlZTEXNSWsp8EzqZMCirKTjNGmA6AcIVy4f4t0XL+AJRw/htsMTPHTxACcnWaSAYxhjN0es8+ogMKhHe81F86ytZ3TGMDqXIlis985oFsHfm0WGUcFfL0HmRDW+pXmtA8J8kJoi2DMpXIP0YzqQ68MxsLrKSBNhe5FDHu0q4ZtLGe3dDdftJ9uriGrhkP+DUZn6nhlZOhsewbKXAO7LtcoeAN6E4pk1uhd8ltWj/32B8C7ep/f2ahc3Gh8lkPG0ImxuI4xHEvIinQbjfzsEglG0F1OJEeSgi0Awll0ELHDLDhQjKCkVBN5ILsxF8BekAn2KpeYgGgAcTrjt6ASHecQDmyPce/8tWL87YfWQevSqQT4lqiDPCb3FiCsi+YkZP6yoI4d5gkoJFvlADeuyUnWvA2MGiFCy5O/dXEwYD6mmczN7OY/zV9PwNcCvm/ul9REGQOtL4pxhAEu8uSPAtLFp2xpSBgUuNeQCBSihve4Ab9pP1OaCRQsGALjnsaipRb1dVgRadw4hkQmi1mM0hrnxuQgHry9LZCCCpFa8s+VFaIbg0l1b5wk8FaAo4jCPG/MYNS9hMqeP4PjRgSZRsdsF0piHcFMBMEAjsHoQOL1vhXtvu4DbDiSe5ZWLa2xOBkynCTSSA6A68XXeXPVLqCGDOoDSv+8m4ar7jmq1zK01RMwT3u9BBbt+f3AyI1fNhu6k4EEeMhiBIU4dcXxNO5CMOQM8V/P6ssQGzBsWxirZu12BbPUUpjltpjoPTZMGFOOYH2VCvz0A3JdrlT0AvInFuENcDzHgKjXB0jMdQXY1R99mE/alxouzOkCQrA7hoGUEwUX432ORQYl9DI2ikr6lAL+RQMY6o/1PTLzegEBvb2HcPaiIn6b98HeC5P09LFgdbXHp4AQA8GfHFzG9+wC33AusrxSRjJJOhEleUg2OLRIbsf9z8Gfen8b5qy2fB1WeWIEE4JK/lYI/DZljnqAAwJkwHiVsLiZsLwoQnNaonr7uQdsdNBH49Yfu/BRvMVoGiqKnxrvSVMu+hqSqdADGRIxAnqTfgAFKzIv2aW7OULtoEj/rWJqAdAoMx3JYg4DxULyDwagSoG6bxZRx5tGLVQdQuYI/UXOLGrhkcu9c6VcMe2Je8+2czGI+AoKINfczmce32X2aGYTakgrElJR0cf+5BJVVRT+olIsEIA7HjPX9CVdvP8IDtxziybdcxhMuXMGV0zUeOh7ApwN4ZFED2zztYjAX6Ei9oT4XswUtvfNN/RFYd++peSpHDUljotIzejHAud1r1YVnqJNMGmM4rYHpUIBr2og5he0pG2PjDcyo72QAgVHa14zT6oigdYEuvbcL4z0L5fIow7P78giUPQC8CWUxxc8SCNz1Lu4Cgd09nq/Ufprg6hPzVFxdUYmCElg/oKOX3djVGzhyoALNPuo9Q0GgSfgikcdcwrfLHmspYGqUVvT31/F3c0WYgT+zX+PDgotHG1wYNrg6rnDvAxdx8OcZh/cVDFdFAshD14cEoJhXpY2TQEHSxynVg3GoEj0qrMBP783Bxs+9e6lm8VCp2HRA2F4UW7+y7iUf3MRM83EjHqTc/jabe81BGsG0gmTqgn5XlW29zw7VmLGDLT1Wr4IP62TXos2WS7BN2hykeWK3xchbA4AGQDWlm4G4nkmaIHl41f6VNJRM4yDU9S+CDEuxlxLV9H+ArDMK2N4xs+XkLFJhrIFxdJUvgCr5ky/y31SA7Sg0Yizg9QAqGaWY7WdNSWavd8oyHg+WrO/s6iFgc/+Ad9+uauDVCR534RhXjw5QrmSkLen6tOA6MgyN925k7iKwilIw6u7tgU7fTmDoOE5FwIszwVLYvy7dD3Efo31idQCpbbsNa9gTaSNzkTcKCg+omhPYGJpxV/u/SssWxhme566OmSnLWfR8X/blUVD2APBmlJmkY0fIAbTXeMfv9kx/gEWAJQbiNWOFeXHSyJKntD+YjVD1dn5+WJO3Sf1BEPvKCo4Q7rf+OsVv67musgsEG6AgBM/mOWg1ohzz/l46OkEixp8f34LT+w5x233A6kpB2hbNNkFN03GeAWkPQ5JxkaZpy6Rel3ZgyUSLpyE5qLSwImWVHPSVodr4eVq3lUj9TGUlH67gqjs8fU4SNDxFvcfWxw8j+zk8zGgPy0YV2d1b94aMJxXNjVsEeEqardAWz5+LEmoKQNJtyLj9v6pyzVO5hmbp+0cMpA0jn6raONP8EF4oJnnjzNXxZqUe34pM4x6QvU6SJi4zeMgq6Us1RiCAGhLIPqIyJmZwKSBFIC5I1CwqSACPsl8mSi3YDgB8uMo4uC/hym1H+POLt+D/d8v97hF8fLACn6ot4I5x72RSAzj0S028vMBkIG4sq1fpmTmhGGiN4NCYyEgXwm9LwLJqD/S3UsHfYspJQvVu3+rfo8UGRGOX7CWA5SVGqy9Ry1NTb3IHfB8dad/2KuB9uVbZA8CbVOxdqfaAnT2JH5JG1VCvxd+B9pkIvBhy6CcSLlWlcyCRHJWBqsQocrf+PM8OXPiBzEFNVp1IvCzRgkD0zrxnBxhekuI1kgYEomxAJOS9bYAm4LZ/5Uilf6sNTqYV/uzBi1i9e8DBZUY+ZQdn9cBgpKmIHWDh6uxhakBUQCex/MI9gPw+JJR1EhUk9KDIwLROHsx5WouUz+yULCVbTe0WgF9qp38+b1xBMS3cFg41IoZLpiJI2yWtYGrvW3DsaPbXDEHrfOnCkInvDOTpvrN58kO4O9BNvQviagcWrqdJsj+krWzE0u+Pfq8jtGnV6J6RvZXAoyrNLPML9J12J4SQFYSoenXrNZQCVm9hlxyWIp66GifSvFUddFmYEQigTKM4LZQJHsgYkLGuLwPbd6/w57dfxB2HV3Fh2ODi4QbHh4coVxNoi5ofOMxVX1y6RmEJbQ9w+1zDk10LE1wHgNpZP1fg6aB/YU/04/F4ijquXuoc7RMBeV8L2LPdOHgMQNebNIbbaO1CaUxzGK49ODPywTmUPQDcl2uVPQC8yWWXGnRGCnZwu0B3MC9c7+txW60gGav2K0uNL9RvMb4I88Y6cHs9JYZ32Nl+Dx56DGwgT8fk/y+AP+tnGQA6nHDr0QkO8xbvPrmIq5r2bXVlkoN3qADQ07pNFgfQpKOsh3VooHBrhF5YMmMMCdNhxniU1GGBABaJ1LS2TB6o2TxiMGcPc2Eq5AB6Z4dRnVwHid16zcL8wOaQQaUFds28X4/AogeDfWnAoYWBYZf4Nfct7HEfIxn4kx/TqLZ9AbTa9TTK8Ke1eUsrsG8Yn7ZvkSlpAUkArAV1D5jxoOUEdkmfPmi2oZoxxveM2QLGUgCMReMpmnFboBfmkT6yxJrWXNA25uGYsXqAcPzgAS5fOsT7HT2Ei+sN7juYUFaDp0NrVJxhjhelgHotOslUxrQu16LqljCT/PfOSlEFfJZWwNuK4G8Xw9KVKL3rGRsC3H65StUJhSQoeM2EFPap9X1JK2NfIxPY9e3RIAHcl325VtkDwJtUItDrY/udyRU37HVLyPz58LupMdLEHsbDU3mpJIUCoYoBV00KwyqBaCQ5S/0Cqr1f159eetc4tMDq5YYbb23U2A3JbQpmIDgCjubZhfsTPPZfdP5499UjDO+WtG/DSbW34kxzT2eXgHCTy5dN0qOhOsDwEDK8UvB3IWF7JE4FxdTBSUFfCGVhkixXre5S+c4O2youaZwqdnIG7VwSFASi5u21Idcbl6trAJT3nZq171W4nk84hI2BMgU7C1m9mqd3KzaBYm9o3qiyBtGpQOa4pp0zhqZK5eGSxwYYWl+nfu8RKBMYSTzAmWuOZwBsqd+K5AkGkuwPouoNbk4g9jdQvYQ1ViAxxEZUAYmDjgmexzZZyBgDxpOENqGHBlw+PsSl9QkO8oj1wRbH6xVKzh6o3ewsff7DOvTq2WYNQmiTs3bXouR/B41bYta8jsj0xL52zzcp/npw2INO3WuyDy3un65fEm2JmQws0gEf5FKfdR2D7ffiXCy+S+cHDPcSwH25VtkDwJtUdr4rzYFdCUcPDOcAqPNGs8NRc7Ka6ms8FCmTc/xRPWVqROPMrQ1GE+5lCYBGR4+ZjddZHPzSPMSxos5D/2xTd3M/6sFl9mPo2iJVpR5OuHh0iltWpziZVrjy0CEOLlPN+TsIWOiDziJTVUMRiZoXgNk8WTgP79MgHr7j0YDtxYTtheQx++RwQSvps0PKpHbq3duoLBckenF8UTI4u49tby3MP9UlcElgmNP+ucaWz9a+y9Dgns/9gRzWyZ+BHMKlkO63XVJKmzMCbYt49k6AxSjqnVU4kxv3lwHOUPRMymy/zsBqeGcAXZvkTkESBFwBoII8Tkn2iQV+tudzcqAHQIBjAIbELOFayqQ2kgIcDYgIH1dAKYl38yBp/SwDDCChcoaHEh586AhXLl7F0bDFxcMNTo4OwFeT2AHqGkfg1b9ji2tg03At9HetwuEVNsa031dLe9r6FWmJ7Q2q1xpGwpmSML4S8KRdY6GbwzGjrIDxCK1dYEejrpnDPdDUCAR7gHgmuH0Eyx4A7su1yh4A3qyyi/O1/3vwB8zATuNoEVVUsT6CGuOLinFzu8X9k4OBJsLMBsbqiQTXiBmJRKh1+OgGE2lkTwT7Ie8icEvP7Zgz73f3d/ytp01my0WHE247PMVhHnHf6QWUh1ZYXVGJioZoMbu/JvNH33dzybSwL1m8eaGBZMtAKAcJ24sZW8vWoSpel/gtSfUcDHKjsjdAOFMzRQlDD/66Q+VMYeASCOwlKawN9edeOMCIBQt5HtZoy2fAqgeTOo9p0gDTkeeIB2dSW1aTemlwbvM8FwBNrnotlo7E+8YSO6Wbw8XiY9c5z+LAw1Oq/U/QAMvLMSA5J2DKEDMCmwjdNxY7cpoE/DHXwet9EouSReJZpB9EBKyS2/qKfWplKsCyl4eHCMcPrvDg7Qe4OGxw+9ExHrxwgNOrGWmbweolG238mvfXwHwHXmR/QG6K0Q1su3F1ANs1r44d476Me6wDUb0E0GimXW+YI+7qiHSte85jX+YaXmn1kMQFTFsGHZA7I/kSe57qGu2gp9keE9CY5OBU57mDLdxTDB7fvRv7si/v7bIHgDej7AJ48ZYzgj9bHV7skAyErYYbqcTKYv6VFZwwJkINAxEkHY3kxiQDgBNAt+Nxos0u/TJ12nUTL+4+8VIMIdM/1oM6OxxiKJSlZ43YrxmrwxG3rE8BAA+eHiAdJ+QTOUQBeOqvNGquX1svdQBJo3lw2iEA8ErVRaukTh2SuWM8lE9Zt6peV0V2/Y75extHjx789YdhYBQWwZ9J1HrGAru+UzjQgSV800xvWEuaVDiahAFJ6PbGjnW/HskHq2cuZ0LJLP4VLOtFYAF84f2KUsmapSSk84rthrmluK8yYTpIKAMjDYRMBNAkKQA1EDhKcUagToo6dawkywdvR3H2sAM/ege7A47+ptJFCxBNCg6J4eFgSE0U0ihMBbE4uYBFtb66CmwvD7j/cUe4/fAYR8MWt144xenRGuVYnUFM0osO/CH8j/a9M7og8yMLcOb+6OiW/9ztxSUQ2EgBu+evp0Qpvnkf16DOcLvoooGhy0pyWk9r8hSIjWQRldYZ8OtTvrl0MtgKGtCbScP7+TnnwkyVrj/M5/flsV32APAmlhtODg60B/msvg4QcLVnsUMuH7fPuiG3gb+pVd3ZobcIpAL4M07XuP1FddGO53eOc+Hw2TXeKhVD43iwNKdM4kRR1gXr9Yh1GnEyDXjo+ADDFUI+hRvXS2iIsniopbGIgb7ZfRWANNafqHszpsOEaU0YD1TqpyFdGqlfzFKiY3GAF22V/Hu4FuZnLtXg9vtS2bGP7BoVquqxcKDNbKBUymd2fMk+Yz1xU2YUNTWw+u0ei9Pmak7A1b9NP22fxj1sNoYG5NR+K6HAUqjJegF5U1BWuY0bZw5N/VyFOS4DAczYQtaPioICfTcyM+h4FPWv2nu6JM+dPBQEUgGVYKAWgV90BFEgKTaoWYKEqyNIBI5koFeZECrUMH4oQD5mrB4kHD9wgMu3HuL9LlzBxfUGl4+2GA8GpFMCpgDobPwIOJawuF+WgHJj3rEA3hpweS0gF5mibi/3TiuR9hkdsjAwpHsUgGcPoeBs5MJslrAwaSO0gLNkN2y8g8NceCrCSHfQqYS5fSbOk9gfViZtMcPIOZQCeo8CQb8nz+7L+0bZA8CbURgze5GZ3cdZRPcaoNGlixqHjaYKjNIIYBO4WLNrin9b0FRvm1s7pVB2GSmfJQE8U/oUwAxHsLCjjQYkpfl8zLwSldPnFYCBsR5GJGJc3hzh+MEDXHyQsDoWezIBJjzrY/T8jeDP+5UI0zphPEpuc+levQb+PJRID/ICaIuH3hL4C2NdtAU8C3DPxtT+7iBCAV2zP/ui4VfSKGYFaatguKgkldVBYUVV1ajMhj8zVsmRO2H07aP+vvQOkXphe6y9Ih659VkCnwJDIjDJZim6v+3waubV9qI64hSLBbiSWIN5CwBJxrEJGzUntwn0YNHqKEQItoEI14D6WxZwSFNxMMCZUNYZPKS6J02NXMKYFbUJ8KbmPRyuAOmBAQ887hCPP7qKW9anuHi0wf3rAzFZoHaJGzMKu7YLBPrwSVXwVkcFTY05iT9Y13VRsohKu66LkQm0sbHbnNqc5ZyA1A3YY1FqX5LGBzTpu/XdnIx8H8J+X+jWAmMRtT7NM4HuOwjcY6p9eRSVPQC8WSVygruu7wKB/TML370Os71KmHk9Vo/Gjtu09pw7jRcrwGz+joDF1CrogEUAd9T91qh5WLntAOh6bNNLFGaEtJuO5j7j/g8mHK1GFCZcPjkEPbDC+gHGcFwc/JmkxQgyFVUF6+HrmT60g5btw7J4NKFc7BAxu74+ny5xc2A0YzKAR93YGwM6LJfmwJ07VLSAvEqP0hZIp+QSDhlHD7rggXTzqQRaTlu4Cn0G5lSql0a5L2+NSRFQ1K9ndQ6RTVNVuOz99O8TfG0EJOmaJI3HWBg5AIE0ESb90IrVRIL8wJ+BEAKISJK3qISWCpAOEvJJQh4SeEryvni8vzpfpKYCbt8XAawxWKY6VrtAGgFeDbDMMmUgiSJTdAMUAb0cbVMLa5YP9nA4uUhg6PUDCccPHeD09gGPP7yCS0cneODCEfhBQblLkvv4XjcBn/vi9wWC1O/jWAJYA1qw2ZiWdu+6/4ZKL0za19Atp3Pse9CecambdSV6VZvE2/C1hRSy9zS8s04fbW8StzRxBxPcj9fmwzUp2p/z1KrunUD25VplDwAfidK/N9fidAMnHQ3knaDEe/Q8qnllQzOBODkB5BrguV4L9/R97Po6c0hQSQ0TtXGz7NkGCHdgEvFaOHz663HsfekAJrHY/fOKMawnHK222JQBD149xPoyYfWQSrBsLAb8gu2fAwwi8Eo7Z2BjSPqMgh0VnUhqNyxKM3p1mRP+s2z++jGeAYBtMNeyyTRHjwj+JGsG3KGgrKmCQKYaOmNEyLKBOl86h7FvxKwSNAOLdi97OJwaeiPMkY0tMjDNR9dmO8n6WIDllMArPfiT2coVTJuM6SB5tpXpgDAxS+DtAP5mzJcaMnJmTCtCWgPTYULaZOQSwKf9b/Z/AGg7AtNUVbgI89PbDXr77G3D0twl2QzNa6JgPENtURNAK3hKs+GEsHoQOH1whQdPD/B+hw/htoMTrA9GnK7Xssd2caRh783mhcJXA4kdMOP4U1jDpq2eNsR2d/SlzlGoM/YNRtu45ocGMAv2HKXxtr/i+Po2zeCU4cysg8G0MIGBJrt6WJ9doluzBADnUPY2gPtyrbIHgOdZjAbsAjeo1+1+IyiitiLwxPV8KZIxwCV0rnqkUH9Q/Rmo6RwxlglW93sAfw4CU00F5lx4BwJ3zcMSeIn2jnP7t+6+0EdODB4Yq/WITAVXtmucPHiAWx4iDCdTdWKJcfy4m4+s/yf18YtBfhNAY0HeEqaxAoqYs/Ss9XTw14/NJ9uucTtnEfxbKVgGf/HeuH8KQCOQtoS8FW9xGuH5htnsSbXCvl636Qv7wcBIVAHGw5Vtnok8Q42pyYvmQfa2DFjrYRvjttEk+XPtU0E5JDxLSmKzyQxsE2hkpG1CWifkdcI4JVfvFQPuPTC36TXzviyZWqbDhHya1SloApUSDnESwGCe+lPnKBIAIGseael4eN5U2yaRzrpJbCIto8yk9pQkaes4QdTgqo7OJ0B+KOHB4wNsbs24MGxw4fAUJ6ujCpC6Ne1Vw80e6v42EAhefqaxIe3fqR31t4xq+943/dRnjAYSKuNiEtbmnUrt+trfKZgepGACQm5qonVlqu994IlsPH1YrugoF8fXMOzvxbKXAO7LtcoeAN6M0gOlM673xvZ92rVeRcoaygCkEplNPYATA1wsiDBVpwnjfK0/1n6h0C52EygjkJHzj2NbILLW9xkIxPK9i4UiiMV1EVEn/ANjPYie8ni7Ak6ShMXpDpuAix3wITMwcq0PqCo/DftCLJLEvNGsE+t5P3fOKdXDzCR/u8Zf69LDJp7ES3trNiFhsPpMmgiktqPXqsMP2ihZLmFdFfh6rEOVwNkeLJk1ELFUNDWhcTrkERiiaMJgzh1pU0BbBX8q/UNKDrKkCdKg3QW0VdOuwpgm6dOgKnyAG+enXdNgphXTSryD80kCoYv1B8DtRD0zCNdg0HY9PtOHBJkYtCnIBS4p81A0RPWdjiW+dypZTSNjOCYcXznA1XGNOw6u4taDDe47GsFDBpMAoF3rfGYJW2/GEPYPX2tv8sLf8X3p6AP1z/S0Jv62690LUjyP9xiYFQmbJe9kWeueVo/fyISXbh12aSaYwrvCu/u0L/vyaCl7AHgTSg0Bs0AcIsijSkzjc26P1hNJgqsa80ZCPwDA9hah3mYIbfYvjFaFNLc5C7/vAK2980AvVZrZCMYmuHsutn09JRLzhb7F26LkgDOAoWDIBYkY20lO1LIGtkdJ7NM2QpzdWxRAzczAIAoxAbmVeFUADbV10xhueor2YNWkeYtxAJfmQjEhM1SKUUEig0E9yj5rChkiHdMqoqdkY6do87C09t38u4MMBHSVTB7w2iXOSfL1JtS4kn6fpWhb7C87UPX0bltGPilIp6NkzSgdgjEHDHey6IBXIcmUs2HkQe3mElDAsuZhHWb7nSoILGtCWSdxCCnFpT4AqlrYHECipK8vESwarZgmpBPpu9gCJkkrmEjD4JCHigG1gDuaHlARKSBfHfDQ5gBPOHwIt6xPMRyMmFZrmPnColQ+gOEZ4IpSLO6eQ92GZ5ohcPs4d/cvSvztHt13fd/jO7QISAPAi/vbsshYvuiSRbq9viz5wQHNNuP7KNbXDbLpa3utsau0eijQzXMsexXwvlyr7AHgI1FmwGhZrRB/bwid1lGyqNBM+kQTY7xA2N4m9+YTUq9MVEI1QQBAbyDNTdWN7c5O1U3HoZ/FvUYOu5+DMwPHUgVzUZXaePgtPGsHlt+WGVlFHYkArBjbWxinjyOAMlZXCvKpOQxQPWDG0oBtDyZsILBzZhCJGteA21oPA1g8qMxBxDx+l8rSwftwSjg4FwP9Zolb7HMevSS7RvvDuTlUO8BroImz2s8Xqa+qyOd1N2YOanOYt4y8EaedfDIhbcz2LwAtFBASLA0bDwlIqVkfAWaEtC3Ip4QysKf9ssDPDsT60B46njKY53cW1TJBvHiLgVZWUDzI+GIMwKZObr9n1csWgMok7ytnkJkeWBdsT0XQbuC12y9pBOg04aHTNTZlwDqNWK8nXF1VRqJX4cf1dJUmurqtpHYI/XzNtjUDHkJKx+D3RfrQg774fHAImjGTC+3OmE/jCcLeL1mYEZHg6zs8Svifpv7YD32X+hBNAGbaGwemqT7bg9SZVPcRLPweqoD3APCxX/YA8CaUeQiYjjDMHog3B0IWCDQnElsnQNR3RQAKWGP/pXovxbqKEN+otar9gnOjZP3mwLHKj7UfC8Ctps3SepTY9WBjpgLRamcEsQMTDTBYAJM+lhjKIQhftiVjKgRkxnQIbG8BaCT3Ok2j1j1B0o11nsEA1FmDECU2JjnyuGwWi8zO9wLQQtiapXm18SEcvlWsKRI/vlFdkc8buae4HKLUHIKN9zKW++tq9SzgSWynAmguApJp4irZUxBoeyk6M7WHZpgWDSuTN0DeiCQmnxQMxyPS6QgEu78KpBIABVsTARjAKxLZd1yISUAbjxb+hzznr7wz3PStYZR0LNMaoAsJwIC8SkhT9fo1qXsa1UllM4I3W7EHDPTAnIsAVNtIQDyIicBullGlfy7lC8DZvVwZ4rms82thiIiB0+2ABzaHGFLBKk/ggSXANVWJcG8D2Uv4a4PdWmHhnrCmZ4HARcc2q0/3absvKvDysVtXO6eQ3gZxBhaN2dF9XzQ4NE3kJiLF34sqXfUc1mYG042t7psaJLpn3hxcQ+cieCbvy748Gkq69i2PvvLzP//z+NRP/VQ8+clPBhHhR3/0R/3adrvFP/tn/wwf9mEfhosXL+LJT34y/sE/+Af4kz/5k6aOZz7zmUJIw+czP/MzH16HeE4Ad6VT66/30rkoOQIEsAwnDBqVeJF6dGpojqUwGmbwvORZadK+Pmj1WWODnavMAVhUAOnjM2Ibgd2uasMBM5P69dIABx7hcEAk7HJDYcJYEsaS/PBg4/pXGsZFD9gITDGxOhAUzQgCtStM1W7Mg0irmrKzqVvqu5nhzeaSly72Y+43DM68H938mOo3BhC2LCVlJcCgZPa5m1WptqfTAcSbdhVSkY2aenBr8f7Y58C9gUMw6F19TqPlZi1YXSkYrk5YXR2RTidx/AiStuZjKdamUj1zi9gKps0k6ePGaj+YJtZPeDfip9R3KYLAksWbeHsxYXtrxvaWAdtbB2xvW2F76wrjxQHjLStMF1bg9QDL9yvjC/3V2JIe2y+C2gSRYA6ibpZMM9TaS9r7PdV3AQB4AKYjwnQEcGZsNwMeOD3EZso4WI2gw0nU79Gu1qpcekfP2mNABY0BRDpTGRzQbgTkULd3naYFNWqkFS4xVlvRtBWTAbGPZpci2ydt6l70506B4SowHEs75pxkDJmPNZYl2rRUZufADrp2DoWx/Ppc9+d8u7sv74XyPikBvHLlCj7iIz4Cn/d5n4cXvehFzbWrV6/i13/91/HVX/3V+IiP+Ajcd999eNWrXoUXvvCF+LVf+7Xm3pe//OX42q/9Wv9+dHR08zqphLHnbgE4d9z/1kiE9DeLr0YFmBTImGTQCSeHbB/WNuYEvhJrcq7f7LV6rrbpF8I9DcCp0h8AHi9sUZ3Mza1tn/TCkh0QgOYw8Ps8tIgkdk8rkXoAQCkJGJMGMW5j2PWqJ2tLPDlZVHE5taoaFrUvsyDDMllsPZUGGrHk2u8Z8ew2QVW76r9ReuBzTvU7t8/G+3wfTFTBH3dzOHt44ecILkgPxbX0kROAU8JgKfQmkVROTH54VhtJhnkA72onjRJiZnW1YLhakE/V6UMlavCA3FzBEwA26V9RxJATsNW6J3bpdioFvMrgMbkDjIGA2Z7bxYhAY8YxZDwDq/pfbmISTywqLAGdcwJGlfI1e19ftJgTONotAnWPK1PjMRb1R46qe/1Ma8J4CIyHLCFspoTj7YBb1qc4Wm0xHG4xHq4wHJNMF8+24fK22PGuzqRrumdt67o5QUhB16RDRNe+7/NQX2xniW7G/d3Fjpzt+dAukTJv1qYyytB9zkRzkBefXwB2O8uOe8/UCj0CpUAl4+/B8/vy2C7vkxLA5z//+fi6r/s6fPqnf/rs2qVLl/DmN78ZL3nJS/BBH/RBeMYznoFv+7Zvw1ve8hb8n//zf5p7L1y4gCc96Un+uXTp0sPuU2u/Vl/0JUPlSMSiLZbXE+L72XVTXRi33aYdC7HWzNZFg+BKCA6VfOnH1EZlBeV+1fswddKxZnwB7AWOvwduZ08S5kQWoY4Izs7imsMclAHgwwlHRxvcuj7FkAq224x8JWH1kMRJyyeaocKyVpitYietcDVbCSDHPqOlkovZKarkwp/fQeBdihkOKbdHXJqjEj56n4FNl8i6xJcq+JvqtaW6XSXshyk18QIbgJ9kf3jmEw087jZ7pyJliZlmbA81AbHj2AwkbuT54bhgOJ7E5m8rH5vzRhxh82ghV8YJ2I6g41PQ8QZ0OgLjJE4jY6m2g/ac5n9O2yopStsqyW2kTwEI236TOqBgklvHmh7szRaf5teI6nNjQdrKHOTTIvt1U9TuF0onSFWVwQkk2zus4HhMGKeMRIxL6xPcevEEfGHCdMA1bE/Tr/n6NI4X0QavzPfHoiRQmTP7xN+XbH1noK8HfwsMW18ae9XgION90WtRi1D3Kxppa+OMd510rQmr1YHGWFeTEu4xWM7SzAHA537u5860bs94xjP8+rvf/W588Rd/MT7ogz4IFy5cwPu///vjFa94BS5fvtzUc9999+Huu+/GpUuXcOnSJdx99924//77z2GEj73yPgkAb7RcvnwZRITbb7+9+f0HfuAH8IQnPAEf+qEfii//8i/Hgw8++PAaWAAvTeDPBRAIVM7XQFdUp0RpRLURg6fbMnWQSQzKitRrUT+apsxtvgJ4XCSW0WN1aWz6d0O84zgcVPDy8z3Bj6WTPvRqoYYgxz4kgFcMOppw6egEt61PUJiwPV5h9UDCwX2M9QOM1RXGcFL88DeHGklxVYEvZwKSOYJoEOLCzcftsAwwldrX2SG2Y3y77msAYTgpzwR+Y7BHdPCnzxhIiWCM43VyW6uZFAXhWYvl56p0ueZquFH3qaqNx0PJleyZarzdKkHLcS22akc3mgq+lf7Vzuh3UwGPI3C6AZ1sQJut/Ga3qnetHe7EKnXcMIYTxupqwepY9sVwqv2I+83BkPxunsn5ZJL/N6paHmusQhg4nfRjfU8JvBokA0hKaNIwFoC2E9LxFsNDGwwPbjFcGTGcTFUiugM0uLnHSEibBN4kbLYDChMuDBvcceEYw8WtAECT0kawFGjN0jvdmF0smJLsYuJ6M5DG7rCvfxdTeAZOqq8INQyyOHhIAPCyVtOFNbUMTG770fQ/IZiJoL5vS+/zEq3r64t8gWcCuV5u+T0v5gX8nnxupJhm7tu//dt33vO85z0P73jHO/zzhje8wa/9yZ/8Cf7kT/4E//Jf/ku89a1vxete9zq88Y1vxMte9rKmjpe+9KX4zd/8TbzxjW/EG9/4Rvzmb/4m7r777hubnH0B8D6qAr6RcnJygq/4iq/AS1/6Utx2223++2d91mfhAz7gA/CkJz0Jv/Vbv4Wv/MqvxP/6X/8Lb37zm3fWdXp6itPTU//+wAMPtDcY5lMB04zr2ykd4vpcAEtpK2oymuBhO9IEMBtHT7A0aItp1rQfUTLlkkdznJhJpNAQt947tBnrDMDoM12g6dnYFbiC9RaTNtj9va0f6rXI1ZfMKCvG6mDELetTJGI8eHoAPDDg4D7g4LI4FriqyAIMm5TP6o9BeFW6Z6nhZCFUMlqqlK23s4T20XF/mJ+d5wTJjXMTAWrW0P6v60ONoXwFcRXQNdWl9hBr17n7G/O/fWwmWR7IwVzaaqrbRGA9ZJ2qRMaF2QGLMTBpDJJVPmui4mAqQGRdI39/iMCFQUlcaBzUQ9srZi9WYDEui9veBZDgWXQAC02TN6qm3kqbnEkcQEaWcDWmtrY+QtchazDoIcNTwgFis9h8J3FcmRi8SuLdnJNkOtG5AggFLDlv9eUpmUQVvwHG7YCT1RqXbzmUeICrExwebXDl4ABlJY4w/u6FtY12j8vvddgjxkTGeq6nRPDXg6olBpHOxICVHuj6OpOT6g0NAI3MufXBaIKuszAwsg8A8jSDzbaM/Ej0JO/H4/ecNYhHthSmuS3xDT5/I+X5z38+nv/85595z8HBAZ70pCctXnva056GH/mRH/Hvf+kv/SV8/dd/PT77sz8b4zhiGAb87u/+Lt74xjfil3/5l/GxH/uxAIDv+Z7vwcd93Mfh937v9/BBH/RBN9Tn/9fLYxoAbrdbfOZnfiZKKfiO7/iO5trLX/5y//tpT3saPvADPxBPf/rT8eu//uv46I/+6MX6vvEbvxFf8zVfs9xYQxjqb30KoN7TsN7XVkcs9mt5I5knthdUkmHqSwYIDFawYNEtvC8R2Kk9kQOeEF9sqf/xt6b/C4DvrDzCM0Aanqsq8mqlsqgyDE3PJJYZ4DXj4GCLwzzi6rjG5YeOsL4/YX2ZsXpIcgAv9aNZB1MBmXrPrvuBrjaBCrId/LgtoP3envE+h93cRUA7G+vCYROBH1BBPAxQqYerg8G4v3rpTtwbO1TXrZ1VBbpAnXdblDRyOGQ1T3LXXurU5T1ojrZwFGPmhYmUgNOhWmZIGhPLSKPAcJpEijsZkJdPYlm3fFqQTifJ8KH1lnVGOkiYDhUIBsml91edhNzhpbBILbfBZjElCfNCJBLA2lmRZibMpZoWP9DARCkCBosskkufJ+V7GBoAGsjqDDYeA2VNGC8Ax1jj3Rcu4vFHV7FOo3oDF7VrhQPfOuE61tIsQ1sW9ocxl76Gsdh+j+BrgX4sgVGrnxcemUniTNJo6ubO3nDWFuBS+wj+7F1aHTOmlcRZjWnk7PloH3umVmOBllLh5X79P1Z+9md/FnfeeSduv/12fOInfiK+/uu/HnfeeefO+y9fvozbbrsNwyBQ5Zd+6Zdw6dIlB38A8IxnPAOXLl3CL/7iL+4B4A2WxywA3G63eMlLXoJ77rkHP/3TP91I/5bKR3/0R2O1WuFtb3vbTgD4lV/5lfjSL/1S//7AAw/gKU95yvyFbwAg3E6IAtWMtkPUUNP22TIQNrcSNpfkIM6nErcqxvmzw9U8zlp1XmcoDbu3JUhLHoE9GGmN52lOBHfV1xB3bubFQKwfMtR9uCW4nnotAzwAdDjh4sEGQ5pw78lFbB5a45YHCaurE/KmeKgSs620HMoJFeztLA5S5D55nhxUmzcwZxLgF4CmjKlbVx2fg8QemHJbR/tsUANzXeek4SzEI7e2YXaeLulFW++SvWKjevfUWdADkwMI1FRkDrCsAt0XASA2UsWwB03aMh0k/y2dCqgTEGQ3VgcQaUMmkEjdqIgqqGKR3DJNQM4BPBkADTad20nGBYjn8CYjbzLGw4zpUD1xE+pz/VxN4nFMm1HAXiJgyPCYgDS5OpiAZjw2DlapIA+KNjvJrYxHPzbnk/yeFCTnjeQELivC9ljUl1cvHeC+S0d43OExcmIg85wJ6KRjpP4pNid+X1/ienY/9VK95r01fnPXPaH+loGed2EGxMKzMtfd/l7a55D3tiSgrPU9uRcYjtnVx01Yo7g2zpHaGJS2x7Lz3boGzbmJpeOhHtbzwFzTdXBwgIODgxuu7/nPfz5e/OIX46lPfSruuecefPVXfzWe/exn4y1vectifffeey/+v//v/8MXfuEX+m/vfOc7FwHjnXfeiXe+85033Kf/18tjEgAa+Hvb296Gn/mZn8HjH//4az7z27/929hut7jrrrt23rNr45stS1U5UCUSHiKjpwhoKGi0a4lqWpdGkB2acp+BQOoJcgB+uw5663MkYoSOg1ZM1kvNOI4vgh5rO94bG+z7dI3ScNndYSVSKEZZM/J6woXVFoUJD5wcID04YLgiNmZ+6JrXpYI/ABLQN+QFlbmYA3FirlE7QkBoUQsSppWo4EklEMRadwnfl+bED5FWzkEWF64rS+DPw9JsJaRFPmU3FxBbKDRhQOJazOq1v4va9W1kDptQLr5H4ZJAc4pIWyBlQia0ErQOAJIdgiR95JTcsWFgkawiqeGBmyGo5C04hTCzTDog3rdBiuZjs/A+idWzVqWBbrPHLsXO2wnpNCGdDhi3A8aLWUCgjTmJo5SDNLYUgSxAr6C2T6L2lXde+xzsEwFUj2AgSGI1eDKZM5Y1HpYuGTi3QOXyvSg9GB8ipCsZD54c4MJqCyIBgO4MEfd7ZOhMCph0/3K4f5GRm22L6ysd3Wj2ZtjfvUR8SRvZSAoVuEbb3D5MVe/g5qGOFABOa82V7fRXsoP0jLBLz6nVgEg/SZvr2r6RObpJ5WZlAnnKU57S/P6a17wGr33ta2+4vs/4jM/wv5/2tKfh6U9/Op761KfiJ3/yJ2cOnQ888AA+5VM+BR/yIR+C17zmNc01WhBVM/Pi7/tydnmfBIAPPfQQfv/3f9+/33PPPfjN3/xN3HHHHXjyk5+Mv/f3/h5+/dd/HT/xEz+BaZqcM7jjjjuwXq/xB3/wB/iBH/gBfPInfzKe8IQn4Hd+53fwZV/2Zfioj/oofMInfMLD7xhVAuCABwsgrD+Me0oaDklADnY8pMb3EQBM3HCmM47YOO8ScMYSx7xE7O35hTGeWXpw4ZKgCv4aSaJ5PPd9D20teS+KBJAxrCas0oRNGXDl+ADDFcJwIm3xkAQoAHKYBi7cnTq8r9XD14FjQg3U6zdWcJ+2jOFE+gLzfA0HRJrEZovC2KrkswJsC5Z7zVMirL2of6na1W0Z+USAKScBhTSJJMO8vc86C7zPW/XOPYF7+LqDx6BhUWDMggU8Z40NKIdlGecHewStDiCTgUA9NE3SyAy2MRIB2zA5RcGUASpa8GNjBk0TeMziyDORr3fSoM20GStzBgBbiL2dZYYBMF7M1cYsA9M6ORhIdu8mATxWm1EFf5L/N3l/ZgDVxMAmIaxcRpVWBxszt2NlBYBjkbleJQ/lRIXExvGUsNkMGEtCTgVpKJINJZGDpMYxIwIVqq/Kksq13zMd/zK7vSFt3R6fOZ7pHrG2Z+Cvw8N+D7f1W4DxnrZy4mpmQrIGZmpjDPW0lvlPlhs8hbkI73ZvCynv8BkvcDeG8yg3CwC+/e1vbzRoD0f6t1TuuusuPPWpT8Xb3va25vcHH3wQz3ve83DLLbfgv/7X/4rVauXXnvSkJ+FP//RPZ3X92Z/9GZ74xCfelH79v1TeJwHgr/3ar+FZz3qWfze17Od8zufgta99LX7sx34MAPCRH/mRzXM/8zM/g2c+85lYr9f47//9v+Nf/+t/jYceeghPecpT8Cmf8il4zWteg2ypmm6gNCqLhsK112cEdRfhjOo2VafRWO2b3d4rhK0QXVYlqJHbndnWhXY81APQcsfBni8Stp7jnR0mNq6Oa67P13u9jyYR6MHjQmmkgAMja/7f02nA9nTAwVUSO68xAL/QDwtcHO25RG2n7RcGEqGQGlCXWo8HJoYAirxhgJLmaWV1joBLU0CQ3LiJF22hCBUbNIdYmMv+ADXwl7pUdAayazgTMfpPo9iQSrL7up/iuRAlf+IlK8HHPYCu2dkVAlbydwX17Kr0XAryqYJ6DU9U2wghTQYBUyYpLO7FnsCnyaXgdb6lrl0qe1bAF9eJAaSURPJrv08F6XgLOtlW+84YokUBaA7zXw50fRMBg3aHARRCGqSvyeISAgL6FOwxwrsTgWFUa0c9nYFGA38mldsWsWGcqNqaGoOoG4hTvZYmYBqFjq1SQV5NGFcW9NtU5x1dYIgflNkI9ozKwt70vbOr2IMGLLn7XZ+PgK55fIGZbWhMVPX6ftzdJwPQkYagQO1D5d1ge8dim6hz0dTHAExqi442RgDrddGMfr4vlNtuu+2aJlQPp9x77714+9vf3mjdHnjgATz3uc/FwcEBfuzHfgyHh4fNMx/3cR+Hy5cv41d/9VfxMR/zMQCAX/mVX8Hly5fx8R//8Te9j4/18j4JAJ/5zGdWyc5COesaICLtn/u5n7u5ndIX3nJ2NtxgOMxblS231/XwalTAueZU9UoiIQ4Etgd/Teyvnu4wUFOa1X4sefDu5CKVkF9TpWscsqlFqBLL4NC4CJSXPPncQDsz1sOIIRWcTgPKJktmCQ3rgaKpyoLq1gFLAzYVyLCAP86SmYGB6pCgYpE0smjstP8WWmZa61zm7gABBEiqBT+nMNZecrFwAPryhYPOnD4aBgBwlRUCCLTsF1MBKHi6zqQ5Lv0TCWANi2L7kZUBITBpOBdV/wroqJIzl+wSZD7jYa/gujWCRE3HNZD2p0isP+48sr3Dqqv0yWJ1AEm+lkxi6wlz7ClFJX8FM6mcAbFpAm1IQCADZcqYDnIDllyaOaq9YqiLc7xRVcHTsocF2f5M4vXLKYFXCWWVUdZSj6irBQQyUwOqfejG+EHWOp0StpuM7ZRxtNri4GDEdsX+3jjIs3dLx2r0C4EpaTs8X4aZZqMDeQ4gjcQEUOR2y7GKhXeB7f0P9MyBYwBs7A0uO35ZXTJn1KypSV05VUmr99vqCu91C4J3MCZKG72v54z9ztsL+CzN3B133IHXvva1eNGLXoS77roLf/iHf4iv+qqvwhOe8AR82qd9GgCR/D3nOc/B1atX8frXvx4PPPCA2x++3/u9H3LO+OAP/mA873nPw8tf/nJ893d/NwDgC77gC/CCF7xg7wDyMMr7JAB81JVrEYTICWOZKLRxoriqbQOwi+1xhhyksQ+xyfh9yTuO43fyAzN60zVgNQJP3lVPd20X/VDwy6qCacBQP4YwB/XD4IFBq4KD1Yh1GvEgHwAj1fRkJgGMYwnSqsiRG+g2tZuAF+1NjoeXhS2pcQPNGSRvCVOfTszUUKYqSjLQxrsQLbiLhbp5pRCGJsYfjA5BxijQyBoyiJCTOsJkBaj9WgbpnwVJbkCse8Sq1BNQ28OQS1lBoh/wweGm7m14P/oDWDJtEEpOyCa1M/Dn4KwApVQPYH+U2slSNT5tRzAz0nas1w2w+X2ltmUS4XECAcjMSONKwNeQfM8QayiZbVFkHaR7Vm8EmC71Qws6cgJykowlg4DAssqYjsT+0NYoTVO1OzPVO6r9WTQDsfR6fJKxmTJuWZ/icDXioVUB57z8TgYm63qO/EZ6vHhD+39k7ux3CtcW6UfP5HYNMgIPEFSxcq3O3VJHG6bYGUPA4gA2/Sw1TIxJHPvYibNQX5FZRUs/zrPcLCeQ6y1naea+8zu/E29961vx/d///bj//vtx11134VnPehZ++Id/GLfeeisA4C1veQt+5Vd+BQDwl//yX27qvueee/AX/+JfBCDxe1/xilfgOc95DgDghS984ZmxB/dld9kDwJtQJJiwfQkXdnDRHP/uHCrcu1PTW3FSw/6BKuEx06LOrqsJ3cGVFrEJIJxgdSCA4GqMdlxzDtrbMtWcGwwtjNUrwkw9Y9w7IjFGd1B0ANhDv+iHhoIDTf+2mTJom2qO3mZeuI37p0DEAvIyCETcpHL1TBSAxHJzg3+tT98cItQME1tZJzdLC4eLg3D1Dm7UYWzr3q7Bkpo2enQ3YVV0Lg0c+KFlF8Iei2Cz2pMqqAse5iCgJEsvx9X5wAIgTzxTy86EBnFv+HouSF/0d1EFZ9A2uyqXxikEWZ7aUCp9eyWgIZPqLjiIzFSvgEjiTP3q3rvAsJ2qpI7ivElbPGQJ5wLIc6PsyUYa2E9L77hijIdl7lEAKFleEjC6mMs1B5K1gpo9lCaWSAEnCSfbATgChjyBVgVsdoAmNe72oJcdAGZxHN20+lfefQ+Axv42qkV7kBTtY7nbty757hjFeWf6Tofn4/7XcEVuwqC2AJb1pnG6s2nv1L72v9u1ghtG/7GcCeRamrmf+qmfeo+et3LHHXfg9a9//Q33b1/mZQ8Ab3bpiU534AJwqZdL3Iw4FJXCnAgxKoMaJGvw55IJCJk9Gq9dI4zmbGhEjuYcOAELAIQrmOOWkDchEK4x5obAceWOo6oyTot9WXJgASI40N8MBA4sIS4AbMqAh04OkI6TesKyPytzEqQ7Fhy4kxiRAhA5dLl6nZrNFHQslkw0HrpbkZpNG0Ia6jyS9X0hMDIHWyvL2mFSBp+CuLbh0PL/DfypOjZmszDAZfusN7j39TcnEpUYxmeLSupM6phN3btlUflOOkh3CEEjpbIxN/Eiqe1HXG+x6ySUgwwaB9GaFwYwafgdXbdEzTyxgbliEwsJAzMMNf5eWGsHkGY3mFKw3QuSvMIgiBoao7yIjbSRWaNgc/XqbUw/lMEwINg/a6rwUcAm5TopLuVzO1llHIIzMWeSPmpOapA5gsAdQSZOYgc4FEwDwFnHonvAAF50upD252DnTFOPCBjj9/697sFmVxZt5IwGRVrElY42GoKlTB873p8I/szjXepnlAxMR4TxCJ6bOY/1GdatAt3bfZivRwPQk+24CwVf3/P78tguewB4E8qSk8Qs3l0gPjPVJglRSSNjuCqSpM0thM1tYrOVNNRHI93Tg5Y6AEmBWEqH9FrXJ+lrNw6IQXM0BI91LHHUHrpiR/2LhDCAAFel9AfFQuFwPydGygU5FZyOA45PVhiuEoaTUqVSZhhvY6C2LpmzIM1SCV8Tqy2oMA3QxrFjQpOtIW3V5m3UdpJGCdFQEyo2cMlAlMClEWLvVeqzwPJ6+X6yMDCnVT3rXrZAULmilY5wrcfsBF3qqXNseaQBjTGo88XqHU2uylWEUFABMsJ8G4PheYJptvdMKltWJN62W/XgzQk8ZMlikSX4I2224MJAmfSDCv5InSjMMcMcfGzsEfzZOhsQ5A7EMcuDpDt8ksE077jtk6gGBFqVsN2zGsQpZQpOK8ygUqTrmlnEnTzC2teK4w9VOibrQhWga2aQ7ZSRU8GwmjCuCjjlRcm+vYOO03cc/tfEE9ThO6rPtICy50h31BfBWqy2cZwJ/Yrvecco7QKeLvnLwHQg78Lqqni2S6xK8Q42BsuBaDDTacbS9/+9VG6WF/C+PHbLHgDejBK42sY2x3434QUCPYiHY6iHikhexguEzW1AWQmokDhv9aAmYKY+9jatiU4a19inWX8iAXNEol/7Qy2qEkEV8LkuZsf8UEeXz6IrXR0G3ti+WP8SMAwTBioYOWHcDDg60TheE7tKUdrjehYzgh0gNb9Ro1qkqipuFq7Oa/X+A2oYjnqgEMtaTodqf6cgTCQvVCUvBgA3ssYegiKuqR5QnElS/wWmwcJYSNYTAjI8n6mltioDdesc/g57w6XTKk0xT12L1QdKyETApoiTzZAc2OaNABgDgr5HDIClpHZ+uidsfwVmqAyENJCkQ9uIXRxxFvBEBKh9HpUC3qo9Xw/+hqHGBDPHkKLrbesb9f2mNp40PVv00KUC5owouaO4d4Cq/lUvXjZJX6KaE9i8enV9GLmxu3UJJAeJngK7KI1u3g2umYC8sDrznBA2JxmnU8aF1RY5FwfBUX06wysGBLWumUPW9ZSe0Qp7zcEn1Xt56W8EeqVjXdKi2O+JSbB7r3UP71jfp+gQUlbiyDVesPdKgkKnDWFao2oegp2vbTn2emlGc5uuvI96Ae/LY7fsAeDNKOGgFtqmB3hvnNwBCQEeaA7AaW2x3STQMEwiZ02VoOZDDS9i3seRm45cth+0fX/6oRjYMOKKQGwxl/bZOPxZ+8mJrN4fJF5LbTY/t0KOprjEMDMGkwBuB/Bp1th1Eh/NAQtDsig0c6hzN5jdFUSi5Qf/vN3aV9YAwqiBpRVsmg0WgoduGeS+oinG/OCIAKyIFC6pGjdt65wD1aOXE2FaMWitwFQPqhTsFQ0UABXATatqP9pOZp1jDnvCvHXdtjUBYp5I4lDLACCBjstKsk/UjAnVKaQyBgymVD3abd4Q9qhKDktWCeDISJssIA9wYEWZxFPX0q5Nk4Z6EXE45VTTsc2csSKCCCCtBMlftCHU+2i7tGlV8mlexyZtNJXwzClFgk/zAFSplXj+ovdU17VpYlISVWYkrh0MsJMzF+LQA2CbME4Zab1BTobwtbrwnvt3tHW6ea+9D2cxeN3eajQdsU4EkLbwbrtZRM9wBeYktuFzYWYmqDRnpnrW36JpjG9RDRTv9tfKcEHnE1yZorbTcCAf7aJn+d3fCyXg/If9/L48tsseAN7EEtUQ0QjYfuuLg6gAlMoQONAr1Rkkhv2ItmJk4M8OawpcdgBmrCCIUo+2doOyOrBwCIRDZNezSyXayPREsVHfNJ0I18OHMwNDwXoQNdrplEGbhLQBaOyesb+Hlgq7lCuRCIcygS22ngNriylXD15xGIHC2dAnd/LQ9fPwOiRq3VHjs6naPoLnXeopl34U1n0gdkplIpRB5jJbEFsOBx/QHvDdQdzPcclAGkT6RtN8IfzgplofD0ChpCnnLG4foUwJ2dSygIMhs70UyWQAOwY47Q+TPK4SyjqBtkGkk6BqWF0bs92LxSRp9reBNAOEUcVrzxLX3L0aB9LaWPTsjZPXzBM5mLNnRKK4YERrksIcQruYF7rNMQSgRo9qb7mo7dlAQTorYxRmgkAjYSqEBMaQJ2DganKiy7z4/oY9bYGZm9F2P8zUoPZbfMjoXKi/qSvU3dq48ryfEXBG5tNoYng3dzK5XV+ZZO8Px8KEAcqMs2hgoO8X5wUm0cB6oON9cVvoczSs26uA9+VaZQ8Ab1bpCVJM/h2BWE/4lHt3IAADJnDVRaMi6bln+y2116O0MbaZJqppkrquLI3lugBeR5ybqhZUIu4AY/1dOgzCIWQ2PtHQO60KhjyhMOFkswJtqKpOsx2KVNngCIaidMG8g1WKgMi5g4Eijh9M5FkwKJGvr9nJueemDkRsNGWMpqotI7k2ss5PHS9rQGSzLZT+AaYKTJqbt0wC2gCV9mxbJ5cZQF9aw/ibql6nFatB/G7CX+0RyVXStoY2DzQmpBho2Zw7VuTBqGfSrlLrr1JtAUAeENrs5AqLpC0EVnZVK1CBWk7g9Qq8XqEGVR5B23EeCNrsBhUwcg7gsqhnrwHCKP3LScKrDBLOpQwKOtkkoUGFawuvfbG+WggiUUVqDEpNs+emDJFhMMcDXTdzMvL0cFnrL3KIEzFWuYAyV1pxvSW8m736tgF514sVlu6NIM7HCH9vGxvYCLIi3SjcgNoo2exNKaIZDADZn5ERszkE3DzD6VHA9z6kjqFthnYjc7Mv+3LOZQ8Ab2ZZ4Gabr93B3KhuVLKXJvm9RMBjBywAIlogiJhz1ZFLN8LF1RyLS7Xha0oAZ71qZdeYG9WvtdmNv++zSZ48e4nVY/Y1oR4DfyDtfJL8rplE3bkZM9IpVemfqWVVhdNI2CII1DZpLEhTcfWlxWJ0cFHID01TFTEEEJYDwniYMB6KrZDUJ5NtB4ep5dJWxpFsHrq5KRnASjqZtux2fS7lK3EtpAKLw0dTnUfE+k06cQY3zzpXPCigGy2MjIQZYb3HD1hlIBghbVlw8vB1Ciq5kg38VXW07wlbFjawDA8xQ9sJtJ0qOB+nFrwtqXoN/A1ZAODhoA4SNtGlMiaNRLACPOQQ2mVE9eROAXgSiQ3kesB0kFHWmj/YPKdHjZM4sgDXKeQ07vrLQ0I5yJgs8wjVcD51Dev6iodw8nekeUdZJdAjYSzJQSCSfCyn9U7p31Kxd3Hp3h4QYgfj0YF++/9a3sUc/zba1NdLdR81kuqA1hi6bztG0+mFzkmrWpYPp9BsXIfwavUOgHHM7xWv4F3M3408vy+P6bIHgDerdERl5zUETtQuxcNaPXDTCHccaKSFWd/rKDmzy32oBMzokPxmXOyuFzyASVPNXVMSuNRQGGus1+JsIcEdAmDgT+vqQWCjzgltjJyw3QzIG1OFtmiUoqQFBmbsr1YQUPusINClQ91Qk0i6pgPCeCif6UAkMVSAlKTWRPUwSFsgq/hkAoAc26tz5HZGYwVDYhcoG0acKCjMm8V168fNTXgZsvAsYby9Gt7SsqVGQhXmvGcwYpNhQzko1PtFSkWaUg0zKXVSVZ9lVUkbRj4tyCcj6HQCtqOPzwNDx/Aulh8YqMBNbQR5lVFWGgB5LGJDmFJV5ZGkiGsCRAMtMFTnDpf2qbqVUwIfZExHA8bDjLJWybMBiYmQNozhZGrCtwAIdUTwp3UkC53E7pzUxN20dyjSDbBfI5Y9kzUUzEbFxWS5cGlp14eyBLDi39egBTulzgi/83XcS0J/4tiW6ouAK0qPXdLcMH2t00wvHWw+xngmzMbtwG+RwHZ/nzHVj2h5D1XA7zXjxX05t7IHgDej7AA/dm0GgmJRIuOhVxAlIUI9mhhuen9ULdR4cBUEGuEhwjJn3vcncuQuBQt9tGfPGj8qcGuGGSQETVaIhfmifr6Cyjvm1CXtzHbKmMaEYUPI2+KBmpmqSrgGxlaqbQAFem8m8Eggt6OsQXkbdZNKiMpAmA4J2wsJ45EmkB/COoIcPEjOXonTV40Eyb1rm3Xp5thDy4wCAEyKVlbi2GFzCu1a8lA25Gd8MaaA4V6LYRqaNZIwLIyp1FBAs3A9drt5aEZmwRiUTB60lxNQ1iIhjR7A8kD9P20l/3A+npC3BbQpSCejhEuJntk5KRgy8aJeM8ePIft9GLLa5AHu8GH/c3IJH6ckUkG1A3RbO1cJEzw+oNnaEQEK3MbDjOkwaYq9CsxMgzyVpOFdzHJU1y6LuljU46mJYRffZQd/FkLH7CjV9pcK2meL2K3lU8JmmzGVhEQMSiz+Lh09WHoP3e5zfsmZtHozHHjuBD8Lle1SyfaMXrTB9XpRgV8D6FIFf/6OpfAch70LuMbBM32UucbD9r53oadd/ST1YzUwec5ewJGHebjP78tju+wB4CNROqlJL3WJ6lDPbmFeoCO71yYAVRlpyrTohRa5fwN/IZq9Fzv87Gv3VvcBe50QUpXmyHPz8V2vA4jXY/OxgwYu1deouV0lLodZIsbEhLLNEgply0hb8QKmRIuHlx2obRyyCPhSPVzN5s/WKwXwd6Tg70DCrMxtL+spkPUwz4W1LQX2FtQ7zqetpXr3NrmaQx88CwyFA8z2ADTnsNmRxglXYDc7j0mlsWvpn5kiNJJmB3hAgYA5PxwjGCQCEwPq9DEdJkzqBd2k5kPtexpF6jccT6r2LTX7xdCGYTHA5lJB9ZBunD0o2IHaszGciu97EpCYE3jV7ZWoPuy9eqGAeUju4R1ViSBgcimdbI68oXYtgzSvBGeQ3jSjSacXwZ9J0mHgwh6oe4gnQmFCJkbORZyHvB29F+07F1GgLQABAABJREFUaRoC38Y2HT3Ai4W7/3dd98q0nTKnj96HRZrD3fdwPWzqJXpjzGVkgpOmVVwKVp80M85UGOOR7PdUCFy41czE9sP4Iji9pjPWvuzLe6HsAeBNKEZUeoIJVCKPJcLF4QAtkgWkZML2FnJvYPeEmyCSnSIHNUViYoRLuUzztrX2XN3Zc6AdQWLLJtD3E+0j8wmI7df/r2Xbs1Qawh2kT/V/BpIcZjkVTFMOOYBRJVdUvVNl7qlp1w3pSTrKA6GQpPoSaYwekpbnFtBAsar2jeDPgBxQQ7+QNGbgJE1ST9qyxNEjRjFJkM2VqnzzKXtg5zSGtTSGIXwKAIs/CHBlAFgCNbvHuEYpaQCnzbf9n8XckRKhRMmK7dUszAlYQ2PYXJrkZKqZKngQida0ThgPxAHEDeu7eu3wpYnFmH8q8DRrQeUKlXCaHSYgz7BLyFQ6aCFZzAsYqM4YE1eHEc9kQtJOFrWu7Y+6Ked/szqK+F6Jku0AmosyF2UgTGNqAX1cVwuRE0KISDuAewNTAJmm4rS0et07V0GOvP05FQzDhI05ggRQ5NipBzBd4bh2/QV7jLt6FoBfQ3NoYR+GZxspKM/bd3CHheeU8fJ5aeqz7+y/uy3uoM5YBVg/wFhdYQ8IzVrvEtD1dQ102OcsrPV5lb0X8L5cq+wB4E0u1Q5HpRMLAUyb7xYyRIMXTwfAeAQgQcKasNTp6j3As2JZeIim2IERDtdGjUnYSegFx9HMow5AQ8AcpHFbT3/4ReLXHDDUfXzuAkiJbcWizySVABb1mKFJ51qBX5X+cONJHW3T7AAFCGWqYEskO3KTxASTgZaBJFis2vxJgOUwZpY6iTRuHgM0qPMHia2bZNRQ4AHGROTShDQJEzCcyMfT2lmftF8eS49IjPp7e9A4r3a4FWtT5zWufbi3GUtzUEqMPqyqqMViFxKz50OmUYNwZ5mjaS0f81qui61NGxYyiWscR1S36kMClDL4IKuav4iTiII+2QKpgvvCoDIJQN10KmW0bXlMPlty85gC1RAjrnIm99Z1QN4wLeR7jBJ7lpNZaBMOdUYwHJxFPNh2V28DAm3NleHx/a75pZNKABHMKKIZyWJZAnL9e9+v40J9SzZ38dkZXdBrtkdn9srGbKYwH+horod0ggO9nUAsrIWB8elQ/s4nwMGDwrhNB3MHJuvzkiOcg3mlf+i1M4902WVncyPP78tjuuwB4E0qNW1XSwlmAEpLzOZAW/l7WsvJPFyFex06KFIA4RIWAli5+RgAmjsiCm5jri2pdP166kCgSxHiQDuQFp+3Q8e84YyKd+Ck925eJIoRTJ5xUDGT2u7ovBr4i84loc7avtwzrTR0SRFvWwul4fNH8BhsZWUhX8QOz1S/cRxuy2ntZInZlxR30MQaZiWG8oA6DWhWj62oRM0eyWzrZuAvzFOJ0iCgCbViTEbRAZlHIy8B8+6AdLin9o02VvFstjR6cK9dAGB1kJkOSMwZ+vysHWiA1l8sA8iYaraWutCyDjmjHA4oB1nGu5mQ2WwstX3bf6WATkXaR2PpsnJEYAmVkJYuRg+p9E2kmWJHqZLJwUwFqAVgBtJC1e51mwzcUQUlQeXv9mdszh91f5VVB44RQGf/7lPdByhwG8BsnsB6L8V1Dv8322Dh3fRnd4G/QH8W6QzvuD5vqplDYt49z12dbgDiDFDb3sy8IY5nYgzHBBpFEm/MiwPKQI8WMdJZuOk8AeC+7Ms1yh4APhJlgehRvEao0rtSQUdZG3cpHGwk6pzIVV1+Kls9CwCpORRiBwKo67lYe46AxlZmJwdvz3ZELUodW9simh1Wxk27HZv+7VWSEet6cEkYGKHG2ymBRnJg7DHarF87wKX3KUNTPREmzaBQs2vIwctqTzYZ6ItALAKtMO9Q43OPY5jELo6gIBBax6A5XLnagBqomklYg6SpmdPEGscPDiyAOqdpYsCC2aoziYXI8Xlq6mz3hl8OgLLmPmY3npf5lEweBpYdiMS2uuJAeEWYVgmYsrQ/hnAtFiplPaAcisesjJFRptxIyD1u4LbMnTtULcxZn1dbQtqOwBZNKBgexJCyrJKvkepkwUOScQ6Vwerfjfhdhm6bXZk5lrUxL++0LdXkgBnIhMlCvfRAJ9bN7RpF21AUwlSSSMpjZ7r6bO/2GoprmnLsKtd6xoBZz6DFr30dPs+V5jV95h19jUA1/G3q6p7RpALQRsIwiX2mPuPMt7xz1bkMzbzPc0UHGnGugaCxKOy+kef35bFd9gDwZhQlLE32j/5QRccpBy7cbNdiLLb+PiSgxMDGgXAtEW7tyIzDjZlEPFi1ejfuMryOfZlxt4GQuqpX5yCqwyPRbroYiPcSAW8kmjoPNDBWeUIixnbKSFuq6tvmYOSGa48qM6vbAhqXgUCDqOrSVo3Dbb007AprWrVo99dIQnUqHTR1oLvx8C3m4NGpqqIndxh/9fqMk2f9U89g9f61fMQu1WRSiZKAxARGMZu1sGbNmuwove0UAN07Ut+0TlXy15sndMWBCtkYCOUguQo0Wcw2BWRlSOC1AC8DsCVrerhMYiO4nUTSZ8CvFPfmJeS5pN6CSFtswULV6URBIK+StG1z72GAksb9gwOuazFIBsol1SMjbUoD/qTP0t+CJHEhGUgbru+aSpZ9fxF7+Jm2DQATYZwSppIwRZVguDcylDelBObR2urVzWc6lTXzpYyF2+u2dA+A27faexdBGACRvHJ4r7hbq8hYhXeWM9wW1hyVetp8PfMQgeG55gJeOhNu9Pl9eUyXPQC8GaUjBjHOXM99RucPf04PflevUgUYkTjNQB6FOqcFYt5wnvXgmQdGFq9Y1yr2XogL9fmYwt+tOqoeNB7G4Qzat8jtd/czAM6MtCo4XI0CZIpKAA3YRtBlh4X+yFnt2Aw4uUE9NLWZOt+s0QJHChK/QY3EbX1ie6htRvWdzamo82UhPdTI0pp2IK9RMc4mDupkIOs6meOQgUmLI5dNgkWaXlbtJ009G+wum/FYG3aJ27kxW0mbT8/24eOuz9rhPBufzpnZODbZ3QyIaXaXYkGYrSSq6dcKgKmINC/G8LNcuxbY2U91auvq2xsSykrCvMQwLUw1qLVLhyJ4iVWG3w30i8czI59MyCcTkno7V8kRwEGKKxLhGqTc1MG2zpahxulBMUkygSYST/lACBrTsMh89QzGdZSdtn+B4Zmt/y5g4bRyfkNjy2ztOQC23wKdoboH3eM/gMAmrmIEf7Y1pjr/kXFumJo4FmOkFuYvSglvGsjel325CWUPAG9C8XhcPeHqOdt4KQCFqFoT70pW78F6n2qemgPaPEdpbMFddaagSm/sAOrULlE1wbAAtOGeBeA3G2M4xB38dYd8c79xxt289PY5zScQ+5QKVqmAiFFCsGNOqGmbwvybd2UL0lHBX6oArxjQNtAY2m36Y1lMwvUY0sK9bVMFni7RQuvR6fWrTaJ7io4aQ5A1qLPlgm7xeQWJmWtqtsCA0AgkrlKQSe3QaKgOJCZV2iVljGtEWpcdntZOXasAbnU+zwQWvmfY728yZrj0h9q1ZQiYi3Z7cVNF0Kffm/usTrtH/2ZL63YwiJRvLWFsaozIdqxum+ZzZO8SnJnyUDcbRj4pyKcF6XRC2ozS/0zAEPpqqmgFI2Qqbt3jnETqzSS5fjl3YY+MqZzEE9RtADOLHWBY2JkE/3pByg4gt0uC7MxAZIaBCqR82xgQjoRKvxOAblMugbpomxuZYItPicCUNnbRRk/VLjMyktE5LYK/hm551Idujjqweh5l7wW8L9cqewB4k0ofpqABDgjErpf2AG6nZYTLVWAT1bPNwIQ9R4FmGuEygGDtEiMemDPg10kCiDtVidWTOiLZEe+zDOB3FifE7ZyRDSoAyparlxiARJIGbtxmJM0D7HaANgbUQzpy7jErRgMETcoHzA9BG2fq/leJivSbfGg+rbHuUu04zfkjjlHs4CC5fidCHqsKO28KWJ0RONf8xE3/erBs81ssLR0jZZEKlREN+CsWBHpNwNDV0QNn1Dmo+0FRRPe39Q0Ic7b0Lti6Gfg1YBcOXc/x7O+NeR9r7MBSxGFjQAMea/0K+pgB0vAtSVA/JfEchkn+NL3bdJg1hiE170LjTU51rMZApejQoe93MvB3MiKdjuKYwix9BgHBjpKzhZep89SoNTU+qEky6/e6rsZQTpNM4hDzAbsEFDvLIs3ql2yBWWjond9Y+9SYfXTPRilZH82gPtdqMZbUzdHz37u40F6jIZngKRglDqc8E0Mn7ZJgNlJVhP7281twvuWMtduXfdkDwJtRIvFZut6DQPuNABSJ+5YmYHNRYsvF0C5pAthUD0FV4bTfVX52StQ+USCm3tUI/BSwNeC172NnG9OPo5ek2XPX4oCN2/a/e+Acv8dnE5BzwZAKTqcB25MBF48lfIp78FIN9CwSVs1bG6VVYQ69rW5+vc0O9ETg189Dg5vCvHBiD6BM6rQhYWRCv1SKV0yKpyILk0jmjTyXhgpWrW2y/ocxujNIMRAokiKaVI1otybpy6jiz4mo5r4N8+AeqQPVtHvajgBV82oll0abdKkMVV3cMxO1jhDH0JykXP2bPA2eOU8J+NOMIafbkLlD9bLq9TvL8GEBo5NI+8CkUjEFWfp7WVuQZ4vRF+bDFznMk76PacvIW248e6movZ9K/SR0DQRwLqiiI8htwc0CYjM6EPa1S343kg5uWxJyKki5ZgNpwHy3768H/DWSu4V54f7eeN0YBf8pAOqO4WyyGwHOFC0CySQ2rsxA4lpn06b1L8RQpALQyNX+F22khryR36YDtKG3eloR2gLmoHBf9uXRVPYA8GaUnguO73kvLQuHNkglAyMwHhKO75SDxkOBbJUrjQFGY7YBqzbaq+UFgBb6Fp0KnOCatMaIY0dUF1WO8e/U9mt2ePSgKtTr90UAamBqCTBrEGgAOBkH4CQjH8uhe21VY2ez5YeMfDHby1460PSfFuLueb9DB2xecv14KD5S8LeKOX27eensMF2SpIdUGVQKGNX81ue+b4DHIKORBVcFSYR4NAq6Fa9HsRns51LmR+wNy1D3Zs1AQ8gQZsbS3xFLH6cDkhjMID9AY6Bzy7oQPS09VZsGXC6rJM+yvTcFaTNJxhAL8ZIsmbEWswdkBqEG+G4M8i1MS8jwYbmLi61fUG2LdF73W6p2pRIPEa7mlT2p897l9BVvZBtnrVfyHJMM0/YBFKwMSZmgAKQDUDSvVVu3vGXkE8K4kXRwAgAnlKxA2d7XXe/M9eCVzgwCDLEl7D18dxUnbdyAwNltZiJQh9wKp3taEjzT63c4nRGaxQ7s3WbWfIEGaCgj+e3wXg0Js7L1DgH3e3r8KAF6exXwvlyr7AHgI1G6A70lDvV/05RZXDnLJ8tFPrAgu5quyB+kyp26R6txs7toT/8u96CVWiA447rDWBrGekkgsZuOLwO0IMGYqVxCm24jRoyxJBxvVkjHSQImm5SUEA72Wj+AmYRsSYLXqJ0R2rW/O4kouGsmzo0CwGktDyeTMpnNYTh8YMNTW04BQ9zul2Dcn7Y2luBQ0rRLcggX1hzA5KCSRpbDSwEdoPZkiZEHoKzlWU87aEXnR5xgSHwrpip5pcJgDcjtalzAAxmLx65W5WNhD4SeT0VKRmNxoMOkAZeHABynKk2j7dQeuJOJh2j2v6eFU2BJLP21vwGEmI81lI1JZM05II0CrsA6RxoPMqkK0Wz8SJ07GkBv6QBtyWw/lqKZULT/UxYbTQN8JDZ+VUpd19zsRROrlDnLYokEEOCthIE5TAXDULAduDI63Tsyez276zOGtmPuKN67q0T62Ddo70Dzve1cibazen0RbHIAfQXOmABwsxDXrqDSIDfbCGYhIAQaXPvimYeCnbHZUvtcdQDx3ErHyD+s5/flMV32APBmlKUXxYhcJFTGfQJCnCGHzbQW6cfBu1XFYM/axyUl8EM4cQUQiMBmqXsRZHTAzvsa/+fAFVcmuiHWs/biWI3g2fNnEZIwL7P7/JDgCs4gQHUzZZxuBuSNgKFqIN5VEaV1diDYWIzQq1qxVbO3QWcBNN+9a4qrKAB0Vz8rWAKk3jKRz1M8dBhhXfSgSmM41PTQSgCwBXLmqlLtDxcHaQIy0qQhROItKolyaVEiWJq6pE4oZzES7nCiByQZw6J1WxBrAfNm90gOEs02LW8YeVNEKjmyZvUoDXhEphorM1GjSvUMIL3EpbCqiRVsDYo6U3InDwnurICQqgNFWSWUg+yxDA2oywaQrWix+6iwhoGRDCRpK/mMs4LYKuGugFgko9pnInAhEKuqemzHwgBoSI203cFgD9yKbixikJp15C2QRnJHEEsHh1w9gRtmzd7BuJ/67xG82X7o74/vdNvNFjwuvrDtmHoTDSwwYSapmpkUoN5Twao5uqkEl1vHJzfl0PW0FJNg+FrP+hvnpp+feA2B0TiXEhH+w31+Xx7LZQ8Ab0JxkKRx+py4UHdP4C6J2b08OcMPELDYXzlBSgQeGJg60EUt0VrkMCNgQwv+mjAI4aboteg/Ry7/WjRhlzSgA4hNiWC3u9Z7I0MdQAoTypRAW8hBpwGJo31OLxGUdamqXgmf0oZ1kfXhncDPh9QdwAaY5UDVdSQFgSohivNq0r5eZR49mi2EDQEVEOn+ShNJdo8EkDn76C2Wsi3pYZWIl9NQRYACqgClkP8/U3fr2M1jGZyQcrBz2wLo8he7tIql32BVT56qN+xYJIafgqPoAUy2rCzAz7JkpLHU7CPjVCVnVhyQk0j8iMApAUPyLB5ic2l/yz6RNGAJ06EwZgake3szWxtWDqCGdwkgNu47G+M0aXo/dvAp46xjnjmuqB0rjeIA5fOq9+6Uqk9qRjISpiKewEMqAgCV2fG6djF7Sxgt7PVYGkauY+ia97ivt6cNEUR2zh4lBDDvpagc2yfZz97XJO+i1Ed1rB1ti97DQH1fJVi8rtMUCfvCmHqMuMdR+/IoLXsAeBNK5Majt5oRHiMwpPdysPmJUr0mZRZBg0IDhan1novFOcvd16QtePDnxusWQWK1BP5MFRJVTtHhhFDt/9J1ErsFoHf2/XIqcAJoEAeQrF7AeSLQVFRqNQ84XYNRww9SpKBOy2jVYQam4gFj3wH0BxWHx6rEsw6uAY/WB/vY+e+HDTdqKpcUMsRZIKk61AKOT3KoJVTmwFS0sNiFBKSJNFaign5lVGYOBXEfR5V8GK+PS4EtLHaiSvWkX2Q+FT4VaZR5NZVrMqedSYCN27rlJBIxTwVXBPgBDZBEgdj+bUeJ+6e5gEWyF7iAnNypg1e5gj+q81nU85cJ4EFzPa/bYNbkqm3tlTm0qKMKWUaPjdglEut7bqB6OwkILKWqqQGJCxkBqtZnkiqebH8VAcIJKJwq6Ml2v+0XmoMrCwUDFk/gJBt1yWO/Z3Z2lSWzlkXpX0+TEOqOe2qBQXRpnF7nhf25kykNdJabvkWU2z7rwdajxLcokJ4ibeT5u7M0hu6dOfeydCbc6PP78pgu5woA3/72t+MP//APcfXqVbzf+70fPvRDPxQHBwfn2YVHrrCAqaZQ+3cPIJhIpDcGFrsDtuHSG4BROePWuJlnhK2Rftm9dn0XYAsEuEk1x1j2Sozgz+8Lh0DfhgHiRkqEZYITDxNiUGashwmDxgGs91WpqxPw7iBZqt/S0zUhVIJEwPsb+xnnaddB1xklqYytNbp34GcqUVGLmm1clYqSgxPPPGHMRqnfvW9J8aVKqaYpaWyzybtVUpWCVLunTsXFod5unDZnJQuISRNLmBtVqTvEMQkVqyra9vukqmILkB3Qp0lOvRSASgSF+t3A3zjVe7OwM6zAz72IVxllnZvwKhL6JrnDh8VrLCt4DmMLy+TrFHL0um1gAVKBZvWYkE5HkfYZmJtY+1/mKmvbDDmJutvC0SCCFfmfpiJaAzMsI8icmH2gAn5/t8JSFpbncipA4kWTkUWTB8y28s59v8vco9E20Bn19rQrBS4r9s/u5R041cHwnL6ZBiC203ShMxkBUCX1sPkNMV+vAZSbund62zxCZQ8A9+Ua5REHgH/0R3+E7/qu78J//I//EW9/+9trPlsA6/Uaf/Nv/k18wRd8AV70ohchpQWq9L5SIuBKPH95GEGyxtXuLNj35QkSBmSQCsvQEWWCBzKtDgN6KE3198ZWLVDZWQaQHeMwsDPz7OX2+RhFv5WCzg+DCGgdZAFzSUHFCG0/9UBLibHOkxxkjZ0eOXFGJNIO7iwTRicBsDZIOxNUQLM+xHHGvsfv3YnTAN2+PVu/rYQCyqcSKNgD0DKa/pvUiYqEunDv1R39YxKANh7YhazAUsGySYMNWLFtMGrW2lXbkQFZ3N+t7Z/vISgIMFs+DxHD1TFjknAtXgcQBqZ9DiCKpgJMU/X+be7Xv3OCxE7MDm4j4HMnjwD+Gs/tHkg4w8VoGCNUhxbaTqDNqNG2yT120QW2RgR30e7PYhN60HC9P9YV2hXGsUV7TmcCnbCqEqka2fZ7fG7pvUMFP1rl8r63i7FwALFa5yKIW5DcRxDI4Xustx9n+77oQ7uOFEIDgiMz5DbX6pzUxAN02iBewDP7xzCuXtPRZ1jal315b5dHFHG98pWvxId92IfhbW97G772a78Wv/3bv43Lly9js9ngne98J97whjfgb/yNv4Gv/uqvxod/+Ifjf/7P//lIducRLz2Ht2TbJYephpcgkfwMevB7+JeNAQIgn8p3seUxwAePVG9hQZLawvl1U/mGw7o53BZUuz4OkwQZkYyE24ElNWDO2mlApk9EeC5K2rzBhcn0drqficWmTSbc591jtQ0RuNaMG5LvFzWQsNWdQp+WJIA2/q7PflCwzvlIkpPYwveMFPoXN0MdL7FK/mytNwH8QNouK8J4mDAekjpcsDobaFYJC1yrnuK+L3QfADLu8TBhezFhPNKQKgO5iswkcg7MOnM6H284sG1Pp0nt+TaW27YGwC0rkjh6IZCyMy4K/soqaU7dVKWPqsptUrUVCFCKOX4BkZwNuX5MBTyIuhdD8uDOvNKsHgcJ44WErX7GQ8J4oDZ/6xqge/bRnNFF1fDVkaeqs0X0avPKAgQjSK0buR0f4H0vq+TSSg8ubvvY2u6CYsP2YVjDCmIkGPS25JASDs64RSaloVlxy8b3v98XqHtj9rc/T4vP99din/z9M6ncwrNRTWt7v2by4Po9fCzkkNPNDea090Q/p3BHkBqaq0quQUZTK0p2M6D3dmF6zz/78pguj6gEcL1e4w/+4A/wfu/3frNrd955J5797Gfj2c9+Nl7zmtfgDW94A/7oj/4If/2v//VHskuPXOm5XXTvTyRwg3zSMbC6IgR7e4E8wT0VgDbi2NCAlMj5RwJfQns0v3dJrbkI/HYEo3UJgB5CPWdbx49F8Mdd20AApr00qac73XdmwlgkrMU0Jgxqd2ZhGMyz1ewvW3AnsfOik0Vv9N2oe8MczE9DXdICAX4G0q1uDe0jYGHhNOgkDUmzfkhcOEvpJlKqaSXzbmrhrF62udggpTe2f1xNSQZYxIjdgHAazHEGKETqeKHerXq4UU/8g/TLDtu0NealIKnqGoU1h67Y0XEW+9VspgNFpE9F49pV4K5exWPyPKxgdfYw554iwJCBKg1LFSQ5KFTwxznDwroYsJoO1L4vBnjumJz6v258lv5Nqj6MZhQz29wEcEqgzFXqFwFhlAI2IWoE9JWjAWVIAvQB0LaCR4nRmBRMVyAH3YceVyqzgu26iZklH/BUUu1rD6rsve7fbwqXuQLGpfe9sf+zaiOzaHspPtvTLWunq3cOKgNdsr+tbsuN7nupGwuFOrtrXhL83aNiTJq+41FCTG1A6baTdUp3gthHqHTC5Yf1/L48tssjCgC/+Zu/+brv/eRP/uRHsCePbOmJXrQx8Vyh+j0SOpOcbC8mHN8pKsp8DAwnXCV+QSK0FAS6XkPlRrUN65ufAwuZOha9gRcIlQHRnsD1hFpuDmMltPVxJdT2/KzdDjRyqqoWBrCZMqZCKCeDcOzbEAdQ6ylqf9XbOpmKvrdHmks4Q+dmh6ROqkldtnBpLU0q2TrQQ8ZUUaqu9nPbpKVBYmpr6A4GWRwRzIvYnYdYJBUSO6+AmECcxHSAA5j0PaESUHXaAAwwiHct8kIe6249DaQmzzst4G84Vk/erWyMkgVYTQcJ00raT1utI3jHmyrWcuyWFYHWqQmenEYGjifkSSaLUxKniUKe9YNzFilfCKNial+4Y4eCP83pK+FdQizGCE4M+MX9qGtjIX2oUAXEUa2XIIA0TdJHX1j936SXapcYnT/4QHIPj0eDSHoV5LMCblYbQY77muXvJROD6NDAmT114lQs9Mx8v/dkpWfavPoI4HaBJxt672iy9OyuQvP7Z/aEgDN18V0C4J7gjT1yrD7aTqMCOdMWTAeE6VD+Jias72ekKyINnPTdXqTFJO+7zXHDUOzLvjyKyt4L+CaUCLgaAsSARYuPBMhDfdjhbB59RnyygL/kXqGQQ4RqW2YX1qt1LSuBH1xLRNaIHgeOHp1XYOBcCRFEVsLpIG5xUuAXz9IkuArZvkeJXC+F0Hkap4TNOIBOEoarmkpvK+F0JvNwzZUrt8O6XYTwv4K9IEzTU27edwevWmdU+yYHogweqK5zkoE26rXJVEvsqlpOpMDV1tnSxYU50Y4PLFI1A3s0Fk/vZg4/ZUUoZr+k81cgACZt242xS+Njqm4J22JqargqOm25ghWT6q1FalkGAxpdW6q+NCDm2Vmy9BkW/Py0IG0tVmECoaiJYvZcyHyQ1XMYsDQiAviyAERTMx9JaJca3LkCv9kBvbD3nHGwvqq3dnK1K1dpU+OtXNrf4v/BO7kcDBgvZEkFSeJUImFpkkiQibx/M+GsM0o2p/K7jzGL7WxRSWCswFXAFEjXEvCzd4i7T7ju/z8cyZG/o+3PZ4G/KplsHaOMrjko7PpIob7GZCUptZvRhnBPs1+sPhbAH++z5/thnicIfLhrEZ/fl8d0OTcAeO+99+LVr341fuZnfgbvete7ULq4Xe9+97vPqys3vbBmLPBgxB2hkZv0v8DVin2XAIfDdwPTukoWpIIIkOZIxMBiTTc2l3jN1C0d4XMuNSkIbNAYGiLmqlW7hZfvW5qD5tDq+xQOn564RvDMiZGSTM52m5GvJgxXLe1WQUFCGiU4b5R8upqsabN2urc54ugl2R+2+igxQGOw+Zva+01NamreCEQbmyUDfzHgcJhHZy6oxkCjIsAujQSeRPKVi/TFvW4T0CMFJgAq3bB8vi5JQt3H8cBl1uDL6qgynJaa+k2Bpz9rDElgTmAqcbNZ6w6VmdpVx8eWus4k4M14lFnxgM4iAZRNTKJKXWtaO80iMh4mkabm2keEuW2Ynw4MR2mZ7f00scefTJsaGLrx8rUA0Mxuz+d2l+advB4wHWRMFwZMh6LedUDp80OItoIzqbuCP88k1L+LxO4BTMTuBdxI+Oyd7dZDp3sx6kBfltS/11Uibere2cUyA2D6exIwCNg+Ujo3oY0R6MtDMrULXsrC3AkRkYw38Ow7JZgNeL9DhhEAaipTwSgYwJIpyCNZ3lM7vr0N4GO+nBsA/OzP/mz8wR/8AV72spfhiU98oqhyHiOl9VyEE1O3M/Eb5UMFgNquTesqRRL1VT1wSg4EKtRjh2sD/kIO0NhudVboiBG6e9jofwCBLlkIbQNzIh/btZv6/wNIbLn65XpmB4D+ZunUpjFjOBV1ed5oGq1BJ92JPzV1RTWXq3uCtJERwF9/iMbx6N9uC9ep6iWsC4v0agCm3NbhY1agNq0g9loGLD23bgC/djipl/i0AmgikKrzato4PdzVjoy4VRGaKnNak9tJmlG8rI0Ggp6gaduiU4HZ/xkDUff8YlYHgs9xyUDKCli51kFcvTyjfV2yMDExIwqkTfcaVQmbZGqogEnC5aTq6btSVfpADfCZgb8d+8+YNoAcVAggFtvHvBEGROL8oTqszOZDgVwiBa4SmmY6zOoIYx1AdSrpq2CI128HWJeYnN5uLhFjpXEAOTEsH/CZJdCMNuRUmJuFtmqHu7711/rfeOH3+A7Ex3v6ghaYued/tn2Ndm68bpqtvY8rxn9M8i4vhdCp2pBgXoI2JdweT+3Lo62cGwD8hV/4BfzCL/wCPuIjPuK8mjy3QksveACB/jWAAFPdAWabVQ9LZojt2FAr60GTS3m0HbJQML00I3DCjf3ewgEXzrmmP80h0YM7oAVZiMCSlQgunA1c+zOT1i1JIewyCedeJvW6HSP4Jg/q7GCiGUsFGyWozRtVT9PYju9av4HvkoFUlNirdA+sThZruLo/SoHNzshAhR+wkwkKqjQitt16oxrwV1AVvHOZxWYurViBYuh3kj03QqQbQAV49e9ujVWKVwbrnwBFCWVksfdMChjANQsjk9QWjRNJpgyCBKceAmdgQ3VwvYAofM+wZhxhiMW/gqshuSrW1MwG/GbrHBmTJQAQ36GwBu4ws2UBfjHESzMQqkGprX8mCTTv5OgMo1Kj6lgyzyhU6+76p6ngfJ/FvdNVQLYP4o/xve6ZlSVgF+dlF/Bbqv+s37q9HiXR/kgvOCj1OoNa21c16SCTDEbmy+tDu97xejd/7sE+VYLWhDmy/hoT3bdzzuVhS2TD8/vy2C7nBgD/6l/9qzg+Pj6v5s61NDaAwIzQREl89CyMhNqkeBFIzQ4hhmfzACpxTgVV1agXZgFNI3CkhT5bidfPIuId2O2lnU4QzyB8Nh4A1aA6th1BqJZSSLwxJ/IwLH2Zqe+41tE4y1gKsKgO60DCkirQVakrxmT5fROArWRbqFIGBV9TOw/uUEAAD3CARpNIaQrVtZztCxKvYgefg2T5iCibWCRnTEDOhDJwBUE2hgyweTP6HNNMGiYVCsiVjB9yIW1RK1PbRU4a8iVKPE3iWMjnghc3XlzAcMDa3rJrCeBSD10a1alC1yTm3XXJuIF/fe9MclvBNLtEuAEDcQ52vM99cbASvZNjNTHbh40VtV2CpidcJR/H8hzN+1U7Md+3RT3nxQ4Qzfwu1U3hb5dM7wBxuzQCs75eR4lbowGXHH+s32M8QAL7Pt7FSHKsx+hLAH8UxtswX0arGABZDECa9cf7Htc11Tk611zAZ4H3631+Xx7T5dwA4Hd8x3fgK77iK/DqV78aT3va07BarZrrt91223l15eaXHUTAL8fDQ+8XWyB2ojJTqRF5mrAZkQ4AsgaDRkMkZ7ZA9pyDn8q9Ri57EQAEolj7Fy4vAK5IoJfUg1WtVNt1UGqgrA/RYe0xAYWaOTMwkHISwAIKxvNhjKZyjOB7oY2mn7HEtUxAWavkJQEpA5kIWUEgq4cmsYCtRoKY1FE0o0oWRrXNM9tBjZUXPbojwyAqTrEFLKa2DYbvJq2QYLZqIxbWzELj2Ikf1bWtKg1qO1hVoMwARgVXA1yC1ajOdA0dBK7JJYueA7t/d3YBDWNukp6mLJlHCPDgyZbmzePkJWrG4gxTzOahHteFuL4P3XtHqCDU502lizQRoFJoswHs8/q61MqAn/1m8eI6EOj94uS2hR7U3PoUgSFRC1YQ9tQOez0fpjFptPs+W5eGDuxap6Xn+kYXwFBvg2mPikmqAK6+zih18+rVfIJJnyUSxuAM0G51VvMLtCAYmDHfM9oZQOMsbSaFLp4nqNrbAO7LNco1WPGbV26//XZcvnwZz372s3HnnXficY97HB73uMfh9ttvx+Me97gbquvnf/7n8amf+ql48pOfDCLCj/7ojzbXmRmvfe1r8eQnPxlHR0d45jOfid/+7d9u7jk9PcUXf/EX4wlPeAIuXryIF77whfjjP/7jhzc4I7YLAKwSbLuHRZpiMduaAKT6OQmZIUKGiLRVu6gQDDpp0F87gBY5zMjtWsaD3hg+Sisi11/QHiRBctCMr+c2OwDZHBodSDyzmHduZmAoSEkcEzCRBzs2D0wBUewx6ZLmB268bws3ayXj76h9mIOlPvY2dTywhGoZwvwG9fziOA3garzAaQVMB8B0CIyH8r94rQYgbP1ykCDP1bAmFNKaVYmfz9GCxDTmrvbx2N7QfWHSsTLY2PQ3DZVhgaol1qDsFQtxZFlNGkcQPZCbgMVcP9Kxdm85qIpx9CzAc87iSavp3so6iw2ge/rWwzqNNWi1v1PbcPBfq4S5t3h8xnzQqLaolrHEspYYKATASbx+xbMggMClpuI+owpsPZSP2Qm600n7sfcXDBCx5NBOxTOBMK7vjPd16WjCNd/j/novjWtcj3fU42Cc5sBqBwi1AOVCGwPNXAgCbYGg8yYG3a/pGGuAadszavNrDn/ArB/nKuXbl315D8q5SQA/67M+C+v1Gj/4gz/4HjuBXLlyBR/xER+Bz/u8z8OLXvSi2fVv+qZvwrd8y7fgda97Hf7KX/kr+Lqv+zr8nb/zd/B7v/d7uPXWWwEAr3rVq/DjP/7j+KEf+iE8/vGPx5d92ZfhBS94Ad7ylrcg594d89pl0XFhdpMSvQTQCAwnQmwkYG4Htkyi58QSLQENoAaoHOmSDZPZC7aAT641qgmOhK31KO6lmCYN8Wv94a1qmGiXhvCM3dcT0V20kzNA64L1apRsBhM5sY7ZF6wOUbsySFWm0P64A80Q1LDdObTzIEK9v8G3Lm0AZnugH2+cg6W5sPWL4NtA/lTVXQ6qkqqEE1Vbw0SuOmwM+HlhnBH85TZEylnjN2A1ecBnPXg1hIv0VTbqFBxu2tA8cm8P0gAD1gm8YpTCSCHOn3e/V6cSFBTWBTIJm9iHtQ4tgDARPFpqNxbJcVjH2d52AE4VmFt96pxCRAAXBYLav5QAGoCVrlFOGhS72zC2Vp6ZhaskmKSuaG7h4L3IF1njMJf+Xol5QiZ2M4MlJu0sQLjIvO26v78n0Bx/fwJ9M8ce26NLDh4zTYu9t7uYUAQAPPH8+i4G1kB+iBUJEHgDDMcSC9N/N1pXzA7XhvUoAIFngfPrfX5fHtPl3ADgb/3Wb+E3fuM38EEf9EHvcV3Pf/7z8fznP3/xGjPjX/2rf4V//s//OT790z8dAPDv//2/xxOf+ET84A/+IL7wC78Qly9fxr/7d/8O/+E//Ad80id9EgDg9a9/PZ7ylKfgv/23/4bnPve5N9QfT50GO1i660oACXAgliaJqVYyYXO7HJAi/eMmPlyNARhil8V0ZlHS2B/aRgAWpFtR2jHzOI33LD1rdUYgQ4FwB0LdHOy8UF08vJdAoJ12mZGHgvUw4WQ7gDT7hjsK7LDfMoJsajWLqSfOAXAVZSy9/eZsDklvioe3Hxpy1jfhdGI/+nlrGg5DDnOSRrg0LRq5R/WT9zXURZNAAVnftrFGkkNwT9lpLZK9eDC7FDHkRC0r2bMxULXUp56+JpWeqmG+zU/JJOn8WMFtMNq3cXAmTAcAp4yUCTknpO0kuXZtzVUa6Q4Tag+YUgEnwgCgTLVdVwMDbnIgMQcJ2Gj2Ewk0KPaO/fvkzhkBBLs0nTQsDYAtQJgk6DPgYWqIWRxUSAPDK6ibmVBYsfVdeg9R+2LzUUOQoPkf+k6VUAk3m7yt85og0L8s3MDd/7vq6K434YeAmRStD1Q/cwbRPbAIehxUt3Rv1ifUveI2tmvNopPhmX7yaddGR/96VXBMDXeujhV7ALgv1yjnpgJ++tOfjre//e2PeDv33HMP3vnOd+I5z3mO/3ZwcIBP/MRPxC/+4i8CAN7ylrdgu9029zz5yU/G0572NL/nRguZ8fnitfBlB4GqBwr8oCL1NMzb8L8drB23ygP8AJc0VwHc2GFu9oKu3mjD17Qq60BMl4bFmAGl3mFjcR6MyDeHDu8mNnZYEkAax6wUcXyw1GiIEiQIII/5Wl2ytaqqO5ufmZSzlyBcx4Fm4ze1bhmsT/PDtG+jv2fpfpoYaSMhb4ZT1tA3QSU1VRuxCHx3HtYB/BHLfE0rwnRAKOs6J2YTZSoz2X9c1c/rVkXNWVXZqzr/Pne2x30t9HCcuFG5pSDltMDG5SBhOhIVL+fkoMtCqsQ9S9sJaVOQTybk4wnDlQnD1aLxCxUoxfFxUAufqjq4cLNXm3cgvncGWgkaUoXkfdO+eS5f+zADY1EQW6oEMNipgrt30tW+tndsDPK7OBrNw+U0ntiAp4Lz7qvY24FJtBVcGvdS2UXXzqAXMWOHSf2i/Z/R0d70ZEYjqII0o3O9B3rJ1Jpj+Njnn0WJZZRYx3k1unGtOYrM3r7sy6OwnJsE8Iu/+Ivxyle+Ev/kn/wTfNiHfdjMCeTDP/zDb0o773znOwEAT3ziE5vfn/jEJ+KP/uiP/J71ej2zPXziE5/ozy+V09NTnJ6e+vcHHngAQABLVoIEbMb5GRFU6UneMA7uE06TqeNQTX1ZWk/GGMOuquPati0dkadvi4Te7nO1nBLgQGjF6FlVY0uSxTDWKH00ZwezdwRq/b2ndEPYqdblY2ucQLQuJpSSques2baZbWDslx8CoU4bT1BJRtVUX5rfmgOyHqBVqoSQck1/iwdIXAM7HLoDZjbPYf94LD4isII3y8aBWCeJtIf0sPL4dz2w03AWjUQ0SI3M8D1NZhel11Jbp2WfYQYSWHCNtgFAQWONXZmCFFBiYjISw9XIcfwuASuyl3lIPoadkioFRQmyH1lBLlbSPiX11r5W6d/dpWv2bqkK2G3yEsl7OygIVDDYhq/RqmxdCquNmgBhAA04cgm5vSss4CmVonSFJbROtpvrGlEYBNveDePwOQXm+zHsQ1c/U/s7lp5bmjNbU2/TYjq2/fBHGqamxih1xsn6QQjvITXgi4lQUPfDzvWMoB6ytm4fyvDUnBZ0H4TlGKu9cJJIYiddx5a7qeVaAP56nt+Xx3Q5NwD4GZ/xGQCAz//8z/ffiAjMcqBN07Tr0YdVehtDa+escq17vvEbvxFf8zVfs6PBWFEgBnqtDzfASYz+qVgsO2q8Isug8d0GqsTJ7FIiZxokPohAtO8DcEMvNFMFS7MwCf24qfse2wtAyPtsIBH1wOf4vIPTPpwNeVSMxjaLOVRIXqFIAitYscOnpCgB5ACc2A+BCNx7ELh0QNmhyFkFHLm9Hr1dq4Qrji2Mq5tfGYc5/wTgqQbupppkoILtoY5/WouEr5EEh7BBvNC/KH1JU5U8SwWWOziETtFDs6hXMRVC1sDRgKh5pwAYk6ZyIwQP2u18/G4HV0TKBUAka6pe9ZzAZoahzhKRaTFgbp67ADxvcpznaaUS0JBzuZkT9zhX8O3S+BrcWvL96oNDRuP1a00pUGQNW+N1ThXQe6y5bn/A1PmB4fO6dZ4kFTH5dfjlVgro19EDrUC6dr3zEQT2Zen38A55gOR4OTiyzBxFEOe+2grCpmipj9aWThVnwpRsvcKYF/robQaVvwNXCk5e7bDiAOsn1HnudoF7L+B9uUY5NwB4zz33nEs7T3rSkwCIlO+uu+7y39/1rne5VPBJT3oSNpsN7rvvvkYK+K53vQsf//Efv7Pur/zKr8SXfumX+vcHHngAT3nKU9CkgsMyMXJApWDBba8GPdT9nvjedS/gDs7cwZDdc9Z7b9dd+lUBUxO7StVZEbg2NoELnG6tZ95mI4FK8LAeZ9GYGXiCJVEoErvNbK+gYGeVXIXubWrwYhuLq4LVaxcdkAZ2HCY8v2dx+ATA1FIL9bSqb9QDLzy/qN5fyw+sEiJMerAlmU+20C/MquLW7BerTt0dDydUEGrSDhAa6aCP1UCmA/pghxpU6dIGecaW2Xz6/SSe3WMFsybFsvvAEM/amGmnm0u3tUoV+LHmg65zSK72n1ZQcFjfuWaul9Ip+uKEd83MJ5zRSOKosrUbFPjl+S5xJw1XF2sXCgfP3nB/wHswtbraBst+o/YaL3yaDtD8t2uVSGtiuVGMYHsGoQ99HwP9seuLoaRKaD7U4ZJCXYaeHsR+9zbDs7FGENf1oZ+L3jkshsCa5R3el315FJRzA4BPfepTz6WdD/iAD8CTnvQkvPnNb8ZHfdRHAQA2mw1+7ud+Dv/iX/wLAMBf+2t/DavVCm9+85vxkpe8BADwjne8A7/1W7+Fb/qmb9pZ98HBAQ4ODma/kxl4a4kqhJ4TlENN7bb08IsqzxIC/85sV9R+JoYycePm0I4bvfcHWQR+qSWw7YFDrQ1bRywNaEapkY+tO3hnYNSkAz3hjXUZAS4qIY6giRhDLuADlvRZA4FXSVS9ZltGaA5xYkig4kEcC8paAGDJPAegZx1w/YHFVfoQpa0RVFD/TKh3Nn8LxeztrDKxFRPpmgFaTl1GFKjqe1VDs8zUUqnG9TMpH21tP7FLvGIcwqgmW+onJ93PbHtZVK29xDqGUTE7TkJlQGoGGZWslaBaDTHv3OM52AE286l9tdA4Eh7Hwre087LTEaMvMcTIWAEgDwkF4gUtHhc0D/gcpYEJKOsB0yoFCbW9HAvzmytgNak3sYxfPHrJbSyrQ1o7lkSdmUSYq8iUXlPw0+3jndf632LdBvAjffT9RbN7d65JB/zstyVm1usMTG10pnMgbs4iMbaqdaUDh7EdYMcS2m82x+dUzpKMXu/z+/LYLucGAAHg//7f/4v/8T/+B971rnehlPZNeMUrXnHd9Tz00EP4/d//ff9+zz334Dd/8zdxxx134P3f//3xqle9Ct/wDd+AD/zAD8QHfuAH4hu+4Rtw4cIFvPSlLwUAXLp0CS972cvwZV/2ZXj84x+PO+64A1/+5V+OD/uwD3Ov4BsqEXx1KgsrrqKlFrS5hC1V8OcSlSCBc7XcBMBUKEZESyuxsbAFRf6rB2/gghuC59K4yh03qs1dwCWOrZNYtKxwvY/jPSlenM+pEbDYfCLGkCfwUCTu20oNvYfkcfiaw7xYOBIFHSr9KwPXeYkdX6B6zU+s9/Hy9+simh1YofB37ApS/a046taDX+POmGRBnDTk/pJN9T2fj7gfpgQQSwDpbLET1SHDgA2GkPEg7BeaGCkReIKENlFJJetemFYkNqQTVbuqcACbRK4MhFTgElMC+z5kIqVQIjI2dTJSdRzgROINTO0+kjiFAoLHQ3VwUYeVpZBIEag3253bv81pRPIUo0ohBxkYT0mYNCot+EspABHdr+tUcxYbWFYPf7MBhIJcVlU3Mar6W+ei/o0qAbf+diAw2gJGUNI7gVwLA8a5vuESgJ1vZecs0ew17+oCPfF+RiDWgx5GJSIs829tIoLBeH+YE5+Xs4CxAdjYRdtHS+/eeZWedj+c5/flMV3ODQB+3/d9H/7hP/yHWK/XePzjH9/Y2hHRDQHAX/u1X8OznvUs/25q2c/5nM/B6173OvzTf/pPcXx8jC/6oi/Cfffdh4/92I/Fm970Jo8BCADf+q3fimEY8JKXvATHx8f423/7b+N1r3vdw4oBCKA6UkBBx9QSIlcBA3qKYJnL1fhkxCH6Qw/E7EAFRN3I9eC1viyqNsKzMZRIpL3W10XJV0cEG+lWqH9R6qf3RQmh9WVm92XA70xJA7V2esxNo+4NaJIRQvAa5DqHsb+Luvvd7TbXuFujbtxLpQe3zXM6HEI91IueKNzYMhFoBPIgKlWxLasBl5t9533lYBMph6HZojZ9ICxIY/qTrs5tCep3A6m8Daovw0QB3HsdicArAaReCoMSgYilj2ZIT1q3qv0tEHaUtIAAzoTxSINUHxgg7mIS2pS0+FF/DODQGC0LJOwqYAFmzJB3cUiyrobRVE3JGrja1MKSpSSBozMNCLQC0pYku8golZAF3+6lRwTPw+yq7zAWG8PSsjWSPxufTW/YlzP1fZijJUDUz9/sev+ORHoQ/l+iMzsl5gog+6wbDX0AXHPSMLqdDauDvwnVI53rPVXqjpnDUt/fZirUKW9vVrcvj6ayy9rlppdXv/rVePWrX43Lly/jD//wD3HPPff453//7/99Q3U985nPBDPPPq973esACKB87Wtfi3e84x04OTnBz/3cz+FpT3taU8fh4SG+7du+Dffeey+uXr2KH//xH8dTnvKUhze4SJgigYugzLhNxZek6b4AVCkNa3xAC/uyYaTTEKFe48DZgemSnhUwHpBmZRC1X1lb5ga0DihYJlDXVXruup+DnnhT9+mrWzpAwny5lzPVi4UJ45QlDMwWyJtS052N1enA7f1MCparZDWC4xmXfub4q/G54UWayEEBjfDMAUt7IRqURxXy7N6FOXKQNWhsMl3vaa3/H2hYloHag7JfAwNbMWTGUFWyHqZF1aVeD4CqZoTbVjbhddbAdMAYj4DtBWA8AsqaHOTXMETwMESA1DUdEsaLGdtbMsYLCdM6SfiXdRJV/0FGOcjgdZJQMAr+psOE8WLG5taM09syNrdlbG+V75tbEzYXCeORhaxpPcJ37s8OjAAQSWsIoZQ2XIMLAw7qzB5QwtUkYJAUdQ7+bD0V/LXhikxKnaoalyGxA7nrSwiwTuYlDQEaFH8PewgAppIESHJNy7e0HxuA3oPAXfMX3tnFubV2Svgs7P1d6vhobtEzEL6vzQkoArbAHMQsNRb6J58y8gljONbPSchiE5gXz9i0MSCJZp2ccSU09HZJVfxYLNfK0PW5n/u5IA2Ubp9nPOMZzT3/9t/+Wzzzmc/EbbfdBiLC/fffP2vnvvvuw913341Lly7h0qVLuPvuuxfv25drl3OTAF69ehWf+ZmfiZTODXOeX2G0xuuBo4xhV0zqkrbA6liM9bdrtcViCNevwDBNtfJop+JgxozuLbXWAldsfYNJCfy7ahdTvdc4f6CVACwR8F4qsFM9EsQFUaU5O2SiWKGpl9tDWP+eSgJtCGnDHoaBCrl9JEDVntJAcJ/fNh5ai32f/9iANT3AYlopPxQGPTfS/Nk+oHIfq3EXCCS06+V90PsLR3AlFUVzgt6xoQJtqcwD32YgNSdw2w+zoZtMla72lNMhoxxAcyMz0obAV6XjA1MjFW9iEGYFsCt4Xl5J3wUH9FQYHP6mSd6Jskoi4TsSh5dmjKGvs7XvGCIHUmcxRnpPGuGpBq0fBv5EyJNAbEFH6jaScEUK0lJVT1cHneojWkYJy5MmCartjiLWf5jqv9IcTgkieW2znth1cuZJ1NTOgC5J5OL72L3z15JgkUnLQhUtE1Qbi45zdt1zoAPN3lsUlS8CLa3HuV29j6natoaA0NEWsNHYOCCvjFDaMvIpQBuAicGrIAmM80b2XsGBeh3zGZN3k4uR0Pfk+Rsp18rQBQDPe97z8H3f933+fb1eN9evXr2K5z3veXje856Hr/zKr1ys46UvfSn++I//GG984xsBAF/wBV+Au+++Gz/+4z9+gz3el3MDgC972cvwn/7Tf8JXfMVXnFeT792yIFkwImOH9PYI2N4i1DKNQILGqwr2fh4s1ZwBjOiFBOdLh3tj0xMAnhmQc6EZqDApZORkm76jXrff/P+OWPs9YS68LbNlXJB6Re65VyMTSRqraUpIG9KcnHCOnxiYOcTsqGtWen390qUOuKZJ1K9Jc4lCbdkKIJ7OHA4WBX9po59JssAYgHJp23IXmr77WkRAYynhCLDsFjyyOMX0gN3q9/0hNmYlE1KGqtNj/eQgWpxLFPQdiLR5OgSmI8Z0SwEdTqBcMG4zpisZxeLggWosQQW/pkoTKWZVIbtUdUsa1oSC3V0FDdM6eYibsq6SHge8Afgu2kGiXc8ZyOilTVwBqIWkQcwEkoDCSYMyV7Bn8TwNsPEqYTrImA5SY4/LBPEfWSlAHJLY7AVAEfvm+8GkuV24mThWInEAmUoCT4Rk4yrtGK8H4O0yEenBRm9b6XOyMJYqzevGG8FgCMVj9VDQEhh9WgSLsa/hehxzwxQmuBOVZbrJGxLmRLUxlbmShSO08xfjA75XVL+N+uRhPn8D5awMXVYODg48UsdSedWrXgUA+Nmf/dnF67/7u7+LN77xjfjlX/5lfOzHfiwA4Hu+53vwcR/3cfi93/u9m5Jp7P+lcm4A8Bu/8Rvxghe8AG984xsXA0F/y7d8y3l15eYXqiDED4kFztq4Ywu4S0XAgD0nUjKx5bJcsEY4heuXA4LMyzACKwr1III1nhNEBgjsAWFnHHAVLDQqUq5DrAdGuF4fCP83ICVMWQxc3AMUo/06XvuSEtdMIDY/CIeFe41SBdB2AJ5xMJBJDMIJtqT+mkkA7eDUZPHEasc11PmyOuy+tJWMHmkLcGJMowAp1j3hh1BnI7rkn+K/ETwA9eQBsrXdEUhJctzGdWrWQwGZ2/EFEU5Uo1UVpQCuUYHf9hZGuXXC6pYNDo82yMQYS8Lx4RqbvIZxK/lY9nbaShtMIqWcVsE+jwQ8c2aUlYBBmsTBJW0JKXdOPQOplJeqjWcAgH2ZqRf7z67r8fkd+5ZJgHIaSPqo+1GeIZUYkYC/Q3IA3PQvEUpmTGtxJsmb4rEGYxiSGv4I1bwhMIWAgcId5ziHydgBfpv9slBFJQbd8xEQOtO0A/zF+5oqozNQDySNFlUaFsFfDC7f2vspbU2hTZuf5n9yp7yGsXS1b+3oWXTFp+O9Af5uYrGEB1Z2RcO4nvKzP/uzuPPOO3H77bfjEz/xE/H1X//1uPPOO6/7+V/6pV/CpUuXHPwBwDOe8QxcunQJv/iLv7gHgDdYzg0AfsM3fAN+6qd+yheodwJ5Xy6NAwi34M+Il6smgs3VcCJBW53LzEp4VirNyTD3z8ZzscmbqfXPwJWrQ2M/gZ5QR8Pv2YHXCxN2HYYL9/aST3++74sSb3fUiAcWBxURCZBJJCCQ0d7bgC31/E2TTFAhzIK62r2xuway/Vp33fvbheCxnM3EEEcFHXxjv2T3btnTqsnvIt2SsDRBZav/04L61uvsxiF2cYwpOHSYlJTU8cWlG5nEacEkKHo4Wo5fz9AQQWCw+RsPgfEWxvbWAr51xOEtG9x64QSHw4icCqaSsB5GXGbCdpuQRqk3bUVqOpwweCv72FWg3heZ8TrHDB4IWQ9eG5t7EoeUYA0A7BmbsE9IQXzjkR/3cA9ibBMEpxgCPONICYDJJHISGFrBW04og9ozrqvKegkcCJgnZWTE1nUx3EiT+qz2qwH4Rh84BIHWl2dmSzfrSNxs177ekI0Zs7IE/Lh9KPzdpodDByLbPvTp4hoNRaw/AaV3iEK4dwEsk9n2KjMFChJ7A4ExNWccm09G6Os1wOJNLdcBTq/5PDCzjX/Na16D1772tTdc3fOf/3y8+MUvxlOf+lTcc889+Oqv/mo8+9nPxlve8pbrBpTvfOc7FwHjnXfeeWYWr31ZLucGAL/lW74F3/u934vP/dzPPa8mz69wC7aYZu89ALjEqmSRemRLWbVViQazc/Nl0KwXgeO1EtVR5kgS6WsfcDQeEE2nIhdr4+g59XiIRpDYHEShzr6/wRYyAsbmuWCr1BQy+0cGEiOlgkyMnAumaDenh2E9nKtkoxrJox74RQcepEQWpm0G+hB+a+aKqio7BElu4ubFZ0JfqnchI7MAyLJVABYT0SvYMqA2W4Pm8NPmLBUdyD1VzewgevTSijGtqZnDYqFYyOYIDZgw5mU6BMaLjO1tBXT7BrfceoLbDk9xcbXBKovxamFCTgXbKePBk4ztZiVjmATQcCYMx6oSjnsiHsQKDmF2rogbq0r/eJhL/5Y8fJsS1qMJcN7dE4EF+1yQ7DeNvUiTeCtXZ5e6iVxyl8RmsYI/8vfKTS+8v5r5pZB7BMcUaAAWYx+axHtJ7c1MmJgwTQlQqWq0AZwBk/77dQBAX0d09dHC/UvFGcAFWtWDw/iY2Tv2bTJESmhzZ4A7Au+FvWftJXu3jXmk4FBir0d0BOrHGfrahwU7l3KTAODb3/523Hbbbf7zw5X+WTYwAHja056Gpz/96XjqU5+Kn/zJn8Snf/qnX3c9SwKj68n0tS/zcm4A8ODgAJ/wCZ9wXs2da4mgqTdqnt+McKjGYLcKBFQthqzCv0BUTGqBcHDFMAXSh44D7j67VGBLyda93dj+DqK/eJB0xvazQLPhsIpjMKlklGZ4laoKbuy8LOl7kKD1fTNbsjJB7PPq0SAHN6EC0ViMkQ8g0MYZHQcshqPZCzXShyXAZiChMIhFYhfHWzJhWjMmDWHSS6RcctWkaNMq/a0mB5uyL+phRbpRJgUngM4jWELLdY4qZaWexgcK/i4J+LvttmPccfEqLq42OMxbWR+IynmdJkwlYXPrgNOJwEMW+ylVARMTcMLN+rhjDMK6E2ocRLAHRbY0dzHTSXT2iHPSv4uNNNj2ZPeute9HAPnqtZ8KI20LYoBqz1oSpe+DhHyxeH+wVGYFLgmvu1G7QGZvSWoT2YUQ0RA5DHaGxuiJm4egvmulEDbjgO02CwDs9m+kG4s2a+H9XJrPdnLruJaYxms9HzN5xN+kn2eAw+spEQgGmtg7WFFRW167JzJyce9YN3paiLa+Rfr5PlJuu+22BgDerHLXXXfhqU99Kt72trdd9zNPetKT8Kd/+qez3//sz/7MM33ty/WXcwOAr3zlK/Ft3/Zt+Df/5t+cV5PnWlwFU6hVRQTJTE8gTJ1bVbvw57hAJD8dV1qJtKKk0hJslwCEQ23RMByBJoe6ZwchUIGRPRCJaPc80NWx0O5ZKie3K7T7F+ohlQhaVoWSJdyI2VQJINS5DeDT7HiqxKc/dsN4dvxGhkw7It8E8KY6l1HNRk0d2hdbAAPhsD0hgMjrHsIhHQCgOEdoF6OjUFbP4FJP9mg36ZJnZrVJ1bYyoRDXGMZZnT0OBfxNR4zxYgEubXHLrSe44+JVXFof4zCPOMgjhhAcba0d25aEewthSwfgY9FrTwZeJ9LctwKeimW8GLq9ryCQE4HWOmULat/mIG82zcK6RqaoZ7R8T3OrLg6SJgFbDNLAzASApgLaqgu/BXzOye+nQB9szWpsQm77ouvBgwR1l37UtcTEvtZABUbGEJACQXsHximhaAilpYwUM3MK64b1dWle+xL7HoFS2P/eHjQ/bgP0dLmXAunbH0bTnBZpYwvr2wDGuP8DDbPUlA7G+772wI7rHKOnmTaGJboVQvOcRzlTvX+dzz+S5d5778Xb3/72JmXrtcrHfdzH4fLly/jVX/1VfMzHfAwA4Fd+5Vdw+fLlM9O47styOTcA+Ku/+qv46Z/+afzET/wEPvRDP3TmBPJf/st/Oa+u3PRSk7HrD4EDdvWjHSL2TJDw9UbIKHAv0shp9uo+EEQC1hMrJ25UfwMc0C2+14ZpFojmDJwscPK7VEjeHrVEseemHfjp92ifvquYNIbY1KUxyG8Af4wqLZsgu95AFGuA3c5QbJH4xYOqCxti4WcS6TbIqEGPXVpXDylLBeiTFAqhSjjzRtSBpbOJIrXxtDA0lrYNUIcKqodcDLsS+y/AS9SBPLCoJjXMEMwpZVDgd8gKAAv44oSjCxtcOjrBratTXBi2OEgGAE0FnJCooKwSTg4GnF4YcHnMKNMKRcdeVoQywiVcmIBcRCoZGRkDE5x0XjtGY87wzJduBj703bF1jcAaYX7r3wK280ZiAKYtAxM3UlWoSYd5q3I2oD15xo6ktp8eEmZIVcKqAa1LkIAWdShJBS71AyABoJ0OEBqaMxnYtM0m/09MKJNOUEdbfF6iBPWsl28XoD6jNO+/NyEMigMzBftL0kIy+kUyppr7Gc7G9dEPemDmZht6fUkt3Ev4mr1hz2VSes6zeVyij/77tQD0zSwL63vDz99AOStD1x133IHXvva1eNGLXoS77roLf/iHf4iv+qqvwhOe8AR82qd9mj/zzne+E+985zu9nre+9a249dZb8f7v//6444478MEf/MF43vOeh5e//OX47u/+bgASBuYFL3jB3gHkYZRzA4C33377Den539eKHRbOkQJCsF3iAlGNqd3SlMm9QT1vrxGIxNX5IxLGcFAxqV2UBZbuVSRK52fqCkZNgwS0L7mBv7NKBGuhnkVaEUGgVauHFAN6qAWuHKHe2iUl3IRSEsaSUEpqQbH1vXOS8WpYmx3ZPYSbw4GAxogyzLNf78bUgkELb8JglWqZJA5cAx+nbQjmbVIERo3l6PXBTQLSqKrRSeYu2n/2NoWcQu7e7uBz0BQPOn02TcBUxCt3MhtUs0NcAWXN6qjE4DUjH0w4OtjgwmqDww78rfR0nUiA0EEaccvqFA+tD3B8MOJkk8EjgbcaTsaCZxd4iJg0sXrD1zWNa+FLENclMlD9ei1tzgAe+4DIBv5i+kUPHnxSkE8L0ra4/R9KCVJyVjCRwBbzdGKkky1oO4FzcskhLGj0SlLC0TphOqzvNpOAeSriONM4dSUSCWAckr1HBlwj+GB5f1CWpX8+Jwtllw0lgJ3SrqV7Yzuu7QjvYsPgxvVES8dqnECR38f97gxPxyS0IL+123P76B7Uhj6IHa0yLhqInQpq/uzu/VqMCqHXH6vlrAxd3/md34m3vvWt+P7v/37cf//9uOuuu/CsZz0LP/zDP9xk6Pqu7/oufM3XfI1//1t/628BkExi5j/wAz/wA3jFK16B5zznOQCAF77whfj2b//2R3p4j8lyrqngHqulUel0QEKuw8EhkhjR0wikB4SobC8IVcgbDs8JZXXHhJ6IRrWxtNISY3vOvFNjaIQbYUO7dsliCEa1yQKgbNRG9kffN3TgZNdBowBwmhImpkbiKeCgDXeRwsHoxNiIv3rtFuuH/XctbtcOmF2gWoECG3iYrC+y1tnVnPAMGF612W2FfhArYBzUaYK4yczRBLQN0gkDLVECbZ+Sq6exg5yp9lWkTapq1ZAv5rHuYUYSI+UJ62HCOk9YpxFDmhz8JV/MghFZcjengqPVFuvViM1qQBkSykrandzZhMBbSDgdnSOaKjBuDs6wFs2ewnwPLa0tdWvXAj+4YX/13JY4j/mEBfxtJr2HAdaUbfYdSgMGAgbt9FhA+hHRpjzHOSMVC/mkz2qWE3NyivtaJNmqJrYMFEXqd1VAmA+3Q2VvsrFl6yfquiRU3fttf/vXHXQgmpdweO/s/TXx3uK7qK9vtMMlHYut28z2E117BHgqwq5/4vFuHerAXMgmlIlwcFX253Sg78RISMzwvJ3K0PXSZQ8hcwOk9z0uu5ifG3n+Bopl6NpVfuqnfuqadbz2ta+9pofxHXfcgde//vU31rl9WSznBgAf0yVIJ+z7otcX2SEMZM01mbcCApswLgrcgBqKY0bYaU70miY7CUB9ltAfmnK7OaSwS9CkL20ljYctcCYItHuceDM8n+lO+5IlIrmo00P1yIRJvvRQRAU1yJDDNqbImlQiGKUOpfaxUQ2F9prDRMFkE3gadiDL+oo0S0O/jNwchl6nzdPYTYi2kUbNPlCqatDa6T2KRbpZ4+S5hC8GLU6y/yjVvtsBmkaIetbiKNrBTtrpxEBm5MxYpYJ1GsUrmyQ8T+oWNSkqTWCs0oSD1YirmVESe5w/mW8NEZOBfKo2gSoB5QkV+Mb5XwJ8s32DWWkk6QEcN/aUxjRNVe07HDPyyYS0LUhjUXU+a5o2BpXiLyCRmhW4d5Gsj73TNUSITDwXkSwlKsgeq65dbwCqUeAq/VPgKGCoeCq/+p7XSWL9mHlDYx92PeCvoW3d3C49Z2CoCsJm7ThdiPTsLLqQMH/XjFHuaF/oQlu/XWlQazeGUH8ME2TByKH00Z3QwlTPGEWrL4zzvMqj3QZwX9775REFgM973vPw6le/+prGmQ8++CC+4zu+A7fccgv+8T/+x49klx6ZEomjgrboEexEUIlC2kJUCZmQuWB1RVQK7r3pnD+1wV2vddh1xLlRAZlaesfBKYcIVfDaEcclu0CvjkN9kbh3/dsZbmOpxPrMiYEsDuAcCFROvh3nrNpgA5SMuI8BSGkf+1AiIFRjfRNYFAFuNNn1dqyWUN7iBPbjM8nkLH5ZBNSsuaEtx3EYl6w1V7CWuLmhkVTaIWiSvIKqLtbFFLtAedBAJCdIYOvBUC8kHE8q7vEbi4HAEvqRiLFOIjHMw4QxDVWCPQBTFU0r6COZ15GRTBU8tGu+U1q8CwRGpsTAX1gnse1TSW0AhpL+S9W+G5Xk9WpfInBKLbNUABqL0IESAGOjIWBgLM6MJMiaJHNmcuZP5j6qMKXemhPYGByjG+j3CeT9qW1T82djFhLnspu/BkDHS7vea+qud0CySv/J750xz3ZfX5f1J4TDatq1TCH2m6tnAeoduUJ9JsUHAJoYWd/ffCrPTuvQ9tLYEOeJ22t7ULUvj6LyiALAF7/4xXjJS16CW2+9FS984Qvx9Kc/HU9+8pNxeHiI++67D7/zO7+DX/iFX8Ab3vAGvOAFL8A3f/M3P5LdeUTLzObEihKvGGpAVEpymFr+0yhFdAnfQg7bWGcEfWd6l0XQt4NQ+9nZEfjmQKFwY0/IFjjwuSSvEvL+voZbDv32ryQBoKl+9cMwbW0CEooGPO4NsS1GWkoaRoRF4pVPzTYvHPxcAWCVtkqGht6b2+bdVaZE7uCR3bZsTvWZCMhBMjlBDjI76KjGE3S1ZMz9GgOpN2nH6l6LIVyYUJ08tN4yqCNpsZh0LOmuRrH7A1NVg63Y90YpSZgFLT0IjCVRwSpNoiZONllUx5nEsaFkBmmaOZrQqPeavb0L2C/tH/3uAMikvL3kT3O8DsesAJB9z6RtkWwco3j71gOdqnTZkjhSahg/qEQdBhj1NwOBwohMci0l3XeEvCFRBQf6YDaB9o565mDV/hKro5DNh0oL54xHh9x8f3e3dXN5LWlQND+JKt5FKVsPhvp3vrfHBbfSwtBG07dIQ6HPMTUq4qUYiU2f7Z0O2YTcxjYDo8bmJIaESgo2yE29O+brXKVq76nO+Vz11fvy3iiPKAB82ctehrvvvhv/+T//Z/zwD/8wvud7vgf3338/AICI8CEf8iF47nOfi7e85S3v2x48ESxF419GS5RC8NdGfWjqLj2wkUI9uwhePBx7Ih/VlwFQ9hK8RVsge8Zu7foRx9sDrZ2hJRY4ZHRtNwS4B5A9sWYAhdy+jjQ/J1BAQ8iOENbBDbHJcuaSqPZOGHljAMuAoFwvDpjEQSIZoMoBnLGq9TUmHRIk1yrVxPOmpm6mz/K2kgxUVLXqJVrk8CKGh2ghroc5JwUAdlgZmFqhCUcjEmXy1INuy6cSpbKyuutBZ+piYk3VZgdegdjkjYRSSJxxdIFKt0Bl4eAoTDidMsYxA6PEtrO1ZUAkNYPipAPt19St/RnvQju582s7wd8o6z+cMIaTgnxaKyCN80fq8GGSNqgEtR7mLA4fWcO+aGgYGhnuFIIsauKpAFwcCFJRNXESkCMewzZG22Syp8sqiTSxcQaZTbWAzqC6lCq4ET72wsBmxTrmEv21h1EacwL93x0sCHVMNsfNfSLtbJqOQNEk6KF/1p555/ulXqMSGe4OBJp2ACAkcMOImxYhBgnfPXhUAHuuAPA9bO88+7ov75XyiNsArtdrvPSlL8VLX/pSAMDly5dxfHyMxz/+8bNQMO+rpUr4jCChvjyqgojeZH4YmaSmJ0gRwHRtyBfMQFH8fSnQ6ZLqpQmZ4NfYf3OJUmqb2DUHPvauS2zzQO3vS/cvlu4e4+ot3IYTe/W09jkNQK1K62wi1bbrlGvYDAOTkywgFZL4gjlMXwJoJdK05vAIwCsBApz08OGMcLrYXqmTYB6w+VS6lzZm1wWXXsxTpamDiR6cZv9l+Utt3cqq9jsyJ/I3V69JEtBXpV+MNGoaMg84LeOYJvHG3pQBW04YmDCWDCQgq5HnljOKdnRbMq6Oazx0coDpygrpJCkwRjcn7NJKCaGifV8K8hwZmB6odCAwevlG9a7P+4aRTxnDsXj3AnBJHm1LddpxACqoxZw/AACDePKCCIQC2rDHA3RvYNm8oHFyACigJGlfWRxGiDA4wEw1uLjGBEQMH6TvgI3VbGzTxCjRBIVQVcDXAAY7NMVVArdw/SwAFG1f4/2mniWuIM/nweip7VdqYwY20Q4MYZV63WhcDwJt3mZmJMGez+aoagRiu9p2T+8W6WyYf5w55Y9I2dsA7su1yrk7gVy6dAmXLl0672Yf0VI5R24IAxthifcEiR2nACSC119zuE1KPJRANVKQcID6s530L/ZnJjkMB8FiJpAO/Fm7M1p/FqFQzpwLmry25oDhElFermYn4QwH+1zdK9KOojWwShh6o26L6Wa2g5KNgt0hw6c3qE0NVCaqaftc/avgq+JMckeHaNfUp+WL6QD9sFTplwe3NhCoEkhAJXYDAZpCcFrX8CF2YM5U+HGq7FAN7cb1SA6IDXCL5K5sE65uVriyXnuw55KmRhI4MaFwwsgJV8cV7j85wtWHDkDHCWkTTslgi+V72mJkRucP2//tUu9W/aIFf1FaXsGf2v1tUEO7mLTPY3sGxygA5sUrUjZRCXMW6RyvkkjzNwzajKCTjTwzZH/OVMGck6EywKSHVrcGlhabsyDR1rVPJs3umTfd92YX52YEWdIohoVv6cESeO5fcq7vrLdNFdTF93cXGO+Lg0ClERHMc3zW3h+O7YWQR3avvvSSSWTef2diYllgyMDmvc/6DsAl/Q3Q6xuxdw0dPSWfrgXiuS/78t4rey/gm1F2vNSRUAKYEwxWTj23YUzEbgg1ULC2UTMGhCpS+D8SMiOmWDgEryEBiFLIRdVvN8Zd3H8UOBBQMwNEKYDdV+oZ2dRtN54hYmgOn6gmZUiOSATPR3f4ENtBUbmyeFYaALSQHEwaikRTzQ3VUcfa5Cyq3+kQfk1S+sHfLgEi1M5fHE6merjaWoV1jeBvWtUYg8ViuuncRLU0XPoQGurAEjGrGhTVDjKsmYPsIv2niUFbQjnJuDoc4t3EKEwY1xkXhg2GNCGH039bMk6mAe8+uYjLV45QrqyQT5MDf7CuS5wTkrUwRsj3iqNx2XDNMxz+R913M6nfVMeTJnZb3HxaXPXvoGg0N3KtM0ElTarenYqGZFF7PQ3fQlMRkGf/Q/acX0MAfykBOannLqkUSjOHaERxGgvSaOCexBNbvYCX0qNZCBuTopYVwIPkz9abW8nQWbSgAzmL6uAFoNjcv2vPx0ecmVXuySWaEuevz6xkNrred2NWoTQExvzMG4x5g8+y227GSwAKkLcqZFTTCGeqIn1fGmNo51zN6q5F56/n+X15TJc9ALwZRV/8yP1F6UOU3nkoA6h355ZRLhCmI9Kgr3DbJM9cAX02swboDUCQ0PztBCiAwMj9NgGrw8EhEfnDmIyoRklVIMLep9henA+0zzHgXsAzez+uxH72fLjH4gDG/lXVDzX9QmjD5QFcD4AKAINNlR4+LmWYtEeZgFXClLPPdxkkN+54RNjeAowXNPPDCGBDLkCKqlwHVP18mXBoBZQtIaXWeN/6UzI1kkbfSwXuaWxqQFObNqm2OumFef3mjYQjIk0tFhPe+/oaiBoBOk2YaMADfITNmHF8tMLF9QYXVxsMGguwMOFkWuGhzQHefeUCTh48QDpOHuwZhIYZmakdg3TJJqEuvQED7C5xbxn4m8L6q+p3OGV1BFJwlhRcsjAEsYgTCETyZ169mRSwad2TxgXsPH7lvWO49DClZrvyAICy2gCrqhfhnQU5IwAER5UgnYzvKmfJLDKtAawKhlQwWQD162ECd5T+/Z9dC/Mff+uBz5L6ngnqWBPeZW7v9zaK/UizfkTaNrNR7pgCY5Jjce/0teb2JnlP1g/KXgETJqgGwEWuXfsGXN+bheddu9Hn9+WxXfYA8CYUs2FxFZXGgHOgZfY7JtXRf/KmBhXd3Cr3iU0SACbkkPfTVcNG+Mx+iBbAn9Yfbf3sIHEJGdByyT0g6cEgh/9jG8DcXhGB2MYqIihF+Dty8qHP/nsBaCSMY8ZmzOKBqn0k1sDPiUNqvXogCpggP3jTtgJAMqnPyO1hb/EEGTAD84yiNlhJDtYVsL2g4O9WxnQoACWfilQu6RhsjaBzspQJgABX75WB3T7PLhrwE2lOqMOAvf5vEjyT/jQ2qTDgiupbYPZvG1V1qVqNqAUvNhek6yDCqYRSVri6yTg9XeHBgy0OViPWwwQixlQStmPG1ZM1Ng+tkR4ckI/Fw3iXxMXWDFTH4b/1cxb3TV/s4ItqX03FF+3+hhPN7KHx/WSOyPeMBDvXd9AAn6V760O6mFR5M4rtXyl+3eNTFohkEACyAkEqYM51OjLVIRXIWvRqS4sHqL9TqoCYM4GLxhFcEcoBQKsCUlAOVecbs7ATIOz4vTcBWZRoBfBtpXn/O6ayZ1A4/L5kp2z1CZ1tEVyfCanRiJA1Epg8dG3oc2UgjIcStJ8HgLYKAjWbDw9AMQJIXdsKzH18YZ72dnX78mgqewB4kwoxN6Ex5EcjQm3+XCNubm/V2abYAT5BpEHxd8T6okTH6g+c8ox4ohIiq6eXyLU3t5jPVTU9gbf7Zqx0Nw+hn5Gjp6DyaeJzhXZoIpQxYTtlTBNVLn7UEB0k4URYJTHm3cph3qrUq8Ckgc3hamAxzoUd8pOoCgEBZOORpPQra2BaM1jDpLB6GYuXr9QZgd/MLADQXMRwld10QFWFrYdRWamE0FRP2v8Igj3bCHPtRxhb0TArZZC+SYq61pmkMhlo906RNaDEwEgQbETASJg2CVeHAVezeppqx7kQsElIxwn5RMKbgHUPlTb4+c592hWyBY17I+zFRqrs0nSoUwvc03o4YQxXC1ZXR6TTybN0sNpXeqw/G3tMpWF7JjFAGWksmgKwIJ2MwHZ0da/vpyABlDoD+ipFgBkApAIaCoCkc1D3I9v6KLitdcm6sEotvdoMlBUjZUYpCZvNANqKA04jCbyeQnXbLj4St9oOcK6RmpaiIs1oGQN1nnWTG7M5qzPUYTYFVZKLllYCAEmmFVP592Yxbfgl1Hc4V4/6xu4xMJ0O/vqxvzeA38Ia3PDz+/KYLucGAD/3cz8Xn//5n++5/R5zpT/YqRIHIQjUcLacNZ8kM1ZXGbi3HvxeZQYmiwO2dCAGyZL1YRfxNfVRq1ZrwZ/3L/zvv0WOOrRxLcLWB2e+pg1MB/5MfUoTUCbNZ2p2TGrLRVMBZfMiVHCzZdESJZOU6tFl9kQlSHKAaocFA4Y2EfIsMYCxiIYqE6YDwnhMyAdAOSB4VJMJSFMAsTpnrv5GC5ajnZEERRbglsaas9VDuKhDSJW8Bs9JnaO8KdULxQ8+AY0pMyZOCpAN/LXxBZfMABpJ8lQvJmYN2kxgSs7MIOwXkbhRtWe1QzqsN/mkLG+Jaq9GrWQoSLL6vV9j/GlwZwV/easev1cnDFcnpNMRaRMkdil45MZgzwA824fNl9nybUWaR9tJwJ95+dpzphKeQmUGBt3ZRO0FtxOICDiQ+uOUOLPU/Ejq+GV7t4J5DysFYDNmbE8G0CnJevSAbTbpu9ejuc3oBMV1QgVC/hM116rUDA7UZkxkoFORnjZ9DjSo2UZdX2IQaH9+FyOhbZgDCAguYS9ro6U213BTi8bmMAx3iek7l7IHgPtyjXJuAPDBBx/Ec57zHDzlKU/B533e5+FzPudz8Bf+wl84r+bPtZhdSAPGTCNkxCoD46HYkKRRJBI0VSlPDAK9FP7CwIFLA1A52UZ9Fp1GlIg24CMQiYaA6/0NYAzXjHD3arpFABrAXOyHP0+dvcw1CA8HACgq3AJKBDJnCpY6JcWexPCCgRPrApsdlQ2eVDIFgBkp2HGZrQ8RgImRNgWrq+YkIydLOoLaAJIniLf57w/Ypfn03wdgSiJdRHOYB0chlwCGg1dBbT3ItO+pHsSyP4rE4NM6kuYCtswTdkhaykIODhk0AYlIVF/aYXNWMTAmNn4aa1FtFd02UcFfjNG4q7T2ZFUKFr14HehFo357P0KA53xa1dx5U5BORe2bTyfJo2s2fWAgKyizWHrcHewG/pJk/3CmYSxACO8i/TYQ2e0zu6aAkMxbtxRglO+upleQ76FoCrDLtqw6Swia4sE8VxnjmMGnGXlLzXydCU66fdpLWptbS3vvUt/cbjNg2JkmobR7PDIxQTle9yS6vcQGKINaPIxnJg2MJe4fZTCSBnsW84jqlS8MRqXx1+vcsWQCsi/78t4q5wYAf+RHfgT33nsvXv/61+N1r3sdXvOa1+CTPumT8LKXvQx/9+/+3cdMTMDGjm0BPNUsAaiSHVPFDgH8Ra/eCOIWAN9M2hfAX7SHmRG+YAcUpYitTU0Y2gJhb5xAFg6HNmMFGuI/kzYt1a19ZgIoSTgLUqpOhd32iib2MBimxkORA99SroljTT9Z2nyMIebqUDm4iQlEhDKI/ipNjHxcsGaL30fYXiSXDsRDtTmrl87tCKDDc0WlDmSH0MSS8WqlzgD6LPVr6vNGvvYI65vU85dz2D9QcGyqW63b9o8DhQJgguW9kNsd+JHGUdQ+ZFJ7RU0rZ1OaCGaD1cxJmBuXzgDtfT3gK+3H7rEQHvkUWB1LfL98KoxCmiS2n0n9LGhyXGuOUsBmrUikcikBQwKvMjhrPMCxBsERyax9YbUptcXiCggNBBKBoN7AzKBpAk6hTCMhbZOaFVTzhV3ZZTwVpYYFKmtxAGEGLLuFB7EOtKTZh3HIdl+/Pt7o/O+d+cMjEzvrfVt/j//Nu7evxyT6tk/jPgEJCEyQfQoPsl/H3Nijhr1mIK8oA2PmPVE9XPuwMIj+t12g8xEsZ9p4Xufz+/LYLudqA/j4xz8er3zlK/HKV74Sv/Ebv4Hv/d7vxd13341bbrkFn/3Zn40v+qIvwgd+4AeeZ5duSmmISODQTZridkXRzorhBvwWsNeCDjeEUul9oybriU4k3j0hPwPMzQ7PHeNasl+MTTcqZf2fFvpnY7oW8FvqA5IAwEws9k5kwFnndioifcvZJVnEkHA6quo1jt0OfQGVFIzqizuAyLVUD2ptAynLmb6VgzptGPk0YXWVsD0S1fBS3tqdYDxKLqypAMrSBKRNAM/GHCgIlPAwktWjTOTPxbk1SSfFxZlqeA2/d1QHEK5SjnigMgGWKzmBwEXN4CyMzNYxpDisFAUlQQIoeX0J3Eh855tgCSA2B3y/f8Pfaayp3VZXC/LxpA4ylWFo2+IatoUIlOMGr3vMvw8JZZ1RDiSnMeWkktTJVbkOAtOCyCfpP6ZSnkptQ9XK0qcJaavZRRIAy9rSSa09VmB4GQX8AbwqSIlRFITPJKZhnyyCv+stC+DvWnm5a0NdVUv3L9EMA4VGc70PqKCwSZ+o/1tcxR3Oc/3fbvusvzVS06V+nTVve1C1L4+i8l5xAnnHO96BN73pTXjTm96EnDM++ZM/Gb/927+ND/mQD8E3fdM34Uu+5EveG916zwqjqijsPw/bgBa0KVCaRaMHqpqrPx93EGmrzyQ23BMl61skXDgD/HVgsiF+kEOdUDlgx6URcGpfZmOwWxa44xsljAYmyiohbWMH23tMHVolndHmzQKKYBbyA2Y7WABxTLFFNSDJIg2bJIRI2makMWE7iVe32b8B2s+BXCVHwWvaVef2d7dO/UEdDy7Suqe1gVZCHti9XQ0MxYOsquq52WciZWG4yraILaPUJWCvcQwuQLI91ABAdvBjWUjMlopJnGZKaZ1ZpD/tfPSlZzwaRsj6MQXwd1LBX94WjZun61eiBJLn/wc1b18c1CQBX2VIoMSgKYO3ucYBhL375ADc1cFed2AwTHWcUpVgh8DQaSJnDtwcQelLycF5ZRTmqAwaAmZQqXhJ4sQzdXO5RC/CeiyVxt7P1pBq39qK2v99ffWZRXpl12ed6uiS9pMAcTjS8Elsvwda2nr6cksrQ31LYDC+vyCI93HsVuURm99svDZf76lEbl/25WaXcwOA2+0WP/ZjP4bv+77vw5ve9CZ8+Id/OL7kS74En/VZn4Vbb70VAPBDP/RD+Ef/6B+9zwHARlrRExT9PR46xQ4PsIcLoRFIkKDQM24WLYFqvHcVTDaENhLIngAG6Yn3OT4/G1wglHpGgbtDINajfY2ApqkH3TPNczsOD72XmZo8syI5VdUsIPH6umdlSTSdvParDTar97vkr+tDJmAqoFAhFa4mXRMjB6N6UR/KvRJcWA/jA8Z4SA763SOyPxgJLmWDgtxpJfdOByEOoO21BEBBIGfGNIqRv+S4rTHvpO4AuljD51gQ7ETNPjIbpzSRCMZKd03t/WiM92rfEyMugNnfMQGTqYPDLb1EeUmiHRmXuG7xYJXYjsBwugD+PMVdDeI8A182RxH4BXs8LvV3mljSwA3iXU0HGTQO8u5uQwR3Q21FbQRLUalgqqrhaHJgbYb/qYjaGkOq8+E2m9pfUy8zAAsbpDEAUypgHkTqax709g5bNwOguuESQSAwB2+7ANaOe2Zq/0gDO9Boe7ahS9adsGc8rmpQeVeJoM5lahksl5ieAmVgjBcFVCfUfW/vag8Cz1vdu1h6punhPL8vj+lybgDwrrvuQikFf//v/3386q/+Kj7yIz9yds9zn/tc3H777efVpZtWdhoUE7Dk3OBpjDIBWwnfIbHlLBg0edBa52ajrY7FvrKUYhZagWO7XV+MmJX2PiAQvKUxnUWww/WdB0f/fOCI2/ao3h8P/v77UlHg1+bL1cOTFawxuc0aMqpNm9mBwYB12xBNpapQSdAZIzUOPSBNKUYGzuSgNumbSL8IyWP8oXpT9/PcAf8yELCykB5oHCuaKSRgygQaAB4ZbKnlXApIs33KiRBV3rI2Nm/1gHNPW907Sb1r04YbdbN7RbK2qdKvtJEsCqzvAxVCGcNhG8Zg/7vd1wIooLCfeylgsniICr4bL16T/o0mEexA4FJhFkMwdaaxdG1+mQAekkR1WWXx4i2pgrqiEsGpANMkqu9SQIMGZMxJNk5wKHFAqm3TWMSOjW3Nuj4Wbt55kwCWFSMNxUNJRSeZZk7jcJdox/UU6v5eAh8L6+n2fuF5B6YR+HXPL+6D8LwDuMhcKJPQAkoDfiypDMnmDxo1gZFPxJYUpKr1QcwyHEhfa07eS0BqbwO4L9cq5wYAv/VbvxUvfvGLcXh4uPOexz3ucbjnnnvOq0s3rZgNTpOyCHo4hOwg8j/E/iyEIzB12ent8lveqN2XqmxibC+XxCgQtNAukVu2uHLSiQXg14G/RVuY2SArwfVyLS73jHvtgL+ewhACTYmRzQkEcMkTJpYAugaqA6C1tFCASGoSICqcAvm9hNA7HruvSl7gjiYFnJJWG20F6715W4AraJ0stAgw0Vy+QfJnc9OotALg9zzD5tEZnqEgwYhSmFL1cbr2qYaHsbVPEmIoAmXzBo6g3kGUqf5ZQ6ucMPIGlZmx8DQMl3AKENP9bPmVFTyaJLPPOjJzegJaIBf3qe1tNnCHxcO2OjzoXuEO/PXq/yYouI4xSP/cM3yVxD4vA4UJKYsDCRl3UJR5aMCf1j1N9QVICTxkyRkMuEcyqzaATUpIDI83avMWxxg9xjWKAPVgEQFgNZNU57TeiBZEdSBrzsSFvux4t90WtL/O3XNWt73H3VirI9ACAvN3H6JpsewiECZuUQoY2pFMIJLpZ1oT0ha4+A4xLXDThsgA9u+z1y3rN6Ob51n2IG5fzijnBgDvvvvu82rq/IseqFwkUTsYrlZoCAXQcMbVCxgaw00J64SGAHr6p0g8KdQfCe8UaG/P6Uei2h+4PQAMzy4dAEvgrjkAOu7TaDvHZ5q+d+E2ItHU+yhpwOf4XJFDgHML3gA5AJkqQKZJNZRxGKsdKZuCqjEGquZw+IijCFwqRFtGnsRL2MBoyYSUBfwJ8BGwity11+8TVHBew3ks3BO2GKECpwLp01TMCYOQNvWwLCvCtE41t/FEohLuDt5qN0mwjBqWQi2pprMM7HuxJHjsOQN/EqBawYnmFE5baHacmuLN4tZ5FhMCLG+vexencB26rgpeG4kRoYK8wlX123n9AhApXL8HIghkDULcOIBknT/y9x/GfDQLVNvxcC8L15rvppanDF6RS2pjKBXW/vBQHUDIxmxzZIhdq24Yvx3vu12bSX8WXpFddr3+fA/e9DejY/XhUH9Ps7rSMLshDEvfVqWNDJGOo3WE2TUe67uZ5ZDsYTHlgEvgIw3v59KBX8wtzeHefdmXR0nZZwK5GcUIRh9Qd4krjOpWqsbaeQMc/rl4c7rziN0PBMPwQEQ6At5ICZ3w6AHQqVidGPVqOBsPdhPhZkiGGRoCOAeNhB39vt5i5ywBZEbcLrnUCkPMOgBqIA9FaVylTwTx/m2ksm1oEiIh4EyQg90kQMUGxZoqjFTiE8a/mVQylEDrBFBCTiGOmIIc8+T1eQprY8BsFgcSAZT3/6M+D4ZLD8sAlJFAWQ5NcxwoQ3UgoQlgzQriwbF1Ls3BItrYpW0E3l3cSjKJZ8137ZJBlWBxATikOnTppee6rllOrG1bU1PZzSSn6g3arKOBP3ueNHahOfaYl2+vfk11Hvy3IaEcDigHGeNhRlklcQyw+Usk0ryUYMHf5aL8jlJAOde2Qps0TtUz2jgczTPMWesr/P9n709jrkuu8mD4WlX7nHMPzzz0ZOy2wwt8/oAXJUGxjRQZE2PcAlsCBASkliEJoEyEKUGAEI3EmB8JCUgRQshATATKj1iKiEywECHEGIITvx/w8vo10Mbtod3TM93TOWfvWt+PtVbVqtr73M/T3U+34eGUdO77DHvXrqpde9VVa7gWxJs1yHxUIJwsbzADTHp/O4C7mjapAvc6907VTjUbjgq4eVAHjIDNlEbMH0/+uCl5w83nFmyeAuBq4nnKz88IsPp5wiVwCqwpElXjF9cy1/o95HzfBj7981uRQTfPZvEvfBkR4Gn39k7P35Z7umwB4F0oFlk6CthoBJjbqMqCZFqTriyyAXAgELXwanfUKAtfFqLeNGJtcEK7Nfm26bgmhesGmdUCxHaByJfesEjYd2RC24+bCU63aFFI6OKArhuwnLEEgMwCwiohxeCcuguXYtYksXDXye68NER8wtx42feDCP1sHUYqdBNWBte53CExM/GQwLOI7JgPgIPkEU6zOrLWA7wM+KfG3INq9uDInePH3zsqZmCoNDVRgIOZlQMgrgNDua/eHB16I1JW06/lm7X0dXNoNhW5pIGZHG2uIIoNWDl6GJ+jWlwoudCa2D3ipn82FFSAp12vHTOZ0x7JNMjGlxxYAQH3Sg3DkbLmz4M/0/ZkUD0LCH20IZfoW7t2CCV7iA8+0ffEDI5BI4EjuLNAEVT5h3PLKwBsdSjwnwkH4LxLAriHgOA01+ZC0D6j4/EoQNEA+Uh7NzXe/qtT5vKkaPF1bDpOn/PaH5PqA53czJpjm0MN6DQNt3FIhqE8WykShj2g39U832vdKLmG+Q3OqJ359TKCP5Tn98Wcvy33dtkCwLtURoKRbdHTXSgVH8H8u5rcbIcIQHO+yg6+3fUyUAmcLCgnIn39wgQgm3lHfHTc1OcW0DsyV3AlT6cFOk3Xlc2XTgEzOicLcEaMjEUcMMx63FokDPNOiJHVDGe+mF4LYEDbAkNa3zMDNnlHb8M1CMVMjINYbJco9B4ZIJSFt3RKF2IEgMR534BPmJNeTx3JSRWLBpo2jXEzNlnbZblt1b9O6EAcGGJPf4PsP2rjkEwLaetoBlzSHiLWjBo6VmvNqKG+gkmjj4c5MkG1XcvmWorQ7CAo/mzeFJpc95wmpt7kyODIveVynJp9M+AxLfkmbNdG/tr90nvkr8eJCmiNBF7MkBZdBn9pVsAGQ/gTWTV2EjkODR4JEhVN1m8abTZyyUBR5xdR1vqdFqjifY+ZgGEeMOwAvEiIMSElAq+D8GT6B9UN1yQI9NM6OBlUneRB6Pi8VvM37rM7pj2ufe+v58fet/M0OWLtcZ8r184kmyCKJLmdO52LQeYXoOBPI9qz9WRCvo2UAS8v9tuWbbmjsgWAd6lsetB9EAg5IW3FABygpjoP/nwEJsqiSo3ArLQeBvLctau2cXmN6rHf/OFTAhWohG5Oc0eN7Lf6ThN+jUCeKr4NMSTsdD0wTxgWCjxy8Ia2wZNpoywASfm80hwYZgYQjaeuyY86AHHOxZ+NTUtmzoEEBA0O8ODByH2ZJXgEmqYuBYQ1Z+qU0DMG5cvzARS3K97ML1lIxBwLyIKV5sgmQel8AXSmERXNH1UmWwPFFLWNiRGV2Dn1dk31+zMQOaO8YbFxypsUJahmTSkXMkows7TmbB5kIhqNDENTn20AO1l7pQTfYSUBOaknDAshTM6+jG6jIwCH6+jfPKiFR89APRnY7wJ43mHY6TDsRvG5M//NBiBVD5TzMxTg6jR/4LyZyObnrDFlMY3b+UYkzZgEgB6UMQG8CFjvEtb7AO0OCMRYDxHoqdD0+LZPDPNoHtoGpWDe0u+7AWxapdkpu8kpOes3siNTs8lPKnO92gD7ADiTnV1xE/GyteVNnbLOTPWnbNo3z+uXpDTy/AWdvy33dNkCwLtR3A6Y3XdVEIh/GAlZU1V8k2yB1kPMBOE1U4HGwrnZbbeRlKPADC/ERtJ8omvWp1bI+X7Z6c1uelIT4I4l12ZQA44n2sIMDEkHSHPN5jGbJO1FNgeLea7RsAJiiu1KX0ybEgZoaq6gGTlkMQ9roNIaOe0OWPyzDDyUoBFGGBJST+iWSfy61Jetwo+NRqV0pHnvzPxGfpwrcIvciOhb50Zq80xDtYEzgJiQBiCqaTwOjOAyY5hPVfYt7IqPVTZLuwXSgmDYzLjO/7AE7TACEzhJAE21yKpPYPYNJL03yQApgziB+iDR9Ro5ayCQA2m2l7IRmwR/IYjWnJJof+DA3yJiWISsYZTxtpRrE/dNo8Yt1282/aofYP4+sUbzymtEQ1R9l6Ax7DqvjNuwPDQcJLCn3wWGXUbs5Dp9H0FryibNDIpsGt9uoZ94xjcFUeTgDz/E7H6bOOdOvhsBrFZ+NfeAgOw7mjMuUXOckw9+MzR1veJaU2R2pfnzANT1f8pH+uUqWxPwttyubAHgXSyn+m0135kPFQcIL50J5h6Zp66KIoOAQfYRbC3400hE1rbUppJa6Jcv6zpO76D73wphv25t0irY2uvO81qFVviaD6CdmxKhTwF9CkAf6mjpJBJehDNljYxpVc1Maf6Vvt21H6TXynFO0Tf0EZRYeF/71DioU/kfdKVpTYsDCxULuchX0xqRKmZCs4iinlOnCXTSaFkeNJUZIYNDIaSuT6wc5nXBSp2sVrLxIMRMoCzH2CKZNLp5RB80pXFoNiBma7b+JxtzjRL2C2zWVipgt5zOpkmhPslrYMQgIDvT2iThAqyieRXsZe5Cu0dJGkjuO6F5ieL3N9ecvwzQWjkGze9vFuqoZN18+Wsiik+fmIYJ6DQaOUBNxkIBk902NODEAon8RKiIn6sbWuZNmhPSLCGGhHUfMSwj4kpJoKt7UaoeAbcpGbOpNDIkT1/3rI98M+1w/X2Tj/PoWK7fl3nctMO1vwK9TXtZN5Iyz6CBNVJfsGchqe9wQPZXrQAlu89WrwO8HgS+3H6A27Itp5UtAHypCgMET/xLgLHR64402e/BNDlmBpYqQt61FyAYPCcakBdgvxP1foFZELH7bQMIbB2kN/arBSK0QWhP7KJ9e1qw014DTEWLxlSwVApAT5lfzhaXsE6izensWqSLtGbRmKOY79C0wV3X+pJmkrnCABGliECEQKQaLc7jPHZGJ/g8rcQAekbEoPUHN+5kLoWF4mZqfPw9tCFmdVwfxBztgX9YCwGz0ajkvk8tmvadpb2KAEdbnZHNxyPeyGbeFd9UruddMp5Bo92hfN1C7aJtNLBj2r+umLVzJpCszZIoXwwArScAsvP140ggybejmwfZYRAzWAN6StS8ArDO+Tb2CWGloFMBYOgDUid0MDJ3NHK3CwVQms+olRjA6ASQzjrwImagJ6nkIAAwBviJwdHTvpT3GWCxpYEDeCZ0SX0fgGUssuT5ALvmmDvRCE1q+m73GZgGce74yufZA0GLZrav2g2t3+A1z02uu9E4W+ad1AOzpPRcgZHsWR6mB2JkAWquNQpSeanL1Ibs+Z6/Lfd02QLAu1H8ztIECorgyVkfAuWcpJaRQkxIBNKsCtwB/S6yFkr8sTRicmBZ6Eza2eLpo12tDUNp0qmmF6rfV/9boNicX8naDaDytkLEX3NiweFGiAXiTARdjnNbbAXVZrZN+r0HGb6NWWhz84IY3SgZl56cGHWMaa2gIyCTC2dgbtcIGsWpF6AEoAfisj6QAzAQlYhg17bRQtIsXKFn9S2U1VHmCik44ZwCS8CdadOonjNaH5tfo9LH0EAIjh7D5mo+RzcjbdCGH0cPCtsNSA4CCgLwTLNi16yKLfimgbGczvpc0cBCs2J8gy5QJ98Pq1N9RknNvlkTC4cX9TfWaGUkyflMfUJYDwIcQ5CNQM8IoQQjpXmUNq2HnHWkpMjTeUGqYVx0SItOwGmfhAA+IwYxw+dIcgV+lvuXYwGAEixC2ceV5wldN2C96mTzovmYK/B0yvMtB0z8xvXvFehp69xUstas4f5sr9tcr55Hep8TlU1TI7+YIBYR22vkm1u3s9LcBZHBaab39Fg2UpmayZ5Rm/MNoCZfn9vIjTZML0fZAsBtuU0Jtz/kL2d59atfLazvzesf/+N/DAD4xm/8xtFvr3/961/4BTc92LpQt4EcQFkcDcQRS4aF2ZEInfxbdAEMnXF8FWLSNvtFppTRfLDBuNh6riKPszBrzVbPR3BMAKfRWPiduALOO3EenzomECMISlD6EfF7yhQkqm0z/7CwRtF8NItXBtBuHLwmyrRhw1woINZ7Af1exLBQig7fPhc8QLbg63ufTg7quxXWCXGZRIvp2jjS0Nj8MbDlgZXd54EzEOxOGLMjxvwwYXacJF1bNqmi8gEcaUtMyxfLvRotxgYINWijIo92i/PIzBiUfsYBz+K/Wc9v8b1E8YG1Pg6cv8sR2IQSBATkMc7F+dhZ/twMvnY68O4MaWcGnndKu1LMtcR6n056xOMe8aRHWPUF0DFrIMqAsB5AvWw+hr0O/f4Mw5k50u4MvIgl3ZuZducdeN4h7UpwSZqHivYFgGgaFUSGXoms+6TR3KbdpsIp6Sh5aDEgRkW8g24i3VwavVqw3pRq3m34fQSqNr3yMfUDTs08auVQSxTuI/1pKJudDHRJ59VcXsMO5Vevr2FRxpASJG3hCdAdErpDYHZYcmp7+TZ6Pu4U3L2MoMrf0xf62pZ7u9yzGsD/+T//J4ZhyJ//8A//EF/6pV+Kr/mar8nfvfWtb8U73/nO/Hk+n7+wizULaTYZ6YLJqQA0tjy0tsAFlrRDc4IFGcwOWMFdkzlAz0coXGCjiGKrOxXNTdYoOcAzabadAiDkhLn7aZMfom9T5cvmgdbUDn/DopKr0N8TC+UGArJpd9gJ4HXRGo0cs9sFhTa00Qtzi5zVNF9AyXYBBFhO2exbFyDUHzn6V7+jpEEABHQlEtTyPRstjIAaqheSKe0HCvDLHICunwb25XPhpjSN3pQmtxrzfJ+ozBXTXLl2tUDB+1cxSfo9A+KA3X/Jd10t4kDO7pL0mYhA1u5FrTNxCQARsJtqV4jcEB1fe+5Ma6m/5etqIE6m8xmSaHqsUmYBX8tBAzrcfTbNoQebUfwEh7mYjcFA6ANiIIRACEGjw11kfprLZiJ1pMFerL6sXPrixpYG0X6HIcl4mHxIJQp+mBHSghFmCZFYnheda97cuQno2f2t7vfUMHO9katMv/554vF5U/XmZ73VJluTGrnBDrxa5LjUw3pcCdAZcZ+2MtPVFTR7DZIQQMdlCSCDaefZ91+fWUfF02pFZSxsUKbHc1u25dNR7lkAePXq1erzj//4j+MzP/Mz8cY3vjF/t1gs8MADD7z4i1XAQnPPZiCGQpERAECCAPLOewDItE1z0QZBBVFS+0FLN9Ca2ypti4E/a48BSA/kPPhhJ7y5/t7Oq3a8z2dYbnP8aRoHOMHcMiewq3jkV8NiCmNru13LwLDzGdrYTirncFBQFAVv9CiLe1gHpexQc6BFaiZ18s85gcuqxkRAIklr1yeENakfI00uHK1/Yu7LIJQswZk8MxmwS5FlZjYiBU4DbYzQZgW+piWUHKoAJdPYFR9Ac5rPuXw3jF+wLB6ETD2TTMNoLhLZdI+cBQTQoBbXf6F4UZDriJFzZ/QeVORuDkwxQTR/s1A0jdD6APXrpEIVk7W5GrkbAzjEspgbAO3UD3AekOalXiEejujsXgypAAcLMFGzsfgYem0tZb/Aak44zZfND0s7JuTPogGMUUGimX9t/vs51W7E3BybAm/VseT+29ceBOYGTpy64Xw7YPLZbDeiTpaZv+/IrOxkcK4jNP9RjjE/bAuoAhvBudFNNeOoZv02hWUle21NMIC4iQPypSingfw7PX9b7ulyzwJAX1arFd71rnfhO7/zO6u0Xb/5m7+J++67DxcuXMAb3/hG/MiP/Ajuu+++u359S3+VFSgEy04mJRUlhfcbLPlta0GY/3twYNGT7M7PpMjASNjbeY3AbX+X9pcdr33Ov/uTJ4BAuyj4ejYVb4Jgi6jlMl6JCRgIYQV0JwnxRDVCue8MVu9w4qI1SjOqCI9vV5jg/PKkHazp0/odAvURMxPofdK5xbC80N63rK5YNwBE9T1r71M+vgb5eaEyc76ZQxnjBRgKECyYyEBO/rG5H6TzruNC7pyQF7QM4owCpslp7DcTBlTNBzHnTdZFMc8n/Z6Ziyl4ZjmDk2qwComyBGJwuR5IgFFiIAZN0ZeyzyxMezuTbDGsGTtMo5MgIJd7eUZN45c5HXPWHn3FMmDcBaSZ0MQMi1BocWD3V/oT1gRaK0APAYmQgzgkoplr7Z/m/7XxlLlRfP8AqJ9vIcROnczLtDNgrgAw9QGdgf72HjXvq/nmji3zCLVs8G1rywaQOWk5cPWPNNLWzuSeRV8lId9H2UBRrttH62Y/WD0+u0HYNcy9wuZ5J5s0uQbl+WwbrrpPXLfVgdNJcPhylS0A3JbblL8SAPDd7343rl+/jm/8xm/M3z3yyCP4mq/5Gjz88MN4/PHH8QM/8AP4ki/5EnzgAx/AYrGYrGe5XGK5XObPN2/eHB2Tsxb4xVx3flWOylAElDjwI/9mi6wHUFOaspFTdAZANbfVSAg7k0f+usYE4+La4MlMS9L1CSBh359ScQ4mmdI4cNN3JtFqMImJZgV0x4zuWP2yzCmelUx4sEAIiCO8alvtWlxux2gMYAsFVFGl12cW8/ywIIQhgLhDh17HdSgLuPqe5XtugDy47wl1ZK1d2o9Ds2iUwI+irQCAnIva8Upu1Oo29XutMGtbM0+imY11zvoUe7fVCtv9Uw1g6Ut9ks2BFAmYMYaBEHpCWEkqttAnhJUDS2s1vasfHEPeBzPJsvm6+oGj/N/8RT0FTg6mGFjA3zDIWJpPnjf3KkFzmgUx4+7E7EuWNaIsA5B9dO08F5TiXRVG5NeJhR3Aj5WNu3Wl4UxMM5IMIDMxFfd9BNaOLik/v25YJp45/5/8fz+HbnPfq/fts91iqDuoa6Q19LjKDXmtMecKzFq7mSQvdsVf6dxlWrLmOtrf6nBtaOSz1/zl8++kr9uyLS9z+SsBAH/u534OjzzyCB566KH83dd93dfl95/3eZ+HL/zCL8TDDz+MX/3VX8VXfdVXTdbzYz/2Y/ihH/qh8Q8mDGwX2giH9ljWrTMByKmwdFfqzbMMpX2xehqgN3WNDP6yw319XNbm+Da24M0JutYxu7o+AEJjAvF1e4Ftv4UJITgF/pq2UCKkFDA4H0AxyciCDSLJB+wDbMwPciChRIkKGpIbFw9em0UFgtWy1oDY6HhZ2pGkXdQHxIGBnsBBiaCpaGoy0W+nBNAKEgrHHWF0LycWzQz+VtCUbAr2jDqF5FoGBI0vz2888pBPbCj8WCT1l7NgiwJY63qq++TqrcdfxzKinkep6bfWP8wgafPWBF6SBECkVJ4xJVLmrmh5RyZbA1ok9yQHXxiNio+AzvOAbh8Wl2liAI6i9Rt2zLex9dklpZeZLjSwuAJkSiFDcpA53qdCD6NjFJCQKGQ2ATmeRROpbiSYJxABw0CgdZCNApeXf77b+1cD9Q2/v5Ay9Yy3G662tO1gZBeOqk1wz28GcwUcj10e2G1mys7H0hB6v+l2c2bXyufBAU0+Hfy1wPWlLi82kGMbBHLvl9uJu7/05c///M/x3ve+F//gH/yDU4978MEH8fDDD+PDH/7wxmO+93u/Fzdu3MivJ554AgAqALRph+c1ZSONmVtYaRDnYxpYQYJG+xqwaaL3vGA2p/YKZHHz8sXaYf5YdyCc2n6YeaQS1lNtmLjuVGn9GfP3A5B6Qj9EiQKeJeX1M3Cl0XwaSekBXRgY3ZLRHQPdESMei3O3adF8LuVJodeAxByZbVGrGtxhQJFDqMEfSjvzOCptSObcyxGNG8AZI5t+44pljqh/6TDTyMZdASNpRlU0KQjqTjAe9MlFQvtonJQyrmUeboriLqZfdo717F4Tc5eRA27g5o9kC1GuOxvKxAoGuQThWJS1i8y1Ogx0m48eO22eN70bGJc0b6FEDgf3v4sSHWwULp1oANnS6jnNnI1PvaniDKYNqMZlQncyIC6LSbs63o/tYFHABhj1BwM6MA0gIy4GhJCQlC9zKvhHrlGPu58How2h/69jNlWmNnd5PJpgjFNNjC1YdXNk4+bF/FPt2TRtbJ4/GAdQAdn/2qKDk/KIWnR+299ag1ruRXvPX9a0b1OllaUv5LUt93S55zWA73znO3Hffffhy7/8y0897tlnn8UTTzyBBx98cOMxi8Vi0jycH3QTahPAp+W8Esd8zposDiJsumM5v98hrM9Y9KaYO+MJwEm0gpNA0wmg7Kic/7g22W7VA0B/WCtkuRZmUxol+X5zu+oDy/FTPkEeJGQewETgPmDVR+wtBtAsYZiLP16OzvPtCIUwlyy12SARt8OMkDoGzSARmxao44HwbcDwZF+D3UgugFC/z+2JRt8RdJFy98wwSbvYaFBQ0KjE0Et/RVtWAKSknCPEwAAnUE9jbQRT9Z9v19FN95Td/ePSTq9FGWle4ACnAcVmblZmNvXFCl0AsYvEtSANoqwNBCAuADGiMrUqGLegHEoDKDGGWQFwHAiIQIoBFEMF1OX+hZIuzmXoyAC+jTB19zOnqzMtn/pjhpNetJKEDNYrIG7AM5D0J5D6IkpdBjhJf08zQr8L9HuMxWKNToVEJsz2z9zEvZwqm57PajNE9fetZnGkWdfjNvkR52uS+6mSo/r9VHuAEnDHAHWQIBjLG+1zIfs+KH2OuT2Y/2l3rKLFzMVebvoOuY1Euff1BmNbtuUvYrmnAWBKCe985zvxjne8A11XunpwcIDHHnsMX/3VX40HH3wQH/nIR/B93/d9uHLlCr7yK7/y+V8oC9cSAVw5BOsx2Q/QaQrgNGWhB7ploYBJcyB1Alq4R32eLwp4/MLT7uzbAI7sN+M0fyPBykWQTTk427V9O8p5m8eK7PqtRqG5trXXtHMYxAcwEKObDRh2VHOjUXY08CjTRwauCQgsF6EEpF40iqljhE79LlXLhZYjz7dR22kULhZcAaBwkwXTXFF1ri3aYgqeuAa7+t13Fvkal1BOMs4ZMoa5gEgAEsgwlPdm+hZKFEwjuRe72/fgL3G+V8FlnTAOwFabna9vQ2T3OS+cToOjAB5mDmaFroMcZ+Z1A0pGppy7nBhBczRzn4BBBm2IUSK1BwWvQwJ6jfq1KOMuovgO2j32zwKVDYEC7vzcaLBOlT0iacDQWuuPfp5Qod2xITJNpIvYymZIlv/9DmG9T0h7PRazXi7TE8Im6p9GHjzv+z+1MWg2dnfk79aCRbj5MdqENnLMbRbADvw1myrL5JNa2iTrg85f21TZnDM/0+p4+Lp5s5xr+vbpKFsT8LbcrtzTAPC9730vPvrRj+Lv/b2/V30fY8Qf/MEf4Bd/8Rdx/fp1PPjgg3jTm96EX/mVX8HZs2df0LWyjxQIreo/L4RAvUMEMj+aaAiRg0NmByJ80kykTnb4dztvb/KVNrjreW2KfdcIpNZEu8nf71RBsGmX24K75ve2zgxI22NN4prPGIBZSJjNe6znrLl9JcJStJ6qLWGIxqT3Kg/RkHGSwJDU6+4/ChBMc2lsIowBWgXkJcVat9T8vkm4HLmLWbuXtXLOgXwEng3cDUBqtXF2TwaAehYN8MpcAwr4G+bISsfMgMKSuYR6gDiVsXEblTK2GGmINs4Tf+/8/NLNTSYUzgTOxUydlOtymFPt0tCCfmuPZfpIAK2TEi0rKHOgHkEAdTIiZyCDOGJk2pScMszG1WUUAdSfc53kNQwYBX3kNhrH4PSY+bENNgbMSm4dSnSxL55j0F9nYDBxCW5y1zDyd9bPw4LQ7wG0O2DWDViuO3AflIan3PtyE13bdcxHG8CJ4ye/nzhn0oTc1l+BZlTPxsh9xN2ONvhNZG59m7KMBFxudTjXhNLv0MuLV3pqD4QVSqCTXb99fqeKAvLS31bQnXLu3S4vZmNn52/LPV3uaQD4lre8BTzhh7G7u4tf+7Vfu6vXqsxpfmdZHaT/qx2ofMlESDPGeo8Ql5LNIayLacLnFC6RmA6oeO2Jf28CdlPwBdqFvCzAU5q/inev7R8360G7CFDzvgGXI3OSvWV3qgaBxJiwNCoSM90C2f/P+43l+rjO4xkiZ965FAnDII1iIvAM04WdH95SKTgCSZ5QgpJ6B00bJcA1c+G1Y9DU27732k8ailZtyp8qby7Ud29IAC2EBDjz4vnNhwWxZH4y5HmSLLPMpnvRqznN5ob3Tx3KguqzhKSchg5FS6t9KSbh5jVAaGA0Mrf49+kFA1RT3iEtJJsGAOFWJKWFsfuinchAXP3DbK6HlWXbGEowhl2nNQlncFrmVg4a0jZmwmpru9UTuJro1AJaJw+AJBsVMo1xfR9tPnEH9AvCsMvo5j0CseTL9hHAwGjOsa9u07ysTqiPa0XcyOph9TbPeCsjRiTPE+/dHq6MdYDQLbnrZ5cRL/s8EPT+vgOAHllLG5z/LQfhAESzUWEnszeVyRR3WzC1LX8Byz0NAF/WorvRygRkP1ULKOfjR5qWQBgWAkrCGm6XO94pG6FuBaTcIpoXh4ASEdwAvingl7U5m4Bfs1BkTaZqUTzg9GOT+z/+arySjA7QzwkYhoAhBURi8IwxzNX8p1Q6hValmOEKwGHXf9aoXTlPctEKgmL14bPcn1VTzYcrp9XjypzNpNe3iFCmEqXrBiA77ps2zN+bpt85yjX3R4mj2+AJf1qQ9qe53AzTAJtzeyTk/lmqNUCAGs3VDUHvudcMx7VGIa+lLRaEYprr0GsGhTVnB3ozV2cC6In7OwkCvYnNxrKN1FX/PIuoZqWGAVC4Ah1ZNevYmO9dTiO2doEkwRCGRhBHyn5/ck3K/zOfoX/GkwKKdanXcgKPNUJyX9scxkIsLhsI6pP4CxoIZGRNsFkCJCNOwu58ABFjGEKmPioNc5dtZY8BMxuqZnPmtW1WVd50NKXSdrfH3AEQmnoGKjmodTIEBHqAaykVPWXRZDus6HF5x9623c3JKe14rrcdK7j7Cf38coPADbLheZ2/Lfd02QLAu13cw59LIwC9SdiTiJqASV5DYpoeE4JUPmfAZULKLus0RJ4SJpdUXpWPHZf21LvwAv4qHOOBXaMB3RTJmnfvsN00innaQKsDQ35HT4No6SwdHJsGz3EmZtM4KSg1EMGFU61obxikYMDcrjhwMf3ovTBfzU1aOpjvm35hZvvcH6BERjtyXwNQnpB2JHMngFImtVXN5eSY6xxIUTjPYKnVVkKsHAZqgJv0IXWa7QRAipzBfwa+KzF9W7q5pFG65kdnZnEDHmlmZl/KVDqT4L6dg3Y/opEfhzIhfDBVpALQVDueICbwwClvykSrWUfrGvjLeZoBQcbsgj7cf/O5A/xcQx6jXKcCYeqFszBoTt82xRuAaVDo+SPb4jcLquFMEeIPu5uwmK1FAzhQjgCe1MxtKhNgxsuF0eFT99JXcyfX5Ob/VL3u+zzuo3mjvyeVk/k5ceDNjvMabEJJGegydbQb+Tx3p7J50Ib3E+1/ucomvPp8zt+We7tsAeBLUfxD7hYH+cgjs0km8zU/pdQIKL+LNQDpwB98HQQkW5QsxZwLjKBWyDrAAGhbWyHVgL/JLrcawmYcTHDb7ryq1582AZaZNwhO63ezACD7BTlERQ54AVnDxAlAR3KNJNoriwrkTn3H7L4ouOTIxezp/LysiKLI/AC1qao1yhpVF/3N7b2dGOfsA8YlqlS0lc5UdUr0rdfshmUCdwFROQglE4X2Z2ZtpNy+HNg0eL82t6gCGqku1CZhLaBrmAfx+5uZFhTTGim3gSnaP+QNA8+CYCeje8l9ss0K5YhhDkAAIw0ECqR+dAoiNWrX2ltpurtQEn7M5E3ylELWZFv8jfqldcNgAdNxJeOQtc1AiUDV3UZFVp0DWUIJCrF7YJHJsXBd5nRzQTPT7AG012Nn1iMxYehjpjEZ8+CVcfffMern1B/bRotv9B92X9tcri0gZZzKga5NroJJ9xB/rIkqv/nh6uciYxwI9ICx8uvLwFp/Jy7Pq28XxmWTdrAFzncEwu9WmdpsPd/zt+WeLlsAeDdLu3sG0JoDTItQaTkySEAxXaKAn1w3oQIQuX5b9FELtMrkiwKWjA6hErBeQ+jb7tvYLhw0Xhgmh6URzFkTmA9A7TPZCGRfQmB0IYFIzaAGSrwG0o1vbr+ObU7DZtqfwBhs0VWQFHqNnp1BMgb4+2Og2oh/FZcZB11ISYEO16bHUHzgLA1V6qheWCxKvALOXLRNJJ8zyS0SmAQcJKdFNJNx8XXSYJUMAhlYJ/Cy4a+LBCAg5o0DjRZwVoLowWmYQQZ6nGbQNH8zZC2jX3ilrjLvTCsTLMfxmp2ZvYBSkANV7eKqbUoghCaS1gKqUifjGw3IsYF6QpoH0BDLc+nbpn5/rHUNs5L319PshB6IS0ZYJoTVIAEp+XnWig0Ee/Bn3INdGHM2tvfApYNLc0K/S+j3xf+PAJysZkgnEbM11T6AWlf13gGxUYAGCoirx7L56IGGHp/BX1sHowJr2RqADceg1FeBzgYQ5kAo+z3PdX1uCCOi7tHGq4kQHvXtDsDbiADa2roFU9vyF7BsAeDdKhuEg9dkTJqCW8FAZlbj7EwPAIm47PodwKuEqbWj3XU74CcOz0VAleCSZjesbZzUvlEtgyfLlMBrT2rbOXFe60tEBMSQEJpzC1GsW1V8daRgJZVFwKJMI5KaP0mdyhNSDJmOh/RchozTMCOEuXA1UhLVWwB0sWWE1YAwiLamaFaBsA6FQHpG6BcoPm1si2U9AAaMKhO/ArvAjBhMG0mj+VDSxiWElQci0s58mwOJdokDOEgKvREPI5ADTEqggg610dSsEigp+JtRidBWQGyBLHBzrw1iMiBJpkXrlSSZLbMJChUMpC3kgk1sPgt/IOUgAXMNsHzC5k+XZtDcwMV3sB5/AbWkYJQ08CipdrNQ8DjgukqiCe1TJquGZSjRNnv/wjrww+YENe2Aaqv9MysBR/0eYdhNWHQJy77D4fEcdBwRl7RRxtx1QGJYdsIVJEcatwDNjr2dXJwSNvad20RU+DUBGChnTGEAlnWpztaicnSwKHshhU4zUv5NLgFSXube6ZjcAWh8qQrx82jrhvO35d4uWwB4N0q7q/bF73TbSGGYdkEX2wQkSGAD5gQ6ZHQnEhnc76lWKjms5wRl5fPnTcY+otI4yZy5GODi29Sas9o++P55ENgI6wwsThOW1Px39Y/MJK4OIkZHCV0cgI6zFs6yO5DxwnkuP1twDPiya2Ri0FojAJMBBLOnhuK358zWHMXsGnrJBwzVxgUqYBtQgGljSQCnJCbKNSH1BED81hRz1sGmNk0GDdpQ7Zr5/0n9Cjg6MUuXoIbCHVjyxbqACtOOKokyBRIIq0Eh1WbA34YAoFMKPS7gNPQl6IMVfBk/I7ho9cwsWkyhyH57YF1sex88oQDKtZv6hJzqDQByKjXXdgA0IwyDW+kd6M/PWwRSF7JmcCpSnpgqjSRQALwFYZl/ZFwx4knSzB519HKdEsxoXELZAFh/jGaGUYJZFERZhDmrGdsiVdf7QNod0HUDln3E+niG7jiAzARsMqKdX5s2oW055fdi0i0gnOA02afIgNtF054KoPxGd2rzavQuRErZY/Q9VGkkmcTdY9gV/9bZIWPdycbA6vABIJW8m5JVGG/ipvhhX5ZyJ/f2dudvyz1dtgDwbhdbiBy3XyV32Vj8Czox01hQsudhBxgWQNA8qHEFSeeU61BtgNUQ3cuBg3Hqo5q4NFMa2C56AnhNme1G/W0/30bwn3p+7qTra/NTDAl7szV4MWBYxKwZFSFPQv3j8szmQI2haMCYxCeMeiBHYuqYhlUCEJAiI5oZ0wWaIBjIkUCJEAnMASm4oALfRfP/MzySxOcurBkx1oC88hc1YLE2UGQ3ARnQFc48glHOmC+ekTNzANI8FrN4n+qxAEQDOJPctt68ncfP+uLuq9fYBSWoRkVIXgIi4iohHis4yjmMqXpWJL0b672SlG85SCKbTwuYylx4DrTaPB60ERxDBm6mhbSNgJipg3IpOl8/cnXBwDQKqbIHyXoPuiUjHid0x8PI9FtuKKEy96oWlpOCQKIiG3ygCwHcBQyLiLTwWkwhgO73GWG/RxcSTlYzYBnzZtE/j1PF7udtn9WmjlabV8kIOBDorpPPtT9T1/QbSwNppuHzAI/K5/xMNps+k4nUu3vHKK4W2o/Qy60S0nSlUZoXeTxiN3Dt8qTfsvm9zUBuQdW2/AUqU55f2/JCixOKkzQw/uH3gizAgQOUCMoFsN4LCGtgcZ0RTxRg9Mh5bC2ooqLZ8NezRUAXWsuxmmb2UrOep4lJ45eZse0FNIuG0wTYYu4Xh6ypnNo1U/MbTRyndbB+udutEfd6rPeBYSeAZ0HNtrJ45uAar3hhKNUHw0xoOf9rE3kpadU4+1C1/lFmDk0zQtIo15y/1pnvMsDWnMH2AlEGT90JY3Ys3I+zo4TZcZL/h4z5QUJ3lMSvrFe+unUdDFFAFqM70eOPk/j9kZordwP6HeHKk+ujcOQFMVfnOdFGjbt7kDU+Dvx1J2JizvlsDZga2BoEIMaV+MWFtbziSY943KM7WKE7WCMe9fn3rP0bBpCSQIs2sAR1IAR55YAMyvc1dZbyT4mgByCeJHTHMn6A+DgOM5SUfKpBTxY5r7mQh4WY+/uFPi/NRiuuS17fsNK2+shi7+tnc8zzAwYBqmkWkeaxZDXJvH8WCV0D1dSJZWB9lrGzu0IMjH4dQStCWBvP4/Sz9qJK81xX/m5eq+ie++Kb6uSIWS2aZz77ckbk7DESlFXLSmquV/n7dgXIiUkXbhNXNoyhZ8wOGYvnRIu93hOfSg5l/mZtt/OzNvBn/Z4E0c1Yf1pMqu29eD6v51l+67d+C29729vw0EMPgYjw7ne/u/r9G7/xG0FE1ev1r399dcxyucQ//af/FFeuXMH+/j7e/va342Mf+1h1zLVr1/Doo4/i/PnzOH/+PB599FFcv379+Td4W7YA8CUtXAs+/71pZwDk3SWgC+uKEU/kuH7XfM0U9GlGiLguDvL5/BYwad1Z0LpFLQtFJeatQJ1bwD2A9Nfwgtq+9zvhymSsgMnX4cFedVzbj2Y8h4EwpICduMbOzhrDLuvCbAAmjPqT/b9U25EjWU3DlMx8XN4bbYoB2rZPHGT8+h3CelcWjbSwhboGk5wBCiofwByBa6bcVQmk8BG1WUOIshC18yn0xQfNTM8GGtJcyannAlIzuMjzr7StBX6jRYttDGU+dica8NCXsbP3IQd1lD547TcNDForaFr1oOVa/q8F9ME0lUnNvkawqzl/uQtiwu1Ma+kAktPWkJqOowPPTJRN1Rn8NW4U3vyfU9m5wB5KjvBZ/QQBqBa0gAxk4CBtF+AK7QdpXuHgKG0oazfR8h7q/Tft3+oswGd67MzXGBKhX3aIJ5YFprl37tn1n0cuLKc8f9X7ZnOV/+f3E5vAqc2UlwX2OW5++Q0uqV9zWKNEPfucvyhg0gdxwd9bvb/rfcL6jHzXnUA33GXMag1xub9VUBNRfpWxkXHwWuWXo/i154W+nk85PDzEF3zBF+Cnf/qnNx7z1re+FZ/85Cfz67/8l/9S/f7t3/7t+E//6T/hl3/5l/Hbv/3bODg4wFd8xVdgGAp9wDd8wzfggx/8IN7znvfgPe95Dz74wQ/i0UcffX6N3RYAWxPwXSkjX5YJAVpRZjj6Cv2inGIgxRFBs7mk2ee8U3Z+S0645qCBKfNtK3DbHTvacxtWeycUzLzNqIWFaSWtP61p7XZgrwVvud5ESEPESj3v512PlTpsV1q3ID433AInA3gWVOBAXr6wmuMCFQfwEW0EdFHpKIMSyygSNZwwAMBQgz/TTg1zyuBC+qX0LOoflwGf12gE1eiQu5/ZR6zQ3mQNpL8fA7IPUnvvfDF/PkudZunTKvOfzi8DqWGVENdJtFlEEiwRJXWdRP8W8zATgTTaOvvGWX5fM/MyF2AaHEgFBAgFZFJm7gLSImLYUfAf3fOgDv8jrZQC4yorSRMZWnH7EWRsG5VIBuJK+IzE0rasnlPQm1KZX9p2BEMdrACPyvwycyMMMJY221wBAcMsYHWGsD7HmO2L9u/wZAY+iQgr1NG/7hkcadX9/zst1bM+nldTriTlBPlMbVvsuE3gc0M7/GaIFfxN+UEHB+TytRkwqh0bZ0oC/kj9VgFkkOg5GDf2LctUrn7PsuP59O8vWXnkkUfwyCOPnHrMYrHAAw88MPnbjRs38HM/93P49//+3+PNb34zAOBd73oXXvnKV+K9730vvuzLvgx//Md/jPe85z14//vfj9e97nUAgJ/92Z/FG97wBnzoQx/C53zO59zdTt3jZQsA70Y55aGechKW78crcDFBkQojLk7cVOhDMnjIju3yP+cLThhpifKCz/Xi700b0N+lzolVge9MfmXzCE0IvY3jMf59NHYJSANhPcRCBp0BsGrwSJzkjYw556U1/0eGOt3bStCAceh37M7XsczrpZ0aINeCLv7aZ9KGG8l0JpFmVHlxjbrC7ptp+7xWlaFAvwMShdGCm03ZBCSveRqKNpH6coPJL06OmzAMDF5z/pyzI9hiDWSNV1wxZscJ8YQ14EGBGxhBNaZpEI5CGtSUbnl9zb/PRcZSSpK7ju2zBia5NF/SLwfyY0CaR/Q7Ef1OwDBzC7WdklTb690g1Ozvzd2jOUdlPuSgEUvFV7lGaKo3mx+Ns3/W/nkuJzNfw6KXFTxGgvdD9f6RrO4FTLIJSJ1q/84D/fkBF3Ylie1qOUM4Cdn8a8+6Xdo2l3IBuHa67/zUajaGY5Nme0IZw6mI6va4fE1yAMm3xz07NSUPahmnQR7Q8UHfyB1fpy82PwwsO/APuPdufzjVl6rqCfC38dyXuvh790LPB3Dz5s3q68VigcVi8YKq/M3f/E3cd999uHDhAt74xjfiR37kR3DfffcBAD7wgQ9gvV7jLW95Sz7+oYcewud93ufhfe97H77sy74Mv/M7v4Pz589n8AcAr3/963H+/Hm8733v2wLA51m2APBulNMeMieERmZR1N9NRSFWGrSp6k0Aen+9VIRQBiXuWj5yr/KT89fyWogWyFUaAK3LfP78OVM7Zl98PSjX9v3lRoh7/OOpYEhNjQiMoSvaoNA7zjfIwsoqtcOQQH1Zn7Np1AC20yBY1GgeF9/mqCBwBgyJSgouQ40ZIOiCbkTTBgwhkabs1Xt2P4LXVlEe2+peWt8M/DAQDaCY2TMVcGc+kt4RHj0jYgAQEWYkCj0uY2NANS4F/Ilf4lBrUxNLqtvVgBALEjMtMnmNX0oloneQ/zVnnoIluydEyLl5c38LuXPL8Zb7xYBFfacgLgL9jgR+VGn4qmeg3oBlf1u/iVAgQn2Z+5l7cSgm6wwGmsCOqgTK/pje5FsRXLv+pRlhdZawusCYXTjB3mKFk3WHYRURV1RF/k4WB/4mtYDcvNpzMQH+7GeTEw3I8ykjreRoXH02WjOyxsnAMsjkY7wcdXV4c7ungWxBPaDPRm/MCBi5QLSawixbW1nYlBH4a8chtWe8dOWFmHHb8wHgla98ZfX9D/7gD+Kxxx573vU98sgj+Jqv+Ro8/PDDePzxx/EDP/AD+JIv+RJ84AMfwGKxwJNPPon5fI6LFy9W591///148sknAQBPPvlkBoy+3HffffmYbbnzsgWAd6F48DMFkkZmWPf7JO9bEpOeLP4slq+1OJunSBgWKBk+DADliN9a4wFyNC+oQd8oa4SB0Ma3r5jEXBf9AjIlZDYBQF+PDdud7o65DGAgRhcHzcqhQR99kuwPmsmBo1CsWN5cf906o4S0oQJplYlWjzetjMZQWOYW6xgzZ6CWOosc5UxlMsyDW9ALAEwMDDOAFoS4dIulgj/j1EsNyJkOdOFKEywVFeRMdvMMqEDHVPMgY8657rxg6SIY1hKwEo+VV9DGkFEid/tUz2mS4BcKYvKkPhUeP6/1GxLQq50uCNirwF8sadnckI+i3607ZHM5ml+ozJM017y580IV5DV3fk7QAMSl+DlGI7i2lGE2/qZ5TsYVmPKmTNriNxWG4GzcdJ5mM6SLAs79oxzUYgwC613C8gLQX+pxaf8EkRgnq8b8602jE89guxnM3wOYfJ7duZW8AyqQ4TV55TtGJe/85tLh41ymwKiNh+3LFBwayXjOkexofrIM9Btr3zYubh6D5at2frnVeMHVt2EzPGq/6+eUVvAvS3niiSdw7ty5/PmFav++7uu+Lr//vM/7PHzhF34hHn74Yfzqr/4qvuqrvmrjecwM8uB9YiPVHrMtd1a2APClKiZoPFCa2Ina4mNRZ0hmoRSwx2oa6k7ktdqXyL801wqaSF1/zXanWoG/5lhgYrNv2qaqjvoc62vrJ1UtOtQI4NsNHWO0aJGCP9ZcwJ1SwaS9hGEnIs0CwnJwpsbSDvHBK+b0iqrFBXnkxSWUhlrAQ1Lzn+Xt9T6O3mTktbik4C9o0EGmj4kGNOVaSVc027GHldYXhXR6WFCtrQJgmkWvFcnaYPVLM1/MtBAW6zCkEvRizuvMAsQsEMFxHnp6msxzl1OcKXhRnY4AoFTTtpiPGwDupG3QyF5k8Gm+mHo/PPgLAdlHrhXugTI42jR/UiTR9EWAWKO0Z9DcxHavmvMN1LFoh7olY3YoASRMkGCjOcZAXKPLRz6N+SAqQR16TvY/85e3flE5RjYnMoeGOWGt2r/5uSV2Zz2O1zOcHM0RDwPCisRU3cicduNVASG4ebWpWD1cAM0m0zEYRRZ4oNkcXoHBqQY0MsSbmP1/v1kx7XtoAb1vXs7kI/cXrAE+c61waE8obfDuLW3fuGlnbrptvnj820taPHh+oecDOHfuXAUA71Z58MEH8fDDD+PDH/4wAOCBBx7AarXCtWvXKi3gU089hS/6oi/Kx3zqU58a1fX000/j/vvvv+ttvNfLNgr4bpRWiNuu3psR849wZiGMACGAyr+FI4T4VTUSHIF+D3lhy349bvcLGIUCZW2T+ahV2rzsc9j6FyK33QeYhMwniBId7MYgU3FsmlWN4N5UqsAPE+ya9g0DYdULCjs7WyKeXWN1jjDsUM6hSs1YlGhQSFYMo+lQzYGnEIEzI1lbquAZC0RoXxHV/c6RxdYGfy/I11+ASb8jvl3DjmqqHE1PdW+ovG9NUsHxBlJiMXnuRvR7Ef1uJzQjMWS/QagPG4LQxaR5AVWV/5tGGVPvwLONtQLLkT9lEnBJ6wHhpEdY9aB1L5o+F9krDQ/ArAPPOnAXa/BnhMnmT+fvGVz7mry3QtgtAHq9GyRl2qLwOm4K3ioBHhbhmxCPB3RHA7rjQbkMUc9/5mnuP6A8D9r+DLwBeN5ECyZKM6rni10iAus9wvI8MFzosb+7xMCEg+MF0sEM8URcCe5o4Z8Af5t83KZAja+njRqdsgzkwDW/ESQUOekidLmRRdUGsm1bKDQxaS6UPWkB2TTN6iC5rK0d9LxZmQNpJi/Aybgse7QNPriEm1fuZxMFbHVweW5frtJG9L6Q10tZnn32WTzxxBN48MEHAQB/82/+TcxmM/z6r/96PuaTn/wk/vAP/zADwDe84Q24ceMGfu/3fi8f87u/+7u4ceNGPmZb7rxsNYB3o3D9PpOgqmYMxOOHyQtVLoDMCx4DWakTcNCdMOYHjPSsCDjTEnjTb6auMC4zA4imFTCtEYDUCKMMYFptgQOY9l3lV7NJOE+NEznBwtVGevM5dn0G0BOW6xlO+hl2ujV295ZYndlBvxMw99Gv1t4c6CBXMuoXuZ4tPlTMNAmZsy/zJGqkceZLND8h802ycWrbT6J55BAKGHfO7FAgIDx8BLBkgWFCvpdVhgq/eOp/ruYMF+1f0hzCGnACAngNMEkDgpIQm1YqdUGoYqyNppyxe+78SgEUGiP1ixsHBBgIVKAHYKQRU+1f1vZ1ERws0MXdI5cuLYM/NYdTYkQlPTYTHpyGlSOArgTjFBBtm4VaNZXviwsQCGba9ZpK2L0REzMNDDb6oKD/BwLpDoCN+sXPDc9fqNp+owiqCIZ1c9Uv1PfvYsLs7BLzbsBy3WF5NEM8kuCPyvzongU/bVpglpvknrPbLv6Um1bmv69z4ln2pm3/v8iSuv4py0Nuv51rANHcMVTu5cxHvflEyliGAaAVA8dls2Tcf4DSMa31uXJa/rzp8sCOG7neyPQsx307X04z5Z1sBG53/vMoBwcH+JM/+ZP8+fHHH8cHP/hBXLp0CZcuXcJjjz2Gr/7qr8aDDz6Ij3zkI/i+7/s+XLlyBV/5lV8JADh//jz+/t//+/iu7/ouXL58GZcuXcJ3f/d34/M///NzVPBrX/tavPWtb8U3f/M342d+5mcAAN/yLd+Cr/iKr9gGgLyAsgWAd6NMCSrzvfM7aBWs2fm/EXiV6S0pJYdph/YIqz5gdpSwuC473WGOyv8pmzvbrCDGlWUg0Wu0NgVs+MXQwIUTKFnwZyNgU5r+ed+gkd9RKIvI1E6/mDYBWgcsT2a4tV5gHnvszHoc70A0O5EKB52y+FuuVu4kgphiQDDNk4FlBRTmF5g60cL1O5TNhanR3OV7BlkoLHC4aArlPAriMOjB30gw2/h687zV31yzXSQJBeTnXLt6jw38pc4tWoPda1KaFQG7PAtVoEG+R8FfW4EYATl7CgvQRCfcc6Y+FZeAKPbtfsj+hhwF6IEIGBLYvPW7mClSkveZsutam9WnMPMtKsAXmg85R3zDHMebAwl5HJyJkEb3ApUG0Ez5lBghsQJmArqiZRIeEdEwI0J8kvok5sTUjiNk0xGUA9DAn96DlMEtFY2+kj6vLgDDxR7n9pYgYhwv5+CjDmFJhftv0/zxm6NNi7t75nPZhFkaENgeW4Edv2lpNzIT9W7aDFa+fQky7CZXM0iT5x02XQNAGtHOAYgQkAdAqHTOSJR9PEEeQ4Z7nhnuuZAfs5ZvanPfgsMsn+t5fa+V3//938eb3vSm/Pk7v/M7AQDveMc78O/+3b/DH/zBH+AXf/EXcf36dTz44IN405vehF/5lV/B2bNn8zn/+l//a3Rdh6/92q/F8fEx/s7f+Tv4+Z//ecRYVOG/9Eu/hG/7tm/L0cJvf/vbT+Ue3JbNZQsA70JpfUKsVLl//fcJcjAXIZkd0T1YTOJ3ZSt9vwuAgnK12bXd8QzRRDAKHxnbIoZMamrmlixI/a4VDnBVGpsa0+VdeyjX8ZF+WdvodtGVz5CvWhdItnqsftTH00AIa0a/jDhczXF2tsS865EWSTJcRAIp0S8FQmAGZsiLKhbaecBFxRY/LONaY80iMbjo26rdfiB0XLzm1Ey6oLJgWUBDy6lomjXL5GGBI4CkMwsBGFwUZFXcfTfC5bDi7DvWRo+aqdq0olJHaRMxIwwa0Qxpc9EqI1PYhLWw+JeNg67GkQCKSmYcJCp4NYCIwDTItWYdeCbCnIahUNT4cQnImsq6ncj0L8MiiJkvEox0Oq7lP5tZUImbba56n8bJOQ9k9wuJEHV5iZMBXkLRTqp/YVC/syg+qtlEnqlsuIBABd7eXcKCPGx8Sxq+4sfZ7xCW5wnLSwk755ZYzPqs/QvHoUT/trl/275ObcDcOIyKkzOToLGRC9VP3iXAHdQGitjn0cZnAxDM8omQeRNHGl4356G3wfrNHYHm+l43dmGJ/OxYXZWW0Y/RJuCqx3ifYi8nRhROL3VpgfwLOf95lC/+4i+WNJwbyq/92q/dto6dnR381E/9FH7qp35q4zGXLl3Cu971rufXuG2ZLFsAeJdKDubY9Ltp/VA0DBJNOpEzM6jccCCwUEAgJ6IvvoGc6QzkAsialZySS4FGpiGBCl4WwmRyYMJrCKbMM6ZpnFpI20J3IPNGvkGTB2kfegJWAct1hwTCLCTwIpWcwGqapD4BnYDlRMg+VVKCLuoTl/G5WDdpIprxIPuuAkrypY29X5SySV5/CwMXwNFzXizNhEmJyoLZtMcWzgwglZaFPfjL58rBeYGz9g8J1AeENYOJQRYdG0yDWuhIaA4M6jsQVMNVMtoQeEbiZziTY7gLCJFAvWj9LNUZGAhrAkdHlcIWLBMKIPCaQA1UGRYBw05Ar3lxPVjLaf6iaj+Vmsf4/ixCeBMoqlLcHbNQ3ayH3I5sjvZ+vqzPZR/UxyxJvaotRJD/XuOXg2OM5mfms5nU9zdFwnofWF1k4OIKZ3aXYCYcnYj2rzshkM/9CweIHOjK/+9kYXcArZ5wDsg0MqHVpJaqysbQ6m4DSCptGaNsCN2zZhtDk422WbTfAFQgcAq8+mA507qz5ln35tpKJtk1pjZhqO9XfcL0eLxc5cX68b3UPoDb8ukvWwB4F4pFVZYvUPsY2YKeNS8+fVArZZyQabVkXEBBzgwwSNaF7Lhsi1wV8eoAXWDl7KUc0JCFKNeLiAc1GTD45pITrqQC3gPGCSE6Mi25VxvdVw2L4Brd/RN6BSE73Rq0SOh3BBjLWIkGUPzXKDOJZJLtOQAEJfF1AMOla7O2TgWBtGDVsFUmhp4xKBHAwotn994WCtPIBiOp9gvSUIB6CBp9rKAgazA8+FTNl6SOE20VR0Jy18vaYU/fkSB9TwkEIKwHDT/nYloNDOoo5zzmIEEVNml4TZIDeJ0qk2aaS85h78eXfR3nsfhO9kF4BJVCRgangCpaD+Kvaab6LmCwgJaFB/QyZsLZl/IcCisBVmGnmMIrf0obl8ZHTOhuJJ9yOFHzdUIOMspzzACEul2kGYFSyCZjBIU+MSqwdVo/3WBIVHHRZuZnygWCDQvC6jxhdanHmbMn6OKAw+Ucy4NF9v0bpQf089YmqQO7rYZ9IzDU+TsCaI0csEN98SBPgJuziEyBI1/3xDUM/OXgYW+lcPOaTNY2ADBn97CNX36WObfXB8d5P8zK7zlnbqllvtTB5fPEhm1btuUvUtkCwLtQKt84W2Op/l1kgQMbTjiP/J30JPLH+iq5OCtnrR/qnWjOgtBoaOw47+xeaf2cYDPAagI0+/ABAhQUXJWLYjP487LSLUAVwJr4vX1vVA8pEQIYO7FHmA+a05gUxFjfZJGOiUCJcoQrR6XR6VF8frQd+Xefd3SqPx782j1S0yNSAZ/eBG4LSlxB6FRWOjGyLyIKkAbUtElIpjGmAvKBovUzbr6oNDiD+svY/QpGDaMm4rAWNG2LokU+BwAYuKKDoUE1eTYmnfQjxSCgkww82dwqCy9I/dp0HqVZyKZO8a8L2bxKCuhzZG/P4kfHZjqOCv5C9s20ABgPoO1/YAbWQOq1br0RqaMMaGjQAJKhbMho0JzMy4R40iOshzxGjABCAhEJ3Urm6BOtqgBAAvUBMelGy1wMqAA/bxpNnUQpmzYzA1nNoJI6wnoPWF1gxPMr7M7XWK47HB3ugI4igpp+fZnaQNnzMyoe/LUaow31tH1ojy+uIO7ewMnF5tmZApO+fdWzR8hBPuJ7W7KeVNmL8oZXz9e2CKm3jGuv7iHVuU5Tn5vkq3Ube081NR6k0vdN9+MlL5tA/fM5f1vu6bIFgHeptJGt2ZwFJ+w8WMjn1TtM75yej63AkoKIY+Gw6heEYcdpDUyz5P1NzH/KdrbBaUImig8MqYBQPsD6yxnY1IPRjMntxo3Lrt4WiY3naoAMMyFMSGDLAwwgC2hJPSYdSnP1s1IgEIDsRySRvgIuCldcqdsvlFP+eGZat05wVE2gtiXkpPWMsOTs65dMcwoU30w0iw1T1lwYEA49o1syuqOE7mQQcmYA1JX+G6CIy5Tz9hphcaZhYQalBKyBkCSaVcythBRKHypqIAU1lIBhYESjaAGyCd6AZFJgbvl6oYs3MSOxZkFpeP1oJppI6gJAlMHfejdk8Jf7qOA2EzIbqCVSkyzngCpAwJrX9Amli7bdUtetNVOJ02ISM3iAzLtAiJnyKORAIZqRRJ6mMOnfSKrRlPG0Z5HKBiARQuKsJe73CasLhPWFHmf3xPR7eLzAcGuG7ihkADilwasi1NsAIz+nfWmOaU3I5fsx8LP3jAKqWiUYMYt/soFAd13/XzaZqDerVr9utrIIMqqWRPUYmAybycaF1BFwfqtspDhCs7nUspbMR8aNwZQ21X9fP6/I4PVUgPsSFjKO0xdx/rbc22ULAO9CMTPp1I5wKvJrZIJxcsv7pWXha4nMgwgyMCEMQsjbXyCsz5EAixUQoEEg2fdI5aJFB4da0HlhlltZgUUHglSoe3+ith9VvRnRNX2d2uU7wZ81BX4sdREj1eYxE5KiAOYiwGvAZuBa/sdVCcc0sDHM5f4k5V8b5iR5ZbuGgqVZoLxmYtRmVqxmpqLEiMviWxZXqdYcurHxZkBQA3TMv1FBftboGTefUbYMkpUiajvDOgkAXA7it+doVox2xee+hQGXYGOlGwHnT5j0zbAg0BBU45yKDyaR+Je6VG2WRYMM4PRGWK3jb5G96vc4zLVtep+GhQTmmIneQLDnJ8wZXqJoKfP46XjZ/RPtaUJYCiiGaQGNJNtpRqsUYszglDQgyeaH0yxHIHQE7klAu+NHlE1BAXsSzWx94Tw2pskcFoTVOcLyImN2folFN+Bk3WF1NEM4ChK4sHYAyAMSD2QMJHlQsqm4ud76/Y7MwPbe/a/89QIVEOg2uVNANNfpN9J6TXbtzs9j69/oIre9OdzzoqIDwg4hHZkbBoFikWmTG2Ivf9CAokbO598bsHqvR/9uy1/esgWAd6FUlABTBxBqEJFPtN+K1oqb87Iwcw7KqZMMEbNDRnciPHVk/mQmBFWlNuToQreA++ujBp1ZaOUIxSL8KwqGti+m1Wjqn9ImTA5RLTfHTthuQaMBGAZCzwEdpex/Jzv6AmQsTy2IQIGBAQq+RGPDquFLUaN+52IaTuZj6RaYEQhsFke7V9U4auCPcZLFpZgWPU2L+RSZf2Kmi3ELT6YjMcCzLiDBawsJAA0JYQV0Wq/wAgoZc/Zls/tFJBx5U/dCNxG5TV4LbJoVEEgzKNAggMd4FkkdQ0uEK6mW2kzRAkqpF6ctS+NUgHdN45IUGFbuAIMbDwV+OXXarIAt04SElQZA20bGnpdeopVzirrR5GyitxOEFoYIUYFc5omMClyVKDpTDilIzNl9KnBvWlYuAWKRsNoPOLlM6K+scHH/BABwcjwHHXWIK0JQjjuj/qn81AyweQ3Z7cCfTbkpjdXt8IvWXQV3TJ3DAIHByV2kaZP36xPwhBxIZdQvxR9PLxO1n9FkYdkkUZINMgIQT4rpVuixeDRum9o12e1Wwzfx/acN/G26B8/n/G25p8sWAN6FMqnhgwo6T7PRmHfb83MSeu8TaCACRaj1C2B9htCdEBY3EmaHcHxkKNowy285E7CR6zLBkBFXff0CAlGDvfa83IFpcDeim5gSqBOL0qR5tQGWnIKYD0NCCKnWVOoxWSsWAIaAwKwp6sU/DUH8gZjUP2wDyMv9MdMRUGkNpkzWHjjnHM1uLCr6j1gAT144XAYOM3Ga5ixHdHeU7zV3QX2TGGE5CACx3Lt+jumxreleiLA5t1HqVNDi3BlyH4Ay7kb1wfX5lRYVMhYhp5QTcGSEzmSg0wJPDPQZuHegxjSNPpAmj2dHGBYhc0DGNVRTanl6nRbbyJ2TguQp37agGk3NSOJNwSmQcgQKAM4UNDObtCH7l51GAmxzK6i2v18QlhcJy8sJu+dPsJj1OFzO0Z90iD7qF3CbAEw+Y5vcKTaCtXZzY1/54zHxHvX3VQq0rEHTynyjqIzNmJibS3sSZeoXtsh6x3nq+R4pAuiBAAL1jNkKeTNl7h6VKd5ReY0AW7WJLbK8+DGXTWc7fpvG9eUo2yjgbbld2QLAu1RuBwLb34AxqBnrYqCLvJh2TYskRMXAyaWA+U3xAxM/qiIIRduAHBxRUZCkcXuNbNcv8JVzuJn2WtmYBXfdl+r/FJCyn8mPFZxQHQ1FOYnNBCw5gbvZICDXRb2Wa6kzvjXCgAMja3siAWFhAyQRromKr1K5bmljgANrEwDW0+rkKOkI0Q5Z9KguXmbWrEyNxm23YnTHqXDROV87dAGsZsXBzKcdZR+/sB5Aq164IRX4oQtIs5gBo42RpYTL3TWTZteMwUR/c0TsUDJ7FLNoAeY1GOZ8HZhZ1DSLlsbQUhg6LbQB7wKiof6FYu5Nc9HADTOp28jPA7gG4dpv7zfoM5DIfZ6YhAHgpCAw+08i+xHaOKcZQANJdU2QhvSDYVRDHhyTRmGvzxCWlxh8aYX9nRWGFHB8tAAdR833SyWAa6JUgV1tMUzlntNNG5jWJJxHZEO99fmFGquVD6Ngk4zIJ/qSfV85jxcPlOeGpUqsNopUrB4UCdwrQOvKHqcCcL6vdwp8cpML0M2WAvf8f9qCQLZlW25TtgDwLhTT8k2q+jcAOwBjYecEozfDAgoWNKNHd8zoSUDgigjDEpqFodSb+ejM6d58gRwtTKXlc20ZaQjZgb9qN1y3vbbhtmM00X1d0MGCu25nIrbLUAKGdcBJP8OFxTF2Fyvc3GP0O1QFgQjwCNlnqK5PzYZDqVg0WQWwDzO3kFo/WMGf9Tc2XTVgYoulBq1Y/VlLwOW7rIFoxo6SRaQOQrViF3KBA+a7yJGQEgufX8+IJ0KyTNpoYgZH4eIzLr0MAJP546lqBUBOk2fN4obUPLcR2f3AzvPjUBVtR76XQTWYgQrYMM1hA/7qm4essR3mAFNwGsACHrP/mKvXb3LCGiAW4nAfEFOuQ8VUrmOA3h3DRkKdEPqQg2WqdmZaG29qNG2vjTFVYGG9Szi5TFhe7XH2/DHmXY9bJwv0xx3isZgzLXDBZ4/J4MPfm7zhG4OTSisH9xsc+LN++OMaYJjPdf0uXysIdMEco4AVfT5HvtMZebrzkg6X8j2mSAiMmhDatxVSd5pDNIiNL61dwFO7eF/JCgR7We5ldW7zeDw8IH1Z08BZG+4UzG46f1vu6bIFgHejuId804NfmUMwLeyqVGCKMmzRFQJno+4QX5bMzbYg4bZTAebr9cLLaGGy4A/NM85eSHM5zi8QTZ8NGIxY/91xIxOe/3li4aq+99fV8ykBvAo4Ws+QmHBuZ4nnzg9Yn+kwLAhhpadlfyvXv8AZlPncrmGdEE/s6gFrHbjKbA4UfzTVOiSg+CRZW/V4UuAc+sL5l/3VGC7jg7tvdq96o/rRqF01X3IkmRPOXGzaXnQBmAm1CRDlnCGVgAYu+YHTPBTexEEiqkkdL6lpWzs3KoBh4NYAlj9+UN+2TKejY2qLoUWkE1ByNiMD9o1uBXKLcnATzQuArIDLAPVjBIZFkOhoex6ToAnJn6tzYnBRvzEU0GvfDRotrT59AhBDuT8p1GPEvj2UNd6Fb1K19K6fw4KwvEA4uZqwuHyMcztLDEzi+6faP4kyroGUr8P7/lXPtJuio/F0X7bgzz9/7M/zFU5s+so5JodUpjRttzoIKHNDx8nG0PJ0F22gXtbItiHPA+lv5F0DdG5WINSDYjTPn7V7chNTfzc6ZhMQfrnBH4oMejHnb8u9XbYA8G6VRgCKRsIJM0xoCE2YZCHJY+CT3DGWwUO1LgFcL7pwoM/vhm3H67UFboEdpSebAH+b/IvkGB6991QyFSt/dd50fRuLCW/NCXy8EgB4fn6CeG6F1bkO/W5Ad5xAay5tyMDR9Uv9A82XjhILRUpeEAnDQPk3883KQThzJUVmNSlZNKcTukXbgMp/Lwxc+yu2x2qgRDzRCFXPb5b0AgMQAoMdxYll7bC0uNTHYt5UU7D52RXtkxzMg37uAsA8SiNnvnOAA63O7CtjI/WZVgxLu+9BzNymsbEoWYtaZogmNjbAptXmtCDFfMD83MzA2wYWmc6HuLRd/CpVA9kFUCRgDQf2kp4esnvEeD6yaA4N+Nkl7RlqnhnLwlMHuNiYyef1PmF5mZGurnD53CFmccCNg32sD2eIJ0KZ47NZWB/zf7cB8RuXkdn+Tp69UzDLSNOW5QVX92ljvV5ecuk/GPXmJl+n4fvz/fLX000tExCYhG4pARxZ6INixosb28b+vW3e23PsOH/MBvCXxwW4/djczdKC7Bdy/rbc02ULAO9GaXbilXO2FwTUyAiTGXaumiC9BimntrJgkjD2w0PSnMEMDLuEYYHMJ2cRqGACJy4ZK+zlcqVmcMiloV4Y1gvMtHTwpsxRFhGrx45tBaZbVNqhk7qtTwRaE5bLDifDDGdmS+zvLXF0bhfrPcL8lkSlVouUXavR/GXADAADI6SEjgFKAXHtAKBL0SZ0MQH9DtDviNaGuxpUj7Snrp+s2hAaSEAhl2tIOjPVSKr2T8B/UMChvmoDQGkA9SxMI7GQN0seYCAtAtIQJR/vSgc8m2G1MyNQJVlEag2haPLEZYBdloQCbrOfo5r8BOgO7tkIGVQO86BzNlVzyTYpWXPYzJdq0bf51YKzBBkjONAP3TyZL2JiYCgVswZ4UAzAMKgfnqvU3kYSM7pF9XYhp3YzH0Qz/bOL8s1tV61Wy8Vpc2SYEVZnCavLA86fP8LebI1bywWODheO9LkVItPzaxPGmXSzmJij7biPgOTE4z8V9OHbND7BHedBuw6WJ2JPbpyQytyrBIWCfUv7JwEfwpZAPZBmXD/v3DTBgz2Tc9UD0oxBli+ng79WMbAt2/IXpWwB4F0otqBmvxUHpsyMW6UIAmqA0IC8HC1sVW2Q5rbIhF545jgCqzmwPiPXod78nKSupO3ImgjP7QbdhScviK2DGIMpBxL9cbD20ngXPx64ifdumHji2Aw61oR+2eHmcgdnZkuc3Vni1pmEfjcidQTD0qYx8PlmpSJbqcv30m9G1ONTX3LSek1XioSwYMlk0RPWAzDsiOP/lKbIZ1bJvG9Gz5LUb1E/e0LjbDKz8QSBgqvTjlOzdIpuNSTzhTNtXyjnWCq6Xn2zlEjYOPgkU0qJGo9mts7gV7JfFF+qup15PFmAbNFIhxzhS3MCcVC/Q6knrCU6OM1ice5vx1PnUzYVhmZuThUDXg5TWkCNBcxQSsCQXCSngr1Gww4FizAql05T383EF7Pa4LiUglWebr850t9TRM73Gy6ssL9YYdl3uHm0g3QwQ3cSsvbP93PS9Nv89+PQBmO048b2x4Okth5/PV+mrk2o65s4z9efGQyS5Cg3zTZ5f9BY5EANHEs/0wzC+9cD3bFlANF7MkGLU1lqXLAbo277qGhfvctP+3v18bS67nLZmoC35XZlCwDvRqkEskhZcr9lQGeLFupdoyy+GO+uK+BVLjLlFE/MoDUQV4RhjXphV6Fp2qGi/UMBqyZMDbi5ur0ZkFMj09u2uv8V+HPg8DTBQlxVWWnU8nWTCPPhJOJgOUe/F7A/W4F3BqR5hJnUpk2UFpfoFisz9ylgt9y11Au4ytx5+lsAgDXrDy7IRDVv7SJQzOFiWg0KKEPPElQAbes65WCKlg5jKv0WQfu3ToirpPQnNdgBIP51XRACYxZ/NUkbVwBu9pOyoBIDfyvh7Atr84eMhS7HwDhLe/Os9wsyW5RtWaiFp88+B8TlkLWvHIAuyMSxzCHejcDPreqzjlM97m4s3CYn88Rpto+w7EGrXsy5gGj/Zp2MWSQFDK5TodQPMtoZvffs+mxmTZRnLZ/j2sxBAj+Wlwiryz3O7Z8gEOPWyQInBwuE46BpH2mU0aMFdJ4MeQROpoCdHzcHpNn/1gK6ibG283miTa7q+jwuQK4iskYByNyx5MLWjQPr85XnRHN+WJfvAOTguCzTPAOCs4KUTXuLTuvnbar9/tiqtGP0MoK/fP0XA+K2APCeL1sA+OkqtihN7KLbMuLIcqCQWTQ8w0xSw81vCOFtMmoRB/YqYObMT1kIO2E/0iyg/OYBY9uf1lfQ15UB4tRweC2AvZ0SqCao1Q9wue7Qp4hF1yPsDBjmGvkMOIqPVEw/kTR6oAAtI0j2ACtwWUXMNJrNjWamJCAiIUU1bwZpoNfsCLASbRaR0JIwA5xI/DkVDOaxJTtPAZ/5yflI4XbsknDchXXI17IxCoPUwUQgzewRevHPI/V5ZALSIqKfaZq1KOMT1SQdlwJM0yyU8dD7kxfQDEgUPZyyeHgSaTIAzABS0gAWgAYjVzY6GmQ/wulKkRdwD1ZSs8nJ2Vg0A0hYD6D1APQDwJzBHxv4A8agwF+2o9zOFCmn97M2Zbqf7PdHGczaGA0z4fw7vj9h98oRzu4scdJ3ODjcAQ47hKUL/Gie0/ZaOROG03C1z/No3FwpwRWuXg8kTgEVrQVkdI3TQKuZ/x3O5gCknhCimG8t1VsG08H9RwH2cYD4n6JouU1rbBvvQplFrh1l3p6qqWv6UTa+E76AVl5u8Lct23IHZQsA70KZdLS2xfyUB3/kq9PuyNs63Xl2nBGbDgsAJBQR3TGQ1ow0V/80R5bqrxVyNGyzcNhlG0DXOmFnARhQtD8e2HpA12oO2rHy9fnfT1u4BkLfRyQQ9roV5oseg/rkpZmm4urLxYkBzho2iK+YW7BNgFNKFd+ekQCT5arlgJAASoQ0EDrT+jJhGNil3FNi4Jl0RNKeaeTnDuWxtOAQMdsLgMpaGAN9FrQBaVf2UzPuuUE0dWw2YiCnhDMTuPeXs3y9NCQghEwibdrPMCh58krAn5iFQzEN69wQKpYAipwjngkOTINGhM7VBsEytqgbBAZGTGIKFwCntDU7BNoJ6ImQnPm0uCRMg4isDR7ElB2XwqsYTwaEpfAkGvizqN5M++Kip1XZK78liEa9CxhmQqmTTJL6eZy1fgW45ihnOzwIqfvyMiNcPcGlM0foQsK1w130BzPEo2L6xSZQZs9D+7Lvp54hcj9xuZ/tczll5pVxH6OciiycXN1TbfZjoFpR87cjffbMfzlFiN/vwEjDmCA81xUa8AqotrnwP2YTsz+PMQZu1SbWC6YCqMebXZ7sX3vuy1m2ZtxtOa1sAeDdKP6hn9r5ut+mOAH5FGHTCvCRds78ByNhWDCS+r1YvV77J6Cn1FNpDQYU3xdbEAIyPYddq6KWQFmIcz88cGu0BhUQ9EPTLjR5Rz0enwJGbUGQjCC7cY0zu0tc3z+D9S5htiMLOUXRKpFG05IuNlYXRwJBNGfEAPdJgdGgWUQUFEQGI8IybXBI4EECB3KU71o0aPICuNMct5WqgCXiNPdPIjvjWkBWzvThiZUJWSMlJkmJJM7ASUsYErACiMW0m8mjAZd+jAQ4ErIfHGB9jgK8oBQ0mnEkKcgZdkKOpLSAJPN7o4HEDK2gNZu9ZwFprryDDbUMsV5jSAh9cppEzqa7oFqasBbCRQ4S7CI41+Uw5jI3/SvnTF4zuhPV/B0PiCdi9iXLjZwnMUtWkL5sCDzvHyOBQgCTBICkuUY4B8quCWSR+4BrH4p51HACAf0uYXkBWF/pcfX8IfZnK1w72cXx4QLhKCKukFO+FXO7e7YmnqP2WWo3fndUTjluE1iaymCUZUXrpwcnL0xOGXH3ACG61mctJrmPaRCNYOq4tm54xgElv899yDtZBwKBSTnU9me67xPHtWP1FwT8jXgtX8j523JPly0AvAtltLNtBe4p2qxWEHkC1Gqx2HC8jyQ2wtmRn5354TfaEU/i653Li8lkDP4q069b5EZ+Rk74Zz8zjGVmu5hVO+t28QIqkEkDYegDlkOHjhLO7ZzgmbPKB3grCLBAAA8MIhLNHovWSpz7CegZnDsuwIOGAVj3sKwWiBGgLucTlo4pX56amMM6IC4LUOp3SYipSepIkQHNTpE1CFkbB6Q1kGIQn7u1RQSLJpJJtW9qbgRcDty++DjKmDBiGjJ4MfCYwawvgXKQgwRhmJoLmXcwzYJk1lhQAX+hqI+MeiaYhjElqUI1loOCv2FWmz5bzR1YfSABGMdeBoQMyR18YmniSjCNaF6n6hQwFleMbpmyNtPMvuiTUM+04M9egUFdhOVY9sdZ1K8B29TJ/Qw5eKc8F9Uz3wz/MCOsz2q6t4vHuLhzjJ4DDo4X4CNN+daTzklkV4322bI5BA+AN5SR35973+5fJ4EmARsprdrjvBwAsv8wUD/jOeCbAR4E7PKgUfK2MU0sQFjlUJ0bunTA0vCx98VtQfEpm9FNfZk0Dd8h8LO+jc7flm35NJctALwLJZtyJ3fF8n3WZuW0WIzRYhg0jRZEu1K0dWOJTq1wYa4Am4GurJFo2wcDhIXCI2XNjhPQuuhYcAumNH6tUHR98n5toOZVtR9jAVo1tv4vvnPIhNA9B5yfHyOcXWN9pkO/IImMHhxAzZo/yz5BCBDOwGISHSQadEiiCWKX/zVzxLFooJiBXrVRIUgWjnVAGCKAmH2MkhIQpw6So7TV0Ch4F5MxI0qeOnAQyhGLyjU/MzNrxlUSnrOhROLaYgnzN5tH8CzUplY3FyTbjACu0JcgFACZsmXYUfBn2ha9V/m9bSBcqjVx2g8ClJQ0u/Y51cAQP6ZGsgxo1pKQ6VgoaYTwMmCYi2YVxunm55r2LajJtztJkkpPTdmZGBsQ8CuJiGHaJus34J6FRGVqhgCeRQw7Hfq9qOPiKHF8kEHeIAHZnK0geJhpureLjHRxjfP7xyBi3DzekcCPIwv8wMivr/KXtf+pPqZ9VqpSnV/mAxOphtyPqaNOaZ/j25RCRM+5OSPqJ/2fN36qiU8KBIWv0ckw6HjYBso2FQmIK6A7YfQLoN+jQoXl6Wnsftxp8XJnE7B2G2E/niP/Z1/fy1C2UcDbcrsyQVpxb5THHntMtD7u9cADD+TfmRmPPfYYHnroIezu7uKLv/iL8Ud/9Ecv7GJerZUXVlS8cD5aEkDt0M/NS+uscts2Qn1TEbAgCy71kjGEBgfWrBqnpUhRzZYLSS83zJFz6+ZoYXX2Nw1MJgqOjq/L1+1BoGoagy1mE4ta7qc7vxoLGw+qxxSrgBtHu7i1XmAn9tg/c4L+LGPYQY7uM7Jf04Dl3LWJM5UKZdOvNUIv4kAJjEaFFXD1CaRBBLTqEVY9wnpAXA6IJwndUuh5hIex3NPKfGWfHS2P5Qwedgj9fsT6TMR6L6BXqplhJkE/g/nk5YVe2pmiau12Avq9KK/dDsMiyjj4qdcFpE7MqkKLkhBWg2oDkdMJmjanjUY302u9kQjymoWcpq7VnBgNDRntTaaoSfmzPS8WDGPHhl59Dd1cCkM9z4RSRnz+wkr7tOwRVqL9G+XudtyQIAK6WPwlnSmNiZBmUczhC8suoW0aXLYd62oTvcwR6BeE1TnCyRVged+AsxeF8+9gtcCNAwn8iEvJ99tq/vyzVYHOCiDewco9IUeyadfX4zcV3rfOzPx6P+V8Bzr8vfPFP9veB9keMZUxJov6XTGT97tKP2S+f1ZdBPodQr8vEfBhDcyOOPuQ2mapBcZV+kXXh2p8qOlnHqfpcWzBX1tX3jS9XKVdV17Ia1vu6XJPawA/93M/F+9973vz5xhjfv8v/+W/xL/6V/8KP//zP4/P/uzPxg//8A/jS7/0S/GhD30IZ8+efV7XyU7PjRNwlQw9H4wiDDCOmss7bqujug6VY/2uVhdUMAslxVyCQebHUvf6DLJw9HQcAJRDDjm1GXuB6XavBWRM7KCbz7m/9sZ1ojIFtzvy28lGt5AC0sZwEnB8NMezJ/u4f+8Wzu4scXA2Yb0XsbhBCC7tFg+afSKpjxlx/mzmQCYS019KjruNVBtIFUiQPujCmIM1ggQyrJLbXskby0ghXak3AtRstzkCQwxIMzFZZ7O+aRbUrBwslyxKkIf47CmdCwGUNPo4CiALa+XfM22gBbcAOi7unue5Xe5tZZo3gKCbjNSRW8wLyG3NcaFXYLbsNQpXufjyAHAZWxuvQEqQTWDlPKyCQbT+MLAGfKQC/laSGxmp1nJWAJ/UP7IzoEzwOYK5C0g7nZh9zRQ/QN0CUNcLVBtAudeSPWZ1lrC8BCzv77F/3yEu7x9hSAHXj3axvrWQwI81AAeMqj62pVmsW7LjUoH7bxuSKXMuHPhr7nsLCnLglIFUoMxVQjVvfQq41m2m5C7nnIGGA4EilDLIgkIcKNY6OADDrjzjswMFfzo3qJ+4TijP4SRgdhq90Vh4+d2yM4zGZnzcHYHzbdmWl6nc0wCw67pK62eFmfGTP/mT+P7v/3581Vd9FQDgF37hF3D//ffjP/yH/4Bv/dZvfd7X8oJQPre/e6GlnGkqUEfRwPkkjOvLnwthtDlZ0wAJOJgpKTGAuGTNcUswbVwuVMBf5q9zC+nULvA0s+94TMp1blvaOm9XtC9hRegPO1w/2sX5+QnOzpd48twK67O76K8R4grgpMAkyYqUfc7sguYLx1RM72TACgIAfJ7YLpbvjaolkGSXSAk0BIkw9bmXSTRvibjWKjiQDRRNRU45Z/5MQCHptvvoFrTUSXtTJ+biYeZMYEmPUZoS7oQaIy5T0eyYyXim5u5AkklEweeU72n+v+HeT2XDMCqWsGYBZUMq4M9r4FzwRD5d0/Xxsc7lwXEWuvrjWiN9jxPicY9wIiAzB/ZMRbAakHbgz/z/OASgCxh2Z+j3Owy7UcDJIJQ6ORczIfMOZuoXMsAu0enrMwX8nbn/APedPUAgxjMH+zi6uYNwIIEfNJTUZ9Xz5eRB5V5xWml/H8mmzQ/exmeYmveuffmeNZu1SntpLgOuPxxJOf9Y3QbIgWgZD44spM66me1OoAFYhLgWLWz2VyXU/JPNxgVw4M1/z+Vz0YKWPnnt4YjPtXme8xDZcS8j/htFxL+A87fl3i73rAkYAD784Q/joYcewmte8xr83b/7d/Fnf/ZnAIDHH38cTz75JN7ylrfkYxeLBd74xjfife9734u6Zq0ta4Ir7DceC47blew31Sxe1fXU8R1Jds3rMwIi5reEH7A71sABl9c2590E3ALtXkN5eSGed/TOBOePu6NFqVko2P93/W4XlwKC1El8FXB0MsfJ0OHMbIlz546xupiw3jdgBAFHkcCzIK8Ysl9gzo0bqdCAGCWIcucJsEsF8A1J6EP6QbREmk2C1gPCqkc86dEdrtEdrAWMLDXAxC0k2X8JtiBaIIG2K1KdYo5Qa5VssSWAO0K/G7DeD1hncxlVGg/JqkDF7w8oIFYXrzQj9DtqNt4JBUhuAv4o34lfpppq2/vPzjS7FCLq1udQxpldmwxgi+Yu9Am0TuiOBswOBsyOEuKqkExbxG9cMuJxQne0RjxaIZysQMuVBPase1A/5JeRPyPGigImNztG8O4M/Zk51udmWJ/tMCxkToWeKy1x5vpzvH92z4Y5SZ7fC8Dq8oDFpWNc3j9CRwk3TnZw89YucEsCP8KainnbAyoun/MzlppjJjZmpnnKASo88duUZirPOZ0zfg5Q+3vZjFTPM2r5187hHKyztoAdcZuIS6Ehot7N8QjNuFI2rKFnzA8Zu88mLG4whhmwPCeac8n+wQXQURk7L0tbU3bufqMFLZrxMfjL/XPj1oLIl73wXXhtyz1d7lkN4Ote9zr84i/+Ij77sz8bn/rUp/DDP/zD+KIv+iL80R/9EZ588kkAwP3331+dc//99+PP//zPN9a5XC6xXC7z55s3b+b3NQWCCEvyDvcmECYWxrZsMhPkiN+8y1QTswE4AnJe4EAYdggriDA1QZscoGi1TsSQ9HF92Z17MwaNBBvKQuLS2VFj+poEDfaxAX+b+pvb4jbsrD5EYUVYn3Q4WC1waXGEK2cOcf38GazPzjFcJ8QTraALSEjqE2raOdegEMBIQCJQCmDWoIHUNHqQVd8yiNjijzVr1GbKWqNAQDyJiAtZlDgSyIJ9PHCyMbTFzkzzuqh6k7zcM1afSjknzcRvql/Umj/yc8/RxxgBc0uJI9Gt5udZwGN17/wmBgoAOgYP2sQGwJNGfwYLyjgaEI970NIBMOUflApZ/AHN/ssMy2AToApXf20FIRb0JBHDqvnrUwaV5LW4BvIz0HefoYt8FH+/tIjod8XvL82knSEZRU+rGkP2VzUtXYriy7Y6B6wuJoSLK5zbPwER49rJLp67sQ++MUc8DJLv1/wb7f55kJcDw+xi7jnMgz5qkntuSsaWkR/klGbUm5PJf+++Y+T7Q0nz7PiqMth0Eb/GqQhG4LLxMa2dyCrCMGOxwndF0yt+zkIFkzWlALiD+grK+Z36P3uXhnZjMuXfdxrzwG1BXTv27TFT9+YlKtsgkG25XblnAeAjjzyS33/+538+3vCGN+AzP/Mz8Qu/8At4/etfDwCgdrfPPPrOlx/7sR/DD/3QD03/yI3w0EVJTI0Thzd+fpORekAdCGJVG2kuvICWA0x48grZjJI6cZqv/OdYjmVbYICxFir3A2gXdV8sojnzcTUagPpgt2C540Y5Xx3QM+2UN83Ye0oEWgN83OFwOcdqP+Ls7ATzsyus9+fiqH9sHWEAAbRORaOx5gImCEAMORhiqlQgIrfVOOgUqDCDZp2YbAdCXA7ojpU3riWxtSoUgA1z+WxUFi3PYp5eqk0La1mIzAxZcT7CzUFWIuQTS+0m/TCamDQLErmr5uPsr7gByPsF0ACYIDCSPK7uPpm5zzRz4WRAOOmFimWqJAZhEN86F7mNDmC2DCm6SRkYYdAxTxIZLb5/XrsXynutS7gQC+AblSDjwp1SveRUbwq8XWCPmKPdhG3M12km2r/VRQZfXuH82SPM44CD5QI3bu1iuDlHd1iifkea7kYjcyr482Vqw4lpoFcVD/TRvLfnrpV1drk2dzLrY8ECDE1GCMUSivawV40qQzYn2ZIgwD4lLtQ/Vm9EJib3r2DBbz4NHLn31o6prrcb0YnN60Zt6aiyyUtsy7b8hSn3tAnYl/39fXz+538+PvzhD2e/QNMEWnnqqadGWkFfvvd7vxc3btzIryeeeEJ+cKAmR/o6M+gIeNkxHjQ1gGBUqLy8w/XkcbogWfSpjzQFmwO+8cg5qoUG/GVfpo6yn6DXSpUo1hINnCk/NHJ49HKAb8pstLFMLmTIpj9aEQ6P5zhYLzCPA87tn2B9LmG9L1QmYjqyNpKAHc0ykRcDM41m7YRdW1cxNUWOskaYj6C+qFcewbUAnXC0xuzWGt1hQnciPkw+4byZt4YFsN4jrPckojG5Ba/VKlUaQ2/mbRYv+xx6AX9xOWTfO097YhyDbZTl5CLm5rppfw2MUS9axmARuzlqV3gGJcJYwBklod2hQU3pg5vUbjxH9wEGHBRoaTYVIXlOiEdrze0LNe9bYEd5teZ9tMDeLuvmQp5rQzEfyvNYu3rYGJnvZb8LrC4w+itrXLhwiHM7S/Qp4MbBDtY3Foi3IoIRPvuI1RYEts/H1CaLJl5Tt9BcH1ogxGV+bbRWOCBaqG/K96Zt8/7Cxc0C2ZQ7LIQrs9/VSN6dUFw2TE65iO/8f41iJtYNkMnFuBK/59A39wOuHU1QhuduHPW3Ad93BOo2gfKXUfsn7eAX/9qWe7rcsxrAtiyXS/zxH/8x/vbf/tt4zWtegwceeAC//uu/jr/+1/86AGC1WuG//bf/hp/4iZ/YWMdiscBisZj8rQ3k8P4j5jdS7RzzIuqET3tcK5uNj46mhVtrnmUYuCIM0Wg35LfUoRDqOkDBhAIoYtEqFbPfWC5U6543RzNGi+KozVPFaxY2aRKtPtZFYUXoT2bZDHx1/wDPXj6D5TM7mB0Q5omBgXL/sqk1oc77mkQLzFGjgYGi9WMWoKLgTwIBGD4bhx1DSXwEOQaEJLQjs6AatnlUc3DpI0AYtF0GDoP5air48wuuaECE8idvIFCPt82TMGgw0HJAWIlJ1MzXPI9q+jWOQSqLuWmaJ4CAb4toFhO6kwHU6/w06hcK0vZBNxwWcZ0goGtD8Ed9Pa6+5xhyhhELxqCB0R0PGvSxlshiA38BMkChmbx6T2kwjXAD/o0mqE+gPiKgcOKlzh40B7ztXqrGlYMAnOUFwvJKj3OXJOK3TwG3jhcS8XsQFMiMs31sAmKtb92kadb95MnlR4CPsNEkfEdlAhgRytzL7iEo16mAoRI3hzlAPSOtKFMntZrO5OZ56GVOp14m6ADKPqh542vPuh8XG7tNoG9i+rU+jHdcPs1awa0JeFtuV+5ZAPjd3/3deNvb3oZXvepVeOqpp/DDP/zDuHnzJt7xjneAiPDt3/7t+NEf/VF81md9Fj7rsz4LP/qjP4q9vT18wzd8w4u6bjaHMRCcT1d9ELLmwIMk+ZpHQrUIes7/cjCJkyiFjkZ/G2ThTJ0uLEtxth4WwPqsmBsrvz9d/E3QZlNlBiYou9sGpFm7vNA+ddfsxqTVHrRjZv0lNzQe6CJJOrXhJOLG8Q5W+xGXFke4fOkAz12dY34rIK4I3aCAJigOYNFsDqoJkqjiQaJA0YFjFCCx7oFhKAuk+QD2VABFVDWmgZokFRJH9SeLyrFn2jHKT58Hpfne9YU/MN8HlvsnOYVFQ2j3TMbCBqoZajOXro3gupAej8z5yZCxVkOujf44nV9xbQEXwrMHABQInEhTeIm/oxFRk3LwSURuA/5C0HFEDdScGZiVX3BYxLyBCQpAw8kA0uhrKBk2acS9+KZSMTt7QGngL4rJ1/w3s5lYx4V1bI2Mu964ufmodfa7hJNLhJP7EhZXjnFx7xiJCdePdiXi91YUvr/1WPNXZfU4bSGm5md/n3z78gMzXYcAJqrlz9RxU2Vqg2D/fd7wwNkJsKUISgzQQJmOKqxk7tgmmfQ88U8Fkmr/4opzUE4lowxgugCqybbepn+jAJZ2I39aaWX/iwRk27Itd7vcswDwYx/7GL7+678ezzzzDK5evYrXv/71eP/734+HH34YAPAv/sW/wPHxMf7RP/pHuHbtGl73utfhv/7X//q8OQCtVH5tQF4UJmWmFyZO4E4BHFi1dyI8bIfszDKmVRKTimgB+x3KZM80ADE5kOHq8Wbp7JvkaRUsQKHZqZ8G+LgViGiOd7v86nenBcuLni3CSQHTccDR4QLPntnHq88+h1eeu4Yb9+/i5OYeumPKGrVCnMtIJDeKGJIvGHJfeBZBIWUNAgXS+8DAcgCv1/K9grvJVGu5T5TBSA7e0Oubn53NlWrNsPHU9oaeNTcsZ59BdhljvMYZKHOmaFya9qn2K6wTgpreDKyZCS4falli3EIqwGtAdyzgj/oE4yIUX1rVwnlw1CdNwzYN/rLGzr73QRldQNrtMOzEbM4X7a9GFa96AZYZqCedUiF/zprPqCbgLiLnLjaXgCjZPizdWyY995ySeaNV+mBpyjgA613C8RXC0UMJ8YFjXD53CAB47nAPN67vIdyYlYhfDWaqNKunPUt2C6wNE8+Wf06mNIV2D728su82atwx/q16flsNmW1mvHywDYY951RcHUhlUIqE2Am1S1gjuxGwbmZ5LpvYDFx1s1oBZrNieOCX52EDck/R1I00hzlQacP5E2D4ZTf9+mu/GMC5Bav3fLlnAeAv//Ivn/o7EeGxxx7DY489dlevm02k/qFv110qi6mlfWv5+SpTDQFotIW+3mIadsTSeUdcds+mRepOgPlNiPnQ2uQ1flVjDXwo91bvooMDAd48nBcxzu3K7fTAzo9H02/S79p2ZDATikw1EEiqPQgroD/s8OzhHq7uHuDy4ggPXb6BP7+xwOxWh7gEOpagAeuEtTX7sbX3LgfDUE0RYwFDRCXAgAmT5sykWUbWgwQprBLCOopm1vlFlnuh6eNQxjSY79NKCKrFV8pNBh+A48GDAQGN8KVB8+0q/x+tBwQiRCIAIW8KxKduKNHC2cewINUwJOE7XBrH3vRaVyI+ISZV1aBmH7zc8TJ2GYgZJ18Qv81hESWwJxatYlwmMfsuh8InaD6bzCLlWp9OoGj8YhQeSAWrBv6GhQLAGVVAIAct6QT05k4E8Wc7uSzgr3vFEe6/cAsxJDx3uIdb1/dA12foDgX8VfMfVqcfvIkBnTrcgy/eAPzInTB1HXYbgKlrtWDR6vFj4zdv9tzDPb8oIJBsU2cbTgLQqZLQ/AUDAytCWDNmx6Lxmx0KaJa0b5ofu9mcjsrtwN8msDP1+/MBdJ8u8Ae3iXgR52/LvV3uWQD4chbLNVub4gCvjZED5SW7Zq5BIDG8xqYFUVVeTSdMK1My7BxU5jsDTsMCwp3XswDAmbyGOYFn5Vi/czfthGkPjfeMCEgm5R3YRNuH3D8dgwqcoh4npxWwNk+NXRsNCDiQehxxeLCDZ8/s4+L8CA/t38BTV85g+dxZzG6pr5WaSm28zJyZ/SvVJkWDpnrzgR8KBKkJIuC+L4AwxmLKBMTHbN0L0IoB3SxopG2QBc58z+DGAOITmFOLDc29MU2KnpOCM02ijCugWhUNggnrAHAC1H+R+oSQer0vndBqDAqqlr2YjTeZvJSuxZcRoTMAsPqaJhQyZqKiMW0AB+vY8iyKqXdWeBq5035CfRstm8hyAK37um3WBvUFpMiS4aXadFABtzE4gEcKxKnWJFHh90sZvCsYDRJBvbxUwN9Dl25gEXs8fbiPWzd2QdcK+PMp44rsKPd40oLQAhEDdW4T4TGL+7n8mJA3jP5H07DzlCbbnj0/Flpfvp61wQNNQ4Bec6bPW4C6nKg/rJcBRkGUVMsdiUBLRlwD3VJuYL+QrCop6ubIBYQUFxlrF+n4cm7WbcuGZyn/tglMn1JO065uy7a83GULAO9moSJs6pypJnwccDNB786dEihVtHD+bsP13SIy2q2zaI3We+JHlvMD+zodyKiiD1MBd7mfumhW5ksXpJLb7ECdF/K2CG/qS+u3kwXwFLC2Y3pCOAH6gxmePtjH1d0DXJof4cELN/FnV3axvDWTFFtHQATLmqRO5BwJiYOkZBsYYSg5aQGIPyAlcAwgywQS1Jmw7wGltSADfzGWhdRpCsNqQDweEHeDUPN0Yqa3hSp3RxfjBELU4BzvPG9+fQCyhiqb7XUR9AuzBPOo5szhJDCLFlDHMCptTFiLqVaidLlEyiYfPVzMqHnOW0S09dv86xR0ZKJnr5HzHHxRAVnUSO0ZFTOs2xAYn6Glesum3wy8Qw3arah2sUr35oseX9KbFTO9kIm7ue+K5K8FlhcJx/cnxIcE/O12azx3vIfrN/aB63MBfyuqny+4943WptIuotzbus24bRkFjsCBQDe3sg8u3PFTz6gDjUVLXr88vZOkUUR2fTAQCCaJzcmck3DyBaI9Dgr859BUheoHqBQwYaXcp4w6LznXbd04XlNj6s8HapmGIpdP1SZOXfflBIAvNpJ3GwV8z5ctALwL5bZOwUURkt8LsOJKILTRvW1wyDTprAokuIOb62bTnIKwIVCtBQBG+TWnTERZQAOF0sGZfEDIWp1qQQluMQiubn+dBuCMzEwGbs08zPVxBlRDD4SjgMNbO3j6zBmcnx3jwb2bePq+fRwenEdcBvHBs+tGjbZVnCDRhw5tMotGKpKAQAMx3tQYAqhD8SmLSjWiAKnlRrO8ppKGjZQ81xFt+36jGRf9PvubEUDK2VdRCRkw3zA15V6L2Ru9AKiw6qWtauIuvoXSZ+qHHABjuZAZAHpIgAVQgmCsDkUeZNrS0HTS+/nZtdXkm2LIINDPM6MxisuUKWXkXjqtLDkgaqDVAOGsQ5p34FmQ9pj/ppuv1m9KlDdtBZxQuY8sWqp+Fzi5TDh5cMDi/iPcf/4W5mHAc8d7eOb6GfC1OWYHE+DPbdo2apJaYDi1wZs4Z9L3b+oaLQCiiZ9auULtAc0z7+sh5E2vuWtY5LaNIbPPogIgFpmROntPoBmKzx8U/C31WejK97dNYzYxDtXG3W80/XRtmRzaOtuxnhinl6tsTcDbcruyBYAvQRkBQg9WvLCcKNwIzfYhrAJHqPm+3ZXajluPN9Oi7azZFucpYdkIcc5S3AFBF2GXNXO+H759AWPh6BY/6w5zaY+nNqnAsIJAbwYvpiXJ/7s+nOGpW2dweecQVxaHeNWF6/jj+3awPNxBdywmI2uQOPUzIidwm5rMRaDKsRHoEmjtdtddFBRmxzjNH3diygSRaNSMekQBnIFPjkqM6wMt3L2o02cV3j10Ri5N+X5MCm7zozNTKhNopeBv3WfQRmRpvwowk065/rrfqDf7NFX+YxnMATkil4mAma7Qt1ugSTWAzgRLrAEBK0Z3Moj/4Vp8DxFCDkARjbUzRft7an5/s4A0j3UftY3mb1jlonXHlehUASfrfeD4PsLJQz3OPnALV89IwMfTh/u4cWMPfH2O7iBMa/7y+Fq/3QYHm4HMxoh4X5d9bMCdWH71/mmUdPUs3WnZACYz5rG+2H9rgm7UqKecqo16lnYNurFMLjgkuddgmybohs8od1BtEqrN04Z2twCvBX/58AYY3vGYUPPdaSB/W7bl01C2APAulElWebdLNyErx04cZxoF8EiAGAiszIO6GMriwCOhnX2HvObAABpzMaeRE6qkvoAdMnCcWqgqM02rCWiEbqXNTE27Dfx4DQjZeLj2e0DrxixrAqvdOUpE8FHA4c0dfHz3PPa7Fe7fuYVrV3bxiYMZZgcSEAI1GxFBTOIGjgYqAQjeFzNSNlGCSKhhWpOm8cplDRiX71MS8/I6SeTqOqjGgsQNLgLQNHF2/208J03iwVK2qWlyAjhW5rgOGBahvjeD0tyY1i6GHDQ0MqF6twY1tWbzMADKiN2BZgWTHCWyWoCav1+aD1ivxZ0Asyr61o7P2U8kJ3BY67kBYGuzgT+LMtY+ZU7ALuQAEwCZENz7I2bzs11f+TBtLgZ1nxgWhOV5wvH9jNVDK1y9/wbu2z/Aeoh48tZZ3Lq+B9wQn7+4wexb3QuU+5w1ghPP/VQ57Te5SPmfo+m5AMHqWbsdCNwE/FrwY9YCBXLFeiCvoM+R8EMiu5ok25iSnEssmj7TFhJYssRAZZqb+96vssz9Anbz941M9f3Km818L3i6z6eV5wOkX6ryYgHnFqze82ULAO9CKQEbUz+6Y1rlkhdCKpS8pisLMPuCmpeBOnctHyziM3pkAcuQXLSq3SAuhMPrfQkUsYhTckoUD/ja4Ix24an8+5wQIvfdJpNXXpgSREtpl/HjtGGci4YMCCvCcDDD04szODtf4uEzz+E1557Dzft3cHxwDvEkYHG9UJ1wEIDELL6Aok102qouIHWCTCkGhBBAqx687vMgVWBQfeGICEjKj2dAK0h+4O44gIPxV5BEP+q9Mwf9nGUilXEFIYOTYUEC3E1b4hevrBERR/oUSag2OgKWyGAVvfah6wrg86nTNhWv4bOLT/jUcRfA806BXaxIt8PKAm0E+KZFh2E3SvYWzUkMqNlXU9+FnstY53Zw8UH0wFV9/Qz8pU7Nvurjx4CkwYslOKhkrChpxnI7BkbqNNL3koA/PHSCV165jiu7BzgZZnjq4AxuXttDuD5Dd1SbfXM55Rmoit9EnQL+RrdmA0irgjR8G/zz5erciAlPeXYrMNmAwixDovKNkvwQ1i7AjIVzUXL7CvjbOZT7NczK3Kk4/4Dqs2lufdT6ZJkYO6+BPfV4nvjOfe81h1Pm5Je6bE3A23K7sgWAL0WpQNMEcSgVYeVlkzfvniazREPENdBCI2BagaN1Wr5fys7s8ltYA90xiobOC3IHrgDUmozbaQOmjrP6wvi8kWYR5f0oaMXA4kgAkxAQHwWsuwU+sXMOFxbHuG9xC5956Vn8wcECq1u7Ygq2fKGR0AdCiIwYWHzeZlGJljmbT7OZN4nqgQCYjxxjEGd3QP36ErDmfIyYSwGEgLgckI6VJJoNINSaQOunpOiTU0V7SzlCMs3EDOnvSx5j/V/FQCTToA2S71h9GAGoeTQKuApFm1e4AW2iaV8MKHqfyXwP3PsQkGYRw06HYSeUzccAhAUjrCKCZuMYFhHDjmk1KT8rNLDm+RVqmtye5tnKPILmSxgp+2HmSN+ArEEyszF3EFPoYM+FBdZQpbnqZ5rd4xJw8uCA3QcO8NCFmzg/P8ZRP8fHb5zHzef2Ea91iEeO5w/u3nDznOl9qjuCzAe46VkjTIM/6PfVAs4Tv8NhNap/y899s4lrzcnVBtX71rr2Z1YenduVC8msVEYB2YWABiAsZYEKmvZtWCh1FUvKt8qHcmoQpr48DdScBs7uFLixA3t26qcLSCVGG2H/vM/flnu6bAHgS1CyAMiAxvnntccBqKLxgtP0uOMAIGuGYDtbHgt5J4DzcYBEt5rWMEF9bjQTxkIW+O6IEZdwztiUzStZQbAJ2DUgcfPguAWA3ELl293Us9FUY2blKXOwajH5KOLgxi4+sXse52fH+Iy963jm6j4+fmuG7qiTlFIrJYQmpaQIgKnUaBYQBjHdSjsVfJhJcW7aPtVAOYLj3C5AAJOBpmEALdfolMsu9MJtF+bOpOsd2nU+Wfo+wAMUFJDUaEDacTfQkTOCEIFnXaavscAV7ocCVqGLsgG9KeCVkgBG9fWrryvcgZK2TrV6sYAqYpIcuEOEkSy31CvEmhN2JaZf6jWoI6Gg2ygATjj8YtbytW3JJWq7zO/PnquujJ/XKCMK+FidI5xcZqzvX+PSfTfxinM3MQ89bqx28ckb53D47B7ijYh47MDfaetoRmD1dxn8TYHAVkvXPPNtGfsRj39rZZbfiBmIq3er9TiZH55PZ5evoWMQEiT1YiybFkA/zxSzq38fDYzZIRBuiPZXoqzluTDrhJHTt6T11seRP20zhpvkym2LG7P8sb0Xm06dchfalm35NJUtALwLxRzHvZm33QX6Y+2ATaJgiv8OKICn8udBI2xbk4MdZxo3Qo6WBRhDEPoKDqTmNRXYdo4K7tacY6bJCnC4SFRuBG8GpLbzdwvsyBzldtGkGsqpxY5JFGWZF9DGQ4FB6Bk4IfS3Znhq9wwu7ZzDq888i792/hncfGiBw+V5gALmN3QxUVWI3KMk2rBeuAPjMlWp1ACIP5kFdbCplAo4yjQpjYaMEgN9QjheCw/fMiJqajPJPkEYFkGytXQF6A1OG2X9tXkhRN3FId78AgFbDJGvLf6WhDTvQLMofTBtWYJEA5t5mBX8eeA3xfXnKV/sZcTR6juZNWuxBnhm1hsVt2GBgoIM/ljAJoMKEIykWkYxMwtvpQLzVMY/B3oEaNo/N3+c9s/mGxMwzIHlBaF44QeWeODyTVzdO0QA48nDc3jq+hmsr+2gu6Hp3XoU8IYNG5120+OegY3gzx+P5js/bq1s4Prn0bleY5j0q1D/7u9Jdb49/3acuV+apSAHcADokTO4WMQvuXraFwcxtw87pDymsmEzEFh1w7ex6miRi16TmX2vVW5XlpS2nAbs3CZ/E6h8uc2/+dp3Cmo3nb8t93TZAsC7UDxpcyVoCKPPk1rAiQe1ondxQtcHlJRjrTL7omkgm7DjTAljoIGD+uJ0CjCigISc0ksds0daSafZyFoUo3A4BQBWvnpuIWkXOglyaNY1D4b9ouSLLVoEIAnHWDwMWF7fwUd3LmCvW+HK4gD/36ufwh8x4TCcQ4oB85vIwTCy8AQkzTUKBElFNWjjM02KOqVbRC5QfrP3MdS8eAaYesktTL1qtIaE0AUBH7OAfjeC9hwInNByVL5cmpeXNHpSwLOjhqECBDmQRMDmekp0MPXioxhSAtK6Bq9eo0aEKjNKIDW1hvKb+t2ZFtBrf9m1yRZQmVcMvxEIg0b+rlP5reJnLAPCXUBaRAw7UfvMCEgS7W7BTapFl1RyVGscFfz5OZoiJKfvZcLRgwnd/Ue478IBzi1OcLieS2q3G3vA9ZnknD6hrJnyJWvaJjR71X3k8fuRb93E81VptuCO89euMdCpmndigDdFIE+YtCv+PgOThLyxMhlSqIuoom3xQWHGE8gkWldWjXjoxR8wrEq9k88Eynyq2okydhWP4ybgdxvA1s7d0ThxY6F5mYs+Ai/q/G25t8sWAN6N4hYWL3S9WaUN1vDmTzMt+mL1ZVPv1GWdz+BUsXqrlGy+zUnZ80GZiDV1yNxnJowrzaPvlwl8Z7KcMi/ltcUvaK4d/vjKZOYXQ3csTdUzVR8Bopgj8K2I6/Mz+LNuQHdxwCt2riPcx/i/EmG5PovQB3RHcvOGGcAaKAPIYpN6DQyJpJGv0gBKQwFHFnxgwAgoJuEQckoyDiTRr/2QARNFyuPKifODSSlIe6JmRfA+VO6eZvOuZqSYKmZi5Y6QiZKhwKmTYA3qNavFesh8h9SjaACBAu4U9NlgcyDJghJI6XKC1h0KBY1p10YbIS7+qQaszffvJKkGVjj/yLSQRLJ7yf0zUFeAhqTMo+JaofcodaTmaFR+fn6s0oywPkM4uQycPNjjzP0HuO/sATpKuHayi2u39rC8voN4M0qwx5Iqvz1/f+ReAj5PdztfW01fdYw7rgLP7t7nB63Rmlf+fpuem4kpM2XFmCSwTqg2KCUAAznCPrDLMT3I/RYXNcqRvp7WxY8JJzP7suYGdtdxrzI+VPqjsrmVFxtpXZr+TtJrTRw7CvJz1/Pz/bacsduyLS9j2QLAu1AyIEGTj9cXkyG2SycCEReZ0exSpd6xsBDzJuc6TEARj+VTrrfaqZajTOjGNWOAaEnM3Gj5YAFHDwPA59tkUtBnL2u3j1jlcp3R4uj6u9F/sAHPBZiOD/Xt8iYkrIF4Qkg3OzwzO4udrseZiyu8Yvc6Dq4s8EfHc6yWO5lDEAASCTcgJdKxIKFHUbqYMAgw4i6IRoqSRJyaybfRlnFn9i5CDqLoB1BSMBV1N6BAEABmiRGXAcO8ECKnjjDMyj3JCknrKwitdkjGhAoADATihNCn3FeoqRk5WCKCovzO0cyoSV6a7YS7WPrj0rtV4G8WRSu3CNmc3d7vnHtYo3yNI1D8IzXbx3qQ1HymaTWC7Ub7QgPneQsUUAidq4aGbCyT01oXjbYQO6/Oi7/f8MAKV6/exANnbiEx4anDM3ju+hmk63PMbgX199s8L3MUPm94BhzgG22A4MAFAZmzz4G/CiAaIHNauFFbGlkz+s4d21otKlO2iTkq18yUL7ZRiZCAMwXaYc2ZRsesBmkun+NSsxT15dzcf9UQWqRwBpmtBnBD2QTK64Omzrs9YNuY+hMerE8EA77UZSJI6nmfvy33dNkCwLtQaq0Xj75rd6Osi1CrCckaIKr9CStTjgkaL/hoM/gTzZkLHlENTFBzcDG1MRKo5ATuJSAkzTT6bqYLVOsj6Ex6Yg51INEvbKbZaRZIb3arzFftuPk+OS1EtbjaZw/+DJesCfEooJ/N8MnuHHa6Nf6Ps8/gwd0buH51F0+cXAbSDPObpJxjchPTjJF6AVw0kGo0uJgVEYAZI6EDGXWKmnZhgRRmIgVKFhF7AaLVWvXqLxjA6uiOZY9IhDiLCqYChkVA2BV1x0BUMiZEAYZFG0N57PMcCYU+BkDm3yMihI6AwDnCljyHHmz+MTDoAIeQtX0YEhjJfU8ZaPI8YNiJSOrAD5T5Y+/jmhGPE7qTQXMP+80E10EfNg0UXHpKGZBoZ8My5evDgETWhlGZGzY+Np+D+COuzxCWl4GT+3rsXD3Gqy7ewOWdQ/Qp4BOH5/Hsc2fAzy0wOyAx+fb1synXcX1kYAT63Nz2JQdcbdI2NfJikya8Nfe251hdGaC4c1oNf6VtDDpeBsYYWbNHBHCiEjwa1R0hAuhEhsQVgZXTz+7NMEfOBxxPgNmJBjzN6v5mENwAv9uZYr3lofSLsjxu67f3/ng/fnfk5+er3WSOfonLRm3v8zh/W+7tsgWAd7NM7LhzMQ1DuxNl999XZZpElEXLfM4AFK2YaQXMFGyC0PlSmemrAloNbxwlAYXZhMYaVJBUK+aAlp3fsvsbXUkGiY0Gw5u+TIhnzZTzVWs1IKPxcguqLZb+f65LozcpazTFH3AVFvhovAgAeOX+dbzq7DWsHor4FF0AxxnmNwjxRK6RooCC0ANDCogr1ZoBoECgwIp7CJxkQCRQBKIVbHfRSQNJzC/QolUtuMR82nqlamExx/K8A6WYaTI4iFk1K1oV3HlXhNGc0gU3dST+hn2SfLp9ApYQ8JUYYSl8hQKuSPz4UieAz1LBxSgZUHzJWTYkDzJ3AcMsCFfhTIBjGNgBdgb1EHqXox5xqeZ0qoMwcpS1AWbzWexCJrYOffGnDAjiojmjHN1d+SASkDOZGPiLQL8grC4Qjq8yhgeXuP/qTTywfws73RpH/RxPHpzFM8+eBT03L+DPUfSMSrMB2ui2YIe721bjHhsMFDA2VY8Davl415aRtrA9xrc5ld+TBW45oEjm6mnBLk5rSwlIqVgNsnuIA21hTaLVW8tUgo5RWMu9rNInWtsnAGm1gXTtL/3gscxxwR/+fmyyQmyi8qreb7qvm9aDbdmWvwBlCwBfqtIIBXYyqhImely7MHizT7X7d/WOAkKoCLfq2Fw/Z3NYPt7eWi5g5UFL0RyvGbNbwhGYv5+jaNdUg1IDQK4WEG6vZ4LYEe22tDBlQakXvEltSu6jk/S6aFkbRTMppjo+jDimXXxUT3/F3g189sWnEEPCJ+gSiGdi7l0BAYQBDGIzXwYEYlA0UMuIUJwX1BSayJEwO/RqfnRpAhjqsRKIIr+XzAU6gMrhl134CBhY+fJg94RyuwhF+5DdBAg5+IGD5PNFX8zBmUyZBGB5EyvPImgYiiYuCnglaKBHUACoPn9VRo8g4C8uzaTLCgAFuIX1UFK2mU+YRe8C4wUYUI4/jZJmgGRA6ueCyiYDhExB4+dQmgHrPcLykkT5xgeO8fCV67i4OELigCcPz+GZg30cXt9FuNGhOyDEJY003VOuDBWJt9/IAM2z2fRNn19vxh35TvpzG0AyMt+65zRbIsycXF24eY4Ay65XXERQACCg/n3siJw1z28aKFsZktHrkGyqqKsExq8AAISaSURBVAfiwKC1aP1A8t3smAvQc+Pn+zb53n+dicnHY5LlowfDbrxGYG/iGjZmVRSxG798jBfNE36IL3lp5eQLOX9b7ukSbn/Itrzg0uxKufm86RyvMTv1ITYtioFFd+xIswa36DX1Vs7RFvQRgX4PWO9Tpm0IK9W02CKi2r6wRnHOnvKBCiXaMs0lc8Uwp5FmoBof9zLN4eR45GNcxgw/Hv4YbW9cEsJBxPFzu/jY9Qv41MlZnOlW+OwLT+OBB69hdbXH6hwjqek7zYSCot8hR0khdC3Z1GkmJaMqmcopbLQwRLUJGED211n3oBOhhwGgact0Ie4TwmpAPO7RHQ3ojhlR70kY9LVmdCcJ3TGjO5Eo5qj0PqFXgJ6MSBkZaFJKCu78dUMdLRkJPO8kpZtF98aINO+QFjPwIuZzWM3VNkbEyP583ZH0IR73iCc9wqqXMWsjjlOZ32wAM5TxEOCoYNI0oxp0MsxD9vOr5pfXHGmE7/HlgMPPAA5f3WP34Vt4zX3P4vLOIQ7XCzx+7RI++slLOPrEGXRPzzC7GQT8ZWBq93cC/Nncvd1zvKk4jeVU4MydlBL5jZE8GF2rAYwyl/UZd76/2Z1gJv57ySLVXe7e0EN9OkVuyDy1ABDXFnbRvYO4Wqx3heC87kjdn+nOTmwUqB4/Ys7zP2sVHfhrx66qylc9AcTvRJv4chZ7dl7M6/mU3/qt38Lb3vY2PPTQQyAivPvd79547Ld+67eCiPCTP/mT1fd/+qd/iq/8yq/E1atXce7cOXzt134tPvWpT1XHXLt2DY8++ijOnz+P8+fP49FHH8X169efV1u3RcpWA3g3Crkdn+3Yp56dBuBM7iAxsQu1c9p63PclKs929uWESe1jo01EFpBqgglKlaHcW0G5t+ycTNlg7P9+IQyUG1TSak1rMPx7r91row1z9c21Ti0T2pgwEBIYksMj4jDs4olwATtxjc/Yu47/z8Wn0A8Rz6QLACLmt4RKZphLUIiZJ4NbFNnyA+v4l2hZAkLUcQhCqwOAUwINHTKVzJAKfYo7n2eami1BwJnV2wWEGCSLRl9URJItgzMgymPvtB6hZ8TlgHAyCPDy9DV2/UzjolrLrJlTrSERWMmfUzcOxuCOMMwDhp1Qp+5Sc6/R3pQbo+DBvnJaP6Mjym2E9ieQcvylbNI1zeawUPDZlXM8OTcCMHQS6LG8RDi5moAHlrj/4i3ct3+AeehxbbmHT14/h+PndhFvFmLn0KM8cw4Q5a74jYvftNhxE3O2Mne7+rzmfCrwYyPg4PJoV5ooAzuhXMQH5VA+pgSWiUOf/GhaP++ukTV7qtE3LlHbZArYopx5xY+bzE924NTJQ//sUzNsfnw2gNlW/k4FydXj0vhdu+tkztP2PFf3qD3lsRzXe4+Ww8NDfMEXfAG+6Zu+CV/91V+98bh3v/vd+N3f/V089NBDo/Pf8pa34Au+4AvwG7/xGwCAH/iBH8Db3vY2vP/970dQxoFv+IZvwMc+9jG85z3vAQB8y7d8Cx599FH85//8n1+int27ZQsA71LxwqQtFYhpzALFv685txVujVCbcjjmOxE4BjxN6KfmWN2RA4xhJkEhhcCXc9AFrTG+hheo+iFFZL6v3D6fLcBp6UYL2yagN/GZXeaHUQYAIJuq0YvJKoPAWx1udXv4+OI8Ls6P8eDiBnAF+P8x8BwugDiiO5SFn7tCwxLWGrGYIAtcCoji+ieW5y7kIIsMqoACrrooQSLMEg1MJTjDzpGAIcswUkBY8V9jhJWSHQ8F3OVAilDqtEhKGkSLSGsHKEMopmI/FZRc2QidWQmdraQoWjbuqFpAxfxrfn/IkbmSgq6Ym5mA1AVtGyvpd9ECMqgGpnn8Sp9YY0/MtcGItEX7p6ekslFhBS2rs4STq0LvcvaBW3jo3E2cmS2xSh0+eXgOz9w4g9W1HXQ3I+KJ+Kx5fr8220WOjk3uN6clzM9r86xtKi24mYrsrr5vZEEGgTo+rRuJpxFqI7OzZkzfkwaIBa2XO3murZ4hQHNMG4jjDJQzAbRrQ8skQDBQr+e4aN8pzaofn7HWruZiHZlcN4zjqT5+E3LXu1b4c6a4YCfv18tREiYtMs/r/OdRHnnkETzyyCOnHvPxj38c/+Sf/BP82q/9Gr78y7+8+u1//I//gY985CP43//7f+PcuXMAgHe+8524dOkSfuM3fgNvfvOb8cd//Md4z3veg/e///143eteBwD42Z/9WbzhDW/Ahz70IXzO53zO82v0X/GyBYAvQfEBHOCyONgudDKSzAQFA5u4/Tamf0MtmCreKr9bziDLp54jWNhe1sBZfEKvGq+IEk0J5F2+RAhT1Y520fLaP6s7uCCRScd0q2dipz8G0c34TBXTxFgFLCDQMmD0tzo8Mz+LJxYnONcd41W7zwFXgf+LCdfCOQzXOsQTiQ6ORmfRcTb7MgVEBVthLT5wpJo9Wg/KG6hm4b6YWQFIUEUI8p0Bm8SibbTgBwWE7PkFEyMeDwjrJPfccvw6qhTR9sj9tewZ0oaU6wQRGEkjepFBV1JS5UKUTBrx7TJ6WFSxj6jVOWcAwUzP8YQRlwr+spaR8pxFoILxDBC6Z8dAoEXJF0BjASE0MvtmQAPk6Pd+h7A6Rzi+n7F+xQqveOAaPuPsdQQwnj3Zx1MHZ4TY+eYM3UGosnq087NSFrnNSwaCbl632M+PVe4jynf+On4eT51fgbfm2E2aL3Lvq2fNaVtlAyN1hYE1uwchDQA0ajezAHQCBAEodRI7s7GkWjRNX0giQ/L1rH5z9TDNeisDXJtHgR9+7kwAv8r/z47zY0Xt8eVZtLH2Wkp/rSlfP/ng/p8C9l+q8kLMuO35AHDz5s3q+8VigcVi8bzrSynh0UcfxT//5/8cn/u5nzv6fblcgoiqund2dhBCwG//9m/jzW9+M37nd34H58+fz+APAF7/+tfj/PnzeN/73rcFgM+zbAHgS1SqTB6YwDdOK8DGpZZPdgsKUABbrrs5Dq2AbE3AbrfKRSi37clfuQVdghI0rViUxbA7YnRLxvIcYZjX/Fx1pfrPBZiYn2CbNi+31YGLqd1/9dEvmhMAFJBrZcVS1hbpek4EWrPQw3Rz/PnsEgIxPvvcU6IJvA/48HyNp86exfLmHPFmh9ktB5xNVaKakBgDOMhNC6sEJDGXAqy78SR5gIeEqXRqJcKXRCtnlCoMCSzR/LVgRjjp5VzTCHrTs/Y7rz/2mwuqkAtxxUWYYsy+f0Y5kxYld6/PDe3v0eh+6H0QrWQSIueTAWEl5NJSj9rDGxMtoPM36G0l0k0TgymUsc+5fBWIes2f+Uwa35zRu+wTVheAk6sS6PGZ9z2Hz9i/joEJHz+8gE9cO4+T6zsItyI6y+XbRLTLeKIGGR78Ncdu2qzY8dx8n7/DeO4DGAWUtJtJdtPSKvKMARkwTmy6PBiUOCqppPL5TaptHihr9z0JvPlWcgRYn/ewlg6bLy0NwOwWsg8moHVms/F47Lws8GwGMo41mJuSia3lZdP4tce1QDvLNEdpNand/YtQJu7x8z4fwCtf+crq6x/8wR/EY4899ryr+4mf+Al0XYdv+7Zvm/z99a9/Pfb39/E93/M9+NEf/VEwM77ne74HKSV88pOfBAA8+eSTuO+++0bn3nfffXjyySefd5v+qpctALwbZSTYuQA7K1QfXmm+bFFLnI+rNqWbAI5bgIq859Fvk34yGwQDV4JVBHiCZJcY5iLwu2PZwc+OCvUIMAEK3G7esjq05l0PhJP60iXTLFA5phoDrr/PUX+AarDqcYGBTl2gAMUdgyxyxAzciDjhXfzJcAVDCvic85/Cq3efxX2LW/jk+XP4sxtX8Mmnz2ONHTH52s1QbVYwImdOCANV4VVMkulDUWIGNIhqCjYzJwzcRPBCgy1CKAuUmmJDn0B9L2bhNSqzbNEQek2g2wDkRrFSz6Ry7S5I5G5HSPPiR1cFUgSnXfMaGLjPBPW3tKCUAWEplDaSH5kKUKkW49Je1rzC2b8vuOdJny1L55ZJnZtABLCCjD3C8qLQu6T7lrh8+QCvPHcNlxdHOB5m+Oiti/jEs+eRri3QHQQNdnIm33a+ufm40We12bxsiv48NSrUjyvXr5yu0Y5rn/H2WbG3VO6dB5NMEE5Ju7cM8VklKsDPTOkDgJ5Fcd0RyDj7QqkrdaKVZi4afwFehNmR+Kqu94xpQHwHp8BbZZ5uZV87dlyf0x5LzQl1AI/zASQHEk0+e3nurt1eq93Y3wuZP5544olskgXwgrR/H/jAB/Bv/s2/wf/6X/9LN8XjcvXqVfzH//gf8Q//4T/Ev/23/xYhBHz91389/sbf+BuIsVBOTZ3PzBvr3ZbNZQsA70Jpd/DABjDWCCVSJDiZqo0cUISCnCwUdUEHj2V/0xY2YebrbQVkc15uiy4Qwcw4HWHYAZYXCTQEzI4ZO9eSRPTOgdQJGLKqyo6+Fu6+r8lrlpo0ZyMfwcbvytddqq21pVkzA7ewQS2jkDp5sEUuoh928ThfRgLhcy98Eq/eeQavWTyNz9i5jt/tXo3Hh6tY8xy4RXr9IuQH/Zx6AvUBITISRQXCCTRj0DqA1qGYc5VoOZuG9TuOETyLQnbcWXYO2STEdZL4kpUzJzcLTTY3m2CMARZ0UuX3beaAaD0ovwdKWsDsRjCoMmTCaT5vAvQc4edzkbyqsRS6HC7BIGpaK89C6XPls6rXSx2pllKBoJs3gGwmhjmwPktYXmIsH1jjwv238JqLz+Ly4giBEp5d7uNjty7g6WfPAs8uMDukzE83SnnWjlOq/1tQlI3DaAMDYPSMtd/dZqPmg6TaMuVWMgqY0ikwkkM67ZIeZ2OZAhyHJgGWps31Peboe7f5I3mWhwWJRhyiBZwdMmYHcvwwJ/R7whVIq+IzOEop53wVS782oWnXX24+++/s46Y6PeBv5SVvvv5G8OfrezlLaxV4IecDOHfuXAUAX0j57//9v+Opp57Cq171qvzdMAz4ru/6LvzkT/4kPvKRjwAA3vKWt+BP//RP8cwzz6DrOly4cAEPPPAAXvOa1wAAHnjggVFUMAA8/fTTuP/++19UG/8qli0AvJulAW0Aij+g201W5gsFV9XuEv78egEp4Khs7Uf0Mlr383GeBqkJemJBogQlg2aNsgSOrxL6Q6FvsHqrPK9+DGxxb9vizUWN5rBoOmpNhW+XX4DzWAA5Ajb30LQPpLxnJhc1YoMJYOUJpBSw5h08zpfRp4B4KeFz9p7EZ+48hfWliCEFPBEvYjlbYH5DzZijAZebxJ1GqiYGpSBAKBAoBNAs5shgJMh3q7X2g9TnMogmTlPBmXYrrQNiDIjHQqFSTOrSR7kf2n8DlRYFa4EngGrjLNo3IZz04EHaRonRQ8Are80QaoLxWmsHJZqWYzMo0r5UwSJD8U/yWsEy96gCvu0cks2I0gmZBlRBwzAH1mcIqwuM5ZUeiyvH+D8uX8er9q9hv1viVr+DTxxcxCdunsPBtT2E653k8l3R2De1mrDj+TiiefFz052Xu9WCwWZOj9w7WlBjmML8IFU+5EMNKFtz/LOEsTwxzTxgwVFaNIsHoprSI4TsvEdF5l3q0M2Ugbc8D6Ql8ozJPU4zYNgRqpewlhRwxjyQ5dNplDX+ljjt9ihSt5UXU6UBw+P6yzGnavPc4//pyvzRlrxheBHn363y6KOP4s1vfnP13Zd92Zfh0UcfxTd90zeNjr9y5QoA4Dd+4zfw1FNP4e1vfzsA4A1veANu3LiB3/u938Pf+lt/CwDwu7/7u7hx4wa+6Iu+6O41+K9I2QLAu1BGPiRTD04jhCpqA8bIPOHPqUClW2RaR+mN15tayFBrHk27NDLD6IJBSQQ1wKJ16VSId8hRfm16umSfW0HsBHwVHcwoqeSc6djvur1wzX44FkHtFg8DgaYlJOtzggAeVg2lM2fmXLEQEPjR4RKGFLC8NMNf230ar1hcA64A5xYn+LP9yzh8eg+z5zrMbhL4iBADS87eKK9umXJu27BOQiBNAHXePqx9yw70moFDM334BTFZTtvcrygLX58U01EGgAL+wjTptAFF0wyaw38a5PqJgRQx6xlpZsANleO9ZZfJVCHKhZi6opELvQSdSEo4yv0JA/S6rGbHEkks84ALoOxCzl5i1xWfP+OSLGOUZsh+fsurA+ZXj/DXLt3Ag3s3cW52gnWK+OjhJXz81nk8d30ffGOO7jAgLNXk6zU1rdamAToVUPR+lRMao7ae8l2jrfbV+E2fB23uOhuBjYHAND7GNkA2ll6zzurfx73y8HXIEb+kz0kIcBpzH6ij9FPumtWGMqjiMEK4IUlz/54ovRScTJgAf1PjZDJhxPtJzf9cSTN+7Xft4fbsNebh8YF1va3mT9p4iqy+R8rBwQH+5E/+JH9+/PHH8cEPfhCXLl3Cq171Kly+fLk6fjab4YEHHqgCN975znfita99La5evYrf+Z3fwT/7Z/8M3/Ed35GPee1rX4u3vvWt+OZv/mb8zM/8DAChgfmKr/iKbQDICyhbAHg3yoQwKbvyWsJ408AkJcAUgDxlNzsZUcyoObWmjvWgyiI8VVtZAU4DSGapWwNgRujUCdxhGVsMOSpJbFe+q8wjjbnOzrV0bdSjWmDyWDULaxVtqcAgK1IVBPoFDop7WOlDSmRraU8gACdSSc8LfGy4hMPVDM9d2sNnnXkKr1o8hwfnN/Cqvav4o7MP4ImzF3H89A7m1wO6I0mbF5YKbGNAXIq/U0IAAgMGZAyYJgYPohkMIQDroZhKg40LF5rBSGUhMlAWJlaWTmx4xFF8/UwzqEeyJ6WG3FOZZgQMjIBBMoSsHdF1JCQN3sigPdl9kmjkEAlpLeBSuP8KcOeoGiAA5KIpM5l21DmY8sOTffx8vmlAgjoGpXpJM2DYJazOAcvLA+KVJR66dBOfcfY6zs+O0aeITxydx6eOzuDZG/tY31wgHER0Jxro0QZu2JxMbl7b5sRAYJ57rq0esE+Btib4ycBCtanx50yBR5R7X7XV4ZPKfy6UfkwyD9iGyW280AsQpBnJ/sE0wFFikUhNw2EgjdwtQIzNb5NtA9A8p4P4D9u1gsYyyaapBn8bo/qrftu1kcd9E8iaDA65G+V2oPCluOadlLtkAr7T8vu///t405velD9/53d+JwDgHe94B37+53/+jur40Ic+hO/93u/Fc889h1e/+tX4/u//fnzHd3xHdcwv/dIv4du+7dvwlre8BQDw9re/HT/90z/9vNq6LVK2APAulIqWYtMzowJq0oxAzXEbr3P7tlQ7cqLKBD1ySlcQlTDWRFSm3GYBogQx4VHx+yGjdmCg7wj9jiwYYe2icFVAtz5+tkAEzSrig0Uqk7UHje5cr43JmgOuj/EglDwQZMCrLGiQxS0uBWgN/QzPLc/jf58scP3KLj7/wifwqsWz+D/PPIEHFjfw/+w/gA+duw/PPnMW62szzG4RusMCdnK9HSE5zYCZ3kxLls3WyouXupKFI6wZWDNCLxova6fU7SJq/fAwEMhUNrIQiF+g3sYQsvYvn+Py+Mp9Vv89pYUBAwFJQKCZZROD1gwMZbMTrJMGck3DOUDO60L2/SwbguLHR+xAmf1O0tekQKRfEPpdQr8PrM8yVhcHdFdO8NDFW3jozA2c7ZZIIHzq+FwBfrcWCIcG/ATAjOa3n1cTnz3H3ya+zU0WgWymtH7Z3OA6dV3VnrYu/T8VIEVT4GcTEHHjShrRHnTjhQREA/YDlUjfIDeX7T0pgGv8H4cd+X1+UwLGkmoSWa+ffUm5aUsGgNPy9DRyfN+vTaXq++0CNCpZ6S+0+ZTbljsEtXerjNLovYDzn0/54i/+YqHWusNifn++/PiP/zh+/Md//NTzLl26hHe9613Pr3HbMlm2APAulVFghgES+VIPwqkCanPl8o8YSLZomm32+RYTQuxydzKEnmMianlkSuLy2f6bOdt29GlWFkrjgTPgZ07luZ4GABr48ybH1hzk6SiEkkIBbqBpAe2CR/I9sXHVa4OQI4WDuNUhMiEMhNATlus9/L/riJvLHTx14Sxevfssrsxu4XXnH8er957F/3P+fvzZtcu49uwZ9M/OML8ecvuHWQmkMLN1UOJmXhuRMyNodgugAKKsKewTMEjwjUReAxYtm7U+5juo0cIpMaiPCjQTuE8a1TnATMD5niv4S3MBgEJVw5kj0uaCL6Jh0jYEzu3J5NNNFLLdUzPfsotebjcGplnM11EqomEudC7rc8DqAmN9YcD84gledfEmXnX2OVyaH6FPEU+enMUnD8/h2Zv7WN5cIBx0Avx6iK+nA075GcjXbebmBEAsk9HaTzj12W42Ue33Ijeo/s6AYQP8RkFSXMAoE20UCy3gqoCXUv3kTB767BKzuJEOVICc+e0yxKUiEYJqbTmVesMa6JaMdST0Rgru3UyaTV6r4bcxGI0hUI31yAqy4bh6LHh8nBufqp4NdUxGG2+aAy8z+NuWbbmTsgWAd6GMOPcImch2o++H2wUzZGGsCJzbYgLRfNusDvd7K/g3+hgZgAzTGgzflzaCuLpeErUDq8N4iACtgNmBLCIWDSo+XrpoVBoU1y97TwpyQyET9ho9AZSaY9QBRgBKo0MlwMO1d0pDkP23iMW25b9n5KDZyASkgKHfwcePOzx3sIePXriI157/FD5n70m8dvcTeM3iaTx+9ir+8PxD+PC5Kzh6eh/DsxHDLRLfSQN9ljdZtS1hbumzFAw6cx0xxAxr98CZKs28xx2J+VvnXYoSHWvBJWFNiOskY9oF0CyAhiiA0vkCGvhLs1AuwFCeQchxagLOAMSBw2waNs2gzWUL3uh8LuiAYVbu68jsad2NZuJVn9MFYX0WWF5i9FfWOHfpEH/t3E08uHcTV+YHmNGAZ9f7+PODS3ji2gUcXd8FHXTK6QeN2K6v4eeBzzk9RVTeRuHWhNRljp0a9TtRvLuIgcDKrNqAwAonNrjTA8H2OwDFXzdSDvKofO5IIndzJg/j59NsM4kJA+l59jwn+R8SJBXhDTlvdihp3vodIM0LHYwH2kC5vqdauSPtnJOVk64wNkjt923Vt8FlVaDJJnl+B/daNMB3OCnuRnmZTcDb8pevbAHgXSiVtiJrrYo2pxJCG3aJBtYm8wKjAENZgDYc40BUpVlof/eagE2dYmSTng8GKe2Fmn5YogctKwgz4lJMP6wgLs0YbNQiTvB7My/bomI+RN5PkAU8kSWYX6l/kVcOqA/jZPTgBPjLizq0Hzpw5iQfoP5OJL/HlfyWVjOcHEc8fjjH9eMdPHdpD19w7mN4eP4MvnD/cbxm8TT+7zMP4YPnPwMfu3gBh9fF7BiXJD6Cx5R5FInFmV5AGiN07MZGcucSySAEpdOQaOAyx4AEskhZ/c5+J0jUdkoha+jEbJeEl69PKDl0JdgDQNHcGcm03oec+i1Q7Z8Zaw2fDLVNWBSuvlkBf+bLGIbmPpIAC8vVuz5DWO8Dwy6j30vgc2tcuHSIhy9cw2fsXcduXCEx4Wa/g6dPzuBjty7guetnkK7PC6ffQHWghpt7eR448OcB30hT3T6/BsYmNFBTmrjK93XDZq+VAZWJuNk0Zd+3Vqh4oMiUNc+Z929goCtRv/asSqBHCeKBZfNQgAfSPOG+Twr0E/Qamid7WMg97Hfl2bGUhSPORKeF9ONXD5zrV/tT+3xv2kRPlU3grzk/k0LrOZO5g9uqXf8+LaXZ6Lyg87flni5bAHgXSuXwndgt0MicaaMFwmm2RgEjjVDKKeD8+VaoOcbqo1Jv6/PiOQWB5vpTD732xS+Gdh4ZUbRqa3hPOAFzGimgABK/66ey6/ecae2CKr6FaprS/Luh5xwBLdrHMt4Vj6B37j9F0BOgAMFAuJ5ChS8QAELSzBB9QFrO8dzJefyv4wU+dXwWn3vhk/i8/Y/jge46Xnf2GK9YXMefnb+Kjx5dxNNH+7h+sIfjazvonuswv0HoTigvhtQz0koCEkJfUmiROvCneZTFmJFTswEyJsnQmflO2fzIi49GdKIAw9QTYqASoGFaPpsbgEbfUjW3BSg6Xr5NC4QCelZtIkf1IzPTcDJtCPKzkDoxlRtFyHpfTLz9pTXm55Y4u3eCs4sVLiyOcXXnAOe6YwwI+OTJeXzq+CyeOdjHrcMdDLdmCIcRs2PH6bcJUNh9TmUuT6Yo5DJvrX+jLt9usTRwXG2i2L0vz+BppkJr56gPPkrePQtZxiTKz41p0g3UCKF2OSfNILl9I+XnrtKODlmxK2DP5lGnPpome/T5JBa6KPHvrccqB5e4OShdazSYbdkw3lNWi43+flSfU2kRDURSff3nG8zBzTW2ZVv+IpUtALwbRRc8SgYmjNOKgNCkE3JlBNqaOgEUM+4mbZ2v14Car4YBn/t3k+AcXX+qbmsXlXMAlF0/lwUEHdXaPvXbM0CSulJvpR3VsbCUcQL6zORbtBhZUzSj4pTu++NMTUBZDFug6TVBZOZgRexqRc3/ixlQ+7busFru4c8O53jucA9PXj6H1559Eq+YX8Ol7gCXzh7g/zzzBI7SHB9fXsQf33wAf/r0FRw9s4vuRpSI4TWBeokeFloM40WzRVcaOsx1kXUBGgCBlBvQg7UM4vSm0aAaOjWpExVePT/2QX0RAQj9S9Q+V36JCha6AjazBtz8v2LhLMxzV+8zJUZgQPINKyHwrtC39HtAv8foz/WI59e4eP4QD569ift3buFcdwwAWHPE8TDHnx9dwlNHZ/HMrX0c31qAjjqEE8JsTaB10fqNgJm/326+tcTOIy1bnljTdVW/mTxor93MdUZNFpw3ilTqyKf6azE2ap+IuQB0F6Uvc1sEQOghpttBnlmwpGlDB1jO79QpCHQBIoC5GADcAUhAtxRwBwIGKnPMtPZY67xSraDJFE+9lHMKT4zZRheUDWVqXG4HvE7V5DkZOOIENLnt76trazVtbqMtfCnK3coFvC33btkCwLtQPClrAR0TwG3qedoE7Nw5I82gW5ws4retMx/HTR1T7d70oHMBW1NmVH9W6FkiTCMybYdcAzlCmBLUJASlaRkDMDP1hp4zJYzkGm6Tsls2CLleGXvOkYyZ30yjF7NPobteHjLTwNjYEiOBELgGgbYeBJhZLSCtZri+PIf/fbiDj164iAf2b+H+3Zt4aHEDD86v49XzZ/DX5k/hM3eewv995iH8v5fvw6duncXh0QKrVQQvI2gZEI8CukPC7BDojhQI6gIKUNaSUNKI4KyloPoesfm66ZjN7B4qeIxifs4RlyxaR/FBZE2pZpx9DOoLgKwCc3QcMzGwLeo+qtdd1+ZD6sQsuDpHWJ0H1ucT0tk1ZvsrnNs/wZW9I9y/dxOX5kdYhB6JCcfDHNfXu3j6+AyeOdrDrYNdrA9noEP18TPAnCYeKAfo7F63ANCbJKeOaee+rztr39BosRpAUwE6/6YBdzbHKxDoNlvVZ99XL2gSZflgWjbThjHV5t0c7MGUo30zeAyApeKjxKLJnUukrwVudcfSjtR5twZ1YZgAybZ5qwJQbKxOia6WMdzgl9zc4/GYlPF6wZQsExvo+rnDxjnyaSlbH8BtuU3ZAsC7UAqfHuoFBY3/nS95J7zh9/ZYoAZhU4KsWmxUu3gH7d9IRguu1hRqhazTdGRCZgDktHEG9ATIAINLI2nnZZDYA3FpPn5lsSu5la1OUt/CEiAAFA2DB5YZLDY+RiHxqD/VKDAQwEhE2XHeawJ14BBgi15EOtnBp27N8PTeWXx47wou7h/jVWev4bPOPIVXzK/hQjzCF555HJ+1+xSeu7yPa/0ebqx3cWu9wI3VLm6c7ODGwS5u3Vigu95hdoMwv6UL7FD6T4kc8Kf6/nkgrIEtHpCVBb+MDSAZHlIEiAVo2rEAMr2IX+xGNCR5SApAHNTvL7lsL2lOWJ8BlhcY/ZUV9i4e48r+MS7tHuHC/AjnuiV24wozGnAwLPDE0UU8fXIG1493cXC8wPJwDj6KiMcBsxXpBqHc18nSzN3Wt2+6Hw24auq700V9E9iwyPnWCgAF7uA6M4o3qxIMuNuxqM8HMk0TGVhX4J2pYoLm382cm+66AaL9I900zeUc40wk0wbOuIrkzpo/Zzb2qdzY/gejlaFa8+d8qTcB5/FAIh8/SQUzBdjaY+7kOq5svJZdb1M9U5rCl7LomL6o87flni5bAHg3SguK4DRKEyBwo+ZuqtwNgUEF5GVfF0xcPy/uVP7nhb6mtwGcQHeKD3P2zl86rVtcMea3FMx0lBcCRPkuLrkESCRk36CUSa2L9kAoKaho9TZobPJiY6BGwdFIOLYcgy2QUr8rM3ODoU8PZUAZekI66cAHEceLOY52dvHU/ln82fnLeOjMDXzG3nXcN7+FM/EE989EOxiRMCBgmWa4NezgqfVZfPTwIp64eRHPPncGJ9fmmN2kouXKmi6gaPpKn7Iv20Ci1TNtSzbnQlCAX6gYSFHIqFtzlvkb1ppThtGyAAVgmvlxmBP6HZIAjjOi8U1zloje3QF0foVLFw/xirM3cHlxiKATSjR9Mzy32sPN9Q6eOdrH9YNdLA/nwElEOAn4/7f39WF2FFX6b3Xfe2cmIRlI2CREIBvUFQREBPxAEHTdCIJZZR9F1Ai7riu7fBhxUVxwQX+rgLqIisLiB34LPiuwrLJgUIHwsCImICAqrAZBJUaUfE5m5t7u8/uj6lSdqq6+d4ZMMkOm3ucJzO2urjpVXV311qlzTuWjxqO3UPE4ZZLQAZ63eUWrF16TYOJUiuYg9//xbo/Vkknl/lWSkGj2gAzaZ4w5Agp3lCPbCGbiJZdNQfgzl1FmxgNepAFkFwvIXXml+UYz8w03tipAKTSGCI0RQtFUlvxxH5Uha4Tq3GmemfzZ7XfXAvYbk+0EeFuvsj2i27BhO8txITzdI6LdqyDsJ12IZrR8uLE1IWEqIBHAiYIZSLpq9EJFRd1qUW4phNfC6+Fz4T2e7MSKtTLXiYnNElNvwnEBpe2kGFlZK+XyUx2dR0l6oC9bQKdUyApCY6tC2SQU/W6rOGsb+7dR3XZkYr6VDVcvSQAlobPbvbwVCTchSPLHdbSx3pjISicUVF+JIq0ckXZilBn+aCZKRfpUhLwgUEefK1tuzdAZyvH7TS08MXMW/m/m7pjdP4LZfcPYtbUVu/dtxtzmFsxpbEFTdTArH0auSuySj2DBwCasG9wFa+fNxp82z8DWzX2grTmykSzQBhoyZLyJs1HjKGMM7j1D/LZ+LyXBnzCZyXt5irYxW7829iKxBlbb+jnPT90/in59KsforiXKwQ6aM0bR19dBf7ODma1RzOnfgj/r34yBvI0tnT78fngW/rR1Bra2G2gXOUZGmmgPN0BbG8iGMjRGlTEDgEd6K5DvSKSpkLw68teNBIbkT3zvFTGCS2G5nLfbMlfgk1hkXez3rFCps/R0pwzIlAIJMgd2tiCtoQb0N8jacDRde5HUhJpvg+0Epfzs5Z2NEFpbyZpp2G+Y4wdyvxO2udKUxDs9KCR/shGCMUjLUjP4haQuhEcYg4E4kt6O45XrVdnsb5lfDanckXZ1yQYwoRcSAZwgeJ60YCLlX3OJ6/PgZ3kAqj3GKYbI98oEyaoTIqvg6GceIadOIxgZZIOBnfNQJsA0bwXa+uQKRUtPElkbaAzrI9MAQ/xajrzZfHjSZU0Vk7lCTHyA1XBo8sJHjPHkRt5EHBrdy+0dfg/SDsvaCJpts7KhyaE1flfKTKpkAmNnoOEM5ZYcm1stbGqW+F2rRN4qMDBjxBLC/lwfiNrISrSyAgN5G3P7tmBWcwQbZvTjT7Nn4smhAYyM6k+20SjRzAtkWQkihXaRY3S0geHhBmg4h+pk7h2VQDaqSSlP2NTwJzPdDvrkB9awUUb6PTR1xZlsAtrei5olKNcaUtVRbmuwvwRmtTFj1ggGZ2zFjGYbuSrRygs0VIFGVuLJ0Rl4rN2ntXwbZ6A91ARGM51PW2lNHwdtjnngSvJKrp9XtH11W2Bj1Ph4fzP5GwvEoqXyvOjHvRZmJOQM7f2khk1/4lqjJ4lwRtAn3nCIJBN/kbXCZUOTz4zzzPzy3bncZLV2Rb8CNbRtqCV7gpDyoo218yH58xzSZJuGY1xAsqshskTbxchf7B0rl48cb2sRe92y70XI/lO2MZxomAXANj2fsFMjEcAJQuyjDw24PURWkASx0ueBT8W9iOsGL+mVRpnWClRXobBKn+hKt2bVareGOdCvnOC4Th7BFNeE5k7nAWtnlg8DjSGtTegMaK/Q2phgrC0gE7qBtVUEu6XkTjlw4S08zZ8k1SJ0DCll3oGrL4kt7NAAHxTYBfIkqKCN8BVABTRJ6ijQiDm2LSOUeRObm33Y1Czx22apHTMUIcsJrb42ZvS1MdBsI89KTe6KHAQgz0tkGWGg1cZu/VuxW/8QBptb0VQlRsoGNnX6MNRpaYN+82+kaGDzSB+GRpooigx5Rmg2CrQaWs2nFCHPdOVG2g0Mj+p0WUboa3bQMPeKMtMaXcBdI4V2u4F2O0dpSGfWIDRbHeRZia2jTWwe7kNJCkQ6SHdZZui0cxSjOWg4R7Y1Q2NEWc9vVdaczyuIue6X/nu1f/P3IohTN9svL//gOa+cmPNBTBMUIzKC/NnvTzzjH9noZxDVUAo5+duyJBBuzLDbwR2y50vbrXsTyJlKN044YgggA5QCGm0d25OUWRA09Da/agClOLnHMxOIyRy2CeCTtpq0nqd0TZ+odYSruxaOn2KcknJVxtm6hUNMNpk+QhYTEiYbiQBOJGKTAeANGOGqPvac1maIcA6RcixZjEFODKEtTVBGreyRPMMYZRUPSXLXKiET2PZMPMt2afkIoTGsvU87A1oDyCd+eOXLkC6Z0PoxwcxMPLEMnsYBgNMUFk4j4TwRlb9VxYILT8yK/Zipr90aVvBsCpUomxPzVjJ4u3VYgZAJebWd3NZmH4aaJdAIZiCeNHPC1lYLw+0GSii0sg4GWkOY2RjBnNYW5CjRzApjAwYMldqDdlO7H6NlbrSMHTSFeozt8EbKHEOdFoY6LU34oNApM7SLHJ3SqYeUIox2coyMtDA60kA5kus4IKVCAaBAE8Oms6uOMsfYwWiVNMFr1hA+fxHk2rSiCTPNY7VddpsYPlRAAoPvMUR8+zhkbYgv4npok2yTh2RWEBB5gk9FPpZL5GMXPEwCRbgXSz4MGeRwTXL72J4JLOotQ8HkIy7wN+XQTl4kvL8BP5YnRH5CZtao2+aKkba6cTH49mpt/iL9JYQ1Zxnjs90dR3yvZDvujOVEk+2N5AWc0AM7LQG88MILce211+LnP/85BgYGcPjhh+Piiy/Gc57zHJvmlFNOwZe+9CXvuRe96EX44Q9/uG2F100UFBlM5ECTKcgj5CQJDI+bk2cOM6fwSFh4ti/iA5/n0CGuRScynjiUIUnK2S152j4rQ5gnz15ACXOyhpm8soJ0PUtlnUEUGe9dubUstGxs/K1Y88fbvbkvsw1eG5A/He5EkESplQD06SU9YO0DC8dvK0TDkEM7KQaaEsfxDHnNFSjLQFmgflBk613mTWzqa2HLpn48PnM2Zg0MY0azjb68g/68jf68g0ZWIFeEdpljuGhguGhaEpcFzIJ/d8pMp+80MDTSwki7gfZoA2Wh/PYggDoZMJIhG3Z2epbQSeJh+kLMdo+k1lTkDddVfJR+OiaA/I4rmkPmzb20U/KaJBuC/IWOBxVQlcPEwO0RngrikQnZTyrPm4/e2EOWHEePY/gp6M6oyHqwSy12qLFjpwyO1wdFyIyTlg3BVIh3BTh7UO7Xsg1DIhyOebKRqCYNRHvUkL/Ktm/kHYfjrbT/G8sWcJT89R4W/PdoM+v93ISCF6bb8nzCTo2dlgDedtttOO2003DYYYeh0+ng3HPPxZIlS/Dggw9i5syZNt0xxxyDq666yv5utVoTJ0Q4iIcDnyRNdjA2JNAanhMqkwMcmbNbSrzqVEIzlrn0bBDOZbjYZXH5ZJ7eMUisncgMCZRH4Jn7WovmE8lQI6DMTcr1cV+jQxn61xeY9ZtSh3lpaE9SytwGtSRt0e0c4+Hoaf0s+SNLwmBiCPL5xACcI0kZ2F2KSceb5ACPl5G4p+x/zP/ZeYFJq3kv+j0pL3yO3bLPAMVaBEtqRKUVQEM5yk05hlp92NKcqTWGzRJZU28Tq6x0pLTU28EUi5MXgEqlyd1oBjWaaW1sEGrF2od1lDvhQZIwKWdMW6M47ExkApYTfkU4kQUTNLm1HyF3lnSr4Br89BUtryF/se1ohbjcXnkyMf9ffmMlAWzPGuYT9D27uJNb3SB9Bi+JwNuCBJJS7gQZ6fhAQjwmUzlAhXPGyjqEcivH+dNkr2jpvmOdrfjd8TdHiH7z0iQltvCNtaFd9EqSJtpxXN603jhWJZRRMinbR6YNb3cLCN2j/yYkTDZ2WgJ40003eb+vuuoqzJs3D6tWrcLLXvYye72vrw8LFizYfoJEBg5vG1iuWsEhGPRN1qhQpu956WyolshgViOKW62LLSZDIu0gCDEISmIqy5EF8MQk7QQzRwI5DYmBlL0MMaLtkjr9wND8DEVLoW9TCVUCnT6FzgAfYwYv8LP1/hVtXDH2J/jewXx8FoeFacDzMM44PWs1RPyyqLbWThxcf1+m2PvlvBQFgW9LmUSBlAisbNvMdSJJXnIjJGUZKCfvSC8SGkN+dxkTwNiEJgmsJc4ufUWrx0SEyZ+oi20Da4/p6u9pnyITZnwLFlUI8lfpl0GeYbtJhFvKoeavQkhj35hMD/MdBMSPv2tPhvA9cFnmuEYbLkX2RyjwQiszDkclmwgY5x5S+u8iU158TM4jNJ3QJ/jofDncUC5O7+CFlyJ9z8rPNoWir3q7AVyt4JjCKNmK/K4sELrxvlifDsmi7Etc95BMym82GGei7wo15K8XGdzOSF7ACb2w0xLAEBs2bAAAzJkzx7t+6623Yt68edh1111x1FFH4UMf+hDmzZsXzWNkZAQjIyP298aNG/0EYpKvHTjMOF0hgZJcmYGf5OoyIo93vi8B1mYjLF+UaScyu70Yrap7lFwcQ84DpV+OPzmSHVhDzYnVokHfy0dYZoWiH9g6X2F019xsQ6FCbnXgZ3NdenwGzhlKTniSlJjJqmyYEw/yMH2g7ZHEJayDGPC9LU5Ow7aXhZPXPlvCmUMG8hP0KSNsE8jbfBXIuhPLpBzBMr+1/CKfOkIV9Nc6DZwMn+MRMNnOot3caSB+W1acBiI2gIqq9yryBG1vqyDJV488vLwkQbE34L0na3YQfGOSMFQcOmy9lXHNhdeHfOENsVP6hzy2jz3aM4jt0dI4eRBA5AJvl8Zer1RmwcXvyGt3s71rtPr6FB9x6k4OcOBxecyb3SHgmH6IE4aQDEriV7sFK8eVWPva7468dDFHjYrHsal/1FYvHLNDGXuQv1otYux72xFINoAJPTAtCCAR4ayzzsIRRxyBAw44wF4/9thj8frXvx6LFi3CmjVr8P73vx+veMUrsGrVKvT19VXyufDCC/GBD3ygR2Fdbgmtm0cCDUK7vzoHDm/ykGRPEs0QggT2SsvEi4mn1RgqAHKAIz+9Ja8iIKCdxE06qxUy+eejevBVHWUJHozWj4+a4nh2JWvtJPEJiUNgdyjrX5ozbMsmrKbM3yaG1f7ZYNOGtEgCZ+sh3ofddpdtzW3DWtwxEBBFJm2ouejyXu27YELGlxQTzYgGJJjgJOTWttdPQmIYTtABuZPkD8r1p0p+CIgl35PvGP49lq/bNqz3/cRILf8dktGA/JFIw+1L/K5E+9TFjvPK4p/8jVvyYLLhdOI9ZtDHEtrQPezsAeWdj60IKImQQaE0UYDskYwFbIgYG+i5ARC0zW3eNoG6G8LsQjmCCM5LkCmpPZNt5i1Yu5CsmPY37Oe1zh6irEq6CLG0W/lAlbDVlB8jeLKuknB2jUE4xrokJOxoTAsCePrpp+O+++7DHXfc4V0/8cQT7d8HHHAADj30UCxatAjf+c53cMIJJ1Tyed/73oezzjrL/t64cSP22muvygQSIiRSlfMsg7ToMpCEtng2iGwXohgST/OjNq0kqFZjoMz2tJjk/K0V8ifqGEGV9zhMXantjpodc85o051HyuXreHqEsqVnSf0b/oBu6uDZHJlJtWyYeIe50/xV7ARNfEDPQUQEsrVaNnJVsJN/SMIEEWIZKyRG+TKEWkdH3oKJIyRZcHKFBCfaJ+QEFzpmSCIiEXt/8hYT41gcSE4j2g0K1h6yosWFuy63dmMay4ptX5iuzgjekkTTj2tmZc9MQvRZb/tbCQ2deKa2PNsO4qxwJmlKa/b4W1IlXEBnQwIhzur1SKDQelPYn2yf4vOrdSctmnw0o0JzS6k1fTnZ8cm2i3JtK/udbhby210uGOQiRul27hVyykJFbkmiXWcfiMi1oI/Xkj8hUy/yp/8OSGxE1lDGHXoSSNIAJvTATk8AzzjjDNxwww24/fbbseeee3ZNu8cee2DRokV4+OGHo/f7+vqimkEPEcJjjaERDPw2AeIDXl2+dsKUmrmaAYlEmcH1kKB5dnyG4XhbjCVVBlo7KBsVDxNYJrq8JSzTQsqZw21NdczxVcKoHaQdOLJR/SPrKE0ajVdiGfRgnuwkUVLGYcU75N4QSfuP34G0NWQtodEMsk0mDEmMkWjFbaS0nHZSFjZcVsMW0WJqxmpkztwlrouF3JoOyF9Mw2fbRU7QgO/pF5ubIt2Gr3fdVhWTqLdOCMh5aOMntc8V8hfUKVqeaEepiQqfqSzAOO/YiRQsd2Y+C7Flz9+hndzr2lCSRtv/HXm0AZ0NCSQ27TCELuvo9CUUwH2Y+3NMU8rjAVfTpLXt3SHkpkPlI5pAln16AaZKQLXhyJrsw2G/gv/ubBD2YOtbyyNeSKyNusAzd5FHxoXkr+Y9e99BYBNYJ0NUU2jr0l3eCrg5diSpSgQwoQd2WgJIRDjjjDNw3XXX4dZbb8XixYt7PvPHP/4Rjz32GPbYY49xFhb8jhCDGAmsOFzEoPy/rdOBNOKOBYwOiGi4crVFRgZP64xi4omFE4vNg+39QiPr0svMk1PbFIoBVBI2npyMlyFvVfFWbWsToRwyW8FNgFrKysLhLrzAzwGx5q1bazcmTjkAzBZx7pM/AM7RwcQlpFy5bWApN4l3YF66jQdIcBokkcTTwilxP7YlKtorRvZDmznveZ6YI2YFtj9Q0G1ifUP2VxJkLdBwRm3yxGQd0z7W5R+ro31mDAqV2smaG9umE2RB9G9Pi2NIIGQb2+870JqJRQi/PFWSZ7OoRLuUYnFCSiFrO0cwmD7O28GAJIHKvrxa20ruX7lZQHVInM1N+uzmWbrv66DPru0q7Se+qTpNmWzjqOctXBl1BM5fFDhC7LepLKcHIRxjf/FkC+pSl2ZMTi1117YX6jTg43k+YafGTksATzvtNHz961/Hf/3Xf2HWrFlYu3YtAGBwcBADAwPYvHkzLrjgAvzN3/wN9thjDzzyyCP4l3/5F+y+++543eteN/4Cu6wkeRKpDBjiXjSvyEDmQikE2jYRQzBG7KQhuYw16IktiWFALj15BBnwylLVNFIGq1EQJCZsN7v1pYAy10S0bCp0Bgj5qHJEis8CNlvIINjj4wC4gMAqbHeYsCzOvlC3D0z4mYD8cfBcMxmXQvsSauBYdkfSjYYnIBoecQomxaiGULSRdByyWYoJNeaNW3kfweRu7RvZVlE+E5JQSdC4PQMSG00fBAqO5h8+F/sOImm539niIxO1bMPwRI6KaYasW13ZsbooeBpE+62Kd2qdo9i0wRA6tu2DcdrQxFCBTEB0+U4zEEqxfVw2jNZQaKdlPMys7b4RmL7LphaA/paKfp1enxdd7XNedWP9AJI0UrUvBO0WtYeTJA6R/iKvmbGpEqMxuF55juWLIUJ0vfr0kqMur2CcSEiYKthpCeDll18OADj66KO961dddRVOOeUU5HmO+++/H1/+8pexfv167LHHHnj5y1+Oa665BrNmzXrK5UYJGP+Wg6aquRfkwzH7PM1SOMmiZltZ5AWS200qegoIQRATDkMhTiSw9VLB+GbyJqiKd7E3kch2ERN2haxwvUhPkpQb78Tcn2CZxOWj5Lx7m7A2gnJy8tqEyZrQ/ul2QSWOoD6RxMlotZLKEQsbaoYndqNli2/HC1nEhMD5Sa2izY/cdQW4kDZw1+WWqnyO00ivY08LJ0mm8u/L91BLBAFvMpRpYrCkK7wfIRVhXnKS9/KLtVvkvk8C/fs2X0GOo9qqOoSLDPOtygUAnzpTEiET7ykrtH2qdUAyiwu9HQzrcMKkkRdK0pyhVLBnMfNZz0UTdqGSDxPyUeNJ33CadRsOCVrzl28lTRa5ToJge+8AcO/J9l0zvsScYfgdBe8wSuJk2bF2joyVOi8ng7xX++62lYxFyoulmdAyx4EUBiahF3ZaAkg9Ou/AwABuvvnmiSlMTD5yq9feiwoYuScnaZlUxNaTeXtl1ZTjbQuCPK1ETIaotkTkVVuWHYR5poDd7pUaLzlIu1AZQRMYuVSpPRephDsbWJRniVfHTJRGe8chL/igem9yZnJUUnXi4Ema7fUCkuiFhGHyJ+wI5ZYJaxTlKSPE5Yv2CjWUsq0lmanMe5Lcsm2aEs+J/yuIOonMPO0dPy/7Bqp5hWDi6TnLhORQ1jFC9EKZXcXccxWNVEhIRVrZDra6sW9L9n/5DhTstmtF2wpx3dSb+4+/UHPfnGNPpp1yBTJOR6ztVgWgck32pLbUntVbkCX4KACVEZArZw8IADmsvSpr+4o+AkqFVqkXSqSUn64AslGtZbSaQpZVvLvwOwodkzz7x7qhNzauhUmCcrrlUdHMBX23Qii7yOKl84h/jcOeR/gpnl9QZleN8vZAsgFM6IGdlgBOCnjQkNfG89GL1badB6VDRVYdaOS2S8WukJUPIQmsW7UKEuvyNwO7IExV7SIc00DkWYLTOAbtIQ3HwYREtIcljkwmA3kp1wN0Ngw0N2mvxqwNewIC5OkDnGdA/mBkCI+F6xZg2BIzPiqLyXnmbAk9UhTUCwhIGbdl6f6WoVFC4u2RJXJErDIBSgIpiVGEdFUmqICg6fTC8UiSO+Xyp1ibycm5G0HoNmnLuvMjgjCosnrfy54JbhfnFfsNBSRYyijD/cjvxdriynQEsLu4FxsxF/eNFhCdII34v0euxLuLmnGU+jQPVQKqo9AYBhrmN28NW/JfatMGaw4BUT5rF/OgfMDzfLZtwfUOQ64g8s6svOT64RgRW4hSUL4k71JTFyWNol7etaBMW5ZwdKmcBFLz/I7U/CUkjBWJAE4E5GAD+JMH4A1EtRoIeS34LcOueAQPwcATS2MGc28SlxmEMhgZY/Z9nmhBXcKJSCcRRvFCVrllLLev2YNWiO5PeDJzY19HOVC0gOYWQv+ThKLp2/EpIue5y0fYKeUWt+a9SAN8T7NXZwjNBK1wpyXYdsqVPZ+VNZF2YoIgxhCTe1BHj6gF74Gf8+wIVUAoBWEDACqNQ4rMy70o/7lY+RCTNXhREpATwHfAEflFtSGhDOFkLNrDIw2CwKksuBdO5LFyRFqp/bV1MLKooF28RYGoK2vb9DWlF0v8jCHxJQhQOj6fMunKBonzkwHVIWRKoQzayjpCeYsVZYNCO3MG9wxr9FobnYavaGl7Wk/LxXVR0NpEzp+JU02sP9eGnAH8/8N/L95vS9jJvocoahYAUW0unJySpHs7DnWBo71MEPQRERxedc+vdqEvCGJPU4KJRDlOZh17PmGnRiKAE4mAVERXfeO9LvKNeg8jIGsKlljJvC0HDdJW5BayhLaAsWPiKqRQyKxKeOcRe7JGiG4lbIyYcD2iS2zjRyibCkWfntSyNlyMtFwJAqYLK/u0owgAvW1stoit0bxJ702oAZEOZeP4gXaAZ82JmUQzQxBYBqnh8bUm4v8RRAk2wXn6yX+iTWXf0QLGJyG5reo0xoRK35B5w92rbAnWPGbz5zwC8ljZIudMlJCRFwsAyFTGbkV3yV8Sn7CdraYKhsR57BPCdMCVXRqtHr8bS8AzBYjzcg33c8GjuW8ohVKRDUNkFx5sv9plTNB2sXrhko+aIOaFWxSVDWW2l42s7PShZF2cMxi3f+W0Fjii47VjRaDgZ+Zf7+a1azXH9j0HhLPbuBqQKulcV1dmRZ6wDWJBnZn88Y4CRfKraQuvvB1JANMWcEIPJAI4EQgHpspMHfkdEilhOF0JdSDSeiSQH7dbhcLRQw5iYgK1A6+USwxooYbJikx+ud6gHMsTrjxHTN1EJ4+Ts3mHJzBYTUHQfIb4ZFznhvImOGnHp7eD9YRZ9AFFv84vJ2hvYE6vBPErZGGAPRlBTpCWJIm2EPc9ezxzxJznOSi0dTZd4SYwklvXcpKTJM1rlKDcoL08A/yA6FXeuSB/4RY0OyXZfCEnbpNvGOJFQvZlk8Z7PnPt78wfRBpb1yCQL9edf0oiKdsumLDDiZlgyFrmLaGQCULH/8/M1m6poD14FWxcvozMkWq8LW3sVfl4PsqhtYGZ1sw6bRghK0yeloCJNhNe5vpkG6AsgXyr1vRRg1DkOoh5qTTxk97u2ubTvVsmg94r6kZSBEHTaQ1Zk4vDGLGSxI7Je9Durr4Ufb5yLdBOyvGjQial2UdgeiGfiTmR2HuC/MXMSGJjmLeAZFOehIQpgkQAJxI9VoG1EMRO5xOc7BGseuVWoo7ZBxf+g8gOjBUSKPJyWovIaltOtvIaxCAXGccq2sWgDfjUkhix8PI2f+vrfiaWJJjfWQFtUG+JH7ehmyizDlxcPUP02FEERoPjOXMIUiiPcPMmodCRJHPlh84Y9m8IwiQ1JEF+IXHmto3G5RKy1sHb5hRt7xKI7iEIa6h5cZ7mJp4jKZ8E2ucdSfLIriQdcPdt2/IiIdJ3vP5r03LfRTXmWeWbEWWSk4lCG1H5vJC9NCo8VUA7YYhFF5Q+QaNouHAuREBJCpl5hvtcqQhKxLe0KJV7v5Lomd9WO05A3gZoRJ+MU5j+nLcJeRsolHteAS6MEWugRZ+qEDbl/+1p4sQ3aq+NByG5k+WGf4skUbs6S/iV+Z6p2l9Mukog6BoNX512r1I+MdkU8qlInhG5t9Urd/wgbJsWb0fKmjAZSARwe0FOQJKARb6pWo1cTXr3HNn0dvuMJ9jMPyWkTrtntSxZZNsjkC92zmnUSSR41g2KVCGHoQ1jOHFXnF8MSfBONRBaljIXGYrD65tDOoPOFpG2YSYzM0ly3L6yAS8cjA3D4ZE1Iaclf6hs7Xr/+LIMNcNkohTaIjBpc/KrUk7iypGTwEnAkwvuuv0ZeUcUkZfzkV6uMQ2NzZP/LkX7SFFkP/RumHuCDFlNXniahOgbMhi2JNlSs1fhdQEhkNpad9+Xw0/DR6kp5AWZ+HxaqDJXUDm0TSLH4CPohQdvuRbGW11pkksNrcXjqtsFHHj7VrSvMvmavqqdOsjG7stH3PYvIIgfHxMHI5N0chLjQszmT6erdpjYOFHn5GHbMab5kuMi//YyrT7C16OaeFUt25NJyiEJXiCDCseyoN/HglH3jC3YZfzfbkhbwAk9kAjgRCCY4GsHLr4XIYR6MHZawPEYCzuvTN/uyK5MQVX5eAAEAu1jRFYIkhqrD6+eQ6NhHpCDiZXr521t2ZndPCqPnQsGUavlYwNtIWdWACgI1DGxAzO97Zt1gOaWEvmIthks+vQETEpPnllb/y5azk7QIyuC2EiSxR6S7GDiawrEZMKTq9EySC2hCzej07FDCjX0/awykZOtm9QkKumMAn2PZEfqNsEKQlDZvvUIpk/GKwQ3/B0Q+hDSMF7a+FUWQZG/LUGHWAQIQhN+Q+GCoTI5d5ERZksVpElg1oHWBBbacSMfhV6oKKUVed77dqRTxv0jQAdlBpDz9r/5Fthph+VkzX7ZhF3sZW0gG+ZTc0zfNfEEWUbbZwRhYo23JH/yBBKXzvfmrfX8FW0ZdfyI9LPK+Bb0t1qvXVkGyxiQ2Lr36m8X15cVkr/YucGVeoV1SNwp4WmARAAnEuGAEE5i4YDJ5Elck6dlyLTdBk1J4FjzIR04YrJJzQmTQJlnt9W3lIm9cSv1hRhYQfqyql6LGex714L6SpstL/C0FNF45irSno9FnzHW7+jG0UfJ6Wtae6In1PaAQmcG3IkIIiyG3dqUQZhzR+ZCOeVWp9U+MLETpC0rhH2ZSUtsw5ULD2ITqsM6rZj/A/C3tAGrkSwzIUdIyoTcnnZTnlATvDOXJnhWbPdK7Z99HyGhHMvkKMilt8UrypeOG1oLHTwu6imJpaf5YpHYo1fYL1qtEmt3TfllAZRtZR0vmGzRqAIpQwKNPSpraL0u4n0j0NrA8F1kfByjjt+nOrDvlZ2eVElQhfLkzArySG5FMy3fhdRcSw2d+P68LdCu5Krmuw0JFoI8w/Ty0ViIlW2Ap8Ejv96S7DJi7TIW8jpmTeb2Rhl+eE/l+YSdGYkATiRCkjeW9N1u1x0xFCkjNICW5C62EpYErG6AHUu6CtEU9apsGbN2wzMiD5KwnaDIx5ZjV+cuoDXBbXtZAqlMeA3AbJMpFC0FtODBakoMySobJo5gB/Y4LBvWhG0EOYSN8PYF4BOHYCJ0nr9+YGjpWerqr4lfGHutEoqCw9yw9rBDVl6CkI/fRUdOwGGjo+r0kYn/d+vT3DZyMo+RrdpJXt/zttntTVFGuFCQBNX83zpTkOm7MpwJpy81SfOIsaivlInb3RLOTMtZNhXKJqEs3PpDk3DuGwTFzh7KJ1/eby6L32eurIME4Jw8dBw/QtnQmmsvfcYkNCDeHnH1CRgAsRhRjlizdpdJm+Q+ES1ZLSmrjBHue/aei/UJJZ6R770u3zCPHr+l5i8syz4i+1cvWWoIcVTmHc2ndBTxbXs+YadGIoATjZCg9VoRdhmwpMcvk7CxroQpLCMY0Cq2e3Ji9QZDv/xQc1mrrYuWy8/UjIRy8kFAFksxaZvMnBOAITYwpDDX4TXsJF6QHxCatSN8fFxOaAwTmpsBKGXsAfVWsCVZxpC+zF2cQY+g8P9DzsvtF0yojlyISZkn5MpWstcpqkSSYxECvu2gCl5BjESJaxWyEzhIeBqcOvlEvWVdOZ0XRJrzMmVLLVLoOMJhS/Q953xS1xdtWV67QTtolC4t29zZ+zBklO3xSHkaTsrMQqEFqEIXnAmtsLbV9AmlzJtj+JUNOIIu6iwduvIRAkZ0jEtV6MWJ3foXhFkuzjxHKG4f7x3AEuIY+XN2lY606WzE9xTYqrp3znlXCaetYzh+jWE86zXmedrHbvnL8VPIqWUVZXUhf5Wt326yRe7FbHC3G5INYEIPJAK4PRCSQHkdqA4gY/zOvJXzWAaeOlIGQa7E5CknVKmtkyTQyVK9VlcXR4JqZOLHCb42UcqQOe9jtyWoM7MTkqp6QEvyILfZSAHU0NrDzoBC3ia0NhEaW7XGsDNgttpgtolHnQ1W2Wfkk3aBYkK2bcETopzBumkKFLxjwCw5EHlWJiAR1sPX2AQTI8Tf5Miz54zCbcUyZCKPinaJGRwq5FHKaU0SmGDAbW1GyYloI0uaKu1b1SKrzBA7UU8SCxZZHpUKREJrJkmncgSQSuUIltwONmdTlwVByU4tv52SAP6+lNYKWg0gh28xjkxsbqBJsNNoZx1CPqKfac9SaO9iTBlE8HEXNohlU947kzab0YWeyUNqmF3DincqocS1mrEm6hEbwi4Cao5bs3kFhDr8xrx+FyGfvcqkSH0C9Lpv5VI1v+sIcELCJCIRwIlAHdmTgwbV3BtPGWEedYjlLwZ+N9iTIykQJFA8Y7c8gwHTs1WUD4UTgiBx+naN4OFEQ0IeljEMnSKLZQ4U84CGS+9xMaOpKVvA6CyFbNRMwrmvaWEHjLIBFANa+5O1gbxjtoulU4Fo+8qk1WVyCe3aLKkKiJXVDvZaYIRtWVJgv+gIj5WtdO1ImXLb0KwxC0mgcnW3spq8NRl3C4xK3D5BdBV8ImbfNROuTGy1GjlkAGZLSHJN2izZLAnIlH++roLdGas49ShtN2n7lwgGrgpBNE0Q5oKUXrAYxxCOWcjtwZ2OlAsYzbKyuYEyZ/Hmo86ZozQLk7KlUPSbd9GCsQfkIOiC/AlSI9uo4s3K715+A+FJF5lPjmLODlEHiIBQ+g9E0tq8VDUdk2hBmrppFUPUns3Lz6geaXrk3zVt+Mx48phoJBvAhB5IBHCiEBKhLvcrtnnBPQBua0xmWldGHdkUA6k3SWTkEwuTNpa1p5WT+Un5pRx8XZADSTZrV/uCiDjy5qezMfYiQV2tDZlMHwkhY8Up3eRXNpQ5JstN+JbceBO6s83LOuw8Ug1izeTJbhOTaAvOT47NhnjILVfrdMIERJAHL+5f3SIjKIvPewUMj2sKAijLIFEGjw7mnj8hu7aXJMkWreCfCewRWwKEpss1HJwNnCFB9v0y6StM9+LtWYi2EM4aVmtXmLh7JgQKkSG/HDCPyXHJqyBYB46sDR0s3OSVFdoTmDJor+ASUE3eAhZ2l0YePmmG2Sv3KeugkWsNoip0XwLM1rIl4S4/Vej4f9kouXztN83vmbS84p15zWsXUmJxFJDucNs8fD+Vv71VWJAmhsjCpULGJMerk7cu+xrNX0WTKcdFKbccS2OI9Odo/gjSyWd3FNIWcEIPJAI4kQgHwHAw4TlH+fdtQFMKPGM5DUQ+YyWBoWiCtNmjrsIJOiBhUh4K0tRdsyIrNxHL8ivnEAt5PQ9IbxtXnCnM8ptJwwtfI+0EM6F15DYPSLYjWHrbl2XSE5KO6+Y8hgnNLToB5Qr5KAGl1gRJklc2NJHkcB2S/FmnDzhCZe35eAIWpEpZL1MjmkxT0aI4ku7ZAcKUaULJkFJAw+XF7ZWJINhQ8MgXE64KQfdIA7c9oVQqvh3ObcB9gwmbSZPJsCNRpxfjYEGuv9nt2kzIXXK8PlOmIWwkZc4CL2vT3pxPaeL4ZfCJre2DXFYuTvwQ+du+ZNrVkl0y5gRbFVSptc7NzToMUdHH+cF6ffMWv+2r1tzByeG1LY8D4aLHpvf7ea2WLRi7PI/2buhGGgPSZDVx/FPIImWuk3esCBe6/P8ovRlv/eryT0h4GiARwO2NGhIo79fa2kXIXvQ4Npk2HIDMQGc1ON3O9o3IVLHzgyM2UiarsZPXg5M/emoOuewCegtRTkDW1kmJa64+9rcgd9H9r1i7BM4YnFnWUdbur+gHss1A/3oCZdojs9OvySFgtoJJp23PBKjBpAuu/sF2I5MIhBMdh7ER5E/KHYOdNFlbIkipd7JHQDQl+VHEmkhBMktx32yPy/Ahmmz7clmia4g7T+SWq5f6/WqP3KDuliybWTUkgQXcVnQZkLOaunnaME5jiGLJxNn2A0GWct29bHaBhpFkXjagt1s0qEIHIM86zoO3bOhn862EfKve0s1HyC0cGvJb9Y+gs+8/RpAg0gTfk0fAA49cENcrIH/y2W4kLixbIpSvDvL9hOXwz7ot2x75q0D26Dm/NTL1LCMko91k6VXe9gAB26YBnDBJEqYoEgGcCMSIWDfwhCN4XBgeJVpGsGL28pNl9yKBBM9OTg6I0pOykibMVubFdoJsdB4hkbV8zCkl9J/2eTHJWfn8dgpjtXmTJdc9aA+3vS7uBc+oElBtTVLKJlC0FGiW3oaDIXpFn/bmZDtAVWri15mp26A5ovTWHtfHkDo+bcSeGGHKZy2cJlsuwK2n6RGEzXvv4d+CCMvtZ2n7Z0kpnzAiwoZI7ZokrhXtotSoqKDrRSbfjEgTNwVth5eh+rlIwiztFhWsM5Ai05YElFD+e64hHh65s0RR+c+IRYSd4DP/n/2ezDZ50VRQHUI2SsgLaCeiGQBaQHMIaGwldPq1s1HR0nH7bGBv4rAyum6ZIbj2m5TENWhz7zf512u9VoPGrnh7R8ayqNZtLMSupsxuz4c2iIA/9oxHhrANQvLn7QyMpz5AtU7dFrXd0m1PpC3ghB5IBHCiIAeRCMHrRcqYBFZW7wjyEfnXlh08b8tTEBoW+FutJjEJ2a0WLTZosfw8SUtnEa4HmcFbufRWtEADWadFrJBbWxdzQT4PRG3+ZJkuW6oWIyZ+RQAKIO9om6uyoYAM6PSrgEC4ZxrDhGIIaGzWE3lzkyYp7FDCpK7MtSdxab09XTuqwgXzteUoo4WS2jjTppWtOYIlWPY3dD6lMkTDbHfzNqOdCI02y/Zf4QThteVYJzEl/nFfEG2bKUJpwt6EiwOuZ6ZgT9bwNFksFxkiFhIb5dpItoO8Z98fE2O57U2ibUPyZzTgZN4lWkBRAllHoTFc6nfc0IuGfISQjxI6A8oSvazQpFXL5941a2rlO61qsPz2rwRbl+n4vmx/uOerNnFU7U/yu1Xwv6EgPFHYzi5fkack2ZXv06/XWM7NrXMO8ba2Y9pN+HUMZbaI3FOxPLg+3UTekeQvIWEMSARwIsGTdiyAMqcJJtLKeBEZRCoTQUgMw2dipEkQihgJDGWw5I6ziJApZdVonCfVly3lBSzhjCLyrCtYT5TaHky5iYt8u8HYs0xGQ9IrmifajqoA8pIsGQNPKso5DFBDt8HM35fo/5OyW4PtmXrS5zaDIpQtoNOvn8tHzJFegWenI5nmZRQipE1ByCA8SyXhFcTFtjkTHLhj5gA4mzKTRjqu+A48jvTIib7SXuC2FensO4MjbGwvx+Xz4kSQWiITdzFTzsZP1lEeexcSd04niJCXjt+r+H684NtSXpOe27kUzjFUmvVGDhQDOpEqFZpbCc2hEiCt6WvPzDEyO7MOHtarWsEc3eb315B82e3mWLvyAosf4bGGyVpAvmMIz7iVbVSHSn490kvt7VgQ8/aNafRislTInySdlYJCQbtVIkL+wudDIjyZpK8URqNP+fmEnRmJAE40SJAbHrR7rQrD+5FBI0Ygu+XthV0JJ2lBAj15xbM6XltAYEMSKL1yy+rkY8tWtqgKke3mHFK7ZUzQDCEYbGW7ewSGoSJlyfqKKpZSK2XktIRYwW6botTHthV9CqOzgMZWWGeQTj/QmaHs6SKMsgGUfQTV0U4Aja26EfQRb47ts4OIZ+dGxruUqLIVa9+5OFcY5MiTtqNzQaQl4XRaLhfKJKa9qcT/M4TGyiA1ZUq5NNyG/Ld5hVy2ra/S7j4eSQz7jNSSIYJA5uj3xKST/DR1WjdlHGmUAspMfxvZiNJnSJtQQnzsYHtIx+9TpB072rsoEzhah3zJOv53weVYmeXl0skaarKs+QOnjTWGecdRJ44KeY8/L+WLnYoRBu0OzTYq3sUV+aQM1W3abjJGT+mA3168aOypiew2DkeI31i1lF4e40i+zUhbwAk9kAjgRCAY8KKDu7yH4P5YyxCQ3q8VuxZokuNpuoLBzoWOqJI71qbVajE5Dcd5M17FNp0tQ24txx1KojJIGSMPxEhp+DvUWKmgfVxmvqz+NhT/Aae1ETKAjEdnwYRPVbaIKZdlE/JRTRLLhrYPbG3Q14qW22bmkynYwzg2cTEZkQGAnXZMHAtngmhLxwYETjxeuwsyZLdByb9v+w5v05ota7uNHHgz6/8TKn3fpA/LtUSCzzrmvksin/AbE+RS1qtCAmtIUqw9wr6S2TOmdXs2t2jyXjTN2b8NoDOgbf1s1maxpZ09gKwtyJhwKIF4X7ps/m44raq0j6wfKeXitkmyWAbkL9YO4bVuY1MP8tcN3Y6Ri2nTolut4nuNiifbIyjTK6ebrF3qX/GmBrqTSJFGjaGNEhJ2JBIBnEiMgejVGR7bSSAcCGsGjOh2Zi8SGJG11glCbkUCVfIDAGYrFjATjgzDEtgOhvZHdXlX4pCRILg88Ea2n+xPmU6WVRfUlFBtG/Huwq1u9vy0miizFZkR+Qb1JOLuNdzknnUIA0+U6P8TrKaO7fLsCRAkzn2FiUcnPFSlE0jZBMrMPcvevJa45Wa73J79atJJLRoTj8DLVZIuRaYcJmymjKwgT+NIOW8zC0LKGmJ5XF0mtqOVKEtO1BIlfIKngvoQbNxB3U7K9kH7ziRx5e9PifYCbKxAAE7jp5wM+QihucnYTprg4GiZd90WeXAfKXiLnyrEyWtn0+/4O64QBfZ2l0Q3JCOSHHEdAhvOWq1VHTGOjA9RTaH8BgOyBkTIn+RPoh5yMRtz+JChoViuuj7T8xi3SB3qFhehHBUzk1j7hQsaVdN22wtJA5jQA1nvJAk9EUxMFpEBpbLFZNJ5WpXA9CK2crRbkqUYDOWAww4DcrAMZR4reALlR6W8ns2aOAlBEIjKv25FEbk6iXZz24h1jLiaT89qUSBnCDtxBEF+BfkoG7BfUVZojWA+rI+Uy4dJOwEM6zhv+tg57TUK0r/bMxTaM/XWIQmnEJDJGzpkSGNYhIQx75eUzqtswWwfC7lFPyrNyRWaaJq6s/cvmffWcERVtk/PiU16CDOpM0GcJeHKOi7mHh+FxseWhfJUyJ30RIa4n8N33hDfmKf1Y2Jq6hd6F6vCnLDRdvVVHU32MnOdw92QsUnkkDhFv/6/DuZMaA4RmpsIrfWEvvWE1kbdF6TNYpQICHnDPlkZGyLvRMYK5G9eSY2g+T7HhG7faS8S1SvrGvIIVAlbtHjpHR0jpQGRrLWfhJ9eZyIFdf+6mqKE9ahpm1qHk+2Jkrb93zhw++234zWveQ0WLlwIpRSuv/762rTveMc7oJTCpZde6l1fu3Ytli1bhgULFmDmzJl4wQtegP/8z//00jz55JNYtmwZBgcHMTg4iGXLlmH9+vXjkjVBIxHAiUSMCKrq36HWzW7TyXhq5F8PQ1xUiBY/FovJNgbiNSaEE6uRMzz305MN/jN1pMLTOBFsKBTAtEOoLYnlFUyUTCStkXtQbu2KPNRcKJ8EslZVBhSubDdyXQp3lrAqja3gbIWR3TJsnZthZDdNAOV2ZzYK9K0nzFhHmPk4YcYfC73VzBorM8mXTaAzw5AQZbYng0GbcmXs0xyhlHH9AJ9MeRqxSL+ybZbBP7fYtJs8BUUSONaY8dY0H3cGQIS+AaxWWuYtiY/y5aA8IK/BRMvPlTksUeYymbSCDHnborV7zU0uOLPVXpqgzNTQW7ztmcbBp2FO8jAndISkxCOqwomI37VHeAPtd2XRIfqX7Iu6MFem9/5tWmXKJFS+v25kb6zoQdxqy4yU0ZMsRerI18Ot4dq8vPfgyGKsDlFb0hj5qzwYSbcDQVRu87/xYMuWLTjooINw2WWXdU13/fXX46677sLChQsr95YtW4Zf/OIXuOGGG3D//ffjhBNOwIknnoh77rnHpnnTm96Ee++9FzfddBNuuukm3HvvvVi2bNm4ZE3QSFvAEwE56TOE9iqaXmqflAuhIo9pA0Xs+EQe1cHeXBChUEK7vFp54GSi4FrtYyTS2O02Zerny1trA6hEMjGXya1keaas52gS/q6xW6QsEmBbwquHXz8S9yvbT4HMsi5WfiY2HbNNXMK35+K+IMlRC+hbX2LgiRKqJJStDMVMTXSkNghKkz8AaG7UJITjC/I75zNnqQF71rEuy69DJY6iIZlyK52Y9GX6foX8hcSQzKNMhku9tV3R7lGVuFZAsBo4UqRPVzNHohUtrd1Uhbav1O8KQKa33PNRQtHR5+oiY1JONiwLh2bJTFBmqzltQmszmXSzY4rpCyC9tcsaWyZ7sa2/6qKJO414p+ys4RHd4JhBcd02vV2kBO0VYEwBkOHXsdaBBH4a+Wy3YMs9xyJRvr+o7EJgx5ImslCsXEeNbHXjxRjy8+aF8RDqpyGOPfZYHHvssV3T/Pa3v8Xpp5+Om2++Gccdd1zl/v/+7//i8ssvxwtf+EIAwHnnnYePf/zjWL16NQ4++GD87Gc/w0033YQf/vCHeNGLXgQA+OxnP4uXvOQl+MUvfoHnPOc5E1+xnRiJAE4kxMfuGZDHBgFBYLQnJYmB1ydAIVmolInqytcjJgLdvIPHi4qmj3S+MecT6aFrV8aReoU2d/zPI5BBG4b16xl4GvDfh2xX8f6cVkA4h9SQ7opnMeCcLThPQexBQK5gAwCz40bZVGjvotDpz9EYzrQXbGibp7RGrbWJrAarb6N2RihaWrPGzhKUAUU/aQI4oqwXKikF5D6x4JMvckEQva14Qygphz5ztg2feEitlUSoQVHuuUyGojH3VAkXJDq0lVOOqGYlULb1AqHoJ+QjypJpPoovawP5MNAifbILSqC5xWzJKhOj0Xhxq9zY6pmwM6UhfxycWb/DgKTB1bdCznghBPgeqXBt6mkETb7STlgef2bL4KaSdmgxginS9yR/EXJSsceLENvqVms9y/G+x1gy8Z1E7flEGs6vrj1qiWYv8teLpHWrQ+zeZJI/onFv41aen0CUZYlly5bh7LPPxv777x9Nc8QRR+Caa67Bcccdh1133RXf/OY3MTIygqOPPhqAJoiDg4OW/AHAi1/8YgwODuLOO+9MBHCcSARwIhD58Gs/nYD42PGBx1rlX/cyC8iKdBypjatnJxIumoIJyk9rf4pJP1pXcd3z1iWnkehWb+9ahEB6mtDSaUjD0DK2foIsV51iugxk4eQp6ySIh/W6NGV2PbUFLi01gonPyCrPoCUmYgRkMCeFtICRfmW3H/UWqiZ8RR+gCoXWlhKtjaW2LezPUOyitYdQAHW012k+qtNCERrDQGOINNHrAwjKbr/CkFGl9DNS3qyj7xd9WttGOWyYE9bMeW1nti2lprHMARXaWhmHi6zwSQ6/9zJzhNMS11xZr/N8VL+UYgAo+xRUB9ZWsmxpz9yyo89tbm7R/7icTp/pT+ac3rIBE4fQkfFKYGZZTya7kUDEMSLChDwkc97WrGg/70SMgIRFbdbE+7LkL6tej2rxvOMVq0Sx4qQhrulnXJtwHjGtYe12rBzPQtQQ29r8AuIb5hMNHD1WclZH/oT8tZ7WkwH2itqm54GNGzd6l/v6+tDX1zfu7C6++GI0Gg2ceeaZtWmuueYanHjiiZg7dy4ajQZmzJiB6667Ds985jMBaBvBefPmVZ6bN28e1q5dO26ZpjsSAZwohEQiQq5sOlSvVz7TWPqAlBHgbXV6z0Vgt7Cy8Q8KFc2hrG/4t1eouCYmCs8zOUICdZmuflJDGi0HPsnl5yuycF3MpFzXdm6SJUcwjQhS8xGF1QwpRxrJf6aEIxYcDBmkyV6jJJSjcKFdzPMy+LS2/8u0c4kyx9I1uW1htYp960uojgLlCq2N2jGgvYvWeoH0VmjWMceU9REahbLboHwurQ1SPaDjF1IONIaVJaQczNg6Rxji5tn1CW/drA1zvB6M8wRsPD1GVhDQVpaY5sNAYxgoWm7rlkY14et/AmgMGW3fCGltHpNIE5olM7Z6inx7QLvIMO/D2Z06eaWG27MbNe80Rqw8O0pR91DzF2q23Gkj7iN3GsaAqAX9zS2EAnJaUpWc8CMyzy7pbJnhNyziUdYRVlu/gITZPIOxMrSHjC3gQjIc/R5r6totHE03vlSXPupl3IMsPp2w1157eb/PP/98XHDBBePKY9WqVfjEJz6B1atXu4VgBOeddx6efPJJ3HLLLdh9991x/fXX4/Wvfz1WrlyJAw88EACizxNR13wT4kgEcCIRkkB5PfY7Rhh7EckwKzFRWU2cGGi9ATYcjCn4HZHbajBiQsiVbzd5mdyIuc6eE1znocwDPMRkKiffyuDunouu8qW8pmwOXdMNYVBsO8mGZUee8+rCUG6Sh9CSeNvohd6GBcgPqwJDUEgZrZ+C6oNtW9bUsRNG2QQaI8DAH0vAOK20zXm0ssx8BBh4gtDaBO3BPGyOLmOnkQLI24RyK6A6+qXkW7VWrujXtnWqo9Ac0h7PnRnGM3nE2B2SJnvIANU25ylvJRQDmqjlw7pNOU2ZA6rURLTvTzCEU2/blrkCzNnMIB2HrzFCaG41W8FNR+y4bMoVipzfnTjf2m65kvdeZTgfIq2VZfInNc6VLc2QiDH5C7oCyT5AQT7cd4IFg+xDdQRGEhH5DUhSVwm0bNmakCOSLoZoaCdbh/rnvGcl8WMZ5Xb5GMhfKH8vAiuJuJ9xd5krYw/VXPcK9fPvapYy0SgjISXGA+ME8thjj2H27Nn28lPR/q1cuRLr1q3D3nvvba8VRYF3v/vduPTSS/HII4/gl7/8JS677DI88MADdov4oIMOwsqVK/HpT38aV1xxBRYsWIDf//73lfz/8Ic/YP78+eOWa7ojEcCJhhxYepC3KBGU18dTbLjK5DGUjxLLqDoAdSFr3iWeB0I5TVomE+FWMOQzksxRhASqyDPyOSlLHdmzZDg2aSg7GXJ7MAn0QkuIPDhv24YlVV9VONkwSQxk8CbhTE+7ytvPEmO1JBBkXp3R2uo0VInHZ9tKAWgYu7Z+hVEFqEJZrZw9l9how4o+Xf/WRtJEkbRm0QbShiZUGNWesTN+r8tobtHXO4ZoqgwoR4DWZoJ6AmhsUZqcDRM6/coeRQdowtncQmZ72pyV2585W0cTJibPdB55m1DmQHtGZo/Vg4I5X5edW4xzCYd64W3cgLjxu/W29sV7s0SOCAQVJTlWK8h9UNgpSvtAz4vXlEHcn2xe5PWjqEarhvx54Hcl4x2KrViPMIXkMSBPsTAqsu6iOA+V7y5cyPKfZtFVJb6BjOHpHV5aJvFUkb92FyQY+2Jb21HZ68bpWNq69Dua/AGYqC3g2bNnewTwqWDZsmV45Stf6V171atehWXLluFv//ZvAQBDQ0MAgCzzbUryPEdpjqV7yUtegg0bNuBHP/qRdRS56667sGHDBhx++OHbJON0RCKAE4FuA8BYyF10NPXveQNvD4LpkRwYTQZ85wibT49Va2WeCYNKq3g6LwPlBmwbLFqQwFi5oTwUaQ/7fNhGKvjN6SQJLeFvhXNbepd8e0nKlT6Brk4zEiHOsg20bMqVFbw/4lsmpl9ICL3QLATrZCKN5hWMrRxpolH0qUqbqI6bhIuWDkvTmaEwPJIhK8hLy162qtS2dH3rdTuWuSaYpEz8PGgy2WkDzSFCa7MmqR2jISw59mEGlDmhMWy2mkkTu86Abl+uRJGbY9Rm6O1lypXdkrYx9RSsV7GtvA3/AzvpKvEOQi2eR/rg34t53nMfcWRePCtImAy9otuS/O+A+5F5NzFSGH4P0SDJ8lsNSKSVs+75mm+/Nmhz7Nm68YdvyT7ukXD/Gd8Zhtz7idSxcspJQH6jhC74zuT3WEe2vefqxqYQXcif1fzupNi8eTP+7//+z/5es2YN7r33XsyZMwd777035s6d66VvNptYsGCBddzYd9998axnPQvveMc78LGPfQxz587F9ddfjxUrVuDb3/42AGC//fbDMcccg7e//e34j//4DwDAP/zDP+D4449PDiBPAYkAThRiA2I4ecj/h/d75GuJiyRv/P9ggPXDVriJR9rs1Gr1KLgWkJRaz8PYACnISrjtGq0LJ6+x//FW/RDPI766ljaEVrMhSLAlTt4kGbYFQU4WdoIldwSaRyyk/HXOJyGJVK45y/DECjnBmfowYbFlBoSSQ71Q7mS3Ggj53ghQBaHsaE1a0Q+UZGzlOrB2l3q7mW399PNlUwehztqAGnGOK21DJtm5QgaeBgwxyhVGm4DaRblrym97/lvbNQrSzNu2JflnJEPUP2xXchOvJGb2CDuhTZVl2zzhEynvWkA4ouSvpGq7R0jHWIhI1AkiSD+mcC+Vb67+Wuj84Z3yEhYkSWcdmUI1TehUpUR7+UHoDfmTWnvAI3+x8vzMZTldGqruVnhdfHuxdOEW/I4ClSVoG7aAxxsH8Mc//jFe/vKX299nnXUWAODkk0/GF7/4xZ7PN5tN3HjjjTjnnHPwmte8Bps3b8aznvUsfOlLX8KrX/1qm+5rX/sazjzzTCxZsgQAsHTp0p6xBxPiSARwolFH8GIDe5cBMq41EgO7zC8kgYC1WQu3W0NCyQTMWzUHhDKqfQzlDRHK1YsEeo+K7VdvO4qi9SVltlQjEyjXU5YfCxMTu241YVYTYWISCjJRtQeUbRxOatUYguE78WTPUNVy5IgjJDCcGU+e0hzIkEdVOscJuX1aMScwz5RNeLaYWeGOeCOlAyEXLeOgwcfYGTIptZkWmZODg1vHzrDV7SrqFuYTaQtJMLytRdF/HCkUBJPgvrPwu6gpV8YwrGxjCm1ehbzI9y/fWbdxoRfGkLZis9uDk3gaQc92MSC2cPd6Lg6lyKHNLoXvr/od2XGJ328PT+Z4wWO81guSzEb652SQP12w7FRP9fmx4+ijjwaN45lHHnmkcu3Zz342vvWtb3V9bs6cOfjqV786LtkS4kgEcCIQfmfhCriG2FUQTrx27uhypq98VubNk2CEgEmbO7ldXJGB80HNxNuNDIaTWUDCQhIYPqvTReThJErILgdYOekG8ksiHNsOl9vUsectSSE94fDRd34AX78d62y6QkISOoJ4z2fkTR6hMbu/fQZnv5e5v5UIzmxl4KDFLHJHP6OETLId7L/S2CUqv4xsFFAd8jR/ljgIAudpA0297bZuRl65XnOSe64iX5DePSTIAfdBYTdGkiAH2u06R4goQYb/HjyCJGSpC1Jc6wwVqVv0u+hBiF05kes1ZXn9BaLepg1j9oAxZ7Suciq/TUKbQ18mqtShQv56xb2LjcmxNHX3I/LX3gvSVBaACQmTjEQAtwdC8hMOKGMZrEOCFhCLp6otkM4NHGsPQHQ7tBL3K0RAOKPlhxOBIIEhSQ23X+2tyAra28ot6slijOyF4WcUwcYa5OuWpJjfHgksAcpIe6QqaE2fIhuc2K34RVmR98UTmpZRXINfV+/MXAKIjEAxjWdI2rhsSS4RpAnb3dRBiTYlfleZeSQgI9xPswLaebAjsjSkskLaZdvy79Kk5a1U2y5+G1a23PnvWP8nQdJlG8hFQ+hwIJ5hohjfJvWJebewJJVrgviFZYeIbSOOWdMVQG7jemSY6ydJmOxDHpER8goZ3Y84gVZ1eQvZQtR571biMBKicnll1aEbkat7djx5cr47kv+VIeMfJxJZ3emRCOBEIJwYwsm210AB8Z3KgVgFEyD88aOyldMtX5G31Ch6JDDIzzNGJ/H/UJ460oHI3+a33Oa1cfs8wavPu/h+ThtqiRm5+sk8eFKOOsDAkRImgbHrlgTmcKdWkN4CtZOQIS0Q25ax7W13z01Y/jYhvLa3BEW2hZ3kFCrvPTK5ymPwvOTBhO3yhet/IeGRJ32E7c7n/3J1SviTdoykc5niOStSSAxiz3ab6CXxk6Qvi6QNEbRHV+/SXpBkKNave8yzHvnzwgEJWYP8ogs2xXVRrn6SI7CcINu23eQONZ5j2eqMet7Gktd+OILA8iWKmAt0e1dhv+9WZkBkK44xsefGU5/tCSJ4A9JTej5hZ0YigBMBOSHDEZWuGjKhvbDBVC0hECRFEJKwzLGscmW+QIwAqcrZwdEtHLvqNvJGmiEqSw3J0GUJIgrRbl4FfBLhadXgroVlSWISDTgNN9lV+GnM5tJc1+fsOlLB3sQ2VIwiT+bKKxGTZ8/FOQGZDEws6xlO5AFUEWhpYv1IkMlaEcL+C9HPg632UhjrW1vBcNKUxLQDt90cHCEXavxCGcJ+JB1ColqpgDhIu9JujhWenaB4ju9XNFzy25dZReLeSbmiIASyKZ/U1tU1yL9ySThQ2D4SOXmkIncXOV1dfGJW0cqFBLFb/wsXH2IM4n5f0dyOZZEwFgTjc0iUZf5PeWt+O4NKAm2DBnA89nwJT08kAjgBsJN9uFIewyq0cjTbGAITc9pe9iRevp7GCd6Wp7QtjJGh0Njb0xLwQ3V1lQRFZm4JJ9lJgZTybXjshIGqlrJGwyGzr5BpBGQx1HiY6z3PMwYTS5GXnQQiZxazeEHjVm3GaurH7ywgu7ocuU3vSIokUMqUpcm+n69XlmyDmIG/eGe1tmR2kvYJnRNEfC8x5QQ/L+SulBGSq8BbWqnqcyH587SCIl1Fsx0Slogsse3bbtfso8p/ZzGE9fDtTeG9u9BxolsoFE/GgPxVNIi9eIBHQl0Dyj4YxiccT57R91QT/6/ObrNbXt2ud91afirk76mQ0YSE7YSdOCrR2PCZz3wGixcvRn9/Pw455BCsXLly3Hl424h1/xhiopGOBeF9nXHwt13xBsbEkXTRtGJiVOK+roNcuQekVuRtnwknNa6L2CKVdbf1jU1CshzlX2fZ2AbLI3Cx9uW6qCC9uB6rf2VSLyMG28F7lPmHbW2dRMw/q+XiZ1Q1jdXWBsGEJRGG/AcxmRJs+aQUylzpGHm5IyFe6Axy9dBt45fl1Vm8W3kCBkXa2CN2Ctp+kf8Z5x+WrWjpf2XDlW01wmF9EZdDasLY+aTM4wRUexaTF0fQhW0J6uOVGfnmRH+giKyVdgkgy/DOHK4hDUxswrBAlXSZ06h7cka+PfvO4ROd2q1ckY9MIz32OZ2ntZexEqW4dQSprt2CPu8R2JiGVjwTGyei1yMkjutbb2eMantNBfJH5bb/S9ipMa0J4DXXXIPly5fj3HPPxT333IMjjzwSxx57LB599NHxZRSbCENEyIP9aYPXRkaNYICKksxIurrn/dWtX7ZnUyYH8eA5L3vl/13Z2rRkJ2gjQWokCfTs6ayc5D1TO0mQSx+SvQqZRVA/2SZhO0bKjNrfee/Jvc8KwY+QN4AJobvPk2slNEuI2D0F7aFryJfVvhXk/+vo/2cdQ4wMwYi1H+dLSscEtFtx8AmQF5NNLkbMP4BlM/83pCXq3CAXNHXEVRA5lsuS7vBbk/XgsoXzD2WGrGZBo0o5wpA6YRgZ+Q5ku3iyuricnh2laDcV9CfvHeQB2RN9ShNFv2/VamwDVMhM7HuAnybaz23bVN9vNwLrCwOE32f4fGXrOqxn3TsB4nnXlFORT95TvgzeMYHdxqvtDCppm/8l7NyY1gTwkksuwdve9jb8/d//Pfbbbz9ceuml2GuvvXD55ZePP7O6SVgiJIFdYq7VISRQ40WMUMS0bXWTvx34Zdl24g/IW4XIREiTnKANUfDyNddrJwOINOL/3TSKtYR9LER+POD6xEi7mSiygnQ8Pak5DCZzWY8KCYmSWEMAPE0iT9bB5ATYWH46rp8rj8lQmSuhXVOIaluUeM9KkhunMXZaby2bKgQhrdOyeaTbET1J9kJS7REgmQ8/z/Xo5k0b9hf2mg36YkhquoLbNKIpipLCCCTp8WQPCXPsuW5jRk0fihHHuvKldtaVqbw8K7LVEaS69ozIU7vlOx7iF8oQk3MMMnTdEk5ImGKYtjaAo6OjWLVqFc455xzv+pIlS3DnnXdGnxkZGcHIyIj9vWHDBgBAMTrsVoCAT5jGsnrutjqvy2usA2ZNubLs0BYodg+oagdiBCDMOypvj+t1oSIqg2vNtVCeqCwhGQ9tsbq153gnisi7klvngCMAAKqG7WERISmXWUvCG8k32j4y6DKTYBHwulIViufVy7Yr7Euhl3TdOwxJYWUBQvDTRN5JNzs+eVKH1yYk2gL+N+Fdl+9LeEhX303vb6+2jMi3Fu0nYf9T8GSJ2gaGbSbeQdTrFdV2Csscs01ejCTVEbQYhJxOti7PjYWkdUvTZeyqc3aR9S9Gh3WaHeBg0aERbMs2bgftCZQmYSpi2hLAJ554AkVRYP78+d71+fPnY+3atdFnLrzwQnzgAx+oXP/Zl//fdpExISEhIWHnw6ZNmzA4OLhd8m61WliwYAHuWHvjNue1YMECtFqtCZAqYSpi2hJAhgo0A0RUucZ43/veZ883BID169dj0aJFePTRR7fbxzzR2LhxI/baay889thjmD179mSL0xNPN3mBJPOOwtNN5qebvECSeaJBRNi0aRMWLly43cro7+/HmjVrMDo6us15tVot9Pf3T4BUCVMR05YA7r777sjzvKLtW7duXUUryOjr60NfX1/l+uDg4JQbaHph9uzZTyuZn27yAknmHYWnm8xPN3mBJPNEYkcoC/r7+xNxS+iJaesE0mq1cMghh2DFihXe9RUrVuDwww+fJKkSEhISEhISErY/pq0GEADOOussLFu2DIceeihe8pKX4Morr8Sjjz6KU089dbJFS0hISEhISEjYbpjWBPDEE0/EH//4R3zwgx/E448/jgMOOAA33ngjFi1aNKbn+/r6cP7550e3hacqnm4yP93kBZLMOwpPN5mfbvICSeaEhJ0ZitKBfwkJCQkJCQkJ0wrT1gYwISEhISEhIWG6IhHAhISEhISEhIRphkQAExISEhISEhKmGRIBTEhISEhISEiYZkgE8CniM5/5DBYvXoz+/n4ccsghWLly5WSLZHHhhRfisMMOw6xZszBv3jy89rWvxS9+8QsvDRHhggsuwMKFCzEwMICjjz4aP/3pTydJYh8XXnghlFJYvny5vTYV5f3tb3+Lt7zlLZg7dy5mzJiB5z//+Vi1apW9P9Vk7nQ6OO+887B48WIMDAxgn332wQc/+EGUpTsvdLJlvv322/Ga17wGCxcuhFIK119/vXd/LPKNjIzgjDPOwO67746ZM2di6dKl+M1vfjMpMrfbbbz3ve/FgQceiJkzZ2LhwoV461vfit/97neTJnOvNpZ4xzveAaUULr300kmTd6wy/+xnP8PSpUsxODiIWbNm4cUvfjEeffTRSZM5IWGqIxHAp4BrrrkGy5cvx7nnnot77rkHRx55JI499lhvsJlM3HbbbTjttNPwwx/+ECtWrECn08GSJUuwZcsWm+YjH/kILrnkElx22WW4++67sWDBAvzVX/0VNm3aNImSA3fffTeuvPJKPO95z/OuTzV5n3zySbz0pS9Fs9nE//zP/+DBBx/Ev//7v2PXXXedsjJffPHFuOKKK3DZZZfhZz/7GT7ykY/gox/9KD71qU9NGZm3bNmCgw46CJdddln0/ljkW758Oa677jpcffXVuOOOO7B582Ycf/zxKIpih8s8NDSE1atX4/3vfz9Wr16Na6+9Fg899BCWLl3qpduRMvdqY8b111+Pu+66K3ps2VRqYwD45S9/iSOOOAL77rsvbr31VvzkJz/B+9//fu80jB0tc0LClAcljBsvfOEL6dRTT/Wu7bvvvnTOOedMkkTdsW7dOgJAt912GxERlWVJCxYsoIsuusimGR4epsHBQbriiismS0zatGkTPfvZz6YVK1bQUUcdRe985zuJaGrK+973vpeOOOKI2vtTUebjjjuO/u7v/s67dsIJJ9Bb3vIWIpp6MgOg6667zv4ei3zr16+nZrNJV199tU3z29/+lrIso5tuummHyxzDj370IwJAv/71r4locmWuk/c3v/kNPeMZz6AHHniAFi1aRB//+MftvanYxieeeKLtxzFMtswJCVMRSQM4ToyOjmLVqlVYsmSJd33JkiW48847J0mq7tiwYQMAYM6cOQCANWvWYO3atV4d+vr6cNRRR01qHU477TQcd9xxeOUrX+ldn4ry3nDDDTj00EPx+te/HvPmzcPBBx+Mz372s/b+VJT5iCOOwPe+9z089NBDAICf/OQnuOOOO/DqV796ysosMRb5Vq1ahXa77aVZuHAhDjjggClRB0B/j0opqy2eajKXZYlly5bh7LPPxv7771+5PxXl/c53voO/+Iu/wKte9SrMmzcPL3rRi7xt4qkmc0LCVEAigOPEE088gaIoMH/+fO/6/PnzsXbt2kmSqh5EhLPOOgtHHHEEDjjgAACwck6lOlx99dVYvXo1Lrzwwsq9qSjvr371K1x++eV49rOfjZtvvhmnnnoqzjzzTHz5y18GMDVlfu9734uTTjoJ++67L5rNJg4++GAsX74cJ510EoCpKbPEWORbu3YtWq0Wdtttt9o0k4nh4WGcc845eNOb3oTZs2cDmHoyX3zxxWg0GjjzzDOj96eavOvWrcPmzZtx0UUX4ZhjjsF3v/tdvO51r8MJJ5yA2267bUrKnJAwFTCtj4LbFiilvN9EVLk2FXD66afjvvvuwx133FG5N1Xq8Nhjj+Gd73wnvvvd73o2OyGmiryA1joceuih+PCHPwwAOPjgg/HTn/4Ul19+Od761rfadFNJ5muuuQZf/epX8fWvfx37778/7r33XixfvhwLFy7EySefbNNNJZljeCryTYU6tNttvPGNb0RZlvjMZz7TM/1kyLxq1Sp84hOfwOrVq8dd9mS1MTsx/fVf/zXe9a53AQCe//zn484778QVV1yBo446qvbZqdAvEhImC0kDOE7svvvuyPO8smpct25dRTMx2TjjjDNwww034Ac/+AH23HNPe33BggUAMGXqsGrVKqxbtw6HHHIIGo0GGo0GbrvtNnzyk59Eo9GwMk0VeQFgjz32wHOf+1zv2n777WcdgaZaGwPA2WefjXPOOQdvfOMbceCBB2LZsmV417veZbWuU1FmibHIt2DBAoyOjuLJJ5+sTTMZaLfbeMMb3oA1a9ZgxYoVVvsHTC2ZV65ciXXr1mHvvfe23+Kvf/1rvPvd78af//mfTzl5AT0mNxqNnt/jVJI5IWEqIBHAcaLVauGQQw7BihUrvOsrVqzA4YcfPklS+SAinH766bj22mvx/e9/H4sXL/buL168GAsWLPDqMDo6ittuu21S6vCXf/mXuP/++3Hvvffaf4ceeije/OY3495778U+++wzpeQFgJe+9KWV0DoPPfQQFi1aBGDqtTGgPVKzzP/k8zy3GpSpKLPEWOQ75JBD0Gw2vTSPP/44HnjggUmrA5O/hx9+GLfccgvmzp3r3Z9KMi9btgz33Xef9y0uXLgQZ599Nm6++eYpJy+gx+TDDjus6/c41WROSJgSmBzfk6c3rr76amo2m/T5z3+eHnzwQVq+fDnNnDmTHnnkkckWjYiI/vEf/5EGBwfp1ltvpccff9z+GxoasmkuuugiGhwcpGuvvZbuv/9+Oumkk2iPPfagjRs3TqLkDtILmGjqyfujH/2IGo0GfehDH6KHH36Yvva1r9GMGTPoq1/96pSV+eSTT6ZnPOMZ9O1vf5vWrFlD1157Le2+++70nve8Z8rIvGnTJrrnnnvonnvuIQB0ySWX0D333GM9Zsci36mnnkp77rkn3XLLLbR69Wp6xSteQQcddBB1Op0dLnO73aalS5fSnnvuSffee6/3PY6MjEyKzL3aOEToBbyj5R2LzNdeey01m0268sor6eGHH6ZPfepTlOc5rVy5ctJkTkiY6kgE8Cni05/+NC1atIharRa94AUvsCFWpgIARP9dddVVNk1ZlnT++efTggULqK+vj172spfR/fffP3lCBwgJ4FSU97//+7/pgAMOoL6+Ptp3333pyiuv9O5PNZk3btxI73znO2nvvfem/v5+2meffejcc8/1iMhky/yDH/wg2ndPPvnkMcu3detWOv3002nOnDk0MDBAxx9/PD366KOTIvOaNWtqv8cf/OAHkyJzrzYOESOAU6mNGZ///OfpWc96FvX399NBBx1E119//aTKnJAw1aGIiLavjjEhISEhISEhIWEqIdkAJiQkJCQkJCRMMyQCmJCQkJCQkJAwzZAIYEJCQkJCQkLCNEMigAkJCQkJCQkJ0wyJACYkJCQkJCQkTDMkApiQkJCQkJCQMM2QCGBCQkJCQkJCwjRDIoAJCQkJCQkJCdMMiQAmJCSMGZ///OexZMmSSSn7n//5n3HmmWdOStkJCQkJOxvSSSAJCQljwsjICPbZZx9cffXVOPLII3d4+evWrcMzn/lM3HfffVi8ePEOLz8hISFhZ0LSACYkJIwJ3/rWt7DLLrtMCvkDgHnz5mHJkiW44oorJqX8hISEhJ0JiQAmJEwz/OEPf8CCBQvw4Q9/2F6766670Gq18N3vfrf2uauvvhpLly71rp1yyil47Wtfiw9/+MOYP38+dt11V3zgAx9Ap9PB2WefjTlz5mDPPffEF77wBfvMI488AqUUvvnNb+LII4/EwMAADjvsMDz00EO4++67ceihh2KXXXbBMcccgz/84Q9eeUuXLsU3vvGNCWqJhISEhOmLRAATEqYZ/uzP/gxf+MIXcMEFF+DHP/4xNm/ejLe85S34p3/6p672fStXrsShhx5auf79738fv/vd73D77bfjkksuwQUXXIDjjz8eu+22G+666y6ceuqpOPXUU/HYY495z51//vk477zzsHr1ajQaDZx00kl4z3veg0984hNYuXIlfvnLX+Jf//VfvWde+MIX4rHHHsOvf/3riWmMhISEhGmKZAOYkDBNcdppp+GWW27BYYcdhp/85Ce4++670d/fH027fv167Lbbbrj99tu9LeBTTjkFt956K371q18hy/R6ct9998W8efNw++23AwCKosDg4CA+97nP4Y1vfCMeeeQRLF68GJ/73Ofwtre9DYDWLp500kn43ve+h1e84hUAgIsuughf/OIX8fOf/9yWt3HjRgwODuLWW2/FUUcdtV3aJSEhIWE6IGkAExKmKT72sY+h0+ngm9/8Jr72ta/Vkj8A2Lp1KwBE0+y///6W/AHA/PnzceCBB9rfeZ5j7ty5WLdunffc8573PO8ZAN5z8+fPrzwzMDAAABgaGupZv4SEhISEeiQCmJAwTfGrX/0Kv/vd71CWZc8t1blz50IphSeffLJyr9lser+VUtFrZVnWPqeUil4Ln/nTn/4EQG9jJyQkJCQ8dSQCmJAwDTE6Ooo3v/nNOPHEE/Fv//ZveNvb3obf//73telbrRae+9zn4sEHH9yBUlbxwAMPoNlsYv/9959UORISEhKe7kgEMCFhGuLcc8/Fhg0b8MlPfhLvec97sN9++1l7vDq86lWvwh133LGDJIxj5cqV1nM4ISEhIeGpIxHAhIRphltvvRWXXnopvvKVr2D27NnIsgxf+cpXcMcdd+Dyyy+vfe7tb387brzxRmzYsGEHSuvjG9/4Bt7+9rdPWvkJCQkJOwuSF3BCQsKY8YY3vAEHH3ww3ve+9+3wsr/zne/g7LPPxn333YdGo7HDy09ISEjYmZA0gAkJCWPGRz/6Ueyyyy6TUvaWLVtw1VVXJfKXkJCQMAFIGsCEhISEhISEhGmGpAFMSEhISEhISJhmSAQwISEhISEhIWGaIRHAhISEhISEhIRphkQAExISEhISEhKmGRIBTEhISEhISEiYZkgEMCEhISEhISFhmiERwISEhISEhISEaYZEABMSEhISEhISphkSAUxISEhISEhImGb4//dL9wKw/fFiAAAAAElFTkSuQmCC", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "HEAD Functional value for shot 96: loss 1.236203e+00 for shot 96\n", - "WORKER:0:0 (ShotID 96) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 96) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.64 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 42.22 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 46.29 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.83 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.69 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 92) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 92\n", - "HEAD Giving shot 98 to worker:0:1\n", - "WORKER:0:1 (ShotID 98) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 98) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 98) Spatial grid spacing (0.500 mm | 4.288 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 98) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 98) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 98) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 98) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.68 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 39.74 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.31 GFlops/s, 0.95 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.54 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.96 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 96) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 96\n", - "HEAD Giving shot 102 to worker:0:0\n", - "WORKER:0:0 (ShotID 102) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 102) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 102) Spatial grid spacing (0.500 mm | 4.288 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 102) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:0 (ShotID 102) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 102) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 102) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.67 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 41.27 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.61 s [OI=2.82, 42.13 GFlops/s, 0.92 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.91 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.06 s [OI=0.50, 43.55 GFlops/s, 10.89 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 98) Completed state equation run for shot\n", - "HEAD Functional value for shot 98: loss 1.267112e+00 for shot 98\n", - "WORKER:0:1 (ShotID 98) Preparing to run adjoint for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.64 s\n", - "WORKER:0:1 (ShotID 98) Running adjoint equation for shot\n", - "WORKER:0:0 Global performance: [OI=2.06, 43.20 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 44.76 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 44.50 GFlops/s, 11.13 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 102) Completed state equation run for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 102: loss 9.614290e-01 for shot 102\n", - "WORKER:0:0 (ShotID 102) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 102) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.73 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 37.02 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.62 s [OI=2.82, 41.35 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.44 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 15.66 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 98) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 98\n", - "HEAD Giving shot 109 to worker:0:1\n", - "WORKER:0:1 (ShotID 109) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 109) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 109) Spatial grid spacing (0.500 mm | 4.288 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 109) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.149 μs)\n", - "WORKER:0:1 (ShotID 109) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 109) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 109) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.79 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 34.20 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.67 s [OI=2.82, 38.34 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 3.79 GFlops/s, 0.07 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.77 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 102) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 102\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.53 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 52.17 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.48 s [OI=2.82, 53.35 GFlops/s, 1.16 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.24 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 58.22 GFlops/s, 14.56 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 109) Completed state equation run for shot\n", - "HEAD Functional value for shot 109: loss 1.171093e+00 for shot 109\n", - "WORKER:0:1 (ShotID 109) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 109) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.50 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 54.04 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.44 s [OI=2.82, 58.63 GFlops/s, 1.28 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 6.09 GFlops/s, 0.11 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.05 s [OI=0.25, 30.55 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 109) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 109\n", - "MONITOR Pending barrier tasks 1\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-2.572275e-04, 1.218688e-04]\n", - "HEAD \t grad after processing in range [-1.000000e+00, 4.735184e-01]\n", - "HEAD \t variable range before update [1.490000e+03, 1.507594e+03]\n", - "HEAD \t variable range after update [1.489074e+03, 1.516093e+03]\n", - "HEAD Done iteration 2 (out of 4), block 1 (out of 2) - Total loss_freq 1.824911e+01\n", - "HEAD ====================================================================\n", - "HEAD Starting iteration 3 (out of 4), block 1 (out of 2)\n", - "HEAD Giving shot 15 to worker:0:0\n", - "HEAD Giving shot 20 to worker:0:1\n", - "WORKER:0:0 (ShotID 15) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 15) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 15) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 15) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 15) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 15) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 15) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 20) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 20) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 20) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 20) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 20) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 20) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 20) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.55 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 50.27 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.49 s [OI=2.82, 51.91 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.45 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 53.03 GFlops/s, 13.26 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 15) Completed state equation run for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.63 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 43.89 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 44.92 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.42 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 46.92 GFlops/s, 11.73 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 20) Completed state equation run for shot\n", - "HEAD Functional value for shot 15: loss 1.094963e+00 for shot 15\n", - "WORKER:0:0 (ShotID 15) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 15) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 20: loss 1.112300e+00 for shot 20\n", - "WORKER:0:1 (ShotID 20) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 20) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.64 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 42.22 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 45.66 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.86 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 22.44 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 15) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 15\n", - "HEAD Giving shot 27 to worker:0:0\n", - "WORKER:0:0 (ShotID 27) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 27) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 27) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 27) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 27) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 27) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 27) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.73 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 37.02 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.64 s [OI=2.82, 40.15 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.87 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 20) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 20\n", - "HEAD Giving shot 30 to worker:0:1\n", - "WORKER:0:1 (ShotID 30) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 30) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 30) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 30) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 30) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 30) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 30) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.69 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 40.07 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.63 s [OI=2.82, 40.87 GFlops/s, 0.89 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.06 s [OI=0.50, 43.50 GFlops/s, 10.88 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 27) Completed state equation run for shot\n", - "HEAD Functional value for shot 27: loss 1.448839e+00 for shot 27\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.63 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 43.89 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 45.01 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.99 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.06 s [OI=0.50, 43.76 GFlops/s, 10.94 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 30) Completed state equation run for shot\n", - "WORKER:0:0 (ShotID 27) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 27) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 30: loss 1.592616e+00 for shot 30\n", - "WORKER:0:1 (ShotID 30) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 30) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.79 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 34.20 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.67 s [OI=2.82, 37.96 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.09 GFlops/s, 0.07 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.18 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 27) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 27\n", - "HEAD Giving shot 32 to worker:0:0\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.71 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 38.06 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.60 s [OI=2.82, 42.46 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.48 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.46 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 30) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 30\n", - "HEAD Giving shot 44 to worker:0:1\n", - "WORKER:0:0 (ShotID 32) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 32) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 32) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 32) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 32) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 32) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 32) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 44) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 44) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 44) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 44) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 44) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 44) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 44) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.69 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 40.07 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.62 s [OI=2.82, 41.40 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.08 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.06 s [OI=0.50, 38.39 GFlops/s, 9.60 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 44) Completed state equation run for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.82 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 33.72 GFlops/s, 0.68 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.75 s [OI=2.82, 34.25 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.10 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.85 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.07 s [OI=0.50, 36.20 GFlops/s, 9.05 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 32) Completed state equation run for shot\n", - "HEAD Functional value for shot 44: loss 9.760806e-01 for shot 44\n", - "WORKER:0:1 (ShotID 44) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 44) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 32: loss 1.648838e+00 for shot 32\n", - "WORKER:0:0 (ShotID 32) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 32) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.60 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 45.03 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.52 s [OI=2.82, 49.42 GFlops/s, 1.08 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.19 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 21.92 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 44) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 44\n", - "HEAD Giving shot 55 to worker:0:1\n", - "WORKER:0:1 (ShotID 55) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 55) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 55) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:1 (ShotID 55) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 55) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 55) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 55) Running state equation for shot\n", - "WORKER:0:0 Global performance: [OI=1.79, 40.33 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.01 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.68 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.02 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 32) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 32\n", - "HEAD Giving shot 56 to worker:0:0\n", - "WORKER:0:0 (ShotID 56) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 56) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 56) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 56) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 56) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 56) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 56) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.58 s\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 Global performance: [OI=2.06, 47.67 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.53 s [OI=2.82, 48.25 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.09 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 53.99 GFlops/s, 13.50 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 55) Completed state equation run for shot\n", - "HEAD Functional value for shot 55: loss 9.777708e-01 for shot 55\n", - "WORKER:0:1 (ShotID 55) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 55) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.64 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 43.20 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.65 GFlops/s, 0.95 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.07 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 51.49 GFlops/s, 12.88 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 56) Completed state equation run for shot\n", - "HEAD Functional value for shot 56: loss 9.225104e-01 for shot 56\n", - "WORKER:0:0 (ShotID 56) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 56) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 40.33 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.04 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.69 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 21.82 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 55) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 55\n", - "HEAD Giving shot 58 to worker:0:1\n", - "WORKER:0:1 (ShotID 58) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 58) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 58) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 58) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 58) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 58) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 58) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.65 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 41.57 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 45.38 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.75 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.99 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 56) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 56\n", - "HEAD Giving shot 72 to worker:0:0\n", - "WORKER:0:0 (ShotID 72) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 72) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 72) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 72) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 72) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 72) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 72) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.74 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 37.37 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.68 s [OI=2.82, 37.95 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.98 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.06 s [OI=0.50, 44.05 GFlops/s, 11.02 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 58) Completed state equation run for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 44.60 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 45.28 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.06 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 51.22 GFlops/s, 12.81 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 72) Completed state equation run for shot\n", - "HEAD Functional value for shot 58: loss 7.975239e-01 for shot 58\n", - "WORKER:0:1 (ShotID 58) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 58) Running adjoint equation for shot\n", - "HEAD Functional value for shot 72: loss 9.483827e-01 for shot 72\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 72) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 72) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.62 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 43.58 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.53 s [OI=2.82, 48.52 GFlops/s, 1.06 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.10 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 58) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 58\n", - "HEAD Giving shot 85 to worker:0:1\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.70 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 38.60 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.61 s [OI=2.82, 41.72 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.41 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.31 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 72) Completed adjoint equation run for shot\n", - "WORKER:0:1 (ShotID 85) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 85) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 85) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 (ShotID 85) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 85) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 85) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 85) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Retrieved gradient for shot 72\n", - "HEAD Giving shot 87 to worker:0:0\n", - "WORKER:0:0 (ShotID 87) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 87) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 87) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 87) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 87) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 87) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 87) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.54 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 51.20 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.49 s [OI=2.82, 52.28 GFlops/s, 1.14 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.18 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 53.95 GFlops/s, 13.49 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 85) Completed state equation run for shot\n", - "HEAD Functional value for shot 85: loss 1.435027e+00 for shot 85\n", - "WORKER:0:1 (ShotID 85) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 85) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 46.87 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.53 s [OI=2.82, 47.98 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.14 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 52.55 GFlops/s, 13.14 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 87) Completed state equation run for shot\n", - "HEAD Functional value for shot 87: loss 1.172027e+00 for shot 87\n", - "WORKER:0:0 (ShotID 87) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 87) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.65 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 41.57 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 45.55 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.92 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.24 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 85) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 85\n", - "HEAD Giving shot 104 to worker:0:1\n", - "WORKER:0:1 (ShotID 104) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 104) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 104) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 104) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 104) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 104) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 104) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.65 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 41.57 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 45.23 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.72 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 21.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 87) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 87\n", - "HEAD Giving shot 117 to worker:0:0\n", - "WORKER:0:0 (ShotID 117) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 117) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 117) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 117) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 117) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 117) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 117) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.64 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 43.20 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 43.86 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.20 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 55.33 GFlops/s, 13.84 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 104) Completed state equation run for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.60 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 46.08 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 46.60 GFlops/s, 1.02 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.23 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 58.39 GFlops/s, 14.60 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 117) Completed state equation run for shot\n", - "HEAD Functional value for shot 104: loss 8.546681e-01 for shot 104\n", - "WORKER:0:1 (ShotID 104) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 104) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 117: loss 7.345829e-01 for shot 117\n", - "WORKER:0:0 (ShotID 117) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 117) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.68 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 39.74 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.61 GFlops/s, 0.95 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.00 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.78 GFlops/s, 0.00 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 104) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 104\n", - "HEAD Giving shot 118 to worker:0:1\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.61 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 44.30 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.52 s [OI=2.82, 49.01 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.10 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.84 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 117) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 117\n", - "WORKER:0:1 (ShotID 118) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 118) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 118) Spatial grid spacing (0.500 mm | 4.285 PPW) is higher than dispersion limit (0.429 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 118) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 118) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 118) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 118) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.47 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 58.83 GFlops/s, 1.18 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.43 s [OI=2.82, 60.43 GFlops/s, 1.32 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.36 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 64.41 GFlops/s, 16.11 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 118) Completed state equation run for shot\n", - "HEAD Functional value for shot 118: loss 9.810508e-01 for shot 118\n", - "WORKER:0:1 (ShotID 118) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 118) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.46 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 58.74 GFlops/s, 1.21 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.42 s [OI=2.82, 61.43 GFlops/s, 1.34 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 6.49 GFlops/s, 0.11 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.04 s [OI=0.25, 43.96 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 118) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 118\n", - "MONITOR Pending barrier tasks 1\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-1.949478e-04, 1.163244e-04]\n", - "HEAD \t grad after processing in range [-1.000000e+00, 5.967184e-01]\n", - "HEAD \t variable range before update [1.489074e+03, 1.516093e+03]\n", - "HEAD \t variable range after update [1.483947e+03, 1.520258e+03]\n", - "HEAD Done iteration 3 (out of 4), block 1 (out of 2) - Total loss_freq 1.669718e+01\n", - "HEAD ====================================================================\n", - "HEAD Starting iteration 4 (out of 4), block 1 (out of 2)\n", - "HEAD Giving shot 2 to worker:0:0\n", - "HEAD Giving shot 6 to worker:0:1\n", - "WORKER:0:0 (ShotID 2) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 2) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 2) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 2) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 2) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 2) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 2) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 6) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 6) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 6) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 6) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 6) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 6) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 6) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.55 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 50.27 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.50 s [OI=2.82, 51.17 GFlops/s, 1.12 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.22 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 54.31 GFlops/s, 13.58 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 2) Completed state equation run for shot\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 44.60 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 45.43 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.18 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 53.78 GFlops/s, 13.45 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 6) Completed state equation run for shot\n", - "HEAD Functional value for shot 2: loss 8.168808e-01 for shot 2\n", - "WORKER:0:0 (ShotID 2) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 2) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 6: loss 8.358492e-01 for shot 6\n", - "WORKER:0:1 (ShotID 6) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 6) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.60 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 45.03 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.51 s [OI=2.82, 50.10 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.19 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.06 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 2) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 2\n", - "HEAD Giving shot 7 to worker:0:0\n", - "WORKER:0:0 (ShotID 7) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 7) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 7) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 7) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 (ShotID 7) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 7) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 7) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 40.33 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 43.90 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.71 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 21.76 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 6) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 6\n", - "HEAD Giving shot 24 to worker:0:1\n", - "WORKER:0:1 (ShotID 24) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 24) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 24) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 24) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 24) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 24) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 24) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.72 s\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.53 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 38.40 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:1 Global performance: [OI=2.06, 52.17 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.66 s [OI=2.82, 38.94 GFlops/s, 0.85 GPts/s]\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.48 s [OI=2.82, 54.08 GFlops/s, 1.18 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.22 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.34 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 47.06 GFlops/s, 11.77 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 55.49 GFlops/s, 13.88 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 7) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 24) Completed state equation run for shot\n", - "HEAD Functional value for shot 7: loss 8.400701e-01 for shot 7\n", - "HEAD Functional value for shot 24: loss 1.267633e+00 for shot 24\n", - "WORKER:0:0 (ShotID 7) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 7) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 24) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 24) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.53 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 50.98 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.45 s [OI=2.82, 57.09 GFlops/s, 1.25 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.59 GFlops/s, 0.10 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.39 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 7) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 7\n", - "HEAD Giving shot 28 to worker:0:0\n", - "WORKER:0:0 (ShotID 28) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 28) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 28) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 28) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 28) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 28) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 28) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.82 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 32.95 GFlops/s, 0.68 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.72 s [OI=2.82, 35.56 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.33 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.17 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 24) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 24\n", - "HEAD Giving shot 48 to worker:0:1\n", - "WORKER:0:1 (ShotID 48) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 48) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 48) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 48) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 48) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 48) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 48) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.64 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 43.20 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.07 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.24 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 51.69 GFlops/s, 12.93 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 28) Completed state equation run for shot\n", - "HEAD Functional value for shot 28: loss 1.347402e+00 for shot 28\n", - "WORKER:0:0 (ShotID 28) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 28) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.55 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 50.27 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.50 s [OI=2.82, 51.31 GFlops/s, 1.12 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.32 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 55.18 GFlops/s, 13.80 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 48) Completed state equation run for shot\n", - "HEAD Functional value for shot 48: loss 8.294619e-01 for shot 48\n", - "WORKER:0:1 (ShotID 48) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 48) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n" - ] - }, + } + ], + "source": [ + "import mosaic\n", + "\n", + "await mosaic.interactive('on', num_workers=2, log_level='info')\n", + "runtime = mosaic.runtime()" + ] + }, + { + "cell_type": "markdown", + "id": "announced-cambridge", + "metadata": {}, + "source": [ + "## Problem definition\n", + "\n", + "Let's start by defining out problem as usual, starting with the spatiotemporal grid." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "broad-pilot", + "metadata": {}, + "outputs": [], + "source": [ + "from stride import Space, Time, Grid\n", + "%matplotlib widget\n", + "\n", + "space = Space(shape=(356, 385), extra=(50, 50), absorbing=(40, 40), spacing=0.5e-3)\n", + "time = Time(start=0.0e-6, step=0.08e-6, num=2500)\n", + "\n", + "grid = Grid(space, time)" + ] + }, + { + "cell_type": "markdown", + "id": "magnetic-origin", + "metadata": {}, + "source": [ + "We create the problem object." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "therapeutic-ridge", + "metadata": {}, + "outputs": [], + "source": [ + "from stride import Problem\n", + "\n", + "problem = Problem(name='breast2D', space=space, time=time)" + ] + }, + { + "cell_type": "markdown", + "id": "breathing-guarantee", + "metadata": {}, + "source": [ + "And we start filling it up we our transducers and geometry." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "unsigned-elephant", + "metadata": {}, + "outputs": [], + "source": [ + "# Create transducers\n", + "# the default option will create a single point transducer\n", + "problem.transducers.default()\n", + "\n", + "# Create geometry\n", + "# a default elliptical geometry will be generated in this case\n", + "num_locations = 120\n", + "problem.geometry.default('elliptical', num_locations)" + ] + }, + { + "cell_type": "markdown", + "id": "constitutional-daniel", + "metadata": {}, + "source": [ + "We are going to populate our acquisition sequence with 120 shots (one for each location in the geoemtry). During each shot, a different location is going to act as the source and the rest of them are going to act as receivers.\n", + "\n", + "We can easily do this in Stride by calling the `default()` method of the `stride.Acquisitions` object." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "incorporated-pressing", + "metadata": {}, + "outputs": [], + "source": [ + "from stride.utils import wavelets\n", + "\n", + "# Populate acquisitions with default shots\n", + "problem.acquisitions.default()\n", + "\n", + "# Create wavelets\n", + "f_centre = 0.50e6\n", + "n_cycles = 3\n", + "\n", + "for shot in problem.acquisitions.shots:\n", + " shot.wavelets.data[0, :] = wavelets.tone_burst(f_centre, n_cycles, time.num, time.step)" + ] + }, + { + "cell_type": "markdown", + "id": "legitimate-linux", + "metadata": {}, + "source": [ + "Now, let's load our breast model." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "impressive-tribe", + "metadata": {}, + "outputs": [], + "source": [ + "from stride import ScalarField\n", + "\n", + "# Create medium\n", + "vp_true = ScalarField(name='vp', grid=grid)\n", + "vp_true.load('../examples/breast2D/data/anastasio2D-TrueModel.h5')\n", + "\n", + "problem.medium.add(vp_true)" + ] + }, + { + "cell_type": "markdown", + "id": "adjustable-label", + "metadata": {}, + "source": [ + "To get a plot of all components of the problem together, we can call the utility function `plot()` on the problem object." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "handled-economy", + "metadata": {}, + "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.61 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 44.30 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.52 s [OI=2.82, 48.96 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.01 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.24 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 28) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 28\n", - "HEAD Giving shot 54 to worker:0:0\n", - "WORKER:0:0 (ShotID 54) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 54) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 54) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 54) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 54) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 54) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 54) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.80 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 33.78 GFlops/s, 0.70 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.70 s [OI=2.82, 36.58 GFlops/s, 0.80 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.43 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.17 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 48) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 48\n", - "HEAD Giving shot 65 to worker:0:1\n", - "WORKER:0:1 (ShotID 65) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 65) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 65) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 65) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 65) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 65) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 65) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.61 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 45.33 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 46.20 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.20 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 54.26 GFlops/s, 13.57 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 54) Completed state equation run for shot\n", - "HEAD Functional value for shot 54: loss 7.690869e-01 for shot 54\n", - "WORKER:0:0 (ShotID 54) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 54) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.53 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 52.17 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.48 s [OI=2.82, 53.68 GFlops/s, 1.17 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.44 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 54.60 GFlops/s, 13.65 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 65) Completed state equation run for shot\n", - "HEAD Functional value for shot 65: loss 8.265238e-01 for shot 65\n", - "WORKER:0:1 (ShotID 65) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 65) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.75 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 36.03 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.65 s [OI=2.82, 39.40 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.77 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 18.99 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 54) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 54\n", - "HEAD Giving shot 71 to worker:0:0\n", - "WORKER:0:0 (ShotID 71) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 71) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 71) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 71) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 71) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 71) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 71) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.69 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 39.16 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.60 s [OI=2.82, 42.73 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.00 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.32 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 65) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 65\n", - "HEAD Giving shot 76 to worker:0:1\n", - "WORKER:0:1 (ShotID 76) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 76) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 76) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 76) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 76) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 76) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 76) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 46.87 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.53 s [OI=2.82, 48.24 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.15 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 53.05 GFlops/s, 13.27 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 71) Completed state equation run for shot\n", - "HEAD Functional value for shot 71: loss 9.669240e-01 for shot 71\n", - "WORKER:0:0 (ShotID 71) Preparing to run adjoint for shot\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4ed71cc916cf46259748b90c44047f8b", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyAAAAJYCAYAAACadoJwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9ebgcZ3nmj3/et6p6X86mzVosSzZeZGODt4ADMUvABjuGGAwJq3FYkiGTZH6TmWTiuYCBEBIIg/PNkBkghOBkME5sh8WJh9UBjLHxvm+SZcmStZ2t967t/f3xVLckLNmSfI4syc/nuvqSTndXdXWfc+q8dz3Pc9/GOedQFEVRFEVRFEU5CNjn+wAURVEURVEURXnhoAJEURRFURRFUZSDhgoQRVEURVEURVEOGipAFEVRFEVRFEU5aKgAURRFURRFURTloKECRFEURVEURVGUg4YKEEVRFEVRFEVRDhoqQBRFURRFURRFOWioAFEURVEURVEU5aChAkRRFEVRFEVRlIOGChBFURRFURRFUQ4aKkAURVEURVEURTloqABRFEVRFEVRFOWgoQJEURRFURRFUZSDhgoQRVEURVEURVEOGipAFEVRFEVRFEU5aKgAURRFURRFURTloKECRFEURVEURVGUg4YKEEVRFEVRFEVRDhoqQBRFURRFURRFOWioAFEURVEURVEU5aChAkRRFEVRFEVRlIOGChBFURRFURRFUQ4aKkAURVEURVEURTloqABRFEVRFEVRFOWgoQJEURRFURRFUZSDhgoQRVEURVEURVEOGipAFEVRFEVRFEU5aKgAURRFURRFURTloKECRFEURVEURVGUg4YKEEVRFEVRFEVRDhoqQBRFURRFURRFOWioAFEURVEURVEU5aChAkRRFEVRFEVRlIOGChBFURRFURRFUQ4aKkAURVEURVEURTloqABRFEVRFEVRFOWgoQJEURRFURRFUZSDhgoQRVEURVEURVEOGipAFEVRFEVRFEU5aKgAURRFURRFURTloKECRFEURVEURVGUg4YKEEVRFEVRFEVRDhoqQBRFURRFURRFOWioAFEURVEURVEU5aChAkRRFEVRFEVRlIOGChBFURRFURRFUQ4aKkAURVEURVEURTloqABRFEXZRxqNBqVSCWMMH/nIR571+a961aswxnDGGWcM71u5ciXGGD760Y8C8A//8A/8yq/8CuPj45RKJU455RT+9E//lG63O19vQ1EURVGeV1SAKIqi7CO1Wo1f+7VfA0Q4PBNPPvkkP/rRjwB417vetcfnvPe97+Vd73oXP/rRj5iamqLb7XLfffdx+eWXc+aZZ7Jt27a5fQOKoiiKcgigAkRRFGU/GIiJdevWcdNNN+31ef/4j/9Imqb4vs9v/MZvPO3xr371q/z93/89l1xyCbfeeis7duzg7rvv5rd/+7cBuP/++7n44otxzs3PG1EURVGU5wkVIIqiKPvB61//ehYuXAjAlVdeudfnDSokuz5/Vx5//HEuvfRSvv71r3PmmWcyPj7Oi1/8Yj7/+c9z+eWXA/CTn/yEq6++eh7ehaIoiqI8f6gAURRF2Q92rWhcffXVhGH4tOfcdddd3HfffcDe26/y+Tyf+cxn9vjYf//v/53FixcD8Ld/+7dzcdiKoiiKcsigAkRRFGU/GYiK6elprr/++qc9PqiM7Doz8ouce+65jI2N7fGxXC7HhRdeCMDNN99MmqZzcdiKoiiKckigAkRRFGU/Of300znppJOAp7dhpWnKVVddBcBb3/pWisXiHvdx4oknPuNrDPbfarXYsWPHcz1kRVEURTlkUAGiKIpyAAyqINdffz3T09PD+7///e+zefPm3Z6zJyqVyjPuf9fHm83mczlURVEURTmkUAGiKIpyALzjHe/AWksYhrsNig8qIkcffTSvfOUr97p9u91+xv23Wq3h/6vV6nM8WkVRFEU5dFABoiiKcgAsX76cX/mVXwF2io5Op8N1110HwDvf+U6MMXvd/sEHH3zG/Q8er1QqTExMzMUhK4qiKMohgQoQRVGUA+Td7343ADfddBPr1q3juuuuG1Yunqn9CuDGG2/crXVrV6Io4lvf+hYAL3vZy7BWT9WKoijKkYP+VVMURTlALr74YkqlEiC5H4PsjzPPPJPjjz/+Gbft9Xr8l//yX/b42Cc/+UmeeuopAC677LI5PGJFURRFef5RAaIoinKAVKtVLrroIgC+9KUv8d3vfhfYWRl5JlauXMmXvvQlfuM3foPbbruNqakp7r33Xj784Q/z0Y9+FIBf/uVf5pJLLpm341cURVGU5wPjnHPP90EoiqIcrtxwww2cf/75w6+DIGDz5s17ndtYuXIlTzzxBB/5yEdYu3btsGryi6xZs4bvf//7LFq0aF6OW1EURVGeL7QCoiiK8hz41V/91WFqOcB55523z0PjV155JX/3d3/HOeecw+joKMVikTVr1vDxj3+cn//85yo+FEVRlCMSFSCKoijPAc/zeOqpp3DO4Zzjm9/85n5t/973vpef/OQnTE1N0el0uO+++7j88sv3GmCoKIpyKPP444/zxS9+kfe///2ceuqp+L6PMYZPfOIT+7T91VdfzXnnnceiRYvI5/MsXbqU8847jy9/+ctPe+5XvvIVjDHPeLvhhhv2+lqbNm3iAx/4AMuXLyefz7NixQo++MEPsmnTpgN+/8q+4T/fB6AoiqIoiqIcGVxxxRVcccUV+71dv9/nkksuGV7EWbVqFUcffTRbtmzhu9/9Ljt27OB973vfHrdduHAhxx133B4fGx0d3eP9DzzwAK94xSuYmpqiXq9z8skns3btWr7whS9wzTXX8JOf/IQTTjhhv9+Hsm+oAFEURVEURVHmhImJCS644ALOOusszjzzTL70pS9xzTXXPOt2l156Kd/85jd55StfyRe+8IXdnAS3b9/OnXfeuddtzz//fL7yla/s8zEmScJb3/pWpqamuPjii/nqV79KqVSi3W7z7ne/m2uvvZa3ve1t3HnnnWqDPk+oAFEURVEURVHmhMsvv3y3r6+66qpn3eaGG27ga1/7GieccAI33HDD01pQFyxYwOte97o5O8Zrr72WBx54gPHxcf7u7/5uaKdeLpf5yle+wr//+79zzz338I1vfIM3v/nNc/a6yk5U1imKoiiKoijPG5/73OcADtr827XXXgvAJZdcQrVa3e2xarXKW9/6VgD+6Z/+ad6P5YWKVkAURVEURVGU54Vut8v3v/99jDG88Y1v5MYbb+TKK69k/fr1jIyM8IpXvILLLrvsaUJhV+6++25+8zd/ky1btlCr1XjJS17CO9/5TlavXr3H5//sZz8D4Jxzztnj4+eccw7/+3//b2655Zbn/gaVPaICRFEU5SCyfv365/sQFEVRDhnuvvtu4jhm6dKl/Pmf/zmf+tSndnv82muv5dOf/jTXX389p5122h73cdddd3HXXXcNv/7GN77Bxz/+cT72sY/xJ3/yJ7s9NwxDNmzYAMig+54Y3L9+/XqiKCIIggN8d8reUAFyCJGmKZs3b6ZarWKMeb4PR1EURVGUfcA5R7PZ5KijjnpehpZ7vR5hGM7Lvp1zT1uT5PN58vn8nOz/qaeeAmDbtm186lOf4sILL+TTn/40xxxzDHfffTcf+tCHuOOOO7jooou4//77qVQqw21HRkb43d/9Xd7+9rdz7LHHUq/XefDBB/nsZz/LlVdeyeWXX069XufDH/7wcJvZ2VnSNAX27pA1uD9NUxqNBuPj43PyXpVdcMohw8aNGx2gN73pTW9605veDsPbxo0bD/raodvtusULvXl7T5VK5Wn3feQjH9nn43vPe97jAPfxj398j49feeWVw/2uWrXKhWG42+NPPfWUK5VKDnB/9Vd/tc+v+/u///sOcPV63TUajeH9GzZsGL7e2rVr97jt2rVrn9fv6QsBrYAcQgz6G89+xR/h+3NzZUFRFEVRlPkljvvc8uNPPeOcwnwRhiFbtiU8cftKatW5rb40milHn76ejRs3UqvVhvfPVfUDoFAoDP//O7/zO09rd1q8eDFvf/vb+fKXv8wNN9zA7/7u7+7Tfj/2sY/xN3/zN8zOzvKDH/yAiy666Gmvt7eqUb/fH/5fQ2HnBxUghxCDEqfv5/H9wrM8W1EURVGUQ4nns326UjVUqnP7+imyv1qttpsAmUt2bYPaW/DfiSeeCOzfDF2tVmPNmjXccccdPPbYY8P76/U61lrSNGV6enqP2w7ut9bO2/t+oaM2vIqiKIqiKMrzwq6Bg3urrAzuT5Jkv/Y9qKbEcTy8L5fLsWLFCgDWrVu3x+0G969cuVIH0OcJFSCKoiiKoiiHOYlL5+U23yxbtozly5cDzy4Ili5dus/7TZKEhx9+ePgau3L22WcDcNNNN+1x28H9g+cpc48KEEVRFEVRlMOcFDcvt4PBIPjvq1/96tMe6/V6fP3rXwfg1a9+9T7v82//9m+ZmZnB8zzOPffc3R779V//dQCuvvpqms3mbo81m81hAOFb3vKWfX49Zf9QAaIoiqIoiqI8b/zhH/4hlUqFm266iT/90z8d2uR2u10+9KEP8dRTTzE6OsoHPvCB4TaNRoPf+I3f4NZbb91tX0mS8MUvfpHf+73fA+Cyyy57WuXk4osv5oQTTmBycpJLL72UTqcDQLvd5tJLL2VycpKTTz6ZN73pTfP4rl/YGOfcwZG3yrPSaDSo1+uc86qP6BC6oiiKohwmxHGPm374MWZnZw/60PJg7bD54WXz4oJ11PFP7tf7uummm4aOUwCtVot+v0+pVNrNUerOO+8ctl4BfOtb3+Itb3kLYRiyaNEiVqxYwSOPPMLs7CylUonrrruO173udcPnz8zMDAfYR0ZGOOaYY/B9n0cffZSZmRkAzj//fK699trdnK8G3Hfffbzyla9kenqaer3Osccey2OPPcbs7CxjY2P8+Mc/5qSTTtqvz0vZd7QCoiiKoiiKoswJURQxOTk5vA0sbTudzm73/+JA+YUXXshtt93G29/+dowx3HXXXZTLZd797ndz++237yY+AMrlMn/xF3/Bm970JiYmJli7di133XUXhUKBN77xjXz961/n+uuv36P4ADj55JO5++67+a3f+i0qlQr33nsvlUqF97///dx9990qPuYZrYAcQmgFRFEURVEOPw6FCsjGh5bOSwVk+Qmbnpf3pRzZaAVEURRFURRFUZSDhgYRKoqiKIqiHObMh2vVwXLBUl54aAVEURRFURRFUZSDhlZAFEVR9pOTZ9bzrnU/YFVrK+sqi7hy1au5b2Tl8/Z8RVGUFEeiFRDlMEEFiKIoL3j2Z8F/8sx6PnfbFzHO4eEY6zc5fWotv3/G+/e4zXw/f3+PX1GUIxNtwVIOJ7QFS1GUI46TZ9bz53d8mX/60Z/x53d8mZNn1j/jcz932xc5Y/IxFvQbnDH5GJ+77Yt73eZd634wFAcAHg7jHO9a94Pn5fn7e/yDbfb181EURVGUuUYFiKIoRxTzLShWtbYOnzvAw7GqtfV5ef7BECyKohz6JM7Ny01R5gMVIIqiHBbs61X7+RYU6yqLSDC73ZdgWFdZ9Lw8/2AIFq2WKIqiKHOJChBFUQ559ueq/XwLiitXvRpnzHCbBIMzhq+ues3z8vz5FCxaLVGUw4d0nm6KMh+oAFEU5ZBnf67az7eguG9kJb9/xvu5bfxYtudr3DZ+LL93xge4f+To5+X58ylY9rdaoiiKoij7grpgKYryvLA/zk37c9X+ylWv5vSptSROnrOvgmLXY/nqqtfsdcE/2Oa/vvR9+/xe5/P5+3v8+/P57G81CdSRS1GeL5J5sOGd6/0pygAVIIqiHHT212p2XWURY/3mbovhvV21PxiC4lBjvgTL/nzucGAWwoqiKMoLDxUgiqIcdPbU2pM4uX9PC+kDqWoczoJivtnXz2d/P/f9/b4qijJ3JE5uc71PRZkPVIAoijJn7Gv7zf629hxIVUN57uzv576/31dt11KUuWM+hsZ1CF2ZL1SAKIoyJ+xP+83+tvaAVjWeL/bnc9+f76u2aymKorxwURcsRVHmhP1xTNpf5ybl8GB/vq/qsKUoc0uK/O7N5S39Bcc8RZkrVIAoijIn7E/7zf5azSqHB/vzfT0Qhy1FURTlyEBbsBRFeUb2tU9/f9uqtKXqyGRfv68H4rCl8yKKsndSJ7e53qeizAcqQBRF2Sv706e/v45Jygub/fl50XkRRVGUIwttwVIUZa/sT5++tlUp+8P+/LzovIiiPDtzPf8xuCnKfKAVEEVR9sqB2OVqW5Wyr+zrz4vOiyiKohxZqABRlBcg8zXXoSjzgc6LKMqzMx8VC62AKPOFChBFeYGhcx3K4YbOiyjKs5M6Q+rmVjDM9f4UZcARMwPy+OOP88UvfpH3v//9nHrqqfi+jzGGT3ziE3vdxhizT7e///u/3227r3zlK8+6zQ033DDfb1lRDgid61AON3ReRFEU5cjiiKmAXHHFFVxxxRX7tc0555yz18emp6d54IEHAPilX/qlPT5n4cKFHHfccXt8bHR0dL+ORVEOFjrXoRyO6LyIojwz2oKlHE4cMQJkYmKCCy64gLPOOoszzzyTL33pS1xzzTXPuM1PfvKTvT52+eWX88ADD3DWWWdx/PHH7/E5559/Pl/5yleey2ErykFH5zqUIxn9+VYURTn0OWIEyOWXX77b11ddddUB78s5xz/+4z8C8K53ves5HZeiHCz2dfBW5zqUI5n9/fnWgXXlSCHBksxxZ30yp3tTlJ0cMQJkLvnxj3/M+vXrCYKAt7/97c/34SjKs7I/g7eDfvpdF11fXfUanetQjgj25+dbB9YVRVGeH1SA7IF/+Id/AOC8885jYmJir8+7++67+c3f/E22bNlCrVbjJS95Ce985ztZvXr1wTpURQH2PHibOLl/T33zOtehHMns68/3/v7eKMqhjJsHFyynLljKPKEC5Bfo9/v80z/9E/Ds7Vd33XUXd9111/Drb3zjG3z84x/nYx/7GH/yJ38yn4epKLuhg7eKsv/o742iKMrzwxFjwztXfOtb32JmZoZ6vc6FF164x+eMjIzwu7/7u9x0001s3bqVXq/HnXfeybve9S6SJOHyyy/nr//6r5/1tfr9Po1GY7ebohwI6yqLnuZWooO3ivLM6O+NciQxcMGa65uizAdaAfkFBu1Xb33rWykUCnt8zpve9Cbe9KY37Xbfaaedxle/+lXGx8f53Oc+x+WXX8573vMeqtXqXl/rz/7sz/jYxz42Z8euHHnoYLmizB86sK4oivL8oBWQXZicnORf//VfAXj3u999QPv42Mc+Rj6fZ3Z2lh/84JmDr/74j/+Y2dnZ4W3jxo0H9JrKkclgQPaMycdY0G9wxuRjfO62L3LyzPqnPVcDAxVl/9mf35v9+X1UlOeDxNl5uSnKfKAVkF34+te/ThRFrFy5kl/+5V8+oH3UajXWrFnDHXfcwWOPPfaMz83n8+Tz+QN6HeXIRwfLFWX+0YF15UghxZDO8XXl9BdmpBRlrlBpuwuD9qt3vvOdGHPgfY9BEAAQx/GcHJfywkQHZBXl0EF/HxVFUeYOFSAZa9eu5eabbwZEgBwoSZLw8MMPA7Bs2bI5OTblhYkOyCrKoYP+PiqHOjqErhxOqADJuPLKKwE466yzOP744w94P3/7t3/LzMwMnudx7rnnztHRKS9Erlz1apzZ+QdAB8sV5flDfx8VRVHmDp0ByfjHf/xH4NmzPxqNBh/84Af5gz/4A84666zh/UmS8OUvf5nf+73fA+Cyyy5j6dKl83fAymHNvrjpaGK5ohw67G/CurplKQeb+RgaT5zOgCjzg3HuyPjpuummm7jooouGX7daLfr9PqVSiWKxOLz/zjvvZPny5btte/PNN/Pyl7+cIAjYvHnzM6afz8zMMDo6CkgeyDHHHIPv+zz66KPMzMwAcP7553Pttdfu1cZ3bzQaDer1Oue86iP4/v5tqxw+DNx0BgOtgyupv3/G+3WRoiiHOfr7/cIkjnvc9MOPMTs7S61WO6ivPVg7XHf3cZSr3pzuu91MePOpjz4v70s5sjliWrCiKGJycnJ46/f7AHQ6nd3uT5LkadsO2q/OO++8ZxQfAOVymb/4i7/gTW96ExMTE6xdu5a77rqLQqHAG9/4Rr7+9a9z/fXX77f4UF447MlNxzjHu9Y9s22zoiiHPvr7rTxfiAvW3N8UZT44Ylqwzj33XA60mPP5z3+ez3/+8/v03CAI+MM//MMDeh1FAXXTOaKwz/DHOT0iisvKfqK/34qiKM/OESNAFOVwYV1lEWP95m6LFHXTOcR4JmEBOAMYg7OAgdQ3pL4BAyYBL0wxiYHsoog5EC2iAuawRH+/leeLFEuiOSDKYYIKEEU5yFy56tWcPrWWxLFbj7i66TzPZKLDWRETaWBIfXBeJjR2IfUMcQnCmsF5kOQhrKdgwIYGv+sRNCA36/B7TgSIewYh4sAmDhvJzaTZ8Ti3+zYqSg559Pdbeb7QIXTlcEIFiKIcZNTd6hBhIDhMJjpyhrho6dcM/TFDVHakeUjyDpONjrmcw1kHvqM03mHNoi1Y41iYb/Ly6mMkWKbiCut749w+uYINT43BbADOYByYyGATSD1wngOD3FLw+ha/ZQg6YCNElMSOoOUIOm5YVTEDEaJi5JBEf7+VFzqPP/443/ve97j11lu59dZbuf/++0mShI9//ONcfvnlz7r91VdfzZe//GXuvPNOZmZmmJiY4JRTTuGSSy7hfe97327PfeSRR7jmmmv44Q9/yD333MPk5CTVapVTTz2Vd7/73bznPe/B2qeLshtvvJFXvepVz3gcf/M3f8OHPvSh/Xvzyj6jAkRR5ph9tdj9ry993553oMwdu4iMXVumnJX/p74hyRuioqE/auguSSmumuXVyx/l+NIWgkx53NVaQeIMZ1UfZ9xvEZiYEdthgdfFw1EyMObl6bmYB8MceRuxOD9La1GBxFmqXo+8jVjXXcBUWGZlaZIxv03J9inYiHaap5UUmIrLbOyMMhMW8W3KTK/IxvUTFJ8MyE96FKZTgm6KDR0m/YUKiQqSQ4Z9+f1Wq15lrkmxpIdAC9YVV1zBFVdcsd/b9ft9LrnkEr75zW8CsGrVKo4++mi2bNnCd7/7XXbs2LGbAEmSZLfctmXLlnHaaaexYcMGbrzxRm688UauuuoqvvGNb+zVGKhWq3HKKafs8bElS5bs93tQ9h0VIIoyh/yiBedYv8npU2vVgnO++IUqxtMwkAaGuGCJSoakAEnBkOTAeRDWHfGCiMpoh9FSl1Or0/zyyKO8uvwIy7wAzxhm0xCPlJ4L+NXyYyzy8lgskUtoOSgZn4rd+cdtgddldW4rzbRIYGIWeE0W2D4Rhi3FMqmzHO038AwkDlKgmQaUbEzVODpj8vVMWmRLXGfj0jEeai3h1qdWsP2xOoVJn9yMI9dyeKFUSWzkMLHDpCpIDgf0PKEcyUxMTHDBBRdw1llnceaZZ/KlL32Ja6655lm3u/TSS/nmN7/JK1/5Sr7whS/sJi62b9/OnXfeudvznXOMjIzw4Q9/mEsvvZRVq1YNH7v66qt573vfy3e+8x0uv/xyPvOZz+zxNV/ykpdw4403HtgbVZ4TKkAUZQ7ZkwVn4uR+rXjMMdbgbFbBKIvASLMzmnGZKPEM/VHoLoupLW6yuNqkmutR8GICmzCRa7G6sI2VuR0EJqZgIkZsn8QZptKQBV6evLGckN/MlniEB8Jx7sWwwGtylBeSApCQpF0ilzKbSs9/1fbYHtfYktSJAp9CsIOAlKVei6o1VEyOlJTIpfRcShPoOY+qiVnm5wHYHDeo2h4vL24kqd7NveMLufWY1axrT/B4Y4wd01Xivodp+RS2+ZS2OHINh9/LKiQmmzlRIXLIoecJZT5InCFxc2ubeyD7+8U2q6uuuupZt7nhhhv42te+xgknnMANN9ywW34bwIIFC3jd6163232e57Fu3bphNtuuXHLJJTz++OP80R/9EV/+8pf5i7/4iz22YinPHypAFGUOUQvOeWSXCsdAXIQ1j+YKS2tVTGlBm5yf0OnlSGIPP4gpFUJOGp3kVeMP84rSoxzlJQTGErmUKVEPlLKSQYpUJHrOMpUWeCIu0nMBk3GFu9vLuWPHcrZNV4l6PkEhplLukQ9i8l5C4CVEiUcnCobH2OwUiCOPfCFi5dgUp408yTH57SwNpjnan2axByUbELiEhIi+gwQZ+gyMx5jnEZiQsrEE1vLa4gyvLd5OfzxmSwJPxKNsiMa5r72Ue6aWsnmqRjRTIL/Vp7zZUZhKCTopJlYhcqih5wlF2Z3Pfe5zgIiXXxQfe8MYs0fxMeB1r3sdf/RHf8T09DTbt29n0SJ1ojuUUAGiKHOIWnDOA9bsnOHwIC5Y4oKhN2ZpHpOydM1TfGj5bfxScS0lE/NoNMFUUmGxP8tir8GEF1E2lp5LeTgqMZlUANgSjzAdl9kRVXiqVyfNrvR14hwphk2NGtPTFVzbp7TRp/pEytLJBBulOOOTBjWSoiXyDZET56p8uvOw80CSN4TlIhtG6jy8YCVJNYVKxKKFsywpNyh4Mb5NyNuEst9naX6akwqbGLdtFnkJY55H6hwJjsDI8UXOMe5Bzkwyk5Q4vrSFl1cfY2xVi6mkwvdnTuJH61fTeKJMaZNHaXtKrpFio/TpLlwqSp4X9DyhzAfJPNjwJgfBhrfb7fL9738fYwxvfOMbufHGG7nyyitZv349IyMjvOIVr+Cyyy6jWq3u1357vd7w/3sTNRs2bOC9730vGzdupFQqcfLJJ/O2t72N00477bm8JWUfUAGiKHOIWnDOIZnwcL4hKlmikiWsGXoTENVTCstn+cCLbuX86r0s9nb+2V3gbScwkwR4gKHlDOtin592juObW17Mpuk6gZ8QJ5bOjhLFJwMK2504T2WuVM5CruE4ejoBl5KfauJtm4F+KIGnYQS5AKplTBTv/BogTiBJIAhI6xVcMZA8kEQSsZNyjt6Ccbb5E+CySk7ZEFUN3YWOcGlIud5j5dgUZ44+waJglgV+k6X+NNakbI4Xid0mhvu6yzixuJlXl56kbnNErsnLixt5dKLOzScex7efPJmtj41T2uwTNMDry9yI30vxewPLX6dC5CCj5wlF2cndd99NHMcsXbqUP//zP+dTn/rUbo9fe+21fPrTn+b666/fL2Fw9dVXA3DyySdTq9X2+JzHH3+cxx9/fPj1t7/9bT71qU/xH/7Df+CKK67A87z9f0PKPqECRFHmELXgnAOyVivJ2rD0Ri3tpYbeURETS2d55eLHKXoRS3IzvKFyP0f7OcBje9JnKvWpmphFnodnDFuTPjd2VvLN7adxz5NLSbYUyU1bXAuKTUe94cjPRgSzIX6jh+n0cIFPMlbGtkJsq0NaL2Nn27h2B1MsYtIUF0a4ThcTxzjrYapl4okqJkmxnVBEiDHY2RZuS1cEiPXAGvzUUXko2bno932oV3DlAi7nk+Y8knyB6fEVXLfkGLoLHNHykIULZ8l5CWHiEcYelXzISyc2Mu615GPDEhgomYTjglmOG7mNV1Ue4N6Vy7mvvYyHGwvZ1qww1SjiPZWnuM1QmHTkZ1P8bqpC5CCi5wllPkidJZ3jHJA0ywFpNBq73Z/P58nn83PyGk899RQA27Zt41Of+hQXXnghn/70pznmmGO4++67+dCHPsQdd9zBRRddxP3330+lUnnWfd533318/vOfB+C//Jf/8rTHi8Uil156Ke985zs54YQTmJiYYN26dfyf//N/uOKKK/hf/+t/USgU9jq8rjx3VIAoyj6yr7aZarF7AOzqZuUZkoKlO2ppLzOEx3Y5ZcVmzhh9gpOLT3JKbgt5A30HgWEoPNZHC+mkeUq2z3Z/lqqJeDRayL9sewl3PnI0wbaA4qwhP+0o7UgpbunhNfpgwQUeptMj3TGFMQZvtglxjEsSbBTjej1cr4/xfVy9CrUyttODJMXVysS1AqQOE4nwcMWcvC9jMJ6FJJX3aC2EEelkExfH4HmYXA7re9BsQ6eLlyR4xlBYME51ooazhv6CAr3RCeIYLFBMHGHO8P+OXcINa07kwmPv462jt3KU16eZWvrOZ5EXscDr8tLien6puI7JsRIzSZl2muPJcJw7Zpdz5xPLyT9UpLrBUphOsGGq8yIHiX09T6hdr7KvzGcL1vLly3e7/yMf+Qgf/ehH5+Q12u02AFEUsWrVKq655hqCQCrKZ555Jtdffz2rV69mw4YN/N3f/R2/+7u/+4z7m5mZ4eKLLyYMQ97whjfwrne962nPOfvsszn77LN3u++EE07gf/7P/8nKlSv5/d//fT73uc/xH/7Df+CYY46Zk/ep7I4KEEXZB9Q2cx75BTer7rils9RhV7U4Z8XjvGLkEU7Lb2TCiygYQ9Xm8fHoupCHI8u3G6fx7Y0ns+OpOljHyESL48a3U/Ai7tq6lM6jI1S2GmwMXs+RazpyszH+tgZMz4L1sIU8rtOBKIJcbrgAd1GMm5nFBD62WsFVy7hiDmeMOKpEMWk+kK+dA2MgirHNEAKftFYirRUx3QjblD+y5AJMLgfWYsplTC6Qikq7TdrrA2A8D9ds4fVDXLtD6VGPUi6AOMYUi5AkuChi7I4xOqtG+LeTX8Z1p57Kacuf5JTaZk4uPknVbgbkqmhiHCv9Waw/C0C1/ARba3fxs4lj+H8r1/DzR1dSeTBPdUNKrpno4Pohgp53lEOFjRs37tbGNFfVD2C3jI7f+Z3fGYqPAYsXL+btb387X/7yl7nhhhueUYD0+33e9KY38cgjj7BmzRr+4R/+Yb+P58Mf/jCf+cxnePLJJ/nmN7/J7/3e7+33PpRnRwWIouwDaps5D2QzHmnO0hv1aB9l6CxLqC6b5nVL1/Fro3fw0vwMgbGkzmGNh4fkcgD8rLeAz6x7PVvuXEz9YVixIyENLN3xUR4cGQMDfgsmGik2ciR5SRHPNxJyk11Mt49LHZDgOh1cGEmFYnh8HqZUwhTyEMcAmDjBNDqQptJWZQxeGGFLBdJSDhOnmGYb1+th6jWpiDiHCSNcpyfVEM/DOYfxfUypgMsF0O/jkgRjDS5JcAm4dgfX7YkocTLdbvxArm+mjrTTwXR7lHbMsHzTAmY21nhw5Yu4fcUqJpbN8LLFj/P6kXs5LpgEoG4NKdBOHR6GozzHhZW1nFt6jO+OHc+VS85mywMLqT4eUN6aErQSTILmijyP6HlH2R/EyW9ubXgHvhq1Wm2vcxTPlV2drE444YQ9PufEE08EYP369XvdTxzHvO1tb+Pf//3fWblyJd/5znee0SVrb3iex1lnncWTTz7JY489tt/bK/uGChBF2QfUNnMO2XXGo2xpHeXROD5hxXFbefmCdby4tJFT85tY7AEYmmlCChQwNFPHj7uruLW5iv/38ImMfb/A6jtnMe0erpQHY6g+FGM64n6SLKgTVXOkOUtctNjYkd/ew26dEmEwWsflA0hSbKeH63Zx3R6u35fWqLERXKWEmWmSTs9g2j4Us6t1YSTCwFhMnGDDCNPu4jpdGUj3PEyrg+mHMudRKkCc4NptGVL3fQgjTJLikhTjeeB58lg2xG7yOSyIOPE8ET4Avo8tlYafp2n3qD4eUNriEz3g0V44zneWTvDDFx/Hr6+6m9NLjzPidaiZPoFJ6SRQtwlV65H34KLKwxx33Ba+teAl/L/lJ9JeW6G0JSA/7ci1U7ye2+mipULkoKHnHeWFwK6Bg3urrAzuT5Jkj48757j00kv5xje+wZIlS/je977HUUcddcDHNKjCxNnFJ2XuUQGiKPuA2mbOAQNXq8Fw+Yils8QQntDlrSfdya/V78DDMZOW6DuPqTRiMs2zMRqnmRZoJkXuaK7gx2uPpXBvkWX3xZQf2YZptGSxnqQQxbhmk6TVBs/D6/WxtQppuYBfy2GiFH9Hk7TRlAV9vUo8UsKGMTbwpUIRxbgo+6OTpDKY3uthcgFmpI7L58T5ynRxUYSpZdaQ07Py0xH4YLJKirVQyOOKeZJ6Ea/Zh35/OBPi2h1cLK9nPIvJ5TC5QOZJqhVcMY9xTsy5cjlcmsq/+QATJ7iZWVyrjTUG3xiCOKEAlGslwvEizXV1rjr2lVx59NkUSiELay2Oq29nUb7BKysPcVJumr6T6sgpuQYjYz/l5dVHuXHlidyyZQXbt9bIbQ0oPWUobk/JtbQ962Ci5x1lf0ixpHM8AzLX+9sTy5YtY/ny5WzcuJF169bt8TmD+5cuXbrHxz/84Q/zD//wD4yPj/Pd736X1atXP6djuv/++4fHpswPKkAUZR9Q28zniDWkviGqeHTHDe2lEB/dY9VROzh7fD2vqj7AKr9DyXpMJV22p3keiia4tb2ab29Yw/SGUYqbPMqbHSs2R+Smm9iZtoiDsTppPsA2O9BskrbaUjEwVioLzTZes41tlcD3pHIBUCzg8r5Y76ZIC5UxmFYbE9rhnAWFHKZQgFxAMlHDznag25MKRrVMtKCKDRNso4kLIxEShQLJaJmoXsA4h+0nOM/iagX8sI7ZMQ2eFaGSJJhcgK1VwfdxrTYERobUZ/rSGpammCCAelWqJv1IKknGYooF8H1Msz1sCzO+h63kqK/rUV/rSEo+zhQIa2VuXn0UvVO6RCd55Gr3ULJ9AtPHAmM2ZFFhE0v9ac6pPUr72Dz3tZfy/SdeROehGuWNPsXJlKC1y7JEhci8oecd5YXCW9/6Vj772c/y1a9+lQ984AO7Pdbr9fj6178OwKtf/eqnbfsnf/InfP7zn6darXLDDTewZs2a53Qs3/nOd7jvvvsAeO1rX/uc9qXsHRUgirIPqG3mATIYMC8YumMesy+C8onTnLvkCRbnGywMGhyX28LKbDg6cimege1JlX+bPpV/fWAN9VsLLNsUU9jeIdg8jZuekX37viy8Oz28bh+yeQnj+5h8XlqsfE9apqIYZppZdSHFVMrEq5cQVQPyU3287TPS9pQLIBvyxlhZ9Ccp5AJcIQdxissFuAUjuMCDFLxGHxNGMvMBON/DBT4mTslvbUE/xEQxLvAh8OX/SSICBBk4J5/HlbOgrBa4bg/SVKojqcNYA7Uqab0kA+3TDVxHRJApiQOXiyKpmpQKON9iwwSv1cdMzeLiGBMEFEeqFHdUmdle4OrZs9h02givG7uPLV6Hmu1xtN+gbCzHBV1G7JM00xynF9bz0soTfHvhi7l74zI6jxWpPGEpzKT4PU1an0/0vKPsD4mzJHNswzvX+9sbf/iHf8gXvvAFbrrpJv70T/+UP/7jP8ZaS7fb5bd/+7d56qmnGB0dfZo4+exnP8snP/lJisUi3/72tznjjDP26fXe/va384EPfIBzzz1XDEWQNq5/+Zd/4bLLLgMkSf0XnbKUucM45/SvxiFCo9GgXq9zzqs+gu8Xnn0DZc5Qq8t5wBrSwNAd82ktN3SO63Pmcet57fiDrAy2M+J18JAB27xJ8IxjfTTCv86eynfXH0/8YI2Jexy1B2Ywvb5c2e/2SWfFj97Wa7hyEdMPce2uWOWGITafh3we0kQGyX0Pl6a4VhtTLIio8H2iFRM4a8htmibdul0ESz4voqnXxxTymFJJ5i4GfcfGSOWkkMP5FlKwM02pltQq0pqViBUvxkC3hxtY8GYiACBtSnaHyeWGrliukgmQHTOkM7O4ONr5WRqLNzYCiyZwgYedbpJunwTPk8oJSFtZqQjjI1IR6vTlc+uHcgwjVXHwCjziap7+aEBjhUdrZUpajRlZ0OJlR63n9Mp6ziyuZ8zGw/YsgCdjn4fCxfyocTw/2XQM7XV1Kk9YyltTco0EG2uOyPOFnr+ef+K4x00//Bizs7PzNqy9NwZrh7++/WyKlbm9rtxtxXz49Fv2633ddNNNXHTRRcOvW60W/X6fUqm0WyL5nXfeuZu977e+9S3e8pa3EIYhixYtYsWKFTzyyCPMzs5SKpW47rrreN3rXjd8/ubNm1m2bBnOORYuXMhxxx2312P653/+ZxYvXjz8emRkhNnZWcrlMsceeyz5fJ7HH3+c7du3A2L/+6//+q9MTEzs03tW9h+tgCgveNTqco7JZj2SgqWz0GPqZMcJL36CNy66lzX5TViTkiNhudenYCwbE8stvZXcNHscP9mwCu6vMvZASmVDG3/LDOnkNA5kce37mFIRY61UK5yT0L80kfapYgFTkdkJnMP0QmlxMgYKecntcCHGOfxtDalGzMwO3a9cvy/zGLlAggOdE3HR6ZJ2e2LHCyI08gHpaAWXlKQlyjlcs43rdIbCYrAgN0ZaZ1wUyYxJNvdhMzcsfI+0INkhnu9hCnlsvooJAlycYKplmfuYbcl78axUO1qZ41YuJxklzRYG8Mql4XyJiCErxwyYniHXCcmv7VK72ydaMkJYD2gtGeWHy8f4t4Uv5kXHb+bio+7ghPxmqrbNuC0ymoM1uR2cX97MwxM/5uvLz+abD7+Y8OESlQ2G0o4Er58NyasQOWjo+UsZkGJImWsXrP3fXxRFTE5OPu3+TqdDp9MZfv2LA+UXXnght912G5/85Ce58cYbueuuu1iwYAEXXXQRf/zHf/w0h6wwDBlcQ9+2bRvbtm3b6zH1er3dvv7Upz7FjTfeyN13382GDRtoNpuMjIzwmte8hre//e285z3veZodsDK3qABRXvCo1eUcks169Ec8missnRN7XHzKnbxj9GcEJiXJ/pjJsLnlgXAx3546lZvWH4P3UIWxB1Kqj87izbazhb9UNYwxuGaC8zyZxwg8mcPo9XEulQVv4GMqZVw+J7MegDNGXKasEbEx2yBt9bClksxOOCeixpe2p7TbxXgeJpBTo+uHkCbSwuRl8xae7BvPI8l7OK+I7fqZ5a4MiZuyOFS5blcEh+dJyxip/MFMHTYnf9xcuy37rpUkxDBNRUwVCjKEHsXEE1Vc4OHvmMF1OtjRERirY6plERaeB9UyttsXS+Gp6aGjlotiEUe9HrZcgiCQQf2ufA5BkhBsMhSfLDH6WJGo7LP58RX82UmLeNGKrfz2iht5bXEHeRPQcSGbY0fZxLxr7GYWv3iWGxauYd1jixm516eyOcHviJ2wipCDg56/lAGHSgvWueeey4E215xyyil87Wtf26fnrly58oBf50Mf+hAf+tCHDmhbZW5QAaK84FGryzlgl0yP9kKPmRMdq1+ygXcvu5kzCxtInGFzUiVxlo7L82h/EXfOruBnjx1D5Z4Ci9YllJ5q4W+ZERvcehXygcxWGEkQH7RHAbKwTlOxwQ1y8q/n4Qp5TK+Pm+5JfgdI69MgJBBkXiKOZQYjl7lJ9XryGn6ASxKpdmTD3y5JMZm4MUEgzwWMZ/EbPdJSjrhWwMQpwWxeQgULObHhBZwNd7ZgFYuYYhE325CKThY46Dpd7GQDAh+XOskC2SFXEB3g90OZQ+n3d1ZrAo+0WsD2Y0yUkBYDTDGz7W21h2GHdLoioPI5aR/zLHR9yRJpNqHTwXgetlcliFO8RsCiTp7qxhwbj1vBx864gFtXPMDqwjbKts+WuM6Y1+IVxfW8p34PF1Xv4bpFp/GF8i8T3V+kvMmSbyR4fYdJtS1rvtHzl6IohyMqQJQXPGp1+RzJBs3joqW92DJ9asJrX3I/713wY472O3Scoe88CibiJ53j+c7WE1m3dhH1+wKWbYgpbGsTPDkp1Yk4a39Ky7K4tnWZY0gSGB8hmahK9aATYdtdsBYXZwPjvi/Vhl5fsjaiEFOtgrWkjaYMn3vezkH0bl8ERrsDgY8tl2TAvN0ZBgViDfT60vaVz+M6XVy3K4t7RAQkBZ9wRE6l/mwFMzULvVAEjmcxnpVskMDHlQpyf6cj4qNchGJeQhHbHRFE1TLGk2N2UYyLI9z2HZh8XoRQ1uVkogS/1ZMBe8/iZe1mkuYeZJ+NtHuRJFIRSVNMmkrVJxeI0DIOTCqtXM0AmxTIz7bFfndLlf79dW5YdA6NVVA8dpaXLH6SV48+hGdg1BYYt4Z31O9k9Iw21xz1Uh559Cgq63yKWx35RorfTVWIzCN6/lIGJFiSObbNnev9KcoAFSDKCx61ujxABrkevqGXtVz11nS5ZM2dvHv0Zo4NfCDPVNJnBsstnWP52/tfRuHnFY5+MKK0dpu0RfkeZAtlF4ZgDDaKsb1YFsy1Ci6fIxkrkxR9TJTizXRwrY4MmkexHAtIxkactSSlTuYxArG4df1+Fh7oMLlA2pv6kQysT4zIrEWzDdUqJo5FDPiS6WHyecjnpKIRx8NKjO3FBInD9gNczuKshWpZKg9pKu8vjmWhnwSy+A98sJ7sJ02HLV0uDKHbBcCUS5hqGdvpkU5OkfZ6ciyVsrSjFfMyE9LKBFE+LwKn04MolPeUVXyMZ7M2M1+CEMNIPqNd+q9NUeZriCJMS8QISUJ+pkm+WKC4ZIT8TIHOkyP8bEmdO49fxsyLfsqFlftY4uVY4OW5sPwIC1c0uGn0OO4/fgmPPLWQ4JEStbWWwkyCDTXIcD7Q85eiKIcjKkCUFzxqdXkAZOIjLnm0lnjMnBJzyknrefXEQ/xq+UFeFOQIjMds2uWOcIIvbvoV7rl3JaP3WMYe7hJsmpEBcc9i0lTaqZDEb/p93PQsdHqYfE7amZDFfupbvG6EabZJm02ZtygVIZCqhmu2wBpspSwVhm4XigWio0YB8Ge62MkZudrfGgxpW1zOJ15YwURVvE6E8wy2G0klo1ISJ6l2RwICS2LT65otqc5USvj9LJuj25O5kiAA35N2siyXhNiIwAGoV+T5bREcLhYx4JzD9PsiGKyVdi7nZCDe80R8JKnMtaSpvOd+KPMimSNY2uyLKCuICDHlslREen3coJoEMujueTJ43+/L3EapQDpSwfRKkibvezjfw5/pMtIOqa316I8XaKyv81ebXs8dp6/g1yfuYFWwg6M8w9n5LZyU20o0Zrl/6WKuPfp0blm6mtp9AdUnE4KWzofMNXr+UgakzpC6OR5Cn+P9KcoAFSCKgvwR14HNfSRruYrKluYKj+ZLerz31J/xlvrtWBxlm9J3EdNpjxvaR/OXD/0q8S2jHPVIQnlTG29HUxbfuUBaprodcadKEhmWjmOSVhsPpOqQOqlseBZT2sWVxNosdTz7A2kM5PPDK/4gV/ad72F7kdjP1gp4wTh2ti2Bfln1wTQ6mHIOF1iIpUUpLedlDiVNMY0W6dSMLNrHRyGKpTLh3PA4Xacnx2nNTt+Yfp80jIaLbtdsYZJEjisM5flGjteO1AHEcWt6Rj4PwPg+tlaTqk2/j+uKMCMtyOB9qSjzIb6V92OtWAhXyuIQ5ntS7Qkjec1Be1mW1u5SB2GIKRZIq2WisSJ+w+L1pEXNdHoicqIQz/MoTY9Q2F6i9kSR2546mZ+fdjQXrL6Pd4z+jKP9hKq15E3A0f5WTln6ba6unMHf534JkxaobXB4vVRFyByj5y9FUQ43VIAoRzzqkT+HDMRHxdJY4dF+SZf3nXoz76jfxpjnMZum9Jzh4cjyg/Ya/s89r6B+Y5FF93ewYYLpR9KW1JMr7i4MZXGbz0k1w/Okncj3JUTQOakqeB7ECbYbi0go5DHdAIwhbbWldahYlIW5kRwPXCpzE50edse0fD02SlIvk4xURAjEKabdxU3PEHR74hA1OLbF48TVPMGWWZkhcanMc/geJkkhCKQlK5K2LqwZtlfh+7sNsNssrRyAMMrS2lNspSyOWXGMq1dIy3m8ySbMNjAgjl+DlivnoCPzJ66QA9/KTEkuELevjmSl2HoNVykRj1fwJlsSwMigdcxmQ/2Dz74PIJ9TQVzBgukedrJBOjUtz/estGjlypI1sn0S22hR3hKwYtsIU5tqXHPGWTx8yiLesOBefqm4jmV+j45z5Ay8tnof0yeX+EZ8GpCj+qQ6ZT0f6HnwyCedhxmQVGdAlHlCBYhyRKMe+XPILha7jaMtvZO6nHvco5xVWsuItQR4JC7h570V/NOWM7jn3pUs/rFh5J4dmJkm5HOklZI4VcUJJKmkltdrYptrrCzi61VZyLe7uNnm0OGKKMILI9JqWRb8qds5y+B5sqiOY0kuB/D94QJbwgVj3Nbt2HZH5jQCH9Pqkk5Ny3bdLE8jn4MwxTY6+FmgoKmUpapQkNRxCS3MSetTSUJDTbsrLVcuGs5QmFyAqdUwpQJpvSyHMtWUNPckHQ6quyw/Iy4HOFPFRxLVk3IB2+zIkHokwYSmUhY74m4oMyTOZQGIqRyLESFhuxGmF5K221JpCXxpTctmPVzUGqasm8CX452cgSiSRHnPE3GUC0gmarjAw3tcKj9kLlseMNEJqT9eYeNDq/iLs47irafcwZvrt5NgSLCM2B6/OXYzldP7XFU8nfT2ErUnIGhlCQMqQuYdPQ8qinKooQJEOaJRj/w5Iks17yzwmT4Rlr10E7+66CHqfocUCROcSXN8Y/qXuPbOlzL284DV93fJrd0iFYpsoNvOSgI4vlQ0XK1MWilgO6FURsJIZg8CXyoNo3URGGEkLVfGYGeauG5XruA7hy0WZM7BWhk6z+dEfGSD2y5JIeyLc1WSiB1ukuI8J45RgC2VZH/drlRPAJsk2OwY3aIxsb3N+fiNnrRZZUGIrpiDxMFsc6f17mAQfsG4iKlOZt0by8yGi2Nwks7uOtngeb2CP9vH2zZNOjOLCXy8rAICyNxJP5vh6HYlVb2Ql9mOdgeKBQgqIkiaHWm5yt4LuQAWjpMUA2wnhO1izQvSgpV2e1hjh21xJAmUSjJX0guxnZC0nMcEWWp7Jq4IfEynR+6RJosa4+QaNa7unol3Vsob63ex0m8RAD0Xc8nIzxl7cZu/zb+M6Vyd+jojCeqgImSe0fPgC4PUWdI5zgGZ6/0pygAVIMoRjXrkP0d2sdjtLLBMn5zymrPv47IFP+Iov8tUErA2WsCVUy/jhidOJL5rhCUPpRS3h3j9LKsjina2H/meLHDjFFeR4D073cKkDlevADKQ7Up5mT9o9WQAvNeTRepgZqMgi+G02cqqH1aqIcaQToyCbzFP9nC9Hi5Jpa0q8KXVqFaVFiznMG1ftrVmmK+BS3dWY5zDdHoYIC0XZb4kTjC9EFcqkIyVRTxtn5LsjWzwmzCVRfxMM0sxz0m7V6cnmRy+5H2kgxYoP8A023jtLsnUNC4M8apVKORl244Ms5OmO/NDej0Iw2EFyASBfN5ZJSRcUsOf7WOf3CZuYWGEjWIZvgephmSZKK7XFzctazDVirh15XO4TJCYTg+vH+GiCFOtYAt5XOCL61cqNrt283YmZtvkmov4evflrD9znHcsupkTgh3UrWGBgfMr9xG9yOPrwUuZKo4x+pBHfibBxqgImUf0PPjCQKqOczs0Ptf7U5QBKkCUIxr1yH8OZFWP7phPY7UhflGHNxz3IL+94EaO8T0iPB4KK3z6sdcxfccCRh9y1Na18dohgLQIJYkMV+dzUsUYJJTHMa6Yw/kWG0bQDzFJMmyrMqFUJly7u1s7E4O5gV2CBV0YQdQYXtG3M01pawqjzDnKkSYJLknw8iJsbKsrVZB+KIPZSYLJ57FLFuNKBVnwd8XilkYsV/wLefxcDpem2U9TAZM4bKNDMiVD49ZaGVIfH5WWrHYH12hKhsggk8NJHgli7iUzIqMjMuvRasn7MzJg74Kdws0UZI7EjdbkOf2+DJNXK9LOFcfiLGYMzrP4s32ZcykV5LOPYqk6dbvDAXRpK6vhZho7U9tNX8RMJjBMIlkpplSEelW+N/1Q/nUONz5CtKCGv6OJm5qhdkeCjZdwe/sEnjxjhN86+sf8amk9BQPjnuPNtbs45oRtfLH8Sp7ILWPsXo/iZKLtWPOIngcVRTnUUAGiHNGoR/6B4TwjqeaLPabXONa85HF+c/EtnJrfxLjn2Jok/L/28Vxx/6spfbfCMbc38LbNyoK0kMNEMemOKVwcY0fqmDghbbXFttaT0EDnHCbO5jWShHRmVkRDxrBiUSjsPDC7y9U457DVSlbh6JFmg+dueyKzJQOHqCTBhiFpGEkLU9ti+v5QfBhjcFE8bJ/C93CVotgDt9tyv+fhen3S2QZ4HrZawXT7eF2xtjW5APpZ1cNlizzPygwFyGt1OlJRKZdFFHR6uLiByedJJ+oya1LM442luNmGtKPNNGUYP5+DegUCn6RexHZCbBDgykVcpSj7DUWAEScyeL99MrMYDjJhJ+1nLkkhzdqsrBER4/tZ9UZCE53pYUHa4tpiV7zT2SuU1q7BfrMBfJfPSVUljCg/uJ0l6QRb+0v4gnslK46b4iX5NiXjMeoHHOVtZXzlv/IXnM+GzgpsDPlZFSHzhZ4HXxhoC5ZyOKECRDmiUY/8/STL90iKluZSn5kXR7z2tAe4ePw2TspNUjCGdVGBf5o+k2t/fgZLv2eo3b0Vtu4gTRJsrSr78TwJ/xvkW3S6OysNJQm9s82uLIKTFIoFWVB3OpmDVWYVmwt2tjX1QwkL9OzwNcjmEGxTBIKLs8H2UklEQT4n+4pjTFPmT4zvy+xEPxSRMlIfJqKnk1OYMBThEPji/gQ727Sck/dYKmYWwtksRqU8DBZMt09KxcT3sWOjpHVpabKzYiHsykWcyRLWPXHMMqE4VLlSnriUIwDc1u0yPJ6v4nwPV8iT1PK4wGK7ZtiOBpCUc7iRArYbS0hjGIkDl8dwhibt93FRLO5TJkto7/bk87ZWPi9jMsGVJcynPcgF2LocA7NNyQwpFmU+pNuH2RZBs7MzANLzMN0+xY1NFrkq25LF/FnwBn57xY2ckd/CIi+gYgucnW/z7mU388lT68zGdWrrMxESo4GFc4yeBxVFOdRQAaIc8ahH/j6ya77Hco/W6V1+4+TbeWP9LiLn80A4TjvN869TL+ZHPzqFo38YU35wC67ZyoaSc7Kwz3DV8s407jDC2sxRKp+XSkm7I2F7lRKunDk3ZeLCFIvDSgr9UGYhsgWva7dlcWoN9DxMqSQiw7Ngc1kWhsx0OGsAgykU5Ip+Pi+iJRNGplgkHa/hcj7e1hmxv/X9nVUMMpvdwexJsUC6aIyklMNv9LLXtJh+OAwJJI5xqQzHu0qRpJrHJCke4Hx5f3aykeV55DG+h5uahTjG5nKYauaWVc1mYopyzMY5aW8bWO7GMSbxcXGKDROIUkwYY+IEB5nDWFVmSNpdbFuCGV2ctZQF/rASJS/oSbWFzP438KV1axAGGYuociCfT7M9nB/ZOYfiizNYpYRJHMXNbRYlJTZHK/hvZ72J3zrhp7y5eg9j2ee5JreZN6++h295J7NjZITK+oDy1oSgrQ5Zc42eB498EuZ+ZiOZ070pyk5UgCiHPepvPzc4awirlsYxHv2XtvjAmpt5c+0uCsbxs95Sbpw9kZ9sOob+vSMsviOluKm5c3DbWkylTForYWfbuJlZuT+7wk8QSDBeP9wpIPJ5MNmQ96D1Kk5kP/WytGf1s1mQbg/iWEL9jNkZQBjHpNlrmUJexEMYSSJ6LoAwL+5RxsLYCM6zmFY3a4eS9i/T6WNbWWJ5Fg44yBPB8zCFvIihbh83NYPZtI2gUBAL3cH7T1Ox8EXmW4wxmNER+ouqOGvI7ZDgQ9uMpFKQhSgOFu+mXIJiUURFsy1CrlgQh6wd09IqFQQirpJEwgrjWBykykVMlGCnmiJ+qmXconFpd0uywfdeD1MqYkpFXLst7V3ZMLvp9yXAMZcbvhfXD0X4pZJMT9NCmpCGEbZcGlr5DnJK0tmmiMBiAVctk9ZLJOWAuOgTlS35aUfj0SpXl15KaWWfVbltLPRaBCbllyuP8KITnuJnS4/lO4+eQHRPidr6zCEr6ypTITL/6HlUUZSDiQoQ5bBG/e3ngKztKi6K+Oid1uH1qx/mZeVHGbGwJfF5pLeEHzx+HLlbqqy4pUNu4+SwijAkTUU0xIm0/+QCqWRUS6SBJ4+Vi5hOXvI94hhyxaz9qY+pVSUrwxhJ9e5FMhg9GEh3TsRHsSBCI5HXIepjyiVMqSRtWGEogqdcltmSfijtRb4nosL3xEp2YF/b7ZIm6dCSlySV14xjcX3yytlguAiStNnCdLqYYkFCBwfioF4Tp6o4llyNOCG3rSWf02xTHKcyhy3jI8cfRjgbiyPX4D3FcebOJYGKaZbYbitlzEgN5+VF6DRbuH4o1saeuFGRtVGZJJH5jSyd3Q2sjLOZGlMU8UGS4Aaird/PjtENxQog2yVZVcXEEtZYK+OMETet2Ram1Qak6pKWC3SXlGgd5dEbN0RVR1xyuEpMJwy4YfvJLCo2WF6Y5uTik5yU28qpuUkW+7NEqz1+ml/JZLVG7TGf4lSiyekHAT2PHhnoDIhyOKECRDmsUX/758guMx+tozzaJ/V5w3EP8uLKRgomYiaF77VO4st3vZz6LQUm7u4QPLiBpNHClosyUJ2TFHOMwUzNSmtVPoepVYcWrmIn6+NyPjaW4WcGC+7MKhffI64ViMs+JnHkAK8ZkDRbUlGo12RRPNjeGMgyNEiSzLWqJ1fpydyxnNjWmiCQoe/AlyqIc7JozwUYa7NZDLEIdu22CJMkkcV4GEnFJU2zOQ+HKQbS+uV7kM2s4NlMFCUQGdzMLGa2kVUXAnHz8rO2p15P5jEKeWndCsNsgW9ESMDQIheQas2gYpOkMkMzNrrzmFttqUAEgTyeiSdsFiYYRbhOV46jXscVgmEKPFGUfZ6+iMJIHL/SahGTOBFs3T6GGEbruHxOvq9pKp+Lc1LRyapdac6jX7c0j4ZoSZ9cKaKci/FtirUpm1s1dnTLbMyP0hsNOD7Yxpif46TcNO+YuJnTq+u5buQlPFpbSv1hn8rmBL+tyenziZ5HFUU52KgAUQ5r1N/+uTEcOF/mM3tmj7e/+DbOq9+DR0rkPH7eW8FVT5zO2L/nWfizSczULEmrndnSFnAjVRlwrhTBM9j1T4nzVS0bWm40paKQz5GWcrJ4jxNxnQIcyELck+pEUvAIa1mlwhoK3Ro2kmqE8TMR0O3uPP5BCvoutrI2qyaYXCCtRlm7E90eph9KlSCb8zClImk5u9LvGRkGj2OpCDgnr5emO2dR0nQYfOjyASZ1OzNOQARNHA/FD/k81s9ySqJYxELWemVyuaGTlCkWhjMkJvClXS1JMWEoVZLUSbvWTENatmpV0tEKphdBJ0tgz1q/hm1hIMdZLYuI2D6N8SxpISAp5/A6EYZsLsb3JD9kILw6PewwF8VJS1YUirCMk51VqUy4iVtZXqpdeZ/UN8SVlFKtR85PMMZhjPyeJqmhm/qESZk7WE7V63F+9V6OD/Is8PqclHuE4/Jb+L/ll/GDwolAQHWjk0rIvPwWKHoePTJInCWZ44rFXO9PUQaoAFEOa9Tf/sBxniEuebSWesy8OOKSF9/Be8duZoE1TKUpj0bjfGvHqczcM8HKBzuwaQtpJhxM4IuoyPlY50jKAUnJpzBT21lNSMWRikByKUw/wYYxZItl1+1JFaVUyobGs+WlMTgLSd6SVPL4jYKIgiTBNVuk3d7OYzBGFu+FAuQCnO9hGy3I50gW1PG2zkg6urW4KJLB73JZLG37oVQFsv04fBEVY3VMs4ObbWSvE8ggN2B6/jD4cNDiZDwLQSYkyiU5lswRypUKOGPELSoXiLAZhCKWJYjR9frD9itcunMGphuKmBgEI8Jw2NsV83IMzba8p0ACFaUFTVq2jGeHVRMXeFhPLHbtVBPTK0hOSa8nx5uJjzRrpaLdzt6DFQGSzaq4ZEbEXSEvQZLZ48Mgx9RhowS/5zCJwRh2Ex+7EieWJ2frXNU4nW3Lqrxr7GaOCeR4l/sN3jrxc/KnxfybdzKpl6O2MauEqEPWnKPn0SMDh2GuZbpT2a/MEypAlMMa9bc/QKwhKVoaKzwap/V53ZoHeEnpCRJnaLuU9XGdR/uLuWvTUibudgSbp3HGymI/a0NyvT7elCzSA8DriiWuKZdEfETxcIHNpg42n5eWrzCSNqNBS1HmvEQ/wu8mRLFPEogIMWl29X2wGM6Eii1moXzdnizOM4FClq4+zKfYdfGc2c0CmH4k8xh9mbdIR2ticWsNnmfwOr2drVC+R1ovYboBTM3g2l1s6sQeeNAKFsfyWpUSrpoH35IWpN2L1OF185hOXgbMw1BawjJMIT9skQKg5pGWcniJJL/bbF5D7IWL8pk6h+n0pTpTLuHKRWwvxHktESCD52YBkKbblyySJBGDgMkp0jCUeZRubzh7Iq9XgGAwkJ4Mc0Bc6oaVDy8pi9Bstod5Kq7dgUYTv1GmVDyKoJknDD0CL3Mc+wUR4pyh180RzeS5bvolPLF6jHcv/injXoueC6jaLh+Y+HdedPYW/k/1Fcz+rErtCQha6pA11+h5VFGUg40KEOWwRv3tDwBrSPKW1hKP5kt7vPe0n3FB7S6qNiLAMZX63Ntbzr9sOg1zf5Xa2qa4Si2eIB4pEWydlayLqRm5yu55mE4Jb5ByXi7KcPZsS9ymkgRTLGJKYs9KP8RskwXvMK08J1avzoDXSwGLydb/w/mHBKkWGIMZqeMCX9qd2m25but5Eh4YxxBFeFtSOe4kwVmpUthaVSoRvb60HlUruFKBeLRIGlj8ToRtdIdZJC5JcLNNvJ4s4NOeDHS7MNx59T+zDB5YDtuZJgCmVsb5Fud5OGOwnR5pQ9yiGAQflku4aglsWQa4p2dgtoFXzMucRT43dA9LZxuSweH70Mjaz5IEqlURJeWifD86PRFGxSzAcVC1KpdkX3EWLpglzw/DHzPxMRjed50uaTaYjudhfUOatZalnQ4mSSSQcaQmQZOTU7hulyQMyW0qU9yyiJmJAu0xKBYiPJs+TYTEkUdhq09ps8cDa1/EJ35plHetvJWXlx7lKC+kbnMsqt6Hd5Lj87ySmaBK7fHMIQtUhMwReh49MtAWLOVwQgWIctij/vb7gTWkgaG1xGP6JTG/fvJdvKV+O4u8lMg5HojqfL+xhhs2nkjv5+MsubmPt3EbabbwT4o+dryKbXdI22JlaytlTKUkMx9OFqsunyWRT2VJ24Mr8Z0exAmpc9kVdZmrGFQvvHaEDRPiSo40yNywMnvawfFLBoiV2YNiUSogVrI+XDHLIckcmuj1pB2pUpZt4wTXaIqQ8Typ2MQJvmcwUYKZae684p8k2FIJJkblSn9X2rVMLsCO1CXroh9KFaa3sxKTdruyYM+qItZaydJod4afDyAVilwg7Vl9qSAM2qcII0yS4rIkc5Ok8jl5nljpOgfNlvzbbktVKhcMZ2KM72ftZZn7V5xIJSmV2R2WLsJmFr3EsVRUrNgKu35/OFNC6jCBjx0fwxVyeNsnhy1wrt8ntRZTKUEhh2kGw8/eNNuMrA1JgxztFSU6S3qUSv2hCHHOkDqDa/tUNjhq60NqTximZxfw/738V5g9qciv1e6ibmHCK/L6ygM0jy/wNf90pvMjjDwK+ZnMpldFyJyg51FFUQ4mKkCUwwL1qJ8DMvHRWeAz+yLHmSet49X1B6jahGYKP+0dzVeffBmP3r+UkQcty+7p4D+2mWRmVhai26fJh5EMkWeL0EHyNXEiw8nZIt+EkbQfVcs4z5OvG82hq5MLQ4w12GpVWqnabcz2SexMThb44zWpSvgWVyliWl0ZRM/lRHz0Q2h3htax+NlMRJyIS5PvSf5FlIXuxXkRAWE2B+L74k7lWVwYYrdN45wT0ZLPi9BAAvmcc7gkxTmHzQWYsVHSUkFcoAbtV4OhfPyhvW2aDXTj7+KgRSY8ahVcLpD5kH4I2WyLy1y07EBw9Psw3ZB2MZvNYySpzLAsGMMAdnKGtNUW2+NCYafg6HTB9IZtW5DNs1RKJNWChBqCWBZ7InRAnLhcP9xZuVo0QVrIYzs93MDFK47ByGdnpmfle9jry/blEngexfUzjJlRsAHNQp6+n1DMR8MqiANMaMk3UoJmiOlGLGzk2Z5W+HL4cnasqfDB8R9xbOBxlOfx2up9TB9d4gZOZDJfZ+Rhn9KOGBuhImSe0fPv4UGaCfu53qeizAdHTG3t8ccf54tf/CLvf//7OfXUU/F9H2MMn/jEJ/a6zUc/+lFp53iG20MPPbTX7R988EHe8Y53sGTJEgqFAqtXr+Y//+f/zMzMzDy8wxcuA4/6MyYfY0G/wRmTj/G5277IyTPrn+9DO3zYRXxMnuo47ezHeOeim1nlT7E5LvKPs2fwp/eez8YfrmDpjbDo5lmCDTtk05E6dmwEopB042aSJzeL01W5JC07xuA6HdIZseB1zRZupgGzLUw/wvT6uE532LqUdjo7r9QX8piStAolsw2SHTtIJ6ews21sN8b5lrScJaeHofwbx6SNJm62IcIgjmW2JJ9lYPRDzNQs6Y4pea04xsUJzvckD8TzJARx4RjpojGolmURbq3MY0yMYGrVnWLH8zClglRDgiwV3ILphWLBmySYcln2tXBMEsytlXPI4PWSBONZaW8aqxMvqBLXCrggc/wyRhy8ioWdLVpx1qbW64ljVyZkiMJMaHkk9YK0vGW4Qk6ERNaelfb7pO2O5JmUCrhaBRf4kpzeD8WqN4pE0DmHK+aklSsXSIUqE1kmjHDN9jBEcTCIbowhbbSk/WpQpfL9oQAsbmww8lhMZZ1Hf7pA4gwuW9AYAONwBmwnxE7OEDy+hUU3zbLk2zmu//6ZfHbrr/Jgls9ylNfnNbUHuPS4n3HM2RuZPNXROsonyVucp4uk+ULPv4qizAdHTAXkiiuu4IorrjigbZcvX86KFSv2+FipVNrj/T/84Q954xvfSLfbZcGCBaxZs4aHHnqIv/zLv+S6667jpz/9KYsWqYPIXKAe9c8RayTlvOLRXGlYetIWfmvJjzkjP0XHOf5x5jT+8WcvY+IWj9GH2/g7WnLFvloCUx4uQgkjbDbXYXK5nWnhTr4vZjATYQymXpFKxGxTrGVLBUwQkM42oNuV7asVWaxai128EDM9SzIQFZ0eXjskzXkkxQBbLcmC1blh9oeplDH5vCSrJzLo7DwLzbZY7vo+plTClEuk4yO4go/1PExmV+sAZ60stkGGwz2PeKSE1w2wqVQd0loR63vSbpWk0jKV5YlQKUnLVC6QdrE4FTFTktYwk88NM0QA0pEK4XiJNCefVc45zFQoYYl+Fj7Y7cnszCCJPatMYM1Ol61+iH1yO16pKJ9J5rxl4gRIRHDk89hCXmZeQITQINckK36YYmEoREwvHAo4ggCvUhbRt2M6swveGTA5yHDB94f5HC4MxY0rdSLMjMHMNCk/HIMbpzfhE497+LnBcA9gxY3NdHokO6akWjU9w8hTIxR2LOPH3VPZfm6F31/2XY4NGpyUm2Sx1yC/JOLrccAmu4jU96g8BV43VYeseUDPv4cPCZZkjq8rz/X+FGXAESNAJiYmuOCCCzjrrLM488wz+dKXvsQ111yzT9u+733v46Mf/eg+v1az2eRtb3sb3W6X//gf/yOf+cxnCIKAyclJLrroIm666SYuu+wyvv3tbx/gu1F2RT3qnxvOQFIwtBdbohd1OG38SRIMHed4IBznnx85jaXfM9Tu3Q6T05KuXSmTVEvgW+yMhNyRz8kV/kYe1+lImw4yCwDIYtlYTK1MMl4Fa/F6fYy1JCMVbBhj41jajjJRQBbyFy4sk/M97CDjIwox7S5eKUdYz8HCCl4hh211MWmKcTmxvrWySHedLnR7QzFka1VctSxWubkAV/AxcSqD6xOjuH6ImZzByyx1XWY/6ybyEoTonLQ0xQl2pp0t7EVkuSA7bRpDWi1IW1anhzfZlJDEwJcQxm5PHLSqRdKCiIC4miOsS06GiLU8tlvBxpKKjjUiqrIZFZPNzqT9Pjafx1Qz69teX+yMwwgzUoOJEbHS9T0JF0xSTK1CMlEjKQZ4/QRvsimVk1wgn4s12SB/sjNfpdUWYTVaF3G1bTIzAMjef6EgVaJBS1kuEBEDMpMSRhg/hUJRjqfXx6QpuZkqQbNEGPrkg3hnG5Z1pL7BFXKy32536MiV3zjNiu/UeKy7mo+9psAfrPwuq4NJEgxV2+XksaeonNrnwfoS0jvzVDcmBO1kHn+TXpjo+VdRlPngiBEgl19++W5fX3XVVfP2Wv/7f/9vtm/fzoknnshnP/tZWcQA4+Pj/N//+39ZvXo1119/PXfccQcvfelL5+04XiioR/1zwBqcb+gs8GicGPMbJ97BO0ZvYYGXEjq4u7uCaFOZ4ta+tOZUykNhYaJEPnFrMY0WrtmWAehSAQO42Ya4JA0Wp4MwunwO2+xJRkWvDwvG5PF2V67q5/O4KMK2u7LY7YfknoxgpimL0Hxe9hknMhjuIPUsNrA75yCyliFTyGetUp60iLW74GRxLIngCbTa2CnJr6CQx5WLuFJeBstnZjGeJ1feK2WpSkz38KZauOkZ0ijGFAukSxeSLqpjO6Gkubf7mEYbbxAu2O1mbVQFETx5H1PIYTo9yfMo5QhH8kRlS5Iz0n/kDFHZYidKBNZiW7IPlwuGTlquVh5WngZtZqbbl0pErSrf40gsitNqCSx4vcyhC7CtPraTCUVrwMtO+WEkFSuQtrlscN4UC5hKWYRMt0/qHEQJtliUQEMnVryu288skI0ILWuk4uNZWDhO++g6uZmQYPMUhBFeLybXgE4zICpE5PysXctzhBVDtLBCkCzETDdwzSZps4UFfOc46t8dW3tL+eTr3sDvr/4+Ly08yZmFDbwot5X2WI7vjJzCP5nTMXGe2gaHF6ZaBZlD9Px7+KAzIMrhxBEjQA4m1157LQDvfe97h+JjwIoVK3jta1/LDTfcwD//8z+rAJkD1KP+ALGG1DP0Rjxmj4NzT3uQt4/eyrGBj8XyVNLlsc5CbN/QW5AjyFvyW5AqSK+PiWKSap604OPbLEwvTmSmo5tZtILMRoAMa6cprhDgPA8visVZKU6wzY5UGQYJ40ki8wTG7sygMEbmJwp5aUNqd7CBj1cKMHGKNyUzJW60JkPxPTkeAFMuAkW5st/vS/p6mkr7U99CFIpdri8OUzZJcSCvV8wGypMUun2scyKMfB/Xztq9ehHWOWyjM8wWSTtdbLkklZjMdQpjoVYmqRZktqFWIPUtUS0gKlupfBipShkgDQxRxcP2A2wvxPSlIuTqFdJiQFTPgwO/U8Wb7ogQjCKpLrgsA6RSkqDBMBaRN7AYNiarhiRSvQIRRzk/c+Oy8pzU7RSRQSDVk+mGtGX5vrRfFcRdzMTJ0D546LaVfd6mXpXPsN2ltG6nwxbW4k02qa0v0V0QENZ8cn6MNQ5TSOiNB/RHA7xWAQsYJ/bJrtPFJCn+9CxHdRfzVLqQT776PD58/L/zq6VHGPG7RHTpVR9i7eoJ7pw5Fi/0qDzldDB9DtHz7+FDiiWd45apud6fogxQAYLMc9x///1MTk4yNjbGWWedxbvf/W4WL178tOfGccztt98OwDnnnLPH/Z1zzjnccMMN3HLLLfN63C8U1KP+wEmKlubRlsJxM5xS2UTBJGxPYjrOsD4a5ScbVjHyCOSnItKcJS0F+JUyLk4wrQ5BFOPyIijI5zCNlgyAx7HY75ZKkr7dy2YucjnJF8xb4gU1bD/GtHsylxHHEPhyNb2QkwpFKAF8bngV3eBKmZPTTAPX6eJP50RozDTkGmytjJRFsgWmlw1yxzvbb1y/D21fZk88S9pLZfbEOVngF/O4WgkiGcbG92QGIpv7IJ/DZO5QJvAxrQ6mkbUp+b4cdxiSgrRJkbUnlTPnLgNRNSDNGVJfDAAGdvqDC4rOAFnieziSwwUWE6W4wJIGVpLg80ayUWoeBWMIWh1Z9BMPF/ekKaSGNOfjda2IOeegmIdyUVreMgtk0+lB5MtQeSFPWs1jcj428KUS0utDkpkEDOZ53GAQ3ZPKUrEgX2ffK5PPyVxO1n5GmsKOKdJ2RypUhQJ0E4pbuxR2VGkc7ZMULdY4/FxCVHP0qx7FrCJjalW8LPvEdbu4boTdOsWCO3JMRiP8eev1bHtxjddV72W51+eEYAdvWXg74Ut8HohX4vV9ipOxWvTOEXr+VRRlPlABAvzoRz/a7etrrrmGj370o3z+85/nve99726PrV+/nihzZVm1atUe9ze4/9FHH537g32Boh71+0kWNtheZOm+qM95y9Yx4TeYSgo8mpa5tb2a7z91PPaOKqMPtgm2zJCMVDBJkqWFJ7KI72dX00eqw+C9YT5EpUw6WsVumZSr5ZUy6XgN0w0xzhGNlTAOTCzD6iYq4HyPpFoiLfh4nRA725a5B8+KvaxzMhiez8FITdLUG21xgkoSCHKY2Za8R2Pk6vzAcjaOZSDc93FRDJ0OpBK2R5JIBcbzoF4hqeazhPJwp3Vv4OPyAUk1jzcti3FTyGNGR+S4BjMO2aLWFgvSctXr4RLJQxlUGNK8R1KUdqtfFB674gykPoRVS1TJMexyyaokDMSKNcTVAL9clDR1GAoh0+tjigWS0bK0WYURLu5ijZHP0rMyQN8PoZcNw/dDCWUs5UlKAaQFGbo3RioPWWXXhaEcUpBisoT5oQVzkoiIBPlcM2FHnGRhiFJFGlZP+hG5psP1PJLUYr0E66WEBZkDMamT70XgSwtb14cowgQ58H1ym6ZZNNMjPzvC3zZfyeYzRnjvxI9Z7vU5Jb+Z9yz5KX99ap7N3aOwD3rkpzWscK7Q8+/hQeIMyRy3TM31/hRlwAtagCxZsoT/9t/+G29+85tZtWoVxWKRO++8k0984hP827/9G+973/sYHx/nwgsvHG4zPT09/P/o6Oge9zu4f9fn7ol+v09/MMALNBqN5/J2FEXILHfbCz1mTkw567jHedPo7Sz3Z5lN8zzQW8q/PP5i3I9HWXR3H3+mA3GCN9WQxO1mSyocpZK4OeVzpDlfhr89T2YmyGY0On1pCQqCYZsPIPtrhdhOH3yPZLyCswYbylyHP9uVq/F9cV7CWmnX8rMB8E62yLUW1+9IdkexgPE9XKslC/9KSVqusrR18nmZBXEOQ5QJKYaD6oMQv7iaJ/UtwfYWptXBlQq4Yk5mLLLU8mFLUqUiA/WJw8sGxV0m0myxRLpwFBOn2G72e+x7JOWA/og/nPV4tr/fQ6Hh9nD/8HsKccmSjJTwG62smpSTZHXAOocXxbhWm7TTASBttjCdbjYHlLVdDd6X7+PCCNvu4fJlER6BfPbD0Efn5LPMMkRcmooTVi+CNMVkVRNjLRTyJGMVTOKwPREtpljAVCuk5SLGOZJyntQHkxjS1EBWuMI4vBBMGEvrG2ASJ0GMSYqpiM1wum0HWMtoP8RGC7ghPI3kZYaLx26jZnuckNvKB1f8iM+n57KVxYw+7FGYVBGiKIpyKPKCFiAf/OAHn3bfy1/+cq6//nouvvhirrvuOv7gD/6ACy64YPhHuNfrDZ+by+Wetj1APi9X/LoDR5+98Gd/9md87GMfO9DDP6LQoKs5Ipv76I77zB4Pp522jvcv/ndOyTUInaPpUh5qLaH9WJ1lD0UUnpiWYfGBvWqWR2ESOTW4OJZgwDAWx6o0xZSKmCyLg5lZgOEAt90+M7R9tTONYXigR51orITzHd5kEzc9gzMWU6sMnZ5kR0Zab2YaOwejs1kDE2SZGqlUYUyrI+1gUYwdqUO1jIkTsdXt98XpqphlZCRiIUsUy1B2IcAVc5goFhHjJF3dpCk2SkjrJUy5QBp4xNWciBJ/DFsW21sTxdnAuE84ngNTwaSONLBEZW+fxceuPONzDcR5SzhWwGvWMA0vG8hPJcm808XFzWyQvCjD4EHWGuZ7UCzIsHynA1ZyTQaVCs/3sgpVjGu0RKRkPwukEsA4DHx06TB5niSRalCpKM5gKdJuF0aSjo7YIpusxS2q5wjrBue5p703GYhBREcmfAYmA8CwNc6FIabRovZwDpPW+U5wCt6Zjl8bvZNVQY/XlzYxsvpf+Z/+r/KEW87Y/R752UQKSSpC5g09fx8a6BC6cjjxghYge8MYw6c+9Smuu+461q5dyz333MOpp54KQKFQGD4vDMPdvh4wqGoUi8WnPbYrf/zHf8x/+k//afh1o9Fg+fLlc/EWDisGQVcDr/mxfpPTp9by+2e8X/+I7SfOQFy2NFYZVrz0Sd675CZOyTVopo77w4WsCxdy46PHMXG3weuluFIe0+rIkHYuwI1UJdAPIE5loR1GkgWRJFAswkgV0+zgpmekElApy2t3sjmOXk/mQga2sl4P0+2SmyriKqUsVyRrs+qH0sIUZ4nlU9NyZT2MRDDEMc5YCejLAu7wvKzNKM5mFVK5eR5pWcL9bDfC7JiWK/SFvAQANluksw1Mt4tfLJIslkRzO9uCrGUsLnkyC+Nnf3QNOCufazjiY5IiJgUTO2yUyv9Th7OGqOyTFAxJsP/iY1++r3jSqmWW1wkaRXmPUUnarPqyMDflEmmpIDa9zba4kpUKMtzuHKZU2tkqNag0bd0hos73peI1mCtJEqiURWjEsaTKh5F8nvnc0FWMJMX0Q6xnJX2+38d4JRE42bnQ5PMEzTI2DMC4oQ2vMQ7nOeKCBd9K2OFA5FRKJEsnxAmtF2FzAa7RhCTBNruUN+UYu6vM/6udyLGnbeO4YJJFnsfZ+Wl+e8WNfKR5IY3OKPW1jlwzVREyT+j5W1GUA0EFyF540YtexNjYGFNTUzz22GNDAbJr29X09DRLlix52raD1qu9tWgNyOfzw2rJCxkNupojrJGh82Ue5uQG71n2U1b40zRTx8a4xg0zL+aGB06ifkuB+roO/nRHnK2y7AzX6UIxjyvksP1IrvDn/Z0p3MUCyWg1c8WyWJclZRcLkknR6cjsgM2Srj1JFndJStoWRyPr7zzluCgSoTGoFBor1Y5yGVP3pB2s3ZFh734fM+tEtOQCGBnHFQK8Rgc3OS2L4E4P0+5KGnilCEsmsFun5Kp5TmY8bCDiyrVaeFvAFfOkoxXCiTJh3d85s7EH8ZAG7HzAgUk9bOywicMZaXtLPeZcfAw/LwOpb+jXPeJiAa+XwwtTbJhie5IZkgYeLu9hLWJzHPjDEEl5EynOs/QXS8Um96SICtfrSwXMFWTmJ8jSzPshFAq4WlmS3bdshyiW5+Rz4iqGuGOZ6QZpO2uHc07CJgsFXCFHMlImrAXDeZgBnpeC77IKSCYkwwhTq5JW5QKOCJDMga1aEaetXh9vR5PRR3ySQpH/xa+wdU2NN9bvYqXf4uz8Fv5/J3yX/2ley4wZY+QxyDWSYWiiMnfo+fvQwTlL+ou/ZHOwT0WZD1SAPANBtliJBz3RwMqVKwmCgCiKWLdu3R4FyLp16wA47rjjDs6BHuZo0NUcMGi9GvNovDjk3cfdyZr8ZkpWfnY3xaP8+4bVjP0oz9gDbbxOOLTVpVSUfI/pWdgxhdfqSBtMvYpxnlwlz5K8bbuHN5s5R2XiI60UsM5hominPatz0vLT60Eo2RxEstCFneGFImyKcpW9VBzaxw7TuQsF7EhdBsgTsYAFcIFPPFLA8y1etzd0fnLtjgy0O4fpyeu5blcW2IGPGx+V1quO5J7E9SLhSI64bPevcpG1DSWeIdlFrcx3t4KzYt3rPDEZsLHD66f4bYtPH9voYqaiLKujC1EExuKiUGZkYnHPCqaKmCSR763vYyo+eFZCECslXCHA9KIs8LArLajWkIaR7LPXk/syYwK6Pcl2KZekUgVZOryHKwTElRxxyZLmAd9hrVRBrHHgORF0USLiwvNIR6ok5Tz+jqa0CGaCxuWlbc71+rBjiny3z4J4Ic6WuL60hrHj2tQq93Fs4LiospHaSd/mk/75NMMFjD4in5Uyt+j5W1GUA0EFyF7YsWMH27ZtA2DZsmXD+33f56UvfSm33HILN9100x6teG+66SYAzj777INzsIc5GnT13Bm0XrWWGV52/FreXLuDvEnYnhSZSUtcs/WlcHudiXua2OkWriAtOINwuwFJowWNljg8VcsQpqSzDZn9yPrx025P5i5qFRip4nK+pGtXyqTZYDjOSUp2kmDqsv90VkLmYDBbklUlcjlp+zGSDu6iKEv5DrELJoiXjuHtCGCmIVevoxA7OUMQRuKa1OtJC9Fgv2GEafcksC9rzTK5HGa0TjReIS77QIk0b4kLdo8Wufv6mT8fDOx7nZWKSJLzSHJWslK2zpBs3S6taRnG87DlonzeWV6JfXKbBDcmqdgH53Mi8LJh9EFWiM3lSFttaV3zfUy5hKlVpf2t2xXpleWiYI0I0lpJfiYMeO0Q05MgQkxAkgObS0R4DLBO3ks5jx0fgWYb2+5iwgimZkjDaOd8UjsbpM9CJ00YkQt8xioBW2p1bqiexMnHbGSRt4OS9fiVwjYaq3/IR7dfRNDKUX1SM0LmGj1/Hzok7H5BZK72qSjzgdbW9sJnP/tZnHPU63XOPPPM3R779V//dQC+8pWvkOzyhx5gw4YNfO973wPg4osvPjgHe5hz5apX48zOE6cGXe0fzjMkBUtjhYc9dZZfm7iLZVnS9NpwIX+/5Rzuvn01E/fGmK4E3dlOD9dsSQUklivhLo4xgY8tl6TPP8qC7TLHI3xfXKYGbVapw/QjGerOFq8mEgGAc7hiTmZKRmu4WkWGw+NYqhWeJ+1AvcxFy9qdDk2lImZsRAbbA5/UtzK30A9JZ2ZJuz3S6RnSJ54k2biZtN0VUdRqi7tTuwM7puS4i0XZz/gI4dJR+hN5wrpPfywgrHqSs5HNeBwKs5bGPf22JwbH67IZlSRvCEdzJAtG8BZO4NVr0s4W+CIcg5xknxTz8n10khY+aJPD96QlrtHENtvY2Q4mTiWvJZfDlkrYRQtwSxeSHDUO9aoM9vfDrPokA/6EkVQyhgfqhtUzyUMB47mhALHGYazY8CblQBLqk0Qcr7btkJkT34fUkTaaJNt3kE7PDCtpGANRTOHJJkt+FrLp9qP4l8nT2Zzk6LsUawy/VHyCC06+h+mTHN0xn9QzwzZB5bmj5+9Dh9TtHESfu9vz/a6UI5UXrAC5//77+Z3f+R3uv//+3e7v9Xp88pOf5M///M8B+K//9b8+ze3qQx/6EBMTEzz44IP8p//0n4a5IJOTk/zmb/4mcRxz/vnnc/rppx+cN3OYMwi6um38WLbna9w2fiy/d8YHNOhqX7AG5xs6Cz2ap/T5vZN+yEsLT7I58dicVNka1/n5oysZv9vgdxLi0aJYzTaa8tcq6+Eny3OwlTJ2Ykx67fshaast4mPBuORy5LJwPt+XjIgdUzA5I5WIQU5IIYfLhsEHadxmtjlMzjb5PLZWw9RrEmrnnLQL5QJcuUhaLpIsqGNqVQgj/EYP0+wMqzDG86RFLHNlMoEvx1UsYkbrkg7e65O2JC/DlIq4Qp645BEXDEnOkPocUsIDMsGRgN9z+F2H13eYBMyzdA0NREhUsvSOKhGuWgRHLcTWKth8PpvtSGVOI3U7P6tyCVMuy/fL96RVK45FwM02MdMNEZO+jxmtk4zVSEs5me8YhD5mblhpVrEiSTDdPt62GfzNU5hGGwKfpOiTBAZn3W7XU41x2CAlqkLqW2yzO3ROM4XCUAzjZ7MsMHQsG7w2qQzBFx/dzpKfJHzvjjX8tHMciXMUjM8yL+BtY7ew4sQtNFcaoorNqkiHyDf+MEfP34qiHAhHTAvWTTfdxEUXXTT8utWSsLI/+7M/43Of+9zw/jvvvJPly5cTRRF/8zd/w9/8zd+wYMECVqxYAcCDDz5IJ/PRv+yyy/ijP/qjp71WrVbjqquu4oILLuCv/uqv+NrXvsaKFSuG265cuZIvf/nL8/hujzw06OrAcAaissfssfCKEx7ltMITrI9G2ByP8mQ4xjWPn0btrjz1xzp4vRgTxtiZpuQ01CpS/eiHssjM56QyESdi1xrFcvXas3KF3PMk8wGknccacbpqtcUityjhfsQJttuXwLo4xqVZO1ahMGx9MZUSyUSNNLB4nQjb6AwzIACSvIfNB9DuYDp9cT4aHRGRMj0rgYmBL3MmSSLD756V1q2s8oFnScdHSCs5Ut+SFDN3q0NIdAwYiI9cKyE3FWLDmDTnE1cDwprY+j7TMQ9dsioeOPA6Pl4QkPb68tmM10lGyqSBh41TTBhnw92hJMBn32N8H5JUKhtZvouELfbxts/gqiX5HvZDeeFuT+YzjGStuETcplw+J1W1KIIkJfUMLhvQN79Q1vH9hN6Eo7Eih9cbxQ98mG6IjXK5JD87g9fxfRGtAC2xj05nG9Bo4pyj7FkmFizmf42/kvwpEReWH6FkPao25eUL1nHVcWN0pgt4kcPv6DzIXKHn70ODdB6G0Od6f4oy4IgRIFEUMTk5+bT7O53OUFAAw5aplStX8vGPf5yf/vSnPPTQQzz88MOEYcjChQt5wxvewG/91m/x+te/fq+v95rXvIbbbruNT3ziE/zgBz/g3nvvZenSpbz5zW/m8ssvf1YHLEV5zlhpvWovshReNMNbJm7jKK9P5DwSZ/nZ1DH0bh9j2e0dcptncMW8uET1Q2lryeYnXNZjb0pikeuaTbmvmDkiucxhKk4k+yMbNjcFscZ1rfZwoTnMyIhiWZTmcrjB1fJ8Dor54dVz2+pBISctO92eHJM1mH6ID5hOT8L0wgjKJfAsrt0Rm9eBoCkA7SzHxGTiqJCXzIg0JS0F9EfzON+Q5OwhKT4AcGBjR9CICbbOQhjhGYNfKcLyOv0RX6o2+yBC4pIlHC1Q6NYxSYrxLGkhjwlj/G6UWeym4HuklQKmn7XaWYsZrcvAvktxSdYW51KIncyVlAry/QBYtEC+X1EseSDOSR5JpyvfgyTBGGnHGRyfOIzJALoxDucM1jrSYkpc9ogqPrZTwGu2cS7F1cqkpRzeFDA9IyIks3eWMMgspLDZxCUJ9qltLLg1B2aMv4hfR+fUHG+o3A94nFDczFmr13NLuAqTBNQ26DyIoijK88URI0DOPfdcKc3vIyMjI1x++eXP6TXXrFnD1772tee0D0U5IDLXq84Cj9nTQn5j5X2ckNvOiPVJ/Q539QLWbp+gtNURTHflinXg78zdgMz2NFtYRmK7K45JWb5Gr4+plDF+Xhb+nS5pZplr7S9cFQsjcStKU9lPXmYOBq5VpKkMiRdzuBTJ3tg2iTewxe31MGOjMnPQ7mJ3TJM2W6TdLiaKsYMKzaCFqF4jrZYlnT1NIQxlUeqkAjMQPcZBmhPHqGdbwB8KpDlLMlrGdsXJiiTF6yfY2JPZhX04/iQwhCM+2Bq5cl4yQIzBdKVq4XKBCJNeuLMNybMiSlIn1awgkDyXVlvsmY2RmZJGS2Y+AJPPybH2LDTa8jMUijhNq2Vsq4NrtjDtLn6njElzOPv0zidrHc53YmEM4BmxWo5klijNedhiXtqykBYs1+2LLXA+J+d9Y0XYeB5mtsX43T7O1vj/klfRPy3gtZX7WZnbwYUTdzN2aofvzJ5GfsajMJ2FKSrKEUCKIZ3jofG53p+iDDhiBIhyeKCJuXODM5AULd2FhmNXbuWsyjoCHEnmRHPT9LFwf5XStgQXSEaE6fVx7Q5puyPD5tWKLDYzByqXLSABGfrt9rCAGTyvJENjLgxxUYwpGXmsWsF1eyJSnINCQdp+AqmymKwywq69+87huj2ZMfF9mTMBnG+lUtJokXZ78rw4EvesuLizlcsYacNKHeRzGOfktf0sZK9ewfmWqJqT4WfvEBcfA1vfnMUrBNheLJUiFxNsb0sL2UTwNAHyi+/JZRolyRl6oz5R2cPrpfi9BBuKi5lJUrzJUMRCnKXAFwvy/dolL4QslXww8G2sgU5nKCpNt4cXiRhxzSZpt5fluGROaP1QWuRMD3+yTXE8T6vtEyW7i1eTWfE6D2zkRHwh4YUuivFafXE0KxZgfATjHGb71E5xlGELeflZLOTwJpss+HlKXBrl+oUnc+KqTawMphjPP8mC0QZ3nLiMxo6F+H1H0HJaBZkn9HyvKMreUAGiHDQ0MXeOsIY0sLQXWjpHR5xY38JR/jRla2imCTd2VnLz/cdyzE9DCusmZdEPuOlZ0k4HY40MJxeLYsGbC0jzmWVup49ptqHZylLGs4VZPieiwlhJy87sW9NaSQ4piknjWNqoBmFyaSrCpN+XK9SeJHZjLa7fxyXJcHAZa8V+NWuRdNlwOfjSxpOkGJeKEHIONzOL2x5jqxXcaA3KRUhTknKeqJ4nLno4X6oBg7mPQx4Hfi/B396UGYgolIVxq00u55MULFEpE4uZYBncdhUiw/97EBcNSd4jrHmY1OFFjtxMjOd70pIXedBqi1jIrG6JY2mlimP5nqdi12wG+R7W7pz5aLVlbiSfx3oeRLFY9rZaIoWtkcrK1CyljTkKy+r0Qg+3ywE7ZyAFrw/BdA8zOQPFAq5exHT7mG3TYrUc5EjzAUklh1fK4U21xEwBsMUR2VepgCvmoNPH7phl5LEKT6xdwHfGTuG1I/ez3J9iZTDDO47+OZ+bfDXdHQW8fqqtWPOAnu8PPokzJHN8pWWu96coA1SAKAcNTcydA7LWq37d0jjOcfbJa3l1/UEW2D5547EuyvHXa1/F+M99io9sIt22Q+xvgbTTwaUOm13tdq02dC2mXMIaQ1rKkVQL2GoJ7ylZcJpSEVeryBXxdna1ebQuV6S7XeyOzEkrTeWKdRhCK9w5Z+KyQV+X4rIWIJOXK/EM5gbiWNq9PItrpxKWlzpspSyCwxhJM69WSOtl7ExL2sSyVqB4rExYD8BBUrA708xhZ3D54fA31CAuVf0QlyaQz2OyWRbb6FAIPLxqjjSXhf8ZQ1yyxHkjrUl7qY44T1rRnGeyalBAkq8TtGK8Zg+bpOJC1u1KdcP3pRqSWeiawJd0+kops22OxQwg8DE9aekzNsBlPxf0epggkMrKLkn3drpArlnD9Tzi1BJ4IjaTxGL6llzD4U01cEkKhRzOWkwY4fqhCNg4xm7ejlk0RjRWIs35+LlAZlmKAd6kDKK7nI/zPLxeSOnRSRbevIjriyfTPjHHr4w8zNmF9by6/BD3vGgZP9x2Cl7Pp7Q9lh8VFSFzhp7vFUV5JtTeQDloaGLu3JAULc0VlkVrtnHhxN3MJCXu6B/Fg2GObzdOo/nzBYw90JXFYppKTka7i0uzHvlC1k9fyGMqZVw2G2JbPbx2NicwVoeF41L5iBPiBTXcURNyJbyZ2dvmciICjCEdH4GF41K18DxsrYoZrctMSa8vblkgC9ORKm7xAmy9KrkixmA8KwvuYhFTrWLGRmC0jqtIsvaw7aotcwmAVD9qFZw1pIEhqorNrvMyi91DzGb32Ug9Q1TySUcq8jn4vnz+1kI/xJtsktvWJr+1Q3HDLMV1U+RmYmz87Ivm3TJDcvJZJQVPFuuVogiPQWCjtWA9mbXJiTOaKRVIy8XM+SyUxPlWR1LmO10RnsaIcPF9ERH9/jDzxTmHa7QoTCV4LUsUSRtXklqSxGASI+/D82DhGM7zJKummIfFE/KzVa9irMXOtsk9OU2wcYc4bXkGZ42I5JkG3pZpvNm2CKUd04zdOc3oLTl+vG41D3aPYmNcp2QSPrTwh7zinPuZPgl6o57sQ6155ww93x98Bi5Yc33bXx5//HG++MUv8v73v59TTz0V35dK9ic+8Yl92v7qq6/mvPPOY9GiReTzeZYuXcp55533jO6iDz74IO94xztYsmQJhUKB1atX85//839mZmbmGV9r06ZNfOADH2D58uXk83lWrFjBBz/4QTZt2rQ/b1k5ALQCohw0NDH3OZJVP7qjlt5JXX5zxc95RfEJZlKfjfEIX508hxtuOZUVt0QEm6bkCnYQYAsWjB06BbkwGlYWiGJxoDIGVylhe+HOvvokkYWkZwkGw+XWymIza9kxQQBRjO1k8xqpk0VrLktXd6lYuXoy3I5zkguSyP1epYyLY+zYKOlEHeecVDi6veHAOYFkjpg0laHj7DiM75MWApKiRxpkcx7zfEllVwfZuRQ2AwerqGJhWQV/tIiJU0zi8Ge7kqeRpuDJ7ItptCFJ8LoVbCIOWfvaZuZsNqhe88FBkDi8UhHX6oiFcakolYcQTCGQIf8klRmiQh6yygdJInbHxkjFa2pGfr6iWL4/nrRqORimsPvdhNxMQH+RT5KLh2cC5zvigpWWwCjG9kPc9KyIn3wOVy2TjlQgluMwvVAERhBgEoeJUlwhqxhl2TbGGHApttmm/niF1ooijy5bwKuqltk0wMPx5vHbmT2nwH3uWBbeYQmamvs8V+j5/oXLFVdcwRVXXLHf2/X7fS655BK++c1vArBq1SqOPvpotmzZwne/+1127NjB+9739OrZD3/4Q974xjfS7XZZsGABa9as4aGHHuIv//Ivue666/jpT3/KokVP/7l74IEHeMUrXsHU1BT1ep2TTz6ZtWvX8oUvfIFrrrmGn/zkJ5xwwgn7/wEo+4RWQJSDhibmPjecgajq0ToaXrb6cc4rP8gSr8hyL2V7XOO7j57Awp8ZihubMvzb6WZBbW6YMg6yMHPOyZXsvgwYuySVK9rTM6STU3KbmRWx4Rzpth2kT20lbbVlKHnQWmWMJGzbTMwMhsk9S1qToDtAFqWZoHHt7s59gyysY8kcMXE2P2KtvEaSiGuTtdLK0w8xtSq2VoW8tIxFZY8kmP85D+OAwQ32mlJ+oDgDaWDo1zy6C3N0F+fpLcrTO6pKdPQCktEqptPHbp8hbTRxUYSNEkzi9v94DMQFccsKxwskI5JUT7cHvb58H0eqpKM1ksXj4k7W6gxnePCsmBbEMaZYxI6NYAoFuVXKUrGCnT9jUQRRSDDdo7jNkTYDur2AXjeHSy2unNA62tA4aUwyZxot2TYMSRtNTKcnPx9hhEmdzHqM1UlHpT3Qm2lllsFup01wsSACKXUErZiRh+Gue1Zxw+wpbIhH2ZTU8UzK6yYewB7borXEIynswaZLOSD0fH/wSZnrFPQDc9WamJjgggsu4H/8j//Bv/3bv3HxxRfv03aXXnop3/zmN3nlK1/JQw89xNq1a7n11lvZsGEDW7Zs4ZOf/OTTtmk2m7ztbW+j2+3yH//jf2TTpk3cfvvtbNiwgXPOOYd169Zx2WWXPW27JEl461vfytTUFBdffDGbN2/m9ttvZ9OmTfz6r/86k5OTvO1tbyNNNS9ovtAKiHLQGCTm7uqK8tVVr9HE3H0hSzxvHWUpnjrFWxbcxjI/T0rKo3HAP285neD+ErV1bWyrI1epK+Vs0Z9gKmW8WhXXakn6dTEPkzOAk7A3a3GNQf6HZCsMh8PTzKo3SbKsj1RauXI5ad8x2aBx4EPP4Po9bD8iHa2Q/v/Z+/NgS7KzvBf+rbVy3tOZauyuVnVrnpDQaMCArrD5QgxXkjGYEAgEhAzBYAYHcQNbgcGWjTCELNnXWP6EhUAGBLLAcK1LfxjLAlsYGSGpNQv1pC71UMMZ9pjjWuv74829T53uqu6q6qoe84k4UXX22bl3Zu48J99nve/zPOtDtHOSH2KMEI1AksuXIYJoLTqChayw+0Nr+ChAz0sJmuslmLLCjydCpvoZrA2wvYhyI8LG1z5cUHlJJF8W+zL2c/XfZ+li5QIAhQ3br9SQVhZ2x/vuYIVDjxeEo1i6B+YhXvwC79PECrce4E1K4lzrclajqKTsCAyuH+FdIhky05mQizgSE4PFQp6XJqBFl6K8x1c1vqpxVb0iqyrooRYlw7sayo2QIs/wGlzsUL2G8mTJ6SSiHG0yvHNAdGaO3pvixhP8fI5e2kYP+9SHB7jIEE5ldNDPFuCdnBtrUYMBDHrSiatqgp0565+zKN/nD4dfwbGvHPN/9D+LwdOLK1554xf5o3NfQTw2kkAPnR7kYaL7e//Iw18DG15/Ba93/4iD9773vQ+5zc0338xv//Zv86xnPYubb76ZdHkfanHo0CG+8Ru/8QHbveMd7+Ds2bM8+9nP5q1vfSumdenb3Nzkt37rt3jqU5/KBz7wAT72sY/xohe9aLXd7/3e7/HZz36Wzc1Nfu3Xfo0sE0OVXq/Hu9/9bv70T/+UT37yk/zBH/wBr33tay/7HHR4aHQEpMMjii4x98rgFdSZZn694wef+pf8zeQ0EHHalvzp/AV85vMnOPGZhvCeXdFIbKzh0wjtHMpa/PoQFwXiMhUYfBKje5msYiuFj0LYWJME82XKdV3hixJXiRuTBAVq0ZWUJUaLcN1sT2Uky5iVcNlXFaq2uCxEVZLXAcgKOxIWKMWpl5GfNMX1U6qNlKYnad5BHstqd1vULrNHXBZTr6dUo0AKb/3I6DyUA21bbclFatP7dyGuZL/O30YBXivJApkJ8dCDvhCzyQS1s0e41qMaBjTJhcXoD/o+bdelGgV43SeOA4JzU/zuGD+bo3sZZhkkubTkbUfjfD8VG9+2M4VWq/E75ZwQTdOAV0JqD23g45D47ILhHQPCmcZGMnZWHlbo9QpuyDm3FjE/FrPx+YDhJyvU5LwDylJ8FssomvdyTqoaFUe43T3cYgFKoxcL0RW1Bgbce4ZgL2UUGubHMm556vV8x/DjHA9irC9Y2/pT7nz2BnfddZJoqgnn9oLnrMPloft73+FS8ba3vQ0Q8nJ/8vFg+L3f+z0A3vCGN6zIxxI33HADf+tv/S1uvvlm/tN/+k8PICAA3/Ed38FgMDiw3WAw4Nu//dt5xzvewfve976OgFwjdASkQ4fHOtruR76p4XjOi9I7GemE0tfcXg/5b2eexeCLAf0vbuO2d2X2fkkiQiENKm+zFBoZiFBlJV2QNJbU8qrGbvSlyJ+Im9CyA6KDYDWyhbXijgWtcL0d4Vr+LEmg35PuiPfoRS0r500jj4GM5Cw7Kogw3W0OqTZTqmEgHQ2g7mlxhfJQD/rourcqmM+3132kROZeI2F56sLdjyVBUVb22WtwgXpYBGnZqZA3UOJQFQTga+lMFSV6VhDOY1xgcMHlkZDle7hAxvvQCWhF4D2qKOW9JjMoS5x1+EbcxzRIhy1uwwHrGhXHuPUhLgvRRY3WWghK3YgGqC0OdF4Tjy0uFEG8qRTKG8o6xqYOVWrpNjlQjcVrhVob0Rxdw8WGYK8g+tJ2m7xeyM/DpebIo6IAlSZyDS/thOMYn+eEd51j7bbr+MgdJ/nTzZt4de9OhjrhaWHFqw5/hrc+/TjJdogppBvUdUE6PJ6wHJu62q95rZHnOf/tv/03lFJ88zd/Mx/60Id4z3vew5133sna2hpf+7Vfyw/8wA88gCg0TcNf/dVfAfA1X/M1F3ztr/mar+Hmm2/mIx/5yIHH/+Iv/uIht3vHO97xgO06XD10BKTDVUcXPnX10aSa+XXwFdffzVEzw7W/urdVh/nCX1/Hidsa1N5UuhXLojEIIInb+XvEUWpjhDeyhK+KSvQXVS16gulMuh91O4YVhTJm00vR4ymurqUApXXAqmvUZAZJLCSiqiWdetCXAMJ7zslYTCmz/EotRNQOqCAQHUcS43spzSDGtmNES7cmANXe/GyopKhf3gsfIeKx6mi07+3PyxQ50KnwQj7CqSWcNajG4RJDNQqoU33ZpOB8eC2fv+vFmB210l7ghRDovSlRL8aZlLqvHxYJqfoGrxOi2BDs5uhpjvJi46zKct9CubXqdVmCyhLUdCH7pEHVDr3TjvNFYdsRq1Fnd0QYrhThKKXJEvCgGzA5JOcUyhmiqSfZroi3C3xg5BqMQppeiE00qo7EqGDS6j7CYH9EsE1sxxioalxZCmEe9vGLArc3Zvi5HoutDd4+eCUnn/e7vCReAPDK3uf59POP86df/kp69ymwHfm4lujuEx2WuOWWW2iahuuuu45f/MVf5C1vecuBn//e7/0ev/RLv8QHPvABXvjCF64ev/POO6lr0XzddNNNF3zt5eNf/OIXV49VVcVdd911Sdst3yNcLnJ0uGroCEiHq4oufOoqo3W+qjNNtWl5av8coXLs2JKFh88ujtO7I6B3+w5uMkXHMRw9JKF/uxP8YiHF4tqQZlME4cFeLvaloXQyvHP4stpPvE7iNkDO4vNcVq8HPXQS4+c5lK1I2XkRCM8Xq9BC7yTDQRUVfj5vHZHUKrhOaS3C9K01bBKhaivJ1tbBBbR+BwjHRU7R+SRh+dwD214BloJzbVnZ3DojHY2Hem1dNuiiBmJ0ZtCRbPtwSIi8aSs2DwIptKNIujF5jjm9R6wVqIS6p3Hh5b/Ryomrp/EmFCIxzeVaIoQwXInR3XQGzqK9F0KrpTujZ8XquvFVvd/lakMMl9ktumgwpcOGYtGra9BTIXDpqSn63K4YI0ShOGD1EnTlZB89ohtqxNhAj4b4fooOQ9jdk2tukaPiCJ0mokfZHQt5rhvU6XNsfjrl1PF1fvXQ1xEe/SADXeG85quGt/HHR55POdSk2x7VdUCuCbr7xLXBldrmPtRrAkwmkwOPx3FMvFyQeJi49957AThz5gxvectb+NZv/VZ+6Zd+iRtvvJFbbrmFH/qhH+JjH/sYr371q/nMZz5Dv98HYHd3d/Ua6+vrF3zt5ePnP3c8Hq/E5Q+1nXOOyWTC5ubmwzzKDvdH54LV4ariQuFTyntef/sHH+U9e/yiyTTz44pDT9nlb/Rvw+Cpgc/XW/zZvU9j+CWHPtOOXm1t4Ib71qh+Lqu7PhTL1WBctMSkQDWyYsygh97aQI8G6H4PvTaCI1uotZEUk5OZhN4dXcPdcFhE67ByC3KrtPM2LbtuoKrFtSiJMetr6COH0FsbkqLuHWpRYMZz9O4Etb1HsJdjqqWz1uWfI117woUjmjkREbt9YqL8hb8eFB6CwpOereh9aUbvrjnJdoOpPFxge6+EZNhE49IAH8q4UTC3hFOLqfb36XLcqpadlWjSoCdtUOBypX/Ql9wV56GuMfOKILdoy8XZ2kMddtt9amJNPYywa318FOKzBLc5FNepMMSXpYjDt3dhb4KfL2QMr5bcj6VTmer10FubcN0R2BjJPvcydFkTzhqCQj6voPDy+WvwsVkZFviqXl0r4ekJyd0TgklLnuNI9rko99+3l8k5aY0XOLyFHg7ETSvP8U2Nn82JvnSOQ59wfPiTz+Av85sweEa65qboDCduPMv0KZom7RyxrhW6+8TjDydOnGA0Gq2+fuEXfuGqvfZ8LtlOdV1z00038f73v59nPvOZRFHES1/6Uj7wgQ+QZRl33XUXv/Zrv7bariiK1f+jKLrgay9JUt4Gol7udvfftsPVQ9cB6XBV0YVPXUVoCVir+prFCcv/efwLPD+WlaLaw/+aPZ3t2za4YdoSCZBsiHMT/HSGL0spyJRCLQoRBm/v4aatE1YY4NNIOg9LEfkSy1GpXk9GXABVWgg0fm2Amszx87loRNJE5uyTGJ8lqKoW1yut0f0efm0gBfOiTciuKvxkJp2WpZpbqf1AucuA8qAsRFNHvF2gqgbbjynXI+qeBtNqM2ovnQwlXQwXKCl2L/J2ykOQO4K9Ej0vUGWFqnrYdIALzYW3U2BjRTUMCbXC5A3hbo5ZBCgX4wOFjS+eXH7RY7SeYFLC7kR+s+o2GTwK28/MyjjcPEeXCepyQkEugPMzSZRLib1HLUoZSfIewgC9Ntrvaiw/QycGBMuUdtoOG4ER84KyknBMrVB5SbCrwXp8oNGldMK8lhEtPxJy5fNCxgJbTdOyG0cUopKkzYuxqLppxwebdl8cNBY/zCAYoYoCynIVxInRZPfkDD/f58+f91T+du9zOOBsM+R5G/fyRzccone36bQg1wjdfeLa4FpqQE6dOsVwOFw9frW6HwBJa9sN8MM//MMPGHc6evQo3/md38m73vUubr75Zn7sx37sAdtVVXXg+yXK1mr+fGH7/be7EJbb3X/bDlcPHQHpcFXRhU9dXbhQUQ0VwWbOU5MzZMpTerizGfHf7n0Gg9s1pqghjvDjCe6+M1IseYeKYynSmgbmC3HDavM28A4fR61AvYDJDL/IJSOkafB7Y5l0GQ7waYwqa8y95yCOJBAuS2A+F31JOwqEW45S+ZUDEVqLyL2s8dPpKu0ckHGetrBzUYAz6opGlJTzBHmzIl7hcIBXa3gT4bUiWIguA+fxRtH0w5VWYtkDvr+eAw+mLYrdMMVsN6hFiWr6KHfhwEOvAC1uZV4HxM6jZxW6qAlnBhdqcOBVOyJ1KeL01v5XTpKVghsZaVIqwq+P5Pu6EUJp9GWTuIvBhopqYNB1Qtg4eY/YYEc9WO9h0xDlPDpv0ItScmSmM7z30p1QbZZLUcBsDtbJvgXStdHOETYtYWmvEUAyPuJASEZRCulttUrEbfetsS0Jaa/xJIb5Qmx4QchLUaDyWAhQEOxrQ+IYH4WYScHarQl/+YUb+f3hV/IV6V2cbQY8LT3D0adsM777CEFpiMa2IyFXGd194vGH4XB4gIBcTZw/BnWx4L9nP/vZgGgyLrTd7u4ux44de8B2y9Gr8587Go3QWuOcOzCadaHttNbX7Lif7OgISIerivfc9EpevHMb1suKVhc+deXwWrQf5QYc35hwNNyjpzSld3x0cRP3fWmTE19qiO+drgpTcRwS4a6KQpnDbwtSvyhW2gFfVjJn3zSgtKwKV7WIxU2EymJ5DGRkq2lEZNzO5QMQRvjZXOx0Ae29kJmleL2uZTSrKEQjsswOGWSyH+PZKhdEz3JMlQCXEWZx3nmysVl1X7zR6MoS79Wo2hGcm4kTV0/EzKa0KBdjY42N1QVDDJWTdG1VNfggEscwL2NCynoILlzkL7sHTapByXkyCyE/upaC25SGemhoYi0E6BI0K7YfoTfXUWd3pNs0HGCPrlOtxbhQrwT6NtFXJZRx6b5lI0WxGdKkA0zp2rBEjYvUSmcSLBzJadDndrCzOSqUnBfVS4SEFqWEYmoFKpDRqjbMcpW34Zx0PpJIxgVdS6rqWvJivBcdkbUSSthaSUtHrZaUdpBrU2tUHIlgvrHSCTFGunHWSZ7MdIaKQnrA5l9s8p7+y/gHz5/zt3ufJ1Oe/smC/7v8evb8Omu3Qrxnu2yQq4juPnFt4K5BDsjVfr0L4ZnPfObq/xfrrCwft+eF6p48eZIwDKnrmttvv/2CBOT2228H4OlPf/rqsSiKuOGGG7jzzju5/fbb+aqv+qqLbrd8jw5XHx0B6XBV0YVPXSVosW8t1xTFDRX/5/FP8vzoHIWH2+p1/vvZZ5DcExBOWnvdqpbAQWPQvRS1sS5z8osCt97HG4PZmeyHBk6nkkZuHbqXipNVHAnR8A6GfarjI1TtCO/ZRalkNT7jshg9WeCm05X4XAUBKkvFaasVlS9vW74oIYzg0DouCqjXE5rUkN6l0HtT2SelVrkUlwuvRSdTb2WYKJAV80Bj5jV6bw7be3jvZFXee/TelPQ+hdsYUB7pUa4FuPu7aimFiwwuDXFxgO2F6NISzGqC1OACA+bCpGHZCWlijRqEBIHGLBrCe/fEFnbYRx8bogYhNt63E15+3f81vYFqGOLViDAKUdZSr2WUWzFNqg90Y/xFXuNKcD4JcYFBObN63C+JkwcVaxGit8W5UpL7YQ+v4RUEZ1uNSN46Ui3zYqzDL8lJXQtBDQN0kkAYrjQgy58RBitNE2EAiwLfjqP5opTts0yuX+ukoxcGQkwbix/0hBy144PSHbRsfHrB/Fifj9xwI6/MvsCRIOGben9N9KyGd0Rfx9gdZvOzjmDRkY+rhe4+cW3weLXhvf766zlx4gSnTp1aFf73x/Lx6667bvVYEAS86EUv4iMf+Qgf/vCHL2ip++EPfxiAl7/85Qcef/nLX86dd97Jhz/8Yb7ru77rkrfrcPXQEZAOVx1d+NTVgY01iyOKZ954Ly/PbiUETtuQ/714Kl/4/HUc+4IjHBd4o1FZim6dq2hn82UOXixhvTEyotNLwHp0XUu3RGsZlXFOSIh1kjo9WxDstStR3ssoVSgCc709wc9mYqmrNMoo9Po6qp/BohDb1V4qGoDJvN0Xi9qdoNKEQClMbkST0uoHfBrhIi3F7WXaxyqk2PebEXq4v1JlcktcSAYFFjlPdYOfTAHQgSHoxzSZxmt9YCRKSI1BV6EQmaJCzUSIGJsNXJi0IuUH2V8FPmg1HDtz/HgiK/ZRiM4bkrzBZiH1QAwCXKRo4vt1L9QyS0ThghCbiA9+k0r35lqHMK7Oh5HL5PzHloJ6Uzj0QhLPVRiISUFgVgGVvij2XdD6PRj20YvWuKAs8VUl7m1xDM7i5gvpYCSJjAA2YmrgyxJfN+g0kTG+MMDPkGsrTXDDTMT/DpS16N2Z7G+g8evimuOSEHe4j5lUmN0p7OwR7E44OjrJ/zz0bP7wFffyXaOPc8SkfFPvDuyNmjef/may+yJ6lUc3dF2Qq4TuPtHhfHz7t387b33rW/mN3/gN/v7f//sHflYUBb/zO78DwCtf+coDP/s7f+fv8JGPfIR3v/vd/MN/+A8PhBHedddd/Mmf/AkA3/Zt3/aA7X7nd36H3/3d3+UXf/EXD2SMTKdT3ve+9wHwd//u3716B9nhADoXrA4dHoNwRlH3FMV1Na85+glOBAsWHm6rD/GnZ5/O4NaA4W0zzLmJzM5bi4oi1GAgq8VONB6+n4F1IqSuG3TrPOUXuZCVNrXcz+f42RxfFOIYtLuHuvsM+vSOCICrWlbvxxP5WZJgrj9GcOwIejBA9VIhOG1BqRoJMfRrA1S/h69qcU2azjG7U8z2TDoqAEavckCuqAOipEBuEhHsL7/qYYAd7mtOVFWvtAPEEsCI89hQnZc7sr/CbxOFDzV6lkvOhRcRttldEG9XBIU74Lb1gH3S++RhmRLu+xloMOOc4N5dojMz4nMl6d1z4t1aggz9hV5nKXA3lCNDk1w++bhcB64LHtP9R9WsJ5w16Hku18TGuhxnXsi1MpmKJmg0FFes1kKYMJAxwTQVQrG5jrv+sLivRdL9wGh8P5OQwaWdbxQKEbZWEtCNRvV7uGGG7cW4SMi3yqs2HFNGu5T16PGc4MyY8NwCM57jx1Pszh5ud5fsllMc+zP49x//Wv7f+TNY+IqRjnhhchfPfMp9zG5QNFl3u+zw2MayA3K1vx4J/PRP/zT9fp8Pf/jD/PN//s9XNrl5nvNDP/RD3Hvvvayvrz+AnPzQD/0QW1tbfO5zn+OnfuqnVrkg29vbvO51r6NpGl71qlfx4he/+MB23/Zt38aznvUstre3+b7v+z4WC+muzudzvu/7vo/t7W2e97zn8ZrXvObaH/yTFN1f1A4dHmtok8+Ldc3a0SkvTe9gQwdo4HPFcW794jHWbm8wp/dE1+Gc6C3yXIquvMDPcym4A4NqrUyxDj+dYc9tS0BbL0OvjdDra+J2ZYWMLO1MUZK14K1r5/aFnKg0wfczfFsMql4mgvYwWNnw+ukMqpp6PcUeXZfQwaW1al6gpnNJa9dSZNbDEBs9POemZbG+HA9ygaIaRditEWo0aMfPWtLjHX6+INhbEE0sQd6ubp8HFyia1MixGS1f7fkMd3MhDPWDV/QuUNQDQ7PRww/7co6slxyWPEftTgjv3cWM56h6vyN0sWNzgZCtRzIB/mJQDkzlMTO55kTgHUmuzEw6X7rfW9k2+6YRZ7bpHD9vr1WtUa0jjbIWH2jUcABBgC9K0XYsxeVtQYLz+DzHbe/g5gvRJZUNwc6cYHuG2ZvB7liuQcBHAd4oCSbc3sXf+WXsqXuwY8k18NZid3YZfWaXwccS/ufe0yi9Y+Fq9lzKid4exdGmNRdQnTVvhw4PgQ9/+MNsbW2tvt773vcC8Au/8AsHHj916tRqm6NHj/Jbv/VbRFHEm970Jo4fP87LXvYyjh07xq//+q+TZRnvfe97OXTo0IH3Gg6HvPe97yVJEv71v/7XXHfddbzkJS/hhhtu4MMf/jAnT57kXe961wP20RjD+973PtbX13n/+9/P8ePHeclLXsJ1113H+9//fjY2Nvid3/kdtO7K5GuFbgSrw8NCl2Z7bVBnmtkNnq89cjcDXaMJWXjD/zj7NDY+buh/5jR+NpdcjcBIKOBsLpkdgK4qlHcy8lPXQgzSBOpAxmG0FqF40jpYeS8ShNYlS0URxJGQiaoWEuK8dFnSFPISP53hlnkLOsMbJcJ1Ky5bqqoxeS0ko5eilyNXxoiIOArxWUy9kbZjUFevqF4me9cDAzojHEbovMFMCxmlahpcOUfdfZqsqKiPrVEcjnFG7xf3S23JoYyoKGF3jMoy3KiPjw2qdpjKX9TRavUaqaYahZhZiKoa6cLUNVgn+zBfwJEtXGT27ZQvckxwMN/k/j97pCD2x55wZtFle30U+0YIq1HA1mrZz+aiyYhjSAwUpWTMLK2EZwt03eAHmWg2nMNPZnLtLfM7GkBpMTsIAjCm7d4t5Jp2rjVVaMe9ggDqWhzYjBFzhCgEbcDPRStijGhSADWZk53e4It7h7jvmOGQbrBe85R0m97hOcXGiHiiOi3INUR3P3l4eKxoQOq6Znt7+wGPLxaLVacBDgrKAb71W7+Vj370o/yLf/Ev+NCHPsQnPvEJDh06xKtf/Wp+5md+5qIOWd/wDd/ARz/6Ud785jfzwQ9+kE996lNcd911vPa1r+VNb3rTRcMGn/e853HLLbfwT//pP+WP/uiP+NSnPsWhQ4f4ju/4Dn72Z3+W66+//rKPvcOloyMgHa4YXZrtNUCbfF6uKYbP3OG1m39FiGfhaz5THeeLdx/m5B01TGayIu8cftG6TSmNCtU+UWhdQ1Qcy9gKyPx6KwL2kyl+V0alVBTi2yLO5YWItdfXpGhTSjoXxkjnoKpWs/sYI6MweQkq2e+EVDV+UaDvnIM2qH6GO7KBDw0uMjQ9sd11kWpFzldmwftgWJKQamCoM422EaZMCOYDgmmJ2Y5WhXGwF2MGIU2iD6QTuEBR9wKiOJJV+TikWU9pekErtvfo2mPjB3HF0q07VS8iyCtx5KpFM7GEqhu0vUAU/P2wSmhv2o6NOi+h/SG6Ilf7/GoLwbRCFZUQyprWgtlAFAkZbax0zcIQNQohTcR+2WghpkbD7lheMAzwRjpMWCfXd1VLzsjS0peW4CyT4L2XjmEcymOzxer9vDFCeu516CyR6zRN8VmCNlq0Kcucm9kcmoZ4bPnSHZv8l+tewHev/RVPD3c5PLiF3adk/P5TX0q8Z8hK39nyXgN095MnDl7xilfs5wNdJp7//Ofz27/925e93XOf+9wr2u7EiRO8853vvOztOjx8dASkwxXjQmm21svjnbjwyuCVrLovjij+5pEv86L4DANtuKfxfGj8bNRORDnyxEc30edkzMQ3Mjuke6lY4y5kZEVHIWysSWE2z6XgimNUvNaGu8kqNFrLqnBZisWrlkRz30vxWSz5F3UjLlJlJWMvtRRzqt+T4jNonY2MRrUJ7BIMV6NGQ9wwo9pIaXpGnJ/MeQXzNRZRi4Ba4UKwocGFEnposwizGKAX1UoncP9t0ZLF4kPTdogsumwINKjGt6NR0UPmerhA8kfMLJTRs/URGIOuG1jkUJTo0rYjWA/GImTsKZpawokEaNXDiGpgZITtEs7lqoPi9jNGVqNrXDpRUdZjpgV+dywal8FAOmqBkS7PbIGbzeUay1L80UPYUYIuG+l2pJHY405FoO8LCQr01spXW8CoKJLrsSxXYZm+quVabTUlqmjDxLSW6y1L0ItifzRMayE/YSDX67CPP7JBPUwweY1pO33RbsXwCz0+cNNz+ZbhLZwwDkfNc7J7+NDJXeb3bBFPNGpuHwFz0icXuvvJw8djpQPSocOloCMgHa4YXZrtVUabfJ5vaaqn57x0eAeJUtzTeP5o9jxu/uxz2Pi0IjtTisi2LMV6N0tlxde5fVIBIuR1bYDc0rWqXWX3TSN2qUvnj7oCrdBZJna8/QyfhKiyRk1mQia8kxyFXNygqCpYqNUIFyD2tWUrAHZeRl7WhpSHMupBgI0U/iL2tdcSq/czErCnE41yHpuG2EwcuJr+hRPOXaioNlPifAjjKcGZsazeBwa70ZMuSCNidsWFj823RAbHSh/BUpANkCa42OzbEV8AykvXId6T7Be1O4E4Quc9VJNRbAZClh7k3K5CFmtPMHcEuVwrTWaoexLOeLFjeOAxKVw/wYwGYlRQ16h2tI5Q4Z2T7lmWiv3uVNzVZETPC2moa9wiX+XMeGPk+jVGtgXRiLS6C9UGCeKsPO/IIewoRRc1eiadOx8ISXGDVFy5qhqfJbKPexO5LrMEn0ZChiZ5q2+qCe/dZf2LEV969hZ/+ZSTmPQOMgVPjc7wwkP38MGnrBHvGQanPMa7rgtyFdHdTzp0eHKhIyAdrhhdmu3Vh4sU1Uhx9NCYG8JtTLvOeroeEtwbs/6FguiOM6sAPzXoS2aC91BVeOvEWShuNRzOy2q081LsFeXqvVSaiHWu97jtQsLj0nS1oixdkxK7WKwCDiVMToILdS/bz2uYL/Dey2NLG0Rr0YM+dpBgE/OokY/7wxuFjTXKArF0ZGTfHthB8O2IUzUKCOYZwWyBjyPcQITTOE80qVEuwI8CXLDvpHX+ayjaMalAi/ahbtDDCD9oO0ihwYb6Ic+NbjzRdg6nz4ldbRShG0sQB+i1AHcJeVmm9iK8n9YE4xxVVATrPTicUQ2NiNwvAS5UlBsxSZmhTku3QYHYKzsvHYfNNXnyeIZfFEJu01iK/2mOXyyEQCu1GunzILa8xkjXo2nkOVsb0slYEt5GOiVmLt0PHxgZ2wJJUG8JjG87Msp5vPP4xQLKEl3Vcv1HoWSC5AV+Z4/szoT+rVv8P89+AU8/cR/HwwW9aMq3b/0l7oWKPyueS7Kr0buPRETbkwfd/eThw3P1gwM7it3hWqEjIB2uGF2a7dWFM2Ijmx92fP3m3Twl2CXTITu14U/vfRqDOyD68o7Y4BrTCtCDlfMVyGqxiiOxmgXJYVgWcL1sP4E6TcWxyGjUPBeHoSCQlHLr4L6zuEVb4GaZjNj0e1IUTudiu9tLW+JTS+GpNW5rhNcaXcocv+3H1KNYVv8fI9WaV9IF8T19Xs7G/s8egPb5Ng0w/QzXj3GhweQ1Oq9Ev7HRxybZSsR+off0RmHTkLDfFxF6mkjB3Nr7XtrOg6qtjCB5L0S0rFoHrQffdNn9CHJHfHqOylu75KpGlRZtvZCnS9mNlpg1mcFlEUEg+g1vHczmQkCObuHSED0r9wMu22NV1su4VrSBjwNUUaPnubhkVbVolpYBlXku3aI0lv2tG9k2jVE7Y9zpc9JpCwKx7A2MXMNNI4QlEJ2SvLcTIh3K742aevzGCJ/GaNbkPfOSjS803PK0p3DnkS1eHt9LrEK+LpmydvhDfOzk9ZSfWyOaKjmnXRfkqqC7nzx8dCNYHR5P6AhIhytGl2Z7FaFFkL04qolvHPNVw1vpacfUVXxk8Xz2PnqIk381xZ05J+nQoXQ0lFKyerzsTARGBM5lBc6ukqPV5gZ+1BeyYR1ubYDrR5hpid+bSFGoFC40EBpUmqCNQQ37+CSWVfs4wiuFbkdafKDRYxkn8sM+bpBQj2JstAzVaIvuSMlo0DUOzbtktLoTb9R+qjcX37eVm1ViCAYJeE9wdiLi6SAQ3UGRoCuPSrhwB6Et2H2kVyTPO4fam4r2YWsd6F3Svrs0RGepkBilRNBtHvzELsmHcqBrj96bCRnNhEjaUfKAVPVL2pcAIWbDnhgZtGGPlBW+bjA7bYZMmqwc1RQtyYkjfCgkww0SVBTKiFZjpatW16IJWWpByho/neKrGj0atnqOQIwTlloTkA5gLxMyVOetg9u+A5vKUlSatCGJpVhUay1jWlGIykuyu6asfXKdd930N3nq036PF0QFtXckynNibY/bjq6T7Gjisb3o6elweejuJx06PLnQEZAODwtdmu1VQKv9qHuaxTHHVxw6g/WKT1VbGDz/e3yS7B4wOzPcshgLAhkbycR5ShXlygHIzxcyimX0vs2otZI9sWg7JXUDRDTDhKBZlwT0pkHvTGUVWGtYH2E3B9gkINyew7ldCSNUCnoyNoN1+EFGdaRPNQqw0cEi9nyR+aNJPlaWteeF8bk2TwMuUfMQSAcDkFX9tphm0BeRukfGfC5GBpTCGY3LIiEttZXPoQ3OupSQQGfApiEmifGteZToR4L947vQ8bTOWcqJeJym1VAohcti6kGIjS/fCtm3rm0+CvBRgO1FqMYRnJvK2FXbbfNZIu+ZxrgspllPMYsGc2ZPnK42Ru0InJLnOofKSzyFmCIYLeN/bbfBFyXcV0qq/HCwf90vLXqDAHyNryV7xDuPjkIhH0m8/5H0e9j1gQR1Tucr22C1KNn4Qsm9f3acfz94Bf/k+P+LRTHxMS9ev4vPPf0o5d0J0aQTo19NdPeTh4euA9Lh8YSOgHTo8BiACxXFmsZtlTxrcJobwh3ubtb5/+08l4985qlcd1bE4yoK8a1Il3bUSjm3yj7w84WMuxiDGgxQg55YneYlfjyVcS3vUc5irJXuhnMQhWJJmxetha+MZzW9kHJdiu4oL1faE0AsdY+uU63HVEODDR/aCvZRxXlFuHQk1CXrHVDyGS3td4OkzZRQCj/PpbhtEh4s23XVbdEaGocez2UFvpfh0mhlpfvg+yH6FR9LHouKI0kBjw269phWZH/gZVrxelB4goUl2m5HnYIAN0ip1xOaTAshuwz483bXa42ylmB3IQnztu1iNI2MQ83mKxtdnSSEjRAMd3Zbuji9VM5n3aAaix/2cL0EPQ5WVslLxzc9HKKSWLQcTQNJIiOFTsiHGvRkRMt7dBDg9sbi8GadOI5VtYwvJrGcR7t0H0PIUJagrCP+0g7rm0f41EuPMz0acsTUDIIZa6O/4nMnj/L50TPx93RjWB06dOhwJegISIcOjwE0qaY4BKP1OYejCQNdsGlmfPrsMTb/MmDwBek+YAw6TVDrI8lTWBT4RQ5liWtHXFC6zUhw+Gk7IlWLQF2vr8k4VVGKw9U8l6C3Qub0vfOYMMAPeri1Hq7taJSbIU12CFNtggcXaVwoo1U20pLQ/VglHi2U37eefUCX5hKwTCQ3lRedy3DQ5rAUok14iG2Vas9boAnmpRTbbUhjvZHRZBd24Tr4QkKgfBSi+z35Pq8IdzXBwlD3Q2xqViNv0GaG1PIV7hXo0zviZrY5oNrMqNaClYXv5XyG5wci6qJCTYQooBWkojkiz/GtFa4yWjI8KKDurZLNfVWjzu2IhbRrDROyBMLWzldJ98PntWiRAoPvp5Al0vUrS3G/ahohE0ksJKIVouv11na6/R2QnVbi1gXo3ZnoROIIP54KWWmDDNOzFffcO+QTzzzBN/XuoK9CQlXztN5ZPjl8JjbpLHk7PHbQdUA6PJ7QEZAOl4wupfYaoB2/KoeK8qaC/8/1t/Kc+G4Mno8ubmTv1BpPuatGnd4WUXiaSM5BX1yYlPeQF7iylBXgMEAf3hLnn70JfrFAD/oQpBI8WFaoLJFchaqSNPPWVlcFoQQZxjF2s0+5HmMTjTeKJlTUqV5pCe6f4fF4uEcd0HsYdXl6hxamckTn5qiFFL1Yh+ql2I0+NjGixXmw9zcKZR1qupDt01ZLUzt07VGxelARuNfSASHQ+45kiwKTl/gswewC7ZiX7Um4pC4tZlGhGifdiTSB9SHV4T7VWkATX2Hnqu0omUKE4YSBGBXUdduZiMVCt24k18M5Ib/Woqdzsec9fkSS1Gdz6WgAaI0uSjm+MBDiUijJoskk0NKmIcHZyaqT44d90UPNFvg8R9c1vqzwQYDqZ9JdcSlqqQeJQiGNixw3XwiZW3YUtV4RGpM3RGdjPjx+Ol+d3kGlKr7UZJytBtRDRznQmNx1XZBriO6+06HDExMdAelwSehSaq8dXCjWuzcc2+Fvjz7N86NdTtmYP7rnOQy/YEhOT4HWNjeOZeX2PItRNehjtjZkNX46E3EuiH1pGGCv28KHBvP5HLe7i9YbMoJSeBnnaqGMhLj5IxuU6zF1Xx8o1P1KPXze948nqH3i4TWXXXR7jRTds0LInDGrDobthbjowUmN8qK/0IUU6L6XQhSiZwWqtthYsjgu+v4KMND0NE0/IpyHrZZkISGTgcFPZ1DVmOFAgimdky5ZWYpDVBJLKGTb+bhS8rHsJgULh5kWqLyULkJg5NjyXAjWoAfDHjovxeZ2IR03u70rye/rQ9yojxr20Iv2vFZiorAkAivheBiC0fjGEYxzOLcj3ZOjh2kODVDWEVQ1fm8s+Tj9npyTRS6vlSYy/lZWIpZvJOxQj4ay37Vk4/h+Jhkl4wlme8bwjh4fPnUj37pxiOdGZwB4Ru8+bnnGcWbnDpGMFXrRkY9rge6+c3noOiAdHk+4gjXADk9GXCilVnnP62//4KO8Z49vLMXnxZbnqcNznAj2SJRmx/a55951Rrc36HNjySs4soXbHOKzGB+0IuZCUrxdP5GCVinYm6JmCxldAVn5pnUH6vf206OjEJ0m6DRFZxl6bYQ/tkV+3YB6YA44V/nzOh3+SlbLH2Ws9lu3LlVXcgyt/sINJFgPa2XVXCtUcwn+tUsNSn2e5qCxUmwvCnRlL02IHijqUUizNZAMkaYR7cIil1X/ppHX10p0Fntj+T6O8FGIDzQ21Vc0dnU+tPUEuUUtSnnv8QS/u4ebzXF5gR9PUM7TrGfUx9dhY4Tu99CDASoMcJMJnN1BlRUuDbEbfdhYawmBuFvR2gR7Iy5VvijhjlP42++S/7eZM7psMOMcP5nKe3uParNEKEsZM5wv8NM5fjoTwmQdKorww56cl6YRIjdrneOyFFVUDL9UUX2pzxfKY1Rec1Ow4O8Nb+H1J/83+cmaYs2IfudBul8drgzdfadDhycuug5Ih0tCl1J7beA1FOsKe6Lg5aPb2dANhYe763XMuYh4R4oh10vxsQTWudgQjEvU7gQ3m4vwtijahGkn7lj9DPoZ7Oyh7rgbkybtSEws41nLDIkwQvf7+F5KdahPtR5RZ/oxERh4LfBwjmmV5dGPUfNMCtVlurzzKOdR/sJJ5KodW3OhwvViGZU6s40a9EWvkJeYUojJxV5jtf8a6kyjmhAzLVFNI+YCTSOBkWEAYYDLIkxRSRp40gYnBoZmENMkl+94deBYPCiLkCbr8FGICkOxzi1L6dR5D4scM0nwaYgqKvl5L5PMjroSkjRbYIoKP8hoDg9lN/dysZLuR6jZQs51EODzApcXMmqYJjL2lBfosYyieW0woyG+FOKlwgDiWPYtz8WuF9BhANpIonpVrUTzBAG+sTDo4Y6uo2qLyRuSMzF/uXeSp0TneFZ0moFq2AhmHDq+x+zEIaKpJpp2lrxXG9195/LgvcJf5T/cV/v1OnRYoiMgHS4JXUrtNYCW9O1iU3HTsXMMdU7tIdKKqUsI5wpdNqtQQT1eSMcjMFKIzeYSSDgaAMj41VzcfnQqFr0qinDzxX5GgtZiy0sr5ehn2K0h1XpM3W/Tyh8reR3XAMsOw5Uen3IevZCgPD/oSbfJe/QwlWT1BxVwgI019ShGL0Yr+13CQDQU5+3f+Z2QC+2rC5R0MQYx4WK4Kv6hQKUJPjDoaSEZHM7vF+NReMX6lwPnwUueiJmV0qkY9nG9pN1fJedkItedXhRiyTueCHlYmin0MghD6WQ4h4+GlOsR3kBvXqEntWTPLPUaTXuOzL5dl/ce8ly0UGGIv+4Q3ijM6b39DByl5HeozSZRbadCZUJg/HgioYS9TAhhFGLXM2wSEJ2tCO+dc+gTIR87/HROvGKXZ2yc4ZTrs2czvvroHfw/z+xTfjkhnLcZ1J0W5Kqhu+9cHhzqqiehX+3X69BhiY6AdLgkdCm11wbegI09aVCzZzPOupixc9wyPUG8DTqv8UmET0P0PMft7AKtHiQMJO/DOprrNlCbA/QXT+EWCxkzqWUWf5WYPZvLHHw/w40ybBrSZKYdx9GrXIwnIvk4PwcEzrOPvYRjPeD21Hj0dCGBjiAZE2WJ7qXorfSCSeJLvYSpPNG4IdpeiGNU3eDtXHI7hj2aXigb+/N28AJY2t/aSFOtR/honWA3Qd1zVrQPyxG7vMSP+jDqo85si1jbaHRp0TbAhZdy5i78/miwiaI4PsBsZnil8IFkgqAQu99FCUkkGSl3n5HrsjVKUFk7Lug9atCTMSvn8KZNpjcy0uSVQjcWP2/T1dtMEBmXKkXnEccSJJhE4Bw6b0MMk1gCMpNQTAOalnwoLdoRrfG9WAiMVpJXYoSZ6UUl3aXxDMKAcFIz/GLIXzz3JF8//DyRstTecDI5x7GtMZP1lHRHEeQd+bia6O47HTo8cdERkA6XhC6l9urDa0WTaGwCa9GCE9E2a7riQ4un86effwbXn2qgsfgkRE9yyCVEENeGu6WxpJIXJbpopGgzRix4m2Y1D7/MX3B1gzEGH0cUh1Lqvj6QPfFEJB7nQ1kwtTAEFyqcuUho3/L5S+LhlgTCoWsnQuY23NG3GRLKWtHatOr2A8GHTt433quJTs/E+jiNhRjkJX46R81yzCDBDALR3lxKMKKW41CNRxW1jOJFkXRDWjG4muf4JBZ3qrJC7U0JlaIehtjIwBV2u7wCGynsukE5046fsXIB81oRjDL0rECP57hFLhbP/R4c3sT3EpgXMpZlNMrLMZjSi9NXFqHW+vJmbReHKGy1LRrvWgeyZTevqtrXqKQjkybYzQHNIEaXlnBniqsqdJZBHOOLAr83QRWxaGbiGIyWtPVEoaft71tL5sy0JDubcPepTT59/AR/a/BpnhPfTeFDbhjs8tFDR6jv1ZiiWy++mujuO5eHToTe4fGEjoB0uGR0KbVXEVpC8OpM4TLHRrTgpmCHI0bz6fl19D4b07tjFzWdo/JAxleqSrZt3YAIg5X+QO/NJNvAWlSayP/b8DedZfJ+RSkjOEmAi9WKfDzR7y+q1SuEc0e8K0GM1VpE3Te4i/wFPL9rESwcprCYokE1jmarjy4TzBmJIldpAmGAtm3IIed1PPYagkWNKi16lsPuWDpSG2vYXoQONGo6x+2NMXFIMIhoErFmfrDP5XwLZDMrYXcijZM4ktT7opJCfTyBeQC9DF+UuNkc4z3hZg+b7AvR7181XxIBWm7XamPOR5Npys2EdJLjd/bE8GA5ChWFElyolIyN1bVct1qT3DPFRxL26EMD1st4lhfxsa/qlc5Fp4mQrbLCT1tXsihCDfvYQyOKQwkuVMR7Hh+H7e+FFmcs57DjCWoRyO/HsI9LIyFyldgC0zSotRFeK/Q8p3cqZPjZATff8Bxe2f8sz4l2WXjF16zfysefdj35PQPicRdMeLXR3Xc6dHhioiMgHTo8SrCRpthUmPWSUZDjUHy5gY+dO8HwToc+NxY7U5CcD5CiK0mgsaidsYSvhSFYJ2GC1spIyhLGSLZBEEh3pJeJg5aVIvvJQD7w0oGIpjXB2SmqqtHlAMioBgbuJ7hfbVNK1yKYlOhpgSorMAZ3dIRLQnQaS8aKUqK7qZwQkHZUKxo3xF/eg7M7MqoFMnakNercLkHdtN0UDVkqn9Xl1K3Lwl8pEVMrta8FmS9kVV/p1kWqRMUR2jt8XROMcxLvcZGRrBet8IGMP4mjk7zFJROR+8EZCdd0gwSzGEp3oQ0G9I1FVzVM59JlSBPRXhiN3p6sLIP9+hAXi9Uw1uIrhER7h4pSST+HVeK6r2q09yjXw4UaFylsqGjSgCCL0bYvmSSTqYQXInoS1e/RbPZxsSE86/A7exKoaAzMc1QSg3OYL53mcGS4/SlH+MSJG3hK/wscN4a/3fs8t990iP/yhZcz+LIkwj/Bf606PEbRidA7PJ7QEZAOHR4luFBRbnhOHtnmGcl97LmYP54+n3v++hBPO5VLIdbvS1bEpM0C6WX4MJDRmrKSEZE4ElH63liyPJaBakbjpjNJok5i0AZflJidOWESYKMQGz/xby6m9oQzi5lUrS6mwNzXEIcGFyXUqX5AB0A5MIVDF1LYo5R0m8qK8K4atzmkPjyQwvbsnti6ehkZWmpFTGFXad/Lf1WaCuFoGihKyFL8xgiXhtSjhGoUPKCb8FDwRqHDcEVuaBrcYgFlKQJsLUWxXx+JLmI8RW9PiM7sCqFaH+L6kVjdBoq6H1BnknR/xWgdv6qNhLgeyEhTEIieKQnR0zYhHWDQo9ka4LXCTEr03lS6D0UlPMg5SZ1PE/zeRDo8WSodnqIQBzClUQbR1eQ5Om/QdYSNxO1LWS9jaUbDbDlz6OSchQFeKcysgjPb+NlcPqcgwC8W+MUCZcTuOLrjDP07T/KXkxv52uxWNozhKYHhpf07+L2Nl1BnmiC/X2BOhw4dOnR4ADoC0qHDI43zxmtMIf85GuxxZ32I933xK1n/jMbM26Rt70VcG6yJE1BVw2ImlrrrSWun2zoEaYXqZdQntrBZQHzfDFXXUmQZCWSjtUmNlMIm67jggR2AJxKUgyB3hHsleirifF+K45FeVAQLKVLd/UfRFPhA0QxCcAFxbYX0eQ/zBaqXwjDBtwW+T2OafniwaHceVda4poEwbNO4PT4vRKeTJtiNPvUwpukZmuTSx+JWifQebBpishR/bkfS7ZduUWp5kRnpitUNfi5BgD7PpWvTS1HDHt5ozKxEj+eY9QEcy6iGD08j4gzUPYMZJoTzQjQas4U4Yun2mixL1O4YE0c0w0QS3kGu1UUuRAOEqKUxqhLnMJ/Jta+iUMhCXeNr0UOhNGhQjUc3HhcpmrWU4HQl5gG9Htp5IWltdyXYFm2Onc7kcwPpKi3zRIJAOi2LnPSs45PnjrN3OCYAjNIcCiYEaxXVICXZA+VUN4bV4RFHpwHp8HhCR0A6XBDP27vzgPDvPTe9skuevYrwWlGniuJ4zUs3vsRRM2Pb9sn3Eg7dbdGThazmqhKaFDeQFGc9Xshcf1nuj1alCWyuY9IUXxQEewuCiZYRLWulEDJOOiKVx89z9M6YeJDggoy6r6+40HwsY5VX0Xh01WY0eC+FeRJjezEuUCjrxR3p/NBFTUsIDKZy+EAKVUopcNV4SjRv077DALuW0WStkxjt+1on2pDNdelaNRbyApXEuENrVJsZdS/AtsTjcu2PlRMrXOVancR55ANjxKigaVBGS5csDMSutixXjlQ4j8pLwntrCemrK3QYEOQxzXlhhVf2AUgXxKaG0BjpVuSFaDiiENXvoeNIOnllha5DVG3xZSV2vVEoInPnhIwscnxRSK6HdatwwuXnCqAnczAam4YEhUXXHhvLiBlKSVcjDqGq0UhHceUYtsj3SYO1gLy3L0tUEKBHQ3xd07+74vY71rntaYf5G7Ekox8yc55+7Ax3HDlJ77RG110myLVEd3/q0OHxj46AdHgAnrd3J2/76DtXCbQb5ZQX79zGT7zkjd0f+asEbxT1QLFxfMxTkzN8oryePxs/A7MXYGNPeXKLKEtQuxP8eIopK8lDKCq8czKfboxkHyQRLovQgWk7HLUUXN5DKI5YKkvx/Qy9M4a6Ej3A3pwoCXBRTBM/jELzMYzlOBSAz2K0HeBnC2gsumqASIp/tf/85f9d0OZZ1B69qGTUpy3s5QU9vpdi1zKqjQQb7Y9yea1wcSCp6YtSCuYwgKCHjyPKo32qocGGV+5CphtPOGsIzs3w46noIFqbW50mMoqnFWrQpz4ywuS1ELCNNelGWCtGBqWYG6jAQNzHA7q0mKp15Lry048zQkJ8GIjjWN0IKS7FwcpHoXQXQHQ2swXeO+kWgZCPOGp1Lm4/Qb6qxYY6MOKGlUvH0BcFKgwJJoUkzteNEIxG/u+TCN9L2u7QQLJLnAMHOjBo3zrM9VJU3YDR0rEKDH5jhNqbEp2Zkd6zxZerTRruxaA5aizfePizvP3Y9dgvaILFE/LX6TGB7v50cXQakA6PJzzMOKrHDu644w7e+c538sY3vpEXvOAFBEGAUoo3v/nNF93m4x//OD/7sz/L13/917O1tUUYhhw+fJhXvepV/P7v//5Ft3v3u9+NUupBv26++eZrcZiPCF5/+wdXf9xB/NeV97z+9g8+ynv2xIE30CSwlhYMTM7UJsybGDu07DzLcN/LE8bP28AdXhe3oNlcnI1AchRGQ1m91aJNULUVYbrWUmQ2Fm+djJHY8768E1LSWo4G05Jg4dD2YPjdEwIt+VC2JSChwW704fAGvpdCq/MISjn+8yvtpcOTV6xGqfzSDtZaKUyzBDdIqIcRdU+6HyvyEirqQSBjRVrDIt/XaLT2uUvyseq6XCKWDl1B4Qh3FrCztzIrWMEYEXdHEViHWVQSDAi4fobu99BHD8PWhjw/TUSLsjbAxxFmUhLtVnL+rvC6WJ5DG0lg4jKNXRmDHkh4ppvOpKs0ncP2Lm5v3I5WRRKc6L0I16NQuh1rw5XN9FKXo9p8HD+bCXnoZ3KsZ7bxX74Xf/d9InY3uiUjosfxaYRLAlTjZLRLKdRggDu0hs/EyEElCXp9Dd/P2i5TjdoZ07/b8xe7N3J7XVP6mpGO+BvpbWSH5tSZuJihu8LtWqC7P10cvh3BuppfHQHpcK3whOmAvP3tb+ftb3/7JT//tttu40UvetHq+xtvvJGTJ09y++23c/PNN3PzzTfzvd/7vbzrXe9C6wvztMOHD/P0pz/9gj9bX1+/vAN4DOGm2ekDybMgf+Rvmp1+lPboCYh2zKcXVjw1PMsNwQ7n+gPuvGGD+/pD7CLA6whlh/TSELM9k4Tpxq7GSJTzQkzKCrWQvAKicF8T4ixuJoF3Ki9Qe2IBq/u9dhxFo/KKcFJhkxhn9IPmYjyesLLRLR2qcUI+YoNNDC7U7XiWkBNTeJzxcAHxtzdKtuknqN0A344vqShCZSmmsZg0hNHBP6VLFyhlDWqjh+5LWJ6qLS4yK63IpZ7r80mAshCUjmivRm9PcK1jkwpDqCTt21e1rMAbIyN7O7s4QA8HYke7DO5rwwB9YMT2tnHi4jTLCZ2jWo8OdGmuBC5U1KMIsz5EN4105NJUUtLDAIJARgm1lmMwrVi8DR7ECcnAe+mGhAEEBq+VmApUtWw7GOA2BkIkxnN8VePKEp2m0ikMA7HYnQjp0b0eqkhRiwI/m4mN8doIHwXoeSm/W0myrzfZm660K+l2w2fuOsafH76JNX0rRikqegTGYePWncw+0Rj9YwPd/alDhycGnjAEZGtri2/5lm/hZS97GS996Uv51V/9Vd7//vdf9Pnee44dO8ZP/MRP8PrXv55jx44B4JzjV37lV/gH/+Af8Ou//uu85CUv4Ud/9Ecv+BqvetWrePe7330tDudRxe39I2yU0wN/5C2K2/tHHsW9euLBK4h0Q6YadnzAqWIdDwx6BUUYkl9v0LVB+ZRe4zCn9/DTaTt6FeDbsRI7m8uM+qCPH7TkwqQyZqRUu1osGgYVhbA2xGWxdAbKCjMpCfohNlQPz/noMYKl9kOcqBzKQ9MPqfsBTSquSCDPWRb2F0qBPz/xu1lPCRdrqO09lHdyPvMCby3BrEcwCnGh2Oguk8qX71OPImwcE00aVG1o2nN9KUX96ljsMgjRo5ajV2en+OkMV5ToJJbP1tqWgFT4qXQE1KAP0xkuL7DndkR4nqawvSfHELa3gbYToKpaxpJUq49xDzw3lwqvwAVQDTT+xIBoGGMmpRT9QYIbbGLTEB9qIdjOoxqHrixmXqEm81UnYSlMZ3NNsnDO7eGX9sOxdPX03kwIuFKiIQlCfFXh9sbotRGEgSSgt6YMCvD9TEaspjPRoiwq6XgBBEa0PAsxIPBHNigP9ZgfDnBzxacW1/P85BQRjlP1Jh5oUrE0prr889XhodHdny6Odl3lqr9mhw7XAk8YAvKmN73pwPfvfe97H/T5119/PbfeeitZlh14XGvNj/7oj/KZz3yGd7zjHbzzne+8KAF5ouI9N72SF+/chvWysmRReKX4jZu+4dHetScMvJLAsu2ix5eadeYuZlonWKfR2mGMwycWmxqaWGGTAB2HkEueB1qDl/wDnJesAqVgbyo5CYGsLDMcYEc9dNWgdsa4zTV8aNBFtbIgVc4RTiqaNDmQjP54xjIIUJfiZGQjjY3VAaKh/MGb64UKbCmgFdUwxMwyTFnjhz18oMVatqphURKOxU2rSdSqi+SNoskM4dySni4x2zNUXhKsDXAnh1SBetCO0/lhiNFeQ7STo2btKBeg8hLnvWgprAjcAXTUZmfAfpdjLqGUGIMaDLBH19G7M1nlDwPUopBOSBbjhimqaPCxufCOXSb80pJ3aGiyBH0oRtdiu+ui5WeyFMJ4tIVg4Yidx+w0+Maikhg17Ev34twOgAjVjRGL3jDEz2UMTRm9ysfRo4G4nmUpbmNAvZ6KbXFpCWYVlDU+CsQaWCn89i7MF6tOB8a03UaHaizVZsa558VMn2aJN3L+enKY/x49h/+j/1meFd3Ls7bOcMvmGs3dmmDhrsr563AQ3f2pQ4cnBp4wBORykbTzyBfDN37jN/KOd7yDv/7rv36E9uixg0+vneQnXvLGAy4jv3HTN/CZtac82rv2hIHXsjK8Hi84HoyZuoiteMaXzRpVY6hrg54GBHNZ/daNk1XZpcvRuV0JmLNWVoiXBVxZ7ocW9nuQxkI+FoUUckWJnjv8ZNq6Y2lUHKNDg27ii+zt4xBKdDaArKovbWvPw6Wu6Hst41TVekLkAKPQeS2r4oscZjOiugHWKbcimqR1FWu1Hqa0BF/exu3uyQhcGGCqPsrp1T4+YPfP03nE2zXhtmiA/DKYz3vRP2TpSltBK6CmrkVb4T0E8gbeSjFsNtZprtug7ockszZxfL4QsXZRoGeSVI5SONO7rFP+oOdQAQasUQ+RPaNwAXitCeYhRmtARgp9JUYAysgxLbt+JDEUJb4o0MMBPktQ07m4axktBCWOcKHBxpomM0BAmAVE2zlmWzJ2aGz7+6TBtla81qJm8jvXHN9g55kt+Ti6II0rdouUj+yeRCvHV2df5MWju/jL4yepb4skFR06O96rjO7+dHE4FOoqryC5J8KKVIfHJJ60BOShUBSympguHW8ugFtuuYXXve513HfffQyHQ77yK7+S7/7u7+apT33qI7Wb1wyfXjvJ//Wi73+0d+MJCa/Axop66ImMpfaaga5YDxfUTjOdpTSzkPScJhqLC5OyfjVKpZJEikajMVubMjrSNDIi0jTtqFW0SkgnL2WOPomlBm9EkO6tQyFBhs0gFhenJwCWo1Oyiq1QhcPkFtW78hV9Z6BaC3Bxhi4dkfcYZBXeNzXaOkKjUX5EsRVRZ/o8gblqDQAkU8In0QU7MAcPQshHcrYivHdPCEIYQN2IDmiJ9vNGtZ+d0eCDNjm8Ri8d0awV213vMdMSMymkmxIE4u4VSmfNFyV+MpXrp5e29rXy0hcSo1/OWJa//+ucNwJ3vuhfIV2nJjOE/UzcqOoGqkoIBzJCq7UWLctsLqGG3u93fhoJJJSkeQO9FJQSS2UjnRevFThk26qGJaFRStLkm0Z+z6xDrQ3Jj6fMT4DZLInCBqU81mkC7dgwc0JleUl2O88++XROfeYk2RmFqTrycS3Q3Z86dHj8oyMgF8Hv/u7vAvA1X/M1F33OJz7xCT7xiU+svv+DP/gD/tk/+2f8/M//PP/4H//ja72LHR6P0ApvFIvDmvRZu7xsdCe1N1gUI5MzWSSou1KyiSLe8cRTTzhtRBTrHCqO8EkkNWEYyPz+fC4BbO0ojm+D1Lz3Ury1Tll4L6votbg5qSCQZPU4RFnf2tWqA1a0jxVcSfHrDNjYoEuLsq51dFKXfWz7bk4KGxq0FSF7Wq+jywo3bVPqG4uZlQS9ABvrdiUfmtQQHlqTglkpXBTsd6wucqzKQTCzBKfH+HM7bZhg1AbuNajhAJ+2HaswWqXeM56KxfL6mgi2nUPllWTGWIvbG6Na210P+7bC2sgYX5pAK75uBnFbqLf75eRr5UylWfkoXpaYfqlpKR2m9ELIkzZz5PwcFY9cu7UI12nHCn1dC+kKQwkfzAsZuVJKbKjDAAZ9VL8nY1lVjWoselERLSqCJMD2I8mHmcnPfZ6jRkP8+lD2cyZhjSoIYJBg1/o0scYmnihqMFo6Slp5jiYT/kZ6B4eMw/qSr9/6Iu88dgPVPZpkp81p6dDhEUBnw9vh8YSOgFwAf/zHf8x//s//GYCf/umffsDP19bW+LEf+zG+8zu/k6c97WmMRiM+97nP8da3vpX3vOc9vOlNb2I0Gj2kdqQsS8p2XAZgMplc1ePo8NiEixT5Ec8PPPWjfMfwk9QeTtk+p+sh+ZcHHP6UJ1w4SfCeVATbYlHqy7aQnC2kAEwiEckOBvt5H2EAaZu3MJ5Amu6PaCmNXyxw52kFVByhZjlB3dD0NlA9/ZglH1L8yv99G7nxYPvqjaLuGZQN0Y1jmRx+pVgSEaeg7mv04R5JuSnnUes2bFC6LbpvcEaW85uepjjWJ0pCVO2wvRAb7xf2F4K2Xhy86gbfjhz5upZiPAr3P/skke8Dg2qLcYIANkb4MEDvTYW4rq+h1QQ7nki2SZpIB8xoVK8nTlKAG2Yw6tFk0b4DFktHMU84t3gtJE5bCflrUiFbq3N0ESzJh6k84cwSzhrMTPI7qq0e5XqAUwo8hAu59tXeFLe7Jy9gDF5rCVY0RghCFIlzVdsJ8rY9Z/0Ul0Sih9mdSCdjMpUAwijELDsp09lBC2PrpIsUGCHnWSLuYEhHSjUG1V6Q3itqq5k2CXsu5rgpiLXmmcm99J46Zn7POtHEYbpU9A4dOnR4ADoCcj/cddddfNd3fRcAP/zDP8zXfd3XPeA5r3nNa3jNa15z4LEXvvCF/MZv/Aabm5u87W1v401vehPf+73fy6D1u78QfuEXfoGf//mfv6r7f6XokmUfGTijqPqapu/QyjF1moF27Ng+H7jjuWzeolj/zBicQ09z/N5ERmS0ltn+opQCTGt0FGJHGSoaovJKdB5VJTkJRYnb3cWNJyit0GsjVD+TleSWgHjrRKAbBNJNCfRlZ1JcaxwY13HsZ3oYES9fjISsHKxiRTUM2jTzhxh7ugy4QFGNApQfEQ4SCdErSigqgtBgBgEuMNKFCRV+FNBkRqyTjWSAXDT53O93GnwcodaGQiCrGk8uK/tKoaYLcasqStFFpKkUuk2DmsxQ3q8E2EJYAkl8d14K9SCQrkcUigtUGOCSkGo9xiZaAgTP634EC0t8ZoE3kqWhx3Ps+oDySEbd12Jg8BAdEVN54t2G6MwcVZRyPrTClAmmMmIcUDmicSXdn/kCV9UioEcyRNRggApDGTnsZ/hea5NbNajpAr9YQJ5jQgkz9M7i54WcK5Bk80UurmFKy+/LMvjw7I4Q9jCUbhCgx3OoapIsJN7NmE8SXL/Ce6jykI/Z6/nz/tMZ9D/Dhm64KTzHt9/0cX7tzlcwuEuh6yeEr8NjGt39S+C8Ql3lP+DusXRD6PCEQkdAzsPOzg6vetWrOHfuHK94xSt461vfetmv8fM///P8u3/37xiPx3zwgx/k1a9+9UWf+zM/8zP81E/91Or7yWTCiRMnrmjfHw66ZNlHCO34VbmmUes5Bs/YxdTU3LK4gfqzQ6777By9PcH3U6hqyZwwBt3vyQp4XkgCtHViGTotZMyqKGV+vyxlRbyWVGwAby1uPEUtcnzdrCxbfdWK2tuRrMc0ztMHKAfg0bQFstp/DuwXv0sS0iQKG7VdhKsgc1npFEIhIQBR44QAFiVqURJOY7xWNJl0B1wg5HNfUPEQRM+3xgOtOxXWrjpgrp/h0xAdBlJwV5UEUEah6HwKGddj2JfvZ3O4L5drwxgZVXIONRrgo1AyNlrhuZmV6H5E01MXdERTtUWfna6uHVOUpOWI4FBPbI5b4sKFyFWra4l2cvS5XbmeR0PslizSxNul2O9uT/EzcaJSWYrRSo7JOrmWZ3O0VrCxRrM1wCUGkzeYdtSMNEblJX4u5wZoR82S1lrYSUJ8mgrxXuRyTpZuYlVL9ItCukNliS8rwi9vc+gTIaaMWRyLwMHwHkW5nvA/1p/OC5K7OBTtctxYnpd+GTeqaZKIcOZWxLnD1Ud3/9qH99fAhre7dDtcI3QEpMVsNuObvumb+OxnP8uLX/xi/vAP/5A4vnxXoOFwyHOf+1w+9rGPceuttz7oc+M4vqL3uNq4ULKs9fJ4J/S7unCRotiEk0e3eWZyD6GyfLE6zEd2TpKcU5hJIVkfRSnBaJHM8WMMSotjFWEguQ7TGToMaY6t4wNNcG6Guu9sW2RqtBedh68qXFHg6wq0QQ/7qEEf1ToH+UWODgJ0NUK1bYXH4qKX19L5UM6LuNf7lduVM+qCXZFVJsd5+vPLTR2/4L4sOyyhwiaSYUHTiE4jL4m+vIPJBxRHUqqBkX2/DPLjNdg0wAx7qMkc7/0qnE9P5/g6FlJSlJJ2rxQU7XWSpUJUshg1aYnLMtdDqdZ8ACgrVGPxRSEibe9RiwJTZkCw6oYtNUHKi/WvbxrpmGiFmy9QRUE07hH2UppDA8qNSMayLpCtsgoqCEMY9mk2pJsT7IjLF97jx1M51tEadpBIFkleoRcFfjzBLRa4yQztPGFeiibKefx0LiQsCuWYtEL1e/I7FAZQVuJatuz8mDbLZZGLG1ySyNjVRoSe5zL65WaipTIaGkv2uftIT2VUh3rYWBNvFxRHUj515AY+vXmC50e7nLWKz+bXQa1xIW3oaDeGda3Q3b86dHh8oiMgiBbj1a9+NR/5yEd4znOew8033/ygo1MPhbBt/TdLy9THOLpk2UcGXkGdKooTFa85dgsngj12bMat5RHu2l0nHYtI3OYFzPNVsBxhKMWSUvg0xo5SApAV3ukUkyW4gazurkS7YSBk5UJoU6cBiGNU65hk8gbdBFj9wJXvRwsHnJMUq46Hrj3htEYXNd5oXBxIZkqmaWIN5n6dkCuA8pI6bup2bqt9f2f2xdJeQ5NobD/CLO1gqwrqBlM3RJHBxglNfBnnVMmIV7keYuMRwbyHLhvMOIdzO7hzO6L1UXply+zb8EAZxUpQYSA5JXkhOp80BeckuHA2b7dps2DqRoTpWksieqBWepcD+2Tk+lOVOERR1dI5UFq6K1VNEBi8AlMGVANzYctd346J5WCmgYyTTebi5mZMq1nSQo6MxocKUzXiHrZxHWZvhr3vDD7PV+OJ3jlJfz/PzUslMXo0xG70UUUjhLzViazCDZf2vsj0mAraW6JSqDgWMtceq69q/N4Yzm4TnemJIURZkRab9G/f4AsvOcLtWcZ9zRqhblCxxZvgMfO79ERFd//aRydC7/B4wpOegDRNw3d8x3fwwQ9+kJtuuon/+l//K1tbW1f8etZavvCFLwASdvh4QJcs+wigHb9qMsVga87T4/vYcwkTl3Dr4jCLUwM2z4q9qllfE3efdv7dJDG+l+IDjcsiyvUYM46FmABqPMXMc1kRNwZfydiOMhpflDJDfz5cO9JTFCJeVxqahmBSEI4iXPDY64KcvxLvFejKEewuJM0bCKIIn8arFfg6O0hCLhfKg24gnFmi3Ur0FFqsW21iqAcBTSKkwoWKehhgNvqYc05G2lpNgZmVhJMAtxHiLqZV4YGdFm+gMYomNqiRwdQRcS8kAukEFKUU8VkqXa5W2+PKUmQYSuHLal8T1DRSpHsvovm0TUMPTNsZKMR2ty+247rx4kq13GcPPlDU6ylRO94kT1wegBBaNZkTLQp8lsD1Q4og2He2QqyRfRyKQ1ebTWKHMT5ex0ShkBDvoa7wY0tgrZCSuoGg/Qu1dBAzBj3oixZkOgPvcEW50otQyagZ1gtp8r59rRq0xo160M/QxogNb0v4Vd3gBxl+bSAdt7xCzXP5fbGtBXIp447eWvQsJdlZ587pJrcND+PQPCU6R3+U06SJ2P12edLXDN39q0OHxyee1ATEe88b3vAG/vAP/5Djx4/zJ3/yJxw/fvxhveZ/+A//gb29PYwxvOIVr7g6O3qN0SXLPjLwRmEjiYmauASNwyjHF8eHGN6miXcLsVZtZ9gJAkxVo3oZLtD4UMZewlkbLOgcJMlBa1LdpjdXlXQ6wrAVI5+XHeHk/6rXk05I0+AWC/TOmDgN8Sal6puHVcBfC6zGqZa6j8ZKBkRLsFQSEzgHjMBHNOm+juFyx66UhWhiSe6bo3enB8Zn3Hof6OFNsBKT21jTDGL0TLogqu1W4SDILU1lgPs5jJ0vCXHSaVFWxspseN6+G2i0wm+EODMiGqfouXQclHW4YYaLA8w4R5/Zbl9QgXeywl+WMJ22GTKxjCXFcasnSUD10OfGrUWwEXva+mB4o248qmkfs7btzAX4oll1HlQU4hYLfFmiBwOiLMLGGXVPrz4zmyjKzYQgNmAUdS+gyTR4iEcJ8d0h7E2gbvBVgZvNUVGEXhvhkwi916a3L7t4YSinMArlmLyTDoeVsTQ/m2MaK4S+kX3FWlS/h01DvFFE8xSiSLqMZYUPDK6f4EKNzhtUazuMbi2LQd6nboT4lRXhwnNukQFwNBizZzNCY6kS6WaZfbPDDlcZ3f1rH10HpMPjCU9qAvLjP/7j/OZv/iZbW1v8yZ/8CTfeeONDbjOZTPjBH/xBfvInf5KXvexlq8ettbzrXe/ix3/8xwH4gR/4Aa677rprtu9XE12y7CMDScYG6zTOa04EYz5VHePuc2tsnXXoysqKa90ShDTBD3oyHjKe46MQHRiZwx9PZCSkGktR2YqIKVsxelOj0wS2NtDzHHtuB9+0nZBlcTbq49IQndeousZNphggYQuvpXC8oJj4UYY3ortwvUSO0drVKI0azwiUQlc9qvWYumcO5Es81LEsMzjChSM+vUDde06IHMgKOKCSiGAR4yKN74vTlTOyuq+KUkacWsGzDw3KOuJzFS42EvaoxM3LhRofyDiZamSkzMxKfGgot1KqUSBZIueJ3pueIdrz+6v5udjY2l4oWSd7obhc9VIxL3B+FZaoDKgolI7JfA5lKYYGaaszygvMLMZlEboJUNbLeJQXy91w0RCcnYoOoyxR3svIVyTuVCw7CQDWYnZmxHGA16IJ8a1mxg9lVM5rKc69BjzYVOMGCaasJNujbkdYnVjjuixCRYGMl81zuc7zXLovYSS6jsCgnBg0uOlMRqeMwS/k+XjRyfjdMUEc4XqJ6EDakE9fFCzjTTRIN2Q2xy3EqlePhvi+EA29KOQ80n6eTnNduMshM+fuep0kbJj3/UXT7jtcHXT3rw4dHp94whCQD3/4wwccp2azGSBWt29729tWj3/84x/nxIkT/K//9b/4N//m3wCSdv7GN77xoq/9P//n/1z93znHe9/7Xt773veytrbGjTfeSBAEfPGLX2Rvbw+AV73qVbz97W+/ikd37dEly157uFDRZBBox9zF1GhuLY7SjCPChUPVVlbAtZZidtGO2QTieqWUklX/qVzb4oZlRSAbBNLJaMdClonpzUYfE4XoxoKzUthZJxao1mEWMvevhqJ58nmO3psTDGNsLB2bxxJWWRyBwvZC9PpIXI3aLAc/n6PqCrMoSCYZwWaPahRh0zbo7kEI1SoAsHDEOxVmR0jeSi+jlIwN7ewReI/XIxmrS9T+CJXWqCxDDXoiAncOc2YOixyyFLsp51mPF9g1KWSDc1P5vGtJ3tZJQpiE1H3pEqw6OG3B7iKD2anx07l0G5QiWpQwneNnc/TGOq4dpSIPUE37Z751k6Ju5BopSlTbvXB5Iba8gBkbIjawcYaNpRuka4+qHWoyw+aFdCWGAyn4rQjcfRyitJHuRJrgJ1NC58CvUxyOqVPdfnasMlLOP/c4UEVb8LfkSEWhXNt1gx4v8InomnxjpcvnPXo4EFKQl1CLWN+3413EsbhfwcrpSohKgItCOb9BICNldS3jinWNDgJ8P8VPxOzB1w1KK/x8Ib+PiVj3KnqrcbvAOAa6YEM3nIzO8prrb+H/u/O11LemRJPzOpAdrjq6+5egs+Ht8HjCE4aA1HXN9vb2Ax5fLBYsFovV97ad4T0/APDUqVOcOnXqkt6n1+vxL//lv+TP//zP+fSnP81tt91Gnudsbm7yzd/8zXzP93wP3/7t3y43uw4dWogAXZMft3z14Xu5LtzF4Em0rBjr2qMWJWo6l8KqzUdQUSRZB1mMVwo9WUAtRGM5FuTrRlyA2hVpZYyMo2QpyjoJUju+hY8CzNkxlDKe5WdzWRGO45VmQBmNso5wWtFkZpXt8Ji7B7VdBFXVkMSoYR+sw89mbWdoDzWfE1Y1ZpZiezHlZixdnQuMli3Jh6k80bghODfDL2Tm388X4kIFoqupHLpuMHlN7DymH+KMkg5Wa4VL3aDPjfFlhWv//uggQE9yVFXjJ1OCUj5nt7MrOo1+b5VwbhNz0GK4hTeKehCiyx7GWnE2axqUawt1s2z1tB2SQIr4A1oRpdGDnqz8L7Ucyw7GEm0QoinBLBp0ZdGL9lpNk30BfBpDP5LO3TKjpapWY1q+rAiVwpsN2AxpYn3B46LtsqiqPtj9qMX1zCsNaSxjiGGGVjLK6Bf7nw1RKMddVq0LlpZxw6KULJStdbxRUFtcL6baEH1GpBVBFOLHE1TTdnfawEaCAJ0mOJeLxqQs0YuFuIAlESSRnL7KM54l3NeMOBmc5TnhmFDdxu8OX4wNU+lidU5YHTp06LDCE4aAvOIVr9i/EV2D5y8RhuEF09E7dHgo2Aj0RslLRnfynGibTCmel5yCyBFOGhmtqqqVS5FeG0G74qsWMmqDc1JMWithhL1sJUanqoRUAGyuUR8aoqtmZeSuZ4WsfjcW6lrGV5bWvkHQFtc1Ki/QiwRTiI7C68ca+0BsbwGMwR4d4mOD2V1I0RjWMopWt/P7Woslq/WS3m0OHs9S66AbTzhpCM8uUJOZaCe0rJArQMUxPktE3+E9elqgFxqdRxBoVF6LtXGer1baldErfYEvKymOnRUC2BbMejiQjkESiQ4ji7CxlmL5wDHLqFfTM+g6QZUWXVZii1s34lAVyBiUPrMrGiEQowEvAnS8RwUau95DDVL0TiDX1HAAjRXHpzhCVw3xfTNoX0JZK923fgYbI2isXK/GrMYG1XQhGhArblyq3xPx+/YukfeYfEi1FtP0zP7oVfs5msoRTGs579Zi+j3UoC9i9XakitkCU1Si1Wha8qU1LMl41o69ObcvFteJEPh+iosMuqjBOmwSULfjc5CgFzVqKnoTrIU4FnvfxqI21tFbGyJEr8TKGudEGN/miiRnSvRf9/iDky/iucdu5ogJiLAExlIkCh8oVN2Rjw7XFl0OSIfHE54wBKRDh8cstGpFrKC1Y80sGChNqDRrZgEKzFysTVUYouNYikot1ruqqtu8Bw9JjB8NZBW6TcrGaHygpYOytH7WGl01ElTYEhvKEpIE1UulgGuDCZXzYtubphL2VhRQVpjaoa2MzDyWrESVl4JVeY8bZjSjGNU46Qg0zb7IPgxwox7lVooLRc9CSzYUB7sgyksXytTyuhgj2RFBAMN+GwboIAxEi1BbScguq5XJk2+sFOBVjR4NcIMeqpfuhwk2tk3jbo0CvEc1dv8O3zo9ucjgInXhVPqlQD26X6hIXcuIUBSiGovb3hGSlCb7LlK6WXVJ9GxJrgw4JcV2XuILK9qOuVj4AjDoCaGyTq65upH/Nw1qnqPmiMjbWlSaSBHvJWnde4/L56gz5zBFSTLu4eNIOhmxwYVi+6ucx8xLOSdpihoNcKOeaGhqi97zuLPbEqTZS4VUgVgLt+GBNM2KMOr1NdFnaCUku2rQjYNA40YZNgvabBaFTRQuCwniaOV0pYzGaw2+wQdGSE87iqfiCJ/EEgBaSQcq2AsZ3JHxibPHmR8NsHgyXTOKC2aZjF/qjoB0uMYQAnK1RehX9eU6dFihIyBPYjxv784Dwr333PTKJ11y7CMF386+J0nNQBfMveOeJuRP589CTQMpjh+w0f5y1jKfwLeZH3qhUbnM8HujUV5cgdRwIAWT95gzY+motEnPqpdBmuAGbejcbIYrStFNGA1ZKjV6UaIai84bTBFgw6try3uxcL/zz9WDbusRR6ZaindTNCKkz0X/skyE14MBPmg7CVqKwAuO/9COX5Wic/BGrUYoVdup8KGBvEIV1f5H1VjceNLmaWjpMrjW5jYM90lHq0fwvVQC74pK8jnmVlbr8wKKQkbhttap+8FKrH7Bc6PFGctlIWo0EAJa1bA7RiWJkDCt0VErSK9LEYkDKgxlPwA1y8WSNgwlh6MV2QPSTQF8XsgIFBYWuZBW71e5G2g5VyqKZMypFWireS7H5vy+Y1UQCBk7u73K2PCBEc1TKt0fBj3J/wiEeGC9ZJQ0VraJQtRoiI8jIUml6KS8dXL+iwaVAL0M5ZwQ9+1dGYkb9LGH16kHkaS1t9kuLlC4WHQdqpCOi1/k8vlpDa3l8cr1KghAZ/gwEBKSpTQbPZSDogqpvWbhKgyGtTjnrtYJa2km0OHaoruvdejw+EBHQJ6keN7enbzto+9cJchulFNevHMbP/GSN3Z/rK8BfKCoe4rjgymHggljZ/jL/Cbef9dX0julUU27urzIRTOgtKwGV7UUfU0jVqRpu/K7XE1XIl6mlGLQR6EUZ23mA3GIbos/t95HT3P0NJfCL4www/5qNR6tpFDVSgr7cU4UaGyS0GgRWq+sWZeE5DKIyVJnIaNQ7XlpV6EPdCPYt9q90GurdlxK5zVqMkclkazIOydjP8tiO45Wwv6mZ1aWuXABDYjzBHlDMC7E4jhvXZO0wStFvZbgDmeYRUOwV6AX52VCKL36V4UKNWhF0fX+WJ3SYoGmGtEkYMx+sd4G6ak0wWYimHcP5pykoEk1bCYEvVD2fTdHnWmws+19QjAaigvUrE1St14Ih1I0Gz0C5/B74zYdXbpHOk0k2LEXo9prxwftzrTPU0ncCvLbjlMcQ5uKrpXCD/u4zTURuC+KtgthcButAD8wuLU+LjRiJ+zEbQujJEiwabM42nPDZCYkOo5QSSbdmKWdbiKdQAX4tQE6L/G7Y/zOrlwH1uJmrQtYXqCrmqjepFlP8ToUIgLoUsbY6GUykth+tr4WTYpKYtTmOiovRCu1O5HxSK1ww4xiS34vyyJi7iMKXzF1ET1TUQ09TaIIpw/ymXa4Kniy39c6G94OjydcaN21w5MAr7/9g6s/0iD+6cp7Xn/7Bx/lPXviwSuwkcJFoJRn6sSVJ1SW0/euMbrDorcnuL0xttVwqCReiYb90jAhMKi8wpyb4JOQ+roN7PpALEe3d3Cnz+LvO4s6u4PaGctKexjgh30JVguNEJTlSNjGCPfU63E3HJMV++29lSjZjydwZptgd4HJHab2BKUnmlrisSUaW8LcCaG4hBb9+Q5TyXZDdk9O79SC7N6SZLsmHlvivYZ4ryGaWYLSo+wFXrsdv4q2c7jnNPbsOfy9Z/CzBcSRrJwHAXo4wG2tUx3qUY0CbKTEDvVCpKbN/VC1kBgfhahBvx0nCrGjhGotoFwLyI/E5CcGlDdsYI9uojfWxampDb/TaTviBqiywmcJ/sgG7tAaPonxcYhfG+A2h7Kyf/qsZF1ojRtm1MMIGz50donXMrYUbi8Iz85RhQjEl+Jt1cskDNAYlBGtkO73pBtz7xmCvz6Fv++sBFWW0iHRcSzbn9vB3LcrhgfOoeoGN0honnIYPRygwjbIMIr2yReIi9R4AjtjIWhKiKzPC/xigR7PUWWD72c0wwTVOCEogTl4J6obfJZQHx3hhnIufZ7j85b0laJ18mWFn82EZBxaY/GUIeVTNuDQhmhsqlq6U7DqUKGF6OjaYkq5fgG80XJuykr2Z+k8F4ZynEGA66W4w+uwtS5krLX51eM5/b/epXe6wc4CdmyfgVY8Jch56fAO9Ik55VA/JrVUTzR097XHBu644w7e+c538sY3vpEXvOAFBEGAUoo3v/nNF93m537u52Tx5EG+Pv/5zz9gu5MnTz7kdkopfv7nf/7Adh/60Icecpt3vOMdV/3cdNhH1wF5kuKm2ekDybEgf6xvmp1+lPboiQ0XKJqe56bBNjcFOxw1sGlmqIUhmh606NRrIzi8CUUFi1zGTjbWZdRqPJWsgrpBlZkUeFbm4Fez+dBqTpRoQrIUT4AeL1Blm9MQekmkdqDLNnV9Nkf3ezLGU9Xi9KM1QWFlRr90BNMSPStRdYPd6LO4LpPV+EtwylIOdOUJFjVmZ47KS4xWBEmMTyNULsWiGyQ0g4i6H9Ckej8Lo+3A6Mqj8go3z/G1pH1rrcX6dr0vo0eNpdlMV+TjUjo1umxQRYVPIilI2+LaBxIK6AIgULhANBou0ph+RJglqLM7ontYG9EcHtH0I0zREOwu0DtT0ScsYYys2E9n+4TTaNAbNJl5gPj8gteTodW1aNR0JiNCcYy2dt85LQ5RRbCfY1JV+DwXq1lEI6PCQOx3exnEkXQepjPc7p7YCfdS/GyByYt9u1qthAQsi3ut5ZjSVAiCs9L9saIzckUpn8myM7UzJhrPVt0F5gv0ksg4i6tqVNMQRAHNMMH0MtjZa4M2tRgBhAF+b4zLC0kyd44gtwSzWrqG0HZIYlQY4RcL6QqlCVSNZHxkrXmDB101Yh7QEhyshSjE9/ryWc0XqNPbog2xDlcUMqY3HMjoVlljCkuwF/O/Zk/jBdF9JAqOhmOOrk/ZS/vS2uucsK4pnuz3tfOyQ6/qa14u3v72t19xFMGJEye44YYbLvizLMse8NhLX/pSrr/++gs+f7FY8PGPfxyAr/qqr7rgc4bDIc9//vMv+LNjx45dyi53uEJ0BORJitv7R9gopwf+WFsUt/ePPIp79QSFUrgQ6r7naekZjhqIlfzq6VJhcgkGXKaWY4x8386cqzahmarGzeeySp0X6KKQoi8w6LWRjKvo1skqjiAw+PEUygq1PsINM3wSo1uBscoLTBDIynWbu0AQyFiX0dJRUIpgVmMUmFmJ2hnj5gt8XWP8EYK1WBybHqqX2oq8o91KyEe7io214upVJTJWVteY2QI9TjDrPcrNhHpgpPinHd9qZFxM91LcHBEhL52PGoeLQ/wwoRqEl0Y+lGgqbBqijUZNZL88iJaitOja73cmWj1Jg8bGGvSQsA2IdKMe1UZCNTToOiBVinAm2gnVy1ZjdkQhxDHaexn1MiI+t5GMiT1o96PVEjSpotxKSRYlnJG0dmUMatjHDlPQGjfqSdG8vSedFqMxo+F+IWz0vl6lrCRAcXQUPZmL/XBeQFlil05TWqGzTLYPQ8zmQI6lbuSctboPX5TiyNV2hrwVrYsqNXZnFwCzsQ6jIW5n90CaugoCOV93nyHM1/BaoUdtTs2wJ78b07lofdrsFHV6h3jWiv2XFr7GyIhWlgo5TBLpbhXVfrbL8hJoLYRReuWCxah14aob/MTid3fx7TnW/R4c3qQZpXJOFgZdWuJdxRcmR9hZi1jTFdtNn7wOV52WDtcW3X3tsYGtrS2+5Vu+hZe97GW89KUv5Vd/9Vd5//vff0nbfv/3fz8/93M/d8nv9b73ve+iP/vVX/1V3vjGN3Ls2DG+4Ru+4YLP+cqv/Eo+9KEPXfL7dbh66AjIkxTvuemVvHjnNqyXFSKLwivFb9x04V/SDlcOr6EcavRWzsgsKLyjpuZUvUG0pwnPzVb2uUuxMHUjzkZZCsO+JFIrJYVU07QFW4hbk8JMVXW7TSOr7YGRleKRjGjhZLyIQK8ExrSjMdRN686E2Nd6GT0Ri1GLmjuoaukOtFoLb8WG1NROijejHuAsdQDt47puyYI+byQmjkTQ6z0+byS0r6oxShHGATbZH18JCk+0I3bCan0N0+vhJlM5N86j5wU+CbFxhI0fupjf/4wUNjGEYYDfHcuxp6mcq9JK1yXd1704IyLmIHeoqtXvRCFNPxJXpTYZvdiK0MUIU9dCLNtsCaX29SgqiWFznXoYSe7KpVxTSkhQtRag7YjIOfy9Z4TQOd/a57r9EapccixU2hOdzLKL0TpbyYue5+EZGCGxcSREoxGHNLRaGSKofg+33uo6dqdiMwzSjWkaSJKD+9xY4H6BfK3eCFqjhTgWIgUyEjWeyvlZOsOV9SpfhFDS311Zwtlt9HSG6gnhAiSgMI3lvK+PRFNVVmAdLmqvq3Ya0aYh4Wgo+5QXkMS4JJbnG4Pe2pAE+LxAxzFqfSTkAzDTUtzA8oponLFXpmzbHgNdsxnM2EgX3B3RKdAfATzZ72uPFQ3Im970pgPfv/e9771au3NZeM973gPA6173Oox5MGFdh0cDHQF5kuLTayf5iZe88YBbyG/c9A18Zu0pj/auPbGgJUejGsHG2oyxzThtQ2JluXVxhHAmbkR2sVgFCKosxYdtJyJNqI4MxXp2HKKKVnA9nUESYwexJJqX4qzka5l7X44l+TVZoVbTOepeGefyw56sjIeBiKQXstLtG8nP0HGMWhutHIqoG9ibSOGcJVBXMl+f5wR7BUEW4AIjGosHgQtlxT4MDcGkQBWpuCklMc1GD7OQfca1Bb2Tka9EQ52JU1g4rjFnx9I1yJYEoRV1p7EU3IsSnUWXpE1ZwivwRuF6MXpjTbQJ50Hdb7bBawnOi8Y1wd5CbI17CTYxQk7a59hIUY8S9LQvbkzLjInW7tjnOXowwK5lNH1zyYRpCRsqio0QVY+I5rloMLzMvVM79O5M9DzGCKmMQrGUXZEOh/dKfgZSfE+mEIb4jRHNunRtzLwSVyqA6UI6HFEoxLi2+2NFzgrRaUkAQYDZWBNhdxTuW/s6Lx0ZpeR6tRZf6f2wvjBYkWCMWdkL0+aRqF4GSYRuLH46k/1JYrk+3b5lsrIOylrI+KLAz+ZthyiiyaRz5x3S2YpDvDGyD625w0qj0o6YmZ4kn3ujMXsL+f3Jc1kQGA5WnQ6HZqA8L4/v4wuHv8B/GJ3ABZ0V77VGd1/rsMSXvvQl/sf/+B8AvP71r3+U96bDhdARkCcxPr12kv/rRd//aO/GEx8KXAhZWDO2Kdsuo6cq7sllxdUPe+i2E6GSGNdLJVivDWEL9gpxFCorfNjaheYB1A3BOJft2oJZZZkEpdVtQN08PzCv7+cVKgpxWQRJKIVdHKKdF/ctJ9ajvs0Ycf0InbeBh2W1GntRRuOLEn1uTJRFuDimTi9sHQv7NsTV0OB1BFphjBJHLqOphyE2DQjiAFU79KJdVZ7nhLOUIItF75BX+EWBn89lTCeOJI9iOMAO01XSuGoufeZlaW1b9w3epERxQHhXJQnlWYZKxGlKW4/V0rlQHkzhCXbm+CjAbvTwWokuo+2SgJCapmcI1jKCyQyXF7LSvzZEG42ra4hCXBxI9+MyyIdXoJ04gqk2I0Y1PXwa4yKDmbXdsDAQQX0SiwlBYMA6CdkDIRt5vupgCEntUx/qUa7J+FAYG3SbERLMc8nYgNbqt+20JEIAfdNIRyoI5NgGKTYOMLtz6W45L+S37ZCoqlpZ9cr4YCzCb2MgMNiNPvUoxgUKUznC3QJV1thRiosNZjLAjOe4LMElAapoZLRtb7yfqL7XZuoM+thDI6pBuDrfyrX6n1kuye5hIOen7Qz6WdFqogI4fhgfGvT2RDoi3gvZCgOxyA4VRjvW9IKRjnA4RmaBCzsr3kcKT+r72mNFBPIw8N//+3/nM5/5DNvb22xsbPCyl72M7/me7+Ho0aOX9Tq/+Zu/ifee5z//+bzgBS+46PPuuusu3vCGN3Dq1CmyLON5z3sef+/v/T1e+MIXPswj6fBQ6AhIhw7XGF6Diz03Drf5qt6t3BSMuaU6yudOH2V0zknY2pEtOLvbdgQCikMpidaYcxP0noy3+FEfN8hENO49FIUUM0rJ6nKjZaSqFaT7vEAtchnjCgLpkFRVS2akmFxZ+Q77mKx1HEpj7EafcjPBxQrVJIQbKdF9Uzi7I8VsKpkWICMoYRZIQF6oLrqCvyIhA4ONNUE/IOxL0ruuPfHpGZzZkTGfMJSC2LW2r40DnJCwRgpDFbSr5EEgxX8cUJ1cJ5g3l59Z0o40OdtuuBxJcxa1KDF5iuoZCO/nzNU6PZlZKSJ6PaTJotXxoiSzRC9qfN0aAHjfhv4V7cp6go31qnPykLt6v4JAxP1WugvOomYLgkoSv5d2wipN8Ztr2H6Mch5VNajpHDcRb1hvLTqWUSe8ww0SyvWQJtHgwZsAE2mChQjBVRxLIJ+1qHkuY3DGoHqZ2ArPF0IgkjV8oNHlvjuXbrVGEljoUWYkOg1r8eMJajTArg+w/Yim1xoRtNeVth4bG8JpLV0cBxglhgoa9N5c9CFLU4YoEuJVlKh+j+a6DYqthLp3P92S1mI+EIXo8UzOm9JQV6un+LJE74wlmDKUkEVfVfK7ZR26rAjmnrOzHtuuR80uC2c51wxAe7H8VYpHvKLr8OTBNRjBumoBUJeIP/uzPzvw/fvf/35+7ud+jl/5lV/hDW94wyW/zn/8j/8ReOjuxx133MEdd9yx+v6//Jf/wlve8hZ+5Ed+hLe//e3d6NY1REdAOnR4BOACOBaPuSncYU1rvlgeob6zT+/eaiWc1ogzkrkvJG1X8H0YoIpyP927tqjdiYyvRG1oWl3DvA1iqyTnwbfBaUopVDgUIfxsLuMsRYEet1qQspJiMY6F4PRiml5INQpoEt2OGgEEmFGKcesSfAerVWI9WxCGBhtlBwTjF7pveQUYaBJxk/KBIlhYglmFGs9w7co6rR5ADfqygj5I8ApMHEryeBDI8TqH0hLKGOwusMkAXVlU1WBGITYyl+TQtSQLYsnbju/0e7KSbx26Fm2F8mrlyCUbevTZPXxdt/kRgwOvqzwEuZWiVhshg9ZJ4V/XrRbGt6N6D76PqxBGJ7klsJ+rgvdCSuumNSloOxDL0ShrYXuPYLx0xGoNDapq5U5FGIjzmVP40GCj/SK9ibUkxReN7K/RkoeBZGWsRPtLG2cr41K6sZJkPiuEIMURbIza67aBKMT2Y3QlVtQqSbDrA4qjGU1PS9fgvOwWbxR+oPEqJNqrCM9MUbPFipAuxwmXOSUqjvC9VPRFWUI9jGhStT8u2J5PF2p0YNrcnfY12hwRQPbX+9WxrmAlIJFUTBT69zZs3zXks0+7jhdF5wiVom8KXOgvmWB26PBYxGQyOfB9HMfEcXzVXv/YsWP8o3/0j3jta1/LTTfdRJqmfPzjH+fNb34zf/RHf8T3f//3s7m5ybd+67c+5Gt99KMf5XOf+xxaa173utdd8DlpmvJ93/d9fPd3fzfPetaz2Nra4vbbb+ff//t/z9vf/nb+7b/9tyRJwi//8i9ftWPscBAdAenQ4VpDSc7EveWIL9ab2GAH5zUudtQDQ7St0fNCVluNwZcV+r5tIRLOiT7DWnRRtSuorYXqsI9bH6DKWkjJZCpF3XlWn75dBV9ut0ykJmx/9atair5jG9SDCJto+YrOK/w02FhRjSJi69G7M1RetvarohExezPiUIOS1eVlwNuFsBJyBwoba8kZmVdS0KaJjOY4B2mCHfWw/Yh6EOCNwiSG2Ht0q2HwWSIhdtaBdcRfHqMmoo/Rde/yFpvbLkjdD9GjHto66Rgtf3z+VJeX8+JjsfylafAba7jIHJyx8cg4WNOIpW3rlsUiF9vbfg+7ORA3rQdx61JtVkm4cITTBrNocz9CI+L7vBb3qdaGV2WpfOZxLGGEiwV+byxuaWmCn0xxeY7OMvSgv3+tNRbVS7FJIAV/S7ZEm6JQVSOuakHQWv1G0EslQ2QqI2Z4J/sQhVBW6F23GvFSVSW6jyTCJ1K8SPeoFBK2uUZ1KKXu719D9z8nLlA0mcaUAYFWbUfMi4PWoC82xHW9SqBXdQNhiOvHQqrOIwKST+PRtWSS+HmrbwkCOYcAoYyZ+aIQ7UkbJqmW42etvsaXFfG5nHhnSOlCMm0IMRwNxvjMYuNQxvcu45Ls0OFycL6PxNV8TRB73PPxT/7JP7kst6qHwg/+4A8+4LGv/uqv5gMf+ADf9m3fxu///u/zkz/5k3zLt3yLLAw9CJbdj1e+8pVcd911F3zOy1/+cl7+8pcfeOxZz3oW/+pf/StOnjzJT/zET/C2t72NH/mRH+HGG2+8wqPq8GDoCMiTDM/bu/OAQO89N73ySZEQ+2jBKxEK+wCsV5xthlivOVVsoKwsuatKErPdMsPDO3zjVgXUKjeiFqtS0gRljOhBlILQrAS73lqUV6g4Rkc9Wa1tx11UEEgRpcVVSs3btO+tdcrNhCaTBO7lbPyq8GvF1AwMykbEVbIS6S5tWqkijNFERuNNTG3UQ3ceWktb5T1UdZuYvf8nyYcBtheu8kC8kTwObRPCxslqdRRIUeyciIWtE5FwGssx+svjILZ1lkL3iKIAlde42NBk4WqG/+AH7KU75WScTZ139191SZZ6COvkc2wzQVSaYg+NKA4l1NnF2x/LzkdQOuKdivDePSEwaYIbZhLoN13ga7GXVcO+mAzkFco6KfinMiLFaIAdZZjWNleliSSyay3XQ9Ng1wfU/eBA50F5Wm2L2j8mreX6iwMwfVQcoSdt5knrZuWLEmgF4oO+dGj2JlLc91JUY/GTqaSeD/rYQdxmv1yYfCw1FC5UVKMAbfuESrXWyW51rlUcrayF/aKAUR/bb53RziNWS3tolddCxuNYXieQ3zOUmEgo66Q71DpjHeiE+LYLWVfovEZXkOmKRAXs2JJ76nXQogPr2Mcji+5+d/Vw6tQphsPh6vur2f14MCileMtb3sLv//7vc9ttt/HJT37yQTUdTdPw27/92wB8z/d8zxW954/+6I/yy7/8y3z5y1/mD//wD/nxH//xK3qdDg+OjoA8ifC8vTt520ffuUqK3SinvHjnNn7iJW/s/ihfI3itaFJNM2p44eDLPCe+mx3b5875BulpTXZqCmd3pZNgLa4oMUaj1karlfVVonTT4GcLWXm1FqaSmQHgF/kqMV0F7fhQEq8chbzRK2tTX9cwbcXC/R52lIk+40Lkg/2iz4aKciOk6Q8IFj3ie2aonT15HZBgwUWFKUNsrFa5GRfC+eNEuhIysUyvtue2ZXSsl+JDjV1qADSto1gAPiPcWaAnCylgqxo9GuK2RvgkbIvjy/yslscZKYqNoM3y8O2IzsHj8ZrV/1UUSQHdWOmMLN/Xi2bBB0ocurZ3pSBvA/XU2pCmF4obk3lwsqYcmNyJ6H1ntxVyh213pbU2jmN0EuNGPXn9Wq4dn0To9bXlLomVbRyhNzekE5HFYD1qUaCiSAr1ZP9YlwGQqvH7QZYgz5/M5HX7mZChWIiwS0PM7hw/mUpXr5/he4noZOp6FXQpG/v9jp1pOxQP0g1amgbYWFGuh3jdJ4hD9CwXQhMYfBrhjZGuYd3g1vvUvQcK/aWz5FfXn1vvo8MAPxcraABlrQj1B5l0nIycW7c3FlIXRmJfXTci7HeSPWG9Z8cZztV9TGxpskjspLswwkcET8b73bW04R0OhwcIyCOJZzzjGWxsbLCzs8Ott976oATkj//4jzlz5gy9Xo/Xvva1V/R+xhhe9rKX8eUvf5lbb731Sne7w0OgIyBPIrz+9g+u/hhD65Pu5fEnrWvItYRWbWYEEDk2ghnHTclRU3IkmXKqBD0rxdEJpIDRCtXr0RweYXZm+Hv3RKibir2orwr83K9GP1iOLEUhlAalvAjEQZ6fJZJlMJ7Ipx4E0HgoS9T6GuXJTYrNEL/UIFyk8FuNTSnwSqMawEgxpVrhsi8KVJERzBsRdBtzwddbjhMFhSOcWoK9XFap26wPtQxiDAOaxBzUAWiwkabJDGYRoqe5/KCu8ZMpWinRVmQpeisFLk9AeP+ujz1/lEztP0cBdc/A9X3CQYyZ1/hQ06Rt2nerzQinFpM3QjCVEt1OG7bXHBlRrQUH3+MiUM6L1sPJl28amM1hNpfV/iSGLMGu9cA5zLlJazk7wPdTfD+V66i24iQWBvh+gu2LY1YwLve1HeaBnR7deILcomatqD0TEwI/K/DWSbK48/g4xA4TmkyIiG5H1FRVi1ObczLS1FrZqrppXdtKUIomNZeUhbJyLks1NopQGyG66UlIpVsSXI+yCWgl10yr/ThwbL4NtlyONtZCYJTR+FLE+8SRWPQGchG6NETpIdpJtw2l8GMRvBMYlIWFjamxDLTlK7JT/NXRG7hzQ6x4TfmQh9fhKqC73z2xELZW4U3bQb4YluNXr33ta+n3+9f8/TpcOToC8iTCTbPTBxJiQf4o3zQ7/Sjt0ZMA7ZgRjeaeap1zcchI19ReY4p2YNeY/z97bx5sW1rW93/eaQ17PMMduumB5gKGAJYoghX4aVFiNCiGKSpCBBVBzFRoFJOICCUJGBMKLAyWgBKQgFFAyhiMpaiUjUKIoAKNCk3TDD3ce6Y9rul9398fz9r7nHOH7tv0Pfc23ftbRdF3n73XXmvttfd6nvf5DlI0xwCqLVQXK6Rai4YjBHEY6nXbItQL73x9QL3WQVcN5s49yXwAWWU3WvI1phbdZijE+ZwwnaN7XUI/b+kltMF5FynW1hAtRCtTlViWy3BC7T3We6Jeo8k0Xp+74qwbcFNPdmchmR7jiVBzYkRlmazWh4DPEkKizqECLZLIo2sblRClqAUJdIwBlSaYsg1JvMhwv3OOs/38LvT3YKHqiVjb9hym9Og6kIykoDWlJ/nyCM5sS5aKMXB8g+ZYj5AaoZZld6392D9xiqZnKK8ZkhUl7EkuSywKKZRbK2JV1uhJIWGKyGRMK4Xf6NH0E4JR2LnH7syWRbcuPboSu96YHghDjPs2v3YasNN2+uF963rV2ub2e8R+V8T7SqF8xM5qcSbLEnTVELVM+FTjl45Tal6KhXSv0zbAimgvfnK1aIq9BmUVPlUyVVtM19omZHH+oj7wOPL/por7DeIiF2dBcwyBMOzKJGVWorfFMSwcG9KsZbgwQI1n8l3sdYmdjGaQoQKcrvrc4QMGOG5HPKi7x2ez6+7WaGCFS4cH5P0uXsyPyVewzSuMM2fOcOeddwJw7bXXXvB54/GY973vfcC9z/745Cc/ebfvt8K9w6oBeQDh5t5JNsrxoR9lj+Lm3skruFf3f0QDptPwsOx2TpqaGii85CvEzKGPb0pzsLO3zBNQTUCVtbg8tfqNpZ6j3xWaiZLgvGo9IZqUJHe4OxLUeCoWtm0gnao9cTIRa96qbXSMlgIeKTB9eg9uMq2APKQW0+2i+pIJEnf3CPMCM5lhxzmua4l630JVtZQrN/GkZwr03gyKUvZpYVGbZcROJtOPYbpPvTowfZCmTmhpC2thPegTB72lfW5MHLpssHMJSeRuKE5fCRbNGIjQ3ExrkoWguqVFhdGYMJ3JZCvPUSEQnT7kMnZRSe0iFxK7Xd8Kn40W4XjdSPEfAqqooawkHTxESbLv5NSDlGptX9dhzwQJsFwGCQbJCMkcaIVu5LowVcCNGtzWFLW9R5zJxEl1ctGW+ABzoW6F9R6+m4KSXA09kSwX0S45MQywSL7L7IAxwrwQquFXQJs7dH5Arg04oP1RQvNrIrqhbUAWIYwsJ3BqbyL5Ket99LiQjBml0BP5jkStCBt9ojOSA1J5mYgMuqIdmcxkyuMDUYHVnlmwOBXIVE1uatAr2tXlxOp+d//BSYTBkwABAABJREFUa1/7WmKMDIdDHve4x13wee9+97uZzWZcffXVPPnJT/6K3+8P/uAP+MQnPgHAt33bt33F21nhrrFqQB5AePupb+Wx25/Fx3YcjSIqxdtOfeVf1BXuGlEpQqJIs4oTZkxfW2bRo1VEeZbp0jFNxJlKKVklnrcNxELH4b1MR0KEtjjCGFQqGRjiPJUSknWSrRR9Zo84nWG/KA5EfjRBaYXudcXeVmv0aI5JLU2nLbLuQfEXjCI6sfKNnRQ9saiiWLoF6TN7pFYTXIfKKhkkxHY1feYxO1NxHRr0pKH68h0ySSkKdCVUoqZ7ATpOO30IqZHwvbqGLCU6i55IKnnIE3zXoatAMhG6VLCXvgmRVfRAsldhzoxkkjOdiS4mlTwQ5Sy601nqbeqOXVrcXvRqv0aoUVYT+x35/A9QA2JVwd4YjCaUVRsWadBrwyXVq0lFlB9STUyt6DGaQMjkultojdI7Z6RtI6cacYeibkSD5D16Y52w3oMmoNsQQ+oaNa+wZSO0qrohFqWEWwJq0BdtSL8D/Q56PJPnNTJNIYhYnoPamgP1+lei51lsQ/mIKYRqZQqPndb4TG59dmcOW7ty7eUpvpMQjUbnCcFqCGB2xqgATS+VsMxpjdmby/4v0IaG6kq+z4ZAES3QkKkGqzwrXF48EO93R+mCdZT45Cc/yS//8i/zL//lv+RRj3rU8vGiKHjta1/LL/zCLwDw0z/90yRJcsHtLOhXz3nOc+42v+PZz342L3rRi3jSk56E1rIyE2Pkd37nd3jBC14AwLd/+7ef45S1wqXDqgF5AOETazfwkm984SFXkLedejKfXHvwld61+y2ihSaHblbhlBQsCxaGbpCV8rqRnAJrRcw6nrbhe80+37+uhWOuFbGuWrtdjU4cyveJCppUEdct0CGdlTCeyHTBWUyvKxSn9TURKdde7FRDvFsB9DnHtGBVhVZ43a6gE4LQcxopQo2zmLUU1YqsgWVonprMCJMpWrd5JJ3OMmAQY0ScnekLMgqiUdRdizk+wDgLVY3e2pV8FGthrU8wsvptpx4CNF2xF14cw73FYqKjyyC0p8lMUrETh9Jqma+h0xQ216hPDCg3UgnBuwfn/KA4vlqz6LqLcQZVNnL+ptN9EfdsLk1Ct4MeDmiu3WR+MpPjbs+lTzXNMMeVDcp7fJJi5vVSYK6KijieiP0z7USh0xGntTZZHaXk2rWtBW1VwZkdYlkSqkqmdt2uUAZb0T1aETJLTLSEBs4qoYwNB5A46s0uPpFvhwrs25cdmDTdk89toTXSDeg64MY19swEdkaYTiYTl/FEtDJ5LhQsL5OhRcihqhcTJy1ZJWWDHs1RRSWua6F1q7OGmCb4XCabn5tuMhpmdOyYIlic8vIduPJslgcMHpD3u8UX9lJv8x7ixhtv5GlPe9ry35OJmFW8+tWv5nWve93y8Y997GNcd9111HXNG9/4Rt74xjdy/Phxrr/+egBuuukmZu0ixgte8AL+3b/7dxd8zy996Uv88R//MXBx9Kvf//3f5zd/8zfpdrs87GEPI01TPve5z3H69GkAHve4x/GOd7zjnh34CvcIqwbkAYZPrN2wEuBdRvhEUxyPPH7zNq4yM4qo+Ns65+bdTUwZl4UZVY3SGrKsLe4aobe0Vp+q2wEttBvyXChLTbO0ml1qI6yi6RjcWleyMpSSQqnxaB/wGz3qQZs+XnmanpOi7x4WdtCKjqdzoUF5Lw1EG8ymsnQp8NU+4g9mLzStE1cIhO0dsRZOU5nOWEvoZPjMLN2QzsbSBSlTVOspiVaY7alQgdJEismqJvvymJhYSZpvAio66O03IZcEUY4PEJvWSrJalHPE1gJXDfrUxwcUx8Vi9p5MPs455kRT9yyQoVOP1kpoXW0Qoup1pXhWijjoUvccPt1/TxXFzazuW+xIRPx2d4baHRP2RmJ2MByAMfuZHsbIdhMHU3Ed07O56E9AsmaqSpqgGJYhhEorsX5eTPB0e535SMgcIbHSFBktiecdLYL81j1skbsSdTtxu0g/gaW9bhNJxgE3qlBNQJcNqqwIRUEYjZZNm84zCSzUWqh0Z0aE7V1UkEYkJg7V70vjMS/lWJOEmCVirTyeigHDoI/ygWQc+fzeOvWDDF3VcIvf4EvFGrpSl2c5eYUlVve7K4O6rtna2jrn8dlstmwoAHx7f7vhhhv4+Z//eT70oQ/x6U9/mr/927+lqipOnDjBd37nd/IjP/IjfMd3fMddvuc73vEOQgh87dd+7V26ZC3wmte8hj/5kz/hr/7qr7j11lsZj8esra3x5Cc/mWc/+9k8//nPXwrRVzgarBqQFVY4QvgE/MmSbxreTEfBdoD/Oz/F6TsHPHjPLwuSWAjNRQ36ogOZzVG9jmQlFCV0JMQuglCzQMLVutkhYWs0yAr7g3LMRioNQOml8MwMPtMHrHatUJnumVEU0DY8Cik4J6IB0P3eMgNCZanQyjiwmq0WVCItq+nGyPMXmRSL5qulttydYDdYRd0zQIJTCusslBXMSzi9LTQoo1EPOknT7eFGFURHWLOXRhMSDxyb1suJh0pT4qArjc+sJHQzqo3kHmk+zvt2raNa3RfxfbrlZVpRVSIGdw5/Yh2MQo+FDqfC4fdbNDJNrkVIXTWo0VQ0PL4N2Muq1ubXCpWrDeWLeQqjiehA0lSON0QIB6hISqNat6g4EXc3lSTQG9AMMqo1Cbs8pNnQ6lCDpHxLT1wYMUSFUlF0P3dx7g5ZOzcROwukd8wwt52R5vjEJv7YAKMUcW9MmM3k2DbWRHgeAmZSyjXk/TL9XCmZRqpRvQwdxLWNbd0sQw/jzh52XpBf22G7ksKlo6COls+P1nEjdTjMcoUVLjGO0ob3nuBJT3oS8R4022tra7zsZS+7x+9zEC996Ut56UtfetHPf/GLX8yLX/zie/WeK9w7rBqQFVY4QqgAcWb5UrWO78JxrXhMditpt0KFjJg4obGUFaGqiXsjmXK4ZFkUiX1qs885t0YaFh9QnQzdyGrxsrg1UHc0Tabbgk6+5tGow81KK+he/vc9QFQQnZZwOaXbhsNJQdxqIHD2UDAfyEp203eYzTX07rhNZfcimk+c5FIkdim6vqv3Z6mLUG22QoDxVN7b2jb3xLMIk9OVx04VPtc0qd7nwnGgoeLizsli6mTKiN0rRaBdS6p8XOvTDDIAtDH4BZ3sUjQ9CwMAp2RC1LqbqTSBPBM3KwBraAYZTdec2/QoOW9NblFrHazW0ghO2qyZokB1Ohi73rpdGWmOQ5CGotuFjSGhk6KrBj2ZEfdGhGlL/0qcTOxApkGZBCbWA0fdM9LwnnUelg5nHNBqH/w81Pmbj6VOpG08TBUxRcDOPaZo0GUtn39ZofcmKDfEr/cxMUoqu2mpU+sdVOkxp3cJ09n+FMdaVLeztLOOk6nYBvc7+H6GTiym8a37mjjaRQXea+po6WvLw5M7efjaaf58cGKpQ1oxsVZYYYUHOo60AfniF7/IBz/4Qf7sz/6Mz3/+85w+fZr5fM6xY8c4fvw43/AN38A3f/M38/jHP3416lrhfolgFLpXc32yRVdptFL8XXUV5V6231jMCmLToHtdEe5OpihXoxb2noMezMuWttTSXGZzCSQ0WgLiDtjNLhuL1hHooA3tpVocW6w2LykldY1qRHgc53NUv0/sZnh32Nkoaqj6BnWiSwJgNTQBddudckwxghe+fkiV2NReYGoQ24mKOGWpZXCjGg7wGz30vEZt7cJoStK6F5nSk+7UqL4jWpaFq/Kywh7a7I+LovtEWaXXhRgGsD4k5DL1MeNSjqXxIvK+RFgUr8pH9EymH4usCqoa5T0xcYRBTrWW0OSH6XULXYQpA3ZSY0eFXH8hiqtW07TWuprY6aEXieJBjkWliTR423uYSWt9vBDDxyC0q34fhj1xA3MWv9mnGaQ0HbO0e74rBKNQrWUucGjysbzuDh1PxFQROxe6lVkc07yAqpZmonUk00Ds5vtTjlbQKonuRhqN+Zw4l2YKYyRMsf13mBcAGGswiRWNSFktdSIkjqqvOXV8i4e70zhluc7UfOfG3/BnVz2MJktJxkGa31UY4QpHgdVltcJXCS55AzKfz3nXu97Fm9/8Zv7iL/4C4IKjuHe/+92AjN+e+9zn8oIXvOCiuHsr3HM8eveWQ2K8t5/61vttGux9Am2ugU/AJp6uLqmJFCHw/8YPxp22qFiLG1HROho5sUBVRug8EvjWEe59VaNwECNhZ7ctPIWypH04RHNa4Ejt22NE10FWxtswNqFRpdIU9TrU/RSfm0PJ1ksx9dCi6xw7KtCTGaEoIRZC/YkRd8cIGBBOpksB9Xl3Q+3rXmyeyNNmc7TRkortA5RTdOuUBQi1DdDzBlULJ0aXNdGKOLvcdHfZ+Czfu53A0NrRqroh5olQiObl0hJY19nyNQdX7A/hAmL7s7F4vW4iqmxEB6RarUWWQJoQckc9TGk6+pDz19IGeRbIb59jTu9B48UEoNeRBqKqUcOBTOaA6KwIrrUipqn892wuOoheVyiDvQ5qVqBDFPpdryOUpKoWZ6le0qaQc5dL/4vrI5pFX7vYcTlfIigXXZHyYqermogpA6ZoRAe0N5ZzEqJk3lQ1OktlUrdorlpqoF5fIxxfw3dTcReLETXI0SCBlouMk6Ig7I1Ey9Jm9YTRWDRWeQZpgmrNFEKWouvIF/eGfLy8Fvhiu72ASxt8mhI1KyrWZcbq/rfCCvc9XLIGpGka3vjGN/KqV72KM2fOEGPkmmuu4fGPfzyPe9zjuPrqq9nY2CDPc7a3t9ne3uZTn/oUH/nIR/irv/or3vCGN/DLv/zLfNd3fRevec1reOQjH3mpdu0Bj0fv3sLrPvqmZSrsRjnmsduf5SXf+MLVj/ARIjhF01UMe3OO2xEOxVZQfGL7anq3QnJ6jpqV7SptWBasOCdi6m6HmKXtyr4X96GFwDhEKf7nJWaWYnoWn54du3WEUG1atjVCFVMKVcmEZlGM+Y7Fp+qQxmRRZMq5sZiJFs2H1lLUFiJ8ZgrOGpquJQ5tm8B+vv1oBcptijp1Q7Ozh5nNod+D4ImlTGVijCI4zlNUE7FnxsTpTDQKra7GBvC5kSmIvnC1fPA4QjfFzHI5B2Ujn5EX96TYyfC5FPMLbYIppXBWQT5LaaD0RdsEKx/RVZv7kWXifFWUMOgSOglNz1H3DeFAwvrB9PlkRyyDw9aOaGQSRxi0eqOqzZ6ZFUvheJxOUVkmdKWyAg4U75mTKZDRIsK3RqYBszkqk4I8KiXBleb8B3fQbnfZRJ/1VO0lPybZqTBzaRaDM5h53TqwIWLwqhb6nZNpjkkSaahyaT4JoXXvsoTNAeVxaUZN4THTWqZZzkpjNZsLPTLL5NpeuHsptVxUW177WoIMMYpsx7PzyTXeu/n1HL96xKaZUkeLMQGfLqhzq2Xqy4UH0v3vvqIBWWGFi8Ela0Ae8YhH8LnPfY5rr72Wl770pTz72c++6GnGdDrld37nd3jnO9/J+9//ft7//vfz5je/mec///mXavce0PiBmz+w/PGF1hM9yuMrh5CjQ3CKuguPXj/N1yYjejpju1Z8+csb3HBLI1kILbVKWSs5CFkmHPM2mI0QZDUdpLgD9KCPXhtKeOFsjp6m6DplkfJ8Oe4XUYmoPXbz5f7hJQNEZRmhK45P+4L3C2zIamKvg1ZqGZYo2pac2HiSvQqfa4JpU9cvsB3tI6po6TZRrHxjLnkntKvZVJU87oSnTxAqG94LjcloVFVjx7U0BO7uT2SwimqY4MyaaAj2xI1rmXCvFMoH3DQQNbhpg90tJDBQy/QkdFPmV+VUvXOPUZ1Vp6oAdh4xRdu0DbriIrYImUwkFybYfb3PwfT5dKvEbE1kdd9IgCQ7eyhnaTa66MZhtqQxkwZEiRX0gmZUV+3n1hbedUDPSmlcrJGp06RNB+/kbVr9okk8z7EttBt1RNdiCe0Tacb2L7aWZlUE7N5cRPNZgurlkmXiPaQJcX0g573xUFTojTUJV2y/NzGxqKohjqfy/kWNm9REpYSKtrVLLCvU2kAa7BhhMl3qWFQnF3ezskIFD51cvp9N61Q3mqLShGQ3ofd5y+d2NzAPCmzoihvcaYbdOdN0cNFuXitcGqzufyuscN/EJWtAjDG85S1v4Qd+4AfuNgDmbHS7XZ773Ofy3Oc+l8985jP8x//4H/nyl798qXbtAY9Tkzs4e23cEDk1ueMK7dEDCApCVPgYmcWKT5cPwZ522Mmc5vhA0qgnpRRVc1k1VmlC3N4h3HlGmhBrUWsDYrel8jhL6GXoSQGnt2WCcLn55AqarpE8iVlbcCcOZQ1+vU9xLDtk/3o2dBOFr396D4pS6FFOKFSq2yEOulA3mL05ruvwTt19Q6DUMvQPQE1mUiR21lFlBbt78nhRYw+4bS0mUCpLUT5gtxVmmFDn3C1lKBhoegYVIJlVxNFYCtR2YsDWDm4yww57RK1bwfZYmqRFIGTdQW+kqKiXYmzYpxwtLJajEpF1ul2K/iNzYmmcp7L6jhgD+EwTDkwbdB1xk0VY4hh2R0TVXle52ECrvTGubgi9DD/sorWCnT2hLFkr+gYAl8hUaW+Ems3EOrmRRlgyahpCWcqxK4XqZDKZO2v6cdAq183aqcy0IqSW4kRO3dOHGygfQYEfZJiFPXWM0jTOCihrwuZAUsr3xObTn1iDGDFnRmKlW8nEMDaN6EPGE8xuDwY9aaDaDBU1L+TcaLG8jmUlzVq/Kw5rZbm0zqZuRe69zjKN3sxq0r3I9jyliA6nYE2XbOYz9nIOfTYrHD0eUPe/+0gOyAorXAwuWQNy0003LdMk7w0e9rCH8eu//uuEsCLJXirc3DvJRjk+9CPsUdzcO3kF9+oBggi7Vc6XfUIWPB+bPJh0W2HHJSG1RKPbVdvWenZeSOFjLUq13ye7T70iBNRoipm1AtvF45f7sFQ74Rk4dD1ANQGfO3wuyepNri5s77tY0Z6Kq1CcF9IgeC8TjGkb6FfVECNJYvFZj3Jg7rohcFYmQ9ZI4zYrRECstDxm25+7nRFqyxOKUvIthn1ZuR9PpbCueuhqiIoXR2lbuFLJToiYG60k5K5plvQuChF7y+cZ5POzVixdz6J76QbcWCZAEhapiVahS4+9fRdi3J8+tVkVMXNyTbXbWlC+0p2G5PQUAqC12B1bs0w3V1qLwcHOHrqqCWt9lsnoIYhBQqe1h57ORZcEhN094pntpe4nlhXUtdDcej1iluD7KT6Ta+FQIxqlmbIzaYzcbbvEnV1sr4frnKTJnRxHFNpYdkeJu2NPcm8W4Z2NJ3ZzmYbMS1TtUfMKNZrI9ClGgjPoTiZTkcVbF22Wh9IwmQoVrpOhhgOYzWSKtzYkHBtK2vveZN9soWnE9jhGCS1USqh+iWunLZqQGLSPxKjoqopMKcZE1pI5TT9e1GRthUuH1f1vhRXum7hkDcilaD6OcnsPZLz91Lfy2O3P4mM7fkYRleJtp558pXft/g8FHVtRRMsnywfx8a1rcFOIbVaCrtvCyDkR905nxAVtCKRgbGkkarIIQhO3I5yDbk7MJSH9cmGpf7CKum/wWQflWz1Ey/VfrF6fPf1YCKFNEVDT1krYWSmEW+vcMJuJRWqWgjbo3Ql2I6fqmQvSuYJThI5DVZKN4rsOO0lRX6pEw7CxTjyxjh7NCHeeIZYlKI22ltBJRfcwnYm4v2nQPlwcpU3t55GYzQ7pXpc4kyYypqnQgPIUikqS6ZsGFYM0mN3OUofQdA64hS1C9PYq7JmJTDrKBjWdS7MxncrEZjSRFfs2O0bNSowz2EQvVy3dpCG5cwKnd9ptB6IxYhwAMklwTqYc7URBT2ZQlERj0BvrUnQ3jehz6gb6XWKWoJtGNDS9rtDoJjNJFe90ltOIpmslXPAs6pX2YOftVGZUSoOgxA5Y1wHtIdj2eROPGZeyrzZpeWhCsaOS9Paw0W8DJzWqzmU/YySkRjQ6Z0bEnZkktS8CFu2B5l8pMEI3Q2nJ3FFKhOZGiwNYVYvVsVJynbR0rDieiPtaIhM8bTTJWkpdWEYho44jujryyN5t3Hj8YTSZW1nxXkY8sO5/5xFQXZJtrrDCpccqB+QBgE+s3cBLvvGFh1xA3nbqyXxy7cFXetfu1xCHJhi6gq6qCWhyVzNKkGTmyT53PnYyGI+lQM1zdLdDnM0J80LStK1kgsQQxMWnaYipI6z38GkrOL5IJ6VLdWySzC22tcDyPnV3+6C98P1xUoQvqFMxdajJHG6/k1iKA5jq5tKE1QFTR5rzhdG10xjfcegqJToNRooMBcS6IU4maGclaM9ZyS0p2mZuXrVC5ijnWRvw5ya439V5CE6cvdR1m5jSE6xMQXxq0JXHnW4dk2ZzCfdzibibIZa4poxEI5MCFUBXUVy65qU0IFVNnExQ3S5qfQ3V2jXHqkJPlFjBliVmMkNP+rh+RtQKMxZLWnodaWKLSgT546lMYXwQilGvIwGRZQ11JZSqxC2pXbQFN52OFO11Q+x1oNch5Amhk6A6CarflevUaup+QtMzogNafFSLoMC6tY5G3KzCsIfKkn1aHPsTHMm5CUJ1ShzN8b4c27xGz2uoG6EjgjRoRsOgiy4akqKdLFoDweMn07b5cKjEiQEByPlbvG+WQllj6pFMUuqGOJ2C0qhBT2x8u7ksFOyNiZNKPp+qlm3nuZgEjB2fKa/iUcmdeBSZrjF5QzAry/nLiQfU/W9FwVrhqwiXrQHZ3d3lc5/7HJPJ5C4TMr/lW77lcu3SAwqfWLthJbi7jIjLojiy5mZsmJrr3BZ9V3C7BXyUFW2QFdYQRAORh31bW90W5jHCeCJTDpfI39JEKDFGScJ5qi9b83HwGIGLXiBb8v7riCnbgMCO0IGi1eJkFKMct2p/mrQm9HN0E7BTj3f2nByJqMA7Rd23hKSzbzvbOEw3R02nkq1S1SIkzkXgTozEokBPnBTbiYNuZ2nTuryZX8TxRSXi6fnJdF+z0U6l3ERj5ilm6ojMpQHqtDkwsxKjNc4oVJTPUYXW4hhAK/R4Lg2B0iK2Th0qBKF6KSVCci//jrM5FAV6N5VmCkQz1M2JmUVbA7MZYTxCGdNOPgI0qdCJYiTWdbvCLxRBFQ3KdQiDDiEx0tSMpiKC77UNYiNNR+w4VASfGuq+ETvjsxpj3UTcuEG3TlDRauqNHBVy7G4h5gZarhdTBOykEvvfGNGzgmZN9EV21Iq/G79PtQt+XyDfeDEEAGn+8hzjvTQKSKOhnCMWhVCyWq1LrGtowwh1v9c+bkQ3Mms/O6XA18QQ0f2eaEBqycGRaz2iGsWezymiQRPp6BJr/aEAzBUuD1b3vxVWuO/hyBuQD3zgA/zMz/wMH/nIR+72uUopmqa52+etsMJ9HkpRdRX18Zobsi02tGVTz2iiQTVIEbKw8CxroYFkqWgHFrqIbrd1uwrCt58WKCfFExtD0Bo9qVBdJ0X5V8Gk3NQRN/bYMxMRiVtDjA5VRVmdH43RaYo6tiETHmMIqW3D5gIqRFRUy4L2EB2sq6i7+9Vd0zEQ1nF1gz+zJQ8uxNewzM/AWVkhdxbylKj1kiJ3MdjfBw6FPsofock1zSBFTyRjImYJoZOiGmkyVIzYcYkpTKtxkOMEiGkC27tCbep1xfYVpAC2FpxMxFSeS4NaVkILms0lVbzXBaXQ4ylMFBQlYeFwZa1cbz7AeCzaEESHJNS/ZLn4GVOH74jGR1dezl9VQe0gdctmKzpDnRuanqE5y4TgoPDczhrMtJIgv8YTVYd6YPFOL6cmykvGh96biSWuUsT5iKSq28DAUpp3L9kcykrKYSwKuKMgpqkI5luNkcpSOUalpenShuiD0NkWzZhSkvtRCuUrGoMa9KVRmRey7boSqpYx0qxmYgIQE7dMjSdA1BGnPHXUPMg2PCa7lavWxuwl/Yu+tlZY4R5hNQFZ4asIR9qA/O///b95+tOfTtM0ZFnGQx7yEI4fPy4rbSuscH+FlgK5WlM8+LozPDy9nToGOjqymU65RdGuGBvUeEoYjVGdXALdmoZQ1bJK3u8SOhmqKKU4SoKsUM9mIqzVWlZsVfcuMyuuNA4WnsnIk94xgTPbbUJ1657V7UhRjLhg1Vev0eRG8hkWNBqlLhi4eD6LXp8qqo0EM19Dz+aEyVQK7U5GOLEuOrOW1qOmc2InI/ZyERKf3UjcDS40fVIRTCm5HX69Q9zoyuM+CB2palDTAt14oQ7B/mQszyQIMMtkwpGmhMyJnawzEpanZqhOJnSoRhoDpRQ0dn8aEAJhe1cahhBlZT9xIsAH2BsRCgkhXFoHL0Ibx2JDS+LQdUAFMQaIwx4xsYTE4LuOJjetBkgtqWRnTz4WDl9RibhcVQ1qIqnjSeYIridNSCIaIl2zzEqJZUWYzYh1g65q1MQRrZXGq2mkMVBKnMWyTKY4s9m+HXIMy+kERqO6PdnudL5/P1pkecTY5qHIuWI+b22OK0mMd1YmI+tDuXbmJZzelial14G8S0gkyDLVNR3d0FGG42bORjZl19BqvFaV3QorrPDAxZE2IC9/+cvx3vOjP/qjvOY1r2E4HB7l262wwn0HCuoePO7Y51nTM7ZDABRDN6fJIOROBK4Lt6HFf2u9n4S+s4faG+1vstORFd3pjDiaiF1tv09I9YUdp64gDjYepoq4iSf94h7cdqdoXTq5HHeMUvzl2ZI25L64xZIprxTRGpxS+FwTjTl/MGGrL1gUvlFB3TVwdZecq9FfOi1cft/Sm0KQ5m9k8GUpk5eTx2hODqSAvJc93UJsnYxr3Jd3iIkj9GTyoWYloZfjuwkGULsTCbjLEtFl7I6Ikym6dWNS/Q6MZ+jtMdS1TDlAVuDb6yd0UimOx1OYt1qTJJECfNHsgTQfeS4uXIu08MSh+r2lNoaqliyQNCU+6Jhcr5MKXVaEYYfiqi4+08tmI2p1aAp3QTqgaulpVoto3BqZJNQe5eOh/BLtI2beoKqa0DRyPFqJdqPXk+Z7VshnGgLROZQWS1yMQe+NZbrRumDFlsaouj2h/i0ajpFY6sY2aFBsmVtziBilUdNajB+qGt3poAZ9/CAnJBYbREcT5wU6RmKvI0YMLtDXBY5IHQO3NEO+MFoX/dNd0JBXWOErRjzfD+Ml2OYKKxwBjrQB+dSnPsWxY8d44xvfeJRvs8Jd4NG7txwS37391Lfe79Jf78twyjPUJUOtqGPkhBsTHajSy+rvWh+dpcLdD4t061R0ClUlxeXmOmGQo+Y16vQ2gIi000R4+PrSC9APhsTJA4c1Hxf1XhFsGcnuLHHbM3E62hvvF3oba6iyIu6NoG4Ia338IAWlsLtz1PaeFMEg7kNAahRRZ0K10vur6gdtXVFCe/KJuHLVfUM0PdKOw56ZQFmh90TAjfeEZj9HRU1mOKWIdkiT3z0Na5HZcXA/VKClioEpImYilChV1ajU4rspKnc0HUdINNFpjNWYnSls7UpORSlTr5g6fDchDlOsM6g7tuV8IZMirIWyEs2BM6i6kYJ+fQ12dkX70mpFlLPtJM21+peyteGV0D2ttUxcykpoRcaANYQ23DDmjmYtox466q45FBZ4T669aBRN12JH0nzHqzZp1jKartnX90RQnn2amtHSXKXy3SBGoSpWNSrPUP0eMU1EcF83hE4K/a6ko7fPi1UlVKuyEi2NMSitWxqetLtxMhXb4cFAkt3rmtjrEBKLmReiD1GKOJ5iqhqjlExaQpCpCMDWLmk3w22v8aG9h9LRJY/LbsUQscbTrBgAVwyr++EKK9x3cKQNyPr6Otdcc81RvsUKd4FH797C6z76pmUK7EY55rHbn+Ul3/jC1Y/uZYCu4Y5yQI3Gqche8Hy+2ECXSPGcJYQsQSVWpiGTmXD3Y5QskPUhpAkhd0Sj0FUtqd1Z2lJpwpGspC6TsyceN23AR5quCN5ppwrB3nXRedBu1xRiIRtnhax497piW1pW4j6kNDFLaDZzynVHVIokNaRVLcF+VY1qGlRZYuuGVG0QtSStLwS9KkheRLJXtavxSUsHEm1G3dOEJCNNDWZaS4J34lDHNmTR/sy2iJOnM8my2OwBF3YrWiaUx/1/qzazIt2pJe28bvMqiraRBNCaeuAkLNAq7DygqoCetxOHeSGTIUA5R+jlNLmh6RrqjiXtJJjtvrhj9XKKqwfYWY0Zl0Sr5RqJkdDryDW1uwchoget7qDVvFA3y5V9Fo5a05mYALRaCEIgTueYGOHYgGozp+obfPKVN7yL8Ma6qzEbOSZ3NF0ngvUDmpFFMwcIzSnL0Eqj1ofSfOzsimvZVcfFhrpsWncumQ5pY5aUtjidSVPR60rzkjjCIKfpJZhZjS3K5dQnzGboNIVhj7BIWo8RPRUxu+r3pMEZjUW35b041TkrxhBKSTihj6gATTAUMSF8NQi07ud4INwP4xEM11bDuhWOCkfagHz7t387v/3bv810OqXb7R7lW61wHvzAzR9Y/thC64Ee5fGVI8hlQISpT6ijBjxfaAZ85LYHk+5GsS11hugM1MgkYzYX6kgnl6A4gMaj57JqrJqW059lSxFxsPocV6h7A9W6VCUjT3rnHLM9grLCtbSW0EmJ13Spe/sTiPNtY/H/IVEUx3NSrTCfv6O1EU4libtdiWZzjXqjQ7nuxDUJmVq4YQcz7rX8fi2Tge3ddkKxSTiR4BO1LPzdqMHMaqJR2MTgM4U36pBlcDW0JIAdV214n3D+zZ4jTmeEGKUAvZvmakEt055loWzKQLpdYr+4RTizRWipXipL0cMBcdijXstoOgaftjoIHyXjYmtXQhCzVChEiSNoCbULqZbzkkPTzbHrKXbu8almftxiC0u649ClRzuLmhXoWSHTjG5XrpUsFRpSa90cjULPa9RMJi0qcdKA1bXY7YYg16P30MnwubvXzcf+CZTPothwmNLKv90+9WrRzKkg1VTsSNChGs9EN1XVYiTgnEw6YpRMlKIU8bhS0tx2slZor0WknufEjSGhk1Acy/C5xqYaM8lhb4QfTQCI1oomZ5G0XohNc+x1xDpaKZk++rB0dIzeEydT0AaVJJQnutRrgVPdM3xNcjsd5bnT9xnNMrJmVdFdCazuhyuscN/CkTYgr3zlK3n/+9/Pj/7oj/LmN7+ZrHVZWeHy4NTkjkPpryA/uqcmd1yhPXoAoS3QisYxjQllnHKn77O30+XEKKKLBlXWhCxBV424/GgFx9bxa11UWaP3pjCdixh50BH71dZCdLmSre+9VmG5y23z4WYBO/PoUlblw3iCGo1RaYreXMNUOU04f+OzLM59m29RBJQXOpKIhUvU+hrx5CYhdwSn8bldWrYuttlkmuJ4TqZOoEdCT9PjKX5nV5qQPCUkA6qBRcVIul3j7hjJ+WmnDU23K2LyRaOkpdAlgtkaQ1EuE7Pjwn0viA3whdLlVUsNSiYeN2lQTSQkmmAUdu4x21PiZLK/PUQUHrs51YmuNFmpFPHKL7bnoRQ6VJxHzLzEr/fwmV1mjCz0FZK7YqgWqfBRjqnpGNJ5+57ew6xB5ZnQrRpJlV/QrQCqYUISInZrRJyL6F33uvL8BR2t2yHmKdVVQ4pjyaVpPjjsXLY4hngw36VtzJQXbVAkwEIvsjeWBqPNj9HbQumLpWS6xLppAyx1+904vLMhdxTHMuqeXjY6ALgEMxzI8Ve1iNOtEaqWa+15EysTkca3upogE0mjwUkDpzJDHPRougb6NV+T3cZxM2U7JHyx2qQqHXlghSuAB8T9cOWCtcJXEY60Abn++uv54Ac/yPOe9zwe9rCH8f3f//089KEPpdPpXPA1z3ve845ylx5QuLl3ko1yfOhH16O4uXfyCu7V/R+LTIhoYN44vlBv0lUVX67XiYUhHQX0HdvEosSsD/dXmxNHTBOC0+hoiVmK8kE4/hOFms4PcPr1vovRJcCCdpWMPHbaSJCfM2hrJeG5dU0KnXS/OLyAU5T2YGcyDXC37S6TopcuRM5SnezKlGPs0U0gKnvIWhcjUxBURmI1ZlwKvz9EwrzA7IxIjMHMxa3J7hXiHuVl5VpnCbrunHPzDFbRdA1u2EVNZsTRWOgzyw9Pikpi3C9OD5wjFcBNA/mXpqjbzkji+caQkDtU1YiOx7TCamtlW2lK6KXUPbss4g9vWEkGTCo0oljVqKoh9pyETNqzCv9WyL3cp0XTN29EY+O9WPYayRQhBNlmSxHSswo9SPAdhxn2xAWqlpTv0M8lhHFWELOE6mTvUNN0KXVGUUNA7R9D63Bm6oidemwhgY52ayafvVJCTYxRmoQQoCylYUpTlEtQZUmMUfQeQRLT9fFN0bt0c3Hs6oh4XpcRO20T5q1ppyMpZmdMbJ3ImkGGrj161Gp4Gi9TIqVgbYCaF0KZzFuhe7+D72eoEHFpw+OyW9k0kY+XA/Z8jrH+kk4sV7h4PCDuhysR+gpfRTjyHJCPfOQjfOELX+C2227jta997d0+f9WAXDq8/dS38tjtz+JjO25G0qHfdurJV3rX7t9QiiZT1L3I8XxCpmpu9wM+uncD+Rct6ZlWAB0DoZdJMT+eCPWlrLB7Qj1Rs0JWp+sGxhNxAvJerEATh6K7f284y5r2Hu3uQq9RBdyoxp4ZS+Mzmy+584vVZNUEzKzBdMw5xfTBoEE785hJKavFrRWqGg6Wq+tuVGHmGj1viE6jG3dOvkcwsvqPlmaIxC3tYWOM6PEUvSfNDXmGv2pdiu46EJ1ehtkt5Rrt7ja5pl7PSHcyCF5sbtskdLRGpen+OT0Luokk4xq9MyaMJyJkns/3s+WCFL86TVHrQ+KsgBhETB336wPVfl5RK0Lq0Cc2UGVPiuEYiUq+qxfzudkiyD5NC1hMyHxA+dZ6NgY5RmuWk5i6Z0i3a7GQjZG4uYbvJoTcEowm2ZL3rrv2bpuPg0L8i8Xis0CBaiR1XtfyPzNrsJMKmgBGyfegrGB9QMz76L0p4fSWUMa0QueZNFdGy0c2nYpQP0uJ115NdbKLKTwh0ZRrTq4pRJ+ki1qoam1jo6cFcTonTqdoazBZKhki81JsmtMDUxHdiuPrRr4feNTOCDuZU69dhdYRoyJDnfCIZIcv1FtovVpOvlJY3Q9XWOG+hSNtQH7zN39z2VBce+21fO3Xfu0qB+Qy4hNrN/CSb3zhIdePt516Mp9ce/CV3rX7NaKCaMD3Al83+ALX2B0+XV3NZ3aPkZ+OmKnw1KMPYquqlGQOVBWqclK0141YsmZrUvzM50vRK0pLIX5w5f4SfKVUg9DBRhPCbC7F1dqQ2M1RexPi7h6qKDHOoHxy3uNeFKPaB1AKf2KIqnvoSQEx4td6YDV6UmCKCoqS2OtgBglNpg7nmbSUo2rN4axC+RxljgkPv6iI44nYn1YVut9j4UQcjSYMLzxlDVZR9yz22ACdOOnd6kZyNNKUmKfossHOPD6xh4pvFUCXEp5HCMS6IbSWrQt7W5W056aslqF1qqiX4YKLc7W0pE0NwSh0mzVBkIR0ZzU+s/ispT8d/KwWzcc8kN82x962IxqEGET34ayI2utKJjJNIw5O1qDqHF1J+GEcT1FZSugk+K7DJ5qmYwhJDxUiTX73k497u0CqIriRJ9maoeYVMXPSlMdIXKS5a7Ea1ntT4p4YE0TvpWmtGyjaxPOqlmZSa1S/T8gsRGT6lGt82maMNNJw60kJexNiXckUyprWYS4VW+gQpEmzhjDIhQ4IYDVqWshrF3krVS3nXylUEylGKX9TXs1Jcwd9pXGqIQR1zmRthcuDB8L98BCt8BJuc4UVjgJH2oC8+tWvRinFq1/9an7yJ39Sgr9WuKz4xNoNK4HdFUBUimgDG2aKRzH2OfPK0RlLERXKShx76tZGtNtZcvFjlkigXLuyKo1IgtJSYqvELV2KuAQBhItiODhFSC0mSYQSlqayOjwviZOJ0L+KEu0cdkMckc4pTpW4TvnUYBILjaz+R2cJg5y6n0iSdmXbQL1WBF4GtIfgDu9XcEqyPABVp1gfpbCvalSWoQZ94s6e6FTmhdisDvqobrYsYg92ZwstSJMpqvUMZzS68lA1Qq9ppBEx2xMSo2m6huYsfQIhEgddtLOErR0oSrFO7rTNR4xi37rIrnBWTAXO81GFRBGcwU4q1GhCmM5kunMaTNWHYwOI5zZ7cMBlbNxOyowGT6v1aH9rQyTWoo9Q1qKmc9wdCrubSF6I0cTUoUdzXNWgBhnRKpqOuHQFc26Dcb6C5CttQqISvYfbKdB3bMt1bfrLfacJ+wGVXly5YinnW6eJpJM3khVCnqGGuehcQiSmrnWjivhs32VrmU0za2B3RNjdk2Y7TSFLUUbsd6lqoXEBMU8JzmCqWvJZyk57bitxwTJGvpfHNmiO9an7BjVXfKY8yTfnt9FRhuvdNuv9GYVbJaFfKazuhyuscN/BkXYEf/d3f8c111zDS1/60iNvPj73uc/xpje9iRe+8IV83dd9HdaKW8mrXvWqu33tn//5n/O0pz2N48ePk+c5j3zkI/n5n/95isWq2gVw00038dznPperr76aLMt46EMfyk/+5E+yu7t7iY5qha9mqEZxW71GER2promAncc21ToRbUW3g1/vE9b6kqzczYVuFKMU1necRk1mQvEY9tAnjsGxDdhYIww6+MwSzKUYf7TThvWE+tpN1NUnJEehbsQKdyHY1po4mWLmDdqff2lMJgyGapgQMkt0hpiLtsXMG+y4BB/xnYTQz8BZdNmgK7EuPVjgLqhYTSZi9Wg1qqzFGct7mZgkbYZDVQv/v65R0wI7bdDNeXeRaBR139L0E0KycBxrpwQ+yDSk3hfQL2lGGqEpdWVSorIMPeihux3Rg1SVvL9S4mjW76GGA6Ld//1bHp/aF5CjASc6G5UkIqqeF3CBcwytg1Ypq/1srMGJTRFngzSn3osYXmuh0VkrjcrpLdQXbyOOJi2tzsPWDvrOHcykQpdhed7PbpoWkxfdsKRMKc85n9vF4KCmRcUoWRxZKuc/RPAePZnJY/02QT5L0cfb6/P4Bvr4JnptKBoQ1dL1EidNfOPRsxIVowQDHgjrVCEKzRAkX2RtKO8RozShpTTdFDKtRGvZjrPyPSgreZ5LJJiwvQZV4yVoMkA0kY6u8DGyGxqK6HA6XDLTiBVWOAfxiP63wgpHgCOdgGxubnLy5OUReL3+9a/n9a9//T1+3Tve8Q6e//zn473nmmuu4brrruMTn/gEL3/5y/nd3/1d/uRP/uS8ovk//uM/5ru+67uYz+ccP36cRz3qUXz605/mv/7X/8p73/tePvShD122Y1/hPgqvqKPhuJmyZaaEIBQQf3INVXv01ki0HrVvc0FSSYeuvRQ4iL1nmM7QeSaFVZucHvOEpp/S5EbyOe4lFsLvqm/waYYdONyoRlcNupPJCm/TCNUE0EWDKeIya+PgdhTQpAq/6TADiykTdBlkylF7ohYL30UBuCjO1YUM59tJSNMx6H6Ka4JQt+ZzKfpBVq191VKYAsp7nLM0rZD7oGXwYgoSnCK4he2WXzpXxTwl5gl+kBymhCGvqQaOtAqYok0jb38f4rhN3rYWOjn0RJCMarUtrTvYMjFcSSPkc02znqMzhy56QsuLUSyK7+azVTEKzSizEMA4mSrFLEHNRAgfex1CN0OPZsSR309FT/SymI5tHgsgrl5nC9/ZNypwE48pwvKz8Zmm7uiltuIeoW3Cqo2cJAr1TC3oh8YJFTFxMt1pqVCxk0kjWnvCsIvq5qjRVJrkyVS0VK0oXKkaVYVlEbWgCUatqNdSVDiB3u3KNakUTOdyLgDSVD6DxqNGU0wQWuFScF7X4pTVzfcXDLZ2MEVJmlyF8hkdXeKBL/uUP58+jC+fWWOtWFV0K6ywwgpH2oB893d/N7/+67/O1tYWm5ubR/lWHDt2jKc+9ak8/vGP53GPexxvfvObefe7332Xr7nlllt4wQtegPee//yf/zM/+ZM/iVKKz3/+83zHd3wH//f//l9e+tKX8oY3vOHQ68bjMd/3fd/HfD7n3/ybf8N/+S//BeccW1tbPO1pT+PGG2/kBS94Af/rf/2vozzkFe7DiBqiC6zbKWvtMnyMUPUUzSDFjiuZJuyOUOOJiIShdcJyorvQGm3MkmalpnPC3kisP/MMe/UJmt6Fw/Lu8T4v6EmpIlgrydRKEsa7SqH2JlIINh7mFW7a0OROkrTVWdtp/9cYhU8M9IysOod2Bb2OyxV8FaOE7eX6vFSexX7VHQ1RKFy214GYy3maFTAvlsnmiyZJFRWm9Civz2kkFtuVfZKsCT1N28wRRdMX16qFBe5yv1r6lulaTDdHN76lPgWwFt1NxW1p2JEJUKpFWD332JlH+Uhwum1+JKndJ5pq4DCpIdmhbTBTYiclaiVp9OcxGYgamsygKosuGnTRJq4nEnBJJ4EgTYqqvQT6DQdSLBstIZdKCa1O6/baM4REnePUtLAfdhNPdsdMtBBKETNHM8wJVsIyL5QNc1fXXDSKemDQdYYragg1aE3IrOiEtnfl/HZyaNPOVSXPicM2fVwrVL8rn3NYUO8Q++aqafU3h6l4Ta4JJ3KSxGC3ptL4DHoiaK8bOR/OoqopYXcPdvckL0WLJbDq5PK8uhE9VpqiYnsdVB5dKPa8NKd9VVMHgy+MfJ4rrHAUWLlgrfBVhCNtQF71qlfxh3/4hzz72c/mN37jN450IvCyl73s0L/f9a533e1rfvEXf5GyLPn2b/92fuqnfmr5+IMf/GB+7dd+jSc+8Yn86q/+Kj/7sz97aN9/5Vd+hdOnT/MP/+E/5LWvfS3GyBLw5uYm/+N//A8e+tCH8nu/93v85V/+Jd/wDd9wiY5wha8aaGhywEZunh/ny3lOV5ck1pPuBZIv7EixM5sJJUZrWXWtpajSgz50clmR9x6MI05m4tikFDEE4lyKsEt9v1nqQRQijG4iujqQuB6i6BlCQFfhLmk3y4lDOyFRB3ZULYL4QptWrfezLi64LQNNrqg2ZAXc7s5l5TtLUOvD5QRFKSUhdYMOUSt0I7qU8247RFTVoCcFcSY2x1obzCCn0sl5LVMXVr5mPceFgNrek8lHnhNTh9/oUhzPJKkdSHcb3NZUgvT6HZphTjSKai2RhHYj9Ldk5NG7U7kmilJSzddEDL5wGDvU6GkldrJFg6o9vp9hZ4VQ5HYN0QqVT/n289O6NTFQxJ4kgSsfMRpCmzvSdM5j+4u8ty0DyW6FnlUSzgfS1ISInQeCU3inJNrjnjQhWih2bDigj92RbBc9KYX+N5nuC/tBjqs9Nr1oPhsPJzaWdshq3trwlhV6NEdXHejsXwMqQLLX4Hbm8vwl1UpJs7NoAp1c66qqJFHde/T6GnGtT1QKvbUr2qjEgZZskFjXNL2EkEec8mRK0beKJw8+yZ9e8zBm+VUXf3JWWGGFFe6nONIG5A1veAPf+Z3fyRvf+EYe+tCH8pSnPOUuc0CUUvzsz/7sUe7SEjFG3vve9wLwghe84Jy/P+EJT+ARj3gEn/70p3nf+97Hi170ouXf3vOe9wDwgz/4g8vmY4Hrr7+eb/u2b+P3f//3+e3f/u0r2oA8eveWQ44fbz/1rXxi7YYrtj8PCGhZ2Z6fVFx13TbXpLtshS5fqDYpa0u/jjCeHqLuoA2qkxG2dyXNeTpDFYVkF8SINgbVy6VBcQ61sQZlRcjceVerLwX2bVJb157GE6czVJoQN4ZL6tg9Wc09VDyfpymRP7Sr7We/btnMKHyqSOuA2mlD9LJNYidDsyZFdmxtjCdznFEE18En5oLBiaqohT4zmRK9hxgIiVk6Jp093VlQeNDteWk/KwA6GU3Hyeq6lUI3GEXUWhyVZgV2QT1zA5pOQrRtU5Nb9GYPkzjU1q4U3lmKLgOqc54pjgKfiqWwKRqx+g1RxNGzuTSrMUKSiF5lXraBeg69NyUZzQidTPJepiU0gaaT7zt+HWguVQRdRcy0ElvcooSmQdc1es9hB12gT9U3rXXyuZ/5hbBvDKAxXYu7s4HtPagraex63eWEMI7Gor1QWiZPabqv2wmB4AxaKZk05QlqZkWXEQ53yipG7KRCb42E7rVwZmybtTjo0gxz7JboZDi2gc4yybRppzNirdxuVynREJUlVBVut0AXCXU01G369g12j69ZO81fple177eiYl0J3K/vi0eh2VhdpiscEY60AXnFK16xvAnWdX1BStTiOZezAbn11lu57bbbAHjiE5943uc88YlP5NOf/jQf/vCHlw1I0zT8v//3/+72db//+7/Phz/84SPY84vDo3dv4XUffROqvfltlGMeu/1ZXvKNL7z//NjeRxGMZIA8euN2/lH371nTBR/YeyTlrT2S3WoZdBcR4bQynlgoWbnv5mCMuPvEKM5FaSIp6Kbl6Pc6qG6O72fnX62+hIi6TawGoTgljtBJRGjbZn6o5J5Tb5bbP7AirZuInUdMJYW0itJwNLluqVBixSqUpJZmY62s8LfCcZxaNktohcrSQwX1wX3UPqKbgKpqQlmCVtjNY/hrj1NuJJKafhaWmSllEDteo4XypWuU0fhBTtMx+41Lq5Hwwww9mYlVbpv5YoY5es21DQo0HY2unUwYYEkls9MGnxnqsyhOsXUcqwcGn+s2lf0YZj5Ejwvi3nh/v+dyfGHYxXcS3G07EsJoNDHvonbEFtkMU0yt9xtL1U5aVCs0r2WCwlpfrH6Vkm2XlYT6NRGfapquvkfTkMWEy2eK0M8we2PCtJb8mF6X2MnaXJyCMJvJdWDtfmaLljwOM6+JVhNyJ89JEzm/7TV8aGKnFBi9DPuMRSlCfYAmw4xL2BuLo1iWtmnrFeyNRA/SBogqo5cNkup120akRtUKpzxFhC97SxEtfkVnuaK4398XVw3ICl9FONIG5Od+7ueOcvP3Cn//938PQJqmPOhBDzrvc06dOnXouSC6kbquD/39Yl53ufEDN39g+SMLbfBSlMdXNoSXASrStSXXmQldrfhSsUb3ixp3Zrak6qh5Kfa7pWRaqMSBSyAG+e8KWdG3ltjLiSFIAWgUwVl8dv5V/UuFxcq0TzVhkGNGPZmItELyaJSsLF+CG5SKYItIdqbAbE3aRiMSraHZ7FGcTIlaEtZ1FSR13Ll9vn6MUhBOpkKlms/FnegCwnZpIiJmWouNbp6h+z3qq9cpTqbUuT6vCFuFloq0U2F2ZsTUwlXHpYlJHNV6Kknbi8+ldRerexa7yG1ZOGRVHjsPMp0xIsaORsIeSRNx99IKuzVpJz8pPlGHmWRK4Z3oSKKGcs3iZgnptsPGKGnvsxmxKNGDvgj+20YuVrWEOcYoov4YSb5scDuJiLKB6DS+66i7klQfrZb3j3HfTADR29g79nAhEjoZ5VVdynV7j4XpIkjPyOZrqLoWJ69ORkgdZjpHOYuybhlAGKtarI6zFFVUqMYT00QyO+a1NBZtJsyiAV3oWaJCNB5BnNPCbCZmC9aKxsQaWRxrvASB7o2JTY1qGjSI7XK3I1qRTia2v02QcEy1b84wi0aaj6M1nVzhIrC6L66wwn0HD9gGZGdnB4C1tbULBiOur68feu7Z/734+8W87nwoy5KyLJf/Ho1GF7HnF4dTkzuWP7ILGCKnJndcsvdY4e4xi4a/Lwf8/fYx3CS2bldSXEaQUL1ZAXsB1Zd8gDifLxPDldHEbk5xsoOKkOyU0gBYTXDnF1dfagSnKDcz8ukAzuyidyfEXoem01qPntWDnK0LubtF34W+QfmILhrYHQutKQSUMbiqJiab+NSQ7JQyIdjeExeifg8IiJerIo7GhAUdyoubmKkCYA69n/IiDNcjcT1S3Q7NiSHlZip6hPM0H4uU93SnTYsfT2HQozneJ9p8ufofDrMyiRp8rglrXUxLFYqJrNCb0qMbjdf7U5B6o4PpJKJNGc+JkxnOGpquRXXNcvtLXYje/99SsB5Fq7PQCwHShIwLaXDaFf9mOkPtWHHuAuLunmzbGGmSjMYOB+hrNqjWEnwvRe9N4c4teY61xOCFLtg0KKXQxzaxg5S6bw/lulws1MJ6+OzfZa1ReY5u3bpUmrSUs5bSNplIuGe3g7ZmmQofnRH3uMVm2wmWqoNMG50SO2WQIMqiWOpAyFJpBJVCK00YjeQ9nZW/aS2C/pb6t8wNSSwhiTjVUEdNphoy5RnY8kgXDVa4a9zv74urCcgKX0U40gbkvoxFxkeSnD/kC2Q6AjBvA+IOvu6uXnu+150Pr371q3nlK195cTt8D3Fz7yQb5fjQj61HcXNvZQ18ObEbUv58+nC2z/TZjOC7KW57TNzeFbvQNFnqB2LqhHLSrk4ra1G9Hr6TonzE54am60humxNbncHZGoVLjWUOR8cQehlmLHz56Awh0VLYtVgW6V7cpaKWILu7o+FE6R3k+ZnFdjLidEqYz2VFOkYSWuqZ93BmFz8atTkqgZgmIhRu81J0lsqkJhMb1SWFTO3vo6kjyW6Jms6X35BoNNGeaySzPK4m4iYeuzWXcMYYYWeENVpyQQ5kfRykSSlkQlFuZmTzWrItFiLqwmNKu7QzblINxxKSXU1yuoZ5ATFAVZPsVZjSHrJdXh6bUYQ2Ld1NGxHoj2dyYvs90U14L3QpkPOTOCglzX3RcMiKv9gtK2sl12R7FzPsEjdTqrUEM+tL01xXqF6rY6obYlVDlhC7OU3HivD/HkI34EYVamsXP55IQzOaovsdEby3ky7mBX5nV6h6iZN9LUui90SjxbEtcYR+TtM5oJWKkoDuRhV6Wuw3Oc5CNiBkKXpXEfdGMB5DluFPDKkHCWnm0METRhMRpE9nMoVrBegqBjh5jPr6YzRdS+x4jtsxHd2wGxLqVedxxbG6L66wwn0HD9gGJGs5u1VVXfA5i+lEnufnvG7x2oP/vqvXnQ///t//e37iJ35i+e/RaMR11113EXt/93j7qW/lsdufxcd2zIwiKsXbTj35kmx/hbtHiIquqnl0/kV6a3O8S1uXHbGKjcO+FMDjiRTQO7L6HEGoWbUE7pnbzpBvJ/jjw6UOIiSt2PdyUMoV+FQxe1COHV6FihBcm2mSqEMr/tqDG3t0HSR9OlcEe3FagGikCcAYVJouCSvKWqHKxCg6gLLcX/luPEo3RGeJgx46TVpLXEPodahOdql7h6lq2rdUrr2ZrHYvKDR2v6FaTnFa2pUKETcLJHuVJNTbtlEsS9TOCFNk+LXeeVcLF01c3dXYzRwLqLpBj2fivmXX8WmCb8Py/AG9C86h8ozQzVClJxkVonUBcBbfT2UiNCuJ3YyQtxqSeUnsd4jGiMPTzp6I0+dzVC2BjarXlUyLqpbr0lrRtBS0ye4dVBSKYDByvYVMoU52yJpN9N6E0M+FFugsWueo9TXqYz2ZftiLvzgPaWt2p4TRWOhXxhC2d1DzOco5odeVJcoYdLvQowZ90Yhs78JsLrSsvRG610WlDlN6iHb/s5947J0j4pltmUAmSdt8uX063yJNPUZ02WDnRkIhtUF3c1BazmV7vcSZNL8KljbLeMU0JPRVpGNKyog0IasV5SuG+/19cWXDu8JXES5LA/LpT3+a//N//g8333wzk8lEVg7PA6UUb3nLWy7HLi1pUru7u0sB/NlYUKgOUq0O/vfOzg5XX331Rb3ufEjTdDktudT4xNoNvOQbX3jI7eNtp57MJ9cefCTvt8K5CFG33G+FbitaPauXrj1qOpdV6cQR60YKnqpC5RlxYygr6jGCl8JbT0v8MKe6Zkg1tOdQfY4KB3M4muxAJb+416mD04WIrgOmDoREn+tydRfvEWyrTdAKrj4OiZVgurISR6Pai8bDe6GmNQ1hNEZ3O5D0iZlrXZ4szSCTpPOOiKGXjVq7Am5mbXbD+lBoOHmy1LSoIM9XPmILySoJts3jWGRM1K3jUdOIE5NpXa78+S1zF6GDAHpWyAp6VYPRuNRR99ckL6WdBPlMjkOFAEGhdyfSWCEUvVjVqE6OYV2a1+kcdkfYLFsmuqumI4fdiF4mgtCx8gyOb8g1WDfSfDmDmhZwZofoZcKwcGdjrY/vySQpGKgGhmj6uGkuOSVNxPQyMQzoOuq+OIjdU3MEXUcJOFRKMjaMWOCKzmMin3l779CbGzRXr2PPjEVM38gERqXS5IfJlDAB1c1bqqK8hykDyW5JHLfXUZrK+3gPXss1AeK+lWXE4xvExMpEaW8i2hxrZGqp5RoUVy6F7naIIeB2C6LJ0TPHrdUxZvkt7IaE077PbfMhyl/8OVnh0mJ1X1xhhfsOjrQBqeuaF73oRbztbW8DuGDjscDlbEAe/vCHAzKt+PKXv8w111xzznNuvvnmQ88FuOGGG3DOUdc1N99883kbkPO97krgE2s3rIR1VxhOea6yezx88zSfOLkuydaVuPsQoxSD/e7+6n7TQFWj5iVhQ7IZVIiY1tmnXE8lO+KI3a/OxsFwwXMeP/hvrfC5Wa4CR32RU5q2AanWEmCwpHCZ9rzo8RyqWnIYBn2ZAk1n+8GD3qOmntjLqTZzqqHFH7AoXjZIgGpAN0GscZ2VKcpkjosRVI5uDKqJ2JkXe9uqAR+JmW0L7v3UdNKUcHyNpp+iQkT7iKkiTXoXx1034oalNbo7wHdTaXhCOwXSCGXIGXmfopCVeWNE9LxoVBMnjQeIiHo8Qc0L0SO0hTvI7yrGLF2cVJbKZASgFD2IqrUc18JpbT5vNREJYdihHthlToukwRvqrrhlyXlNlqGCwXCPrs2FKNzOAqb0NJs9rNGo7T35fEHOg3Noa4WSVteYvTlxOpPjNkbOx7AvzYD3qCzDDzs0XbOcxpgyLidfylmh6TkLs0YavPb4lVLiOleU+1kjoU25txa1ngmNbm8M80IaJqWEmqYUPhGBfh0NGljTFeNQ0wR9l9k5Kxw97s/3RRXP1eBdim2usMJR4EgbkJe//OX89//+30mShGc+85l8/dd/PcePH7+g6Pty4vrrr+eqq67i9ttv58Ybb+R7v/d7z3nOjTfeCMA3fdM3LR+z1vIN3/ANfPjDH+bGG288rxXv+V63wgMTTgWu0lO+/din+PjDr6U4ntP9ohQrhCDFaE8cdEzjpXD0HqYztDXouVidhl5CuZ62q89Xbip+d1oOCWHU0kAoDjUAd7vddnXdpxnJqMHMZWUZa6AoReTb6xG7uQQhtqGMWCPahhBojg+oBnbZAJw3Wd2Cz9u09NLL5KIJqGlBMi1InEWVrYPSotEoS1SaSgMwmy8FzigtQXaNqK3dbgkhIWw4wvnef2EhDLJiPugSnDQ8uon41lQgWEXdT0iPrYu2ZfF+3kPi0OxrL/BegixDFBrQQrtRVUIvyjP5W1mKbibLZGoyL4l7o2WjQtJqkFxb5AM4S9NPztUbae7SAOGeNh9uFnCzBl15aAKqqIhBrHZxVo4rTeR8G030gfjF29rGI5GMHFg2EarXI2z0qdYzmmx/AhINxDQR3Yb3Mr2gXRzLEpq1HOuDaGGyRKYc47Gcu35/f0KSiSDfNl7On2opcy09zuea0G+42u3S14q+TtgKJfPGyQTkbhbjVlhhhRXu7zjSBuQ3fuM30FrzB3/wB3zLt3zLUb7VPYZSimc84xm88Y1v5C1vecs5DciHPvQhPv3pT+Oc45/+03966G/PfOYz+fCHP8xb3/pW/u2//beHwghvvfVW/vAP/xCAZz3rWUd/ICvcpxGiwqjIDe40D9rcoxqcpLO5JgnWe1MJm0udJC7XUgypLJWiqqphJJkRzeZxsXe9gs3HRaHVO7AQSt+Dfd23/VVUQ4tdaAhiF1VJKnXIHNFodNVI4Nx0vnR5Ut0OIZMG7a5W4H2iKdccumfFcal9Xnb7DPOlM4TpjFCIoBnEEUoPerJwMpsLDSdG0e6UJcxm2DyTDIgYUfVAcju6+qD5ltCz2qA7lWfE9QExsZhxSbRaitYoU5tgFHXfoH0HqxR6OifO5H8qFfOLWNXSTOQZ2jkpwpVqKX7tvlsr7+UsOnFSLFsjhbIPrd6mtdxtZAqg8kyarU6OPzag7p2r57gU1+BS91FFklEttLgmYHYnYo3ckf1e0siMkfOd9lC5haYRK1wg7O7Jsc3nck4S+U5Fuz8tBGmO62Md0r0OYXdPGttEJhuxdbsKvRQd2jT0zKFnTq6xRdNQVqiywsQo39FFrk+vI6GHswI79VBrxiFjL0Sgoo458T795V3hqx4rF6wVvopwpLYcW1tbfM3XfM19rvlY4Kd+6qdIkoQ/+IM/4Bd/8ReXFLHPf/7z/PAPy4j2R37kR7jqqqsOve7FL34xx44d46abbuInfuInlrkgW1tbPOc5z6FpGp7ylKfw2Mc+9vIe0Ar3DShZZc9NhVaRVEGiPEVjsWUgKkUzyPAbAxH6hogqZRVbGYPqdpcuSTFGMJpg9SH3o/sqDlG1DjhB3ZPXRy3ZGT7X+NzieynVyT7za/tMr+swe1DG/OouzbEeJE6C4vpdmhMDmsxc8P0W+xYsNJmi7mqqgaHqGSlM10R7oxIJfdSJk//lGawPiZtrxH6XsN6HQU9W0Vv9QJzNiXtj4miC2Z2Q7FbYMiwD/VSQ4MPoNHGtjxoIVYgmSC5B0Yg4ugjoRp5rpx67M5cAw9FYnJnqmjiZShjfgp6Up4TNAXFzTaYYPsjEYLFv07lQg6xBLexpYyQMe8RrTxKvvwquOiY0IkA5h1of4q/eYH4yp+5cere1g7bGbtyg5w2qlmlUzBLC5hrN1es0J4eEY+uobmdJJcMs0u7DfqPlpNFiY4047IH36KI5JwE9GCX5OalMQGJVyXa1Ru2McJ+9Db03QxUV3HkG9eXTcu59m3g/FoF8GI1Ru2P5zvZ7hGPrxG4m9LeiJN0qcDuGz82P84VmwDhE+rriWD4Rd7D7AAtghRVWWOFK4kgnIBcK6jsK3HjjjTztaU9b/nsymQBidfu6171u+fjHPvaxpdPUQx7yEN70pjfxQz/0Q7z0pS/l9a9/PSdOnOATn/gEdV3z2Mc+ll/8xV88570GgwHvete7eOpTn8ov/dIv8c53vpPrr7+em266idlsxg033MCv/dqvHe0BXwQevXvLIbHd20996/0j7fU+jqggpIGOqbi96ZO5XXZDh91Rh2snHnXbnSQ7LYdcK1nl9V4KqjwTmsciCG0RCGfUZcsPOOgAtf/g/rHdHe5tobqkcmWyeq28JRqhJS3OQXCKkGTUgxOSwO0DIRUR911xlpf7pvYPT0WIUbXnWKO0aC1Ukoi+pGlkOlXWxKpCF5KhEX1oaUEimo7rA7G+jRFd+TYlnqX9KxHqjiWe6OJ2DHpnDDOx2dVKk631aU4MqPsO1QTSM3P0zmSZc6HyHDXoCZ2qnXYsCmcFy+ZDZSkqTZaOUSIoV+g0RQ36hM0B1bEOTS5OXmYecHsFZpZCKfbCcdChOJ4f6dTN1BE3Ddj5vipb9DYBXYg7YXlVF1U79G6Q8z0cELNEJl9VvRSDK2tRGwP5Ls0K4qwgDruHtFKqzUzxmSKsddHjHmF3TyYhzi3Ps7aLwMiWzqY0qmnENjtrRe67e4RRkHDHQRfaiSZAHPbxmaVe8zy+fzMPtiP6WvH5qsOXJkN0zYqCdQWxui+usMJ9A0fagCwK+7/5m7/ha7/2a4/yrajrmq2trXMen81mzGaz5b+9P2xB8rznPY+HPexhvPrVr+ZDH/oQn/rUpzh16hTf//3fz0//9E+f12YX4MlPfjIf/ehHedWrXsUHPvAB/uZv/oZrrrmGZzzjGbzsZS+7Wweso8ajd2/hdR990zL1daMc89jtz/KSb3zh6sf2iKEi6EJz63yDh6TrnDATvlBtUu+l6NYxJxaFUGiMRqmh8NKtldyKXkd0CaMpsaqgmxOMOhKHxfPtuwqSeaHaPI+FQDxYJdz/yyh8906B49wGSMvfjAFTNOhdEXWr4z2CS+7Rvi6nLqmmWctwYR21M5JzX5TSGFaVTAayVIrcupbpS78nz0kTfD9DdVN811GuuaVGYkGpUkFh55LkHhKDNgbqitBSyEyWossGFyJ2dwbbe/tC8iwlrg+oNruERKxcdeWxowK9NQKtCet99GgGFWJLm6Xo3T38aAKNTN5U4qiOdSjXLd6Js5dJNT7t4HoJulwnakU1TKj7hmCP5vNWQUTnblxLszaaiyNXnhITsQNWdUOyVSybEdXNCf12SrPIMbFWJj7eixHBaCqaDSNTDp/qczNZnKIepqTTIbosCdM5yiENZwzScHZylBsQ2yT55bTkQOCiyjNpSHwQOuX2brufHdSxHrjAVXaP48ai0WSqJjWeYjX8uGK4v98XFUcgQr+0m1thhSWOtAH58R//cf7sz/6Mpz71qbzhDW/gu7/7u4/svZ70pCfdrcvWhfCEJzyB3/3d373Hr3vUox7FO9/5zq/oPY8aP3DzB5Y/stB6nkd5/P7qAHJfQrSRE+mYU8mddHTDX46vp/s5i9sZi5BZa1hkHcwLEb1uDNsMC009zHE+oLwnZKnQry5T82HngWSvwU5rWZEGmn5KtZ6IruEChf0y0fzA1/CgTe892Y9l/sYi6ftC24igpyWcEevrpKpRcZ3ieCKWwfegCQlOLV3KYl3L1CNNpfivKnFOQjQhIBoMJjMpWBuP2bEylVAK3bE0HYVPYL6pKY5FUBo7NeSnHYNbKswkQfV6aGNkNX8+R+86dJqgJqJtiTGie138VZuUJ3KarlnaCuvakiaGtPagFPV6hosRvSUualiDyrJ9GYrSxDxt09rbyYCBRiu8M9S9fYem0GaS3OPP7Tzn9XzPUwHcuMFuT2WiszuS78GgD8MezVqHkMqEBqvRWkPdoOYVOEvodWDQIXQSccP64u2SdZKmYp/b61D3k3OychZ2z3XfYNY7uHEPtVgIaCloEsRoRP/RfgYxRlTbhIA0K6rNeVLjqbhxtaGREpYYodHs+g513GEaG/7v/FF88cwaa8Vq+nGlsLovrrDCfQdH2oBorXnPe97Ds571LJ7+9KezsbHBQx/6UDqdznmfr5Tij/7oj45ylx4wODW541DaK8iP7anJHVdojx44CFYRuw0Pze6kqyqKaPjs3jG6X46oqpHkbqNRRSKFbtNAURL7uTQmMUKAmCeoOoNFwnarlz7KCYRqtQfJ6akIlVu+vR1FQmpoMnVe9yMV2xTrqcdNGnTpCVZTDx111yxTse/pvl+o8Vi4ZoVESfietcTplHhmG5sl2K4Ip727uBDE5XFUoS3ebRvMZ4i9HFW0Nrazuax8pwmqrkVT0dJyWNjYNgHto4Q3ntRMrw2okwXOeZqg2NrJqLspJwpPMppK3oZqDQjKWrbTyaRuns2I6wPKE2ItfDBd3Cci1jfzDmZWoepASC0qT9uk8lZD5BKhisW4bDwOTZQWTeJZGqN74mS1bDwj+w3nXb0+iiBfzUvwYWkRTFFAJyOkhuKYTJFM6Uh3rSTQt/qVmDt81+GdRs9rCIFQliJqPLZBc3JIPTCE8zVRShLn60GCWeujpjP5/BInaet101oze/l+ttSsc9A0QqFsbZl1NxeamLX4joUkoFsRUADuqAf4sUM3F3deV7j0uN/fF1dBhCt8FeFIG5DJZMIznvEMPvCBDxBjZGtr67w0qQXuC/a89xfc3DvJRjk+9GPrUdzcO3kF9+p+Di3FuU8U2gnV77Tvs+V73L7T53gZCd0UPS2l8DKtvaz3RECf3oU0IeYpdiy2stFKGNsi4O5yULC0j0tHrujMkq9+tqD3nNcG0RMkt24T7jiN6fdQp64mqlR49y0tCi7iONrV+QUu6GjlFPUwIz2+jopBVtFLcVSyRkFX4xO1Xxwf3P5Z2xTtiRSiqEQskqsKVdbETgZ2E1XVhGFXKFTDLjEg+SBtk+hzS92zFOuG2VWK6YM9dnOOc56Fhlpvzhk9KkPXHU40m9gvbcuKezeXlfPWaStm0uQEZ5YaoIP7rGibkLUE175/SAxs9jCJE/veWrI8SJzkVTThvK42X+l1tRSTe6HtEUXkH+8uBV0pQirHrKZz0VskiTiZtaGQtNOvJtOY3GJSI9TEokLXDfgcY5TYIK8NJZU+TfHDLuVGOwG7i+a17mrMsQ5JuS4ZKIljEYSpJjNJYw+iPQGgzWVRSSLTksQJHa+TiTVwr4NuPDQen2hM2rCmZ6TKopXnYdkduEFFcJcl/3eF82B1X1xhhfsOjvSX8Gd+5mf4oz/6IzY3N3nRi17EYx7zmPtMDsj9HW8/9a08dvuz+NiOmVFEpXjbqSdf6V27XyMa8CkY59k0E66zu3yquIZ6J8POWgvWeUkcT4RzvqB1xEicilZJrw1hkYRujYTGtbSVIxeiLwr1GMUCeKuRScDGsA0VPP/0QwWWBSMgq8ZliR0VxNZ5yOeSkB2MktiEi6Rn3ZWrVTSKemBQsUeiFHprF0LAjsvWYjdBNwrV7Dc0iyaRg6vji305cIwxdS2dJhAyS+yn6EkluSypBa2wt+0QQ059vEvdsTRdTTHUzK5SzK+vSdZKnDusOzMmkK0X7D42ElyPqz6MrOIrBWUtoZRVvW/LPK8wRUD1DOpAE3IwO6XpalTbBKgmkmiFLcXhKTrbhif6Syp+XjQfpo7oWnJMxK737n/fo4a6Z9FFhpvO28LeEdOE6Aym8LiJanNvWjqY0UJRnBdCo/FBPq/E4R+0KZqhrqMa2mX2x11dW8EpqjWLikPMpEKP5rC9K9/JRQaJMaL/yVIRwI/GqDQlHJPvp6o9lEaakTwBH6GsMGXAF4YiSj6MQeGUR5sLTFNWuCy4398XVza8K3wV4UgbkHe/+9045/jTP/1THvnIRx7lW61wFj6xdgMv+cYXHnL7eNupJ/PJtQdf6V27XyMqRbDQ7xbc4M5w3AS+qfMZ3nTsiUSbo8cFcTIV/UDbfCzyF6AVG/uA2pugrJFV2dxdpp2X6YcpGnESClGapMThuyn+QKDb2VA+ku42pF/YbWlKuQh6bz9NMukSex1C7vC5o+laCbYzUvAfTM4+W0dwQa3J4u9acj18ogmZRQ/7IkaelZgYSRToeYOelfhhy/G3utWzHBZZB6NEH9HLlmniygdJpi89ykf0ZCYFJkj6eFmhG4/upfjNhGJdM7lWUV5bkfZLrD1/wWlMwHVqgkvQkwpVNzTHetQnhZ6a7FWY7SlqVqDmJXZSoYd2n0J18PwY8O3EQEURlqMTdNXF3L4Du3vCjMoyfJbcZYDgxeCgRkeul4ip2mbALZq4u24cxeVMkSRiW0sQhys/7KB3JpjGo48NiFZsgINT1IOEkFpMJ0VPC6FK7U1lwtNNKTczmq5eamQuJjTTJ5q6YzHTehl+iEskIR1EgB4jqtfFb/YxdUOcz0WL0knFOrgol9ofrAFj0D5A5UQDgkz9fVSEsFp8u5JY3RdXWOG+gyNtQHZ2dnjEIx6xaj6uED6xdsNKWHcFEJXC6shuyBlXGVoF1nozql6X2EnRTV+0FYlDb+/hz2wDoLs5an2N6CyMJsTpFJRGx4geZqigOUoluoqgK8kkwRpxGQKZADhDcBfhxKWUrLprRSxabUtVo8sKk4sg2mz04HhnuRrvMy10GXO4CTn7fRaPL6YtMrGQ4MOma1A+kynIWIpTNW5tbOsajMHEiGoTw3W9TnhQTjD7NJ2oZTtmmKNrj6o9YdCRlPSyQu0UojNpk69VkqCHA7G13ciYb2pGp6C5uiTvlWh9EUuHGhG+R0OTG6qBWRazaekxZSUuS2WDnXmCNYeC9Q59Hqo9LRrqrkFvZGR7KXF7R6hJ1xyjONERYfZXiCXlqonYeUTXAVMKRbDpGKI6P+3pfIhGEawG59Ab6/j1rrxHLTqpkBjcXo2uLVGBnXvMWBzDsIa4MyJOp6gsxadGcmMuovlYvr+Sa8fnGp9ZjFbiprWw4TVawiW1kabzzEgakhClMWwnNzFEsT0edIjOoGpP3bOYYcUNyRkA9oLntnqdprSShL7CFcP9+r54H5mAfO5zn+MP//AP+chHPsJHPvIRPvnJT+K95+d//ud52ctedt7XvOIVr+CVr3zlXW73pptu4hGPeMShx9761rfyQz/0Q3f5uve///38k3/yT877ty996Uu88pWv5P3vfz933nknJ0+e5ClPeQovf/nLueaaa+5yuyvcOxxpA/IP/sE/WOZxrLDCAwUqREbTjC/Umzw8uR2nPJltGGeLpfYgDQi0gXG6DRyUhGrVuu5EH1BKxLq6DocK7yNBW1iq1lUpWiOTAGvwHbss7s77Uq3wiSambXK1teiNzrL4J03kuOsGszMla9qJT9UQOgnzq7vUvbt3rdJ1xM0Cuo6yKt6RrJAmVcQ1S3AalzuhYE3mqMZDnskkyXuZPs0LjNHY9ZS6o5faGoVY8VZDR7IbZeownYsovChFR3HiGHo0AWsJx4bUw5Rq4BhfYxg/BMKDCvJOdVE5c8YGptd5bvuWdXq3eVQQAwMVJQ0+prKaLtkWJdkdCujQdKUJCeb8pgSLwrrqG8xVQ1xrbCC0MS5JrofQ7lrqVdVeL/rinbMW9Lu6Z7DXbGBGhVjxzkvidIbKUqzRRGewYyWThtGUOJ/D+lCyctok9LA5oB66c5qPi3LlUqKjqQcO2++i9kZt7osmVq2bVV0RdSrWu65tyo0WyuQioR3kuwKg5LuggF3f4YyfUEXNzfNj6DMJtoyX3Cp1hRWg/V5eahver2B7r3/963n961//Fb3fddddx/XXX3/ev13IwAjgxIkTPPzhDz/v3y4Ui/CpT32Kb/7mb2Z7e5vhcMijH/1oPvvZz/Krv/qrvPvd7+bP/uzPzml4Vrh0ONIG5F/8i3/Bi170Iv7kT/6EJz3pSUf5ViuscJ+CUrBhJjzSFYxjIDUNIyMFd5zOhWplDTFP0etrMg1wTgLuikJsQY2W5eyWCqT8UXYfLUIU3YMSbn2zllMNXBtId/73XtBZ0Ih7lw8i5jYaTCrbirEVddcwm0uhZyVw0WQpaeYISUqTnf89FjoTU4tLl4oRMLhJENpNIrqOYA0hVSgfcKNZa9maEZ1BT0rZmJHGSvl93cLiXYORoDrfsZjSEcsKxhOx5l0fUF0zRG/2hMa15mhyTZMqyg2Fv+rimw/ZjUB61Yw9lxONJT8dpBmC/Y85RjASrsdoQj4f4Ic5vutoOmZJT7pQYT0/kVD31oUipRaUt4ufElwQB1ZaQ2IIica3wZEXs+2l3a9T1D2Hntfo8UzONxAmU1RVoQd9aQBnM0KbwaG1ke9P4qDfpemnS0rfctsHbJxpr+fldXpg/5Z0sI7GD1KstfL8NJFwy51dYlmilYZOXOZ+gFDaaDVCxChZIHlK6CTSiEXF7c0aA13Q1wVbZRe3pzHVagSywv0bx44d46lPfSqPf/zjedzjHseb3/xm3v3ud1/Ua3/4h3+YV7ziFff4PZ/ylKfw1re+9aKf773ne77ne9je3uZZz3oWb3vb2+h0OkynU573vOfxnve8h+/7vu/jYx/7mNiAr3DJcaQNyI/8yI/w6U9/mmc+85m88pWv5Id+6Ifo9XpH+ZYrrHDFEbWik5Xc4LYZ6Iw6zEmMl1Xr3GF6HUI3pz7WQfmImQnNJyYWPSlQZ3ahrsAl0DTE0QTbyTB9KXiPevE0GgVZQugk1D1L0xFazYVE8PuUKVm1152MOJoQZnNU1joE1ZJavQzWc21mRhsMaiYlZs3RtGnm598xoYiZoiGkBl0H3KgBUoI1IjpuAwpDYsTNyAdU2cj/Wl2L7nYIvQw7rclDpO5amlwti+dgFXXX4JMc209InUUVFb6f0eSGZsMJfchIAV0OFdVaxLhw0c3HAloHcEGK5wWFKrbn0mgpso2WFf/ZjPjlOzDbGWZjiDrRJ2pHrc8S1HNwoqMIzuwr8Fva2r12U2snGCGRpmPhcnZPtq29hBHaWUN0hjDsoVKHCq0Ivz1+VTdynWgN3uO3ttFZiup2UY1Hl400iwqhxvmILQJmHlAhLvcxakVwCp+qcyZtwSqajsUN+kszCJxFdTooY8QoYmsHNRzI51E3rfA8FbvqvTFxNEYPB9BJCEaRZhXXuG0yVVNEy6RO0XVLIVxhhaPAfYSCdTbN6l3vetcl2plLh/e85z186lOfYnNzk1//9V9fTle63S5vfetb+dM//VP++q//mve973084xnPuMJ7e//EkTYgp06dAsSO9yUveQkveclLOH78+F3mgHz2s589yl16QOHRu7ccEtu9/dS33i/SXr8aEKMiREUZG4oYqXwbXudEWB4zi0/bVfhaeP91P0GnBtd41HgKeQZVTdjaRp3exq13qIb2kBPSJYUSgXZM3VKEnexV2KnGZ4am13L8zVmvW7hgKfCdBDXsoquacGZKLEr0sL90/EJraUrShDiXsD1A3IPu5kanoojd9azCjMJyquJSs5yCgDSATddgjvXRRYMezYh7Iynu04TYF62BvWMPYzTmWF+Sv3sGn6g2FV21mRsGfbwLdGlyK6v8br/Q9gnMHhQJDyrI0vqen3IFykTqLjS5ws5jewxQDRzQw0xKiA6V5xJ4V1WYNMEUOXYqK/91fq724mBq/DmPfYU4mCYe+oebmovd/jLwchZIdirMuJSsG42I/mOExBF6Gb6XYrWCukZVNdEYtG1T0JuGuL2L9YE8QtNzRKUwRYPdnaN2JCE+Dnv4XooKEZ9ZihOHJ22LKUjdt9irhrgvNMS9kVynvQ5x2ENPZsTZHGIUjZazsm0rie1xMiXMC5S16GkH6GFN4Coz4kGm4uamw16ZYcq7t7Ne4Wixui+uANKAAHzv934v/X7/0N/6/T7f8z3fw6/8yq/wW7/1W6sG5IhwpA3ILbfccs5jd9555wWfv7LnvXR49O4tvO6jb1qmvm6UYx67/Vle8o0vXP3YXiZUaCax4nafMqlSdBMxowK2djBFhxQIqUXPKtSsxPmILmuh21gr1JOylGbAmH0q0xHRsKKCJteYnsNtN+hxuRRtN1evE1yGJQiFh30dgPLy/3bmMZOKaNp8hx1NqGpiWYkr1snjKK1ktdsZ9LyL3t4j1jXK+wOUmQsUsjESraIZZLjb92BrF5Um6LKPbuI5GpVgNSQG1SaCx2GvdfOSnz1Xe6GcNYFkpwRSYhv2Jw2Gou4qfJbI9hbUpYNWuBpCEnFJc4+nHwsknYrieoXyCb0vgQlxOY2RsL5KpjfzORgjuo/JBPOFRly/GIoL2AWoT0eSS3ag6fhKoOtIulNhT4+WTUd0ViY+uyMoS3QYtlOP0LqxJejESVZIP0dNCzizTdjaRs/npHkuuR1FIdO2RcM7m2M7OXiPHvRoeg7vzDlTo2ClibF5CvO50LacFXtdpaAoCHsjtBoShjLJV7NSUtyrGmUMatinXu8QWqlIES3jWDMNKVVjRIC+6j+uGO7398X7yATk3uCP//iP+eQnP8nW1hYbGxs8/vGP53nPex5XXXXVXb7ur/7qr3jOc57D7bffzmAw4Ou//uv55//8n/PQhz70vM//i7/4CwCe+MQnnvfvT3ziE/mVX/kVPvzhD9+7A1rhgjjSBuRzn/vcUW5+hbvAD9z8geWPLLSe51Eev986gNxHoH1kb5Lz8eLB9PPPUEf5FKJGKFjOtSJvjU8NyieYeYW5fUuoSk0DIUoBBdJ8BBGHay+F0tk9yIWEgveo+FSy7bAIdxtNZNVXK0wnI3GGaBWqljA7M69F6B0ioZ8TrUYXlUxQnBWXKBCh8HoP388w0wo1LVCl0GkwRla3R1PsvCe5D5qlMHx5bO2qeXCK4niKmXYwE0kJVz5iZ4EmlWmACpKFYYpGgveUgjQhpI5qmNB0DXbqcYjjkh5JwraKQ3yuCaa1G140G23DdVQhkNYGQrfG5+5QYyPUtxSbW3TRk2lO1Ygt8LyUhmRrB9dJqfuGqO9exH8lcdBBy00DZlKiikq+C3lK6GcAmD2Fn7afyXiyDOpU3S6sDfCDnGA1JkZ0LtbKqnWuikVBGO0bnyjnxDygbUyUMdhpQ93VYl18aAdbnUgIxLKSUMu6Rh3fIPRydNxAndkmFiWq3yEmFuWDNB+JE1phWWF35+gmJ0TFlu8xDjmfrU4wK1LSFf3qimJ1X7zv44Mf/OChf7/73e/mFa94Bf/tv/03fvAHf/CCr/v4xz/Oxz/+8eW/3/e+9/HzP//zvPKVr+RnfuZnDj23qipuvfVWYJ+pczYWj99yyy3UdY1zl8kO/wGEI21AHvzglbf2lcKpyR2H0l5BfmxPTe64Qnv0AEIEX1huLTfZTr9Iphoy2zAHEWl3c0K/Qz1IRPyaa9IQMbtjwngiNrY+QAyoPJecgxhQdWjpG/uF07I4XyZSLyg8QhM6mDx+VxkbSx2HlsYoGoPKM1TeCm2LEruthAIzK4T7HgLsjgiTqYQndnKoG0kONxrV78F0itIaygZbTqSpaVfyaY8zlpIGb0YVtu9ociVF/4EGRDctr78ImMKjy5rY68j+jOZYq9EDg9eSg2ELj96bSYHYiv1DbiUQMVEobwidBDMvYWdKrCt04rDDZDlNOBvnTaK/t2Lus7elD9CcEoV3hrprRCtURczck+yWaGclJ2Y8QU8L7Dxv6WNXtvu4S8ecCLaIJKMGN6pQVSO5GY1HzQpMVctn1eugm2Y/L2fhpNY0qLohOE21lmBTQzop5DpMZUpFK1CnrsVFzlpUtyMhho0nFgVue0bds6KNOathi1oRsxRlLWE8lqmJc+j1gTQyrS5LTeeoKeKOlmfoJGEZ8hiFTmh1YNNM6OuKKhoS1yy1VCtcGdzf74tH6YI1Go0OPZ6mKWmaXrL3ufrqq/kP/+E/8IxnPINTp06R5zkf+9jHeNWrXsX73/9+fviHf5jNzU2++7u/+9Dr1tbW+Nf/+l/z7Gc/m4c97GEMh0NuuukmXvva1/L2t7+dl73sZQyHQ/7Vv/pXy9fs7e0RgnwRL+SQtXg8hMBoNGJzc/OSHesKgiNtQFa4cri5d5KNcnzox9ajuLl38gru1QMECkzqOelG9HVFpjy5rdmyCt9LxObWyGprsArvFHqQYHsd1HhMqGqUVlI8dfJlARXy/a/r4qaga8ljiAaUBzeR9GyfGZpc9ArBHHaRAuHwLxyBFg2MCrS2qgHV/jhH177n3hjVeOHezwsR4rb2rjFGoVk51ya366WLFlUiCdy7I+JsTqgqdKeDGvRFYDyZSXBglqGLivw2ltOhpuMIicaUHjNvlgWju21X9iFLha42LzB5AjHb/wy8CJljUaKslSDEVJLYo1H4FHwvQY+s2KzWDWpvTLKVSZNylhvXIjBRsV+wNh3F/IQi9JqLy/y4C2gTKNc95abF3Cafw0JUHxRg1VJ7YmcGVYg9MiHC3pjkdEZwHareudSiy4XFNaR8XDZri1BCAFNFsu0Kd2c7oajbnJglZSqge104ti75G7QTjLb5iHVN3BthM8kI0XUQi2KtpREAlDXQyYljLzr5Tk7MEpkaWUNsQE1muElHmv/kMG0PaB3dlDjQLd6/kqDCULQNz2gijXMI6PU1Yk+ab5ylWe8QLJS1ZRxyrrMzrrG7dNKK2X10OvVAweq++JXjuuuuO/Tvn/u5n/uK3KouhB/90R8957EnPOEJ/N7v/R7PetazeO9738uP//iP89SnPvUQXf/pT386T3/60w+97jGPeQxve9vb2Nzc5HWvex0ve9nLeP7zn7/UehRFsXxukiTn3Z+DzdV8Pr83h7bCBbBqQO6nePupb+Wx25/Fx3bMjCIqxdtOPflK79r9HlGBdQ0PTk5zlfF8ubHsFrmIhQcWuwd6XGBbLULUCu2FA6/6fUxZEsq2oNJaeOjOSmHP/kq88mDnwqWPVqGqgD0zFuvZToJzhpCZNiBO4aYNdlLjU0Pdb8fJ7YqsrqTh0HWQDI2i2rcvdRbd7UjhBeI0NJlJQTidCfc9S6XQa3NDaLxMQ6wRPYvRMtlRCpWlhIEkoxuj5Rjb15qtMeH0FgrINtaJg66skE9mhPUB9fEOMU/FJamWZotEEtYPJYRbOW/MCqG0LXJKjNov7K1e6muUMSIgLiqyO0VcLI2QwqeSu+FT3TYwct68UzTdiEo96l4uO1obCBsF5ajL8GbJOalb97GDYnKfKHxuMSP5jCKIlfHuhKTj8ImmyS9/lbtscMuIm3pM6QlWEuoBTBmwkwp7ZiwC7163tdedSwYOoLJUpn1FJRS+QR+qeuk2tU872yUtKvm+1G1jMpujOjl0cmme5wVooXYdvF6Vc1DVuO0ZwWnKdXuoCdE+osdz/GhC9NLEiLOWULjwknkCoNJUGhUrgvRFDogK0oA1jWbL97jdTxiHDB/0Kv/jCuN+f1+826TYr3CbwBe+8AUGg8Hy4Us5/bgrKKV4zWtew3vf+14++9nP8td//dd83dd93UW99pWvfCVvfOMb2dvb4wMf+ABPe9rTAMiy/cWqqqrO+9qyvQcD5C3Vc4VLi0vWgDz60Y/mZ3/2Z/ne7/3eeyUmv/XWW/lP/+k/8ZCHPISf/umfvlS794DDJ9Zu4CXf+MJDbh9vO/VkPrm2osUdOdSyRqGKkb+rT7A96ZDPI27SyAQEpCDbLdpJhJIV+7U+6CF6a0eKs8ajihI1mmCcgY22cVjQkmZeuPS1l4J0OkPlGWZWoKdzlDW4E+tErTF37hCnU/SxDcy8gy4aaQhCkNe2BR1VTexkNJtDqrWEaBWm7JHslOhpKQ5AO6MlXUwlDqxdugEpKxa7sfGy6tzJCJ0UVXdQp6NQtgCdZ/tNTYyE3Mn2dvcIkyn+ztOYphHXqhDQ4ynOaqJSkCWSRB0C8dgxqo1kP4NCy2QpZik6REIvozrWpe4ZQmvcFLUSR6teiil7xDzF9zJU1WC/cFqsWJ1FDQf4YZeYGpquo9iwIqQHkkkkfkkxyhNCp8aYe8etMSYSasjO1OLkdZbl8mJiVvcNdpqgpxY218SNKQTs7hzbs/hF4OBl7kN0I/Sq5PQUNSuJ3UxMFiqP3pvCvCDW0jjG6QyURnU74kw2maKyjLDWR0/nEoLprDSa7fciDDuYbSevt0Ya3elcskOUWoY2EiPkmdyHQoR5SZjOiPP5kpKlJjNcYok2p+qbZTp81Eomc5kI0WNVEbZ3hI7oHHSAGOW/ndufBIZAzBx6UmDvqNDX5WRZzTV2h76qqZVBq3if1ec8UHC/vy8eoQh9MBgcakAuJ77ma76GjY0Ntre3+cxnPnPRDchgMOBRj3oUf/mXf8lnPvOZ5ePD4RCtNSEEdnZ2zvvaxeNa6yt23Pd3XLIGZDwe85znPIeXvexlPO95z+PZz372BVMpz0ZVVfze7/0e73jHO/jd3/1dvPe86U1vulS79oDFJ9ZuWAnrLjeUiJYT17BmZmRKcZXdw1qPrsVZKXQS9KREb42kWFokjrf2o9EZdL912bEGfCBWFbpq0E27WhxbG9PtuWxnkZMAxN09obQ0jazqJ46YJktxu2o8qvRCK1FScMVOJsXebC5FYpbgc0vdkwwFnSkICc4oVBMw0/2R9II+o6wVwXAlnH2VJlII1g167IVbn6WSHg1SSBalcOpjBz1PpCEaDoTrPxfXIdV4YvDQ+KWjbCzKZc6Izx1NpvcF3EZR9y0qdjGFUKrKtf2V7qgAA3XXEB/UxWzK6pauAsm0JIzGhNkMZR06REzdSBNle6hwgAbnI6YE3ezT/79SxAhVacnmkmMRtVpS4w4VrQqaTFMcy3C5FTOAWY3ZnqDmJabqXjCv5d7g4Mr92UW02CODnQeSrTl6ZyKTgSagXKtJSsSYgBCkyW2Ldtrpl6obYpbghxkYJQ1L3RA2B4Rc7HUBwsmhmB+UtRT93RyVJZJ4DzIlDFGu6xhhOpPGp6pAaWKMrWlCl+i0uJ+FhGpohZqXKaoHDUi8hzvOtPqrKFTDNnAwLqh9xkDiUM4JNS91on0qKrSHsnSMQsYpN6KmwuqV+OO+gNV98asTCxF4s7h/3IvXJUnC9ddfzy233MLNN9/MP/pH/+ic1918880A3HDDDSsB+hHhkjUgf/d3f8cv/dIv8ZrXvGbJDXzoQx/K4x//eB772Mdy9dVXs7GxQZqm7O7usr29zU033cRHP/pRPvrRjzKdTokx8o//8T/mF37hF3jMYx5zqXZthRUuK6KGxHq6qiJThk09x+qAnUeSO8ao0VSeqJTQQgCcIs4KmEzR7Y+dylv+eoxQFKhZgZ12ZWVcidBaVVIc004x8J7QFlyqTfyOkyl0MuqvuQYzqzDbE/SZHVk51gq1sYZf76KNQtWZ7E9RoSsPWJbhfH2L9hG3NYMQMBvrUgC27xsHPfx6B1V6lPc0PbG81ZWXotFH/PEhOkuJZ7bbFeZaqC5Ng2pdiiKgel2MMZCmxJObYLXkeYzGogdYBBqmCSEzhxO42xyPYsOivV2GE56dgB0sVD2N6mh0E8m2glB+tJb98L4VzGtIj/YGVFcWd3PG8Y/XuDtG1CcH+6noB6+tRWZFV+NTJ9bOmcF0ZP+qgb3kzcddYWF+YKpIslOhd8YiGs8zEWpbje8k2LJGjeei94gRtBFjhcUUoQ2mNJNSPud5AcM+1bEOdd+I1mnmMdNapn2lCNbrqwcEq0lOT9F37gj1CklSJ0Zpip004cpJvk1sGvTeBD01RGtwRhGcmEEsRPwqxP0xZpvboRZUK2ulyTGauDEkJBY1K8URbjKTSYyGNK0JaP6+HlJHSxNWacorHC2OUoR+JXHmzJllhMO111570a/z3vO3f/u3533dN33TN3HLLbdw44038tznPvec1954443L561wNLhkDUiapvzUT/0UL37xi/mN3/gN3vSmN/Hxj3+cz3zmM7zzne8872sW3N9ut8sP//AP86IXvYjHPe5xl2qXVljhiiFEqKPB44VnHBWmjiKaVoo46EqI2ayUgjtEKEsJM0ucUD46OVgj9CglLj52WmM7bcp3iESt0XUpfPosgWEPk6aE0Vh2xHtZra2bNkMjRc8q2NkV4XWWonwQe9xZISu8/e5+yNri5qNEf9B0DHbiCCfW8V2ZkujSo3yk6VrqgV1mg/hEBN8qWOzMYWceXQf0mGUquspSdLfb0riMTGo6qUyBZhXRaoqrewSnSEYp7jYD27soJ8faHOtT9+zhbI62SJfk6/3P5OyV+0WeBQpiG6QYezkqfRB6MiNs70oDMpujncMUXVQ4zHtWEQiKcD7brItEjNCUlo0vQPeTtxNHE/RG9xzHs0P7bcDrVlCfROiLZiUsEtUvIdXn7goQ3UTsPKDn7USrLJc0XL0bUTMn1/BoTPQePehL4Z5ZWAwFrEbNa/SdO0KV6vepj/WoBhafKrSN4oC2M4WdPZnmWYszmtDLULWXx5QW2l+M0oRbsYNenrumke/ZbC77mGcYrcl8FIvmniG4RRinEnOFNBEjiMTJdySEVtDe0h4X05zdEWE2l+NT4IzHqYZpSBmHXHJA7gPF3AorfLXhta99LTFGhsPhPaoR3/KWt7C7u4sxhic96UmH/vbMZz6T3/zN3+R//s//yS/8wi8cCiMcj8f81m/9FgD/7J/9s0tyDCuci0suQu/3+/zYj/0YP/ZjP8bf//3f88EPfpAPfehDfP7zn+fMmTMURcHGxgYnTpzgMY95DP/f//f/8YQnPOGC6egrrPDVCGcCmZKR7zgkVI2hG5EVVKWIiSU6sVdV8xLKSoojaEXdmfDc60ayOOqKGDx6NyGxrbB3VglffnckPPphj5g7zNSijKzUKueI7XQkuWNCdK3tabcr9K4QW/5PLavHzhGHKf8/e38ebGtW1/fjrzU84x7POffevj1B0wqiYCBMVkzFfKP5RuLsj0RJCpBBy1QwJVYlaowVMVpxLAKVAiqVlFHQBDWIplQsYoT4jeRbmG+I0h1QoLulge47nGHPz7TW+v3xWXufO3bfHm7fHva76lT33Wefvdd+9rP38/msz3twZUrbt3SZ2jQ7GAkqrE7m0pBkGm9AO/ka8UboT2u6zHHtrPDG4FNFOumEK39iV54zz8R6VWvcKGaJtB5vNX5c0BWGtq9xicJlKV2+Q7rbIyhFN0joSk2XPUQK+CNBiOu3CdrnqEWKXyyhaYSWFsJlz6M6yA4Uy14OuxVp6h7x064WGfmnM8afrvDnD2QC44LYtV4ld3Jt1SuMMHXZ7x5PXGjhfKl1s/JihGDnLbqWqVRo2k02BlW9oeJR5CjnCIMevkwlA8cH9KrDpwbTiKBcDQZ0t+5S72bSxEanNt141LLCTWaErhWKnNKYVSHvTZZBYglZiuqX6PlSbo/nmHKR/mWtUKbqWsTrzmHajsQMN+5x3bgkWQ4liDPPRB+1sYz2BGtlEnf+IGaAJPKarZXXZxVawZ5eMNI1Z5wko19Z7rrFFo8TnqJBhHfffTfvfOc7efOb38wLXvCCze1VVfG2t72Nn/mZnwHgh37ohy5yrZpOp3zv934vP/ADP8ArXvGKze3OOX7hF36B7//+7wfgTW96E7feeutFz/mqV72K5z//+XzqU5/iDW94A+95z3soy5LFYsEb3vAG9vf3eeELX3iZw9YWjx+uqwvWc5/7XJ773Ofypje96Xo+zRZbPKkQFKTGMdItucqOLR/XO/SrCpVYwlgKaQUy6ShyMOL6g9FSLAGkqdCBlisRoxcpeNCzBWE6F61HrxQx+XRFmM3xqwpdltBPj8vTzqFnSzAaf2Ikxf50Jfx5HS1HE4vPLO0oZXGzoRko7DJgV0rSxmM2xQaKi6YMFx6Di2CQRmFkgQKrNXoRrRBDEJ1I46Bx6OkSnVjak33agd3Qq1yq8DuWZiRCY+Vl9900YWM3/Eh3/y+0J9Z1zA5ZSS6Jr5s4GpGG0OfJZfQm0wR6D4DuLIuuwJ+oybL2mlPRQwAmCSfu6sjuOw/DAaFX0OUP/9X8RAqar5xMH6lXE3GVookuU2VBWFX4xUqK8zwTbYSSHBlCQE9X6HUGyHyJLmSypIoCd2JEvZPRlRIsuX4e3ToRpucZrLxM7/qycbUxP/AerMHv9FFFiqpa0VgpJTbOIchtIUAp1s+bKdcyR7cpXWJwhcX2S6GGwUYMr4rY7HQdpIVsGjQtoVkKtWs4wI17tD1FP224yay4yaQYNSM1jnorQt/iGYA/+qM/2jhOAcznYr39Uz/1U7z97W/f3P7xj3+c22+/nbZtefe738273/1uTp48ybOe9SwAPvnJT7JcLgFpIn74h3/4oufx3vO+972P973vfYzHY57znOdgreXTn/40R0dHAPztv/23ecc73nHZGo0x/Pqv/zpf8zVfw/vf/35+//d/ny/90i/lM5/5DJPJhN3dXX71V38VrbfUyeuFrQ3v0xwvPLrvIseP9975tdw1vuNGL+tpDRXAx4pNozlpVvTyRqYJpYiyw1rYmltc0pOUc6U2YlrqRsIIxwP8bh89TVFKyw4rgBX7WIyGDsJ0huo62a11Toq9roODI9l9HvTifTvCcER9ssS0fiMGVk7E8L5MqU4VzG81TO8EVzqyc4byTEAto6vQoyiiNrShROGNkt3ygyOhzJQ5aI0+nBESi+/nhCyh69lN9sWxwFziGXSnsCtHOomOUaXYDbtUwbo/Cpfs3F/SnBzv4Huy/Qa7P4fDCb6qUWWJKgtMFDOHPMWn+oqFuG4D5RmwK8O8Klid1uRl87DZICHAap6RnzUks1rCEk+OaIcpLtdPqJbjkeLYdtdj5g1qtpRCP00gT9HDgRgaLFf4+QLVtgSlpRlJE5k0pRbVajgQ8wPVK0VTFIJkfCizeS7deKEOao3KxeFKDfrS2NTSHLjZXKaHncP4KORXShqH2AyhlOhLxkOaW0YEo8gemBHOHaJnK8xeSdcz8l4nBj1tpdkIQbQdQ3FkU9NFXEsG1sqUsmnAGNpByuqk4vn9I3pRU9IGTec1uuMJ2VHe4sp42l8Pr4MG5NGcr23bsr+/f9nty+Vy01CATCpAhN4/8RM/wUc/+lE+9alP8Wd/9mc0TcOpU6f4hm/4Br77u7+br//6r7/s8Xq9Hj/7sz/LRz/6Ue666y4++9nPslqt2Nvb4xu/8Rt53etex9/9u3/3qs6sL3zhC/mTP/kT/sW/+Bd88IMf5BOf+AQnT57kO77jO/jn//yfPyK9yRaPHNsG5GmMFx7dx9v/579FhYAhsFvPeOnBZ3nLy77n6fWl+2RCkIJ0VmV80ZX09IqZT0iMo+opXC/FThVM5ht3JVVLwFpoZZKBjbuuZS4ZHMsGNVtIA2ENerIQVyHvoyC7IfiAcg5VVUIF6ZWospRE6K6Dw4m4CnUdatBDBXCZOc64yDVdrqiHiuqkorrJoXdrEuOpkhxTW3QTMI+RQ7JJWtcataY0mahpCUFoLh6aUUo7OLbNvfQYm8ZHUXIDncfONK5MhMcf8zN0G9AxeNGnkgOynpLAcfORn6tJvnAg70FVyyRoPMD3C3TVoJcVvl/Q5eaKSeMqgK4D5RlPMtPMFjmr2wwqc9i0I0ncRRMR5zRta3CVpfx0yumP1aT7S2g79OEcY4e4LD3WqDzJsBaeqyjO9oVF56mcY8bA3phmt0SFMfbsVCZ1e2N8Ka9JtV4mcVoTUhGIk2f4UV8oghcifp7s0qFnMt2j6yRgsF9KE58lqJ0R6uBIqIcgJgcgblw+4EOQxiXmzrQn+lQnEkwVyJQSQbmV9zcooRp2/ZR0YuScWIdVLlfScHSdTB6NRg0GsDdGz1PIUlYnE5bPbfiq0b1kSpMog8MzrzLKRdg42W3xxGJ7PXzi8H/9X//XRuN7LRiPx/zoj/7oI36eJEn4J//knzziv7sQt99++9Z19QZh24A8jfHae/5g82ULMXgpyO1bG8LrA+UCdgmH53v8/uyFVP0/ow2W3HbMewrVenEJGgtVQzUdarqQXARjoF+Kted8SeiXdMNcHKSUitOKIK5WRgudRUVqixaBbWhaKcJ8EKrV3h5qUcH5Q7EiBZjMyKIFarfXZ3U6Z3lCszqpqE96wrgh6zWkiVDAup7BZXYTwPdodsQuErPnCjfMSA7zqG/poMggdLGgNLjC4OL047LH8mCqgF20qFWDipbAOrHYcwY/KvGJwU5FMBwSg+tltKNU9CSp2hS2ycxhj1ZQN5Bl4n61WMLBEWYdxth1BKPw6cXTmAsRNKigSJaewX2a8kGLtwnzZweqmyvU+nWogJum5F+0DA5g+Bcd2QMzyYHxQZqQpgOVXrHZebJAd4F05skfmKNncvz8ciV5LWUBqifnS5pICn0pvG1dRRcrHwidl9OpyAh5NB5ouo35gfJBGIlHHXayOs6MSVI5XtM5oVfgR6VQEhdL+WxsHNKyzdRPmUjdCoFQN9jzc/q1ZPKoVX08kYxBldIYKwnU1AqSlLBYiUmEWYfJeEhT0bloEbQHrTBNIClaBmZFHTxtqPg/9W0sjgqGldgAr521tnji8Iy4Hj5FNSBbPDOxbUCexrhzfuZYfxBhCNw5P3ODVvQ0hw8oBckqYCaWz1c7JAPHWK/ITIfqQC8q0XIkCXphN3oDSYbuxGUn5gyQZ5JpsZOTsIueLqVQNlqKrEyjxkM4uYtuWsJsLo5X/Z5w8Z0Xa1DnCSd3CT3hvKujGeHsPhiDVYpkkGBGUvSFRIqnNOkw2uO8JjxGscGm+YiZFl2mqfcygj6FnTdS/K3zSHJLvZfT5eqKu//rx9KtR9UtqqrFXanrhG7jHPpogD4xjhSaFVQ1Sa9ANwOCLvHWyBSlDth5I8dyHVy3qvDTOf5wgpqLXbLOJE3b2ysfh/Wkwiv5h60C2Uw8dE2l8ffm2KU0Ke1AktSzw0B+5EhmHb5MUZ2HzkKW0A0yXKav2uw8UbhS9sdx5kcg26/QZw/F8tY5fFWLte7RlHQ98om2uMZ5aSDq+H7nGXoRm88LMmxoOxRWMllmHjsXW2KOZoRWGmg1Hsn05HCCAqEuNq3YT3cdut9DjYbS0K+pjG1HWC7jOeJh/xDTDoTul1hUWeDLLOqNlDSeHtksiA0NWqGTTJramLEjB8dvpngoRVcoTu7MuD3Zx4XAg97y/y3uQE/tdvpxA/GMuB5uG5AtnkLYNiBPY9zTv4ndenbRl65DcU//phu4qqc3pEALqFbjg+KkXjKOhbytgohajSFMpqi2FbqVWYcNtvjVPjrLUMMBPk/wqfDRTWrQa0csrTbiWLyX4t0a1HAAN53AZ4loLPaPCPsH4vqztxMpTwqyFBUCoargaEqWJ7h0gE8MPjVUSYbZ9egkSAPSaEzDo+Kvr7UCysVAOiMFeNPXdEWO7jJM7dG1B61wmVDBrlbsr+EToe9gxHLVr1bRpUqJrbA1sCPptSpLCWmCXjYk0yTqShSm8eKMFCcPgFir5hmmV8pEaVWhBn1cT3QLD0WJWjtTBQOdFtF+76wjnbbY/RWqquluGrG4RRpLiNOlvCCZtWijcEVCc0Fo4o3ChmZ1weQKQDtIFo7sXIU5eySNsnOE9tjBTTh0IvRe/57u2B1MpYlM8pZLwmxGCAHdOXQuEwufJ5hlQ7K/QM0kwTzUTQz/0+JMlaVik1vVsFjiovWvLktUnssT1Q1hudpk4mzCOY3Z6KfcIMdoycMJWXJ8zAOgkeepm81j6J2xnBdHE2mk2k60V02L6jrCaEC1q3luf8LCZ9zTlZxzQ/77mTvJz2j02lhiiycc2+vhFls8ubBtQJ7GeO+dX8tLDz6LC3HcjFikvufOr7vRS3vaI9iAVoEDnwMVqy7B1FKArxPDsZZQZCI8r2tC2xG6lpCm4pIVd4VV5zHzWihUa1emoiC0Lf7MORHDpgns7tCNCymoZzEBuu2kOPzig/BFpBk5sUvYGaIOwc/m6DOKIjGgSqmeQ8JKQddv8EGhKoOpZef7keBYqBwwjRetSUrcKRYLWbnNSBjgBY+/TvOOQ4XLH7vzqNZJA7am5mgjRaz3kqDeNGKXOuhJhkNVCy1LSX6GWbaozkt6dlUdC+J3hvg8QVUtumlxO5dnjVz1fVfHYWDrxitoRSjk+ZXzm/u5RMWARGnKVGfxqdgK38jpx+Z9awK6iZShcCwGTw9W6DMH+MlUjr0x4nYV4uXEWkKeEvJM9B1VLUYITSuvdVBKeGUUo6q1pW0Fql/KsW896nAqAvayQPdKiQxpW3lec4FWpG2lORgN5bmrmnBuX8wY0lQydawVqmJVy8SmEW2PmaVC4+scKktQnbxe0wRU62U6kqXSZLkLTtD4701jEy142RvT5dCzDUufsfQZn6lv4sG/2OPEg3I8t/SrG4NnwvXw6RpEuMXTE9sG5GmMu8Z38JaXfc9Frh/vufPruHv87Bu9tKc1ggZXenbTBQ92Y1ozp+ostg7ogxluOgVATQKqzmUikSToXkFopDnx5w8wbYcKIxHmNq0EquWZFDCJlUwFLc5YKA3LFcmDCEVksYoFUnTLWjczawqK80KDUYrQOcwXzlO2O9hlia0SdJtQ71hCIha8qkMmKI/4YEQxeH3sagQXU3qCAh3ALj2mduJqVRi6QuGTK4i+fcAuOimCpzPRHRRFDHAsJPckhszhPWEyR0XKmW77JLXQftRiRegVUihHOo0f9HDDDLu/QLUdftynG2e4qzhgXQ3Kg608ybQVDU8tNCNvJQdmnS6/RtOPx0Zxw6lXx/a6HclRJe5TbSeNiHOE6Ry3bh4i1UqtJ3urSppaY6CXi8kCxBwNF1+7TKCwFj0eEQY9oQlmCe24lHDL1qN3hqimkedIEgnmdCmhboQaFc9rlcagwPFAzuumkUmYteho6hBWK3E2GyaousavVvjDIxGVO0coclSakExl0mUqjz1cbvRFJJawqnBnJI15TflTaSpak/h6fGrxCXxJeY6/XtzPF13KR2dfil5GB6wtbhi218MttnhyYduAPM1x1/iOp4/A7ikEFRQDU/Hc9CxVMLSdIVnvfPogk462Q61WUhgXOWo0FHpItC8lTVB1iz5zIDSULBNtR9cJZcR7KcpO7qKWFeFwIjqSRLIXlI2Caq1Q/T4hT0Vwu1gSDo+ExnVyD4Bw5jzqczX5fkm6PyKb9Kl2DM1A41OwVZDMkhCuGEp3NQQtonOfiIh9TT26+FjJlCQ7s8ScOxIe/c07VDcVtEZJqvnahlfJY7SjFLs3FhqbNiIw9j46gBX4YSkifcSVd930absOlJPgR5VncTfbQ/Do+VLCHaczccMalhKseI2OVGvqku4CybQjeXCCch4/LPGDHJeb4+N2gRvX+t83evIBMdl84UjPL1EP7su5CKI9MuY4YbzIpeBf3z5f4Ktaph6AWlRyvs3mEhLYKwhlTlBK6IQAZUF3ckAwmmDFTtlbRTI/Xtdab6HyC1Loreg2QtOiooOWalqxyO2VKKXwi+WmQQ3Oo5pWUs3TRJr3RqhVGCMN08GEpKoJ9oRkjpw/wlcVulfK504rcBDWn+PoLKB6pdjzNi0hM/gUSt0w0im56viK8ov8dvaS67I7vcUjw/Z6uMUWTx5c1wbkgx/8IK985Suv6sG8xRZPSyhFyDuelz/As23gwNUk1kmQ3u4AXTf4w0PhknukAE7TONXwhKqSwuhwAiD6BkAPBrKjvFhJY9G0UtjFiUboOmlOiiC1rYm6EKWkCakaeex6TecKwklXCh/1Djp4dAj0p0uKnR6rm3ssT5rjYjnSc1jHgayzNa4QALjWRLhEoezV77dOuTaTBe7ceZQx2MRi+yldcXkeRlDQ9jTmVI+0c+KGFAXQKLFTJdr8qkVFWCwlNyLPxH1sVEruytlDmSwpJUW0isnzVSVZEUptHJs24s6H+CrbNB9Opjn2cAVHU4IxKGtQIWDzBBWSDQtdd3Hy03hcqml7GswT34Ss126iM1j+wBx97kimaFkq51JZEIoMfSh2xaoo5HwDQhRmE6TYZ7lCdR0+Crh1lkoI4Gwph3Ad4OcX2CJjdfuQth8tdHXU6CwL7L4Vc4Vamh7W2R7WRtqTkcZ6PdEqMkKewmK5saDeUKcq0MMB/paTmNmKsH+Ir2vZEFit5JyJNr7eamyvkPW0YgqhlELt7cqEcjZHpSl6dyzTnZiD0owz2qGnDYYHXEOmIFEO/COnMG6xxRZbPJ1xXRuQb/zGb+SWW27hNa95Dd/1Xd/Fl3/5l1/Pp9tiiycPnGLpM3wI5AoS42gTRbtbkrYO3Tb4xWrjoKMysRalc6JFKApCXctu7WgoYtqqFjpLLbu2arcnNqSpxdSRdmIMaEOI2ggV083xXkTau2OU1uiqlsYFpBB07rh47DqUUpjzU3KjaXs9moHCW7A1pFNHMmvF0apnJQAwu3hSscYmyyJcvag2rVCqqBvRxsS0bBXClf9GgU8U9U6CS8cksx5m0aCabmM/rFYNqqrlMa1FjUeyC965DaWItRC/aaVBS2K2inOyu680arbElilt30J+5Rew3tVeJ7Mnc092bimF+tp/92gmIXwXPITy0nzk5yvMZEU3LvFpTqefWAH6xtmq8mRHIpjX8yWhc5sGgxCkWUOE+gSxkw4hCA1JRzrSejKiNNS1nIN5dky96uf4PMVMRIcBQNuRTBuCSnGFxltwmaLZTTGLXRF5+yDHr6pReSqBhXUrjaPW0jg2LUprycgZ9NBpKmusKtF9hKi/SaP26sQuJgRxUatqWWdZYCcr0e5Ygxr0CJMpflWJvmjQQ7UdalVJs+I8qlnhpzP07g7LU5bkWXOek51lESz3dT3+v/kdJFONreNncIstrhe2LlhbPIVwXRuQF7zgBdx999383M/9HD/3cz/Hy1/+cl7/+tfz6le/mvF4fD2feostbhiUD+i54X8vnsWLs/sZaB9vBx21AJzYxex4EYovV1L0zxbSAKyLYWulyLEW8gB1jZ/NhDIy6G9SzHUVHYISK6FoMetgjZDYmIfgpBlZu2GB/L816OFQivG2hcZKvoFS6KrFVp7VnnxVZFNPtl9hzk1AKcyJIZARTEwhvwquKCRfTwzagG4cZCnm5AlIE9zegK40V52soKHLFV1maUYW3ebYlRdtSOsws1oaqzZqZ7TeWKqqtiPM50LRck4mJHkmlCsdj7fScedfoydL7DCj7evLrsUXUq7sKmBXjmTaiP2vUjDqy/NN55D08GmkYMW/MY1Hr1rUqsYYgx0meGvxV5oUXQesm4907kiPWuzBQnJp4jTNb7REBrVYivOTD2J6YKKLW5xKKBOPjzFy/hp9nF/TtoSsFNtbhTR6Wgp8nybY83P0Kmf5rN6G8taWGnOiRz7tS4PRL6UvSxP56ZxoU6KVr68qaBtpkoY9mTwtgjRDSgttsa4x+7Mokk83wniVpnKetB36rEwnVZbJc6apNPbeiyYkS9GDvkzKqipOIGW8Ue0ovvLmL/IlyTmqYNh3fVYuQTcK3YYtBWuLLbbYIuK6NiCf+MQn+F//63/xi7/4i7zvfe/jYx/7GH/8x3/MD/zAD/Ct3/qtvP71r+frv/7rtxStJwAvPLrvIvHde+/82m366/VCAOUUszZnGjKy4Da361aKJrKUbpBh9kWnEVY12gcprODiwjkmLoc0ifkEke4yW8B5oVOFrhOKVpaIo49bi5oVWINPLdp51NFsUyyFrpNJS5aI+xMQnBPnoXWewtKQn6tZ7RlcBtoF2XmOdqJ6XmFziyt0dHS6tkN0IeVHt4FgNG63D2qAyy3t0NL2zBWDCIGLdBRegTdKbIQThV1qcQ7LhIoTQFKwEwnFA4Si40O0Y41p19bK/awltLK7HhIrU5PWX3knML6GdOpID0SwrVa1NIGDEp+nkvrNsfsXsAlTNMsOXBD6j3PYRYcrtExO1nl31/nrUcUm0Cwa1Dzqj5w0q3p3LP+vtEzIZnOZJDgXb1eRSiX6m7DO9ShyoWglVn5fN6g82xyfEPNBCAHlPWpZoe2xEH99vHyqN05xqu0k2DCVjBs6R2haSSmvJEww+IByHh2nM6Fb54yo4wDBzm2ad7VYSVOllXwOY+OxngaqLBWx/Ggg9L4qTnWs3bhZrV2yAHwCJ7IFuXJUwdDTNaNkBYpNcvwWTzyeKde/rQvWFk8lXHcR+kte8hJe8pKX8La3vY3f/u3f5pd+6Zf43d/9XX7t136NX//1X+f06dO89rWv3VK0riNeeHQfb/+f/3aTArtbz3jpwWd5y8u+52n5JXzDocCngZvzCbebOeu63FtohxnZrEItK1RuUbF408Oh0D2yRAq0o4lkUpSJUFeqSooeYyTI0FpIopYghI0GRK9pKTH1mVq0Hso5SVdvWlS/PBakWyOp1MvqmA4WC6wQQ/6SVc0wv5l6x2KXXjI9rIS8qdkSPchRLnnEh0k7SOaeZNqgQsBnlq5nafsyTblWQfaFQYBdocVGdWkwWouuJs+FstN2cmxA6DyRHqSGAym6mzYm0uuNnevaQjYYtbm4X0SjCtJIpAcV5oEDocoFj+r38T15D1TbSfOR2I3zlfIyLbHTCj2Zi0tTv4dZpWTnweYGlwu1zV+QCP9Qx+PS7I4N/e1h/i4ocKnGp4ZNv5dY1GiIH5aophO3NefQXYePzYNfSCaNSlPZRFofT6WkMbAWqjjhU0oocYmVc9znou2YzeVvlSJYfVn6u7cK388x8xVhtkD1Cjn3nAdrUCojBA+mQxtD6Dr8QrJDMAazM4bhAH00hSACdT/obd6D0BP3NOpG9Co+iuqVlcZmsZRpzngozdTBhDCZyudOa7HhNWFDc9QtrFyCQ3GTaajCkrPVAF2zpbLcIDzjrn/b82yLpwieMBcsay3f9m3fxrd927exv7/Pf/gP/4Ff/MVf5OMf//iGovWyl72MN7zhDVuK1uOM197zB5svX4ge6EFu3zqCPP4ICrCBkV1uZAMBsHUg+8IEzu5LMF4hlrr6xC5+3IcuBrg5aQTwjhBTprFWdmpjkRTWjYXR4sKjFME5KbycuGOFXgFpIknbrdtw4XXbQJbJ7rA2UshZEy2rPKrfw92yJ9SgM+cJyxXp+QXaFagm8tiNgVKmJ4CEL8YC+OGahuN8EE8yazGLBp9Z2nFC2z+epDyanX9vpAlhJwU9xmpFmMzFWSx4ONKofg9/ckw3zPGZUKJM67GTGr0/JSxj0RmnQfiArl1svI4XtX4duvVSpHed6HaKnDDs4XJLcrAkLCtUUUSLWQk32TQysXAPdQPOY+oG7T2pUoRBj/amIc04xWWxIdMXHJsLmouNjqP26Pa4AulyjUvVVfNUIFIGW48vLO2zTmCPeqjpQuhIkwWsqo2WyDsvUw6tNg2xUkrOzSRBDwfyoLO5TAjiuaLKQs4ZpQiJQR01x9Q35whlTjfMCRfEewQtWh+hrIWYldPAIpUJRdPGMMCoRVlPOIIndOE4U9BGAX2Z44ZFFIQ7af6PpJlQowE6z6QhyjJpKCotDaWPeqTZIuqF1u5XPckvmc2lwSpEtD5rM+7vxsz0kiNfYrW76iRvi+uP7fVviy2enLghX4t7e3v8o3/0j/jYxz7GT//0T2NimvEf//Ef8+Y3v5lbbrmFN73pTdx77703YnlPO9w5P3NR+ivIl/Cd8zM3aEVPb6gAqlVMupIWuMj8Ju7whuUKNZmDNeJs1XnUwQTOH4rNaVmiynKj1VB5Hu17O8lccNKc+MVSiqR16FqSyC7w0QS1rIRGs5DCGh+LtJjnAEiT0zkRrSOTAfJMAvoSg+r3hPaSGMy0IfncOThzXtKh8xRfpphFQzJtN2nn13SMXMBUHnycfPRTuvLam49N2N8Vdvy9VTRDw+qmDD8qpblKEykYY+gdWuMzQzsw1DuWai+lG2VC9+n38LsD/Kkd9Mk9VL+MFBo2u4uXNlF6FqlLXhq4kFrsUSU0oZv2aJ5ziupURpdplBPKVnZ2gVo1ojOwFj9fyATGOfxiiZotsPOG/OyK/ueW9D5fUZxvSeZeMmU6WYOI3yGdOcovrCj+YkbxFzPKeycUZ2psHS6ajFyKYFSk0GmhjlmhPYV+tM11Xnb9Dyeio4GNLa6KzYUeDSMtyUfbW2l4N3oR56Q5W9WopdAGVa8Ug4XE4gc57SDBR5vmCxss1Xop8HdGqH5frHSj9kRZK1RFH/AxzBMl2TjKWmnsDieEheS6qM5L87GmQkZ6FtENTg360khG562w/n3M21HjIXpnLI3W7mjTWOnxCHdyjE9h2aW4oLmvPcldq9s5aspjq+UtnnA8o65/4Tr9bLHFdcANyQG5++67+aVf+iV+5Vd+hQcffJAQAidOnODv//2/z5kzZ/it3/ot/v2///f86q/+Kh/84Af5a3/tr92IZT5tcE//Jnbr2UVfwg7FPf2bbuCqnsaIu9HTLufAJSTK47wmGIXvZZg8I0xqwmIBXYaKxb+fL6Bt0f0e7vQOqm5Rmew8B61RBxN8E12dEotKc9ldXiehRzegddJ6aFtUpPf4lVC41KAva/RBHnstEK6buLuuoGlQ87g7HYXb5lB2xN35fQBMnkPn0JNWOPeDDN0JzeyadCBK4RNN15NC8pE2H8QGYH3/C3f4g4oC78rjigR1agc9W8Gqkh1rraDzhNiseCvThbZn0bs99DwRFySD0IXqFhV3wS98cbqVsD57fi65IetwvKaVIrvMaHeGtENLt9bIAOnck39+Cg+cEypYv4yag5iurbINLUk1HXYqTYkxBms0yajEFQk+0dE1SqGbII3QRPQmvpdDC2bVkk4MYWwl1PEC7UxYH2stkxIAUzk5VssVoV8Sejm6zAlaSaL4eIiazkTDsdbQrB8y2vXinDTJEJ2nzPFUwXmYzGXydmJMN5KpQddLRPtyBdqdrluhqK1NApyT8zUKyIkaDl3kx+vRRly4gpfsjraDVYVW0myEuiHUtay738OdGuNKaRrVbC5p6yDNTF0L3bHIQGtxnuunBK1I6uZYk6XBpTBOV+SqZWgrKp/QOLNtQG4gtte/LbZ4cuIJa0DWtKtf+qVf4uMf/zghBIwxvPKVr+SNb3wj3/It30KSCJ3j4OCAH/uxH+Od73wnP/iDP8j/+B//44la5tMS773za3npwWdxIY6fUQSleM+dX3ejl/b0hIJgINMdOm4757ZjnoPqfBS1DqVwytZCc4fulbL7miX41GAXdUyIjoNKHV2FnEPtjCX8LARYSSFFF5uOnRHBaFTVyG7/etqRWJmQ1E3UlIizT2jbKCpGdnt9IHTiKARI8xKzSAB0GYXch1N5nNEQVTuShcNbc0ybeQh4A12p8dE5yyXqIvrNVQ/thvYU0C4QtLrob9d0JNOIxsKnBtfPUMuo50iFz+/7KS6X0Lt1AKDLNV0vIek8VB2qErqbL3N8Yo6nCLHBTBae9MwM9g/lPRkNN+9TyBOqm0qa4fFzyALlb9fWv6Ft4eCI0LSY0VAaktUKX0ugn6oaaQbW7mhaY5xHGy3nRp4StAarJShyTREyCp8k6KolPbfAVDk+1XijcPnFKfMXNiGmn5BYI7mLVYPq3CYrJSQWPyzQ1qDO7UuQZpZBlorTGqlkzXROdDfDvkyE6jbqPgJhsSJUFXo0pBvkNCMp5F2kil3WvCrwWYLplXJeVvUmdTwslzJJMbHBsVboiGv90/6huMOtXayaVjJw2k4mjLEZD3mGy4w0Wa2LwZTR+StN5HnrBpUmBCWNqGrdsaEEyOdMKVwZuL08ZGyW9FTHp4Lh/sMxyVLee7ZC9Cccz6Tr31aEvsVTCde1Aem6biM8/+AHP0gbubrPfe5zef3rX8/rX/96br755sv+bnd3l3/9r/81H/rQh/iTP/mT67nEZwTuGt/BW172PRe5gLznzq/j7vGzb/TSnpYIWuFLx/OLBzhtHC4Evmx8hv/n9C1yh67buF2tBbF6voQkCqXrFntuBhPZaVarYrPTq0ZDVJHTnRrRDVJM5bDnvDgvRXqMHxRCn8pSsBq1qOTxQSgpdX2BvsFLcVbkx8VR8FIH+iAce9gkha+pL346k13pOG3RVYNZJui+wT+MHn09sfBGjtW1iqUv1DmojjiRCASlcfoCnYMSWlHQCrtoMVMR/Yeol3HDgq6X4C8Quq/XQwBVyW62ijav3amhWAJvXoA0OOlRDecO8JOpUJB65eb4V6d70nxc0owpJBm+OzkkcZ5weIRfrGSiNezLDv5qhc6y+P/RLUqrY7fA5UqmVjEzRSEUvVBkohnqOkwI+FEPPOjFCj1ZEPKMkFhCbml2c5qB2RT96ybEZQo3LqX5qRuh8Wkt04LDiXB2QxAqW9PKhEFLFodq2hh02UCei4tYLlMLVTeE6VyMEoYD/IkRXT/FJxqfHAvtL33/vVW0uzkYhao6dKRDASKIj/kguleK61WaEPJEGs6N1bSXKWJVH+d5jAe4YSGUrCYm1rcdYVmJyH6tXen3jo97iG5l0wX6/ikhBDzIbXkuIYQjz4lEdttnPuWPp8+hvnfA4NBvXbBuELbXvy22eHLiujYgt9xyC/v7+4QQ6PV6/L2/9/d44xvfeM2UqptvvpnPfOYz13OJzxjcNb5jK7h7ghA06LLjS9KzlMrgVOAVg3v50HNeQLNXkN23gtUKVRToxSraia6TnsV2l4PVxu0qhABVJannJ3aoT/ZoxhaXanRnsX2LqT2m6iT/AmTnf5jhE4Vpcuy8hz6cw/kD2d21VlKgQTINdoaye300Fa6+tZBlKB/tVq1MXnzTQjMBkB3iohDHLaVEiO5FXf1Qome4Mm3qobCePNjak51vwChcotFRdxKMEfrXhY/vAvbBI3EUi9ScMFuI3esgvTxh3ciiVFVLMVpJSradxCaAZDM1yI5azPlIRVJCC6JpCaM+7W5BO7j6JKjLNO0oxZ7TshufZxvXMaWUOGiNB1J0z1ass1pwMTembqSozjIJ/XMSCshsIetxDrWqYFDgy0R27Fc1vp+J9ub8lHzZwC0Dqr3kYtqbgmC1qAO1aEHWNL8wmcI5oeAF5zdNsdDPOhFzR01EmExhsZD1aSPicR/Qezs0t+0eC+vN1d3OQpxMdaUhmYCeLcQWOVKySBOxis5SobHFEELVdHA4gaaVvJwkITQNhGpDddNNi6pTcXyrW4I18vfLZdSFxIbTOcmHsVZer3PHzZ+Ldr7GQJayPJ2QnFxy0s6Y+ZxctSxcSravSZZuu5N8A/GMuf5dD83G9rzd4jrhujYg58+f56/8lb/CG9/4Rr7zO7+Tfr//iP7+He94B0dHR9dncVtscZ2gPPil5b72BC9K7yNTlluTQ8Z7cxY3j8lHQ7G9zTMpWqNYNzgHu2OwJZw7lKK+lAI/dKLt6AYZzcjS5cKX90bhEhunAwm6i3keRsmOfmwM9NCS9hMy52E6i7c74a7DhgYWmpio3isJ44G4Yh1OxZI0HE9IAFSai07Ee1TVoLME3aSojGuiUz1Slyvlwaw8yf5Cdua9FObqtl1xvrqEv6OCuDCpPJcJT1VDluIG+WXNwXpy0gwt6rYd7LzBnJuIU9OqxnYOvcrQrRzf9OwC9o/k0I1HEhipFN0wpxnZjd7jiq/ZyKSBNEGPR2IF27QyveiVtLftUe+kBAPJvCQ5qjCHC4I1+FtPoBe1NIsmJoAvZbql8hzSVHJhnBcKWZ7Q7hSwU9D1LNl+RZjMYFVhxwV6bHHRYnhz3DqPWtYyAQKYL+XxyuJ4EpZoofDlmZw3VY3KUtzJMbqRpHBf15K3EjVKandMe8sO9YlUzt/15OvC577ERS1EOuM6b0T5IK9vvojuWqX8t+0IWYpqWtRsgV+uCG0nk5w8kwZKKWkWfSBMpqjocEavpLtpBAqSVUWIdr4hakVQOk4ExaUuxPcc2DQo9bN3OfgKxUtu+zx3JOe5M5my8Jppk5PMxaxgiy222GKLY1zXBuRTn/oUz3ve8x7137/oRS96HFezxRZPDNZJ6J9c3cJfK+7hhHGcNDNuHU14oNwh5BmqbjYZE/7UDgDm7KG4S3krRV5Zys5uYoXvP+zRDlNcdoFYN+4SqwBYJYXtpYg7+y4zuL0BxnvJ8Di5R5gvZNKi1DFfvt8jDEronBT61kA5hKpGrycJjYiA/XQm9KHREIxCNx7Tajr98FOQR3Vc2yDFdxWnNMpe0ctv44yVpXKsvd9Y73Y9GwXPlyxOSWNQ7SWkqSZf1LCspMGaLzGTGXomzmRqWUnehzGonrhF+SyhHaV0mX5YMb23CjfMMc4TMiu0IWvweUYT7YiDApdpXKbJjEa1Hp9Z9EScz5SWYLxQ1xsTAjUeQpHRjQpcaekKeb8kob3FHMzxsZk1yxa7SAna4M2xtkb5EBs1ObbmrId6QeiQgjuVta7D/PAeVea4U2N8akQfMehjdsfxTZC8jWavR72bbJpnEEqddgHl2TTUxF5yc/wColWqanBL+TykqWiTTE0YD/CjEr0SwwRianlwTqZHQbQjoWk3DQk+EJpKmhfnsPvRka5filHBqpK/r2ppLk0e11DJtKnfg52RfDaAtm9xt1e8cu8u7kymDJRmhmLeZNgqoLrtNvIW1x9bDcgWTyVc1wbksTQfW2zxVIXyYFeKT89Oct9whGbCR5fP5+57b+GWQxETk6VCnXFOMgYScQ8Ks7lQrWK+gtjUJnTjknaYCLXHXF7cPqR2gqi1MOATI0VY1DfQdfi6RsVJiFBotIQUpgl+T4TValHJbjYcu2x5EbgHQDUtelaRtQ4VSsLYPmz+xKNFMBp2R/joUCU3xp+4o67bgF51Unw6D4slKkuxgPIZrsgup2CtdRCpou0Z7LgkWVbSKMYMC2aLjUMVSSp/qPVGbxBinMrDvwZFO0xRtUPPV6L9UQqfmYv0EF5BMzAEU2AXjmRaS/OzqiQRfJ3HYS0hT+lODGjGYmm8nvLoLqCcxs4kw0VZCdnT544oABV6uEyctEzt6fopVolTGEpJ1stSbYpy5ZzQBK1FacmbCWkC3mMWDr2spCmKieiSv5HTDuxFzYduA7YKmJVDxwLdp5q2b+gyOXfWpgPyBwo/ryT0UmtpDIqcUKT4RBof1V44PpGsEBZRrJ5nMnHqF9JYzxdCDxv0RCOi1LGTF5FimFhx0PKraNfb4psWNZujlZbmM002U5wmWB50Gf/H9fmT1bP44vkxe3Us4rYakC222GKLDW6IDe8WNw4vPLrvIjHee+/82qdnGuyTAI23nOuG5Krlv5z/cgZ3ZQzum0nI2zr/Y7ZAPXAeba1kP1gbxePye1+mdP2UeifZhNE9GngjadeA7NpmqWROJKlY6q6FtlkqRftkhhoNcDslwWiSozluNt/kP5Am4ri0/rf3cDRFFzlJEp2f+lJMc42J5tcEJWv0qXx16apBNX6zS7feATS1F+vgo5kE2HUdqhPXJqP2gOyKU4q1NsVlimYnxSx6qAeqWJimMJ2JnmTQk0nIQtzBglGEJNJ8eHj9y9oCGCvibX9wFG2Si8vui4G2t7bbdZgkBgBaK+9XfB+6nR71XibTkwvOk6DlPVDOQxdzLZSV0L26pliOZQLTeXBe/n9RoebLY+3DOpcGjicBa22KNai6QR9K7gydw8/mYk6wtyu2tVZflOguTXogO6hFY7OeVCQGTvWkgU3UcWOpteR9aLXRKKk05oG0Dr1OawdpsnolOh4j1StRwwG+zHGFNEraRVG4Nbheji8sunHo/RmhrtGjAWo4EGesSkITCR59y2k0EA4O8dMparmUINFUYaxn7nI+3Zzm3vokH/ziV6D/IseutvSrG4Vn3PVuqwHZ4imEZ3wDct999/Gc5zznmu77kY98hL/+1/86AG9961v58R//8Ye8/yc/+Ume//znP+Y1Pl544dF9vP1//ttNKuxuPeOlB5/lLS/7nqf3l/ITjKDAJ3Ayn7Nr5hgCizbFLgJ6upKQwDXVqRXuv4870yrPCHkKiaU92aMZiFuTS68u1r2W9Sgko6PrWaDELBthLq2FtOvCOdKSVK8kLFbYB4Q+sw5bAySoUClIZcJAYsWtqWkhTdGTJXnVkYxy6t2UtqcftyZknYqt5yvRTSyWmGGJqVNcajbic7Ps4GgmRWKaogZ9EXr3CklAt1dfzMaWttC4fkZiom5grevoOrBGQhg7RzCakNro6qQeNhF+3STpTuxc8UEocJ1Y/+o2Bgdy3KyITa40RXbWQ0dbXpRM0/ywpB1ndMXF58mGPuFBz2v80UQK8EE/WtmuCJ/7gpwD0eEM56WOifbNatCX8yFLNmJ+vUhkWtc5yZpZLAhZJmvuOsnk8AGVJPjE4Eq7EfArH22Slw57tIKzImzHGLTWZICpclxpcZlG+YC3GlPkYpiwqjYBiKHrxJXKB0Jm5ZyoL6ASZiluWNAOM1yh0bWXAMjOydQjT4WiCJJmP5sTqhp985j25jFBIeYOBwksV7hRdK1bLOWcj5+feqC59cQRX5F/AYAD0+f8pE9xRmGabQV3I/CMvN5tG5AtnkJ4xjcgeZ7zV//qX73q7x944AHuuece8jznxS9+8WW/v/3223nWs551xb8t1zuGTxK89p4/2HwZQ/RED3L7M8Ih5AlE0IGBrbgjOaJUgV7ScD5TdLs9kulAbGzPrUTY7ZwIXRMr7j5tC+MhZt5gEk1X2EfdfGzWE3fc6x2LKwzJ3JC4gD6cEqpFzD7wKKNRoyF+PEAvVoSjKapu8Kf3YFCgp8v4gCEWq0GcmVaSVaHaFtW2cP6Q5HyKrk/C6ZK2//g0Icoj9LD5khBEFKyP5qT9DJdpvIFkKY5gymh0kaN2d+hODfFWE6ym65lN4vZDP9lxQ8Y6gX49qTp/hN4d4Qdi5aqXDQmIpaw1l+tLLnsdQj1Si+o4wLDrUG0XdRgXC/kvnMy0OwVWa3TdHk/TsiTmjTzE81rJtQirSvJbBgPU0BLO7wu1KsuOTQViQ8TapGC5gskUpUXzIvRBL783BrUzxvcKCbB0DsajOE1JCRtamZLmow3Y+B7RRZ1G1GsEbdCHc9JzR5AmdDeNaYcpPjd0p4aonR56JrbKKIVqWwn0XK7Qw75oPdbWxeMBvpfhckvXM3SFJgGZsqwNFZScw2bZimhfiaUwqwozr/GFZPKoMkctluj7H5S/a1ppcsoCPyxxOdxUznhJdkCmNBovA6IqbOhlWzyx2F7vttjiyY1nfANy+vRp/vt//+9X/f1rXvMa7rnnHr7lW76F0Wh02e/f+MY38ta3vvU6rvDxw53zMxelwYJ8Kd85P3ODVvT0hyGQKkVpG7oSVjfnqHAK+wWLP5qgjRaNQszwCE1LWKxQqwp9mJH6m2lGj8w97qpQUiC3RuGyhK4YkA4y7PkZTOdSZPoAdZyORLpO6DrUqhGdQlUTBj3ZQa4bsVzdGUKvkKyRLBUr1CQhzBeYBw7IUoPLc8mceCzLD1K408SiM+pkwmSKTSy5HuMTjZ036FkFWSoWrXlKUEKR6nJzsYj/mp5YbRK+/WIpDUhVY4wmFHsEo9CHC8xsSZKdkAbnoRLhN2GKTug9dSPFvnMyUXBB3KAu/bPYRLYDKyncU4WpGnm/5hV6JwbwXeYGJkLvNVVL74zlNVkjOiCt0dZKNs36J+bGqH5fmtOqFoc02OTYqNEAP+rhypRgZVKh2k40TdagqhqyBJ8ZglJCi6sDpnKozmPmtdD44qRircOg7eBoCocTTGLx2ZhmlFCPxVLYrAqy/Qpz5kiCHH2AVItFrw9QSjZIaDsgox0kdMUFwvfOxyBIcX4zq1ooVlHjEpoGt3+IWiwxZUG4aZeQW3SvlM9IlhJ2U3TbiTNZIfbMhWnJlCbBsAwZrjMSOrnFDcEz8Xq3FaFv8VTCM74BeSjM53N+8zd/E4DXvva1N3YxjwPu6d/Ebj276EvZobinf9MNXNXTFEFRe8s5V6BZYZXH5dD0NWYvQ7kdjDVScLatJC1nImoOTSPBbzFx+fG6AGwyN2IAoLcGn2bkWpE0rVBKEuH8h2UF3kXhbEBN51LsNa00JtbIv+tGJgNai12wNVJUGg0ndkQX7mUX2NtrSzu/8uLXRXsU7qeJND9NC1UDZ86TLlYXWRsHH8QyeL4gWfZxJ4b4JKd7JH2QUpIPETUAtC1KKxE4dx2q6WQiM5tBlm2yK67WfKxF1aby6EpS7+mfQNetJJ5nycPqR3yiCFZJsxGnTypNMLVD+csPsHJBflc18snP0qgL0SgfheZNs5lEqC4Tx6lIWSMEVJGLrbFShDwVUXk/weUmNgWeZFqLFsjETI04ZVBd1HocrVCzpTQw0RwgeCfHuKpRUcMRvBd3tqbFzJcoP8LlkniPUrhUE0xB7gLmrCfYDoZ9/LAQqtmylkail9OORBOzdvkyKy9TvNiY0naExVKoVzHVXM6bljBrUE2DHvQkZ2ZQ4G6OTe6iRU+WErCoFPUYTqRzDAqPpwkG32p0B9sE9BuD7fVuiy2e3Ng2IA+B3/iN32CxWHDy5Ele+cpX3ujlPGa8986v5aUHn8WFOI5GEZTiPXd+3Y1e2tMSRgUS5WhRaOXxWcAl0OWa6mSO7SXYSY2umhgyV8Nyhcoy9HAARU7XT6853O+R4FhXoGnGCXo5xNSNFO5NAzpmLGgl1sCrlUxnnEM1jWgBnCOEgA5e9APGoJJEbExDQHUJJBa9arHLFJcolL5yON9D4SJh+aKJIXgaVRSo4UByKOYL3MGhaANieGOopBDVRS73bY+nC48YRoOyKKXRZbFJsmdVw6pCFQX+1A7tMHlIfQmI/iFZdBcV626nB6MeIdH4tVnAVbDRd3T+eCrhPXZSY3sWl5rj/idqTcyiFScopaRJXNWSVJ7IRCSs3/s41cJo8E6E6FkqCeqJxZcJ7TClHVgxRVDyenQbhI4XGw/VtOJQZQxmUgmd7/AIN19IgQ+YYR9VFISYr+GbRqYxvVJ0RmlK2B3RDtb0svUUSET56lRBHgL6aC6UqDoVehWgOkfXS2lGdvO32gXMqiOspzu1PF8YDyVJfTIVfUmeybQrBkOSJmIWMK3RiUHXYPZn0rQ4T/vlp1nd0fAl+VkcgaV3/EVzAjWz2FVAuW3zcSPwjLzebTUgWzyFsG1AHgK//Mu/DMCrX/1qrL3yofrwhz/M3Xffzf7+Pru7u7ziFa/gda97HadPn34il3pNuGt8B2952fdc5Arynju/jrvHz77RS3v6QQWscuTKMfMJR02JasHWgWThsasOverQi0qoTUBYRrvQopDiLbGo2mHnTnIjHiOF6VJcKLZud3LMYSap4c6jewX0imOBepahjJEJiPeb5kPFKURYVdHFSZKnWa3wkygAtwbdFsCjHX9IEW0XDj1dCl1Jy068WKrWklES7YsBiCnvpt8TN6NC6EnKXYHb9HCwBnpjsSc+mkGayO65j9qF6BZW72W0PXNVetdanG4qT3J2jpqL3ieEgI47+K5MLnKLuvxBOH58F2QNRiZp+nBGMsrEMesCwbdyiF5Ca0KvwI1LTExHV87L1GvUR69qwuFEpiB5Tmgl50X3SrFntgafiYZobYoAMpHpSo0ZpmA1etkQaMShq+3Q+0fSZGQZ2hiZOHQdKE3ol4QyQ89WEpAJ4qwWpy/VLQOaweWUuWAUbd8AJUXTwdl99Lq56hyhzGkHiXxmVHTdWnrMopZQTSdOXipNYFDi8wKlFToX22CUwk7nMYhQGi3VtJgHV7E5iyeRVqxOGL70OV/gluSQA+dYBsO9q5PYucbW2wT0G4Xt9W6LLZ7c2DYgV8EDDzzAf/2v/xV4aPrVH/7hH1707/e///289a1v5V3vehevf/3rr+cSHxXuGt+xFeA9waiC5WBVkh8oeg80pOeX6NmKcP5AMjjSFGU0PopnFciu+jJg6oYk0bgiWts+npa2Ed4qCebrFbL7G+k3tN1xo1HkMqVhKY5QXSf0Ha2lCL8AIU9l0jFfSEOlNS57eGH2lSAJ72CqgK7j8wQPSPq1miwI05mEzPV78hoWK3FCijkRGI2qZFKwTjK/VgSrJOdivbO+3ojQGt9L8Jml61naXizKr5DRcunr0U6Kf79/ILelCUwlf0/niWS2PBQNyyh8oglFItMC58Qad1GTnFuQJTrqRMDUF0xb0oRQZrRDsbO1Z5zQ1coe3SjHWI2aLaR5s1amJX5NNWulUdFyvqybj+PsFE3bt6jGi37IiL5ETef4xVImDGvtUNvJFCueNz6zqKU+thU2Bl/mtCdK2qG9bKK0fs6ghV5GnIgRgtgia3Evc+u0deR+ybSVBjZJ0cVxMxyaVs6lthMdSpYSigRVpOjJApYVpotUsRAI8TjqmbhoLW7RvGx4lqXP+KIrMQQOmhLTqK0G5AbjGXe9205AtngKYduAXAW/8iu/gveeL/uyL+PlL3/5Zb+/+eab+ZEf+RG+/du/nTvvvJOiKPj4xz/OT/7kT/LBD36QN77xjezt7fHN3/zNV32Ouq6p404twHQ6vS6vZYsbA60CifLs6orMdqyWgeyLU9ShvM+hacSqtJTCX7l12rMjeI+K04f1zvn6QqAewuL1kWJdzLWlprp1QGaUTBSyFObLTeYCVS27wc5twgrDUnbwVZ6hkp5Qr6JrUohp1SEEQp7g8kdvI2zaQHrUYFatTDKyTJqbdVq1D1LEgxTJRY6KCeHUkoCN0fAw+oorHZuuMKjdEt04SSLfG9INMqEg5aItCFptdB/X8vg+NjUqTQhth+r1jsP8wkNf7TfvV0+jTuVkahczWUnhvVjCA+fI2w5z0xCfGeysEZOBOk4ktMYu43tkjdg9nyjRtUNPFoS2kfdssdxMZ9Ta7cq5q75WeW8VdlqhDibS7MwXuOlcNEIq5mmsVvj1+5ZYVNthHziUx89S/M6AZregHZiNq9nVjqvykEwb1HwpWpJaJhvKgq67i9yntAM7b0RrUuaiY1JKzqc0ic5qojvRdUMY9iXgcNQTzcj+oeiZskxey0rE/+2tO6xOeQrTcK4bkignOoOjPeyCbfG2xRZbbHEVbBuQq2BNv7ra9ON7v/d7L7vtq7/6q/md3/kdXvWqV/GBD3yAH/iBH+CbvumbhEd8BfzUT/3Uw2aJbPHUgwqgOsWiyzAEBjqwky3ZT5WEtE1nMUk7QecxYM0YlNGEILx+ZQzB6PhftRHSmlZCBR9vPYi3imZg8HZAsiiwR5WctyFIqBxI81EUspPtJFU7LCSsTg16m9A2GhGre+dQ/R5dL40C4kd+HHWHJICfmcL5QykW80ymMIuFaD6KROg8bSvJ6M7JlMRLAJzKM6Ee7fZxpb3mdXgrNJ+u0EJlis2Bt+ryKcAjQUAmFs4T6lpeR5YSygyfmodd3zqcsOkbCDlF41CTmeh1ADVbiCXwsEBPloSDQ8gy/M27BKtFR5OK65WaL0k/e1Yag8VSGg6lpAlpxXpYZSmhX+JHJV0u5+Nl61EQrExnNlk2i6VohmJjFZZL/HRO6Fqh84E0DVUtdrbjPs1uQTO2dJl62IbOW0V9Ikcvh6jPzfFNix4NNxQq/DHtTTdi6BDaVj47zgsVazKV9Y2Goic6mspncSlWv353gO8V6KrGT6aE5UoCLa2VwMLWoTqFVoFMt7TB8KfL2zl/3y4nzkXK31aAvsUThK0L1hZPJTzKXOWnNz7xiU/wJ3/yJyileM1rXvOI/lYpxU//9E8D8NnPfpY//dM/vep9/+k//adMJpPNz/333/+Y1r3FkwPKBdKJ4pOHN7HvM0pteP7gDMtbA26vj0oTVJGjT+7hn/ss/N5wY5GqskyKv9VKQuIWS8y0Ip048kNHdtRh6xhU93heGJQUjwQw0wa9PxUqFgi1JU0hSWSqMJ1LVkQSpw5dt9FjEGLBpbXQtk7s0A5TSQp/BIX62i3KrjzZfiWhgstI/8ozODFG3XIT6tm3Eu64FU6fkGM3W2x2skMIQiXL0iiklvyPa1nHuqj2VrI3ukLRlpq21LhUyeTjGicel8I0HjVbikjeB5kITKaoun1Y+tWF6wsGulLTDTLC7ghO7kGaSMN4/hDzxX2YzFF5DrsjcLEI1zoGIEbx9/l93OHkWNMT/6t7pbzvAGkidrtGmlLlLzn/YhPrBjl+1MOXKSpJ0GkigYC7I1RZSs6MTdBlKbf3S5mWdB24IFMP+/DNB6zpeWL9i1byOo2W1+U9pvbYSqx/7dJF612z0QmJdkk+Y2EyFVF51xGmM/zBIWG+QFWtOF018uNXEiTqD4+EvqYVwQZuTo94RX4vd6ZnmXYFdqJFgL5tPrZ4IhGu088WW1wHbCcgV8B73/teAL7ma76GZz/7kQvWnve857G7u8vBwQGf+cxneNGLXnTF+2VZRpZlj2mtjwUvPLrvIoHee+/82qdvQuwTCN0F0imcPepz5EpMMuNL8zO0p1q6MsH4IDv2hYSkaQXayF6AHvTFXrbrpJDvOjhznl7V4Ps5Pk9QXQojcSF6PDUhQSNbEkbsTkMd7YCVQvVKoeRMpkJrcu44v6ICfTiV4nW5Qg37koqdJrSjXDIYHkXzobtAMu8w5yb42WyzkxzyRHbwOy/ZHv0UUyVY54XWNF8e7973e/hRD1zAHi7xSV9CEa+1CbkOUD7ITnxiN45LYbFEz0tM3UMFe00F+CYXpG9RXYGdSI6LKnLYHeOLFH00JyyWqOkCczQT0XcvR60aQmYJe2N0COIIZfTG2lcVOeyMpHGrG2g7SQTPNLoVG+A25p2sGzFvFM0oIbFKkuitRfVKyYSJ+gp9Yu84u6OOk74TOzIRyu0jOp91G8jOrmRqET8rYTqXyY5SZA840rOGkIhVMImF8UA0I3UtyeuDQRS9x3DCrsMvVoSuRYeAXqxEFxIbFwXSBHuhzs2eXaBuqSh1g1aBAS1WO0ylMI1/rKfKFo8C2+vaFls8NbBtQC6B957/+B//I/DYsj+SuDvcrZOEn2R44dF9vP1//ttNUuxuPeOlB5/lLS/7nu2X9WNBtMw1VaCdp9zXnuSO5Ihb7CG33nJAdeIUWWKhrlGLFUkUcoc0gQWya1/mhCKVXeqDCf7gCOYL9HCIGfVRbYnyokPocrXZMYbHXjS7VON6iYTs1TW+qtFpIkVo10GSiEtXCBc4Xw0InRMNghaamdLSYPnMXN3R6RKsd9SVWzcfjmR/STic4JsW0+/BjmgwfGqkkDeKrjQEq1BdKdz/SgTo6pLmXk0XmGEOKn1sB+kxIiglFJ417W79i66T9/wR7DgGhYit19a9oz4kFp+nlzSSUb/TOXQMlFRFLuddnsGwL2L9OJm5lDaklhVmVZNPZMrg+znhpoK2p2E9DdLgMo2pNKbzkryeJITVCuZzyHPRVqQDseU9mkpaepkTyhSfxSDCh8GxMYFHz1fSTCTxUtZ20BCndAEVPNpawqAnUznn5T5dFyeRhRyjYU/elwfPCX0vBJl6TGeieYLo6GalUXMeRn2md2he/uy/4I7kHAkej2LW5tgqTrq2u8dPKJ7p17UtBWuLpxK2Dcgl+PCHP8znP/958jzn7/ydv/OoHuP8+fOcPXsWgNtuu+3xXN7jhtfe8webL2mIPulBbn9GuYZcDwQwDajacNj1WHrL7XbCX73pHn7v1tOMR0Ph5XcOtayO3XVCICxXUjCVmRRMSkVtiHDotdFoY0i8R9cpthQxdJdH69VHoUtYF3S28iRzh53UhMkMHylYwXlYLlF5ht4d4wc9AFln3RBuPQneow/nEqSXJlKgOY9uvIQQJkLvelhajYNk6UmnLcn5JepgQtAKMxrCyV3q28e0A6FSEXfdUURb2FzoWkixSJoQJjMRFfeicN7oR02dejyg1pviWotLlzGoJJXJzaiPK5NrbtjWCAa63KBGBbpK0FWDOT8RilfbyPNEjYyfTlHLpTQjbSu0JWsIeRI1E4F1ICFHU/l/pQhNi4+GGbosMeMhuVEEk4sgPqwnV5K1YSYLoSiFAG2Hr2u0jwnlZYYb9zFKCS2q7aRZegQwTSCdNCJsV1qmGFrLpKKuofaowUAmK52kvauqlgmJtSJW94GgGwncLHPIxP5XhOaa4Bx+VaG6TqaAeYYaDTdTIjcoacaBFw6+yPPTQwD+3+pW/ve5W7Bztg5YNwDb69oWWzx1sG1ALsGafvUt3/ItjEajR/UYb3vb2wghMBqNruig9WTAnfMzFyXEgnxZ3zk/c4NW9PSBFGOBoAO3pQfcZjvaECh1Q1uCL3PUIjtOmZ4tZJcYjsWt+1Nx6MkzVD+Kvq2VjA3nUAuHrVp0lWEKi00NXWHoeloC/7i2Inujtag9+bkae24GRzNC08jEYe1gNBzgdvt0gxSXanQbSI1CLSp8blEuyE52ntCNc8y0wTxwHus9SbYTG4SrL2iTkdEG0mlL+rkDwv6hTAl2dwiJpdvr0YysPFbUaKwheQ8a5TPyaV9cjhCnMb9copuGsDPCZY8+i+Qh134BHtKGN6aSi+tTJjvqicWdGNLs5kJrSh55dxSsIhiFOZoT9g/xF1ojhwDe45t2c5Pu9+DUHt0gR7Ue3XSo6QI/nUl4YwzCZFUJZcoYdNQnrR3Q7BccSXkTXa4JRl6bXTjswQJ/bp/QNOh+D1UW6LXuYlWhAd8v5fxOrDQ/cE1i7QuT5M20Fic5o0WPpNSxc1eSSX5LE+1+Q7Tr1dJIsLaJngp1UJ0/QMf8HZ1nogeJVDSVJNKwGC05IzG3x/VTXN8zsktcgHM+4yOTL+fg82NOLsKxHmqLJwzP+Ova1oZ3i6cQtg3IBVitVvzGb/wG8ND0q7vvvpt3vvOdvPnNb+YFL3jB5vaqqnjb297Gz/zMzwDwQz/0Q6TpjaV7XA339G9it55d9GXtUNzTv+kGrurpA+WBAInqGOiUc65m6VNxCsotWgv1RtUNfr6QCcKgLwVeXW9C0kIU8a4LakByLpoGNRzg93q43JIerEjPOZpTPeqdGMB2jXx63QWSmcNOKpjO5bnzDHbHhDIjaE27m9MMLd4iDYkL+LRPemAxk5WsLwT0UU16NCdUNX6+QAN22UeP1n/7EMcsCK9fXcidTxP8sCRYjU9NtL29wutS4BJxrTIn+yTeS2MX3ZxCI85LIWZKXGhlvHFKcmxscIN5eNvgC/9O+RBpSHEKdcmUZVM4NwFdtXJ8lksRew8H+MTQlVrSxR+prieAXYpTWDia4utaNDBaxQYnkQZivZbBAE7t0u6WtH3Rm5jKkxqFbluZEg16oqVoxGY5ZKmco20nxygGUpqqwzSSOWJXnvSwgqOpiLu7TihVg4EIzlerKATX6KqOwnOP0kIVsyd3acYP/32pXEC38RyJ1CpfpITUoqc56mgqupqZJKSDUMhCGxswa6Acoq3FT2figtV2BL9EjcVFSzkvFK7hAD8oxM1qVcvEsusgz2hGCenJJS/N7yNX0FMdPVM/Yre3LR4/bK9rW2zx1MG2AbkAv/mbv8lsNuPkyZO88pWvvOr92rbl3e9+N+9+97s5efIkz3rWswD45Cc/yXK5BOBNb3oTP/zDP/yErPvR4L13fi0vPfgsLsQxNYqgFO+58+tu9NKeFlBerHjbIB+xgTacSGa4POATg65qcespcnSvlJ3ntpXsjCyTnefDiezUxqwLtDp28FkJdcv0Ij+9FTpXcmgIStEODV2uH74JCRLylxxVqKMZASQ0rovBbI2B1OIyTZdfYKVrFEFrvC1IegmqC6CR3fS6Q88qdJIIDepaAwgDmNpL3keeivA9BEnRDtdg47tuQoYJpu5h2g7lPNoYVJbi+xlBK3QXcFptHk75SD+bOUzlCFbRDBPa8ljfcNlTrSc2TSCddNiVk9yQnqXrGbrseAq1aVS6QDLr0BOhQOGcvLeAzwwuvTzx+2ERJ0GqlYbLN83xr6xF7+1Cmoij2TrVXim81fKeluI6ZXKNdgVJ3YntbpyahDKXEEKtxH1siTSFqUU5h6478nM1KoA9WomwXAvlC21EN5EmUrTH9HOyNGZpVITQbiiIDzctuHBKZhcdelnhBwXBavSsQlUx72XYFzvotVajbTcUKmol2hOtCGtTg9gMKSMp6r5MpVmbLwhHU9RyJa8pTQhFhuosIbG0fc24v+IWuyJRivu6Hf708FaSQ4Otw5Y7fwPwjL+ubScgWzyFsG1ALsCafvXqV78aa69+aO644w5+4id+go9+9KN86lOf4s/+7M9omoZTp07xDd/wDXz3d383X//1X/9ELftR4a7xHbzlZd9zkVvIe+78Ou4eP3LXry0uQQiYJmAXmruXt/KS7H72TOC52RncbRWL23LG95ein0is8O6VAm3ElhQ22TGhld1ytBYxrNKEqpId7q5Dzxbo+XIzIdHTJdmyxpzos7opv7hpuAqUC+hK0rJVmgo1JmpS1LKC1qKbEhXMRj+hAJ8oWqPoynQzOVCx0LbznHTSQOdFiP4ImE+qdVJAan2sLRn2CKOHTjFf52N0paYdpKhViSoyVBfF16uWbL9CdSnNWKhcEJuIow67aKHzYDU6N+hM4a6gTVgXwrYO5PsNyYMz1FSyUpJeQXt6xOqmDJfGJufCRmVWS+BkbCb1oI8/vUc7sBtr30cKbxQuN1AWqOVKKHoxmDFUFco5KbB7JSGx0fTA4lPRDQUtu8RdbrB5nHrMl4RBj+7EALOUpiYkBoqUYAy+TMBb7P4cPV3J+XtwJA5uILoTLXkiLFci7E5SVBmF70ajQhB6U57KhOLhXmhsPszKY6diXazXCe1VLedgkRMSSyhEa0Ln0YcykWGtR1nGfBJjRPORpjIdc44wm2G0AufxXSeUrvlCTA0GA1Qnx5LxkHqkuKlYkitFojRtsDw4G5DtK0y9dcC6Edhe17bY4qmDbQNyAX73d3/3mu43Ho/50R/90eu8muuPu8Z3bIV51wFrKlE6UfyP88/hpb37+Ir0QY5ciTZBbGmHPWhEKE3bxcyMMT5P0YtKhLJ5KtkQVS3FUkxhpm0kRboopOBbLMVVqyiABFU32KMVSWnx1kqReZXCdi0cFgqKl4I5WpKqVS072krJRMcL/enCnd2go33vBV2OSxTeKHyisZWjK45F41fDOuHbJ0psU9d6hTSBWBDbQXZNVC5vxRnL9lPMrAaLFN4hYPZnZHWOTwYELQ2V8mHzeLrpYOlIrJYC3aorNk/KIy5dD0xR0/lxozhfYPMMvZdKgxMbleywJTm3RK0nX0mKTlI4tcvq5h5dcW3WwFeEQtY6LNHOSW5F1xHmC/xkKpkbw4GYHtQNlIXQ2dLj8yJoeQzXS1GLSt73JAGt6MY5qvGoEHC9QgInfcAspbHbCNWBEBugEPUWeB/teIv4RDG3o5FzDqVQTSt2z0V21anBhsJWB2wVM0yUksaiUjJdAZlyKCWvc93YR7F7WN/HWnRZyvQpBMgyaZCWnbyHmTiE6eFgowUJIaBqoc0RAuH2U8yeA39teJYqBBICA73CeU06D1sL3huIZ/J17RJp3OP2mFtscT2wbUC22OI6QTlYtQkLn1IHw731ScIXCsoz0fknTcT603mhpiiFXtZwOCX4411slYjVLdbITq8S96TgPcp74flHMbMUh5JInk4aXGFo7NVF6RvdgtGSo+CD3Dc6KAEoY7DzBlsauuJYTC6TgEhj0TEZPF4BfaJEEB8Fytfq7ORSCdZLloVMX3zYNFlmPyEZpvjE4q/iZLVpZFKFzwzmUIpM38tlx322RJ9dkRuDaXJctK/1RqGaDrV/RAgBa43QqXIlGoVLjp+OYvK1i5nK87hWHa2H1SYoLz3qSL8wgclMCuU0hVEfPyhp9nK6nt7kaTwW+NQQTo5QrUNPFhuthhoO8OMBev8IfzRBK3X8vl8w0XKZwhUWmwp1jhDQyxbXT0WDY1XUASnSmcMerqQR0FGc3e9Fe2Z37PCVZ6hBD7fbRy8b1EL0QqGJts7RaQof0OPh8Tl0AS6kuyWzDr3qCFmC2tuRZmZV4WOjHIoMX6aYZQWTQ3kd1h5neKRJbKw0VJVQGbtOGhDvpYEZ9nHDAlU7kfNEVzDJ5vFgDM1uDs9e8pLefVRBAV4oP05jV1sHrC1uELYUrC2eQtg2IFtscZ3QFfC8nbOcthMAXNCkR4r8wQVM56iyQLWdTDCcgy+ekcA258RGdi2gHQxwJ0bCuV9VIvBdF0XzhUxPTu4SskQKzyqGrC0b7EJ24sUl6gqLjDkS3U5JMlviJ1PCYiG/ijkafjrDWkPhPO0ox6diZatdEDF6IsWpT+R5QqQSeatEQ3EFUfYVERuXZpSg/IDkCy3h4EgoNj6gqoZk2sQAvId+sKDBW40vM5T3ok+Z1YTFUlyx2pZssUMooug5BPTBjFA3qLIgeI9ddrjc0CklU5dLn0NJ4ybBel6K3b0xzU6OT0Son8482Zk5nD0vtLkiJwx6tDcNacYJXaGv+NgXHZZrsC8GQCt8YlBWo1aJJI+XSLFe1dKw9kpCT3QTlz7m5t+dEwpgzNZQPtD1LG3fbKY6AKpqCUdybqvBQKh7OyMJ01zneYQgzVjVEayGMkdVDapVhGjPiw/oIifk2WYqc+naTCsUtvTcAjqHLzNCP0PPQbkE3e9JFk3nxJEtS2AeJzJGy0TGe5TJCf1SGpdOLHdDI4GIajCQxqlqMJ0TMX6ZoxMrjUqcoqg0oSs1o8GKL0nPMlCBA2/48+Y01Sxjp44J6FsHrC222GKLq2LbgGyxxfWChpPpnDuSIwyBo7bEVqCaTpyuYoGislSEuc7LrmzdCD1kOkMN+oQiQ89X4ki1M5T8hihKD1UthVFqaXdyrNXoRSrOQKnFzhuhNY2uPjXwiaIdJNhhDxWfX8Vk9tB1YmV7bh89mZL3eqLHSK28Dh/wgxyfGAkF7CfRyUkaEf8I8x0kzC6up4i2r1UtDVnXoZcNpsnETvehBNsBdOfFlna+REfh83p6E1YVerESR7G6Fi2CF9pQ6DrUbIlFpgQ+yWRCAhdQlpQ0Yr1CCvU0wZcp9V5OOxBqV7IMZGeWcPaA0Hbo3R383pB2J6ceJxc5Xq0pRnBMcbvUReuiBjIc3667gO6C7Nj7SF1TSvI9ikzOq6OpNBWDPiFN0I3DNPbixjRORghBggtDQOcpvkwkoDKV9eoOVBdQTSvWvpFSRpHhxz1cL8FbOX+UC/JcyxY9XRIWor9AaUlGB7H7PbFDfbonE6lL3cMc2IUnmVRCC3QOU0exvZZJC8ZL431uH3Veb6YVyhihu/USoXk1rax73JdpUd2iD2ayAWCtCO9nM/lcJYnorpJEzr8il5DHYcH8tGGvWJEoR6IUn233+IV7v5ry0ym2enKGz27x9Mc2iHCLpxK2DcgWgCTIXijce++dX/uMSI69XlA+oFo4akvaoEmUwyMFnM9TdJbJDumpXRHtzpdSzPYKlHMiOl9FvUAIQtc5KXaged0SDiVojhAIXYc+e0jadARjRJCuvGg3nMMujFCh9JVdsbyBrmdoTvVJUota1ptsEmW0WKgulrjpHLWq0MuV5EiEINSoSYqJ3Ps0BGl+hiXVTSXtwOCu1QWLY0cqO492rSf3NpOesFii8wyz6qFKfUV3rQsdp8yyIyxXsaCUXXI16GPSVCYh05mIjLtOhMi9HmgjlJxeKRkkLggF55LxkTfQDAz+jpE0A1G/4lKNN7JjnywkkM8vl6g0xe8NqU73aHvH4u8LXbJMK40EsegmTpEunSCt9TjKy/3NypNMa1TrCEUiwuu2k2nAZE6oa2kojBZHqPmCZFESkhN0RYa/QAcSrBbqlhbdhJotYVxudETKR6tkH8QRqixQeY47OaYbZbR9K41VbDyVDyiXYKqUtEywZxUcTpDUQyVTo2Gf5qRkvFwoxL8wo8aunBglrCqZ5ChFqKrotiVBiaERGta6KdEnduUzpUQMr1aJaDqmc7QPmwlPGIrNtVqsCIsFfrESkXqcmpBncl5oBdmQ6nTJ6rQi0Y6Zz/mz1vCfzr+Mc39+gt0HA7rZTj+eaGyvX1ts8dTDtgHZghce3cfb/+e/3STI7tYzXnrwWd7ysu/Zfok/WsTiadLmfLo9yS32kIGtjuk2sWDSU3Gc8pOpFHNWHHz8sEArJRoDYwiZwS46KTLzVIquuhYXn6IQGldVi4VuLenOykqys/XgcrOhSF20zDX/P1U0I4tuU2zdEnqF7Ph7LwnTTYtOElSey3QkirrRSrIUKhHO08lURDctaW5xeY5LLtCMPASUlyyJbL/Gnp0C4AcS1qjrRujN1mCqDluJtoULilXC8UTAVB46cfWiL8ntoWmkoPQxdb6qCV0brX6DHO80FQMAawhFgs/NZY3OOgTRZeqKwYbr15EcrAjTmQiv84yuTHC5unLz0QSShd/kWyTTBtU6uoEU9cGoGGIo91Eu2h2v4sSj7WRn3/RljVpBv0AdzfCT2fFtPkhTmWUyxfDSXK21My5XuBMDTGKlAVZKCm8k70S3geyoJTlYikHC3g7tiT71bkqXq01+ygVHAwK4zOCKnCwzpGkixX6W4kclXS/ZBExyafNRefKzNbr1ou2YGHGsKjLRcsCxhW/bQpKIeLyMbliJvD96Ji5YKsvwh0fSXMephtCxOqFwJSkq7dB5H3ZG0iDFz2E4PEK1HfNbLLxgxovHnydRjge7MfdN98j2NencHafdb/GEYHv9ugBPEg3Ivffey+///u/zsY99jI997GPcfffdOOf4iZ/4iasa+Lz1rW/lx3/8xx/ycT/5yU/y/Oc//6Lb/vzP/5z3v//9fPjDH+ZP//RP2d/fZzAY8KIXvYjXve51fNd3fRdaXy5C/MhHPsLf+Bt/4yGf793vfjf/4B/8g4d5tVs8WmwbkC147T1/sPnyhuifHuT2Z6qbyOMCBal2JKqjp7qYAwIhFq2h6wjLpRTEq5UURYU0HnoSmw8vu7BmVqOmCymUhn3UcIB2Lk5B/MbRR3WdJDbXNX46B63QXUeaGFzRE+3EJVOQCx2oVOtQR7FgjQL3UGToOGlR1kCWEoyOhbWIr4WqYmVSsapgscTsZ9h+cryLz3HBvfn/zSJiGN6kwezPCbOFCLUzKzvRRY7KM3yRolsvu/Drx1pb/64CybzDLKUo92WCGvWF5tN1kaqjRVujlKTMtxpf1xLal1jUsI8f9HCDbJPp4ZJjsfaFuFo+iO4CdunETSoWves8lKAv1zhot268KvS8kh382FAkiwoz7uEyg6kderoSh7AQNoV3KMWeOEznqEqaUlmf2gjB13Sktf1s6JfSPK2PYVxPl2tWp3PsMMXOW1Tn5bkbj6lj4OHhCj2vCNbQnuxTn0glDV1f5bgoeY4uU4TdhKAHpPsWVybUe2JX7K9wjHUb3cMeOBLhepFJc60VlLlMLtoOVTfyGqPwnSwFa1CzJSpmgITFUn4XBekoJUn0SUJYLiWoci1QTyxqNKS5eUwwCjtv0HUDSUqwhuUpxdfd8ee8tHcfKY42GBpnMBXYat3UbfFEYXv9evLhHe94B+94xzse1d/efvvtm2y1S1GW5UX/ds7xZV/2ZZt/33bbbbz4xS/mc5/7HB/5yEf4yEc+wvve9z5+67d+izy/so37cDjkK7/yK6/4u5tvvvlRvYYtrg3bBmQL7pyfuSg5FuRL/M75mRu0oqcHlIcuaE6bKc+2iudmZ6ifVbO4tWB0fyHNwqAvRepqRXDR0co5OJoJjz2mUdOs80CU8NTzFDUagpXCSiktTj7WSnicUrBcEhqhL+nlEN2WD7mbFbTCZ1KghelMMhXKXNy3rJUiLiaKq85tKDRKa9EaJFZE9cuVpKBbSzosMPVxTgjqAnqOC6jOozuZVuiqkZ3mZQVtg+ocZtGIY5iXbWW1rMGDblJ0J0Jq0wTSaUdyboneP5J1ntqjfvYuPilJjAIX8P0UbzXJ4QqaRmruaNGqrEXt7tDePBZxeK6P09Cv0cFrrVdIZo7kYIWqGmkCdHzdVl/k8rShi7WB9KjBnD0iTKZiCzuMQu7pHNO0mJiJsg6kDGunqraTcyIoeY9mc6GOZSksV4TgjwvrLBXL205sbCV/5ng960a0LfTGSjmdNNh5QzINqKqTBqduwRp8L6cdJHTZwwcoXjppC6bcGBWsG9SLqFcu2hw/OCPsH8r0KkmOpxxWdDdhNscvVzI9jLRA6ga1qiTc84IpISAN+d4O1M3GOY6qkt+1nWha4iFRzmNWDvPgIWE+RxUFblTS7Hr+Uv9+bk/2yZXjwW7Euf0Bo1mQQM4tnlBsr1+X4ElwCp44cYJv+qZv4hWveAUvf/nL+Xf/7t/x/ve//5r+9o1vfCNvfetbr+m+IQTG4zHf933fxxve8AbuvPPOze9+7dd+jde//vV86EMf4kd/9Ef5+Z//+Ss+xl/+y3+Zj3zkI9f0fFs8vtg2IFtwT/8mduvZRV/iDsU9/Ztu4Kqe4ghgKvjcdIdzpwd8eTLjK9Iz/NUv+yyf+N9fwQhkUhGD4fR4JHqFOqYy57LjT5rIjq1z8u/Eipaj7WSnfGckhf9iJYX7OvcgTWTnvWlRZUko0ocspIMSXUO9l6DcCez5HN/LwWrM2SP8ZCrFX1GIJqOJBVzel1C5tpPN9FFfbF7ncwgesz9DzxJpWJYraW76sh61qGA6F15/1+Gd23D4Q7RXlZA4LenwzqGSBD+SXbB06tCtx6w6zMECzh3got5iHeRY7yTUu8nxlGQZsx/WomMdbXaTBF/mNKMkumxdfGyu+T1vA+lhjT57uEnYxnvR0Rh1mShfO5kq2HMzwuFE3ss8g1UNXSdah/nieId+NMT3c1xfNDf23Aw1F6cn8kwat1ycntg/Om5q10gT6TfaDtWFK9LLFNKM6tZjz83kPYoOUKFtCUnU07hCphbX2KCtH7vLFG6tv7hU3xKpV8lSJkKcPxDXsn4P1e8T2laaKWuk2Zov5DWup1rOizYkJs2rokCf2MWN+2JxHQLduMRMVpLJAjIFqRuZhK3zdrzHHi5lCtl1kGWEXsH82SXmtiUvze/jyxLPge/4xOw2kntzioOt+9WNwPb69eTDpTSr973vfdfleYwx3HPPPezs7Fz2u+/4ju/g3nvv5Yd/+If5hV/4BX72Z3/2ilSsLW4ctu/GFrz3zq8lKIWLW6EORVCK99z5dTd4ZU9RxAJEtzBbZUy9jH4HKvDc3lnaPsJh7/cJZUZ7akD3rFPieBWL+1CJ3S5K4fu5NBtWqFtqvhR+ftNKcXjmPP7g6DiMbVmJqLbfQxc5Kk2EC/9whbQSCk51KqO+bYzrpxuaj1IKvTNG7YxEMxGnMqrthJIVJyXBavzeEE7uSSEXMzjc3gCMEb1ILZMB1bnNsQpNc1ww7oyl4DRGhPR5juqVonUZ9Fjd3MPlmuzMgvT+Q8xEjpMqC/RwiLrlJurbd2iGIojuckVXKFwmAXpCwdKRbpOi0lS0M0VymYbhWpsPFdbNhEe1PjaAqfyk6fFjXWH6YZcyTVKjoUzElBIntLoR+9hYTOMc1A36YEbywBH2cCn3HZSiWVku8atK0s8Xkj4uhXvvWPNS1WAt7uSIZpQ8ZPp6MLGRjXbDylpxJWtbeYxBjsv0tVksX3A8xSJZfq40OVEuYBcOPVlTo2Ta50+MYPcCXUaWoQYDsfB1jnA03dACQxs/CzefYvXck3RjORdV06ICuJ2SkKXgPf7kGL07RmcZatCXBjAGcYaqJuyO8M+6iea2Hc5/peFr7vgstxhx4fpUs8P/PncLxVkl7/2293jCsb1+HWPtgvV4/zxZoZS6YvOxxt/6W38LgMPDQ86dO/dELWuLa8R2ArIFd43v4C0v+56LXETec+fXcff42Td6aU9ZqADJInB0tse99Snq4gEAbkomtKOAH5WYqkFVLSa1UpiN+hjn8LO5uDORoJxH1dH9p5LAttBJgjQgRSlspiRhMt0kPm/W4hx0/mFH82sKTpdLroepA4lRqKqPNhI2B8jOfFlIAa8UPrWSIN60hF4fV1rCToFuHHrV4QuLTw1qZ4jqOsJihc5S3G4f1SvQ+0co51CJhb0xbqcPncecO8IfHglFxnkR1rct5eczfG7FsalfCM3JavxuT8ThhaUrjTQSa3vb+Npdqgm9HD1PpbisZRecKGhW0dLWx0ZEXXhsrvI+AzGl25NMGszhjDCVCRBJisoTQpqIg1QXNqL8jVbEeZpbxU3Lzmr0ZCkhlGvq23iAXtWE+ZywXKGyVLJHjqbSGMQd+xAbRb+q5LzJUkK/xA8LVFuK3WzX4Ud96r2crrw8ff1CRy4VwBcJxhhpOowWW1vvCVlC27ei3XicsEk7bwNm1Yn5wO5Yjn8SbZ9BzrM2NibWEMiEMmUNYdQXwX4n56NarMjvDSjn5bMB6MSKRqRupKFzXs4F51CrSk6VLhOzhbpGLSs04EcpzbNr/u+du8iV5ovO8ZHZl3PwxRGnptHBbIsnHNvr1wV4kojQHws+/OEPc/fdd7O/v8/u7i6veMUreN3rXsfp06cf8WNVa3olUKxpmJfgc5/7HK9//eu5//77KcuSF77whXznd34nL37xix/tS9jiGrFtQLYA5Et8K9h7HBECpgnYqeGBZkRLoAUmriTogM8sphOhsT4SVyNf5jAaoEKQgEGjN49FkUPdELpaCk7nJMTNObEcNWITGtpOfpyTAnidsD7so3wpoXYPtey1G1KqIj8/wdseyTQR2sp8SYjTg1DmkgGSJ+imE7E40OWGrjRAQrJw4rYUAiEzaK3xkyNU12Ha0cZmWI9HQj1rO2mWrBadS78n4XlRX4L3UojmFlfKhCZYjcsNLpedT1N5soMG3TjaQYpPFKbx0qgoJGm9HcGZGA64TpxvOpJ5hwpSWLtMXSSgvxQXFuumkmZCt060BPOF6A2U3lDUkmmNTxS6kAe0c0d2foVqOpqb+qjOYw7Fbhh9wXsPUjDnORQ5flCICHx1cJxd4UX/o/LsWATtvBwzrel2UkwqzmXtOBcr4Kukr+sukEw7svMr9NGcsFjIRCEE8B69M6bb7eMKsRy+VlxpJ/WK04+5WO6GXk5XptijJRxMZBJT5EIDmy8gbaXpDkFoZnmGTy2+TDB+F33+EL9/APtAnsk0qY1TO62OPwfLVZx87OAPDkU34pzQHdsO1Tl8L2N6R8ptNz/I85KzVMHzifoW/sf555Ces9iV39KvbiC216+nD/7wD//won+///3v561vfSvvete7eP3rX/+IHuvXfu3XAHjhC1/IcDi84n3uvfde7r333s2/f/u3f5uf/umf5s1vfjPveMc7ZANmi+uCbQOyxRbXCcqBqeHBasg5JwXlZ5anSKYa1UnBiFJC9WhbKHO63R66n6EnPdF1NE0UCwsdRmcpYSC2sqZqhFLTxlC2JEVHnvyajkXbSWFfN2LxeqEK+irYFIWaaK0qWgm9bIUSNegJ5SdPCEZjZpU4dGkRmPtU47I118hgF07oKS4QvMc3LVpr4e07Jxz+XPQqYVmhy1zoPbt9wskh3SDBG9EkmNbHcMBYoPsgaeWF2ljVWh8wiwY9XaKXWdwR94TE4AsJyfO9DJPnog8f9AlZimoddrJC1wldPyVoc9UgxXXzYWsp1tOjGj0T17LQdehesdEs+MVSJhLjPrZy2KXDVJ1MOhYr0Jo0BNRsiTt3Xg59lm2mWiyWBGvFgSwE1Ep27kMIKK2k+YiJ4mh17PYFhFWFOa9QvYJQJLSj7Njy9iqvybSBZNqgzxzgJ9ONc5acdIYwHtDs5nSPgH61nm7INErO56C5zJFNd2AXHbpuCVpjVq0YE3SdTKk6J05w9QXTq0jVC6sV5sigXIHyXuhisKFwkaXyWZtM5VglNloyd6J7KTLJDjmcyONaK3knZc7R83rsf1XH/+/m/8OuaXFAFRLOTAbk+wrTbBuPLW48rmcQ4XQ6vej2LMvIsuxxe56bb76ZH/mRH+Hbv/3bufPOOymKgo9//OP85E/+JB/84Ad54xvfyN7eHt/8zd98TY9311138a53vQuAH/zBH7zs90VR8IY3vIHXvOY1PP/5z+fEiRPcc889/Jt/8294xzvewTvf+U7yPL+qeH2Lx45tA7LFFtcBogkImEpzWJXMfEquOmZdRrIAM683RSJBqDNBC32oGaeYcU72YNR3zOYyxRiP8DtDfClJ1igRUIclhOVSnLB6hTQs1kY711aKqzxDdx7dQTA8dIp4xFo07K0E7IU8ZpT0pcBTqwY7r6QYbloY9el6iTQt8aW5RKETTTAenxpsmqKjQN6fGIn71WQux6BXELKUbqekGaW4PO7Sb0LtJBhQu7Cxjg06TmrMMX1Ht2GzW6+mC9TaQSuxqCpFJxbl3EZf4PulvJ5lhWo7WUdi6HpX1s1smo8qkJ+rSfYXqMPpJhgvNI0I/4c91GSOr2rJ3mg67FFAz1aExVJ29PNM3qeDibg5WbuZeoSmETqVVujBQCx8z+1LQ2mMaDLmC2niuk4oWIlFl6VMS6yEUobZHDWbo3ZGqL7oPq7WOFyYp0KWokdDaWiNQcWpjOtl0mA+wuYjWfhoAiDBl12hN+eYvL+I3e+ykemN86ijqO8ZDqJ5gDTuut/b5LmoaDdM00rqfdR/BOdEfxMF5L6Xoa2BVTzO1orOqm3x+wdodgnjgXxeqtjQGYMflUzv0Lz0+Z/hbw7uAuCLLuNcN2B1lNM/iOGDW2zxNMbtt99+0b9/7Md+7Jrdqq4F3/u933vZbV/91V/N7/zO7/CqV72KD3zgA/zAD/wA3/RN37QxGbkajo6OeNWrXkXTNHzDN3wDr33tay+7z1d91VfxVV/1VRfd9vznP59/9a/+FXfccQdvectbePvb386b3/xmnvOc5zy2F7fFFbFtQLa4IrbJso8da+3BIK24yawAOJEu8AmxWFpIgRQLOz1dkiQGf6KgKw1mXJCsBiKYThPCsEcoRBei96fiABS8pECvJx0X6D+UUrLLe2oPNyrQtSOddrR9s6FYPVwRuRZO+1QyLFAKjEJPVvhz+7JL3O/BeIAf92j7Rh53/bcGulITrMVahW6G6OimpJa10FyihW83ymlGKV2pL0oA36xFA1bhghIq2aZyXRevQSxwZ408dt0ca2PWQYnWSENyNCMsFnGXO4YT1mJzrGJmh7fqqsdGO0inHekXDglHoi0gBj+uG0s1WxKW8r6Hqoa/+IKI8n2c+OzuiA6m8+jVen1WqHPRqWvTUAz7skYWUayfS3J71AWp4KVZibkfoRf5zpk0XlQ1QetIQ7vyi7owD6brJRCEsqBXrUzSjMbnKfWeiM+v1f1qHbSYHTSS6REC7c1j2Mvo1jSu+B6qTprHkFgwSiZAa7vhw4k0QkkCUdivQpD3tutQo6FkhfhIPVNxgV2HWqwwkzl+OpPjNxpuzBREU6VFvL9MopuWIyxX6OGA+bNLVs9p+Kqdezmpa2be8N8Wz+fX/+IlFPem5JNOmuIt/eoJw/b6dBVcRw3I/ffffxGN6fGcfjwUlFL89E//NB/4wAf47Gc/y5/+6Z/yohe96Kr3r+uab/u2b+PP//zPecELXsAv//IvP+Ln/L7v+z5+/ud/ns9//vP85//8n/n+7//+x/IStrgKtg3IFpdhmyz7OCHuJFvtWWt1b8mOWJ3ytLeOSfbF3lZFO1iqCqM1tkxpraRsm1JoQr6fo1YN+nNnhILiw7FN72IJq2qzc66slR1x59C9Em8MupIUddU6lMvoeuYyu9mrIjoXHadKVxIUCGC0BChag8vMZU2NZD1A0LGpsD1yQD+4Tzh3EBuYEjeQ5qMdHK/pqo2ROr7GbtykukCycCRHFap2hCwllBndMEe3DnO4JCSiD1Ctx3ROKGPLFeFIKDcqTdFFiR+WdD17xXC89ftqGo+pHMFoVC+GYyklKfVKibbFeWlGtIpuVl4aHGOkmZjOUIOCdrcgXZSwWkko3rqJ9EF2+m85JXSic4eb34WmJbiZUOJGQ0gserGUKYUVW2aMluNgNEprfJnhiuPGYU2tuCxgUStcptGtRbVOHMvWDeI4fUj9yGVvVfwMmMpjz8/xZ86Bc9jlCr06SXVLSdM3MpVDpl2ul2GnFepocSzmj8cDWvxytdE+qXLdaGW4UyPwYM4eikVvEwMKrRUB+tpRLNIZQ5bKZ6tt8XUtAZpKyeeraVFZhrv9FPsvMLz8+Z/hq8tPM9YaExzn2wH7f7bHic+J/meLJw7b69ONwXA4vKqO4nrjec97Hru7uxwcHPCZz3zmqg1I13V853d+J//tv/037rjjDj70oQ89pEvW1WCM4RWveAWf//zn+cxnPvNYl7/FVbC14d3iMlwpWVaFwGvv+YMbvLKnFnQbsAu4fzbmnq6PB76692nu+Etf5OxLCtgbx+TmTH58ICyW2MMVybxDOy+783WDWjVivbuqQBs4fYIw7It7zyqmZxsjtJ3lMoYWakkQbzvUqhFa0TCjHVihvzyCHWzlQNcdTGbwwFnCbHb8+6YlWEPXsxu61EV/HhsYlyjavqbZLQjDvjRddQ1K0Y5yugsK22vO3kB2zu3Sk+6vMGcn6MVKdvIzccOqdzPq20Z04xy9bDHnJ+KQlGcS2LfONXEOspRuLA5RVxNYS0EdMPNawgbjDnzIEtBa3qfDCeHwaEORUonFnNjF3HIavSsXRD+bo/enJIcxMb0opGAGlDHoXiHNxHSBOpgIzc5a9Hgk0w+EphWWsQFdo+sIq5VoGc4diJaoV+BLmewoF9Cd6C2Uv5gzvs6DaQeG6kRKfSKnvqXP6rYB1amMZmDwydUnQ1fEelc2UsV80+KPJpjzE9LDBlt5lAPlxUnKTivUfCl6D2R65FeVNG/Dgbh7NVH/tE6Fb1rM2QnmwX1pPrpOmrZ1cGMrmSqqLDZ6I7Wqj+93IXxA9XqEZ51m9pwe9XNqXjz8PDNf8Bed4aOr2/mDLzyP/uc0+aHbis+fYGyvT1fH09mGN4lOhd0lLo9rhBB4wxvewG/91m9x88038/u///vccsst1+35tnjs2E5AtrgM22TZxwe6C9hVYLrKub/dw+DJVcsrT9/Nu557mpvHPfThRNyurCUMetIszJeY3NL1U3yZYhZGhLiViHGVVlL4Gn0cuGaMNCBVTWgb4c23WsL/Bj38qKTZzWkGQr+6KP36IbC+AOk2TleUwjcigNZrDUtiCXF3/Wq5EhfqSdqhQd06wo5K6Dyun4ow+hFauq61Bbb2pJMWc36KPzgUrUdi8TsFLte4VNEVGrvSmEUrU4p1eGPdbETWejjAnRxRj5PNMbri8QmgOnHjCm0rDWBsHPDR0jU6WYUQJK+iLw0D68C8IkeFIBOwaDMcghdB/rpQtlZS5RcLVJahbzqJH5awqCTPosxlZ38R8zLyXLQ9kVK2dknTAMO+vAddIFkETC22zK7Qm0nYZmoVXdBcojYTpgsDBx9R87GGRuyPxyOxlI5Ob8kXNcqPqXcyglXShFst4u+ukxyVXinNy9pcwXk5pmUp1rttC06aLgCyTHJdFks5/s5FulXMmklTyCL1cbWSz06abqYfZBmqV9DsFhx+meYr7vgiX5o/CMA0ZPzuwVcyuWuPvTNejB22zccTiu316ZmH8+fPc/bsWQBuu+22K97n+77v+/jlX/5l9vb2+C//5b/wJV/yJY/pOe++++6HfL4tHju2DcgWl2GbLPs4wAdQYBpYLkSw+iXJWUrd8tzsDHbc4FODhk2RpHyQXd/I0w9a4YoENeqhZ6tN8eoXK7QPqLIgGCMuP7tjQpFhDlPhuSuFKkvIUny/oNnNqUeXU6SuBcoFTOWOcxiMkf4lSUWwbQ2un20e+6Egxa2mHkuOBETL36vRnR5ubR50HVCtk+lDYiFJCUVKM0joci30ngAoTTfK0GVCsIp0scIvlqA0uizxJ3auXd+glTyftajxKBazUvAHraRoXtshg+RvVNE2OUkk1dxI4ntYitvZuhFSWRbTvi0kUnSrLMUPS1yZYJsuZp9IlkVoWllHr5D3XSnCQGHKQqhgWkPTojuPqSU53h4swGjavZ5MNLS+yJhgE5p4yXTkUUEh60Ua2GCMHI/lEu0cxhpyF2iHKS7VNHslthDbZ+Yr/E4ftEZPl3Jso1Zm4wqWJNAr5bOzpliBhCiuNSNKExYL/KpChwB2TOgXYg7goouYc5ITMh7hhyWrkyn181b8pdEXNi/lXDfk4w/exuBeyKbuSbM7/EzC9vr0ELiOGpAbibe97W2EEBiNRrz85S+/7Pf/7J/9M971rncxGAz4vd/7PV7wghc8puf70Ic+xF13ieHE3/ybf/MxPdYWV8eWgrXFZdgmyz4+UNEpSX8+578ffCkNhtPGcdpMyIuGdpjKLm4U1Ppz+7iz5wl1g2o6zKpDt07sY3sFqldIgQ2bwlYEuQmhV9DtlITdkeyelyWc2qV+zkmq06UIwc2jK/Il4btDTxZSsIOIoAc9/LAk9HJ8qh/ycTcWr3XArjx25UmnLelRS7LwEuL2CMb9m9C6xpPMWnQtImmyDHaGNCfKaM17XEyv/6taCUikc+gix4yG0swl5vj+Fz7PpVQEJUJtX8RjX+aEPBV60WIpu+z9HmrQR2eZ0HxWlTSKA6EQ0YrOQB5PimqVpuidHdQdtxF2RzKlyfONzkHvT0nu35eke6OlaShy9O4OajSQRiMEQpYQ+gWhF3+KTPQvVm8avfXzgky3dBsiDepyStYjpcRd8f3yYh/spzP8fCH6DKWk+V6s0JOlaGrihGxxa0F1+4hQZGJZDbhRj/pZu7jTO9K8rWSCRSpBj6KLkfuGVo6t0pKDo7IUVRaYfk8+H53oobDRslgpVFGgoyVzdcuA/Rdo/vId93NzOmHpM45cye8e/CWW9w3JD6Pb2nb68YRje316CITr9HOdcffdd/MP/+E/3Ewd1qiqin/5L/8lP/MzPwPAD/3QD5HG6+Uab3vb2/iX//JfUhQFv/3bv83LXvaya3rOV7/61fzBH/wBProkgmwGfuADH+DVr341IEnqlzplbfH4YTsB2eIybJNlHz/Ylaf/ecv/vv82PrF3Oyf1n5GrjtPDGUe3jMg/30fPlxCirapuCIsF6kFFUhb4yN33wxjEB1J8dZ1QrspcKCbTBbaVYMNNYQu0fSuJ1yE8cm3FBRcg5cWZSPd7hM6J61WZSRHXduh+dsXmYZMU7sBWnuxAmgXVetFiAOamMcEUeHMsRr6m9bnoerW/QM2Wx3a0eUJXmCvqUQigq1bWHUP1SBMJo3PuuAnyx68bRJi9TkYPGrpC044y9LKRDBSloCxQWhO8l4J/d4hJE9T5Awk7PLGLGxVCaTtaoKITV2g7cbvKMsJNeyyfM5Tm7P5arIR7pehs1pkciUUxIvRLaX6MEnOBw6kU9CGIvmGxgrZBjUc0t4+p9xJconC5JiksupELr1047MLhMk1XRoreWhT+GBuP9TEnIIW+MdA0KGWjA5ySZiEEglXH0zBkUuZ7Oebckdgm7wzRreS1bIT6aSKUt4MjQtOgB31Ic3kf4sRD1hCpcDsjEeaHgJouRD/TdtIcDvtyTK1m+izL4KXnec3p/5exXtIEwzk35P+590sYfkZjl1te+I3C9vr05Mcf/dEf8a3f+q2bf8/ncwB+6qd+ire//e2b2z/+8Y9z++2307Yt7373u3n3u9/NyZMnedazngXAJz/5SZZL2fR605vexA//8A9f9Dxf/OIX+cf/+B8DMBgM+JEf+ZGrruk//af/dFGa+u/93u/xq7/6q/R6Pb70S7+ULMu49957OXfuHAAvf/nL+ZVf+ZXHcBS2eDhsG5AtrohtsuzjA+UCZhXwnWagV7RotArcXE44O7pdaC9HE1Aa1e+h00REtLM51DUqTej6vehepEiMRi8rwsERfjpD1bXs/IaAWiZS60Weu1rV5GdX1Cdy2v6VMy2u6TWEQFCK0C/wgxLdSCK5nq0kA2TYw+Xm8lTrOKUQLYwnPWhIHjyKu/QptK0kW1uN6kSA7K4S/HcZ4nTJzhrJuugVQkmaL3FlKqnol2SdBK3oCoPaEUti4zxqLXR2Mddk6SIlSaG7gHLSgPhUslDWlrEiqDeYUYHtHGq2gLYVcX0IYpVct7CmXdmC/z97fx4t2XWX98OfvfeZa7z39iS1WrOs0RaWPGALYWMDBuIEjMHgkBiDwbBI3rwJi+EXYgwEVjAxsH5ebwaCQ0JMGJJgHGLMaIwJljwJLFmyLFlSW4PV6uGONZ5p7/3+8T1Vt1tqTbZktazzrNWr+9at4dSp6qr97O8z1Hu65HsilIUoCQiyGL0R4Ta35HwlMV5DciLHjHIhVJ1UJiFGOj2YzWTKU1v0+lazc5/I9CeJIY2hqPDjqZCeWHpOqn4gcjQt50E5iApLeGKCGk3EN9LrUO/tUw4j8fM0/SpPpu9j8dosL2s8OsHcirk7CESCRSM9VAbV7VCvdam6EmKwkL/VqaLcm5IUFZzYghNbRJs7MvXwToziRSESNmsldrqs8L7pRskLkQtGMp3ydQ1N/4pPYwkNKKWMEGuhtrg0ZHpuh+0rPP/o0Ge4MFxn2yWMbZebp+fivpCRHbet9+MZRvv9dHo8nUWETwZVVbGxsfGIy2ez2ZJQANhmkn/++efz8z//89x4443ccccd3HnnnZRlyb59+/iWb/kWfuAHfoDXvOY1j7i/svEjAhw/fnzpEzkd8jw/5ed3vOMdfPjDH+aWW27h/vvvZzweMxwOefWrX813f/d3873f+71LI3qLpwctAWnR4umC8+CVpA0pz9DMMHjGLsJ5jY2RxVhZiVY/CETvHwQiuwlDXBgsNfQ2C/BBF12mhNbhNzaXPROq0xEPQFPUppooWDMt0f2I5Zb2FwGv1O4uu/e4NEQVFuVLMaBHJ6VfnSRX0rWXdKqdSlrUKysG5NlcFtFRiE8iaS+f1riokQg9RknicqLiQJdOkqjG0ufh+x3sPjE0n7bDQ9EYncGMC1l4V5WkijkL22OiwAA9XCAERFcyJXChpk4NdUeLWV5BnWjyfTFRYoiOB6jJDB+FMkmZzGA8xTsriVXDPnVHGsiVB5trwtqBUui1VTGvD7rUKyk21LjYYDoyYaEohTQksbw/tJZ+F6VkkT0aC6mzFqaRrP+dBWfwqwPKfR2q7CRfS3NezLSC7RFuMm1IkyW0jmAzxHVjqkFC1TPUiYZHCRc4mXRI07mX18aKpMsUjmirwJzY2Y3GjSL06hAfBqiiEgO+0eK9OekxXKAoewa9v0sYBdLtMi+k+2SBxpCu+10592XV/B8wMJ7g80LO23CPEKDpXEhhGAixSxMhbo33ykWGrUsMBy9/iBekD7DtEpzXfHp+iPfe+kKGh6VQsfV+tGjx6HjlK1/5yHS5x8BwOORtb3vbk36c888//0k9zsn44R/+YX74h3/4i7pti6cGLQFp0eJphPJSwuYmIUeqFa6MjpOYOZd1j3LDec9jclGXwdYe3PF1ibY1BmWMaNl9id4eE1c1ZrWDSwzKe3RpxUDbPSiPsdV0HOSF/ByGsqObF7Ij/kViN7kK6k6AyUORHBUWPctltzlLcGmIawiItuIpCMc10U4pUqPJTMrhokjSn4yRRK/coqxFVzV+T+9xtcYnd36YyhNOatTORArk0hQfaCky7JxqIl/6T0q5ja5kp9tA480QkzJYWdB6TzCzBFszSRsLhLyFcUS1NyNfDbGx+EuqTOPCEBv3CUeJyMvGIilSRkM3w/VSbCdeTh5QyE5/oKGX4TryGtWdkGIlFBLmPeEsINo2mB0FgZYUqcCAUtiVDj40mPUxHN9YSo1UJHIu4hjf71Lu7VAOgyUhW3Z/aCDQEkUcSBmksg4/meHzHB0EJMM+wd4+xd6EsmseQUJOfj2CXDwR3siExRSOcNS8V/JSznOSoMJQfDJFKUlUoXR0BMd2SIIh+VpErZs3npKAgmIo3S3hVOKOCSNwTblkFKLSBNfPJDFucwpbI5Q1u/8PjKHa08XGmmgnlfdkXgpJ0VpIcVXBsM/4vJT62jE/cN7fcDDY4t5qD6U3fGz9ArLbEzpHrfiV2ulHizMRX6Em9BZfmWgJSIsWTye8LJZVqcl9SE8rNBCqRvqjlSxwncPXNTpNRfPvPX48wW5uo5KYwO2l3tNbThpcN8Er6eZQYQjVDJeLbGdZzraA/tKE/C5QVD2D1ynhLBQDtwa6CbYbS3pRokVuk1vijQKzMdltG4/CZW8F3jdpVdI47Z1D5bJQVc6f9svu5F12U8lUJRxVBJtTWYQ6LxOQOMQmZkmGlrdtyEe0UxOMpB/FJgEmDOW8V7UQhiBAzQuCjTkqb7o8tMHvX0OVFXprRGQtdTLERmbpCbGRwg0NdZYQbddEtUPVqbyGkYzwJYHKiqypkXjZToQurZjDE0PZlwmJpHZJdDCEqG6Arjwmr8UorxUuDvCBQg07mOlcpFkLBAH0u1QHehQrIXV8+nQyF2pMM4FT1okxfjrF5YV4UgBjxC9SJxqrd+9HefH1hFNHtF3KNMXIBMEmAdo6SbGybpnMRUOefFli53N0VUn8rfOwtUMYhdRpgAt2Y4EVYvj3gUZVEnusel25n/EUBj1cGqHyCpNXsDPGbW1JslknFc9JGGBTQ51qdB0SzaM3BTcAAK4WSURBVEKYLLpylExmrMVffJCN5yu+8YLP8dXpfRg8nyli3n/8au66/SD7HpTwhBYtWrRo8aWjJSAtnjCu2r73FOPfb134qrZ59gnCh46zwy0yZRi7mjumB+jdHdC7awe2dmRRHsfiA+jI4pXZHF9XqErLAjivpTNjKIbvYFyix3PpP9AGlUi8KUpLWVsnpR5m2OjU9usnYyxeLAJtqHB9Q53JIk65VBbTgZAobcXnEU7qJflgYRSOY3xX2sJVUYr3wxj8oCuPUdUo55Z+i5Px8F32cFITbuXo7Ql+MpVFpLWoqhKTfcDSyC4yMAinVgrvtsRwTBigd5zc3johClUNfo4uS9R4vExT0oMUF8vkSY6/WhrTF+dHrihEpBwEKJcSVVYKBMsKVQT4LEEHGhNqVHMjFxtU7dC1ow5DmVKcPLlxiBmexgyvlHTDRBpdOVTtqfoxetxFbW2LpyIMUL0u1d6e9JnEj0w+U06ayc2kkPdYnsN0JiWWZSU9M8ZI8V9txS9T+FNiloVsOtKjM8yD6/J89g4xlcXMKnxoGmJo8FqLeX+Wg3foOBZi4KSbQ2WpdH5M50TbCTZOcKa5TVOMWHcMwUoP0xAafxKpVmUNG1vyei7e/0ZLPHFqpPfFeXQp00NqmYqQF/hCfCJmdYX153UYvGCDl/TuIWyY8LFqwC13nsvazZpkq25LB58BtN87TxyqCaF4qu+zRYunAy0BafGEcNX2vfy/N7172UC7Woy5dvMe/vmLfrD9MngieNiif1zFhGOPzssmajWThXkTS4q1eO9QQSilbbMcozXKZfiVlLpjsJGYj0OQ3eskgijEJQE2DcVzkGrqk7T1X0yq0YKEeANWS1LRyc9JWQimEquriyapa0GiRsA8l1SiXgfXzaCfySIyNLhQzPFeK4nyPYko4UXSZUqHyT3hSEiEGs8kgrVZQHonpu8lMTjZgzJ1pEcmqPuPClELQzEhN+ZH3e3ILnhZyflvOiOwFSqOpcjv3odk0dnJsKtdbKIf8Xp6hbSvh6rpEdHiBQF8FOLiEF3WBBOoswAXaerENORQiel7EZF70qQnPjbDbI3xnZRqNcMbhTMK1xi50eD6KWb/XjAG102oBinlMNw1nZ80tZAoZEe8kaM3x7LwT5tpTbN40XEsHolAfCZ6XhHMQlykcF6hnMcUjZxt1BDgIJC4XOuEZCol78l+B580JZuLEkatxf8xEk8IUfOaTGcERxVRskdkbSe9z6pMY1YSzPoO7tiJ3f9WRSEa8KZfRaep3J/W4v8IQ5wxhKNSTldpZSIYLFiqQq+tML1iP+vXeP75BR/nG7J7MUrxsXwvf3zkStL7QtJN28buPgNov3datPjKRUtAWjwh/OPDH1p+CYA0z1ovl7dpJI+OxaJPlZoTdZ9t9yCbLmAj76ArcEmECg3eGMz2BL89gqJEdTJUr4dWGjce47Z3ULMZOu8RAt5k1JmhWIupe3sAduU9TZKQWyQKfQnkY4HlbR+edNWkHCXHZ5gjG0I6lJL+iSRGG4MfjeXKgUFZi0tiij2plBLGUhSorHhNTt5h15UnnFjCSS072ItOlL1DlO2htybY4yfA1WLOLmt04THGL/0ewahAb45xRSFTDVtIJ2EYoAd9WWR7LwQQJMlqkarknTSd5wW618XuH5LvTbHx6euTvBJvhQs1dpCAHqLmzcI3L1HzAh1HeN0Vw30sBYDOsHzNpNtEnnd8fIZ6aB03maKCfSiboMuFIV4vO0vcwRS9L9l9DyxlXo88Rl1LdLHZGMvkKEkkVaqZVuksg7WhRBMjijhVWYJJiW/uO5hbzFQmQXaYYdwq/tg6PPCQSNqslELiHCrPMY1kCoSM+SSU12QkBEg7j1oZyNRiMiU6nmCTAW5olk1VLlDUmcH3MtRkKilYzbEra1GDPr7fxSehEKHpXHZujUGPp+iNSo6pMe/TpJ8pY3DdjI0rQy69+l5e0bmTVRNzSwm/d/ylHL11P2v3e0zeSq+eCbTfO08SrQekxbMILQFp8YRw4eTYKc2zIF8GF06OPUNH9OyBJDYpHiqHbLqAEEcvKhgbWdzpWS7lcVmCygvczkh2dKPGRKu0yGGMwVeVFNKFBmjSnrRqdt7VMqEJnqIOh8d6XosJxdyhR3Pc1rZc3slQWhqmfZZAEuGVou4noBU2bhrZ2ZUWLRbLumbpm4l2aoLtAp2XyzZvNS+k9K+b4rspeifGWYufz9HHt0gBl4Tool62x/uqQmUpOghkt7w+TYdDXQsZyVJUEKBHLHe7VRjg+12qYULdaQjDo5zbhQzMJgZcTFDU4idxXiYscYQP9DLWdzmhUA2ZmzuS9ZLg+EjM+4vCybzETAp8FFBn4pFYSKIWvRmPdjy7P0Aw94Qj6RchifFGo+oaXzl0J8Ov9HHdBJsIMQtGOXpniqmk6NFHGjMp0eMcAiMG+iiUpvadsUgGjRGJE418w8lkZJngFTRSwaZJfhGPi/OSCFdWmMKirEyHll6QSFEPUwK7Jue0rJrpiUz+lnIvV4scazZfTlykKV4mb8sktjCAtTXyc3rMDjpevHofe3WN9ZqZSzgyHZAdVSTbNdq2049nAu33zpPDmRLD26LFE0FLQFo8IRzu7me1GJ/yZWBRHO7ufwaP6tkB5Ty6gu0qw3lFxziyoJRFZ17gTmyIcXzPCr6boaYz3GwGc42KQnS/K10Gzsnu/DzHWIvKh/g0RJU1PgooV2LKXlMk9zSTj+VzayJ0VV7K4i+OUd0OPgzAGGwvps5CXKSb5KjdeNxFbKsupW8jnNXowi4XemZaSspVVYlpva4l8cr0cUpBHKL7PZmyFAVuNEYDuokzlp4JJYtda/FKzidZKjvx1koPSG1lcmM0PjBS+KgVhNFSSlYPM6qeOcUH8VjQtSPYmaMms6U8iDjCpxE2MeKpOaljYyEZi3ZqwiNb+K1tfBihkkRI1HSG9h7iiKATUvbNI7wdj/taeQjmFr0zwy8a7eNYYmh7HeywQ7kSS8t7qKQd3YMqatQsJzyyKdKpWsoniULoxJI+laaoyRRfI1OHNBEvRpLIbbQQED+ZiRQrTZavmwpDfFmKZyNLQWvMvCYaG8q+kK3dJ6F2/44jMaYXhZC7vMBoja8tfp6LvEtpIZAAVSWdNlUl3hOtsHt6nPiqkIOXP8TLOneTKM0xW/L+7a/mvrv3sXfdLwsbW3z50X7vtGjxlYuWgLR4QvitC1/FtZv3YH0zBkfhleI9F776mT60Mx7KicSocAGhclQeSiuLUOU8bj6XhXKTxrTYPfZ1JZGq2iwlLYAUD87n6Fki5untEcp5kskQdVafYqXpm+Dpm4IspWUeWQyGAbrfk8V9Y172YYBNA8phk+70MEnQ4rwEuZCP8PgENZFeE7zf1ekXhUwCrIM4xu4bUndDdOnwZojOu+jpXAoJ01imJHkOSktB36JBPkuW/gPXS+Q4KyfFioskrNqKDMs6VKyEqEQhdS86dWLxGOdFVx4zKmFjGz/P5fX0XkhkM+3x+mHm8IaAKO/xaQyTSIiT0ZCKvMqXlaTTVk4M6p4nTTSXj1dWuHmO7jo4sIdqX5eyH1KnTdkiEGiPTQy6l6CthfEUZrkQllAmJHpWSjKb2X1xdZqgVleWj6OqGp/EMg0ZT/C1wq/0oZeiJ7lE8lY1SilUluKyGJ3XRNtgEzGkL86VC2WC4p1IqVReyPvCaCgKXN5I7bRCBcHS8+OKQjwhUSgTGoA4ZnIoxb94h3946BPsNWM2nePW8gB/dt/lDD8TkG7W8h5vpx/PCNrvnSeJVoLV4lmEloC0eEK4bXg+//xFP3hKGsl7Lnw1nxme90wf2pkPD8Fc8cB0yLaL2Wvm7E0mfHYf2JUOPKBFCz8vFleXcrUmQpSqxM1mknAUBKiORnW7srNc1bI4LyvUaEqYRKASiXSNH7vU70vFwqcBEgus0hgfaEmoGk1ENmP62PCRreRAo+8X17UuLGqWy062Uvj5XMzRSSwRvkHTBB6FFKsxdWYwhYN+iHKeYJahK5ErBcekBdtbJ1GsAHGMW5EYY2W9mPQzibQ1pSOYVpitGeTlbmxsUaCKGNdJTkkSe9TzsTDOVx49K4Q4eQ9liZ/N0FmGWuk++h14cEbLRMFoXF7LRGDQeCjKCh8YfCiRx08WXkmaVLW/TxBH6LyAKKRa61D2QykrXPRV+mY6VVhUXktMbxhKyEFPOlf0pEBtj1HOSZM6iFzQGJkk1VY8Gos+lDCTl7xoyhXjSIjYdCpkqN/FJxEuMuhZhZ6V6CJGxSzPvQsULgrQtRVCHke7hCKQqZv0etQQBcvAAV/VUs7oHUQRqtejuuRs1q/WfPfFN/PV6WEAjtqMD25fyeyBHvs3nUw/WvLxjKH93mnR4isXLQFp8YRx2/D81vj3ZOFEXpSse+687wA3HziPb+jcwQu6X+AvL7mM2aEO3bsS2aGdzVBpispSiePtSXeGGk+BedNboKW9eSEVKht5UpJAFKKLimjDo2xCsSodEItJyONpeZ8sUTFN4WC4MZXEozgSA3BZSS9HJ8VFj0yMejiU8+i8lkVp03LtG9+E8h7SBLvWk+s27eEuABuZZWpU1TUEc+mkkIMz8rBNkhV1jZqX2LUOVS+UFLHGO2EqWd3qebgrv8pNQ4IqXBpgE0kSe7xzpJxH1V524JNEduedRVVGduldM/k5TeWJFPhZzLFt3HQmUcqDLrafoPNayGa4661QXj25zUkFdaqxZ8Wo/fGyFPFkE/zDE7OU9XJOnJM+jZUOths1V1Jo51Djxm8BKK1wkym6qnHWSvlkt48PtPyxMaoo8UdPiCxucWyLWN3aYrYkvtjHEaZw6FrjjSLIHdFOidmZitk9S3CdRKZm2yNUGKKyTCRdi/dRVUtJo3cySTRGfCdnrXHimoyVa47zdd3PcnHosXg+kmd86L5L6B3WRJO61b+fAWi/d544Wg9Ii2cTWgLSosXTDOUhGnvCYxGfnpzDZfER1syECw6ss37wEN19a+jjG7LLbS2+bnZqAyPxrbDc5fVlJdcZT2TRX5aiuV8ZisxncwcVR4TIbrEfBMt4V7VYUD5sTL+UBDWJWY+7yPYLY70nmJQSizuZSmqUleQo1e3gouCUvoaTby8PLMejK4+q7FJ6tmj1xvulN2NRcAeN6VqpZQqU8hIP7LUGFYEfEhgt/SpFIbvfWqO8x0WGOjOnSMKcb6JzI2kEx3vxKXgnXSrZ7jl8vHNiKo8prBzfSl+kRc43Zm8LRUm0XeDChCrTsJg4LBK0Ii2dIbWU7rGxTTBPRV42m6HDEBMFqH742C/SaeBV05Fi1CmLioe/3ovfuVBRrkbUvRBlPd7IebKR3D5IA2LANO3xftLE8AbSxK6qUt4HnRQ1zUUmF4VNJG+J3ZrJ+1zJC+FGE5FUaY13Dr0ylL6TxisUTJv0LievizcKVdnd6Uwcyf8J71GDvhDaaoLSCu80pt8VUhiGzM/qMrrY8oZzbuVQMMJiOGYdf7b9fOq7e6wcse30o0WLFi2eRrQEpEWLpxteYmHNXOO8Zq+ZsqZnXDl8iD/bc4h6/4CwtpLcUzYSoDDENYtmjMb3O5BEkghlRWLkmsW1jpBd/qZpmtqiRzNi71Euo+o3UqPCEUwturTLQrVFslGVSWeIDdVyUfyoRKTxK5jcgvWS3uU9fjSWfg7nCcIQlwZNq7fcbLmr7uT20tNhidfnqA3Z9fdliTJG/CRKySQlCjGTAl1aaTDXspA+uaxO0TS2Zxp8hA+GBN0U9dA6fjKVx98Zo/d08SZc7vYvixkXz7Xxi/h+F/pdXD/FpubUfpKHn46TfRylx0wK1HSOj0JUUTWG9gDKHLa2CeYFqV1Fr8ZNn0sTmxwo6tRgBik6jVCTudxP0ExzrBXjfGW/ZF32o722J/ev4CUmucoe5llppk6gCZIAnURC2IwB0xj66xrCSHwiOxP8fI6b56huR2RT/R7GedxkKl6naFdKpaJQFv5KSLHyHmXB5LUUJzZm8oUJndqKwT8M5PK6maYVpcgWw0DKLpNEpmnDLsevifiqr7qL1/RuJVOwaS1/OL6a93/6alYPQzhx7c5vi2cfWg9Ii2cRWgLS4ktC21L7+FAeTOExOUzriBDHWuC5vvc5PnDpVWzfm7I26Yg+vvE52EEHNOidGWpeyO6utZICFQSwNsR0MimBWx3iA9MYeWNZRBcl2lrivEKXXXyoCTfnEk1rm6SpuoY4wnUz9FwIQ9UJqDN9Spzvw5+LchDMHLr22E4ox2k0KjDoMBDjtffooiaYyhTExkomBIUjHEuvhKocuqhQs1y8Es7JQjRJmnI5B7WVlnTnJB1Ja3wSUR0Y4PZHy7K6k0lInWp0bQjGSPKSlUWxH0/Q8/oRBm5tPbqQRnSck+SqIMCt9qj6kaR3LQiIa6ZIjeXBBbuEbQEfGnwUyv3RdF/EAWxWuMkU5jk6z8k2etR7ehR7E6qOkcbvTKOHMdGJObqQYkq0Bn9Sw7336MqB10+62f4JvV+bOGAx+St8tmtMP1nKp6zHzKX1vD60BzMfoE9s47Z3hEg3qWWARBuvDIVUzHJ8J4Wz92FGU+m4iSNUrytkKy/Be9ygS50GOKMICocqhGioLMX1xNujykqki1Ek/0eayF2iUKSJINK3JgzARyGz8zrYF475Jwc/xMWhxXnNXXXGnx69ku4dEdkJ28buPkNov09atHjuoCUgLb5otC21Txy69iSbnpseOMQHh5fzis6dDM2UF593Hzcfupy1W5QsvrSsdJW1qFJa0X1ZQpagygo3nsiEIIllYRUEIlmJAggNVBaVF3jnpIl7lhMa0d/rE9ssGq+Z57iiQMcxOm8K8pIYPUhRqwm+J83cp1vcLiU6kUZpRTDKJYY3DGBtBd2YjM2xbZJJitnXo+oFQj62cyFVi8lAUS5jdtW+PUuzNdZCEi4nOqSJELCdEYwhSCPMIBQC0EwzliQklLZwVdnlREMO2EnvSulRkdqdzDgwlQPrZVKRSfSuS0KqbhO965uCwKkjmFRLSVLdDak6ere1G2SCZZ1IhXoZthuLzyUw0rwO4pkwBhMGREbjdSz3EyqqjiEcGWlot04aw5vWd6IQVVlM6Rpp11PMPprpVjCzmNxSpwZSeU+e/F5QzbRHTwp5rbKIuhsRjcQf4uumPLKTSoiA1vhuKu+T7RHKaOxqH7XWF+IdGJFqOScEJUuo9mZUHb3sjEGDzxJ8HGKzUFrNvZdzkxfoKJQpSNx4VALTxEFr8Z0UBfbgGhtXBFx/3mEuDHaovOKEVfzPjZfy+dvPYt8RRzBvY3efCbTfJ186Wg9Ii2cTWgLS4otG21L7BOE8Coh3PPpzHf7irMu5JD7KyCXsiSdUXfE6qMmsmQR4dLNA9ZXIU+ywg4oj9HQmU4+8EN2783DsBLrXwzVpSd458T7EseyYW4fOm4V+vydt5DsjkWDVNeS5DAPCADMtCY3GJvGjdl4sGsyVcwTzCj2aSbJRvysRqo3fwU8mMBoTeo/JM/T2FDa3RaefJmIWrmQqoNMEeh3Z8c9z+V0UNu3VDjfIRO8/yyWdal4SzCx1qh7hM5EyQIVLQ3QUylSl6Y/QkxnROMVFzfRk4YupPco5XCfG7uvijMammroxnweFJ96siI5P5BhqK9HDe/u4ID2lDFDPSvyW7Oq7lR4+NFLcpzWq1xPiNZqgUokCDnbm2FRSy2wkf/I9CbFZw4xzmBWSpFWWMJ6gkxgzTQhT0xCk3ef9pWA52Wj+9oHCxfoUkrOQaJnSE8wldYztEcH2CNXJ8NOZECWaVvW9a7gsRuUyKaE28p4bTdBhIISvifDV07kkWNU1fu+Qsh8sz+siqEDlEtkbzIql/EpFkfSITGci8QL89o7cbmWID5OmsyRl64ouwUu2ePXwdmbesFNrPl0c5M/uupyV2zTx9q48scWXF+33yVOAVoLV4lmEloC0+KLRttQ+OZjSEe0EjMuYoZYiuNpLkpOLA1Qu8aEqy8T7MJfSQToaNa9ED9/tgFa4PSv42GA2xvjtEr8zQjsnPRhK4apa0n7WhjJFGE3AOjFDOzHt6jRAZamkCWWx7NyXNWZeocsIlQCPIvFRTszWOq/xYYAfdLCdCDOTtnKUQnU6Ihmb5ZhaphfLAjyQeNSyWpqW2dxe/p40FZJlrbSYay0ToJkU+6nRhHArpe50qMypccOLeGA9FwmT7nXFU7Mzwh1fJwwMXq9gY4OqHSa3mIksmm0aUvZDbKyalnlpZ4+2a6IjO3KMSot8LQpRvn+KGR4liVLLDgrn0EWNyqtljwuO5fRHeS/pYc4vFw++kWKhIkwnQFcZkVIwmeKrGj+aECjpMFH70t1EryZEAL40MuK1pIqhDDbalV/JL8VoH8wcurD4JETHMW5jcym9A5FcqUFf3lewnChp3ZRBLqZEdSEBBk1LvZ/N0f0eVTdaemOUFememszwo4lM/ZApi+pkqGFfDP7ei4+qCTFQYbA8527YZfvKAetfV/Czl/0F1yRfYOxC7ir388cbL0Ddn5JuOJG2teTjGUH7fdKixXMLLQFp8UWjbal9clAWdAXTMkIrx6Fgm16Qi79gsYvvvUwvFh0SSonG/SGL6veaKFePnsxgqvDTuSzeXeNfaFKA0FrShWqLKkrcaCwL9+0A70UeRCS9Dj6Ll+QB7/FKoUuHrvSy0PBkeLVrmPY6gdUEr2SRCLLYo3boWS6SMudgNgdtUEkMQSAdH3W99KGoTiYExTr0cAB7V8QbMs/x/a78ezwWU3Gvi7cOsz0hHMbYOFwmMy0WyOGohPUtKZ/rigQIY6QNe14QnpgR5YUsaotS5E5n7aPuBFLGt/hkXEiSJiVqLH0VWNn510mMC/VyAuM12EhTr6SE9QrkJWqaQyfBZzFqNMFtbErUcrezW7QYmCXZWRKIxnNiCitdHGUlU5ykkTiNJ5iiJC0H1MOUOjW4WAthCB4Zq/tk4LXCRvK3P4l8LFK+opHFzGp8oGXKFDZkK27KE2mM5ItyQutR82LXKhMEqDTB9TM5j0qJVMo5+Xe/g82aBLWmj8QFCtfroJ3HNyQUY0RmlQrJUbNcUriMQXUy8YQAajrH7htw4hr4p9d+mOvTe6lQPFCv8mdbV/HxT1/M6mHxvbRyk2cO7ffJU4P2Pdzi2YKWgLT4otG21D5JNGb0ze0ufzc/n+uzu3lJ5zD/c/VF2CQg6HTATSTpKInRUSQkwTpJEeql+ChA74xxJzZQaSI77YCvK2n2XiQJJQmqk4qefjSW+F6tYDxeyryYTIXMVDVqFuMGGT6IUWVNOCqbxbVeJiAtn4YSn0VlDDbRmNwRr+eYcY5LIuphjKo9gVH4KMAFGjMu0Ntj6KRSQAeoqpbjrevlMep+F9XryDGe1B6+aCfXq0Pq/UORJo1nBNsFYWygK16BRTywmVUi5ykrVCETGd0kMPm0aeUGkYCNx7Jj7/0jFu3ih3DovMLXVuRDgB4OcPtWKAfRKRG9LlSU/RDoEOwEqFIW6iglO/x1DUUhi3CjIYlxWYRNzFLqtEiacqHIy8y42J0cZSl+76r4e8YzkSMd2yHMSwgDfJZQD1OKlYg6a8jIEyQhSw+NQQ7gpInSYqoUjmuirRw9mosEqqrx40mTXqaFXA0HUpjY+Jl8bPC9TCZjeSHLy9qiN8fLqGVVVlJyuH+VaiWlzqT4US3kXtMaPWlS0pJEXkejheSNZ0JE5rn4PbJUCGdeyPleGbB9aZfeJVu8KJPCQYPneN3nk0fOpXdXQOd4jWqN588o2u+TFi2eW2gJSIsvGm1L7ZODsh5TAMqzGkxY1ZYroqP01qbka33CzT7aSleEyrKTytlkoae3JhAGuLIU+YkxshCbTKVJvd/FDjqYJs3JhwFM57iiQEVS0ubzHK0kFtbPc0kpqmtUXaPSSPwQOxNUGhOmARCgrafqGNHhl15SsiKFD2SXXDmFiwN0bpp2c2SSkHVwkZjZzTAi7kboWYmal5I05T1kKT6JYGciC8tB0/A+y/FJjOvG6Hkl3Q6ZkBc9q8Rcbi1mfYe0qAhWM6p+iDcKXTfkwnvpmWjgnRPpVxzikkB25IOmXT6KpAQvd+hU41BoK7v98bEpejzHAzqOUatD6n0DytWEqnvStARZvNeJAh/izG4JYzBtomajSCZC3uF7Pexal3IYN16Wk8jCoiBQK9Qsx83mMmVIYiEqpZPXrqqgKLCTKSiN7nYIRx3MpMf8YJeyZ8A8eRIiPyzKJq2Y0ueVBAiMp3Jug2A5DQKkbyWoUIAq5HzrcROU4Bx+1gQqaI1nLgRM6d144TRBJREukkkOCOmJN0qCUS7vi7pJF6tqVIUUVlZlMw2R1xKlmulLCGtDNl+4wvprcn70khs4P5iQKcWO83x850LKz/VZe8hh2unHM472++QpwKI76am+zxYtnga0BKTFl4S2pfYJwnmpNag83ioMHqMUHe3Y35uwtTqkG0kCk8pS8WpYJzvMdY0rCjh+QuQlUYjev1cIxmQmU4zhALunj01DlO9Ih8RkhpvNxFdizO5iXEu/hopj+XezO6+sF3O1taiqJlyfETrRxJt9PVyoJXkpaPwRRqRCdaLxeyNMN8CUDhvpZafIQlZkI4OLE+INQ1g0yVRKye639SILU415HUBr7EpGsRITzmqCQEsLOqDHU1nE9joyRRlNieYFwTjDZpE8p9pJtKtqGsmDQIzytfRoKKVEshYEEDVSnbLCzGuCWBa/pnBEm3P08S2R8+xdwYeGcjWlHATUsV5KlJb+E0SeZhMAIxOUeS1N76GcczeboZTGDTLyPcmjTyqUasoD9bLBG63Rm2ORIYEQEpCYWWvFAG4t2nvCXoxNNPUXk5TlG+P9VkW4OUeVkmqlykqIj/PQ60oQQlhJalsUgXW42Ujec1HYmMyNtJB7h0piCRiYzVFpiu9mQkbzQsiIkgQzr6WLJJw6whMTkcpliXTOlBV+Opdz4L3ELAO628Frg1ISEOC7KcWBLtuXaL79ipv5rt4drOiMiS+4udjPR+67kP49EI+skI92+vGMo/0+adHiuYOWgABvfvOb+W//7b895nXm8zlJkjzi8o9+9KO84x3v4MYbb2QymXDBBRfwxje+kR//8R8/7fVbPHexkJP4zZiPTS7ikug4Q11zaf84HzznEGu3NBKcJJIo2qaEUAXBMsVJZSmsDqnWuuiyxkznknSVxuDATCvxcFiH29qW6UcQiuF7PNndIS4KaavWWnaRfRPpGoSosjGkb4/xRYEKQ0LncN0U2xXDtFp4phWgZde/jg2qWZEvZETLRbWGOtaoYQi6h8liIQJl0wNSSMqTdhbWVrArXcqByIjqToTphwQzSzgqxSdgFC4JQSvM1gy2R+i8gL1DOU8L74d1UuQYGDElg3SkVLXsyjemfT+RZnkzr4hA7ncqHg7f72JXMspBJMRqYcxWjyQNiwmCTIYc0XaB2ZyK/Mg5CAJ0lqGSGBcHTWTwo79nvJFp1UJqx6Kwcj5H9Xr4TBKezELuNJ+L3C7PCbfm1N0QG5lTvBxPBLr2Yrx/cEcmHp0U18sgi6WLZdS8N/o98fNUdTPpaCYiWslEIwwlza3xrixazqkq+XcaiT9mmkMcURzoigHfC1k3hZXXqfHA+CQS0751+PFYiLnS6MVjxZEQtzDAxyFlP6DOhFjMvKeH5Ujt+a2HXgaf65BsOXTVSq9afGWgjeFt8WxCS0BOwiWXXMK+fftO+zvdfMGfjN/+7d/me7/3e7HWcvDgQQ4dOsRtt93G29/+dt7//vfz4Q9/mCzLnu7DbvEsgq4h3tTcun02s2HIUNd8Tf9zfOjKS5jd3KG/PpbFatOFIYV8jeFWi8beJSFmKqlNbq2PmhWo8RQznu4uwMYT6ZCIInQcyy7xQuaSpiJROalzw9cePZH0ID+ZiTwmEMP3IkXLTGaovUNs2pXUJk7yLCA/Ptp31YKo2FhRJwY9b/4/BRoCgzYaygo/7FEe6FH2A2y8u9B3gVr2kkS1Q09zNGA7sRA1ayGJsZ0YXVlwiEF6VjaLYyO78vMC5Q0+DVDTuSyCO+luTO/OFDVpOivmJco6yv19ql6Ii9Vy6vF4kiZlJaZWT0rUvBBiUJQihRv2sXv6lAMxz5+OyCzuw5RuWU4JSNxsWeLKCrW9g65KCCP8oIvvpuj1HfzWtjzWsXXCfkLZTx9Rlviox+2b1K+RJVqfwtZI5H5RiC5rSbPqpE1buaNe6WCmJUwmy9JBQM5n09EBoBqzuCoqCRuYS8CABuxZq7g9PVxsKPsB3iiC3BFMxYBPYFDdTF7nnckyRYtFZ44xqCyTZLjQoJzDZhHzsxI2LzOYcyeM6oRbyz3k4QY3zi/ils+dy57DUqjZokWLFi2+/GgJyEn4qZ/6Kd785jc/oevee++9vOUtb8Fay7/9t/+WH/uxH0MpxX333cdrXvMaPvnJT/ITP/ET/Lt/9++e3oM+A9G22T4KnMcUjs4XNHfed4B7D+5hv3mAK+KHeNk593LTeS8gPTYg2MnF4GsMqklKWnRm+PkcXVVgDG6lj+1FBFVDUBaLslmz2E2kBwTrltIcVdeyi9xJhLgsFrdFKcb2xULXWbmtUiLvcR7vLHo0I+gtZEOnxt8+ESgH4agiWB/juolMQYoKu6dP3Y+liT1Vyw6SkycoNlLopDkf4ylsWcJOuuxE8R1px64GMfWBDB+AyRPCcYXZydFlJclT3sPxDdxcWuWV0dh9A4nt3diGeY7aCuQ5W0tUVqhz9zDfnzxustSiKd4UnmBUoHcmIvVa9FMUJWoxcdKPnlS1aCM30wrfSSCN0JMcv7klhCAMRFYXBCJtmsyaWNtaUsTCYBnzi/cof/pSyUccu4VwakmOzdA7U+hmYihvemooShj0xI+RF+hcUsVcVe/KoRaEOS/kOJNEyPNoKsS4biKirRVP0ryiWs2ougFeN9K3nZpwO0fNCtgaSfwyNClxjawLQGkJYBiP0VGI2zOgWk2ZnhVx4ho4dPWDvGzP59kXjdi2Hf6i3Mvv3P9issMh6WYtfqF2+vGMoP2eeBrQ9oC0eBahJSBfJN75zndSFAXf+I3fyI//+I8vLz/vvPP4L//lv3Ddddfx67/+6/z0T/80+/c/d2IE2zbbx4aynnTTEX0h4sbxxVwRPwRAairyPR6bBoT3T0QSpDSq28HHoSyymyQrr7SkZM1y9Hi625LtpMlbRRF6bWVJHrwtRcJjDGo4kGK4spaG7aqSxfHKALZ2hOgMe9JUXpSyCO918GkkC0wHurREOzX4gDrRT9jkrLwsLs20gNlcJFFa4dOYapBQrASPORGQO0FIT213fRALolRJ4lTZD8QIrqCOpVMj6IUE0xRVO4Lt2bIIUCUJPgrxRmP7Ccb25T6DAN/0juiJQtWrImN6Is/TekxuZfoSGHwiqUwKxOcQR0v51aOdJ+UgHNcEx7bldVBKCGgur7NKYnQngzTBG41vejWWxZJJIgZ/o9G1dIs8EbIoEcY11A7fzaREcTST915dS69LEEAvk/da7eT4rCSE+WYxryMjvqR9K/hQExzbxm3vLEsK5XWLUd0ONouwqcErJZ6PnZJgQ4ibz2IhFluFGNWjaJckn2SAV1GE2ztkdEmP8SHD5HzLRVce4bvP/iRXxg9iUdxT7uNPjl/F8Vv2s/oFjynaldUzhfZ74unBIrHuqb7PFi2eDjxSV9TiceG9533vex8Ab3nLWx7x+5e//OVcdtllVFXFH/7hH365D+8ZxenabJX3/OPDH3qGj+zMgPJgckd2TPHBey/l5vwcjtY9ChdQHSqYnN1E78bxMj1IWSd9Glrt7tYWJX48lfZnrUWGU9e40USa0hc6+KqSTpFaJio+ClG1Q+1McKPxMt7VZ7GY0oMAHwUyJalruS+kKNFHAcpa9NaE6IEtsiNzwqlD2cfXCS8nA7kTs7sxsqNe1bgsos7MMs720RbJysniHq3FYJ7Ey8UoYYAbdkTWFO/ej29SqYqhYXYgIt8XU611YN8arK1IB0lZYSYFZpTj4wB37n78oIsKDLrXhf17qYYx7omYub2Yp01uUXmJ66TYQYoPjXgXGvmQRBxzekLT+B90JYlobiyvFV7CBvRwgIpCvG3kWSCvt1ZCcJyX33mPmZbE2xVB/tiv02L6YQopTsRIBKremeJ3RjLVyFJ5X9a1EFTrRMa2mPA0QQc6CtH9Hr7fAY3cHzT+Dy/EutOBA3soD61RrIlXLt4oSO/bJnxgHXbGEjBQO4gjdK+H7nYxZ+0X70stpnidJuhuF7U6ZOfSPluXGsZXlbzomrv57rM/yYvTe7k4zFnVOR8bX8xnbj/E4C5IttrG82cS7fdEixYt2gnISfj93/99/vf//t+MRiP27dvHddddx5ve9CYGg8Ep17v//vt56CHZub7uuutOe1/XXXcdd9xxBx//+Md561vf+rQf+5mCts32cdCkYSWbjvHne9xywblctHIT1w/uRF/u+PD9X8Xwrj7BsSaRqpHQ+G7WFL01C07vQTtUmOAHXYklBZhKWzazuaQShaEsHnO3vJ2aF0I+rEVnmaRp2Sa6tmzK85QSU28QSGeHdSKXykuZquQ5xnnMIGoiZKWw8LRyokYWoJwY3X3QTAMWLdWBxkWPIUdqbq9rkbDJ4tfKtKaTQmCoByn5vpg61afcz8kSLt8kflWDEF1nmM0pfjSWBbX3YlhPIjG3WycL6n6X8uw+Zc88Ie+HPChCCBrjtZ5XqGkuxx0YXCcVc/mjPFdtwZRyvlFKXscgaEocjaRAzWpQTohiFgupnM4hS6CTyvHPc7RzRGVNMI4o9qSUPb300jz8mIPcEW2VmK2p9HI0BZa+LNG9nhDdxZSj6ZJxeS5kME1lN6sx/QOoyRwzmoop3mh0JxMCFgT4s/aQ78+om3jn5FhJ+IUNmZJYKwSmI8SN2kgYg9ciMazq3d6RKEKtDJg9by87F2rmB2sOnLXFa9Y+w/OTB+ipmpmHv549jz+783KGtwVkJ2rx1rTk4xlD+z3xNKGVYLV4FqElICfhAx/4wCk//4//8T/4mZ/5GX7nd36Hb/qmb1peftdddwEQxzFnn332ae/rwgsvPOW6zxW0bbaPD+UhmHuSdc1nRwcIVy2vzO5laGb8+dlXUqzFmM0A5RzUEsUrjeVJE82qUIU0c/tCTM54L4vTfk8mHXUtDepRJHKcMBI/SbMwpSEfatCTnfkm7hfnxX9Ck8bVJEfpeSWXNffhywo1zwknFS7WVJl+VEnR4jnr2qMrh5qXEsOaxI25/vH9Cdo2BYO5ReWVSMfiGNdPKYcxVS/Axo/T/t2QIByyYB9PsTtNu3ohXRLKOjFVA37QpVqRyF0bPUGjiwIXSA+KLhLMtvRmuMlUejH2rmH78bLn4hHnqPIiQxpVIuGC3fMEkoLVyJhUt4Mddqj6EcG4JNjcWSZOqarGz+ZCOGuL3qiJ/V5c2KEyp3p3FtOpaFQTHB/BzgTXdIwsZFV+Ppf3R1XJ8ZQVbjIV/4lS0lHSyWT6khfyvlwcs2uilQdd6a0JDfmBDmXf4BWEU0+wPcNtbAqxiGN8r0O9IsbzcCyP7a2DdbkOIKWHnYz8/DXWrwqZn2OJ1+ac19/iQLhNhOOYTfnk/EL+051fQ3prSveodL205OOZRfs90aJFi1aCBVx00UX8m3/zb7jlllsYjUaMx2P+/M//nJe+9KVsbW3xbd/2bdx0003L629tbQEwHA6X6TkPx8rKyinXPR2KomA0Gp3y59mO37rwVXilsM32bttme3qYwhFvee4+upePTC/lgTrDoemvTRkdCnAdkaX4spL43NFEGp8bY7GqrUTXjse4o8dxDx0Tf0CaSKpTFMlicDpbpi/5TirSrbxAdTqoFWmsVhOJsfUzkVuh9ZKIqHmB2hrBsXV5/AbikSgJju0QbxQEuX9crbCuPOGJGWxsiSxsOgPncFEjRzoNdk3djmBm0aVMgBaRq3Uvkk6O5PEnKKaUUr14q5DFvTHoVEjd4o8PA+pBQr3WodjfJd8bi8/lsXwpD4MLFHWqcWkgpvc4Qg/6qDQB69CVk/triiaXz7H0xFs16RfGRF/YRI2mMi3od2WqsIgNThL52XtUURGMS8w4x09nuJ0RbGw3KWh29/OpKNCjuSRL1Y9cfOvaoxvZmDJabmcMetBHJ/Gu98IYIbNxJMQtCKTh3TUTIydGeJWluD0DkbKlKQx7+G5KPUyZn9Wh6sprrmtPOKklitlaCQXodiAK0UVNcGIsUyolsjt0c1yxBCzYvUPGhyLmBxzBas75eza5qneEEItF8cn5hfz6566DTwwYHLYEs7Zw8ExA+z3x9GARw/tU/2nR4ulAOwEBfvqnf/oRl33DN3wDr3jFK7j++uv5xCc+wU/+5E/yl3/5lwDkTdxk1BSYnQ5xHAPSH/Jo+MVf/EV+7ud+7ks59DMObZvtE4OynnDqqTcSbp0c5NLkCHvNiOsOfp4Pnv9C9t2k8LNcygMb2QoghWw7E8gSVL/bFOwV0ocwn8t114a4lS4qDiX2tCwlIjXP8a5pFM8SifgdT3FjMfzSSGzIC9HrN+Vz+GYK473c/0p/eX0fBui8JphZ6lSjTkMCFp0gNtLYXkxQDKWHQ2vqte4yevXRoGsvqUhbc5GHbe3g5jk6jqS0zjxGlO2CfFSeaGyJj0zEuB8GQtQAVde4taF0ktQWVTvKlZiqax7fFP8wLHpAbKwo+yGqSmFFEp6inRI9KU97X9oi5Oj4FL0xkilHXUMYQS8T8mgdPgllQpUj/p/JlCAUP8iiTRylpaMjCJZGdKZT2Noh7KZU/Q42VEsF2IL8oBvZ2MYM7z16ZYjvZagTm/jJVORXZdnE8kbiGYpCIauB9G4QGJFqVZUUODbE1yfSUu9CKan0WmGK5nVdnwkpjiIhIFrD9hh9rJD29AUxSRNUryeTvNo2vSqaqqewayVnr474ur2f46XZPWzYLrfk5/Le+19I/akhK/c6orFrfR9nCNrviRYtWrQE5DEQRRE///M/z2te8xo+/OEPs7W1xcrKyrJgsGykAKdD0cgk0jR91Ov8y3/5L/nRH/3R5c+j0YhDhw49RUf/zKFts30cOI/SinDuSY8Y7treS7UWcLQeshpOqfaXlKsJyX3IrvKeFcqVFJPXmKNbMBtLktJqDwYd9MZIPAxV1aQVWYnXHU+Xch1vRSqjVgZi4m5kW74UaZXqZCLfqmrczkiu28lAg5vksthLIlwUiK5/Pl9OIZRShIGmTg1V51FSsZTE6BZ7YupOIEWGRiYFdaIfXTrVSLfCrTnqyDo+zxv9v/SioB+fGejaE0wd4XYh3gbrUOVcpgtV4yexlnpPFxcbXKipO0+efJxy2M3zdZEhGBfEpcXGBroRXp3q/xAC4GQSYBu/j9Zi/i4KMbN3myjbWSFkcHWIT0L08S180XwOLXws2ss0x1rUQurW7TbFlguz+u5jS+Gfk0jdqhY/z/49uG4qhM+6xn8iXxdLCVRHiJGa5bvHuuiYcSIDXBZoTnPoJHLf1hMWjmizJDy2I2EKs1njFamaRLcm0QvQWbbbg5IXUnLYpLXlexPGFzi+8crbuTBd5+r0fkJVc+P4Yv7igUspPjNk5bAjGrWm8zMN7ffE04DGM/iU32eLFk8DWgLyOHjZy14GgHOOw4cPc+211y7lVdvb25KPfxoZ1kJ6tbju6RDH8XJS0uK5B5M7sqOah04MOHrugJ7J6ZmclbUJOxeskny+Byc2UPMCk0WSCGR0MxExkghV1ctFOc6jbEM+GnLhy4pFP4i3tulmaJKjnBMNf6+L379K3YkJ1sewXuG1bkzwbqn7V86jp7n4Aea5kJ1mwmfygtSv4c/pUGX6EYZ0rwADVUdTp3p52VJ65U/1ZHu1K03Cg+3GhFkiUqKVofR+pPFSxnQ6LJKdopEleWiC3prIl6lSIhk6yUvg4pCqF1J1DYviwy+WfIBMNIKZI9zO0Rsj6efopBCFuI601i+P04o0TM+EQKrayiI7S0VmtzNCz3N5TasKkmT5+nsvkwuU2m1LbxbZypilF8MPurgsohzG2Maro5wYz+ONinB9gtoayf2treA6ybKpniyV95D38t7ReilZU7McP5liJ1OUVmgkXtc3sb2EIUrXIh20jiAO8DrCVA7lvUxcdmTis4jwVdAknZ302VhWjUfJLeOk60HC1vNC9l5xjDftuYG9Zk6I54jNeDAfMrt7wOrnJPGq7fto0aJFizMLLQF5HISLxRpQNztyl1xyCSBTjiNHjnDw4MFH3O7w4cOnXLeFoC2fauA8ykI8cuiHEm6bnsNrV27mYLbF+NyE3772qxl8fpX4waP4o8fRjQ7e1/VSEqXmshvumrZp3e1Ib4gWUzB7VlCb27LwWjSNz+YQNwlSZeMHUbqJt1WysE0WPgMjUp4oksdu4lj9wqRe17sN63mBiSPCYSIN5qf5ZFm0oS9IhyyAZfcdwIXSdr5Y/CsPQeEIJxYXatygg3Ye35UFsYuCxyYIC+nVVoE6ckJkW/0epIkUMuYFKo5wgy7lairSIKOW7etfDPnY9Zs4kVyNZjKZCgKZLgDEIdp62ZFvHsSFGjSNvKoQ6VTT/u13RuLtUFqa1NMUNZ3jJ5IwtdgA8dbukjitZaHeyfC9DNeJKVdiSfPSLFOvwpHFTEpY38ZubaG7HaCHHs/keJNYZHbTOX57JM+jeW19baEql23nnPzYWsl7ZT6Xc11VkOcE3mOm6W47vdbofg8dBEJovZMo4SZy2i9kX36XQJjhAHtghcm5KaPn1bxi7/2EypIpz9hpPj67mL+7/xCdBzTpRo2uWvLxTKH9vP/y4unwbLQekBZPF1oC8jj4zGc+s/z3OeecA8C5557LgQMHOHr0KDfccANveMMbHnG7G264AYCXvvSlX54DfRagLZ86FdIJ4kmPKv76Cxfxsv7dfEN2P2evfIxjV/f55K1Xc/bh/WIqXhjEncNbh25MuT6RPgwd9XD7V7FJgNmYyAIvjlBZJtr+MBB/Q1FKN0gzMQFw4zH6CATVqkS8GiNm9jBABQZvJ3J975ePj3eiy48i6YFoFqpmXmMKgzOPnILA7mRj0XURjWrCzRxd1tT9hHIYYRvTt3KeaFs8AgSy6+7TZle8qlGBfvz+EefRpRj2l1ICayWpaT4XYhaIL6GOtRT2nea4T36cR+0paa6ja08wsQRbTXP4YlqTRmA9qrKYucVEWro3yoaAxQE6jmQCYi2qlLQx772U9iUxaCMTML+YcmgpTMwLeU2MkUmI1jLl2bdGtaeLizTVSbIyXXnirUrIR6BRvQ56MU3aGsn99rvYQSoN69u1tJE3fgzCsOk00RCGkmaiG2ZpNPS7IiPLC5nQ2WbkM89FLtikeelGSkUYSKpbXkhstBVC5YtiSUhU0y9iD+5h64oe69d4Lr/8C1zVeZDKG+6rM/56cjnvueMlJDd16D9gxfDfko9nBO3nfYsWLR4LLQF5HPzKr/wKAJdddtly0qGU4nWvex3/8T/+R37jN37jEQTkxhtv5I477iAMQ/7BP/gHX/ZjPlNxuvIp6+Xy56QW2Hl07ekecWzcPuBP9j+f58cPcraxfHX/Hj54xZV0ju2nd1eGObohu8i+ickNgmWvhYoi3L4Vij0pwayWnevJVKQwnRSfSvQpViRUCxkL3kvC1XgsC72Hju+2SysFQ2kF93UtnosmkldZKzvvnQ4Must+C9tN8aFetvEuFvOPBtXE4qrKomY5OgowRSCkofKYvCbYmML2CIZ97EoGcYCZFKiZBEGoJ7C49IGWNu2J9FqoRUyxlZJH6mZx/LDukAWhWBQgKi/JVUu/ymm6NHTticaO+MQMTmyKFClNUIvXqqqhqgmrGpOLP0xPC5noZJGQlI0tCQZYnKcgEEN4IuTEpzHeiNyJvABjMAuPxCIswBhJourGVP1AUrmaydJiMhRszdGbY3y/g8sSCTYoK9gaiceoJ143Pc7xk4kQA9VMVpJESOeij6OTsWhrX5Bf30lFZuU9OktlwhGF2D19VGXRO1OR+VmHmksqmpvNllIsvNsljUqh0wR7cA/bl3VZv8bz9S+/hTeufZzzghEVij+eXMl77ngJ4U09+vdZgqltd2+fQbSf988A2h6QFs8iPOcJyF/8xV/woQ99iLe+9a1ccMEFy8t3dnb46Z/+aX73d38XgLe//e2n3O7Hf/zH+Y3f+A3+/M//nHe+85382I/9GEop7rvvPr7/++XD9Qd+4Ac4cODAl+/JnOFoy6ceCeU80ciSPRjyyQfO5WMrF/LK7C7WggkXXnKUI0fPId5MSHcSWawZhUoSIQB5KRr6WNLYou0Csyk+B9XrComAZaGdVyKxcmmCTUMxdgcGouhU4mEtfp6jm0UlzuHqWvwlUSQL0FSkWt4Y0PUykShfi5bxqvYks/PJWCRFuUBRdQO87qDLFB+IBEtZTzgqMOsj/PYOvqrRQYBf61CuxSTOY2aB+CnMY3eIOKOwaYjpdSV5ayFhqqrlVEkVJcHUYmNNHe/Kv5YL9WljEHceGxtcJIt5F6pdkuVBW5l8xMenIvkaT0RqV9dS3uj97nneNujjzcevVqheVwjFwiTf+HYWkivqGnZKOf6diUymwgC6GT4d4pIQVTnM5gisww17VGspZT9syMfuOdF14zmZ5BJxW5ToOBK5V54vgwnMOpK8NZ/j5k2CmhZzuNJKemm6KS5rwglmJXo8l+lUXuCjEN/v4rOYciXBTCuJUfZezPS13S1SnEuSm7dWyO6iQ8RaOWdKo9KU2TkZ6y+El73kDt6696+5NHTMvOKPpxfwn26/nvCmHoPDlnDSxO22049nDO3n/ZcfrQSrxbMJz3kCMp1Oecc73sE73vEODh48yNlnn01VVdx+++2UZYlSire//e288Y1vPOV2F1xwAe9+97v5vu/7Pn7iJ36Cd73rXezbt4/bbruNqqq49tpreec73/kMPaszE2351GnQeEHSTcf0ng5/dOAFXHTOMa6IjvEj536Y/+fSb6e6NSYtK/xMejh8E3Pqp1riT7VCTaboRT+EdbJwbGQ/Kq/Q6zuNDMlhOpkYostKFnrGiLQmCkWy5Zw0YE9ny4WgakzIEsHa7LZPpjCfCwmpa0xt6VaWehBT9kJZoD/WUzfI4rghHQvDufFODPe1Fc9BHINzBFszdGnR8wofhTIxeIz4XpQkbdlY4/oZ2nv8rEnRCgKIY6hKWN8irmqUX2O2P8Y1d7mIxk2/MEZt7oDWhAv5k9b4ND7lGFRl0eMcNZrgy6rpGNG7RYKjsZSkx7Hs7lsrlweBSLXmORQy0dAH9slB5IUQzKqGPBcZFDQFk5JM5QYZthNi5jV27wCbhsuphw13zfQLU384ccRHRiKH6mTyOM1ru2gZp6qgKmXS0bScu53R7nthnst7t5Oi4sYnpxQ+DptEthpVW1wvxUUGXVhcHOBDg5mWIvXLC+GnUShN6XGMjyL0cCDkxnuZjIzHEMdMv+oQD3wjfOtLb+Ifr97I5aF4+T+W7+U/ff569N815GNsxdPU4hlF+3nfokWLx8JznoBce+21/Kt/9a/46Ec/yt13381tt92G956DBw9y/fXX8yM/8iOP6uN405vexMUXX8wv/uIvcuONN3L77bdz4YUX8sY3vpGf/MmfXMb1thD81oWv4trNe7C+Gce35VOALAzDqaP7gOH2Bw9wz779PD8acX36EF9z4T184tLn0/1cT9q6tcKPJ9L70XgDdLcj5KKuUZ3OblO2UuInKCv8tDEsR6EQh0lTctccg+51sYf2YZOAcH0CozFuPNndie9kuxGrzeLRNwlYKk1F0jSdocqKsFzBBT3q7PS9IHDyFERkTcoJwdEWdC3dHj5LdsmOVqiiwozFh+CHPepuiIvUo5YYyu3ApoZqNcNkEcFDW7j1TZFFpSkecKMRqq4JBh2CfkiViQfFlFJ+KAlMFrAo52SBbi2EEcbo3SQ8pfC1xXuHylI5v43nRnpT1NIEL+cwX3o0wmMj/EPH8WUpRnCtG69KLq9rvyfnYmNLJlCDnpRIWicSNuepuiE2MdhEjPyL87I8/176PqJRJYlXdS1hA3Xd+C7sckKjokjOz0qfajWTadnJhveylClZUaC1BjJUUUkwAohcr6xQc4N2MmWyaxJzrCpJY8M78Q+NpssSTTXoUQ8zbCavezApUStdJhcNePDV8D0vv5E3DD/Jqq4pvObvyh7vuu/r2f74flYOOyEfLfc4I9B+3j8DaGN4WzyL8JwnIIcOHeIXfuEXvujbv/zlL+f973//U3hEX7loy6ceBc6jS0eyqRnfn/LBcy/nBfED9HTJK4Z3ctNLDrF1/5Dh7QZlrejp1zdxk8luc3ReyERDqWVBnE8i1Hgmi9imgFB1O/i4MY6XlTSll6UQi9qhKyvlhdbKIhN2jc2JeAtIjchkYDeVyzlZiFcllBW6Xuj3H31CsVwYL5KxvCyadaCkPM9oIUhGy5QlL2AywVc1qt/FRvox43IXqVs2VuhSE0z90jOD0vhuigoDdF1LWtS8JDk2R+2RvopopyLYkXJH1esIiWgkaVS1dFdYK+dgkVCVxBJrHEeovBAzd+1EgmUtBI08aZFAtjBnO4k7Blg0shM006mywmUJPg3Rs7l4frrS0UJl8VpjQ005DJYTj1POL0JytYVopyY4toNrWuhZmNyjUKYsWmNWV3ajdr3HFELC5LVSEMfoTiYm93kOszmqIYi+IbYqiUXiVhToRkJmAJ3Fy8kWgx42i9GTeRPnLE3qZpyjZxU+NNhuxM5VPU68vObNL72BfzT8BJmCCrivNvz7B1/FA584yJ47HPGObWVXZxDaz/sWLVo8Fp7zBKTFlxdt+dTpsZiC9O4z3HT2edy8ei5XJA9ydrDF1x26iz/+qhcR5F2698/wtZNdcit6eurGmxFKP4gPDD6JJdY1MEtZzXKaEAb4JADrMU37uZ9M0Z//AqrXaw5IFuoqinZ3vadTlFL4QRffTVC9DFWJ6V0VpUxhtExMnNFLD8rjYWn6RoiIixQuDjDbTszmgZFEr7zETufimaAxhD+Bh3BGoWuPOb4t56rfFf+BbXbgF4bpWU4wnaOLgSRSzSqZOoUBPjDgGiO5bohRI1taeCPEpN2QB9OMH4JAIo+Ngdlcmr2NGLcB2NwmKiuRYHU7u4TES3SyiqS4UFkLi7Rb5+RnJ+fadkLqrjktGVvIrpT1hDNHOCrFb1GWjRQtRHdS8QzVVkhQmkBRigSvKNEPFrh5LkSzkUjZPX1pM9+ewSxHTYTo+qqWiUohng4AbWUipOZCuHwSCUEOA0k303oZC83xDZnMBAHqnANsPb/P+itLfvCaj/DGwd/S04qZ99xbd/nt9Zdxy00XsfcznminLRo8E9F+3n950XpAWjyb0BKQFi3OBDiPrhzZccX0vpiPP+9CrknvJdKWA9GI/qWb7Bxbo3s/4kcIAnS/hxtPZKd5z4os+HfGqDSRnojZHN8sBH1ZomohCqoxmLtuguukaO9hZyzHYTS+iTvFmGXsrZoXQm6yBK8U3hhsN8ZFBlU7gsmi86LGdhJsoqVo8El0aZxsTrepIQQxSTc+CV80UbNBjE9C/BMsC/S6KRZs2tN9FKKmc9jcloU1SFpTU3anioIgTcWHEAaovNztrYhCfK+DaiYcPs+Xx6e0LKb99liIWCryJj9rSJPRQqSSRF6r+VzOcRjAwvOQl3L9jS0hjiA+jclcihOLQi7LS7ldGOBD8Xo8vE1eucZEP3cEU0u4naPKGp/G6DjGOY9OE9TKEDvsoosKTmzh1zeXDfM+z0+azDSeo8A0RMtgVzvoKETvTKRsME3EBD+Z4utq2V2jwkCOd1FwOZujNrfEq2SbiUjzfFQU4s4/i2Nf3Wf6NRP+6VUf4Tv6nyZTiturDrfmh/g/D13N4ZsOsXY7JFs12rbko0WLFi2eTWgJSIsWZwiUl/bs3n2aD996GZdkx/muwd/yiu5nOX6wxx9e2mfnSIfVE7HIkcKTiIJSIqkqK4gk0QhrUd0uWmlsJaWBqqpQyVAWoeN503YuJYQ+L4TA9Lv4lT4+kIJCNS+kUTvqSKTtzlQkXWt9bBKgTCNLmuf4qkK5njCJxvj8ZAv9vJJSQkIxiqsoXBIpjEH3ulSdCBs/tv9jcV/KS9Gf62eoqUxU3LCHnoVQ181iuZbFuNHifZlMpetCKVzTwK26HVS/t7uQNgbV7UrRXxKhyxq1sS2maZBJgPNNn0WNUgo9lBZzP53L72nIBEgELsDaUCRPYznPvteRgsiRlwZ6kNd/NEYlCXqYnjJt2i1D9EQ7NfH6HL09kcdsom29b8hHk3Rmjm/teoucl5ACY2Sq0Mnkb2vl9SgqzPFtDODjSMhgL5OoYeua9nUN+qTp2WQq4QjeCZk0BpxvpGAWtEEnMbrfo7z4LO7/ppQXv+p23rTvBq6IthjqgAdqx/u3X8gffu75mNu7rN3j2pbzFi1ORhvD2+JZhJaAtDgj0DbmIgs/IFu3VLeH/N7ea7jw8uO8OHmAV/Vvx1zj+AP7IjpH9hDf8aAs+pNmQlHbplPBSmN5KNIfTFPiZgwg0bnYxsOQJbKwnsyFrIQSbUttUVsj8X2AGM5nM+l7SCKRd1mLDzQ+UKjcoeblrq9hmmPmGSrT0lXyBPGIUb/3MkHQChWGIjtTCr/Sp84C3GMlYD3sPl2kKNdS1EqCCzWmsIRNvKt3HsUihrhhNFqL3KzebZpX4wm6rGTq0LxeaIWqa/Sgh09CkYZZJwtwpSAKxJLhxX9CGO42he9dk39PZo00KcbHAbYbE+w0z80YVF7AzImZHVBZKjKm2uKyuIkyPrXkMSiEfART6Y7xkcjzVNGkqVkrHg6tJFFtNsflhZCI5jVXnUykWU1vzGIixGSGH01k6qNUM4UxkMSo0URM892OeIea96fb3MbP5+gsk36auhbviTFi2jcG3e+RX3EOR7425upX3sm/OvuPuTiMgZRjds4Hp1fyh3e+gPhTHfr3iuG8nXycGWg/v1u0aPFk0RKQFs842sbcU2FyT/dBx+bNK7xn8DKuuOAhromPc9HaBp+/Yo3PX3UJe8sDBMdHor23DtVJZXFoDG42k06JMBTyUFZijk4S8A6f56goxA4kglVDs2PdJC/NcnAWlSZiZPde4mGDYLdMz7lGelURnBjD+hZ+Ppdj2dgm6iTUWY/KKDGZPw5XWLaj1x5TSTQx3ovsqq5Rgz6sDCAMqNY61F3zCMnRY8EFiqpn0KWUP6raL70Qyhi8tbh5LlOKOIb9e4QUnNhAJ/Guf6ZqYogXxvwwkKmE91SrKaFawwSBSJdAFuBR1HhjmjLHxXSqtrhOhF/rYzsxNg2wsZA6mwQSOVxagp0xbjSWc2/E41Oc3SdfDdBWJGYnT4J07TG5kyAAwIcGrxP0rIB6LqV+/Z4kdM3neJ8vCejC8+PLUsheN1ua710/pe5GRFUtsirv8BMnPplhD9dPMYVE+KpeVx7b6N33SxAIeeo27zutcVWFSrqoQ2dx/KvXWP+aildd8Wn+8d4bOS8I0ChGLud94yv5/336lcR/22Fwb9Pz0Xo+zgi0n99nDloPSItnEx5HwNCixdOP0zXmKu/5x4c/9Awf2TMA51FOiuL6hz2f/dxBPji5gplXJMpyzfABtp9fMbpQCIcbjXHbO/jxpGnF1uheF9IEb534QPJCFpENVJri+hk2Cah6EXaQirdh0SHiLKrbkQ6HOJSpSBTiOykuCvDjKX57B72+Q/jABv7oCez2Nq6REPmiQO9MicYVppB+j8UX42N9QWoLwdwTb1XE63OwDr26gh4OcKs96n19ygM9irWIOtZLidcT+dJV1mPmjmirJD46ITyyhd/cFsmaF2mQL0vZle91ccOOTBmQ3g41HMDeNfSeVSkyTBN8N8OnsSysy4pgXErErNEyWZnny94RX1YiuZrn4icxBj+eoGc5dT+hXI0oVgPKgaHsauZ7Q+b7Y8rVBHdgDb13TaYKnUyM55Gm6GvKrsZGJ7EwD+FMnmewU2DGBXo0x+xMpWF9a1sI02I6EQqx0r0eZnVFpkxRuCs3S+T3apajx/mySBBrcdM5bmcsz88YbBJIwprSkBfiZdke4UcTmYY0JZYEBtdL8Ct99Fn7sVddyBe+eQ/mO07wrut/h7ed9adcEY0pfM099Zxf376ad93ydWQf7TC8p+n5aMnHGYP28/sMwuL/xVP950ni85//PO9+97v5wR/8Qa6++mqCZlr6WImjP/uzPyvR8Y/x54477njU23/2s5/le77nezjrrLNIkoSLLrqIH/uxH2N7e/sxj/XBBx/krW99K4cOHSKOY84991x+6Id+iAcffPBJP+8WTw7tBKTFM462MfdhaKRY8Y6le0/Ifz/rxZx96RZXxw/youzzfPrKg3zm3ktZuS1cav/9VGQ1KkkgjsRoXdtlVKyyWgzcYYiPQ4k7nZSoNJAeibISCRfAygDby1DOocczWTQbszQmq8DgZjWMxrveEe+FECykR96jC0uyWVKnAXWmcYalJEstzOMndVSohnypyqHKGtdPsfv7eKOoU4OLFc7sdlwoJ3+gkR8pHtl9gZATU3jizQI9K1GTGW59E18UMsXQgRi8QTpVuk2nxVSmBSqJJVksjvBxhN7Yhso3k6Gm52Nco05sSEmkUk2McQV+Ki9pI2/S3qE6nSb1qZKujKY0z598/AasUbjAYJMu4VqKmdUylQklAjke+2XD+TJJzIGZO4ITIxhPRYYXBkJ6vBcSoJWQA6Pl9YoiWBvishiVV/Je0BrXS/GhQU9m2PVNdL9LgAQSOGvxdSXEIk1xSYDJJRHNO4uflzIxKyuZpjR+Gl/XkqwF1MOUyQtWWb9a8byXfZ5/es6HuCLaYFUHWDx3VgH/fePlvP/mqxneHNH7Qo2Zu7Zk8AxD+/nd4uF417vexbve9a4v6raHDh3i3HPPPe3vsiw77eV/9Vd/xd/7e3+P+XzO3r17ufLKK7njjjv4lV/5Fd73vvdx4403sn//Iwswb7/9dq6//no2NzcZDAZcddVV3HPPPfz6r/86733ve/nIRz7CZZdd9kU9jxaPj5aAtHjG0TbmngbOYwpP9wHH+mdX+dSh83h5+gDXxJuM9t3EzS84h80vDFibHUBP5yKfCsyu5EVrfGJEVlMH6LVV3Fof5iVqPIWNbahr2ZnKGvmWUvg0pl7r4hKDzi3haCbkJgxQ8wJtxUSse13ZPTdaFsW1TBJ8XUsalJHCuej4iDAMqPd08YHCGY2LdGMgV3jTJFTRmM8jRbEa4/fGQjQan8dpE55KSXhStcMbhYu0NKs//FOtITc0Dd0U5W53RyeTqNv5XBbMayvYQYqZFEKsGlmbmhfin2hav/1sLlMnpLQPaFriI/yiVVwrObfeo8oS7/yyWd7PG0O4UujKSqW32j0PSxioUpl4qJUA/EJy9ciiwcUUyOvmvhrZnOukoEGPRf7lAyPSvaIUU3+ng+umUv7XEc9GsDOXxKxAHsRbi88L9HS+2ytz0nMxm6GQy6IEbaQLJY1RoylufQNVVXhjUI3MzQ4yti/JpN/jq2/gjcNPkijP1Gmsr3nAdvnPx76Wj3zyclZv03SO1Zi8JR9nItrP7zMIZ4gJfc+ePbz2ta/lJS95CS9+8Yv5z//5P/Pe9773Cd32+7//+/nZn/3ZJ/xY4/GY7/qu72I+n/PP/tk/45d/+ZcJw5CNjQ2+9Vu/lRtuuIG3vOUt/NEf/dEpt7PW8p3f+Z1sbm7y+te/nve85z1kWcZ0OuVNb3oTf/AHf8B3fdd38alPfaopW23xVKMlIC2ecbSNuaeHcp54ZOneH/J/7n4+F8QnuD67mzUz4Tsu+xS/O38JLtjH4N4CM63QRY2aFfgwkJ3oqfhDzMoQt2dA3U9kB7uSRCamMvHwhZQYql4HvCfYnGJXMklgCsS34BdG7FD8D35tiO3FMlHYGctiXksJomqavs3RLekOSRLCohSJGOD7XewwQ3mwWUAxDLFxs9DVChdLCtajTTPwoK0nmFnijRy9PQWtheTsjWUKcTJhWSRyVRY1miwb3lUay/OJQuh1qNe6lKsRLlCE44gY4Ng6bmckd7MgCMaITKlWjcdGpic4v/tva5dkA90UCjp5TXAeFUfQLNJ9oB/VJ7OYEjm1eCKPPCenvGc8Eg6QxWL2Hk9QTQywFDj2oJPilSRWqcBgz1qlXE2E5HhPOKmhqlGzHJOX+Fr8Ib4osCfWG/KhUVGCKwrczkhKF5NY0rySREzvVS1+I2PkPVGJ8ZyVPhsv6LN+fcUbX/gJ3jT8BOcGGVtuzlEf8tez8/n1u7+G+U1r7DvsJGa3aiVXZyraz+8WD8fb3va2U37+vd/7vaftsX7t136NEydOcPnll/Orv/qrmOZzd21tjd/5nd/hoosu4gMf+AB/93d/xzXXXLO83R/8wR9w++23s7a2xn/9r/91OV3pdDr85m/+Jn/913/Npz/9af7wD/+Q173udU/b8T+X0dK6Fs84Fo25N61dzIm4z01rF/P/fdFb28Zc59GVp3PUYm7q8a7PvIo/Gr+Ans55/fAmfuQlf8X4mydsXRKjnEdvjkUe08uo9/Vh2Bez8UofHwUE40LSqqIQv9JHra00MaxaolCdk76P4xuYzx8leHBDpiIH96F7XfE0WCcmYu8xO3PUrOnm0NKzsZgGLCNmOx18ryN9IsZI+d/OmOD+45gHjhMenxCNaolSVSKvcsFuweDDF9onS4107cH6JhJXo2qHLv1SlnXybWRioCW5KU3Qe/fgLj2P8uKzqM9aodrfp9gTU/YMVaYpVgLqlQyVJGJMXx2i1lZkujEXf8qSYIAsssMAnWXofh/d7ci5GPZh2BNzd+O7UJ0M4kh6M0ZT9KyUXcbHMNQvOlUerVtlUThoCke0mcvrsmdFJhGl9Jj4upaI3HkBowl+OsXXUp7oQoVN5G+vRM/miwI/maHiCN3vi6+lKGTaZYxE8i7OgW8IQvM4OAfjKX4ugQcqTeV5X3gOR1+5h9E3TXnLiz7Ctw2lXHDLzfnQ/Gze/vlv45c++s1UH1lj7XZLum5b8nGGo/38PnOgeKTf7kv+80w/qcfBH/zBHwDw5je/eUk+Fjj33HP5+q//egB+//d//7S3e8Mb3kBvUcDboNfr8Z3f+Z0A/K//9b+eluNu0U5AWpwhaBtzHx3h1DG8B7ZVj98OX8TFVxzj5ckRvqN3C1wB/2HrVaQbHQbHmqjTSYwjXRbcuUR6QdRkjprMRJ4TR7sL924mO9azXBKn4kZGNJ5AWaE7qfgclJTpeaS7QuQ2Gno9dBiJNEcrWfQaveyxoJOK0X2YYWalTGm8b0oBA1QtRMsZ8Ead4g151B4RD7qw6Gm+LMWTGzzsak25oTfgw8afYp0QJO+l56R2+DRoFt9yHy5Q1J2AoJvBbC69HGki5Y+jpuejmWyoNBEvSVHKZCNLwSawMxLZVhJJ8SMSAOCzRDpbmmQoH4fLx35CaWHN83/45Yvej2B9jN/aQXU7Mt2yVs63a3o4qho/meLyAtPpNI+rUBbCsSXcnEn7/L41aYxXCjopJolxG5sySVkY4gG9uiLyvsrCiS15DxUVHtCDPr6b4dKIcm+Hoy+JOfDqL/ATh/6GA8EOh8t9fHzWZ73u8kf3X8nsb/ew9oAn3bIEUyvPtyUfZzzaz+8WTxX+6q/+is985jNsbGywurrKS17yEt70pjdx4MCBR1y3rmv+9m//FoDrrrvutPd33XXX8ad/+qd8/OMfP+Xyj33sY497u1/7tV97xO1aPHVoCUiLFmcynEcB4cQxOKzYjFf49d7Xsnb+H3N1NOEbOrfz4ItW+MD2i0nX9xJ++l44to6Z95aRr8o5XBziu+L1UNtj/Oa27GB3M+l3qEXjr5IYt9KVHfSiwG3vwEgkSDqOZYJQ1WIuXngesgS6KTovpZuil6KKGj+e4MsS7R0mDKgHiZQbNnpaHwcS5bszB0D1mhhaDYuGc68VmIctzFVDKAItU5uiAheh4lAIzGnmui5Q2E6ISWOYzcTP8MBxiSCOIly0Bj485TZegQ8DdBKfJKfSy5haZZtEKO93U6UWC/3FfUymwonSBK0UJLGQPaMhDLDdlGItEQnaY5CPXekZje9FFuW6cktSoktHMC7E49K0xksRopOflcYsyBdIvHAcCXnJLSaHcDNHn9jGD3vYQSoSu1y6RFhI7LIUeh0JOrBWiC6IpCsK8bmV4kGAlQH1vj7TgwnrL1Bc8jWf5xfO+99cEDrurAIeqFb5m41LuO2+s0nvSFi5xxGNmn6P5v3fokWLJ4jF59FTfZ9fRvzf//t/T/n5ve99Lz/7sz/Lf/gP/4E3v/nNp/zu3nvvpWr6kS688MLT3t/i8rvuumt5WVmW3H///U/odovHCMPwtNdr8cWjJSAtnhV4ThddLUjI2DK4Bw53DvFbnZezeuCD7DcV3zK4hU9efS7Hjxzg4Im9sgsNSw2+VgrI8IHG9RKM8zCdycRi0BWSsjMW6YxJxSsxL/DOowc90fRX1W7pnFYo72X3PkvwsTSD+zhcfgGqvFju8FNWqO0xQSPx8tM5KjDQzWSSkhdE44ygn+GjoJmCKNCSflUOAomaPWlCIL0eAXpvn2B9LNG0sTlFvnXKKTSKOjMEnQQzTcREvjPClRVmdSgStsqjAyE9pvQEeZMO1kwpACjFwO6rGk8lyWDTmRjY+93l8/F2Ec8l8b7KiZndG/FZoDWuH1GuJFTdJiHsMXwdykKQO+LtimBj3hyXwWuNcjLVUPVuRK6KQiGYSqGNEbIYNEWT3osnoyl6NOsj4nkKRqHmzVRLKXkfFLVItpqJEUaLb6aqoaiaaUcJOxOoSlgZQpbAaILqZEyu2MfGVQHT55Vcf/nn+N59N3BeYAGF85qjxYDPPniAzm0Jg8Ntv8eZiuf0528LAEbNRtQCcRwTx/FTdv9nnXUWP/VTP8XrXvc6LrzwQtI05VOf+hS/8Au/wJ/8yZ/w/d///aytrfH3//7fX95ma2tr+e+VlZXT3u/i8pOvu7Ozg2s2ih7vds45RqMRa2trX9oTbPEItASkxRmPtuiKZTRvsmUZ3BXwobXLWI2m/L3BLeQ+5JvPvp33fHWP9e01Vj4bYyaFLBznHr89Qo0nog/u92SqkCaSSDSdy2IvDEXPbx1qPMNPp7K4XhlQr3Qw06bLwntZZDeJWa4b441GzyS+1WcxqnYiWdJadsz7XWlPbzwCaIXvdbCrHcy4gNkMd+wEaiOQhbPSy136YG2IOneVYjVY9l14BWioUw1rMT7S4KDqiYzqZKKygNdibCdYONudlCY2scA6r4nGFbqW+wjHtSz059ICz8Qv+z1Up4NydtdUXVXNOQxkKjDLYTwRElJVIvmKIzkXRQVNmpZdzYRcNccMp+8z0TWEE0tybIa+/zh+PBYZXK+H2rcqZKGsZILVGOUJAigKfBDIlCNL8f2mSb6qZRK2M8FtbMJoLMfWyUR6FYVSXmgkWQ3vZXITBrC5LV0iDcFSRqNXhqhOip+CHXapVhJghe1LIravz3nT8z/C1/Vu55CZECrYdLDtIv7Pzgv535+9mu7fpvTut4TTlnyciWg/f589eDqLCA8dOnTK5T/zMz/zpNKqHg8/9EM/9IjLXv7yl/OBD3yA17/+9bzvfe/jX/yLf8FrX/va5edc3hS+AkQL/+HDsCBJ8/l8edmTud3Db9viqUNLQFqc8Thd0ZX1cvlzSnfsPLqC7ISlviXi99W1FC8IeO3wZl7WuYudS1P+oP4q6qzL2q2G8FgtfRNFKeZjpWA2byRElZTueS9yquYD1p+1D9uLCY8GQlzmBSYMUHkpxEUpiW9t+hxMWeEGHVRZCeFxDjWdi0/CNbv/zTRDTaRXg14H10mk7TuvxaNR1XhrMU1Ttpo3De5VTbiVY5MMZ8xSjuUVuACqjsaFEcr5R5VfLXwgdayZ70+Jw70EJxI0G7IY9x710DrRKMOsdnGRITy6g98ZiTciDMUzY534KYY9WfSPZzCfLyNv1XiGPbACaYjxXqYsdS0+iP2rOGPQ4xmqttjVLuUwXE52QORVupYWeNUswhfG8vj4DH10AzedCnEyTa/LvMDHoRAfraU8saphW3YrfVHiZ3NJxFrryySnDnFZSFBb2JbpiJ/NRI6WxDK5yhJUKD0nhIFE95aVvG9sU9xoLd5qVCV9IHiHco5iNWDreYbopZv8k4s+wdd3b+fCACyGW8qUj0wu5abtc/nUHeczvCWke8QSzFq/x5mK9vP3WYSnMYb3gQceoN/vLy9+KqcfjwWlFO94xzt43/vexz333MOnP/1prr76agCSJFleryzLU35eoCgkfTFN0+VlD7/d6bC43cNv2+KpQ0tAWpzxaIuuToKTRu/ugxYXRvxZ53KufsEDvCq7mzev3siVL36Q/7z3azjaPcA5f5bD5rYs/o10c/hBTyJi80J2xXsdlHVioI5CvAZdNovyOMInES6L8N0YVTl0XsoidVKDs/g4wnZijJN4X6IQpnNJe0pTiQJuuh8wWqRCzoNRUlw3zcFadJpAHEMSQxTiOgmqkjI/Pc0JRyEuUtTJbmStV4ABG++OPE7uxDhtWpT1+FBT7+0ReI/a2pEF+4IAzXO0c7jJtJngNB0fXZGwqcpSrXXEu1LVEk+7kGcVFebEjnRtzHK8lZhjFQTSKF87iUcOA6phLBOck1K9orGVBvPtuUyZFigrOY/eCZmprSz2k0TkVpN6t209CoUkzebiRTFmaT73oSHfm6BrT7QxB+/RvS5ue0da7K3F11aic4979KArciznRfJlHSpLMf0e1DVuPJHHBHlth31mh3psXGXIrl3n/3PJh3lFephEwTELn8wP8X9Hl/Kxh85jfMcqq3dD96EaXbb9Hmcy2s/fFgD9fv8UAvLlxPOe9zxWV1fZ3Nzk7rvvXhKQk+VTW1tbnHXWWY+47UJ6dfJ1B4MBWmucc6dIs053O631M/a8v9LREpAWZzzaoqtTobwkY/XuB2+6vFN9A/lVId/e/Sxfnx1m78UjfnTnDYzuHTCYl0sToZrMpIujkQT5flemFNOZTDSyBFVLsd8iKUvVVno2wkDkQ7P5btGec+jxlMBLhC5KoaZz6QyxFhKPGvSkRVwp8SgEYubWOzMhLN7DQD7c/WL3PS9xaQdVWfEWAGEYYBPxeJwsWYJmwtF0g1CzOwk5zTREeXBGQ6AJFrHBabqM1vXlDFcUu/GyxuD7XXzjj1BFSRAaeb6BkZ4UrcWzEoMaiflaZQnaO5mC5LkQk0a25LupFCYuEiN9M/moPWYiMciuKIU4NCSmOQlQN/6O5nzL7f2ycVwnsTSbL0oXaTZFrUNPChKtUUWFHs2EXDQEC++aiZgYyVU3w8fNNMW5xtheiiyvm0GYoYNA0tEGPWYXrLD1vIidK2suv/Revu3AzVyfHiZUcGN+Nv/rxIv4xD3nY47ExFuK1SOedLPt93g2oP38ffZALabaT/F9nglYmMDrRp4LcP755xOGIVVVcfjw4dMSkMOHDwNwySWXLC+Loohzzz2Xe++9l8OHD/Oyl73sUW+3eIwWTz1aAtLijEdbdPUwNKb0aGQZ3gWjosevhdfjnqe5MD7GATPi2573aX7/5V9NkO8hPTJFTwqR2kxnUsKXpajaCvmY56L/NwZq6QOhrJoI10Z2ZC2urmXHPQhk4W6M3J8xuD0DXKAx6yN5nPkcVZbotVXZlV8YpstKZD15jisr2dEfyALfhwY9zvHjKcY5yAtsY3w0gSFKQ1ysRYq1GHr43Ub0cFqj5zUuMlS9kDrTYko/iYh4I/KmYFxIG3hthctYK6btIEUbs3zOSmtsPz21xHA0kSSoOBJp0ngGVSWm/LKSqcnC/9LJGolWiXcOBj2qlWTpVYEmQrfwhONKTODGoAd9kbvNdyOAldbLSYgKgmWbuzwxhwoDIRRKSVpZGMrf1gpR2NhCHzsh5YlRhGqIn4oitDHo1aHI6WqHi4Llc/aVTEdcM8nSWYYPA5F7DbqMLhty7MWafV91lG/Y93mu7dzLNckXiBXcVBzgP9z/Sh646SCrd0G66TCFTDxaydWzA+3nb4tnGuvr6xw/fhyAc845Z3l5EARcc801fPzjH+eGG244baTuDTfcAMBLX/rSUy5/6Utfyr333ssNN9zA93zP9zzh27V46tAWEbY449EWXZ0GTjosgpmle8RS3TrgNw+/lE9ML8LgeePw47z0JXdy/NqAci2VVKp5LuQhS2VxO50JochSSJNlgzrjKT7PxT+w0McuonOtFQ9AmjSFejG+k1INE8phjBt20XtW0SsrEIa4rW2RgZWVpGVBk9IUyULdWiE9WooEVVVD3UT4FqUcbyAJUigFJ5ksF90XyUZF+oUx0QNbBPcfJ7pvnfTIhPR4SXa8JD1REe9YopEl2q6Ijo0xRzbEaF+VssBeLNibskJMM9lwDlXWqFxih7EWNx7L85rNG/N3Ln6R8UQmBGEgC/Qswa72ccOuSMv6Xeo9Xcp+gAt2RzjKekzhCLZmsLUjcrUoxKcNgUkTib3tNiTRe3xV4SdTMaQvDJXGSALXeAJFIQQxlddHBYEUSebN5XUtt51LS7rqdnArPaq1DJdF8pynMr1xk+mSfCyLGKuael+f4y9f5cFvcnztK2/lRy74ay5LH8Ki2XYRH8/P5te/8LXc96mDDD8L3aM14dQ2Ppd28vFsQfv5+yyCe5r+PMP41V/9Vbz3DAYDXvziF5/yu2//9m8H4Dd/8zexJ0+Mgfvvv58PfvCDALz+9a8/7e3+5//8n4zH41N+Nx6PlwWE3/Ed3/HUPZEWp6CdgLR4VqAtujo9FnKs/mHN+nCFrbMyYmU5FGjeeuCv+bnr+hwrD3L2fA9hXkgvRL+LT0KR4VgnE4/ZXIhI4wVQ/Z6YwxdlhN0O6B6+KIQQBIFIcqoSVVYyUbBSduizBD/oiOn8+IZ0YXiPzqWHxPe7ItfKpbNC5YUs3Jt+EZWlItVyHuUzfBpTr3UphzE21ijnUVahnCecWKIjO7A1Eh8CNEb4nDCvJOUL8D0pzVPjGX4+F8nUgnQs+juqeknKpOW78T/MSzHhey8FfMaIuT+NhTh5LybvTopd7VB1Q/GLOI8uHeF2jo9C6rUOxVpMnejlVEZXnnDmCKbiQ6GucYVIvWRyJM3tOC8RwFqJ96ORXy0mLiqOd/tHTm5on+ViHK9KeV2TWLw2RYGbC3HRcSzdLNOcaC6vpw8MPo4k8ausmuQsI0lqQUB51pCHrks56xse4OfO+wsuC9dFllOtcldxgP8+fjk3PHQB41vXWPsspBtN231LOp6VaD9/Wzyd+MxnPsO///f/nn/yT/4JV1555fLyPM/51V/9VX7pl34JgJ/8yZ98RGrVD//wD/POd76Tz372s/zoj/4ov/zLv0wYhmxsbPAP/+E/pK5rvvmbv5lrr732lNu9/vWv57LLLuOOO+7g+77v+3jPe95DlmVMp1O+7/u+j42NDa666iq+7du+7Wl//s9VKO/PEIFfC0ajEYPBgOu+7mcIgkemObQ4PZ7zGfVaUaearUsCgus3+bHL/oJXpfdRATfOD/Fr972CYzeezVkfKUgPb+DDALuSoWqH2Zzgx1Pp5UgT8XgUJexZwaeRLL7nhZCKNMJHATYJCDem8NAJMBp/9l7xjRzfkClLFMntsxj14HHs5jbKGHS3g+p2ZAd/MpFG7TCQxX4o/RRSoOdRaSr3nSXUKxm6ksW1zQLp+zAKUziizTl6eyJTFJDpSTfDd1NUWe8eU5aJyX42lx38MJSFvG+K+YIA1e8BiKwsCJZN8T5L8FrjQ4PtR7t9I1pkVIvEKheo5R8aeZi20i+iHNhISeO5Zun7CKeOaLuU6cf6Nm57R6RfYYDudSU2OQxEulbVQjy0En+GUrC5A84KIbJOJh+wnHIA4hnRBj+dCpHQaukt0d0OqteTyUhRQBQKmQkkktnP50LKwlBke2lCcf4ejlyXcPBVD/D/nP/HXBONqfAcqQPuqfby3hPX8tFbL6F/Z0DnyEnFgi35OKPxnP8c/RJR1zk3/NXPsbOz82U3LS/WDl97/duf8rVDXef837/510/qed1www1867d+6/LnyWRCURRkWXZKotSnPvUpDh06xM0338wLX/hCAPbu3cu5554LwGc/+1lmsxkAb3nLW3j3u9+9GzV+Ev7yL/+S1772teR5vrz94rbnn38+H/3oR0/bpH7bbbfxtV/7tWxtbTEYDLj44ou5++672dnZYXV1lb/5m7/hiiuueOInq8WTQjsBafGsRptRLzC5o3+/Y/vjq/yS/0Y+d8GneWF2H6tmwiv238UfXRtxf3eV1VvPovtgibZeUq3CQBbhXiJclbX48QS1uY2OInwnxQ17qKJEj2bSDD5SUlzoHSqIUJvjZdQv3uMmU7R36CTBzeaNPyFeTjb8bI6bzmXCkGWNPKjJWa9qXFGgrUV1u1BbgvXJcpKhuxlBEoo/YdyY59MEnway25/nYiBvpEoYgwoDIVhRKMV51sq/q1KmANai0hTlnHg6gkCOM45wnYR6EFOnBheLAf7R4n4XODl9yxu17C9Z/E41jebxVk04qdCTErU1wo5GQj6MQacJqt/DDjoo7/FJiMorCRJALwmJX5yzeS6BAtY1qWcyBRHSkMrvcnOKqV1FkUxDjBZSU9cy4ZrnMikJAiE5YYjuZNhz9jK+oMPmlYbui9b5noMf55Jwh20Ht1d7uGH8PP7q6CUc/+xe1j6ryI7XmNy1Xo9nAdrP0RZPJaqqYmNj4xGXz2azJaEAlpKp888/n5//+Z/nxhtv5I477uDOO++kLEv27dvHt3zLt/ADP/ADvOY1r3nUx3v1q1/NTTfdxC/8wi/woQ99iFtvvZWDBw/yute9jre97W2PWjZ41VVXccstt/Cv//W/5k/+5E+49dZb2bt3L294wxt4+9vfforfpMVTj5aAtHhWo82oR2RCWhHt1Kx8zrBTrfBbo5eydUXGa4c3c2X6BewhzedW9nH7hQdYf6hLdr9hz20V4TEn04c0EZlRYypXWSat11YM6aqs8LNcyu2sFUO50UImCpF2KaPFI2AtdjRBTaZ452UxrJR4FYpCvB1Gi5yp15GCu04qi+xZgd7YlvLCbiaSsK0R3jeRstsjtNa7npDGML7wXuC8ECjnRFqVpfI3yGQlCGDPKi5LUMc28DticlfWglK4QYbb25fW+EhjYy2JVeEu6Xi0xvLT4eHXVU1Ovykc8YkZen0H30TaqiBA9/tClowkbClr0ZN8lzhYi2/OIc6h+z088a6vxhjxjUShvJaLbhCt0dFukovfHsm0aZ4vJyUYA2WJK0tUXcv9JQnq3LPZev4KJ16o6F2+yTecfZgXdT/PRdFxKg8bLuYvdq7iD2/+Krp3Ruw94ki22oSrZxPaz9GvEDyNPSBPBq985St5MuKa4XDI2972tif/QCfhyiuv5Hd/93ef9O0OHTrEu9/97i/psVt8cWgJSItnNdqM+gYNCQnHluHdoOuED+ir6F5Z8LW9O/n63mf4mu7nsAcUD16+yrvv+RomG2uk9zU9F1mMHs9loqDVsttCVfVuclVdyy55VcsOufOy8+6deETCCMYyGcF7vBO/gB70xTOyM1ru0Os0gWEfl8VLk6PtJdCJCeKIuhfjQoOZV2jvxRBdlrKg7XeleM86kSVZh0LkSarXFVI0maK9x6/0m3Z3icddRBKjpcUbpcFJ8pdPIup+jI00NtHY6NRpx6MRjyfSPHzybaVc0KPHc+zx9SZtS6GHAxhKbDG1lXM/nuImUznWMJLulelMygiTWDpBtEL3ukvvh08iScPSCiYzmZqkibwmoUjLVBLvEjel5HWvqt2DtBaVJFRXnMORl6fol2zzjy68mdf0buXCMEcDY+fZdBH/Z+ca/s9tL2DlppDukRpT+LbR/FmG9nP0KwTe737GPZX32aLF04CWgLR4VqPNqD8JDQkJZpb+vaDqlN8tXsL2CzL+wcqnOBRss984wmSLrfM6vPvSryfdHNC5f4qeFkvJks8L1M5ECIfRqE4mO+5WOii8tbJYTVN0tyPEII5RUSRTjrICBToKJeq135UCvslUkmcbiZSyTl61QEMtLKTuBFT9Ht6Ij6LqBgTdiOhEBOtbMgGIpefCT2cynel2xK9QlE0ErsI1ZnLdTD98VQnZqCQCWI0jaSlPE5kAaA3WEUwqgtrh0oC6K1G+NpLOjtPyDy+EQtdeTNYgvpBa0q1cpLBx0/mxLB304mlpon6BxvNipIBw0Tg/z3HbO/L7LNslH96LrwPws5n8LhZ5mfceNbFQVCIjq2vxwOSNN0SL+d47L90uYQhhiG9SYHSWoXpd6kN72Hheh42rPddfdyvfu/cG9popibJMHYx9wL3VKn++/Xw+cMvzWbkppPegxRSuJR7PQrSfoy1atPhyoyUgLZ7VaDPqH4aTScj9HlOE/On8au69cpV/sP8WXtO5k3OCiFd07uBvXnwxd3A++8Iuw9sqmOfL8jqqplnbuWWB3kLihPN4RM6kuhlqnuOms+WEQxmzjHZldSC3nYi0a1Fi6HcKVF6gzD7qvX1sGlB3DHWya+5eoOpq6qxPkgSYo1v4rREqS8T74Ty+XMT1GjG3N4ttlxfSfdHtoMJQ2s0Xu/x5IRKjLEM5K6RrNME03goTBgRpjB2kFKvSWr6YhCgnf0BKuszcEY4rzFQii31oJFJ4XuKymGoloeqZZfqVtqALK0QNIWp6OBBSNR5LapW1QlCcR0fhMgLYey/TJmgmI0amI9bipjP5d5IIGckLaUQHkdMFwa4sQit8XsnzjiJ8VaNXhpQXHWDr8pSNay1XXnYv37p6mK/v3calYU2iAjat5UPz83j/+tXc/OBB/Oe67DkM2XGLKVvy8WxF+zn6lQHln9hE9sneZ4sWTwdaAtLiWY1FRv3J6S3vufDVz+2M+qaoMJg7ukdAV4a7Jufxe9dErJ4/IVQPstfADxz8G/68s8Wf7r+C6YE1hocHZA9MUA+t78qlmpQovWdVzM5b20sJlWpazf2gh1YKu7klC+BFV8U8R61vy849oHpdmE5xo2L3fvMSMy1Q3uMijYoVTrNbNAgopUQS1Y3QncYsHkeyg181srA0lp9BivzCqumrqGSqk0So+RyX74ba+6IQE34QgK6aWGEhIKrXRVlHkJeouodNAjAKHOjKomonREkrzNYMtkdCKBrzPalE5Zr1HLM9IVzrke+TBnQzdwRjmTjpKBQzeBiI5wNgPpc+D+dRpjGLN1G8qq5RSdKQQ4+30mOiwlBIWBI3ZnsL1VxSrwC1SPrqZLupWouySa3Q+/YwuXI/R643vPhr7uBN+2/kknCDgVZkKqQCjtmCvysO8O8Ov5LNv9tH9z4pFgymrk25epaj/Rxt0aLFlxstAWnxrEebUf8ocB5TOjrHPLoOOFqexS8Vr+GVZ9/NFdkRXpzeyz/f95dc17+L/3Hei7n1zkOs/u2AvZ9QaOdRjZcDwGeJyJ2mkZjHtRZZ03QGYSDTBmtlkZvEoI14K6pyN27XNTvk3oHSMhGpKjGeO4itR1cRZT+Q5KiTJg668uh5Lf0YIKlYTe+F6mRyv6OpeCICISK+lFZxX4ip2scxWmmZJrjd5yZFh1rM3U0KlbJWiM32HD0ao3UzaWiuu0RT0EiWQhBIjG45RlUVLG5TVZgNiANNGBuCnUISxfpddJZKS3rckAalYGWAri1+Ol+a/tU8F3/L6kCmI03crneNFK3Xg72ruDTCpZISpr9Qw2Qqk55Op0n+qmE6k/uMI/zB/YyfN2DjcgMvHPF9z/sk3zH4O84LIjQpha9YdyV/Mz+P/3X0RdxyzyG6d0Ss3dfG636lof0c/QpA6wFp8SxCS0BafMXjOZ1v7zy6hnS9xpSG8XgP7zu0wseed4K9F414RbrBa7L7OXjOFn/ev4oP7LuSew8O2XNLl84DM8zmBJWX2ChAey89EVo3nR3lMj53kXal0lR27BupFapJu2ouk+lJ43cwGhVFuG6KSwL0vCI6VhGMQ2wWUmcGFyl06Ym2SoITI0l2SlORWVUlqteTONpGdqW6mUxqZvOG7Pil74GiBKPRSbMY11puO5/jrVt2ZKggkGNfNJ9PymUKlYpjMXwrJS3pYSiJU3EIgUE1BnhfTeT6SSy59bXIuoz3sD3GV6X4PppWc9U0p3utdwsaoxCyBGY5ftZEDgcyXVJxjB4AZSUpZHmOLhJwDpNXch2l5Lw7J4WFCxJY17C2ws4L9nD8RZrBVRv8/YOf45v7n+ZQMOJB2+WEdVg0H589jw8ceT73Hd5Hdl/A3iOeZLuN13024jn9OdiiRYszDi0BafEVjTbfHiEhQLxdE8406XHD+mg/v6xeg7vwL3h5cowLwxHfvfIJXtn7LH953pX8/9u78yip6jv//897a6/qrt7YdxpQohJEBKOOE4PbKJxRY/wFmbjELTPGYxLHaIx+Iw5GUROj44lODprFiFmMQWOMjqI4GowGBDEiKEtDg+y9VXfXXvfz++N2tSDd0N303q/HOXW06y79qepPXe67Pp/3+/OH8mkUrCyk7AM/wR312Ml0U4K0+42/SaXdm37Lxo6E3OlajuMmgXvdy4plWe4++UDAGPD53SlKluWOUGSzWJkcJuTDCXjx1CXwbqvF6/fhLY3ihLzuyEcm544Q7PdtnBUK4ZQUYNc0uMnYQXc18PxUKjsUxAqHMIURd+XzpgR5A24Q5ctXf8q605citvs6AgGswog7pSq/KKFxME1rhpic4+a+gDtVqjGD5QRxiiIwZhiefXXkdu9xg7Jczi1x7PO558vm3NEWO4ATq/90NfJ0BjtX5OZmxBrc0YlI04rwPq9bQteyINFULKBpbRNjGt1RkkQCZ3cGbLt5FIdwCMvrxUml3DyXgJ/csGISw4LsO86LZ3otl01YxbmF7zPWmyFs+diatVkZL+eTVDHrYsNY99EoCj/2MnyHg6/BXc1cFa76Hl0HB4b989M685wiXUEBiPRrqm/fpCk53ZNyCO8xeFMeqhqH8726Czlz/MccF9nOlOA2JvlqGFe6nM+duIOflZ3GthFDiG4so3RdEv/2ajcA8XkhnXYXGAyFYFApFjQtkkfzauT4I7B7H6ax0Z2O5fW6oxH5NTwAk81hNSbwWBZO2OfegDfGMQ0GD2D7vFjZHCYScqeBJVOYhkY3eCmIYOWaplGFw1iRkFuKtyAMRQXuyAS4JW1T6U8T4ONxN3AKBT+tyJVfWTyZwvLYpEcU40nlsCsz7ohIKOAurFgXc6c/NbXHchyoi7nTr0I+MlE/gZzBqql135NwyM27CPjdYALc0YlUxg2+mhLOnca4mxAeDGAXF+EUFQBg56eaNa3KjjFN+SHudDbTVO3L8nrB5/t0mpvHHa0hEsYuCNNYXkTtBC/xEQbPuAa+evQqLoyuYqgng8ey8Fk2u3NpXot/jmc/mcr2naX4tvsZvBFCVVnstEY8+jJdB0Wkt1EAIv2a6tvvp+nm0R0NyVG2ziG5o4D/Gzqdv4w9nkmTP+HfRr7NaaEtnBepYNLRu1g1Zjyv7pvMP1aPZ9jyYRR9WOtOZfJ6sZrK8OaKwhiPjcfvw6qPY+rr3RyRptGS/E042RwmnnATnwMBN5k6GiEX9GMn03j3JtyF8WjKy0hn3G/bjcFq+ubfGMedMmUMxBNYn7jJ2gwfQmK0O4JgZQ2WMdhpB+/eeqiqcUcFQqGm3BSnuV0m57gBknGwgkF3apbPh+P3uCuWOwYnVu8ufuj3ufukUu5ih5aFUxTBzjmYZBJPTRy7IY1d1+CuUxIMukFPMoXl8eCEAxiPhR1LYGrq3FXH/T5snzslLZ/8nh1ZCo5xp5zl2+7xuCMpwQAmmcKpr3dfN5+WO7ZCQfc9TiSwfD5yw0qIj45QM9FL4oQ4F05ewRnRDxnmiTHIk6HU9hOwwjSYFB+kA/ym6mReXH8MwQ9DDNpp8Nc7eONKMO8PdB0cIJQDIn2IAhDp11TfvgWOO43GG7eIJBxC1e60rC21o/nFTA9l4xuY6t/Hcf4Ux/jWcU7Bh7w2+CgeGHYGydJSyj5I4A34sbJRDGDH0xiPxw04gn6IezDJpJsInnOwiqNulard+3DicXdqVCiIUxDG+DzY8RRU17kLGOYcd3TDtt1RCWPcaVJ+36d5J02laK1QyJ0SlWla88JjYWcM/j2Nbh6FbburqKcz2NFCnMHFGI+FpzqMs6/anaplHDepO9k09SoYAMsisL0WK57EaWx0p3XV14PP7yaVlxQ1lyY2Ho/btoYGzI7d7rQzcKtWhUNutammmwK7pt59fcmkWxK4aQTJKizEKSpwE+yzOXf9EK+N8fvc0Zmm81mW5QYuaTcRP5/Mj8eDFQqSG1xELuCOsuSCHhpG+tl3gmHy57fwxUEb+KfIRxztSxC0PFQ7sDOXJkeGVclRPLjpDGpWD6ZkM4Sqc3gTjqZa9SO6Dg4QvWQldJG2UAAi/Zrq2x9CU7ne/LQsT9rDnoaR3HDsJZw+cQMXD1rBVH8VQz0evlL4MYXTkvx80KlsmDaMSEWYgu0OoaocvljaXZAv57jraDjm0xW2bQvj9WC8tjslyeNxV/TOOe5IQSjQNG2oaYTC11SRqqERJ1aPFYlgFUZwomGsxqSbZ+L1uue2rKbytA5WVS2hppt9qzHh5p4Ypzn4MEUFkHVwQgEoLsCuqXVHCoIB7HD401XW86M06TROU+K2PagME3GDCdMQd2/MfV6M34cT9uGEi/H6vFh7qjDZrJt0nmtaXT0Scsve5nJYsUZMfQNOIvnpqEYuh6mLYWcy7hQqj41d0+BOPUumcJoS4a1EEscYcBzsQWVuDk1DI1YkTG5oMTWTCqk61iI9Ko03kMOyspQW1TFvxEecG13DME8cG4gbiJss27JhXoxNZdmuSezYVkbBxz4GbXXw1auyVX+k66CI9DYKQKRfU337NmiqlBWszuGLO8T3Bnmzcgp/O2ocp4/dyOyS95jq38dZ4UrGle9lxfBy3p5Szrq9Q9ldHcGuCxHeaVPyUZaCmkZ3hfFI2A0ukkmorcdOBzFerztNyMm5C+4lU+4IQDAAoRBOaSHG78VjWc2J5JbHblrDI+1Wj0pn3OCmoREAy1foTu+KJzC79ro3/yVFEAlBXYObL5FMYsUDEPDjaQQrmWlaE8PjTskCd8X0prLAJpVyywobx61E5fO6QUSmqTJWpikPxmma4mVZbo6J14sdDrnJ4z4vJJoWW4wnP53G4Pdh5fNnPDY4DrmGRmhoxFMQaR7psZoWG7S8XjffIxTE9rurvGdGlZEucldprxvnoXFcjpKx1Vw0aj2nFn5MoZ0kY9zXVe+ESBofPgvqHQ9/qT+Ol3Ydy9bdZVjbg4R3WQyuNgTrsngSyvPor3QdHBgs404/7exzinQFBSDS76m+fRvkFy+MGwp2GAJ1NvFPovzvhON5/5gRfHX0uxwd2IGDzeTATr4wfBP2CIfqXAGVmTKe3XU8H40YQ1nxUErfD0FNvbtIYM4BHHdqkc/njlgkUziNcZx0xs2t8NhYto2VzDQv8GdHCzHhILloCCtnsHdVkatx8yEA8PrcXJTGuFtqNhjABnc18HTGLV9bVICVSZOLNWDnHOyyEjdQSCTdG/uyYrcyVXUt4HGDi1TKHVGxLSxvoDkQsBvikEy5ozPZLFYmi+XY7lodxsE0lRU2oYCb/5HLuet75HNePB739/t9bvsbGt2pZIEAnmAAJ5F0q1Vlm1ait93EeCtagCkuoL48SmKQjeOBTKFFYpiDf2wDJ46s5PjC7UwM7OJY/x4GeTzUOTlqHS8eDLuyxXyYGMnfsPjrvgl89NFICjd4GbzLwdeYw84YrJxR4DEA6DooIr2JAhARVCMf+DRJPQv+WA5v0uCv91BdPYwHys+isLSRaDDF0cV7mFWyji8Et3KML0cuWMvMYAWvDf4cz35uKhumDiW6uYhglYMv7uD4LCwHAtUZADzxDF6fD2rr3BELy8Ykk1Df4I4QFEQwxYXkCgNuexri7naPB0847I4u5AORXFPSdTCIKYxgWxZOQyNWOu2ex+PBDgbc0YZkyk1eTyTd6VNBL5bPgx0PuuVr43F3DY/8+xAJQ7TAHf2orsPEE5/moiRTboAQbqqkBe4oh8eDXdeAU1vnVq3y+bHspiXdc44bbPl8EAlDIumW0w2HsR33WLxed32TSIj06DJi44LEyi3SkxKMG1ZFyJuhIR3gmJJdzC17m8F2nDrHfZ9yWGzPwt5clE+yJezIFPNu3Vg+3DuU+l2FFGz0Mnx7UzndTNNox35/d+m7dP0SQEno0qcoAJEBTzXyP2O/kr2hvQZ/vU2mwksmUkxdscX/DR3CigmjOWv0R8wq+pDJvn2UenLMKfwH5xy9ll0TC1ifGsF79WP4qHYIibSPWH0YszOIt9HCkwgSrC6gcPtwQlvrsesa3NK9udynyd2WhacugdWQwMTdErV2IIBVFHUX/atvdHMjooVuDknGHZUwBWEsx8GprXNXDw8EsKOFEAq6IxOxBpy0u7CgZ18MEwnhlEXBtrGzWTf4MI77u4LuMQDGGHeEIpfDCofdaWDZLHjchf6wLEx+hfSmPBC36pYNjrt4oGlw20wo6J7D63VL6TYllVslRTjRMMZrs+/4QqpmZjn2qC2cV7KVEyObKfdW47EM27JRCu0kx/hyBKwAKZNhdy7Lu6mRvF73OWKZILFMkH9sHEVos5/QPsOwmMHfoHK6/ZGuXyLSFykAkQFPNfJbkB8FcAx2zuCNQ7DGwtljUVhpk9xQzF+GfYEl449n5sQtnFq8ifLAbsq91ZwYaODkwCZ2R9axdVCURuMn6fjZkSkhh4UHw75sAX/dO4GNq0ZS+o8SCnakCVTWQHUtpqHRLW1b4OaFWOGgW1ErnXGnQeXXAbFtiNW7VaDyix9m3EDGakpStwLu9CwTCpAtDuH12G4ORiaLqalzK0wVhN3AJF+ZyuPBKnSngDUntadSWH6/W4bXttwSvl4PxBqa1+GwvF63GlfWHZ0xjuO2124KRnKOm3sSDLjTywpLMF7bXWjRcUiXhmgc7qeu3GbIP+/gB+NfZpJvHw4WNoZi26HQ9jLYrieDIW5gdy7L3lyIP9XN5Hdrp+P/OIS/Huw0DK1zp1l5Uo6mWfVjun5JMwN09sKBumRIF1EAIgOeauQfRlN+iJUz2FkLb9zBX2cR2WOT2BZgzabJrJg0lkkj91BeWMUZRR8yJbATsBjhrceHwWdBMLSToOXBxiZlslxU9C5Lhx3Ds1OnUvHxEIo/HEp0axm+mLv+hyfuTtnKlYTxOA52Mu3e4Nc3YIWCbvK5bTdPZXIKwtj1jZBrKm8bLXATwo3BSqbx7Uy5K5H7/RjLcvMzqmuxGhrdHIxkyn29ljsdK5+Pkc87sYuimGjEDV7AnZrgNJUJblqsEL/PXQMF3PVCkm7gQggoKsApDJMcFqZhhJfG0RapwTmIZPEGM/j9KUojNVwwZBP/X/EKjvV7gQA7cwk+TJexJhdmmLeORuNnV6aYj5PDWL67nB27i/FtD1BSAaGqHJ6kW0JXU6wGBl2/RKQvUgAiA55q5LfDfosZ2g05PE3riMR3B6kcNJbNBWN4cehxlAyqZ1RRHdOLK/mngo8Y7Y0RN+AhS73jY1euhEYnwEnhjZw4aTN/HX40b39+PJurymisDuGt9lGw1SKyK4fxWKSOjZCNWNhpQ2SPg+OBXMAiWJMjuCuO3ZBqXkcDr9fN+bBtnIA7hcqTTGNqat0SwEUFYEewvV6c+gZMwi3va/t9WIWFWAVhTEO8ae0Pnxt4hAI4IT9O2I+xLaysg6fBzQMh4McUFZApDZMp8IIF3ngpvpoEdp1brcuJhkkPjlBzlJ+aKTnGTdrBGYO2clRwF2XeBnLGJmKnGOutYYTXImz5AdidS/BK40Se2XUCm/eWkUl5cRp92HEbb9wiuM+tYuWvd/AkmxYN3O/vJP2frl+SpypY0pcoAJEBTzXyO2D/QKQxR3SrQ+F2yAVsMiEv6cJSNpaV8cGIsTw76vOMLKoj67g5Ejlj4xiLkZFaTinaxIxQBZcUvcslRe+yY3SYVYnxvFc/mvf2jmBHTQG212HUoFpGFdSyN1HApt2DsACfP8vuWBD/jiihPRbehHGnC1g0L8hlvOBrNIT3hPDWuwsRJocESJTZYIZgZ8BqmrJgPJCJWOSCEKwyFFam8aRyxEYGSZRZZMMW2RDkAgY7Y+GNF+JJD8JYkAtCpsCQCxlyEQe8HqxElODeEnwxcPwQH+FQdtQ+vjVuBedEPmSwx+DBImkcdud8hO0shZZhR9bGIU2VE+KlulP4w0fHY38cIbTLojjm4IsbN4ncMeCg0Y4BTtcvaWbogiT0zj2dSN6AD0CMMSxfvpznnnuON998k/Xr1xOPxxk0aBAnn3wy119/PV/60pcOOm7+/Pnceeedhzz3unXrmDx5clc1XTqJauQfgaYbXssxWI6Fncm538zXQMEui8xmm1RRCZXhUkxTjrbxuDfrm4cP4YMhw3mp6DjGRKoJeTLUZkLsTkSpzwQI+bIUj9jH0FA9o8M1TAjuoXhQI3uHR/FZOcb4qvBZWf7WOIlVtaOJZ/0UBxKEPBkyjodkzktdOkTlvhL27ArjjfswNmQHZRg6vIqiQJKAN4vfzmJbBq/lEPGmyRqbtVXD2LytBCvlwzM4yZgh1ZQXVjEqWEPQzlCdjVCdjjS/DSFPmgJPioZcgICdZUygmoCdYUVsPOtqhuLz5DiqaA/TCioZ7a9ic7aUtxLFVOciOMYm6fhwsNibLmRzfRnJrI/qeIiGbVGKPvIQ2Zlfndx9rz/7/svApeuXiPRFAz4Aee211zjzzDMBsG2biRMnEolE2LBhA3/84x/54x//yO23386CBQtaPH706NGMGTOmxW3hcLjL2i2dqy018lXq8jD2D0ZsCztr8CQNgTow+VK0Tf9xfBaZj9yRks3hMjb6JmAssEzTiETTfbWxYacXVhQZrNFxvjCugjNLPmRGsJIRXgvHGMrsNUwM7CZtPHw+8AlDPRlyuLmYGQO7xod5LzmWj+LDKPCk+Hx4G5P8u8kYD2k8RKw0YStLxHbwAdWOh+VFE6gZE2GUv5rRviqK7SRBK4cHQ9rYOFjUO3525YoIWhlGe2vJYfF/jUezrOooVuwbS8CTpSYZIpnxEvDmWLFrDCsYg2UZkmkf8boQdp0XT8rCyoKVs/CkwJsAT8IQTEBhwuBrzGBllUQ+ULXluqM1PgRQGV7pUwZ8AGKMYeLEidx4443MnTuXkpISANLpNPPnz+eee+7hrrvu4qSTTmLOnDkHHX/llVcyf/78bm61dDeVumyn/YORz26zm260GyFYbWE8n+6RHyU5gAXZgE3jJxHerJuM53hDtCxJ3FSTw6I6V0CxJ84wT4xBngweyyJnDBkDPguGeeJMDuwgaGUY7I0xybePiO1Q63iJZYNUmwKK7TgjrHqCNvgsh2JPI34ry2BPDD85tmRK2ZEpoS4Xpi4bImBn8VgO+zIFNGYDjAjWUuRJ8PKez/HR+pGEt3nxxsHOgAfIWk0jF02zxIIORNJgZwx21n1YTtMc7qyb8N88tUpBx4Cl646I9FcDPgCZOXMm69atw+s98K3w+/3cfffdvPfee7z44ossWrSoxQBEBgaVuuxE+eAE90Yb+6AQ5SCehIM3ZeNr8PD2jin839BjsIvTRCJJhkdjDA/HKPIl8DTVoMzh5pnYlsExFomcn0TOR8iTIeJN4RiLxmyAkCdDwM4Qawoqot4EATtLoSdJdTbCn2JT2VJbSm11AVatD0/cwpNy22tssHLuw3jBeAy+eovBew2BOrf87aHmTzfnbZj9cjg+8x7JwKbrjrSLAwd/49MJ5xTpAgM+AIlGo4fcftZZZ/Hiiy/y8ccfd1OLpDdSqcsu1IabbQvwxh0Kk4bIHotM2CYTDpINh9gWLWFLEA6+iz8MY+EEDI7XYKeb/tVuWjfQCTlYGQt/jU2gBgbVG7wJgzeVc0coWpuW8Nmk8LZQsCGt0HVHRPqrAR+AHE4ymQQgFAq1uH3ZsmWsXbuWqqoqSktLmTlzJpdddhnDhg3rzmZKF1Opy16gaTqXJ2Ww0w6BWtwVyG069K2fsSyMh0+rZuU1n8tgZZ3m6VDQxhhHAYV0El13pD1Uhlf6EgUgh2CM4emnnwbg1FNPbXGfN95444Cfn3nmGebPn88jjzzCFVdc0dVNlG6iUpe9xH7Tt1wt5JgcygHTvdrxD6uCCukBuu6ISH/VUsqnNFm0aBGrV6/G7/fz7W9/+4Btw4cP5/vf/z4rVqygqqqKeDzO8uXLOffcc0kkElx55ZU8//zzhzx/KpUiFosd8JDeKV/qcmXZRPYGoqwsm8i3TrxWpS77Gsd07CHSA3TdkXbJV8Hq7IdIF7CMUe9qyapVqzj11FNJJpPcd999fPe7323TccYYLrroIpYsWcKECRPYsGEDltXyd7StrSVy6pfuwOsNHlH7peeoXK+IHI6uE/1LNptk+bI7qaurO2xuaWeLxWIUFRVxxjE34fUEOvXc2VyKVz/8UY+8LunfNALSgoqKCubMmUMymWTevHncdNNNbT7WsiwWLlwIwKZNm3j//fdb3ffWW2+lrq6u+bFt27Yjbrv0rHzZzBOrNjI4FePEqo08uHIRx9Vu6emmiUgvoeuEiAx0CkA+Y9euXZx11lns3LmT2bNn88tf/rLVEYzWHHXUUZSWlgKwcePGVvcLBAJEo9EDHtK3tVQ20zKGSze/1sMtE5HeQtcJ6RKagiV9iAKQ/VRXV3PWWWexadMmvvjFL/L000/j8/k6dK78cdlstjObKL2cymaKyOHoOiEiA50CkCYNDQ2cd955fPDBB8yYMYPnn3++1dK7h7Nv3z727NkDwKhRozqzmdLLbS4YSu4zdZlUNlNE9qfrhHQJp4seIl1AAQhuNarzzz+fd955h2OPPZaXXnqJwsLCDp/vgQcewBhDUVERM2bM6MSWSm/36/JZGMtqvrlQ2UwR+SxdJ0RkoBvwAUgul2Pu3Lm89tprTJgwgVdeeaU5f6M1a9eu5brrrmPt2rUHPJ9MJrn77ru59957Abjlllvw+/1d1nbpfVQ2U0QOR9cJ6Qr5hQg7+yHSFQb8QoS///3vefbZZwGwbZuLL764xf2GDx/evChhJpPh0Ucf5dFHH2Xw4MGMGTMGgHXr1hGPxwG46qqr+N73vtf1L0B6nQ+Kx3HLCVcech+V4BTpv9ry+W7LdUJEpL8a8AFIKpVq/v8NGzawYcOGFvcbO/bTb6bGjRvHggULeOutt1i/fj0fffQR6XSaIUOGcN5553H11VdzzjnndHnbpW/Kl+DMV8EpTdUzvXoT3z7xGgUhIn2cPt/SY7qiapVGQKSLDPgA5IorruCKK65o1zHFxcXcfvvtXdMg6fdaKsGZM+7z+kZUpG/T51t6jGPA6uSAwVEAIl1jwOeAiHQ3leAU6b/0+RYROTwFICLdTCU4Rfovfb6lx2ghQulDFICIdDOV4BTpv/T5FhE5vAGfAyLS3fIlOPevkvNE+RktluBUtSyR3qOt1a3a+vkW6VxdMWKhERDpGgpARHpAW0v1qpqOSO/Qns+jSuyKiByapmCJ9FItVdOxjOHSza/1cMtEBh59HqXXUw6I9CEKQER6KVXTEek99HkUaZuKigoWLVrENddcw9SpU/F6vViWxV133dWu8zz22GNYloVlWVx99dUt7jNu3LjmfQ71uPPOOw847vXXXz/sMf/zP//T4fdADk9TsER6qc0FQylN1R9w06NqOiI9Q59H6fUcQ6fnbHRgHZCHHnqIhx566Ih+7d69e7nlllsOu9+MGTMYNWpUi9vi8TirV68G4OSTT25xn2g0ypQpU1rcNnz48Da2VjpCAYhIL/Xr8llMr95EzjQtZnaYajpKWBdpv7Z+btr7eRTpdsZxH519znYaNGgQc+bMYebMmcyYMYPHHnuMZ555pl3n+M53vkNtbS2zZ8/mhRdeaHW/p59+utVtjz32GNdccw3Dhw/njDNa/pxOmzaN119/vV1tk86hAESkl2pvtSwlrIu0T3sTy1XdSuTwbr/99gN+/u1vf9uu45cuXcrixYv5j//4D4YMGXLIAORQfv3rXwMwb948PB5Ph84hXUcBiEgv1tZqOi0lyOaM+7yq8Yi0rL2fG1W3kl6tK5LGuzkJPZlMNgced999Nw8++GCHzrN161befPNNAC699NJObKF0FgUgIv2AEmRF2k+fG5He5a677mLjxo386le/ori4uMPnWbx4McYYpkyZwtSpU1vdr7KykiuuuIJt27YRDoc57rjj+OpXv8rxxx/f4d8tbaMARKQfUIKsSPvpcyP9Si9JQu+odevWcf/993Paaadx2WWXHdG5nnzySeDwox8VFRVUVFQ0//znP/+ZhQsX8s1vfpOHHnpIU7e6kAIQkX5ACesin1JiuUjnisViB/wcCAQIBAKddn5jDN/4xjdwHIdHHnnkiM61cuVK1q1bh23bzJs3r8V9QqEQX//61/na177G5MmTGTRoEJs3b+ZnP/sZDz30ED/96U8JBoP86Ec/OqK2SOu0DohIP5BPkF1ZNpG9gSgryybyrROvPWTC+olVGxmcinFi1UYeXLmI42q3dH/DRTpZe/p3ez43Ir1eFy5EOHr0aIqKipof99xzT6c2/fHHH+fNN9/k29/+Nscdd9wRnSs/+jFr1ixGjhzZ4j4nnXQSP//5z5k1axYjRozA7/czefJkfvKTn/CTn/wEgAcffPCA0RHpXBoBEeknlLAuosRyka6wbds2otFo88+dOfqRX/Nj1KhR3HHHHUd0rmw2y29+8xuADk/juv766/nRj37E9u3b+dOf/sS3vvWtI2qTtEwBiMgAo8Rb6c/Uv2XAMnRBFSz3P9Fo9IAApDPdfPPNVFdX87Of/YyCgoIjOtfLL7/Mnj17iEQiXHjhhR06h8fjYebMmWzfvp2NGzceUXukdQpARAaY9ibeKl9EeoO29kMllov0LfnVyq+//nquv/76A7Y1NDQA8NRTT/HnP/8ZgF27drV6rvz0qwsvvPCIghmfzwe4IyrSNRSAiAww7Um81QKH0hu0px8qsVwGrD6+Dsju3a2PUiYSCRKJxCGPr6+v57nnngOOfO2PtWvXAjBq1KgjOo+0TknoIgNMexJvW5pPbxnDpZtf6+5mywDWnn6oxHIZsBynax5d7L333sMY0+IjnxNy1VVXNT/XmmeeeYZ4PM7w4cM544yOf+Hw8ssv88EHHwBw5plndvg8cmgaAREZgNqaeKv59NIbtLcfKrFcZODJT7+aN2/eYdfvmDt3Ltdeey2nn346tu1+F2+M4dlnn+Wqq64C4Oyzz+akk07q2kYPYApARKRVyheRrqS8DpFO1EumYC1fvpzzzz+/+ed8Hsc999zDgw8+2Pz86tWrGT169BE3EeCTTz5h2bJlQNumX7300kv87ne/IxKJMHHiRAKBABUVFezduxeAGTNmsHjx4k5pm7RMAYiItEr5ItJVlNch0j9lMhmqqqoOej4ejxOPx5t/zuVynfY7Fy9ejOM4TJkyhalTpx52/4ULF/L666+zZs0aKisrqa+vp7i4mDPOOIO5c+dy+eWXNyeiS9ewzKEm1Em3isViFBUVceqX7sDrDfZ0c0SAg7+lfqL8jBbn09+76uecWLXxoG+pV5ZN1HQYOUh7+0tb+6FIT8hmkyxfdid1dXVdVq62Nfl7hzMHXYnX9nfqubNOmqX7ft4jr0v6N42AiMghdVW+iKZr9U9t/bsqr0NEZOBSACIinaI98/Q1Xat/as/fVXkdIp3MMUAnT2pxNElGuobK8IpIp/h1+SyMZZHDAjjkPH2V9+2f2vN3bU9/ERGR/kUjICLSKfLrL7Rlnn5HyvtqylbPaM/73p6/a3v6i4gcnjEOxnTuuh2dfT6RPAUgItJp2jpPvyPlfTVlq/u1931v799VeR0inciYzp8ypTpF0kU0BUtEul17p9+0d8rWcbVbuHfVz3n6jXu4d9XPOa52S5e8jr6qre9Pe993TasSEZG20AiIiHS79k6/ac/Uno6MlvT16V3taX973p+OVKrStCqRHmK6IAldIyDSRRSAiEiPaM/0m/ZM7WnpW/uccZ9vbX2Jrg5YunL/9ra/Pe9PRypVaVqViIgcjqZgiUiv156pPe391r4j07seXLmIE6s2MjgV48SqjTy4clGr05i6ev/2tr8974+mVIn0IY7TNQ+RLqAARER6vfzUnpVlE9kbiLKybCLfOvHaFqf2bC4Y2nzDnHeob+27OmDp6v3b2/72vD/ted9FRETaSlOwRKRPaOvUnl+Xz2J69SZypml60WG+tW/vNKP23vB39f7tbX973x9NqRLpI5QDIn2IRkBEpF9p77f27Z1m1N4Rlq7ev73t16iGiIj0NI2AiEi/055v7dtbuam9IwhdvX9HKk9pVEOk/zGOg7G0EKH0DZYxGl/rLWKxGEVFRZz6pTvweoM93RwRacVnq1Qd7oa/q/cXkZ6VzSZZvuxO6urqiEaj3fq78/cOs0JfxWv5O/XcWZPmtcTveuR1Sf+mERARkXZq7whCV+8vIiLSlygAEREREenrHAOWktClb1ASuoiIiIiIdBuNgIiIiIj0dcYAnZw0rhEQ6SIaAekEf/nLXzjzzDMpLS0lEolwwgkn8PDDD+NoBVERERERkQMoADlCCxcuZPbs2bz66quUlJQwceJE1qxZww033MCFF16oIERERES6nHFMlzxEuoICkCPwt7/9je9///vYts1TTz3Fpk2bWLNmDatWrWLo0KH86U9/4oEHHujpZoqIiIiI9BoKQI7AXXfdhTGGq6++mksuuaT5+alTpzYHHgsXLiSTyfRUE0VERGQgME7XPES6gAKQDorFYixduhSAq6666qDtF198MdFolKqqKpYtW9bdzRMREZEBRFOwpC9RANJBq1evJp1OEwwGOeGEEw7a7vP5mDFjBgDvvPNOdzdPRERERKRXUgDSQRs2bABgzJgxeL0tVzMuLy8/YF8RERGRLqEpWNKHaB2QDqqpqQGgpKSk1X3y2/L7flYqlSKVSjX/XFdXB0A2m2pxfxEREel98v9umx5cNyNLBjr512dRDqt0DQUgHZRMJgHw+/2t7hMIBABIJBItbr/nnnu48847D3r+nTcXdkILRUREpDvV19dTVFTUrb/T7/czbNgw/rrrL11y/mHDhh3yXkekIxSAdFAwGAQgnU63uk9+dCMUCrW4/dZbb+XGG29s/rm2tpaxY8dSWVnZ7Rcw6XtisRijR49m27ZtRKPRnm6O9GLqK9Ie6i/tZ4yhvr6eESNGdPvvDgaDVFRUHPJ+5Ej4/f7mex6RzqIApIMON71q/22tTdMKBALNoyT7Kyoq0kVf2iwajaq/SJuor0h7qL+0T09+cRgMBhUkSJ+iJPQOmjRpEgCVlZVks9kW99m8efMB+4qIiIiIDHQKQDpo2rRp+Hw+kskkq1atOmh7JpNhxYoVAJx00knd3TwRERERkV5JAUgHRaNRzjzzTAAef/zxg7Y//fTTxGIxysrKOP3009t0zkAgwB133NHitCyRz1J/kbZSX5H2UH8Rka5mmZ6sGdfHLV++nNNOOw3LsnjyySe55JJLAFizZg3nnHMOu3fv5t577+Xmm2/u4ZaKiIiIiPQOCkCO0A9/+ENuv/12wF14sKCggA8++ADHcZg9ezbPPfccHo+nh1spIiIiItI7KADpBH/+85/5yU9+wrvvvksmk2HSpEl8/etf5/rrr1fwISIiIiKyHwUgIiIiIiLSbZSELiIiIiIi3UYBSC/wl7/8hTPPPJPS0lIikQgnnHACDz/8MI7j9HTTpJtdccUVWJZ1yEcymWzx2L/97W+cf/75DB48mFAoxDHHHMOCBQta3V/6hoqKChYtWsQ111zD1KlT8Xq9WJbFXXfdddhjO9on1q1bx7/9278xfPhwgsEgEyZM4KabbqK2traTXpV0hY70lfnz5x/2mrN+/fpWj1dfEZGO0EroPWzhwoXceuutwKdJ7GvWrOGGG25g6dKlLFmyBNtWnDjQTJo0iSFDhrS4raX+sHjxYi6//HJyuRwjR45k9OjRfPDBB/zgBz/g+eef5/XXXyccDnd1s6ULPPTQQzz00EPtPq6jfWLZsmXMnj2bRCLB4MGDOfbYY1m/fj0//vGPWbJkCW+99RZDhw7tjJcmnayjfQVg9OjRjBkzpsVtrV071FdEpMOM9Ji33nrLWJZlbNs2Tz31VPPz7733nhk6dKgBzP3339+DLZTudvnllxvA/OIXv2jzMRUVFSYQCBjA3HfffcZxHGOMMVu2bDFHH320Acw3v/nNLmqxdLUFCxaYOXPmmP/6r/8yL774ornooosMYBYsWNDqMR3tE7FYzAwePNgA5oYbbjDpdNoYY8y+ffvMqaeeagAze/bsrnmhcsQ60lfuuOMOA5g77rijXb9LfUVEjoQCkB503nnnGcBce+21B21bvHixAUxZWVnzhV36v44EINddd50BzNlnn33QtuXLlxvA+Hw+s2vXrk5sqfSUfB851E1lR/vEfffdZwDzuc99zmSz2QO2bd261Xi9XgOYd999t3NejHSptvSVjgYg6isiciQ0t6eHxGIxli5dCsBVV1110PaLL76YaDRKVVUVy5Yt6+7mSR9hjGHJkiVAy/3olFNOYfLkyWQyGZ577rnubp70gCPpE3/84x8BNxfpsyXEx4wZw5lnngnAH/7wh65ouvQh6isiciQUgPSQ1atXk06nCQaDnHDCCQdt9/l8zJgxA4B33nmnu5snPewPf/gDF1xwAbNmzWLu3Lk8/PDD1NXVHbRfZWUlO3fuBODUU09t8Vz559WPBoaO9olsNsu7777b7uOkf1i2bBkXX3wxs2bN4itf+Qr33Xcfu3btanFf9RUROVJKQu8hGzZsANxvirzelv8M5eXlvPrqq837ysDxwgsvHPDz7373O+644w6eeuop/uVf/qX5+XzfCAQCjBgxosVzlZeXH7Cv9G8d7RNbtmwhk8kcsL0tx0n/8MYbbxzw8zPPPMP8+fN55JFHuOKKKw7Ypr4iIkdKIyA9pKamBoCSkpJW98lvy+8r/d+ECRO4++67WbNmDbFYjPr6el5++WVOOukkampquOCCC1i5cmXz/vm+UVxcjGVZLZ5T/Whg6Wif2P//W7suqS/1P8OHD+f73/8+K1asoKqqing8zvLlyzn33HNJJBJceeWVPP/88wcco74iIkdKIyA9JF+H3+/3t7pPIBAAIJFIdEubpOf9v//3/w567qyzzuKLX/wip512Gn//+9+55ZZbePXVVwH1IzlYR/vE/muDtHas+lL/841vfOOg50455RReeOEFLrroIpYsWcJ3vvMd5syZ0xzQqq+IyJHSCEgPCQaDAKTT6Vb3SaVSAIRCoW5pk/Refr+fBQsWAPD66683f6uofiSf1dE+kT/uUMeqLw0clmWxcOFCADZt2sT777/fvE19RUSOlAKQHtKW4em2TNOSgePkk08GwHEcNm/eDHzaN2prazHGtHic+tHA0tE+sf//t3ZdUl8aWI466ihKS0sB2LhxY/Pz6isicqQUgPSQSZMmAW7Fmmw22+I++ZvM/L4ysPl8vub/z/eZfN9IpVLs2LGjxePUjwaWjvaJcePGNfex/Pa2HCf9W75P7P/vlPqKiBwpBSA9ZNq0afh8PpLJJKtWrTpoeyaTYcWKFQCcdNJJ3d086YXWrl3b/P+jRo0C3Cpqw4YNA2D58uUtHpd/Xv1oYOhon/B6vc0lwdWXBGDfvn3s2bMH+PSaA+orInLkFID0kGg02rxQ0+OPP37Q9qeffppYLEZZWRmnn356N7dOeqMf//jHAEyePJmRI0cC7jztCy+8EGi5H7311lusX78en8/Hv/7rv3ZfY6XHHEmf+PKXvwzAL3/5S3K53AHbKisrmxdPveiii7qi6dLLPPDAAxhjKCoqal6XKk99RUSOhAKQHnTbbbdhWRaPPfYYv/nNb5qfX7NmDTfeeCMAN9988yGr2Uj/8corr3DrrbdSUVFxwPN1dXXccMMNzX3kBz/4wQHbv/vd7+L3+3n55Ze5//77m+f9b926lSuvvBKAq6++uvlbcen/Oton/v3f/51Bgwaxbt06brzxxua1Hqqqqpg3bx7ZbJZzzz2X6dOnd+8Lki6xdu1arrvuugNGV8GtcnX33Xdz7733AnDLLbcc9O+Q+oqIHBEjPequu+4ygAFMeXm5+fznP29s2zaAmT17tslmsz3dROkmS5Ysae4LI0eONDNmzDDHH3+88fv9BjCWZZk77rijxWN/9atfNfebkSNHmmnTphmfz2cAM336dNPQ0NC9L0Y6zV//+ldTVlbW/AgEAgYw4XD4gOcrKysPOK6jfWLp0qUmGAwawAwePNhMnz7dhMNhA5hx48aZnTt3dsfLlg5ob19ZvXp18zUn/7fe/+8NmKuuuso4jtPi71NfEZGOUgDSCzz//PNm1qxZpqioyITDYTN16lTz4IMPKvgYYCorK81tt91mZs2aZcaMGWNCoZAJBoNm/Pjx5rLLLjNvv/32IY9fvny5mTNnjiktLTWBQMAcffTRZv78+SaRSHTTK5CusGzZsuabwUM9KioqDjq2o33igw8+MHPnzjVDhgwxfr/fjB8/3tx4442murq6i16ldIb29pWamhqzYMECc+6555rx48ebgoIC4/f7zahRo8xXvvIV89JLLx32d6qviEhHWMa0UqdRRERERESkkykHREREREREuo0CEBERERER6TYKQEREREREpNsoABERERERkW6jAERERERERLqNAhAREREREek2CkBERERERKTbKAAREREREZFuowBERERERES6jQIQERERERHpNgpARETaKJlMMnbsWI455hgcx+np5nRILpfjqKOOory8nHQ63dPNERGRAUgBiIhIGz388MNUVlZy++23Y9t98/Lp8Xi49dZbqaio4NFHH+3p5oiIyABkGWNMTzdCRKS3i8VijBs3jpKSEj7++GM8Hk9PN6nDstks5eXlJBIJtmzZQiQS6ekmiYjIANI3v8ITEelmixcvpqamhksvvbRPBx8AXq+XefPmsW/fPn7729/2dHNERGSAUQAiItIGixYtAuCSSy7p4ZZ0jrlz5wLw2GOP9XBLRERkoFEAIiL9ytVXX41lWZx11lm0NMP0Bz/4AZZlMWXKFFKpVJvO+fHHH7N69WomTJjA0UcffdD2LVu2YFkW48aNA9yb+mnTphEOhxk5ciQ33HAD9fX1gJsE/uMf/5hjjz2WUCjEqFGj+N73vtdiQvj8+fOxLIv58+dTVVXFddddx6hRowiFQkydOvWA0YutW7fy9a9/nREjRhAKhZg+fTovvPBCq6/p+OOPZ+TIkbz99ttUVla26X0QERHpDApARKRfefDBBykvL2fp0qU89NBDB2x75513uPvuu/H7/Tz55JMEAoE2nfONN94AYObMmYfd9z//8z+55pprqK+vZ8KECezZs4eHH36YCy64AMdx+MpXvsJNN92EMYaxY8eyY8cO7r33Xq655ppWz1lTU8MXvvAFHn/8cYYOHUpZWRnvv/8+l1xyCU888QQfffQRM2fO5Pe//z0jRoygoKCAVatWcf7557N06dJWz5t/PfnXJyIi0h0UgIhIv1JQUMCvf/3r5mpPa9euBSAej3PppZeSy+VYsGABU6dObfM533rrLQCmT59+yP0++eQTHn/8cZYuXcrGjRv5xz/+werVqykrK+O1117joosuYuXKlaxevZoPP/yQ9evX89prr+H3+3niiSf48MMPWzzvo48+yujRo9m2bRvvvvsu27dvZ+HChQB873vf47LLLmPWrFns2rWLlStXsnv3br7xjW+Qy+W47bbbWm3vjBkzAPjrX//a5vdCRETkSCkAEZF+55RTTuHmm28mmUzyta99jXQ6zY033siGDRv453/+Z2666aZ2nW/r1q0ADB8+/JD7ZbNZ5s+fzxlnnNH83HHHHce1114LwLPPPsvDDz/M8ccf37z99NNP58tf/jIA//u//9vieb1eL08++SRDhgxpfu6mm25i1KhR7Ny5k23btvH4449TWFgIgG3bLFy4kGAwyN///neqq6tbPG/+9eRfn4iISHdQACIi/dKdd97JtGnTeO+995gzZw4/+9nPiEajPPHEE+1ew2Pfvn0AlJaWHnbfK6+88qDn8gFHaWkpF1xwwUHbp02bBsDmzZtbPOe5557LiBEjDnjO4/EwZcoUwE2MD4fDB2wvLi5m/PjxAFRUVLR43vzr2bt3byuvRkREpPMpABGRfsnn8/Hkk08SDAZ55ZVXAPjv//5vxo4d2+5zJZNJgMPmjAwePJhoNNri8wATJkxo9TiAhoaGFrcf7riOnjcUCgGQSCRa3C4iItIVFICISL81ceJExowZA0BRUREXXXRRh86THymora095H6fHYXIsyyrTdtbWxe2q86bn5o1aNCgFreLiIh0BQUgItJv3XbbbXz88cfYtk1dXR3f+c53OnSefO5Fa7kUfVX+9eRHSkRERLqDAhAR6ZfeeOMNHnjgAcLhMK+88grFxcU89thjPP/88+0+Vz6HY926dZ3cyp6Vr7p1wgkn9HBLRERkIFEAIiL9TiwW4/LLL8dxHO6//35mzZrFT3/6U8BdqLC9Sdf/9E//BMDKlSs7va096e9//zsAp512Wg+3REREBhIFICLS79xwww1s2bKFs88+m+uuuw6AefPm8dWvfpU9e/Y0l8Vtq1NOOYVIJMLKlSubE9L7uoaGBtasWUNxcXGbFlgUERHpLApARKRfWbJkCb/61a8oKSnhF7/4xQHbHn30UUaMGMGzzz570LZDiUQizJ07l8bGRl544YXObnKPeO6550ilUsybN6/NK8KLiIh0BgUgItJv7N69u3l045FHHjlo7Yx8UGJZFt/61rfYsmVLm8+dP+/ixYs7rb096Te/+Q3gTkkTERHpTpZprT6jiIgc4Oyzz2bZsmVs2LCBcePG9XRzOmzjxo1MnjyZc845p9+M6IiISN+hERARkTa69957yeVy3H333T3dlCPywx/+EGMMCxcu7OmmiIjIAOTt6QaIiPQV06ZNY9GiRezZswfHcbDtvvcdTi6XY+LEiTz22GNMmTKlp5sjIiIDkKZgiYiIiIhIt+l7X9+JiIiIiEifpQBERERERES6jQIQERERERHpNgpARERERESk2ygAERERERGRbvP/AxQ4Y2Er8AT1AAAAAElFTkSuQmCC", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 (ShotID 71) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 44.60 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 45.28 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.10 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 51.92 GFlops/s, 12.98 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 76) Completed state equation run for shot\n", - "HEAD Functional value for shot 76: loss 9.792010e-01 for shot 76\n", - "WORKER:0:1 (ShotID 76) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 76) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.59 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 45.80 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.51 s [OI=2.82, 50.64 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.16 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.84 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 71) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 71\n", - "HEAD Giving shot 79 to worker:0:0\n", - "WORKER:0:0 (ShotID 79) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 79) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 79) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 79) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 79) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 79) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 79) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.70 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 38.60 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.61 s [OI=2.82, 42.01 GFlops/s, 0.92 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.51 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.66 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 76) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 76\n", - "HEAD Giving shot 81 to worker:0:1\n", - "WORKER:0:1 (ShotID 81) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 81) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 81) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 81) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 81) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 81) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 81) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 46.87 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.54 s [OI=2.82, 47.85 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.10 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 53.32 GFlops/s, 13.33 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 79) Completed state equation run for shot\n", - "HEAD Functional value for shot 79: loss 9.045984e-01 for shot 79\n", - "WORKER:0:0 (ShotID 79) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 79) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.74 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 37.37 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.69 s [OI=2.82, 37.38 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 48.95 GFlops/s, 12.24 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 81) Completed state equation run for shot\n", - "HEAD Functional value for shot 81: loss 1.196671e+00 for shot 81\n", - "WORKER:0:1 (ShotID 81) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 81) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.70 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 38.60 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.62 s [OI=2.82, 41.68 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.51 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.24 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 79) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 79\n", - "HEAD Giving shot 86 to worker:0:0\n", - "WORKER:0:0 (ShotID 86) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 86) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 86) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 86) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 86) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 86) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 86) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.71 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 38.06 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.62 s [OI=2.82, 41.14 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.67 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.74 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 81) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 81\n", - "HEAD Giving shot 106 to worker:0:1\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 46.87 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.54 s [OI=2.82, 47.75 GFlops/s, 1.04 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n" - ] - }, + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5689f7df49a3497fb8b23a98a38a9d38", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot all components of the problem\n", + "problem.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "decent-report", + "metadata": {}, + "source": [ + "## Modelling operator\n", + "\n", + "Once we have generated our problem, we can create a PDE on which to run our forward problem. In this case, we choose the isotropic acoustic wave equation.\n", + "\n", + "We instantiate our PDE using `remote(len=)` so that instances of the PDE are created in the workers for remote execution. We choose `len=runtime.num_workers` so that one instance is created in each available worker." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "anonymous-tolerance", + "metadata": {}, + "outputs": [], + "source": [ + "from stride import IsoAcousticDevito\n", + "\n", + "pde = IsoAcousticDevito.remote(grid=problem.grid, len=runtime.num_workers)" + ] + }, + { + "cell_type": "markdown", + "id": "sporting-platform", + "metadata": {}, + "source": [ + "## Forward problem - Generating observed data\n", + "\n", + "Before we can proceed with the imaging bit, we need to simulate the acquisition of some observed data.\n", + "\n", + "Here, we will exploit the parallelisation capabilities of Mosaic to run different shots in parallel in each available worker. We do this with an asynchronous for loop using `@runtime.async_for()`. In the previous code section, the async function `loop()` is called as many times as there are shots in the acquisitions and, for each shot, it is assigned a worker." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "unusual-springfield", + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.29 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 58.61 GFlops/s, 14.66 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 86) Completed state equation run for shot\n", - "WORKER:0:1 (ShotID 106) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 106) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:1 (ShotID 106) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 106) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:1 (ShotID 106) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 106) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 106) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 86: loss 1.096196e+00 for shot 86\n", - "WORKER:0:0 (ShotID 86) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 86) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.51 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 54.22 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.46 s [OI=2.82, 56.02 GFlops/s, 1.22 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.40 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 60.59 GFlops/s, 15.15 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 106) Completed state equation run for shot\n", - "HEAD Functional value for shot 106: loss 8.537210e-01 for shot 106\n", - "WORKER:0:1 (ShotID 106) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 106) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 40.33 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.74 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.77 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 22.46 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 86) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 86\n", - "HEAD Giving shot 108 to worker:0:0\n", - "WORKER:0:0 (ShotID 108) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 108) Estimated bandwidth for the propagated wavelet 0.235-0.695 MHz\n", - "WORKER:0:0 (ShotID 108) Spatial grid spacing (0.500 mm | 4.270 PPW) is higher than dispersion limit (0.427 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 108) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.148 μs)\n", - "WORKER:0:0 (ShotID 108) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 108) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 108) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.68 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 39.74 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.60 s [OI=2.82, 42.94 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.52 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.60 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 106) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 106\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.51 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 54.22 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.46 s [OI=2.82, 55.76 GFlops/s, 1.22 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.32 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 53.82 GFlops/s, 13.46 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 108) Completed state equation run for shot\n", - "HEAD Functional value for shot 108: loss 7.556317e-01 for shot 108\n", - "WORKER:0:0 (ShotID 108) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 108) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.44 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 61.41 GFlops/s, 1.26 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.40 s [OI=2.82, 64.82 GFlops/s, 1.41 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 6.47 GFlops/s, 0.11 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.04 s [OI=0.25, 42.83 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 108) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 108\n", - "MONITOR Pending barrier tasks 1\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-1.822110e-04, 5.493866e-05]\n", - "HEAD \t grad after processing in range [-1.000000e+00, 3.014407e-01]\n", - "HEAD \t variable range before update [1.483947e+03, 1.520258e+03]\n", - "HEAD \t variable range after update [1.483234e+03, 1.526246e+03]\n", - "HEAD Done iteration 4 (out of 4), block 1 (out of 2) - Total loss_freq 1.428585e+01\n", - "HEAD ====================================================================\n", - "HEAD Starting iteration 1 (out of 4), block 2 (out of 2)\n", - "HEAD Giving shot 10 to worker:0:0\n", + "HEAD Giving shot 0 to worker:0:0\n", + "HEAD Giving shot 1 to worker:0:1\n", + "HEAD Shot 1 retrieved\n", + "HEAD Retrieved traces for shot 1\n", + "HEAD Giving shot 2 to worker:0:1\n", + "HEAD Shot 0 retrieved\n", + "HEAD Retrieved traces for shot 0\n", + "HEAD Giving shot 3 to worker:0:0\n", + "HEAD Shot 2 retrieved\n", + "HEAD Retrieved traces for shot 2\n", + "HEAD Giving shot 4 to worker:0:1\n", + "HEAD Shot 4 retrieved\n", + "HEAD Retrieved traces for shot 4\n", + "HEAD Giving shot 5 to worker:0:1\n", + "HEAD Shot 5 retrieved\n", + "HEAD Retrieved traces for shot 5\n", + "HEAD Giving shot 6 to worker:0:1\n", + "HEAD Shot 6 retrieved\n", + "HEAD Retrieved traces for shot 6\n", + "HEAD Giving shot 7 to worker:0:1\n", + "HEAD Shot 7 retrieved\n", + "HEAD Retrieved traces for shot 7\n", + "HEAD Giving shot 8 to worker:0:1\n", + "HEAD Shot 8 retrieved\n", + "HEAD Retrieved traces for shot 8\n", + "HEAD Giving shot 9 to worker:0:1\n", + "HEAD Shot 9 retrieved\n", + "HEAD Retrieved traces for shot 9\n", + "HEAD Giving shot 10 to worker:0:1\n", + "HEAD Shot 10 retrieved\n", + "HEAD Retrieved traces for shot 10\n", + "HEAD Giving shot 11 to worker:0:1\n", + "HEAD Shot 3 retrieved\n", + "HEAD Retrieved traces for shot 3\n", + "HEAD Giving shot 12 to worker:0:0\n", + "HEAD Shot 11 retrieved\n", + "HEAD Retrieved traces for shot 11\n", + "HEAD Giving shot 13 to worker:0:1\n", + "HEAD Shot 13 retrieved\n", + "HEAD Retrieved traces for shot 13\n", + "HEAD Giving shot 14 to worker:0:1\n", + "HEAD Shot 14 retrieved\n", + "HEAD Retrieved traces for shot 14\n", + "HEAD Giving shot 15 to worker:0:1\n", + "HEAD Shot 15 retrieved\n", + "HEAD Retrieved traces for shot 15\n", + "HEAD Giving shot 16 to worker:0:1\n", + "HEAD Shot 16 retrieved\n", + "HEAD Retrieved traces for shot 16\n", + "HEAD Giving shot 17 to worker:0:1\n", + "HEAD Shot 17 retrieved\n", + "HEAD Retrieved traces for shot 17\n", + "HEAD Giving shot 18 to worker:0:1\n", + "HEAD Shot 18 retrieved\n", + "HEAD Retrieved traces for shot 18\n", + "HEAD Giving shot 19 to worker:0:1\n", + "HEAD Shot 19 retrieved\n", + "HEAD Retrieved traces for shot 19\n", + "HEAD Giving shot 20 to worker:0:1\n", + "HEAD Shot 20 retrieved\n", + "HEAD Retrieved traces for shot 20\n", + "HEAD Giving shot 21 to worker:0:1\n", + "HEAD Shot 12 retrieved\n", + "HEAD Retrieved traces for shot 12\n", + "HEAD Giving shot 22 to worker:0:0\n", + "HEAD Shot 21 retrieved\n", + "HEAD Retrieved traces for shot 21\n", + "HEAD Giving shot 23 to worker:0:1\n", + "HEAD Shot 23 retrieved\n", + "HEAD Retrieved traces for shot 23\n", + "HEAD Giving shot 24 to worker:0:1\n", + "HEAD Shot 24 retrieved\n", + "HEAD Retrieved traces for shot 24\n", "HEAD Giving shot 25 to worker:0:1\n", - "WORKER:0:1 (ShotID 25) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 25) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 25) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 25) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 25) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 25) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 25) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 (ShotID 10) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 10) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 10) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 10) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 10) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 10) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 10) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 48.51 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.51 s [OI=2.82, 50.15 GFlops/s, 1.10 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.38 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 50.55 GFlops/s, 12.64 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 25) Completed state equation run for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.66 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 41.90 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.61 s [OI=2.82, 42.32 GFlops/s, 0.92 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 47.74 GFlops/s, 11.94 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 10) Completed state equation run for shot\n", - "HEAD Functional value for shot 25: loss 1.524191e+00 for shot 25\n", - "WORKER:0:1 (ShotID 25) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 25) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 10: loss 1.145241e+00 for shot 10\n", - "WORKER:0:0 (ShotID 10) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 10) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.64 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 42.22 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.54 s [OI=2.82, 47.29 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.06 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.26 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 25) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 25\n", + "HEAD Shot 25 retrieved\n", + "HEAD Retrieved traces for shot 25\n", + "HEAD Giving shot 26 to worker:0:1\n", + "HEAD Shot 26 retrieved\n", + "HEAD Retrieved traces for shot 26\n", + "HEAD Giving shot 27 to worker:0:1\n", + "HEAD Shot 27 retrieved\n", + "HEAD Retrieved traces for shot 27\n", + "HEAD Giving shot 28 to worker:0:1\n", + "HEAD Shot 28 retrieved\n", + "HEAD Retrieved traces for shot 28\n", + "HEAD Giving shot 29 to worker:0:1\n", + "HEAD Shot 29 retrieved\n", + "HEAD Retrieved traces for shot 29\n", + "HEAD Giving shot 30 to worker:0:1\n", + "HEAD Shot 22 retrieved\n", + "HEAD Retrieved traces for shot 22\n", + "HEAD Giving shot 31 to worker:0:0\n", + "HEAD Shot 30 retrieved\n", + "HEAD Retrieved traces for shot 30\n", + "HEAD Giving shot 32 to worker:0:1\n", + "HEAD Shot 32 retrieved\n", + "HEAD Retrieved traces for shot 32\n", + "HEAD Giving shot 33 to worker:0:1\n", + "HEAD Shot 33 retrieved\n", + "HEAD Retrieved traces for shot 33\n", + "HEAD Giving shot 34 to worker:0:1\n", + "HEAD Shot 34 retrieved\n", + "HEAD Retrieved traces for shot 34\n", + "HEAD Giving shot 35 to worker:0:1\n", + "HEAD Shot 35 retrieved\n", + "HEAD Retrieved traces for shot 35\n", + "HEAD Giving shot 36 to worker:0:1\n", + "HEAD Shot 36 retrieved\n", + "HEAD Retrieved traces for shot 36\n", + "HEAD Giving shot 37 to worker:0:1\n", + "HEAD Shot 37 retrieved\n", + "HEAD Retrieved traces for shot 37\n", + "HEAD Giving shot 38 to worker:0:1\n", + "HEAD Shot 31 retrieved\n", + "HEAD Retrieved traces for shot 31\n", + "HEAD Giving shot 39 to worker:0:0\n", + "HEAD Shot 38 retrieved\n", + "HEAD Retrieved traces for shot 38\n", + "HEAD Giving shot 40 to worker:0:1\n", + "HEAD Shot 40 retrieved\n", + "HEAD Retrieved traces for shot 40\n", "HEAD Giving shot 41 to worker:0:1\n", - "WORKER:0:1 (ShotID 41) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 41) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 41) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 41) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 41) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 41) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 41) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 40.33 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 44.68 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.58 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.05 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 10) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 10\n", - "HEAD Giving shot 43 to worker:0:0\n", - "WORKER:0:0 (ShotID 43) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 43) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 43) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 43) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 43) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 43) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 43) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.53 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 52.17 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.48 s [OI=2.82, 53.92 GFlops/s, 1.18 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.42 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 56.99 GFlops/s, 14.25 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 41) Completed state equation run for shot\n", - "HEAD Functional value for shot 41: loss 1.023631e+00 for shot 41\n", - "WORKER:0:1 (ShotID 41) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 41) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.65 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 42.54 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.28 GFlops/s, 0.95 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.21 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 46.36 GFlops/s, 11.59 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 43) Completed state equation run for shot\n", - "HEAD Functional value for shot 43: loss 1.113774e+00 for shot 43\n", - "WORKER:0:0 (ShotID 43) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 43) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.84 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 32.17 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.71 s [OI=2.82, 35.99 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.31 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.11 s [OI=0.25, 14.23 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 41) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 41\n", + "HEAD Shot 41 retrieved\n", + "HEAD Retrieved traces for shot 41\n", + "HEAD Giving shot 42 to worker:0:1\n", + "HEAD Shot 42 retrieved\n", + "HEAD Retrieved traces for shot 42\n", + "HEAD Giving shot 43 to worker:0:1\n", + "HEAD Shot 43 retrieved\n", + "HEAD Retrieved traces for shot 43\n", + "HEAD Giving shot 44 to worker:0:1\n", + "HEAD Shot 44 retrieved\n", + "HEAD Retrieved traces for shot 44\n", + "HEAD Giving shot 45 to worker:0:1\n", + "HEAD Shot 39 retrieved\n", + "HEAD Retrieved traces for shot 39\n", + "HEAD Giving shot 46 to worker:0:0\n", + "HEAD Shot 45 retrieved\n", + "HEAD Retrieved traces for shot 45\n", + "HEAD Giving shot 47 to worker:0:1\n", + "HEAD Shot 47 retrieved\n", + "HEAD Retrieved traces for shot 47\n", + "HEAD Giving shot 48 to worker:0:1\n", + "HEAD Shot 48 retrieved\n", + "HEAD Retrieved traces for shot 48\n", + "HEAD Giving shot 49 to worker:0:1\n", + "HEAD Shot 49 retrieved\n", + "HEAD Retrieved traces for shot 49\n", + "HEAD Giving shot 50 to worker:0:1\n", + "HEAD Shot 50 retrieved\n", + "HEAD Retrieved traces for shot 50\n", + "HEAD Giving shot 51 to worker:0:1\n", + "HEAD Shot 51 retrieved\n", + "HEAD Retrieved traces for shot 51\n", + "HEAD Giving shot 52 to worker:0:1\n", + "HEAD Shot 52 retrieved\n", + "HEAD Retrieved traces for shot 52\n", + "HEAD Giving shot 53 to worker:0:1\n", + "HEAD Shot 46 retrieved\n", + "HEAD Retrieved traces for shot 46\n", + "HEAD Giving shot 54 to worker:0:0\n", + "HEAD Shot 53 retrieved\n", + "HEAD Retrieved traces for shot 53\n", + "HEAD Giving shot 55 to worker:0:1\n", + "HEAD Shot 55 retrieved\n", + "HEAD Retrieved traces for shot 55\n", + "HEAD Giving shot 56 to worker:0:1\n", + "HEAD Shot 56 retrieved\n", + "HEAD Retrieved traces for shot 56\n", + "HEAD Giving shot 57 to worker:0:1\n", + "HEAD Shot 57 retrieved\n", + "HEAD Retrieved traces for shot 57\n", + "HEAD Giving shot 58 to worker:0:1\n", + "HEAD Shot 58 retrieved\n", + "HEAD Retrieved traces for shot 58\n", + "HEAD Giving shot 59 to worker:0:1\n", + "HEAD Shot 59 retrieved\n", + "HEAD Retrieved traces for shot 59\n", + "HEAD Giving shot 60 to worker:0:1\n", + "HEAD Shot 60 retrieved\n", + "HEAD Retrieved traces for shot 60\n", + "HEAD Giving shot 61 to worker:0:1\n", + "HEAD Shot 61 retrieved\n", + "HEAD Retrieved traces for shot 61\n", + "HEAD Giving shot 62 to worker:0:1\n", + "HEAD Shot 54 retrieved\n", + "HEAD Retrieved traces for shot 54\n", + "HEAD Giving shot 63 to worker:0:0\n", + "HEAD Shot 62 retrieved\n", + "HEAD Retrieved traces for shot 62\n", + "HEAD Giving shot 64 to worker:0:1\n", + "HEAD Shot 64 retrieved\n", + "HEAD Retrieved traces for shot 64\n", + "HEAD Giving shot 65 to worker:0:1\n", + "HEAD Shot 65 retrieved\n", + "HEAD Retrieved traces for shot 65\n", "HEAD Giving shot 66 to worker:0:1\n", - "WORKER:0:1 (ShotID 66) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 66) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 66) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 66) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 66) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 66) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 66) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.72 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 37.53 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.62 s [OI=2.82, 41.55 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.41 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 17.21 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 (ShotID 43) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 43\n", - "HEAD Giving shot 68 to worker:0:0\n", - "WORKER:0:0 (ShotID 68) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 68) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 68) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 68) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 68) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 68) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 68) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.55 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 50.27 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.50 s [OI=2.82, 51.36 GFlops/s, 1.12 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.23 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 56.70 GFlops/s, 14.18 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 66) Completed state equation run for shot\n", - "HEAD Functional value for shot 66: loss 8.543838e-01 for shot 66\n", - "WORKER:0:1 (ShotID 66) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 66) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.75 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 36.87 GFlops/s, 0.74 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.68 s [OI=2.82, 37.94 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.10 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.80 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.06 s [OI=0.50, 37.76 GFlops/s, 9.44 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 68) Completed state equation run for shot\n", - "HEAD Functional value for shot 68: loss 8.834987e-01 for shot 68\n", - "WORKER:0:0 (ShotID 68) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 68) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.73 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 37.02 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.62 s [OI=2.82, 41.28 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.32 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.71 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 66) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 66\n", - "HEAD Giving shot 75 to worker:0:1\n", - "WORKER:0:1 (ShotID 75) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 75) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 75) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 75) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 75) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 75) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 75) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 40.33 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 43.99 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.58 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.00 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 68) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 68\n", - "HEAD Giving shot 80 to worker:0:0\n", - "WORKER:0:0 (ShotID 80) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 80) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 80) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 80) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 80) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 80) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 80) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.61 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 45.33 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 45.85 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.15 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 52.53 GFlops/s, 13.14 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 75) Completed state equation run for shot\n", - "HEAD Functional value for shot 75: loss 1.301561e+00 for shot 75\n", - "WORKER:0:1 (ShotID 75) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 75) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.74 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 37.37 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.67 s [OI=2.82, 38.23 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.08 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.06 s [OI=0.50, 40.61 GFlops/s, 10.16 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 80) Completed state equation run for shot\n", - "HEAD Functional value for shot 80: loss 1.162087e+00 for shot 80\n", - "WORKER:0:0 (ShotID 80) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 80) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.76 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 35.55 GFlops/s, 0.73 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.66 s [OI=2.82, 38.97 GFlops/s, 0.85 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.28 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.09 s [OI=0.25, 18.43 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 75) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 75\n", - "HEAD Giving shot 83 to worker:0:1\n", - "WORKER:0:1 (ShotID 83) Preparing to run state for shot\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 (ShotID 83) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 83) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 83) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 83) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 83) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 83) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.63 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 42.89 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.54 s [OI=2.82, 47.83 GFlops/s, 1.04 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.80 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.82 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 80) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 80\n", - "HEAD Giving shot 84 to worker:0:0\n", - "WORKER:0:0 (ShotID 84) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 84) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 84) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 84) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 84) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 84) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 84) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.60 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 46.08 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 46.80 GFlops/s, 1.02 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.01 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 52.06 GFlops/s, 13.02 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 83) Completed state equation run for shot\n", - "HEAD Functional value for shot 83: loss 1.538268e+00 for shot 83\n", - "WORKER:0:1 (ShotID 83) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 83) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.63 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 43.89 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 44.79 GFlops/s, 0.98 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.17 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 48.64 GFlops/s, 12.16 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 84) Completed state equation run for shot\n", - "HEAD Functional value for shot 84: loss 1.589576e+00 for shot 84\n", - "WORKER:0:0 (ShotID 84) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 84) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.64 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 42.22 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 46.93 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.97 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.20 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 83) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 83\n", + "HEAD Shot 66 retrieved\n", + "HEAD Retrieved traces for shot 66\n", + "HEAD Giving shot 67 to worker:0:1\n", + "HEAD Shot 67 retrieved\n", + "HEAD Retrieved traces for shot 67\n", + "HEAD Giving shot 68 to worker:0:1\n", + "HEAD Shot 68 retrieved\n", + "HEAD Retrieved traces for shot 68\n", + "HEAD Giving shot 69 to worker:0:1\n", + "HEAD Shot 69 retrieved\n", + "HEAD Retrieved traces for shot 69\n", + "HEAD Giving shot 70 to worker:0:1\n", + "HEAD Shot 70 retrieved\n", + "HEAD Retrieved traces for shot 70\n", + "HEAD Giving shot 71 to worker:0:1\n", + "HEAD Shot 71 retrieved\n", + "HEAD Retrieved traces for shot 71\n", + "HEAD Giving shot 72 to worker:0:1\n", + "HEAD Shot 72 retrieved\n", + "HEAD Retrieved traces for shot 72\n", + "HEAD Giving shot 73 to worker:0:1\n", + "HEAD Shot 73 retrieved\n", + "HEAD Retrieved traces for shot 73\n", + "HEAD Giving shot 74 to worker:0:1\n", + "HEAD Shot 63 retrieved\n", + "HEAD Retrieved traces for shot 63\n", + "HEAD Giving shot 75 to worker:0:0\n", + "HEAD Shot 74 retrieved\n", + "HEAD Retrieved traces for shot 74\n", + "HEAD Giving shot 76 to worker:0:1\n", + "HEAD Shot 76 retrieved\n", + "HEAD Retrieved traces for shot 76\n", + "HEAD Giving shot 77 to worker:0:1\n", + "HEAD Shot 77 retrieved\n", + "HEAD Retrieved traces for shot 77\n", + "HEAD Giving shot 78 to worker:0:1\n", + "HEAD Shot 78 retrieved\n", + "HEAD Retrieved traces for shot 78\n", + "HEAD Giving shot 79 to worker:0:1\n", + "HEAD Shot 79 retrieved\n", + "HEAD Retrieved traces for shot 79\n", + "HEAD Giving shot 80 to worker:0:1\n", + "HEAD Shot 80 retrieved\n", + "HEAD Retrieved traces for shot 80\n", + "HEAD Giving shot 81 to worker:0:1\n", + "HEAD Shot 81 retrieved\n", + "HEAD Retrieved traces for shot 81\n", + "HEAD Giving shot 82 to worker:0:1\n", + "HEAD Shot 75 retrieved\n", + "HEAD Retrieved traces for shot 75\n", + "HEAD Giving shot 83 to worker:0:0\n", + "HEAD Shot 82 retrieved\n", + "HEAD Retrieved traces for shot 82\n", + "HEAD Giving shot 84 to worker:0:1\n", + "HEAD Shot 84 retrieved\n", + "HEAD Retrieved traces for shot 84\n", + "HEAD Giving shot 85 to worker:0:1\n", + "HEAD Shot 85 retrieved\n", + "HEAD Retrieved traces for shot 85\n", + "HEAD Giving shot 86 to worker:0:1\n", + "HEAD Shot 86 retrieved\n", + "HEAD Retrieved traces for shot 86\n", + "HEAD Giving shot 87 to worker:0:1\n", + "HEAD Shot 87 retrieved\n", + "HEAD Retrieved traces for shot 87\n", + "HEAD Giving shot 88 to worker:0:1\n", + "HEAD Shot 88 retrieved\n", + "HEAD Retrieved traces for shot 88\n", "HEAD Giving shot 89 to worker:0:1\n", - "WORKER:0:1 (ShotID 89) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 89) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 89) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 89) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 89) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 89) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 89) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.69 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 39.16 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.60 s [OI=2.82, 42.43 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.94 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.28 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 84) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 84\n", - "HEAD Giving shot 95 to worker:0:0\n", - "WORKER:0:0 (ShotID 95) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 95) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 95) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 95) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 95) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 95) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 95) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.63 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 43.89 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.38 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.98 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 51.98 GFlops/s, 13.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 89) Completed state equation run for shot\n", - "HEAD Functional value for shot 89: loss 9.939608e-01 for shot 89\n", - "WORKER:0:1 (ShotID 89) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 89) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 48.51 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.51 s [OI=2.82, 49.86 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.30 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 48.78 GFlops/s, 12.20 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n" + "HEAD Shot 89 retrieved\n", + "HEAD Retrieved traces for shot 89\n", + "HEAD Giving shot 90 to worker:0:1\n", + "HEAD Shot 90 retrieved\n", + "HEAD Retrieved traces for shot 90\n", + "HEAD Giving shot 91 to worker:0:1\n", + "HEAD Shot 83 retrieved\n", + "HEAD Retrieved traces for shot 83\n", + "HEAD Giving shot 92 to worker:0:0\n", + "HEAD Shot 91 retrieved\n", + "HEAD Retrieved traces for shot 91\n", + "HEAD Giving shot 93 to worker:0:1\n", + "HEAD Shot 93 retrieved\n", + "HEAD Retrieved traces for shot 93\n", + "HEAD Giving shot 94 to worker:0:1\n", + "HEAD Shot 94 retrieved\n", + "HEAD Retrieved traces for shot 94\n", + "HEAD Giving shot 95 to worker:0:1\n", + "HEAD Shot 95 retrieved\n", + "HEAD Retrieved traces for shot 95\n", + "HEAD Giving shot 96 to worker:0:1\n", + "HEAD Shot 96 retrieved\n", + "HEAD Retrieved traces for shot 96\n", + "HEAD Giving shot 97 to worker:0:1\n", + "HEAD Shot 97 retrieved\n", + "HEAD Retrieved traces for shot 97\n", + "HEAD Giving shot 98 to worker:0:1\n", + "HEAD Shot 98 retrieved\n", + "HEAD Retrieved traces for shot 98\n", + "HEAD Giving shot 99 to worker:0:1\n", + "HEAD Shot 99 retrieved\n", + "HEAD Retrieved traces for shot 99\n", + "HEAD Giving shot 100 to worker:0:1\n", + "HEAD Shot 100 retrieved\n", + "HEAD Retrieved traces for shot 100\n", + "HEAD Giving shot 101 to worker:0:1\n", + "HEAD Shot 92 retrieved\n", + "HEAD Retrieved traces for shot 92\n", + "HEAD Giving shot 102 to worker:0:0\n", + "HEAD Shot 101 retrieved\n", + "HEAD Retrieved traces for shot 101\n", + "HEAD Giving shot 103 to worker:0:1\n", + "HEAD Shot 103 retrieved\n", + "HEAD Retrieved traces for shot 103\n", + "HEAD Giving shot 104 to worker:0:1\n", + "HEAD Shot 104 retrieved\n", + "HEAD Retrieved traces for shot 104\n", + "HEAD Giving shot 105 to worker:0:1\n", + "HEAD Shot 105 retrieved\n", + "HEAD Retrieved traces for shot 105\n", + "HEAD Giving shot 106 to worker:0:1\n", + "HEAD Shot 106 retrieved\n", + "HEAD Retrieved traces for shot 106\n", + "HEAD Giving shot 107 to worker:0:1\n", + "HEAD Shot 107 retrieved\n", + "HEAD Retrieved traces for shot 107\n", + "HEAD Giving shot 108 to worker:0:1\n", + "HEAD Shot 108 retrieved\n", + "HEAD Retrieved traces for shot 108\n", + "HEAD Giving shot 109 to worker:0:1\n", + "HEAD Shot 109 retrieved\n", + "HEAD Retrieved traces for shot 109\n", + "HEAD Giving shot 110 to worker:0:1\n", + "HEAD Shot 110 retrieved\n", + "HEAD Retrieved traces for shot 110\n", + "HEAD Giving shot 111 to worker:0:1\n", + "HEAD Shot 111 retrieved\n", + "HEAD Retrieved traces for shot 111\n", + "HEAD Giving shot 112 to worker:0:1\n", + "HEAD Shot 102 retrieved\n", + "HEAD Retrieved traces for shot 102\n", + "HEAD Giving shot 113 to worker:0:0\n", + "HEAD Shot 112 retrieved\n", + "HEAD Retrieved traces for shot 112\n", + "HEAD Giving shot 114 to worker:0:1\n", + "HEAD Shot 114 retrieved\n", + "HEAD Retrieved traces for shot 114\n", + "HEAD Giving shot 115 to worker:0:1\n", + "HEAD Shot 115 retrieved\n", + "HEAD Retrieved traces for shot 115\n", + "HEAD Giving shot 116 to worker:0:1\n", + "HEAD Shot 116 retrieved\n", + "HEAD Retrieved traces for shot 116\n", + "HEAD Giving shot 117 to worker:0:1\n", + "HEAD Shot 117 retrieved\n", + "HEAD Retrieved traces for shot 117\n", + "HEAD Giving shot 118 to worker:0:1\n", + "HEAD Shot 118 retrieved\n", + "HEAD Retrieved traces for shot 118\n", + "HEAD Giving shot 119 to worker:0:1\n", + "HEAD Shot 119 retrieved\n", + "HEAD Retrieved traces for shot 119\n", + "HEAD Shot 113 retrieved\n", + "HEAD Retrieved traces for shot 113\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 (ShotID 95) Completed state equation run for shot\n", - "HEAD Functional value for shot 95: loss 1.142328e+00 for shot 95\n", - "WORKER:0:0 (ShotID 95) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 95) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 40.33 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.50 GFlops/s, 0.95 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.66 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 22.82 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 89) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 89\n", - "HEAD Giving shot 101 to worker:0:1\n", - "WORKER:0:1 (ShotID 101) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 101) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 101) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 101) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 101) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 101) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 101) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.69 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 39.16 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.60 s [OI=2.82, 42.49 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.44 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.73 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 95) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 95\n", - "HEAD Giving shot 103 to worker:0:0\n", - "WORKER:0:0 (ShotID 103) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 103) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 103) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 103) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 103) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 103) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 103) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.55 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 50.27 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.50 s [OI=2.82, 51.63 GFlops/s, 1.13 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.18 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 52.89 GFlops/s, 13.23 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 101) Completed state equation run for shot\n", - "HEAD Functional value for shot 101: loss 7.874326e-01 for shot 101\n", - "WORKER:0:1 (ShotID 101) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 101) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.82 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 33.72 GFlops/s, 0.68 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.74 s [OI=2.82, 34.44 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.93 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.07 s [OI=0.50, 33.49 GFlops/s, 8.38 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 103) Completed state equation run for shot\n", - "HEAD Functional value for shot 103: loss 8.601835e-01 for shot 103\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.66 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 40.94 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 46.06 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.74 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 16.76 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 101) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 101\n", - "HEAD Giving shot 112 to worker:0:1\n", - "WORKER:0:0 (ShotID 103) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 103) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 112) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 112) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 112) Spatial grid spacing (0.500 mm | 4.149 PPW) is higher than dispersion limit (0.415 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 112) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 112) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 112) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 112) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.85 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 31.79 GFlops/s, 0.66 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.73 s [OI=2.82, 35.02 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 3.84 GFlops/s, 0.07 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.10 s [OI=0.25, 15.30 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 103) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 103\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.72 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 38.40 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.65 s [OI=2.82, 39.13 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.91 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.06 s [OI=0.50, 40.58 GFlops/s, 10.15 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 112) Completed state equation run for shot\n", - "HEAD Functional value for shot 112: loss 9.090915e-01 for shot 112\n", - "WORKER:0:1 (ShotID 112) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 112) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.49 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 55.14 GFlops/s, 1.13 GPts/s]\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "05067a3d39d740728d1f61196aa716e5", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e8ca2e85134f4e0ab1aac812b6b81b9a", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get all remaining shot IDs\n", + "shot_ids = problem.acquisitions.remaining_shot_ids\n", + "\n", + "# Run an asynchronous loop across all shot IDs\n", + "@runtime.async_for(shot_ids)\n", + "async def loop(worker, shot_id):\n", + " runtime.logger.info('Giving shot %d to %s' % (shot_id, worker.uid))\n", + "\n", + " # Fetch one sub-problem corresponding to a shot ID\n", + " sub_problem = problem.sub_problem(shot_id)\n", + " \n", + " # Access the source wavelets of this shot\n", + " wavelets = sub_problem.shot.wavelets\n", + " \n", + " # Execute the PDE forward\n", + " traces = await pde(wavelets, vp_true,\n", + " problem=sub_problem,\n", + " runtime=worker).result()\n", + "\n", + " runtime.logger.info('Shot %d retrieved' % sub_problem.shot_id)\n", + "\n", + " # Store the retrieved traces into the shot\n", + " shot = problem.acquisitions.get(shot_id)\n", + " shot.observed.data[:] = traces.data\n", + "\n", + " runtime.logger.info('Retrieved traces for shot %d' % sub_problem.shot_id)\n", + "\n", + "# Because this is an asynchronous loop, it needs to be awaited \n", + "_ = await loop\n", + "\n", + "# Plot the result\n", + "_ = problem.acquisitions.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "continuing-portsmouth", + "metadata": {}, + "source": [ + "Because the loop we just ran is a very common piece of code, we can obtain the same result by running the utility function `forward()`:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "internal-ability", + "metadata": {}, + "outputs": [], + "source": [ + "from stride import forward\n", + "\n", + "# Run default forward workflow\n", + "# await forward(problem, pde, vp_true, dump=False) # uncomment to run using utility function" + ] + }, + { + "cell_type": "markdown", + "id": "vietnamese-favor", + "metadata": {}, + "source": [ + "## Starting model\n", + "\n", + "Before we can proceed with the imaging process, we need to determine a starting point for our inversion, a starting model." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "secret-metadata", + "metadata": {}, + "outputs": [], + "source": [ + "vp = ScalarField.parameter(name='vp', grid=grid, needs_grad=True)\n", + "vp.fill(1500.)\n", + "\n", + "problem.medium.add(vp)" + ] + }, + { + "cell_type": "markdown", + "id": "drawn-vietnam", + "metadata": {}, + "source": [ + "Unlike our forward example, the speed-of-sound field is unknown to us at this point. So, we define our starting guess for the speed of sound to be homogeneous with a value of 1500 m/s. Because we are going to run our inversion with respect to `vp`, we also define the field with `needs_grad=True`. That will instruct Stride to calculate the gradient of this variable when running the optimisation loop.\n", + "\n", + "You can also see that the field has now been instantiated using `parameter()`. This will turn `vp` into a remotely addressable object. What this means is that, as `vp` travels through our Mosaic network, it will always keep a reference to its original object here in our code. This will effectively allow us to accumulate the gradients calculated across different workers into a single local buffer.\n", + "\n", + "## Imaging operators\n", + "\n", + "Apart from our PDE operator, which we have already defined above, we will need to define an operator for our loss function:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "sophisticated-minute", + "metadata": {}, + "outputs": [], + "source": [ + "from stride import L2DistanceLoss \n", + "\n", + "loss = L2DistanceLoss.remote(len=runtime.num_workers)" + ] + }, + { + "cell_type": "markdown", + "id": "statistical-making", + "metadata": {}, + "source": [ + "We will also need some operators to proprocess the source wavelents and the modelled and observed data traces:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "departmental-apple", + "metadata": {}, + "outputs": [], + "source": [ + "from stride import ProcessWavelets, ProcessObserved, ProcessWaveletsObserved, ProcessTraces\n", + "\n", + "process_wavelets = ProcessWavelets.remote(len=runtime.num_workers)\n", + "process_observed = ProcessObserved.remote(len=runtime.num_workers)\n", + "process_wavelets_observed = ProcessWaveletsObserved.remote(len=runtime.num_workers)\n", + "process_traces = ProcessTraces.remote(len=runtime.num_workers)" + ] + }, + { + "cell_type": "markdown", + "id": "damaged-translation", + "metadata": {}, + "source": [ + "Finally, we will need an optimiser to update the speed of sound model after each iteration. In this case, we use gradient descent." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "timely-consideration", + "metadata": {}, + "outputs": [], + "source": [ + "from stride import GradientDescent, ProcessGlobalGradient, ProcessModelIteration\n", + "\n", + "step_size = 10\n", + "process_grad = ProcessGlobalGradient()\n", + "process_model = ProcessModelIteration(min=1400., max=1700.)\n", + "\n", + "optimiser = GradientDescent(vp, step_size=step_size,\n", + " process_grad=process_grad,\n", + " process_model=process_model)" + ] + }, + { + "cell_type": "markdown", + "id": "understanding-theorem", + "metadata": {}, + "source": [ + "You can see that we have also provided to the optimiser some pre-defined processing steps. These will be used to prepare the gradient before updating the variable, and to process the variable after the update. \n", + "\n", + "Among other things, these processing steps will normalise and smooth the gradient, and will clip the speed of sound of the updated model between 1400 m/s and 1700 m/s.\n", + "\n", + "## Inverse problem - Estimating speed of sound\n", + "\n", + "We can now proceed to solve the inverse problem, that is finding the speed of sound that explains the data that we have generated above.\n", + "\n", + "To obtain a better posed optimisation, we use a multi-scale approach. We will start our inversion by using only low frequencies to construct our model. As the inversion progresses, we will add higher frequencies until we reach the maximum desired level of detail.\n", + "\n", + "We can do this by dividing our optimisation in `Block`s and specifying a maximum frequency. Each `Block` will run for a number of specified iterations.\n", + "\n", + "During each iteration, only a subset of the shots will be used by defining the `select_shots` field. In this case, 15 shots will be used for each iteration, and they will be selected randomly without replacement." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "automotive-dayton", + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.44 s [OI=2.82, 59.07 GFlops/s, 1.29 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 6.13 GFlops/s, 0.11 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.05 s [OI=0.25, 33.22 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 112) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 112\n", - "MONITOR Pending barrier tasks 1\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-2.861954e-04, 2.358813e-04]\n", - "HEAD \t grad after processing in range [-1.000000e+00, 8.237627e-01]\n", - "HEAD \t variable range before update [1.483234e+03, 1.526246e+03]\n", - "HEAD \t variable range after update [1.478219e+03, 1.533828e+03]\n", - "HEAD Done iteration 1 (out of 4), block 2 (out of 2) - Total loss_freq 1.682921e+01\n", + "HEAD Starting iteration 1 (out of 4), block 1 (out of 2)\n", + "HEAD Giving shot 16 to worker:0:0\n", + "HEAD Giving shot 17 to worker:0:1\n", + "HEAD Functional value for shot 17: loss 2.008485e+00 for shot 17\n", + "HEAD Functional value for shot 16: loss 1.792513e+00 for shot 16\n", + "HEAD Retrieved gradient for shot 17\n", + "HEAD Giving shot 27 to worker:0:1\n", + "HEAD Functional value for shot 27: loss 2.335841e+00 for shot 27\n", + "HEAD Retrieved gradient for shot 27\n", + "HEAD Giving shot 40 to worker:0:1\n", + "HEAD Functional value for shot 40: loss 1.678519e+00 for shot 40\n", + "HEAD Retrieved gradient for shot 40\n", + "HEAD Giving shot 45 to worker:0:1\n", + "HEAD Functional value for shot 45: loss 1.577361e+00 for shot 45\n", + "HEAD Retrieved gradient for shot 45\n", + "HEAD Giving shot 61 to worker:0:1\n", + "HEAD Functional value for shot 61: loss 1.375144e+00 for shot 61\n", + "HEAD Retrieved gradient for shot 61\n", + "HEAD Giving shot 69 to worker:0:1\n", + "HEAD Retrieved gradient for shot 16\n", + "HEAD Giving shot 70 to worker:0:0\n", + "HEAD Functional value for shot 69: loss 1.638430e+00 for shot 69\n", + "HEAD Retrieved gradient for shot 69\n", + "HEAD Giving shot 71 to worker:0:1\n", + "HEAD Functional value for shot 71: loss 1.660910e+00 for shot 71\n", + "HEAD Retrieved gradient for shot 71\n", + "HEAD Giving shot 73 to worker:0:1\n", + "HEAD Functional value for shot 73: loss 1.770017e+00 for shot 73\n", + "HEAD Retrieved gradient for shot 73\n", + "HEAD Giving shot 83 to worker:0:1\n", + "HEAD Functional value for shot 70: loss 1.657740e+00 for shot 70\n", + "HEAD Functional value for shot 83: loss 2.230196e+00 for shot 83\n", + "HEAD Retrieved gradient for shot 83\n", + "HEAD Giving shot 90 to worker:0:1\n", + "HEAD Functional value for shot 90: loss 1.995775e+00 for shot 90\n", + "HEAD Retrieved gradient for shot 90\n", + "HEAD Giving shot 91 to worker:0:1\n", + "HEAD Functional value for shot 91: loss 1.725538e+00 for shot 91\n", + "HEAD Retrieved gradient for shot 91\n", + "HEAD Giving shot 102 to worker:0:1\n", + "HEAD Functional value for shot 102: loss 1.345104e+00 for shot 102\n", + "HEAD Retrieved gradient for shot 70\n", + "HEAD Giving shot 113 to worker:0:0\n", + "HEAD Retrieved gradient for shot 102\n", + "HEAD Functional value for shot 113: loss 1.522479e+00 for shot 113\n", + "HEAD Retrieved gradient for shot 113\n", + "HEAD Done iteration 1 (out of 4), block 1 (out of 2) - Total loss_freq 2.631405e+01\n", "HEAD ====================================================================\n", - "HEAD Starting iteration 2 (out of 4), block 2 (out of 2)\n", - "HEAD Giving shot 1 to worker:0:0\n", - "HEAD Giving shot 3 to worker:0:1\n", - "WORKER:0:0 (ShotID 1) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 1) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 1) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 1) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 1) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 1) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 1) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 3) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 3) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 3) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 3) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 3) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 3) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 3) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.69 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 40.07 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.62 s [OI=2.82, 41.52 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.88 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.06 s [OI=0.50, 38.88 GFlops/s, 9.72 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 3) Completed state equation run for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.82 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 33.72 GFlops/s, 0.68 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.74 s [OI=2.82, 34.47 GFlops/s, 0.75 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.78 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.07 s [OI=0.50, 33.23 GFlops/s, 8.31 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 1) Completed state equation run for shot\n", - "HEAD Functional value for shot 3: loss 9.337030e-01 for shot 3\n", - "WORKER:0:1 (ShotID 3) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 3) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 1: loss 1.329823e+00 for shot 1\n", - "WORKER:0:0 (ShotID 1) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 1) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.59 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 45.80 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.50 s [OI=2.82, 50.97 GFlops/s, 1.11 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.33 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.19 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 3) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 3\n", + "HEAD Starting iteration 2 (out of 4), block 1 (out of 2)\n", + "HEAD Giving shot 13 to worker:0:0\n", "HEAD Giving shot 14 to worker:0:1\n", - "WORKER:0:1 (ShotID 14) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 14) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 14) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 14) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 14) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 14) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 14) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.70 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 38.60 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.61 s [OI=2.82, 42.34 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.45 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.51 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 1) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 1\n", - "HEAD Giving shot 21 to worker:0:0\n", - "WORKER:0:0 (ShotID 21) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 21) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 21) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 21) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 21) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 21) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 21) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.65 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 42.54 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.60 s [OI=2.82, 42.75 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.20 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 52.46 GFlops/s, 13.12 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 14) Completed state equation run for shot\n", - "HEAD Functional value for shot 14: loss 1.397958e+00 for shot 14\n", - "WORKER:0:1 (ShotID 14) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 14) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.67 s\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 Global performance: [OI=2.06, 41.27 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.61 s [OI=2.82, 41.68 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.11 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.99 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 49.92 GFlops/s, 12.48 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 21) Completed state equation run for shot\n", - "HEAD Functional value for shot 21: loss 1.523751e+00 for shot 21\n", - "WORKER:0:0 (ShotID 21) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 21) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.71 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 38.06 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.62 s [OI=2.82, 41.29 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.03 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.61 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 14) Completed adjoint equation run for shot\n", + "HEAD Functional value for shot 14: loss 1.302665e+00 for shot 14\n", "HEAD Retrieved gradient for shot 14\n", - "HEAD Giving shot 22 to worker:0:1\n", - "WORKER:0:1 (ShotID 22) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 22) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 22) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 22) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 22) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 22) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 22) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.66 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 40.94 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.57 s [OI=2.82, 45.17 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.99 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.15 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 21) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 21\n", - "HEAD Giving shot 33 to worker:0:0\n", - "WORKER:0:0 (ShotID 33) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 33) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 33) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 33) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 33) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 33) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 33) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.65 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 42.54 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.16 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.36 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.06 s [OI=0.50, 44.11 GFlops/s, 11.03 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 22) Completed state equation run for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.58 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 47.67 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.52 s [OI=2.82, 49.18 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.29 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 51.07 GFlops/s, 12.77 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 33) Completed state equation run for shot\n", - "HEAD Functional value for shot 22: loss 1.625440e+00 for shot 22\n", - "WORKER:0:1 (ShotID 22) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 22) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 33: loss 1.652942e+00 for shot 33\n", - "WORKER:0:0 (ShotID 33) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 33) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.63 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 42.89 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.54 s [OI=2.82, 47.77 GFlops/s, 1.04 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.12 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.12 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 22) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 22\n", - "HEAD Giving shot 47 to worker:0:1\n", - "WORKER:0:1 (ShotID 47) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 47) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 47) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 47) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 47) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 47) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 47) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.69 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 39.16 GFlops/s, 0.81 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.13 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.48 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.41 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 33) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 33\n", - "HEAD Giving shot 49 to worker:0:0\n", - "WORKER:0:0 (ShotID 49) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 49) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 49) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 49) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 49) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 49) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 49) Running state equation for shot\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.65 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 42.54 GFlops/s, 0.86 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.56 GFlops/s, 0.95 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.33 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 47.89 GFlops/s, 11.98 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 47) Completed state equation run for shot\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.61 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 45.33 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 45.89 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.18 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 53.22 GFlops/s, 13.31 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 49) Completed state equation run for shot\n", - "HEAD Functional value for shot 47: loss 1.441496e+00 for shot 47\n", - "WORKER:0:1 (ShotID 47) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 47) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "HEAD Functional value for shot 49: loss 1.456686e+00 for shot 49\n", - "WORKER:0:0 (ShotID 49) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 49) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.53 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 50.98 GFlops/s, 1.05 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.46 s [OI=2.82, 55.86 GFlops/s, 1.22 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.62 GFlops/s, 0.10 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.06 s [OI=0.25, 26.11 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 47) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 47\n", - "HEAD Giving shot 50 to worker:0:1\n", - "WORKER:0:1 (ShotID 50) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 50) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 50) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 50) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 50) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 50) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 50) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 40.33 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 43.96 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.63 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.37 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 49) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 49\n", - "HEAD Giving shot 67 to worker:0:0\n", - "WORKER:0:0 (ShotID 67) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 67) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 67) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 67) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 67) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 67) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 67) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.60 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 46.08 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.55 s [OI=2.82, 46.94 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.20 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 54.02 GFlops/s, 13.51 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 50) Completed state equation run for shot\n", - "HEAD Functional value for shot 50: loss 1.436214e+00 for shot 50\n", - "WORKER:0:1 (ShotID 50) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 50) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.61 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 45.33 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 46.20 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.23 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 54.80 GFlops/s, 13.70 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 67) Completed state equation run for shot\n", - "HEAD Functional value for shot 67: loss 1.186245e+00 for shot 67\n", - "WORKER:0:0 (ShotID 67) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 67) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.71 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 38.06 GFlops/s, 0.78 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.62 s [OI=2.82, 41.10 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.61 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 21.86 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 50) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 50\n", - "HEAD Giving shot 82 to worker:0:1\n", - "WORKER:0:1 (ShotID 82) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 82) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 82) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 82) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 82) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 82) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 82) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.69 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 39.16 GFlops/s, 0.81 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.61 s [OI=2.82, 42.08 GFlops/s, 0.92 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.55 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 22.47 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 67) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 67\n", - "HEAD Giving shot 91 to worker:0:0\n", - "WORKER:0:0 (ShotID 91) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 91) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 91) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 91) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 91) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 91) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 91) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.59 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 46.87 GFlops/s, 0.94 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.54 s [OI=2.82, 47.52 GFlops/s, 1.04 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.12 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 56.03 GFlops/s, 14.01 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 82) Completed state equation run for shot\n", - "HEAD Functional value for shot 82: loss 1.656813e+00 for shot 82\n", - "WORKER:0:1 (ShotID 82) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 82) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 44.60 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 45.61 GFlops/s, 1.00 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.21 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 47.76 GFlops/s, 11.94 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 91) Completed state equation run for shot\n", - "HEAD Functional value for shot 91: loss 1.287086e+00 for shot 91\n", - "WORKER:0:0 (ShotID 91) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 91) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.61 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 44.30 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.53 s [OI=2.82, 48.37 GFlops/s, 1.06 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.97 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.07 s [OI=0.25, 22.33 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 82) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 82\n", + "HEAD Giving shot 23 to worker:0:1\n", + "HEAD Functional value for shot 23: loss 1.799923e+00 for shot 23\n", + "HEAD Retrieved gradient for shot 23\n", + "HEAD Giving shot 26 to worker:0:1\n", + "HEAD Functional value for shot 26: loss 1.852457e+00 for shot 26\n", + "HEAD Retrieved gradient for shot 26\n", + "HEAD Giving shot 35 to worker:0:1\n", + "HEAD Functional value for shot 35: loss 1.955671e+00 for shot 35\n", + "HEAD Functional value for shot 13: loss 1.373600e+00 for shot 13\n", + "HEAD Retrieved gradient for shot 35\n", + "HEAD Giving shot 48 to worker:0:1\n", + "HEAD Functional value for shot 48: loss 9.249851e-01 for shot 48\n", + "HEAD Retrieved gradient for shot 48\n", + "HEAD Giving shot 58 to worker:0:1\n", + "HEAD Functional value for shot 58: loss 1.092716e+00 for shot 58\n", + "HEAD Retrieved gradient for shot 58\n", + "HEAD Giving shot 74 to worker:0:1\n", + "HEAD Functional value for shot 74: loss 1.233636e+00 for shot 74\n", + "HEAD Retrieved gradient for shot 13\n", + "HEAD Giving shot 84 to worker:0:0\n", + "HEAD Retrieved gradient for shot 74\n", + "HEAD Giving shot 97 to worker:0:1\n", + "HEAD Functional value for shot 97: loss 1.200127e+00 for shot 97\n", + "HEAD Retrieved gradient for shot 97\n", + "HEAD Giving shot 100 to worker:0:1\n", + "HEAD Functional value for shot 100: loss 1.053366e+00 for shot 100\n", + "HEAD Retrieved gradient for shot 100\n", + "HEAD Giving shot 105 to worker:0:1\n", + "HEAD Functional value for shot 105: loss 1.199744e+00 for shot 105\n", + "HEAD Retrieved gradient for shot 105\n", + "HEAD Giving shot 106 to worker:0:1\n", + "HEAD Functional value for shot 106: loss 1.124721e+00 for shot 106\n", + "HEAD Functional value for shot 84: loss 1.726474e+00 for shot 84\n", + "HEAD Retrieved gradient for shot 106\n", + "HEAD Giving shot 115 to worker:0:1\n", + "HEAD Functional value for shot 115: loss 1.297943e+00 for shot 115\n", + "HEAD Retrieved gradient for shot 115\n", + "HEAD Giving shot 116 to worker:0:1\n", + "HEAD Functional value for shot 116: loss 1.253540e+00 for shot 116\n", + "HEAD Retrieved gradient for shot 116\n", + "HEAD Retrieved gradient for shot 84\n", + "HEAD Done iteration 2 (out of 4), block 1 (out of 2) - Total loss_freq 2.039157e+01\n", + "HEAD ====================================================================\n", + "HEAD Starting iteration 3 (out of 4), block 1 (out of 2)\n", + "HEAD Giving shot 1 to worker:0:0\n", + "HEAD Giving shot 10 to worker:0:1\n", + "HEAD Functional value for shot 10: loss 1.192814e+00 for shot 10\n", + "HEAD Retrieved gradient for shot 10\n", + "HEAD Giving shot 25 to worker:0:1\n", + "HEAD Functional value for shot 25: loss 1.497280e+00 for shot 25\n", + "HEAD Retrieved gradient for shot 25\n", + "HEAD Giving shot 30 to worker:0:1\n", + "HEAD Functional value for shot 30: loss 1.742769e+00 for shot 30\n", + "HEAD Retrieved gradient for shot 30\n", + "HEAD Giving shot 51 to worker:0:1\n", + "HEAD Functional value for shot 51: loss 9.617972e-01 for shot 51\n", + "HEAD Retrieved gradient for shot 51\n", + "HEAD Giving shot 53 to worker:0:1\n", + "HEAD Functional value for shot 1: loss 1.089886e+00 for shot 1\n", + "HEAD Functional value for shot 53: loss 9.857967e-01 for shot 53\n", + "HEAD Retrieved gradient for shot 53\n", + "HEAD Giving shot 57 to worker:0:1\n", + "HEAD Functional value for shot 57: loss 7.078637e-01 for shot 57\n", + "HEAD Retrieved gradient for shot 57\n", + "HEAD Giving shot 59 to worker:0:1\n", + "HEAD Functional value for shot 59: loss 9.039650e-01 for shot 59\n", + "HEAD Retrieved gradient for shot 1\n", + "HEAD Giving shot 88 to worker:0:0\n", + "HEAD Retrieved gradient for shot 59\n", + "HEAD Giving shot 92 to worker:0:1\n", + "HEAD Functional value for shot 92: loss 1.194708e+00 for shot 92\n", + "HEAD Retrieved gradient for shot 92\n", + "HEAD Giving shot 94 to worker:0:1\n", + "HEAD Functional value for shot 94: loss 1.151145e+00 for shot 94\n", + "HEAD Retrieved gradient for shot 94\n", + "HEAD Giving shot 98 to worker:0:1\n", + "HEAD Functional value for shot 98: loss 1.050555e+00 for shot 98\n", + "HEAD Retrieved gradient for shot 98\n", + "HEAD Giving shot 109 to worker:0:1\n", + "HEAD Functional value for shot 109: loss 1.015291e+00 for shot 109\n", + "HEAD Functional value for shot 88: loss 1.292400e+00 for shot 88\n", + "HEAD Retrieved gradient for shot 109\n", + "HEAD Giving shot 110 to worker:0:1\n", + "HEAD Functional value for shot 110: loss 1.055282e+00 for shot 110\n", + "HEAD Retrieved gradient for shot 110\n", + "HEAD Giving shot 112 to worker:0:1\n", + "HEAD Functional value for shot 112: loss 9.233050e-01 for shot 112\n", + "HEAD Retrieved gradient for shot 112\n", + "HEAD Retrieved gradient for shot 88\n", + "HEAD Done iteration 3 (out of 4), block 1 (out of 2) - Total loss_freq 1.676486e+01\n", + "HEAD ====================================================================\n", + "HEAD Starting iteration 4 (out of 4), block 1 (out of 2)\n", + "HEAD Giving shot 7 to worker:0:0\n", + "HEAD Giving shot 15 to worker:0:1\n", + "HEAD Functional value for shot 15: loss 9.959779e-01 for shot 15\n", + "HEAD Retrieved gradient for shot 15\n", + "HEAD Giving shot 20 to worker:0:1\n", + "HEAD Functional value for shot 20: loss 1.072309e+00 for shot 20\n", + "HEAD Retrieved gradient for shot 20\n", + "HEAD Giving shot 22 to worker:0:1\n", + "HEAD Functional value for shot 22: loss 1.319239e+00 for shot 22\n", + "HEAD Retrieved gradient for shot 22\n", + "HEAD Giving shot 28 to worker:0:1\n", + "HEAD Functional value for shot 28: loss 1.363289e+00 for shot 28\n", + "HEAD Functional value for shot 7: loss 9.282386e-01 for shot 7\n", + "HEAD Retrieved gradient for shot 28\n", + "HEAD Giving shot 62 to worker:0:1\n", + "HEAD Functional value for shot 62: loss 7.194777e-01 for shot 62\n", + "HEAD Retrieved gradient for shot 62\n", + "HEAD Giving shot 77 to worker:0:1\n", + "HEAD Functional value for shot 77: loss 9.600102e-01 for shot 77\n", + "HEAD Retrieved gradient for shot 77\n", + "HEAD Giving shot 79 to worker:0:1\n", + "HEAD Functional value for shot 79: loss 8.640406e-01 for shot 79\n", + "HEAD Retrieved gradient for shot 7\n", + "HEAD Giving shot 80 to worker:0:0\n", + "HEAD Retrieved gradient for shot 79\n", + "HEAD Giving shot 81 to worker:0:1\n", + "HEAD Functional value for shot 81: loss 1.240638e+00 for shot 81\n", + "HEAD Retrieved gradient for shot 81\n", + "HEAD Giving shot 89 to worker:0:1\n", + "HEAD Functional value for shot 89: loss 9.015474e-01 for shot 89\n", + "HEAD Retrieved gradient for shot 89\n", + "HEAD Giving shot 93 to worker:0:1\n", + "HEAD Functional value for shot 93: loss 9.438744e-01 for shot 93\n", + "HEAD Functional value for shot 80: loss 1.003544e+00 for shot 80\n", + "HEAD Retrieved gradient for shot 93\n", "HEAD Giving shot 99 to worker:0:1\n", - "WORKER:0:1 (ShotID 99) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 99) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 99) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 99) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 99) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 99) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 99) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.70 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 38.60 GFlops/s, 0.79 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.61 s [OI=2.82, 41.78 GFlops/s, 0.91 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.41 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.28 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 91) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 91\n", - "HEAD Giving shot 113 to worker:0:0\n", - "WORKER:0:0 (ShotID 113) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 113) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 113) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 113) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:0 (ShotID 113) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 113) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 113) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.57 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 48.51 GFlops/s, 0.97 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.52 s [OI=2.82, 49.39 GFlops/s, 1.08 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.15 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 53.18 GFlops/s, 13.30 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 99) Completed state equation run for shot\n", - "HEAD Functional value for shot 99: loss 1.295979e+00 for shot 99\n", - "WORKER:0:1 (ShotID 99) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 99) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.52 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 53.17 GFlops/s, 1.07 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.47 s [OI=2.82, 55.10 GFlops/s, 1.20 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.23 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 58.67 GFlops/s, 14.67 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 113) Completed state equation run for shot\n", - "HEAD Functional value for shot 113: loss 1.215057e+00 for shot 113\n", - "WORKER:0:0 (ShotID 113) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 113) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 40.33 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.04 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.86 GFlops/s, 0.09 GPts/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.17 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 99) Completed adjoint equation run for shot\n", + "HEAD Functional value for shot 99: loss 8.847746e-01 for shot 99\n", "HEAD Retrieved gradient for shot 99\n", + "HEAD Giving shot 103 to worker:0:1\n", + "HEAD Functional value for shot 103: loss 7.527244e-01 for shot 103\n", + "HEAD Retrieved gradient for shot 103\n", + "HEAD Giving shot 117 to worker:0:1\n", + "HEAD Functional value for shot 117: loss 6.467879e-01 for shot 117\n", + "HEAD Retrieved gradient for shot 117\n", + "HEAD Retrieved gradient for shot 80\n", + "HEAD Done iteration 4 (out of 4), block 1 (out of 2) - Total loss_freq 1.459647e+01\n", + "HEAD ====================================================================\n", + "HEAD Starting iteration 1 (out of 4), block 2 (out of 2)\n", + "HEAD Giving shot 2 to worker:0:0\n", + "HEAD Giving shot 3 to worker:0:1\n", + "HEAD Functional value for shot 3: loss 7.558197e-01 for shot 3\n", + "HEAD Retrieved gradient for shot 3\n", + "HEAD Giving shot 6 to worker:0:1\n", + "HEAD Functional value for shot 6: loss 1.025622e+00 for shot 6\n", + "HEAD Retrieved gradient for shot 6\n", + "HEAD Giving shot 9 to worker:0:1\n", + "HEAD Functional value for shot 9: loss 1.076054e+00 for shot 9\n", + "HEAD Retrieved gradient for shot 9\n", + "HEAD Giving shot 31 to worker:0:1\n", + "HEAD Functional value for shot 31: loss 1.515861e+00 for shot 31\n", + "HEAD Retrieved gradient for shot 31\n", + "HEAD Giving shot 41 to worker:0:1\n", + "HEAD Functional value for shot 41: loss 9.670873e-01 for shot 41\n", + "HEAD Retrieved gradient for shot 41\n", + "HEAD Giving shot 42 to worker:0:1\n", + "HEAD Functional value for shot 2: loss 9.920448e-01 for shot 2\n", + "HEAD Functional value for shot 42: loss 9.719697e-01 for shot 42\n", + "HEAD Retrieved gradient for shot 42\n", + "HEAD Giving shot 43 to worker:0:1\n", + "HEAD Functional value for shot 43: loss 1.018190e+00 for shot 43\n", + "HEAD Retrieved gradient for shot 43\n", + "HEAD Giving shot 52 to worker:0:1\n", + "HEAD Functional value for shot 52: loss 8.038019e-01 for shot 52\n", + "HEAD Retrieved gradient for shot 52\n", + "HEAD Giving shot 55 to worker:0:1\n", + "HEAD Functional value for shot 55: loss 1.013667e+00 for shot 55\n", + "HEAD Retrieved gradient for shot 55\n", + "HEAD Giving shot 60 to worker:0:1\n", + "HEAD Functional value for shot 60: loss 5.470030e-01 for shot 60\n", + "HEAD Retrieved gradient for shot 2\n", + "HEAD Giving shot 78 to worker:0:0\n", + "HEAD Retrieved gradient for shot 60\n", + "HEAD Giving shot 82 to worker:0:1\n", + "HEAD Functional value for shot 82: loss 1.623824e+00 for shot 82\n", + "HEAD Retrieved gradient for shot 82\n", + "HEAD Giving shot 87 to worker:0:1\n", + "HEAD Functional value for shot 87: loss 1.269356e+00 for shot 87\n", + "HEAD Retrieved gradient for shot 87\n", + "HEAD Giving shot 107 to worker:0:1\n", + "HEAD Functional value for shot 107: loss 8.909570e-01 for shot 107\n", + "HEAD Retrieved gradient for shot 107\n", + "HEAD Functional value for shot 78: loss 9.574547e-01 for shot 78\n", + "HEAD Retrieved gradient for shot 78\n", + "HEAD Done iteration 1 (out of 4), block 2 (out of 2) - Total loss_freq 1.542871e+01\n", + "HEAD ====================================================================\n", + "HEAD Starting iteration 2 (out of 4), block 2 (out of 2)\n", + "HEAD Giving shot 5 to worker:0:0\n", + "HEAD Giving shot 11 to worker:0:1\n", + "HEAD Functional value for shot 11: loss 1.030801e+00 for shot 11\n", + "HEAD Retrieved gradient for shot 11\n", + "HEAD Giving shot 29 to worker:0:1\n", + "HEAD Functional value for shot 29: loss 1.228628e+00 for shot 29\n", + "HEAD Retrieved gradient for shot 29\n", + "HEAD Giving shot 33 to worker:0:1\n", + "HEAD Functional value for shot 33: loss 1.450502e+00 for shot 33\n", + "HEAD Retrieved gradient for shot 33\n", + "HEAD Giving shot 34 to worker:0:1\n", + "HEAD Functional value for shot 5: loss 9.146921e-01 for shot 5\n", + "HEAD Functional value for shot 34: loss 1.506798e+00 for shot 34\n", + "HEAD Retrieved gradient for shot 34\n", + "HEAD Giving shot 44 to worker:0:1\n", + "HEAD Functional value for shot 44: loss 7.956617e-01 for shot 44\n", + "HEAD Retrieved gradient for shot 44\n", + "HEAD Giving shot 47 to worker:0:1\n", + "HEAD Retrieved gradient for shot 5\n", + "HEAD Giving shot 49 to worker:0:0\n", + "HEAD Functional value for shot 47: loss 9.335254e-01 for shot 47\n", + "HEAD Retrieved gradient for shot 47\n", + "HEAD Giving shot 63 to worker:0:1\n", + "HEAD Functional value for shot 63: loss 5.334662e-01 for shot 63\n", + "HEAD Retrieved gradient for shot 63\n", + "HEAD Giving shot 65 to worker:0:1\n", + "HEAD Functional value for shot 65: loss 9.077389e-01 for shot 65\n", + "HEAD Retrieved gradient for shot 65\n", + "HEAD Giving shot 72 to worker:0:1\n", + "HEAD Functional value for shot 72: loss 8.337521e-01 for shot 72\n", + "HEAD Functional value for shot 49: loss 8.743588e-01 for shot 49\n", + "HEAD Retrieved gradient for shot 72\n", + "HEAD Giving shot 96 to worker:0:1\n", + "HEAD Functional value for shot 96: loss 9.939452e-01 for shot 96\n", + "HEAD Retrieved gradient for shot 96\n", + "HEAD Giving shot 108 to worker:0:1\n", + "HEAD Functional value for shot 108: loss 6.731066e-01 for shot 108\n", + "HEAD Retrieved gradient for shot 108\n", "HEAD Giving shot 114 to worker:0:1\n", - "WORKER:0:1 (ShotID 114) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 114) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 114) Spatial grid spacing (0.500 mm | 4.135 PPW) is higher than dispersion limit (0.413 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 114) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.147 μs)\n", - "WORKER:0:1 (ShotID 114) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 114) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 114) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.68 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 39.74 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.59 s [OI=2.82, 43.78 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.54 GFlops/s, 0.08 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.49 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 113) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 113\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.54 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 51.20 GFlops/s, 1.03 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.49 s [OI=2.82, 52.47 GFlops/s, 1.15 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.28 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.04 s [OI=0.50, 59.67 GFlops/s, 14.92 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 114) Completed state equation run for shot\n", - "HEAD Functional value for shot 114: loss 1.237048e+00 for shot 114\n", - "WORKER:0:1 (ShotID 114) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 114) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.47 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 57.49 GFlops/s, 1.18 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.42 s [OI=2.82, 61.50 GFlops/s, 1.34 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 6.35 GFlops/s, 0.11 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.04 s [OI=0.25, 41.20 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 114) Completed adjoint equation run for shot\n", + "HEAD Functional value for shot 114: loss 8.088626e-01 for shot 114\n", "HEAD Retrieved gradient for shot 114\n", - "MONITOR Pending barrier tasks 1\n", - "HEAD Updating variable vp,\n", - "HEAD \t grad before processing in range [-7.065401e-04, 1.791294e-04]\n", - "HEAD \t grad after processing in range [-1.000000e+00, 2.535367e-01]\n", - "HEAD \t variable range before update [1.478219e+03, 1.533828e+03]\n", - "HEAD \t variable range after update [1.479618e+03, 1.538667e+03]\n", - "HEAD Done iteration 2 (out of 4), block 2 (out of 2) - Total loss_freq 2.067624e+01\n", + "HEAD Giving shot 118 to worker:0:1\n", + "HEAD Functional value for shot 118: loss 8.542686e-01 for shot 118\n", + "HEAD Retrieved gradient for shot 118\n", + "HEAD Retrieved gradient for shot 49\n", + "HEAD Done iteration 2 (out of 4), block 2 (out of 2) - Total loss_freq 1.434011e+01\n", "HEAD ====================================================================\n", "HEAD Starting iteration 3 (out of 4), block 2 (out of 2)\n", "HEAD Giving shot 0 to worker:0:0\n", - "HEAD Giving shot 9 to worker:0:1\n", - "WORKER:0:0 (ShotID 0) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 0) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 0) Spatial grid spacing (0.500 mm | 4.139 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 0) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 0) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 0) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 0) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 9) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 9) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 9) Spatial grid spacing (0.500 mm | 4.139 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 9) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 9) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 9) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 9) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.62 s\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.64 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 44.60 GFlops/s, 0.90 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.56 s [OI=2.82, 45.42 GFlops/s, 0.99 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.14 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.45 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 46.70 GFlops/s, 11.68 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 9) Completed state equation run for shot\n", - "WORKER:0:0 Global performance: [OI=2.06, 43.20 GFlops/s, 0.87 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 43.92 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.30 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 46.05 GFlops/s, 11.52 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 0) Completed state equation run for shot\n", - "HEAD Functional value for shot 9: loss 7.956193e-01 for shot 9\n", - "HEAD Functional value for shot 0: loss 9.473675e-01 for shot 0\n", - "WORKER:0:0 (ShotID 0) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 9) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 0) Running adjoint equation for shot\n", - "WORKER:0:1 (ShotID 9) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.67 s\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.68 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 40.33 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:0 Global performance: [OI=1.79, 39.74 GFlops/s, 0.82 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 43.89 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.58 s [OI=2.82, 44.01 GFlops/s, 0.96 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 5.23 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.94 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.86 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 19.43 GFlops/s, 0.00 GPts/s]\n" + "HEAD Giving shot 4 to worker:0:1\n", + "HEAD Functional value for shot 4: loss 8.293226e-01 for shot 4\n", + "HEAD Retrieved gradient for shot 4\n", + "HEAD Giving shot 8 to worker:0:1\n", + "HEAD Functional value for shot 8: loss 7.360731e-01 for shot 8\n", + "HEAD Retrieved gradient for shot 8\n", + "HEAD Giving shot 18 to worker:0:1\n", + "HEAD Functional value for shot 18: loss 8.943943e-01 for shot 18\n", + "HEAD Retrieved gradient for shot 18\n", + "HEAD Giving shot 19 to worker:0:1\n", + "HEAD Functional value for shot 0: loss 5.655379e-01 for shot 0\n", + "HEAD Functional value for shot 19: loss 8.734545e-01 for shot 19\n", + "HEAD Retrieved gradient for shot 19\n", + "HEAD Giving shot 21 to worker:0:1\n", + "HEAD Functional value for shot 21: loss 1.147754e+00 for shot 21\n", + "HEAD Retrieved gradient for shot 21\n", + "HEAD Giving shot 24 to worker:0:1\n", + "HEAD Functional value for shot 24: loss 1.338102e+00 for shot 24\n", + "HEAD Retrieved gradient for shot 24\n", + "HEAD Giving shot 38 to worker:0:1\n", + "HEAD Functional value for shot 38: loss 1.352444e+00 for shot 38\n", + "HEAD Retrieved gradient for shot 38\n", + "HEAD Giving shot 54 to worker:0:1\n", + "HEAD Functional value for shot 54: loss 7.585951e-01 for shot 54\n", + "HEAD Retrieved gradient for shot 54\n", + "HEAD Giving shot 56 to worker:0:1\n", + "HEAD Functional value for shot 56: loss 7.968095e-01 for shot 56\n", + "HEAD Retrieved gradient for shot 56\n", + "HEAD Giving shot 64 to worker:0:1\n", + "HEAD Retrieved gradient for shot 0\n", + "HEAD Giving shot 68 to worker:0:0\n", + "HEAD Functional value for shot 64: loss 7.274514e-01 for shot 64\n", + "HEAD Retrieved gradient for shot 64\n", + "HEAD Giving shot 85 to worker:0:1\n", + "HEAD Functional value for shot 85: loss 1.272877e+00 for shot 85\n", + "HEAD Retrieved gradient for shot 85\n", + "HEAD Giving shot 104 to worker:0:1\n", + "HEAD Functional value for shot 104: loss 6.462344e-01 for shot 104\n", + "HEAD Retrieved gradient for shot 104\n", + "HEAD Giving shot 119 to worker:0:1\n", + "HEAD Functional value for shot 119: loss 8.429440e-01 for shot 119\n", + "HEAD Retrieved gradient for shot 119\n", + "HEAD Functional value for shot 68: loss 7.852683e-01 for shot 68\n", + "HEAD Retrieved gradient for shot 68\n", + "HEAD Done iteration 3 (out of 4), block 2 (out of 2) - Total loss_freq 1.356726e+01\n", + "HEAD ====================================================================\n", + "HEAD Starting iteration 4 (out of 4), block 2 (out of 2)\n", + "HEAD Giving shot 12 to worker:0:0\n", + "HEAD Giving shot 32 to worker:0:1\n", + "HEAD Functional value for shot 32: loss 1.344790e+00 for shot 32\n", + "HEAD Retrieved gradient for shot 32\n", + "HEAD Giving shot 36 to worker:0:1\n", + "HEAD Functional value for shot 36: loss 1.255521e+00 for shot 36\n", + "HEAD Retrieved gradient for shot 36\n", + "HEAD Giving shot 37 to worker:0:1\n", + "HEAD Functional value for shot 37: loss 1.129683e+00 for shot 37\n", + "HEAD Retrieved gradient for shot 37\n", + "HEAD Giving shot 39 to worker:0:1\n", + "HEAD Functional value for shot 39: loss 1.010604e+00 for shot 39\n", + "HEAD Functional value for shot 12: loss 8.125896e-01 for shot 12\n", + "HEAD Retrieved gradient for shot 39\n", + "HEAD Giving shot 46 to worker:0:1\n", + "HEAD Functional value for shot 46: loss 8.060646e-01 for shot 46\n", + "HEAD Retrieved gradient for shot 46\n", + "HEAD Giving shot 50 to worker:0:1\n", + "HEAD Functional value for shot 50: loss 7.412825e-01 for shot 50\n", + "HEAD Retrieved gradient for shot 50\n", + "HEAD Giving shot 66 to worker:0:1\n", + "HEAD Retrieved gradient for shot 12\n", + "HEAD Giving shot 67 to worker:0:0\n", + "HEAD Functional value for shot 66: loss 7.007262e-01 for shot 66\n", + "HEAD Retrieved gradient for shot 66\n", + "HEAD Giving shot 75 to worker:0:1\n", + "HEAD Functional value for shot 75: loss 9.774604e-01 for shot 75\n", + "HEAD Functional value for shot 67: loss 7.374524e-01 for shot 67\n", + "HEAD Retrieved gradient for shot 75\n", + "HEAD Giving shot 76 to worker:0:1\n", + "HEAD Functional value for shot 76: loss 8.130559e-01 for shot 76\n", + "HEAD Retrieved gradient for shot 76\n", + "HEAD Giving shot 86 to worker:0:1\n", + "HEAD Retrieved gradient for shot 67\n", + "HEAD Giving shot 95 to worker:0:0\n", + "HEAD Functional value for shot 86: loss 1.088886e+00 for shot 86\n", + "HEAD Retrieved gradient for shot 86\n", + "HEAD Giving shot 101 to worker:0:1\n", + "HEAD Functional value for shot 101: loss 5.647735e-01 for shot 101\n", + "HEAD Retrieved gradient for shot 101\n", + "HEAD Giving shot 111 to worker:0:1\n", + "HEAD Functional value for shot 111: loss 8.084124e-01 for shot 111\n", + "HEAD Retrieved gradient for shot 111\n", + "HEAD Functional value for shot 95: loss 8.929266e-01 for shot 95\n", + "HEAD Retrieved gradient for shot 95\n", + "HEAD Done iteration 4 (out of 4), block 2 (out of 2) - Total loss_freq 1.368423e+01\n", + "HEAD ====================================================================\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 9) Completed adjoint equation run for shot\n", - "WORKER:0:0 (ShotID 0) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 9\n", - "HEAD Giving shot 11 to worker:0:1\n", - "HEAD Retrieved gradient for shot 0\n", - "HEAD Giving shot 19 to worker:0:0\n", - "WORKER:0:0 (ShotID 19) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 19) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 19) Spatial grid spacing (0.500 mm | 4.139 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 19) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 19) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 19) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 19) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 (ShotID 11) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 11) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 11) Spatial grid spacing (0.500 mm | 4.139 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 11) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 11) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 11) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 11) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.55 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 50.27 GFlops/s, 1.01 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.50 s [OI=2.82, 51.45 GFlops/s, 1.12 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.37 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 53.68 GFlops/s, 13.42 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 19) Completed state equation run for shot\n", - "HEAD Functional value for shot 19: loss 7.783401e-01 for shot 19\n", - "WORKER:0:0 (ShotID 19) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 19) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.73 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 37.88 GFlops/s, 0.76 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.67 s [OI=2.82, 38.11 GFlops/s, 0.83 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.18 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 44.38 GFlops/s, 11.10 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 11) Completed state equation run for shot\n", - "HEAD Functional value for shot 11: loss 9.077128e-01 for shot 11\n", - "WORKER:0:1 (ShotID 11) Preparing to run adjoint for shot\n", - "WORKER:0:1 (ShotID 11) Running adjoint equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_adjoint` ran in 0.60 s\n", - "WORKER:0:0 Global performance: [OI=1.79, 45.03 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.52 s [OI=2.82, 49.84 GFlops/s, 1.09 GPts/s]\n", - "WORKER:0:0 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.88 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:0 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 21.17 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 19) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 19\n", - "HEAD Giving shot 29 to worker:0:0\n", - "WORKER:0:0 (ShotID 29) Preparing to run state for shot\n", - "WORKER:0:0 (ShotID 29) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:0 (ShotID 29) Spatial grid spacing (0.500 mm | 4.139 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:0 (ShotID 29) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:0 (ShotID 29) Selected undersampling level 4\n", - "WORKER:0:0 (ShotID 29) Selected time stepping scheme OT2\n", - "WORKER:0:0 (ShotID 29) Running state equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_adjoint` ran in 0.72 s\n", - "WORKER:0:1 Global performance: [OI=1.79, 37.53 GFlops/s, 0.77 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.63 s [OI=2.82, 40.39 GFlops/s, 0.88 GPts/s]\n", - "WORKER:0:1 * section1<<2499,120,2,2>,<2499,120,2,2>> ran in 0.02 s [OI=6.00, 4.81 GFlops/s, 0.09 GPts/s]\n", - "WORKER:0:1 * section2<2499,376,405> ran in 0.08 s [OI=0.25, 20.83 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 11) Completed adjoint equation run for shot\n", - "HEAD Retrieved gradient for shot 11\n", - "HEAD Giving shot 35 to worker:0:1\n", - "WORKER:0:1 (ShotID 35) Preparing to run state for shot\n", - "WORKER:0:1 (ShotID 35) Estimated bandwidth for the propagated wavelet 0.245-0.715 MHz\n", - "WORKER:0:1 (ShotID 35) Spatial grid spacing (0.500 mm | 4.139 PPW) is higher than dispersion limit (0.414 mm | 5.000 PPW)\n", - "WORKER:0:1 (ShotID 35) Time grid spacing (0.080 μs | 24%) is below OT2 limit (0.146 μs)\n", - "WORKER:0:1 (ShotID 35) Selected undersampling level 4\n", - "WORKER:0:1 (ShotID 35) Selected time stepping scheme OT2\n", - "WORKER:0:1 (ShotID 35) Running state equation for shot\n", - "WORKER:0:1 AutoTuner: could not perform any runs\n", - "WORKER:0:0 Operator `acoustic_iso_state` ran in 0.66 s\n", - "WORKER:0:0 Global performance: [OI=2.06, 41.90 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:0 Local performance:\n", - "WORKER:0:0 * section0<2499,456,485> ran in 0.61 s [OI=2.82, 42.30 GFlops/s, 0.92 GPts/s]\n", - "WORKER:0:0 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.13 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:0 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 2.22 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:0 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 49.23 GFlops/s, 12.31 GPts/s]\n", - "WORKER:0:0 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:0 (ShotID 29) Completed state equation run for shot\n", - "HEAD Functional value for shot 29: loss 1.113545e+00 for shot 29\n", - "WORKER:0:0 (ShotID 29) Preparing to run adjoint for shot\n", - "WORKER:0:0 (ShotID 29) Running adjoint equation for shot\n", - "WORKER:0:0 AutoTuner: could not perform any runs\n", - "WORKER:0:1 Operator `acoustic_iso_state` ran in 0.66 s\n", - "WORKER:0:1 Global performance: [OI=2.06, 41.90 GFlops/s, 0.84 GPts/s]\n", - "WORKER:0:1 Local performance:\n", - "WORKER:0:1 * section0<2499,456,485> ran in 0.60 s [OI=2.82, 42.53 GFlops/s, 0.93 GPts/s]\n", - "WORKER:0:1 * section1<<2499,1,2,2>,<2499,1,2,2>> ran in 0.01 s [OI=5.80, 0.12 GFlops/s, 0.01 GPts/s]\n", - "WORKER:0:1 * section2<<2499,120>,<2499,120,2,2>> ran in 0.01 s [OI=1.84, 1.98 GFlops/s, 0.00 GPts/s]\n", - "WORKER:0:1 * section3<2499,456,485> ran in 0.05 s [OI=0.50, 50.97 GFlops/s, 12.75 GPts/s]\n", - "WORKER:0:1 Performance[mode=advanced-fsg] arguments: {'nthreads': 3, 'nthreads_nonaffine': 3}\n", - "WORKER:0:1 (ShotID 35) Completed state equation run for shot\n", - "HEAD Functional value for shot 35: loss 1.498258e+00 for shot 35\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9c12595a171049388184a2aa738d1234", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyAAAAJYCAYAAACadoJwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9ebRvyVUX/tl1zvf7vfN97/XrKZ3udBIQMChOiUIQUHGRyKghAYRkJUSMLEfWUhEN0vzAgUE0LgwuCRICcSVgEjFGs5YgrkCDiBLGJJhO0ulOenrzHb/DOVW/P6p21a46dc73e1+/fn27qc9a9913z6m56lTtT+29q8gYY1BQUFBQUFBQUFBQUHAToJ7uAhQUFBQUFBQUFBQU/P5BISAFBQUFBQUFBQUFBTcNhYAUFBQUFBQUFBQUFNw0FAJSUFBQUFBQUFBQUHDTUAhIQUFBQUFBQUFBQcFNQyEgBQUFBQUFBQUFBQU3DYWAFBQUFBQUFBQUFBTcNBQCUlBQUFBQUFBQUFBw01AISEFBQUFBQUFBQUHBTUMhIAUFBQUFBQUFBQUFNw2FgBQUFBQUFBQUFBQU3DQUAlJQUFBQUFBQUFBQcNNQCEhBQUFBQUFBQUFBwU1DISAFBQUFBQUFBQUFBTcNhYAUFBQUFBQUFBQUFNw0FAJSUFBQUFBQUFBQUHDTUAhIQUFBQUFBQUFBQcFNQyEgBQUFBQUFBQUFBQU3DYWAFBQUFBQUFBQUFBTcNBQCUlBQUFBQUFBQUFBw01AISEFBQUFBQUFBQUHBTUMhIAUFBQUFBQUFBQUFNw2FgBQUFBQUFBQUFBQU3DQUAlJQUFBQUFBQUFBQcNNQCEhBQUFBQUFBQUFBwU1DISAFBQUFBQUFBQUFBTcNhYAUFBQUFBQUFBQUFNw0FAJSUFBQUFBQUFBQUHDTUAhIQUFBQUFBQUFBQcFNQyEgBQUFBQUFBQUFBQU3DYWAFBQUFBQUFBQUFBTcNBQCUlBQUFBQUFBQUFBw01AISEFBQUFBQUFBQUHBTUMhIAUFBQUFBQUFBQUFNw2FgBQUFBQUFBQUFBQU3DQUAlJQUFBQUFBQUFBQcNNQCEhBQUFBQUFBQUFBwU1DISAFBQUFBQUFBQUFBTcNhYAUFBQUFBQUFBQUFNw0FAJSUFBQUFBQUFBQUHDTUAhIQUFBQUFBQUFBQcFNQyEgBQUFBQUFBQUFBQU3DYWAFBQUFBQUFBQUFBTcNBQCUlBQUFBQUFBQUFBw01AISEFBQUFBQUFBQUHBTUMhIAUFBQUFBQUFBQUFNw2FgBQUFBQUFBQUFBQU3DQUAlJQUFBQUFBQUFBQcNNQCEhBQUHBitjb28PGxgaICN/1Xd+1NPyf+TN/BkSEP/En/oR/du+994KIcN999wEAfuqnfgpf/MVfjFtuuQUbGxv4Q3/oD+Gf/JN/guPj46eqGgUFBQUFBU8rCgEpKCgoWBE7Ozv4qq/6KgCWOAzhU5/6FD7wgQ8AAF796ldnw7z2ta/Fq1/9anzgAx/A5cuXcXx8jN/5nd/BG9/4Rrz4xS/GE088cWMrUFBQUFBQcApQCEhBQUHBCcBk4uMf/zjuv//+3nBvf/vbobVGXdf4hm/4hs77t73tbfiJn/gJvOpVr8L//t//GxcvXsRv/uZv4lu/9VsBAL/7u7+LV7ziFTDGPDUVKSgoKCgoeJpQCEhBQUHBCfBlX/ZluO222wAAP/mTP9kbjjUkMrzEJz7xCbzuda/DO9/5Trz4xS/GLbfcgj/8h/8w3vzmN+ONb3wjAOCXfumX8NM//dNPQS0KCgoKCgqePhQCUlBQUHACSI3GT//0T2M+n3fC/MZv/AZ+53d+B0C/+dVkMsEP/uAPZt9953d+J+644w4AwI/92I/diGIXFBQUFBScGhQCUlBQUHBCMKm4cuUK3ve+93Xes2ZE+oyk+JIv+RKcO3cu+248HuMrv/IrAQC/8iu/Aq31jSh2QUFBQUHBqUAhIAUFBQUnxB//438cf/AP/kEAXTMsrTXe8Y53AABe+cpXYn19PZvG53zO5wzmwekfHBzg4sWLT7bIBQUFBQUFpwaFgBQUFBRcB1gL8r73vQ9Xrlzxz3/+538ejzzySBQmh62trcH05fv9/f0nU9SCgoKCgoJThUJACgoKCq4D3/iN3wilFObzeeQozhqR5z3vefiiL/qi3viHh4eD6R8cHPj/b29vP8nSFhQUFBQUnB4UAlJQUFBwHbj77rvxxV/8xQAC6Tg6OsJ73vMeAMA3fdM3gYh643/4wx8eTJ/fb21t4fz58zeiyAUFBQUFBacChYAUFBQUXCde85rXAADuv/9+fPzjH8d73vMer7kYMr8CgP/5P/9nZLolsVgs8N73vhcA8Pmf//lQqkzVBQUFBQXPHpRVraCgoOA68YpXvAIbGxsA7L0ffPfHi1/8YnzWZ33WYNzpdIq///f/fvbdP/2n/xSPPvooAOD1r3/9DSxxQUFBQUHB049CQAoKCgquE9vb2/jqr/5qAMBb3vIW/Pf//t8BBM3IEO6991685S1vwTd8wzfg//yf/4PLly/jt3/7t/E3/sbfwH333QcA+MIv/EK86lWvesrKX1BQUFBQ8HSAjDHm6S5EQUFBwTMV73//+/Hyl7/c/z0ajfDII4/0+m3ce++9+OQnP4nv+q7vwsc+9jGvNUnxohe9CD//8z+P22+//Skpd0FBQUFBwdOFogEpKCgoeBL483/+z/tbywHgZS972cpO4z/5kz+JH//xH8dLX/pSnD17Fuvr63jRi16E7/me78Gv/dqvFfJRUFBQUPCsRP10F6CgoKDgmYyqqry/xvXgta99LV772tfeuAIVFBQUFBScchQNSEFBQUFBQUFBQUHBTUMhIAUFBQUFBQUFBQUFNw2FgBQUFBQUFBQUFBQU3DQUAlJQUFBQUFBQUFBQcNNQCEhBQUFBQUFBQUFBwU1DuQekoKCgoKCgoKCgoOCmoRzDe4qgtcYjjzyC7e1tENHTXZyCgoKCgoKCFWCMwf7+Pp7znOdAqZtvXDKdTjGfz5+StMfjMdbW1p6StAt+/6IQkFOERx55BHfffffTXYyCgoKCgoKC68DDDz+M5z73uTc1z+l0iuc/bwuPPdE+Jenfcccd+MQnPlFISMENRSEgpwjb29sAgBd9w3eimsQfukkUIpQxnPNh+Ldx4Uz83FAc5iTp+bAmSY/DiXRyaXbST8sq8umkn0mT3/XmJdLy+fWUcWlaJ8Aq/bVK/E75+voW4t2yMhHi9k7TRvf9YBrpGEvLkZSxk1caJoO+fh8ax0P9mfbPSZEtTy7NVb4H8S11Xol0s/U5Sbul3xeQ769MuQwl32fyjcr0Vv5eM+OmEzc3dgbeD6GvXJ0y8XOVDz+Y/knmVZn2kjm6U1dkwi9LD0vaPTMvZNMW9ZN5pMh9Y6vOg0NjKJf2UJmXpXOiuOl6ItDOp/jQ27/Hr+M3E/P5HI890eKT//de7GzfWO3L3r7G8/74g5jP54WAFNxQFAJyisBmV9VkDdU4fOirTKa9YXITphDCTyKcDU7CiWC/UlmXCLyrLjIrER2Z3wmF3ZPixOQjEUD74keLspYBxPslAlBHEBHCh1+Me4hrpwxSmOlr41zcFcvYN077+l0KEycVUNJ4K/WZj5ykt4w4D9RpqExp+svK1hE2OxkMPD+J4I9M2IFve5DMZDYKejc80rIsa/eed51n/G0lpGgpaUnrvgL57LSFj9D9DrLhMuEHN3JkWrJdVySOvXXpIaRL15IlWOV7zJGIvvxPMrf3xh0gIQCeVvPprW3C1vaNzV8vnXAKCq4PhYCcYpxkF6cTZkhAyu2oZRbvTn5Dk3cfoRlaVAfirboYrgIyLo5J/s6Ey+Eki9jShRqZBXOgPrk0cnF7tUm5fNN3iTDVS24Qh8sJjr3jM61jbgzGWXZeLSsDJURuKG52nA4IMrlCDo3DtD+itqHwTKYXlQUhTq6sWRLv3vUJoH3hO/PA0Ngk93rZNzHQF/L7i4KkbUDhv9w3J/32UwFWptEruHIb9AjVafr+tek2XxQuQyAISVuIMP5dSo6jhAfykvUQkYwKz/23bgar2Wm39N0qfd2HIeK0itawd83JjJkhspKmnRLUXLsW0byg4PpRCMgpxVKNBtC/a3UdYTjPwd2tqDArlK8PCRnIleVG72gNhRsSylddPHvzkoLUCrt5femsJHj1EMulgjIH1YgFlqGxk5IPFV5RWmdK6t5TzhRpO3WEmROQhWycPsGlpzzAsODvy8ivc98ax30Skku2P+X3xI/UcD4R0eRyyd/yFbd9j1Du+90gEtJyZY0EQhaGRT5RXtxWCYmLhMK++vWMj95xRSFf/y2I95GGEJk4aXroxgeSsZG2SzIH57Q00be0ZJz6vGS/sIWO+25vpMa3j0SsujHjy9z3rm/8pW0i5rFVSMhQm2ZJa4akPtl2vBFojUZ7g8vRmnSiKCi4MSgE5BRiqeoXWE4sMgJ03677UsGYw2aE6SjtgfjZHfo+sjMkNPUs3KtM/iuVOdMuy/IffHdC8iHNJExm8UxNPjp55xZW6j6Pxo/sD5O8J+T7Swir3lbeIBaYUnLTU4fBdk7qGrWf6ubTO6ZyoCXv02SW5JMjV532IGQ1CLl0O8JnhvR0SITIK/wml54J8Xh8iXSXjfeUWPcSWyn8IRHekYzpXPoZEpOOP08A0nxPKghKIZUTloJ5X1oG4bPKjIu0aB0hdqhImbHeR0RItHUI3Kle6JOEPPnxiOXtlitDf2CRJ+L+SufraDwsKc+yebSPIKTjpS+dvuc5DdAqzXCzoWGgV96ZWT3NgoKnAoWAnHLkBLGlwnyPUCexTJOQJS5yAh4S3nICzZLyLivrSoL/APnKxkmF+YGdr04+OQKYIQbZ8mdIVkeQpq5wmcuj049p+Xr6sdOHMu1EsO/rr+w4zNRF7ianhe0Trg3nO9CHRrkfoki4Tss81G+ZrDtl5f7r9KH8nbRDp85OG9HZcU7j58ZFrpDpd5T0aazZ6ja+JyfyIcXp9n5zsl3T9uz7f1r2nlc5DZUPS4javUNurkfAFGnK5Pvq4MmDAaABcn3aeZdBR4OXPE81nn1EJLupkCFtnmDIuSRT7igOBvod/e87wrkkAVy+JFyOcEZVEmGWaTF6CUIuj0w6ubYfIiGduhYUFJwYhYCcYtxI8pFOsOmz9N1QvJygLp938s9JG5mJ/LrRR54yQhuQkA+xSPt3spip0JBps8GdUuT7MSpniqRfSTyPgqUkwmcoBEy5wKYLcCqgUxy3oxnJ9VmSRi/5WCJopwJvnwCW2/UmmKj+nZ3jFQUJHz4R7jqC0kC5o2eivXmHndr8NyvLIk2nor7vG2N93/sASenVjjghUArFq7SP7C8k/ZbVzuXqkowdGSa367zKvNG3eZEVlPuE5GXCs0Z0YpYv+5J5eOh5R2OSzAfG/cdnw/G1fRCFIVgCzONBh3J3SOgy9IzbTrCe8ZttR9n+ot361qKs5kvk1dE0meFwKXLfM0c8kRboaYCGxo02mLrxKRYUWBQCckpBmYk+K/QtEWpzC96Q+roTJl1IVyhDN+Hlea+KwV2nlKD15T0gcJtVFpkekpd7N9iPKaSAkMTpIxjyXc4cI7cbL4WbXu1WSj4Gyt+3YHfGxpDQjzhsbkcz17bcXst262X5O2VL3nnhrK8uMo4L6wV4X7+kkQygWPAzxveTIYpISlT3vjK5vFkDFAlWuXKnRSaAOK4L0Gm/nr42XGck7zPfXCo4d8IBnTaN+jfzbKngJ4X0TJnS5zlik9VUpMKzQq/5WyT0Zt5zHr3P07KmRMN030nh2IdxY8T3eVo+EU5+WznSlmsnib5NgizJADrfdocoZMqQS3uoTNm2SdLPaTuyhDtNWozx00pGCgpOOwoBOYVYNvH2akaWpNGHbNzcAkTh+dCufyrAdyZ/H7D7fpn2JivsJsJztHOZy5vj5AiLLEOP8N8p20A/ZBenHHHgv00igGYEvEEiirivIvKRG0O5suaE0VxbZfo5rUsnfgaRkIJM+6flk0VLNSxIxp9MS5Stj7z7caPjtEK8QB5sHArPXFpGUe/3wmFZIwJvRhbqQToW0qK4Ls+s1NXznaSkktvaE5gUPd9F531mXPm/c32QT2opsloYxM/6NB3+HRAJwKvGz8XNkRD5zfbIrKsjFdaRpJuZ/3195DfP/0/mEiat6bfj60YiaTF+c8J6tvhJ/ywjIXI8raJN7ptj07JG3ynyfbKsXr2bSRmcBiLSGoPWLCnodaRZUPBUoBCQ0wiehFOBDImAl3kfhVklqyXExodZcYFYmuYSnFhDQvFC5tMQQmQoWByu8zxFKtCJ+CfSbPSk20fM2AQnbcccMYq0FJR/l91RB5CuykOmBx1yhzguTCzAR+OTTYoy9ZbpLkO0O5whOl7b4yN0y5iOx0gbREkYWUZfBQIhEAH2QeFwRgGmEmV02hnty2LDynL6/ubyJ+PWC3IZESrS1CR1lW0gBWkvNDvToU7bU/IjyjBIfMTYSwlzLzlA3Ce9nCcTPxVGfR2jQEmRxNjMxh8iIWm6OaHavUsF+GyayfySFYSlsE6ivUzc3JJod7QzJtRd+n10HO1lfcT3Kst4EuS0mLIPOuWXJGtJujLNwTDiWV//drSEGZIj88v1m/1jqNQFBQUpCgE5rRgiH+J99t2KWFmr0iOYpeXoXRAGyp2L92S0Nx2SJFc0GbZH6F3JlKdnlcwJrivXhRf89GSndLFNCQZDxeF8G1AQjDskYEiYFOWKxkmPOXCWvFJSl0SoyZGPHMHtaIhyJmqubLl3UoMgTZ6y9WThMS17GpgAXQGmorivpBAp+6ByP0qUtYHzCTFxv2SJnyMuxoR6akT9LOuV0ypyWkSwjunGPqSk/DJspIlL2yP5rqNuE20xCA7TRz5SctP3jF+Jb85rmQaE2z5hMxUsJaEgg85nEmkR+uqRIT25ukRaF/6dm0OTb7nzraVpwI4b2aeGEB85nPiFnGgOy6CXJIo6pW2WzTNT/1XK1de/vRD9lH09NO8/iXa6USinYBU8k1AIyGlEZuEeUg/nhI2hybk37YzgEz0X5cuml1sYk/A3Sk2dTSdHkjLkI7tjZfLtkEVOaM6UbzC93LNMu3d2+3rqmG2PSIAV2aW7dml/peXiR32nWaV1SeoRjUlRlhzxGNKwseAdaQ9y47SHXDH50FVcRm+KRCKcSsotyVzt0pBhtCMTbSgfkw7OL1QE0DVANaAaQC3IkQkDrSgmE/ybd641QbUAtZaIGPnNCm2MLZOBahFpVIxyfspEXjiLCBoIufFHXHdhspWOTULcp72bFhy4L25uPOYgSEvfvJIlC7kwA4JlLn6ksRgok2/fgbmktxzJt5nVVHEBTSzIZ/NNw4k+SAmP7I+TzNkn0lT15JfmOdh+J8RSQrUkn6G4T4aoFRT8fkQhIKcQJyEfufCrphul3Uc+VixDlEaabk4QXVaeE2CVBaWzsPchEaajBUumJVd7GT3XJmlaKwhWQFyvIfMoiRwZjZ73pJOt4ypISEtOq9GJkpSrs5svypGWkUkQazPSbmCTIq9tSMmJJECKPEnghPwOsSMlpAHjymaUJQ6mss/VDFALl64K/UttyMwoG6aaG1RTSziMAto1oB2n0msoq2qMJzOGAD1C0LZoSzR8ufvqqAgaBkoSqMqZgyGOZ0kNAQaxloYJn8snMueTY4eF7T4hmbPqGRdGpC2rkw0eSdqhXN1Ek2qKvu8zu8ltHAySHArC/CpzV6pV6fteIwLRk266qbAUnJaJ+yzSDiVzTo7g95ko5guJeNyIOL2cLBM2l28u/1UJUPq+L91nGqnQMGiLBqTgGYJCQE45VhH8pUDft+veK+znBEifUSbcSXaIEgli2WSeIy05LFtwhsJ3X4r6DbVZSj4y+WfLNSSMPxkClhsDSfmXmgbknsvyJsJPjphyPn3EQ5bB76ZDjFUn4Kq2v4yR8zU/VtT1X2ABuwZ0LQR0hHBeoHaCNodRC6CaGksoyKUxoviuBFcfNQVGhwaTPYNqpkEaaNYIiw2FdiIE+NagaoBqBowPDeojDdUYSygmhPmmQrNO0HVIX7UG1AD1zKCaGajG1l/XhGaN0EwIpnZlV+TzUQtLbqiNiZKvo+G2cfGT/lItgkmYNrZv2kC80jbIEtkM+YjGjBREe4hvqoWL/kzeLVdt9L8aEmo7wn9uE8EHFu9y5ZRxTBj7S8ttknL0pO3TF+8H0+9rt5SEmOHgQBxmEMl3H5U7ITzp/4fCZ7NaQjD70h2KkyvfaUUxwSp4JqEQkFOK61H19gmcQ0KhfZCESwWEVYlDlOlwnN40hhZ7DC8IHQ1Dn/CfCj+p8E75RWnIRGQVjcFQ2YYWu5UWwZ6+7O2/HiEk+n8q8MnocgFPwwhSJ8mdLAu5sllCYCLb9NTfAYA3k/JCdY92Q9dOoFew5MYJ0d5kSvrCkCM/c2B8YFAfa6gmpNNMgHZiNRWmtnHUHKiPDMaHBqQNmnWFam5QTw2MMi5/KxGqxqCaAfXUFnB2RkFXhHpm8xod2+fNhiuzsSSgWsCRGiv5jw81qmloi8aRL9KWoKi507DMjdec6BFhsUFoNsiWvxJkwDiy4jQbuoIlJWPbXqohwGlx2oR8sJbI/4YglgnZ9KZjqRCZ+1Z6CL7XrOSIS26so//ZkOaV30uzo5SEpAK0Tw/dZ2l6oWAZoT4V0AfmzpTM9NVjMD7nKcvS9+2LfDptI8ufmR86GpxMWssg23DZurcszeshOOmYGCpHQUHByVAIyCnEk57gMrs72XRz4YbIRx+RWVKGFEt36JaFOUl6nOwyIVzU/7rTG3iXJR+irVNTh5PUn9P06fS847Sz70SZsjuN6cIsX/HCLE5k8toNKbAm40keScuJ6ipoHcgQvKai5l19itoqOjVKmE2pmRX+q7ndzdc1oR0HMsGCXjU3qI/gCARhviXIw8I+0yMD7aRmtTCoFrYsx7dUmJ0FRofA2iVLSIwT5gEAQiMx3yIc30rQE6A+JKw/QZ6AeGHQaWc4/HyHoEfA5IrC2lUDak044teRiGoO+7wCFpsK1BqMjg3U3KCaw2pYRra8TFbqqSVM1cySGj0izDcJzTr5E7y8eVpKCGTfOh8Tf3qXfA/X920suPkxJnxJvNBNXSG/M8ZcHr3fRyLMLzOpyu3CdwROGTcVvIHuVJdsBqyMREC/3vk1SjIRmiONU0pCZL4JcchuQCwpY9ZEjPv5BHPcMmIpw/WSpIG0l2lDUrJymk2zyjG8Bc8kFAJyCsELI5Cf6FaxYV3VzjUK6xadrCZlBcF8pTxWjLNKnbLkKhXyowgY2DbsT3MVDUSvwC52LDsQQkHWLCWHnjr0EsjkvRcGBNnomMqsQq5E25AkF+L/kcbD/zZxHymCTrQbsi+MCiZHqZDuyZIUaiWpmIWKqMaaKVFr/S90bZ2wremSQTsGpmcV5rs2nfE1wnjfxmdhnIQvSDshLLaBZsvAVARqCdVMmH5JUlVbEsDl1TXQbAAgcnUURA3W36PZIDQbgB4bkHZlnZNvI3Z6h7GkarFlywMQxteAyVUNNiUzFVx8p+mZGlRzDWoAtdBQC4PRocL0TIXFJlnTM3liV2vbiMeNqWx9yJD1j2lMx7Qt7Xuv6eL2lCRS8DCpncppO7hN5Rj0YVKCC/FdZOYHRlaglO9lljKsEOKz5VsGElF75ruheTCdn5ZqPvrem7it+oiDDyPadDBvmZ7phjmJdrtT5J76XC8JSfNfVRuySlkLCgryKATkFCM1S8oJ8TeMfLh8ssLySclHsiCvWu64YMvTyOYLdMobCQwQi0tmMYmKsOoiM0RsfALD6WZJ3/Ug14eUSd8JvtLsKb3NO7vz3SdEGClootMXYcfbJqr5hKgaMHXw55DkxRA8+aAGGB0Z1Mdu174KO/vet0E50yLnN7HYsFoEQ9Zno5oFwZ0EoTHKaUfWgXbdwCigaQhkCNQ4B3B2SCdbdl3bv6tjsqRmbNvQkyJhOsZQC5unap2J15rx9fRtRqFtrAbBkoFmnaD8/SLGt7UlQ5bQNOu20am1hEi1lixQY9ulPjZQCwNdAfNzlmxUc4ONCxrVTKOeGbQTgh7nyRz7r7QTqy1px05bVQm24OrM/ikAgqlYIyRuivubR4ZhQVeMrez3OSDwpu8isyNJbETaUuAk5sg932wkdPc9T8oVEQ0Zj9CZPlbVDHQ2ZHhMp23aM88tyyZqN/c77ukkbF847m/+c4U5bhXycCNJiCzXkMlVTnNzmjQimWuEbkiaBQVPBQoBOaVITXaWhnHhsuQjCbNSnj1pDqrDTzjRZzGwK5ZNY2DnMpv8EtLRm08mjV7NhijHqvnYwN340fMlafa2SW6MeAJCUbi+MdBX3pSABC2IPaXKEIIpDwA4wsCmULoSeTCJaWBPeuId+MYSiPGB9XPQrI3QAGlLHtKZrB1ZrcB81xGUkdVoUBvqY8uIcBKWAaghoLImTe0EUEIT4OEEPTUDaklkmTSIo4J9XGM1EJ5cKUe8DLzTdyTouHtClCMm7COiWgCufXwfOvLlBSgFtGsE4whPNbPmWNXcSoaLdcJ812pM1IJAWmG8J5z6DR8PbE/uqubGE6RqweZbhMVm7HTvy6Mo8dWxJE0tbJrRMcoIbcb1Zq2WN/NBQggS0i41xlmzIAr1SjcsWEBPvx0WvIe+Xxlv6XdOoa5c9sHpUkrwsr7LNksyZIfSMAPlj/5O08Lq6fm2pm49h4iDDLNMC5Erdy7cSbUVuTxSEpKme6J5vqCgAEAhIKcS6Q4y0DOJLiEWfWYFK2kklgi7g+TjeifmHkG51zQps5t44jxllivuzHUjnnyRyxcgn0ffgh+FWXFMpFoPG9dKQ9EdGznym/aDIB3Rgl/B+kxQVzjVtd1hZw1CPQUU+2kkF/sZ948VXG2c2Y5Cs0mAtr4M7GPBu6wAACUcqwnWOXxkd+35lCvDkqcy/i4NexKWFejlaVK+MIkQwg7rqUO8NI+S34li8iMIoP/W3Y9vLx2O7E01eHF7CqLWhgD8jE3Paufv0Y7JajlGIVyzTuH+EgpHANsTuOCd2U0FjA4M1q5qVHPrdG+I0E5Cm5J25lrCnKx1J3fZ2+AJamE6ZIAcEQvaXgpmdgremb1XUE7Hae4blCQgI1D6uHGUCH3feWdnXBCZiDzxgyXkZ6UpROYv88mQEFmEpSZbJk4vR0KY6Jm0Xj1pyXz5/0Pz5CrvVtXKLyMsubWMMvFWJUNPJ1rc+GN4b3R6BQWMQkBOM5aRj8wO1KrpLMuzL/ygoN0XVwhnvcgRrlXIh8hjlfo9GVV5n1mXLyuX60nknabVt9hm0xogrZHmQ15W13ez9lBesk8MIG8YtyZV8NoV6WjOArOurLA/2jeY7Ft/BEPW96AdGzRr1rwHlUhfAYs1wvQcYbFrQAtgvE+ojl2RnJYlMvfSNh/jLr7wx91yucWdH4Bz6p4BpkVEnLxmhrUaCdnoEFD2d0iJA+epRBsLEidJlDW/Cs9j7ZLLk7UMTvCnRsTlsK3TYDjyw8I8mWAS5rU9XmMCf0N7OyYstgnzM4AeGbRrTmOyHxtmGCJrarWwGpd6Zs29TEVYrJP3LYnqgEDe2grW18URITKOXFKII8kb0r6Wcw//mQj2vcQvN1chiZt7l2SYM8+JhPm+6KlwK+raqYsML8YyDECqh4QA+boOYRUSwkUQFfRmW0NhXfgna7q0qqlVHxGJtFGZdlmmCelLu6CgYDUUAnJakRGoo8nvJKRiKJueSXvV3aXB8sj/J0Jr530af4joyDgrEo9snteJLAlM65cKpRnBflCgSeMMpcUCQELeOiYSfMu2CcQj0nxk2llqOHLCmFGAAQV/DqfFCEI6WXMqwO9iV3O7kz7Z084BXHmNCJ/spGsDPq/Vn0RV279Z0G5HofxGlkf4d6gFwm3hyu3Ccxxh5gWC1zpoLqs0vUqFWCkEp+O8j1ToUCcZltOVwmOURtL2TJqsAO7aRGivQr/aU6o6pkqOmJCSbWZfqMaaWTEx4X4F4C5AdD4njZV2pfYnOKE7szgA9bF2ZlwKiw0V0nJtbG+Kj32A1MJALchqmKRwD2uSxsQjErhFHw2ZRkqC/2SEX04rZxblhfBM+pGAPhDHC78pkRDhgSSfDNmJwiGkHQKIlynRWEZCZJ45QV0WpoeEdNpgyXq0zNTqyWhOOuWmOP0hPNmxdKPQGn+C9g1Ns6DgqUAhIKcQXogCOoJHTnWcQ6+gL993Ms6HzcZbhQyJMNl4afCUfJglE7sQBHN5+nz72mGgvjltx5CpRicvUcY+4rF0125J3fvSTHfv0/ZhwRRSaE3HFfngnZ18Lxh5ARLBD8GdilQ5ksBmV8aRE8DtkDtn8uNzFY5vs/dgjA6sVkT6CMh8AEso6qPg8xCd1uT9IshrIFTLpj+iDk6YMhWsdsRJt2QM0JJ18agscelqkeJO437KaZuI298g0p5EApvsL9FXZGBPmOI4kqgogmdV7l1kPsf+Mck3KvPxp4nJca4t+VBM8KR2ZQFULdkDAGpCOzGWqXnHZ5uZHgHNpr00UTXA2iWFtSutNdmqDBpQpK3y5QVgaksq2zF5TYpiLRC3oXEkxJFH1fMNDwqNPKbkIynE982NGBC2c897su/77jvERRDY6DvkgnAQd+eNLGO2PEk5OyZHQ2U3ybslQqkc3525f6BefW3DRKBjsrYCOcilFZUxGyik3yHwSZkj4vs0ozihFzyTUAjIacSKAvjghJfZXYri5YTingm5zwQnl/7QItfJL1M2uRLeUPKRK+d17Gylu57ZBUmWLVPvVQQYDjtUnlz4QVLKzs5s39+3skhhFUJYk/Wi4LPBp0SpBVAdG4yO3B0axBfiAYuR3RWnNtTDCrL2WNx2bCUMaskJqxSXx9/DIYhHSli53BzewAvjstyGrNBmKkAbQLXMSOyPN31ylxf6eMo+81ohp9GIxgS3kSIYoWXyGhkYaJBNmxyxonCxoC+H9ncp2rJymVlY1MG8LdJiAVGeQFx3K1CxNBeESdLW5IlvQrdtSzG54fT4FLBW5AceE7af9ci2XbsGNBvKpsnHLYvjfasZUC2093dZrAd/E1MTtCeHrjEcceZnrA2T9TTKtVGqwUoEbYn0O+zdbOA2WwHXY+aT5pMrK2uDIiE+MevjcMvmhE5+Yl7r1XK7/y/dJIEon8xHHKOdy+ukJCQlhasi1/Yp2U/Dy3CQwVZpi4KCggiFgJxG8GI5sBM3uAomYZbu9MioyybyJQL1qnF68zPx4pIrYy7twbaS5UxW9Zymo+/v3GIl/99Z8M3AIk3o72OgIxDl3nM6ve0v82eBzQmZqjVR+7K/hv3torOwyE7dbMIlxhULEmphT6oaHRqo1gmwRN6sikwIq2uCrgyInFA+g0/UOkfH+SC8tsJuE4QYeSs6ax2k47YXXOWON7eZ06poly4L36EDQlg2e7JkhqCYLMBAmfjSPhZ8NQgKJlyWKCUxSZb4VK2WQK3zyWmtczxRuDODy+DrZRyZ0O4+DkEIvAYk6WMeF14QJAjiIeKkwldirmZUKGvUpuxP01pyoCugWbMv2UQPLk9rbmeco7y9GHF8DVhsV5hvCUd5R2xQARgBHb8l98PmWUBo0853ltZN/r9PCE6ZQM98tmxDqO8zXUpChkiByz8V8ldBTpsxuMEhSHaOlKVzqaEQx5dPErKkLGnZ0vJky557fgIiMERCVk1rSNt1s6FBaG9wafSpqV3Bsw2FgJxC0IBg2ie8Z9XzKxKP69k94jSGhPK+HbS+fIfMu64rXlrHE5ItuRClefWWIX2WI0GurIPmV8nffTuS2XKkpMwJlixke/LhhN9wf4VNzDjCERGPjLDPeVAbbtcmY0+qWmzaAPXURATIkN09b8dW00ENUB8BbXSsrGuitM6uDvz/SLhGiNO5D8GZ+PjdccP1du+rkE9oPyfYy110ji/JEIcl8n4Z/jdgLaWcgCZJgyaKtDikXVin2fDlSf1UEoGZmAS15E0lcv48nXHCwjscWZDky5FHeet60PqEtu8SHNGGLZfdmWtJCVnEayYEvW3zGe8bTK62qI80jFJo1siOw8omyv4u7HPEqxffM0JNUk6uS/o9Adlyh5eizUznsQggfqf1TyHLsWy+lWEzwj3nIQm1/AZSUtFJXsxpvcKzIEwmGXNZ9JAQH4VJCMXhffSeNjkpoZBx+jZxUjK6inaqb062f7ghrVBQUHACFALyDMQy4bdvMl9lIu81oeoEjCfgoYVJhl8qdC9ZpE+izcnGEYJ/1rSsZzdsCL2akz7ykYmTmhXIeDLMYN5cN+nXwcSDT2bSYfHkneWIVPgjbF1m7lhV78Pg7tTwDudkhVfOs5nYy//muzbv9ohQTxHvSDuSYdxledXMCvDeNyDn/A0IkyPyvgceqamUbAcdCz9S+OJ0ImLh2s2k/SfSkO3PJMOHk+ZrmoJgn9RHagy4WiTDmTh8hIQU+CZx4yi6VJK/z2T8GSamQpNhy0SOeMILaJ7ESrKSCvEJwQbgx5PXrgjtjK74EsXgI6Tayh7jy3WMzMrchYbOK7Ydkz8xTY/YeR3ehE7e+eLrxm2RNk9afvEy3a2X8ZahY6qzYviURHRMwqTgnJtLRPxeDUuujGk+PeXm+cPnI8L6d5m0UnLVpz1atoatvAEk/t/RJInvYoiERHFEXfy4OSFBeiqhjf250WkWFDwVKATkFCI7gWOJ8J3BSXeOVsonEeKyO4wZMpFO/r15pOnjZIsOo9ekIREW5btscQbyGCRNOfIxsFj1pRW1s0QqRAlhVAoebM4jnZINwd8e7u+RIH4ufDoaq8EYHQXHZKu9AJq1cL+DcXdutCMKJjZsIuXCy3IyyWCndbWw/9cjeN8IX01BEmDYudw4syprLuaVIuJUp85OuNOwgARhoOSnB1J7FmnSpPAi25Y1MGm6kgxyeGlSlQhjTCTIUDxsmGCYIBxbvw0Su9ZusOWEKqdt4XJEZlTOVM3b6Lv3fOeJPLgAcmwSvCbN10EKpsJUSmrfQPDmX4A11yIdiDEZ2AsZW75N3ZpsUWPH1nxLYb7tSEhNnhgN3meTgW9H9Mwdfd9uJv2+TYtlGzDpjnok3Msy9RCGvjkPmXxzu/vRurOiYN3RoJguCclqXIbmTvS306rv++KsSkLSvupYGPD8ghC+oKDgZCgE5JRi2Y5OdoepZzdpCCcyocrF6ZukTyDQ9y2iq5ooRXnSaml0E82XYSkRzJAsKUzKndWc5sU/7yMsQ0UWi7g/ejXtgyQvTzxGfGwuRWWTu958WlU1N2hH9h4H48hFNbdhW7dT3o5Zsod3Luad7/SiPsAKmEpZqU+1ABZWYtdAZMIktRopyWLHZgWKSYggAV7ol9+HIDWGEN26nW078d4TKylICQFOEhojfBK8oE+ISCLHy5GV7BhCph0ksSJRJzabIwLBhPaQv3lc8FG8rg/98b4GoNZAgeJxz20s6pD2MWvdFPuXCKLBp5oxAeV4lqxSiN8GDZxRwGJDwShLjMf7LSbXNEgrzLcdaSF4p31ZFgDhWGXxHRr5N1dN1i0n+PcQkRx5WaZ9SMvD5CMiIRzsBPN7hxhk0EdKls15qTAekSX3W5KQ3rJl8hjUDJ8QubiDZCtDQtJ44UE+3acbLW68D8iNTq+ggFEIyCnEdU1mPQL0sjRzC+Qqpkm96ac7RQPlGVogBvM4SZlyO2wDC0zfgtmfyZJ4cqETQmMqwMn0jBCgsu0hhMhIwE7b3udB/ijbdgJ/E7YnBhr+WF5OXzWAmtvni3WF6Xl7mpVq7XG51cw4ky6rRWHncRYy1Rz+ngm52+37TVkCpAwLudaEhrQjRcLnhIVKDUAZKySTiKdhQPLmdSGER0IjxxH9Egnsoq+soC8+Dn5fAUaY9nhS4aT/6AjtxJRMCrzpeGNTjkizYYDgn5OkJbQJ8mJDSYKMqCOnTZqs9sP5oYAAVASjja2X0DIZQ1bj0fKgoJC2YuJqEAmeUgMnytg5FjiKY3y6ukYga/zO2OeLTcJ8l9Cs26OYtz4NTK61qI+NPxo4qjPEdyG+K38EMeIwkbmNIM6pFtL7EfGjZC5applN+z4rvGfiDhEE+V7m1SlPMh/2CdkpSUjT9nVwaQ2RkBxWISE5ItCHZZtlS8lWQkLSfJ/UxlhBQUEWhYCcRohFM/taTMyDu/MOJ5kYs0SiJ/3BdFfZRRpCjjgk6XfSTgW1k2TXs6hH6SO/oHXKkRNIhNA4pN1IhUb7MJO+JCFJOaOF2xEPoyzxaNfgTxdie35ff7lDnNrprwHNpnP25Ys15NGswnmcHIHxAj77E4g21DW8wzWfamVvLQdMa7ymxqfNR6tWAJA5gtbdXm4JjKt31O5BUFZE0EKI9MJpoqmJhHyKw/HFfQACcZPpIBCdSOsg+nlojEQCsDuJDLLv2RfDERUtw5LIn9GZJygKy7e/q8YE4ZqJALclQt08SRJO89QaGGcaZ+sUMo3uakFcd/vdijhu/Kk2tEMzITTrhGYN/lJK6/thJVnSxo4nSfo4DVc3PUa4j4ZE34r2930h51jue8TP/Te6ZF7rIwa+7pys/N7TOV4Ixyed4zqa2RXm9vhFnHeqzc2SEH6fS9eVoY/kDJGioTpSpv2y70XaHRKSvF+W72lD0YAUPJNQCMhphBBOhia/ZQJ9L5noSfMkWoy+nXmO06t6X3VS71uwV0EqGIjy9OWfmkdF4SUBkJF6iEbnnRRmZXlSYSARIH3ctAyJuRWb0Mg6G5GW9a+wd27o2monRgcG9bF9345ifw4mDazVsM7BQDUjn7auEGsYhKDMTukkGsw7gLsw7DeijT0+1Z7OBX/BnJVd3Z0ZJOrjoA1BseCrnWOyssQiNcNiQce3f2tAiuzpV7wrzmRNuUEqiIA3G2Ifkxowzm8le9ytdLgXBIm0u9+E2032sxC4O6dYUaiD7X8T6myC8M6aJdamAEwiTCy4unBRWPHNkOs7TbadIpImsgpaldBGRIAxJpyupkzQOrTwRy9LjZD3HYnKHPrOVG5sOr8k1ZAduwCaiTXJ0uLQBP8ta3vMbzW3GTVr9o4R9lUiMvGGAYV6gOvHxTJivKd9l3yvnf8PCdQu7w4JEfE6BAn9GBLYc4L2EKGJCMIyApSrRx8JyREhkX6u7GlZc/VMSUia79Am09C7Po3MadR4aEPQN5gx3ej0CgoYz5qD4z7xiU/gR3/0R/Et3/It+LzP+zzUdQ0iwvd+7/f2xiGilX5+4id+Ior31re+dWmc97///U+qPnInyJubSCH0SZIPTr93bnGLbC7M4K7UkvDps3SBGPpbxh1sC7OkjDhZW/Yi6Z+c8JASCBakpTDH4f0uO+8Gs2CXCMOpkBqZK/EPawEqRLeFV1Ng7bLBxkWN8YFGNTOo+NbphRW82SG8nVjSYsiSlvrYxud7PZAsxF7jQiyYGusA37g40gfAmWD5W9KdQOKdjRchDmsYmPj4usndeOdsDyG4RhoL2abi3otsv6SaEEkuKlGGHsGyMzZ0IAE+ryQu9zMy5MODCYIgtPJbiLRnFMeR6aVjRWppokMLRLsbRZ12gWxL1qb5OOTM7MheKFhTp8069czNJeJELjJyHNrI7cSehKX9kbw2XTY3XKzbvKu5PUyhPraXZPLJZIb7tA4/3lQrbedMfeWxxL5akujJPk4E7uy8IcJ32uaEcmAnzyXhcuFNOpbQJSFpWTtxcmnLOaNvrELkM1CP3jr21acn7jI5exVrg4KCgtXxrNGAvOlNb8Kb3vSmE8V56Utf2vvuypUr+NCHPgQA+FN/6k9lw9x22234zM/8zOy7s2fPnqgsEkM7LE9WWF5p0jxB2M5COfR+SfxVF8sTIV0ohTCZWxCzi3ymPQbLIRfhhHwgFXApZB1ORAoCIJvZRDBBCIgETkJwRBYCur9FvLGCW31sAANMzygs3B0M1TxcQmjgBLixjcunILH5WEdo4r9deciRKOVPJDLOHMr6H+gaXpg32gqpbL5j73JgYZ1gyATNBt8PoiwJqJwvBmmbTnTClGsfEv3nzZxcmUiT9+Hw/SPqwH0BI9rFpZklkSb8kIn/9kESgSsWcuXHIMZRUvYofblJ0CP4+bxV17cmLUcwe5IMMx6z0jncE0sejyoI9V6bZuBvOvd1EfnKOhtl/VG8+Zj4jqixfa4WxqfnLzcE/K3oxl1+2K7bsrQT28/VTKOauTE9Eu3g7roxFfx4VQ38XSZkkvon33RkooVunXy/y/fJ35251oTvzY/JJN6q6Etflk8+IyAapz5bMeZ6NeCC+HfImYjX0UzINIwoQw+ieSiXlhxj4l0Ul4t1gjUlbcshzcnTgWKCVfBMwrOGgJw/fx5f8RVfgZe85CV48YtfjLe85S1417veNRjnl37pl3rfvfGNb8SHPvQhvOQlL8FnfdZnZcO8/OUvx1vf+tYnU+ws+nauhojJoCYjDcOCcQ4DgvgqE+2QkL7s72UYDL9kce4TCihTX0keTrTAJIJs5x25C/6cgO4FzkQIIMMCXvg7TdMLeyzoQSz4LJQqitPntCp7fOnsLGGxbePpY4pOIwJsOA34uxVII/YrIPjjbf16z3FMEDxZmIKxJlUk/FJ07d7zDjrB+6UoWFJklAEqlwn7gzhzKUPGNq1BOCJ2WX+xkCN9LaJ2JRg+DUreHp7Un02MgFi4jo63FeNLMwGQ/ZEzt5ImZOiGjTQyKfHIwY8HIWyn5W1hNUhGmCUBEWHh/mbzL8WaLdYm1OS0bhQ0b0wQyZra9RGyiJxkSJ31EbIR5UlafFEm3w3iNWtjqwEx7iS2xRFZwmmCn4uuxDHUlawnQTfiXhEe4+ncxoJyaOYI2TmZ0+mZwwkIPkWI079eYXdlgZkzk/US5CoS7NOoKclZMiZzgjw/7y1bLh+I8sp5XbxbtjacFNkyFBQUnBjPGgLyxje+Mfr7He94x3WnZYzB29/+dgDAq1/96idVrhuBZTtBKZYuUiz3puEGFpeTIDL/SheWJ7GLlzNN6TNhWAYjFtZuZojbaGjXL5cuEARFKSz6U3WEEzXivFiQVtK8I2kvn44zHTFE/m4E1QZhrmVTLM7b2PDNWjhOV81d+i5sp5+I6y4uq0tMmrzWQ5h6GQMY43azncmWvUvCROY8pnJhW7LO543z7WgNjCbAGL87zQInEzlyJ1JxXcCmTnzSE0RdEMqZagpI9rXoKzYj8n3Dfg6sZWFCCTjfEdd3nK4UlN3A8A7QTAalsM9kS5DIjrZE1IXLGJlTJmPJUOgrT37Et5OaE6XmXJ7IyjjaeIKsGlteJhuazZmchsHnEWmowhiICI5x/ePL5ciQPOFM9o8jHxEDoPCM+Hb0Nox7r1UQbUQaoIU7QauiQF5q8o75EnyClh9fywigRB9bEa9JiXAZ4Toqy0nmPsGlJZmIiBU/T0lIkkY2eROH72gjMuF9/pxZSoLcGFxF2yGJQaQxStJL65yWJ0WOtJ1WEtJCob3BlvXtDU2toCDgWeMDciPxi7/4i3jwwQcxGo3w9V//9U9bOVJbcWB4wenTnPSF7X958sk1WiiAaLHo7IwhX7c0vaisCfnIxe08y+ywdQS7bOYuqNydPiHRyZGPrImVMLWKfB+SvKVZUfCfsAITGbtTW0+N9eVonIDobPm9sFrb+zqscMUXDdo7O6jNlD/TLr6srfPvaI0/aYj7nAVQe9eIEOK90IpgWsZEyt9LEtq+Wjj/lLk7olfEiUzZKFNGqS0QpCP1Ccn2LQuxqXAs+gqGhWDygiqXO/KHSOuXaDUijQbn1eeHkpIPJQRz8e1lvxfRVvydRn3ZcaYn3wayHF4b0SC5QZ1cPd0Rz4KMQsOPSTseKZhPpb4hwryrWgSS4/2BDI9/Cg79XDYuunbfw7HzF3F31jQTcXN6FUh4NbOHMqxfNli/qDG+alBPHaFyY1hqgcJGwvBc4glO7mdIG5RJc0g47j6M0+7EpeQ3/7+vPn3zXuZ5OvaWaujk2F627gji2Ek/U1eTqWfaD1FRBvrxpJuAv99xPT65991331Lf2o985CMr5f9zP/dzPs6XfumXDob99Kc/jb/6V/8q7r77bkwmE9xzzz14wxvegE9/+tMnqnPByfGs0YDcSPzUT/0UAOBlL3sZzp8/3xvuN3/zN/GX//JfxmOPPYadnR380T/6R/FN3/RNeOELX/ik8h8kHj07aMs0DCtNkgO7Q/J5dpJPnqdpSXLSp25ftYx9pg1ROXoWtNyucvo+u9ivuMjkFntJPvxONjscQwiDOfMhIRRIMxrv1Aur9agd8WgnhPmWO55UlocFp9ruxlNj81dzUb6cTwOCsOtvmU53I429qA7KXkzImgHekSftTroyQbg0iqBF2+gaoJqgawNdObMvZ4tfKSvYKnf7tR9TXgg3XgCPjrGVHENZkxsyxgvLUluV9pcfP4nvg9RseA2OGFOswfLhyOVL4SQqQ9QhFQCCJinx3fHhUkKbmQu8aVBCWPg3j28j+oNvGpffjPQTibR6OQdsPyZd/9ThEkowWWHi6bQflqSSJ53cZ6oxqOZw5MOdoEWu/aTWRByly6eCeVMvY5/JvotMFdsuyedb1McHGvUUmC8U5luWhElTSR72rN3pfK/pt5H5nqK+4nQdl/K/OapIL50/fbLpWpCWBSHNSDshhHYTRTwBetabSJuRe835R5UVFZBlI3Tm5Y62AwPv+sqYhI3CZ8INxT0tJMSYG38KlrmO9K7HJ5dx991345577sm+29jYWBp/Op3iW7/1W1fK60Mf+hD+9J/+07h8+TJ2d3fxuZ/7ufjYxz6Gf/fv/h3e9a534Zd+6Zfw2Z/92Scqf8HqKAQkwWw2w8/8zM8AWG5+9Ru/8Rv4jd/4Df/3z/7sz+J7vud78N3f/d34R//oH113GaT5RDTxLRPY+3aqhpAsgmk50rz6yEc26SUL5SrvUlKTEgh+vgydxZafJen3Eb20L1ZqDyYObsc91XykZl7+rgpCbKIi7NPlc1AsCOoRYbarMDtrhUA1s7u/kcDMplbCZIkL3iFn/F/21QCFE5KEIE4mXAZIkS29tcWHcZfbOXt6agDlTLGkP4gRWh2jjHMCdtqcBUGNDHTr7nqISAgiu3k4EiDNrQIBJC9gd3ZUpYAX9Z3oK2mmJEyCoryNCCf6E9LnJ0d+4MLBkqT+MPAXM/o2YI2OTuLIvAS4/1j7EcgmeVOqjuM5h+d+YQ2PcuFr4VPh4kUaDHfhoDTT8qdXGUc+ZpZMV3Nn56Soa3bmLqpksscaOL+rLQlUZQlgOJ0NgDFRH+sR0KwTVGNNtMb7LcYHGoBCyxd2poSMx0TnGw59zmWWGjgkY43/T6pflvfhM3OOf90nREuhPclWvvc8ILeGuJedzaYeguEF84Qw9W72UEyCOnwkR0Lc/NQhGjK9nrm7t7xpuVbAaSQhpwHX45PL+OZv/mbcd9991533937v9+KBBx7AV33VV+E//+f/3BuubVu88pWvxOXLl/GKV7wCb3vb27CxsYHDw0O85jWvwbvf/W583dd9HT74wQ9CqWIs9FSgtGqC9773vbh69Sp2d3fxlV/5ldkwZ86cwd/8m38T999/Px5//HFMp1N88IMfxKtf/Wq0bYs3vvGN+OEf/uGlec1mM+zt7UU/ElnywYJRuhggvDfiBxiYGJdMyr07divsEOXITLqDtQyD5EOWMU13Sdq+LEn6ofBxnkNEKmpjIfik/UTGZI/wjAkMeWHV3s1hBaNm3d5f0Ky7iwTFhWpBg0DWxGTDXhjYbNifdhLs8aOd7eTLlzvnaft4cjAG9Ji8SYoXQJwQqBpr+qL4VCQlBM1R0DooaW7mHNxDPuSP57VmMhQE30aET0gV32shhTR/JKvom0iwzn0XFNKKzKCQGTeij9PvMasJc2ZNkSO6fO+FZuocMxyZX1G42d7I+pi43iF8aINIUE6c5OVxtP42egrkg1o27UNCPkiQxyB8cj+zhsUKa8JUS5rcte6IXUc+2OTO18E5tusqNndTokyqMcGcTIe4UV+KvqHM+G7WCe3EZqAW1gxQNaGt5PdhKOkDCRPn5evB5UjGlgwrNZ4n0bxSJo2l8UWYzvzeNz9y+kvKk0WmXTrvB9JPNbSdDSBBfDptP1Dm3Pr1TCQUfArWjf45Kd74xjfive99L77zO78TL3vZy7C1tfUU1LaLD3/4w/iBH/gBvPzlL8df/It/cTDsu9/9bnzoQx/CLbfcgh//8R/32pXNzU289a1vxS233ILf+q3fws/+7M/ejKL/vkQhIAnY/OqVr3wl1tbWsmG+5mu+Bv/6X/9rfMEXfAFuu+02TCYT/JE/8kfwtre9DX/n7/wdAPYD3N/fH8zrn/2zf4bd3V3/c/fddwPomfzEQtE7MWaEfvmb/58XjpJ46cS+LJ8BwT+b/xKi0Eto5OLYl0aGpGXbTJKGvgVnSFBdVTgQfgGqDQJ6VDb3oytCOwZavjRtTZwUxelILQrB3QpthShyFwZGQn1KiiKTKx5UcTmjH0Em2rEjIqNAQrxWY2GP81VC62KU9AcJglrnGFcZns1zmLQ4kyjlHJNVE7ehvCsiFdqlw3h6L0rO3Iz7w2TGUG6srSQoMYS2JzV3M6J86X0UuXRYEPeO2AjkIzrSNyOI2lvD7W9uQ3silPxBWB1MIB/dk9YQEQPePeYxQY31EWIiGJlqCTMqb3o1N1AzE41ff0fHCP5CQhJl8v4o/tsIdWeNjq03InMtPna44os5D+07e7eI8gc8+LZ1JKmahvtwAEuOuM1MogHk9uuYz0ninOljuVmQ9t+qwnGHhOQIUfITXsLXe9lcnX03RDJWeS/TlmGp27a59SxHQoDldV22kdYp3jOQpDxbYYzBG97wBiilVtoAfve73w0AeNWrXoXt7e3o3fb2Nl75ylcCgLeIKbjxKARE4NKlS/iv//W/AgBe85rXXFca3/3d343JZIJr167hf/yP/zEY9ju+4ztw7do1//Pwww8vTX/ITGpZnKVhxQ4p/73STtfApB3tqvUsZr11yhAXKWTlSFIfWeozWxgicyZd5NI0xHNKFzEpAHtn3yBoR+X2O8mILgBkX4jxnsHaZfszvmYw2rfCkpo5IcgJ+YasMFUfAfUBoZpSXtPihUbEWgP2B1gYfwRp5PzLt5ePhVZD7kYvrIDGP5EQmWhBWKCj1MFYCKntiG+tJi9UqBbR6UbSdIg1JjktiO/vVKjr29kVJAQ9z2RY+Xc0phLSJ03qojJQME2SJKVTRkmOZH0NwBcZevMoUadYCI/JhxwP+cv4TER8oziJ4M1j32u4InJJ3vFcC/LhBfu5QTXT4UhdTn9kCXY63iT5kKfGeQ1RhgQE00Oulx3n1TQ4qy/WCYsNQjshf2cNjz17oaG9xHO8b+yN7Bpeq9OOYyf8iJAlGqcOJGGWj3vmqRyByGprMyQkK7Tnxrycd/s0Dn1IiUMy3jnMMo11RELEtxylIcvE9Unm5Gz5ZdgB0tKHVU21bhZao56Sn5uJX/iFX8ArX/lK/Nk/+2fxtV/7tfj+7/9+PPbYY0vj/diP/Rh+8Rd/Ed/xHd+BF7zgBUvD/6//9b8A9N8Hx89/9Vd/9QSlLzgJig+IwDvf+U4sFgvce++9+MIv/MLrSmNnZwcvetGL8Ou//ut44IEHBsNOJhNMJpPsu0gIzwg2q9i0Lt2dkemmQpN83rNbJReXqHxi8u/Lk3E95mFpeqmgwYv+UDpZ0nPSXT5ZhmRHLUovIwjLHWQPsdsLsidUjfcMRodWgtM1gfgSP+Uctke8+2wbnVqDyt3p0RGETcjPKFiHdO7f5EQkW07ryKvgBDoTBE8PLfxCNBMiE0xmuH2EwEraWP8OkS+JMch1s2PfhmehEoDb4absmE2JYzQWpRYIiPtH/s19JP0GRHp9mjVy7UoaXmsTxcmZv4nv29ef4+luuXwdFaJvko91jmzkc8Iuj0UxBkkhOg64V2CNhMnYVyQiBqZrKucdz3l8u/ahxhEPR0BizQf5U9us6Z99p1iz4vxLIq2Min9C+yDWfuQ2JJTQ0lEgONwGhuAPd6inBvVUg7Tt2MUGCa0OwQizwWg+MIi3/ZINDD/eejQjXJeo3EvmeU8+ZZ4U5+nHIYkhKcdmkr8k28uWGZ+nLMsK83uUNpMD/m+yxnTK1FP2wbCShGB5u8r05O+nExoEfYP3lfXKi/GNwQc+8IHo73e9612477778OY3vxmvfe1rs3EuXLiAb//2b8dnfMZn4Nu//duX5jGfz/HQQw8BQC9Z4ecPPvggFosFRqPRCWpRsAqKBkSAza++6Zu+CUQrzj4Z8EBtmua64ueE5yFTj1UmypXV3ZlnK2tZEiITxZNCt/jJxlmlrMluWo6c5Xa9fFmRhO/LM1f/RNhNzXWIhUdh5iF3j30ZpODphXS76lIDVMcG9bGGUcD0rMLRbQqzM8re48ECXGpuY5wGY8bH1yanEAmTKj4e1gtObPJjgvAlhT1/VC8FbQ3/eAHUxzXxDrjMU+7yyzaWAm60K09ITZJ499oKlSaK16fdGNSEpP2bEWY7WoxVfurwfy3Nv/p+i3L5+lJSpvQdF1sIudlvNvMdRHkmQm8kWGXaLpizUQinxTjjCwpZsOdjd3nstkFrZn0tbHhdEfQ4kA+vVVByfCE23yPOh4K5n9MOye8R4ju0/igUzN74yN3a+R6JjQNdWf+Q2VnC0e0KR7cqtGNyGhGD+thAMYGSwrbUMAqH+aw2WHwHOW1JRKyTvu77Sftbppf2c47odpDO6TLdgTw6yWS+zb71oqMxkWlQT/wlyJmi+fQz31AxtULHX3U2m93Q9O+88078w3/4D/Frv/ZruHTpEo6OjnD//ffj5S9/OY6Pj/HN3/zNeO9735uN+23f9m24fPkyfviHf7h3U1fi2rVr0NpOBGfPns2G4eda645/bsGNQdGAOHzsYx/Dr/zKrwCwBOR60bYtfu/3fg8A8NznPvf6CyR2cFZWAfMuYG5izu2Gpvn1pb0kbtaeVpoaDU3eyS5WbtHNLQQk6yridsjEkoUju2il6Wae59LvmF5F/3fCGAm/hiQ9LxCb4MALAM2awnyXsNi0z+pjQjU1/uZwXzbIk7as9oLI5skaBr6UjW9+9hcQuryVcZcHSj8TYysnLwT02o0xQNreRG2E4MRColE2L0/WKsBosqdmaVHnXB+wtkbszubam0lTTiiP+iklrEy2dBKPy8llMCH9tN/l+DTJ2M+Zq/QKaBnhy5dLd8OScVGclsQK28bvXKffTSq4WRLBlYhPwpLhfTE5qArvOgTOwN52LrUMFEz9tDuel+smtR9MPlhL1o4t0W4n9mJAU7l0WwjzwPhyzHZkw7ITvUfirJ6angVyGE7XYu0FtSGcdVJnLQlhfEBWE3KsYUiBNEGPTKR90ZX9Br2mT8wJcuyL6d73re9jisN5UiXn557x5LtmxXnQJ5mOnyRtQjxcZB5DcbPaE1EP4nSS9U+Gk+1iKF5rpPY//f5STaYvixjb6XeQllc+P424XqfxZWkC8D6qjO/6ru96UqdVpXjDG97QefYFX/AFeN/73odXvOIVeM973oNv+7Zvw1d8xVdEG8Q///M/j7e//e342q/9WnzZl33ZSnlNp1P///F4nA0jiczx8fGq1Sg4AQoBcfjJn/xJAMBLXvISfNZnfdZ1p/NjP/ZjuHr1Kqqqwpd8yZdcf4EGyMfKk19OIM9lZZYsUMkO1+DCJHfnkjRzmoeUQMj8chN/thxiYVq2Qyd3BqOFKqljJBgkZCcLTlcI7p0dSGeG0o6FgGQsOeHdWhbQbHgrjAFul9j5eegawIS8eUjUzkJ45YvwSDSKXbApaC9YyBe27jAUmasoAGiCINZyHEdCaAS0LVlBtg3tzAIj18W3Y+UKSsG0ShIC+3979wPH82SACZUxoW9SUNyHof1Dn0cCnSRBJPLi8PxKCixC6Da+H93fKVHJkIvUDCv6bjjd3LfB5dAIZmvepIoAcVeLHxpSmPMaDwpl8QwuEQjRbUfSNm/ZVnKH3/+W3zIFAV+SPnlCFowbT7WCHrkLA8UJbkDw//Hkwwn0ugrkox0LPyNpVpjcXSK1OHzqmh+j4sAIO84o1LEFqtZeXgi4sewIS7WwfcCmYqzR1CM37zitYN/mTGc8S0FftHWnb2VfcRr+W+5k0xXuewTuLMR4Xho2yUuWUf6dIyHyUSdcpl1WNumSbcP/pZC+JyGi7LkNsFXzfDbh4Ycfxs7Ojv97FU3DjQAR4Z//83+O97znPfjYxz6G3/qt38Lnfd7nAbBE4q/9tb+Gra0t/Mt/+S9XTlMeMDSfz7NhpIZnfX39OktfMIRCQBze/va3A1h+98fe3h7e8IY34Nu+7dvwkpe8xD9v2xb//t//e/ztv/23AQCvf/3rcddddz3pcg1OconAHgnJA/HS3f1V1ct9RIDRUaGnZUI3bJ/6P5dun5lVnHB/eXM7YKsgSke2r1zIUo0Bx3PhNZG/idzbsrtTnThduaMsd2dJG9RHABnyzuYs1HXrn0i8onx+cW9jyYFJj64AjOAFRB/H7VYrZWAW7hZr0a9sykUGUIJEWG0MWQE/NT9TtqxS2Jfl9YIFgoDQEZoN0LlbQxKIdAzK3yK/qAlFXB/GNbKmOM3IVMOXR7xHXlAxysRjWSdxRZnIhCp6YmEAiMv7+MdomxZpOG2U6ZQpbcfQJ5bw9ZElJn2+aj3fDhNv4rs2VMgz8hPxx+bCEwJN5E6BY/IRLtvkAxL4WNz4qGf7XbCplic5rg2Iw6e+IrUgH0z8xd0zvv1cmVkjSdpqbgwRmokK5XC3q3O7qhYwxtj6jAFyJKdamM73EE0rgkBye/vpRn4Xogs7pNpF7NOCDZEQjivHYAeZObSPkKxEVFaI59uJ5yWVH4Y5LUjnmfh+pebFk5BnKLl4KpzGW/fd7+zsRATkZuIP/IE/gHPnzuHy5ct44IEHPAH5vu/7PjzwwAP4gR/4gRNZnOzu7kIpBa01rly5kg3Dz5VST1u9n+141hCQ+++/H1/91V/t/z44OABgj7r9V//qX/nnH/zgBzuqxF/5lV/BAw88gNFohK//+q8fzEdrjXe84x14xzvegTNnzuD5z38+6rrGRz/6UVy9ehUA8PKXv/y6bwEdQp+2YFUCkYY9yS7Oynnk8kpk4sE8kzKmC1wokEj7JOXryzslc7mwaR4sfAo/D/+Kd1idECYvaoNxTqzHloDomqDHBq0iVkBYQuCEI9W43VVYYYrt6E2m7605FQV7d6mVYFJBQLBrCgI72+rbelktiDIIJyAxCXECrGZndEK4nd0RD9sGQSLyxewIw4IsOKEiCInkpW9DFO5zEG1vuA6Jj4b3Z0lJR9penJ4Pb+JxK8MlQjuTM6MBgul8W5FAKKVF0W9WMHLma8tIuKGOmZ8niNxPcqefyKXrNGxJnbKkPyFZ0lTLSHI79L1I/pum6YmBSIo1fcTmV3Cnn7kseOwtnFlU4lvSjhGdPgXAmU+Z4CsiTLWY2Lcjiu7TSX22fFndN06NgRIqsXbsDlUwSdpk82Snej0C5lsEPQlE3ftiJeNRzu1M9AwhulQzJ6zHiSB8QxHRRRC6c2mkz0nkv+I60amTqMtJ1pD4+wjlMhBzRI5ECWK0lIRwmZ05XFTsnjo/00yynk3I+dZ+8IMfBAB8//d/P37wB38wCs9mU7/4i7+IO+64AwDwa7/2a7j77rsxHo9xzz334MEHH8THP/5xfP7nf34nv49//OMAgHvvvbc4oD9FeNYQkMVigUuXLnWeHx0d4ejoyP/dtm0nDJtfvexlL8P58+cH89nc3MT3f//345d/+ZfxO7/zO/jYxz6G4+Nj3HLLLfjyL/9yvOY1r8ErX/nKJ+XEDiRkA0sm71QoOuFkuCx8X969ZcosYkvz6dkBsxll3qfCXi7eknJ2FpkTkBhe7OJd6NikKHZaJi/kVFNjj/CcGTQT4RPCZXCkxdTWphzGEorKmW+Y1oTL4jJCMgtCMAC11v9D2sv73Vxhe9aOQ1w9cvUZ2V1vDVFH4duhZNs6EsLaichsSrSbHJ8dYuAEPX9CkoIzD4rr5oUOKYAIsifz9WRExWWRwopRwm4/EZR9OXP+Ja6sCZ/rjrf0e+C2CEWI4wnSFNXVmHi8+vHnjltW4cfuvnM+oQAk+yBDsKXJmyeB0bfmPhoKfy/baOgSKVF/Ct8GEwpPJFx63lndaTKA0J/tmPyx0NFFl2xGFZl4kdfW+YMN+NQrSTTkaXAU3nntkyNKcNpJJS/GhBB0FaGeaoyONNRCYb5jtTueWEuiFvUSOhqQlIikQr5set/uSMKuQiRkWjz+hNCdNVdFN10TDxufroyTyxuZ9HxbcN3F+2isIrRV31wekRAOi7i9ozqkpFqQmzTsaYA9BevGFuZGp3c9uHjxIp544gkAed/aCxcu9Madz+d4/PHHAcTy35/8k38SDz74IO6//3584zd+Yyfe/fff78MVPDV41hCQL/mSL4Exy2bXPN785jfjzW9+80phR6MR/t7f+3vXlc+qGJrcBrUfvLPo3vVCLKonRd+uEOffydsk75csPtmJvE+wGyjTYHoinlTJ53a+c+lG5kmRMEWBACQ75tacw2oV6qklBM2EcHSbQrMRBKZo194JX/5kIRMLltoYZ/MU6tM5FtUJpGyapQBnZmKFOpuJFQBbKdzXgOZwiWBgd5bJylyJvwMLc5EAI95z10ThhbAddWWiUfJtK8NLkpMKRpFWxERmXqxx8OGqRFY3cVqWyJiYhMj+z4y1rJDvEvTjh+ucEOGEN2TbzpdB84V8ZHf+nXlR59uTY1ecBuXLD4o0OUZsonhB05ljRd962s9pfVLI/lOhm+WpWp4UaCYU8ohedwQwX4y5wv0yPi9/yWVwjvcEoxW+JToRbrl/hWbTth8BrbhTxcCbg80mQH1QYeuxFqMjDaMUaEOMV9m2hOCzlQrXPfNmh4wm7c6mYSTz4PRyc7VICz35SqF8JaFbMqNVkObJbcH/XVUWNqHeqXbEB0kIhm8n9IQR5TtRGxQ8afzQD/0QjDHY3d3Fi1/8Yv/8P/2n/9Qb561vfSte97rX4c/9uT+Hn/u5n+u8/0t/6S/hne98J376p38a3/d93xddRri/v+8vIPzar/3aG1eRggjPGgLybMZKmoMMoYgmzxUmytxu1pM2bZLvl5Ei+f+EtJyIfKTp9ZTH75KvQjwgSEebLGiifN4MIzUXcmY6LPTpkb3sbLEDNJsGakbWsVUIH5oL54i1PM6XWic7KSlxANDW7MYfdSsvvXMNqwyCHTWbVfG9DqPQJmxWBRPfZs1tIc1IUmIsd/Hl+6iJc4s923ULoTYQgJiAdMyt0C2HUcYLpx3BRhIQR1JSTZRRttCmcgSGd//dc/tjQMr++B3jVkG3ZB1HvITtCuC0FrYPKJRblCtqpvQZJfVtCSBAk7GE06UdmWtJAuI0BB0BzCD41qR5SQKUCGCr7Gin3zC5/iPRd/JGdY6vHJnw5MP1l+YjjoX/hjRDY0JPxvUf30MyEsf0Cp8UteierhVpMZ0TPR+lHNozOLiDQrh2DWg2bBqLPcLo0PmNqKDx5LpA5OHR46geNS/3wwCJ6JgMESI3sazJlIw3MK+nafeuP9Qfb2k90jJk/i/JiU+mr9wp0UjWmt53GVLkg8j2fZqhodA+A+8B+d3f/V38m3/zb/DX//pfx4te9CL/fDqd4od+6Ifwfd/3fQCAb//2b+89teqkeMUrXoHP/uzPxkc+8hG87nWvw9ve9jZsbGzg8PAQr3vd63Dp0iV87ud+Lr7ma77mhuRX0EUhIKcYy4RrP+EJAYMRTYaZ8ClWmTxXIiZ9AklShlzdOuVbMu8tFczSfJKw0e9cmExe8nhdHyX19ZBOvk5IkQJvO4Lf5a1mCDb2zkQLcMLPiPMOK6FCKAcQfnOcShtoY/9gIsJHoNoyORIi7gRJfTuk+ZKprFCqhY0C74yTQTiNKW03QRL8jr4kPiYvvEoSwgKZNGmLtBqV8c885EEAIv+cVsGA03QkpTYwtQEqA9QaqtZQlYFS2pqxKYOq0qiUxrhuUVctRkpjUjcYqRa10lAwaIzCrK1xtBhh3tRoWoXWELRW0JrQtsoeRSwkF2MAoy1hMUxO3N+W9BLQUmc8R2TNawHCeCM3Flg4N9q1b4WISPu+zIzv6JsemEM8eZIEkMJYl9+EUbZ+ugqmTtIEzpchKY/veyYTdRCU2bRQNXltCRMPJucAgnnXwl2GuIjJh79XZESRmRdrSTzRcX4EXE7VAPWRvWHdOta7/PgSTcCOZSPKWQFUIZyW1dfGohuA+BvywvfA/LzK5gwHXbYu5MyRTgwmDgPrXYcU8O8cQWBwuD5iknueISE+izSvPhL3NOKpdEI/CU7qk7tYLPAjP/Ij+JEf+RHceuutuOeeewAAH/7wh70J/etf/3r8g3/wD55ETWJUVYWf+ZmfwRd90RfhXe96F37u534On/EZn4EHHngA165dw7lz5/DOd74TSt3Y9iwIKATkFMLbG2d2lYBkssuQj1W0HX1mUX2LwODzRODo08r0TdK552l+Q+3RyftJbtikC4q3DReCv89T7F7qimJh2CQ/XiCD37WtjhHu5kAchgB/TKiXshSiy86kGQ25+HD+KCzgssClfZ1sQ3oy44RT6xciyIqoY7wSh/ZJd9m9diLX73LhHhBw+Whg3xZek2NiLYjXhrDUYDPLHQNrw4uTmXxa9jdGGmrcYjxpsD5ZYHMyx+ZojvV6gVq1UGRQk8akarBeLbBZzbBRzbGh+GeGETWoyGCqR7jWbuBau45rzTrmusZCV56YNEah0QraCQoalows2gpzXWHeVli0FZpW2WfzGs2igp5XMI0jIprccbHuo2CH84RoWcHOObmzdkQQkYhYO9MsJiJR/yV92JFJkm/d9x0F/w6vcXBpWqLJ7AERsQ1jyoRvh8ksH3jg/ubvM9KWmDCW2K/JXjIIP1Y8YXGXIcojcsN9JLC3sLPJFo8z55ROzsHdH9drYE0U52TTbKy/VrNG0fchj9v2mxNuo4Aq930uku8EcXge2x0BWM6B3I5wfQA7/uVGB//2SSTCuH8sww7MsVmBPLPOLDV36iQcfhsgbHzw3CPfSXKQpiNJxhAJSaOla8IpIR2nESf1yb333nvxPd/zPfjlX/5lfOQjH8Hv/d7vYT6f47bbbsNf+At/AX/lr/yVle/4OAk+93M/F7/5m7+J/+//+//w3/7bf8Nv//Zv49Zbb8WrXvUq/ON//I+f3F1uBUtB5nodJwpuOPb29rC7u4s//Np/AjWx51Tn1NqMQd+LVZGbSFeYXFPzDc5fkoAsOYF4TpmFCkm8XNy0rEC0e9oRhgbqkKrWs/GEo3lUJkk+Ru4EKB1Ov0nT96f9KHiSYJ8LswwmC/IEIEcOwglH4qJAaZaVXHbojyZlJ12WVRu+Jd0JUCauB5uZ+PbW/X0md9BlX/tbv6tM3+TaMWmnYJZionS8SRQLo14o4YFA3T+VsSZU7odqA6o0qLIajdGoxWS0wPZkjnNrh7h17QB3TPZwtj7EGi2gyJI5RQZrNMemmmNbHWNTzbBGDdaoxYg0Rq4BjkyFfT3GVb2BQz1BC4I21jSiNWTNJMQuZQuFhan8z0yPMNUjHLcj7DXruLZYw5XZBq5N13A0G2M2HaFdKJiFAhoFWhCocT+peaBv1JRsUKQt6pyk1UfiZNfJPjf5sSC/kXQMSNIjx0NUZh7roj89AUkd1Z3fB2R4ec9HLci1ceRjDlSz5DJEFd8rokfuuyRBWkQ8f/gEX2hYu80IEnUwok0p/hb5UAdrtmW/P85DHh4hd9z92E7nMBEumnvF99KZX/v6tPMyv/7k5ubOs1yafWMqrYeog0y3c6oX1xPd8du79qRrRiZOp1w9aBZT/PaP/yNcu3btph/byrLDf/iNz8XGdrU8wglwtN/iL/+R33la6lXw7EbRgDyDkBP8woP8JMvxlplz5Z4NxcstLHJCl7uYnYVm1cUvs0issguVLiS+bJ2AcZmyi68Ulkwoj9zV5fP/qQXqY4N6aoXkdkxhp1P8eLOhlpxDt7G70grQ2u3SJifw8M6vPaWI3NGkxvqgs9DJ5YRxjuacAHmTLqMA1LBmWiAoGG8W5Xdv4RzM0zbj/hBaHiOEvbQPst0shATZv7JdbV0D8bBkxnQ1HoSgwVCOYHB/u0KQMlAjSzLGowaTUYO1usGoajFSLdaqBhv1HGfGxzhTH+H86ADn6z3cVu9jQ81QQWNhasxNhQUqVDBYo4X7aTChFhUZTz5YVlSkLXlRGhVpjKjFGC0UaVQwqGCgRMNpQ9EtxgtTYWpG2NfruNRs4WKzjSfm23h8toPLsw3szdZwOBtjOh9hPquhpxUwV1BzR0haxLu63MY8lpQzNTLi3pAW9tZuFUiIHPNAPCf4zy8ViNPvXhLQdCyRzbMDIbj7R14IpQxRQf4Y7EqQD5bL2LGd/T7ckb0cLyIf40Ba/GbAwm4yWI0Js4LwXUtiYMtA/pQ8Ng2T5VaNPRFPHwGzRmGxReFgBDa15MYeIgjovovm4dRcMRc9ITQdkslh0jwG0ovKnpTVp5d7T4hPF3Onzhk5dkRa/jcTrf5ihbw5nwyklmYVMrIKSSkoKAgoBOSUYsiuNOeD0PsuJzgsmUyj3eihMkQPEBEF/zu3oPWll5CPuFDoCCMd5NJ2ZciaKeSQW8BFntLJPCJ9rRVK6pkVmmbbhMU2E4UgHPndfCd4KZA3M2FhxBiKd4W5vJy/KxcpgmlgBVkDKEPxjrE/G1bctO52crU7phfG3jPSMdlgAiTbJDMu/LGg/Fq0FxnEp01xPE5HEg5P6EzXz0MQENvmTnpQBhhrVJMWk8kCk1GDutJesCcymFQtNkaOYIyPvemUgsGIWoxUgxG1WKMFNtQMm2qOTWdOpY3C1IxwZCbYa9ewr9excKqhEbWWVFADBY3K5dkawtSMMdMjTybStDfUDGu0wNiEsioyGEF7TUpF9r7IBfYwHV20GpX1DVxqtnC53cLFxTYuLzZxeb6BK9MNXJmu4+B4gtnxCO1xDZoLzQhrOWTf+aEhpECFyDwrOspX9n3yXdgKiPe5TQQ5ZjgNScxlHAMQHzmckhsgKoucF7zQyUKq0JTInXHp96EWEP4iwedDkg/DpmrsrD43QTthErLjnND9wQeirSRJ4vCLCWFBhMlVjck1DTIaZJQz2Yq1P77Ksh1Y2M58oyDEGwQZ8tI7/wsin37XJ4Usb2eel2OLMhwkJV0JaUmGZq8plixLpz7p+EnnsGStWGoq9jSiNYS2b9F+EmkWFDwVKATklKLPNKnzXC5GuYU/FSKvI99cOdL8e21+B8rRm1eapkkWroEFYCmR6SEuabyOPbsUlOW9HRxEB1OJdmzJx+yMQeVtweHbRGoAtPsPtUHgotZA6aSgypEGNkWCXZytEBc6P5gmGH9zsyFyArJNM9JAOA2O3MnldKIFnKOrWGblNEiHhZ/7PNJuAJEgwjvjvcRDOodXJhAQZQBlzaiqcYuNjRnObx3izo09nJ8cYKIaVK5VFRmsqQW2qinOVEfYUDOMnbTZGmv2NDcVFqbGwlS41m7iWrsZaSEO2jVca9ZxbbGOa/M1HDVjfzdJpbR3PFeu87VRaIzy/jeKDNaqBdaqBpv1DDv1FFvVDNvVFBO1wMiVp4LGmlpYgkIzb95lCYnGOTXFGTXDXdU1HJoR9ifruNpu4Gq7gcvNFi4tNnFhvoUnjrdx+XgDe4drmB+PoKcVqAlaEbib0j05ZOdpOD8RCpdYegWa+DZS7Yf/nfnGI41hTqgVz/uEwg5kHh1pNYxt1jx48z8DKFcv1YgTr9xJWWwGKR3OJfmQmo+us7o7YYsvG03NzdqgaYEJc0k7JrTr9lAKagmjQ0I1M6iPja9DRP4H5ubeDaaMUC/LljOl9bNJjhwi9GuvWWxffkgIjftjaLMt7W95aSATBj9PpeVHqF+6CcJl8GO3p7yyvhInNc8qKCjoohCQZxjSnS6pvl7Jtjc3cbJgnJl4s8iVQTzPakc6BRK/+3bh5PtM+XvLKhc8ucBlSNKgjXJSXkk+gsOsQbj5O9zgbH1ByAscuo7Tkr81wd5ezseGGkC5k7O8UKEQH7HLQjo5QZEviAMBxqBa2N+qBUzDJ1zZ92zPLvvR31qekIaobZjcIAgBsm1SYSk6gSr97dtSEA9PSkzwG6jcyVQjDRpp1KMWo3GDtfEC5zaO8dzNq/jMjSfwgskTuKO+hjVaAABaECrRqS0IC1Pj0IxxqCfYb9exr9dwrdnAlWYD1xbrOGzGmDsncW0IC13heDHC8aLG8WyM+byGblTw5neaGGKNTNpegNUkKI2q1qjrFqOq9WZgtTPPUmRQK421aoHNeo7Nao6d+hi79TF2qyNsV1Pvc8KEZY0WOFcd4Ex1hOeMrmCxVuNQj3F5Zwufnp3Fp4/P4NGjHVw9WsfRdIzFtIaeV0Aj/EUSnxH7nRhHKO0Flt5HQ34nLAgiFuDSne6VN04pEUz7whC65lfRe7IEFfL7hLupHsLnwoTb0Y0jEM53I7pRnYXXxOxKLcQpW07rwUf8ptqWlOx4LSqPb8BfrtiOKSYaglDx3/IbhGsvaYo6pLFONdvc3lIz5fsXPV2RmYNzGoFIcyzLT0kSksnmsqMkLPIkpEN+kV/PclrwDjnJlGWp9l3k/XSifQqO4W1PQ8UKnpUoBOSZgqFFxqBXAO/MHemuzxBhke+XEQXkJ+4072x5+ojTwA7b9ZqR+QVG5isFxrQsLDQLfw9fLqH18CYfrp3UDBhBCNZC8PBQIW64wZqsLwdrRNiEQrsjdp0Dsb/ngwBUQZNib8u2hVCNE8J0OOHKkIHRFAlJHeIgfwuBUwoAvl3TH26L1FRNJWlL8ypuXycl+rgjDYwM1FqD8VqDrfUZzqwf4+zkCLdNDnD32mU8f/IE7h1dxB3VDBtEqMTgb2FwZAwutyM80W7hsWYXjze7uLLYxKXFJq7MN7xz9+F0jMW8Rtta9ZI1gyN76pRw9Lb3oXQlm9TRXo6dRhk0CpiyvwqJ3wSr0VEGqjZQVWv9VeoWG5M5tscznJkcY3d07LUn0nRsW02xXR3jjDrCHfVV3IuLeMH4CTy2fgaPbp3B4/MdPHa8jcvTTexNJ9ZnZF6jnVXArAItCGpu6wYeb9oRQ5DtF3kIgXCkjv6GqL981Ef+edyzQBp9g6k0y2NKSKOrkBs3bn1QHY7o9Vog7ycSaz6ksO9PyZo7EuJIG5tbpcf0Agj3kTTOUV0QFr4rBHCEyLV5s0ZoJ4R2BOixqK/cADDGb3CwOVmkWR1ol87mQTrPIfMcMVnx5YAgLn3zviADmWSjcDnC0K2ASFMjnlOUIGY5EpI8k+vAIKHKvE81TafZJKug4DSjEJBTij4twlItxQqT+HWbdMrJPElnaXlTkrSsfLlVi/LvT7IAROQj50Bt4gWGiQXf0BzChJOogCBsGxUED9WygGN3WP0lfypZxNyNzOzESi2gibyNOYzbJXVCjdbGCseChBg20Ro5nxK3WrMvhy0v2RN3jLhwTwrLoC4J4ZTSBT5ZmFPzKtke/rQin64gGZ7cJVqPkQattRivL3Bm6xh3bO7juRtXcffaZdw5uoI76mu4rTrArlpgzeU9NQYaxu//LQxwQU/w4OI8PjG7DQ9Pz+GJ2ZYnHewzoac1aCbMlAzZjXQ5TrxTP3zn8d/2qFlHKiSB9UJhTvoW/xdClFYGUwUc1wZXxwYYaVRrVuszHjXR/SMboznOTI5x19pV3Lt2CXePL+GMOsIt1QF21BR3jS7j6tomLm9s4fHFDi4vNnF1vo69xRquTtexN53g+GiC5qgGTSuomSMiECTE2PIzSeAjetl8ywvqAzvYsp6dHW/5/xwk4ZBjiB9nNhHsc+PmBvJ/+5O++NtT4bQ2f6eIOFnLHusrTK/YX0QQF76J3ZIQG9ffEdIEHxMyxh5WwSdyJRsAuiaYDeerJTSCrIHhDQlDsGZeI3i/Mz6uN9L2pm3uOyTuNw6Tfu9p+0fPWZjv2fihtG9d5EETYvS85zSjB3E9pLnndS1tRiwnT4ZUXO+6egOhTTje+8alWdhVwVODQkCewchqKXogJ/GVzSPSBYrzHCIJSMJm3qeLTu45x4sEjDTf64EUKnW+LeQuvRVKbAC5exqZiPGipUKD+ONMWwCNAdU2sHHCi6yzND/SThNCTnAlis1FqAUqd6KO1ujYnHtzL2MTZ+GHyyYvMOwIKsqEm7BzgqEUIKVAKDQ58pknFEww0vfE7+1dCagNTO2Ix1qD3a1j3LG1jxdsXcQL1y7gBZPHcVd1DeerBdacYHlkgEfaMS6027jabqCFQgUNRRpTPcLjzS4enp7DI8e7uDTdxLXjNRxNx5gfj2COaqipQj0ndwM2dUmpCW3v+4vitvR9LwiI311PNCMR8c0SeQpjoQZMbaDrERa1wTz1hxlrjNYX+OjWedy1cxtesHUR90wu43y9h51qig2a4Y76Km6t9vC88QUc6Qn29DoO2jVcXGzh8dkOHj3ewYXDLVzbX8ficAQ6tkREOfMsK3vYyrOPCB8jDYLXgDBBSeeidLeYXHInEfA62kyK44dNBZMnIj5yyDvrqM6E2DCBgDuymomE8fOfduZa0THXKpTHO7o34fvTtTPRFBchMvTIVs4TjsaaYbLZWDUHVGtJesPH9Y5ci5rkdK0UFPrHz3fp3NxhHi6si89p8J9DWoJ0rUifDyGaj0U50/HDZeOTsdLwEh0NTu55pv4hQxH+lMvixQSr4JmEQkBOK/omxFw4oCPIpEiFg1Twv26tSFqczITd2RWTZUL8vNc0LCUe6S7cEAlLBUC5CyoJBIcTwgkL7tXcoJo6wZ8vNBM7lfLkG7afV+JSNBZIIgLCwjs/E4I5ubSVCo0niQhfmmZaS26MOwoYgHOoNeC1mZ2mO+YIcuzwc5OMFXSfec2QFLBFG0bPCEG7kZhMGHYyHxuYsYZaa7C2vsDOxhS3bR7g3s1L+Mz1J/CCyeO4u76KW1WDbVUDqHFkWjzWVvjo/Db83vROfHJ6DtcW62i08idLzdsah80YB/MxDp0Px2JWQx/XUEcV6qk9IMD7QrjjWTtjT9ZfCr9CoJPCp28nqf2R6ej8+MudkqQrfklB+HZERNcV9KTG5c0Jru1t4lPbu7ht63bcubGH2yb7uHN8FbfW+14jcqY6wh3mGuamwnQywuX1LTy+uYtPbt2CBzfP4bH9beztb6A9sMf6qoVrG4QyG8c2CBSEU5P8xE3X8QfICYNRgNxj9v1I56oe8pEVFF0/yZvOO6fZsZbEkYBq0TXZ0s7sqp2gQz5UG/w++M4eQ8HHJCI6oViB9Cz4bhGudwinGqCaa1Qz+wEtNi2pIQ0o6ob3f/M8nM6RSXtFTWZC0M7nkOR13UtHjgiJNSPVEnIwSt+JtbKPbMiwTKAijY9J3nFaA2Mq9R0pKCg4GQoBOY2QC3ayk8hYthOzktMcEK8evPuXkJWoDCkxMj3PRRkGy5osHn11iAQPQSBywmLfiuiFRt65lvlK4cYTAbtCqdYeu1ktDJoJYb7rTCDYQRchDgB/XKwG+SNyAbeDaYIwZZRdTOXJTyywRiZMYsVlEsI/xpXB1Ca6/Mzb1yfO4VkNkmsz2z5CC5K0W6T9kA7miRAX5SPISjjlyhGP2hGPjQYbm3Oc2zzCHZt7uHv9Cu5du4TnjS/gjvoablUzrBFQEeGybnBV13hwcSs+PL0Lv3twJx7cuwVXjtYxm9XQ2jI4YwCjyZqqaVeflkALhepIoT6GNTligZPNrJrgFJySAylgRwIvcR/B313hSWni9+NJhmhLk+bBY6KC1YRJ+PHi0j4mtMeE9lDhyv4I1zY38PDGGZzZPMbtG/t4zvoe7l67jPP1Ps5UR1hTc4zQYkdNsaOmuLXew52jK3ju5BZ8bP1WPLR5Fk/sb+HwcA3tkTBNc/4vBDfmmCTLeUZ+7wlBizYINMIRvKkgmUOGeMhvmXQqPQfhsTOnQPSH7F9HDCHGgmpMuKwR7r4f7y8iHNaFORWbbCkxjqRGMDs3GWHmNYW/EFGPCHpifUNMBag5YeMiUB9pT+rbCbmx0G0DX0d0BfpUO5FrOy5btsjXK3DL+WnJGgZ0hXxyaUSbKSuUpVdjk5KQZzg0bvyxuXp5kIKC60IhIKcVmZ2s3gl7yXzTsckVacaZrF68ZejsoveVMSUBKWlZkbwMERn/nslHTiCX5MOVQ7mjafmkIF0DzQYw3wFMDdACqBaISAjICmh8oZtpxSVkTBxcAQLZsSurdhePpTeIs4O5caukvxXdGKAlbxGjYCJhV+5+9rW7/5PlF+MEOlAnTCoI9rYd0LkwjIUwXRuYkf2htRZrm3Oc2z7EXVvX8PzNS7hncgl3ja7g1moPZ9QMCgZHpsIFXeNqu4HHml18YnYbPnZ0Hg/u3YILe1uYHoy9QzWf7qS0qJMjPaQJ1AD1MaGaWWGR6xWER2duw4KPsMWX46drQuXGihgL2jnZd3bY2zhcZ7w6YVVXFN+vwe0o/H7QwtZ3TlAzgj5QOF4f42h9HRc2tvDw1lk8sHEe59cOcWZ0jJ36GGdHhzhXHeKW+gDb6hh3ja7gTHWE86N9PHf9LB7aPIdHDndx4XATB0cTLI5HwLSCmSrrsN66+mo3RkiMZ/7TiAsOhe8QaxHSneV4w8TqV3qnuwzRCS+T9kpgEOeVmxf89yrKG8Zv3lldOXPLap4cuUsUyDdfCCrmOn/C1szeIVTNARgDPbLO6M06YbFpNS1qYcdufQTUM412WlniwWmlc2Y6tih5n21cV26V9km3z7LRM6QvO08zCVlWHk5TJiGnJpPkyWtIbg1I1heDnnB9yKRbtCAFBdePQkBOIwYmtM7imYub2Q1M4/ZNliubZp1kss3UZ6gsnR13DpMuoLl3Ofid0iAMdYTjRICOLgAjOFMHu11WzQDNtu+EsJvLYOGb/TkMQC25CwnF5WKcl7uFmeSpOoB1TocTOI394es6FGAFQClAibqlQl3cwD1tjpiIdLRjQKztoLgdI9MyFt6dtkPXgB4bmElwLt/ZnOJ25+PxmetP4HnjC7it2seaYwZX9QSX2i081pzBo/MzeGS2i0ePd/HE4Rau7G9gfjAGHVeonPO0NX0h0CL0X9C+WCZX8YlGi7is0vxFLUw4MjU5fMC2kYkEvnTM+L7XBNMCHQ1Ia7VhuXHMZNSa33X9ZnTl+twdVgCy48b6LJAVjqcG+lChWa9wcX+Cy+ubeHDcYDJusDGZY3cyxZ0be7hn/TLuGl/BbfUeNmiGe0aXcKY6xJ2jq3h0/Qwe2TqDR4938MThFvYO1zA7mMAcV1BTglqQvSkx1QCSIx3GOId1ip3z/Slb4pmrnxxuBs7IKxF6e000Zdzs1epA53QtwwKwPRmOfD+GG9ilf5O/5yPnrJ5ebpi0C5MQeSs8+5nwBabW9MqaeLJvialsve0JXPb/ekRR3tGBEsn6wPPMUuE48BjRjrLxEp43sA71Lhncf0MkpI88iDKRiO/j9MTLalB4zuwWPTxP1qw+f5fo3SmAhoK+wT4gNzq9ggJGISCnFIPmSP4h/Aw6ZFrTi2Qx72gtcvkni9lQnE75ZNHEjppcmHK7mqnpQmoilkgu3XKnPyJeZCJDVnghE1YnL8BWTtDQQH0U233n2sU/q51A5siIaoTgxsSBd/E0YDRn6siGEIBMBRhN/lQSv5Mu+9ELVciDkt9ps7kxQ2yKJYkaRHsJwZifR8SEyUcN6JGBXjMw6y1Gm3PsblnicdfGVTxv7TJeMHkCzxldwQ7NAAB7ZoILzQ4+OT+Pjx/fioeOzloh+GgN06Nx5Dwejjslr5GKbrfmMrKg6E4nk9oLMvD2/tZ8Rhyv7OrhfTBkU3qhxPVHpP0g25fp96JZYBU3fTORS8y10vbUNYFG9vCBQFrIkxFTsSBM0A2gFgr6UMHUFRbVBPORwd5Y44mNBo9s7eBT22dwz+YVPHf9Cm4b7VkTLVrgjtE1nKmOcOfoKi6ub+ORzTP41NEZPLa5jWsH65gfjqEdEaEFdbU5XF8FQBt/jC9p6s5TPPYBS06iwRiHy0uM4nnm+4viy1dyXjJwGpcQgQm07x8Ff5qdPzTCj6n4xCtvwsd+PO7kK39/jyO8fIpVNXOE2ATy0Y6dczzBH9Vb2c/DmmQpdwJXDUtajSBOyXzORLUzV8q2c20UmWZJ8pJyNzmme9q4GyAmBL39mYbLxRPrhQECqYVYWzJjIktCMuXJanIGystxCgoKVkchIKcQK5EP/7IvkaEM4rl0FXOnrE21FOr7CEZP+YZ2lGwA91oIth0ygXzcrImFiZ8H4YB8OHtUpwnxfNhwSg61JjiXE6Id61QDEDmWOwJij+klL4QCiBzVYawpFXjLMRFKeTc/HJGaacNUoEjgtRayvZJ0eBc50gyJn5xpR0Q+Kks+2omBXtdQWwtsb01x584enrd1Gc9bu4znji/htnof2+oYI2pxVa/jUrvliccD++fxyN4ODvfXoA9HUFOFakZ+h5k1Umw+xYKcJxBSENNhp5qMO+7UldsKjyY4D0ufAl9f189VaJvQfuGwASAQgZTgy7A+D+7qiuxYdBKV9DHhE5RsncidkGbj8vG/loBYQsanoNGCUBE8eTIVoMcK7UGF/YMRDvfX8NjWNj62eR63bezjtskBbh3v4/zI9skZdwnibaM9PHdyBY9snMFDW2fx2EEgInQkju/leirEWjRRVkuYwzcHp93zO/XcbLnvOxEYvfYxM26XzjsinXxAVwT2wRLEm+S3ymOmCRsUts/gHc/5iN/ofhG+HX3htGGw/deOyTq3j8ibQfkT9bTxhMNU4kQtnhtb6/sktVHSkZ43VHz78Lwq2tf/lnNIhrhEmxKiDzpaQZkWQhgjyyD7xcTh4kxF/yv3f+Gg0FmfKMSRZYrqLOKl61VHezKwnsn0n060RqG9wcfw3uj0CgoYhYCccqyyq5KSgjTOSjszaZhUyFwhH7nbvBJ6hONowcgJyxmCIXfE0vfRoshp8vGbTnir5O3Gsp7SKbwCSFE4jtcAfHM0FHmHYb9AGndaKZtkud1TqgHDtvsLJhwIplmte2aC4NMxh3Dpm7S+A4hIBMLvyCwCyW9JpFIykkKQDz0C2jUDs9lgvD3HrbsHuGf7Cl6weRHPn1zAHaOr2FZTAMC+Ix6fmp/Dx4/P45MH5/Do3g7299aBvRGqQ4V67syr2m4fWwfeYHvvCR2TE238zjQTTENWsiLtyMfcQC206wMOQ516GkcWokvxDMLuszaOIIqIxkTCDLUmzkcR9Ej5E5M8oeG+UY6JwkT9xCZbpoI9iKDi458p3EHDAh+P+TmhmhH0MaHdr3C4PsbB+gYe2djF5sYM5zaPcOv6Ae5au4o7JtdwrjrEjjrGzuQYt4+u4TmTq/jUxll8ausMHt3fscf3HoxBzj/E3xLP40eOTX9vg4EyFJkY+ijaVVHBHh6A0E5ZOHLoSSXnG3Va3H++WNGYzgxoSTw5aXeCFptzxnd9cJ844iHIR2qypRYJWSZLKNqRIxby9DRBpqVvGPuAEeA2Riwh0pV1TtcTR3oUQc37j+o1abPlmjtdU+QjOdQz3wtx/BypzKTh81tCIg3ZcRITfPgNlnRjJUsokngy/YKCgqcWhYCcRlzvRJgTwHvS7yULUihNX/WlmxFIO2ZSfe/SdNJdLJFv5EDeky960u7Y0rtFnrQlH9XMxtMjeB+OtOy6BqgCQGQJAgvDTpj0pwMhCIbKQNyF4X5gF06/s0jutCzeRecdUr4wsLL26VkSouNnsh07zWsQCQ2R0OUEGv9MljchICG++GHH6ZElH3pDA1sLbO8e47m71/CCrUt43vpFPGd0FWeqQ4zQ4mq7gcvtFj45O48Hj2/BQwfuBKb9NZiDGvVBhYodxlt0tRpiB9oLgezrwxfPOdLhzZ6kBgRW26HmGtVCgxoDaBPeKxKaN87YnTpUUXT0sSc6jfbhvOm07CN3YgBpmxdr0Ugb6JGCIeMJCsDCrLK77CY+oYudoq2jN9l7YdzpTVr6rrj+0jWgasAs7LuaAFNXaCcK7WSEaxtruLqxiU9v7uKT22dx5+Ye7tm8grsmV3BrvY9NNcNzx5ewWx/h1vE+bl87g4c3zuDxjW3s7a+jPRjZU7OkJgBu7Br4U7MIliyxqaFJv2k2S7QJwHQ+8nRgd8dytJufoDuOAyvpIzs50ybVGufXlZC8kTO5cjejh+O53XidWafzao7grM7h+HhvQT5Ui3BvkTzAAJbMAXIes2O9WSPMdgjNpjXnAshp9+AF8nSO83/n1hHxzocRj3o3o0J20dxMiPMPpnBxHlHeUWIunnydvkvTTEjIDYMcF08zNAh62fdyHWkWFDwVKATktGNgJ2gpenaaeifgE5CPzg6Tf7Ek/6Hy5CZyI/JKSU1GKJbl6SwILCjzLiJgfQKc82ezRvZs/VEQFlL7aaOAlmxiRMKZuLN42oLbnVwnmPCOLwsYtZBNiUAqvl2dyQ1gLzKTphBWaDJ+Y9wvrElbeB8Hfi/akRCbIskd5JRYpGQvMjFzR+rauxEM9GaLenuB82f38bydK/iMzQt47vgyzlRHUKRxqdnC5XYLT8x38NDxOXzq4Aye2NvC8d4a6LCyplZze0xuNRc+HYKIWmGMzaacMCj8abyWQWpAGksQ0vGlWg1aaKiFBhotCIjtlxDW2L+JCYiCqSnY4DcaqtGg1jmPK/K7814zIv4mbUJaBpEGxB8oUBGM0dZ/orEdyFoYPXJ/G4KuDCodhGlFdgD5HV8FKNb61bHwVx27gw8OKrTrCou1ER7bXMOl7U08srOL52ydxXM3ruK28T52q2OMqMGdo6vYrY5x63gfD62dw0NrZ3FhYk8kM9MKNFfhIk437oxrTu9f4Rys3adihzK5JudvIEewxd+D06OfB+RWtxzDYbz3ERb/jUjB24ixZUL7RiZXI/e98zzDp105n49qHi4YjYh8Mh96vyU3F9njfY3Ik8KxwBPCSBHWrrSYTO2kYxShXXNl0W7jhL8R47OJ5n5ujmy7Zl7mTHh9k/I8hPhTisLnCEW6pqQkRP5JcRmyecsqpCTkhOSko5HnNE4BASkmWAXPJBQCchqR2YHKqYezmoKhyVnGyU3ofQvLiohsaTPvug+XhBMLQydeSj6S973aEtmOvMAbK5g1G4TFjt3FVwtnHjUPQgIAr/bXI7egOjOelPSwEGw0rHmWO6XK8G6nXHQrZ51C5AXr1ImSTOwk6+vkwqRChG8HsQhHbcwCIbqmK55cZJzNo/fEZiaOfKwbmK0G67tT3HX2Gj5z5wKev34Bt9fXsKYWONITPD63N5OzY/mV/Q3M98dQBzVGx+SPefW277zrK0yvJPGoxIVvqcmV9LPwplat03SIdvKaC61BWluS4uuaISKur0ytoHUF1CpKh+ObSl7i58gFp+VJhhNmGw2zEHk47YVpyGtiWKuiK+XIh+0E4+prNR5dYZu/EyusmkBA3HtdWVLSLgA1J1R8t8hBhcf3Jri8vYmHt8/ilo1D3La+j1vHB46MHOHetSnOjw5wfnKAj6+dx6fXdrC3v4HmuIaZKai5AhqA3CD0mhAAMAaGL1rU/A3EY86bOxnk565kbPvx7f+/wiSWEJXOfJmmJ+ZZ1nr473gUnM1Zm8OO6hH5WATTK+Pu7+H7Xbju1PaMdSPIhyMezYa9GLE5tocPrF1uMD7QaCdi/CCul9zoyN1Rkp3Lk7Ui1cqmmiI5L3WmrwwBkmmlQj0lZYrmUCR5A71kImuG1bfWLEHfeldQULAchYCcQvSZKA1NdNnd/r7dHLHDFsVbQnKyO0SZsNkdor4yDCG3KLnf0r49LYcXOlnQFiZE9idILYbc7iALOg1AKpzXb2pY0yhRH7+DW7urEFoKeZkgpEiB2ChAGWKZM5jncJGFAzuI3BGmYTXtO1o00kShKxBwW8ndRhkm1XpE8frGEOdVOfIxAdpNa3K1s3uM5529gs/afhwvXHsC5+oDaKNwodnBg9Pz+Oj+bXjo2hl74/b+COpIYTQlVNPgXB5pblrx49pVOYdzu4tsvBbKE5HWBBLnKxo0HR0tCBAIAZ933Fq2SM4UC0qFcCzUNpW9XHJSwRBZ7ceitWSCwulQ1BpLbohglAIqZoZxvgTb99ZpnLyjbWh3S3qoMiCjXPuw8ErWrEkIzP6ABNefSgG6gT9amIkkKXeyliF/Spda2D5hInJxb4wrW5t4ZHMHt2we4a7Na7h34xKeO76M8/Uetqopdutj3DI5h4fWz+LiwSaOjiZojmvQtALNuX+co7RrTg0DZelJ+ITF+PNDN7OxAsRjX3R1fhc9asvkz+Qm9W5imVcE79/FBE8K8v6ENtZ8zMOYZc2QFodh+JvSxdwgL0X0pJosyWknQLvmnNbrEJ7HA4wzT5w7kpSuK44gcTtGVXUd0itgp4I+iccizqBJsEyD/yPJBMXhfHri/+mcFdXRdOMsXRP76tcXZ2B8PB1oodDe4GNzb3R6BQWMQkBOOyJhccXdlqGdn5R88E8ibOby6eT/dOz8ZITiSNuRI2LuKExTUyy4gE/B4l1og/qYoNtYAJamP2yiALhy8O5ntPPnhE9hBsTMQ8Hd0i39KmRZlf9vIEpykRUwoGiHN7dQyvJKYdSwkJI6ubMgMaT9cMSsnRi0awbtlsZod4Zzu4e4d/cyPmPzAu6Z2DslpnqERxdn8f8Ob8fH9s7j0Ss7mF9ZQ7VfYTwFqjmFE4Sk74AjhKqx/eLNXbQ9atfem6ChFsZpGBz5aKyWw9u28SlGQPAtMPCmVh04AgBF9rhkY+zvVhre2+fUWo2J0drG0ZaAoLVkw4fVGtS6MHUFVKpLaPwFL44pVOTueTFRXdBWwMhYkcDY4OGELrHTTQTjTPTYF8QoA8U3qCvjb2rXFTmTHDvYNKzvErVOIzIjtFNCe1hhf2OEw601XN1ex9XddRxsT3Dv2kWcqY5wz/gSdqtj3DbZx6ObO3j8aAdPHGxh/3DN+odMlSX4TNhdHYzL1wuiJpAP7ardOWxBCrxpF6YvlsxTfhwIoTvNR6YVCbSCgEifn8hJ3d3h4cmHJwl2/mlH7thd55cWXQJoQlpWU2HJRzMhtBPyR/GScb4lUxuxXVPBWV0n9eB5wGTaalmbSabo+sRrWSUREeFSbW42n7R8HK9PuE82XUimsyphSvLOWRn0/S3rF82xBQUFK6MQkNOI3KTMr5aRkCWTKaef9ang3z3pDzmPp+QmyjtTn2W2tqtoUVjDwAJoKqz73UVxEo13GmethnNIZ3Md5XZqPRFIdtlI1MML8+L0K7ZpJw1rUuVPtGLh2ibIR/JGAn5KNtO8ZN3Ff1bigQOklDU6HQEiESz8Tq+7VLDZMNDbLdbPHuOus9dw79ZlPH/9Im4fWZOry80WPjG7FR/dvxUPXj2Hq1c2gWsjjA4U6mMKDrx+lxeR6VS4tA9+zJJ2O8kzjWqqoRoOy87bQpgHrIROTkoShIM8MTCuvmSFfvd/YiIiyEbkLW0MgBZoWmAewvpwkoA0LdC2gFKgtgKUgql6dhU1Ae7W9igNdp4g7TVyyj1n8yw25fH1IXd3SDSGAinx30TFY5PCnScm9LfXiMwJ7YzQHitcPapxeDzG1ek6Lu9u4Pkbl3Dn6CrO13s4X+/hnsk6Lm5s48HNW/Dg/jk8NtrBdH8CHFfAHK4OclAKEuL6XleBhFDuG0cSXf7JzcfhBz4S73eDJGz6zXGYTFq8WUDaRdPBSb2aO/MpPoFNwR27jHDnx1iYbrk85KWV0fG+7GPinNwBF87NXbomNOvBRMtrVUzS4gR/EIf3CUkJmAgbbV5JMm9Ee8u1QJBEkulgyRomwmZJSGbd4jwp7buUMPWNnZ7y9iE1A+s1B77J0IagV3FkOWGaBQVPBQoBOa0Y+OaXqcWReW8oCZNM4ssm0Cz5IJHuMvKRK8sK6OQrF0GT/51eAGakiZUzs/KOnGSFMXlikHeedflJIiDrQI58yJuONZMQzY7AgHZ+ImEX3zjtBbyfRWprnm0vUXcmKN4BOiMc+TDLGlm0bS/xAPzxou3EoF030NsNNs8d456zV/AHdp7APZPL2K2O0ELhk7Pz+MTxeTywdx6PXN61Wo8DhfrImVs1EJoLhMvcPAkRwpf3/3AnQS0MqqlGNXOO497kzXhCEZ1aRbCd4Y/KdeZVrSMHzjzKaz60SINJRdsGLYgkBmjjoSHyZe2H0do5oVuNCZQKGhIiqxEhCqSEtS78Xo7NxtWXd8TZnIssaWEyQrAajkoLHx/uY6f5sKaBBOI7RogFaRPfbyPMd6i1fjp6RmimCo9MR9ifTnBxdwsv2NrCC9Yv4PbRNdw9uoS7Rldw++gazo0O8eH6Djxcn8GhWodW1kldNamo58i5hj/hTVdBsJXH0YrqdGAQBFeuOyURoyOWTYaEJPBmlQkR8jWQJlwuHB+LK2+991qn2h63q8eJ3wjgyXg1N/5iTcUHGxBrsMLHHRF1AtpRMAdj8uGPd+YNGxLv3DHOkU+IaIOOaa0gEUaQFyn7+9buiev7iNuL41P4O80/9EUcL0uaxNDK+XpE4fj3svkXcbn475zpcUFBwXIUAnIasWRCy6qIV5g8++JLgVPuhPGrTho54gFEC0IfTlSnKGKSV5JmtNHFC/yYrB09H9XKO+m82DJZqQ3aEXktQKQdksI9ELeLCpoMU1ny4TUi5MgIy7UtH+lqXP0cCWHzCEkAkwU4Vfnn2yA2x5JtEwkMnkxQb3tG/cvpVF3ysXHmGM89cxWfsX0Bd02uYKIWuNxu4rHZLj5xeIvVelzeAl0dYXxIUO4SQWlu5X834R4Df3QukxK3kwzAazqqmYaatVCL1gvrcT8ZTwaI7XgkNCwRaVtQI8gFC/vcceBw2msxfPpax2kaY82JdKajlNOqGAPTND4MVY7V1byVTVHZbX6iHNppRzQLcTZdT7L4dDSh8VHc76wlMfBaFiYi5Bm1gW6sJoRJdTsKg8EwWVwQaKHQzkfYm23heDrCtdkaru6s47O3HsNnTB7HueoALxg/ge1qivVqgbFq8Ul1Fnv1OvRhDT1XoIUjNUD8zQEd3yX/kfM3mAi94DT4OwT8PRHRAQ5y7vJpdQl8+G6Y4MJrUDksO9R780xBCLw2z6UlTd5YgyHJBxlEt6qznxNrT7TX0IWyBz8j+HfeLyVqmFD2amHLZW9dd2aoKtQ/nXt8uibkbZxqik/5i2Di/siuFbL9c4QA4Z3Md/XdlCSfHEGRZUBmzUF4npKMpWvk0wT9FPiA6OIDUvAUoRCQU4pViMP1aBlyTuerTJ5ZO9dVyEdmJy1bligz5BerjGDM74wMUwV7atUA9ZFBPbOZafYDYUHBODtzMvZkIV68eXFPFkR5LCg7l4MdPoHYjILC//0JP/oEK5UUBPjRqtF939r/2FOYEHZ+SSzq7v+pqZWJ2tOgHTtn8+0GW7vHeM7OHu7evIqdeoqZHuHiYhsPH53FQ/tn8cTVLSyurmF0tUJ92DW38hcDtsbv+FryEfxmVGPCiUGN9m2vWg2aa6h5Y52+29wHYLwjeSTQM7Fgn42mBRZNIAUsTZEC1RVQiVvyJPlIn2ltyYfUlADOp6OKTbo4jNEw2l4FbvkBOWE2lNcQObJiAunRFD4Px3LJhSW+JNGREX/kLwBT89FmCLvXZKANOfnTHverG4R7XWomMnaMe3Me51BO2t6C3swVHp2OcDCd4GAxwXR3hM9ZfwR31FdxV30Fo40Ga2qBjXqOj49uweVqE4vDEaCsSZYxZP2pjCVDRosxzySCwjcLJh8soLo6sUApNyWyn0yfQJqDnNsSAd3fa4KEoBgWXG0B/UlZKtyKrmvyR3Pz98BO40H7YWISI0+rkgRElo21Y74tyGlnCcoY0MzdF7KwibI/EGC/Pd+Wol1kW/rqM8nLNXBu7pJ/pC/74qcdmBIRQVgH05NJJIRiMIqoP4ePNV9J2QoKClZGISDPAKzkeO4DZ3ac0h2enkkz3fmPhFQZzyQLURp3iCzI8DnkFp5OZiIvBsuGboeRhRU1N6indmFt1gnNul1xrFALf7Eb+xfIYzDZPtoYgteEMDnhvLUT7k0IJ28rhoqL2buL19cPSZj+Xbrui+wdHy4dI4QZaUImnWr9jc4jYzUfWxrV9gJndw9x5/Yebl/bx2Y9w9XFBq4u1vHo0Q4e39vG4dV1qGs1Jvv2SNdqHuoSExBJPsK9CGyuZi8YNKhmrT29ysAK03ya1aIFtW1X4yBNp5y5VWQ+VVeBDDStJR9NY4mBcAY3prYkpa4DaclpPjjPtrXpROWpgvbFGJg2aFOMMdGnRQCoYYHflpVJCYBQH6XC5yF9RYjs37XtSGLSwj4kOpaeSVnzLO/szSdVORJtKme2Y2yZVBtMGnWNcG+HIZBWaBcj7C228P+aCnNdWdvxDeCu+gruqq9gbX2BDTXHerXAx+rzeGK0henBBFpVALmb1A1suxgp5Qnhl7UighRIwVj6AETPuz0m0rGRUn+vFNEGSyKN++AmEBFPglhzIbSlkbO5se1ezSX5MJEGxVRkNSfJSVs+P41w0aY8gMFdjGhcn6rGal2rmUE9syoMXRNaPqxBCRISESkEUzg3R6R+ar5dhiDXosz8lmvbXHyk/ZQJKzVkKdGQmp0hE6vOWnPKSYY2CvoG39txo9MrKGAUAnIKkRXc5cLaN2H2EQYsmfA5bLrTlMu/Z6KPJuiecvQJz5FaO5EYsv4uJvN/ihcT3ilVjVuIFOwO/pqLpghKGRjh68Fl8MK5zN8A7JzLhCMyVXAO5srt3nr7aqENAZsrLCFmg3VetthLwtEjTEV9I4UKFeruj9gdAe2GhtlssbYzw607B3jO1jWcHx9CkcbF2ZYnHkd7a8BejdGh8/WYIVwi6Mob+XXwrm/j7uhwRASODNrnGmruyIZmYmHsKVaLJvhzSL8N/s0CO/thAN4MCpWyAnnbhp8UjrQYbaypFFeDBVYiTySYfBih/bB5afucBwJrPljD0epY7iLyZlxUKWu6BThfn6TDJalSBFLKjsvWwLCdkGYB28XVru6A087Y/leN4yqOAOqa/MlTTBp1TaCRsUe+GndalvN7qmB9mlpd4Viv4xPmFl/MakPj7tEl3FFfw6aaYauaYrOe4f/Vt+GRegcHah0aVkLm70eaNPk5RRJzJh6ufOy4nm5UGB7jyfzH35c0r5LxIvQJwwOIzELFfBj5ZLi5gFpncsUnZS3YX8w4/zR3WtY4HBwQrQGOfEjTRiY57Zj9TNw37Q4U0IcUjrFeCJM7UfaU5BiRn7TKicqCfFv1rUv97DBBLkzfWph5Fq0NYiyQLJsoV1+dZDucuA43AS0o9Uq7IWkWFDwVKATkFKJjg5tOjELI7hCTzGKZ3dUZLADiSXWAfHCZ/CQtF4WUeGQW+dTZsdfMjHqey3ccX9uCsHDBC6tyZ/L7hTa9oCsjeMgdV96xNIbcb3hhmQUhf3yQgTMpEeVdYaFioWo4wHAaaR2WpcOLc0o+2jWg3WyhthfY3TnG7dv7uHNjD7ujY2hDeOR4F5+8dg6XLm8BV8YYHViNhz06N5hVQWg1gumVIxnO7CQ1tQr3ebh7O1od7tOQzuNsZuX+9toJpTw5Ma22khec4AfY6+zZH0OaTFVV5PRt32mYJmk/d6s5hzGsQQHAGgkDgI3lqR3oNG3sWNEGBo4FGGO7qGlhTayEo7r0T3Fl8XeHALZdvI2J8T4LZIzzF9Fud1y5SxSV1YZoa75ltB2/RtvBYZzfifcVMUxqKPrelZf4K0xpDQ/SuVDGDeDu0SXcoo4wmjyCNbKakHHV4pMA9uFICBTIELRxZB5hnEbzEP84YdhfFkrJkHdzWfTZDMxjOY0hmy+Cmz39BqVwiy758GGk5oB9gIz9VqpFnnzomry5VutPvqLgsM7kw31z4XJDZ4Zao3O6FsDfue1vP3eJ8hqXhvdRS9ahdMMp267cTkYI+twWSRP69FeYr7IbaekaI9OR+cu8dSZ+X7pLsMz3saCgoItCQJ5JSCZViWiHCUuE2DRemrb4O5sOJfkN5NWZmAfkMEoXuISc5COJ8kR52sT4ki++EKyG8XbXoS4U1UUeeSnrGqn0mXwYWGGWj46NCFAQOmT9pO9FhFw7De0WCmGoc0u6jLYKYeF2rAA9ju/3uOXMAe7c3MMd6/tYV3Mc6zE+dXQGn7h8DgdPbGJ0qcZo32o8pNmGv8mZtR1OwxF8QayDuSUe9l4PWmh3iaCJTq3yWg+tLdmQvh2N0z4sFr7foQSRMDr4d5CCQQPvPes0Eh7OZ8PeA+JOLWAtB2tRKrcF7dIw0ofEpWEvMFTBZMoJ//497JgxUqvB5dXOKMoIx3c+ulcpEY7Zrb2gUN6wTkb4vzCc/xE5skK1gdEGpnanYZEjIDUBUPbgLmPHhGFp2qkkbNZhQOqRO+jLSd/moMIxreNBnIM2hIWpMN+ocO/4IjZpjheOn0DlPghtCA8BOKQ1aBoBRqECQcM53PMQ5e+Hq+1MhTwJ8d9Cd2hzafnvlOjHGyFDk1TyPQmTRd8iUsg1Ig7PAzr89qdlLcQdIXCO6rW76VwQCV3H5INNF/kST0P25DBd29/ezMudJGfN7KyGa7FuSUg7SgiKn1Ndf2tBRLgZTAgekaykXSOtkyCJORKS1S5IGPSvaycgC+kGW2R6x/lA1K1nQEV1HSrbTUQxwSp4JqEQkFOIjsAodqWyJCSdPHMTYY6wyLi8qA/tJOXKwfnJiTiTfWfhTl+n+fL/h+JRXI/o/+IYUSAc78omQdLPgch085AnXAmbax+O52S3qKqW3MlKJm4bnWkPSZqWkYOehVXuuMb/ScIMkUVXfzYL0TWg+XLB7RZrZ6e448we7t66gnPjI1TQuLrYwKcOz+Chy2cxe2IDk4sVxtfgyIfxxxlHGg9xso8/1crfWg5Qo+2zhba3ifNRs659/Z0djnxQSkC0huGTrFgLURl3vK0wN9LCiZxt7+Rz33AagPVL8EdIpY7unC47jDuCY7Sxd1xUlW3yqgq3qZNK8uDiiPtLVNyR9p3T7FSCfKT3jcii8aldGb8gjkPk6q0V0FbBed1pRJST6jW8DGotvVLpDQZ88SaNmHsTqgowRxWO1RoepjMwxt5PoKFw7+giNtQMd9VXsFi3viKKDD6ldrFXraMl65yuiPyhBF6L4ecJN84QkxBbf0TjPLX/96V3QrY8oteTD/HdcRh58pMPL0+c4vLJbzbpnsh3TAsTRL7wlPhbtCZXkdZDmF5J8uE1H1yeyobna+SpdVOO5rmPrE/XRBzpC3hNbigs7MaGEpsrPYi0131zGk+NQuDPze1Zs+IVkPYz5+l/96QzmP4yUpF+DgUFBSujEJBnGlKikHm3EjJEZhU1cta8akhANmJ3LUOU0p2ntIx9/i45MhY0DuEMfMAusKYywR+BF1OxeJBIhzMLTqPC8VP4dRj3NyjIP14T0UcWRT34bjmuZ1o/SuJ1QAOvZdoZp1V+xzblegRxuWCDjbPHuPvsVTxv6zJuGR1iYSo8Ot3FQ/tn8eilXbQX1jC5pDDes7cvB1MNI7QfztxKHqnr/T3CxYGkjbs13sQO3JJ8NIJ8sLO49O/QLaRvBRntiACCIJ4I974TKgokom2tGVbbWkmTKJAJocHwv9k7V5HNzxEL0wJUKastGWWm2RbBd4QIpmlsmeWpW4DVvgD2Ukt2SGcHe0cmgkDt6sG+LxB15+r6gxaCAG9PbXLmWNqARzORcQ7q5O7sYCJCIDIg5W6xZ4mSs3Smh6QBs1CYHo/xRL2Fj9W3YqKsLdtz6itYUwvcWu/hM9drjKjFRj3Hw+MzuFhtYV6PYaoKamZP2eockGF8rfMcPfnejAsU7dwrF1eeTCeHiPi/gSAhnpgk4dPd8FQgl++FFjC6ZFBZosF3hLD2I72gUJIPPkgj3H9EMTFKhHBTA20VfwveBEu2Ec93xl3Umpj88q/UjNWI/2c3ltBdv7KmuHINyQn4pqfvZRqcd08/DWqhXR2Q1iGNd4rIR4sb77OR8Y4rKLghKATklGJot+lJ2ZvyrrfYSRtyUDcDi0DntCYhTDN6Fw4domTL2JcXEGkl/A3aGn4XPz0Gl3f5jIK3sU42cYUPhygm59N2yQifGuWJhopkolyVfF42P3sCkT9ZpodoZTUX2YRjpOQj0nhxX6rQZnpk0KzH5OMF25dwzpGPh4/P4uNXb8HFCztQF8ZYu0oYHcCeMNaGdJl8yAvY7DMjBCfrXE5NIB3RKV7+6GBtza5ae+O4PwVKG2ty5e7x8CdQMSkBYLS2wj9DCN2ebACuD/m5SxuOhHjnCXJ/cx4GUNprTqxJljVnsh+KMOmS8I7yOiJQXCajNbBoEF1U6JzPDeyYIQ7PBEQ5nYTWnoCQzgwW0b7WSdmRFWPb3rYlgaAtESEmhi5ZQUJYw0isDWhhb2U37tLPiftWxgYYa1SVhjaEw2aMx2c72KjmAIBz1QHWaIG7RpexqWbYrY+xOzrGx0fn8ehoB0f1BO1RDTVVloTIwww0YFgClSaUXEf5HfPcwcKk7CaVkUGTzQBfZ/btMvHljp17Qgbm004Z5XxM7qSrGtEdIVLbykdXdzQfnE6FsEmSEqRks4Mc1+QLCsMlrS7MyGlJKkdCjbwUNCY4fSJvSia6AZK2oCReDtyPmTSXaUtSf8VOmmk+mbJEprhD5SwoKBhEISCnELkJbdAHQv5/aHcnk0+fj0afajxbDiHc+l1BubBwen0LNMW/OyZewq9AEgFqjT85xiigmZA/JlSarcqLAY2i6HhLTzzEJYVRfdmpk/NtjUtf5COEel/shFD4+vtCORLCu7jL+ivXxisi7TNJTuwFgwbtBNCbLSY7MzznzB6et3XZk49PHp3D/7t0K648voPRxRqTK4T6SJA5rps3ueIjdYNJBzuWg3d9G+twroS5lW1Td8SsOx2KWntPB6V3esj7NJzZlREmWd7vom2dxiLRLACOCCgr4PFxp4Z3pJ0GxF/uR17a9mGUHCzkLhXUMFqBnJbEGGNP60qz7vhn6BCeCEY57UsLoNVWc6EdAWHfEsbC2ON7JeSFihLE94SomJRpgEjDQIGgLTlujXdStiZmljBTFb7j9F4cMvZgB1MbmLUW4805tjam2BwvMKkazHSNi4stKBhM6xHO1Qc4o45wV30FZ6pDnK0PsVNPsVnfhofqM9irN9CqGjRT9rQmnVzeqeEKwvWFIwtiHhXzjuQh/hK9jIl7RxYV32fkIyIDCnITIua/V8MbFqDoe9Tuwk+exzrkQ17YKTZSwkZL/BORLvd9En+bGvH87MrL3692B3Y0tdXCwBAqY2J+zWNAbnIgaYOh9hDzO+RjQZSyWLY+Oa6YamBkffv8GyNNG4mfnrxOEwkpPiAFzyQUAvIMwCq7OkMCac6cp2PSIHbHQiDEpGGJgJyWI901gixDKlAnaaXl5Anf2zeTXZDtUZLAfJOw2CZ/zC6bWsk82G+YKtsovABTayIZpCO4CAHbEGBawFR2IWbNSqcdRD0iUwhOx11e6J8nu3pS89RJO9MPHZ8errPKhBcCix4B7QRot1uMdme448w+7tm84s2uHj46i49ePo8rj+1g/IQjH4e2zWVdWfNRLdjfxgTSgUBA5OlWqnEaDq8Nck7Q7L/jSYjQFDifi/Q+DfvOmWSxpsBrLlw8aXbCUhT7eziSQhyWNSGobDz2B2FzF2ONcuxzHSTKqgIhECJqWxhfBkceGJW4j4TfdzrWBDMsuCFSI07HaYH8LezsBM/1ZxMxIJApJiFJXqQtCVGkoRV5LQhr+fwN3843vpXjmMeD06qpSYudzSlu2TjEzniKtWqBEWnMdY1Li00sTIWFqYERcFu1j1urfWyrKc5Uh9itj+2lhfUtuKzspYV6WoEWrltaCjd+E/zBDxExEVpWOX11SEi6IcJhxbPsTv4yoVO0R3qsN2lnzsYmXfxNVvB3fRhXjw6xd0ft8nfjCYybG6Pjv5l4+FPp4rtCvNbYnbbFc9xk315WWNfiGN/aubiJu5PkGiJvYPftlWnbSLPgyiBNwIbIRU7YHyQp3NGAP544em/6/+6QDC4fDzVJeAoKCk6MQkBOKwYm4nRhlHFSh/Ds5kVP2p3JNE3PFyLzjJ+n+eTeSTkwN4HL3SqxS8eLtCcEjmQYZYXoZh1oNuzJOWoOf/pSRLCEdoQFAXLH8SoylqAIjUtUFrnwaPfD5+cTvOAsb1OP6suyWoYQdsgHdR5H/iIdpO+k8JO0PRMTPQbaNYNmx5GPs/t4/s4l3D7ZAwA8MdvGx6/dgstP7GB8wZKP0T7foIywQytIojzdipiIGIB9Q9RC+x9atF7oJne5niWZruCsBRDH3fqjc3Ubkw+GM0myGonkJKzG2QwZQWa8P0cVTsDSws+Et8hZi1IJrQprSLQCVaKvvPmUCk7oQNe/Q5G/j8S4067IheM43k+Ezc0qIV3yPST8ThwnbPgGdgCoxTTvtUT8cZEfPpY3Mds3zukcMIa8X5XSTtIkm79RBtrdjxPycMVTBpO6wZnJMc6Nj1A7yVUbhZke4UqjsDCVt1m/gzR2aIa10UWskb20cFI1+Ki6FRerTcxoAlAFLNzHpSk4XxHcAHR978aSPymLhXlRxJSYpOXvPBYBI40IKJgQEqI5N8wNCJoTEVYeBRuZlvL85oi7cpoL9qmK5jRBXPiWdS6bJx8Luzkgj+r1p2WNyWpAeZgYwujYoOajgefwjur2twnffGK26usl25bnUn4miIAX7JetCRgmIWkYmZY/OpnzTuZDb1JFiImG/A1kSciyMt9stEahvcEaixudXkEBoxCQ04g+gpGCkt9974cwMNmnZekgfSdW9Y4DoFwwhYCdSydn3hHFcbt/AMJOoV9w7YpiKnehmUjPh+NyuPgsaGk+dcflbaSJAgvX6eLDYa2kZk1WgKhvjPw7qii3lauLZyZJs6akIm070a7S9jsiMjIN1nysO/JxZoo7zu7j3p1LuHNyDSPV4sJ8Gw/un8OFy9uoL40wvkaoj0ywwwcioiYdaoMTujta1x9RbE2v1Ly15MNpP2z5jCcpBrDEqRLkwzmIG639reU58uHLJnf9o+NudSAEIbA1n3IEwTQUNCCkAFJOO4PYnEs6o2sFqlW45I/JCRMbbSyxEccBexOoVlsS3LqyVZUjGk6DIjUjTtNB0smcT+ICBLliJi1Ij7aDl7hNUq0IkxHlHNvJml9pZ1JmTasUWOo35C7Kc1xMmvmoBjAtoTUEBYOxarwDeqMt8Wh0hat6A8ftCAftGvZH67hrdAXnqgPcUV9DRRojalGTxkfVrXgMwIwmMKSgoIDGuYaz+0toJFgJO/zpv9FlJMT9IYXnHDpCMIX0o2+fEDYmRHqpRiXyp/C+QqE92UfDx1dB02Hq4LTOh0r4zRvXF0w+2L9D+4MnCK2M58mJLSBpS15M5eY2edy4qHtHC8bPHCfkuZS/7+gyw3StEGnm/C+WQRIK/5O8zyKtkwjbt1FG4t1pICEGBJ1W+AakWVDwVKAQkGcCpFDfs9vU+55fS9k2t9MDdFXKYlHhNKK8liFdoFNBGmFRiuIkdWGHbz6Bhp0mDVlHTdY2VDMOHy7X4gXcV4MS0mLCMxvI3XYuF1peOJ0dtlwou21u/TpI1FUSgoiYJfUm2MvgSGW6sY+wyb5J8hokHxODZjtoPu7duYTbJ/tQZHBhvo2P79+CRy7vAhcnGF8lVMcuX1c2eZkgC0p8pKg1sRK3mLfal5lap4lg53LX5mgNoNzFg3zrt7zdnE+74gv/tBG3hgfTps6Rt21rtQt+19n5V3BY345CAGc/iSGJQvpPAMFMy73zRIJ9LVpbdnthIWJyQgrQLYjjCzIECIHUH8HbWod3IBAOf5oXBc0Op8eXEXIbOPM1SgiIv+TQkBDIDZTW9l2lQEZcckiAUSr4ZElzoQVhMa1xNBvjqBljrmtMVIMRtaiUhjIGx+0Ye80E03YLn56ewSPjM7i4to3nT57AbdU+zqgjvGDyuKu6BpHBY7SDKY0dBXIkxJA/kThs1jpyQvBakBwJkYTDVck/j+bMFMn76JQs33FAdMcQ7NyV3Vzx7xHPgdymooCayUcVm0/xbedcPk9eWuM1yexnwuRDj+CJgD/Qw5lXtmPyd4n4tjJJeeQ8xv+X84377e9GGZj/fLmTVyshMydmn/VArkFZ81fxboiYFhQUrI5CQE4jMkJkLsxK2hH+fzJhZn1AetLozUcK8EuIUFYgBuLFK43v0o2cvSEWb2U3evmdWti42u0Ayt1DWQ55/K3cqWOTJQD+lB/jy2RJjxZksON3wX8K53IYeEJBCHGj9ovqLAiMSNcv5Gm7unbIjoekX7kt9cReMljtznHr2X3cs30Ft0/2AcAetXt4Fg9fOoPFhXVMLivUh5ZY2J1R6wphd0bD5WnkSJu/fLDho3bdTeYGVgBu7a4+8WlWfGxuZU9j0nBmPopix/O2FTeNK3e8rg73c6T+FbDvI2dvvhwwBxHOa0tYS8HPWOjn+0WSY31JkBi+PBAs1AMQN/oBpKzWxanfjKZwoheFU7CMqoARQt6+rMnhmN5JXse+Lhw+RXSZobHkQrM5oSUxBCZu7oNSxv7ZWnNFU9k+1rX0p7LfoZoRaKpwfDzG5fUNbNRzjFWDUdVipFooYzDTNabtCBeOt3A4H+Ph6gweWd/Fxe0tfOb647hndAmbNPckpCIDRQaP0g6mNLFjxdiPy5/EBniiHT5qMVVJEsIkQnwnXkgWf4OfJeh1YgYQ3SfiEuI5ZJUNHLnxYdNDmA89+XAHYTARkX4fTCb4KGwT4soTtngzxl+KuLDltBcZWufzdkzerItadxoaa2NEXEkqolO45Nyf1DGaQ0X8aIlICVrueZp4BkPEwheOknLJuTpHbJgwLSE4NwvFBKvgmYRCQJ4hiAhDTtCMArvHfZMiT/Ir7OKkaXTiDBEhLkciIHecvE1MEnwct1vHTueh7MaTg87RuMYuvJy23KUHhCzIO5OpgO41IYjzNG43lYSZUAJvbuHbygm0uksoOmYLol0iAiObMl18pVCSLPQ+XdEHpnaajw0N2p3j/JkDPG/7Cm6f7EEbwuOznXDPx6UJJpcqe8/HzHjBjYmdaoxzOHd25W6XnZ3MrQ+IRnzPh/YEBJJcAKCmhVEE1bQwozrczdEmAwMIJk1AuBtDvpOXBLKpkiMfrDXx2g8X1p+YxfF8WhQTDVUFcy12IOc8JLmRZlNC00BE1ieDf7u6UNM4rYYoLwByp4J573ev3ej56OQteUqUT/rTSFLkTN/86VjST6E1oY5E7ptxp2I5kmncxZJaW+HUkk/rg1UdKSwOxrg03sCoalGrFhgDW6yqhDXHOpyPce1gHbpVuLa2jv3FBFe3N3Btcx3PG1/EjpriOaMraDfIVcvgEdrBMdb80bikKQi/FIRCq5XokhCJVJCVmwX8INVepjv5lCN5/B4J+ZB+H1I4l10iBWH5rbPZVSUIhArxIImEczqP/EzYUV1s6nC5lNusMUTQI+NM7qyWhP1DFLGpqmgLbfypXNFmj/SFIcRzGLetqLs8UU9+1FLAz/p/EOI+iyKmHRKnkVuTojJxHXnOp0xdkClTQUHBUhQCchqRTmam+zzVjuS0Dn4BM/H7juiSCq4Ik7TcDer4hWRkoKgcYoGN0kgW8OiYXV5kxQ6fX1iN6S4wInzkoG4QTu+RZXOLHCG5/ZzghS95Yg2/MoA75YW6G8oUfvvFzSAmEUmbSedLo535Rrc5u/GTNPxurwrlTQWaiHxsGmB3gXNnD/Hc7as4Nz7CTI/w2HQbn7x2DpcubYEujTG5qjDet5cMOtN9r1Gq5sY6py7sD5tckSAg9re25h+s9ZCXCbLNDOAcrJ0/CBGoriwJIYoJBCDMsuxz4+7CAOA0Cip67+Mqp3Fw9bAO4JU1g3LpGjjhXhGgaheVghDOPilVBdTsRWusGk4K721w7o5QKYBGPm/D5XEki8BklQJhYId348rg8iEmMYC7iFGQJjlsDPt8aFdfm7ZhHxPWQiV+IMGnJBmV3taJ73BB8Png77ABqgWgpwS9X+GoWsfjZIlDRQYVNCaqgTYKjamwaCosZjXMtEJzVOOh6Qh70zVcmm3g4vY2nj+5gHP1AW6t96HXg1T7KAGHZg0wtS1mI03HIARTJlCI790hETYH2ZQp+Yj+FvOSn+fcyW6+Hfl5knZCQnzRUwFd8dwYyIN0WPfzKJtCLlgbGfLUVabuXnuJ5HQtUb/Waj2ZpPBczBcekltkWAPt51lRPymwS7+6SIOe+ISc1PdjECYmMhFyBKaHvKTxThu0IegbrI650ekVFDCeNbq1T3ziE/jRH/1RfMu3fAs+7/M+D3Vdg4jwvd/7vb1x7rvvPvANw30/H/nIR3rjf/jDH8Y3fuM34s4778Ta2hpe+MIX4u/+3b+Lq1ev3vgKSqG9R6i/LiS7UFGWIv0O+UjCrFKOiHwMhVWOfNQ2rFoY1FODahbMCXL1YHME406C4Z07u1CG4yrlAhf5ijgTot48EnIF4ZtiT6GJf/vTedJkJHEiToOin46gIOspSYfULok0/d/cHmODdt3AbDfYPXOEu7av4ba1A2gQHjo6i49cuB0XP3UG9acnWLtgbzhXM/gdTav1SMjHPNxsXi00qlkLNWuhFtbJ3NqeW2JBrbHkY8E+HLEGBMZYH4n5HDiego5nNiwLvFUF6ddhT44KJMNrNPh4MuF4TlVlBfaqsj+jGqhr0GgEqiv7U1mCQvx8PAaNx8BoZDUV/LuugbqCcSTJjGqYyQhmPIKZjO3vtTEwHtl8OMzYhVmfwGyuQ2+twWyuwayPYSajqExWM6J8vYnNq1gDwXVxv8mRK6qU/b+8yNA2Djonirnnpk+bIgmf06J4Xx5BHu3utzC5cyefqQVQTYH6kKCu1Ti8toYn9rdwYbqFvWYdB+0EM12j0QqNVjCNAs0V6LBGe2WCi0/s4EOP3YFfvXAvfm3v+XhgegemeoTd6gjPX7+Az9y5gLt2r2Fzdwqz2UCvGXv3SI+sFL6z7jeSakEjrSJCmJyJY2dTxKdD0e80fUB8/+Q2NjL94DdkHPmQl5/6uauBPfVvbrWV1cyeXFXNEe4LcfXweSIhHnyr+sL13Ryop0B9ZMLPsUF1bDA6NKiPnGbUuDnP3dguNRhyvYram9tOxz++zqpbVo4jf1ZyJk+ed3wO+8KfMO0ioxcUnBzPGg3Im970JrzpTW+6rrh333037rnnnuy7jY2N7PNf+IVfwJd/+Zfj+PgYt956K170ohfhIx/5CP7Fv/gXeM973oNf/uVfxu23335d5Unhd9RTwRWIJ+XMQhlNtulCm8sneddRefMCMzThZt53NB8yuMvD+yiwAM/k49gKOs0aoR25RViQAbYiATILrAo/qnUn5iRCgyyqvRXamZkIeh60NMZVkULkdAePQnlScw9ZZx8/qUsahtJ4qZDUt6vHxGhk0E4M9GaLjd1j3L69j9vX91BTi0eOd/GJy+dw+Ngm1h6vrcnV1HTLzTuhfJ/Awpre2ON07Z0e1IqOACCdn/mej44QLLNgEsJVcpoIUymQqUBtBaNbb43UOc0qOu3KhWHSIRy7O3dkMBEi8uQCQNAOpOWshH+HTdAK8+x7wQ7f0nTJ+VaYWsGMYu2HmjoVE58yFLWfBow9TteYjHM7KNSBy+Li+t13eelgn+mWsRorE5lnkfPFMc7xx/6ObwFn4k6evGu+J6QFqqmt+6KucThew6XJBtaqBZqRwqytMWtraD5OtyV7xPNcwcwIs6ly2pAJrp1dwx/YmuDO8TVsqymet3bJFdHg07SLQ1qHRg11DHgn+dx8I+ZQ7quoRdw8JKdXjhZpVfo2QbIkQmhC0Df38gTWnTM8+ZBzuwlhw9HXCFoPr8mwGy88p/rTsyi0T3THCH/frZ0jjdsM8g7uZNOuZ+EuoGadvMaatWJR2b0jvqgjknqIOS1qHtneFJKQ6WS7IuWFPQEjfw9ZpmhR6MbJaaRPA1ootDd4X/lGp1dQwHjWEJDz58/jK77iK/CSl7wEL37xi/GWt7wF73rXu1aK+83f/M247777Vs5rf38fX/d1X4fj42P8rb/1t/CDP/iDGI1GuHTpEr76q78a999/P17/+tfjv/yX/3KdtXGQk6YQWOVOfp/JU7r4LtuhSdXdg+Gp+z4txyB6F29EFw1S63b2GoN2RFhsEtp1F5zPxG+TdBMiZigQEL5IDcJeHIYXuFAo9sGIBAEWtHwdjRNkKOSZLFzcF3Lt7bQPFyUllDLrNLzQfASTD1EMrrsCTGXsfR+bGqOdGW7bOcBdG9ewU09xdbGBxw53cHBlA+NLFcZXgZE7apf7ItTdCiWqDY7nnnzMW29u5YVtIDouGQDgtDvE5kSJmY/359D2rg9yu/umdgJ3XVuBPBLShbaDtSo2MdCoDmZWikDsGC4FbN+ujnyMrIYD2sCQ3fWPtASJH4Wvr1JR3Y0Ia9tSWdv7WjnTQpteNbfpq4pAi8r6XXjHe201D8o6Q0XkRJabTcOk+ZQ0XUuIh0nMtHwcZ67lCVbqExI58wth2xHzsJtN4TQsBWBK0LVCM6mxv76GK6MFtCE0psKsqdG2sbOAJS8ENa+gZwpXZhU+vKhxsJjgs3fHuGdyGVvVFM9fv4CaWtRK4yEyOMAGtK4tGQLPSbaM0W68Ct9kdCpWbl6K2lqEyTKUzP/FpoV/LeZXKSgPbdKkeQbNbbhYUB7X68mH4pOynOM5b+5wXQwiLYgkH1aDao/3bdbsXSFkgNG+1UjXU/d+FJzg+ZCKTlu6uZKMsWPHxHXxxE/M3dGaJ5tgqJ94SCbzsDxYQKJvnTupyVdWs1JQUDCIZw0BeeMb3xj9/Y53vOMpy+vf/tt/iwsXLuBzPudz8EM/9EOo3M7qLbfcgv/wH/4DXvjCF+J973sffv3Xfx1/7I/9sevKY8iUwAubfPKIjJMsfh49xKQPfWGyxEPmkYYlsQBwmTJl8CYSvDC7XT3yu3C8iCLsmLF2Q5gJSfMGLhP/X7MsJk+iMdyeQZiKfoPDGEiSxeUiHVY2doJfaj/MO3digeXnOQfHaEEW5GKQ6DkCocdAu6FR7Sxwy+4h7tq8hvOTA2hDuDJfx5XDddBBhfrI7j77U8NE2krskPpjdhtt7/RoLAmhtrWCXEUwULZvWBDWCKdeAUGYZQ0DH7PrTXtYAG+t4N26wjgSYeraEg/vf6GD4M6C92hkBweTD0kgKiHwAnbHlm8G96ZPliR58pGcaCW1Gl774UyarABP3mTGKHInCilvWsh3Kpjako+qUrZNW743xQSNUmOJCJo2PhmM867FbedMWrw/U0w+wviQhARdUpiL16c9AWKhmE9CW4Tw1ZTQHlc4Phzj6mgN2hAUGczbympAvNOZy5t9GY4IelHjqNnEJ5oKC11hvlvjeWuXsFVNcffaZSgy0IbwkFY4bNahG7IkaMhck+cPN9btJoR7nQjQWd83Hspk/bfStghxTWeu4TQj4pH5v88r2WgAEA586BAPG9Yf1cvmqH7cxeQnusuH47oNIDZjbdbsxk87tuHV3I73aqG9yVa4U0a0D6efqCr8xgz/jZB/pomj+ud4xCqELUXvBtvAutspwykkHMUHpOCZhGcNAbmZePe73w0AeO1rX+vJB+Oee+7Bl37pl+L9738//uN//I/XR0AGvnfePcsuVAyxsADIe/oMEIchE6tB+1nqn9hlmbMqbBGXd3rJOMdJp0ZQC3vXBx+zm5bDL2Kpb0RUARa4EG3AR+nlCJJbMeXCk+5k+kvI0jaBWLDEWjzIU+ROHrePQoeIRPlwHOH30awbYKvBzvYR7tzcw/nJAQDg8nwTjx7u4GhvDaMj5R3NmQDJSxflHR989K7yAr8z9eFdVyEgsQmWP/XK+xEYf0KVvdXcIHIadwTBGGMd1hkcF4A/clYB0ApEsWkQgOBQzmn5tiJEJ1Y50xQmGUYpkBDw/fM6b4rAp0MZRTCjCnrERCPckcEHKrBwZ78HAo0MqhFBj5XzoXAO/MJ8jbQJN8fPG4Cd+AGnGaosAdKwxKMBjLjlPDLR4r+Tdwbhu7P9Z4RJYeaj1gApY7vNaS2oQnBIn7v+N/YDqBRQHROaoxqHkwkqZTCqWjStgtHKfRtM7uCIiPvmW4DaCgu9jodahUVbYbZb4/kbF7FVTXHbaB/zrRrHzQiLRYV5o0BNZbWdXghG9E2ld+1Q7ttFMg8IopKdg4FY2yHnuww680eCyA9FpOe1sUw+xHzlNZ+efJC/ZLBzR4jwfQNEPBJxx7C3pI9s/TkOm4WxCZc8FSvSzIs5Odsmcp7ra590Lqb4fZYgJumk75dq+aMMxdDguTfJ5rTI6BoK+gabTN3o9AoKGIWAAPiFX/gF/O7v/i4uXbqEc+fO4SUveQle85rX4I477uiEbZoG//f//l8AwEtf+tJsei996Uvx/ve/H7/6q796XeXJmlgNkIKuyj9+1+snINKMFsLMorDUcW8onyHwglkl8XmBqIHWjVJqgOrYHVzE4eTOnyszcVlSJ0ZRl2gXzi0okfYjQ0gMnCA3tPOVaz9C19Y8aYOcsBL5/AiTq1w7e/KR+H2YjRYb21PcunmIWyZHAICLsy18fP8WPH55B+rKCPW+s70XZVF8vwYLK3zSVQsvJAOwO/1ETqMjBFvFhQosz8dhLQdrRZrGEhBhLuXr1TT+eNzoLo4UihvKkde+XX/WGFRxPpZAKG/O5AmLcaZW8lZ2YYrEcST5aCcKeqzQjm08vszNVNT9pow98lSNhXZJ+hsZOG2CQTVtoCqCmhLk0b+mZgdzKdEmv2W5GazRIZuekQRPHsPLbL01jug5Uy3DF34ar01QLWAamS/foO0cohcKi3mN2biGMWQd0A0BrLHQXO4gTKsFWRKiFRbNGj7dEqZNjcN2jOdtXMZudYxzo0PcvXUF06bGhaaCbgmkFZQxTrsD/22m5lj+m+W5A+glDb0YIi6Z98Cw0BrtuPtCISYf4gQrWZ+gMQ4mVx1zSndHCKcFJgkUNCZ6ZIkIf8a8AaQae19MOyY7xlP5VBInOfwIec1Bph1OYho1SELS55m0UjKZTS8lIZmynhYSUlDwTEEhIAA+8IEPRH+/613vwn333Yc3v/nNeO1rXxu9e/DBB7FYWGntBS94QTY9fv7Rj370+gqU2/XiP+UuHocVwqv3e5BpDRGXRKBdad1NCM6yMF7zwaedSAHAO51TqIsB7DG5FAvbcrdNPhNmDn5nTtYtrbOoe6R5kcUX7RqpLKT/SJq0SRYjCnG9oJMhGGk7peVddsxuFLYCdO2czjc0Rtsz3LJ1hFvXDzBRDfYXa3jo8Cw+fWkX5ok1TC4rjA6dr00b2lH2FZmgAaFGQ7Xa3evBJMT98I69MdZRXDpCE4WjX1sdTJ7QxnVgXw1jPOEwfOlextFaak+ICIY1knxcrSRFfHxu5Xw95A6/JBmsFXCaEMMmWYCtt3hmtRy2bqYmtJMK7Rqh+f/Ze/dg27KqPPwbc6299znnPvoJ0kh3WjTGClShMWCJFaXK+sVAsAA7YCoGBNSQWOZhEuMjXQYC5SOVoiCpAkuMIjFlR9IQTCwoJRotm4hJ2YI2IOEVOhiBvt19X+ex915z/P6YY4w55lxz7XNucxtuwx51z917rzXXfK85xzfHaxEsgFttr5Pqnj9jpOSdVxhwYyiF2QwDEJacn1epUkQp3fSqWc5TVTFFNNggkPquF9sV9bZVxWcpAB1F8BoIzOA+yJCHVJzaQhmDK+9vERSUQGsCrwPWQ0iqUzEkxxADIazJonCPTrHXQLdOz69XC3x22eFw1ePwhhluP30O1/UH+LLFRRyemWGIAefiaQw8txcvDDR6/3Lm1Z8ClQkHEsVzGxjbUVpU64qjWppp16o5o3Zo9VpqhxW6nnrwIWuPl1YksNtYj0Vl0Fz9CjOevWSlpMOCsCZYUENzGkKESFzWTcA3gCQx9WX6T7e+eXDQJLaklm6U9ARABxiDD8vPgb4i7ZWC088jDUwYrjISutr5bWlLSl/SAOSWW27Bj/3Yj+EFL3gBnvzkJ2N3dxf33nsvXvOa1+Cd73wnXv7yl+Omm27Ct3/7t9szDz30kH2/4YYbmvnqdZ+2RUdHRzg6ykG5Lly4kG9ytZEpI+qZanZ/kqagmgHnEyygFaCZTKNZ1mVyeb/UWXYbi57U9yhOhv0JmffiompTplJRAQ/7JH1OMmuehAuPphtsBXKKT9dOQlkPS+c3KNcFBWCgxCdb++ry6m4kwLvZbVG9cbIyIGb3scSNZ/fxhFMXcHZ2iBUHfPrwDD710HVYP7CLnXMhe73yfWgMYz5pVYYlWFwPNnuF5G4XYufhKlZFOy9UgSJL5O8Gl6fgQyODj6QeOomcXYnE1iAX9M/c7qrdRwjZyFwZbyUHJrJnLBk3d82CWhLAXUCciZpVH8AdMCwC1gvCsBDjXFXvGr2HXL5nCkQq4EcxeZVKWmmdPROWlOKqVEDBbEFsYlf9Whuge9U07cehylNsaxI4YAHhaVwCAFAAd+IJS+2iiLJqkJ9bEeBIiDEgckSMJFHgBWQsU21ixyMQQDG59g3rgNV6hovDaXyUCRGE20+dw9n+EE/cPY/IhCESHoqEIc6AfQdCWqBC10n5UwGdjlXx2XjWSycAx7w2qLZ/OE6SXHoc4+b6bTZhYQw+rCyGqcepu+QwuLxI1V1zvYq+d7+j5K+AR6XXqprl13ADNAbCc0eZ2ptT9/R9ZN1b9IfUTcuogMhIQlztjZtU3ibphPz3FUvNtrSlL3H6kgYgr3jFK0bXnvnMZ+LXfu3XcMcdd+Dtb387fvAHfxDPfe5zTaXj8PDQ0s7n82a+i8UCAHBwcLCx/J/8yZ/Eq171qua9WvWqFU3cM40Fs1ud2HCdZ4vcJrppc7Tkxy3K1Sbu69sCH6aLXIEkipz15uXk1kCASiOUKfTPKZ/I3NyMWBmkesPCOG3RXnL4wfez6lETGbjR6OFoPYvGhqVjTfnTf6/T2U9NY/E+Iuj0Gjec3ccTT5/HzYvL6GnAA0dn8acXzuLgwV3MHwqYXQL6Ax57EnP1SxHNYYbndgo7iMH0Ojajm1N9kq7G3czJhmG9zio/CkIElDCFdG2IbYCiaYEc6wOU4mioxyyz3yD7zZ3YcnTOe5XULfbZS5V3eZqiRiv6hHOMkF2PcqfehpKb6GEOUV9xLk/dHEwaTWR9zAb6KiAYAYqUBEU23h04oDRaH2K2wSEGBpEi2ZhKIV4yokDEj5Hr15HqlkRpJyonI3fBQCgFlmwpOXwY2KlWoWA0C01GTkbjQeJZgJGcGTi1Ie0rkikxAwHU4xKdwieIEcC4/fQ5nO6O8MTd81jGHuuhw4VIiHEGYrIDgEkJhb63jBIouPJbZG52WyCkWHNgaZon7MX7Xi5II8CK6hkFH11m9gvwV7vaHVCA6dhR3iv8/PNlcS7L5qm45AbgHBDkPuQeiJA550FV4CxdAcQ9em5f1cS8FtoFZEmK2ydPChauhMZqk7kejwjQPIq0NULf0mOJvqQByBQREX7qp34Kb3/72/HRj34U73//+/G0pz0NALCzs2Pplstl8VtJpRq7u7sby/nRH/1R/ON//I/t94ULF3DrrbcWjLtXDfCbWuvE6DhpxLHEE99R5nPi9UgZ7nrDlM0y9imjsGZRAcrgxNchiHFz4ckFrg+YCqPp+oR51BYGCCwbKo2FJPXu5/9azSyYA847pgNMIzpuw6rGvVV20+5jh8GnB5w9e4BbzlzAE3YvYh7WeHC5h09dug4PP3QK/YM95hcJ3YFTw3D1KmISmEejaO49UzvhjKQTWKC1BBgUg3MzMAdSFHJVjxqGBD7iYEEFAYg3K8COqb2EQ0kZZ/m0uiv4WMyTpMNLQvTTqWOpq2UDH/OAYZZsN7IKSmk4nvsHdursT3in3J3WTIo5PeDyO0KOU8MMs7MftAySzx5mtK6ukE0ixakA9l601BlAENDmwFcCkA4sVi57J8nmQTJEVzfNEckNK4cEIsxVrMbWKbLwiwoslgixzADHoNen8WGVghyCelykU/i43Lvt1IPY7VZ40t7DWMeAIQZcHgiIvcxfEvVAzSx/FlJOLX5qDUFOn26PQcgk1WmMMdd6NMCH6ydfPoBSUurmqR38DE7qsc5jVRx4+PyQ+7te68ny5Ow1j3O6sAa6VZKcDjNgAKX5EHkMsHR/IE5TzqtmVe0lUTes9zqvruilIa096sRgoTWGvl/970Zdt7SlLZ2Mtu4NJuirv/qrceONNwIAPvKRj9h1r3Y1pWKl16dUtJQWiwXOnj1b/BlVG00BPuQ0sQYoRlR91nQMQ91M7+pS3OL8NyqTx4u9qRZprA9Op579UWKGY68+58XAsdAhdxteyG4i40zUjubut51M0xhEtACH9a14HZKYF6Ze5E/aauKyH7J//qzC5BmCWspAdT9RHvNWff1pYA0+4t6A3bOHuOXsBdyyex6nuiNcXi9w/6Ub8Olz1yF8do75eUJ/OTELfoMPa0a3klNSq3vuC7X9GG/OroICPjAIuFivgdUSfLQEHx6Cj44EmAjwoFB4qyokHv6e/lHIUcBnEnF8PsvXVM1K/3q1+3CerIJIO0SFKu50WO/2WJ/qsN4LWJ0KWO0FrPYIq72A9S5htUdYniIsTxOOzhKWZwir0yk2zXoPWO8Bwy6luTtP81FdoKqaSvHdGQcX11Qq2CXXvXot9qJ3v5PqtDoVsDrdYXWqx/pUj2G3R9ztMSw6xHknNinJo1dyLwyxyaCkbtY5SRGAQgqife2N1OtxLiakeO4S72g+Xs5obmM8n3M++T0Pa7U7yn/q1UqBcXcEzC4S+gdnuPDAKXz8oRvxycs34vJ6gVPdEb587zxuue4Cdq8/RDw9JLuozkVLNxANjNbbWt21qqdPmw8KcuKrcSJOakPl144iAZprmXmtWyXboW4pkdFXKgXJ7zBLvQs7MyrzKtc1AR8uwnqcAeu99D6sd2WvksCIWk+L2O6M3/WeBUf0IKoGU16FV8G7OwSogddkn7WoXte5vD6lHjZ1MPSFJOaAeJX/uHmCtpk+/vGP401vehO+7/u+D0972tPQ9z2ICK95zWsmn3nlK18JEru9qb8PfehDo+f+4A/+AD/0Qz+Eb/7mb8Ztt92G3d1dnDp1Ck996lPxQz/0Q/j0pz+9sa6f+tSn8Hf+zt/BrbfeisVigdtuuw2veMUr8KlPfeqK272lK6OtBGQDzWYzAMnzldLtt9+O2WyG1WqFj33sY7jllltGz33sYx8DAPz5P//nP/dKVItcbTQ4tUlO6iE3Trsmy3V5XRHVjLYu3sFt7prObVRxBqxOS8Ar8dTCq2SYqsAAEhOCCPmE2UlEWAGaGKpTRDppNYbIuWttAZHqOwHJEBpJv70wUqyfqZ5jIHu/In9xemMsQMfE2PoTeASAeza7j/7MCjefuYxb9i7gbH+Ig2GO/3dwFv/vobPgzy6w82Aoop0rY2HqGR54qMvdZVK10jEwtasYoYH2zOuUtz/oujQgAxKwGOqGyEToulLSUUgvVIzk73dZoqLBB0WtiA2sVCpI5KKQ9yGDj54QF8lzlRqNx84xRCblgJ3alie5bqxc2o3MK+e5WjNL6rnW3h8iqT6bSl/sCKFPEcrDjNCtCN1RBK8ojdVKj6+VgdX+0cnXAB0TkiKgkkKRqK/pfXsvU5qEH6nsH2033PsjX7juJH1/3WGL/a7yzEbUBGCGC3QKnwwRfRjwpL2HceP8MuKp5GnrT4eAZdwBDV3ByJokqnqvGRBPbvld1TXG00YG163TV8qsFvZtPq8NZZFIJLVe/tAmOO9qVieRrBnIreyVrOxKQgrkeT7MU4yQ9U5ajzWeULdK9deDIgWVCviSlIvbB0RTbdU2aj+SG6+QAVFRd79X6qV6b6zW5Sl15mJfa43lNQZGvpD0+te/Hq9//esf0bO33norbrvttua9vb290bW3ve1t+Nf/+l+j6zo84QlPwFOe8hQ8/PDD+NCHPoT77rsPv/ALv4Df+I3fwNd93deNnv3ABz6Av/JX/goefPBBXHfddXjqU5+Kj370o/jZn/1Z3H333fjd3/1dfM3XfM0jaseWjqctAJmgBx54AJ/5zGcAAE960pPset/3+Et/6S/hve99L+65556mK9577rkHAPAN3/ANV7dS9aKpTGiLcT5mw/L3Rzquj+C50QZbnUCxq68ZEspmpEyVuX1Uzy2OJwprMlewYBXry+amwMZtRlMbR4rnoY0Zt52ZzFPQSKrDaIv3/UY1wXQWSRp9PMWg1BKTIp2AsDhDsvs4tcb1YnR+3ewAkQmfOTqN+x++HkcP7mLnoYDZxQQ+wtoxYVGCDK4S6CA5xVa3sGGltgYMrFPQQRrGjUjuVsnieBCQggaqd6VhyDYbREnlyozE/UAIeNAAguqVqmUT4oEGUltY3MKyZ6r7gDjvEBc94tyBj1n6G0RqFnuUoEPtQfzpcOt3zXA7htaPJVvH4FggYoyOAhEx8CaRelGkLEEJAR1xAgQSCTxVwAO33Ffko8aLd7IU+4MyyNBxgrteRV1PqnhS6YCk4uTmKNVt03eek9G9Vc/Pa7XV8BG+JWFh0AyAVSpCBKYZHgqn8ckuYqdb48t3H05BN0FYDR3+bAgY1gtQDCCmkX3H6HCBZC5ovZHTW9s+B/KMcDlPHPjgsm5TlG3edExgkhBztYu8rhrwMBfRrm/h8qg8DKqkR4PCDjvAeo8xJLNHCVLo3g19hyCqes7zVtIw5Ctm3AtAWNxoJT5pppuvTwJBD0o+x/lwNWgAYbjKSOiR5HfzzTfjuc99Lp7xjGfg6U9/On7u534Od99994meffnLX45XvvKVJy7rW77lW/D1X//1+NZv/dZCi+T//J//g5e//OX4zd/8Tbz4xS/GH//xHxfPDcOAF77whXjwwQdxxx134C1veQv29vZw+fJlvOQlL8Hb3vY2fOd3fifuvfdehGqf2dLVoS0AmaDXvva1YGZcd911ePrTn17c+47v+A68973vxZvf/Gb8k3/yT4pghJ/85Cfx7ne/GwBwxx13XN1K1YeFNXCYOpkpHprOrzaw89dbRpV1HTT/kZ2KB0uSj2dgbcMCEI7cMw3mJAwABgYPYjgZYeorhRhev/rTLl9XYRYL6bLVl8y+IeVRMlVF3lLP+lStBSg2Sj3cM4XBZfUMAYjKHFfxPk6dOcLjTl3CzYvL6BDx2eVp3H/xelx4aA+zBzvMLgL9YVafIM7BzHyQwSTtAMIg9gVe6rEaSoNzd5qu3o9SRSl5pQIEEEgneeBCquKTAUd6VDrWG5PHmPIyj7wigdGNQQ3Nay9PXYrVwYsOw06PYSe5yU1gg8wWqVCDsgjmbky8VKMGITowE+Ouc9mAdwuIxMxA1nODoIADYHuBcvm+zcRBTr87U1VM/YNyrLQfOyRnDgDIuNRqHB34SKpbvoIpr2T8jrSjSHsKdSpToSIgEjgGsIJJYnDg8tBBpRRmQ6LrEBfAUIMVgoAZEbib4Vx/Gp/s11iENb5scQE3zi7jiafn2F/O8NBRh2E1S/USJxYt1SbWPvOXRQJl41WviUhrBYEnl+KWwfo4EUyCMUkGTN0lzS/m/i8lFlmyNznXpZ2IDamJlwr694XyOKc4IQCICq9aSc2Lre+S9FuETP490rbBtc/tIUUfob3/TO5NJySTMG9Yv+09v4bAB5DOAq6+EfqVP3PnnXcWv++6666rVJsx/X//3//XvP7n/tyfwy//8i/jCU94Au677z787//9vwutlLe97W34wAc+gJtuugm/8Au/YNKVU6dO4c1vfjN++7d/G+9///vxjne8Ay94wQsetfp/KdOXLKy777778P3f//247777iuuHh4f4iZ/4Cfz0T/80AOCHf/iHR96u/u7f/bu4+eab8cEPfhD/+B//Y4sLcu7cOfytv/W3sF6v8exnPxtf//Vff/Ur3gIdGH/qAloY3jUWkknVgJrxnVqEHENWgA53fyT9QGZOwGKQnrTd0C0Z/X4KONgdiR6ziO7Nk454y+mOGN2R6DcvvX5xBYJ8m9xfrZ9enGLbhk1NYNOios9bG+Omzcr3kddp9s8j919iAjjZu+xGzE4vcfPpy/gyMTq/sN7F/ZduwGcfPIvugTkWDxP6/WQ4ajYd0l9Zb58TQ8kCPjQq96DXNcZHFLesQ/6rg9jpJ7MxsKAA6kJWn+p7UN/bNSIC9X2y5RB7juQ+V8BIJ6pXKhlRgCJ2HqwesCQ4IjoJDriTbCTWu8nGY70TsN4hszVS+6FhrhIRtSPCyI6jZrw4jO95VaxC7dDPrxqwKK6obCC8MbA/qTY1MbUPmWf7kPVeh/Vuh2HRgRcdeBYQ532SAM07xHmfVdFmHXgmbok1oCEAirFQ3zJbkk763duP+GlsEbrZ7A0s4J0wnRC1yCQBkferA7jnkevYgoq+4VxWFDuyfWD+cADOLfD/zl2HT1y6EZ9dngEAXDc7xE2n9rFzeom4N2BYpPJsB6zXCvcu16p1Bkin3mE1sD4hI1zcb6yhBcit60UYrfVFWpEuDyLlG/xcn6e5r3PdHBMo+BCPWRZRvh4PTnO0OyT0lwmzS4Q+xToVezzKgE1B14TNhpcE1aC+Sa3+1X5zal6jxyauX1G6q8vfb+lRpMc//vFmi7u/v1/ce9vb3gYAeNGLXoQzZ84U986cOYMXvvCFAIC3vvWtn4eafmnSF40E5J577sHznvc8+33p0iUAydXt6173Ort+77334tZbb8VqtcIb3/hGvPGNb8TjHvc40zn84Ac/aBP1e77ne/AjP/Ijo7LOnj2Lu+66C8997nPxb/7Nv8Ev//Iv47bbbrNnb7/9dvz8z//8I27LFFgA3PX6iM2dFE2pQxXPTTHKLr8CvPhyUDHrcAu221AKZrmx6Vg5wkypZEQjbhfVidUfAywaOTRwdulblVPWictya1e8LWptYhNJfYLCk02j/+qxGtkPeFUIP9aOEU0qEBG0t8Z1pw/x+L2LONMfYh07fPrwDP7s4bOIDyyw+yBhdpHRH6IIQBacvQcpyNMAgwOLOo8woRHZ3sLiYTAsIjeQGVJ3z6KXUwD6IAMmIEIZWU8CIEZ2CoGQoqQHYWYox/ZwrnbRieG1go+5Sj4Chp0UoyPOyECFngKXqijIoBrjuT6ShFCZfjTmesmBdHO9y254BYAkNTh5JgDckxkIk5tDKfhfKiiS2q7ISbPSiiyiuQaDo4ERAwExmGoTBgbWBGDI756PLdIiuc7eSxhkPklMkBAAHrjwcIVIiAMhurHnwOkgQjAkuyw5kNWzsAFg/Y8yeGMAFHAUFrg/XA8A+PJTD2O3W+GGxT4unZ7js6sOw0BmD+KdTOgy6g9WGKikPrke9TJs7zWyJKToMi6vTK47VE2heq2fIGl+0lQMuYw8v2k8z/VBVdkaqjgh0imxmuPECaB0KjGRIJLDAhYhPbu0Vlsx5/Gq1RYbgIn2cnmtkFACbu667K4WYGgAVFsSTgBqPh+khuNXO8/PJ/3Wb/0W7rvvPpw7dw433ngjnvGMZ+AlL3kJnvCEJ1xxXh/+8Ifx4IMP4syZMyOb3N/7vd8DgKYavV7/mZ/5Gbz3ve+98kZs6UT0RQNAVqsVzp07N7q+v79fIN9hSCvU7bffjle/+tV4z3vegw996EP4kz/5EyyXSzz+8Y/Hc57zHHzv934vvu3bvm2yvG/91m/F//pf/wuvec1r8Ju/+Zv4oz/6I3z5l385XvCCF+DOO+881gPWsXSFi+YmSUahv1oxTYXq0MQiOqWrDDSe9eDDMcumU85uZ5D89CSXAaAjURHKesv1qaCXbnhmjmOlnmHPcpFHbgs3mMyygd4lrda7TlM+gKyyZR04TlOU6RneDaDQJEgBiB0jzhi8E7F3+gg37V3GDfN9zGjAp5en8P8unsXhQztmdN7vi3tMOY023XD1SBOBsIoJlKwiwtrF+NBAdKsBEIlHdu+qA4ASNHhbD7XvIALg9DJq8OHUfSwflf+rRyZRJeJOT+RDfhbKDCeD8zjrEBddAh67IXlWEwmHudf1kgoXVM2PQQE8gvs+AiHuJakYNT/2Bfgw1SLJShg5Ehud2ImevICQOntj7IK4PrX5KQESDyl5PdLndA2ISKpQIvFiZQwDkrpcjECkkmGWYIQWGV7VsooxgxmmZyNoyt6sVrBo6CnYYF4PuEN5WOG4+6JLFQBA77OoPiWpKQBw6LCkXdyPpJJyy94F7HQrPG7vMpbrDg+tA4Y1gWJAF509iAchDfIg0NTj6jGeohFamS7DmrbhvqemGlk1b9k7V9BntM02Vs7DlVvLa+lKLbUB5J2CvIPFOpvL40bvNg+NXFl1OR5cgMt2quMAX8SUDU3zgG2CjktzlbWevqTpd37nd4rfd999N175ylfiDW94A1760peeKI8HHngA73nPe/DP/tk/A5AOor0B+3K5xCc/+UkAwJOf/ORmHnr9E5/4BFarlTkl2tLVoy8aAPKsZz3LDFxPQtdff/1IT/FK6SlPeQp++Zd/+XPKY5I8k6o01bwqzaQEpWJ8gTFTPkUj8X5jkR+pCZEydbIhObUfIG08FHRjSswWhWTjQAO500nOaumUNjkfVV1VAZiVmeTRJpkNrnN7ydVV81ZQshFoOeAy7lvlJOsOLK8Vp+rKINTjos9p/sZIiNrELqM7tcb1pw5w885l7HYrHMQ5Pn1wBg+dl3gfF4DZZRY3x1Vkcw386PXsVxFhOeQggxpDYhiA1TqDj5rqgHZAAggqIaldvsZslE7qMct7V6rBDXOSdjjgoZKOPAaietWn2B5x0WG902G9G8Q9LjmVKtFR9ypSlS58a7zaIISr94OL96l8h9P8MPBRzxXPEEY5XYaAEJXw5WxyPTifMIOANQgpQjkliYqATAWdiefjBELAoEBgdXssSIYogsUAnMSbGceYTHY4CNjTcU1n/hhSXl5ameyLKMX6WRLCUlTfOpJYJ6Tdlj/9+qLrU+O9ykBE3tuYvDDNLgGggGXYxf8LjD5EfNnuRZydHWJ5qsNq6HBxFRBXCRyxBEy08lCRL1sBY81L1+9si/w64NcMX5Tanrmmlfcn8gWaa/9oHVQpktsrbG3wKqxw4EPXHolHU+dbSIrYSVKOq6v8ZsljlG4TY+/XdNdWBYij/QlluuKZ1pJ2TH2mbCa/kBRBiFe5MprfhQsXiuuLxcKCLl8NuuWWW/BjP/ZjeMELXoAnP/nJ2N3dxb333ovXvOY1eOc734mXv/zluOmmm/Dt3/7tzef/8A//cOTp6mu/9mvxX/7Lf8Fzn/vc4vr58+cRZW+aOizW6zFGXLhwATfddNPn2sQtVfRFA0C+mGh04qQM8wZQ4dM1VX6qhdMW/BOAj3EFcz7225dTbF7CXAyM7ijZeADJ8NdOgxVoOAabTHc4ZeR90FNA3ixrRkWNJsO4TiN7ECRHTKMTNM9sTq3lrs2FW1+3YVud/HN+Q68ZqtaGp18lvRqexwWDdwfsnTrEDTsHODtLqlefOTyN/3f+LOKDc+yeT6pXnYCPkdRjAqgm1Qon/RC7j6x2xVlS0VE2SPfqWN443F8HkmqWxgphBocu23QAGYTYREtlmapV3yXmNwR4r0ypf4JIP4JJPtTeI0k+2upWBkL8GNVjQmV6nVAt6ePUK0VQ5pJK8NFgrIMZ7KcT+jhjk9oUZfl8AiEKIOKQVM3CmgRwinrXOr10BkIGZdw0HoR40WICAifmvAg8SEhsScgcrTKmJIBFAG1Yp/r3R4zhEOiOEgCJqwDuGOgYPJAdONQ2XKkvsjF0S720DlIHhgUq5C7gqN/Bp+ensejWeNzOJdy42MfRqR7LZY+jVQCtusI709QAKqM6xbA2qQYplheNxjw3qZI8TdTHiqgBmy+7BrfQ/nWHD56R92uOUwdV2yOfZyGF0j1qQFLLWokNiVeZ0zoYmJHHB5Trdavd9btSAS4/L+p3t3mYU+UzSY003ubEgPFxYOmLgG699dbi97/4F//iirxVHUeveMUrRtee+cxn4td+7ddwxx134O1vfzt+8Ad/EM997nOz23dHp0+fxjd90zeBmfGnf/qnuP/++/HHf/zHeMtb3oJnPvOZFtcNSLa+SrWNr5IHVwcHB59L07Y0QVsAco3TiQ3hWuBDb9ULsXum+X1iIT22LlPPDYxumTwwUZRAgzsoIkwXp1hucyqqFWG65GHtgIhunI2NztfNdPDFm43p33N+pHmiRVW3TgCPdM2VpZenxsSlbdnU1O0opR8Rs70lrt89xPXztDg+vNrF/714PS6f28POAx0WDzFm+2yRiUfgw7ctJGYTnY/r4Y8QEwCgSNmjUh37o1LXSfVnsQOJhUtdeDBDEUDnjNUlX6deVUg+DHCkzzhLgIRnIblzngfEOWGYJ5uPYYEcnNIDj4bEo7bnGEn+HPgoGJ3W3BsNevXblUdVOhLvUumd5lwRZgeCHBhx85tJYtYEThKQdXpvwsAIfZKIgAAsBYRElGMXKOdDAkK0hh5LMieQqm3rUoelQwVOKlxIjg8AoD8EhgPC+pAw7KQxZY7AOoBWBFo5b1mOSQ72uw1A7CtlGzCKSR2LLxFi3+PifA+f7gfMwxqnZ0e4YbGPg9MzfHbZY1gSwhBAMcUcAk4IMEiBmxtyfzAhX6ga+FE8Gc2usX4XEurW2lTfb61DDhjWEraWe2FQkkJ76aB5y/Lrk66l5H7r2uwCxqpjgSCBEEH5XdSyFYQcd+AzpZ5mh2o1UbnG+7wsoysBk1PvNW2o++eRBiYMV7kimt/9999fuLm9mtKPTURE+Kmf+im8/e1vx0c/+lG8//3vx9Oe9rRRuq/6qq/C7/7u79rv+++/H//kn/wTvPWtb8WHPvQh/MEf/AH6PrG8Ozs7lm65XDbLPTo6su+7u7tXqzlbcrQFII8FqhdMvVyfBNW0YVGcPMlrMV6bqrZpA3XgQvWKY5+CDa5Op/s+QBUxAL9xEbJOONJGRl16hgOlE/01Z2PJut3FpzADwsCpeteUFMDa1uj3dI+Ke8UJXGWwWursO+Z3VMdGJTxIsYjn2fD8xp19LMIal9ZzfOrydfjsg2cwe6DH4kFgrtKP6BhaJ/koN2W2dnEXwCSqNqPggQIgWmpYes/n52J3sHjBApBBi6rxqBtdtfXweaptSCXxAJA8Oc0DhkWHQYBH7NXjj3q0asX3cONUMW31eGqaY4HHSYlp8rAAGI9LGEjUoACK5N4Ncb7QV4H/DLQShgBwl8Y+DoQgQeFBYry/jAhIbpd5ENNpaSd1BK7FLZ0yspzHyX+HzLUo8XRAIEogpFumGDTdEaE7olRvDgkcLQndkszzUhg4z1HHKBNkOnnGsVqD9HJYA/1BWivibIaH5qew6NeYnxmw169w424CIReOOgwrMte8tSSgOS6unzcegiuQa7j03gSmPKiYqk+dzi55yUVj/SMHQIqDCHLP1aBDwZbuN973RF1/yp7j4owwyAFzfwjMLiLbJAWXl46zgh5dMytgVbe93q/qgxsGijFS9bNJwOKomWaqLl8CdPbs2QKAfD7pq7/6q3HjjTfiwQcfxEc+8pEmAKnp1ltvxV133YUPf/jDeN/73oe77roLf/tv/20AwHXXXYcQAmKMeOihh5rP6/UQwhes3V/stAUg1yAVutDNBJsePjl4aBn7Tdk+cLUBWVrjrN2fq4eeuikDPTjXjxwSk8AhnY4p+MAagNiHGD/rAYnyn5RORyxAW6NuekpsB8hIzB8zTO95BEIqxuB4o/NG/wlHUmykLm8DIjX48IyV5q8MhUg/eDfilBqeL/YRQXjg8DT+7OGzwGcXWJwjLM4zZgdcBgwsGBp1i5p3WY33QYO4YNWT8ZHnK7fL+6jlLXWrQBIJnY0pRgjQKOr2rLrR7boyT/Xe5KUegBhLJ1uPYZHc6w7zkAIKCuAwqYdzj1v0PcYgZFIKUgMP/+nppKepnlydOCTmjWKaCGYLxTDnDFq/KPYvLdfN9r5SUpYiYgRST0YJZBgQIaBbxiwJISQgiGiqDp7BYzFQbxJzknwE58lOpGlhTQmEHADdDiF2AXHujdWdi12LVVP1KZXdzrpGMDLgcSfrYZ0Y33gx4GhnhnPzUzg1W+Jxu5dw/fwAR6d7LFc9DlcBtBZVrGVu6yaGs/Vuj07bbR04ZlF2r5RXv9q4B7i1mVACiAxAXIc1DmnsloIOsdmzuEoVQGKglJoU70iqbxR1PO5h0kedP91Bmtt1XTfa39RN93OiGh8vjQHLHqLtBcqzDXbpa9ow7icBL18o+mLwgjVFagS+Xq9P/EwIAX/tr/01vO9978Mf/MEfGACZz+e47bbb8IlPfAIf+9jH8I3f+I2jZz/2sY8BSA6Ltgbojw5tAcg1TLY4nhBQtIDHSYzrPMiYIl2sRwu2B0tc5lUYpncpoioHpBPOVbpmJ1VOKmExQoTp1ojnhZ6wivatgkn1w9QMFHw4hjKDEO1XSobA3uMWUD1TczyuDi3wQeV966IA1AzACHygkUbyNduP3Yj+1Ao3ntrH43cvYrdb4YGjU/izi2dweG4Xuw8ELB5m9AexAB8Wi0HBh4CvMEQzTkbk5P1qNZjHK7XtSK55JQChpwiRTkhDKjsOAlIgQq+7o0bnymj1HXjWA7N+HOguhErVKIOS2AcMZmQeMMyT5IM1uKAanLckTqiYdj+GtSoIcTHOk+/jlXAlrbkQEtMWObnSTbYbYrfh3gv1sks9J7W4vlokPENmqoaECDaX06quxAT0SMELA4stDwlID12qpvcExwyz/fBSMAWsRNngXYCHRm0Pa05xfg6AuEjlDwMVDKgBnQizWbIiqGwjE8qTeMbYEx6n9aY7BGYXOhzOF/jM/DQW/RrXz/dxw2Ifh2d6fHrVYVgvENZJIjPJ5FJ1SdcabGBkkUEFE5X5VevnseTmMOlvZYirtWi0dlGaBxCDfa2KgRUFHxr3RsfCDi3QBIWFpEWvB/fuQdcflF7O9HmZ+y3nA6Pm13tP1T67rACNrYuKNHV+I0l+la7Y9zTP49aDLV01euCBB/CZz3wGAPCkJz3pip5VwFIDl2/4hm/AJz7xCdxzzz34ru/6rtFz99xzj6Xb0qND1wa03dKYaua0WoxrsLARfNQLeyuNfK9/t56rxd1TKgB+w+KQTsIQkgi+P0hMQXLL6TY4hriJ5Ryde4XkQadKy37j9HrxWvaE+11tQ7YDcIbJtdqCBxWyURZjQ2Ve9ru1OVWApUXEZX/aabec6PPOgNOnDnHz7iWc7Y+wih0+e3AaDz98CvMHOiweSl6vgq61NbhRyYf0MwZOEo8hIqwG0HINWq6B1RoYcqBBrNYJkAyDGY9bLI7W6a7e0+CB6mHJ3xeDcnRdAh8SFK/460OKHyIesNTAPC46DHs9ht0uBRZcJFWPOEdSw5JggqPggPV4NgCkSjxAEqG7kbagY5gmVPOvYGT8WAvTNsyRXAbvJPuVYUGmM69SK/Uop8EKa0lloU7mmEvuBOTMVD0meaQa5kFAm6jCSRBO7kUlz7m2TnlTe9yVHLC3QJaDAJBDoL+cjMT7fUJ3BNCQ2hc1gJ0cLhSG6Ross9G/6uLX/grJXrIH6S8RuvM9zp/fw2f3T+FwmGGvX+Km3X2cPX0APrXGsMPFiX2T/Hu/CYxW4GMyO7fOTrWv+FnvDVqnUb7cno8T74BGSi+wLKOQTqmrXm9HVrwfbg0EII4PcqBYphKYtFTAWm0u2j7R5nreNw94jslzSpXZpDX2EIpDuZNqHTzaFEGIfJX/rgGE9drXvhbMjOuuuw5Pf/rTT/zcer3Gr/3arwFIHrE8fcd3fAcA4Fd+5Vdw8eLF4t7FixctAOHf+Bt/43Oo+ZY20RaAXIM0Wswq5mZqsTPG0jPbmzYgn3+xCU4sxPpsVaa/V6i7+CKEuYp9YuxpnZiC5BkLpUcrrYcyH2vOjEUd7XzUBxl0WLC9gR0TU7bPTrwDjf5qQFHbDxSqL5s2opopHNW5Ah61NCYA3DPiTkS/t8b1ewe4QQzPH1ru4rMXT4POzbF4iDC/KC53mcVlJjXLbDPKCZBYpHP5hH0OSf2mCA6Y7TdyncmCBKYo5b1FOre0IafhvgN3HXjegxcd4qJPfzuzFERwIVG9Zx3iLAUWXO/2WO8FrE4lL1exEcm8AB8tsIFybDPTwo1rrt/qP0x8L5hQvTe9mdscM4Dg7Fj8abK+G7Gc25OMahGpPbm/NaAzpwTedgjDToc4Dxb4EKrC09glWBjWqYjoqZ5cgBD1wtUfRMwuMeYXGPOLQL+fXPQCAsAMdMFOnqfaCE4gTA8ruiWjq0AIxbTG9PvA7HwAHprj3PlTOHd4CgBw/Xwfjzt1GbtnjjCcisnDXI+SGZ86xKnmRlviTMWnpi/eeXdgguq6ph13cNkPunZ4+w6f59ReMFq3bO10gG4p/btitwbzuK6uvnn9hkm4Yi8quH5sN+Cz1j42kjS7tMVh2AkBoqadvIfpdOTKugb4dJF0Xt0//jw07L777sP3f//347777iuuHx4e4id+4ifw0z/90wCAH/7hHx55rXrpS1+K3//93x+FYbjvvvvwvOc9Dx/60IfwhCc8YQQk7rjjDnzN13wNzp07h5e97GUWL+7y5ct42ctehnPnzuGpT30qnv/851/l1m5JaauCdY1TvaAeS3VawskXZHePy71yxDzXUpBCEuBOv2z/CLATWC3PRPuSd72Ys+YvRtTMAKsRbs0c6KfbhIqTZkrPoz7JlU/yjfXd0mBajep79SZWp3V5Nseh2viMOTbpR8TuXvLgs+jWOBhm+LPLZ3H5oV3sPBQwP8+YqerVBBAyQ/GpedA6klD1Km9k7lzjejWZ4l4X0r2OAfQwqYl6u9K4HjMHPOZBXM0q0yZZKmAMYmS+SH8psnm2+6glHtruybHz74nr8/p6ull9+uxaAKPmrE5yTKrzPoh2G0PiZXBRR2+grKfS6MhOZa1If9Is72dSdSQx5pYxsXYnmxCNHaK2QBkcZ/DJ5tEMdq3o64jEvjCDmRARERBk04kIA2G9gsQFSdKPAuhXjL0tD5xsPULFAOtnYkSSnUFAtt3pxG6Fe8LRzgIP7u7hunkC8zfs7OPCqQWODmYYDgPCEqAhDQZp/yHXR8dqk8SruDQlLarAx0g6hg0MejUf7R3R77a2sowLFVKRQq1Iy/QqbQIc/aEPgELam7zY0XgtbORnB1Oc3arbcqJfCvDkPglJXTbkd3SkKuX7wd+jMknLrsg+62eB0VhOjvuWjO655x4873nPs9+XLl0CkAICvu51r7Pr9957L2699VasViu88Y1vxBvf+EY87nGPw2233QYA+OAHP2jA4Hu+53vwIz/yI6OyfvEXfxG/+Iu/iDNnzuDJT34y+r7Hpz71KXz6058GM+Pxj388fvVXf3VkSN51Hd761rfim7/5m3H33Xfj3e9+N77qq74KH/nIR3D+/HnceOON+I//8T8i1AFzt3TVaAtArkE6sT7wMc/UIOJkGVVMd5HhOLluBP4Zry9sefq81QC4rrP9lhW+um/2CxGmEuJF/UUzOOdHLkuIZAAZhzQBgd/8rUpFgrIPJmkDENmYVkFYB8SeMSwYYXeNMztH2OuTX9NzR6dw7uIpdA/1mJ8X1auV9k9i/kbj4MBePqEWY3X1DFbUV7m30Ky+GaZ7YOIjY+s1782KKBmchwQ+4jxJPJKkI4jaD0bSG2VOY0/mXUe9QMXilN+NSQ0oKoBXpAFKjmwKJDaSgsmBZb1Em12Llo/be6RT1eKEOGmERSyXPIOoxvAaFolambTRu6xzweHJqHYapnbF6ENqXFjF5BjCN9qAobx/yEbf6hZZCyN53yCumwMjBTKMJH8hqfbIKbuqXiWVKTa1nTDIO6tjwiLZVM9Y9Tsm0qEwkPUHgGSLdEiYXSIMix4X9nbxmcUZ7HRrzMMaN+wc4OKpHVze7zEc9skxBqMwkG4e7EzRpvlTAA1ng1Yz0RNgt7hc1UXNc2we2WeVmVuX03MJKGp7LXaQqPoZiK3fJQEG0PlbFmrP+LXHL/OweQgD1N2KAVW31bQhg5CiSynn1ZIceecTxbvlAE5T66AxfgVo08/G2vKFIlWbutp5XimtViucO3dudH1/f98ABQAMQ5pst99+O1796lfjPe95Dz70oQ/hT/7kT7BcLvH4xz8ez3nOc/C93/u9+LZv+7ZmWW95y1vw3/7bf8P//J//E/fffz8uXLiAs2fP4pnPfCae85zn4O/9vb83GWzwqU99Kt73vvfhX/7Lf4l3vvOd+KM/+iM87nGPw4te9CL8+I//+BXbm2zpymgLQK5FqpikOiTDxtMZuV+cgtLEIuufbzAslt3Es6ONnzND5KOds9gVR2LzWsUNxkwlIskwnOyEzJ/a6eZFwpQU4ELbDpjRd22kqqe4BUMDlN+rDabYyCf6gRtMQMFAbOjfoizOmzUbAAF4EbFYrHF6tsQsDLi0nuOBg1M4PL/A7sMhudxdlsb0JEwDMRcnsDZuChTXEvU8xuSdyoMJIEsyVN1G76tBuveM5RnQwYGT2ltW1wF9hyhqVzwLSfph9g7ZSDp79RE7gU77hUxVxtsCbdwvafzpwccIrNQ8W+t98+DDnRSTjF+tF7+xblX+fi405xAnJpFXJPYqlUten1bzYgduhPmjwFnligI4cNKQW8Y0dGupXgNQm4qGMbKSUN9d4UzV+xHHAERCD4A4IAxAt4J5XqIobntXbNK82AMUyDmp4DGw1p8S1Vy1x6KkIU558gFhdpFw+NAcDyxOYXe2wuN2LmGnW+H0zhEO9uaI+x3iEugGap+2u/HxhxnFWFJOUxwQ2buufVSO+yaVpGYaLaeoWFXf6ju3rld1M6cg1X5Uvm9U9L9vizo8KOYg8jpvku1AQJft3MKQKtap+p6u+WrEHl1+bq77ddr3QT6Qyema7a7XhuPo6vL5X1T0rGc9a6QStYmuv/563HnnnY+orBe/+MV48Ytf/IieBZK73je96U2P+PktPXLaApBrma50QTwuu4pRPnajYzQ3utFJky7qMTESGu188PEXCHa6ZRtml+/Zpsg5Xdb7prxZFe0RxtptHvqb5f7USWXNlE/28RQIqU75WmDsRCdijilp2dPEnhHnDCwG7MxXWPRrDEx4eLmHBy/toTvfY3YR6A+S0X7pAICd33uWdgOI2aWuxXRQwAAYSGDKv7kTzrULyShdwcfgAAuQpR91rBCN8+Gimcd5D/RJDSt2wbwXxY4KBkdBRxHHw6dpMDiFGkg9FBvep5JRzKoi8rMp0fCqIt7OyOaJAKP65PbY969qV76eJ5zaR4R1ipIeAmMI5bwu6kuubo55CyAMhDTmBmKkwmsGkZOUqUvmmvQFVuAhrrGNOZRPYuEkQ0JtYeVUMwGxGchlcCBbCwqvSpzv2xrDACPFIQkDJ3BVgYHuiDG7TBjOBxwtUpT0jiL2+iV2ZyvMd9Y43J0hHnbJ8YUyvJvGy61hNvU2zrOTM2f5mdzFo7nh5nvxe6oex+0pLh8P6tmD/+rdU5XblvTZgwKzCzJ1q7RuDQvCsCseDzkBEVapbL33+Hntfo9AiDaDXd0cMBpJuk9KdUH1+v0Foi9mN7xb+uKjLQB5LJJnflExTcjXav35+vvG/Ou0usDrQqubh1w35kKYhvWCsDpNWEsAUTUgB2SjUj7VMUFWjjhMUn11Pc1UIFI2FAVzUbYjxwhp7i6tnWpTf7hHRiAE1fdWNlVbC7Ux/5ye/HcAzwBeMPrFgL3FEvOwxuEww7mDPRxcXGDnYsDscpZ+FMG9RBXFSyVSlOIMNizatX4XkFFINbxKFQd5ZsgG6kpe1apQyQo5wKAYqHMfUtR1ibyu/WcnrB1KIGJ2Hc4GyNt5CCOeglQiReWmPE6FrZKOlT5n45knQxGbwknzYid5T+3JPl8FIowSLHna9D6OgI3MY+bi3TYQIgwbRVj06VG9gGLuJvBhHnTF4026mdaV9BKS2PrQWoDBOmZJBxxDrQDX3wOBI8NUgAYgCPildRg5rPAer0w1bCDQmsxhhJVF+YubRmBmi3+iUlffX90hY36REGc9Li328OBsjbDHmIcE9A8XcwyLkACI2oKwK9ONjRY6sqlokV8jqvVVrzXzqddkeU/GnPbE72qtKyWiPLpmgMpL70jeSbW1cqDP6lcHLkXeE2ppT/I2RugPGf1hch6wJMKwA1O1pMhpTtf9rfM35Ht+HyqmhrUzP2uAqnqPmu9jvde66179a0tb2tKV0RaAXKPUPJFpMMzHbXijBbsBSkblutO8UV4CPowpU4ZRNoJkJMxY7wKrM8B6L2UYluKKUfSqLT9ncFictNUeiFQ1q9rw/CZQn4SbzjuUgWg0mt3+UXAwvuHtvtLnm8+MOq/66TfUBlORGFZGnDF4MWCxs8LebIVAjEurBc7v74Iu9ugvZelH2uhTQXqCXDCCa0YYImhdo1UFGFxeq5lsZVBCSNG1VZdnyiWvgo8+qVtllS4Cq0TEeQZikbQY+NDTVnUh64GH9hUyWCiAgjBJVh3O9xDkdQjl8BlpfmtRJxTgzB2AmU3Z0Zja/AsZNGCA6cgrFqzdeQLj+UD1dTsxzlIFDpTrsWmONgC64q3ErJfTNyIB0bUtFiHHIgmUVPZCl1WI1mIrMjhQUsUIsaJVPW2IwCogdOUcKOaPPkcEXlFK22UVPWs3J6BR9islA/RApR2BtDOsxCvWjDDszvDwYg/zbsCp2RJ7iyX29+ZYHnUYlp3FXiltfjb0dYtZvQIqJAitdQIyh+rJW4ENA9/I3zdL/7JUONkvpQKi2vv4w4Augw8PEKwexTDK+guRYAu40CCFCITuKIGQ9N7md3+YJUmW2ac5lTADHlGKa6lf1sCQ7XKRdpRm0/t00jRfALpWbEC2tKWT0BaAXMM0sr04yTrQYDb0umfQGY0NUhdVd5Jk13UTVPDhTqDsZJoZsUtMCms0XAIQGDyjfKC+dnmKdEPBRctGwk7aHBipRd4tXWNrt0hSTF1rA9mmSlVWVPbpaGxqnl4ZXl+nRh7aD37clEmOPRDnjLCTpB+7/QrrGHDhaAf7lxaYXQiYXUrSj7BmU1MDkN0US6cTI4GPlQQVjJwkG5GTJKNl/xHCiJEEgBxSu0HGTCrYCEniEYLYQkisCYlirkynMR0B5ia2dB2LrIJVj7XMBbULiB0lE6DMUefxcjYkI0mJNsHsDBL4UMmdGjSTA4n5IflUY1wRK1AEgoDnbnBMXFX/3MdjZqnuXwZbn5gOvs6XbhzLoUVe6qRA03hnSkFDAcbAOWp6isrOCF1Gbsm1LiEcDen0O8aRlNKr+fk5ykSlWloISdWv9jojAJcJ4D4gzNLcUemZgrqsKqecN2XJEbn1SG6HZVLFiucJRztznN/ZwawbsNOvcXrvEA+vOgxrAnFI9isKKjnnUZy4U+6/3HbfERiN6bGgRud2dPc1H7cGFQdLjbEvVAIpj0FdLkFACMHWcHs/nAqklaX7Qa16WPdDFCACmavqKlvzk7QaeNNiTwSYJMswl7dL2dDeohu1f/QZzn3lD9xG715jzCb3kEcIOLe0pS9V2gKQa5FaG9gEQ2EnN9VpziMt12/SXn3F+5a3tA582LMdTPWnO0rcQewds22VLBd7cuV7EFS02zF9Xt/YTsJcuk39cxy1dIlbwGgEgBrXW/fThYk0rh+5B3iejM9PzZfoacDhMMP5gx3gwgyzi4TZvqhfDTlbL/UwkOGZDDUOtyjoMV9TYKLSCVXLirEELVZpNgbRbDxaHrAAkYYExFmXGE0FKWp0LsAjebYqpSBlsMn8qUxQmrcEdfuKSCNgkvqVQKbHLli2FtwocHAG5f66qlXVtiY2hsIpqWegEWjvSpuWJrn8LEDhLM/K2Oeo79YvnfMGtoEpqw81RkAqAuhlmBnQqOlBVNLijKx+FBWcMLCOwKoCGDo/Bs4AV+2PABQANwSQquc5tUGrGhF4FcDrAMwlSKUyyhLfRNcOVUPT9cE0xJxklVjsQS4Rhp0el3d3sDtf4YadA1y/e4gYA85HwnqYC7hKwLb2uGd4RA86guvrRv83iV0a/13vcdmvV0SaX/lzVKdaDbb4pDID83Q4ZACiz2pfFOpJTmKjeQbxchWWCfTELqkWmsqt3wvkgKsGbIbFPACb6udqT6sPf+pDDc1vJClB49lrhDR2x9XOc0tbejRoC0AeA+QX16sqDfWL9Yj5JxSGy7rp6KN6kut08JW58hsMS5BBQDYb71O+2lhTW8nVAcUmWNe51j3Wk9AWGChOwOo+kHSj/STzWcduNKOTzIrJ83VolV+UGbLxOe0M2BXpR+Qk/bh8cQez80GMz2OSfmyiQICoV5CcBCdd/pgYQ68y492sCkjgdRQ7kcw81p6yfGwPc7cr9zlke48468DzZHRuXaA2Hz2ZjrkZuVbMen26ykBiljWvzg20gA+VuBEAjgweYIbNYGRPWpTnVOtkWm0tbK4ps9UCnzpvBbCQupMVZopUwlPP78YcSSfGqUGxl/HpYLFPMpOGDID02YxZijr6k3N/EqzMo/ZldIbe7IJ5ap+ENSOsVeIpEo0hM8lMlACuSUD0heSkhlXMvQCOIdl6uPnhAS91ARw7EANRvdn1KXYJOgWybvxjMkinkGKH6BoF5PWo3wdmF5Iq1vnFLvZmK5yeH+Hm05cxMOHiKmBY9amdziDaGFHH2Fr/6jyygRiPa0E0neYkqlwnUcV1U3OSivXXgw840IE8D8wbmesH804YGk1yeVFM7wUxsuqVAJAucuGIQuvj3RWbpNqA8ua+YS2f3Cvh8kntH/dPE4RU+8a1QlsVrC09lmgLQK5Bqt/3TZvL6MTnuLWiPl2bKNv0u0XvVk9wva1GreqRdPhRAIgwOF7VGfbWUXRtMyHnClU2Qz29Lk7g3AlWeeIKTB0QmnTHt79OeyW7SSNtreqQb5Rpms8rEynSj7iImC3WOL1YYh4GHA49Ht7fBc7PMLtAmF9KkYnrzTdtomQMX+tUkPRUutbXFymHBntLLnThOHyXVlVlKAUdTO51g3jQygAm1UnAiarn9bnCsSMM84BB1DJif4Kggr69MuYaQ0L7NhllS+wMtT0w5wmMAYQQgKjgoxoOveajSQcQsErlR0iZyGW2xpWUER5k7AMjxpKxKgC9Ms8O1Edl7NTxg9q5uBP9jXxCtUY033/PmOn7HQjcJa5zCEAYKDOi5uDAZaYetKztGXAAmJagyXcaYuqXGC2/4vko57GUpBFxFtI8dtIP6z8wEKk87ND+0zpGkYJcJMR5wNF8gYcWu9jpVzjVL3Hj3gGOjmZYHgWEpRjCw82zEbdavvqMzev3aD3SPB1znT8bAzwxjkWenC+P1qZ6nWrkb8y2A5/ek5WXfiTwm9aOYi0up4gBOeL0/mPu3P7G+hnnNt21b6QC66eV7wPf/ur5SYA4BQh9/7We2dKWtnRi2gKQa51ajHK9uJ7kaMs/3gIt/k/K9ca9o1Mu55WozNwxVC3Jhd+IHPjwDJe1jxRYABbBvMrPS0+UUWxu1OQ2YE+u76b0hot0PsvWBsVVORPAowZe/gRb3e9iFrGzs8KuBB68tFwk24/zKep5fxARBIDUZaidB4nOvXkwGqKdPI/ABwBVlwEAWqNUo6kkH9xRNjx3Xq6YKJ1K96GcH957kQAdBSPDXKKbzyWyubhvjnJa7QFICXo1b2FqkPvW1D44GSQX7wuLRGKgQnpm+YodThoTMYSV/gmgQm1r5MWpAfi03cRIXqCiXkjtiSL1Ub340aNSFzvNbb1jjfKKOml/1Uxng2nWelFwQw6UhwnGiKpDAhggKYBHpbKU61fOJ6uOStk8uPHzjgaTtJGW6cZVJVsAgJ5FnS7lxSy2aCGPEw3AbJ9lHva4tLeDSztH2Ntb4vT8CKd2j7DcnSEeBMQVoVMQ47twA8jI7UW5ZjWY80lqzXlda05Sbp0PV/d1/WPORuOV+qGq1mb7MjfXHagz2zNfT/dOKLA118khGbrTwF5Ty+bg1Ho+6ouY3wcDbUC57rq2+wOpyT7zL0Yrrbt/LQgKthKQLT2WaAtArmVqMcT1BlJtLs00PskE+GipLpW+2iVLMyCkQpVhahf0qk9c7S5Mymwgb1IoNwx7WHaPIjo2AdzYFQqXoFW6InW9Cdf5VG3I+deNHD9b3G49X4+bPwUX9auwM2BPYn8sY4cLhwvgwgzz84T5pYj+MDN3yjzQwOWGG9Xtbgo2qJ/wMT+sosL0qaoMOT19f2rtDc0lroe36QCQ1CkkxkdWk+CiLzikiObrnfQ3zIE4F+PUWj2pxSzUTJmqDsl/BWgJJP0Ad4oLMzQvwIQyl52AGoldo8+xexaE8gS4MadULSUd98LsEmpQwARQbRRfgYV4HBDT2/qcK6egKRDSWk9Ehc9OuB0jZyfgzTIaAMMDk8LVcyNNdByws08ilx8xIwII6p45Up7DlAzHk+ohI7C4AxZHBcXhwBroDoDZJcLBxRkunFng7OIQ85DewUs7a6x3esQlgwZK7nl9X+pXavf3JEBxzPmkVMpLIFtJqvIn16MWH+/WCtY5bojE1THmd6e13hfquw5A27vmgAq4UUXffsnHe79TsRwHWfM82OH8jN8DbT5TWU7dHceCkGP476uuGr2lLX2J0BaAXKvUOrXaRDX4aCVpnHp55tffa4KPTsDHnIpgUbQuXYOOquBPkJz6Vopsq95l2Ax7rQ5+s6gX+epUqrCTYcq+5zUvVIEHfT9M1bd1axPY8HWpmGe9XugtV2k5IKlezQCeMxaLNXZnKwQwDtYz7O8v0F8MmF1k9Ads/Q4ARYwGqyu7U8sqkFxtdwMkOw9ldkSikQy75fcQM5Oohupq3+ENhwGzCVDdfHPlSUniEWeidjUX8LGTApGZ9MPPy9a4O2pt/trPAyCetYCwJrFByupQYRDQRarmVL5H3AsfHJMUJRcKk2aYMXk1X62+Tppi0el1XFjbKXOWadweeVdbKifmAarqh3qOnQiEaH0rhs6uV+9ctg3zcwlmB3JiUqlb5Gz7YSCESyAjjSRJw5iBuuQauAtAjFlMxMRgcSGszCt3ZDFPzL5IKAyM7pDQXe6wv7/A/t4c88UBTs2W2N1d4sLuDMMRJcAa0+QyNTnflf73pjHYBA59fwKF9Mu64UqYXj9/JkCK2TNw/lOpsnm6UtDp6uClceYeWfMJbA5DCoCic0jfgxrcUPICHMHZQ55M8i4md761PUixB7r3z75ydU9xFpf9acAFZbrHAm0l0bkTVwABAABJREFUIFt6LNEWgFzrVDHYrZPL4hM5XVOSUJ0y2cZhqjYodHE9IxXFL7tu2kGinlvgs4DEFETKmy+j8M9uereyWeiGR0ziqlF/c3HqV2yeFdiqGTOKnqFzfdM60Wptxu6ZetMuGAnPqPl6uvqNGFrk9o+e8cbnu2vs7Rwl17sccOFwgeHiDIuLlON+MIwxs7gf6s0KQBGR3DNy1Wmq+f9XANGXNhys9iKan9bbgQ/uNNhg1c/iGSvOghiWC/iYJbCxXhDiXMDHHKWLXN+XLXJcQq1Lr8wK+iQ1IAV36xKITEkStdwImNcsr61m4APVc1ahsi5+DpDO70Zavd8CIeTT6hg6yVkzDkJdxcZcb0qWPONMkPnB2c2wtcVXnMxFc3pPqsIMvCKhPS/xGEQPTkU8tWROpSHBAeFI4kghpDk8pIjt6V0SoCKqQGEtgAMAyVoXvc2arDthBfQHwNHlGS6cXmBvtsSiX+PMzhEO9mZYHQXEZWcenEbMqvaZZKnaYU3mF43v9ThoPhiP0yaJYH19BFha65m/7aTItRTD1nIHrGNHef759ZZzEMgRqXpoBT6IYU4bYkdYM2O9JwEQZSkLK5T9afWGjWVNXhrfJL9XVHuGgbOisKrcLW1pS1dEWwByrVLNoHratNi5BbNI2wAqpcqVMLK15EP3IVUPkg07rJPxZhjSif16l+yEd8RM6cH51IapfLKqdzCaTIz5p68Z02qzyJKG5JbVP3vikyztR+2nqX6twUpVP6+a4PM2IAYU6ldRjM/nO2ucmqfAgwfrGS7t76C71KHfB/ojzp6vKEt71FbDGF9ku4eCabV6cMHoGQjpsmQDQAIfiIkB1/gfAaZ6xZ2z9xCQYv0UnJH5jth6iPcmVeWzmABNd7vlZN8kBSuYaUaSelUedMjNY1pTlty1QI8yaRb12YF0tTPglGd078aICCUQ9e/VcSDLZ+McQhRSxz67L4avQwVsaqbX5kZjnupv8/bl70/U2dS1VArKOhcqUKyfCljWETxEmBFP1yWw69w3F7FBqjzqqN7220CINj7ZjJhnLHl3bd2JcqhyQAiXO1zaX+Bg9xA3LPZxdnGIg1M9Hlr2GJZB7OLIglTmCuSuLkCHAhECGLIu+bV505qufb1hLbf+t35w12j8fXT6766NvqN6XsffST1qt72aB8tnsQ4xSick0hZ1qsAdIawZ84vAbD+CWNxO78i7OIgqlrahbv8EAKn7qQn6/R5SPXecqtW1AEK2EpAtPZZoC0AeQzSlIww0Np96s3I00hePmWlv2idQdTLNSAaDQ7o3LAirUyl5t4S5VhyV1Tr9qzfTxLNkpkfiOfg8bJ/wG47P0sDCCXaEYhOqmF0pYNSFrQ2uZozrv+o5b0xsp9gi/cAiYmeRjc8vHi2wvDjHjgs8WDDbxhCKUW7hPlncnWqgwcGpX3nmTQFF5b1qZKQuuvocAtBLMEELWEZihyHuSgMQu4A4D1jvEtY7Idl5zIRpnsG8XRkDb4w6tzf7mqFqjEEGYAJCkBhic7UrjFKQmDVwAKRwLS15moRhALDO80SDW3KfD/ULQ3ZhYgoGvtEebjhYIP307wwL8F9yskGQ9zbOGJinh2PVR/VczQwgisOCkeTJkar/qBRE+09PvoNXuwHM05Wp71lGDoggtVtddINjkmxY36WYICPAApintWL+iooha1q9pvYrsmoE7XRZ02go51EYGP0hob9MWF6e48KpBc7Mj7CnHrFWM1w+6jAs+2Q3MmSwManq1gIPjXT2vAMto3xQzXv3vVC7q9Pbd7LnSG2y2JXr2uLLaHmhU+DRUjW14ut2OvDh68aS37AAhgUM3HVHjG6Z5nzs83tiKmmc+7/oqqoNJ7HTqPcsA+H1+4MyXX19S1va0sloC0AeA3Q1jNwmn3cMcRN8wDHJZviJkgEWxqg+7dM86nJq9ZTixNkzT5Tz9CoBymjXurv+hK0lofD1yOl5fN2KZyvP18Xuq/tfdww3OtEelZevqYREXaqq7Ue3s8beYolZN2A1dLh0sEC42GN+AZhdZgRVe7N+ShXjyn3uyPbDgQ9WsOBPkSWOgnmrik6SoaBDgIpGokZHBVOjqi96Gh5nhPVuSOBjB6Z6xRXwyMwvl2NaDshY6tUY22LIq3lmqhSUhTmprg3mW+eyY7jTCTqcHjyLWgiNDNnHQD65BAbKd5pdu7we/gh8DBJ3Y5Wlj0zAEPUlkb7vKmbYz1mVcK5TXuqWlnpgEBBT2BtI1h5E6SGE6ebLvClixViBlSTT35P7yX2zujub4ORUWqLzVb4nUC3MdOQkiWOAWQNpikQkcALWnGJMAAFd0Lq7cWdRw7pMWF3qcen0Dg72DrC3s8R18wMc7M1wdDjDcBQQVwFhLVKQ0dpQVr9Qy9I1rGorVfNFnxv3RZlv8btKMjpsGnm9a6z7VXMKAOMkiiOJh2+HW+dLN8i+kzT/PO8MBNnBgOw56zQu6vjEz0OvuqXvju+DK6XW2LWu1+/wtUAMXPXAgVtstaVHi7YA5DFAfpFrnbQct/iNN6H2tfQlfyqjloO0paBjlq8wKulEnsY66A6IFCev7gRM9cvJb2pUbmKpsJxPMiiXunqvWMhpLXaDlc8m0fDXCkav7rNN4AV54xwBplFm5c+ir730Y8bgRcRiscJOn3Q7Lq3mOLw8x/xCMj6fHUSEVZTHdWLkApITAM72CWr7ASkryjh1XVaxAqBudQs1Kq16oPxprnNDVr2Qe1GCDaoqEoekOrFeOCPzPks91Og+SRi4ycyU/V32cT1s5MZMhy4xfnnCMyGpYQHlqW6lpz5iBmtbKWXkCaI5xGV/aL5aL81HmXjf9RVwVubLGunue9fYYa2BDZMLX9J4GL7MGgDHDGLUjiF2GViVflAbnSx9qC6SE3AmxBWBBkrG2T7WhzL/Xv0vEMR1VbrXi8pVCCUAaTmN0FuRwWI0RkNMUpF1AGYdMGOAAyzops7tiGSI3geENSP2qQ+im7NggAZGd0SYXSIsL83x8KldXDc/wE63xvU7B7i4t8CF/V7c8opL5VgDDPe70Y+1DdAjoXzYkfupUO2Cm8dcPefv1yCEcjtGUhQ/hyvgZnPX51vFe7I6eI067YuBEJYJaJAErI19zi+sOTHXsraUGcq7Id+b6oGOpkBG3S/SHaNDgjoff/8LSVsVrC09lmgLQL4IqCkhqdZnT6NTZLgNpz4NcwyfggcFCGoUqJuDZ6z0pIxGG5QLYKXlhMxIpZNUV3ytK+yASKobu01SmK9jVK8KA8tWe7GhT5sZTm8+foMaGXFqm832gxF219iZrzAPA46GHhcOdoCLM8wuplgFYel0/xsbYlGuMRTCiIkEQ+N0xD4U/aHgIlvOJvUiVa3KJ5XiycoFf0vBA5PEI3YwZry29eBePA8RnOQjg4+NYDm4oWqAztGYwIMSB9JAQOfydupeqd/Gg2kMWMjpgoA8k46I04bW7PNSlNgBgbOTBLNJ0Odr0ODfS5bxUvAMZKmGugaGm29VH5kEZZkYbRCSmhKV6awvRu0QAObak1xHE3hN4IGScbh2fO30QL1cdQRI0EEy0RJhJAEZxROR30GkHyoRicHmt7lj7oKsJal/bd6GHBskCpjTYJQQINYdAf0lwvpCj/OndnB+dxc7uxex1y9xeucIl3d3EPc78DIA6zTZqmlW0ob1eBM1GeUCGLixa4x3nU+h5iVpWoc9pjLowZQv24ENAGWcEM+81+srXL5V3QicAxTGNLeGOWVQMwCB2NYdk2xpXRpz2NaUqT6q6tU8/NI6axbFWlGVu6UtbenEtAUgjzGa1DNu0SZmerKAzEhpecU9WXBrl4ujyOaxBCRaj6aHrcExM6F8rgAeblP0eea9xt2oNoaRC94N4MMDNK9+VdSp3pA2gJCRzrZrC5NTv1pEcb0r0o/lHPuXFujF9qM/FFUqAPXpMBljirGxOSWGm1UqIqonZrvBDcavI0Qn1fDG5RxIQBOZCkvss2erLOEgAxmF1EPVnQIQu8zM+jFIHVeNhd6fmsut98IzFb6zkPNujluDCTHQR/keiX1B7cVnci5U+vIjwDLxbtv4wjOdXN6PAiqYmsIDiowgqixhnQouIs233jnG9HpDaYyjzAXqSYAUST6c1P6iurfT5xrzjSiBk/q6997G1WA4tSySfqGBk4OBAChIs8aI6IacOpbZwlTS27Bi9AeE2UXC0ekFHjy1izOzQ+z1K5yZH+HhnSX2F0kKorZEx6tdXcHaPUGPRB13VKZ/JzYBo5q5ZgEJTMUc8YdKVK89dZa2X6C9nstPJgDitawQTsp7YNJsv0958LChj6YObHR9sbxc3Vrqvr7CBGws8/NFWwnIlh5LtAUgjwEqFr8NDMpxeQAlQ5cuuPseGNSMuV/vqWQuNeMwQBgO5M29rkhdTy3fxUdgd4pZ1KHxfXJtNOaSit+Tm61nRv2zU+CCy+d8PlOAxG/6XvrBPSMuImhnwO5iid1Zcr176XCBeHGG3Qtk0g/Nx5/WmjtZRnbDW8X6KOtIrq1ipu032k6Mx2fJfS73wtwJo6GAIwEQ/Q6L5u1tOgrQ4T1cKdgMZZ+3xqQGH1PqFKxN4/I5Fej4tNb+Rj4tyYGvU7O+vv/cteYJsL+n7bpC8nUgGfewkoaGhh0Np3csrIFulVyfqhF5shkpGbqact9wka4E1/WElzk4OACioAEQxwgOWLTUrwJy0Ezvitfn42xCtI7ccDdtIFpO6SmKHc2Q1rMAFKpB3RGj3yesLnW4tL+D/VNz7PUr7PVL7C1WONgZEOcd4hLo1scM4iZGv0EtNSnLx+dZ/VYPWyqtKOZjsTaRAKM8niN1rYkmmdc9v85rgE9fVr2GjzIqP33dzNHD1LsjIhQD3hVQLg+mTt71LbCWy3TrECoQt6UtbemKaQtArkE60UZQA4T63qZFsWa8vDpUzcAZs1jl7f50IU6u/fU02AUWrE64LF/Om9akgV/F8BXGmydl4KqNmlEZgDbKaOVbnwxPPT+5cVendV4lh+eMxc4KpxdLzMKAC0c72L+8wOxCh9lFoD8QZk3UqUxXnzMzlYMM5vqRpAFzBnVidJ42aUbNlGuE8jgPYrehwfFyv8ReVK16NSSnNuhw0o580s4FEJnqs2JKTAFBOEagTq9gr+ExZ1In3MQiGPejvy5lMKjJ7BfSQPdMvpY5JAvYqKCyUb9R29x7RwOjA5mEww4INE9j1NjsR/x77Y3mzbmBXweqeV/3hTGBzrZrRDoHyb38XqqhAR6cWpWpa3lSl7yte5rPWsxwJThmel+oGqMU0ZyCxAghNuNd7fuwBrrD5JZ3dTDDxeUCZ+eH6EPE7myFfj5gPWdRP0N5qi/9o1KQ4zjgETAu1qvGEl8DkeIeGZPOfhyBkce1ZKzvxs4XtgEY2FyopNlJQgqzG9x4QKNqnVUdibkANXYopc907pmBm/1bSyumXqdJoKftb+1LwGi9qfv5C0VbCciWHku0BSDXMl3BotZSDxotrlX6KamJehcBOWbSnYBLKhSnlP5ZYYDsFKpgWNh9RzqlrPmW1iblywCJ0WfZgJGaldtIrX+0PpT3Wr/BbgQPNUM2RZLxJqmU9ZO53h2wu1hhb7YEABysesRLM+xcIMwuM7oV23MWZK0GYgEpfooqKFTeiPSzPj33p9PcB4nZkaKUD/MERjxDkSUaNAIcPtK9TwuReHhGu+ny1epbfqqtRk6YH5w8tZxg4ri6l8eVNo5zZrTdPd9Gz/BEl0fNrDmmLb2HbkJumjPm1ckxWBEIkYGBEWT+pv5nG2sdYw+A2TkMUBBozBVc/uw+675QUCN/Nt8qN8+kYCE6o3FApKhihzREIIqO4DAkr1hDzJ6vgHRNgYmqcSmoMQlOUvlicZfMfQIrFuPGpCSw9YwGIFQuZUmyToEJCauDDhcPF9jfmWOvT8EJZ/M1VvOI2AeEjpP9CwMI1fiPBhJ5/XOfYyCBYsxGakA+v3rOUwIXJi2Au1+vh5oeru0Ta6KBG7EDsrxkz2D4973cg6wcsynLFcjSFAlMKEC5iHauYERUVgFILJ8sdR/1zwbeudAG4LK/p57P79PJytjSlrY0TVsAco1SU7zb2syoXHT96UyxkdSPuTQj8Tu5TUTUM9R4FYALuJYK0FNTZWSmVJD0ZlFmRHEaXKuK2WblNjOSvY9jPpFrSi2o2mS0eY6hGm20rc2dq9+epsqbYiQ9A662EXNGvxiwt1hip1vjcOhxcDRHdzmgv5xUQcCAd4Hp1R1SvztmI8rkCZTUVxR0AGL3QcU1klN87lPMjmFH3ObOCcNcNnwX6dgDDQ8kWiAlP1MxLI2+LsCHjT/cZB337UaQp2m0XAUGnqE2BpCKB5snnP6+ghA/nm5+2ntojDoy4+n15eXZfE2CJ060ywCfBGSjQSNJC8ds7y+Bu5SJuQxW0NhTlryFXK+UePzOTJ4Ke0BmkswKhEhQSyIC1kjgwu5nUGAxQ+rAfkD2mqXfFXgo4PHCkMgAR1DHYHQJDISqOxmp30Ja1zhkqS0J025jGRlhSeguBxzsL3Bpb4F5WGPRrbG3WOFwZ424SC55yUVHh+fbp+arBx+u/4uqaj6uTmWC8pniIOoYGpXt89i0JkLWIgOaOY8sWcvrRUu6U0so7B1QqUe1DwDpXr8GhiE9MCwAnkHsjjjnpfsDYdQ/V0zueb+Xfq62PI8WbSUgW3os0RaAXIPEbsEbgQm4TWn04IbTGb/Yt8CHY7oYMDebKVhYCgYVVoz1DmG9S7bpkFvwLagbleWOQIA8pwyhGTXqtQKQsJ3k1RttOowb+9Mv2uvqUG6EOUr6qBupscFMgD/7PMka7frGNuoO4FnEfLHC3myFPgw4Wu7g6HCG/oDQH+ao5wr8lOEsDPmlL9I/Bzo0gcXnIHOnq4xbFB36KNHK1zsB6wUhzp1dR8jl+9P+mqEYST6o4eHKA4ypPrW8ebJvR6qKrfzgpo7WT7OswMdI+rEJhGCczs9pPUn2abLbZ5nfKpUgQhg4qZZUZdb6/57BU1Bnp8braOsEd+KRyvUTd8Agqlnmpc6YUBdBHGiMA0r7GpSgydJqPBDKQFcTJ/fFEc1RIgKrO97aaB0oYtNkABKTVKRlQxI5GZuLPUiKE6J9TwACiCKYgjOipkLdR5nibpnUsJaXZ7hweoHT8yPMwxqnF0e4vDvHwX4PPgwCCmEHRzrvfP/5tXsEADYxy3XfsyZ3BtmNZwt35C6P1rszWa62obwEkxq4+zY3O7cm1GX4dcDVp5hHhHHMDwD9ATC/zFhFiKpoWqNoSA6xLLimBzBU1X/D2t5MV4NDqc9xBvdb2tKWNtMWgFyr5Bi0ln1Evpm/bzpNq5nqqdMvfc50bZFjDoCA9R5heTZvzLQWd6Sc95Nir+TMgxRxFzSdnsB6g/UKILV25kKXHgJUiMoKNDaT/Ll55y0kUFPgo9rYmuoRQMl4u3Qa/wPziMUsnaoCwOG6Rzzs0B2SBR3MmTmG06u9SJsmjdAjJ3UXjePRaUyPNM5xluw9hkWK26Guc82LlYtSPjIu1X4I5WdT6qHpfT82+rZWuZo82T0pI9UiAR+T71ervCKdzL0oEb07mDSw0AZ0dWzZhagaYvOkvMW8OYCX1LEIxFEAqb5wPMrL1CiNW5S6qN3H1DzX90DKApURddQdapwFABHUE2IMCAYUWvk2Bj4EsMQCofWQgYhXJfTgw5M3cgcyYNF3YZAON+lSBIXO7GY4UApD0mWuWrsprIB+n7C+1OHS6R1c2jnCjTtr7PYr7C6WONydYzjskoTYu+TVPqbGn9Xbj49LDxSHTsVYcPmzfocm13auAMsjoDrvWrqhUpPWWjg5pzU/nWNdmYY7iSE0S/O7P2T0RyliugU+7QisnhiHnC8hTYECJE2AkbrOtvdqWz04Rf68lgQEzJQO7K5ynlva0qNBWwByrVJz89hw31OL6fP3NjybT1hdOU7dRD3pjIr0gceoAhMegFCVN1B43sqxEaoNS08uC8DFuS3UBiHkysl5lXXb6O2qRVX/jox56zJrJkKe5U6Coc0SAJmHNdaxw+FyBjrqktRJ1DpKHWn5q9rldfFJGLdiXJiTtKMTw/I+WOwOtfcY5hDJR+XNyrVvxBRVfQGxUygCU06BD7eJFwxXpXa1UeVhE0io01UgoL43mY97zgCEjEkQpp9D6l9U/WT2ElNlsAMFcP3g61gxfsV7auXIeJO2nC0/QNT0RW0rDJ55k7aY+ASmIaWdqIwuufFWNS7qAYgkgbsO3BF6iAvVdUxgYWDzhmUeqwqJCyVbjRDsPabVupSYKMhogI+kupbzQQjZfbSz+4ACEZV8DIl5zfYgBOpz+ymKS95DQi+BCS+cWmBvtkQfIk7NV7i0WGO5SIcGtUveQkJA4z605crNC5Vu1AzuxgMR92zRNSrpLfJnu9dMV7+zPl+3Tvv3yJbmKGPnVB3L96Yq262XFtcD1XPQcQAQ87wNA8BrByxEYqJTuT6c8CAEdZqqvfrbJB2+rdZnG579AlEEXfVI6Fc7vy1tSWkLQK5BmjyBbWwOJz2caDI/1SJfMzVezUelId2KgcvJA5IyYeRd7zZOXo3Rt1NbKhdsByZqfXlAeAgGmLkAL8XplfRJAULqPqvKOra/9PlG2knwUY/HiCFAZs47AD2j6yJmISJywMF6hoOjGcIBoTtMkqcMLBwAadU/AoicmL769DmwGfHGPqlbxbnG7pDPOTDMUvBBlXoUrnMdE1X3g5dajNIjf46q7canlnpM9qVT2fPMxSR5wFEAW6qYo/Ixqp/zqm/O9iIx1ClAGnUCRlxTiHN6b1hbSCX1XVLtoxbj5uvogDOHsuIWqV2YOu+sIFAEd4k5Z2LE3oFv36euHPtUgCmJuUtSMpA4r4qirimG5T3SOxtWDBqG0o2uNyQvoqYDSa0ypOCCzGLLpJ3G6fkYszteILn0RTAQkpjZAO6DqBuSAHPX3xI53mwP/JrmcA9FIByJFORyh0v7C+zvHOHs4hC7/Qo7ixWWixniLCSXvGKM7vGCgg4ESLA9Ajn1wo3LkUszCcQbzHOR8SbgYvkT6vfVqDEPiz7SxpLkFPPcK/rT0nGxhgIpfRFMVsdCx4olaGQv+1EEwpILEG77g+5HFWiwOk71BTfu+77ksmumpN5b2tKWjqctALlGqThBq5joKduQ/PDJgUn9nJ2m2ol7+h37zDzTwAgabEx86deMesG8KQDRzcZ5QypO90ZMl7RX64ac18ZmVOpVXuVgEnw06nIcSCkY8gnwUWx+XgXNXNYyuj6iCxERhEurOZb7c8wvB/QHyftVWGdm12J+VGV5VTQwJ/eUrh+0D7K6VRAPV2Ucj1HgQBuziTlVg4/id65nwQBMUSX1qPsyfZ4AfHD5XQFEGMgx5ijmVFMaIvM/rJEMjNcZQKjOuqo9ZUNmFCpYlmYNdKt0ml7rjiszFwZGHATEuI7bBM5TGW7OSswMtQMqDgQCI1lla0ZJ/1FPOJMClZStY+gYMjvlJiT9+z5xY7HLbQ8DUrkxGQvTqmpsCEDfmaSjGDDm5EDBKuw6Uu/7fOp7MabnOSTj9z4gzjozXCcgqem4Zwzc+/4eGAHOcQMBEClIt09Y7c9x8dQcp+dHWPRrnN45wsHOHOtFDz4i8MpNLbd+25yTITCgiQ10tZnbCWBp3+v7+ozOw015MvJhEaU5WDhccHmb9EdVcGX9UCpUFP1eEAT0ChjhqOuoAzLq1S1m0GZ1qpf/TWuNr5IHLv4+HuFe+yjR1gh9S48l2gKQxwB5xri1FpjmBFXrqe6pVKztI/F0M18HBtQgkCXeg913Yni0NowKgEA3AP+7Yla96onf7zaq8hR9VYEN93kcjdQMaiDjvcK4+hZ9p0yxdx9Z1V/tI7hnYBYxm60xDwOWQ4dLhwvgco/ZZSQActQAHyjLo4KREgoAV8wcO+Nzjb4+zLyqFRUSHRt3r1p2bCe6z03gw/OOFfNRty8nmk5WpK/negTCmgp7pdpL16gZCgpWOXK4ARFjStIJLwMFo0WSwJjyNcyLXBCAUJeZVRB17nCWXlTgowRAnKViaw3sV3ceUn9HQhgGmdeiK8QJLMSeENmBEHmPjEH0XWzMIyGCU1J3sm8xNtbBpC0UQtptxNUzgMKLndpskEpJfPDC0eBIBYLrxJg6kCh7/+I+SUBSMMPcDUWfOzsqXScTY8vQ03mmFFk+HAGzS0kKcnB2jtVeh+sWBzgzP8LF3QUuLmZiZ1WtubJWtaQgCJzt3/z6sxGoo5rj4qjDAeriU777Qy3Lp16/3F5jeUy9mg5cNcuq5y3b7SwZ0nXSAyGXf32dA4r4INZvbq8q8qvqBYy79lj+Wiqs9RlpE5xse9nSlrZU0RaAPMboOAZsxAx7EIK8GXhGpni2YhxJT5W67A0JpBtHYjbU733BaHL1p8lbi70HIa7qtmHw+H47j3ITLsT5x5Hf9BV88IayK4DV4vlaG5NXO4g9QLOIRT+gCxFHQ4+Dwxm6S8n9bn/IoLUgsdjKLAMTb5CedKRTkDWNk2D68NB+SuoOIxUyD0BOAjxqIIGJMW48c8UqV8W1MlnBiAAlQz+Qk0Ag8d0dsged2qhenxV7p7AS8KD2OKbHXjLoBaMlz3cevAxO+lF5EqslMqkNVSN9G105MDVINk9YdVTxdHDAApqi9E1AmBGGeUDsOQWfHAiYCQjpHQhxVKxB2gcx9SMzxMYIiPOk6kfrPoHnNUm7q4b6oILMCXzUUdLhnlPw4WJ/FPYhOj5B532eH8XcjFxIXIiRJIeDtovE+QIjrJNHurhP6C8FHO7PcXBmhht29nF2foiLOwtc3tlBnPfgQ0CcCpfMqp8vKgXRxbIGIRM0UtuDMvKVFzNrU17Hynyoue5qvvbJ1TPSDohqFQcHQibqb3Yw2gd+j2l5yEOVxq3j3nV14WnLASe/DumcHLXJl29tKuvQBF8KJusxOG7N+zzR1gh9S48l2gKQa5X8oj6VxC269elWfdpkP+oTKb/oUna9C8DsDlon12rHYCt3fXqFRhkuj1pVp+lzXtvQ2NSydMMlrevJaDNxU1SBhxHYqza7Y/OcGj/ZPNEz+tmAeb9GZML+aobVwQw7lwn9vqheafs6KqP+SttM5cobd/YCMCojfZsbhRE7FcxW4YCg7pupeeBUr4q/Dd1TgI9N89yrXPm6tMjGHCPwEdZAWCYAkoyltd1tJszbAoQhSzFq9amR1NGBgzCgsBWppZAs/a5gVA3/63eglizWp8qkc0GlYIObFxZjI5haDIYUvJDWEWEWQOvkwSqugdgn6cXAhMGBkJP0vTGYJmEjDIuAsA6IQ3KxaxIOnbsKikWnn3ywQg8sau9Wlf0HupAAhdqV+Hrp2hKUyeeiHSpNCiuY0bG5nRZAxVLX7pDR7xNW+z0uL2dYx4Cdbo292Qqz+RrL2RyxJwO6zX4Spl2V4OyEvR76+r3wTLIbj2x/Ub1P+rNe561f3Kd7fJJcfRiUpDead+tV1qHw3T1a91GOUU26hrv3sRWDx9pLrh2av9+HeJyWW/1a1WHUuMZ6saUtbenKaAtArlWqTnRGJ8D1Yu03m8aJUpFuAnxwhxSkjODUPFyVxMd6waCSbtBlXuPy8gpdbDYFIzuu60jE7zekatFP6jBU/K4ZjZpS9vJcC7TAbVLFxc2fo03NjUmOJJ7sP2YhYuCA/aM5aL9HfwB0SwaptzFjvpB1/B3gMNUOOeG2GB/RMWNi4KuMajqVJ9Asq82r9KMew9EmPQE+JiUmGzbuIi9XXpM2bPI185YYFmebsJb5O6iBLEyVw5/CFrrncs2r5rR8/6skpOg7HqfRaNEefCjwMJubCQBYMFAGOFCCDlHDKhh3ZlAIxkAD+swArAlRno9rRlylIIUURUWKCDEr9JdjUM9t7f+GFGRYBtC6ywcalWtek86JVli253CFeHUrUw/T90LyDm6ue0DmBSyU7tucVgDKMLCY+kjieYqUEApSBkJ3BITDgIOjOQ6HGfb6JU71SyzmaxzNxcg/5C7zh0O2Psv9xKCnCpg75IoKtdKCm3d5w+Vd3WsdALXecU1bqtW2JSupHJK1My8/k+ukPuOckIycVbiyVXVSbQw1OrqXQAIYqY3We5/Pe7TvtfbMDfVX6cu1LBDY2oBs6bFEWwByDVJTPxxogo8mU12dLvmT0jJjSe9PYOUEUNVOPOAI4LxhthZqqspGXvAL3/PVIj5SA3PXavuVcWNz8Qom/L3i2YppymVWgKjFPPrvVTtHYG/qxMwxqtwxMIvo+wFEjNXQ4WjZIxySnNJvaHNV52QALTYiQGa4FIT4TZ/EDeuKEWYJhHCPFO28GrvWKd+UCl3B0NRpuLxv0o8G+CieaUk/JkgZIH22UE/Sv9a46COtMa7V0IQJLdPlII0GIGRoCmCmnKHYjEyBj6lTYHuHtS1DsidJxvEy9rECH5D6tVzeiiSCIgNrRkAERULkgI6ShIgl9kvs2ObOcaRMvbrnVY9rvIrAcvx8kafU3dQJFTSFqv6egoKlqt0RSR2NCBS8Qbm8D1J2aqdOxDzHOVTl6TVGUuc7JCyPZjhYz4AFsNOvsLdY4uJiQJx1+Xk3f8nn5d+ZIB2nEoUiXavPxuv55LvJ5T32eXoGXD8d8Mh5N4JUGthxdjx+7awYeg86CnfsFYPP+p6KUwZVg2xJEcFJKpmkVMmeTVUqm1IdykvRCEjXa7f+lDYUfYNGmi1taUtXTFsAci0SOcZ7kmnOn4UOrrvPoXTBaWJszVcZaO9FhJNrw+4opRskGvZx9fWLc6M6FfOplfQVlmTVZ52mkH74zbUutD7t2lT3itQnPrs0pc98FAw18THFeKBCCXxwB1AfMesGBGIcDR2GdZc2U/H0Eucyft5zU0f5ZFgYq6S7Duv8QoJTgQ+rc1TbhOR5ycqoGBZrwkQD/Txs9afnSbRtCj7adg+bOrJNxlD4MWfK8121fqT/mN18d+2bZCTqvF07mRKzbXFTQr6uhtoo3sE0BvqMgo8m8GjUw9SFBjVsjwjLAWEdcxBK0+3xz2ZmnqNIRcjdG2RKrxkhJIDa6dyZaR1b3NdEXaXtUVz1xj6A+qSORcMgfSSZidG9xq4BIG5zkcGHqlY5SY7VvVV8jMBynYz+Nehmr+6HyernbaMAZZAFlEu0+IJxhqjjHRFWBx32VzOsY5cio8+XeHCxxmo+SwcMImkp5l/dfw6EsM7Zps5p1dfKTLeSVmvn+F3m5ABgYixH0dNrqsus6+LXOqr6UNta94Xfn0yyh8J7FneE6KQd6iSiP2KEpdbZgZBG1ZsgZGKtKwCUf2ZiT74WaGsDsqXHErW0vR+T9PGPfxxvetOb8H3f93142tOehr7vQUR4zWteM/nMvffeix//8R/Ht3zLt+Dmm2/GbDbD4x//eDz72c/G29/+9snn3vzmN6eTtQ1/73rXuz73RvkF0jGx9XrQugbkjaw4Oa2ZKQMgaaOgARIAjzHMgNUZwuosYdgliYydmdhRuXJyRQPMbSmZ6ksu3+vyhiGnUYY4rIWJ8i5H2bcLxeakG3x5gpc/m9KfFh23zvpN04EPfzpd1LcBgLwEhDpGFxiBMtjhDhh2gNUpYLVHWO+EpBYnHsiiuNGNs4Bo0cx9ZHP5c8zdlOvh3OfinWmq/i2GgwAf6fy4bqsBxogBGTEj4wjlI0mLp2rMfVlanhmez9NnzfhvAvxFNVw6fXeil2D490MZ2uB/o5AwjNpelWXtUpUU9ap1xOiOYor7ogH/VHLmVSfVLbOTknEnYKSSjqiKXreM6JbJDXThdaj+a71flNuqUp5hHsDzAJ4FcNclIN1Ran+1CyUVwpBjhQBNoGFG6mIzQmoDIulpNSAs16DlGrSK5iXMvMm15rUDHzZmwkhnVa1kT4RlUps8HHp0xFh0a8xmA7hnC4pXM9bNNcGDca2Di4nh15zCeBzV5wnWr/yOOA9q+qfSp6n1sr7mgE6t2rTxeZ073r31ui3p0Hk0zIH1TloTl2cIy7OEoxvS92EuzYsT5U61obGejJ6v1pDJPj5J/38eiEUF62r+bQHIlh4t+qKRgLz+9a/H61//+hOn/+hHP4q/9Jf+kv3+iq/4Ctx+++342Mc+hne9611417vehe/+7u/Gz//8zyOENk57/OMfjz//5/98894NN9xwZQ2Yoga42LTIetGznUo1mBqft8V7ICCopxEgu2vtUx5BAUas8qlOzpqSB22HnirKcz7YoW8DOVn3cVKTor3uXqE3L8Wyz4dQPTSucyqfxmmqsk1q1cjGux32J56J92Nb6IkYPGesd5NqlJbNISZ7jejGxvedqKyY6g9UgkMp9kOEfXJIjJ+fJ0n3nZL7UWGKGRjrPBcALIOPEzE/V5t07IASfEQk8OJOTqFzvCvre1KmzbslJmpiuZKq90s9Htl8coytpa+ArV2Xv+DAYrdidIcxgY+jAbQa0om/gc3EiHMkUesRBchI4JAkEQnjOWYdWXmR1sm1bgiM0BOCqudt8Io24lG03zqJNbMgrGOXPPF2MQEGRgYWApJABOoCeJ0CF5J3x9sCIYNHWpQ/VZISBxDLy8bBHDPY2jDoe0vjNlRrg5eSEQO0JqzWXbIDiSsEYsy6AegjOHQmMbG5KXmO3iddP6a7t7hhak8VCDkpFQD6hHuLl6SPggV64O/bEmFqZUmqjHL9qsfT9pH8HQQBhCJJm5UximgNOYhBBdRgfdtS8Z2iYnx1rEZ7k7vG5VK0pS1t6eT0RQNAbr75Zjz3uc/FM57xDDz96U/Hz/3cz+Huu++eTM/MuOWWW/CP/tE/wotf/GLccsstAIAYI97whjfgH/yDf4Bf/MVfxF/+y38ZP/ADP9DM49nPfjbe/OY3X/3G6KLZWCxbaiD2WL0At55x6Uz1yoxTUzr1tR5WQH85nRbrfTMObGwexUbUAhWEfGquz3iPXFbh/OcX/EItzW1WdjIJTG8wml7TFP1TRU+HbJgtVYgWI+GqXTSj2sDsBNyVP0TCEAMGNfwNnOJzLBKDk06sA3qNB2KMtjNCXns0JP3mQAi66p4r39sUFGpYapzd6NdCnaxm4hvAs0WmtuaZ8Clq5e/G058ym+TEzUWv9jEZsb5BNl5dii2RVBGpOKHN6iJUuvvUyk31zYbyLYK0tEldAatEQiUf3dGAsBqS4bna/zivaBRCjrWhc7mXyNFdVzKVAaaGhZDK5E6lJsh2FFPr0ob+iz2wXuj8JnR9FC9srkO8G+EhglYBtBrAWIPWQwk+WoBEnS/U10cVTQtRGS+oepfl/YLafAizHMXeJ85kTSRgvQ7YX82x060QmRBCBPUsUhAajz9vnnq2xlV9bYyxVRr5gAkYr0Ub0UzO2z/fZNQbXVl4IPTAwzPlMvZ2WAW2+6P0m9bsCrQD5ZrVH2Z3wJMe/Fw7dC0rDotcX9i6hgxCrD/8Au+/H9fXn0dibJ7+jzTPLW3p0aAvGgBy5513Fr/vuuuujemf9KQn4SMf+Qj29vaK6yEE/MAP/ADuu+8+/MzP/Aze9KY3TQKQR52qRfOkNg3FYllvEpp1tWAn5jbpliemIa2o3VKuuZOhSSmHr3N1f3JDrPOqGQG9VW2QeqNmjIt+qIusGOaR+pgDcFNta9Wnrf7mPh2zzYGFGU4JmAmrGLAeQvI2IvVIHsnk1G/FiANSdGauJEZRXa7WFZC6qUtlZ0iqABEkRp4i/SCNi+DG5BFJ36uxNKBBjfzqOeJv1WOu+VTgw9t9lOpKOa1J+rzaVQ1mGmUpAz3Mc4VoIAc8xJBf29dhxLyZ0fg6cWbRMZctKYydLMshQLcU8HGUbD66ZURYJtsPDz6MoY+5QamPOMXWAJJXp1lOY1KIQIBIRigCLNGmC3VJjOu7CfArQ6dR09cI6AIjzsmMhy2teGZLDhKiSZ1pkMJ927xdTWqU9LMw/d5OxH2qmmKcBfH6RqM1IKmrKXeaDyY0Zk6cE4YdYFhwsuWKAfurGRbdAkSMWRcR5gPirEfsWdSpyvXA3ocNc1t/j/pb86jt1ODS1e+tf2ca63atzlXTlFpSrXbVfK6+797XwtHGRNn63tr7vIZJUsKakyocRCoSaLRPTdVN8y6k+K0+8+Ckfu6Yft3Slra0mb5oAMiV0s7Ozsb7f/Wv/lX8zM/8DD784Q9/nmqUaUoMPhL/YoKhqzcyXewdU+ClDObS07kZ1RO+4tRpgrlLCRrMVHViVKgeVO0qO8BdrzbHFgipJSaj4us6tcoE2n1X1at+jifKbqUxV7cdiwoWW9RsZgIPlJhbsYsxmwxSRg6g2ODKGdkA2epa2+to1G5KEpOQJkKAxH6IKW9TPdB8kb+fSHLA4+9TakuT+tauIzeqiOi8dnUvTlZPStWYF2WolLAnRGFsLSYIUz7Jl36LvQSv8++NuT1OmTMRaGrllbI19ki3ZPRq63EU0a2i2TOo3Qd5iUAtKVDDbou/EdJc0UZW4IXEhigEgAd100vi/YuKOdBixOq2ZAlUkiINIJAY4JtLVU5tHQIlWyTJP8SYpCAxZClO7Z3KtzOEDD5aIETHM8CisfvnCUmKRXBen/z73SUgOuwAccFAlyKQH616LOcdFt0aO/0a8/kaB/M5eCbewFQFr567x8zT+nDFq85OHTjU3+3QQR7wfHaWYo77tHBeUlRqc50n07n2NuNQ1eVq3Z3EMqy5VJHSw7IZ4Btt7oyPW6tada773F0fScquQYog0BU3/Pg8t7SlR4O+ZAHIcXR4eAgA2N3dnUzzvve9D3/rb/0t/Nmf/RnOnj2Lr/u6r8Pf/tt/G1/5lV/5qNWrBUJqMvWZ+noFBiyNLOaq4hPlpDgqA8uA+vCvI6lbvdSvPbXL1jQjCU1Vt9HJXZ2He9SYH21P67Sw8aNVRq2GNVK/qvtsQx1bFfAghDskF7yzAfN+QCd2IDwEhCWhO0yxBrqjdvC7QsIQMmeSJBvuSI4JJKe+xtgKI8qiMjSEHCujAJYR2ZOMbyMjx1vQYuouaY1lq2/su2MeuHl5xKzZOyCMjEl1NG01t9ilb9VjCryo+paqXwHCBAn4CAL+EjMtjC+oVBmxOpZxanJDyjaqga6BD7X3WCbgERR4ROf5qpZ+6HeJqaG2EgyAPIPOfrDywsFDAi5mFCwxZcxsROLPTB0q+P61tktfAs6GYbSOJEcLpIboGnBwyhg9lgNNQ4rDgdAAGAObl6+IKJ62fLBPiKSDbP0r4kyIE4NhzoizVH+OMBXK+Tx5tNtdLHG4O0e8LA4k1jC1Rj/Oud5uPatpql83HZRgDCq8SmkBPOrxM9xRpi/Aj6Qr1Jg2kQdbm4DTVHv8u+nX08495tYAiq57NvWfz9Ivm3qfiiLt/lReW9rSlq6MtgBkgn7lV34FAPBN3/RNk2n+8A//EH/4h39ov9/xjnfg1a9+NV71qlfhn//zf/6Iyy50VJXJwjHMeYOhr0/ni5Ovlq90cveC++RcQMFwNpjrpiTEp1E//FXZG/VWfbuQA19pROGxWsiE/YanxqahIKQVNHFkP7AJADpGthgDZWRmjLAYsLtYYm+2yt5GjgK6A8LsMlIk9BWyxyMNosfj/FUdo1UPHioAoyfdUicyFS5y0gQYc0U6/o7HNY5EBuK4k9wRtQBHgzGppR36qe+F2khQpGxzNFEXDzC4vo58b4rB4JCAOUAIYETx4MamEiLqbJQqPszyvIldOvXXpjdjfrhx9XYfySV2A3wMnKQXXspRkzLeTgJCaxm22OUYGt4VrXpM0Pgb0kc0oHplePRe1B6ain7XfNj1lahcteZnqx1FO6ckIXW8E7lO66S/E5iB2IHUCxeQcJd+l0MXi1DvgkPqtUIKFAkxpve3pwE7sxUOdma4tLOD1c4M8ZARVgSubN2aEl3flBqn1ulOAj4qUFFcQ3mtsDFpDcEEbjbgpHtM652Fu0d5O/H7SFYxpqKPfMyQYp657E0FNeZ1bdyAvFf4OCEF+GO7NAIhRdsba9Yjkrg8CrR1w7ulxxJtAUiDfv3Xfx3/+T//ZwDAD/3QD43uX3/99fj7f//v42/+zb+Jr/qqr8J1112HD37wg3jta1+Lf//v/z3uvPNOXHfddcfajhwdHeHo6Mh+X7hwobhf66gqCJlcD6oNp2bIxvrOLj/HEFm0WpdOF+PYAejGG+LoVK0AQ5yZkwqkMI/raXXXttQMP7Uv+/LKyk30wUmelfKaVNd5MlNtr+iN9xGz2YC9+QqLbo2D9QzLZY9w0GF2iTC7yOgPs/QjqcfpKXs+lTZXqwTTfSevHx/lvL3F5VDaWJS51Cjfdtotc8IMq/08bDDym/qsZvivRE/bZ2LMkdZBjM6L33UbDUC7Z1sVYzQZi6I9BkQI1HFSIxocUx2TO2NVYbLAjh0wzClhAAEksXN5V+BDgwwGz6QPIsVQV7tTAHs09zP4SKpYQ3ofmYGuS65uJVglIEx2Jyf3wQUmNaP4cuBLaQGbbYVfi4xB5DSPk2pZRFg5l7g6hyNLADqnYjbEZMPi2xalnE6N2Kj8rAzcMcTk1GEtal19SO3sRHSLgBQ3yTPG5STWSOi0BmhFgMRSWc16LIcOkQPmYYUz8yPs7Szx8M48ucvu05gWJ/maLY3no+F7v8BNMNWjSxPg49gDGbj30Y3ZxsOFCkz577ZnuLSFtMy9T7rfTNmyFW3S9vighNUeUthhAaY+XHv1GwEm16apvWXyuU378pa2tKUmbQFIRZ/85CfxXd/1XQCA7//+78c3f/M3j9I8//nPx/Of//zi2td+7dfiLW95C2666Sa87nWvw5133onv/u7vxpkzZybL+smf/Em86lWv2lyhTSuhp8aCXzA1BSCQfUZO+tI1x9B6RsO5XCyCSjkQAVQLvmcSGWDk5yxtY7Ge3Ox0Q/RtRbV5V/dGzKRP6Dc14PjNWfq2UOWp6puZFpTj5QCeGUHPGPP5Got+jUCMw3WP1cEsgY8LwPxSMjrOutLCDAx5nFLfuk2YkNzrDkmXPd3j9sm4MpZy3+IADFkdS/u2Bq32yQ0jWN8Hre96aQoQeOJq6NxcTp+UVS78pzKzVDFyvg1VpTcBj6ZqloAKjfZNrNHrU+GBEiNO7hSdzIIbhfSjUGnUd9X+OI9jzQzSxMJQqFWJ9API6lhAYsbVE5Qy8EpiyGvG0+qsgBUMQeJpSBF9UpninjDMSWKicG5jtQ6FQcDHURQ7GpY+oTwP15wM7FdDBh7MgAQwzOpVAgI0WCHnuZyAJ0sf5zKS6loHDF32VtUHcMhxMJLXL0jQdDKsw0ugOwB6kZbEFSX3wgAuznZwcXGEvX6JnS5FRb+wGBDnvRi/y1yM4/nOyPOU3DgX0hJ/rV4PNZ+Wu/AJqtMW4EOZe67q4NNqxWUY6jQF6Xrv302RKEEli26xae4Dto+N7RXrdyN2AM8ghzINNdZqnRiBpbqdrfZPrRVfYIpMoKuMhOIWWW3pUaIpp3VfkvTggw/i2c9+Nh544AE861nPwmtf+9orzuNVr3oVFosFzp8/j9/8zd/cmPZHf/RHcf78efu7//77AWxeyIin748Mw4G82FabSREMDRCdcwkG5WwBdEPPhSCrJqg/dh9QzQGTEeOn3nTU3mQov4+CD1YMeIt5VEZz4wbp0tbgY0SMqs8c89fqe3+9xaj6U74O4J4RZgPm/Ro9RayGDpeP5sDlHrOLhPklRn/A6A6T+k1Yyd9aVWmUUXVB5ZRhFEas7osy2JjecJu9Y3hNDcsxjX7zLpgjlaC4vyb509i6fyeu670afCT1pGQITqKiRutq7vv6VEOd1YDKee7HzacZSUZcWnuHHKDIsTqSCpUx6h6AeoasYX+jTFZR9ohrzSBjBDKr4IKj56o/MjsRNjW/DIg4BYpbJWDQHQ3oDgd0B2v0+yv0l1aYXVqj3x/Q7ydblW7JLqhcldfAJuExD14RAjpSXJNwuErBA1Vyo0EJO1Ebi7FsU91WzhKjIk6I0pDsZ7xalx24qCTLBUUN63QgMDtgzC4x5heAxcOE+cOE+UMB/UM9Di8s8ND+Li6tFwCAeTeg6zUoIWebIOd9sHDJ7f+A0bpt83liHSz7w+Vj4ICKvyKtK8+7f9a1wILLunXaB6e0ddrPY83Wrc/FOtiRgXi46/6gZmRHpeDQzS1fDz9OnXrHmiWHB7XtXtGndf2cbeSoayffx2PG5PNEjdf7qvxtaUuPBm0lIEKXLl3Cc57zHHzgAx/A13/91+NXf/VXsVgsrjifs2fP4ilPeQr+4A/+AB/5yEc2pl0sFs0ymiLeikZB4uC+66YjX0fMoYKIPn0PS0a3Sg+sd5PrV9tYUD432iSVkaqZdLeh6TVfP2MsUdatKR05yQLo6uT7b3QC7h9peHoZqZYB6aSfyQ7p6raM6udBmG6kHcvJHKOfDdiZrUHE2F/NcbC/QHc5JNuPw6Tzb4xrg0FhGXtrViCwRIGmwMBQ1UelWwGAMSGJKTGQOYh6iXfHq487Lz7FNGIUnZukJiIVqcGnnzNw4z81tq15FZG9hAl49fFmCgZvIttNY+3TjACYqcKhUEPyDFYQEBdWOrdU/6v0jAWgBHlclav5qkF2HxCieKBd6UBwYqK9ZMMaRvbJ4mRg3EZ5Rt3zJsuWNO4xQGNyaBRFc5O7SnYotBpSGwCgI9C6Q1gGDIuAOA+IcxLGL7uh9ZKd4lBDJA9hJfmunWevvkvzNBCIBqtv4VrYVA5jaSOSoinCIqvX/aPjoM6zhqTCyN4mihgBBAyc7H3EO9lwKMztnBBWhNj3uLi7iws7R8ACab0gZLW0SgrgpQcM6WYneTwpNde3xnrUfrhxzb+Tmxhw/x5Vv+t9yH+3dcflx2q7Ue8H+j54yUej30yFGMl5x/xSBA1pf4szKsCM5mfD0Npv6i6ZwvJuXdx4ALOlLW2pSVsAgmSL8bznPQ/vfe978Rf/4l/Eu971ro2qU8fRbJYi963X60f0fFPE68BGS//05JljpAKSpB6M9YKwOkOIvXhgWmHEvKg6AFUbqZeY+DYUm0ld37qdupFUwGrTwj7aHBqAQFWn8v7vd8sq/7o+/rpnIHzZ/tOdpvmTvdgn8IF5xGKxxrxLKOFgNcP6sMfOPiWpxyqfQidmJNVWde2BxARZv2hchKq9G4mQdnypr6rXJGN3Ag/A4OeI8rj+T/OpGBHWDOv+8sADOZ8R4KuBSgEEKNtIrJLEznTrgRw7ReyUChWLopBjukeZHn03vAOASmUKQHFyal6jGDDUJy9LcQo7ATy8dCX2AC3IbA06IMWBGYbx4cBxx5SBLNJ4U0LCDMTsVliZccT04pIGClRGfeBsjzIA3TqC+wBad+BVwLDuMMwD4gw5anVrXXP9YR67aglHSC8U927+qATD24f459S+BcgSFA/WtA+mdACqd78IDDmk2C+xJ8RlGtthh3C03+Pi0RyzbkiqMMQZeLhDiREgVGaaMlNcM/XN+k2Bj+P2g9b9ag2bysfW/7pMnxUjz/UGg2/uwId0z8CH9HNrTS5+uwMGfe+GOYH75LxjdhkpYOdKQWT1fkpZ7NvYAkAbqLAj0T64BgDI1gh9S48l+pIHIOv1Gi960Yvwm7/5m3jyk5+M3/iN38DNN9/8iPMbhgF/8id/AiAFO3zE5Jk8t3npLSq+NBgtZdo43wdK8BHWOV1hPM6OiVamS6tTLbSTKkr+9xRTX7WTkXlXz/wW6SoyEfpU/toXqHhhD6ROsnG4fItTs5qP8wyHVzkISOpX86R+NQ8DBg44WM5A+x26A1WBa1SmYGKEzfdMjDKGlR3PRvKOBgBA1U5WjNhRclUacnRvGxf/vSbpYANPBqKqNA2GW9s5AoOSVj1dQVT4wgqiogYLlKluUjFP9VYQWHTlScZa1QTFFS6tBYjoXKHxHDAPSVB1HpIDeBY7qxyUrqiHMT086guVIISO0QUyoNkp88+UGGtVw1Km3PpPjLm9mpZ6t2oAkcQYorALgjKJapMSORuHrxUEAKAIWlEy8F51oDWDhg4DBwzzkIVB0LUll61t50DJRTBRaThvFaQsyaj1QxptR2Rz1VpLikwdqQul0byWg8xEq+MHPWCJSHY+euodD4HukEBHHQ6XMxzNVxhk/BE42yM1xn20XjUAwOTBk3/G06b1dlPZ0H2Ai/Eq0vr6u/1lJMWuy/NtYJSHQJKmGV/Kle09Ylk5hFHEeXVmkMCyK9ftaaP21+04Zp3wkidb47Z8+pa2dEX0JQ1AmBkvfelL8au/+qt44hOfiHe/+9144hOf+Dnl+e/+3b/Dww8/jK7r8KxnPesRVsx9dwtu6559HTE0yKcynsl3Oq4knnYgzBpFoL8MxLncdyoTNbO+SX3l2Lbphuw2pvr+pFRiIs8REGmlydmP9zjHHKULboOrTotrkFRsuMVzECkIi14zowvpDwCO1j2ODmfo9gP6A1WvQRG3o2B0OTNDSS2Ix+NQKe0yITF1oUxoXsk6ZQJT+Z3qq4ekzkWBCuBh6gu+ja7tI5WQqn61rYZ/tjh1bYCP0jZJDJpXGbRxAIYhGTPHWZLkmcvbmqaYNi4BTneUTlNN9QooPD/Z/NDTbuj8yMaySZIoXqKoKlvfp+qwwJitDoh2OBBE+hAQogIPjanhxt0bXysjPqWmVVOMoBjAamOkzBUj2WmsBtDgDMTrbhVPUxrg0LLtHZNIolqm1UWaawEAD+lZqgGVABPuQsqm41Idy9uGaOwQvRdj+VtBjHjsMvspG5M0iQsjZ2/I7knn4hqgJWG16hL4ABBCTMEK1UbOPXMctQ6dR5KRkzC89Rpbr6v1fJR8i1dxtAbJ/QAzqufq+ebnBJPv3+mpAyuVvFi8KTXqJ6QDgxVAh+l9Taqu6UBA14aWSmv9Lm4EH9W6pOkLMHQN0FYCsqXHEn1JA5B/+A//If7Df/gPuPnmm/Hud78bX/EVX3HsMxcuXMArXvEK/OAP/iCe8Yxn2PVhGPDzP//z+If/8B8CAL7ne74HX/7lX/7IKjb1vjMwOmmqT6bQAAf1CZIySs7OQw3/iJN6Qdbbdgwvj/Mu1JAqsOR5omJHc7xAUfeJ9vg2HbcW1vYZVqwytFVVfN75QgU+Wpt0s/DxJdNPDsLMESMQY80Bh+sew7LD/BDoDjkxusroNDbvwguW81TjJVeWVr2WdQl8eIN1z3xmlafkBatbcuGggLo09gpQU+h02Fgb8Jtg6AuGSb+35nGNDNnd1PQtBkEZF6ljsidI0d5phuSlqUdpXLrh/VLJR1gJ+FhyA4CI/RTD1OLqeml/B4ZEcFZd9MyIF7ZK5nUupdGI6lmVj5LNwTogrAOw0gHxhRLKWBgOkBQAhPI1laTI8yR6KoFIzICC1U89UyU7jdrQSItkYJXABDrnEEGlINJ/6EOytVApyDqCehJwMKCQ3hDlOB0hpG4yyYdrr7fzcPUxr1jaRxZhWwyy3fsQhmQU4qFV6uaq/6h0PqCG2VGDEnYD+i4mT1vmFUzW1eYilP8m7UDcOukDBZ6IjGnm6rKOfeOReg2yst17PQVWZH0oVGl9G7jaUwyA1BtMfjYx18jqoFa/DDI4AMOC7NmwmtgzPAjxdZsAH4VE15VfS0K2tKUtnZy+aADIPffcg+c973n2+9KlSwCSq9vXve51dv3ee+/Frbfeiv/xP/4H/u2//bcAUrTz7/u+75vM+3d/93fte4wRd911F+666y5cf/31+Iqv+Ar0fY///b//Nx5++GEAwLOf/Wy8/vWvvzoNq05cambdL6AjV4MbqHD3yUA0ryyUy4pluvrkrXWaVKuKbWpXobZVb8i+rjX48Olq5tYxdWUmG6pSPdOUfGyo30aSPuEAoGOELoIoRT5fDwG8lOjn4vGKVAXLMTh5TBz40PgJWje5n/uKsktVSCA8t7mnWBBJ599sSDipG3UrIPaMIMy7Mgde/5vhrsFhB3IdWo8NdKzLjlR1jILFk3Q2N9xcLcbXzbkUryLp6Mc1ENeEOEtAJPaUveu0wJIyQMMYfJj7WQEJHHKLmbO72hwQjd1vLuqpQf+mDg9ASY2MAiSmi46n5CEgJnWxGKJ7V7WOqTcD9KngfEMs0tp1SRrQJ+cGQJK8rCYkH166oH/rAXRI6FjVuboUE0OAhAfCNp4tY/m6nJA6kruQ+jegaQflVbfMCF2flwjrSZJFZf3FDiZoc3RtkDKSsCkvBtmRA0BrwrBOACT0a/TdAOpj8oSlY2ZtsSwK5haELFmo1zFl9htr3nSfuc9qvZhcR2uq7rWkFP6dKoIHetVejUvUYvR1jaxfTutv95x/XttPudwoth4Gcvy7po9Ve471fb3Hah2quhb1a1T7C0VbN7xbeizRFw0AWa1WOHfu3Oj6/v4+9vf37fcgvuR9AMD777/fXOAeR6dOncK/+lf/Cu95z3vwx3/8x/joRz+Kg4MD3HTTTfjrf/2v4yUveQle+MIXJrWXz4XchqGbU9OgtqYasOhlD1aUkYvjNKWondv3Qv49khTAXa/b4+pILJusupZttd81qZlPi1qb5QmoCW4aeU5uNtVGVrh01M+O0XURsxARiDHEAEQqol6n03LIyTqVGzjaDHir3aZaoifHwlwZRSAgJgZaJRrCi9GazD1yGDjloZIPLbP6Y2WcahBYMEs0vi4dWs9tr0Lo52ktiTNwJ21SKUUXJa4EKxOfdPdrkFyDjyT9QHZ9rK5Hi/cquZkFxGMSlAEF1JWxRZj3p+d6ku/elyQhy0y5jZcn31bScZVGa3DC2v4BuS8QqKxHkXcGGCACIwIS3R3MIGdzkVSrvEEY5c+qTMYggFgM2tcRtOhBswALVoi8ppmq5zoboSdQpJNSyqptQlqqZezarXYjfQfuEwjhEMCzgDjvwDMJQFi4oE7jluY0FZ82Hg6EEEPeYWB91GG57nBqDsz75Ip31VeesNz7XNgRqHG14MIR2LA25ucf0aHIFOmaX68xzXTtepXrX3a8kM4jKDs10Pah2psqcGXPaTpdTx3gKO0XS7BSLJWMcd39+tEAKr4uBWDUa1rPice+VOnjH/843v3ud+P3f//38fu///u47777MAwDXv3qV+POO+9sPvPKV77y2LhoH/zgB/E1X/M1xbUPf/jDuPvuu/Fbv/VbeP/7349z587hzJkzeNrTnoaXvOQl+O7v/m6ElnRU6FOf+hRe9apX4Z3vfCc+85nP4Mu+7Mvw7Gc/Gz/+4z/+yLVYtnQi+qIBIM961rOMGXg00ivNZrNmdPSrSSM9cU8T1/0JTlNNyj2nC7HZKMhnLc3QVd0zh3mDoWJBruu36dBE94oCo/kNtQYwNG5Tkd8VDGOzb/2GDt30AAKjtv84EZHvU9H7DwwKCYB0AkAYSG5l16L6o7Y2ZXUKxsDaIIaWysjRoIEixW4jZGY3jbW46FWKSLr2A4O6HEMkuQNVt7xAFM9T5vpXGTPtx+AYCbfBZ29YmUkbncDqdx1fKtN41YyWyob1tRh5FyAFyX0qh9Q+BTG1uYTWjRgWebyT+CLBqV1pWb7eYc0CorXPYPFavLTKS0FMQqFuedWFsp7gu/nfAvEaQwGBwF0H6hz4YOfe1ksjvAG6ftaesCRt8m6VIqXTWucE5Ty8VKdS7fJtLfKJEUEimodZlyKQSxA6I5WwqB0HUfJk5evnvFwV4wI497vyW2PidMkDVop83iW1sECI807+gkiwRAIpk6h+7wuJjbNVIFH5CysWQ/SA5arHOgYESjZVK7OrcswrkN/1ev10a9SIgZ6g5jrVWrpOsFZ6Rr21jo8kIL4sm7s0age5tpkNh9Vfrjfqagdwwe07U23TP1eO3ZNDBiCvYz697aGubFtvbB3N9SzSXSM00ra8SnleKb3+9a9/xFogt956K2677bbmvb29veL3MAz4C3/hL9jvJz3pSfjar/1afPKTn8R//+//Hf/9v/933HXXXXjHO96BnZ2dUX4f+MAH8Ff+yl/Bgw8+iOuuuw5PfepT8dGPfhQ/+7M/i7vvvhu/+7u/OwI8W7p69EUDQL6oSBdobwRZJSnUYahxD27h9Pnq4q0bTHRp6sVbddY1L+SNQPMrTpTc82PjaFcNYyyzJ5lR2pPw/TUjq3WaSvcIsIRRDawaQImra94DFgJAXUQnNiCRCcMQQCsJqqdGu4RCLSQzlL4M2QGd2gkbP6diCAdavGpLZaMDQKKny6MxZRYGzjE3YmKy9Hmdc2YD0kGFDJm5dxOzkGbUzIvf2Ku55NX+vNSuCFbpxkbLysH/dDI2GKl67sQ0BjoWYcjMvBmaYmyYTGstM6nPhSEW/Z0YTrLv3vXriGlUdSgPDlw9dX7FjhBnIUkTBjHKFklIMuFwKlkeOADJa5YadMvJ/8ijFDn7gkpFqwlwGm0o1JrWg4FaXg1J/anLdVCAY/X29QQS8FhPBBX0bSPKoJyqP1c/7hMgSY4KhOMcJJs1RnYIxogzgyBqWApoZYxIHSIcJUP0dQzoQ0TXHW+IXqzh9bvh0k9JwE90SMLjdtV18QFfR9KCVv1G9XBVVxXP6OrdAC5NSUajbh5QFP0gdbR3V4OSQvJ1QQ2NnPmSHcYBxR5XVMPvi/bgybepzyelV/Lq1uqRAJCbb74Zz33uc/GMZzwDT3/60/FzP/dzuPvuu0/07Mtf/nK88pWvPGHdGNdffz1+4Ad+AC972cvw5Cc/2e79yq/8Cl760pfi13/913HnnXfiX//rf108OwwDXvjCF+LBBx/EHXfcgbe85S3Y29vD5cuX8ZKXvARve9vb8J3f+Z249957N0pQtvTIaQtArmGqF9qWZABobEqeWW4x+NBFO58Ese33qSCvPqRXS+kICiZxFFG62rD8CX69eUyeiKO6PmoE8sbsk1YM6UikUO8cxy2wHlh4gOHBCByj4p8RA3QOLLxQAh/LocPyaIZwROZK1qvaeYYk9RHD2w4U7iQ5MbncIY+BbMrwdiFeT15wSt3PmZkmcctLpd2EG1/i5HGGIsSBAQopiO/fUfyMep74uczl94J5kbwSQECWPjg7JTPAR3vcakCv0o8iwKGrn2eMEuhKwENBiEk9RJ3Q9zGiU91xOvE+z3QQwGKzU12v3gUWj2axJ9C8S/eCGoaj9PhkdWhPcGP4PWAxI+2SaU+qbA58tGJviG2FggdvV4IYgRWDYjpZIVFHI1GJSu1l6eNgY0i+TK/KFsjUxizeh9yzz8LeJU0cY84I5s1MEYC+q6qqSAzz5mUgwWz/Kc8/Qo7QvSIMq4DVEJKkM4gh+iwFIqVA5jmqGItqHbRx17Wr8amG6NZvBdBymSv4cO9lzaPafZXu1Fivfl8b5Zjk2OqZXjR7xSv1SZ+HSjbG9XLtRvm8rQ8CPoJ4xAsCMHQPi53YsinQ6XKexWFd1f923feB20tG6stbMqrVrO66665HpZyu6/Cxj30MN9xww+jei170Inz84x/Hj/zIj+Dnf/7n8a/+1b8qgMTb3vY2fOADH8BNN92EX/iFXzDpyqlTp/DmN78Zv/3bv433v//9eMc73oEXvOAFj0r9v9RpC+uuRaoZr5qB8iDAp69BwARRTIt1d8QWDMo2YowZOi1zxMjBlasnyANbPAnVo09BoWDB48JKNmuJZF0Dl1pdpzCYr40zXZ3Y1XFKEkK+X+u+qvJgOa02MHZc/sj5FfnIs6oCNcSAw1WP9VGXjJ2PsupLqkfJhObAdr69jTRDe+CtLsIAs2PSfDyGoo+ibOprjYPB9t3iYjhmvQUc6j8dv7DOOvNB1J26lZwgr/J9Gso/DxLUVqNzsUBgDKz0DWWGfnS66uYXbP6OmSQWZwCxJwxzslNz7tHOT3XUO40zQflaqy41YKver5E6pdQlig1DsmNIf+g7kS4EcN+BZ30OyOclCgoIYkzerNbr9DfIdzVsb0k7NPDfMADDAI4RvE6fGIbCHkVBWSFlcd9pnWKJ0CCqV4XNmeuEKnK6ARsDSwHoOvB8Bp714L5DAYDUTmbg9Nd6Tajxncs2qOvr8jqgUbp1TvMqYDV0iEzoQ8yG6CoF2bR+XAlR1U812dya2BDkngcnCj6Iy79m2WqLUTHyKoUsQL2+zyrB9HvLVPP82iHqohYwVRx2KOCwAIOUPNRFOVoNK2B2wJgdMMIS5sEPbk23vsJEe92afyXqvl8IUje8V/vvWiUiaoIPpb/6V/8qAOChhx7CZz/72eLe2972NgAJqNSBp8+cOYMXvvCFAIC3vvWtV7PKW3K0lYBco9S047AfPqFLX5/WuHw840xrYXoZWO7Aop97ps+fhhVMd3WiRQI81Ii3UC3gnK7ebKgGNBsAQ1OyUgOhenNofa9ATkualPOmsbF9na5VVgES2SRHCEn1qgtJArIaOuCoQ3foPGDVdWoRa/3Zfqv6j9keAM5gXDJ0Hs6M6uMHBghsalgUU2T0sJY+KAyqZaOfUzKe1c28OiUEUIJHDy783NS0es31fcEcODuNToz2/RxlNeSlKg5IxSR56WApRak8iVECE8MsMb6q85+8GqUxBWIKs2J1L91Ye1enNfjwp9elOgrGRBJLpEsAKNnnBCAyQozJgxM0DLwUESOwWoPWg5OGeEAxFLZwRFTG07BOozz2Q9JXYq/iJa5uk1cuwkgCwWKPoYb5YPFoxSAEA8gjCZKdZieJByuQKox4KIEOZ5jPJo4DUM37guEW6d0IPAPFO5aGj+29oIHMRXUxt1cErALW6w5YIMX96aIZoiuzfmLTMrd2jVSE/Dydem7iN5VNs75oSShGa5/OU62LX1/99/oeyjZYWTIfmKhchr3Uhsd51evuYG63UweFFaPfB2YHEZ34nNF3s46tdVJpRlMy4uqwpc+dfuu3fgv33Xcfzp07hxtvvBHPeMYz8JKXvARPeMITrjivw8ND+767u1vc+73f+z0AwDd90zc1n/2mb/om/MzP/Aze+973XnG5WzoZbQHItUzVYu6pVvdhIPuXd2m8BCUqX6KbDSWf6etdgHuAV0B3pIweGzNAwjiN9jllfuvNq1EHX5eRdADt9pUXynyL61IXr2vc3BR91RuAopB8nIA2gsQiP5gRuhq5DkNIak5Libat0gv1HNNqr6pTceXG1erDWWXEmHIqTt+N6R2pWCQVMe49GpCPmGLD6Hcdx2GeOnzkuYmrqumYyEloWKqxNsq57ZkssZ+JXQaCCna9nUbQE21Tp8nqg8OGYIQtxijP4wyykgpHAiFRPJOleAPsvPwkYxiK4sEs5L4Oq5jrqAAPuS9H6mIaFK8CIQRl2ghRGeFBJSwkkg9AdYLMdfMwwCKYD8rNC3MuQIM8WHDzwdJPvA9ElIy6FYhEBiMmz1m1vUYQ5jJylrppEgl4aV7aXP2T84R0j539SiGVqWw8CjWsLqmF5Zg4Ot76POV3whheLiSFCXjk+aLAMutiQiQgSWWRlgHrdQAzJTWsTkUKaDOpjfX9xDS1LvrsiUZt8I8X16f2HL/XuPXbkvo6bNi3DJhr93EGcL5iI9UoLn+P9pOQ3FcPC0JcpHe2O0qgtZfP+lCkaNcJ6ZqXgODY6fCI8vx80u/8zu8Uv++++2688pWvxBve8Aa89KUvvaK8fuVXfgUA8NSnPhVnz56168vlEp/85CcBoLAb8aTXP/GJT2C1WmE2m11R2Vs6nrYA5Font/B6JoqBvAEo4+02o6nIytDn5Hu3ZHRLSgeNfpNViYaVw9NSAM7X6z1HNxm/ijVVmuq8NEvfrjpdC7TUIMjn5wFB3XfyfMpWmEIuiz6xJLpuEzEQgBAYXYhgCABZUlJJW7tAgcZ8ktQj55WZZobG+FCmFYHBUUCiPx1m11FTgEa+mx/+4EALdC6lzjFVJ0G73BGi2hJVnm20TM/cqwQjRQfPjIiNXcwSjdgTaMaIfeYpw+AYllF75IMScLG4H85j25WSB5HelWpUtM/ZMD31QZJOMImBNwVgOQYhHghSYIt27k/JjfS3DSWBuxTtnQYCzUQKwpzsKdRGgmWsugAeSBwJ6GRPoCWX4QpUcOLtL+p07nmKaSBNkqLAZdSR6bnM/CWwkACM5OfVq3TeASKN4Qw+WvW1eskgqX1Jn43ePbipSdcaBuU+17qzq0uUhG4tUZDeLYGwJMShwxAD+m7Ihuh+DQY2c3Z+LWX3u17P/NDUtiBW/w3leMbe5+/Wxxp81G0YSd99/fyewfZIWX4FLqRrx9IGt454oIhGv5qa5xq2tnlpqJWrnezH+yT91qJrHJx8rnThwoXi92KxwGKxuGr533LLLfixH/sxvOAFL8CTn/xk7O7u4t5778VrXvMavPOd78TLX/5y3HTTTfj2b//2E+X3x3/8x3jDG94AAPhn/+yfFffOnz+PKGvGlAqXXo8x4sKFC7jpppseadO2NEFbAPIYI672FmB8KkObNgVj7hIz2C2B2SVGWLiAagMX+vCWr9+UvIqMY5A8Azqlyz6pelWBiuKUTO+j+s3l8xvBR90VjWsjEAKUm9ME1X1RqK0FmAtejf8xrDuEFeV4E5yfK/zaK8Cw9nJRnrreBQKY5UR7ANgzmnCbtZJTb2m5OaltTDIo1bqyuRAmBwo4jMcKyPd9MEEDNgZ0VJ87XQsDY1A3wMIrm11KzPXUQIZJ60ZifwBlLJZjqEhLSb1K+6+ep3XfG3OjLl57lIw2BxDHLOXSvnFt4E5sSyobgVoKol/UgJp7Aq/T8wlkwDxLceRy2qtEoGCk647gMTipqQAhJFFMGTQMLu+Y86jUsbLL3HS9UM9CY76GAIsM6PLgPn0vPHO5Z5gogQ+N/0FSpkmZyCLZs465vbNZjU770YBJpyp42mcw9UB1qa0CoOSKVwCIi4huXdliyv1wEJpLZA1GRnYex6xXU2RtrpnxVn5uvW2qyk6t8Vbn/EydT9HuGqAwbMwJAl5JwAZEChUZnUiXVR1zmOXxLg7oqnb6PbbuZ39YUqe/FujRsNnQ/G699dbi+r/4F//ixN6qTkKveMUrRtee+cxn4td+7ddwxx134O1vfzt+8Ad/EM997nNxXJy1hx9+GHfccQeWyyWe85zn4MUvfnFx36tmzefzZh4eXB0cHFxJU7Z0QtoCkGud6tMmZEa1PhlqnkYRipM3i3zeZd39ZJTO5pZz5NnK56W8sQMLXlefi7Tj3XPECOsqDxgjackd+LDiKsBh2ZwEdDT6sixw/EytbuDzqTfp+pQ89b14wBL1q2T/ETCsA2Z2QgfHHME2SXBmrvUE1O92ZqMAYYSVzxPvS0Z6OAwubUF6SgNpki4qmIYidoFXTVI+zYzKGXFN5ue/Zqb8nCwYfS7b4wEPDWxpjKkGxMkBst1RxXiNJDAt8lyc9m0QqUIvti/6LvlnRu1i1y4BPQpECEl1SPopRkp5KuNkJ/taNmXG1pleFMAHGDFDRTRvdWerTLM3/gbGQEDtJGpXvV51yXmYSqpcMT/jYscgIgEFbz/i8ilc6tadWTMTKqUIAFPIv32/x2gSEvZtVOARUDyn75equKmErOhf53Lc1le1CZI5Y+OkjKwADzu8EQNrlvevI0ZHDBJXvKN4IJ65nuCpirUe+Vn/iHrEKvtx3NXHkr6/jfWuSNbYe1p7RS31Makqs01BjTPUBD5T5ep+4w9KYjI6B7JTAKZkGxL7csxGtKH/c93L9tXXrnX1rM+V7r///kKN6WpKPzYREeGnfuqn8Pa3vx0f/ehH8f73vx9Pe9rTJtMfHR3h+c9/Pj784Q/jKU95Cn7pl35plMbHBFkul5P5KNX2I1u6OrQFII8FmmCc641pzPmJ/nooN0g9mY2iohJdvI9k68EZuDQYes9kl6fBZVqvZpU3qQaHWlGhQsAAxMtMDUKKDUuvTwGQaqMoVVrcc8poOFuCjb7iyNWhUivzm6kCEGbCeujAq5AMVt1pMFduWGsuwxgrAXKF334HHC3qda2mAiRg0rk2QgIUsjCzffpTb0/qTSbVITE5I0Arth0Ignsq7zJeFRAhMQNgTt1a2w6xzlEu5qtFVBbvXNZelPOscDW8aZ5NvCukalsxj81I7QW5vuTaZ0DGvTuxI1APCern0LSvioCQaCpj2l8lR1QYRXv1Ob0/ZMBB8tuil4uUJad1QKJmXAMlr1KzPkUQJxl38ZpFa3Vf1yCVeog7XhbPXKo6RWtttMxPBTkF6KEiaCD3oQAH3lYj2arF3PYNZFHk+5Rn7Mnapnmb4GtgN8acn5d3G9B1lG0tTICYBABSfrVDBMlBRCuQXrEeNaildjUFQjZJLCal4j7vk9BxjHYFPkZrmtY1AkVk9OD6ot7zZKnT9Q/sVVBbQEfWokqcoV4fbX3msl9UgjslHS+6wdfzWgEfx43xI80TwNmzZwsA8vmkr/7qr8aNN96IBx98EB/5yEcmAch6vcZ3fud34rd/+7dx++2349d//debKlbXXXcdQgiIMeKhhx5q5qXXQwhfsHZ/sdMWgFyrdCyTnj+npB+FGpDkaapVkjSpj5SGz1FACNU8RsVUTxpru3K9txRljut6jk+xS/Un23BrsDVVvOPTTpRmou41yCpOKydotHFR+TUyYYgBWAWQuo9FZlyLfg0OVPi8DJghgw8JnKefKVMu6pM2cVWhoswogAwAxZ4wLJLL2WHuTg0HiMcnKhjuxASmmCEcnKMCz1DVTHqX+gFg53nNuf0dsntogEXcnhhWc3s6VPPE9U+hO67Mi2cUKubGxlelIF1qj/YhmNrMh91vzFmSoqp5ZEU79Ss1oDfwUoN5rTdg4ExV1RLIkCB+Mbm1zWATpS2H5cXlnycFBeLGl2cdNEBlilSuCJGmGX6voqXAgih5p+pCXo5UOqJxQ8RQnGcd4qyTgIEqrSAr06RfkRFWETQI9682Nd443SRMAmxmAcNcwIdzFmDPxAp4tJrIDnwo06+HFBEJbA7poCHy2rpCDzNMgu3mSe67arxbDOUUCDkhgGjN5eKdmZh7dRHNtc6vlxPgo87TP99Uz5VhoHq6Kvgg5IMHN55U2YuZjY/PW+ui4AQoDjSsf/04aB/5PKjRH18IehRUsK6NhsGMwNfrdfM+M+NlL3sZ3vGOd+CWW27Bu9/9bjzxiU9spp3P57jtttvwiU98Ah/72Mfwjd/4jaM0H/vYxwAAt99++9YA/VGiLQC5lskzbdWC1xSB1/c88PDXUaVVXsuXQTRe7CfKz5slyyW3clf1oiptq95p4WeYiL1Fm4AF5ySbQIimL0CVqiiNNlLjh8dlKXPh6lYwvO4rM2G9Fg9Y3je+S2RB2JwqHFPJ5NaebfJ4VLu067+pfUTVSuKcMMwDhrl4kJrldiVXvKlHC/fMLCBqBbDs8MxVf1R1TOpJEEmDuOVVL0Lyp200SZSoNQXJHx0nd6+oyuHkJle9FBnTwiPebkw6/qaa6PJXICPpPAPiJVF1fqO+1hN3BeYhM9gqCZny2KWqaSnehMRFWEX707gauTAeq1cBWZVKpSAKFMwuIqSYIn1InqOIAMT0fVADd8rPMaf7PAFKYm6v5V9JPAAI8JH4JosOwzwBEOsTQhpTBayrmOoRU0DDbB+VPG4lD2EpT+5Cip0ySzFULI6LMp5qm+TV+qr1rxxIeW9JPWa5OayueIeAQV46IgYTl+vRMXxdk+mt6qOX2T9zhTSSJE+RW+9cFcr6uPVyU+ydUeBDl09WUxtXqjC092DFtSVLUTE6wGm55M6A0qXR75gAIXDrwZYedXrggQfwmc98BgDwpCc9qZnmB37gB/BLv/RLuOmmm/Abv/Eb+Mqv/MqNeX7DN3wDPvGJT+Cee+7Bd33Xd43u33PPPZZuS48OncA8c0ufb2qpfCj506oW+CgTj5/LKlc5bxJ1DqoWau5yUKdmTAVbvJM71BwwLp9iB/dnG72PYs3lRjEKYDVwc5PyfdXSQZ40jqy7SDcxv+l5HfwpcvkWfaf1U3WbioZIiEMArTQCetbVJ9mY1VNUVqvKUba9G1w1Xi4MYj3ZCTRlRrKrvACJDcGwCFjvBKx3COsdwrADxJmoq0gk4fRHhZpQBg6QwII8MkxvjZExKFoNmzd6n9z8I3GpS64O2csVIP1mTEcVSLMqv55Pdurr3xEtq9LbL/9y/T2IrO/ZnHDqN6U6EJXvZAVwUv6pb7oVozuM6A4H9IcDuqOIsBqAdZQgew68OemC5VGrXCkQUFUp+WO1pWjYZyiI4L4TyYKTZKi6lY+C7oEQUKQtgmJ2hDhLwRWHRYc4F2mFjb38zeVvFhC74DzCkbna9aAj1TX3NXd5fIqYIIOLowMFg1IvL4XR57SfHTOr7wGtCMOQXPEmXCcgrKEuVMwRR+WBUJXO/Y1O9CeoBAfl3/EPV+9xI+8p6YVJab2kVtd5sZkp1gUB4moPV/6RBff0DiZS36d4Shac1Mcbsvc672Vw4+bbNgJEfgyqttX75heaauHm1fr7QtNrX/taMDOuu+46PP3pTx/d/+f//J/jDW94A86cOYN3vetdeMpTnnJsnt/xHd8BILnqvXjxYnHv4sWLFoDwb/yNv3EVWrClFm0ByLVMGxa0E20auiHYwl0+b4u9GabmxbQwIKw3TGXiLDItLMCcfV/lDYHWLmqtRq6NGWQUIET+iijYjpHd2NzWBrKh/+oNs6ku4E/I6nyr302dZNdvLOpXMWYJiI/oOwIZDAdMfPsyCLG6+ujfnWO6zLCZ7DQ51TEzVlHUrdYLwrBI8T080FAJROyTr/0oajGgPHYaHDCrUSEzFg2wRq4d2Vi6bJvVsS/BiAGDThlrnSc8mitFOQ1Gw8+VBD7EY84cpoYW63ginvkLWUpTMyueObX5gQw+9ETe+ttJP2rbJgN6S0Z3lABIOBoQVkOSfChDrF6f5C9975JNRxfM+xOCXJ/1Fj1cAUUCB5jeHRSYaD5qx9FJNHZXHiqwCwEMxfXo8g0OaMyyHZYBQInHkoFIkL+ktpUATJ8jxIvqVVQQ4eKsoHifPKDItlj2DjkHAaN12TOkKtFbp4OGyEmdNXQREDuQJDWZ6Ns6T/3eAKWPmDbkNwVKptbUybQedFT2XAY8jlmv+Zh2J9CY/sJKQMcSJfio9hIANrc0YOG44EadqKqPS7ulz53uu+8+fP/3fz/uu+++4vrh4SF+4id+Aj/90z8NAPjhH/7hkdeq1772tfiJn/gJ7O7u4r/+1/+Kv/yX//KJyrzjjjvwNV/zNTh37hxe9rKXYX9/HwBw+fJlvOxlL8O5c+fw1Kc+Fc9//vM/9wZuqUlbFaxrkfwpU82IoGR0EVGoBtUMlW7WgJ5QpzTDDIhzmGpLTYW6ieatUgph9kKlumDpZLEu3LL6trXa68qtVR+aC/+GPMaNyc8Wp1nAGHxMbKi1yL7OowU+PIjzQQjjQOh10zS3ssKU1BIKUS2pVbq8+lU+PSQLgm3Mkp5EuwjfWucMPkIK4DXPrio9WM19S4gi2SEHPnTsA7hUXwMKdSLy80iN1yuQ6dvkQbIG0YxS+eQ5h23uE+sgsfSZG6vGnCrmt7ue6pva6SNke9UMLSZ2QNC+ciBE3xmVLHoyvfJO7W0SCCmNz8cAKjFuAuBXEWEdnb2CJO5dwD3IdeoMKJDYg3BL9QpwDhGcJENJHRtM2ZOokbu3//AxPSZUKUvbGXWAECSWips/hQG4Byap78IqpIMOL8HQuajgoeH5KiV066ZfF7xkBf691nz1d07j7Q2i6OMTMUJgccVbrg8b8QQds6z5Nf8kBy9Vfsed3LNLo3OyVkstDmqQ6zHZLh5/H+0/BmBQ7D/2nlf5tFx8W7vkmbCUewNh1QHDDkAB5jrZtgWd4vrnl+JqDWkeQH2B6dF0w3sldM899+B5z3ue/b506RIA4Cd/8ifxute9zq7fe++9uPXWW7FarfDGN74Rb3zjG/G4xz0Ot912GwDggx/8oAGD7/me78GP/MiPFOX86Z/+Kf7pP/2nAIAzZ87gx37sxybr9J/+038qoql3XYe3vvWt+OZv/mbcfffdePe7342v+qqvwkc+8hGcP38eN954I/7jf/yPCJtckm/pc6ItAHkMkF/oR+J2QmnYXW8qkl5jfvRHnNRsTqXTbjAykFAmsMoiVwR2Ol8bqDc3U0k3dZrGdTu48b3Kb7JylPeLYo+b6re6/Csh99xoQ25cR+AUD4CSG14DcaJqNQJcnf/BxsiNNnw3xhqMUBmhwsgWSPYMGhEbMANfk3zMnZqdY6xMfYFyOUxABwYPBCZ2jDYlQ3VK1yMc42YdA0AlJuKnv1s5CZC2y8pDwdgzUv2iAJjUNpZuYLFRgDt11XgcXHrIaoAQAwcBGVC0iNOYcpcAGwCnOibvkQBENRS3MQ6EKEzzMA9JtawKlpjtefKnvd8qLarUqZT5L7xFQeoZAtADHLsEQgZOn0C6B2Xs5BpVIDhGkHqa8q59a1Uub9chqoxNqp1bhFSP2KtKFZy0wTtncJ8AiNU+KCDMRPWvZTiu89Z5+7NblfqPjlHxG77sDGLUc1nTzorzjyAAhCQOSO1FsAlSW+ufr7qfI1Pgw10z2yNXv8lyJqg4+PLvjFt4R3YrU21orb1+/juVPf8+HFffBBzz79gBCITuEJhfjggrRpwFDDsTYHSUYfU5leYaAB/XEq1WK5w7d250fX9/3wAFAAwStPT222/Hq1/9arznPe/Bhz70IfzJn/wJlsslHv/4x+M5z3kOvvd7vxff9m3fNspvuVxCA6B+5jOfMTuRFvnYH0pPfepT8b73vQ//8l/+S7zzne/EH/3RH+Fxj3scXvSiF+HHf/zHJ+1NtnR1aAtAHiPUOm2iCnhMLc5eXYpiUqNZ7yU1E5WIWF7mRabaTOo8jcFxa3Qrvd9wxodXow3JbEtap2L17w0gpFUHz1D4k7KaCfWn3U1gUZfpx4Y08zI/UJKABL1Ygb3CniPkgSYGWNOFnNbKNuNcIHTBwKj3bmYeexgWm4IDxCBXwIfzld+085FnbAwHkQCIcbrpd8tDGqRPI3xbd5mhroCPJVswxqyKg+wVqnZbaqBE860mBikzTaUhKsFcflp4vimmgco5YZc9Q6ceszgxwgHZ5iklyJ6q1GAcSFIndXM8mGpXA+y03j/KQANB0ZguBtJXEgtE66DXNZ5HWEexF4HE7pCkasjtgQOzgRVaR2A9AEPyhGVAx33P9iGEkcTD1Dw5SelcvbPthvRN3wAfapdFef4zkNzbijQp2RdQs9/GfSvvgwI5BeZV3UcSU5uX1TysFh4SN7yRgZ4YXYigLooKFpl0Tz1h1eXVjP1xdBIwUdi9nJQ0aQM4jOraeK44bHKgy+dV22Mx3Pose9NUfoXKo65P+kdpXRsW6UCkP0w2VKaO5UFT1SYt+1iAKOXU6pxfMGrpxF2NPK+QnvWsZxkwOAldf/31uPPOO6+4nNtvv/2KymnRrbfeije96U2fUx5bemS0BSDXKjUW6WJPLQDD+FmLX+E249gRqEvMX78vizAje2LyBryDK0PIMwGtE0krvrEe2KLdWKgnNyRX96kTvpZEyBhnl2cNhJqbpgcfE+t4U3rjfk+t/54fY7e5cgBYVORGKiLCbKnqlrdR8eonZo8RMZIksPNcBSKwSAK8Lj33+bP2qV+oI3CehymQZXJZ66ViNDA629nTxq8MFynDJ8bUtb2IqniYjYSLYaN9S9rX0s/KDKoqz8h7jmdiZGxTL5TAaDxgGDGVyhgVp7+ufoV73JjbqhIaBR9q82HgY0M9VLrk+4V7AscAxCFHBNZPVcsyCQclWwiZY0MnRtFO4pEL0zwAwgBoVHr1mBVjBhwKNhovJg1OZdADKzWMR8kEq7G7B5xFQEYDINrW3P9gmVuBQSGDTgU4xel5zBJHnbNB3BhrvmbPM2qUe//sj2we6rz0z3IkMUJnkQyi/LN88/f8cKMOFaNeS4xHjLGre5lN6UGvSYwRkz1Fmxjvom1uz/DlNPPT9aRWzdQ0mpeu1VqGy4MBc/TRHUFUj/2hDLKEvlUvHje7dQC1qS1b2tKWpmkLQK5Vaiymxnzp/WqzKcBBxRgBkKBy6WK/n4CIP8n0huBmKK4ng3rKWRmFKrPg6zx1IJEYby6DzzXaa4yea/9GcX7rt8+vlY4x2viVgWgFUKw3dlNN8mVVDEbOP0k/iDjFAGFKKlHIfavM9OSG5oCH/uaQPUSpvUJi6sm8h+W5QaailQyghQlWJl+9o9VqCcII2PwD8qmtmwvanuzGNJ8SDyEx6gp2w1Aaq5O3ZRCmznuf8n1pTL/UWT+LyO9V3cMgc1JP+xWEMOXXyDNvVZ/73/Xc1LmhwRjDqvJeJpIPc3XsvHn52C/Wtk3MnBwqpOCGMgHWsbQFgO9HSm5tZyG7MQ4MjumPVpxf1oAkFWFRz1qxBPiLGKlaeU9X6tIXKGKOkN0X0KFOA7ReWk+pa+zV5a4ANcesetfY2k8lCEEaf8fkEyjXRdYx7/DBpB/qOaxLdRiN+wmZyuJwRp9jFPrzxjT756RLroRGUu/PgfFtHh6dJN96/QbGoAjl9xb4OGn9C9U6UhCVnvVrU/GM7WNpnfFrZbHuKHBs9IWt7+SKr+vcGNcvFD0aXquuBS9YW/ripC0AuRZJF7gahPhTM3/br77VKVMhJQlJJK3pPMCwzSCWC2yOO1ExqoVLUUwuwj6vpE6UGIWmyH503DQGAEUf+A2NqvtTpOUUAIWyp6+qLQVTWOuuazZubyw2K+IUr6JLOuCqNYOBChUsPckz96ANRngqoBeTjMksfY89oVsBvIKdxit3zciSBfMypKfwVRRu35wkYUAKRodxHUZ94txsxiFJSBhJBz17pXGSmoqyDQaVY6VjgjQHqSfrQ3MDHVO/h4FscDjCJD42r506mQchV0zKyFYefyxSuYJL53nHQN4JylNVNlLAOSMgBhA74YJTIUrN0DIDeBbMbTEgDEoXwCEmw/RhyGqXXtIxiMqVch9q22FetJRzFiZ/0MmcQS44AF1I0imk9HHWjRl88Qg2zAPinJrAM/fH+HpbOpoN95NbaDXeT59JUiT9FggRIauGCZitVXMosMSeySxvy9ZF1XFSNPT8V9hPn2D8W4B0ZA9Rg0/ka4+ETJoDe32ajHn5UON7Y51uqsDWoIVyu8u1qFoXdT+q9qD2epKBfuzSGtEt2d1vP2f3dS+t23ot0ucISCfz3NKWHgXaApBrlfRkZorhblFro3Ai7HyC6tJWTBgFlBulOyHKbllLd5RN/V4pn1mBDmTT5HLz0XpOnTA1TtpqF7dTKmBNMGLPUHFtUnWqAYKsHi4/ryJXnNx2jNBH9P0AIkaMARjIgu/l8icGVu4VHni0XNd+7640lU3gtQblSw9kEJndyg4tF7PWuIohCQJC9EIxtm5DVxAlfabe0PIzDogUJ5uU6944kfT10XlMfbqoEhTNF8xJ4DNIeyUwIXdeWOJsGXKTR/0/RfXcMEAZUp0sP7W3UffBG/L0uv/G+1HOM3YA5pIpgBABmLm/tgpm9xE1AniQoIzEAjhDAg0DxDDdAQ/3GzEBlbKSWkHOv0dHrzpP1bYpmItg7jKY1rkdZwFxkeO9PNJTZVXzM/ubpQAPFzGe1kmVDCKdQh+SszDmDI7dGsQB5p0uHdgI+Ai+HVK+AWwAAkCGGPJaipyeyU2vTUxePTlboOSkTCJX75wvw2VfgI8aVLTqMVF+DRDUGF7XTq/S6NNFPfQIbh+b2AeakicFMe4ZfUe9OmZrzas7IqtAPkZAyJa29BihLQC5FqkGGlR9KrPDJ9h8PPMc88IcK3Ufrr603Fk2QRDnRdnUCap6FvYlru7NjdTnW23YRfkbAEN5oXze2uPujfqb3U8HhOoTuI1EkFgKjNAx+hDRhWhBo2uPY6P6MITBYatzzZR7Rj1JQtLNQYBPOi3PfWJ9KHYj3EHsPzIo3XTap+NbSti4HCvt46quheGrA2iFFAhArYbWGmPT/e4gXsXktJudPYowktyhcI4QQQjIbn11sJOtjav/FFOC6rp7BxUkjJKqrY0y3j7vqfYB7r2SeSDgMamTce4HF7zRHvRSPU86pwIJsBApxzBk8KFElGJ7qKG4NyQfYv5d33MesVjjhMzEy5XEPjEDcznQKFXT6v7wE6nsYgWBPhBlsLgQjLCMCMuhCDJoYNW7AIYAF/k0aWdAko4E5PXTAVdjTHXdrACIukUtXJmSVkL7rLHWue9V0mk1vdZ1mr5fSNVb2bmym2utz5eq/H2dHfhIvymvB/VzCgyIyssbvJsVlREASqIN6O1Jiv1S27SpLxV8aDVde5pA5Lg94fNA14ob3i1t6SS0BSDXIhUMHvJJe82wTJzY2E9COrX2aRUUkGyile5ylrhUi45brG0xr4wDVU3EftviP45MbfcbTRmpGbj2bAIfRf3h0tXAo26XVqDVx3Vyzsnrvm5KUQgIXUTfxWSICphUotiE63GV37FyHVswJ04aVRjtdkhGxy2Aqhu8SrQ6Bz68Aa1WQYGlv+j6VZnjpHLjmATn6ccYfLDZMMQ+zYek1uUYPi3HAWebDjY35Voo+0AHx4MdWqcylNsgFm0lUYnJAI4L5odGTDDG5AC2zQsXPyVLRCpDcze+xfttD8IaXTCgVj83l2sDXfceWyDEat7XARJrl74AxBVtA2DUFNIgsxiAayBMi6zekaiCpQjncR4qT1JUAmJv71HPW7nmGd9kf8NiV8QF8OhWEbSKSeVKVcMUMEg/2PqnxYhkJL/nJKpXbmi4PT9MpZXFxktfb0pG6BSAGHhsL4KyrZ7Ztbzr97goPN8bHRxV61l9YGAg5BgwbBWr7zlGvRgzv8YbE58XT+9EpZX3aJ3xCMylH6niuc1y5GI5uL50z/j3r7Un6XhsBH5bHn1LW7pielQByP/9v/8Xv/M7/z97bx5s21XXiX++a59z73sJkxloAiQikyhY0NjEalDKqp8tKIMMilEUISBoU93lCA6IIHQDTTXV2GAowQFbBdQELVtjWypKERREaUQgyii04EDClOS9e8/Z6/v74zus71p77XPvS95NXsL5Vp177tnDmvbaa30/3/GteNvb3oZ/+Id/wL/+67/ixIkTOO+883D++efjwQ9+ML7u674OF198MZbL5cEFfpFQy6z4uh4XeFtQc7OZoL4+mwOwaiG8zCz/MKgAh5bBD4t8JUlC2Wx9kbeNvQ1vGJlgnl/EezbMreS+17Z4fSmsvq/yn2ivb5lBqpneSbmdE3OmcXbcGBAAGEcxwXJ/BaBoN2burySscUysTTYXzKSgaWbPdEE0JuGeTh+4vdd4qsgMqymUSI4lvpTXEUGR95M9q7kxaWklzIkwJMV/hMfAvMfEiLE9Tb8nHYAyqDp3eZB6LSeDzY8alLGCE5rMjY1kQKsnrb0RVIGPCAStOgZMki+/1ddC/TM8LG+k4KsiJlZaVyLQXAdbAGJaDvMD0YznnLTTQwIPg4CPADzyTky6GEwCUwAfTc6bilm0tSeMr2s81pIhvtJ6rM2kTAsYAIqgKjEsi3ubH8TbAMCEKP5ME4NSgoX89SZWz5/EBCtLFKwhZaSUxYUkqjTmhrydP9w/XjPTM5PuVObipmsbRjs+owoctiAkl/sme4HtHZ36J1rvmXZUe02GA9I21LmtW7nVDG4CdwAm+3Hn+llwckvQmdSWLW1pA512AHLixAm88Y1vxOte9zr8xV/8BQDMxmm+/PLLAUgM6Cc/+cl4+tOfjgc+8IGnu0m3OqJmAY/HJ5KxeI+BFWP4jClTSZPfHxZ0Y1qqrLPK0PaY3xIakSsmGlZk2LQnICS0bVZiNLPRTm2Jw3UtMKuup2lddn3DXPeo3WxaiVvVzF4ZiZ13G3PCuB4w7JFk5rUs4Or4yi2T7f0tjH1vo6s0DZ3NddJGY/zs+kYKXHUlMr/NOFQMJNcP2CJqefK3MCfNJMnmUJkzmkvD+p4UsKimDnH+K9MyMZuKz8vnn0Y7WkvuDhoJycLfKsdUO+dbxLjazn8yQGEusjdaT+s7YgwpqcalYsbIzKg0NGjsw2T8i9mK+Tm0gN4zdFuoXns2cXwzxCfCGHQzuVLNRaUJab/VB6I4oic3+/NoUoCYXQ0WgUsAyKjgo+T4aECIvas2BvZMUd7BNEZNajHntOhWw570S0yuskcg87GZPEM1i7P5FY/b5WENLQw+lTUwk4DjhommNUBrwnqdMOYkUfASayS60j9/xnHtbSmuiZ118bQwv3FdrkBNXVcUNtn1EajBAlXEPYxD8c1+4NfoPChaET3YjlXbbCsnCMTSGpO9qQVOeQGwcj/uNxb7GffQZh+c3Te2jP+WtnRKdNoAyHq9xmWXXYYXv/jF+PSnPw1mxt3udjdcfPHFeMhDHoILLrgA55xzDo4fP45rr70W1157Ld7//vfjne98J97znvfgVa96FV796lfjUY96FF760pfiK7/yK09X0269NGGm9fAMk27EVCJVSfhJkTLzAIzHIMxJU1arobD46NQssBPw0W4m8dqepAilHxOmN2zAPabZ/u+aJzTHJuAjbqwbxq1qi127oY92rlukMhzDkEHE2F8PGPcHLPckCovn7DgMReasaW9PU9QbF7umct6M2oMwRoxpnx3wxnpS+A7XlTwXqJg714J0zFAqZmItIWMldw0wK9ylupyJT4qCD9f4LUgT8NUFchLmeNyRDs5KX8M4uPZngEi6LfJV+Hi43wwkCOBIdt7Ai4dAbhhhexDaL2O4y7xjB6iAPQcN92umT1pekQxn0Gr0Dyx6VUoAM5hYxyxEtYpk2pBEasKUdEwCcNF8H6wO8JJjpkQAa8MPe9EeLat9ygI+qjDHDtxLLo+0PyKZg3lgPkuUO1tctK2asZ0JQTvMaM3NJpoFB7XkICTOfw8zvUcY1wPWY0JKsga47449L5tL/W6HNmB+/eqA1K7gZUZ4sbHicG/EGWWdKTd7pvVN+1NvXwjrmIN0QH/UgGaTGZQBCQu9W4BN2e/SmjGs5Z1bnUUeFdKEQVEb3J+jdbvjGnwmaEG2PiBbujXRaQMg97vf/fDRj34Ud7/73fGc5zwHl1xyyaG1Gddffz1++7d/G294wxtw5ZVX4sorr8TrXvc6fM/3fM/pat6tlrrgY4a5d7JFN+mCvJKFd3WMsLqDSHpJpXQuLeKwaJdiupvYRltYu7d3DeFAxq5X1lwf46VTZnlGesY1Q9HdqOeo0/dJ4B/zJVDmngZGklBFWI0DeC+pBoSRxrJJtn1r7bIrhp3LsUm7AhioJJOx3AZ8VH47nevjseq+QbhpMcEqm7xENdLQwEMH7CL87gG8EM0qKbPgDtwJ06kR3o9SLvv/FJ/5GkhZIkGZyZdrIDJLBfr+iPmiAIgKpNlwWDZ01eawaQctx4CC+LTWUMDmdB/aw0lBDxOyPvCKqQlJHqvM6gZcjbk2xlnzjUi0KWVKVauRRgatskeC8khXwWm8yuthYWoBZ+Bd+2HHoHVUz0PblMgjX5nplSXNbBk3k0BzYmTUARdIQyynFWPYzyW5owe10AhXEcwnSMjvFNpkfXLNSNZ6E9AsXlU/Ufrp/bV6R0JKil8IDkyGfSCtCKtVwsiEBQHDkHVcyvvsayw36x82r/GT9TWAEP+9YT29qTxlq43392umzRyaZQBmVqgDfYea48UEL5RJnWuqtZAwLuHJVtMaOPYZxnCSVeBALoww7cs0CMIB+61es+XTt7SlU6PTBkCGYcAv/MIv4Lu/+7sxDD2D7Xk6++yz8eQnPxlPfvKT8aEPfQj/5b/8F3zyk588XU279RLXC/aEgiTNJfG2KAfGMqlT5bgkrM+STT7tEYawoLvdbFxoqf5uzacqE68gnYs2wRNTAzQbR1t2vLy36NdCtnK4U088V7RG8+CjteeO/elG7tJyo/WRM06NhH09DlitFqD9hGFfMoFD+d3KB2RmvKqy0RkAvb67EdL0mgp8qCmQ9D8wk/b8WubFzagAZMIARg7P285J+NXOBq4Mp0grOw7QQCXN5LXU6ak9ev4e1jd3hjf7fJ0wyogThJnlyum9TPi0Eu1MUnOs9nlHRir2lSy0MmeUiEziOuuhi1EzzpabZIhtJwESVc4U94thFRqUZHqAvU/kAME1DaGctFLwsc7FXKo1sapMVlpumOr/ieR64sB8cugowTKbG/DIA03nMJf+ATofGR6KV0yvVHK9Lz4epMDdtV1jM3+sDe02lHPJ7J4hWHNk8FBAmGik6gnWRuGSshR8rNgng2ubRogJ1gqaNwQYUhZN6CKDBx2n8H5T857RzP91w2bO6frKbbM3MNCxzC719h8GCFzaEdbJnla2Kl4f2UYtSfi/Au4RYLQRDWMxalbJAzDuEsZjADJheT1j2DfAqpo86wfggoO5Pp/RdABQutFlbmlLR0CnDYB84AMfQGrjxd8Iuve9741f+qVfQo7hIL8YaY7BROEJJ3a0tlA3UqA8EIaRsbyBkT9LyDvCPIhJgzInyuz11PsR1DiTGxhmDu2ldmM5xOJV2dzafmL7TE9SZiBkTuKkG6OZc7R28rPOmk0Z1f82vtHEwSiOUQABTMKA5pywHhnr1YC0X/w/AIQITqXMjWYRPYY4Ao8G2JV+1+1zTYn5IfjcsqSBqEyNWqaAB4smBWGYTaqsjDQPoc6KmSrMtCeJ84g4XJoetHdu6pSoAjoVab15ofhEy4u23QWoK/Nh4G8guRZF45JG8nZ5t8PYsrYRLFqQKoJTZO61XGeWcxknyNCJiYONr0YFM3CW1jZGxX9DNAINcPMIT4XT87HeD74Rq1yH2gVKe1tn85QcELn2YxhCeN04tuVe18BoyF3RfhRHc2tfUpCWFFTJvfF5Qm36lWFc68fN7FjXupDY1MakfcczxN9lZPlmlgjEA0BMsGztdf9RhBSRIQZLMpl1BlGSOWrXMEnS0TWQ1uRJZ4aUsUgZaWDkqM1scV6zbrYmP9319DBMZ8PQ++G590nr820kAopwzPch3Xui30W15rQml9zsFe16G9vq5df5WWSN4hps+T5SzPyIbY8jDPuMYd/O9/eCKFTqjUkc74370Ja2tKWNdNoAyOkAH0dZ3q2KKgkPqkV74/V2G0M0Gso0jDvsi/DO59Q0xngLc4QOm8fEjtjMXuJGFZkdlONlw2I/cCizsdD2WFDPbKcCKQeBkGhc7W00x2AFKQigrmniRtteaupvn5e2gxlY54Q8EtKqJCFswxh3y9UxLs6Z5Zqs4CUbYxcdy3sMeguSzCE2XmN1dZidiRnFQvgriywV5207Bv4dGBUPRWxzJZFrBzBKToZMcO0CD6gl5UBgjEKELdN2rMo1FdOqGkFmAKblIDiISpo5m3I7iKFfYcLYmJs/SMw6TuqHhbX5LhijHRBIfL95ynSnVS4aFfVxME2KjZtN8zSKaJ+tL2p2lTQiFJkWYMzOqLtjuTUa0N+xjVSyoQ/k/hPuWxHAMw9idjUuNe/HgnyOss9n7j8biM+Pr0Wq/SDV+vQijBl4lf7Z820nr4ydaD8K4CLKAj7axzytpqyL0JDSrKZ3HIJ4mGZETVslEpaUPyQxxxwHLu+qDV1434oPRKy8/t/fU72uKxg5BPn70xx3raW2K2qRY1sma3soyJjzosGl6l7WdkcQUrVH6/ZEpiDA50qoimsgEKPaARBh2768C6b5GHeoWk+Acn27hp8Jvh2Hpw6qPS1lbmlLp5+2eUDORAqMjfMAc4x5WByriB0ZwChRePISWBO5r0dahfKh/wemlcOC4wxtw9xuzKlBWoZtSJnrRbyzkdVS8umxSkMS/4+XxLGITN2G9TOCkMlYt21A6HeQ6HVBUGD2AYgfgeX/MOl/LgzNpN1tv+ImSxJKsoSNDdLlpt6qzDnwEcdqpt/1GBR+iRcAJUwYkIqhoPp4a84mZlMQJnFSGVz6T6Mw9D6/I0giSy5I5doRMBORyKTBtBQoz7+SoBsobRiq3jhAGUiL7DU646wg10zNgplRXYgxssIgsTK1SbUcaZWVAc8w3xYHMgbeMoHcmTphSMWkLjLmAjwYluGc1kU95ExeMKGKDucV8HAAAvWfCb4hGnkrLxPGnYTxWMluHh3i7dnKOBIwcIkEFxhPNztb5YmPmpQlQCwpuKhMrOJ1PlZhDgQ/D2eEMwBkMBJoDffZkLkR/rfnb2Xrekewcbc5SI6vh5SRBlGrsV2YSHPh1GMyRQTo001hjts1t1lXa9PV8u3g4KYSFTBXNEh1uxxomZZUTSsnAq2wX/aEMLbmMIkpss+xdbjuVPp0pvLkB6xZN7rMLW3pCOhmAyCf/exn8dGPfhTXXXfdbFheAHj4wx9+czXpzKXe4halQ1RvDkCQ3oQNk0ZI5BXAGdSJKp3cSmBjWw6KKFUx8m0R3Gwi9a1dprNtQyuVak0BenSgg7m1HcHsaMPlk/rbT3stAWlgpFQG3RhwN5ULjrzTMhy9hGKpenYxD0YNEKdtLoVEzmNDdzsMgVFULHEKjIJJLK3oCcMYPqxhas0HRZ2GWR3DszpUgwpwkTkNNwtDaAMgjtyUACIFImuZrJVEPBXQF4G0SO/VJlwZ+sNo7cScQ3xHzHdB+iimacM+xCQp57od+l6IttKxiAAX1cIYEDHw4W0mDloxBpKaeo0dlGOappxB4wis1gI+7Fr3eYgvlTLnqs1AShpVi4qPBEFD/iYPNiB+PxL1atwN4GOYMrQ+tlZOzAViDKIlGFRNjrcNDfiwkMLRxKpHnjnbnnF4x3KZK+ajA26iCmVJTMgBqEU/hIkAIUNAJRSAJFatEU/m3qF52rAXlPtLG1qaXjuzZgYQ4ve1jD7C8t/uB9TZY8LauDE/TmcvKwKxcs1BGvI5c14/X5zdPLBD1Hy05ffK6NKZCki2tKUzmI4cgPzJn/wJfvInfxLvfOc7D7yWiLBer4+6SbcaahniiZ0rCo/q5kjULJq53MOEkvXapJWttGhmoa3V/fZdN7ANwwjUzHaVMZoml85UPO1X1Z62zRGshPsqW+K5jdCa36uns8HMMfnuj6ERsBYpI08QI4oZUNvuDhXTBJ5e1ANn1Jxv29YbU21X3ZmGoWj62TXTCA82jr1HMzJzGgulivp6GBM7EHgBNw8ycx0zjapMJmJEpgzJu8CSkVoSxlHROBEVB+XYJ5PmL9o5oJ2zaWPMMZc2WXs4ARkCqogkFgEPcEd6Y2Yj4BQTLai/CusxuLN19POwNjMSiHMd7CCatJl/ROzDegTGEbRaFxMsIvlfc4AI4KvBBw8DsEjIi+TmXqbtyEOSELsaQtic4PPCQjHL/9WaZfPKNFtc8rC4TxSKD4zkLdHwwbbOmbmemVyNY6MVCv9HrY5pc8x8DPUYsTnXI4OYgEUq90LfvxBda86Xo6VEjMziHwL1W+gSTXBAoebdrNam3rLQW+PiotsuwHNtagBIvNb5efXXsWPterZJmNEr10DpZG094PZWiyuCMXigM4vYV41XBDNc5qd9XMDSlh/XzwMbdjPRYcb4xpS5pS0dAR0pAPn93/99PO5xj8N6vcaxY8fwZV/2ZTj//PNBp2in+sVKE2laT7Jj+5lK0yuGNl4Tpe0GQsyEx0AIQrneiMIoF18RLsCis4FNGPgGfByaWvARN8ywaVQaAb+eJgy2XM8bmepTpWiuUJWVGBgYwyJjMWSMuWlP5/8oPazKJ6oZ0QACS8eaT1sHgGL6AbQMwqE3mQ5DQG07AgiJmgsPeqBOx22+Brk/JNAbQiVWTgYoaFzi+EOZINeGLFi1EEnasW40IT4stRnebAjn0Gkf/xD1J5qxTAbJ/o2ZviOwCknz3GTRDg1ipuNmY7nfDyQAo1xH64zK5ChrVvBxLOBjjpRRF0fz5ODDnMuLxsLyjRQTq/jsou9HnA/e5xycz+056rX+rEfRcEjeEvVhCVoH0+wgjM90/AMIiWPV0TCWZwABqdnulW8RCsVFx+rABuQgtLBcIO275+OO6XsYwUJn/avu7f3fFndAEI5NZq0H3mNayZl3oBYCzZSj73Gl4eys49XxMC6+z3BY66NzPJmpZnNffN9asHSYtXHL0mxpS6dMRwpAnv/852McRzzrWc/CS1/6Utzxjnc8yupuUzQnDY/gI5qzVAsmlQU82tzXNujqeKob7YEbjZdV7NpbULFRGkhhHacN14YNrCdJs77H79jnXmhdL7fTxy6A6fQ91uPf1j73veDqPGkSwiFlZE7FHC76j7gNPWAZzyf9so2Sqe6P/Uv1p4wZV9dMgEln7CvTmAbo+H59wGZbKXsyQGt49JmSgHE6rvH5VSFNoeZNgDt1E5Xs4bH98R3IAwFL+52QUnHetrlc+saA+phEm/5N5BqZOF65HCu5OxC0Lyialupd1naZFiOMS04JlPSchd8NjtSl/wY29P/oaG45P6IPhH2rLwSrdsCjXFlOEWvzYppYUMyrAvjwOQ3/tKB4XvpvL76NnYYbHs3vZXSTM+rFKAm+PbC1LY6L/fSoXknHv3nQbgJkYyN96q2RLpwJvkMe4CNDndBJNKB+00z/W+Lm/wZk+KHDMMhWL4fvw97XlNFLPuqYrAdgbB3Jze+wjrtGPOxbzOxrAmFatoGVCBSKwEvDysc9MrS/AsWmoddy2n5R+L/6tjacSeBjIgk7TWVuaUtHQEcKQN7//vfjvPPOw2WXXXaU1dz2qMeU6/GWoY5qeNdo6KKd1OTF4ppX6wjDndLNwmS2OXGRbj8d5pxaRhhhUW/ARdtHAqaAYEPbCiMfwEenXJeIzXayc6iVgsW2h/rZ658px4BHuFGS9QVmu7EHL2FVUUwAItPeAUK1ZoOn7WnHk0p5hYmm4kDbms0FZrINwzxnU14YyWDLH0PR+vxoHJUZJdRsluEpAFoa7gnr7PoOqDGfDCaJIJtWALK8GwAKCDFwrVGMuhq7lhlp30VjfMx/QzN3myM5ANcaeIhXQMFEbU0FDoz8IAOV1oyEDFqxAILYVXtGBGHOzbGLw3i3oXNjdUOSAVoMbobFKcn3YL4f4lyel6RRhDTbvWk9wvybZJS2xwZ4xDAa4Cc9bLM/y+IHQxFspd5Ea8iASAQh8ZxpciyLu2pQaj+hVPxZDKC1zHVGCPVcuHvLjm7vTx4lGaE8jv5i1gX97bsexxCd+dle2x7vMdAH3FeZVaJm3qsQxRTGr1lTqu+22uac70fhneL2xrAOV8Ak1mVa1zYruppoevTAIdw/hrHvzN/uesD94dzSlrZ0MB0pAPmSL/kS3O1udzvKKm6zFJnfluGd0zoUKSRpyEFh+jgR8i4k62vLnAcgIvV2ltN2YW99OQ5agYN0tGweVNfX2RznQJFLy8JGNAs+Zvrltsth8+pqTpo2VW1rGQMFCpXmgYExJ6zHAbxOHoK3mBoV5k02eqrLr5j00qfK+Ty119emVpM2t+0O/YuS+7SCMIE2TrZpL0J7OuVUpoFxzgSAwGrvb/fmoTgrA2qmxTL4hSFjd90Q5/VQvQIdB9vKuHOSsLwmmR+SZBLPpKBmLAwvAPcrEKaF6nnZzo/Qt2R5O1aSZDKtNHTsKN82XmayFLOUT8xGAHfkdkd8QPKNEJCIapMti4xlSQYBeNhcNAxcjGzV5BHB0ITYHUwrom0J4CMvLckbVfNv1sTPmqpzyLR5pi2o5nAzFlVELu1vl2JI5x6ZFmc5IO8MrtWgkUCrUczXrCidL5L7JDiao7RLQjoLr5q9neJ7FM14mAljTkDKzlj3qKt9tMs7IOQwWpCJ4uXGcMtxnY1BApq1Npp3TTQdYa31tZuheW/qdrVR0uYw1cYm5/BeB/Ah50Q4MABY7xLyjvQrcVjv2rUNOlfHpiKu96Jbmg56BW5smVva0lHQkQKQb/zGb8Rv/dZv4frrr8fZZ599lFXdtqjdpBpJzISo+YYyRStZaNfHgdVZkgUdUKnQGh6rnsbap2NOmg0057S+3FusW1DU27SAIhF0Rq8BJDPUSlWrdm5gsLtlhHup+d2lOWYgoUjOIF2RJITywUrygFCrBZjpUw08NVyl1eU+LgfvfFW5Ybi7dxogXWvs/JWYMjAJaMAOiYXPEhufUSXFbeZMHuqaDSzkRTnHKnYlJiRwMWNa1wmuDbB4voisdSwIoz6PnCB+Z0GUWykC7FG0vhfNeR8fhms4Ykb3tFJTs73suSsos84NZeB3qMry7e9cyF3R868wLocHQh7rkL60zqodMYYrgZEBGkApFa7EtBpx/C1qFOA+H9ERnc3JPIKPRQM+WgCMDiCxtpqv2gBklohSLQDurkHUJI5rNBuTMLsWYncgX1N4GMA7C+TdBfKOaHVI883QyDJmKhyI94uAIL6Mnbnh/S6aIAvhGzWgOSeJpGXLHHXeww3vVRT4cJlG3Xf5VJniCqw078FEeNGWHdbZHvhoQZOX25plxSLbchBAKZr6mvZXgi6do0V4QljcACxvyAADq4VEa6NUgCUxdRlvDji4Ow5b2tKWDk1HCkBe+MIX4sorr8SznvUsvO51r8OxY8eOsrrbHvWYUzvVboKbGO0E5B352DWJAba8IGanPk43ntiO1jSqa2bRXM9uQx3ObQAzJTFgYEx6/eruuP3+S1sC87Jp09hUF03HoJX2VuMCeBLC1WoA7SdlUuFRoLKGcPXwunGsbAPO8MGqpKJN+7hp34QBbDf/ZiiitqKYD6EAEDawAGf0uxowa3cFbtnbiGCuAxhzUMx5pDE2URKYGMN+lgRvIxfzDLaobuQha4u0EyDTshgDAulEzBNSNfsAMOcMkYKN4kyvGpC1tDN58kD2clu/CaCMScuoMaF27g7aojbpIzEjrUQGT2MCJ7FXI81izoxijpVQhdOVbPAskv8ATkpd5vNRMprH9lSmh/aN8Fx9DpK3NTLneUAJl2yR6VrGdTK3Qg4Unyco4CNG4YghcpMAkLwckHckQSKTuhCsBUwRdMwUcJhmtfUrYyrj7xrMJoxwHpThTQxK7FGwuhqQZi2xqb8RQMyt95OXOhzfUFa1TkRQxajWNqdct2HO/MrLadZIB+CKj92UKYKNoGmvgof0gI41vV2H7d1fAHkJjLvqOzYydq4TbeV6JPEVm9tTQn3tntUT7tyi1Jtfp6PMLW3pCOhIAchFF12Et771rXjKU56Ce9/73viO7/gO3Ote98JZZ501e89TnvKUo2zSrYMiE6q/3VEvbMzR/8Mv1YU8axQaUzcvTtjmaMxSYKDWxVa2ygxriznImep2Ye85fsc2zfpFtAxGe02z2RxcHs8zkBvAmZR5I3eOFpiFtjKx80Y5J4zrAWmfMJxUR+wV+wYsDtWM6PdBzSZrdZV50HAazsBwZZrWaj3mBwFiirIuc6PSigEirTT7duX1KNzv3w4+ipatMGz1XPJjIZs7YL7GxgFBNCFZc12sMxJLeN00yNgV7R3LvDcwZYyNMcvBQTqOSGXW52MduEB7Hq7pCA71jOKzsDYG2cotfgTRYVvKp/K8IrNuoCkwtJGZdwdsC0nM0HwnkHsHAiuokHmiL7WBD8vnwUDCCE6iRrIM5u7voOBj3JWkgjHSlY9nBB+ddzT6CZgWD6G//ommbB6mOWR8Z9UQmYN9q+0wqnypZCxEk0PIOwuwgo88WEI7DtciPHxMaCJkicDDtHfNO4cECX5Q2Xs25QDT8Zi5rvIBROdYuybFa3sLQAUMSA9xjUFiG9GAjbl2hOtb4FHlTdHyqqbZ2p8h4Fjs20A5BCHvAFNvg2k97FQAPGkl38OevLNm3hiFUx4RL7ajGbMzliop1Gksc0tbOgI68jwg73znO/GJT3wCn/rUp/CKV7ziwOu3ACRQ895PmNL28iAA5ETIO5YLgbG4QRhBi2pjZiPmbGybSbvJcuWrgBp4VMxcv61ObdtnJGf2f5RuOR8aNAvd4doEQg6i3oYdz51qsQmgQRKPMQO8Thj2CcMeY9hXvwDS7PQ+fnKs+2x1EzQrosoJnJr/KYzVYdptzLqBj5Uy0iblDMwPRW1Zqpva+nykaCpEIfyl/o5zoM0GT6QMOItmhMSiyCMOWXI+jj4PkH5PnNHD3JHwsKrVMVOkIM01qbePi89FARUG3ocVO5A0xrhkKEdhZMIzsb7F//NAIBMWWFCIMDZxvCqQxABpo03TVDPlKMy6+xUpM27+FJp/g8y0K4ATGSsBTeNuUvM4Ax1Uza9J//w5Us1gN32y/ljEospxf83uwC/hg8PiBtR5TDIUtE2BCFsY4WVC3lHthwGFXJIOensPohBGuWjXaHpvZMxJNCDwRIRca0nDMFW/G0a+Kju8a71xbdvR9fFrQYFPewWKbVlNG3pgKNbl98/UE4USbT/9PaeynphjP6ugwTQnMs/js+/sT/ruQs2Sh30BH+NS90Mdx4lJHId3rkPVGPQA3pa2tKVZOlIA8qY3vckBxd3vfnd81Vd91TYPyKlQxd3VjKap6aP9q0nOze48DwB2ABqFqU37AA+2ohbmqkg0W8SjZUdJZwM+KiY3MBki2Wo2yA2go+f0PTHRisxhr5wGPLXlTf5vN8R4KmzUxkjOUXQeLRJ3y8jNYCbwmpD2CUmZ1rRmSdAGKpL2IG2bmDYFBnnC+MW5gXKs2tDnm6/PiYppkmrEihQ/AItRGEROKomPGa61/dFUweZNBlX1mbaiMr1A6YcBLI/sNhDyEj5WFDOEaw85QSXeEODdYeLNAdpwS1pLf42xiQNWOc8bVRHgzGEdAHO3vsnv+KzsXVoAbGZSBqwM7DUgz+41UGSZ0qvoYj7ONdMuTJuG5GUq+UYA1xZ4mN3wf14g+HsUp/NWINBKynvjIO+SrEHGZFs+kGTO+2MBHx4UwMIJt162jclVqVP6A4vcZeBjQQq6QihmLX8TAKlNB2sTwjLW5HN54s8AYCAOmdCn41fKaiufueaQTO/ctV1QoI3lmQVvUyTBru9gVZ8jnKqsuL7WJk0GDjo+ily0nJUgw33jyl7lDl8BtHGC+zMRo0TACveWhpfhqXBOM6YH9f/moImZ2Gkqc0tbOgo6UgDykpe8BESEl7zkJfiRH/kRpNQRlW+pS3MaezmJjZt8GuvjMWpRtcAb+OD6WGyDUSVZB5xx8HsaJtjtd4N9d3cha8FGD3TZphBU927ScSohOkJdHNrtZbb12/UQENHbkw/SeBMBORMwkkh3TVpdldGE+GzHqgM2SijX+vgEjGygqsoIWrQMH5qw0Sd71guAdSOnplDbwPMgDuQw5t4AGuscbebbpGGhHBo0wlWy6Fc2p8o3ZwJn8asR8x2NMhVD1hLcARqQ8lIqGdr9mUfwkTF59jYf5f3p5G5RYOkmVT6HbYyEERfHZGhIWntn1HzPJLutuV18LjHMaCTTfuT6BlrnmlEHgEHbauB3EH8PcYQv4APNHLnR1JQRgW3lvB8Bx6QvAXCYw3jr85FS8M9Qp34LhqHj7OtTFoFBF4QY+EjUf7cig98y0rAmsjZbHvImzUJVZtsOdI635w9BG/eWdrrNvKOMwrTPCXko1NU6kLsgIpohhncFACxctURL4/q+yRjNAJmmXXkBQCPQAWhMRMP9nXtjfyaaqi1taUunREeKCP7+7/8ed7vb3fCc5zznyMHHRz/6Ubz2ta/F937v9+KBD3wgFosFiAgvfvGLD7z3z//8z/Et3/ItOP/883H8+HF85Vd+JV70ohfh5MmTG+/7wAc+gCc/+cm44IILcOzYMdzrXvfCj/zIj+Czn/3sTe5Pa78PHEISETYok2Sbo604RVo4TfKINuMOYTymn93yne3cUtXUAyqpkJvBBMllccy1+tWUwn1MgL5GRP8PpmCxT9Vm0NtYZsahllZxNYYUN9mGOXTGKG52gcnrMfqTDZ1Jo2BJIjJBDZhu7i2A8PaG+q2NZgITow+lzmZ5iiSAgd08KS8lRwkvMH3u4Vm15nvezlSXMy5Vih7Ks/loYWZ7AQ2iFJNt/rqvCIU2sWgO1hlpzEj7WTRN6ujfAjpv34KCadHU2VgunnkWppkx7cBQGN0IwCyUruc4IQTTECrtWNZldKnHFFXtotoMCahXeJmQoHGUT85l7Dzfho1R0Hi0oJYLaIjJ5WbbPNf+lgx8GfCYo5SAxVA+lq9Ebf+hoYSrouN7ZkAjxTFP5fkf9l2Kgpu5+xgCMvXDOpibhDGRqrk3B0pu7D6x6XxvzYWCgeCYPxsOvNcvX0ubwCfB78wAaFor4AwmnBFIZo1c5XtY2LvGXXufwrxt318tz8Zrku8o+DrFts+OYfuO3FLER/TZ0paOgI5UA3Luuefi3/ybf3OUVTi98pWvxCtf+cpTvu/Xfu3X8D3f8z0YxxF3u9vdcOGFF+Jv//Zv8fznPx+/+7u/iz/90z/tOs2/5S1vwaMe9SicOHEC559/Pu5///vj6quvxn//7/8db37zm/H2t7/9Rvd9dhGnzkY0x6xzZ58J52tVd1OnLdaRuTBnV67V4fUmXCR73Q2z7VcrOWuuK6YeVI63fQ7Hu1nQwycyShMfCivD7jPiTjNbsJKgTuR1+1jBB4eoRdZOH6dsuSt6zC+jygtifYxtiA7dM5zH3BBXJxXg5KgtG9Qp3aS3QbPmplAhGpa1kwIjMmrELDPxilmKudn0q3wS1sbAzNPI8p0Ac/I38w2xFWfwKA6/aWTwipEWomGoorDB5hWcyTazIPfb2OBDY/flQRqawMBaZwkT3ETHpLfqoFxJ0CmEB46olMo4l2dNE0ZqYuamz4D0eiQGI8lzqtBX+D8y7ZH8/Zsy5BTMtuyaPMBjI3fzJ8Q1oaXwHKDAkjNAYNcGRc1H1HBMNDmhX/5vO1bhuYpmjcDL5KZvcpG+dxO/Dr0m+BvZdxV+N9QrACQs15sYuwMY2J6JH8+cmzMHNM1cXNTcB2sTcJg0JjwLu0aDRPh0jlMtlOV7S/Br8zlSra1czKGsvjgf4/yiep654KE13bJmpGbsAjiy8739s0sHPLctbWlLfTpStcRjHvMY/O3f/i2uueaao6wGAHDeeefh0Y9+NH7mZ34GV155JZ74xCceeM/HPvYxPP3pT8c4jvhv/+2/4ROf+AT++q//Gh/84Afx5V/+5fjLv/xLPOc5z5nc94UvfAHf/u3fjhMnTuA//+f/jH/8x3/EX/3VX+HjH/84Hvawh+EjH/kInv70p9+0DrWbVG+R8w0kXGsbukmbg41+tKVtQcQsYIg/mVE5IWumWXPMjblF3Fa+XfgjsAj/o/lU4CNuOmHTNBMXizQ0kVZ53+JOWMraFDWLG6Zvcn9kZCneV99j0s+YXbvSxpj5ycghEpl1kmrmjcP5ZkwnoMgZjoOpMGdBC7IDjLsavtk0GDFz8NycQWDQVeuRl8C4Ix8JB10kleOOakpcO1JrIqLpH6uzdtQ61CAwMI0hoWDrGxGfVQ/4tVGeKsmmt4XcN6VE8SI3XxqPJayPJayPqwZRV1oPSWzv6mAaEIimaNn0q3n+vX5UpkeRrJ2LpOZISTQDKUlOjIU4aPOQxAFdEw5Wfh4V+DAHfM13opHAhlUJZlH5lByCOIynJDeM77E9v6wAoaMZMaBAJH1caAZz9zeYDpqbziUd+yFEBvPxhIN7ADKfDKRE/7CgCZg8K0YzeWaoWUPa8Tk0bQI3VZkNcDioTHTWUPtu1+25vkQwEPeGXJ+jUeZXWkHzEKFo1k1T59HRUK1DrsmwgAZjuX9Y1RH5ogYzhv+emF5u2n9xis/n5iCmo/lsaUtHQEcKQF784hfjwgsvxCWXXIJ//ud/Psqq8LznPQ+/+7u/i5/6qZ/CIx/5SNzudrc78J6Xv/zl2Nvbwzd+4zfiR3/0R905/ku/9Evxi7/4iwCAn//5n5+0/TWveQ3+9V//FV/xFV+BV7ziFVgulwBE4/Prv/7rWCwW+L3f+z389V//9Y3qC8UF2RiVdi1oJHu1JDmYTcQFOsMXcDNPicnU4qdytrV8DmO9QE+0IA1FKXMMK9pKV1un1rnNuIxPy4Q0H29AuLYdw7k1tcdszjiLbiyD4AnIwCQ+IOb/ERg1B4Yh+o85NU/7XW+2VnQLiEL3Z4nbf4xZUsYrGxAJZlMTsNj0t2JCXEtQgAi7WZZ+DIxYZu0F1UxfM6ZmglXC2ZbvrAnzODKwKGM1YeBjH1qwGvowaQuVftXmJ6rpWBZwtT5WEveZzbmbnuj7U5lrxffA2h4AZ9uPWb6gZ76kDtkWhhf6nZeSGZwXyZ20cwAhlURf14+0Ys/27iaW69KvTetBBe79/Sc3yfMdKUP8VUZ28GG+IJQ14/vIEPWWVpig4CqpGRZg0b4mjGQzdlXQCQMhwX/EKeazmVtHopbYh5+xTBnDkKsoWC24nRu3TfxgF5xu4Bkpjke8/rDr7QHlt2tta0IWgWpdj70XrAIZroVbEYysQ7hmMwPeb8yBVyYgK6ClROgrc9UEdgZEfM9r53Kzrvi/Wx59S1u6UXSkJlivetWr8M3f/M247LLLcK973Qvf9E3ftDEPCBHhp37qp46ySU7MjDe/+c0A0NVWPPShD8X97nc/XH311fid3/kdPPOZz/RzV1xxBQDgqU99KoZhqO676KKL8A3f8A34gz/4A/zWb/0WHvzgB9/4Rm5a2GxxB6rN1SRyxLJIg4WBrBKFOU8uqndSh2DSMpwqqXuH+Wk28wljH45XanQrPjqRK1jitv5O/yfO5z2GhzvXzm6wDeNOcPMeQoiOo21spYy2wZYQyAwsMtIgUW/WjMrWeeLcz/IspDxyIT4nbYH/tu+ZTNTRj6Lf1ckQuQWQD0bpP4DaFjo+z8BEdjfg5jl6+wKgrhxYjUnJQBv1pprfxuwn9vnPAwFZ57Jdm6iU2TBoXrcCDo+yBOuXmUs1WrBmbst5LvOFyPPvZNN6sDBAnIGUAWSGJlwWZ/kU5ltjcy7+GVSiqXWi1PEACQawIHBOmniwAbGtKZeHkqXCaEfwFkBHNTWccVPfmkEGRcLMSoOyzx3GrC9LoEoTGn1gLEqVJCuRfBDQPpnzcJIbmeA5PJggACSV6xDfX/s26blJ04N2w8PrUgAfiUp5NvYHaXmCoCCRmAYOxJJxm1jaZd9hPGz9nqxX7UvdA9ahnxtN306lH23ZvXbFd7ipz9+3WCeaPnLZz9xMDKXMyZoZ15xmrYl7VS2AKnsjNPIaIJrHcRfCDSnQiX2p9jUu7T4jQUdvPpyOMre0pSOgIwUgL3jBCyTJGjNWqxUuv/zy7nV2zc0JQD7+8Y/jU5/6FADgYQ97WPeahz3sYbj66qvxjne8wwHIer3GX/3VXx143x/8wR/gHe94x41qWyUFbWhiSxvvUy0DADeX4ASsdyyEqUl24uLOdbmYLqyTzaNhRvtSwOn1E3MXVoCA+QRTk/CYDcMcN6oKKERAMYs8Qh965wjiNNrpW8uchQYBA0ALxrAYkVIWJnRNKpETpNIzL3PTENSbXyUhN83CstVOlEgyM/xIOd50yeydGSwhm61N8dklYbYpjM1k7GY2ZXuuFSNi7UwFaLiE3aTptplOOhDarmU6o6gMuCSv6wxGGFsAlTTWzKiiyVlX6tlu8kTIA+t3MFnTvjELYPJQn8rI81C4rjjOXjgXZj+BkMEFRAA+h9xvh8SMKBGQ1nmSMdxNk+I7ZNJwFh8bqK9NAoLGi3Ss2J9TNZ7ZIu8ZZwaRKBto6oxhpbn1vgt4Sysq/STJ6s7IAnrGLFoPGwBAzuu4UoK+XyVhY71eVQuDgxw3rdr0bkfi6drESYATmjrMDHNQELJJSBDfj+6LfFDD5hjjyJAfhqGcgIiZNZTDvNjA/LqwTIfI5C3xHXdBEJc1O5qexj2v2lOs651oi3GddbPQpMv0HmFxQuYVL0RjyQQREsRIku2YxGd0ptEWgGzpVkRHCkB++qd/+iiLv0n0wQ9+EACwu7uLu971rt1r7nnPe1bXAuI3slqtqvOHue+UyDbMitEuG0sFCMKCbMxqXLTzQG7PT2YTu6biTGoMRbu4R40JdY7HhT22K24YbVutvTOba+Q1u/f0jldFNNqKDdfGenvHNu0xzqBUDGnpFKuUUzIgAzymYtrmzC7Vm6g+uzimEXy4nbKZ/5gvxJzJ0ob2R2LAHT/92+aaSvDzAEkCqHbREwftFow0DOdEAtprpzHma8kyHkPixjlmZmyRCZ4DzIW57I9CNLEQaXeIjLVooj/FMt1EQ5+3ScvNl8GAoY5R1ntyJqSZUKSVRsWc4n1MWHLtQYBO60wLEEYNJ8xm3rMi0CqD1tmfp4cEBuAhbkcGhgTirBGaAMpUtACJwAMX/4iZZ0dm0jkKRhhVk1fNJ32WfSBpfYePo2d1Z8gEzGOZWpHRZwYygSiD15DnbVqeITmY6THRfpw6eVwAeXjad1ItiMxVXWs4PHt9Fq35ngwzITH1BRremDKeG9eruesI03ewi3Ji/2uwNG1L72GV725oXC+7rm/SdZ3fLWMf9xO2/SkTUgQhdo1vWtPxqAMOALzQ3B87Vg9j5zoRCq2P2QKDWuPWo7j22aGm71va0pYOpi9aAPKZz3wGAHCnO91pNjHil3zJl1TXtv/b+cPc16O9vT3s7e35789//vPyT1jMo7TTGWOarH+Vz4ibNCQqWo+YaClJgRZpZpJszTY531TLt0vDo28H1ZsFZcDzIFiZLADB+4ey+dm3a0LCBst+PHS63YStinDepZ4cbgsmFKVuzIKViYbJAUNzPcVGy4dU2skMcKaSed45fp7U29rdw5na8FFmN/ogVBui8mWzYG6OvM6mAAp1ZxnQiQ1/O4YHbcSRWQnXurRfbbpjFnUPmen+SzEaU2REDQQW5rLH+FQ+VoCH+RXNUqOJau5L5g8VGKYJ+DCgzgAs74jm86DM/s6YH4gDUH/OQUgwSqQtAyFWpzdLXw02MyROyGbyxTouNo7k/xZHfc4q+U1iNjjW/g/mJG9JHt1OPtughC9lyPOiAMBZDWRLzTwS7WigBDWFAtBbs0cG8agNVPBi5qfRvMyY2qrucl7GAmIqxWJW5knxbNy0Ha2mOj7LHqNaLgynWsb/VBhZm2ORaZ+rkxA0C+3iFi4LWuVyawFc1XWd97hHrRbKNTGE4ovRrK+s51g1bBkk5owz7bb+x3OMuB+Ge1jNYYOgbLYf7TFC/dzPJOBxqvPnsGVuaUtHQEcKQM5kshwfOzs7s9fs7u4CAE6cODG5b9O9vft69JKXvAQvfOELJ8dPSZpCuohyyWQNl+QKo7S4QcxaPN+C3mc26s40t8x8w2BayE6X8EVtiF7uNswBJFiffJPxJjQmDNEc68AN7YAkhBQYs1gel/N1eaGdmNmMegAHhdmdlGkSzwyNgsWh/nmmzExPPHdLdHbWZ4AIAGMI4MAjRBBy4HSaucDmSF7IN5lkOThiR9r03GbndRjrqJVLo4GJMnaUS7bsFqATNBoVADc5MjMqquuK0ah8vBeonMGp067kJmJav2kKUOZBnA8MKACRC8gk9xzaYtPCGSXROkgwCANaktSRR1TzLI5/6ZM2Whn2kizcmM+558NFIp2k3fbMKescIG1okQ50Cmp+d5htZ+bb6zzwBWvGdla/oBxyQuidqt2o3qUMyXWSAMYAWnCZD8nq4JA9Hj5WE6AUxq2MMzkIsWGQD7lMIUdNZdO8Lh0Sn7Xkc7S5v7fWVkBFQWJ9T1z8p3NEbu1PnPgsfchsXk/WWSp7CUM1TOFGoNYe6fhlXfYyNeto28j4M5RjQH7IjGFPLAGWN4j51bhbz43JPhXWgXbdr4QQN/I5bmlLX6z0RQtAjh07BgDY39+fvca0E8ePH5/cZ/fG35vu69GP//iP44d+6If89+c//3lceOGF/ntuEZQDYTEM5hGUlcEhYRgcb4wNqEhWSGFWuC3fwQZNwIg0MGyAgZmaSLZn/rdN7SAnyEn8903c9CE3ArffbsFEbCOXjVkAjzIXUaJGKIAAgSFuRdRVh/ooqMTjNydz1Mm09BYBJhGUdIsr/UF5RIcmKmNhttPCXYXzYQx6DPvscwhzhHpzzhyS4zwy8GHaDwUnlIo2ppjARHMqTXYYnnHU+plGqji3132JWhLT0NTaE/a5EfvhTBZBnvdCeWkmAVABZGVtr71reWAkM8NCqVsYea7HN2h/zDRIyhWG3YBZdY2RZ/e290vBZTPfmGwuyryUtpdM0pHyRAsUXiwr0n0u4nxgB1AlCzo0alzwZ7H1LZFEvJphpNlMsnKanPeofus6AEGMwDWh9gVKpV80Gg4qgQLKO1lusmSEE0ZZmWzTLM2+rOHdqu7l+nxscrcPnXV0VqCj1ztIbgsPzLgDzWa99y3iMAx6e42/17IGWU6h3vhsEhpFPzMXImQBH2sFIFGrOhGs5FIct+Pf9PkWpaNAQltktaUjopsFgFx99dX4P//n/+AjH/kIrrvuOvCM5JqI8Au/8As3R5PcTOqzn/2sO8C3ZCZU0dQq/v+Zz3wGF1xwwaHu69Hu7q5rS1qq3vnIr3YYfGcQwgYa7dMrkwCUsuQYaUI4W3nD+Y5TtzNmc51yxnJGStXpn4GB9p4ImCKw8Fsjk9zy+Key2UVwY79z04cenqCy3rfADAggJNrmN/W72VXTdmeg1YTEnoeb6cQs5aF+trayV1F1a/JIIlMSyqGm35yULxvaAvSyyHTkcCzuhz3+xjZw69/AErZWGXtx2i9M/8Y5pfk4PPN4GMPW/KKSaFo7mIWxjuAj+kq1x1CO53ZOBOdr1kG2iFXV+Ab/qzqsr5RBxvFokjdioGdK6Ix0L6Ge/R+fKQGs2cIrIGOk9VvI4+gbE/vdUgmVPGXiJuMfAJ6Pq2p96kK1/WNABkRFG1j5AxE8RxDIj5k5D4BixhfBRxxLC1PWzt1mzoDiWMjcmVsYzQmdqwIC+AggpMfIe7dnwAba4y3YQHMczTkO/QfXgKKt24rwdyfcF6sOgIlh4KoU0r5DXnADbux/ey8OZR0QnlfXPyWJPwgIknBV/c+c4tztAdIObX1AtrSlU6MjBSCr1QrPfOYz8Su/8isAMAs8jG5OAHKf+9wHgGgrPvnJT+Jud7vb5JqPfOQj1bUAcI973APL5RKr1Qof+chHugCkd9+pUJd53sRQN+c8jOnYOd8wy8yQqE1cNlO/ND6uarPgGggFJm7StBmms9fm3vU9X40COtTPpNkI4eendbflTk9gI5PrZfeONZuc+YHQwGDzLVD7fqAweBOUEMCGmVrlgTxWfV7CNSTCvXX6gHB4jhHRc73T1qeJaUQ8h/p83OTb8Z9oOqxOY+rU5Md5T3UMBpGHy/SoUuYP0s6VZH4cwZE8TedBBa4oHFMTDaAAntpsLvQxgrYW5IfjDprV78c0kRH4RCDrjP8ApEFNrvQRO/jQdzAy2/A8B1wGsXEcj9q8Kru6vQvh+ZbACCVHi4GQ8i72XngDYNNT7TMoQM+0NihjPRDyIiHlDE8KZxQTTnbITUUtJ0iz3vTXJHtQYc1J5JqONjdPFcGOynhVfauaPFnYZt+7w9LkHWzX6x4ImVvbwjWV1mrGz8NxTHNfC0IqYvVLmmtLu24FIBJ9OCbrfQNYXCuk76/PKwX7YsaFei8LCQpjABbX8Lcd0neyuu4MACCnZL59CmVuaUtHQUcKQJ7//Ofj9a9/PXZ2dvCEJzwB//bf/lucf/75s07fNydddNFFuMtd7oJ/+qd/wlVXXYUnPelJk2uuuuoqAMDXfM3X+LHFYoEHP/jBeMc73oGrrrqqG4q3d9+pUFxEIoMCBKat3VS4ZoIrB9twbiLt1kLZykFYTGN0LF2sq2y2obxKgtdjiCcMVwQLAXxs2pVj+/zmmWs713GiySayCXD4htowF9V4xmNNUUSMYchIy4y8ZEm6tyQMGjLWGDpzSp+AJm2bMaaWodzNszaYX1XgY/rv9Nowh6gdly7DNgNCwnkvf9MGFsCIhWG1Atmc9VmjR5E6BDPcpyY6qps0My9Qso935oePJySHRTGHKsxwMbcKpnpDPW8nXQlzYqKVHAHOGlFq0JC6QB3QQcfCTO/yQg44Lz/KGMz6PjGKz4g7+bICEQoMW+OYb5oS8XKH5UGRrPMG5hqzv8pO3wBh3a4q7HaXI9X5poEHommdhNElARC23sS2GlXABOUckWZ5VxM81Y7Z+9T1QYnrUlwfG9M1z8eia4r5GVXaEl8fZ+aLc7ao19i4rvbaZ7d6Y8q1PW1ORTMMf1fj4JfIGji7eDDKGtm2s6knriuTNWHD4uTPKvrBxT2s2Vugy4YI4AiceVKflRnD/TKacto2xX2Y6zVwa6W0pS2dOh0pAPnVX/1VpJTwh3/4h3j4wx9+lFWdMhERHv/4x+Oyyy7DL/zCL0wAyNvf/nZcffXVWC6XeOxjH1ude8ITnoB3vOMd+OVf/mX88A//cJWM8OMf/zj+6I/+CADwxCc+8TQ0tMOUhnNAWdgrCTyFBdI2Niqbty/ADRPr6vJmgbW62yyxzjQH9Xh3L+HAZEXGZJb5L/3zPrZj0ACZtg8+RoY7wni04+eHmnNdhiRWF5jOyTmSDMgpZaxjVnF16HYTuKQdDuUII0ze5pzkPtd8pHZQNlBvc9wAHiYgLfR1YzUHlYWa8YtDHZmHrLt/4gJILKKbPUy3414L4yVag9pxP0ZoK40sdYlGRc0vULSG0ckdlghPNRNdZs3ei/Cxvppvh+WkMPCeoq9A/ACuyaFBrnctiLWHCuNk/5O9g0jAmOF+H+rnUfl3mOmSkQIPqVuASl4S8jJVWeq5AiBUtVmGgSbPezJWYcxM+2HZ4dOa6/UrCYgQaXYGI9VanEgGPgxoDRqEQDO+u+aR9f0Zw0KRlYkemsSjQGX6JuuccbdUMf8t4O6Z/WwkLmtq9W5uYmy9jgMqOcR76YfjnhKY8J6vg4+JgpC2XH/3esx8uHaTIAPAxEkdqZjXWZsKoICPe4xYFzOf2xpQ7THtXtNbt3qgKdx/kNbvZqE58HpTy9zSlo6AjvSVueaaa3Df+973jAMfRj/6oz+KnZ0d/OEf/iFe/vKXu4nYP/zDP+DSSy8FADzjGc/AXe5yl+q+7/u+78N5552HD3zgA/ihH/ohzwtyzTXX4Du/8zuxXq/xTd/0Tfjqr/7qG9cwW8tTvUhW0rEGaPithImEsgIhwTzLPik61gaAMSeNa01I2pC8LWMyWbib81ECuHFMetd0GLguGdMZ2xvr7/kYHKbcmboodrqjF48aKrvH26Z1VlJXKmPc5mjZKH2jzr9hLG0DL/OqX1h38w0MxGReojnXa1d06A/PxX03ltAcNiTOosfaT8J4jDDuKqO8CIxy9I+Z+FYgaBlMuh9D7wbwEaP2UKe9zTyGDaGCD9MamOmc5SEYd4qfhDFxaBnQyBwpQ+4SffuYI7lqK4zpzir9N/BRrkkCLJYJ4+4gn+OD/F7KubwjHxlb0rFFACDUHYfJ2tN5d6IDesyn4qZurgkM/dM+IfQb4V0w8MHmlO6/7YNK08T2vE3rw2q+ts7elmIWxsUPiSGAJETQqpj/CFzCO3EQPogMeNesam7ti1SBoc47PFdOZx2p28N1uyJQjmtL2C8qIN6CtLAOz62rtmb4x8oJ+1MyPx79pJV8hn397Ml32geGVdCwBZNKX2uW5V00jdzkXWz622/4Aee3tKUtVXSkAOSe97wnUrp5xAJXXXUVzjvvPP+88Y1vBCChbuPxT3ziE37Pl33Zl+G1r30tUkp4znOegwsvvBAPfvCDcZ/73Ad/93d/h6/+6q/Gy1/+8kldd7jDHfDGN74Rx44dw8/+7M/ibne7G/7dv/t3uOiii3DVVVfhHve4B37xF3/xxnemldCExbirwg7X+oZNZROoGANGiSa0BtK+fAb9SKJCiGQ52mRbPca8mS+Cftw/waIOdcxfqs3VmdciOTtQEtaMURyn9uPX9O6zajZsgAfV3drwm/C3B8A4JzEZMtBn8ecZzuhUkrkhMEwBeLTt7Unwul2K4z29ZcqUNExExUg017Zzsv3E66K5QvWMIlNTgQQxWRs1kWb8rDV6zdoZ5KkpzNzcqMyIIhgJpk8eiSsy3Ga6VDHfgbH1yGWBYR/C+7EE8q4Aqrws7SUWIUD9aRgmAzRLQt5NCrpSMZNSnwle6sdAiGlAzLdkJ2E8ljAeH7A6u3zWZysQ2U1YH9fPMRnfyKCVsupxaAUBs++kzS825l7zvqy5C8phICol9ekYwMMApCQf1XpUfiz6nCL4qIUPBmrk28AmMdSJv7yblZYhvhejAJY6kZ6ijbiOhaZlJg3NLZOTgP5ac8B7VI1P+7+19TDUrh1xjwn+T711O7alAix52vY5QUpXMDDz8bba+OselVbyGfaBYU8/J+U77de5Pvy5d8KHe2CPhOo5zwq8/MbDDfWWtrSlKR2pCdbTnvY0POc5z8F73/tefNVXfdVRVoXVaoVrrrlmcvyGG27ADTfc4L/HsU5x+pSnPAX3vve98ZKXvARvf/vb8f73vx/3vOc98R3f8R147nOf2w2zCwD/3//3/+Fd73oXXvziF+NP/uRP8N73vhd3u9vd8PjHPx7Pe97zDoyAdRiykIyRoerasrabEsvCm9ayoI7KRADq6GnOeZ0wmrFcN/VwpqLES6/qaxkMAGasL0kJrVD5VDbFnQ3W+sShPz1p6kRiF47NSfQmtGkz6Wz2VT+dGeW+5odYQm9mQlqRbJYhg7aHTAa7w7A7nEemthMpa7YP8WevPy1QCeNv5kimAUsNAJ3z76m0Vx2GI45Le643d007kqHDk8hNK7wOz30iN1lbzXSNh1BmSzbHQnV5kP5bqE+OzIcxTSjzszC5BbS4NmUBN5fLS4AHbWsG0oow+DiSOL0HAOd9GMP4UwPstR3GCEvWeHOsjeZjdq0mj1wI8Bl3k/jIhBDPFv3L56A5nEfgYWNh4xFBNkq7uuPeglGTZFvSyUlyybD2JAMKFIojWGJH9wOJ74hlUXfzq/LM3I8oE2gk8EjFlyhSYOonjL22K/apMOgsbW3WRQaQszTgQI1v25R4bfPOWNLXeF6cwcPLTji4vuodDuCjAzQ4FD1pU49pt7ZSucQFEk09bTj4to2eBLQBR622xvewGD1QBQ0g2R+Hk/L/+piAeyIx/UxjWRu8Oe36zl51f525BWgW1N7EMre0paOgIwUgP/iDP4i3ve1tePSjH41XvepVeMxjHnNkdX3913/9gVG25uihD30ofvd3f/eU77v//e+PN7zhDTeqzoMoLm6EwDAlVEx9tUByYW4tWdq4Q1jdQXOCrAFWLYeYE2C6EVKoKzCPHL/DtROyDUAXfpBug87klvtaBnQCHsLvLgDAzGLbbvxaTw+8tfU6I9IZl+q+wIj1wYcAEAaEwVkXMwCXjGYUQGdMYgqbZZQCTtradqYzDu3xlgmpmF64ZDGNOkfGMh6VhL/dhNsyokZnaMYotGUOfNiGTqZlmDAaylQwC1BQRj1lubZy6rZ5WFXFZWiMGYWCEP0IQ2+TNgwZhY/W474nFnnLwMcOkHcZeVlCMKcVkPekTQvIWKXmPaTwHoMQolBp+TafR0ZaU9EeZBZN24LLuw3ATMl4gJurjTvkjFgkNvBnPhOt5i2+mxtAxiyFuZIsH4cCkQrwaaAGzkBCEqY0OBNLO3VQQ+4QACrpNjM0uEY4mrsJ0CQNZkCAhWBN8PewdNkYW3awY+0Dynsc5723kdgFEcyEcUyCgFyrSAeOW7VORjDQY/Tje+LzvLNQx0PV3Os3pq3P1vgIRrytsdxuYTrGXhZP3vFyXalvauZVg6TJmMR11N7PJbkWNa2Bs/5ZzLXyQo5LWHrW0PT13jARaoXl4UDzrC1taUsTOlIAklLCFVdcgSc+8Yl43OMeh3POOQf3ute9cNZZZ3WvJyL88R//8VE26dZDYSPzQ7a4U7jmsGVFxKIbALmaoSkrMm4t+Gj/13vjJlCFOIznQ3t8U7XNOkovZxbzts6qf+HWiQlW7H+nn1FCyAlFze+RhCA5PVpQFCutfmv4XajZxTq5Rsr77BuZDAa3ZbWfDePSmyvdudEyEHpMnhfVIGSF4uBNBFKNBCswqMo0hmA0E74S0csY8knUrthfK7c5HrsVp68zkYOABNakfQbuRPNH4rjfYZRjYIEYxhlmdjVAhBkBuDgA1GuMQXfTrQXUxwLuu5J3GevjDN7NwFI417wm0MlBAhFYAgiLAkcqeSUtOzrXL+FaC587I7lgQTRrVEBIjBCmg5sXatK2LNqa+v3W9z2AtwmF8expIP1hNQzuhDlU0N36gLBrAhVoJQJzlvcvJ88FwkMqGojE7pvBBDE/21ETtWXwAYlrF+tzXhDySKI8iZNsE82NTw8QkD5mJow5qQakZqQn62Mssh3rXj1zFEGFl0PVOT/f63t8BxsBgLeJwjsZ28oHDGO83kBYWG/jfISeSgoEY9kTTUhT/iTZbFx7TYM42obU6cdh6bDP5KhpYu94msrc0paOgI4UgFx33XV4/OMfjz/5kz8BM+Oaa67pmkkZnQnhec8Ucoa82eSjPX5feyE35IUwIsM+sPM5xrhLdTQRqjeQWMaE8bVT3FmLIvgw6Xdg3udMB3zTAmoG6KhpbqNtx2ET9RiPBuBRykgq+YRKWtGRqE+1BzrIjPoT297UTfFU55l1qZpDIS6+S6ZRnG+JJTKVXs+dMiyR17ASx880KvO8YPUTasLNRjASQQhP/680EPGQSuppAWVkhZl3M7KkU565YSyo/l/rSyx5N7JpQPylK9e4NNWAymCmVsFpfgcYjzPWZ2Xw8Yx0fI3FcpRxHBPWuwusFwtFcjZhJKpXJiBBwEe2d3lApVmxB04JIPM5aUznPJBEGM/aTwUlMhSV8w5ADqI46XrrUQeEAM01VB6yhbwGoQALfQ3yQrUUZoZVJWIECNHRnMDqYM8LKsAjNoXC3FkqsEGunMonmgCCaBLMz0jNwuJ4le9pnVVQimiHFMZko+mMjrdrp3EwGKmq9GOBe+f6Oq4KPrhML9vXb9Rlx/UhYAtu281hvON7GdYIYpQw8jDzTNIpxPUwsLWH6nWGAVozFiOwvE79RfbZTRsrX7dqUZ0bjGZczhQQsqUt3UroSAHIT/7kT+KP//iPce655+KZz3wmHvSgB50xeUDOZOpJYboq8CiNahg6i7xDWRz0ANYNWa8bAM+C3pg2dE0vbH8YMQEnzug0ZXUlgg2D0kpfu/dVgzMdg7hpdtu8iYGfo3YzPmQZwtwwUuKG6ejcr4y7IbsI5Nr2H2TX6+CwHZ+2/ljuJOs3CoA0CXoGkABKYtcemYAIPopjroAQicHPDgxoZGfcnfkLJmbdFUEZ0FmmJ0ET1qnUn+UbrOAJMr+jCRgnYQZb52Qzo3FfEGgY5NgWZzwjEFHwYcDjGDAeY4xnZ/BZI5bHV9jZXWM5CABhJuwtR5xMjDUvQaM2jghZzfQMGJhZUtG4lDb7Y2SAhuLATSMhj0ErMhZtlGc0d4f7Ypo00XwcggEjoAKuFSMb55l/c3VzNIsiY/ABD30bZwUnAg0Ezua8rWYyBJQoX5r3Y5lKRDT1/ejOrYEEyzAAJKRVVv+MCHAKGCrHECKMxcFAEUAT6rWopQhCInhrxzDWHUFI79m0610sYm4taK45SNhtdbcaBd83vKnc74u1JYDIrmms9rVazlM4SAJIZK3sN3pSrwFzNh9J9kAXSPquhMAtXQCN8IzPRDoKILQFVls6IjpSAHL55ZdjuVziz/7sz/CVX/mVR1nVbY+U+Z31cYgSm3gqZhQPG7wXq4xbtrIZFfPbk2RFU4G4EMc6JyGCG6lYV7oWpV2nsKBXfgdm9z1R5dTXTqTpLYhqGICJRqazGcV7nWchBhKQEmNIjDGzmIi097cbXLi9coglVJF2iiSwZB2u+tCW2QMe7TOP4xkk6OZHMDELr8rR+0IEJ9eeACAmpJFdip8GYbBpYUwcpn4i3Hlubb1hHB1ssyQsNCYiMUsCwFTmWHTuzwsuvgZJxoQHhsQGoEoiDqCSqBaNgmgmitZDwAedtcbu8RV2d9bYXa4xBI3YYpAHfGIkrPeXoLW0IY0Qc6AVkAbGsE8V4I9MXyWkqMCrZlsfCLwSZYLNJwcecexbjdScKWRvDjTgNd42EZz0GGwHhQSm4jifMgOqQWvBjDmSC9jM4qCeACwUdOwkN6MraxhPQEjRgpDPX87F76fWkqFyOGcFPS358YZBleBYBnaoGpfKFLI5VvW9ASEOzuPYAOjuFz1qr+utT9y/tp2HLbNu2u9NWuW5kPJFIdjRWob6edC1qaTgmoIGbXv0S4v1irme7qVjmPphHar634AQxOu3tKUtnTIdRtl+o+kzn/kM7ne/+23BxykSMTZu3Nwu/kC10EZgYiEP4wZm95vjrIfQtXCbIYeClS2bNHv89bRmDCv5uH+Dhu7txX/vm3+gliKi3CP5Aqa7ab1hc72B2ammvL6pWvjtUv9mAw8WMps2mYkJgvmAECORABAeuH4OCGNiEZVCu+IcmGSg9w955Cofh/h/Cy4YaqZUg4++CR2K5DyVNk7aFuebaUHiudHmCrDYYyxOcgmVeVIcQNO+zp3eM0Dbfis31KsMiZsqqalhMk3ASk3DQp4Ac7JvM2nH3CAegSwEB/C5YM7ny6L5WJ/FGG+XkW6/wvHb7eH2Z+3h9sf2cNZyhbOWKxxbrHHWcoXjyxWO7+5jeWyNfFbGeJwFvByHfM6C5uAo4W8nEvgYoGAo77KYglEJka3hiWsHeareQdOuoAVXLYPZAe2z+R4asvwfrSWSv//K4Es+DgatMtJ+9rUmrTJozeqIbt+AokXkQXOYWNLEtOGFjfWbCdsyBIAIIEJyjlC5PoAan+dtoshm7hb/D/nAmWGarF31mG1ue7nwgD529opJ+e2x3u8GKPSAR+VP0qm/BaZVuO+x/ti+YtqKFAJ4uOBhsBDUFOZ++VRhd2N7w/8u9MlNm1NzTWcfOePAx8zaf5M/p0gf/ehH8drXvhbf+73fiwc+8IFYLBYgIrz4xS+evecFL3iBmtXNf66++urJfZ/97Gfxpje9CT/8wz+Mr/3ar8VZZ50FIsI3fMM3HKqt//iP/4hnPvOZuPDCC7G7u4uLLroIz3rWs/CP//iPp97xLZ0SHakG5Mu//Mtx3XXXHWUVt01qFzk9VplJEdT8IFzfMI2TTSKX0LxiitJnFgAEkypj9kqo054GoNvmSlJG9fFefw1U2M82elHFNNsO2ak3Xj/pWBmTypSB56/vUm8jagpIDkQaBkAZr2l+gqa+luk28wC9jAlixgS1n++1zY9RPSbxmVk99sw9mlBhcA08uS13w7xEBtPN8KxMkmM27mldmN68kKhNtAPPjeHPpQVIPieLWVF8BuI8jjqsJ5fRqZ61tgOkvhZalpt5wK3PCmMdAAovQn6SY8D67Izx9iOG269w1ll7OGtHAMfuULQfRsskocDXxweM64R1BnhIIA3TzPvWGAJY3zttv/XNS2uYOrbbVKvASbQqAFzQMAkKMMNQxrWnNfuZSK/tejrgmvgcfN6rBgQ6jzLDbKNIo1PRmEukKzeLIlimd0/C2BFokD3DwL9yGOI8oGiNLEZvB8BMTIV0YExAYBnmq8vkEWI9JqzGAXnUyFud9abVGMT1oktx7Y9lHMQwhvs2mV11tZBz1M6N0J6oxXB/jU47u2tL2OvMVJP9OFVzt10/oynrRKAX2hPXmfhebWS8O3vYobVPR0i9eXU6yjxVeuUrX4lXvvKVN6q+Cy+8EBdddFH3XC+A0Z/+6Z/ikksuuVF1vf/978fXfd3X4dprr8Ud73hHPOABD8CHP/xh/PzP/zwuv/xyvO1tb8P97ne/G1X2lg6mIwUg//E//kc885nPxJ/+6Z/i67/+64+yqtsc+YKKsKiETaOViPYW4hwWWBrVyTZIjyqpLlAxMkU6xRMp50SK2ZEsVfU0G8Usg1D1f8pIlP5z99qq/S3NbeI3giYblTWt7RsgfiBqllWeT5FKVyDEJe5Nm+1ZjNAQscqHAWIHb+ZDm5gPnv4/kYB2GIdqnoT+R/AyuV9BSCUxjfURI6k5k2ne1rrjZ9D0+nYumsQZKL5K2lZ3ILcQnagdgg3EmJO88IzBJwSYgBAH9RbGc0ejXC3V30N9PobbrXGWaj0MfCxSxoJGLFJRtaxzcnOsMSfcwIQxLZBOJmBfOFYaCbSE+qHUZmU8iKN6bjSV1bxJwJhE4xHzZGQFk22o4kkZ1fNCF4SUC+v7W5BbaSrjGhLLt3w4GRrRKpdycpakf2rWJ9nPxdQKw1A7K2f29ppfDydFASgAIYIQAa8EXrACkKZ73o7Q+SovSlkEWnM0o5ElBC+vE9JIteYtjiFNAYx/b2AE3Yn/FJjFyfPUgZldQzYBlVhGc4uvjaGdVaCDlvlHc86almsQEnOdEKAva7jPk1yi5A6x0z7W5Tl6+9t+zox9FJScCeDjTKLzzjsPj370o3HxxRfjIQ95CF73utfh8ssvP9S9l156KV7wghccuq7jx4/j4Q9/OC6++GJcfPHF+NCHPoSf+ImfOPC+cRzxbd/2bbj22mvxxCc+Eb/yK7+Cs846C9dffz2e8pSn4IorrsC3f/u3493vfvfNllD7i42OFIA84xnPwNVXX40nPOEJeOELX4inPe1puN3tbneUVd42KGxGAPqbfyPNifeaEzmM2VLJatzwZWNmdCXvWn6rjvdT8doILBD+DxtOD3z0+uOS99b3IlzXhoysoqW0gKVp76S+2Cnd+CfanKar3T2+AzyMUsvcOaNM7lxs/Zh9DmbapOZWHMbEQEjFOFTj1WlUc92Bm2cApK201DU0HUAimz5Xz9PD+qp0XvCZgoQYIAGYMrIZbpoR85M4Ux2ZuDD/27FwELIWx/rMUDMmLoDQwsAO8sA5UclkHsLsjjuMfFZGOnuFY8f3cfbuPs5arrA7rLGTDIBkLEyNAWBNgwOQdU4Yx4S9bD4CCZRLON9kvgmag6I8K5ZgHkmDODVznyHjaLbyQD3/NgEPLyYwWF2K44zmugZ8VGZ7ClBLtC5WrRYL+HLzJv3tWcfNmUXGh5CAJCZbaSUPlceS2VzaSLLOhez0HvUo9Nu0ceCi9arGjafZNFzboifSWud00sHROW1kIXi7+ZfCmM7+ju99aFtXk7Lp3W7OVVqQCApjefHesJ5Otp+2LaHZBM115HtCQBfhXd0kRLH3nvQPeyfq+VytFTbHGAWQ2tw9JE3ej3b/OFNo0/t6U8o8RXre855X/X7jG994mhozpUc84hF4xCMe4b9/+Zd/+VD3XXHFFXj/+9+Pc889F7/0S7/k2pWzzz4bv/zLv4w/+7M/w9/8zd/gd37nd/D4xz/+KJr+RU9HCkDuec97ApBwvD/wAz+AH/iBH8D555+/MQ/Ihz/84aNs0q2COCyickC/gkYkbpBxI/BFmFX6s49JRuu46FdMZU/SE881jHbcvB0MbFiVvZ2t5Khx9q3qm2tXr30HUGWqUnbFSf9bm/bZ8lvwBbtPko4BKFF2IqCzSxstVHx2/mxtw+0FHYiMRGeDtO+NIMS60pRdzJ3kR87SVksOWKTCcMdnCgwEhQhMzmjYHKnqZXd8zyMJw9/kKnAmNpihpbWcZOUis0W11WOe54YwkUjb80ojwGo+kwcClsUxPWoRRUIO96sYdzS08A4jH8vA7oidY2uc1YCPnWHETlpjScUEKzNhGOT/Y8Max5cr7O0ssFoNGFcJvGDJFbJk0FpAT/T7Kc9E313VgHFvLqIGIN73DaBjE03KMSY+AotqvofnFuZTse9nDPu5ZEKPfh1mS5etgtgQ6wAD66yAgZFWSRj+eI9ngE8SIWyp72XwabK+SF4ZHdOxCfCg2hPkMO/CfDawTRmatd3mIXseEI5Z0H0gO2Cks8ZuFBI04KEC7j3GuQMYqyWsBT12LDLdWnYF0pp6vC0N8I3CKVlL2C3rfI+YWbMm61T4p9LeRbPVyqQ0RIK09d+EcG1dYS5PK6yPn+q7tKVbnq644goAwJOe9CTc/va3r87d/va3x7d927fhNa95DX7zN39zC0COiI4UgHzsYx+bHPuXf/mX2eu34XkLuYS3w2AbTxcPOI+uCzytxdk3rdmdZU0r4hFBuNzbk4bXZjiomOSpPwMmi3PP7pY6C/hsIqzQjrLHFn+HipltwES1UbbjhQBC/EDoM+IYsdc7kUbGsmI/s0g7zfFUOJFyvgKWTTld4ND4gBgzF4FZ13Qm9L/te0WReQzHkoIK0QQAPLBv3j53xnKdOIqiHnPzwWgAqm/4xqAqU8oDkKtJ2DC1wRQLDIk4Ngr3koHC4DRMmY9RnCPmE0XQ6EdyYrS53oTblWhXDF7CnbgxMIadjOVSAMcyjQ4+FpSxVO3HQIzR1TziH7RII3bSiN3lGieXI/JyAK/FFCi7CZY+f+WY3JSEbRwIMFOjGXAxy7t2rp3Tem7ShvY0sxM/IAOOGiEtrRnDXkbay0ij+n2MXJzLx6IRcdMrIgEUA8GyoFPOwIqR1hkY5HwELJwInAcFyQmUk7e70s4CJTy0RYFr+tkuATIuYgbUOl9X97ICEBYA0pVSd451mdqAzQ8yt5zVUPSeZQAKVf3hPXKefWb98ner2VOq3zperhlScGYdqjKiN30ihmcoj8KOqr1tX/U5m2myB2VhC1AhWdDXxwBeUNGMRrNja+cGP70zhnpz63SUeTPSW97yFrzvfe/DNddcg3POOQcXX3wxnvKUp+Aud7nLaa3nL/7iLwAAD3vYw7rnH/awh+E1r3kN3vGOd5zWerdU6EgByEc/+tGjLP42S75JRCY/Mn2B6SyLLBwMAGVxBQGrswnjMbnHMlWnNQBLVmbMdszhoeWL/bT+Hpq6gvlTGzWrbDjYuDlv2kDisRaElAt8iHw8uAUih1lAOxvvHByuJKfh9pLRlxSAkGRCn6s/gsvIaKMAHwBixxWYOFLv6FhsD0BMqpsZ6645SGT2tW+WU8POW54JAyCeBNBN6eo6jVkDWgaPkRKQR4DWkpW6175KMxUYW9MGUAuw3dSFYeFRLYO5zXXPk+EmXRI2eLQcGQF8eGQsgoRWTgwMjJQyFiljOYivRyJGAmOZRgcfyV+KjKyxQxMxBr13sRixP2RwSgL0BkJechUpSXKDwDO+GwB0MyjCRqa1fe5dsB9P9ZhkhLHn+tnUwCjMKw7gQ82lhj01nVqLeZWDVWbx+RhH6WfOxfciETil4v8BnUc5i/AqarrsmS+S2kEmJL2AU3IznIwwpwmIyRFJI2z1zJxs7jHBNW0Vs2vrj/4wEFI9hOadb8nWsgMZ3Grd6H9X12J6fTsv4hrvyQvj5Gj3nXYtRGcO2VyA+trMLLCtdknaybL+WTmxPX7NXDkoAGIAxh0RmC1OMJY3yPs07hJGzZuFkMgTQIkI12hKWo3fzc2o31bprW99a/X78ssvxwte8AL83M/9HJ761Keeljr29/fx8Y9/HECx1GnJjn/sYx/DarXCcrk8LXVvqdCRApAv/dIvPcrib7sUN4Ue+IiLnfEnvQXSGEZlpAAUaZw5Ceti7kAGZeM7bFuVr6o2lKhBqDQudltb/gH1VZtLADpVO4whCOX7b6De7OcYsaYel2427d44PgpCmENsKiqfKvdC0Ci4ZD/WVTEzLCYc5oQdx6FhCnuas4p6x1sQY2VDmTEmBw7Fhp+nJn5Vn5VRdNvtAk6i/QQlYFgBYu5VO73b/Q4YArCQeUuuDXAJrDusyzV5UPtzd6jXdyCUzUk1IsqIUEYNHiOjaZLUBJDmfEnUfLSv8XsMA5/1IS0UhKSBkTVcMw/CpOUdZYKTtItXEJC2tr6xODWrL4jnReiBjsO+c5sYqRZ82HOJzyaESI4AxUN371lIZHEut36U0Lr2ycB6LA+BE4jMvLFpfHxQCoJ9LDQXD62BhOyCFYkEGBhhnVP1+2TPPESusuOZgRB5i6kJ+Vo1LzLT/THuAY0u+Oisf1HIM6etOlTZc9Qy96n+bmVCXS0rUPYJe5c21OHlko1fvQ53TWXjfegDJFj1uj4kvdiBvM1nDs8yPlMq151pwGMiiDpNZQLA5z//+er47u4udnd3T1s9F1xwAX7iJ34Cj3/843HPe94Tx48fx7vf/W68+MUvxpVXXolLL70U5557Lh7zmMfc5Lo+97nPIatP2Zd8yZd0r7HjOWd8/vOfx7nnnnuT691STUcKQLZ00+hQErDOuZjcLa2B5fVq576gRnJXbyDsaCYci9KjySIeNj2g2EMHx9M5KV8ECROtSuAvJn2Pm2+7ERtTrhvGRHti9/SAUCyjASm9JIe+QTW3+30mRUUBCpHx4eqYPes6kk01RtY2Y84isxHNEioNRD2Wcdy6z9OYx2B6hVQAWExy6Zu3OngWiag9OPvdgIXMIpFOCkXMr0n9SIZ9QkqMHo/pjEEOdfpAlb7FaypTjQgeENrnY6sM9FragDB+mQAaBOg4mE8MClnvDXQIABFNyHAAN2ChmhdDxrAYsR4GLdeSIkrniAhQc7EBEFMU04ZBrqfUvNPogI9NwPkQNNF8hLkQczd4FDK9zrUf+5LTQ8CH+n2MRQPiWhCvkAIAYWDMxVSXSDUk9Zz3++19UN8NJggIIQZrxnnRgnQAr85VYohplwEODuteCLtbwAdV84YPeP4TataeU6a56uK614KJdh0OZXlAgHDfRLMQ1/1Qny/Rca32cjHtYzgm/2oAC6+XROto/Ukopq+9LnP9P0PWtsVJ+bE4KSBo3FH/H5vLoZ+u+YhjEwBKXWG/HbcVuvDCC6vfP/3TP31K0aoOomc961mTYw996EPxe7/3e3jiE5+IN7/5zfjBH/xBPPrRj77J5vonT570/3d2drrXRHB14sSJm1Tflvq0BSBnIsWFLoeFPpqYICyWxnjlstBKYiaxt16cZHXAZORFKb/VjlRNiJtNaFPlI6FtLNdzdWyyMXQBh30TJkzSpgU+Mp0IDEi9g1W0kRmL/eiAkJ4UbUJhRxJzdYaZX9SXlYhWlYO0gZFoe1wx3ShOsva8oxYi+oiwtKe14/Z+BO1LbL6XqdfmhTSs1M8+B3sSyDaPCyX2zO3Iwig7pRokEQMY1TzQywjt94P1vPcamzlaj2uxA7dxdqdjd1IVJiSNAPa1r5UJFIT7D3N/1ryuoUQZOXC5OTRykTIWwyhARsGXCwgGaD4SCVGcWJ4JjQCP5C88jcJok/UPZUwPrc2M1My/KO2tzK4i+PCEjyhJ4wDXfpAmFHSzK41+JfXYxWrylFCQVOPX4X4hidUcTT9EUyVPzuo3IInMeNDQy/sEpuRzJoZ/9nutn+aDEsGHjq99F/DRm39cwnFj/nlUwqYeg27H4/emcjrvQRTCbDLHa0HHRu01wnsf50czTj2Bx6QvcUyTvINRqFEnRK0HYSIAq0D6dN6CgfUxwvqYAEkL2+vvd7P2VICj1+Yzgbg3AU9DmQA+8YlP4A53uIMfPp3aj01ERHjpS1+KN7/5zfjwhz+Mv/mbv8EDH/jAm1TmsWPH/P/9/f3uNXt7e/7/8ePHb1J9W+rTaQMgD3jAA/BTP/VTeNKTnnST0OnHP/5x/Nf/+l/xZV/2ZXjuc597upp3q6KJVD4y6vq7J91x0wV1kB13pTAJN6pM74hiJgAUJlDL7UnKZjeXCgA0bY7UBRzwDWUipe9R2MRayVORSLbH58uaMLYNoOnVPUf1Rl52Xqp2bWPwlVkDg1dyKg8U+icdpHiP5jBgNfdJHnmHPQO9SZ0rR3VlylqJeBUNJppQNIx9NkfrAHbSujZJ62WrBxcgFXMkQPlIZ4rbZ9aMkbXLssVXwFyfuWe8js80AgySMfBM4NZnVuY+lqHjk9bsDD6NrD7QEjI5jeIkLloiiWyUM1UmNqdCUWtigBVhjKz9YvLF/tyy2auviwO0gRA3G9Hx9fUhvttzFBjH2uQozKtW46aaD8syP+yH5wd7nmJ2lcYsDuZRgwWgik6RZAJxzqCUfI2iCDS4n7MjAhUCwCNAHt+VgCw+RkVLEZzSm7kUTV8n1Kxjm9YI9Z2fvyTe31l/D0Otr8bsdKTA+B+S2jFocEyzHvTbPVlvYx9bxt7GqjHXck20x/WI62YsX94hMxF1rS6Ha5s1kNaaCDOHa7BhHFs6U0DI3Hy9qWUCuMMd7lABkJuT7nvf++Kcc87Btddeiw996EM3GYDc8Y53REoJOWd85jOf6V5jx1NKt1i/b+vUBp+70fSFL3wB3/md34n73ve+eNGLXoQPfvCDh753f38fb37zm/Gt3/qtuM997oPXve51uPOd73y6mnaro0pyFD/OkKJaZOLiKzbhcCZQwoYSxiU5Q1mkwGq/rPbleSFMpzvb2vdAFSMZw4Gac2m0/Y5qbGMGPaKQf0LW4rDhdxf85pwzr8qsTqRREcAF5qktc/ZzmOfTLvJeZ2lodDqttRhqjx7CkdIYciHYOHMZ17RiDCsFGi5NBtI+sNjjivlb7GUsTmQsTrB8n8wY9lmDD0g58foSK7/0y6M/LUmT72kejEXJoxDnkGgY9FtznIw7JM6du4S8Ix8eilOvS88tjG9rftOSgZMY9tfmRpNV3jSA4w5hvavtXxRAZQArnh+X5O9Z0jG3MU4r+ZCPFQGjfPKYPOBAhn5zkkSDOgcq7YdOlugnMuaE9VqiYNGaKimsa6rsPVrYew3JR7Kgyka9B7xbLUbvUwWk6Bxvza4soaNrP/ZF2zrsWXjd7BoPAx9mduXzjAg8JJ8zFSVde5YDsEjgRRIn9DglqDimywEGxiyf9SjO7OvseUQspwitM9J+lkhc++KbklTT4XmUOtnQ7ZmU/8PaCGCyJimITCkXLYgy1L1yu4x679NrTwuIZj7czJXqWW9iYBvQGSPgtVGj5jQmHNo4aWvT5yryXzCz877aXhKTa9oep+9IXpAIHoLQrdWEmNlgiskKN+0Lc/vNlo6UzAl8vV4fcOXBtLOz49nWP/KRj3SvseP3uMc9tg7oR0SnTQPy93//9/jZn/1ZvPSlL3XbwHvd6164+OKL8dVf/dW44IILcM4552B3dxef/exnce211+IDH/gA3vWud+Fd73oXrr/+ejAz/sN/+A942ctehgc96EGnq2m3PmqZ955UjFC0ISiLeXTENinvNIRuzfhPiEKdhGJHbb/nqN1o1Em3OFsXidVcORNNSrXZo2yS6GxITUb0tjwfp0DVtUDliFiZEczQQRIytrozITq4yrPSHBjQKDltu50hKL4MZhNNXCKdedhIY9DNQdmi+GQ1pWJlrKAaFmXc84JrO/jAyLuEkMVsiDJLedkuRNFotMyFD2rY6K0J6hxODE+k6BoNgg989JkR5ocCoxiYjlg3AMsEbtdViQrDPPZpxsJQMYcs6jqeaSTwmpHWJJG6AgBn1X6MOUnYZQccBkYSVoD7grRmWBmE/Tzghv0lVnsL0N6AtCJvY6UFIYgWZJDzWfsZfXYqs7qD3rFIXJ+PkcR8HraaD9PmrcX0alixMPX7ubRfI7h5mN2ZkNtMNu5c8nhYtCtj8EcGjaNNPjGpioDEwEfQlPhgpARPaz+Kj04GkHwNSfJuuX9P0ToZ0JVhaheQMpncV8pthOSTkr1vM8BjA8M/R1FLdZDEu7seNntK/Bm1Cv66BHBSzZ85Jt3aT2F9CPe4bKYtt+1LaJv5O0kUO5RIgDYW7bxv2xnLDCCk2usa4BT3zl7/izkYzgjq+qachjJvafr0pz/tKRzufve7n5Yyv+ZrvgYf+9jHcNVVV+HJT37y5PxVV13l123paOi0AZDd3V386I/+KL7v+74Pv/qrv4rXvva1+L//9//iQx/6EN7whjd07zHb67PPPhuXXnopnvnMZ+IhD3nI6WrSbYNsQQmLqy2YFBg3u9Y3eztEcD1XmwTOFvf4P7f1oNRh5kEwp2mtZiK0bpnRxta/R7P2tbFNaI83OUGa6yZgJvbRNi2EdgaAw7Y5tW0LfZwwehVSRDHBCpvdRMJvz8uehT6jYoYXwIXeaxou054YQw4YM8oqmWaw7v4JarYTx4Q074El7UNwkE8RDOjlSa43oJCjrwowAbreJpWYRslrAkp4VZ8nQbOCErEqD6UcyTatid5M0xE0Mv5sUii3AUUVL2I/ojZFr48aqGjGQZqZ3BjxvBYAssoJa/2kgbHKAyRZN2Ht1RBWeXBNyf444MRqiZMnl+AbFhhOEmgl485Dw+76OLE4RluzDTQD3f767RvesXhNCWaAeSASMpm7hmNfvmmVgwlZ4TQngQPiepQZloCQzHRwEO0IEgFZcn3QOAIrHc2USuLKFnx4hwTAWMjwUl+WiGds56VN404qa1aCBANAcMT2NaL4JhAzMDaO7DYHQ4CCNgdSz5x1zrR1TqhSjtVrfu++iuYY/QYwuDArMOGTeZRmplNsn7WFUD8LW2sdeIYxsBu1zw5CzNQsT31+4j22tlba+TguZso1NPdUcxRFKIUy/1vQdQbw6LdpesUrXgFmxh3veMfTxiM+4QlPwJve9Cb8xm/8Bl72spdVyQi/8IUv4Dd/8zcBAN/6rd96Wurb0pROuxP67W9/e3z/938/vv/7vx8f/OAH8da3vhVvf/vb8Q//8A/49Kc/jZMnT+Kcc87Bne98ZzzoQQ/C137t1+KhD33obHb0L0aKNtwTU6aWibKNC80i6BvIHPdevttoVrZJUFhgY7lxQZY66jonVdHMKt1ef9Aq3m5+1PSvt0nPlYOZzdk22ozixxDKIw7NpGlF1Xl0hiRuruH68py5YiCcCVYVycDsGgkzzWojANEYTLoAFyonRhkz3XjdIiTbwISkXWbOYEwJA1gQxtTMmbiph/J9rJVZFUDDPiruVB/ssSMQyWr+l4MfSl5QcXAmNQeLDET1bFCkmHYsMFfxGdSmHu05CeJgjIxnI88EGgm8StjfW+CGYUdyflgBA5BHKr8hWo81C0jZzwvcsNrBdSd3sTqxBO0l0X6YdJdDg1uAEd7BNnnbxIwHpZhN70XLCPeASMvUifZDzK/SfhYzqxzmXpvLoTmmgyKRsNRXBICbXnleI8sJMmbQ2mNBg3koACQ4svtnULOtIQCRTt1pLVHHUmLkZQG/rH7qHBIrtmNmGrziX6f3DiyJKodcTLA2jP0c+PB64vPrXN9dk2fqmh5s7mnWSMVpcGEEd67t1dF532LuqNIHNc2MILXTTso6tblzQQNa7Poi/AmX2toQLAQqp/iwflTlH3KMbzHqzNHTUuYR0/ve9z68+tWvxrOf/Wzc//739+MnT57EK17xCrzsZS8DADz3uc+djVp1qvTEJz4R97vf/XD11VfjaU97Gn7lV34FZ511Fq6//no87WlPwzXXXIMHPOABeNzjHnda6tvSlI40CtZ97nMf3Oc+98HTn/70o6zmtk2FX5se53qhdzIAodLEifah2uS4WqRLGSXrdY/RLxsTdRfrql2hLtekHIbaDaA5t4mqzTrujnGz5OY0Te9vwYBvXGFjPhBIdRheZPbEhS0Y6kqqWZiwCE7NWdoYL1K04T4lwZ8kMcCjmu8Ev55oF618gCfrGncB1hWCRnjkLZl3NaicSFzjXEsCWpKBD50HKUqNI2BwAERV8j9iCFOvEcQmYx4Yh3a8G+VUabPO++KLg0nZLXNY2cGvREq/Gha43s2sCOMyYc1rLEiSExplJqzzIGZXqx184eQuTp7YAU4MGPZKnhVn8iL4aMmYuIz6PZl7NzaAkDgWPpYRkJnJVdP/YWX+HqqJMwBBJKCi03hKAOs8MMBs/hl2LzRZoCWNrEyzUL5pzPU1qjmRUFf1QPi6k+DmXa7F0OzsvLBB0nk38X+pQVQxwSkaEfG9E9NGWmiOl4OWvDi/Zp73HPjo+k3N7RndgufbRM11lYlqvLRdv+K6EO+Ldcb1Pds6WKIG9oKfxDnaNQlr2xO+i1YZLsDJzbm2rImAKLR9S/N01VVX4Vu+5Vv893XXXQcAeMlLXoL/8T/+hx9/97vfjQsvvBCr1QqXXXYZLrvsMpx//vnun/GBD3wAN9xwAwDg6U9/On7sx36sW995553n/1v0qre+9a3V8Ve96lW45JJL/PcwDPjN3/xNPPzhD8fll1+OP/qjP8K9731vfOhDH8LnPvc5nHPOOXjTm96E1Pidben00TYM7xlK0QzEf4fFNkbraE205HzwGwhZnO3e1um4YkCsHPX9EKa37EaTXA+p3oDkoqa9lcS8cP5VWZuo5nenTHrn/mpTmWFA/ZCd74GFTc1SvqcFdxwjI7VjFCKSgSQ7eAtCrCwzvfJN14S/bMyyhSKVG9yR3U0VxEyNRgYSkHPS7M9UGP5kwQcEdIzHCOvjEkWNB7iTcSIAFuDAxoab320/bN7C8tAwWIGHS5VDf+OcsqAJZoLFQNHKESqw4EJwY3ZQjvv5lnHQ8TQfBs8y7s+shPys5hJDnp9qRtJ+QiZgxYQv5ITVOGBvZ4HjyxV2F2ss0+hakMxignVitcT1ezu47vpjGK9bYDiRxMk9ZjYPJpZkAxCpM2fnALsf5nCgfffDGlDM/uAJBqtzo4XctY84mPtgE8BIsASDFWWWOcmAhdT1CFeAJPcL423+I5Szz+n4cB186KcIGAgYEihnaQuyABSYlo+qCGiRsXaJfzgXTVs9R0U1uFCfKnWAXgJpIUkqBwOhvOEh2bNon1Xvmg4IqOfBtA7LMdQDobPmeu231rNJ+j9h2EObObY9zN1oKuzPAFTdV5maRsf0zjhReH/b4CuSb0gDe4zqi7Us7bC1mDv9LDmb6rYetE/cbDQDyG5qmadKq9UK11xzzeT4DTfc4IACAMZRNrR73OMeeNGLXoS3v/3tuPrqq/F3f/d32N/fx53vfGd88zd/M57xjGfgEY94xGx9vbraNsTcH0YPeMAD8J73vAc/8zM/gyuvvBLvfe97cf755+NJT3oSnv/85582f5Mt9WkLQM5AqsyuWkYB5ZxfEwF6YCIsn0JeAnnXHJGLMzDW8N2IYrnN5uBFN07kG23NI0MTnKirTQdwCenEuTMwID3pbsUAI3zPAJEWhDj4aOvpjDXNjEepoPTXcl5k9QXginM15k3AAGVIJKVBQMhGEGaMYGxXDqZWmV1KXd8W7slAymrfQ5KIjRIhk0hsx11gfVzBx3HGuAPfsEEE7JvvRj1eziTMtD+aDeYBoAFIAwTMRCKpx3w7WKOyGZPoYUZtPNQnxIFPL9gBmnPBqR45gA8DICEnCMDTyEwIzE8Wf5wMQkICZ8K4JtywStjfWeCGnSV2l2vsLEY3v2Em7K8H7K0WOHliB/m6JYbrE4aThLTfTO6GIavmu6vnGv6g9wwOy0AY4AhrSIx2F/+3MRv2GGlPIkrRqPaKyXJ5SAAESwRY+mAPzOZsLscqp3K5hsz3YwyqKfPtsLlhDu7Bj4SH5ICFBgZYHM0Jaeq3YL4n4aAw8VJmBexdg1PWETdrNL+kJcBLxjCMGFJGZhVIcMiofsCz8PE6JM2Zo8byNprhzdzj/eztOXOMeJjKEw1DZh+HVlPRCgnsVSCbIu16n4sfYG+ec4JGxApR8BjA9SwgZC0V5IFqH6HYDgrL/5kGOM5Q+vqv/3r38T0M3elOd8Lznve8G13fqdTV0oUXXojXvva1N/r+Ld142gKQM506C54v0naudd7jwijYAp8HASIS6Qdit2zSHBAy1EmyMsMKkqAmZK6db9s2bUfHdrph5rsmWR1AUan522IawDCRXEUQcgB1zVFmrpGN1JhLAxiEPBLW60FzO1jjDSwAnpTPGjVIoyMocubStBg6njUzpx8DH9EOHphulKy5GPYB23GzSpwNhORdC/EqNyeIfTwHhtKYAZ+GG6SqxIFhSZJHI5tPBbE/LwnhCwkZbeDDcqToPDWwTCwSUY/1b8+cACZGFF9HnxZxWi9MjYQmtnCiHHx/5LkkMMZkTGOZWP5+mU26PaycwCNhtTdgtVzg5DJ7pnQZfskbkvcGYC9huEHAh5lfMUEiMUWGLD5Hf7/IpbUbqX0fD5zPqMBHMu1HAFxprSGcNdzusJeRVhLu1k2gLPqVmVi1oCNoLOo1h10zSCxcJ61G0GoExlFATtt2N9EK5ZH4dkSQgsygIYHXkHeKACzMBnFqLFaiWun/Ns/C9OIcHhJQQMhgAESy2a/HhHHUSFx2T8tMo/4996xiXQL8O8Cju6SGXCFh/6jq7YCQSqDUrP/xfzdXAooWrwEUvjeBy7tDKEKD1JSLsN8lk3joNW4aR3Ub23bGY/q48xDX4+b5ddrcpUPuJzcrHTRnbmyZW9rSEdAWgJyB1Nqq2v+t1sEW7/pm/Y5Sp5Ex7JcLo5mVO1nqDlJpU7ycupKutsA3AGM0wrmmPO9j3Hh6feByi29sraQsMMLdNvYobBzO/M60oSfpinbBrkmxNmQCRgavheEgYpHSBUCTxgwLO2phSg2sIUhSWzM8ODNXj3OxS0cNPFqpkD3HDCQICGFKGAbGqLknIiNfyoll1IDDgciG8a6enSb/M8bJInoBcACS3WQw+KiE+istyMjFFya2MZVJwUGrYuZvTApgQsjiyvfDngdoYqrowGMk1I7Fmll9re3eT2AC1sSgiqMC0lo0HmkfSPtqjmfvuzmgc6MXbB/nQYzBAeBjqqlEZWJlOT7M1M1+DyvGcJIxnBwxnByR9keJfKXhcSU6lQ1+H3BUv71B8iLyQCALGxYiX9F6rLl/oM6EHssL11FmsJpfyVOCaN8SVFuzAcnZmAUnZnnnLYw0+btmWhEmaAAHuWE9JuyvF8j7A2iVqrVgzuTqUBL2Q1zTNdHlzvlN5bZtbN93KqcqDUgLIoBqDlY8fmLdU+RZTEwmDTyY35qte8387c11S/xKGUi63i5OsgN+036YP9VB79mpCLNudmrX69NV5pa2dAS0BSC3FmoWu0piicAIK2kEUDczWdzASKsmVKRtIgkh6k5TR7g2fkfzKpdqdRZq35xCmNSNjuvOrdZ1OwjhWE4Zm0OvkaEfEdB0Gei5Qjct8gxhcDMkU3Ow53fGYxRtE40MDCqVHHVMnHEm99nxcVSTkLLxaiNUm1VNkrVeYxJjjzJFygSSgxAkYGFmI6ohkE1emQFjtpvNOUrguX1mKONafsAddC1KUM5UJOAGvMxJPpXN3stnEg2HMcxsDHLMlRJ41MDIGMOYM3u/UvBvAKbztIx9eL72HLM40me9maDvkGp2sJLK3YSpGTfPLN9oHcuFzWA6Y0UVgzV3fY8hqxiz5ryDDwvvrAnaKGiaJON5xnAyI+0F8DGOxX9GzZ2kTYyo5ShzNheNRdTaLQZhDHOWa9eq+TDwYeg1UW2S1YKZbC8d1WZdau5FVh+RJDkMA++arhYgzJG+T2RAUwGI3bzOEiWN9xOGdZkLUdM60XBtrO8QbYqXd0CGvyO9dS/Mdf8dQAcxivYimLJZHdU7u6n9oU2mtGRm14Z61K3wDpqwyDT3vXI8YEIwGaQVgBVgvnNmuummWa3gzZ5Nr91oxnTLoG9pSzeKtgDkDCTiejFvGfLKnyIyIlTf4yCE1daVuTB2aXp915cjMs4V8xKAR0bNnNomkcqGEU24qn4Z2eZm/epsXj4m8XcjhZtQy2z1znfGjzrjXlXe/j9zLGoICqNsDLD874BMrzE7ZWdUWvMq6PhnlGMKdiT6kFxLYy4AJJMwbZpXgaFMUxZb/sWJDCZjGgnEhHFH2kJZnND9ObdzxdHh5rFwJoLLnCiSYC4gwEIBx3lpzEDLoLdMAKvJn4EHBkhvTqxjHsy6bGzF7KfUD6BE4lJH+BhOOjJh4t7MpT3aUGfqR4BGRckJLu2lAL4qJqsXdKU3D2cYn4oxivOo+x6j9u/wvB4SWndYwaOqmaZJMoiPahoVwIc7gSe4xiFqPHoUwceQYKFyZX5niY4V/Zo0J4iDj1aDEss1YJ7FS8fHlRlYN1NJNZIWWABcIszNtl3H2NYWX+tM+zGI6d1o5lejhG1GeAa+LnUEONKnuq7qVBORq0ftXJDrm7Vzrr6Z8uzWaEI1qW+mTK821h/nYw4X2Bphl9ieReF17+0TauLm5pkaaCJq9gDRso5L8kh/8X3pvoMtMGv/PwMo8g6ns8wtbekoaAtAzkSKjExksOcWF6rXwagNMaa+UpfHj51rJE1QfiL6hbTAxxe7gxaoRoLV21RbSfnG4sK1HK7vbkahDrT/h/PctsEup5kx72zspUD9jihSmTAz92EDIKMl1guJzbIU7BJSyz0xYUKDgzmz5ucqviLmmG4NlSZl5EUSB2EHPZLDYcki0U9ricg0HlOtSArgI/azxxw1wMSZlQhSwrVu9pCpONlHU7Q4T1HzmF1qwqPCHoP5d+h4umlXAEAMBUQUQqp2wHPFqGg/JJs9F6DEAjBiAkNA6zXpLtfj2r4bfS0HVfPgoLlZgdjI6IZ3NzqZi38HMOwxFnuMYU+iW1kkrDTq75X4Y1TMuWsklOEfOm3zhusAJAHEHhZ30JtyBq0acGGAxjlprs9VY6AL2MgCbBSElCHKFQhJAHIipBWDE6vjPEqEOe7UOekTNHQ0IS8ZtJC8Ii6EyGWh9ueWw7O5kYzeYYBIt636PctgxvfOvrkDQqi+vrSrsyYHgYJdU60J9v4EIOI5qRCAQbPOAM0exyJzIbuXWDR7kNlJzG7y6fV21rgoAJxoD3v92tKWtnRo2gKQM5Eisw5MFr+4MBKjRBPi8qmle3Bpbqv9AJoNJW4GB7VRN5jolIy4UVi9FvK1CNhrJqhnghL6v0kCE8HWBGhZ+2xsDqINQMWPHWKT8Wez4VoaM7AmYVDUwbt6Jp5rzUwJYrhdu0g1GYCDDtcmmNS4Mrljr5uhzj8wLQhUkp2UCU1YH5NQvHlBnosjVD0FCD1GxBid3thSYeLdz2Ct85UZmYIZVhhbj2Y1lG9iVMLwIjZFAWoK8kgnxtRfiX0SEbGXT8aptXPW6rA+cNDoBN+J1ucqmpZFkODmLDoursWx2wOT1tWINL/J+1WDj6gFKRpMNblaKfg4yRhOqoP5mF3b5loCA7emabBIVjmrto1BPTGyc5IswIMInBJ4OYgplPmOrElNFS0XSCgjkY4/ld+RDMA6CAlcsuYXidnTSQEMpRFpQRImmqm8ezO+VOZbVJIWkvsv5QVAC0lAmLMtfOG5cHguzfPc6JdxI0FK3f4afEwAwcz1vf3B19+ZfcPW3omWXU1THdS0wi2EdYFMYIOJ+W4EJtV6m8v41mHfrW7q76/WUbK1hibPf05YttUUbGlLp0ZHCkCuvPJKPPKRj5QFfkunRAeBjyqLLMriN7sGthtAMMtwBo9Qb/SRSYngpnJ6riut/T4K59jz9Si5BeKOhqIJaMei163AaFWbR+yGbjpV37yupr9zFMaZ2zrn2hY5QGNUNPkZJcAS8tkmHqXytYmbAgouxwEUv48cyhpzs0FS/d220ST/bBLuEXlFmtshYdwnrHeBvGORY1C0NYGhdj+idlw74+tztfntTDuEh42rk2vyDEgvGGNMSEhwR25ro5XtWpXAqPo49hh354AINAQmndXGPyMwRIGh13fBokXRGrX2w3KaaPJuN88yDUiSSHUZOpYRxDZMX9vmSR9i3xrGt9V6WKb6FnwsTppzOVf9a/N6OOB1cymevhYpdKZl6AcCBkJeJgmdC4CI1D8nAyttdNQ+VCFTqZyr1pKmvur+VAMXA6kjSz6TxbSfdi+TtLm8zzI28nzNl0q0HwOxvJ6q/RCGfPN+OGvGFJ8BUEzVInFzLVDND79Hr3EhT7y9x2CHIZ4VzjTtr7SecahTWylPhVKxHXG99Rc81GHtS/WYVMKARvPngoywh8V2R82nRw/jmWdjzdq0f2xpS1ua0JECkEc96lG4613viu/6ru/C93zP9+ArvuIrjrK62zbFBbdl6tqFz6RD3FyXw75d8/zNP801DVPnp3UjMaazBzba8qpNJfNk4bd6KqdQ1P2OffMNM25aCjjadkRJutfXaWt/46uPcXOskuorr8QqSY+gMQ8EXiRAzbAm9et1UUJftZunz6G0u1wvRVH53UqJaXqfgdLEAHFWKaLMmDUItGBnXtXey8Pmuh118lOVxqsam4YxiiAijpX/TmXMycZRc9qsQRgSwGtyMyFJXBeyYwOem2JSL3PdJkglrONCuTiRV5oDLdps1smejV2roX2j/wOPBCwgoVsVgIjmSc7nRWkEM2om2090jjW0yUSrkvRyB3zsFfDhuT1awGGJAdvIU5O2MuaA7+S6+HOQF5h3B3FGHzOYmyhlEXQYAGr9QUxT0lJK7m8CQMG0gWt9XiO661gFPhbUCFk0ipvmAEmDVJ4zgTMhqf/HxNyqwwR3qQNCqtM2z2xCtut/uMbLq0+XKirQUk76+tre2KztXlZnfZvWbe2Vlzyu6RPQ3K71sY0EsK63VZv8vQw3DBp2udGwVk0NZrG3GjoKILQFVls6IjpSAHL/+98f73vf+/Dyl78cL3/5y/GQhzwET33qU3HJJZfgTne601FWfaunuQ3Az0efAAprRJQIESozEE4hzG4rJfPKNjXK2kMVsxi/48ZXhZqsNg6uNpFu/2wzCtoQd0xGASGzttN2rmIsO+OEDYAJmF/Q55iFsAnLXl8qdafmZXJHdMvW6xoFMxGKzLdH0+JqfEudUhkTiTQ5Hvc+TjtJrMxwuN5MlaigGDGRScJIEcOjIjFJFBkwY0SIGMXNd6wiPmOE8wpmMpVyLReIDaE9Tx9HsP9vjqaSWLAwG5X2I4RbrTRL1oxEk7ngGedHCu8RapMRLy++b1wzTZD3DyB3wheTJ67M7ayBBrAORQe8wxPQERkzhjueDyvx+Rj2sjqXC/iwOQGgBh4zIMRNnE6FeTPfKHveC0LmBFoOcg4AmxMPqDCTOYuJ1TiWNgxDqXsOhFi+Ev2/ND5oQAJAIUKl15m8T9U7DvCCMSgAkchoVDPEh2AUD/Jpa00IywWo371N19s9+r7auhqFPHGN7kWLmmjbNnYKEMPRaeeqcMi2R2RtXjAfrARXTd9Nc+EmwHFfAnnUO9Z3bRxQmz42bd0k8KnoVoZTtrSlM4F6MrbTRu9973vxrne9C89+9rNx7rnn4p3vfCee/exn44ILLsAll1yCP/iDP8BNyWB5m6dW0tMwEX5Zh/lnjyYDt+32CEYL0kzTKslrovtU4QuDLW27uTj4MPMbs8mPi39oN6kNeWSCShnkbY7UZicux6ftkRPNz1Z6jdK2CGgm/UI9xj3qmhk1F0ymd+hvHtSEw1T9AYTEjN5cffSZ2XNrgKg49JKG3S0fZ7wtqo/PqcJAOvjIwoSltWS4Hk5a0jn5LML/w774j9jGvhEUVsyA1a9fSTQA4w6J8/uOSJKROvdFELIgTZoIjDti/jIuqTCyOibVs/Z3pB6v/jO0PnH97ul7UrQHwOIEY3FCcmSklYWw1c8aHt6W9H0UMzeI0/c+kPYl8lTaD8dUkxI/k3ez9elo3uGNTGG8z/1WuJYWG5lJ1DpLdnKNUgjTkeQAAQAASURBVIUx+7zp18HTkLuRTEuk1/gcXyRk9Q2R6G36oTq5oAPwMctnvS5hfgG5V+9nezca00RWjUr0cZkdh9DeVrhiAAQDewJKjte0a3iPgY5ztZn7XQ046j1iFmjEqhjTfSW0o3e9VxnbGN/J2NYJkEeZZ9nWCy7rUdPXSeCHDeS+Hr7+MEAivMg7wHgMWB8H1mfJGgFYpDd2s825tX4T+OitKbc0Fb+X0/vZ0paOgo4UgADAgx/8YPzsz/4sPvnJT+KKK67AYx/7WOSc8Ru/8Rt41KMehbvf/e74sR/7MXzgAx846qbcashsU91GFYdcEOI5WxhziHm+ANZnEVZnA+NxYH1MFmheABMn6FjfDBPTbr4TBm1DW+MGNsmCm6ZAJPZvVooYNumKEY7Xx7ZPOhQ+VT87oTg7TIAdd5+TxLUQOLZXmV8HIUN43m3XCTCJrTu9xjHz66gGKxGAWD9G+xTpdhmrpo8aenXYz8JcKxARxpk1MR2XhHXqU9Ab78hc+SFlej0UrZqvjAo+/D0IzzVq3GLOkLyQeZwX5OE1Jd+IaWYKyPayLGKRAfLopxDaWM+hAkSg7feQtXsCRAw4uDakAQ1Jx1W0Nfa/aSAEyAwnGMNJYDgpwEQACwp4ieDGtD+r6YfWdf2TvsS5WXV87h3Ud8E1D3kCLEj9QfzjzukBhLhfE+vzIPH/sDluwFz9LKrnEn07tGwXZLHWEzUi6vPBi0G0I+mAbS9od/zdT1pOI6ypItE584zpAsNNtu6qjPjO1p/2+fTAfdRUlGM2HrEJ0+fZrtGbmM1J+0vXSt97ICq8Kw7GDUw7ALBO2PjZ+lXvhXFdy7pu5iD4ciEN6XqwFIHG6mzC6naE/duLkIM4AHozlTRNWRR6zNBEcNV5LrcY8Wn+bGlLR0RHDkCMFosFHve4x+HNb34zPvnJT+KVr3wlHvSgB+FTn/oUXv7yl+MBD3gAvuZrvgavec1r8NnPfvbmataZSz1JV2SeGrDQbmyucQgbXF6qtFhNW6LGwiTuc34RdT0c6kAlPU0u6Q3MZcvsaP+cOQ4ak9r2P0jvY10HSHYPs4lGaVzv+p52pBcNpWWyBRTICSKRghbtAyotkI/DgKljZgPOHHgMAYgokyjHQ3Qf+6hzr5MxfDkXSWHDCErdBlgAWkvOh8WJEYsTmoBunzU0axhDi7kfxmROw2RjX4Ug1T7mBWBZieO4VWNs41YxPprtfEANKhbF1IaqMSfkHcJ4LMlnNwlgsSSMqZRZPeswb8zRfFixay+GVQ3IKq2Q9X0MIME0HJZ7Q53AFycUiOxZ1nFGigBn1ZRhmpQ9YDghwCWCIc+DEO3ouR6TakwR1w8u2g/z/4lgYoMPCEWAYvdFsnmqEbDyIoEXqYosNQFD/g6x/y7lpeo6/1dD/WJIpawMCdMLlCAREWQYoDZyTW8AtrG7FdNNGmQriQlWHO/w7WNv381nomk4DEPogGT+4una1uwfnWti+V3hkglE7FPNpfLO+HwMQKRldivNuO5VeakCiiCkMEHDuNT3PUR6rIBQknvGXbm/3T+rNct89eYEYeGeWW3vlra0pQPpZgMgkc4991z8p//0n/DOd74TL33pSzEMA5gZf/mXf4lnP/vZuOtd74qnP/3p+OhHP3pLNO/Mo8g4daQzUUJc3RbCRFI25kYYE5eiRkbeN9cCUkpYSSqLck9bkgP4WJkJTzBjqPoQJPittAyoGMvqs0kq0wNrXO7tapMCM3bgRtLWHRnKPM1MXZnAR+bOmdimslCeSfmybq62sRYmqZQr1yVhtBcBoAwt0xbHyhisIOWNzykwdpQZtJKs14sTayxOjBKadZVd+xHNhGIkqpbiRt/b9CuzqVOgaArozMqijJ/bhHtDyjXjkrDeVdOvXcK4k8KYo5p7MWStAa4IPixruJsxWf8SQnZ5GaNhxa79KDk2gkP4il2rslBNSDTxMpO4tA8FJgWsCIAJ16nWyrUhbv5Sj2E17g5Og7lVTxMI+GTnIRUgbMU0kaY8LC4gYGAhIXjzMoGXSTVRBgJNOKHfPTO52B7VmJA5mPe0JkCY8yGPibc/Bisw0GRjFMwaF1SAUgQMQfvBLI7OnAmS9NMWuzAP4xqB8H9v7fA+w4VAm7Th1tfqcPCz6AoI4hrWe9Rh7ewJxXiuHyj3tVpBhPcqhs/193oo7/K4Wz7rYyTmVRoufNwRcJEXch9FsL8HLG6Qz7CSMselvpe9se4AtGqM2v2gc88tQm3bTtdnS1s6ArpF8oC8733vw+tf/3r82q/9Gv7pn/4JzIzzzjsP3/md34l//ud/xu/8zu/gl37pl/CmN70JV155Jb7u677ulmjmLUfhpa+ktj0m236msGij3JMXBRwMe7Ih5QWq8JF2P8cbUZfTMwGYaFw8bn5zb2h7z4G96tNhKC76c+fiocBEunNlbPupbhxtv7nmg6R/XIXhrfKvtJs0/DJvazbGSx3CS54MdeDUSE2e28MGODKWDFhCarE5sOhOYZ5EZ20ABI3OZRmn4/Xmp2ORvFS7w0mk93kg0MCgQcPjKsPtwCvMI38mIShClZ+mmW9zAQ3iOIqzMBcgMgqDQQuAVoGhoWLCYcwK63gTsUQraudYAK/iGMvF/MqAhPlYWRcU6HDsZyUFLg7odp8FJ7ADQ8cHwbVfScY+AqQUc8VQuc6eU++dmzCa4X0uIZ6VqW5Dv7aM/kTTSfVxZliEKl4k8M4CeWeQz9K0ePB5Y/PNcnXMhpO2cymAj6gRjODHtY2mQVQgFE29gmkVg8WJfND2qDAmPtOiwaUqCzozITcakK7moLemtV0N69hG8NHeFp5dr05fE6t7DlNus9+glFeVE/vX1mEf1zSxPntLIGjjism76D/CGuECAl0v0pol4SSjaOhHnmZBH0OJDI1SWMLvTjvZtMXauKUtbenQdLMBkGuuuQa//uu/jte//vV497vfDWbGMAx45CMfiUsvvRSPfexjsVwuAQDXXnstfvqnfxqvfvWr8ZznPAd//ud/fnM184ygnmlPq4avQ1KiMHq2t+aS3C4v7JguwgAyWOytw+JeSdZbxsskXq35Uw98NItzVKfHvkSNROy7lxvKiP3cCDw2gZOD6BTuiSr4ysk0lJWSHhg02aBK3TlRxWC1fTRGRn4bRysdN0Bpuc0su7JrL6K5kUZwSoAPtvMCDfCotB5A2ZDV4ZagTMFAYE6Bz9TZlJJG/yHwCLGEGcslDkJCPyehkglT5qUFH63WqiEOwxlBLxNKSOTK/JAcvGcwEhO4ox2IjBLpuAzqSD6sNLJOYJbcr8c0H/oIvXvGMBmDYwBPx8H66uCCwzPSAqr3ScerhEgmbbshufgeotKk9UwRSx4Vu18vTjpxExXzpZaig3cAstEng4ehBh87yZn6EgkuahxSmJsZPCTRyhCJX4fVZ87qoR3+LjmQSgWcqJli5f/TONQTaLo2hrXYn0gqPgk0ZMU9BB5Joqi1a4SW11vTJu8BSr3GmJ+qEGWTc7qDkBmw0Fur7XdXY2lDGf73enLnen8f4O+qrYNkgozgDzIR5OjYJotYp5o+08q61oXlvTGfsQp82ftDto5sQGEb1q1bkroA9zSUuaUtHQUdKQBZr9f43//7f+P1r389rrzySqxWKzAz7nOf++CpT30qnvrUp+KCCy6Y3HfOOefgf/7P/4k//MM/xHve856jbOKZSQ0T30ot5xYEMl4mSpOsjKEs3HkojNcEfFQFwjckJiA10XasCuKaYWuBh0lie+Aj9nki3e5tzp2Nv/vb+t1cP2ECTvPGIRuk+H6klDEQIy1zMWMzc6oAECdtxfQZM0EksG4GV/olPgdUM7N6U1ozeAGkFSGtM7Bm0ZKgfWZUGERjjAFE6TdR3UjjL5mSOlKTmPmoFqRs5JiCDS+kP47VXDDmxM03Sk6ICqxVA1Y24zoTcowOhvIOsBTG0WdHtRGk0eTMhp1Ni2HgIwItd2yHahpDnypJuXwqZsyeXc8XK/hz+dhQo9GI72WFdtAwyqicd71tkzHk/v9z1xxEpo1YDODdYRZ8eNEO5sS0i0ZWsGgLUgIGLmGW2whZVmevzaTmVinVAAWYmIz2+12+iYFMVOcAWYgGZBwT8jrJu2GBGri+vyr2oPWoWk8bbWdvnQx1dNeUcG277E7qtXua8iqANHefgQYFEl0wZvM74Fe20MxWUArl6WEHZiyKKleAQUJ1V778uiBFk9xNOONAOkOAx5a2dGukIwUgd73rXXHNNdeAmXH22WfjO77jO3DppZce2qTqggsuwIc+9KGjbOKtkqKUt1LH67cxPb5BBI1FcWZGxcRW+QoIoIQJczMxIWiYGoR9u2xYNF2kG96oCz5m+u1E03Z0TQ3s8njtHHPRbuJer0pkw4bLvbaGDV2Eq4zFkDEsRow7jLxDDiCoKX9aaShcd1RjGMUfp7SFRlIToE6/s0ZbGgDeAxIx0krE9dwmmEMBIRNTmwyRfgPikGwmZsQCONS0IY2ErNJG1nHwYQ2Adk57MUsMz1fhSf5gwRS4NtEI95R5q/2yMXQwh8LEcGFMCIUpJ9K+ETxvijuOr1nvM7MuVOCjNntheLjqAZJXxWzfdXwMmFj+E5PqVgDRisuBW4Mx5tLudjw82lDIP+O+LoQSdrYCbIHbzLEOrp3JTePSmmKp83pphICPfGyBbNqPYM5U+Y5Ak3h64IUEpjx9PVNyP5FWi1HV2x6bIQrzxZ6dm9DNzE/JYG9+REA+xlgMowMQrJP731RrxiEZX1/v4/oc3qXD0KzgpQNauD3elqUXtaZbPW1IpTmyfyfR2Jr1oGmn5e0oQQnKe9LTSPk+lqSATBKNsPV3jHXYGHMor+SgYsP73f3jTNF+ADhwD73RZW5pS0dARwpAPv3pT+Pf//t/j0svvRTf/u3fjtvd7nandP8rX/nKL86IWI30yveZZjGvJFAGPtzeG754R8loG9oxRpSKDDxrgqbJwt7ZxFrb4p4TX7XR9Bj9U1k4G2lc2RAbphmdjS0yF4XvO1ADZL+JuYpq021zODakjGFgrJcsUVwWKBJ3ap5Ht6/FTK44VxcG1Z5fVr+FCSjLqgUZEgYiYF8mQtLBiePFmUXLoUCDQeo8mwv4gI5BzsJQaYADAx+mCeHESERu2s2Am1JMxmkTs2PzxuqwyE/K2FIMwTtMgY3dW6KJUTGPin452h4L6SvPGSV3h71DZOMKd0avoslVZUeGHA3AkGR6YkVE/u6aeUgejCOSm5MOVCWdBybzHYiMWSgjWd4D+fBgTtHJJdLmPA/ou6Q+EpU5Vi/qlYEPc/6OICX6fAyq+dgt4IMXqRr/SV9svM1xPJardXPQfgCQkL9t+3q/M0BJAaSVZUMWiiCGZ68vB8PzJQEgkmuCwbsjlktByJwJMBMsA5w9pjvWNfc+xHXfn28vpV+gQ4OcAGSbm6pzzL4XER+6+GrseECJjpjrvazdZ8ziD2u4dtm1QG6SRWWt1jJ8P4vj7MCibk8EdmjPeb8P17ctbWlLh6cjBSBXX3017nvf+97o+x/4wAeextbcyqhZTFtpC8VzzWZW+VygmKtUxeuG2pq0AFDnYqo2wwp8tItxADwTqVQDcqpPZxOY9D8eOmBzNhDSpbgpIYAtFCYtYg2/TXkrxhTczLWdmMAZGJkwurMGAgNKFTPb708DPCzmvZpymUmTg8dFs9nGcTdJXpa2IROIxVyKm3Gp7B+kM2CkKfOZxTabmZHGDB4JvM9Ig/ChTGL+QDHogM2xAzbs1vzKwav2x8LcAkCCzNUx8J9WxsSPqgo7rdqPxjRMlEjFXn8YLToYYVATIBtLoyoEcAQfDWNtzHyd64GcqeMwP6ytlIGsM9OtwwJzVfUvRGSSbwED8f2zqFtYs4DWDAEj6i9Eaw5Rn6CgUUHpCEy0HwF8sGkjHLRqw5KaOy0L+JCobta+sMhEBrCdJ8yw3CKkkbQcfCyGAn4AyQNi7QPU8TzMbbJ3iAoTG0zACKh9V3Q+cbsAETwZ5rhLyDsMWmb3/8o5KfiAM90HCVs2rnOTiw8AAXFRaxa4uXq6a6jtP7pe2pz1feggatZ7B3rJxhW+BkcQQpmj7MPvNQBmgRgmfiHclKN9bSPtdcO5e1u4/D6ob2cIbX1AtnRroiMFIDcFfHwx02RTOEUJi5tgAGoWohJUlb6lkZEhZkBzTDVpFJDUOC5O7H2pbFjRQbACSnNAY25hmzAeG8qYu2/TmMVNGKLRsL2ZcLjNP0ox7cNhw2Mm5JywHhnjOgHK7LX9F4Agka287sDQepK9ASV6WarHXyS45O3yDTSLE2aGFJzdQTNB+MMMWktDpH5WxiBy8sJ8clYA1jInDJlXa0aijAUlB0/WIDecae22Q/tNouplhnHtMWx+rUe9KUCnaCeaENDN3I3mFkCZuzZelGXM06ow/MX3hBpQU/uVHPjO2ntDBojr9lVAwssXEGBgodaqUGVWVhgs0UrJ/2pmtc7FdG9UXyQFNZLfRRj88q6bNgSgpBzjaOHVNvVRGP0SancAL0vo2pI3Jns9rkVq/KOc2pw1Cj4q8GPnmEsGdAUc0VSM1Qm9JEAs81TcROjgtcCfgWoml2KSyEzi/7FKwLpoPqr7Ng1dDxw0AELAR20e2i8MleZksgb38EbUjEY7Sltv1Cy1BSHe7ma/qPrQaZtrVMK7Wmk/XZVqBROYAphv8n9USxhDzDeZwaOAxVbz6f5ZzfHpwDS/uRzaMupb2tKp0S0ShndLm6nnY2HqbmNSjTHxtT6XhdYW60wcMjyzZ0ZGgkQZGahI9gNT5oJCiwbUSFWiD8pEIKgbULyvcr7c2PHme2ZsKq1MM04H3e/nO8zALAhpr2+J5QY3TwiUFYjEpHOWRE2YZumQPA+4RDZHc6sFNPQnKol9u2Hbl0eTgTphcgEwHiEmk0hz1SyKsphpiXlVSEBXjVvDuDlDIloQi4gli0q9k2fjNFLD8zQMSzXWPSbGAUmYm0RIybQXKEkxLQJOsOf3YqztLRjSbpTxkv8FqMWxMPDRgI74aW9x7Vv47QyWjEpPcxMZo3ZeRm2Og1V3qlZQYXWMCjAy+zOP/RJgo5OKOYRGhTz7BVWmd5WJFYdEhYAfb8PcGrBwkLjOBSQSxNfDcg4NRRPlCQKHBOQMjmAigoukGjubqwMJAFnU+UkcXHlizxKdDgTQYK81VQtDqTeMDRsTDPBCAlDkTFivBvB+wrDGVPgQbyecGvN60HqE0l7/v72/uVaED42W19dF1p9U3e9CCztk17eBFdq6A8Cuyuv0q3LlMW2uzk8yaQGV66LG2AUSo+TLWexpGHMT8CzUz+im0gyIu0XI1sfTXeaWtnQEdJAF+m2ePvaxj4kN9iE+f/Znf+b3veAFLzjw+quvvvrGNywyZPq7DZfpzqrG/DijAZeQioOk2CiDJWcBsTK0O5BQhIPmRIhJ7JpkgwZ6ovlIjte17TTmz5IdHgRAGoZwk+Rxk2S8uxHMSbKckWcvq/KrmaMZgBifmTlpJ1JfglxHwSFjAENiuErqj7CZLsmzAOehfgYugQ/zwKWAwZynAJrifJwHyWng0t+Y+Tc6EQepP4ewpaw2/8QARgEhacVI+xmLExmLkxmLPU2WZ3kyQjSroqmpn2nFhDdjbMy0OYF7Qr8Ve4bltOYA9Mozcf+PngMrxevC/I7MaTsNiPoMadNuAwKIfXQbeC7zIOQv6PlbOcgIfiYFoFi/qH5/nCnkwvRbAsoxI60z0v4a6aR8aDUKKNDkg5VfGJGbU00czucyo5uZWyIPEV3Aj9a/0jbsj0h7a6Q9SXbpCS9VQMKaJR3LhURVsHC7ESyZaZWafPFSnN7HYwvk4wvk3YUcj+ucJe2056T9zUPSdyZJpK6lASnU84HKWiwARBqTs2g+aU3dABGnTO2aFNo7e/1GEF+/Z1WYXq7ftwJmm3fKNIFN92KyQU9Sau99fP+t+vAuFn83ydXhn51igtrTeFTr5S6wPgtY3Q7YvwNhdTspw5KAVj6RPXBv/WjWJet39b5HAHVLEx/RZ0tbOgL6oteAHDt2DA972MNmz3/qU5/CRz7yERw7dgwPetCDJucvvPBCXHTRRd17zzrrrBvfsEbCNpEQN+CgWg9Vuu5q5YXyBCp5ZNKFfFkj0MpvgwF3yozRpaIEK7QzMjyV43tgvsq1bYObNtwU6gC36rt3yyZTkp60sen73H2JhBmhxGqnXKIulcpVjqjjJXb/4flpWT2znmrMGS5BdBM84duQIaZ0mfUmBlx9tpKoWMIYNM5CGfBcC3PjZFJ9EHhkJFMhIGOhs6tlUtyPopnTk6g6kUlxxl2zr6tDtT8fm286x2OSP3HsLqFxY7btSioepLlViF4bf1Yn8DmQa2AqmEDG9kdmLgKv6v22FxXlK/p05YF9ID2PSNMOsu/MEwZyQlky2vuzP8isygeLRBsR7qkk6DEylgGFLGNMYImkNpo/SglVQABolcFryfUB92sh5OWARAQeMmgci7am1zY1/crLQb+T+9RYFDgf8wyXhJOBmaStCeCzBfX2DD3y2Q6AJWOxEB8QFzw0gLIVbswJO2Z9QVqmcMPadhizr9ZsqrrP2mz/tuvqATTpdwT8jOLLhgBCUig+AgCPGlfPadMa+y1ajgleACBZ8A9re/vazICP2NeJ5v2A+7e0pS1tpi96AHKXu9wFb3vb22bPf9d3fRc+8pGP4LGPfSzueMc7Ts5feumleMELXnCELVTqMezG1BjzZoyKmXJkkQhb5CX7HlYA38AYx8AYBmBRmfaQsQWor40UNpgi4arNt2rnWL0t+AS05cTf8ZrWBKWSFG/aFHtAoj0fmeSGGa7GoW1HQ0wSsjURY9B8IKMCvnFJGHeFQa/Akg2xmuIksTTpm671cICBD6B27LSuDwj+wwYktR2ZJOP2WDOp/r+CEMu/YAwDcVaGwfwDxPme1NwPxOKQPqi538DIxqzGZx/aWTqEivmojrkkXw6nLOFw84K8vCqik+Ukibk/YhjqZmwZ4V2ydyKOh7fNIqIZYFSzOmuzMyzhPpR3lsJ1bn4Xkgs6w+MARBrIWq8xy65BSWpSEoBoNVbOSCmA8QMtRxwAZxwjwwkpFR8zd/LW8znrRKNiFsWm4cs+Hg56AohiIg3bq0BEEw7yziAJLimBd5KYka0SaCVAxNrsfiD+WyTleZlEA0wkYCfB5zrDnls9BsziI5WRAItKZr42YZ5BTVlFs8ignRGLxQgqXa/mcqVhbed39QzCdfFwVQZ318jSic46dgjqrr8cujzh3qd1RGFW1U/7P55X0IEoFND5HtfZuL9YIIpKUAPb86RQyhocLQPDScawL9eIBqXTR6rrmxu7yfHYn1uYJiacp6nMLW3pKOiLHoBsouuuuw6//du/DQD47u/+7luuIc2i6FLOcIxSYDjV/CqtAV4xkkVQ2pFQkRaTfthXpm3oS3cq85RmcfZrrc6G2XGzK7vWGCgro/1uy9ywKVdtiZua/bbvXh1t2e3YbgIhzT0TZ+G2L3pzSoz1QsLwjrvAuJIdNzLREzIfB68s9Cn2rdeH3hhyCUaQlTuS9icsdGMf1sr8BUbVmeexDCxZIeoLIsymMIjG/IMgJjZDUm2EmD8g5C/hti9xPoXn6OZqxoB4+8I5i+AUTcjkIXhllcYlkrajivsfn6k/76nD74SxitSbOw6iOPSDAvMFNwuZC9FcO5lLeckXBarOid+Hjd8BnERGCbfccdo2yXQBnVQYZXX6Z62zGoyRQeMoAS2if0kAC9Jy66ACEiSZL0TI6kMCALRgpAWBhoy0UtCSoM7mWoaaCLKCD4k2BjcXpMxAlrnsIXbD/LDnmpCRKYESebLBqMEzUGuhoGlgDMQYWcB49S427+WsdqJpi5+P7/SGR9kCTLa6Ylmh7FlhSmyHHWoxT9Me18aHZQuMEna3974Ev7CoJXXz0mZttbDjlFHmdtAmmhmmNcAEcZQZ467malmQl2V+JNU+F/eAVhAUx6Vdi7e0pS0dmrYAZANdccUVuP7663H++efjkY985C3WjlYKBOj6FxfLuLBHydMoUXwyZDEfd0kSx3HD4Mwx2lrHJGpIs5FUwKHH5LefTr1F1c6T9sSY+9UGEbrf3QeagxMmko3hnNlF2nGZATW2MRfTNLkxERcJdkhSJ07ShMmO7vUUf4w4vvbcJwxK0zaOz0DnBCeRngOGDYUpG3PyPB4SRUhvTMIEUpbdt4TiVSY3MYhF8kyASJcXxdSFiIJDOGviPS5mNZ0x7kqE2ZhpFNttUsd9u8fDdXI1NkwMIGkuFH1Ac3PdbqeiSSi+TzroastfO6Bb1LKSLHLC7HX6kjQKlEl7o29HLKN9Ty2oRCmPQatw3hh1NVcz5/PiJxHapZqDNtdL1eQIOMwkKZqvMcRnhMQPh7PGPTNnYdN05CzRs8w8y0L3mjQ6mgBaoAM1nzITKgAenWqA4mCN6tUCI3dmT2U8KIKP9tWjULf1u3mGk5wYZL5UEgErJfH9yuMAHksI3p5jdiXgaJnazrGJv0YDZHxtaNrqpoW9NaNDk3Y1tBFoh3emut760tHqkh5n6NBTiczmZTZ+GiaMII/sB9d6prHUE30mx10q/pCABmQIS7C20Ye97fuGPXJWk3Vz01G040zo15Zuk7QFIBvoV3/1VwEAl1xyCRaL/lC95S1vwfve9z5cc801OOecc3DxxRfjKU95Cu5yl7uc9vZUGxDqRT6S29Tqok2szKXeyxp/3xmoHjAIZcV8CZXEi8tGEE0pjNm2+/1Y4/sxWbTDxtpqYiaRjDrAwDaNrtaiByQmdXc2zvYeTK+ZVGebpBbgMe6bTdEk9xWDM6B+Djl8ItiMfei1K/6jz9BBp/DkYh+91HCzy4S8EpMxHsj9JzwTmOWB8H5LaF4kYTAZCkLM7AkiPeY1kMwJt3mmVUMDyGolw6TmFmksDtRV/1Ff7+2DhjZW0FSNfe+5hTJt3ntiQYvqZPM6AA+LqGNS8J7DeuyrOea6mZi9G4Dbs3M4Rij5R2AYMJqn6NxKzBK9aZB3m7I653uQAxucMHAxclR0IHczKmHSGJAoWImcsYcx9qM8bTPJIzVxAiDaBmY1t7LGh5E3LYs/Px1n9d/IO4NoMMzxWzlppgRiIBkzq3lBkFm0csEEyxnLkYODPZd6qXlmppEyIBMAoJkhRkaPB0ho1yUjDVlDcBN4JH3ODegNw+8ag4Yhn/PJ6JlkdakF1I3QpbqmvfVUGc6mnFZj4WaMjalULQSCAxSgnhI+1mEfMh8P0vlmnzRKTqCkwTM895AHCVBz0V5kxgA+JktLb78JYCh+b2lLWzocbQHIDH3qU5/CH//xHwPYbH711re+tfp9+eWX4wUveAF+7ud+Dk996lNPW3u6drnt8SgxMgbKFvLGL6Nyrk3NYtrboMImEaXRLfiYJkPrdCYwm5Fh7PXPb4nmHs2mMb0W1Q4ytU+uQw9XZbWHqWxI8djkPv32zahtlErp0kpM34Y9C3kayiS5zrjjNEIS/GnmaguZ25PMGvDqglJ7FupI7ZJunQdZzfPyWszChN/ScKsd/4DK7n+GiGXzn8ynsHHPSler8eQ6is7kfPN8HWfXhZM6d7f3dzVI+r+NDS10zuQyxsVExPJvoA7/GSgygA481W+FsoKFGWZQ5h9VIIRZ6qGFgTKIBmgNmSspziENMhC1BDbOidR8SdApmw+QggDK4qwt/mUSKKE4YROipiCxMvFDUn8KVlOnXMCB94mqj88nM/tKqvXYGTDualjeRRlXZnKfH48uxwhzNYPTAA/dCxTtRwvGUK6pTM0srwuhAC3zvYnmcwkeoc5D8LLkAPEM6GGeTuZqu9bOMbOb1rzJAtW5pke9tap3X3xnZ6iYbTZVxLU2vv+pA0KCydrAMh9boM+thhGoBAsGgHMnqpkDUfMhmWmzCSf8cGedmIxHXFduSTqKdpwJ/drSbZK2AGSGfu3Xfg05Z3z5l385HvKQh0zOX3DBBfiJn/gJPP7xj8c973lPHD9+HO9+97vx4he/GFdeeSUuvfRSnHvuuXjMYx4zW8fe3h729vb89+c///nude2m1TKgrSahtzhaPoCycdYRmUwN3mMYnXFxSWJY9IPzZpUToWO7G7UAtXQv/kDNZBOKjXwsL27mDfDqldVKGavhCdG95ojjOACTDalHiRCi64gdsoWM9XwMxsRZnxIDozihc0IxLdDNmGJ9zmzDN8nJo7dnaP1L5VpnshckeeV2DZEqtshjKS+jBh6RY3YfhsBMhvqjLfckAlp1cf2/23ZbaF0L6RyvL571HYmk5TYIYxTL1/sn5neEoiVcACMINIS6DYBEO/VoktQDiA35u5MBgiXk04zkPG2zgxgdz6ztH40BVzOrFDQqnlhQTY7kmRvjHwqPzuAe0pYdYBKgGiC4hiYmmyQQ2DRna3smuTa5Ooh0ThXNh4KQBU21SixmjKKcCwBCfUGISRUl2h82EBDMCCHtpJHBxGLWhfI+ypijNhdUB2fXVingHJeSAR3LjJRyBUBce8nNR/vREyxNfM9mrqtIH28PKFTO6tW6i0rT0pPgT9bTmbrbd68syWF/iGtRsy679hMADHj4GsVlrfJgAKHOuBdxs18hrFvWzyYoAwCf6909a2Z/mYDJA0Dalra0pZq2AGSGzPxqTvvxrGc9a3LsoQ99KH7v934PT3ziE/HmN78ZP/iDP4hHP/rRnhSrpZe85CV44QtfODnuKutWmkH9BbKilkFX6WCMOuSxz+263HwHqZE5aRLV17eLfRW5pMlRUNUzWdxLXZM+2P8U2j8ZrHoM5ng/3+z05MbQuy01oKgGR/02Wf0SipfFLCYCOIYwXK0fjm3EukmmEeA16SZM5dlFEGJj1A5COM8V8JDJReF55QUw7hAoJ2fWkIM0O6E4DkemDyjJ3obk5QvwoJBvAfMak7jJ+29251EBbSgaowCmTNPh92cDfA3jE8alK11un6PO6azjVGnsIgBp8+C0RKieayvppaymYp63hKpzU22K9BsDkFnuy0tIrgnORcIPwKNPeTSwoEIxCmF4q7C2RD62JS+Q9jVoOX34TOti88sb3Ax2NAMzHxE1lzPwMe5a3g3LwYLqXZPnF+qL5docjaacqv2QnDbhOv1HIgWm4qulz8imvIETQony5n0giP+HOqATATmrNrHJgE7h+Xd9Bnrgonkv4prp1K6pbUGdcjeaDTXvQ9Fo9yd5G5ghlmuPqmqrvj9m2mevSAwrHQUN0RQuJa73GOtzMG+N7Zd3lFEJCBD2V1jfwvfcuPQo1nUGAJCJlu00lbmlLR0FbTCi+OKl9773vXjPe94DIsJ3fdd3ndK9RISXvvSlAIAPf/jD+Ju/+ZvZa3/8x38cn/vc5/zziU98QgvBZpDRgpLA7LfOvZHZcUdXIpF4auK2jZnKdUErDn9wm/w2MkgVvafXHmt72Hw9wZkxVs2nDcUY29Qdl7jJ53pBnvV1iW0Nm8mB0r/YjgiCmMCZRDoNYBgyWKNgVWFWh8Kk99rlzsorCSE5nBTTrWHfGHLU2qiG0fVmdsBKu+lKFm0NJ1olmLTnQ25bX0uJ5XfpgzKnBjwW5pgdOZrmeTVjWvV9rWZr6ssAKDBYEsadJKZjyqxGvwRrG8c+tPXMMHQ+Xsq0eA6RpeR6kOz05GZxRbuDKRmYapgk1+6YX0uIHjf7POMzjb4nNo/cKVwYbVoXQOIaADPDNGCSMQUf8bkukoPLqOGamjXqeLuTeoLnCokmVynpx8LmpgrAmsO5+H1Ep/xSxoQhDkDGNBye6HA/Y9iXhIel7yjXZrmfRuWG3VQru5OyOayjeY6+pi4g/h9LccRnFv8PWpP7eEX/pu5z7Yyn0SYG8ECmtwE/bXnF36hZJ6r1zNoextjP8fS6MD699bFoNjqfoK2wckT7yboOytpnHxPmTNZ4A5G6fqQ13BSsTbK7aezmxj6ClzOK5ubWTf1saUtHQFsNSIf+1//6XwCAhz/84fjSL/3SU77/vve9L8455xxce+21+NCHPoQHPvCB3et2d3exu7s7W45LaTqbEQM1gx/WVEazKLNdKxdJxCM5N2qWbXOulY2DphsWo2g9ohmMLuiVSpz1VlaeNG5MHeAy0ezMLXidDdTL6FwXz7umJu49M/XMMZJenPJqzsykcFr7KgAkgQEsUgYW7JJSHmQcPJO2VuqSS31WYrZVNCHGaGZ1NM5mmqJMGtlYNMzwLAMTGQEuTEBxwNVCzHekGqNwbmLCRIFxLxqQ1s9ojnky53xhHtRXwsIAK9Ndyir5N9KKRQBupm2E2oSmAh3hWRnDFdsXxyj2tzoWfgcGqKthqZgzdo2Hj4WDEqratom/Kb4oJAB3oT4HmeSBJpLIZMaUIwnoSCRMtWkDzLk+k5utCbBKheHX55LGkhsDCNqJpKZSOYEzg8es5VEt5jLzpZQcpCIlCbO7EMBass/bulBrXCSrOBdAZUDKpOfa55QZHJJVUmsOxqynauAa84NYf2tNZRm3vCABpbuM5WLEImWs14P4f2Rt6wEMXAsIesfiPsAI4bHDPeVAp/xOHXJyems09/J6w/hLe+pKIsCq1unm3qpPWr9X5+CbCki2d6A8RomohzIvmQBe2P9lgadRBDdp3axvYT2ozGp7fcfM+Q5tNQVb2tKp0RaANJRzxhve8AYANy33x3K5BACs1+ub1qAojdokdWmkVtUpAwTGM1po3kEW7vE4PGOsS1/H8u2+IWg2RpNMtov6GDaNZmOqHTipMMBT/q5m+nNzbNNYtKQbYc9npEftptQrz8zJ3LQpbvIZ4FEASGaSbOjLjHFHQAir+QlZpKFYdGOWZQ6TPIrgWEw94JGqeCEZzt1UJZpozfXhoDFrmR9jUP1+8m/RniRnQkVqrloU+wRAZMxdZPi9WDYmN5hemRQaKFoaSwyn5YEl2hATMCj4670Mxb+iecDWlk6benOly8D1wDNbnda3+Jtrsw8KIKedX21dgTkqkmSqPsRccrdovR4et9F7s2YqJ8qFPw9J/YiVqYfMaxoYPEpuDg+PSwaIFLhG7YQBHZsfrvEo3wKsUxOKuDH1at9hB3PBtyMDFh5a/DtyDZIrf7Oi3bMQw34JW9sJlHTO6nwnZX7zgjDuSG4f3s1YLkfVgEDuCw7oc9Seu0lMbGfabyyPMM985+m1ztjH+w6xltheMDkV5z8ADOU9kTlLU01K0xbvx1AHg+AEyRED1ZisWdaMw3A8PfDR24ft+BlEWxOsLd2aaAtAGnrLW96C//f//h+OHTuGb/3Wb71RZXz605/Gv/zLvwAA7n73u596AbbYRj4tHIvUAoJq8+gtHA2z7KrvxYbyrS1mDB8Zpo5DoLeBjUGsgUhRk+vGjrreKIWrNh4/Jv8wdRjZHrjoncfM+djv3qWRdw19qk0rCMjkvM5yyEjLDF7Cs9EDcAfkqm8IYxLHzzKkr0VKzqOEXM2ZnOlyU5wBohWxvnU3//IsHSzm+rmJKVXyqFnFWZ8aJtzmATmAcpOsDeM5GUs3OYOaWggYIWYHH6OZPxnIMiZFxa3yHBScKAPuoW6Z4OrA8Pwm82MDmO8xXnNaD/NjKQxVGV+/zJjvZWG8K2YvMkIb3okyptGki0skKpX2Q80vnekeCmNecr40pE7qANxsLOckirFo+kXihwKr13wuWv+MivGH/180clH7EdYL2NqgUcTMr6MN6+tO9Cz+d9zMVwBVks3quPVjOgzmfyPSdDUD3CWMxxm0O2I5iFo5WwSs1gE9lBOf66wfRlP3Rk1m/L8zT3rSfDsey660bz1GO36b5jcccz+3zvvQa3YBrfD9rtTPUwDSgBAz22rNuuy8gf24d8R9Y6K1R6ft7frQ7DHcfG9pS1s6HG0BSENmfvXYxz4Wd7zjHW9UGa94xSvAzLjjHe/YjaB1EE0W/vg7MkzNdVGt3S6a0TmPB3iI1GFPw4COhTGe2KBDy3bTnHKsjpEfmK1gXtKaAPjGQ7V0vKJm09mYxfmAjXmjY+Hp2jwUeFhEIxHIkiYiZAyLEeOCxdQkSJZjFmZiGU/JwcFTYMRw0x0mZdZHII+yidMCyAsJAwqggJDQV9uoKcyR1s5ayifQEACF2/ejmKvYM7bxc4l1AFBqVuT9a7oUGR9iM72SiFfJ+poC+FiKpDMGUWCXcKsJU6aS0HuUCEeeAK1XP6NEiQK65lZd7YhdYsx5O1/j7+hDFUCIhbSV/lHx6WjqreZuLDO82+L3oP4Lq3Hi1yH3cgEAIbs4MoMk1Bk8MljQdCFxieikIZp5JB9fJjjoSesMGkdgPQItoOG6TcVcs0VSVM3X+A6TvQeeyNF8kAZMEiqaWZb2GyjPN/qQuGbOwDTggKlicK1dllR0B8hLxrAQ/48xJ4yjOKDHOddl7PW9n4CLBjTU41LOt/Mxgqru2tupZ67uSVvae6B7SAAhm7QF1JZNKGu/7Ulx39JCW611GyhF+srF5G0s9Q/7jOGk3JMX5M8yRm5s51YZy84YtOPe7F1nhKag2WtPW5lb2tIR0BaABDpx4gSuuOIKAJvNr973vvfh1a9+NZ797Gfj/ve/vx8/efIkXvGKV+BlL3sZAOC5z30udnZ2bnK7eptE3BCqjRry7UDEGD8FBayOxgCD1sCwJxt5CXeJCcBxyZ/V2WPso6TXwhxGCgt19DXogiUOZcYQkp2y/FDrSNzRrPjvZiM5tDnBYagDthYpYxgy1ur/4RK/sLnW5g/GdaKO9ML1uPIg/J2Bx7QWnx5ixmjmIq0TfzPe5l9iJk+0NqYOyIPY+rtNfsj+HZneOYYo9m3C5LQbvDHUbgJYfBRixKlJ3horIlluDOWQWPjQiYbQmhr4YDcZ1AJZNUOcmnmk791EGxEBd9t30+poIsU01mZlAEIwgqAhm5uLgbEs4xR9ZbI7n0sDqf4Git/FMnlkrMKUie8GTLMRwCaCGR6bc7nNAYLMnTUD66lTe78vyiyPGUhDNY8q5rQFH7medzwQSOLvzmtxDPgQlTkTAYiG47WFU7RDqN+Xag0jN8HKO4zlUAAIWwQsc0D3dbEBBFYmT5ng7nVojh1AE63B5ALUWsjQHttLZpdELtf6OxHayW17O/2ptB92bwNkGJgAE/cTcVNhLvlwtJ6Y6DMvCOOurI02Lm7WaWXPgQ9rSgPk2uvOCPCxpS3dymgLQAL99m//Nr7whS/g/PPPxyMf+cjZ61arFS677DJcdtllOP/883HRRRcBAD7wgQ/ghhtuAAA8/elPx4/92I+dnoYpM7TJ9KIlN8eyInQDZFbGdUlIYECjYCWwnqsdhk06VZlCNJtBlLRVjJhtMgj3oGw6DkQQyosbdjDfqtrTOD3XKnaohK6YMhWGA85cIxyrLjpFKhLc5gSTRMPRnx4JK5pgsYb2pGk7igS9NKySqkM32GTPR2ycaQRG55DFX6ICIS2QVSY2aj+Qi38CUnEo5+B7YX0HF6lrfC4OHtr51I4bUDFKzmAac9nTRtj//qzLfJfkdOorM6q1EZcxLwys+tanUm/RSqD4vKRgstE2Q/1zSLU1zrg1JolptDGGS+4L+lFmVnNKnBL4sP8t0lWTZM9MJOuBJ4BIwMcyCcgkfW8JkrV+lOcfwypX4EOPmfbENBFpzAKAArNf1Rv9Q9rgBU10parJYc2rIojl/vUTf49oAubIlJRxDiBEfYMmpdoalCEheLX/2YJKLFneb9YM6GtSwEn1c+oBgk3MbmR4e11tyqEwp2a1G019E+AAXS82gRe2+sLpFog0/euuP+21sfkRgPacxwOwpzU5qHffRW3juKNBAjSRpWgIdS9s/KtmcdqtCVxsApw3pcwtbekIaAtAApn51SWXXILFYn5o7nGPe+BFL3oR3v72t+Pqq6/G3/3d32F/fx93vvOd8c3f/M14xjOegUc84hE3qS09cxU3sQI6J3VRDSCB1R66khyOsvmaE6XFtDdn8hZ8VFKp1lk8gqHIwNm1acpQTcoO9/vGcRD4iBtXZAwjCEENQrrSvtNFoV7/nYFRHdGXScNzDuqErpoEl1Jr+8pmHU0pwkTw52gMph5TswMyzYSWwRRAyAxjYOOeRq6CDTiZdJuBTKnMBVJGzXwqqAANaSN5Gw10tUxInMttokw/DhaJvPW7moDN9dq2PEj9ean8t/XBfUxkTF0bBbgmAQA8vC1DVkiXjAPmQO/mYhYieA1nzNxJXut0kzJLQun1aNjjRfD/mKMWfERGvHr3qA4aEE2prCiPMqVRpwggppL3gsoD4iFVIMZNkCrwADf/codzAxwZFfDgRYKH37UizDm9MbtqGVTyeiBannV2jY85oNdJTakBHyj/p9DOidO8Op6bhgdcciGFeZ4XEv0Ky4zFQhzQxzEB62CCdRBD2K5fzbX2/pfwx2U92LSeTcxx2zbMrYNU45RJ+QF8eBtQGPq4B5UM99Myqudke1R89jrnuJp7oSzb31J5LoCAaNIIj9CgHQ4+Qsjy+D51TcdaOgwTvmXUt7SlU6ItAAn0+7//+4e67k53uhOe97znHXFrDmCYO5tzu3FQ3HyUUU0EZOIS8cUk1EO8uf72iDxNtW3eAgC1diM41fYk4JXmJPwfqbW97vW9DUs5GSdn7PuXVH0O91VmETqOE9vgwBRyYA7BBM7JI2HFMjclQZzNV2Ht0KhC1qbKB4N133YGztCA+k3YWKIewupZVL47CnQYGBO5P8YmbVbJRSH3MzXMtTF0VSH1WEYyf5hkfi4DinS2N4wEZa5LwjLo/KCseQTW5Lk88qBAL5hReRQpIglSFhz6Y6I0M1sb9uFaAPYHIH1Po+YvWDHSfg0+eNFE9WrfvxawVfMrfGK/BwJzKlqWEDDA1hN3AFffDcn6Lm1InECc/d4qw729E9EHSJn+aS4VAUJYpKKJaSJf9SjWU2FNN82DhhEvWh93tPeLN73oKI7wFumrDaoQ2uF9YXimdfOLyjuEcYeRggM6a1CI7nPawKD2pOw+pg3DPrk2tLMcYp+z4atbbzQpLP2fuSeugxOw1Fljff1ursvlnYzXkvbDtLbmr+jRrcKe5mufvucZch8NCtosQiPq93tCc2sJwp7UXHMkgqzTQBGjnc4yt7Slo6AtALmVULtwHmh/GleiwNyzOeoxO9MyuTY4ycayKr+OwHhPGaGwYQQAEjUEPNduK6MX4Wp2k2AfE98EG0a/tbHeNH5TZqQGIXXdMqYYEBgN8j7WBcWNsCQ3QypmH5YsazL+KGPmkmDo5pwADCV2flpJE5L7bEg0oKiNigA1HneTHgtpyqzO6ABIdnMJrasNDKAjOutKe/V4x6yo9e2Jz8U+yW39xVzQGRIDPXZfh8GL7bC+FAaExWxDAUBhaIxxkUEXEKN1xTDE9hyDnXkVec7OQzQfw76AD0ukmDVB47hTEj96G+pqaopAraf90HnAnMAk/iDyjPQ5uHYCrs10zSdDwAJncS7PBaw4sEk1mLF5XOpXwGFTmO35J09iaQCmkujbc98grHBTwVUBHxMy0BRNr+KaFYFHrz0RxIWEoTFHiI2f+RXkY4zFcsRyyFiNCTknCb8bTIFcuNJ5qBMTqfb/TdfHy+dAVwQMM2XE3/G6LpjQdXBuPQTX103ut1MRRLTtIQY0rDaPMj9zs5+0wiuPNqZzVoKBsAAdADGiVmxL2/buWBywB51RJlqd8TwtZW5pS0dAWwByK6DJ5nUA+GgZcbetMMBgjCfCsXYz4Po6smPxusC0WbtKqNZOH8L9rRocsb2bxqDqKCaL40RjcpjyOsx++3vTvmXlVRuiXusmbix5ATy6k0pya1MJY+Sb+ttKlfmTJIgsieESkKOWQSX05gtBxtzFYqhoCvIgEbv8mY4BIDEwIOtzSzVjrpqPvJA6s4MezDKTkSGamPG1fXZGF5U2Jdu8tmuad6QwrSi+Gu4joZrAgZAWaTLv3OdJ+zEqWOsFaHAQrwe874Cbe6V9RloJJ8yacG/cKRGvgPBexrFqxq8wsxy0IaVPVj/UdYNDhsyehgLOZNskZM/uHhl31rHiAJQwVjqsAmSGQTRIixTABdVMfGgLm9jb88Zox2O/9fmVSG1Zw+/W41V8PFCZYxVTIAUfC0l8WDOWCkaCJkoAbwEqNsc8/O4ukI9J/g8AWI0D8iqBVoQ0UpnT8TNHYd5O1qO5tc/WeUA0HpXAhVwL4mu3nwt1NTS3n/iYpLC3RDDSXCdlcXm+oSxb7ywUuJ+2MbD9SBvEBPV1o8pvMI6VgZAYqEPqYi+7ij6n60c0G41tiHMg/DzUeG1pS1s6HG0ByBlME3MfoGLq5iRX1aKYwq0NU+H272t2k2jPrDzU5bbSphhmt21XLaktx8omEX63/W0X/rJ/VDRnhiD3TreL2Y1i0wbSkYBx7/xMWUSMRIwhZT9fRXhiYyA0lCkYlfmIgakm8pR1hrIEDkjIyJQqW+i0lmc5rGzjlrKLb4CVLcxlXkD8AUYSqSGhMIqZQSuL4JSRBw0lHEx40qA+F0ORVuaBxHwpPEufLu1Ycfn0pL6chZl3U68A1ibAL+ROEal5Fu0Dh7EHJDzvKhd/CGM4AZD6kVgY4UoDgnrsakSlbTKm2ST2DM8Mb+CDHXxweSTNO12ZvFmfzIk+hE6uogDFcdHxiCZZMNMljbZW+iaarSJBtjmgQMV8l9oodzZHVVNGO8nNs+I1BUyya9fMmT0vxDHeHfHtttjXfUbaz6BVVqf+DOQs5lcxGWFYDN38K2g+XEhhvilGjZkgWNjXItSQe8YdwvoYMB5jQMPv7q8H7O0twXsJwz5V/gZza09kertAfMP1/h3nRgNCyhj0GejJu9irtwEP8duATcXAowYoBBbhS9tcB8lU4jGYMCvrdTZ+Widne/+prF/2Dbj/h0cfU8FIm/Olep6253T2o8kYNn3cNFa3FNEB/bixZW5pS0dBWwByhtJBNqbOqFFzbZTgUNh84upP5SNx+2Whz0tg3JWoIb7gZpHYW96QTeCj8tPogI82ulUBG2Q8Tr0pWLPt2ijtqsaqGawbuxFQvTlVZc2U2ZXwx99zq7dJrrXTnLlijkp7gjZBHS4rsKmMdcpZGGVjpBepzA/dtEe736R+ylTmRXn2lAnIJALrtT3DwrxbXWyMt7VxIRoepMJo0xIYQUVa2g5jfK4GzjQTujER1bjqXDVAlSH1VQCEC/NPY5GcGwMetToePtbMjBYkfLH6RERmNoInG1MM8OtrZjJE5FFG3xMO7pBLcq3c4i/Qea/Med+YPjNFsuhbqhGgseljbEtw0gYYhAQa2mh18iA4a/tGgucDsQfXvgOJPHJejhoMK7Yx5XTwtM5FE5ZkruZFGJvQ12R5YVYKJFvwsc5VssVSGRV/k17ULe/DdP1wyb2WE/vOC4msNB4jjMcYtJToV/vrBVZ7C9BeKtHOGlAxp8WdaJ471APm8VxvvzAgiZnzYaneaFLlh2fWwAJ0G1BjwEB9x6r1HbL2VIAbavpn6wDKvkMMQMc0q6bOTTJVK0oZ4H3C4gbGsBJBCDRnECdZY7td2DC2bR+7tzfAbEtb2tLhaAtAbi00BzTiJXpsshDOLbAMTfwmP/NAWB8H8m59zpyrZ9tkDExgliqTKzcVmZYjqvDGuTlIpaq29jbp9rpe3zFz/lQlO5vK2nBdUk2IqfyNEarN15RJUqasqiYk1/IqjLkAxNZfd3ay5zAyKEuYGJPccmLk1smXCDyw5A8ZARqTgsQsq0OGb/xVm4KDLBSspMxAoiKFROmvP/bemOmzFUazSPZb357I1NNI7mPvZTh44Yr571Fsv4F0ds7XPoX57PkFucSc9B0JbZxoPwgTE5IIltJaozuZOVV4r2KAiNL/Aqzkkx1wOMVs6KYdgDB1yAGgOsglcAbGHWmgJaR0h3Et30KeMgF5J9WZ3G3cOkEhiEnXFPJ+CvArIYgrjZZqPoa9rI78GvVqVPBhgCtnIPq7tOBDzaiqtmT2/qLRblmfTUtloZ0BFA3IcWA8njEsRQOyWg3gfdF+pLVy3p31rq6oXic3XrOpmLgGAweuiaYRKFqKBoSg354IdA7U6lgZDt7Ygb0BkQpgx/szVJhSovNFzZ4XbxqOBTzIxpCAxQmZN+AiTOv1w+ryeitAvrmf3oYzDXQcAkzdqDK3tKUjoC0AOUPpQLVnlCpXjCl8AZ2VmhmgoBoUEMcdCGUxi/UoM1uyJZf62s2r0pjkesG3PujetHmN27RR9ySzzb0bf8dyDmjDoa63XT1cn4ixGEbwIiMvB+QFQiQh6DiwO15Gm4nK2ZbDb30OLq21c8YMZyCx+h0MCTxossmhSCNLOXBGiwcFSsp0SkQaZeTt2VmIzCbMpphKsUovU3Ea5QCiZsbWgMNgoWrH9hphGA1k8CgT3CSf0STJHMPB0DwmKFzPWJjnSeQ0AwlD8c/IQSJvbbW++j2RadZ8H6UtdgPVwAPWbnY/kWE/T/05qDwLACXnh/kAad4Wyb+BwvgbCGjAB+IzC+CDFY8wEdLw/7P378G2ZVV9OP4Zc639Oo977qOfNN20iAlG6kdViCJSmFT5NSaxE0QEy1hFQFQSyzLRQlFDAIWvaFBLUkaN4CNW+UAEQimFZUjUaKMYDSryMDZNC9+WR3O77z2v/Vhrzfn7Y44x55hzzbXPud235bTuUbXP3mc95pqvNef4jCcAY2I/Al4TyuGLY4JISvxZ0mADMn/ic0QzJAAkOLrrSFTCFFtx4LcwS+vBR8Ohd/VcFFOunGR906el7coJ3o9lqumRvDd2ZHzSVuIBd+x8PgXaLQc36zCeNCBysCr8bpKLQubFGoAR51TZhGqQTri06J8nv/lm7SdS1FRK/RHxhK57IhQq1Ee0IkGTKou+mAYrICJXBKEVr0PRR5HnndK0E09t/Zxc85abT8UHZVWmeH0C4hwKF2f3nQIobmhDG0ppA0Aey5RLqzQYkEOBmUGyoGqnV7FZr5bA6BDomnivbKb5M7QkPalSLgHje8Lz9fUkDAj1c5CojTv6jsTCe/lASuTQZzLzukk9woYcqzm4n+QbVV6m9Dk3piKL6agFTWzIyOudvilkW45RgXxbSwkaJWOzl+DxvY4SkBIk0PBtTyXlMTGaNjELYWsZhNgRAxoJvWsBIp8zpu/Yi8T+P7QBLIWkdK6FOiJeG8yKNHiQNinn5cAqMYMaow1FZpXalOG3NXlfD+kLgjctY+CWRmFKGeoQIWtgnkWADaXJiP4Kwiz3cmY4hHDH4qheraz3b2BNBtQ4Fv27Qp4c5d+h88oYl74zoSzymgEZsxCeOQIAy/OxWvmBI+tA7ESfmE5VsZ/yPCbp/JBzMUmk5E0pMYYCMquVRbWwMMsORrKrWxvbZTnpoSRfJErmPloXsqSLc7vOgRLCDGdMv/gCOZU0lODnRzcC2hmh27KotlqM6w6dI3SdBx+mi3OiBD56zHBgXoe513BPYR4WJfBZUYE5R2ZSx+tIACFOH4+X9couPXPNXpAIj0KINEpBiEOqUZS9zEEBEFl4+TILUINEQ1wt/Rrik+0iOM331si8WfmxU4CJ3vp/VmgDhDb0GKENADmDJOYxfbOXeD5ejKKEJlcph/syiZWrPMNBbLc8OnKoFwoMCEDQm4IsvDnYUbwTACXVotSGHunircvT7er5jYR7BxhDl9/vkDMAyfOvhQYY6Pwc8f5K1mdF7jg01bjqUI07dFPnzQLqaNoSJNyySYrvgW6jBmOaYZG+kPwUjhl1YTT0PADKx5hJtJUHR2R9GNcACDq5iTKmNgUfOjxuKLoDjMqdEaqgIkXpTN7ShlCIaHXIA6LwaAsY1jSZjh2UW+cBCPlIRb5u8hzW5MD6RNjWczdhLinNh/dpQH9+y7AohkrGJJhetbEuIVysAQMgn8cEEoCAtTY6mlUPfLHdek/LKXUS5jv4VqWLRGA4A3PH804nI8zfbcS+IedBnXYeT8LU6oADfGt4PAmwi8+PyeooNc3U/cnaFq8ZSv1bEvAhgCRn3qUfyKMpnXvEVRF89QQ4QsocVM9FVwHtlNBuAd22xdakQV1ZNKsRbGNglPN5ad3RvgI5CBnwTojMeUYlhrnnhK7qkIAQ9azeGjlQ56G6ufx/1W8B1MjYEoIwwvFCaStK83yIFk3mjdpQRNMRNCRsHmoyDbszQFszgCSKJpkl8OTiWjSoyVgHWDTI2tCGNnRNtAEgjzEqbmIFxh3ob3JQC3jQZIiNc+2i86RI8ZgpDc+VDcYoxkKK1xoV/UxVXy11123JtSapxCxukkBkcvPNbi34yPsh+32i2UNW3yLwcXHThWyEHaHtDJwj1MZiNG6xGjl0YxMyYCeJ4lhSr58bJJQkzCYiM5hE01IcRAACzHRn4CWpuuAXQ3C1QwcAbIbjE+0BpvHH0Ar34MuRvB+pFis3xcn6SCI+dfG4hMiV+riKoBMieuaKQ+8GJsajAQ9cYrsks3dkaCKnQI7LVpoCbfYyKNF04XE9qW7i86HCxJpGa2MYZFVSV/+QoJlSJk1wbB4nplU5wODxkbr7G7Pv0DiKzteqja7yYWjFbEqHDg71lW+eWwEASNsNO47nfi05mJF1ovDehbJUH0cHe5cAn9D3BkDroumV1n6ojOqhbzissCP1nktQB+lHqPUlY+Dl3XJE6EaEdovQbjvQzGs/rAOapgJWBqYhb4L1SJnRsI6mGrpT3VrSpMRpGEBIkU5T77weGeDURZH8kLXHZrfxeyEAtgdCCs9OhGiIQEQAhjMISUb9eRe0UrlAZ7Bd2X6xru/PGvAI6/x1LnNDG3o0yJx8yYb+2mlgwSs6wuoP0gUoMIc5QLERZATBNpuedBNewEfs4FdFhjLfZORZRqR+shloYMQMSEgkVSNEXnIhQkmhjvJRNvHh2TkDo5iYteAj6zfHzEreh6W25k6Ted/2QJMluM6g6Sq0zJ1VlfUOk+w0GZhjAXWBGSTkc0D3B3WKObMumKeET2sV8yr3YbBPBFRaNjvpxuA8B4R2YtBNGDCNfA6LmKwNIU+C9KeYcHVjEz+jVOIcmAY1V0J/SkSkkYnPqyNYS8ZZGPcKbDrl6+lBCPX8QnS7S0xFNDlkZ/Y8c7IeYzXmwQQs5PzwJktBqyFMtTims8kV5X4iwRfCM9Ph2Rbe0Zo/1HQwqxbUdP7TcjQofgcTvwiO8GVr3592XMHyuNiRGscQICFrb2g39wURbGU4dDNF5lGVEcpSZep3pbcmhedJlCwkyQadAhdxrBh4lCJfVcT5Vgx6ZlkKuAcgD66j1vRC5qh/h1zl34l2C2i3LepJC2Ms2q5C21SglYp+pdfA60GnBB8JPZznP5zn5I/Va2pWn6Dd4uAmpvXCDbPyyTqrlUO1dKiW/phZ8fkGQUOvNRmp71oEL0nQBgY+lL27vTX/JBpYj3WZ16xVfzTIPUqfa6SPfOQjeMMb3oBv+IZvwFOf+lTUdQ0iwmte85rBe171qlexqe/w50Mf+tDg/R/84AfxtV/7tbj11lsxnU7x2Z/92XjpS1+KK1eurK3r/fffj2/8xm/E7bffjslkgjvuuAMveclLcP/99197wzd0TbTRgJxVIqQqbOpvavlGvk51HCRS+nreDCy5KDUv5ACRArTwKUiChbHNnMsTyWcJOCFdwBMzjNyRMDAu6caWbwA6stEQ+CiSdE7opIHLCgCo9wz9bItohsW5QJxxgdEUvw5RQ+jkfoBigBQjpOsyaFomwMZ5BktrTtIJk3UBeWbSwAU/AC3NrsCCxNAPmYO2gM2akvj7ZH27yKpIT0irEnOKIDDFfg706xuZ2oxhlLkTzLqQMKjieyF1B0miNGaaBCy08hyKzrAumxrK8V0zT2bF2g81XtLvlZP3i58lJkgCQJhBzv06JMRsOKYl/9IWwxHQRNOhaxvebQEhBnZCCgiruaAYxaRuou3iiFd2nPl/DAD4QaCn3hMqPJM6BQ6A0F7qfJ9AIl8VtD7OGB+eWerOSRP16y3zXYBxmEtiXibF2cjkNluEZsfBbXWYTFoYAjprYFeVz/3RRofp0tqTmzn1mOLT0rUyugr4nXjvurVt6NhAmfK8ZIkIY+7inuLYDIt9ORy5JKIiwOtCISqdBiNBw6KfIfXT9VYTITelKl6vzheB5VkAHmeMXv/61+P1r3/9w7r39ttvxx133FE8t7W1VTz+m7/5m/jyL/9yzOdz3Hjjjfi8z/s8fOhDH8IP/dAP4W1vexve/e534+abb+7d94EPfADPetaz8OCDD2Jvbw9PecpT8OEPfxg/+ZM/ibe85S343d/9XTz5yU9+WO3Y0Mm0ASBnlZxa7E6xwA3ZiIfFNgcrorXoPD9sK9eTvPftlBEW58Q/Q0mKxRyHJKSsbAZcFfmtmY8EwGgG3iGaROjNSG8+oa4OvY2df2vgoLUfCWXcSahv1h/r/D/0s33fEKw1aK2JyQjD8xRDBfTCkYpTszfJcUFLIRJtso5NorJiFUhzHO1nSDLXA6/c6GBOU7PZEw++j6yVtZ3HK/BWHBqzk+hBjoI2wc8vvtI679NhYv0Cg6uZ2gLpuaZNi3z0LfImUJIfQyImKWfjNCqUgDkPlEwr4Mjb83tHf/QYmAA+GpbeLqzXaijNBxCZYNcBaG10ftYRikK7MuDBvg7a7yEw3ZrxNgYhC3hloDUFAayIiRxrqMTXJQFzgDfPcaIhUJXj/hPtVDcmpSUtvxcJw6vBYdCAaTO76JQfwJtV/eIQgIfXBmV9oElFaUtAjIp+FU3qYrZuyWcS5gq/E7YitFNCswu0uw71VovpyKNUMb+ihkI+pUEBSGF9GgQfOcP8MKlv9poOVB7qukSlvSU5hrheih9KCBPO65YjeLNUkj6iABJI8nNI6G55p2VuBq1aWsF0HYiVSAQN+pqkY/z1Q346GoTk5pdpJYbXqc8EnRUTrBtuuAF33XUXvuALvgCf//mfjze+8Y14y1vecqp7v+7rvg6vetWrTv2sg4MDfPVXfzXm8zm+5Vu+BT/4gz+I0WiEy5cv49nPfjbuvvtuvPjFL8av/dqvJfd1XYfnPe95ePDBB/Hc5z4XP/dzP4etrS0cHR3hBS94Ad761rfiq7/6q/He974XxmyMhR4N2gCQs0infOHXLoyITL0DUimnhSTMTp4VM0jH49pGPIYzRWAQEidSIDjcBgmslKexjWLStW1wLwxlAThAlzHQJ0M0BD6K4S9dsgcVAUn5IekntRBxPUAj4Sm9I3d0gJZ2VJ0gNjYtEmasBagiBmmqDXKtfCuTriBl1uOj+xjMG4N8bhZicOq8psxV8HkTEPM4BCbSkE8tYSjYc0unWQBUeT7ZAw4GHxpQCgM4iiFwPWMbOyw3rdOAMJEuW0QfAokqxW2TvknBq2+XgYWFYWdZB4m6I88Lc8FG85Fq6SM1+VwVbPomvhLCMHdRH5HMs8w/oxc2N8nu7Tz4sBwpS8qrDBJNiDyDFLPN/iQOAvLiO62l/zKXgnZI3juj5ubIm+bZEbFpHVL/kdBONbd4/pCY3XT9cdSS8Wh66aC1PSGDehg4BnJEKfBS64nuZzHlCm0sSdV5jkq9vU8BodkmNLsOdrfF9tYSddVh2dTe/ErAhwJXJdCq51J67BrD756G9OIlj8tNo7J34FTFFoCTXhsTAQiJMCXuK/KuxX5Sa4nMAS7cqbGQd1a+gzkW7y1Wol5VsX4JM17qXt1mBSTC+pCt1b3bc4B9nRn/xzK9/OUvT/7/pV/6pUftWT/xEz+BBx54AJ/7uZ+LH/7hH0ZV+Ulw6dIl/MIv/AI++7M/G+94xzvwf/7P/8Hf//t/P9z31re+FR/4wAdw6dIl/MzP/EzQrmxvb+Nnf/Zn8du//dv40z/9U7z97W/Hc57znEet/n+baQPrzijlUqe10uDs2uT4KRZG0VqERFEtUK38Au+MT+Zkx2qBz5loF8vx35SeF8lnq5gQSTjXuMRO3+SmFwp8JH4XSR3i9X2JX/p/uf2RCckp799ByWbGUOlBM+RQk0VtrM/Hofw/IsMljAiUz4zkVyAVlYwG2x+0QAnjpa7VY5ElF9Q+LoEJIwTgaXX4Ui5LZxkPc0iZ9Gh/AFt7htWOKfiRxAaA/Ubkw9mmRxT9kUYIJj8CcGzVb5tPYKgHkJJrRLqvfWTCMfENSMbbxfFVjJORnCWSv0OyjQsTpk2G2G+Dmg5m2fgP+3AgRHey0dyqlXwXStthXQQfOvKTABjtJyHApkSUzafkHOJ7ZgRweB8g+bQz4/2DxnGsS75mPfPKzmuK6oVFPXeoF95sLfh6ONXXoj3S75Nygk/G1hgPPjjKlW539EfITQUpneMasJNyyGdQ3E4JzQ7Q7DqMtlfYGvs45cumhl1UMEvyDuiaKc4Z4JzypmhzIf09dLvUVQHNpOxrYIYTU7B19+bnh66Xd599/bz/mH/3u3G6n0iunSAPUf0ma6IuM6wjHGLXdH4u1UsvCJMcLsn6ktWt1E+JFuUUWLDkD/lINFXXjUpjeT0+Z5je+ta3AgBe+MIXBvAhdMcdd+D/+X/+HwDAr/zKrxTve/7zn4/d3d3k3O7uLp73vOcBAN785jc/KvXe0EYDcuZJb5w9bYcrXCviqAIo6W0eQmrhJesjH8EBbgx0U/+RkIim9WY4pi0w/sLA5oDJpZtcSZKdtzVlhtQx3Y58cdSgw3F7nCp3aGNRz8qvG7SbLi3KYeOMuTlCLhBjMRm1gOQCGafMfAjTypL3xKG30v0nZjq6jmxqYp33V0A/7HEPfFSul/nb9frVHyTVP2IyESIVuWi6FxhSk/alq1gL4sgHoHLGM+0dZcwuMygCYkxafwDMZACwMX+BsQoMtdH8yY5MnGuSNZv7MAx9Z9lnxgGV8U03kUkHELV0fFnI99EoMy++LylfaUCSSFXCYKMCyMJxQ0mDkIL/Q6w0M9Ui9VcaAGG4470AWJPUi3aVzY/w0+goQnKMmPkThhJlEKOI1Jj5PC2eWTSN9BcCyM7rIJqfkPW8Z3ZG0bQsARqn4B6hxlguV79Dmyv/ngbfj50W06lPPLhYjbBcjEGLCtWSvKN0rgEBTsXMAji9BoTUtWo9DGuA9Hm+/jsghOCV9TErV9bM5Fhyv64wknJyLaH2/7MKXADw7y6vRYZD5DpDIRlpWOsScBiDZLgK6IhgJv74+FCSl/K6yVyNs6rOpfX6JLCRjWFx/y315YYeEf3mb/4m3v/+9+Py5cu4ePEivuALvgAveMELcMstt/SubdsWf/RHfwQAeOYzn1ks75nPfCZ+/dd/He95z3uS47//+79/4n0/8RM/0btvQ9ePNgDkDNI6RzeXXxMW6vh/7rtRKjM4+UJtmE4YVGYQKh8Vq5v468Q5NzExcBEk5BLwUB9dcVUv4XG1FCpxxM43h8Dg8+9ChCy9OYtGITke+m/A7GFoQ3LpHl2yKSbhkaSeHcF2Bp0jGHKY1i2qWYt2e4Ru6hk501Bsg0v7NgFfLoarTbJlM7/pQ+7q+ri48+u2EYLpSS/yUdaG+ABmmKVtVhiFOE8i007h2hyEdFKeAwATGdE6Oq4H06vCHApOrWrj1xq2CAj8eR85yyAkIeyY+dd+BgCHAqXQlsQHReaZMlMKTu7i6A5Epl+0USpvRnJeGuQc0Hb+GiP969jnI39ZXSjDaVMjrfkAz3ET7yE2T/ImdSngpc77y/h+TrlLxy4lnqkV53PPAIoW1Gaa0N77rRjTkGhSxogzvjvjQSfZAYm1rGVZMIEerdP6qHcimB6KqeDIFMzxXHg3xPej3QHaHYdq1qI2Fqu2wnw5QndUo5obmCUxM60ACOL8iWUjrpvqeQ+LcqCwrnv0u1i4Z62ARi16Dum+U9qnYoLP7JkEWBmLKs4LayPwcK1fM40KVBHq72LZEmq3m/jK13PnNfb83jt+VWXuJNoJtbcU/UL0bwXIgoAtaSvW9vtngs6KD8gjof/1v/5X8v9b3vIWvOpVr8KP/diP4YUvfGFy7r777kPTeI3kE5/4xGJ5cvwv/uIvwrHVaoWPfvSjp7pPnjEaja69MRtaSxsAcsYpaAeARGKTCKuGNg5VhtPHZDFVzG2+4MNxeMRlLMd0MTRilPpyWRWlzCPiJuMyH5DcFlnzumFjyJibEvBIJGXcrjSvwzrx1jVQ0tknXAcE53x0gO0ITefVwrO6wXTaYL41RbPlTVmqJcVoPVDt1H0QGN9CdCBlMiIbf6hORREciDmEYvJ1mNSEyS/VQR6nmasQuYrSrNEaxOg2MONAPFiOHbzFcT3JKaEYhMADSX00w8XzIeTg6FzwV4imXpzRXUz+YP3tDiDFQbgQ/jcFUoHzUn2TSLkBaA0HlRzFSyTRrUKnCqelAEbubG7If+vnBv8GIGfCtQmS9KeYqVnWJoVQvHp94TGwMr6siSuBw9BPKByT/uJx8tozH4LYOyQb2M73ewALDJbET8hr9VibRc7/ttbn+OCx7oGPoDXlsdRJF40GmWkfRwdo7+vSbBNWuw52u8PWxGs/Vm2N1XwEWhgfMpb9P6DnRIrpkuO+b9K5EcC8uivXaETzWqXJkGetmWuJECYDBVJOfn/JF08LdLQAKr0RnulXzw7vrX63geCvYS04AAS8+W/jYlZ5nj8i/AIHi5Ds5/WC83xQnJuJj4jMQb2PFtbzoj9ZcoH61nuPPn+dtpuzSvv7+8n/k8kEk8nkupV/66234ru/+7vxnOc8B0984hMxm83w3ve+F695zWvwzne+E1/3dV+HS5cu4Z//838e7nnooYfC7wsXLhTLleP62qtXr8Jae6r7rLXY39/HpUuXHlkDN9SjDQA5y6T5TP6/Z0KhFs3EqRfxeK88AR+ZdE6cMG1NMI3DaO4ZlW6MyJDZtFLC+FiV4yM8nzcGkmuBNLxiXl/KNgG90MvGpiLn6E0l8KQKhJxKulgAO8lpDXDkOYWNRkBekNZZeA1Ia7BsajRdhVHVYTZucDS16KacH0NMSYIEXTHwQGAeoxbCRam6+GuQiX3pYvtFmh9sr2uWYAvzpRnJvI08P/L2Bka1NnDM/AY/lYw5kTmVSFiJbb5d5AKij0k2FlKcmkPJOIV+RsyWjfgMifQEgDOyC4/P4VK5TwNTWpnEryE8Rx6dM9vZ3Im5JeLYwTg424/GFJIh2tSEK9dqBOk/m1m52vQBSKiAAiL6GOfGgNaAtD7Aga3JwzEnAEatI6LV1OaAcj4HGaVXTb27epzQeZBGAJx1IF7UBITYmvycBjfFeJDuxCyLnBdqWL6A+yNNNBiBhKtMBMu1YR8iyS3jmfAkmSUD4hD5aseh2ubEg9Zguazh5jXqBScfFN+gnDE9AXT0mPeBtYtUX8saV7xfzqm9oEildyyZyOU6Jr59cCkfL+MMsMkg2EwScb8x8OaAsm7Je8YaEVcBpgJgCMY4QJu1dUBlwUlReS203qwPzqGZGbRTBlMtg2wdTEXN6Z6Qa6i/sv0pOMCXgBdO6PO/Lhqo2yMuEz48rqZXvvKV1xSt6iR6yUte0jv2RV/0RXjHO96B5z73uXjb296Gb/3Wb8Vdd93lQ44DWCwW4drxeFwsV0DSfD4Px67lvvzeDV0/2gCQM0gJwzawmaU3gDevkxfBXB2dl2ErAGN/0rSc26AlH6ZX2/hLWE8t3coBhPqW5+UOyiVVuGbioTf2vNk5cBFABLXZF+4d8usYAmtw3D71/xAQyRkuNAZNW2HZ1RhVHcZ1C0w62HHNieD8hhnCkIo5EaJU2imHdGLfBwEhIdRuon0QMwV2HhaH7rrAXGsuQjEvgeFXm2+i7QgAowBmBvo1SUCoI6cxaCJHfaWB9H/G2HlfFOX7ETQzDDwkRwX3iwH5XAPsqErGeYAs5kvKITmpt0K3CcCX+VYRXMdjopgdMgYOFuQiCPHcNHEUOvJRrboO8YEE1D5cWGRCRX1IcEb5eQyZHOUakIqTEErm8yTHCjjsMMEZl77XYqZH6L/Xyh+mZ1aUrSkxU7XrfTyYII8jJAw1+W/SwQ6A+FDrH0otVybXdkq/CHAPJp0UNYK1UWaDMg+9L4L0mWg/mh0Hu9NhNmlgjMWyGaFd1qClidpgFX63pBFIgMc65jCs49naVejbtUIWvW8g7gtJ9LvT0BBwUudKx0Vok2gX5V2xCJq0sK4qIBKDnPlGEKXrRQjfzMecAdotg3bLO7bDgv1BEPqz5Fu4tg0DNGhydRaAh9CjCEA+9rGP4dy5c+Hw9dR+rCMiwvd///fjbW97Gz784Q/jT//0T/HUpz4VADCdTsN1q9Uq+V9oufRmHLPZLBzL7yuR3Jffu6HrRxsAchaJorQl30x6lEvZ0AcBg4xysqH5YyL9A4EZXsUEixlGljFYyov28JrxUHVUUqiiJErqpRiXHvNJCggk/UXJMW+OVNCW6H41hXC0JcDH7YF3J1i74cRNkjyT1BKaVY1lV2FqDSpyMCOLbuwYEBAk67UT8EGON+JoMtKNfceRgw/3mm+qUl3uhsBsValfRWDUhuaUOk16fHgO+LnBJk0uMu+DwFf6ns0ovKkU+7NYmUOUjHECpNcwOj6jMjuetzbMX2m3MNTk4BnsCnBd/31IQIflfCCdMjdhZla/W+KoLaYgoe8cvLTdeubaGTYXEm2MSOtbjowFwMmLU1dwowquqjyzaC1AVTQrzDQbCZOd+41IzgvjGW6fgJCl/jxHDTvsVyvRmEHNF4KljGHVQgUFDIvA3cV3IYw5j5NpvWN5aEcYBwSwDfKgzVXkfQOApI0+z0RGDD7knfLjRApUqeztmZ8PGCjKutfOvPajOWdRbTeYjFpYa7BaVXCLCvWCYFbEcxkx+lVOFNeingYNBeZ4iEpYU5U5eJt+puMfAUhTLEdTEUSldT7JL0DndZLqO8sg15J/D5VAKwADfvfD+0XZGi5ra/DzQoisBSCOh/IHOVHYhIE9cl2fnKLMv2l07ty5BID8ddLf+Tt/BxcvXsSDDz6Ie+65JwAQbT710EMP4dZbb+3dK6ZX+tq9vT0YY2CtTUyzSvcZYz5j7f6bThsAclaJ4n6hj4XvksRRDpU2OMUwDGlRtH2/rRCSCYb6iIRUeHab3p9sVErSHSRRpv+cwH+4WKa+L7e1F6ARE2gpAJH3RUk4mDG3ITJM4b4hR/UoUUw348R0SiR2HcF2hFVbwY0JlbGoKuudKMd+k62WgCTm807SxHbTLiaLg99kie3kQgSqwEQo5pgAcZpONuChTVbfBwXWlKmErRDyjoAiw0UcelYzkkFKzjhJNBXEgEGcTsG3WWKmguePkzHI6pOPAXXs0yHO4ITEIV4nKYwg1UVTpFCW83VlybxpHCeojxVI5j6DQs8sO9iKUFkKAEjmVTDBMt5syo6MNwcCQJ2F4aR31FrPONfGAxAOhw3LpkcDwxbAB5BGhQIC+JDM5z50rgk5ZkzrfC6Zjp/PZdiKYGoBvH7RsBqkDzGn2fHg88HhdyVPSgAfYj7FkyBkIjcRVAmYhJrj2reml1PFGAYx0STRm65R1ABxIsaQC4Xg3z0eV3E8X+0SVucc3K6PfGWMxWI1QrsYgRZV1H6w70eiLdPT67RM6UmgIOtz3c+90xog5OOij52CYy6V07ttqM3ZniAaiwBEOgrrS6JB1aZTldej5BHptNmiaFNEIBE0dHl9pK4u+y42/ITzZ5SGrAUeaZlngcQJvG3bcOzOO+/EaDRC0zS49957iwDk3nvvBQB8zud8Tjg2Ho9xxx134L777sO9996LZzzjGYP3yTM2dP0p9yjY0BmmIWmOnMs1EukF/E0obxhrwEmU6kcmDQEguLDJ6DCvQTrN0YeIGdBgVhWu8Ru5aXzukWrFju4rzhPQxlwBadhfKoKPXHKuHdtDHyXfFK/P2u8y6Wzpd6+PdV+xH4jrDCyHgKmNxWjcwk6cz4lR6T52oU+jmYFLpYKjaGKkwWBgRsXURDPvpQ0kmweJpiMDLUGCrDUpyhQvCb3r/NhWjY/NXy8458NSxhNxLignUyrMwaHNNEjWJRRwqyJy6Uhs2T1FsjGymGlsiKQl+T2qlf/tj7uQRE9Aus9vYNCNGGBocCPz1YgGooIdG/5UsOMKbjKCnanPpIad1OgmlTfT4+vsmLUjowpuZGBHlQcswVeEJcXWFcAHZy6v1fjJ/OCQylVjYVY+oWK1tKjn1gOHVbSn730k8lMXTeHCp/H31gvny1r48sPaIV1UepfkXQ2RtyJwg/hABZ8C8v5IowpWAJyOylZ78NGNjfe7mnjfK8tBM1LtIXHSQaA5B7TnO4y3GozrFm1XYbUcwS0qVAsfvS6JepXNL5e/R4VziXAIGaDK+qN4OGP0SxqW/sPjp+e7su6eUp2y9aO0vsr9yZyRJJ4rp94teFO2Dv31IIB+5WvI6x85Fmw0ALUOet3Xa2CxffmeMXD+VHRGmPS/qfTpT38an/rUpwAAj3/848Pxuq5DcsG77767eK8cf/rTn54cl/+v9b4NXT/aAJCzSJppPGlhK2x8AOImUCLNpJcWZ7V5kEVIIJjYOofnEXIwE4CKjepwvwm4HgMTEhNKXoUVJ3hr1DOT5F4lkV+s00kMt472c6ooWUOMeakOUJudSOo6L+nreDBGpsO47uDGLiTXixJvZW7AIUsr/hgJjSw5M+roZK0l4Yn2wxTqfNpNVQFW2fglaZgkUozHla8FJ+jzjKfD6NiiXtg06Zyqh9Z09QIMaGZJ94tEsxLmhbOds3IoAQFBEq/AXDDlEdAn5lCdhVl1HngsLcyyD0gEEMtY2JrQTQwsJ+pzIxOAoCTKSxjiSn0ElExH6KY1fyp0s4q/a3RbI9iZBiUMRsb+Wa7KQI+J4CMmEOREcFKPfA7IXG25/csO1UJAiEXViDAhZyQFaESAWTFjKVqPaiGZ4juYVef72nKSRRmTDHDr3COSH8aJCZvyf3HslC8AJQAyceSvfGABOzKwEz9OrfRFreYgzy1XieM5YXXOwuw0mE58iM9VU6Nd1DALw0lUs7m5jjKgMXgZh04uJlbtXTv8nBwMJM8vrWG5hkCvebmJVAl0BL8+6gsk9NoJIBFm6X1Avfs90mA3B3yOwa/kD9FtWNNPQ330sKX91wJWHk3KBTnX6/MZph/+4R+Gcw57e3v4/M///OTcV37lVwIAfvZnfxad9qkD8NGPfhTvete7AADPfe5zi/f98i//Mg4ODpJzBwcHIQHhV33VV12/hmwooQ0AOYPUc+A+xQKQ36M3Li0BKjl8J5soM+aaUSHH2gplWysS8TTOPqL5jVq4Bp8pm0nQrOgNKQIXTaV8HjGDcnx2kuyw11ll8KEZgEHnzt49/XbFtpG3L+J8HEQOY9OhrnxG9J402gGQettoDmRWqaN1AB4CXhT4iKZBitEVpiBnhPINpsBQCYPhanYSlpwdI4TM5ZKUDkA0uVk4Zjx9/bVTaGBsQthMzYCqOaGlszZq1YTp9WDA+qhKhfEKfdh6jZr/WA8g5B4Z7875TOWtl9QbARtKK+K1LWpekkTbggchIy9pF02IdtwPJmpiOkLwzPHYoJsw4JhWXko/joDGS+yj1qSbVLAT/91NqoT5tsyAB/Ax9ZGBJAJaL3GgZtjUHKbQbqX9Eb8dMVNrI9hIspsvbQQkSza9Wvks8AI+IP3Pv00rz7I8VxQICQEYFNgy3L9VPBZznPgx9X1MwZegG/kkihKQIUb1Q3hWN+Kwu+cc7LkW09kKddWh6SqsljWwMCHrubzjQ4Kik9at9GTh//wdzARKPQ1KLs1XjH94h7P/S2AkZFcPYYvT9aOkvZFrQlQ+5X8mfmOuikKMdQErEtCT11H8lkTTEUBPNq8JcR3LGWgqXIvC9SfsXUNjtKGHR+9///vxTd/0TXj/+9+fHF8sFvi+7/s+/MAP/AAA4GUve1kvatW//tf/GjfccAM++MEP4tu+7dtCXpDLly/jX/7Lf4m2bfFP/+k/xdOe9rTkvuc+97l48pOfjMuXL+NFL3oRjo+PAQBHR0d40YtehMuXL+MpT3kKvuIrvuJRavWGNj4gZ5CuySEuYx7y+69JoiOMs1G5FJyDk4y1FiFbNcQ/pEO0KyZVN2LmQYouOa6HOro+SJLrMnOfVK3vwgOCL4Jui2YOehvJwxDryLNUM4t28XJKSeuc88kITeCsUBzH3qbpvH26jh4jDsO+QyUajjD1qaOtMF46eECuVXD83Ny5VByvYdhqxhEMnMdUNUGDV+qASsxvBDCJbwH7OjhEW/+kT/W80CA2GWvPfIh0XYMC3Qe+Dx0nsIgMi/c/iOZW1ClzIEke2AE+eYsDKoOQII/9JqyRqEMRXPg6cijbsUfmnkk3sX0yjhxu2bGvhpM+Uf4OYpLnnI9CB8d9Zx1QxaAEYb7wvabz7XWGos/HxHg/I4l8Je93+HYxZCrQWysigPNg2YJ9k5wyuWrYBE7CCkvuDtGANjb2eZ4bxXkQ4thU0TSsSSMTIyUBUXNUM3eaadGkLN2GoOUMAQkEjKt7Or7P+We1M8LqHNDsWYyU4/lyWcMec9LBFbzW9hRZz6917V23lvTeGflZ2iu0gCUXOvD9IaeHK1xD2W/H5en3a6gZGgwZStazIBSy2T06OIYux6jfXA9vEgi4yqEb87zmvCAhi3pBeDVkGnYq6f6QwCYHfWeABoVnj7DMa6W7774bz372s8P/h4eHAIDXvva1+JEf+ZFw/L3vfS9uv/12NE2DH//xH8eP//iP48Ybb8Qdd9wBAPjgBz8YgMGLX/xifOd3fmfvWefOncMv/dIv4a677sJ/+k//Cb/4i7+IO+64I9x755134qd/+qd791VVhTe/+c344i/+YrzlLW/Bu971LjzpSU/CPffcg6tXr+LixYt405veBKPDnm/outIGgJxFWregDTALg5dTZC5Peh45hEhMwQZ7RJ7BEOl7BXQcwc4nJES6iMtCz0xawlzqhZy/fSQk8s66igFOzKREIqb6oKd5kGJLm7jeKLLzg32TH9MbNWMdV3qWql/YBFVGcuuMjyTKDDIcgtQQYo6CDAx0FmTI812OgMoFgCeVckDMJq4AiLb7L7ZJ2uLK004YAQIiE2pcAjyIpeOimZAQqwCiKZLq12ieEY/r+omWLWrKXAAgOpqSB6DC2AuwAFvg8P+tN50iYYQ7q4CpYyCdttwzy9aPCSMNV3P0KkNIpMcCoIwHIVT78MdkWYDbRW6LOhm3FEhEv5UIEA2DIwEB4GkUzbji86muYJUPjB1x2OVg4heHW5vAxBDXAuK4otqRn/sjmBxJ/cQMrlVAMJk4otVyIfdHnBPZJLNgXxwL0xIACzv2nRwSIlYEqk0wf4uMIDOdpEGh1vwpwJuvGTyHnfGmV6tzhNWeA841mM1WqIzD8bJWYXeV74d2Pkecu6U1zj/PobhW6HuGKD9/wvVD4ENrWp0jfvfXgwnR9CXHkUX1QgzkIWtXWL91PVwqtEj6qLC2ytrjfa14jTgkVAt+9hhwNbwQTAChmAmrviqao2V0mv00uSbf2zaUUNM0uHz5cu/48fFxABQAgsnUnXfeiVe/+tV497vfjQ996EP48z//c6xWK9x00034Z//sn+Hrv/7r8WVf9mWDz/uSL/kS/OEf/iFe85rX4H/+z/+J973vfbjtttvwnOc8By9/+csHkw0+5SlPwZ/8yZ/ge7/3e/HOd74T73vf+3DjjTfi+c9/Pl7xilck/iYbuv60ASBnlSgyDPnCmWs6hhx15ZoS4y3Us82F5xOccZwRmgHJAjEbLUUmRke5CuWpzUP/r6OhiOQdBJ/pmDfEXFLVY5wzCVrYyARoZe3XddJ9qzfBpPg1GwqpOicgpHBdMAfjtlpLsIWLtSM3AdEpOrnIH686FzUcwdQKQSOiAUjI+SH22T3TtTgmawFYAcwFLQbbbWvNBLXRz0Ns9p26RxhvcQDOQafca2Q+siQ9+HKIKRebh4SqM9gwxnpwB/j/OwYfbUz4l7ZHJOsu/O8r40JeCGmDJDcMGdtJzQGeGLYGz1FCiFjG/eR4gvs+J0jSvQBC+L0SrU3FTtvknJcmd1CmLblZnYmmNqIJU874omHUWo0Y4IBAMo+y6FPSNklcKOtBCC7RaqBhlR8TAw7RtOTaDyGR2LIvjiFeOIxLsrAj5MExQGND3VMJfgQeAvS0cEVCLOv33/vxAKsdwuo80F5osbWzxGzcYNVWaFa1dzxfUoh61Vv79PuStC0FHj0N9dB7N8AM6whZab6aU3DPSTn69R5O2Fr0DSxdKu3k95z4Wp3zKX/Xk/VX9WXY7/TcFnNN9tsxHWtkpWx+fvQTYQ2+mI2JuXC+D5XaosakaK4o12T7qtbgf0ZJA7vrWeY10j/6R//IJw49JZ0/fx4vf/nLr/1Bij7v8z4Pv/iLv3jN991+++14wxve8IievaGHRxsActZpzYYklJvOFDcO9Z0ItfJreUMwbInSVQAmhHYKjI4dRke8AQb1eLaLZpIrLSkWQCX17dUzAyxFiZXrfxLgkfVL0m6KkruSBO4kLVECZArXluyFxRfEWoOOO80Q4DjngNYIkNyjMnonycaCRJxBiJNIP/H54pNQigQVJZYQ4XE8nnegy+7Lr3GxfVEroZ3MKcyDJP+CMM6VmjshqaAwIvK/+Fw45PNUgIwzFM17OguzdB5E5BL4LGO4Hi+RoMfCnfqO2gqteXBhTqkuYSAdzKmM1xZJ0sZQfBV9ExKNijDJrTi825AxnQCQoegbwWOt87sM5tfRTJ/0s5irBPATgxtoUyUJa2qUhiP2KY+NaDBay/lYCmBDgAgQwFfS3wK6O+s1WJy9nbTpofX+LcaBfUjiM6KJlQK6qv0CPoJ2LYRxZe3HHmF13mJ0boXt6QqVsWi6MdpVBVpxxvOOguYoRPIaYFh7jHZOQ2uNK59LI/KtBx8BoGSnAlg+DQ3Uo/+s/B5+V000CwUyMMKVcRqA6OhXXBYBcBYh5DEsMDr04+4mMZCAjr6o186wthbAR0n7Mtg3egzza88K8GB6NIDQWWrfhv5m0QaAnEUaeOEfjk1xIrUPBSFIW/XzkgXa+ihMwix0M1+Ad+iNTIHnBuBV8KXNWIGEnrQrN99CZI6p1A9SjoqWk6j0Kba1JGXU4ENrUU61KZ9yQ06ul+fYVANSGZtsxonJgON6dsxIa1Mb57y5gfE7u+MNnjqvrQKgmN9CnXMGySL4BsjvvA3JhqbAcGLPrc4HZ2BmAIShDcntAjNAsTyHELpXpPPa/CjR5inTGjsCiPtBfBn89eLfYSOjKJGTJFRx8nwX/AoCGHEOIT+F8qtxA3NL3qeetg1I31vK2xGvF5M2cfYGtz15l+QnM1YpCEEqOdbP1r4fKhqYI4QIUz4/howRRW1UE53PAzOf+3IEjYfq86QPFCgJJkIU+prY14zIgUz01XEujpWVUPyWfNwFDQTkGeI7xJHlcv48tIk1ad2Y0OwQGnY8P7e1xLjqsOoqrJT2IwkRm/kXAAXAp+aI8OU59XJ+nLS+5+tPzvyr6xKwJ/VxJy9h15wtnZ8dtAqQd4FN+gx5Dbf6aK1IApatBxy5MC1o3Njkt534XC2ijQtRFLXgRiVg1e9XAhhK4EM3Xe1b+lzP8uBa94YNbWhDADYA5OxStqH0zmXH1kl3tIZg7UKpmWLHUifnPINCQDclWGFeNBNZKFtHl9HAQ+cN0XUPzy9lOJbTiukNZk6FZ5eYQG0GcaLphHpe2IwHwFyREUlAFwGWvPRWA5DaRsf6QjlFEofpDjCwkTkDYFpC1xnV9miGNdgXXKbw3HIwB2S5hq3XdgYedsTMgjj2CuMomafzQAJyu/h3rKKzuDZfiZnAKTDYEnWnI5+4T7QFgVGWiEvO+ahJ8Myuqww7gPv7YQGntCXOppJ1AAHw6GhWAgwSDSC5CJzlo7UvSYQhBAYM6p4AujT4qArO+6LxyLJJFzUfUMfCe+t82FoGQ3YkoXojKKWOM727CAjCuIR3W9VX/FaGTC+SviI4du4M0cigxiI4v/t+sJVvmDfFMbCwIJJM2S6AEYKLzstigpUzoGICWgHtDGh2vOP5ZGeJ6dhH0Fk0NZoF+340BNNSlLJrcyEU1htZAwpUXJtOcV/xOgKCCZU6dhLlvh25GZYGREPRAvuFxrqHqUbw84wQ333WjJNoyMXHp+6PT2D+eYGytQMkB0jFmrwWqJbRXFKHAe75GmX7TgIoMuDh26mfr66FKqcEYj6TpAHT9SxzQxt6FGgDQM4wDTKlOQOXX1dYCCnuKcXygpQuAxGmRchcm4AOZS7V02LYdPHWIVZlE9CLPimml7KK9lT8uVRK1R/5RlLqgzWLacJQBPDmeIOOe806MKc3JidgqQO6zmDVVbAgjIwFjS3sBBEkBCYVwSa/9wyD6NDOzFYwJZHjZBDMnxDLTxxFNQOhNRbyraTowV5cMbfJ2EqfsTN3MMlhRtVyfYbGJkRAExAieT2CNJMiI0EKDNSAJe9f4SoD25kQytV1Fka0SKGzKtbYUQyTa2JbTGeB1oEEkVnb7xf4cSJHyRwZbNMgI676M7tPMxABfISQqHEM8iSQenyGAKPkbaERAdJ3RmmnakQNlsrHEcumyPQacfIXQGIBa1NNR2gYpYxsEHLwtQIgKngQSQ5kbDR5Uv0WzBUNAewbo99V32+xv+R9CuuL8lkT7Yc4nm/PlhgZi0VbY7EYwc1rVMH5PA1FvlZg4LLv0iWlsLynBR/yXQAha8P9qjmnTQf9owtrQ+H/XnlI+yLXMjhS6zuxDxELJAyDwBjtLH6Tg9eGJOMf22ZaAJa1pq3sKfF9KPlvlLVQa66T74H3tQc+zgIA2dCGHkO0ASBnkTRjrxdBpqKkxZ18TdE+VN+DjAlX0p4gYeJNJJfI5uZUOulgEhZR8ZUiGYNL9pZQmXwjWLuBSHmn2QhKe6rq5xysEbwpCOnnFSRpOQWTl47QrSrMVyO0E4NR1WE0adFOHdqpN++piACOmCRMle7jkh8ElHkSnPNWJwT4pNGG+e9ookNwKYAjwBkXpZPMEIipRtGnRTEYiZN4MItzwY9DmNl1G7dIPMUp2nQxtC7IwyZAnO6j1N+ydFtyDlDnokTdVnCdTez1yfiSYnI7o5hSB5CBAdtQWQcS8yCsYRYFoLKfju6f2Gkq9KtoTwqmh0XSGhNCBIuIcz33mRqSwga/rNpPcFv7G6IvjRoTviG868ZHAXPBLM33mQeLnfIDQQQUeVOg+tFKB4r2QhxbjJdwt4x1DDudq0YlppMSOc5RWCsDE1opnxYT+14qE8GHdzzf2V1ge9zAOvLv6WIEWhof9lWcz7OkqEXQl7wj6n3D8Nj0Bysdi572K+lUdc0pKDHp427TQoVEG1Lce9LnEKI/YNGkVnC8MOqGp4fza2oYztxRPS/HxTUwN+dNBFr6k92/lvQeU2h3sawzCD42PiAbeizRBoCcQRoEGEBc6EqMcLZxJdfJaTdwLRWu4eNaohoWaN74BWjkG3IATw49xjVUm7INUVX0tPa6vY0np6zeJRV873oFvEIRqh4Jc66YvuJC7by0rlsZLJsay67GyHSYThocbFuf9XpCqBcAWfL5HsgzAlDSaJE+k3HBP0JyGAC8wbcOFW/pfkw8hyFMWOIDAM2sAbaOuR4Afyzpe9W2fkZ7FVlJckIYYoZf9ZEwZYokuaA24YntciAPmzyjz20SpsOKXwcxYABAVvJwVNxPHd9rQSxqTUxCeAwtfP+jMv7ZIReO6ZuOZe9OwrA5BcDYhyfxw2BnbWOMf64yExLTKNFCpf4N8OZhDBRzJqhEOTPlAKACOp05fejdk3sqgpVwpy72AXG4XLIGjsMbw4CTDOqKU9R4yCNCMAi+Vpv/tPC7UocwXkndbATdoiGS9ciBYvSuLPeHXmNsBbRTYLULrC50GO8tcW62QGUs5ssJlosR3KJCvSB2Ps+ARwF8BG0AVJ9D1XOov3V/FOjEBIb5baV9Ifu/uHUk0zsz68rrotZap9Ug/F4RD2kOyIAISPz0djCIIMQRuxS62NeJGZQCHUm9BOCv6/cCDZ6/BjBR0qBsaEMbOh1tAMgZpWDuAvSdOjXTC/RBCBSTrJkltVegtHAq5kP7jUTGIT47RCnqmBnkMIlJsrtsRSYbgcdJTrNSxVCC3uwL/5fC9Ybyss1PU9H5UFddwJc2xSqADykrByEhQktLaFY1mq7CrG6wNVlhf7tDs12hnRJGx8zoSJ10pBsgMmlayqwYeidOwy1QOc514Xw+CokWIwycOOCCXPDPsDWhG3M7RTJ50uaq54toGhRzmEbrUde72KemBUd8SiNoARGESLJLA4CchVWhdGwl4Mwxw+ml+zSqUHUO6Dqgdd50zabMbgLmKUatgiF28CfOAG8i460ZItufA7l/QAAWztedWofKURgfjHUoXgTtDBzK5ogSSlYzZ4qjDFUZYE7XzvdkfHheidYkkWR4bVtI1MjZyWGc/2hQ4fiFqQSFUNQaAf7e/L0MczquOeGUgDStDYIHZkGbo0IVi3mZvJuOADsitNtsenW+wbntBaZ1i2Vb43g5QjMfwcyN13y0BaZXg46BdUfqSoUX51TainyNLpTfo5OKVeu87C299StcokBI4Tn5PHISoU3mjoAFh2BKpQUa1IlFqQvJNGUvELBnGtfbv5JqJH2d7VPXQhnQGrzMxTnZEza5wrHPBJXe++tR5oY29CjQBoCcQUqYF0R+LPgh8CIzKFkTJkL9m4AQteAmDHrOPCsQEqOY+IKodaiWXnpta4IbA90kmptQFysemHYNOnR5Uh9mkGXDz+vdkzqq8/08Fy5pT8n0bJAZK5FGRAPMQdHUQjbihtC13g8EALZGDUazBu3WCO2M0I0NTNOlUkbuD52tOiTe04/QjD5rRqrgOGx8hKywsbvgWAxEJrubEExH6DpCN/YDJlGfBvtD/2sQ8rmEbnUc+rQTptmFOP2Sz0Pnk/CaB2Z+xExH9QEp8x/hWLwWRyYw2BneJ6yztUHVeFkrWQt0MSfHunH0c1yZaomduoyl7TvWClAVUxHJ3yHjI7+lLSaxPYkgxI4YXFgCWpnHsbOdMHnhPaGMccxAUpgY6XfPvE6NadSU8RDkQgKbcmARKJAHGECYp9pxP17v//faisqDPjleeed0N6q82ZcKrRs+YsbDdQ6MoQQpyMGHkpA7A3QToNkG2r0O2ztLbI9XsI5wvBphMR+D5hXMUjme2zi2oe8Ka5Ew9IOvzCmAR1EjPESl8dX/h/EscJCO52XuL7HmGYQY3leDl0QL7QS8gH3gXBBOhAhXUqaeY5JssPLHqxVAHaFauXA+MQvOTa9UfbSGxre/3LRwv17b83ZnAG2wjA1taEPXTBsAcgaptLgmDtwaYGRMLxUW0bC2ZhtGADSnlADpnBPUxLCp3cTbU3cTBMf1oEbn55EBJxZDlFBq6WFwOCxI3giB4QsS5dKGK23mDSUwY9k1JwKPnLkOfZsmAMs34vAYvbHBb6TUAt2ywvFqhGZSoSaL8aTF8cz56GKsPSLrwoARM+h+PrgeqNLSdV8fYXIRmVznI2SJ1C6PZuSdkAnUGf54BrOzjhkCxcBllJgBCQPITIqAjGplA8Mq4TSDuRUQ2hbncSF3hvSj9QZiLuRwIJjKgx65zrHPe8wHQcE8K+QGkT5QTJMGZHLcjkzI1eGfLxo/Mc9Cknk+1FV9krDESVscTGv5XYzmWM7AO9g78tBEgJqWKncOpiPYziseLOK7URIo9MG6qo+qU/J/DmDkfhefEfx+uuh0HyJaaZDMwER8dBJiwCnXOWOA2vjAAmMDO+awwLoLtWahB4TLYZ/JMvgYE5ptQrPrYHa8JpLIYdHWOJpPYI9rVHNaq/0o9WHJZPSkBIFpKOO0rJPMtnrgec1alph45Yz1wBrWr6s804V3PWjSdV/IWi3/cu4VDUSSuaX6zNZAN+Xylx78VUvvg+M6xL1HO6dTfyySOkub17VPvx967itwsq5/zhII2fiAbOixRBsAchZJmPcQcjQez69LiNRamzEQYW1VPIBI64LdLvRGw/c5te84ByuRcNh5PJrz8PVsciSSbnm4FfAQmINYF7K8hzkE5ji0JzC3zGwPMMO9huZdtWazHvThGNj4gwaKrxny/YgMo99Eu5XBcjnCfDbCrG4wrlscTSxHZUrL9uZJWehTyJhpECSMvOziSuPkAOMcnDWKeXTBjIscfNJpAK7zye8AExh3nSDxRHvqLJM3HIW6VxzAQJLsJXkkCmZxwPCm5/1EHAwRKuORrR0JQ5TdxPPFOyvzodbCNNbXl/tJTJt0O8SJWQBYyEXA/iqOAYrMaREKSN3XRsASwGMJpnPsQxGl0T7kLF9uyCf4U31oGgtXEeQyssopfwiYMw2Cjwy06Hu1X5e8ozI3qfUJE6npQE0HtB3ERNCHPDZAXQXfjBDxCvDfmYO+PM+OvOZO8sj0NGJJG/le0X4wg6wFHD4CmDe9as557cfW1grjqkPTVThcTNDMR6AFh90t+X7kfajXDaeuU4BR92VJI5Y0Yx0I0ZQz1no50KBIXb/OzyR/dulccCbnZ4Q8H+Bh1ZHu1J4V834oEy2Vw0mEIqYhmJq1ICOwVpNgWqBesqmoo7BXSWW06VZoR7b3Ffsm619Zu0qaQz3/h/rqzDDpA21/xGVuaEOPAm0AyFmlDIQAWL8IkmIW8/OKoS8ulBRBSM6QhGc55uc6lvpWPi57vXQYH1k4Y9BN0ut1vWQTShKvySakstjm0i2AGYocfJSkW2rjp6GFeGCzlv9z/5ieORW8j0SQHGbXa62T+AiEZFkrg7apsGI/kHHdAbXl3AvEfeJCCNSQcRpIGDXHDwnj0tnIlDGDR+x0bmFAtovMn65nmE/eTApEPvmkYV9s4zvEwjPH4T55lABD1nxIWc6AHeeljoU29cJ9ZuNUYpZUskAnGgRmvHVW5CjFlMGgkDATnQM1nXch6ChhzGxl4GoKWo+QxEyYJPFV6RyDk4yLkXnO8zWx/8/fq6CViUw9EEPHSjAA47lHnxGak/wZArCyIOejRNkaXhMUQpDG98xJvdaQ9vsK1TVIxln7+oR3VQIOMABB2wESFYsoBR8mfXn72kS5B97xX3KT1F5gEaZ/gbFP1hfd9rAYMvjYAlbngOUFi5ozngMIplfe8ZzD7rYx5G7u25Qz/VEbJNdmdUSsR/i3oJXQ/Sx1D+Gz1RrXo3wN0jR0ny47vy5bR3PGnPgP9QuMc1A5/+cmWjDEfiFOacwdm1xxjo8GGO071HMXBBqhPAM15hHsJD5+uk90HfhcrhUMmoOsn4qarg1taEPXhTYA5DFAPalkzvCqjTbYIK/ZeBItgV6I9f0lKY9EPGJTrHbLM0DVymF8aGEXMWN0yEILKZdiGVZttmojEof2UFWj6uJcyHWRh7fUbSsCDwVkcu1OOJ4XlR3T/sCBWVRMWo8B0AAFCL4QtjVoOgMih3HVgcYWboRgKiIaDG3OkjzAgCMEgTdtBh9i0iTXd4CD9Y6cBdtz74tD/pyEnW0tDGtAgnSRgUsAjtLHfN5L61mCzwDB1mw+JL7IXIVgWue9T1VlXPoNqDrLWOeAxQGtgzEWjozX4qgIURISOJSV+cmY1sJ15POFcC4RMwbaURVMDcWUzLTxQ61NykxycdjIfNmRZ2LTOse6O0EGCrBIuY4nvROJLyRcLY+5BUxjAeul9NqsUTKji5AAVejCMItcXqecySTpy5RBNp13DK5WPt+KTxppQR2DDw6nG/w+KuNNqjT4HdQMUQAtrjboxiaAjx7jrjlhAR4m+87usSOg2SEsLzjgwgq7O3NM6xarrsJ8OUY7r4PjuWn7wMOXU6j3APi4VrMc7eBcJP1qaJ+gbOE5zSO1hlRCcwcNhkuv08A5X1tLzHgAINbF+afX3wBCAJ+g1QczMQ0nFORnmNahWnmfsTzhpggGcq1H2E/0tFVgJR7UFS60FVDrX9b+xwA9Vuq5oQ1tAMgZplxl7A9ikNnVm0XPGTKX2OlFWjYIsdTRDAmfD4s9b7Y+lKXf6OsF+azFWiqV+Xjo7MmJnbSNn97G7VIQoqMC9aRdA31U9PfIFuhed+b3ZJuukzrwpnXSeh82xo7gOoJzBEMOk7pFPerQTRzs2Dsgm8Z4hpiCb3PMsQAgmE5pKaswJGJPr01cmKvU5h8w8IDD8UWOTYFqA2etoBNfd4vACOYbvw/bC4DIS+pFLEoOXeUv1AyFM958SDJY+75x7BwUgZKfRxSYFLLsEyJDoc3NWgdDbBqozNGIgYX0RWDwxRTIOgYfNjAtXUWpGYz4fHSI0n4uI5gIjZTEnQEZjf1gOON6YChNAimAgQFPou304YVF+xLCLvOQERwq64DGBubRGdYYjLzvRDcGOkQndQ1CEKdGysApCr48VoGPpUW1tDDLDmblza6oZaSZaJxMaK/rEMIKB1BdAsXSr8H3Q1VcV17Me7Q5KBU+fL1lYclqz6E732L33Bw7k6j9WM5H0fFcTK8y348hB+d+I07PAA6aRa0pvwTEEz+w/H69hoMQ9afp+QSIhPrF7pdHhLU4nzNSDoNwr7z32tMQ3Srbu8R8yvL6Qex34837/HxoR6JtV/uK8rfKNTSJCXFp7S/2adpPpf7bMPUb2tD1pw0AOYukFlCtlk8AhlELen4e5QWzJJULDLVi2NfaA1vPjBnWANgxoTEOpqUg2QomRSJlU5GHtI2ubB4hN0XYDLntjiJfoyTwpY1PtznRdKh+zNstFH7qawakneGUi6ZYyUZX6jvVTnSEznoOalK1mEwbHE8d2qlBN44MkEcgzGDDpkkHNRnmwLQdtAFgLftLpE4WHnhIYjvWPBmONsSaAGLg4LU2BrZ2IVSvaLckkhkgPL5nIpwDM/kpaDWtd4aHEWY+Mg4k9/kKctmZ87d1Ppyuc9xmhHOmYcl7zcy25BMB19MKmothYx0R0FnGS5wnRHKIWAe0nOOm89oGso7rZWBHBt3EcBLJ6LMhSdks18MwMwWwaRADq+j8byKQqWJ7taYpOO92WqMDFY5ZTVUCjCHYccVzzIRn2kpNz/ydKTCUIsmXPC2mcTArASAKfDSdD7ubzbPo6+EBpwbQ8k3GJGMDw87n4vyvIo+ZzoV1T1pcCo6Qv+e2InSc86M5bzHZW+D8bIFJ3eJgOfEZz49rVAuKCQczn498XSj6jOn15KR1RE5pTYZaQ9ZFyzp1CN819w+aBibggPvYIWou1dqthVTBP8RxqHLWZoMAIj4ma3HeT+QBhWXALf5Xvg4IPj29vqY14EOXfS3gAyiOVx+YD+yRZwGkJFrz61jmhjb0KNAGgJxB6vlQ8He+NpakSsVzWiqUn8/vWVcxvt50gIWLsfhZyhjqy5LJ4ECtTRkGwIfWaJzGDGFI0phu5Ol3sZzS/RkTINLBtXQSX+DAmowIQKZVg+3JCoczi3bLoJ14AFKtEDf5oCmAHGDwYCBe1C5wjfysEHHGpv4WFKM1EeAjLAE+V4Yk4eNOqKwDtQamYfAxJnQs8cfIM95QgQQsmLlRDIC2zQ6SSzIwJjqji5lSiJjGjLirUwm46Ryo8pnSA/Md+pYdszkvhUjZPZhC6kcl4IN/w0ZgINoGr61B8FeRiFkCGLoJoZsYdBIljN8lBwIqB89TEyc3RNSccMc7NjOyI1I+JwPzNIAQHVnKBVO93jTTWhx5Fmu8gtBCUUn7oW3zTcPgo2UfGA08Ms1HSHBpEOYqHM+rEuMs1xBHrqo1+FCR22SdEC1eVShKATwxZXKVj8zX7BCaPQfaW+H8zhxboxWWXe0j0s19xnOzYvDf6udl44HC2qTW6n4QhH49e9cNrStD69UawciJxPf2IvmV6q2YdwmrG9duta6L6axfAFRfwPt5eISPxFQsLkfhOWIS6moXrDPF5KontHJq/xoCEKV1X192Up+qa9YJr9ITA8c3tKENFakgQ/rbRy984QvZLGT4s1gsivf+3u/9Hp797GfjxhtvxGw2w9/7e38Pr371qwevPzWVFjlSn9MUccJ1g+dzKZ8GEbJ5sFRSRzQJtwe7eXbkdGqTyTYdsX+XzUZMUqxEyxJJu9R1DfDoOSZqZ8WTpGEJYOlfOLiZ5ccLIC98OCFh2xp01qA2FtvjFcx2g3bLoZsiaBqG6uwIPldCTXAj7zTtnXwpMnnCOHfO2+a3UUodAIl8bDxOnY1RjVZe0l3NO9TzDvWxxejYolo6VI0LDrrBHySEpAW6kf8W0OGPeQDTTnzOETth5ntkAuCQttgx+wBMCN3UoJsatDP/3U0qf8/IM/HBpMopsOC4jyqvDbB8rauiWVAcL4plgAFIE30cBDzYyoOOdmZ64COMlTiAkxr7HDyI30gl7Y9+C36A5RPDLgeGr/M+KB4AsOO3Sq7oSMae/TMa/R6qMbPy/sbfKdiJvh7V0kafD/Y36r1/2fsS/JLyfhbTLPkt2q6a836M+6F3pU5aiOKC7w3F35JQUyLsVd4Erd3yIXfbcx22dxfYnSxhyIfdXczHwKJi7YdyPBeGWr1z69aPot+ZIj8nCDnj/4jMe2jgc633BZ8ZCoKjZC2UdZkjVNmxD2Vs5cPHrH7nTdZXag5rsCYAP/hXqXFOoynGYz1tR6EPi2v1afs7K9dlfVsEPWeIkv3mOn42tKFHgzYaEEWf8zmfg5tuuql4zhRi2P/8z/88/tW/+lfoug633XYbbr/9dvzZn/0ZXvGKV+BXf/VX8Vu/9VvY2tp6+BVas9ANqaQTW+X8XseHMyY5kXbx/0E6pZ7lpFz1nUuJEokYEE125D7t64FYlgNFqbla8BM/mLS5aX2QtZ2ytpX64xQUEsjpsXCFzxoQIveYjkCNz4h+1IyxN5lje7TCdGuF5dYE7cxgdORQNaocMUUib8Hty1TmOpCN2QXmk8QkRgMNsWPLxbosWXbWR1WS0KikJNOuIzabEpUGm/aAQvSpwVDR3A4pGsj8LAhw5BMERsZc+UaEeeajTrmVgyEbcs2IP0TyLEOwRKAagfkRjYvj9lJn4/gQBW0eWQc0qWuvJMSzrPmRnC15GwGEaHIBfEjEKKW9Eq1H0HzoZJyQe8HSeJf6TnTOO33LOMGwZkmPqYAQZqxrFyOVCdAaMKuI5nKAWXoQEnK3CJBSPkfe1ow4qEAGOmSAhbnVfiBCYnY1qdBOKw9OGYAHBii/R4OBEBkpc8IfAe2M0OwAzTmH6twK25MVKrJYdnUIu2sW7HjeIDqSC6NbYOjzdXfIDKuobSj1txpzMR1NolMha7tTZQ6t9T2AmJ1T/ae1Zcl+k69neh0FYp6eijxIEHPOLi1D1k3/WH9CgzGyLoZy18/K2zK0dsu0y+qbgJDsXq39zwVtg2Xo+qi5oe8/SeC3oQ1tKKUNAFH03d/93XjhC194qmvvu+8+vPjFL0bXdfiP//E/4qUvfSmICH/5l3+JL/uyL8P//t//G9/xHd+BH/3RH73meuiF70RVsV6gC+cTVbUqpieh0scUQyn5B4rPVUyXbCjeZMM/s+Ps6LaKjIQjxVQJ86Ceqcvy7Vfohz9U4HOSxiH24To1fO869cxi8i7EjUYAVABSA/2v74MFzIrQLiocLcdYzEaoqcPWpMHxtvXS9RGhViZVIumliuB0pCvL/eSQgg9xvNZS5gSE6MarxHEAXAcQO6X7/nAelDCzbVrANYTKuACKJCGfngslZoHkHPe1MI2oXcgR4f0ipM1pf4aoUQ4g6/vCZMnuguZsZKJul+edMazZaeFBiIF3Ug8AT5n8OLCJk4vRoBKpO88RhoQ5EA7gow0VjyADiEAri9ak7zXM9Iv/CXUMPhItFsHBAuRfsCQ/jGheRKIvY6QWlJxpEi2dj0Ckoly1ObhV7SIqL0uGvLZDImEJ+FAaGwEmblShG0XzKwDRr6BLGds0sh7CuIn21I543WHwsbxg4S6scG57gWndorEV9hdTzI8noHmFannKnB88lxLTVbUmSZ3ifRlIKIGCrLwchMTC1BrOY9gDwNkzSmZe6bqa3te/niIYkHdpgMm3BJ+vRgGRHBDxcuLbCxfD9Dof6KDyMQGCFiXUUa35Sd/Jd6lf867JARgKAOwk8JHXIaMzAz5yIHW9ytzQhh4F2phgPUx63eteh+VyiX/8j/8xvv3bvz1kW37CE56An/7pnwYA/ORP/iQ++clPXnvhufRGLX4nmhLl5eTlySGnmC11TJ6hN5+cSREpYSLtYpMnOM6Qbh1nHQabFmX1DkxoNNEJUYVkEwomLZQAlGhmoUCLiXUtgYq8X3rXZX00JCFONEUD5xNzM/1YzgdCiwpH8zH2l1O0rsKkbkGzFt3MR8OKMfRFmmtg2Y6eHIJDcj8LNXrMHUqMijg1K/+QwJwIILHWM4ta8q3Mk+p5NMdKTFZKQKwwFmGuGT/mLTt1dxNCN6bElMNROsa98g2iVoFNeLqJCR87kv8rdBNv6uNzTZgIPgx5sy0BBRkzWZojJUpNFqVvEcGLAh9gBjrXKkKAQGOjqVUbx6OIvnNtF4+XT7yYmUQqKX+iZegkJCoHP5BcH00Hs2oT/w+fHNHPE9isPmJqVVfRTA6IWhzOE+JNr4wykRMQpEIfS0JTxeTH90uZwMk6wj4fy/PA4gYLd8MKe+ePcX5rjtpYHK3G2D+aojusYY4NzDL6ffSk8Pl45+9+YU7kpkz5vWk/pe0prikKfOjvxLQvYzp7PhqJr116X/wfKh8TR6LiYBGmTc/l8ye0IWSfj+/v4D5m/Fi12z6QCVneNxhkinZw6H3TmuWHYyZEqj/Xgo+s7+WatfvLZ5D6Y359Phva0KNBGwDyMMg5h7e97W0AgBe/+MW981/0RV+EJz/5yWiaBm9/+9uv/QHZ4jbk89A/eMJCPMBAJb4dGuiIH4WKeBQ2tmxD0huoZP6WcIrJJqZtyANjSfE5WjIl5jKFTbbHBOjfJelWQVJWdPwd6LciEzy0CeXnFFNqGoJZEJr5CPuLCZZtjVHVYTRt0W45z4RzZm+ntAHiHxFyLGRmKTqPRHir87dbwEXXgZo2Zq0OTtl8HUvbBYjERIIO1FjUC/EN8ZLLOLaqveu6U42HoxhmMzdL6mVXDt9insVaE3FeFv+BkTJxqqLNejfJ/Eiq/uC5ioFIZWCFQa7FKf4EpkONczLnTApgBHz0mE4GkOK4LloQajjXhphyyeWi4crGF7l9fePBomnElAop8Ag+IS44nVerGGrXrDrQsgOtWgYgbepbpLRrAuyi5kP5fAD+u67gRhXsbIRua4RuwuCDfU+iT4BMGCiBg5ofolHjyGPdBGi2Cc05h9XFDuaGJS5cOMQNO0eYVC3mzQgH8wlWR2OY4yrO3cyHLRcg9IQKA+99T+uRz40hOg1YQbaeqO+QM6h40wBDyeCjD2zi+h4ioLUKwLbwgI3XdAkRnjDoyqywqEnQZm7w9xuel84gCqEMkvr1+rCwppee2QMr+fup7s/BRwJU1DM2tKENPXLamGAp+pVf+RX8t//237C/v4+bbroJz3zmM/GCF7wAe3t7yXUf/ehH8fGPfxwA8MxnPrNY1jOf+Ux86EMfwnve8x584zd+43Wp3yCzGy7Ifq+R3uWqZ5Kf2TMcwZtKFaRwAFiaziBEOSLXS4fxIcKmouuRmHopCTBZ/hmkdX3GYLC9hf9zd4f0JPp2u5kkLCm6ZPN/wkakyw/91nkQ0i18ArTldIlJ1WJrusKVnSnabYPugFBzUi7Hdva2AlCTN3XIcko45u9cJSF813A7nTjnKG6BPAhJojUBPplhBc6S7rwUXtrWVkFaKcnm7AmSwSi5VWBFQF2lks4J+AQgtvC5D4CXoDNjKA7no2jCFYhNqCz5bO4kTE1FoI4fxky/j2KFCIjJBEdxr5VhUFiM6CRt7Pc9cQjZUHcoEKvuF3v4mPTQJ0wUkzvSGg5dBwljG0LfwodY7izMyt9nW4euM6AJBR8WPTclcES1dKgWnQcfCwYcXR9opA30E1BM6bSDedJFlV9MXG1gJzW6ae3BRzC7coFBFVMsRzKGCGAjZ24FfLRbhHYHWO050PkVzu0e4+LWHCPT4bgZ4+p8ivnBFHTIjues/TAdIhN9SuayJ+iReXsC+BjM/SFlFI7Julx8JrL5SDyPCV5oINVyaj1yp2ymrMfE6zi5pN8dlcPrriNZB83KYcQR8Oq5L78bc4CKOgUJwZ8wAwa5RmVo7ck1SP0L+uWH+9T/JSuCkwSFf+001MZHWuaGNvQo0AaAKHrHO96R/P+mN70Jr3zlK/ELv/AL+Cf/5J+E43/xF38BAJhMJnjc4x5XLOuJT3xicu3DpdKiNrjQKYYibDQ5A8/XyaYUTw7voU4wglqIk/JZYitMYLvlj5sWGB25mD+i4MDbj46C6AxakjzlletVFsmCSfoaSi8Lm3qhP8OhDCSVKPiBQO3FGfAI0rwOnulZGqyWNRZtja3RCrvTJQ52GzS7FdqrhHrONtUcg99VBAvj8yGwJsmBQMaxETaPSQUQfEJB33aKzGoWMjX4N7BWBEDwi4hRocAO6i6YGYaiDKFa+jwhuVQ6GQDNMPBcCSFbJWeI0rLJmIW5mDMQTgGPOmo8ehq0MCi5W2860N7XIw6cJPST6Fxd0Kr0gWiPAZFKk79WQJ3M81zrEtvE4GMlGosOJotylT7YBT8USThJGiA4QkAjLubR8LlBeFB0nhV+drXsUC3aAD68lqMLTvtJskHpW4Oo6QBSsz8dapcjkdlxhW5awU58tDOA86Xw/JB5ELSwclwxmAF8SLSrGaHdBppdC7fbYmt7hXPTJSqymLcjPHQ8w9HBFDioUR+bkPcjAR968VMvdNHRXM3FOJj9YZL55etMyfcgEMkpZ5Cl6Ax4hG8NTAra41JZJMcKzLfWRAFQ4XNTQNKrU6kNXHbQkvNa1k78vtFN/LVBA6M07EFoVGoHpb/Txg7smQP9mrR/4Nrcb+dMgI8NbegxRhsTLACf/dmfje/7vu/Dn/zJn2B/fx8HBwf4jd/4DTz96U/HQw89hK/4iq/AH/7hH4brH3roIQDA+fPnE6ZM04ULF5JrS7RcLrG/v598NBWl/3qDHGKeB5jy3JFv0PwoKzs3mUnMkVg6Jqp5Z3yG9NUuodmKYUZ1eExJKhgSvbXoqfd1NK1Bu1QGP8EMQJmE6c0rUbmXmIm8zes2rIIULGzSuvz8eYqBNi3BrAh2UWG+GqGzBlujFWZbS7TbFu2WN0PQ0nLxiQnRoZRTc2ICI3bxIhVHvKafT4LvFXOalhneTn1ab3Ij5jdorb+m5ZC9jUW1cokZljax0/0bxk6d947nwsQizMvcjyeYJbWq/myu0Y0phv7VktDS/Y2L4XVz/xdS4KP2oYK7SapZ0eY4RfAhzeUxi/eo8UzeYQfJh2JW3vSpZg2E1z5wPbPgDGHsOCoWdV0YE+IxktDKhkMr+9C83idEni3JDGOeD5uOs1VR1fLIakA0CRR/I8n5QRTxT/D3qFjzEcFHbtoZOzSOWyqESPvRVT7QRbsFNDsO3W6H8fYKW5MViByOmzEePNrC4cEUOBihOmLwsYohd5OQ0qU1IlsXEv+HdaTAh58jJ9yQPat4SSmkb8aEJ2t0EtZc1mLli1RReAe9KaREE4trTljn5R0OfiLgzOV6rZbw0U7VWe0XFRIfvk6ilW37dw3wwKRauZAYMtUgFTolF3hkfZqMa76P6ltd/JTK188+c5oPJt2G6/nZ0IYeDdpoQAD8h//wH3rHvvRLvxT/8B/+QzzrWc/CH/zBH+BlL3sZ/sf/+B8AEHJ8jMfjwTInkwkAYD6fD17z2te+Ft/zPd9TPJeof3uSL6QaiWIB6rwrHz4N9TQEpcWbJVpV4yvrHacJjqIdt4CPEKZUktDZ8gKXS5i0hibRLqg65PeGU2rTGZSSyTPU83KpYpB0yXkN0KSuIr0dgPYi/aMWwMpgsRxhuVVjZ7z0SQm3OnTTyjPUFVDZyHja2tvIx/b4iWDE6ZSjd4Xs6LDlSkhdbJ/TCVqR7DpXGW/WU1de8+LExMfCjAxM7WAGIlil5XuTGWKNSZIzRM9r6e/gB4SQGM+bhBEsR82yAmylrjJmgWFy0b9hZdm8iSOGcT8muUhq8nlIaiQ+KWmnSIPiO6L9m5I5V1EYm4SRU0xvzLuhwIck+gP64WsBBM2VzcaMvPbMZTZF0fzNgWw8Ls7mhh3OgymeNqcCUu2YiQ78MKYc7EDK4P4LvjoS7SoIL7LwvvD1N3A9v4pE4m046tUUaHd8ro96p8H2bIlx1WHVVThcTHB4OIU9HKE+Mj7q1QpBy5qskaTef92EAiDpmaLmC2v+e6B78uvzZ/XMVYfu1WtkzihTLFfrAYdMJf37DY4WF00mnZhkKbAYnucQApH0lnMNwMPa6tRa6eeI9h0MYyQPWQMcBoVp+b6l2qz7ubhfFM7lAsGN5mNDG3pktNGArKHxeIxXv/rVAIDf+q3fCtqM6XQKAFitVoP3LpdLAMBsNhu85ru+67tw9erV8PnYxz6WXlAAEAnli24BLJzWybrHnJcWc3VdsnkJUyX2643jULBR6hVyOjhmCDPH5Vyrkkiw+Vwv+pWqi3YQlwSGPSleIVpW3pa8D4K9ecnGWJhObeagGJPe5iRMhjDTS4N2VWHR1rCOMBs1qLZatNsO3YwdqcXvIDD3wixzEkIVFlZCx/bI5QxePC5SbS8RNVw/cWK2INaKaCm4T3DoIzSZpkO16FAtRBPS992JjDhCMsJ26j8h4pWecxTHSPezLluk3zo0rh8/SucvM0vevMiiYi2AjqzkCCEpokRi86AozdPR8xfSzIn2bVEMqsz3VIKe5tUQrYzXPigthjihh2hTmTmW9WMeE01Kg7Jv7hfdxzHbuQuaF7Pq4jgDHjyIUzmH1A3gQ45JfiSpS/5s+Q7RxhA0Xfr96UXaEaCu5rReE7T2o9kGmnMW1Z73+9iZrOAAHC4mODry4KM6rGCWCPk+ioxjgWG9Jsrm8DXfrtf7AGrVXOpdH7UNYT4rYJtLsHtrXvaJazWvnSowhK0RohP23k0BJNnaF57tMKj9Ce9DGwMgSBh36cd1dR7s59IyuA6gDNTtNOWeKcqj4V2vz4Y29CjQRgNyAj3jGc8AAFhrce+99+JpT3taMK+6cuUKXGYbLyRgRa4t0WQyCZqSh0slm/fAoDEv5kz//CBlwCIxfxh4XqwMMw0OcIppiDbPEXwE8wyRmmmpk9iBq40zicblBp6vNkWnjmmnSV8PdeNAXwyp209NAthKvx1ArZfEtssKx6sRzk8Js7rB9tYS++fGaHZq1EcUJNYA2NFc+tc3jsghhNytsvZlpkWJk7neXHS0IufgwIBDbz7sU+Ifa0FEIGvhdBhWA7iq8oyhjJ/MG60Z4rpDvigbTz3vciZKTJEUMEiIEKS8BGbwV8q8qLM8T/0EdMxUi/mJgD5kDLvvVxSlnqL5iJoNF4B4tfLmT9E5HLDORB9tgo8CJFoZBh4hR4v0r2boS349Q9JxgM0eKSRUFM2DgJtqKZoXNrNTplMkgKPu91nJtwgwwfyPnPOH5VmVi/5dHbxGTQkgCGmfR9AvWrXYRme874eAD+w12Ns9xvmZ107PF1PM52N0h7U3u1oC1YqSXB+iIArTVI+rHDyB9ypKwfXa4VsV+jNZB9ZQIm0P9VMaIX0y3CPvPfrX6XpK/w7UOQASvsjvHxTHTpIHZhnj9bqcrOfyMPZnA+Q94XtI9aNutwZzel7otpTW2axvg9ZR3zNAa7UaGz58Qxu6rrQBICfQaDQKv9vWh+34nM/5HABey/FXf/VXuO2223r33Xvvvcm1j4gyyWvuFJhsonwNXHZbgVcrUlLQmnqoY8V1OS/HsqkH+zq7CrDaVEf2Totko4laCwpARRhw7cswuLlrJlJ4OHAkmqFNqdTOtZuWYqZLJHVWm6zYUmNlsFrVWHY1LkyOcXH7GEfnJ1jtV6iPCFXjUC3jZg1wXzB3II7YQZkpkZA41wJq46vVMUjR2hDN1KrfoV9zBrPrvCQe8Eyp9WUb8toTUxPM2IBGANnUKdzfk/YlBeY09o/WNCQ+PPDS2FCE1pSFcYhMpbwDElWqEs2CaIoCaHKJrXxwildzRruwpyYZcQ5F3yQXtQpLH8pWMqHLHDXWM3SWgUGSadyBzdtc9MexisvLw+6uI3H+NhTMnqwyVfOO5yn4oDZqP0KYX+M7RDRkCWkgq0PtKj8FD0RcmFshWSb3acwEHxl10W6VNK4+tLLP97Hac+jOtzh3bh4iXh2uJjhajNEcjXy43YX3uUryfeTvvQa8QNTWPlKmFQUw0LtgoJyIJwIYKK0xPRMiKDCSFMB1yV7vcA2vt+F/fRxQAQH8u23IhXc3uUfVKQkMIe9y3gZXOKSX86HuK/X5uldCxl3vm6faFOP1eX0elnDqUaRHw2djY2a2oUeLNgDkBHr/+98ffj/+8Y8HANxxxx245ZZb8IlPfAJ33303nv/85/fuu/vuuwEAT3/60x+dihUWfc14kTuFwCbb0KKdMJJNq3SNHC9KD5FeA4LXfLBdbzf1juqSHTlEomGbfKcW+pgPI9bDCQhTm+lpNpOerX5e5wHgkWya6r5TR7FBoW4ummE1HA3LTB0uTY9wtDfGAxdGWB2OUC+IE8hFbkT8aCRzOGCAygVzBjQWqEz0STHGazBaz9A64ghZIceHzxDe7zBVaYmCBOcZUmtDiFsx0dL+Bdp0JAAL3c0KIIipDcg7yIYgTZx7QMxLJEeALqhkv50zcWLiQZ3lOrkI1Ax/i5RdipZxDrbuGZfk0uuCdq9j8LFgxn7VBQBBwphbB9f5kMpQoJCU47d39O8SQNhz+A6CCEoil/l+IDhjYrK/Os0QL+AjJBcULY12mtbzQML85toWDToAr2kxxmvjlGYu1h1Kg5e/16r+hTwSjrxpUDshNLuE1XmH5mKH2fkF9mYLjEyHeTvC1fkUi6MxSIEP00agmAALoM9g6aEuAJBTM2R6zXi0KcMbA6eG1ywvSQi/E3MnIGih4RBM6CwIBk7Nw2yd4/fZjvxvswLqOc/lPM9HqUmnYe6zOZI0WO9h+V6m7zthbIcAZuLvtaENbeiaaeMDcgL90A/9EADgyU9+ctB0EBGe85znAAB+6qd+qnfPu9/9bnzoQx/CaDTCv/gX/+L6VKSwKZSu0edPjGSRL9oZUwVE6WNJ2lw0n1IMmWc+memw3kndtM5vShPAjhDt/6WNBjEaSx2zouus50kf5P1B2XXSD8J4KPDR81NAv52hb5TTah7lJfx26bPWba7EkkTTEOy8xuFigkU3wrRqcdP2IaYXF1hdsFid8z4THmgIYxmj1TgxHZKEeco0xnFCPTeq1KcGRjXcqIarK3+tdYBOLlcK/dpzwlYMr5J0J5mSc7v+Ur/KmPA9hiNdVY1DteIPZ0gujW2pX5MxySlz6g4+CK2NEXcYpEjUrWrlUC8d6oX/VMtYN9P4+hmp78Khnkso2yYm72t9dCla+RC31XGD6qhBdbzy17L/RTTDsgF8iJ9L6HPxv6grTupXp2M85v8nFeyoQifZxjl5IyzY54STDDb8rNA3LmpelIbDg0yFHiTqVV0BYV5VQG1S8DPm6FecADKEOGbNZoyERskalo+zz57twcfyosPyxg6Ti3Nc3DnGrG4wb0e4cjwLEa/qY+90Tq0a1yEamJv6PV5nxlNkQk8DPNSam/s99NY5XVdCqlkZ2BuGzJjCM636sIaadFTCQpjiZO1X63LuoyF+OnbshU6ujs8SYULIeL6OSmty1k/r+r/oj0b9a9ZrsbJ+++sAlQ+H3KP02dCGHgX6Ww9A/vt//+/4ru/6LnzkIx9Jjl+9ehXf8i3fgl/8xV8EALziFa9Izn/7t387xuMxfuM3fgOve93rgs/DX/7lX+Lrvu7rAABf//Vfj1tuueX6VLTEMFN2LtvAesy0un/QIVGKOEnioxfyvC68iQX7buW7Ua0cRscO9TFQLYBqqaLgANG+v1LRkXLwoduTAINYT23qFO2WXbLh5u0sAQ8durbocJ5dr5mVkvQ0Icv9tDSYz8fYX05hHeH8eI4bzx3CXmqw2nMhLO8Q+BLGLZjvqL50lVFMCPetMK9VFUFE4u/Bv4dyUOjrrWNnaXZKl2hKqq8HSQBFpbRcQHTSl6hXSgsSHl+a33oc5CcDWldTqiWQla/zkZ/EOV0c3Q2HGa0XDvXcoj7qMDr0n/FB/D06sqiPLerjzn+OWlTzFmbe+uzhEhqXwQetWtDSAxOzbHy+jUWbAJWQ9A9IgUdmyuPN7wzcpIKbjDiz+BjdbAS7NfKJ/mYV7JiT/ZGfH15LowAIZ1kP42ktIMkHxbm94NgO0bIw8LHjmn2AyIMQCb07rtDNKs5Cb0Km63wNEUBiK4luFgMMuMoHLFgJ+Lipw+zGY9xy/gDnJgu0zuDK8Qz7+zO4/TGqQ+MTDeZO5zkDqtfB/P2SS0qvQEEAcipJeL5u0HpQ47K65nUIQG7oXZDrdPjeEjPtlABAwl2LY3gSZlftAwIgMw11UnbnNR/VAqgWvlwQomN7pdqu/ELW0bq9KQeLGjiV2n0aMLHumrOm/cjbdb0+G9rQo0F/602wjo6O8P3f//34/u//ftx222143OMeh6Zp8IEPfACr1QpEhFe84hX4mq/5muS+z/qsz8Ib3vAGvOhFL8J3fMd34PWvfz1uuukm/Nmf/RmapsHTnvY0vO51r3tYdTqVzatm/gc2yOAvgWyTyze0wsbXK04v8HJLtomTnFebLFmfhdqOfLbiqgFGRxbVSiWPkw9HXgm/cymo2ih9LHovGRdTrVAxUtdJhB1dr7wvhhiOdQuv2vCLPiAu/T+YxOXPsoBZEbp5javzKS5Ox7hxeohbtvdx5fwUh/s1RocV6rnE3XfpMyCgA6lvQw5OLdi0J28HM+YwkUEXRjTvgCzBHHU2aWZlormPgIpOfNtzUYc6ZgkgS3HMoACfMOKOkrns5z6lwDQAQAVWmHm1lQFV3BEihWWGHI2FMR0qlsYb+DKFCauWHpzoKGO5XX/wLdFaDA3SNMDTmiPDjt6O+137fJis0xQIkOzzOrmfq014DyS/Q4wUhgDGjfjDNNZHMwumeC5GPAPgE83F+eFcDOPrKG2Pd3Q3fB/YFIvzqchnRDERY76W8dyyAYhIv/oLuhGbXV0Aljd12L7pCDefO8DuaIlFV+PKfIr9gwg+qiWtj3iFuD4mWpZYpfBPWEdl2JKL1G+nykR2Ln8A/BzyvkEnrDnrwIWUA5mXCO98EnxDAyVHSMJVI3u+XkIIcMbB2TiPkrVPggNo8z0Xy/TaTIQQuyDvv2NH8o6p9Vy33WXtPg3QcwP9mN2XC+s2tKENfWbobz0AedrTnoZ//+//PX7v934P99xzD/7sz/4MzjncdttteNaznoVv+qZvGvTjeMELXoAnPelJeO1rX4t3v/vd+MAHPoAnPvGJ+Jqv+Rq87GUvC+F6rycNSXR6kjW1gOvNVG8uYQ1ONsWBZ+oyUPifFM+tmH0jFj2VTzhFVrQezMgEk6vIdCQSSVWeToIlEva8Lcier0FLrkUqanJcoYwSMc8+KJ08iaRNHUtpFxXm8zGubk9xYXKMvdECN+8e4vD8DKt9g/qQQgI5060plp31Y/09o0gafBjAWe+D4Ax55p8ZWQA+9K5jKTgQNSW9CDwZCDFAJQnPasBWniG2Q32kAGZgkAGgy5gnudx6V3BhqPIQuUX7bUNwtYMdEUznLwzvg3FAy6CiAYwhVESwzmuNTOczg9PKhxtOQYUAndJD1TGlTQrZ54G0LwX05SFwc4dzrQkRTVbQQHBiP2XKlIP3oAVsLIxoXLquH74X0q8MPgw7azkDB1W/pL3+/wR8mHLCPFmTZIxDIko1pslaUAHNtgcfi5tbbN14hFv39rE3nmNla1xdTrF/sAV7MEJ9GLOcB6Z24B0uCmVQnkea8rnWC36Awnfy3DUPOM06ousb8Jx6T+D6j1XMPAH83rtkjU20yEoTIQIEV3HABqIoVEjWTlLluGQ/cAw8XO0TDjrD49N6Dade07QPYJwTqr1r9qESqEy6YQ0YPemadfecGRpakx5pmRva0KNAf+sByO23347XvOY1D/v+L/qiL8Kv/uqvXscaZaQ3jnUMcX4bX6sX89J6mYOLwBiEf8rM3ZCUzwGJYZ+XfLEWpPaRa7oxUK2EQRhuUAAYwX8DQQKb2Ev3NsK0nrlPS6iv2txCxB7evHNpXM/8TE5l0sWwAfNvl2+GGkByuaYD7JLQzL0D7dFsjBsmR7hxeohP723j6oURVkcVTMsFNeCQun5gvNTeATCwkBC5zpsXJTb7UEysY67fM5hOaz+AuJEp5+JwXW+gCOIz4c2ZKtjGgCZxzASgliahZkgpjCOHZK0U0BQmxTiVoyNjTrLxD4EMBGyxh7t/Fj+QHfSN8QjXdNYzWZ33DTFZdnHo3Ch6w5f8GOKnIf2otArUuRhN6qToSHkfh1wa7ANS+eR+TvLF1BT8K3Q/SMQr/y7G9iTgQ9UnqV8vnCsfqyuuBx+z4JctBR3eX8oPPmlgadTYBBPLGIY3+A+MGHycd1jd0GF2wzFu2TvA3ngO6whXFjM8dLCF9sDn+qgk14cCH721yvXPJe+8Wi/0vckaUKL8WY8C+AgauAQxocyYSx1krQGCcEdAiFzjuOwQ4EMEJNIX0l8ErxExvjBXxecn2hfrtTIiSIo+P/5a04Lzz8R1HkAy/gn4kHrnQK/UZL1fJn2n/+lfv668k4R0pylnQxvaUEp/6wHI3xjSDLB8O7XOUtyL1oIYtVGFcjWzP7C46zqETY43smrlNzc78rbdbkJwFSec6vxuKL4ekMVeBV1KE7y5CKzCZpWBgNIGpc4lTI5J7xXzhFBGiYGRqunnFfpRa1+KjtPcTm8nTbALg6P5BA8tt7A3WmB3tMDNuwc4vDDF8ngG03AsfjhUIDgTmTswX2hggNZz/BL+NfYBRaYRDBrqyneVCpMq1wbNR2WAqurnf5D/+f7AeGqHf8sdZflSNYd6pMbEm/+oUwJWFYpJnF/lMIMXcvH+kjZF6hyiYcF5v4zWArVC0AI61LcHLF0Mkyv9xY93lYnHXQYCSUmerQVgMi5Xc0ZqLAQASlQp0XSIE7c2fVPvaEjgGKJeqVwjQto3plPcoP5fA9Kand1rsa8rcdq6HcyU5sCQQaTl0MdSZxFidGNCswssLzi0l1psXzrGjbuH2B0tsbI1rixmeGB/B8urUw8+FlDvSHxurhnuAZM1v6VOUmeg/xqXAM5Ja+w6GtLm6XU4MQUMC3u/XmJm6EBxbUUsJ/GFETNH60PsQuX6EDCiQUbQfWpLwdBnLo67FkjJete6YCInbU72j4I/ztC4hPuhri8BwXVrzxpaBz5KAPUzSY+Gz8ZZaNeG/mbSBoCcVTrFJlWkfMF26eKeX7NWqpQvvNQ/NSjx4+uD3Xm4IDqVWjhQiO6UMYiyyWQOpDqOvX5OoumRjVfqbcKj+8xo3jc5gFPfoUy+T0ycnD6hNyTlhB/GAvG3ZIuHJe/4uTRYHY/w4PEMFyZT3DA5wk2zA1y9MMUn5jVWixGqEFLUV0ib5Blw4jcBUUKBIZN8FMwRGOPNkChGXApcYs0Dw4CjFwJWohyx3T/ZjHFVfWcktx33P+V9rsYy12qERIxWMUCA0mqgPHdVmVBA03FOCwI8gyXmaZ31miXN6EsR4pDP/RM0H/Id/CS4vDazkSv5f+TnQhmUaiWAFHyYtIwAojPbfM+IRGfiSrKsS0QuqQ+DSPFHKNZZ/mcwKs7lrk77Kfa3aK9UtKsADuN45GaWcr+PdgU054DlRYf2xhXOXTjGDTtHmNWN9/lYzHDlcIbl/gTmgMPtNhQimRVBAdYwUxlYKZmdyjoZDj0MZjbct2Z9L9VRz33dV4EKjH/4JnitoaX0Hr12KoWdV6b6JKdBuSjlAd4aDzINdY6c6G+XtIPXSTlnVJASASi9PSpv+yn6SIOPE81n1RxZK1QbKmLDlG9oQ4+YNgDkrJJmaE+70eXX5feKsExtEEFbkV2bL7Ai+cq1DIPSurxq4r9BjiWukQnRTsNieuEUaOg5Tvd2I7WBDUnHcuChy8o3b6vq6yKQCAyUURu1Azvlxk04Fh0BglxPQDBzcBV/J1qQCgdHUzww3cG0ajCrGty6vY/DixMczXdRzyuYlW+U6djWm7mB4FgtDxJ77UpxppAKsEOwMyBXAS3gYBHyqwAommVxR0ieCcm+7mCCn0mMGMbggxwMUjv/0J9Iq9azLWegFvxZSJvsqDHRTJmMtZob3pzHeAbIAGi8qRosYuhhwIMSElMtBEactJ+EBh+64tqXo0Qm69fsI2AOVbwlJDAEAviQUMuikZLwumJSI5oP4uhFpvFRr6iJIXd9eeI0ThFkybduk/yuDEe5qhKzNvFJ0ST1cQYhA7uMm5XfgRF0oV9s7X3FVnvA8pKFu2mJGy4c4dLWEcaVz/Px4PEM+2x2ZY4q1HNONChhlAdo0JetdI2+LrueoObmaUi/eki1c4P10ccGGGSnzvnzEXwk0aSkn8mlGg9JaKoAgKznlsAmis5P2zzrua6bjH3wz+P68fspoEULpAKY02s3kNQv34+SJUztOzkwS8zGsj6U606tuSiBvbNM64DXIylzQxt6FGgDQM4iZYtdvvheEw0BGD7eAyGl66A2jEIdi45/Lm4sYU/pvMDdVS5mOubjZAFbO3RTHy1LNs0QJWUIhJQ28iD907sMUpCgN6HCxpWEnCz1oZKy+dOeUYyRbdYMmDyPTbP8puxNpszcoBmN8enJNmZ1g1tn+9gbL3DT7iH+8uIYq+OZZ7asg2soMBvOOdjK87hiwuRMdDRHRWyDL8yuDA7FbmyBPLpR6D4xGyLy0Z6Mvy5c2vmM36gcqDEwTQXTiJMrwVbciSb2WTJ+2Xdpvnt/gRimtaf9UKAYJprSiZ+BraVgA2P9AIgjOSlTqiiV5+Nau6MjWsnxSiGGcN1AJKvQbopMvTE+CACbVyVmbexbE8Py+mvtSCKOselVnTJiIVBDa2E4lG6IKsbzM7Q9tEeNvdSRc45IlKsQ7Uo50zvJ66EY5WBiJVqQmoNNhIAT6bvoDKns5sDyhg7VDUvcfHEfN86OUJsOB6spLh9t4eq+dzivjkzUfKiw34n0P/8NdQ3iseR87xz3vdK+BhBSKk/dV1oHeto1ZOtvvg7r9SdjqovPyNod/P/UWuwFPC4eJMAq4O/ID7FlbZYxMcePPNsZxLln4INZwKFm0yrx4ZEcRtq3pKTxSI5l+4tus25mTsk4Zvf11pShvTEpsFyPh6M12dCGNpTSBoCcUXKUrZ+9jacvAUsLwMkLrAIh+bPVo5LyekAku6dnY2zSe0mb4xiwmYg/HjasCd/e+GMipcvrFp6nGAztqJ5UUgESfW0uDeuZL0hdRUKYSQvj+Thga8GH6hv9TFgPttyK4I4rHI2m+ES1i7HpcGlyhBtnhzg6P8Yn5zVWqxFMS6iPvR01gtmSZ+48NjBwzjL44Kzo3KAYrtVn5TYJCOmH2ErMuYRBtRbUwItKLTiXhAVZA6oqn2NipKT6ICRBe01/LJN5opkIw6cMxeRlpXCuUPNNNDnklGM7M74CsljiH0CG1kicRKIt0JoS/Vv3l3IgT8joPBomjou0zSKG9RVwYHzI3W7C+T0qTujGfhQhSEPrYl6TVpmNlfw1cvBBDDLY3Cqa2/mwv73byfug5JmtJcdLCLfN4EP+JwfAega3m8AnGLzgnc2nl+a4ee8AN8wOYchhfzXFA0fbuHpVol1VMEsEsysdsKIEPNb5aZQBS7+fcmZ/yMxLrg33DCzC+TNyIdCQ4Cn6dsgSvoYLLrUdCMIP5xwsP8RArW/qNwmgFxCSrfGW121pRLXwyTkFvCQmT2pfyveMZE8r7V0nvJa9dg4IM5K1JTu/zt/jsUAbH5ANPZZoA0Ae61QADyWGeq2WQ5dFauOTTcLxWq03bfW8nnROP0OZKwX7bBuPyf9V4yX21cpLqkWyT20mMcsZd1lwA/CI4GOtvbeOrFW6TkkC9f+g9HfwXSlI9KR/1tk3AwhRotCRT9S1MOiqEfZHM3xy1GJaN9iuVrhl+wBHF8c4WuyiWvioWD7alYAPGcD4cLL+4yoPFHSIVHC9nSPveN05UI3UhMh6ENMDIa3n+qilJCKUcxWo6WBWBpU4KYexykAIkGgxwpiLKQ155lrQeBKyWc25ni23/MmvcZxoTUe2yk2pgD5Q0OZVBt6B25io5RCzK22mZW2q/bCu578BwIONmvN4jAybJ8XnmdYETYaE8fUAxMCOKThya2bOMPioGhvAh7wj0ek+o0rVVcy8aqX5IIScI9JGclDgF2zSh9CfTpvLBa2Vil4GAKPM2fzGBrsXj3Dz7iEuTI4BAFeXM3zqcCckGawPDaolQK33hxoCGDkYyUlrHHrgY2Dt8FHy9ESLZSTfA9QDNhoEDd6U3VIC7uqYzqHikPWDLlPeCdZkWkc+JoLywQLBg1wCyBDIIORfIufX54DpjX93TcFcaxAIIt2XcsFab+3MX9Xs3U/aVzpeePZpaJ2Q7qQx/2sl6/o+ZNejzA1t6FGgDQA5i6QW1aJNcukWSn8PbmhUFi7lzyBkzLM9UQA1XDeWdorvA6CAgqp7vXRw+94XItkADYAKCdOZajvAUlAFPAZARfI76+chsKHrOGgaoI4NmbJpwV4wA+fnCggxrS/AzQldNcaV0RZ2xivMthtcmBzjpt0J/vLCGM3RDBXbvRtEBkGYu4oAcgTbETAy3rlamEZIH/GgyAZTUTDxCXkuWoR8IEneACAwmtpMiToCug7UVDDLDt4xtfKJ6Ma+Prb2UlNhSmOnKMaFvKQ86WsSZtcDErKxD5GNV7H/O8+Y08qCll2IBOUqE3w+XF15Zjw3RwIiCEnKdTFfSn5N16XmWRbp5Ai+HF6zkOfxAAh2BA6ja8IcdRX3ZcifIZPUm1NJlCFqUu1JYH6Nr4tPYIfgyxMjpKm6ETxo1ZohNquT5HTRp0vayX0p2cxVng8gvmt2BHRTwmoXWF2wwA3e3+PG7UPsjJZorcFDyy1cPtrC4dUZsM9mVyskDufFsdaCiQI4SYa1AD7WMpx5OQPrSixfmbxl9w6ZDA09P5nveV3kHWHNn3MeTED8zAp9QQ7e7wkMRGSs8ihUenxBQOdgOqDqfKJBqZ8fG5cKvMQfZWhNHjiea5qvSbpf6KOTxnTQfEuXOXRuQxva0DXTBoCccUoY2qHFGuo8Bq5xhT1rzYan70kcvB/m4usIAUQkJlAEuBroOBJUvfQmWWKzb2uCG6nrM+ARE8IpcJNLxUoggi1uAjjKQIdLNtyUEiYeAMTMQo8V91XYgOW5hMScjIBgYiQgz3CFnTFYjCf49Hgb2/UKN04PcePsEAd7Ezwwr7FsRwAI9TG8pJv7xIk5DjfAVS5KLZU03TPlNgJBLbGv4IGEpRAtCuDytTlRDmKM/01dB7MAXGdAjYUdV7ArNtWpxZQqjrHVbhTEoVmr+L9QYEbCXHBx/EzK6OrxInYkp9ZrQAIzyIDDiYM7M+HUOaCRiaTASIiA1fl7rPPcXXgY96FRjuwAemZYgcGXjOXquxImUnWIi4xsdMCnOI808Ga/kTDOOhxzABE85iDvVK5MwAI4HaBQNwaDOSMn9Q8AJAEf/l2xNef32HNoLlpUF5a4dP4QN2wdYVo1OG7HuLKY4cHDLcz3p6DDCvWxgWHwEZharGFKXfn3SVrgEiOqBRSJWdXAmtwDHAXKtQIuO66fn95YbouTc/wuAIjaZxvXhxLAimtnTDaYOKdrE1ijrpcwvVbeMYT312W+H3J/r0my9rr0/yR8rwKJvfs0DXT5ScClCFLV2Od10xqkR7IvXncaAnqPtMwNbehRoA0AOYNUktTkdqv5tadSJQ8tJKTWULWACfgY0igkGgnZqPJyHNKwq6TWcrFDNt4G3HbUl9LJJiAbXReZzrxNRfvdRJJGfF2U5ItmRl8bozDFTi05rgdbbIt+mMusH0M7KDIFAjwEhASmygLGESoC3GGFg8kMD0xWmNY+KtYtOwdYXqqxb3cAU8NWhDpkf1YMBABHxme/bhE0AJVjhlZHOwKS6EtJnojQqS4wzsERuVMRAoRRd44T9/lnuMbANNaDj0oAiHee7qYG3RggdlIOY6fnTGGcJbme4fngNQMMaCp9YzpewTyoIp/bRF+jI0k1FkZMzYDU+TwHHz3mnmKSw9BflPZdxeZNAjwIKlJUmpAv1C0BJf1+CeBcOa0nTuaqnWG8xKl9UvsoYYQA1JJ2ae0JIa2zznjO50TDleRpAVJn8wsOq0sdxhcWuHjuCHuTBQDgoeUWrsynODicoTkYwxxxmF0JQb0m1G4i3MjBBFBcN66J+IUN4MIhaXty6Um+RFkbenVzcY2k7L4SBR5eqiaaDMDn+NDmqblZllq3vGbRea0Jj2fIZZTVU2sl4rgjFQRkz3CI9zl1PPnWvzOgJscTIJD3T28sTgYhObhJ7lW/E2Ci6vtY9BnZ0IY+k7QBII8BOsluVh8rXp9Lc3qF5Q/snzu16ltJs4Lka41UJkqv+V7F2AdnVQYeklAt1DFb9AdBR7bBOScoyPXqloCPbANNJJYKXAXnWylPU6lvE9UTommaYryp8SedMWjHI3y63sHIWNyyvY/z42PY84T7yeGK2YEDa0LgtSeOEWAL33+mpZj4yxnvnmAtTyKuQGBIXGRaLVDKlJ3kvUjapsrrWMvQwZshOZ9TwFkH15Fn8EfBuxzeX0WBJ+p3XdKnzoMP07oQBtnCBTv13rzQjLyAj2RuSGI/eABoOjhrgbbyQE18P3ptzrhDQyDJVK6iSMXyjU/kV5sQzjYkFlQ+Enm/JhnfuQ80WCfrGGjyN0e9Cn4fUncpQ/lpWI6qZcf+JLXWp4dh5jqJWAVmNOvYXzGbeQQcOlO9PMdVQDsFmnOE5UWH5lKL2YU59rbn2Bmv0NgKV5dT7B9PMT+awB3WqI4NqmUMs5tnOE/WPOkT0Yyewvwq6c8EpGWncyY5AQ6O5+vD5EBzENArP+ONXfk6QF6/GH1Oh7722l5S/eQGgZx+TjC9FE48X9sB1nYhRMTy96l1rdTeEuWMvAY5LrtGL6M5mMrKWWd+VRLu9bR6pbF5uCD2USTCNezV11Dmhjb0aNAGgJxFyjZXfXxoMU8EQblk6DTSH31v6TmlS7ONUEttCbLhoSzBgmqfy/ZeBUjEbMisfJQoQG12BXMb7RBedP7Wz6ITmipMidoAc7tykeZBSQiLfZRsch65BLMDveFL35G3kqmJ4A4qrKoJPlXtoDIWt27t4+bpAWqysI6w3+3AdDVMx0wa2H+CvNOyqaKPsdcgkQdhxkSQEUyn4JlVl5ntiEZFgEcOTEJOiuik7DOyc3sq8s7qMBzGl+CcX4C8RoNCNCdnPMNDAgRDv2X9KmZVHQCdFb4wqImpU6cGXsahItjKxDkLz4hTU8GJkz3AGh8GWQqEBY2HAA9AhbA1SDQfDD5Qq+hSKrGiY3+dWPc4hyKj7TKm28GsVMLB1kJrPwJ4sDyxxGqsAgcmUEA6AIloGgZAmepJWGPlBJ9rbfg7mGJxfo9mF1hetLA3NNg9f4xz0yVGVYfjZoTDxQTHxxO0RyPQceW1eisPoDX4CMyvXtcU+NDBLopS7RKOLDmHi8AiBx/hnnidkzLCPf1V5TRmWUldddt6hSFdU/X6YsGO5C4GBxBgKK8ngxEdECSsdcj6TsY0e5YGBkEDKeafnUvWtqQBuXAhvIv9Pa+nfdfXuMI1+ZgByb5TLD+jdZqMogatUO8NbWhDJ9MGgDzWyBUYXbUQS3QZAgq7Vpl6i3DhvnXO1fo2zfslIXitYtaduliuzyVcUqgFTOOdG0FAN/LOq66m3iaT2CurTSExyyg1gdT9XJdeyN7SxqP7IC8jO5/beWswE9qs+0Tq3gDVEnCHFebVFA/UHSZVi9u2ruLm2T5aZ3BvW2Gx3IZZVpzQ0N9vK4KBY59gikwaG3JTy/k8LIIjqm+zr4wjn0cEyDJeZ8yVq4xCOAJQItPuiDhyFABwAkDnf/ukigC1yj+kjgyxZ6AQGfMhypjEokQ0OLBTAC8RDBJQI0RyCqZFxniNhnUxqhUz9E7mCJHX8uj8GDkVwIfXOlSh3UkbcwbWcQQvye/RKYZRAEhjY8LBzqb5QxIH8v53YOzlcXVqYqX7VOf10JqOfF2SsNDdxPt7NOccVhcszKUlLp07xrnpAoYcDlfjqPU48loPs8q0HkMmQ6p/IO+Tfl/h+0nn8JBj4b5wLJbVMw/KqKcNFWEHrwESGnetGdaQAETWgbw/9dzWl2dtTgI2VICzLvhUiVlW2Ce4z3QuIuT9IPIH8r4veeLY0HbEOWkkIeGa/WptvwztN0jX2ZMAxDrB2zX7hYQH6IvOGPjIzS2vV5kb2tCjQBsAchapJ70tgwTZQMJmqTbotYBBSSlP2gz0pnai9MhFMJE4LcpmYZFsuEm9s7bJx7TOR1bpHNoJoZv5yECJb4piFobAhwZCGmD02jPAkOT1S/pCS930cQETmkmR45rhE2aDsmvgrzErQlUD7sjnB/n0qMXOaIkbJke4eXqAo70xPrYcoVlNQNagdjGBo9c5OFjngYV32fCTx5tEeQaayLGZjvVRsJzXKDhTBZAUfAm007loP7Iwvd78h2+01ucJAbfTGJYGe4aHmg6GfSJ0KFpXsVaEc3/Y2kXnWoIyV3JBg1AikfxqnwTTRYBExsByqGFy5DU0KmIYgGAHn/h1OJdqPsTcquRzwWDG95c3e3Js9iTtG2R2Jat8q7QcKs8NsYkVcYhhtNabjek6sNN6EulK2hMc9C1HvOJrxayqkmGVlyr2fehbZToHxNwQ7Rah2QFWew7deW9ydXHnGOenc1hHuLqc4urRDPODCeio9o7mjYpypU2pMmARByeug+Xx1xwpGCTE0NI58Ai/EV9bl/yDeJ9Lig2/cyCyjtaZA5W0L8HE1fn3FwQYbVLF1zvjI5XZCqis86lrxDlcstIbhEhZPtgEAwzd59y2EJ2tRQh/HDLaq3VLm8ABGNQOF2mIoddrcen8OhDg1lxTOLcO1JzaD2VDG9rQibQBII9ByiXtgxKYkpTwtLRu0T7pGbJBIt1AdTjedfUJzCWXY1qOjLXtpamuQsKcyD0lE4nguC6S4xwMqHonYKXUztLmmIGPwIQ5Zj4CI1LoL9msDQMB1hglmhjxf1kBpjLojka4MprhE/U5jE2H7XqJm7cOML8wwqdawsqNATKo5l5zZAQMVpxrr2Znf04I6X1qdIdoGyTPnMq3s/AZz1ubhmsFfNzf4JitQAoz9q6z/gmW/Xpq4+dB57yzt2s90zuqPHPOoWnt2KDrDDAVRjImg5NMzL76mcNzBjLFREQcv70DvZ8TDhbUkc8rAY+SqVGMPLfT8X0COhIn/sr4EL4S6KDt4kQPAEWBECO+F8Thd3me5DH3eQ5UKwuztKiWHFpXTMKMACb4AWbH/yTfh4A+ZfIV+keY1pZ9dJwfS6t9OzLn9yj1plBHme9WtB7TCDya8x2q8ytc3D3Gxa05tusVLAj7yymuHM1ClKsqAx+Dmc0zSiPi5SfVPZQd0+cy8BGO6UsV41+sR7YuJ2Xp55eO5cezNiTrC8AaOIQAH96MiiJwdgCcRL5ioG7hfbAs5/yoEbWLxBjV8lpUqgNfWzdAtfSgv5t6gJOYA7qsLwrrcuqXxc0vMfT5uGRlJYIoLmtQE63asm4vXKddOeu0Dog/kjI3tKFHgzYA5LFKelPlhXloY+xpA+S+ddfp5+hrS5so1EagwYe+Nd9083ILjINOUmdah2pJqOYRgJB1EEkfTFomQTHvYrKSgxX9/NzEQ+qgrtVZ0Hv1zjdbrndi3qXK06E8NQhB1o8RhJCPrz83aKoJPl1bjKoOt27tY7de4vG7VwAAD5hdLKsJxlcN6iMZSwYQbLffWelTthgi8v4a7CdhOl8hsVmX72DSk6DIjJzKug2EMn0f+wYREUeRYmmrMPoMdIyr4JyBs9oPxSfDs6AQQhYkzA8l46TNa/SGLD4NtjIgDk3shGlvLYx1cK3xbW2V1ka0PNLEygF1lbTTm6FVARC4ip3jDUXTq1r8ZChGAhul4UplrmrtBrVe62FWFmbV+f4SsyKRXvO1EfzFfnDgcL+18eCujs7mMSqSC7lB9DwOAQGS+csAMHsXfKZ6r/VYnfO5PbqLDXbOz3Fha45zkwVqslixs/lDEmL3oEY99/4e1FLP5Kr3Xoa+ie+HZn7T+Zj2g25bkdYwWz1NyZp1srhO6HqvI3W+B4D4oIBIH6TD30Dk/WUgIXfleRwljjoJjQy/HrDPVNBwyZprvB9W0KaA19HGz7lqAdQLh3bqzfDsiIKQCGqNDVtFATQUBTqyVqp+SIRC2Rqa99WpaN3YZ3VdZwZWLPosMOoDPMAjLnNDG3oU6LSK0Q19pmhg0c1VwYHWLRY5462u7W0K+poTpCqyaLusHoMahSKTkH7AzLiXEPuCxwcWW5+2mH3aYnLVYnTs/SP85udDzXoJqpfQVUuHasUO7A0z3C1ipl5xtCyZeEg/aF8EkQrLR5jrk/q/1K/6emGeRJJbKMOb4ABmSaDjCvP9KT65v4tPznextBUuTY5w596DuOXGq6Cbllidt2i3gG7sHYA9w8vJ38YUPsIAe2aYfTA4VC4MO5XrMKtQTGqerE9rP8RJWzmwxwL8ebLWm2fZFLAk86KxqJYdzMr6sWxdmmlZA1Wk/VjqT++/wB92zg2Ao7EwixZm0YJWrQdcRHCjGm5Uxc+khpuM4WYTuOkYbjoGRrXPKSKmWFXFSQ0rH+2qlhDE/ttWJg25yyDbLB2qeYf6uMPoqMXosEV91KKatzDL1vt32OhgTp3vR+o6rwHpXNR8aBITqSrOX/k95LeSmDMy0yvJI20dAblootop0OwSlheBxU0dcMsSF284wE27h9gZ+8SCDy628PH9c3jgoV3MH5rB7A+AD216VSByhbHW6014n526h/tMgK1ao4rCm9I7O7SWaXAQ3ncKnzA/8zoOkZzvtZHBFHng4LJ3244kOIDqp86vHVXj18Nq5dfNahnXRsreqWTNYmFFfQxMr1iMj7yKpJv4hJgheIFeW6WO+dQq7TPyUQCtp40qAZZ83Kj/zLWWAln/5/VJ/YgG5siGivSRj3wEb3jDG/AN3/ANeOpTn4q6rkFEeM1rXnNN5bzxjW9kE2HC13/91w9et1wu8UM/9EN42tOehp2dHezu7uLzP//z8WM/9mOwtrQgRrr//vvxjd/4jbj99tsxmUxwxx134CUveQnuv//+a6rrhq6dNhqQs0pOrcmy+CLdC0/lJIfCYp6fUwUHyVVJ4lguolBoWn5PqqTLLy3sbM/sIyP5nAGAwejYwjQ+nKytPXMNdhqGA0yWCT1JvKXXIDmvq8H1sso5V0t9A9A4YRNLTgUNAlT/EveLikwkmhCo8Vbli603dV7SiAWhMxWOzRSfNBYj0+HW2T5uGB+hPudNnT7u9rCyEwAG9RxAA3Yo54ZTDPfqyJfrhFkBOEoWkGTRziIqJSSheYPdt0sZWw0sxBxLk2GzK+mfziE48lrnFyo+Z0eKcZcmOSTmS7ldfUiUltfdIrZLH4Nm2I0qi+9nJ15Y6jP8bHIVtBS1CQ7qAoDsiEIbpH6mYU3HslNhdPmbgUZR86TNrfRh0ZBos53OeX8fVVcHBlpSN/a/yZlq7e+hn2FHMcLVas+huRBze5wbLwEAh6sJDhYTHM3HaOYjYF4FZ/Nqlfl7rDOlygQbxfd7HSkmNxE4PFzGcpDZTQUTwXlbbsvWxaR+Lmu/U+smP0fuFyBCRCHylWkBkPf9Qpe+GxrgWUuAi74hg1oF9Y4BXoDRTgjNtje3C8IdCWQh70YO3HKQVqKM6U/qMHDdOsp9auTeU2mhSs+XebiuDZ9BKq5x16HMa6XXv/71eP3rX/+InvvAAw/gZS972YnXHRwc4Eu/9Evxnve8B0SEz/3cz8VoNMJ73/te/OEf/iHe+c534m1vexvqus/ufuADH8CznvUsPPjgg9jb28NTnvIUfPjDH8ZP/uRP4i1veQt+93d/F09+8pMfUTs2NEwbDchZpgJzXlz0SowxMmlQoYzEiTL7Hio70VKcpgm5lEsfCxdlj2SJm2k8Y9VNgNU5wuKCwfKcQbNF6CYswR8jMWHRmo1gUlD4lt9RiijRtfi3SqilwYdTn3hszU6krtHaklKSw8FNVRjoDpzTAzALAxzVONyf4RMHu3hguQMLwg2TQ9x57kHcdGkf7oYVVnusCZkgZB3vRiIxjVqQbuwjGyWJ5Yx6fudCeN5+G8VpvIphaDX4yJ2ynfMJ/sRPIvhX8AM7582Mms5rIpYdSEyQOBcMdT7fhWkdqsahnlvUxxb1kf+Mji3qhUO9cCzp5U/jfKQoiRa1Tmsg4EP8RqTuLFFzyrcDHF0ItYGbVHDTGnY28t/jivvHO553KtpXYO5sdCIPWcw7BT4STRN/ZDwSXw/E+nKfBr8TeYaE6ZXcIJU3B+vEIX6sQyIPTEnj51E7A1Z7hMUNwPxmi/bWFXZuPsTN5w9wYToHAOyvJnhgfwdXHtxG8+AU1YMjjK5WqI8J1YJASgLfi3al3oEINCPwOFk7m72baj1c6/OVX1/6nwauwQDTptbjUzGvGmA5BIBmdKQqWV8kCedItJtINJw6khlxNDX//ohm2Jv6hTwyXdrPjvya2MwIqx1Cu+3XCwmOIPmZelqPvI8eJpAIxTmU96Dsucn5NXvNuufouZG06xG24W8D3XDDDbjrrrvwvd/7vXjnO9+J5z73uddcxrd+67fiypUr+PIv//K11/3bf/tv8Z73vAePe9zj8N73vhfvf//78cd//Me455578Hmf93n4tV/7Nbz2ta/t3dd1HZ73vOfhwQcfxHOf+1z81V/9Ff7oj/4I999/P77yK78Sly9fxld/9VefqEHZ0MOnjQbkDFIOGghqvzlhsSs5/7nSfbpQLZ3Krxms5AnnT6BBx2wumzox9Xd+E62Blm3Mw2YnEV2c3wSlzBCZBRmzop9HCNma9ea11hSj2BDdpghU4ulUkqzv0z4WyeOEX88lvhZeokkEQw6YEzpTY7/awicqi2nV4PbZQ7h1ejWU9UnsYYUxxkEsyf7XRHDK2cQwODLwTqrOwGtBKEuvxnkzyERndd+H5AesMnDW+HvEVKiz/tE6R4YwaNYpoKMY7ZLpDDPbpnVh3AWMVCtm2DncbykqFlnnzaxa60FN1/nrZey4fcHHBEg0CPGFpKgdAUUQYMAgo+IwtqnU22cBN6nvh4tMnGkZbHRWMU/kIxZxfhdv2oYUMEkdpV4onwPAY2HYeZmCdk/M0oJDvMnGKTSCh60G2ilrPc57rcfo/AJ7Owucmy4wqVp01nhfj4MtrA7GMIc1zIJYYh5D7PqxWQMIFPDI34nkfR1Yk3pg/zS07p3HGmY0q3eqIeH5kN0T1h75UxIKOXXOgbVYFO8nJFpbS/7dFQGKaRxMR+znI59+KPOw9hZ85hIhDgDirPQ+wanqj9My/CVwl7dZl5P05fBeWHJaL7VTP7dkdhzqdIp97kz4fwBROHG9y7xGevnLX578/0u/9EvXdP+73vUu/PzP/zz+zb/5N7jpppvwjne8o3jd5cuX8XM/93MAgB/+4R/GU5/61HDuzjvvxBvf+EY84xnPwOte9zp827d9G7a3t8P5t771rfjABz6AS5cu4Wd+5mewtbUFANje3sbP/uzP4rd/+7fxp3/6p3j729+O5zznOddU/w2djjYakLNKp1z4ElonESww+SdKdDLpzzptSqkea49RurHlz/CSvtRWmZgxtiNi+2ME7Qfgf3cTQjsldFOW5AZfB0TtRg3WAkTbaccRYZIEh2oMcslbqj0a2gmBXnhdICk7cfpdB3IUCBGbbtMQzNygOxjhysEMnzrexX47w1a1wp1bl/HkC5/CzTde9ZqQcxbdzGtCuql8e7t90SZ1HA7WsUTcclhcxzkr3KSCG9f+e8R+DaawhEjyPTknOUFyE6LMaRqsZaHWKqm+Ms1yiNm+V16zUc87jI69j0R13KBatDBz+d9/6qPGfw4bVEcNzPEKZtmAmi6CpDxsru5+gnfenlSwE6/ZsLMadlKjm9boZiN02yN0O2O0u2M0uyM0O7X/bNdotvyn3arQzYyfm6NofmUabpNoPRxCPwWn70ppiYzxZl0B+PlxiBG+EDUhxgTfDWT+Ht58xwM1W1HwHbDs55HkTVHz1Gs+CKvzwOImr/XYveUAj7u4j0tbRxiZDsfNGA8cbePylR2srk5gDmpUc/KBJFYUmNdEo6E0ILmZVYxkh5BjIvHj0mtWaf0BUr+PcLD8KfoLlBjTNfflmk3tvxH6P9fIytihXwedaDFqLRRY0Ot11deG+PcbHA0uPk80o5J/J/qNuDgfVT+QhZ+vDfveDfitDTHyJ2l/1gmBkkh36lzx2fm+VSo739f0/BiaC0N0VkDIY5wWi0UAHt/3fd+39tr3vOc96LoOxpgiSPjCL/xC3HbbbTg4OMCv//qvJ+fe+ta3AgCe//znY3d3Nzm3u7uL5z3veQCAN7/5zY+kORtaQxsNyBmldVFETr5ZCZPW3FsCKkUfjZPqoCRXug6D5xTwCUIqJd1LmHHnJW2VdcwUUbQxVgyK2KIHUBI2Uf/tbd1j+cH8SgGY3kaaAbEh6mVf121cg02S/in0r2yWTn5rSRT53B0VM6DN4RifHm9jZ7zEuXqOS6Mj3DF7EB1X6JPYw7Iae7OXpTd7qRqwaZh3UNUmYkZCt3YAVdZnWRdzoM7ANB3QEUhSKYuPgkSGSsCFrzwFrQsiEHEu+oRI2F/pFuIEiCw5No2P/mQkjKxoCySak5gqibQfwgRGkENiQqUd6CXKlSWfGVy0CWw2ZccCtigyNcz86/H2UaCop0EI4xg0MwywLdjsKmYwNy0DNWH4jZ+3QetXxz5KJk3J2V/aoP0RpM6hfZwAUnKvZMy05O4BGLiz7f/qPLC4wcLcuMBN5w9xcXaMsemw6GpcXU59YsHDCdxxjerIoFqSD6/bIjUrUgxfvh7p87nZFWRsM7oWbceJa1p+yPXvOZmZ1oA7u08EEHqtEO2bSz8xopW/L/qFuQAaSfnnBN8QE7UhEDCbr4HsxO4MfDhq5/3s5FmWTVJ10soQuOOEYAGDoKME8IC14CPRJJ/E7FPh91C5+lAOTvPjCtgU7/kM01nxAXkk9JrXvAb33HMP/ut//a84f/782msfeughAMCNN96I8XhcvOa2227D/fffj9///d9PTMF+//d/HwDwzGc+s3jfM5/5TPzET/wE3vOe9zyMVmzoNLQBII8lkr0j38jkmGbiMbBOy+aVL8rXIuUpMcz5w6h/TXhudn9Qp6syQhZ1tdl652gHC4oCWbZl9uEg2THdIDI6uj78navbS07r/rhLNsaE2cw0F9phPe+XkqNrb9yQ3asZDg7Rm/CXHWCIYMnBLHzCwON6ivurPYxNC2wDF0bHuGPmF+iKHD413kFzMEF7XKGeE9wxsXM3YuhNZdbhjHdOJ2MAsQ/nPBnOxIRlIfdEZ4GuC47rSV4QC89cCcCQELXiL6JNoHKzNOeTFVJrgVVk+kmVHYFFxnuU/E/EWV2fcw40Ig96atEaGLix99kI2cpVXoxkzBnIJUn5oOaWi9cLw+ZDS7sQ5YtaBm8aAKlABgRKzmsKc8fEye24bwNoV3M2RrSiJPt8kttD5gGHb25nPiDEas9hdanD+NICt17Yx8XpEWpjsb+a4sH5Fq4czNAcjkHHFeq58ZGW2gg+er5nJaYTsd8SLcca8KFJv7vp8YFnDQCLEkgq+nEMMblIjw86n8tcCguk76tgiinzWvUJiTlVB1Dl1PyjkGhQAIl1XoBgnXIW19UzXhOMEUCWUC0dsEIQDonGJDd9C/IE9S44Ql+Lk69tqp/WBgIo9ZV6brgv39dUnZJ7SvsXZeez567zNdnQ9aUPfvCDeN3rXodnPetZeMELXnDi9Xt7ewCAT3/601itVkUQItGs/vzP/zwcW61W+OhHPwoAeOITn1gsW47fd999aJoGo9Ho2hqzoRNpA0DOIJUkgWpfKtq/JnbEBTpRoyIbyprre4s+FGYoLOglytvSqwPSTSvZ+HkTJmImzHnJPbUARj5qFgDvJ9DF6Cz5phMwUGaDHkAHgHyTDf4lwshlUbJ6gGvdpqovKwE5qQ+pcdDlE4I/iBGmdG7QUY2rtIWPALDO4M6dy7hQexCyU6/w/83O4xO7u7iyv4Xm6gQOFSQreuQ0/D+6TQYCgBTjHupLHljkdsI6FC8oMM0CPDxTbIDaaxeQmXIlEZw6x2Fm4cFlBk5CVToXtRsDoWUBQHJ1+HuiQ3nIlTGqQlb23GdDR9/SJjQ5KPGFAj76kZoGDiCwM/iKwcfSgytiYKfDHkuyQG2WFdot2gyjtBxKwyGgI2huqujzEf5ncBHaFeqIJLxuu825Pc5b2PMNdi8c4+bdQ1yaHgEArixn+NThDvYPZ+j2xzBz1noUcnsEwYB6R3ImVAsFoO/R80P6Jzum6VTS6RKgKFHOuObn1l3Li85pHJkdv1NhnZeyuA9CgkaZFwS4lqJZVcWRrWo2pSN4TUjltW6O+1NCe3tfkTivY9hf19OK9Rh56TfpQzYhO23m8yL4WDcOOVDQ/afGcWg+6fKTdxXp+aLZ1jrwcZp59tdBQwD7kZYJYH9/Pzk8mUwwmUyu32Ocw0te8hJYa/FjP/Zjp7rnH/yDfwAiQtd1ePvb3x7MpoT+4A/+IAAQ0ZYAwNWrV4Nz+YULF4ply3FrLfb393Hp0qVrbtOG1tMGgJxFyiU8SKU7+pyWrPKtQVIWL8LwopQttAnGyDbLdftvSb2d179X5zV1SSuCuNGCsYfa4EwnUj3nE3EBbBsdG6RzRSSPKkni9DPVDdqEJmy0OUORMVODEtcT2t5zPJVnMvPgmCEhAMZJBmSD1o5xxRI6R2idwRN3Po2bxgd4wvQybh7v45Nb53Dv7BI+OrqAudsCBQ6Fn+PEcTrANM+ItFy34JvhO8TBAuQzgAswcOhAyr3MaQ1HCGPL4GMUc2QkjDQAidxk0MEnLbRAK4x36uDt68ZaGGsBNrsrmiaFirmUqednCvgIpknBPygFGbkZjSvNgeJzOQKRRPZqPFcoWpdEmi5heHXfSd/wOARAJ3U3WX3CNRF0yP8h0pViLkXr0Y29uVWzCywvOHQXG2ydn+PSzjEuTo+xM1qidQYPLbbwqcMdXL26BXdYozqqQkZzSU7XAx0o/J8xt0kY7eA/kY7lugh0Pe1T8SIpJ/2/WL9C+WtBSwmE9MpIF904l+RdAveFi74wAhLYh8avAw7oEMYUI8DCwTgVbtuQBydAyHoetFKd97MD2O9u5cGNVetmbgKXtyvXApeAgPRbvyN0H/Svzfem0v1DYzFk1nUaOmn9PkvmVwDKa9r1KBPA7bffnhx+5StfiVe96lXX7TE/9VM/hd/5nd/BS1/6UjzlKU851T233HILnvOc5+Ctb30r/t2/+3e444478PSnPx0A8H//7//FC1/4wnDtfD4PvxeLRfg9ZLqlwZW+d0PXjzYA5KxSgdsPzAGlC6MAjpNsmh2XkZSTPatk3pVUS/GHiXRJX59JmsJ9BYlZcj3WHIdiYozfuCUpmjHekXd8CLhjZb7DoMHWafsH611oa5R0Rwmj1n6kNyiGINu4hjRWa0kBL2kPeH9JTFMsvO02m0N1boQDt42/dATrCHbH4AmzT+PW8RXcPLqK8/UxDDl8uDNo7Mw36JgSxi+AEetAFYE4YpirCYCBMw5UAbA+3wXayOyTIbiObcYqjnzFvh5hg1TZwd2oChm6hTEWMp0DjIIzXd6R6n/JWSLPIWHoqX8tPFOXmH7xNSH/RueSPDPCBAVoxv9IvpJ1IF80Z6R8Qvx4MWOtkj5KW6iTTOUF4KHAho9iZfg5CoRIF/khi47GlTIX0yCK69qNOEDBNrA8z3k9Li5wy94hbto6wM7I5/ZYdCNcXmzjgcNtHF6dAfsj1MfK5Eo5lkP1V+g7qOMD4EMytceu7HdyP4pcvKfkX1J8d09LLo5/yeyndH26DsZ/yk7xyhdLM/OV70+qnNLc+lwfOomgf3fjQ53z5qnh+WKSRUhC7UoCV4nIBhcTlgafOjU+g1QCD9q3Lgd864rS4CW/ntacy+8fqF+gfAyKhfXrvNZ07G8gfexjH8O5c+fC/9dT+yE5Px7/+Mfjla985TXd++M//uN4//vfjz//8z/HF37hF+LOO+/EeDzGPffcg7qu8fznPx+//Mu/jJ2dnXDPdDoNv1erVbHc5XIZfs9ms2ts0YZOQxsAcsapZG4VjgNxQyhdl22Wmoac7eQ+OVwylzrJ3Kv3/AHpVvGWrOyE4eN6OyWJcxWhm3jQYVjrEaSlVZTwatC2TrukN8ggSc41HpSNi2LaS884cbPNNuUwrvm3jZ0RfEOQbfTWm/y0rsah28JfWkLH2RWftPVJ3Fgf4M7pp9HsVeiswX24iFU19dm6DaEmxIc4gBypthjf7koz0RwpxxCMaBsMgKriaEwmaitaydjNjD9HdJL8GHZkgjmQkO0cTEWc1oJ85CoBMbktu5GBYcBjvdN6MO/KpYPiayE5EqwFmo5Nzhzn2QDIGZ+4TYBsNlcCwzzgFC2aB1u5ME5i+gfyEba8SZTh83xd8o5yXQkBpATzqirTcLDPR1IHFenIVtKOOOEs58NpGXg0uw7NngWdX+Hi3hFu3T3AxckRJqbDvBvhymqGy/MtXDncwuJgAjqsAvggBh/JOxEq0+uiMvjQ/wu+G2Q0o9Ahz3DeH4/y76R+mSClVFaQyGsQcuLaRuk1ev1QDDq5GD43aD55SsORj3rV8uJKnHAQqr8FvPEcM3BpW0mVmQlLwhySdU9lVE+DYPh7XNb+tcKl0A8o9/EQZf2arL0DgKa4b6p3Nwji1jx26Pm9+ubrwWeQyJ3Qlw+zTAA4d+5cAkCuJ33Hd3wHHnzwQfyX//JfEqBwGrrpppvwnve8Bz/4gz+It7zlLfjIRz6C6XSKu+66C9/zPd+DX/mVXwHgtSVCe3t7MMbAWpuYZmmS48aYR63df9tpA0AeiySLLq5hzXuEi1LJDnbIFyVnoJO9z2WbxQCjnvigQIEQ3mBNiyDdE6aKrI91T52/2BlwUkFKpKIlZiG0aQ3oSPojZ7BKTI/akAXIPazNQQAHIYAQp45pBs0wV1QDaFHj2M3wUWsgucftzGCvOsZtk4dgzxMmdYuPTc/j6mwL3ZUx7AGhPmImngfPGYJhDYhpfE4BkUyTdZzDgqtGiEn7IAf8WAVwIuApk+Jb+a0Tp1UAyISN1TgO0wtmjqwyxVLPSqJfqchYSeQrrSFh0BIcwbsKhm3syTpQSzBas5AxUUFaDwQfFPHFED8L4sSDXvLsuA2Gv9WEbxE0fJ7pU6ZZOvIWEMGHymCeROHiuloOy2r1c3jOWNZ4NDvA6pxDc75Dtdfg/O4xbtw+woXpMbYrLyV8aDXD5cU2Lh9t4ehwCns4gjkWf4+Y22PwnYA6p98fWzgufXTKRU7mwZCgQfdHiQmOnZLWs0e8ICUMbFgT08omeX6yZ+YaMcg0lcVO+WNpMOAqgILpHAtfCNEnJDxbrRPaJ0P3DQsxtD9TUn8dmCNrayjuBAbcUXZKT82hPh4AFuGe/Nnr6BQbZW/f0sezPevMmV39DaD3vve9AIBv/uZvxjd/8zcn5w4PDwEAv/ALv4Bf+7VfAwB84hOfSK7Z29vDq1/9arz61a/ulf2d3/mdAICnPe1p4dh4PMYdd9yB++67D/feey+e8Yxn9O679957Afh8IhsH9EeHNgDkLNKaxU5L3oD+AlxaHPUCWvIjGSKXbIaFOiqQoaVA4d+h+6Du0/XLNzZ1SIMQAAFkVNbFOPYj8sJ1ZvCCIzPXw9u2s0mB8NdKqpeAjhx4uAh+hFkKeQgQmZ/AbAyUkUt1VTfE5mvwJuWCou+H6tfcFC9KBolxQI2FI3zMnUfTVZh3I9wxexB79TFunz6Ic/UCN08PcN/ORdy/vYf5QzN0V2oPROaEaunN28yIYBugWgFmRCETObURARERqDIIoWeByPA7gIz14ETMqOqYoyJqqBzQRfATzIpImCQPFkJfVUgtq6hi0yobQUc4R14bIuZZeY4LCRcMjpMrEmTrYBpm/FVY2zyEapS+xwoJuKLaAxgBkRJSOAFicepwCGTNTZJKmsngjJlbsfu3Y4lsBY5SxnUgKGdztRawn4doPFZ7Driwwvm9Y9y0c4gL02PMqgadIxy0E1xdzvDgfAtXD2ZojkYxypVKLFgyPwxN0PM6k9anQMSF/xP/tnXMPWLZPTqJAR0CIvk1+rx+//icXpfDZSE4QMbE5s+T8my8wEfB8nPVCkBQkdaCBoS8xsSIGWbWXnl3pJ5GtCN8XcwJQnFddNHnZB346B1X7RzS3CeLuZ4r2R5woslTYZ/sPftawUqBHlPg41H0AfnroE9+8pOD5+bz+TX7Yjz44IP4rd/6LQDAXXfdlZx7+tOfjvvuuw933303vvZrv7Z379133x2u29CjQxsAcgbpVD4Sp1kT1iy4ufYi9ysplqU2x36BSDchrN8wTqt6T0CIAg3EQMNZhIzpLkgFPdCQ54gk1Scw9Buu3B9AhEgZM+dyLU0N0l1lm170a1FMgvZnyDUmoQ8UczBkFkJwcGIOpcYh33DFP4Ra+HwZBgAqLN0Uf9UZLNoaV3eneMLWg7htcgW3jq/ghtEBbp7s497pDfjI9kU8sL2L5UMTdPsm5A0xK58Q0laEiu3FXRuDXDkyqemQOM1aZRJnTfSvUE7XEvnJayB8f7gOgTnPJbteassPzgCg51orz7hJVDRtd8++KUHzUWXhekgABjP51oFsh5A1vDIcBIGd7iUqmh43tsMnfgmo4snVcmSjrF9iuyjcToaS1VlMr5JoVdLc4FyemVjx3PEaEAYm/LEjCasLNOd8ZKvtvQVu2DnCxekRtuoGhiwOmgmurma4Mp/h4HiC1fEYOIpJBU2TAQ95ppqT4bcG3wp8JKGvrdIIaGa0ENXMqQtOMr06lbq4tLYS0uWrtKZJ3QH0QkgXnhHWMS7HSdwB5ahvlLDBqMrbGpBEk66SWwhkXAAtQVAh76aBDyEtU33lUHECw6D5gOpDBTw0INLBCnp9Js8prJtJ851qfwY8ThSO5eNSuL5o7ncK4LFu7yuZNpfKfLgAZ0PAH//xHw+ee9WrXoXv+Z7vwYtf/GK88Y1vvKZyX/nKV2K5XOJLvuRL8Lmf+7nJua/8yq/Em970JvzyL/8yfuAHfiBJRnhwcBASEH7VV33VNT1zQ6enDQA5i0R9gAAgbuxIz/cWvsJCqrUgJ9lUl+qjF92eGVX2DFFnS8K1oTrp+ub7WnJaMfchPC0iEAEQ7PbTHAzRYdOOffbvdgshT4hp/TfJxqm0FgnDlGRgzjL/KuliL0JWviErBkcyDOemX8l1ulMy0FLqc31dyJi8kkpWaLoJPrWqcLQc4+DcFPNzYzxhehl71TEeP34Qu9UCF8fHuG92ER/bOo+DnRnaqyPURwb1kWdu6wo+RKhqq60BspT4QZD0lWRSFnAizHfnvGN0xfk1uO3UOUZRzFRTNIOKjVbAIrh3xPPOGO84L2X5C4DOBpOnxEFezzXOMi4O8UEr4xwkD0cMretC8kLRRMj4URPBmIQwdoZgAnB1XhNEnnl0jqLpVkWwKilknGdRexf8aqR5JtVuAGpeVoRuJO+ABx7tlkO762D3Guycn+PS9jHOT+aY1g0A4Lgd4aCZ4sp8hv2jKVbHI2BewSwMqlUWXncN85ZoOwYACNS80e2N7aDesZ56tPRofZvGp1iz3pSEARTfs2KyUlLlWsRFiVTdS3VjUCkFEhB9MhDXN29BlYEQBRws4HMCwfVzfAhOrzjPBz+8WrEZpUn7NkTXUmPWW+v1fqDq0QMfuc8I1Pns+El70cPSPGRl5pYAp/GXKJ4/w+AjvFPXucyzTO973/vw4Q9/GHfddRfq2rO0h4eHeM1rXoMf/dEfxdbWFv7zf/7Pvfue+9zn4slPfjI+9KEP4UUvehF+7ud+DltbWzg6OsKLXvQiXL58GU95ylPwFV/xFX/NLfrbQxsAclapICkbWsR7C6tcX5DUDN2X0ICEp3fNwPEAkIDIlBUokYDp/wvMfbxJAQR9n14kTWR2TcMhekX6J9/CAOXPQjyeaDzYrKsEPsRZVLIFD5peSTkMYkj1lXRcKcxoiPyTjb/jYz1NFoM075fBTqqWYNoKXUM4bAzuW9U4bMb49M42Hje7ihtGh9gyKzxh9mmcHx0Hs6xP7u7i6MoM3X6N+oBYkkqo2Pbc1gA5QpReUwzr2RGDEKTSVdaC+PFQfhUcgSrY/lvqSb49gLDhXukjzwwxkLEOZCvvzyFBCazPxI5O3ZuF6HVEHnxwVC6v9XNJ6OFemGCtQDExRhNVFE2olHmLaHT8O9Z/ycQHJnfGl/FPQS2lc1GBFjE39NnLgXaL0G4B7bZDu2OB3Qbb57zG48bZIXbrJSwIB80EDy23cGU+xdF8guXRGJhXqOYGZkU+UlJHCZNaomCiWAAgQaM4AD5O8ik4FeXgpFBWcb0plSF1coBY5yX3qfKclEvyO77XxOMXihXmXcCrdTE4gVXTzALoACLHeX+ggCg4whlgQB6Iqz4Pmcptut7LmhZ91Ch5RyOwVe0vrL2J8EPanpVRAhlDfhwnacRlb9ImZUVhnSr71ODlBDA0pKE5K+DjLNHdd9+NZz/72eF/8eN47Wtfix/5kR8Jx9/73vf2wvteK334wx/Gc57zHMxmM3zWZ30WxuMxPvShD2GxWOD8+fN461vfir/7d/9u776qqvDmN78ZX/zFX4y3vOUteNe73oUnPelJuOeee3D16lVcvHgRb3rTm2CyHFUbun60ASBnkTIJUcJoZsBicPHLjueSnwRkyDmcEtisIS1h7NWnsHAP2u7ys8Jtuh6ycUs79PXMHESzAgkrSRhVnkF2JNqM9NpQhoAPLaHVpiFcnxh1CMqOWjXepWWYVoGPTDoY+81L2IMkluCl4wUwpuujpb0OsW3eWd+DAmsdyBp0LWHVGnx8WePK0Qz3b+/h5q0DPG62j1smV3HzaB83jA5w6/Qq7t85j/t2L+LjD53D8qEp7EM1bEUYVSwFZybb9xlFTZH16Th8eGAXNCSmFRCXzpAQklbApHMMzhTjziFxnXD9CnT4XCKpJsU01ptcdR6AwRiEbOnaVCaAU6/5sFyWmDeF4dRAx0SfjEBKS+Pry4crw1qxPqAAkDqRiy+T0grFMtOx55kSQHCI+lZ5MNxNGHTsAM2uRXeuw2hnhfPbC1zYmuPG2SH2RnOMyOKoG+PychufOtrBlcMZVsdjuGMFPAoO5kOUAA3t46EY96gNycCHIfQct/V3TlKGG6hXAAJZH2brnBwK4CFhdomLckXQH29Wa6ZLMZAAkbCQqvc5PkvdyGZtWgNqOpXbg+cmxORUBCCOfKAGEXC04OhZMVFrtXQwrKHTgpeS1qK45qj2yjG9r2izrV4ZhXlzYl9ClU/ZdWto7d5YaMegz8m6ss4anREfkKZpcPny5d7x4+NjHB8fh/+7LlfZXTs99alPxUte8hL8zu/8Dj72sY+hbVs84QlPwF133YWXvvSlSfSrnJ7ylKfgT/7kT/C93/u9eOc734n3ve99uPHGG/H85z8fr3jFK/D4xz/+EddvQ8NEzl3v2bqhh0v7+/vY29vD/++F/y/MJMapThjanAleszBqoFGSUiULr+x9etMzhfswUJauJ9LrSptWsd5Sh1IbS30wNHOJAQF5BrxeeMmiMxIJKLbN50VAiDAjG71I9MPzsnbpvCDh/oQZRTSDEht5GxmDUvu0NDLZvLO+XTsmAs4IKTAS2//KcUhWwE4s3NiBZi2m2ytc3DnGnecexJ1bl3Hr+Aqm1GDhRvj46jzuPboB91y5AZcf3IF7aIzRgUF1TAyqfD+b1jusJyYc3A+mcwGAGe1cLWCPj5uGc19YBL8GHw3KcTk2OrGLD4ZE0KpN0ICYRgEQzSyJ+VdrE+bXEXkHcza9Sh3TkUS1AlTdCEXGVwclEKAaIm0FDZg3ywq5OSqfdyHMUSDV0iWTMDJotuacDRPAjslHtRoD3cyh2XGw51ts7aUJBGdVg5Hp0DnC1WaGB+Y7eOBwG0cHHNlqHiNbyRgHRVxhHUjanvl2lCLGxbJiPw1qLYaYTl1GYd3I+2qozkMS7STLvX5O/g6r57nsve35JOj3XHLe6PdZCzy0f4wqNw/RmySS7DzI94EBkAhZRNBiWl++M4RuDJ9ok5RQRtdzSPhbWp9PWrtRuAbZ+fwxJ+1b6I/fOgrCpgworQMfxWcV9uButcD7fubf4+rVq3/tYVuFd/hHn//vUdfTk2+4BmrbBX7rf/+/n5F2behvNm00IGeUEukLEDagkySPQyZVInwDfw+u+ZoJ0EK7IcnVAPhIHk/ogZBiXRWTQOr/Ynm9g4WNjZnudsJMFG863l/En/dMBYFCxubU4dllm6gLTC+CpFnATJAADviMFG2fTaF89exSvyZMqTBhQMLMJP43isRMwzPzBm4B2IXBfF7j4/MRjpZjXNmbYX9nijunl3FDvY/d6Rw3jA5ww+QQ92zdiP9vdw+H+zOsjurAqFYLQrUA6rmE6VV1s4DtCJXxmep9UjUXzolo0ytGTEiE5oGkBxdkPAhxogIDlFkTYtAB1b/+mOc4JNwvOQdqfbhd6mych7l5lY0dq3NthLFh4ADi/pRxlntUzg4BLn7e8vxh/YUGWTpJYMJ8uzgXNNC0FcUQutvevKqbOnRTBpZbLbZ2lri4fYybtg5wYTzHxLRonMG8G+Gh1QxXVzM8eDzDwdEUzcEE5qjCaOG1W8HB3BXm0hAjn4GMonTbZcBDypP1TZddAh+qzHW+IyUqrTsl5lObMupGkG6f1EWtqwEchMIzIYb8pnhz/t5GLVsEInn9qHPsW6TWpLCuEpxxQUsc1gvxn6v6ghcRkkgfDq09sRJZ360DAcl4rS/nVGBC7SHrzvcOq7r2rAB0lU6qQwF8nOq+DW1oQwltAMhZJs1cavDg+udk8RsEIad81hA4KYGQIRORIqOtj2cL/1ozrJxK5fHx/BkSDcZVQFepS3NpKAMP0XxEzQH1NsigWVDaBQizYqPU0QMQl0gUB7Ud0q6cl3L9fT1l7tQF5P8EpkN4eGGiNLFJlus8k0ItwSwrdEuDK4sax4sxrixmePDcNj57+wHcNn4IF6tDTLcaXBod4batC/j4+XN4aDHD1eMZ5sdjNIcj1Fcr2AMPRiSrcgRl7IRdiRkW+4qQ8+F7GTBRR3C1U34XfhycY58WMY2iCCp033jmjmLOBPETMfDZwp2DMZzdvfP/+5tloKMPimfWfILEYEKlcnwEEywXgUisDCVzJoCSMIZx3LU2DTJmiiznYLG1MI8c0W0MdDOg2XFoz3Uwuw1mWytsTVaY1i22RiucGy+wW3uNhwXhSjPDldUMDy1m2J9PsZiP0c5r0JwTCS498DAtUuYVSJjSkkQ4t//vazv0FMyAR+i3eL2U2zOZkUuHfEd0cTlgCEx69szskfofvbaW2hOul7YozbGEzxbzwr72pA9CBCTAwc81h7421vlIWfJPD6BKfxS0oT1S9SlpLIra1+ImUTiGgfW8VCbSPeW0+9jQvlEEBwPAMdHgnET5HC2s3Z8pIsmBdJ3L3NCGHg3aAJAzSEXNgGJi10qmXOSJEk2CG76tCFoGLk42oIw5KPpv6HqcsFAPmprwd29zzOtA2QZr43PFPt4/xwVwAqRAwVXRjGXI1KkXqtfCR9PqoMyMkIQmlX7QwGZog0yBRYYImRnJwZyT31yWhONNNFryLbbjlkIEMNc5UEewqxrNyuCvFjUOFhM8uLeFB3Z28bjJFWyZFXarBZ609Sk8fvoQju0YV5oZHljs4ONH5/Dph3YxvzLGaL9CNfdaJa9p8cDCNJxTpOHfrXdUj2NGrKXKgJUwtQCIxI4kMu7hvPbB8KnTU2bG+B+WCFRlk02SDnYumHiFsLajxBEkfX4CGiLYSRyVA2hVL0LGwEQmKL6MlkGHHfsM5XbCplUTBztx6LYssNNiurPETTvHuDQ7xqXJEWZVE7JjWxCa/397Xx6tSVHl+YvMb3nv1QZVLLIjoDIujehBXNplaNRRmHFBWrRbRUWdsT20IqOitJRCI8iRkeG0joMcbUfsbmkF26ZxpATHFtxAxFZBWS1bBaSA2t7yfV9mzB+x5I2bN/LL92p5r6j4nfOq3suM5caSEfcX90ZEmePhwRQeHZh7PPwej1lzqlXHbi7PBlWbKVLnvthSn2VEI3jGwlFF17ctSTNmWZDIRyN4PIqKW9aVdRJPIlbB7yBhyLjsD12jR9YqmO+4tAlSYu6eQYX9wKZRjTF20cBZaV00OraT8Z62gzupruwouHuR6EEY4SIGkRvhu2ARpqkfzBN0/okRgJi1PUZeomnUHrrI7WT0edA6aEtcEhISAiQCskTB3ZDoIC25KMUGX05C+OAdrO6BDbII37UXHuEERuVm6Wo2mQV5uomQKg3uFx+Q/U8CBmfiA/4oVCcLUJGHrLC+9BPmmFKv2GpDLDSd/Ohk6RRsR0AImeGkRbuVbOa2pfieE6L4GZkB6ocuTvRWrsB9xKEEVGb1c2cZgNGJ3P9KK6PcFBpZkaEY9rBpkGNmpoc/rFiOvZetxur+NPbozmBlZwbL8zkc2HsEB/c3YHqqh/uXrcK9y9bg31ftgUc3TWF2ugvMZVDD6qK6bGCU3HwO/secqkSVGNZJAe/OZk5Uq5T8wPpRmoIHCiJxX+F+8l7hIwTCHxvsCEgnM64qbpS0bRPsDSBKY6CUsYMGKl99+gHSjyG88broKYwm7SWBy8yxucWyAuiXyCcK9CcGWDE5h9WT075dlnXmkKNEgQxzZQebhxPezWrT7AQ2T5tTrdTWDrJZsr9jpOR9Gg3g1g76rCpf9VN7J9RZEA8YK0OwN0NKJ5Yul4F8X/65c53i8SSSRcqilCUJjjxktgqUa3rbCemGfHvogrlbBmGfyly/r8YqQ2Z0KI/LwxN++ywLZQSq78KfuEXJFy8vGbvp37XFJqHP+DKgihMjGq2sFyR/CVGC0UA8mlyoGudUaX5cCiRkiWxCT0hog0RAdhU45YeTEA7hoRS25tLlordcCYpNUoErGISJKTYh8LQgD+zjonuFksvsJ8mQzSjnNlXecRPXAACGwUlEQVQCug+MJo1bC2BJxUjIhKwQV0f1sk2jYEoE8bt25/h7ZVg75TeM7xVkDSjELzgTLWYgipJVijKi9/g6YAqC0u4oTwU1yjGam8BDW7t4ZGoKExNDLJ+Yw6r+LPad2oT9JjZh3+4mrMhmMTU5wJruVhy87BE8tOdyPDw3hU1zE5gedDE37GAw18VgmEHP5VCzGfLpDJ1ZhXzGkRGzSR1l5WLl6igbwVhoSkIefZ9TnrSEm551RVYUvOKvSu1Pp6IkxmxOV9Y9zB4x3FX+MAO+okzT5ATE9Fvtf/dWM7ch3StzisS1faNrrB3D5eZ28tGqElgxxNTyOSyfmMOK/hyWdQZY2ZvBys4cVnZm0M0KDMsc02UPW0d9bB718ejcJDbOTWDzzARmZ7sopjtQs+ZUq9wSQd7fai6NwscWtXrwMPz3yEfbVnmr7RlpAD21ipKZwAUMoULMB0hz64s99Soj9UTrhNabskZFAJnSKP1hBbb/ZLSIJpHAAqFoGWGPiYbPv3TkAjAnZDlBbBHd3qFqA7oOTunz8vrvQ6o44RkhQ1I47pbmi0fjkDrjxMW/p48bSEEsHJdZjlC9G5dHG/evWrw2JDghIcEjEZAliGBFyz10kwfqg6M0gIpuVRGMM11LZENKw02YNRnJwM/TiPr7KhatxSIMd6OoB6hk8RuOR9ofDesUXGhDPPKhJSGsLvnJVrQcQfmU9d/PzCo63bQOoDrxxrtuVYpBqKhWirK2Zg6lQ7moYhYqh27mN+8zRRZfrcbklSNPytxGcoVspFDOZCi3drC118PW3iQemhzh/qkV+O3yPbDvpDmud8/uNKayAQ6deAgH9x/GbNnFdNnDlqKPzcMJbC16mB71sHXYw9ZBD5tn+pjZ2ofe0kFnc47OVoXOLJDNIdxkXwK6o1EWqqEPVJYPd+IWJSueZGhtjwUm9epIQ6a8hUxp5cmJvwfB1Tdrm6D/NvU9L4shokUX9jQym1fHkI+ib/d0rCrQ3WMW+6ycxurJaezRm8GyzgCT+cCcYKUK5KrEsMzxyHAKDw+W4aHZZXh0dhJb53pmb8dcDjg3qznlLVHOzYrKT2UMa5aUKUY8YoRDUjppohHy0crnnCi1FQltQVDC9Yd4HMVIiCMRLr7dW6WIJQJaVSQEGiVURT4EEuJdLWm9AvaYcUNifJ6u7+T2miMrlCInyukc0P7Ya1j3QbvgAdv/maXLk0ypjSTyQYNECEvNsiWQ1CA85LmqScEf57JVy5uSz5bko5XlP0JqFg0abJVpO6WZkLADkAjIEgV3T1JAMKFLrlKtrBl+tY1MLrqKKw7OTGFoJDduQuPvY7LQvJyO6crGk+ITG02jiRi59K2rj7NIAPCKZjbS6Exr9JXZAxKQFbdnAuRkqyKsQy8X2YPiViDpBYXU8qJGxgUpH2q/advFq+Ij2Axfs264Z+7uBKLUBceTZhoolT85p1aHCmxfi0lLFRoqMxuT9UwO3c1Qbs2xqd/Fli0TeGBqBdZP7Ym9JrdiTX8rVve2Ynk+h4lsiNWdrVjd2Qr0gQIKw7KDOd3BllEfDw+X4Q+zy/Hg1uXYuGUSs5t7yLZ0kM8ocuEdrIuaCpQmV39BXZCDBLQjKwrB6q8qFbKMKI20/Lbj+X7B2lWZ6gvIoEmzutHeERZVAiqv7kPRyrRj0VVmP8ekuZ+jmLD7OTqA7mqUvRKYLDCxfID9Vm7B45Ztwp69afQzY4YrdYZSZ9g8msCwzDFX5tg0mMSjc5N4ZHoS09N9jGY7xvVtYG8st33M31pOyR2tgiblifW5tuQjUPyk9ClBFvKrEnYyquDvKt+WGhJVukk+SpO7dyQZXD+iY4Kyn7omF/hZpmC3V/mLA7VbdFBVWs4qC4AcvVvVYZkbS4rbA1bSY74JKXCWWAw1OjPGkpgPtCG5E6avAfDH8wYWVtTnD5q+SD7GkUqBfIi/S2FbIhZnwa7DjES0jgfU6ychIaE1EgFZiiDKpbjvg60ESZNIlHzwNGITipB2feIfVxAZPl1h9U1BLtO8xnmbJo/nJ19tViidf3XRMzlnhUZ3WkPPwq82ll3AbSBVJbnnQlfEpCQX0mn3j4JPn96OTt22+Hn97l4Ip7A68kEvVXSrmE4Jr628O4IjHP/pFXdWJzpD5btO5Db+6KpSojMNFArZUKGcy1DO5ti6pYvpiQk8OLEckxNDrJiYw/LeHPboz2BVdwYrO7NYns9hypKSLkboqgKT+RCrujPYd2IzNixfhof3MLdvT0/3MZwxSnQ2yIwLnO3UlHxUN9RXF+RlBVndd3Xh6sPWd0k2i7t6ERVl1i/dTffOpcWRnuDktA69v0NVCh+s1aMPjKasa9WKAmqqQKc/Qq9boNspMNkbYkV/Dnv2p7FXfytWdGZRaoVNowk8MpjClmEfc0UHwyLHoMgxM+hidq6L4WwHeqYDNVeRDrOvSXkLm2TxGKf81dytWoQN6tTWZ42D+HR1NN3AskTHqzHkI/hbUnjZ3wFY+CAtoixrywtKR0IKe7yzJeylJSEmrPkbQP24XeLj5sdD104lzIJJZkiMv7UcFemg1he370NpcwHlcEphNGXIjxoBmdsPxQ4WqFnwVPh3MBY3kY8YIXHhW8wVTQtmVOZono2Js/g0P+kZUJtLQ4vz/L6lnYV0ClbCroREQJYiiBJESYhH7DkNMg+ysBAiUVsBZYRmXD6SZYcq0BLGTR61/OkKm64mbp5mad1h6Eo7tT444pAN7T4FwJ8so/Nqn4BYRieDNsdmqsIph9pvfq8sH9Wt6j5t7q5FlW8Nf6pNsHdbAc59JFy91nZpFn4fiyubVhX58Mo3tYgogG5U51aRUbeDTb0JbOouQ9Yr0O2PMDUxwMqJOazsz2J5Zw79vNpQk0GjkxXo5yPsO7kJK3sz2DLZx8blZsP01tkeBnNd43oFIMsrrbYEoEsFXSjoUQYMM6iBsqv8KuzPjnwMDXHy5aKnFNG+RAgLtXKVXaDsanNEMA1TmobWuTY/Ll2+GTi3d3QsK5GvGGLFslks6w8w1TUXAvbyAhP5EBP50J9i9ehw0l8S+Mj0JKZnexgNOyhHYbnNZnIFNSSkg1qMBIwlH3R/wkLJhw/gXxFSo2thpW+osvay1QSex7gxjI0rNRchKYHaWEIWGoglLUNYV+a5tYToyh3LxfP554C/H0bp6uhjRp59X2P1RseysgOgC4wy5Y9o1pnpg+b0uaovcsuDH6fohvVIXfBvK4Cq0hoLGpaS3FjeKozbysKGhRGDpjg167+VbaGLcdsdbpzf3mkmJOwA7PYERGuNG2+8EV/72tfwr//6r7jjjjswPT2NvfbaC895znPwrne9C//xP/7HWry1a9fiIx/5SGPat99+O4488sgdJXpt0Ivup7DPvLIvDdq6erSQQdv5x0sEIuorbIMq5zhNFJAmS04rFxKJmNAVUDupO2W07Kjqa3CBgpOqNFEmrTtNF7WbgrX7R1d14pWHElAjHez3oESqdLeVE/LhCIK5Y0RXFxw66wdty4wLEpadW0Ec6fDVZZUQT76oIqRoeBWkoYdAlitblznKTgeDbg9zvQk8OlGg0yvQ7Y3M/RtKI1ca3U6Bqe4QU90BJvKh2birM3RUiX5nhKJn9mSUZYY8L9HrjDDZG6KXG9KS2YqbKzqYHXUwM+hiVGbmokJXbK1QFBmGwxyjQQ49tBWUa6i8hMrCjuRO+NUlUA5zYGgLnWmgWyLvlcjywobJUFpCprWCyrRPz5GjUZEBlhAg11C9Ev2JIZZNzmGyO0LXpjUscxQ6w9yog40wJyCMdIbZkTkKeWa6j5G1CqlhZvuP8m583goUO8VKWkGOgLu4jVOsOPkYC05UiHI5bp+A/90rw27Aa45P3UtbD22cHLm8qfKuFEpH8rVCps3xuMY6ZkmItkObc6dCFV+7b1ZVaWWq+u7KHNAdsggxgrdu0bHe7yHKq71mSsNeJllZWflY4V18HflQVV1JqC06UWIgkQ+pL/KwkbFcsrxz17lxmM8iXAxN31KVUeR5QkJCI3Z7AnL99dfj+OOPBwBkWYYjjjgCy5Ytw5133omvfvWr+OpXv4qzzz4b5557rhj/oIMOwsEHHyy+m5qaWrhgsQGtYXXKvRf3aFjlW15dDMnJOBISkAOuBIOlBzah8PRd/DFKUo2QkDixiSZYYVNVlOC5JQcltL9YLlgJ1KhWs7WZ3EcTxpc/sE6QyTbY6OkLwKwedDUyq348+SDKgHfXYhvVw7jViUre3YZuNnXVpc1t4tUtz6yiS/ijen0d2P+DunPvFMx+EeciojQy5W70zqA7OUZdYNTR0EpXy8UdjaxXIO8W6HYLZE55t6ShKBTK0lRwWSpk9ta1yc4Qq/vTWN3b6vdGzJUdzJUdlDpDpkrkSvtV55mii83DvndfAoBeVqCbF+gwc1gnM40yKDuYGXUxMzSkJs9KdLMS3bzw92sMyhxFmaEgna/UCoNRjsGog8Ggg7LIUJYV683s3SNzwy4Go44va1may+agFbT9KQtlCNMwM65Vdh9HdfgBOTqXWivA+j9vR1ThaNggLksvlkaMfNQUSCYXd20aiyYFj6bdJO98IJB3Z0F0e0Wq78CcGmdOP1XmPhlXf5aEuKNxSzfgElcsJ6cZS5QNY5+5e2DsqXlZbtq7MzDjAZQ9xMDKqbQ27mBkwSIjLol0vPf1Q0mIUF+iG14ToSD1FlPeo1YSIkPgpisFldobQt+j4ecJSf4m4rQkkI7hTdiFsNsTEK01jjjiCJxxxhk45ZRTsOeeewIABoMB1q5di4997GM477zzcOyxx+LEE0+sxX/LW96CtWvX7jj5VPPfNRJAJ0wehw78fPUK0bG+UbaaokEHaBUJq8n7yGQRrBLWMpblkdyfJJlrcQrjHqVLbTeM0svx7MRuddWiq1BMWqVAV0f4BptI/TGwlazV8zqBKP1+D1RuV6oKmxVGkTB5WUXdyUjIC21bfweG9lnVVhApSawKSysLlVXAkQ3yu7eIBP1LmT9HVfn8EbQkntnj0sGoozHKYchJRCkpMo1hv4O5uS4Gy8yQ1c0KZN0Z9LMRludzWJ7PoZsV6Crzk9lKniu7mC7MaVxz9jigXGn0spG/M8MhR4lMaQx1jpmii62jPgZljlFpNn+XUBiVGYZlTsUzHFUrjIocc8Mu5ma7KAY59EgZlzdbxyWAkepiTtk/tHEbg3Mb8/1HIad9xT53BwNwkgvElS5vJWtSLrm1Q0MeP8DeR5RAMSxI+HHpE9kq64hV/scgSr5cPdDvwckihZfGNdtG7jsA3PerDDlR9r4bZxUhMmkNu+hgG0VQ+v09MaQMzrrhrJJqpIBZevBBNXaYBZXqpCvpWPBgXxr9boH6WE7rlLYHJ098XpHiuNcsXO05l0N47/6OclKpPC0RXXiTSBZ/l5CQMC/s9gTkWc96Fm6//XZ0OmFV9Ho9nH/++fjJT36Ca6+9FpdddplIQHYWFBnYa/67IMrkmIEwGLjd5MvSaiOLqJS4tJxy2jABKM3mIEFB8DLR8oKUlb7nq3NcPkGpoKt7SsO405RA2dGAUii9W4LdZOo2FNsJ350wZO6vAPgG8Zgsfp+FIuTDbXAm5akux4O/a8SvjlLyQk7JcptT6U3s4sQZUR6D+9jIYholHn6viKCM8GeqCDP2/YZYbkQFxR1ZmsEcSdrNMeh3sGGug62zPTw0uQwr+nOY7Jh9E52sRC8boZ8V6GcjT0BKnWGoMwzKDoZljpHOkEF7Fy6OTJUodWZdoLqYLTrm/1EHg1GOYZF7q4WxbhCrxUhBD3KoQQY1p5CPFKQ+TZVw066q6jPsfVAnpA8HVq4YGJn0j2n6nIBIfYLKQOI3kR+eZ1WmpkEhDO6+84pDCSSE1kmT4urIMurlpN8jTTcYa7T7XZvT5Ki7o3XhzJQ26xSK7SVz37MnMLoaV4h8mrUXPbAiSMP1i8zdHWO/IbtYEbQPK6cnK7ExmvcTUv5goYHWbxP5oPUZIRmidZvlE0Vkzttu5EOxd7yMSw3ElXm7ppmQsAOw2xOQlStXNr5/8YtfjGuvvRa/+tWvdpJE4yESAKA2MQSkxb2PTKwx8jGOSHD3LdCJEkL6Qj6BuZ2tnFFS0xq8HlxyjIRQ2Z0yWMLelaE0FNkUrjNDNrrTVhWy7hD0pCNXXnFicnWfGZLj29DvuZDJR+B25RVSKpeqVj81Jyxh+bVVeqo24iwQQWNpkHYhr3RmH0kExP4fKBW6HgRUFja5+/dZ9b/OgXImRzmTYWZLBzO9CTzUK5F1SnQ6BfK8RJ6X6GQlcrvXhJKMosxQlJYoWOFiJAQwFo1SK7N/ZJSjdHtI/CbvilyoUlnlz7hIKXffRlGVKba6TOtIUmr8CWWSklWi+dtk+XI3mlq+sX4bkVvMkEdvq6S5/uDjaf+8Uv5Jgk3jiJS2O7mMjDG1AykcIfbRdFiHnqzp6sNyinwGe/qVtns+qm+8Zp10chAiglo+5o/c9iudmW86nzX3Frny0rT9AgjbW+bDEkury6cJWoXjjq9LUrYqsJMhDEvj1OYGMVNZDo4aiYyQG/q+jWWlKQ0xbzLOLYT0JCTsztjtCcg4zM7OAgAmJyfF9zfccAN+/vOfY8OGDVi9ejWe9axn4Y1vfCMe97jHLTxTvuIkIEpCnOIuKDk1EkIUD0Um07GysTDUqhKTi8tTM6nT/RRAsIJYI0jCBFBlFMmXKiF04gL8SVLKKRgje9kXtL8Nu+ibS7/yoUZ/k65OrCLEQpKBKtEuQ0qERN9pRz788bKhQkb3jNAJEGTFlO5B8X7fsby4LPbOEJ8fUSQUTD6e0NFiC/kESi7Jg5MbLw9XKpyClgFZBug5ZTbm5rklJhqDDoBcm2OC3R4TWlavCaJiYiDvKALzIswG76HyhCIoD3ONCk4oc4qbpJBxcOWN1otGcIdEU/wasWHBRBcrIqPoFkXfKdTLRGSQFDNRLpZG7fu2D7nyT+XwYxkNy7Ki/UdBB26EXmZKQmi6CnavlA7HDTdOaO0Ji5OfkhCUCF3n6ffgyuO/FS2OW162kbZ9EcEpfH7MLMz7TDiC2pWHLqRopUIXUZo3J0ptIIV1jUHHhAVAdJm1eS40jdZWExZOIlfb4u61I5CO4U3YlZAISAO01rjyyisBAM973vPEMN/5zneCv7/yla9g7dq1+NSnPoVTTz11YRkLg6O0gjOOhNSS5SQkY4oSy4Puw+AruKLSIMWJDP6xfGBl8vGpZkEUjkAhiY2PwuQa6Hbul7L63ymR2q/8aRQ9c+LVaJlCObBHWjqdlhEMKjPdIB6u8utwldI+Uu5/60LlNqxTpY7u/XDtWLnSaL/h1RO4vJLTX5RHwlKFRRHxnHJGV44D3dKa+mt9w8lE31El1/U7V/9UEeXKMCUzJWlKt5+ElElnumoHqnx5gUnaYbUHoMqpJxXc4qHD905e6n4XuFMRJSyqUHEQWf3lkdL3SGUC+70hXXHFep5xRMVO+j0CMR1XRlS3kPvvwo13kfHNx6cKuLWyaSggs3snrDJfs/woQGXVXTwmDWX6ulXYa8TN3t3j2yeDucGc7MGKWb+8qIJiW6s/14+Iq6azijhLm1tM4ONpMBY5d1LSb/ycwPsEqxvaf7fXnoemdLh7V8xFq8m6EnXviuXN2mKsfAkJCQtGIiANuOyyy3Drrbei1+vh3e9+d/Buv/32wwc/+EG86lWvwmGHHYbJyUnceuutOO+883DttdfiLW95C9asWYP//J//czT9ubk5zM3N+b83bdpUvSQD5zg3KIAp/FRxDwJVip+3WjQMonwya0tCxiJgATYf4pcMp6BKvqeORDi/balemILWuAJHyIOXx07k+bB6WHbtiTS5guoTZZMcBepWxWHL44/FDEgCKkXGkY4CVisiYYowD6dIBRvWnQmCEgq/Am/icEU9KLqkhPjnxt/enZZFu5arNz7hu4VcaaXZ/+oIJj8JCKRPkn4XU6iVAjl5ywjErS+i1YfKQ55HlXqu4JP4lHR4Wcswnn8ubPp15YyuHru4rE4CfZ3kQ60yQXFjpCc2pqjw2w/iRNKJKYcc2vom1RYXNOD3eHgCGd5l0+TG6fuoU9Qd+ciqOtYwJ1Z54uj2bQHGNQ+orHh5lY4R0QpKyKUC7OKFBl8c0Jny3yGKsJ243EAljy+LJwxVHdExJOiftH5dHNbfKkVchwTZRxT6LZWxQRmXFpPE+YrLLPSzIE8hPn3PreLzIR+17IQytzWURuttMZBOwUrYhZAISAQ//vGP8Zd/+ZcAgPPOOw+HH3548P4d73hHLc5zn/tcXHPNNTjppJNw1VVX4T3veQ9OPPFEKO6rYvGxj31MvEuk9SppECicgCkJkciJ14GI0uf/liagKrm6chSBWA42afh0rFwB4SGKWrD669KOTMJB2kR+Dq942zB+MyqqOsgKAAOjSJTu0kGrHBiFT1V1OqouEys6MEf15jZN6kpFZbOr23Qi5hvYHZHwbhRkI6nPm5EPWqYyR3j0Z4MiFKtHrxNLCoauh21Kk7vCBV5PjrzwdlXsb9pORDEPFAPyyzg3kOAT5Uq9oNwEhJOHk2Snv0vfAOrPau5HNEgDYeIKYVv3EG5hEBc/hLTEthIzqNL2P24McdY2gYRA6XDcaQtHROyBBsaYYe7r8NZfTxjNjeNamb1BpSIXjPpvx1gPaPl8HyAKa0X6zV4gaHP8dkDOlFtMMJH8kbmakA9qPdUwVhhn7XDjJf2uG/q5G+tqpFnoR7T+aukuVBeNxGtcwCJzF7cSNZJqiSxJ8WPl4fXI0q7lS9t1sZEISMIuhGx8kN0P9957L0488UTMzs7i9a9/Pc4888zWcZVSuOCCCwAAd999N376059Gw5511lnYuHGj//nNb37j37W1LIwdeIGaAtLotkTBiUGTIhdT1GgQQdEM8uKrt4q9Iy4GUXkU+x9VmuKkwuQJJ3/zLiuAfA7I5zTyOXK2Pk3TTpTZ0OwTKXOF0SRQ9Ow7Swz4hnWvENBjM1HlX+bspCziSlGlER696RV7shqrs7D+afkDxSnSh0SlWIdyt/pxRExwHaE/AWibsvZWOiz3uLyb3oG2A1HUAuuVUM/i96TCHx2rV1q/rC5c/QZ7e4rqb17/EgFqVa+kXWukp6lc0vsmOMXcEWpKQoL61mEcGpbVYfgdQFai3XeQw1zY12Hfg6t3d+jDCP44W4B8c7m1avK4fuyrmKIP36lIBO2rhhgZ185iwsikNKoN5s7VKq/yCr6fktQN3d+Rsb5G6oT326oOWX0RAiWVlfYlaW5pu2DG40kyBW0aSZfPgbV3MfLBIaWv62kk16uEhO2DZAFhuP/++/HiF78Yv//973HCCSfg85//fNSCEcMTn/hErF69Gg8//DDuuusuHHXUUWK4fr+Pfr8fTafRnA1USgIJ6y0h7j0flCNKqH/Nn2n4FUq6aknTCqwomskTKVMQz8VVECcR/97J4iZdmi9VomNlEdL0srp6I7/7dKxSmPnFJW1uTneTvf0/s3s2zMlYGlBm43I2NMREkXoL2ghMDlcGelqNonkx8uEvp4NfodWZCskLbbtAaWJ9x8b1QlEZ3Sq1VaCi1gEqNldQAH//An0Y/MmVESIbfccVA6nvuvTd3pNYPpKloNGqwaEi77nCw8hBUH+S8i8pevw7lNIQvoeavLFXOkyqyaJRa2NeD6xvATDuaC4gcVlz4ww/FtdvIud5k/0diqXlCuL6snc/dNl2bD/Wylslzf4p891C2ZPwVHUvj0ujhDLhpHKChLXtVMKknZNLRDPA7FvS1Sl22VB7WR1J8gq/Pd3O7wlz3yolKFI/aIJi/YOMv22t8I0WNpaOivRNcdGpIe/oGC/1eT7OZPV34+bXsXmP+9Z2JpIFJGEXQiIgBA8//DBe/OIX4+6778YLX/hCXHnlleh2uwtKy8UbjUbzjisNuOIgSRVKVIraOBLS2ufWRwjTjyn+nIRI+XFrRCAazQeVIkJXd3WJav8HIE4SQZmI8uh1QBX+HpRJhe9pOs7dQhXGTUNrAJndG9IFRlDozBhLSX9TRThUAT/5VSfXhOnzk63cZtFAAaaKLFC3fKAiD5XVhGxad/VgXTnoBnS/cpqzwluSUxFEFbhzNbnfxBR3lwy1ItGTwWrEwLnQ8PdcgYeg1FAlweqWtdVVoHbUbVCuBgW/FVh+UZcXIW+pfp07TU3Zb6MQtVDw+HOflxioel8nhMSdiskVjB/0O/XpsLgMwRHOCtClglLa78FyFgJDMqp8kQHowB7HXL2gp0KpwvQHlcG75mnrxujq1J12RS2a9Bhh+k1nAMrSkBZvhXOEZ6ShZ4DOrCEXo75C0Td7x7wsI3oRKUJ3TF5/kTYC2HuBZMTiS/0jGrcFeRGVeIn48HzZ+CehiZzwtFXDtxNLo02+CQkJ7ZAIiMWWLVvw8pe/HD/72c9wzDHH4Otf/3r06N1xeOihh/Dggw8CAA488MAFpRGsTKN5YA3isGd8cpcgrURFffFrkSuFkpMQqnhxn/WAaAjkJViVd6vuJM9aeYjyElvNjtVn8MxtgKflZnXhjupV9vQl52JRTACDFebI1s6sRjY0m9eLnkLRszcmKwQnUAX7Oti9GNotn5bk+jVHCFApMnzyF/eKoJKduiIFrmfkFnaXvo/jCU5FvALFkrRHYB1xlyd6+VTVHkwhF8kMTVuF4aPWAZDnjIDUSZwcl8aPkRlX1gDS90KV8tgG4hgx4GUQ8owqiOOUIq6ECfKKaXBlTVWP/SPb7kpX30cgu4LpQ9Zi5x+779QlJslHiYdbpHDjDxnvnFuVcvmTDdplxwpjv6VspADSV5VV/t1+EJ+XG49I//Vi8dvarUzO2lJ0TR6OSKgC6LgjdrUhH8PlCsWEiZ7PAdkgtHwE3zdfCED4O+8DNVJN65Qp48HQGutHsfZhcvCxQZRHCe/miSaPAW6FbPP9BYiMDSKRW0w4T4XtnWZCwg5AIiAwp1G94hWvwA9+8AM85SlPwTe+8Q2sWLFiweldfPHF0Fpj1apVOOaYY+afgKRYYR4DHZmAFJ3IiZIupUkVd6cIBEQEVRp+ThFkjIkpkhDF4jESQi0TtGw1tJm8OGkRnvtVUh1OMn6lF0Txt6cwOXerYgIYLQNmsgydaXOUrrbKTtlVnki51UzA7vHoGXcpLztVJqgSzhRGb5EhE6FXsNwGV1fesnIPC/aweLJSbbB3ZYS2NyuT8H4FWVV5suoPFOfAykLiSD7ekkLiy8/7YKSNa96StM5cOhJpkOKSvIK+AFZu1jdrxIfLw4mjDSeShqb+HlPOpbht042lReJwywitCz/c0ONey8qa4b95SkTceKKrtMLvuVLS+Xjl07INockRs+6Ah2ykUUKZ2c72b01IiNIapQYy+pG7Ni+r75vmZYiPITC8D/N6cfmZW8tRWSMVPCEvOwplzxxcgdLuOZvV1XHBqPLV1rVSGhP5+KDp86Z+ScHqOIrIN8vDSGkF8vA2H9evafJszmoTbz7kI+qaaeNtK2lKSNidsdsTkKIocMopp+D666/H4Ycfjuuuuw6rV69ujPPzn/8cf/M3f4O/+Iu/wFOe8hT/fHZ2FhdffDEuvPBCAMD73/9+9Hq97S5zk9+tNEkHJGRMeBPJviNpRMMK77h8NXlIHlEQIhLEo3IL8tVAyu3i1EzvCubuD6pU23jUSqBIHH8UpyUi0BqqtJaOLjBcrvyJWE4Os6qqzZ6QkUbRVSh7CqMJGMvLCP7IzpqMJE9ePk1+h6rIh99Aqu3G1RFxvQK8a5Y/3SsnbWdlVc71w2ZSmqJW9e7aHAgmdm/54IqjU944sRKsOU5Rc21fs0i46qEKjNQHaH9mfXgcyVe87l1/kZQtmp5TMMHazaWl4S1Z3ipExG9jeazlR+Xj3x9V9MDeNeQZfAtMaQwJhxDWlRcw1gW7nyL2/QfWOG8p07XvjR8n7b9Zbfqyd41y8ez3DcCQZ9f/nDKv7d2bqLdV8OOeeQJiMy+qO0I0UJ08R+rCf3O5QkEtlHlYHjUC8lkYCyq9dNDlSdw0ff3y74KSEFYW/y1S4qirv2Pjtk8v1idjSrw0XwhyNllGmtBG6R/r1tUUfj75LQECki4iTNiVsNsTkC9/+cu4+uqrAQBZluHkk08Ww+23337+UsLhcIhPf/rT+PSnP429994bBx98MADg9ttvx/T0NADgrW99Kz7wgQ8sTKjIACgSgBbhAhJCQRSzwJeYvOPicMWfrgw3yhdZ3aoRFyqXy4vLFgGdQPnkSvOrItj/nZJilRsFVBuWnbJJ91C4IhNlOx8ouOM23dGa9NQrrY1S5TepFwB6wGgCKCaNguQ2qXplScH7ptdOryHKP31GLxz0deBO+KHkw4YtO0wR0qj2uRC/88CVhvy4Oq8UdS0rRWKDuTisfDESwJVB997J0pCVlF7wt/+D5M/yDI5QVjZjptxIpMKTKFZHVZaV604bBWes0sXKE7g1IXwXhGeKn1d6STloPWil/P4cWm8aVZu4BwEJiZXB5UnqVUMh47d26zAtH9daEUulfH93/SuDdaWy31ZwX0amoHMdrV+6cFFzDRXGVeoCqUaAcpeXFvY+H3Kqlj9pb2QPqxho5AO7N0S5SzZD0kDbsnZyIFfeWV+QFlliVvBa8/BvT7H/WR3VxmOJCLg+JhAgCeLigTS3SWWJ9H9p3qjl0VaWhISE1tjtCQi9CPDOO+/EnXfeKYY75JBD/O+HHnoozj33XNx0002444478Mtf/hKDwQD77LMPXv7yl+O0007DS1/60m2Wrcn822awbkoXCJV9/45u/PYPIQ7wYUQhDCU47hdFgsbSdRF0GFdy06Llcb/XLAgI39N8+CRWU9aIouF9vp2frf/bFMqf45/r6KQWWCRK2GNBgdwpIPa0LEqg6Nn/gRsIUQDcOz7RO/ISHM+rQFZgGVnRCEiSsgqnV4bIcZ80feeqwpWU2Cqqr16/iV77NgiOaXV56CqPMDFUyrvPlL1n9RW4bEjKOsL3AamieSjt5eX3u1BSEaTFDxZwgivSoX3d1SuPlp9vehZB+rWJI4cP5JPS9nVGFHVos/mbWKqoUgdlN4a7sro2pMSHt4HLj4QJrJ+2v2lVpUUtao6EQFt3LHrUM7HC8O9bZ6jKAaA2fkjjiQplo8dpQ8MvZqiR3cuhgTI335IqATW08Ut7fPfAEX7tT7ELrIUg/9v8anLSumXhbbU0lmlsevy5ADcW0bRq3xVNh45lQn9oY2nkoCRoHLaVfCwppFOwEnYh7PYE5NRTT8Wpp546rzh77LEHzj777B0jEBAoXzH3onHko621JEYA/OremLgBmXCEIUIWYsk1ykonGJ5fEyIKg0+HTHg11yY+qbnwlAToKm5QV07Jynh84+ZUwpyalQ9KdGaA3kYgn1PI5oB8oH16zlc92ADuJmthxTAoriZxiQLtCYhVuEp6QpYLT+5A8Glbi4q5CR7ewkMVO8mKUVNIaX072al8tJ1oXPcnXwn3vxJlnyjKXonmsoAQAEGxCtyHmEWHh9OolHYAQXsoEBkE8hGGlUQh8VHFp+8dpNOmyMtAvpoLkwRJCXSkgu57UOS0Ks3icgVdwypIVbignxHZ/bhHFFTaBuabMIQCyupItPwuDv9WFfne6XiQKXssLqoDLyJjUmDN8v0NZu/G0MqkAT0EsgHQ3WrcqcpOlaYil5K6fWGOLHGXSA+FxjE9UPq5Yi+g9QIW/zZjebaF8N2JiwIR2Tn5mI8lIkifjiMS+RDkiJKhpaKjl3oBDdIizYSEHYDdnoAsRfAVfL4a3AgyaMbM4VIadIWK5hsM9lXSoSsCwnDB+yawicMTF6aRedlUc9xa2rUCEQXMTdA2LCc1vI4CFzWXDq0bYX9GoHQbHyxDQnpAOVTI5zQmNwBlR1t3F1UpKQqBUl87LQtOyYav80q51cYqw8pN68b7k7t+VYY/AVlRJP9MhQpYocN4tK6Y4u/rSlePuFJNb333SiTfQ2Gj0COLw3p2xTTKcdC3a4qG9vmGjUdk5YRhjMIzbpU5Bv7NjwUjIxoqaFOfpq7K6UPTfQQ0LTZ+QIftCWYlqPU3Xo2ZChUYKrMjH46Qutc0eGYTJSe/mX5n4paWhNSsoJy4uPyUBgrlvynfRy0hzxwpAINC0C89kXbfp5VfFWbzeG4N626/V9lR3uLoiG2w78n1LWdhZHtDXLm8OKRf8vaqLaDwosxHn+RzhqC0x/qqNGfVrB/0T8HNNBg/eJkZ6OKENCc0ko9YHg0kTpobExIS2iMRkF0AVPGRVpyCgZ4oyU2TUFM+NE1xhYuQDDfxeisAn7BUPY5X/FGfnESypatiBTKxybeWNpM5XD3lAeS8QGSpuVIR5Z2Gg4a5r8QpKvbvUmugY47l1QrIu8rcfKyM8lN2YFyy8upeAn9UbwcmHj2lqghXo8MJVocyEbnpPpGgfagrFCoFyLtsZVVdO/KRBZcgEqXO+65XZMnI3TBbU0UX9fqueSQ58uHbQYdEwaUZA+0TqN87IdYtlynyLc7n2xMJNpEhFifIl8cPOjGqfqhcG7D2d+EFsgjWf5Cp0GpF6kiS1l9s6cqjiQIdHPHsiIMR1Pc/R0IQtof7xvz/xC3QuYAhC0+pygpAa22OxEYVxxNmN465fVh0MKEbwLXZuJ6RG9Ph9sP4b8l+v7m58bwke8P8hYKo0vffDicfvo+S4E5Z34HKrzTu+//HKOW1b1ez9AhBDNIm78eSD04OiHzBxn5OFJz8CyE4HLR/zHO+3SFILlgJuxASAVmCGLfiEjN7B9aDhnRjKzySkuXTBcKB2U6ybsVV0l9C4REq907JZGULFH1Kpkja4ntB+QpWDN3/1r3CkQaxrnUwJ4VpNEyUnDB5xcxu6laWhJgjN5W/H8Ar0k7B4XFyQz6KCZtPAaihVZD9iUqknlya0mlBdnU1WCmn8YV+wckEJR/BhYasTjw5oHI11F+web5hMvfhXZ2Rule8v2hiBWH9KQivAGQamvoM8TBchuABkZmRGBqGW1Oiabi/m0BJRYvgRh6iJFPiY/M2daWD8HTPUzUGhYOQ0qbuas3Gvkt+t41ideIPGyOEoFLu7L4O2ueVIQElcbcL8nakgu7PKIFMm/tsgj1Q9mhdXZoPWJW22FY+R8SDPu32cvnjcRWpq4qc+DuAimpfSr1xUMniQNo4WNwpw3i1OmdjW9tFLBp2PpAsJEGfoeMKc0+tQRgDeBqNMjNSEfxP3mvyf82iBNTqUASRpZXVMiEhwSMRkCWKJt/a+bhq1BR62DkiRmCkePQdG9AdCXHpS2lzVy6XTuDWJKCmC9rJzStdbrJjxKgG5aM2uwsoMgkRJbZJIabuHpKSqlC9c3ssMq29K5W7q4NvBHfWD7dxtuwBRc88y4niT1dCg9VHtxnXlp3ef+CtH6TOAqXOyUzLHpAVHSh0geuV/V9nquoXpE4VU5ycAsxvtnb1EKyukxXt4EhSlwdQr4egQWy63mKjQ0Vch+lw2X29kO8p9i3VwMkHUdRqq7iRb59/Lz49uO9BuAgPCE4Jo25TjjDwrPiFmDVy6tLOeAWjXn8+LCplLwNQGDLh7rFx/cIdh5spjTJTvu86TlRqhZzuafL9ynwnQVm8jLoqRwlkJfxCcQkdltdtSC+qcmcjQGfmmG3XDkrZtOzejbKLith7UqzCdi/DvVW0zmqWM9rGtEhCO9Aml9IR03B5NMwfTQq+ZKWuJ8D6DlH6fRweL/LNSnmPk82/Y2MaEMrh+9+4dCJYWsRDY/tbLLZ3egkJBomALGE0kRAJTYSlNki6eZkoMO0yAdHmUSlwbF+FpGR5AkN9vnkcJq+wIO3BSQgtR0DSQPKQEqOKoDQZxcrv0hc29QbuYOTUHefeYawUmqy+2iNNqeuAs4KQO0pUaTa2+qN8QWSmMrr83SZd8o66qgRKnHOTogq8nYiDPRKaTdpkgvcTO7XmoArPyUooK3lO/OOpEqGpUkpJW1D57H+XlVcEmTIYKGnmBKJgwzitV1qPSsG4btXJgCkjSyei6NQg9T3Sngo6DCMppSDfDpOVxwlE4AosC+8395N2i4WjbebkcW5K2gqWae3dnfwhA1AoFaAyc4u5BumzmbEIZoC3Aiinc/HDH5xI1lrjFwrsdwXDWfx357+9TBlrWFndQJ4NqzBl17RjPtT+1LqyQ/ahuO+Dflt8z0ekzvk4HB2XhXaS3P9iCnhTHlEFX4XvY0SmRqhpfE6MmkiQjtSXJJtNv0ZweJIxgkZlEdpBSmchlqKEhIQKiYA81kGUDKeI11ZuW5IQ0cWLKFY1EsLS5pYQ/78K049NiHTAD8K1mQjoJEjLbfOnyrYjR8GkREEnYpoeTZOE9cTGtQUhC853XWeGjMC6hJg9IRr50FxK1t8IFNPG995fcOhWWssqXX65IK0vLzOXk07ANIyTjZ3EJFk/glVut3FdkapjBMTJLu1H8dYYSVkn6Qfhx4EQwNqpXaSNzSp5/TjhWt62LnwclleldBMSIhDbmnWNyOkfZVU9mSBWoZbKyNrQ9+cM5shcHwCVxSRCiILvjpCK4E4YWgZNvvmgrEbTpwcaqMzyB23u7MjJhvTMM4OqvhXpW8gVShhCEXxTSnahc+XydaEq+URrrSM5ltioAsgHpt/kQ/tuBHSndWX96KC6/6dAcGJbo5WAy9cUJEI06fuaqxYZ96TFnmg+EcTIhyR7a8tEWxma0qDvpPJzROqoTTtE5VsKSHtAEnYhJAKyBMFdrNoOdmJYNyHp6tdg9Ywp9W3yoEmbh/ATLSU5NeXdKR9EOfFxxqC1mwuI8itM1pQYBUQkQ+XrTssFhOQqSCQslw+LSDiXlw7+DPzI3ak+yICiD6hSoTOn0dtkIpY5UHbtjesdk3g2qm5NhrLH5XbhLS+8vn3GQdtrr5yEK7KcDTolnqTliQT8SVnBCmOpvSWH7r3x5IMcN+otK85KoV3Y6lI279oF+FOIwGRxv1M4BTeoE9dGjvw6GbjSyMjHOCUnOAZYAiMeMZdC15fpZvtanKY8dPi/3+PhSbGuwsKRGyEfH94+LMOLKT0JKUn3IRaKUmkorXz/0grmVnIN6ML+KNK3CvNNmkMalCErLh7ZlA7aD2l7xuqDKuLU8sFd+RTssdn2cyzsEbsDK6N10Sq6wGhC+QMiVEk2prckHtLKvURquXxAvQ+I1m6aF0+PB4k8H+uOJX0XNF/W32Ppx4iHD+PC0fqlMsS+S4FYSHNlW7erhISEbUciIEsU3A3JPfOwEy2fcKgVYdwAWlssFBT21vEpyYlMjkHaZIJQLGxttb6NDEI+MUIW6CiUhIBNZA0TmlNUg0lLIFi+gIKMwWRn4xgepKE7CrqjMJrSKLuqOnY0N+Si7BnFXRUArEXEvS96CmXfpJsNUdU1JxxefiUquLXwTs4I+QhOCQJRJK0rS1aYPJ3i6k73cgTEp11UlyAC8Bt/m44ODlb+iaKi7Z0MVd/SsnLky4la21GF1dWLJ0q0upiC56wNgTtOBG2/WZd2IL/0XiAyvhv6Oqnkg8sf5DQwmjbrqwowp0lBmU5LvgEeVquKUCjWV3RuiLQaaaiiOl3LWNpsv880lFIhsSQ/UpXVXPN4mzp3qlz5y0Chzf4QRU62KrsAOkBZopKnBGD3fJRdsyDg9o1410g6yLC2iEIaa2jcyPgRsxwH5eVjGX0uyScQOcnlKkqcmso7hhj4dIVy+Pisb/sxR8o/QpKC38eRk10F5ZiBZsFpJiRsfyQCsoQhkQv3nCrJNJxoPWEKVjD+SmlG8peIgURinNIhF8qKzSZWSVGgZKYJAQnR9XiBZYbK0CZNQS6aFCciCgiPJObPqYVEkTay9eaVQa29haDohxmX9j4QJ4fSRrnXypysVUwYhSobwW6U1UGb8D5SW4UlCrO0h8HfTUIUc3MCEPyqvz9tyFpnvOLmmknBWz/KnBAEsu8FgFduA4JD5PAb9V15yKp80L9iN5DzNtak3ysnJ2pHyfo7IBzo3h2mBMVcyVzYQByqxHEZfRvo8FtkCpa39EgKFycV7BvULAwl11DMhas05EDbQJSgeSLuyq+sYp+r4HsM7rdxRIb1NUdeYgqoL44G3Ob6wEIA0y+DLeq031oCokoAQ5Of3/PRA3RHoXT9zuXtBhD3DY+s5cNZM3nf4m0hDD5R5V1S0Fl9BO0k5FNbvEL971i/i1qTWV5Rkk0JUMOgyy05gYhsXPL5NPULKS9JVmGO43nP2zK0WNCl+dneaSYk7AAkArLEIa1sScRCihdGQm0yClbupTiR9BpX2yL519yzIqtenkhI7+YxwEfzj+VHJ3+nWEhijqn3IE1av0zZc8/9n4SImLsKnOKryQlCJkJWwLukUGUNSkOrzJ/Gk43M7erZ0ObHlGS3vyPYgItKfvGYX0eqyKlG3PIBe8KUWRG2JwXReyNc+9N4TuEkFxu6NtBk/4CTvbKu6EomepQxSJpa10hA4ylgThn35IewURqGfkeuvSmB0CyOC0uVY5c3EOQR/E3z5vtTnCKtVBCXjg/cklqlafZfBO1rGa32lU3CO2VbKBslFIaAKGhVHbWLwuzt1gWgclq3CEmIc9XT5htwpNyfckVdpXg7IHwWWAhU9X9Vl6j1C1Ua8pEPtT/JrSCWF1+tTiaw/ujypWOcpBQrgJOG2hisSFqaDTtsDArqYByE/rCtyrNkOXTglsEAvFxN6dP48yhDG6IUcwFrSz4SEhLmj0RAdgHM2yVJGjAjK26BYuzCEWXEhWnlbw60nAErRaXm2qSqfAMZUZehRoSaJjolhK8JhWq/RwyxiXUMROsITVORd6iUo8D9R+lKISmN6wgUvAuT2xirO0ZR68zYG5m1dTGBnHdtf4tGuMlcaiNKQFDFdSc0qRLE8lGdAEQ3ItfqTxNljvQ7ZFV+XrYChqzQb4P69Lv0iPyBZYMSLrJXga9eB/dQWFLGUXOfooqx0M5eXlbu4Lki5ff5VJdTurDeOsPaz9/wntmjdgXi48iVIsfaKlI/QRxieaLWQUcUgvoCzKIpUw61d68LT3wzBERB57qSx5bXb5KnPxzum3G/l/buF0KaXFnd0b9ZCaiREUxnyl+omc9Zi11Jy0wuGyT9M7ZQUltgEcYJsT1i0OF7se+Q8TqazDYozPNaAJL6eIv0gRZ58PE3Nu/wsck9lsY/Fq7tPFtLdykgbUJP2IWQCMguBFGBZkQB4EpL+/Tna2WQhYwlXikIWlpRRAuC0CBjbQJrSYgCVyu6QhaNUP3K+Y5X9Fy6TgnT1TvF0gjkJ+QvWGW3z3Vm42eAUhooVbUpvW9cQLrT5mhQr8gpu1ndKdLkJKrS7b9w7lzMram23wOVQs4JhKKKkIZ3ReFH73qCwJQHrtTF+oEnKNQSQOqcEhDnxsWtDM79q6pvHRzPrDRQ0vJJ31wMrvxcSSWKjqg40b6nwjrSmaqFq9JUAaHihFEVti844ueImpUjI/2LKt2+OKxf0n4lEgNKYOwPPdUssxvOFSU4yrrhuR9yB0eUdMQUVjfOWBkdARPjluZI606p/YEN2dD0rTI331bg8kf7t1RHfEBg+dVASQP7fjh5E9PTQvkjeTQhZl3YFgT9JpafzSsg/GR8l5R88ZvUiH5rTflKeYwjFo3pJj09IWFeSARkF0VtxTUycC+IVEQGfpfWvFf+iZIDGAUjWHUHeSeJM0Yp5fkFcZsC00mIT2JCmqJbm/3fHacb5EfJh8supkw5WZwMZT0//3dhL2xTZnNumZuTeACzguvcjsxRvuSSNG1WfrOR3a+RKf/O34ugGfkg1giqLFIF3u/B4MSJ1J9XrJ3CTJUoVy86DB8o6rweCKkwyjRRxKni4wlLVdclOVFLWU1cl8Kxtk5eVGlFlQzpOSM+tbK5v2m5EL6rWTekbGg/plY0Ly/ZWE4UfwV4Iqlc+BLBvTXUggCY/qmJZawiq8ovlLpjdnWuoAvtSYh3q3J7QUr4vR8+fK6hc7MpnYK6efn6JGOSXC9OaARWHl9XNm7uXBTdO0c+rIXRk4+Spk2FY7+3GG9rSmtT3woihr9rl1ZsoONExmXHw0fIR5sxlxMn/t2K7cOf0TG4LbRQj+OIBwnTSHCEeK2tNIuJtAk9YRdCIiBLEG0VfGn1nltDwgjk90gesQm90fWphZw+S6o8KkJsopEreaV8x5ETaUXN/+2FogmGedbInCSb/T1QkpxyQN41lZeu7Pl0iKycHFUKoDaXoOXAaFL529KDlX63Om5P6MmGRhjdMberQ1liwkgHdYdCZq0CTlGkK+7uf0qaiEJClUWuoPiycgUi1n95fWj4y+eoe1Wwd4C6s7mk3KZ2Fz/WDxuU3NpzSqr8jyYdQfm9CIFFixOMeeoQzmIDknbQHqVNNFPeSuTCZhrQhSlIQAp1eGyu68/+6GRl93c4q0aGam9HZkiqIdLKu4NRMug2lgcWNbIZPXDRDCqdlFMpKKVll0kFf8KaGhnLhr8/RyEgoP5bclm4XwhxDcYQiRDSsYL1C67U1pRcXkZqHdJVv6yt/s9XYRfQxnIggbuB8W/dP49mzN4LZYnNQ9EFo3nMSU35KCZX1NpWS2hh+Sck7K5IBGSJookIiBYON6Db32urrDQMqv9rky7Pu2FlqQ3oSrZ3S/IZVelKq0uByxIpVwBWjnnL5iI7wsAnRdTrpkogPil5pQGkDDaOJm1FCYamcmRMMddhmygN5CWMO8tIm6NEc3N0b8kVHFbmfODu17BH+ZZOQWO+7u7oXFRExpGd2ilHZXVrNK0fDXjF16QDBAoKUdaDVVRSV+JqLYnr25BvhkelIKsCnnD49vYbpmXyEaz8KwRuWrFwrty+DoNNzuw4WR4eFWFwynHQHa3CHVp3dHVCV0BuVEW+aJ26cC59ovjXVpSt/L5+XFh70I4vW2lPYSuUISGA7StVmhnAXOLsMbtkz5U7Flfl7p0OxrAaKGkkY4mvL3vCVWb7d2eusgr6PUwgfZkcRKAKBPtYAjcrLotCOMaxdnNhHJmQykEVeMnyxxX+ccrwvCwXQhyJQElzkv+byi69FwVoEUaKxucmIKh7F2ac9b9xoW0bid2iIe0BSdiFkAjIEsZ8SAhQV9arCIxHNAy8UdLCiAgnODydmuXCycE2n0v5UlBXCUnJqALyAtWfBVE1C8ZJElXyiFwiAaR56EpMTkLoCqbLp0Z63HtYhY+W29WZe2RXkv2NzaX2K7v+OFx3IZ61XJQdQz66W0tMPKyQD0xi+ZzJo+xUeWWFJu5aQNG1LlvE+uHctbJRdc+HaedqtV2zsgV9SLO0WF/zFxDGSIurV0Fxq6wgsG5iCvT7kNpOVGSdW5MKw1HSyPu2sS5or8RDwZABRiy8DKSPK1o39Lsj+bm7OKCtopwTWXwfIEXR4Y8K6tgo/pndoO3rzlk2iEWtsh4o6ExXaRHLhnMFgyUsZdcInzk57P/0tLOqESr5TUHD+vV9j3Yq/v1YApHPamRKoTOr0dtqApXUwqLq8aVjsoPfyTM+FDUq/TQPQd5afjoMO9Zq0oJw1PJnCryYfiTdmEWwlk5LSJZqKY1goUqYA5vSnY8MlQAsT0EW6V1CQsJ4JAKyxNGWhPiwQKiokgnUvVLBL/F0axMtV+jJ3+OIS6Doc1kjZQxWoJm4MSWAvvfpU/lpfZBJ3hMkqwDVjuekilOMCLl6p4ogKZtb7a3dE0DriCo8UpmpIokwbQBGEbQarK8jpVEqQx6GmUI2ytDfWGBywwgTj5pbnIuewmhS+Q3pmXanWGmgY1y7igkYv3j/DuSoXW0sIHD3gYT3lVBZAwsQcROiR+F6ywf98WWuGoaTD1/f7oe1YwyiAkHTdWJQWVHJRk+NUqzfuP7lytSkqNKTn0xccqM6U/B8/WWVu1Sg/FuSEPRXJw8tr7Ns8D5lLwP0FhkqgyJ92clekhOuGGnQuUKpiYWNginC1AXLB1GV5c0HLeBPr4JC9V67I6iBbFgitxvLR33l78jRipy2hTBdkHoUFx7ImEQRLKpElPv5rKxTQhys6I8hB60VYzbOS+/9N0hJKyPFgSwxctVCXtF6QvpuE8nYFkStUuxdLJ8lRT40sP0tINs3uYQEh0RAliDaDmgSCTEvEJIQ94yHsYiuEtnIAalogRoJAQLFPSArYgJhMdwffq4TiA99HiilOj6RUWKlwiBx2ZiMIomjR3jS8BreFai26ksnd/J3TQ6FwCoSzDWsjr3LkCJEYgKYzRWKbo7eFo1sZPaQGBJib6UuAejq6NwyVygmTVzAnByUDc1eEue6ldEL2BSqze+dSlurbrl29WQ6lyJ5BfVKf9xjQi6ckljmdStJYFFx9cZO3wqICsj/qMLU/vdpw/fJgCwJbRasDAtl8nn7b5bsv2gDSuRY/Xk3M1pm7irn+kxmOxR1w7NkhZ+Q5foXPTrakyZqMQGRI6s6trOQeQsRSNqWENG6VloDlkRD2dOqBtXFf2UOny6UOaDBCaqz6qS4oqe8i5WvD9In/djhLCVKWVIYhvN1LH1/vB342MnHjnFEgL8Twje6E7VJk8dhfbqKxCPIac/H6hCNGxnn55NXdGGrRdhG2RISErYZiYAsUXBLhLj6xMIFYSUSwsPYcHxQ9Wk2DLactDTK4R8SeTgZkCZ2qlCzvJtALRqSJUEuUChX8MpNxJH6oopWsCKsw3deobOuOFEixgSuNYOqFEOq9HgliogLGJkyshG56ANlT2G4QvljR52bVk1BtokVffOTz5mfzrSuNvUShcu7avWAol/tMTEKn734DpXSqajQXAmkMjhFVap7S0SkvuZkcooov/hQIqhhBkwG8sMtNN7tTWk5LVumwJWIyiDlzQkSD0f7VEHqhJQb9JQyquyz+nUySqQrqH/fTnYTuCCzcqdp8fK7/SqCC5SvU+fe5Q4TsFa2whKb0h3VW1Yby1UGs/fJ1m+ZW7Li6sNtOi8B2Isxg9PRaJ24drLt6UhIE6JuTaQfB+OhRDpYfQTPxkC0HogBQ5kawxJZJKvOvCwPLUhWm3xqrneR9OZrLRlHLHYZ4pH2gCTsQkgEZCkismojuTZ5ZbQNCWkzYTAlO2odEd7FLDJRi4Oqh/FpOVki4V1+tfh0wiSTV+AKFVP23P+xelJhUPEd2ZxN09NAtaeDxRm71B2wibqYWoXKuSNgrg5VWblUZYVG1q/2cpRdGLcZtwnXKnDGGgJ0huZo3860CdOZBnobNfKBtpt8lTkVS2uzeN41lpLRVKUAqpG9+I22p+SK48rn2o0rb6iUfxo2sE7YtIP+q+wJXtSFhyjKwYWGzEpC022COwY4XLWtTovyCi0nK9CE3OgqLVdEDatUkPLxPqSNQo2CKPcCoVBaQ5f2XgyFQN7gW/KbwlVQ/9rL4+TQIXkW6i34X/repXpW1Z4U7fYXDYCOfZl1zN/5nGk7c3xvRW78vhJF2hO2H1p3QUdgRLLvxgpy/GhNMSYQ37H+y98F1gWBvFBS3KQ0tyEewTgtKfRNY56YMWu/NuMXhDZn8aLkIzZONswfPr1xosWIY1N83mdakqudgtIN5Ns7zYSE7Y9EQJYwxhILICAM8yYhkcmRy1AlWoWJDc5ODomYcKtI4PbAECg2ROlpmpB9HEZcwkBVGZrkr9UbjdNm0iX5iy5hThb3DpG6HgebplvlDY4NZellpYaaVciGurqEkCqYCkBm7kAo+grDSXNiVn9Tge5MaU5WKozyVvQVhv0MowkbNzMEpeib44BHk/BHoHaG9iSqMnS1qim9jHjE7uBwZfW/a/gN3pqt0jslNLBWkPoJFFEa3rvfoHb/g6Z5u2hu7wYJ4y0dTCEO+hcEUkHLa0lSYLX0mbK2LjXAyQtND4CChtaq9p0E/wMBWXLvAgLP5HXtpXkdWzndc9r23l0vJ2kTIlx2q4EkGwGdGaAza5hQZvth2QGKrrG6aZdOafo6rSMTB8Ex00HV8HFFKi8dO6hSzMcUppDG2o0TDtHSLSEyDnIyMV9rg0T2G9NoUvpj8rOyR8c8gXw0LYSJMjQgKqeq10M9spxvQkLC/CCdoJ6w2OArVASaDsxjBt5gxUlF3jXA5TVu5aomW/AwlC22UsV/2shYW3nik5YkK3tfW2HjyoZ97lbW/aq5+79k7zRq+cc23tJ4XjyhLgIFVVD+YBXySnFmP3713wimCrtB1+3loLeWF9q7z4ymFOZWZhguM2er5nNlRT6WZRgsVxgtUxhN2AsPc6MIFhNAMalRdnV1xO/AuGwFSg+rm1BxV5WbDldWSDiv7DpXHbsxnlo0dF7Vj68yV1536SLtc7Qf8/rn5CIIRxuyKkctvPAtBhYS2hdiLlrSd0YIS+AuFetDrC04grFG+i44hLJJ75TbZ2IVXHcfjc5hyMNI+xPdip7tT31Tf6ow1jdHPkYTxt3Pkw9dtWlWuL5nrCXZwB6ewNo7aBs2Iypapxph/61VWFh30nPJAhG1zMYIhhAmRiZ4urUxlfb3pnGzoczBGBWpn8BCLYVvQz5YORZq9RBBFwdYHlJe2zXv7QnngrW9f+aJe++9F5dddhne9ra34aijjkKn04FSCuedd9680vnsZz8LpRSUUjjttNOi4QaDAS655BI8+9nPxqpVq9DtdrHffvvhVa96Fa6//vrGPH7729/i7W9/Ow466CD0+30cfPDBeMc73oHf/va385I1Yf5IFpAliNiKTtTCwcKK4RryiZntxbCNkjshUK3oO+WlQQ5JzsBq4gOZH0Xi0LBB3g3lCerThXcr1Tw9mveYFcpgFZMoznQVu5amCypN/k3KnCQjVxZZXs5VixIpqGp+qZQCbe4TyYHhcnM6VjZUnixoayFxSmGmAD1AtQfBnn6VzSmzX2SrRj40YekxvwA8QSg7qPYH2LJQhYDKzRV1r6AUJl7gVsUUCK1UVe/82F+Sr6iMMRJi0guVK7d1XCv4TdpQ5EjiMQp6cB87zY98f/7bkqDD382FgiBlBpCRm9Fp/rScth9rkqbi9cT3Rgj1w5V9Z6DJCuOyp3NbN9Yal9uDDZyFrswNCTHH+WpkIxX0M9dvlGBho4ord8sL+ldTu4DEoXXFQRV5Up/1OiN/sjYMxmMlPEP9uaScB2KxNpXypiSTWlFi80NAJiD87jNh4SWZhDhtyAdNp63i3/Tt8Xaj6TbNoUH+S4GALBFccskluOSSS7YpjT/84Q94//vfPzbc9PQ0jj/+eHzve98DABx66KE44ogjcM899+Dqq6/G1VdfjQsvvBDve9/7anF/8Ytf4PnPfz4efvhhrFq1Ck996lNx991343//7/+Nr3zlK/jud7+LI488cpvKkRBHsoAsUbRZYWmzCsTjtCEbIsgEO87K4cLXLCcRUEtGzaoBIR2mXPDfo2WKlcH9TfYH8AkfXEb6I8juFM6avCDvmIw8bXH1jcpDw2bV/3TV31+4Jsjsy0rucMiGdqP5rEY+ZzTQsgsMVygMVpmf4TKyv4OUKSuA7rRGbyPQ36Aw8RAwsUGjv7lKi/eLsmPJzITdHN8J681bmtxxq06RomVUpBwj+BvfHekqc7tPJSdKN+svrgxVe6pKhlL7H9oOolWDpUetH1GLCW1n4ceko4I9GbVvhretS5+PBRq1vKXv08UVV7cFcutPqgI80XSkwt98zvZGGbcqje4WoLsZ6G7R6MxoZEPtXbFc3zRpKhR9Y3Er+sbaBhiLiSMuirtZSWMmsRSOIx+1umWWRm814e1Qq9Cwf0WV+paoWUZR5R1bPKHxahhDZHyw2ElyTIboXBGDYnUqyUTSmo/Sz+WIkTJKwprm0EDspUY+logFZK+99sKJJ56Ij370o7j22mtx0kknzTuN97znPXj00UdxwgknNIa7+OKL8b3vfQ977703vv/97+Pee+/FLbfcggcffBBr164FAHzwgx/EXXfdFcQrigInn3wyHn74YZx00kn43e9+h1tuuQW//e1v8epXvxobNmzAa1/7WpRpD8wOQ7KA7GJYsJk31J3EFR860NcmSJ4cD0P0Ge1+USTJFoP4OGuNZFmg+QflonF0GC3I08nqwosCVu9p2rGyBIos3ZTu5FfhnzyvGMGLRwplUjZcUGeKzSNCPXtlH/CnKmXDarM5v9fErVybcpoN150Zje602Zxsjuc1J2wVfXscak7qSdvTuJaZdFQB5N6FShvTioK/advVZ5lX95UE94e4FXDr6kVv+fbHxXrCpQOrCq37UFmpFHGZXFSdhh4zrHiaZBO8Oe4WwY+4Op/V86BtFRImINgzAwRyB6vFJWk32mdAykjqqo0S6dIF4C0TqgTykWmPrNC+LO64X1XYzeUzhty5E62Kvr2tHPCWDZDyuTbJXH0TN7VgDGGKcbAwIBAFydIctTyg+pu3hctbVOgj49u4haGYNaJKIPKcvBubxji5YuSK5d80NlaB5Lg1C0RT/bPvMZqX9JyMo6JFpwXGucztzjj77LODv//+7/9+XvHXrVuHK664Av/tv/037LPPPrjmmmuiYd27v/qrv8Kxxx7rn3e7XZxzzjm4+uqr8ZOf/ATXXXcdjjjiCP/+q1/9Kn7xi19gzZo1+NznPoepqSkAwLJly/D5z38e/+///T/89Kc/xde+9jW86lWvmpf8Ce2QLCBLENJE2Bp08AZRqOgg27BC6MNw5Z76QLvHknx04uUK25jyjFt1EhUI+kPjCUq8VAandNfyEOStxdOCnEQhcnIEew+EugnSblBYfJ7Mv7+2Uk3KH5THKoZ+dZpZYejqMJRVIIdAZxbobtXobNXoTGtjHZnV6Nj/VWHSG00a5REwrjQAUPQyDKcUhpPOV19VrlbKytOzp3GV9sStWbearaHs6rayyqlZBTd7Auit7L4eyD4QwCq8joTkrly62ivi2p70o8AVjCmSQf0qVJf4uT02isUj9eotMXzvCv3RrK3yepryHgZV+xZq0DSeCr4jqa8HFhT6jTnrBHO/qo5brurFtanbg6EKk6bOlTmumbRhmVcHGJgN6FVbZUPrnjXS9iQr+IswudWzZjH09Y+AkLrvQhwT+DjG2599bzwsV55FUjMGVA5pTmgzTo1DbUyWxlL7nCv/bSwmLp1xMvk5qgX54N8gtzxJVv9ABol8kLCilU8oU/igOfxOQ6l3zM9OxOzsrCce559//tjwMzMzAIDDDjtMfH/44YcDAEajUfD8q1/9KgDgT//0T7FixYrg3YoVK3DyyScDAK688sr5FSChNRIBWeKQVtxiEw+AYCAMVmGdYskUNv++zeoWn4SFPF24NpOOCCFOzM2gcaVNQy5XRCbRnUGQK1BMYhuEAXF13aUTdYFgyqik9EiEgyulQRmIAhasxLsfWpdEUSuJoubLXZJN3k4pHJiTspQ2SuNgucLsngozazLM7JVheq8Mc3tk9lheVblNIdwg3JkG+o9q9Dc6Nxy7iZgQBZ3BHvELf6N1RaidhhbWud8n4E78Im3nN9+7qBlR+BVTsGlTeSKsQqU2R90K4eQI9rpU/aGqU2MtgqbKsgruy/AXNrIDD+ieGN+WQbywXnwf6CB0eQNJl/YpFcpurBU62OwPDaiR6Qv5bNWujqg6typF2yqzFrAp49Zn9huF5KO2mZ65ZknjTM365BYBAisUanVWW12PjAc1ZZZ9p/MlH3xMj63yj4VAUujz+Y7HosWXjD+1sc39qeXfw0DVDx+jaySf5M/Ti5KiprI2kQ8hTON8m7Ddcd555+Guu+7CRRddhD322GNs+D/6oz8CANx00021d3Nzc7jlllsAAMccc0zw7vvf/z4A4HnPe56Yrnv+gx/8oLXsCfNDcsFaovBm/THPx61+KW3HYjfYA2bDta6/dwqaZOUIxnkhf/9Ih/8rIfzYiVAjOqnRsjRaC6goqpacnCeVl0zmisjD3Zxqk7AKn/Py8+cxVzaaZPwBe03bWnpH+oC7K4ITF7qaqO3ftL/UyGhh7hhRpfYbgsuuClyOqNLo8tCZcdGa3KCBDSZ+PjQFKPoZChC4tsit9WPKKL/5nEI+MGSFW8W0Cq09TlZHpAIFiipuVjZTX+Em69qKMCFz0FbnLwEvvOs3lqzQsFqbeoOtu8zdzJ2ZSD68qmTmBNQTB9r3yHcMrSq3MLeBP3dtBL+Px+2dcJvyqcuguWiwslRkA/M+H9h27KAiPKW7qFKjt8mk6dvUbiSH6++FDixGgZWwYPd0sL7AV7Lp6nlt7CJ106hAOjkQfu9BWjR4C+Wby8bRylWpgcDUxg2mzIvfdgSxMTk2BznZaJiYlYbPWdE2Eshkk3wLtcjwuLHxd1ssS4sFrUtovX33LGzv9Jpw++2346KLLsLzn/98vPGNb2wV5wMf+ACuuuoqXHTRRVizZg1e+9rXYvXq1fjlL3+Js88+G/fddx/+/M//HM9+9rN9nMFggPXr1wOIW07c8/vuuw/D4RDdbncbS5fAkQjIEkbTYEwH/aiCT5Vd94vyc1WlzND3LA1pUpHAFXWfv0ufTMRc6Q4msMhkTcsipREWlOXL85DyhRxPhCMOQHhyVkbqlovfQIJc3cRW4EQRmiZqLcejdefL4QgCISiBoJLi5gpJjiBWVonVmfYrzE6JpnJV5EBh1Ae6pT1WtbTuVV2Fomfctdz9EEohXI23inBn2vy4+0fKDoJNwmXHKs7uNnaNap+CIumWFYHxq+MxZciXQXkrgguvad3yfkbkoi5/4oqtC+/2adh9OaJVzv2wje6aEwlLvtxt4Z6AuHd0o7iq0s08aTHhs6GzfNljcpWq6iA3+WZD43JljtJ1G8ftPiIQolPoSj4yzrh2ou5x0qJAbS+HLXftI5QUSZZnzErQpISOU855X4jFbVJsa+GEMUKOSH4aiFAt79gA1oA2irmbp6JhJQLRIEfMIsLjSnm2IqILIB9LwkKi9fZ3mbKLMJs2bQoe9/t99Pv97ZiNxjve8Q6UZYlPfepTreM9+clPxo033oizzjoLZ555Jt773vf6d2vWrMGll16Kd77znUGcjRs3+s3le+65p5iue16WJTZt2oQ1a9bMt0gJY5BcsHYlkAGaugFQVxwgVDBdvJpLEEs3WPkEG0xdfB1OsNIqYWCqlgbkBsWax4sqgMK7wNWiYXKP5iutpo2J41d+qWxUieWKPH0u1GVNDlKGVqtvROmouWjpqv2D04hcnTFlrrENeVzSz7KRdamaMZuLO9PmBKxsSH5GpjDFpMLsHsZNa+s+Gab3zjC7Z4bhcmVXzJXZN2GV9u60Rv9hYOJBhckHFCY2lOhtLX161Y3YVrbcEpOeES8b2jsmiMIOVN+Gdso0dZOi/Zkp6c7CUnNjIu1Glebg9CRJ2SJ17cKX7g4Tpjx64mf3Yvj0Y7e9l/CWBd9PbVmhzDu3CRyo0shGQGdao7dRo/co0HvUHDKQjUJZAHeimdnHMZxSGCzPMFhhDhkoe8pclOmOBXZxXZ2606tovUjfg2sTRhilU6lo+9VciIhFKRg/JULIyll/MeY9e0eV57ar9pJyHoxLdMyjY720qBBDRA4+jjTVkSh3pAy0TdqSj7GuUMIYRv9vQyx2RcvHzsBBBx2EVatW+Z+Pfexj2zX9yy+/HP/6r/+Kd7/73XjqU586r7jr16/HAw88AK019t9/fzz96U/H8uXLsWHDBnzuc5/DT3/60yD87Oys/73X64lpUnLl9pkkbF8kC8gSRm31q8Uk4laaAotEZJD1yel6fB+GxnXKv5xkQIC4JcbHEVbiuBWHr8JJFoKmFTAevmnlMSgrL6cglxNdubLE2kWhcucQysTTi4FP4G1W75pAV7gDpS2mUPBnvC4VCxIovIAuzQ8tqFGUNcqOu99BhUoSPSQB8JaA7rRGb3NpFWZYty9lf6xSajV1r9TaNPNZo0gbSwu8KxS0PaHJ7rfwrkYAEO5Z9Ps1vGGhU5GbgNTRugBpQ1JGSgh1plCC7XegynXp3NxQKWukrp0y7srlNuLTfRpu/0g20sgHQDFQ3gKSDezFlCO7/4cQMGPRADobtSUp1QWBo74Kj7FVQJkpwJ1QBlLeguxfAWrKswaqU9aq4rEGqFex0uw7403AlW9Wf00r5T79BXxzjS5HQcBQBh5etPKSsFzumhWVkS9uiRTjRGTx8lK5G+YlbomX0hfzENKTFtWiYQQ0Wqsi4RrH7nnkvVPhTYDbO03gN7/5DVauXOkfb0/rh7vz48ADD8Q555wzr7hXXHEF3vCGN2DffffFt7/9bbzwhS8EYNyszj33XJx33nl4wQtegNtuuw2Pf/zjAQATExM+/mAwENOdm5vzv09OTs63SAktkAjILoKY2xIwZvJFOHaKBENY8QlWjxSZuIBKcR438QTCzE/Zlgb9mCWiqfz8nfR3U31IE7BYDvscgsLiFengIbyyKVYjlYMqsO6RULZxk2BASOn/imSnmdI1ttHC/6V9297lhbpRjYyrTm0V2+0LoH09A4quUaw7zlqRA6PJDKO+c7MinV0bFyGzSq+gNNB/tEQ+p1F2qz0qThl2cpX2Rm7A7nUY6UrBt+XIRrZyLIEru9psaNeqOsUqg9k3AxNeKxUo3kohIFlG2bfESYfymL0yRpZsiIpA+sqp2qvsmneZ2ww+V9WjVgpKmb0mnVltSZypm+4We08LAHTc/h3lLwLMOuYCwGxkbx7vGgLi9n34Cx1hiE4A4qZHyVWtq9p2c32Q9qlaOBfG58nicHITU6aZgs7dJPn3RL85Smyko5x9Flw2+pyG59+6VActlHc+hgVyjtNNqey2PaLjK0m3cdxh5CMalpW3VtfkXa3dI+NtLQveD4Q8x72PkZbWVupdGCtXrgwIyPbE+973Pjz88MP4zGc+g+XLl7eONxwO8d73vhdaa3zyk5/05AMwlo1zzz0XP/zhD/HNb34TF1xwAT7zmc8AAFatWoUsy1CWJR555BExbfc8y7IdVu7dHYmALEUwxVRa7Wq0VPDk2PsawUCzYl49RI2EcPmktGi5JOIiEgChnJyANa4U2jBjZRLSjaY5jvTpWrBaPoFMTFafLicaLm1Wf+PavSZehGBpl6+W6yIozxiS45UM5pLk7pMI2ixwIbL3hHR0La5WjnAY1yy32u+JhIZ3jwLgrRv9TQUmHobfiF327X0kyijkWlWd2BzvqryLVWdaozNjylP0qnKrEshLc7O7q6CsUH5vBOD2Opijg9UA6JQaugOMplTl2lRoH95tNs+g/LHDhSVP2t6n0Zk1m7vd3hZ/qhdMud3RtICRvbvFkI0yr8IXmfLH2PY2mzBGFnirhjtIwPexrqk32hZg+QakW1d9SeobVULh702WzFp8mj6PxxV3QmokxTKwAPK8eTqxb15ShBVCOZuUbyITJyzSeCSNzfRvbl2i6QfPYmggXnxsirapkKZEtKS+MtYCz+OQum87zsdkjfaRCJaM5cOhpJunthN2wib0W2+9FQDwrne9C+9617uCd1u2bAEAfOlLX8I///M/AwDuv/9+AMCdd96JBx54AADwJ3/yJ2Laxx9/PL75zW/i5ptv9s96vR4OPvhg3HfffbjnnnvwnOc8pxbvnnvuAWBuVk8b0HcMEgFZiqCDtIqQAcQH29rKEeIKe9sBVCIHVOGWJsBa+IXkE1Gyx7k2SXK1QRtyJkckeQuTNU1P/NvlCdY2KiQILmiMlMYQDS8QHi57a8WJlKWmF9oN5Zq657hApT1tqjSr7LWVWEdoFPypS8ERwUXlauQU7uEyQGc5OnPau2oVPYWiB0tajGZa2PtHsiEw+VCJ/iPWfclaZ4aTmUmX7DPIRhr5rEJ3KwClkA3gFf6CWGTcfhNnXRhNKL+BPp81J0SVHUB37HG+Gfzxxt2txqJRjIDuZo3elhKqsGlYNyn3jThC0d+o/QZxVWpD1jrk9C0YubS7U8MSttK6wRW9Khx19yoV6neX+OOYQ9atdEUEqdIZfBIS+eBKKN3HMUaxjf3dSIpU+N7JXkOEGMTSpYSmZuVwf7K03Jgjkg+aFvtWY4tKkvy03F7OMWWOvgdpVy53JF6NrGBMm0TALfHcihXIH0uLvRfzFN7N1+KcMH84MiFhZmamthdj8+bNY9PU1ipL930AwLHHHov77rsPN954I/7sz/6sFu/GG2/04RJ2DNIm9KUKabBGi0GPrMi1MQsvyHSs2A9YGm5SyOSJR5KBQlKCG8HrhikITZMotUjQehPlaQNWLxAm5wWhQUZx8uXRY4qGRrDfwuWl+aRO8greKeGdO8GJ3r1ALkH093IEz6pjWgEiU43JoLpBe9ZtcEe1idku1hV9hbk9Fbbsl2HzATmm98kwWKn8hYeqMLIWfXMHxWhCQRVG0e9tLpAV2m+A91n7/SoKnTmNiYdLTD6gMfkHjd4We1miD2fSLrpG++5tLrH89wVWrC+x7P4S/c1ldfJXz1hmignzPxTQ3WrCrVhfYuoPBTozZWWl6MK7kpVd5e9D6cxqdGZLTz5Gk5l3mSo7sCeMmTtUhlPK/4wmOPlwF/5pZAN76eSMvYjS/cyY52ZjPyUkCNytFOlfwXHMsW+Ckh1pYYEqj3ScEX5qadA4kfHV9ePYu9pzqgTzAyaExRH/fB4Ku0hy/B/VOzfWxX7aoBaH/wjha+1MCQJQqwPwtG2YcfUuWqSlcYrUXW28Et7H0JZ8xNp0UaD1jvnZwfjJT34CrbX44/aEvPWtb/XPHA4//HAoe/fSt771LTHtdevWAQCe+MQnBs9f/epXAwC+/OUv14jM5s2b/QWEr3nNa7ZDCRMkJAvIEkRMAacuPBIhES0USo7H86tNGi4pFQlXS6TKn7sZaYTp83SBenlig38tHpNZdBtqAcnVicsjuidF6lOSj65S1iY0LrQmTalsHVqf+3GWkBjECTzSLlJ/EK1RXLkhbS+JE7SzJn2Tp0fTdWkqhBc1FqGiBphnudbmAt9udSqWv3SQbk636TrXo7Kb+X0Wbv+D3xit7d89I3w+MJu5M3vjOz0Jy7mblR1guByAytCdNntQOjOlJx1Dd+u3JWRFbgqrFdCdNoQiG2noHBgszzGcUigmYKwYpNxFpqBzjWIiM/0jc2mShiB1Weao3QXkiajztmAEUCSDrsloWuRYask9x6/2k+SCNqSb2oGwHzIlUlrciFoa6LsWhF1ETCGNkHVJpiAtOk6y9JxsTVaRmtUoMo5Lec970YnlU5Mvlh5vJ9vPOJGshaHzkDRucVma5Fzg+1j+TdashJ2LvfbaCy996UvxjW98A+9+97ux33774QUveAGAahP6ddddBwB4wxveEMQ96aSTcOSRR+KOO+7Am9/8ZnzhC1/A1NQUtm7dije/+c3YsGEDnvrUp+KVr3zlzi7WboNEQJYoYgqltCpUcxnyiSAgIbF8anEbyMJYRddNMHRCoZMmSVeCRKy42xCdrKhewusiStKkvBRJi9RbUDQV5uEnTmHCFNMEaxtSAFo9QPiO5hVtHyWKHAUtA1UiqNJfjySnU6uPCGqTtUKt/wGVIqw5uXHhsjCdmvIyAvKR3TNB90rQU5hgiEgGY+lAZvaYgBx24o+upZvn7dG+Og83ljuLjiqMe5ZbhS/6xrowWJ4jH2p7V0q4hwVWFncKV5kbS0g+0ICGOW2ra9y0gIpM0fIXPUtOHGGyZCuzx+7WLhn0FYpQkST1SNssOKKbrPSLFlCaNn8ktLcrh9SW/H0Qt0VfayPX2JX2JnAZhG8opkBTMuHHqxhZQVg3wWIIcY/TaEhnIaRDUvbFwYqEjRGEBZCPJrS1YkkWmTZWrnkt6CwR8qHLEno77wFZyEWEN954I17xilf4v90+jo997GP45Cc/6Z/feuutOOigg7ZJvv/1v/4XXvCCF2D9+vV44QtfiAMOOAB777037r77bm/ZeNvb3uYtHg55nuPKK6/EC17wAnzlK1/BunXrcMQRR+Cuu+7Cxo0bsXr1avzDP/wDsiw5Cu0oJAKyhNG0yk4RKMU0Xos8pLiSkkvTlRNCpbhrmEN9FLyCJaUrmcEp0ajlSZR47X4RyhN7VrMC8fS4nAIBc+kFRMcVhyjYsTm6SgRVHdA4jGhQ6xWA8AZzIKhHT0KEiVgkrqRtasqBS7ftxEqUfJpfk6VLWsEGUN2YbUmIT5eW0x2jG1GKvAvXiBA00h99GEtC6K3m2pr0VRkeHevbIqsu8aPld+m5juNctsqOcXsqJlTYDvZYX1VYopEZIlRaF66yZ+SglhV3l4lEwLRzGdMheRIJJoRvgbYF/Tb5t0q/I/ZO1HtjiivLr5F8IHzf1K+Dco4jSTHEwsYIFM1fSo7JoIVySmnWFj0oWURFPqSFodq4ysf5MXnX0KS0UzIhxWNy+/DsHqWFkI+mOGPdwcbEb0zTP6jLtGjYgcfwzgfD4RAbNmyoPZ+ensb09LT/uyiKWpj54pBDDsFtt92GT37yk/inf/onvzF9zz33xB//8R/jtNNOq5EPh6c+9am47bbb8NGPfhTXXnst/u3f/g177703/vRP/xQf/vCHceCBB26zfAlxKK13goNfQits2rQJq1atwh+d+tfI+hONYaUJduzqcwNqq4qRyYAP/I0rTTY9utK30NWoaLrj4kjJUGVgDBGKykEVP6J811xVBKWryYRfk40+Z4pfbFW60WWNlLlGALiSIMjr0xiXPqp8auWCUHcNbd7o5sDJpGa/Ezlrl1Q6lywdDyOVkULMj9Svu+SxRn5oG/Kykw3vOqvIUEYv6wNJT6i7qMsUbc/5KJ1Cnw4sQxEy2fY7lchHrZ9J/UWSS+gv0Xjj6kBQNqX+0DReiN97ZMyOjqmSTKzexx4HLMgjgcsgvZcg9ivhuwQE4jQP8rGtWOi8MS7NYjCLf/vch7Bx48adfmyr0x2Om3wtOkq+WG+hGOkBrp/5h0UpV8JjG8kCskQxL5cpFie2ktaUh4/rH7C5PUJGGl3AahmitkLvJx4VpsPL0ppAxeQVFA6+Yhtz4RLTKW1cheDmZW2f1VYHWV3rSHhx8rd1pDN4K4nPm9xl4Sd1COlZGXy5SkC5so6Tn4tD2kQM16DguvyVruSMkh6qdEp5EWVSImy0HqQ61QpAjsrVi6Uj9mcmg7/Lg5aZKITBhYqCki0qivQkMFtR0qr3ONJVK7dLMxPqgwYTlFVF/uZ9m7aVWDb6zZF4IsZ854q3OZWT1lODkk9lD7KWFFMlv6+FQ8OYQcNGiEBQrkCouLw0jPumaTg+zjamwcKPXYAZI0+QTqS/1MhHCxnbzgfj4rcNN995Z9FR7gAml9aoE3YQEgHZxTBudcqFaUKNMHAFhiirbfIfl59TNqmSq4BwYtKVck1lozIHcfhE3VQ2l7cO42k6CQrlExUKlw5Nz7oHSS4iQfmIYuTrJIKAHLF8QN3amCKqaXz+nMoOEs/JL/mS67AOxb4nvWeky6Gm5JD2FK0bJD1KKII2QBUGYOXgCpAjP7SdFEumSSb6t4Z3eRItADqs+9pqtZBuLcsG5c3LGlFqRQU7koZm5XKyB3Ky78ETXmKJaSTtXBaXrJbDRcc5rrCi/q1QiIp4Qz6S5aWWtxA3tkhTAydmgsxSHP57zFrKlftxiFqTJDSQBNqPGi2hLAzvY2K2O1HRny9JcdhZFpyEhMcKEgFZohBXYJzCyMKMTyz8k8eXlHsaLkhHUspb5tmWhPg/mTJbk5PnpVBTpgIFwYWNlc+F4woqWJklJVuzMsbypoRhTP61FXhCoLwSSW70pu+4UkFl86vF9HZqILj1m5eNlqNG0Hh55zMxU1LUQjGjeUoWBf6M9xfR0sSUTE9amsgHqR/N31F5aNm4oh5RvPyCI5ErWIQkZZAsHxJ5p3lQ65NUtJolgYK0l7Zl0pm5x0WVYbXVlHMSz9V/jHzUIKUlCo9ae9Jy1R5JfVXqXza+aB2aj+Ip9FvqylYjl8JYEs2TxffPqLyx8rD6jObHv32aXKw+eP+neQvtOK5em4heG8ttkI5QrqZ8Ylgy5EPzgWV7pZmQsP2RtvdvB/zLv/wLjj/+eKxevRrLli3DM57xDFx66aUoy20fCJwiWnNzmEfcWjynyEorfbF82ioKDlyJ5BPOGNmikyOEOC3rxClMXGkVxRcmV6p4+x92YZrfV0Dcb2puQE0KUkyhlBQHly7f2yCVS6p/d0GdUyoZKan1CZIOLROtG1oOxdKj5Wnbr10a3JUpqHdlN27bI3dpPWuF0EWu4Z6IQB763u3joBvV6e95mK6m+eTsuWJyZSwvhL+L/Yy+I770vD6DduH9J7hMEMEdHtJJRTX5aBuV1UlhNXczWl6qJJK+Qb8T2rcC8P7pMxfKyeqjVgdcJiaXlDevl9pKv0DYGheIIuVps6hESXT1kJSJZ8X7nSQLSacpjdq3LsjNCRDt/y6/mGvWtpCPJjSSDyFMWy+CoL8mPT0hYV5IFpBtxAUXXICzzjoLAHDYYYdh+fLluO2223D66adj3bp1uOqqqxZ0jFtthZatGDau0COM61a8oeoDr7TaL8ojPIuGl/LT4Ss/YUrpS/KROqhl17BSKBXC5T9uNVNyNxvbBmQy8ieBMaVRFM2VgdcVqSd6d0NT+QJZ/R9WJlTld++9FcWFYYptbcWdyBdmKMghyFSLplC7P8LXs1TeSJpNikCw+soVISaXqLSzdpTy4avEvD5qLm0t5A9O/6LyU3npL0I/aySkgpycxAT5kvBKG9ISLE5w2dj3wr+pmoV3jAIas3w0WYCCZ1LbUoWY9D+RmPA6EeSJjlH8d56udJEhk3WcYhx9L/VBHlYgFwtZ2Ve8rqiyThck+BzVkGcbOdqSkxj5aXrP04paoBYZutTQ29kck84pSthRSBaQbcD3vvc9fPCDH0SWZfjSl76Eu+++G7fddht+/OMfY99998U//dM/4eKLL55/wmSSiClhUcJB3tcmMTohtB0sSbzoKpcgj5ifNPmRwV1U/HyGcRGbJgbF6zGSTmzlNboiC9RuENd0NZvIHVWkWRka22bMe8lC43538ak8waVz7n1sEhYU05oMXJFkcvn7KTSrU9dPYsdxSvnp8IdeThj8aKLwOhmolYT361jZxvTH2iqo8P0GFyg29QdexxrGo4Ktvou3f1srEL1pnltfgvaQLDdtxgZJ0Wbkg1s5fLAmJW5cvg3fLv9b6mO1tCLjUc1K2mYMFsbIWriI0u+sa43fvYAoERIDI+iH4P1wDGlqTLoNQZLIB+nHsfixOpXyHvdOnE9bkA8uw5Jxt0pI2MWRCMg24LzzzoPWGqeddhpe97rX+edHHXWUJx4XXHABhsPhwjKgE6SAxlVCqgSNMfNz94c2SrvkMqGk/MaRkKbBfEy+QT1whVRQCmvPhfoSZWBx+MRfeycoPFJ9hQEQToZMkZPQdsWvHghhG1C5iSJEiQpV5qWfoMwSYeH5C6dDcbeomsJM5ZL6qq8YIU+WfxtSWKsD6rZUkgsBhf5D++Q40kHl5+Si5p4llCWqSDaVk5KQDvkhpITKxr8xn4VA7Ma1E2+vWJ+q9WWBAIv9nZeZjYVNiwqcfMSsH8G300AggjGo9hIBGa7lKX1bYxD9NpnMVIZtUbLFOML4GvQfOtap6j2XT7JKS3k3tWdUNj7e8nyktmmQhcqzqNDljvlJSNgBSARkgdi0aRPWrVsHAHjrW99ae3/yySdj5cqV2LBhA2644Yb5Jd6gwNaCMuXFx3cQlM0AsQGVTtpNinNDPDrhiCSkFAb9mOwCakpn23KhUqZ9XFbntclkDNGY92quC8brisoZIwqsHOOUvKaVbUkRDMAUz1g/kPpeTGn14Uia1CJRF7KetpeNycAJC60vejs433cgpScSWLJfAmxviih3w090dZeREG7JCMrDf4p4OWt1J5EAokyPW6iIlhNhW4xD2/ElRlBiRCVQLqVVfzSMIQ3kg+fjwkfHS2GMq9UNH+uE99IYPpZIx+pfodrXFLO+NKCRsLB2CWSk/ZiQj8a4kbwbiWSTbEK/ic5DEkGKjDtLAbrUO+QnIWFHIBGQBeLWW2/FYDDAxMQEnvGMZ9Ted7tdHHPMMQCAH/zgB/NKW1xVJu8WFDc2WDdNUAsZVKmCRAftCAmRJqCoxQRh+WsKCCMUtboQJp+mFVenkMVWwBpXa4kcEnhbiOTGPxDaLtY2MYVEsfK0VRB5X2LksVF5ZEqyKxuVQZH0JOVK0XcN82BQDtYPfFoNLlC1vKQ6YGHF+ALxG7e6X1OEpP7O2iGmeCoNT0K46xatG1pebuXim61r5IfKCoTfsuDWJ35X9HlEseMKX6y/8baI9TFRJo36oUGcOLD0eF5UtkYISjuNF43fhnwI9Uy/rVp8OjZyMceUQypDLIyK1btEPkhcKV3aZ7bVEtFk7YkSP1oWJk9CQsL8kQjIAnHnnXcCAA4++GB0OvJe/sMOOywIO19Ig1uwcs+e87jSBFNbFZ+HLK3DS+TBkRDuWgIWxsYfR0K4YhZd5Xd5CpN/YxEaCEFraxCHDn/GTqLCRDh2xa+B9LSZOGP9qEbGIkpjXbDqJ7i5nba9cGIYT6PtHorYKmU9YFwRppcL8n0WvA9LlpaxecfAvhdaXk4UXBkCa4nUplTxo32EyurSd9Ydoa9pmg5NnpICdhJW1ILHSVSszlp8o6LyyL4bN/bQ+gryDxJlv0e+w5qoTWOj1AYtIBIT8g3X0pbiuu8l5hYLBO00bkxqO4ZG28b/wfqJIHtjvpE+EyNh3NoXk1EsQ1P987CLjeSClbALIZ2CtUA88sgjAIA999wzGsa9c2E55ubmMDc35//euHEjAKAYzAbh5jOwtSEnPNx8VrzmK4+f/FFN/O65uCrHw7CJk07gbSwFjWGobFwpcvJI9TRmQmpayQzyFdoqKi+tAykOFamhfFy+pv5CZXGrkm3kCYVDvb5iyjrLz8sSUQLc763brkEBU05Jo+kyVySpXmk5Y/k3KmJcthjGfAO8Dhq/A+nbiyFWV5J8koyMAPi0NGvbSDl8emNQs4JSWWmb0LtY3NjCiAkAmSwLcs2HyAd1YsNEx5cxZfbfI08/ptjTNFk7SPLWZBcwX4Wby9xI/iJ5z4cQ1PKQxpY2YP0wlpebtxfz1KgRhu2+6/mmmZCwA5AIyAIxO2sGm16vFw3T7/cBADMzM+L7j33sY/jIRz5Se/6LK87dDhImJCQkJCQk7Exs3rwZq1at2ql59no9PO5xj8N37/+XHZL+4x73uEZdJyFhIUgEZIGYmJgAAAwGg2gYZ92YnJwU35911lk444wz/N+PPvooDjnkEKxfv36nD2AJux42bdqEgw46CL/5zW+wcuXKxRYnYQkj9ZWE+SD1l/lDa43Nmzdj//333+l5T0xM4N57723UR7YFvV7P6zwJCdsLiYAsEOPcq+i7mJtWv9/3VhKKVatWpUE/oTVWrlyZ+ktCK6S+kjAfpP4yPyzmwuHExEQiCQm7FNIm9AXiCU94AgBg/fr1GI1GYph77rknCJuQkJCQkJCQkJCwuyMRkAXi6KOPRrfbxezsLH784x/X3g+HQ/zoRz8CABx77LE7W7yEhISEhISEhISEJYlEQBaIlStX4vjjjwcAXH755bX3V155JTZt2oQ1a9bgRS96Uas0+/0+zjnnHNEtKyGBI/WXhLZIfSVhPkj9JSEhYUdD6cU8M24Xx4033ojnP//5UErhi1/8Il73utcBAG677Ta89KUvxQMPPIALL7wQ73vf+xZZ0oSEhISEhISEhISlgURAthF//dd/jbPPPhuAuXhw+fLl+NnPfoayLHHCCSfga1/7GvI8X2QpExISEhISEhISEpYGEgHZDvjnf/5n/I//8T9wyy23YDgc4glPeALe/OY3413velciHwkJCQkJCQkJCQkEiYAkJCQkJCQkJCQkJOw0pE3oCQkJCQkJCQkJCQk7DYmALAH8y7/8C44//nisXr0ay5YtwzOe8QxceumlKMtysUVL2Mk49dRToZRq/JmdnRXjfu9738MrXvEK7L333picnMSTn/xknHvuudHwCbsG7r33Xlx22WV429vehqOOOgqdTgdKKZx33nlj4y60T9x+++34sz/7M+y3336YmJjA4YcfjjPPPBOPPvrodipVwo7AQvrK2rVrx445d9xxRzR+6isJCQkLQboJfZFxwQUX4KyzzgJQbWK/7bbbcPrpp2PdunW46qqrkGWJJ+5ueMITnoB99tlHfCf1hyuuuAJvetObUBQFDjjgABx00EH42c9+hg9/+MP4+te/jm9/+9uYmpra0WIn7ABccskluOSSS+Ydb6F94oYbbsAJJ5yAmZkZ7L333njKU56CO+64A5/4xCdw1VVX4aabbsK+++67PYqWsJ2x0L4CAAcddBAOPvhg8V1s7Eh9JSEhYcHQCYuGm266SSuldJZl+ktf+pJ//pOf/ETvu+++GoC+6KKLFlHChJ2NN73pTRqA/tznPtc6zr333qv7/b4GoD/+8Y/rsiy11lrfd999+klPepIGoP/iL/5iB0mcsKNx7rnn6hNPPFF/9KMf1ddee60+6aSTNAB97rnnRuMstE9s2rRJ77333hqAPv300/VgMNBaa/3QQw/p5z3veRqAPuGEE3ZMQRO2GQvpK+ecc44GoM8555x55ZX6SkJCwrYgEZBFxMtf/nINQL/97W+vvbviiis0AL1mzRo/sCc89rEQAvLOd75TA9AveclLau9uvPFGDUB3u119//33b0dJExYLro80KZUL7RMf//jHNQD9H/7Df9Cj0Sh49+tf/1p3Oh0NQN9yyy3bpzAJOxRt+spCCUjqKwkJCduC5NuzSNi0aRPWrVsHAHjrW99ae3/yySdj5cqV2LBhA2644YadLV7CLgKtNa666ioAcj967nOfiyOPPBLD4RBf+9rXdrZ4CYuAbekTX/3qVwGYvUj8CPGDDz4Yxx9/PADgH//xH3eE6Am7EFJfSUhI2BYkArJIuPXWWzEYDDAxMYFnPOMZtffdbhfHHHMMAOAHP/jBzhYvYZHxj//4j3jlK1+J4447DqeccgouvfRSbNy4sRZu/fr1+P3vfw8AeN7zniem5Z6nfrR7YKF9YjQa4ZZbbpl3vITHBm644QacfPLJOO644/Ca17wGH//4x3H//feLYVNfSUhI2FakTeiLhDvvvBOAWSnqdORmOOyww/Ctb33Lh03YfXDNNdcEf//DP/wDzjnnHHzpS1/Cf/pP/8k/d32j3+9j//33F9M67LDDgrAJj20stE/cd999GA6Hwfs28RIeG/jOd74T/P2Vr3wFa9euxac+9SmceuqpwbvUVxISErYVyQKySHjkkUcAAHvuuWc0jHvnwiY89nH44Yfj/PPPx2233YZNmzZh8+bN+OY3v4ljjz0WjzzyCF75ylfi5ptv9uFd39hjjz2glBLTTP1o98JC+wT9PTYupb702MN+++2HD37wg/jRj36EDRs2YHp6GjfeeCNe9rKXYWZmBm95y1vw9a9/PYiT+kpCQsK2IllAFgnuHP5erxcN0+/3AQAzMzM7RaaExcdf/dVf1Z69+MUvxgtf+EI8//nPxw9/+EO8//3vx7e+9S0AqR8l1LHQPkHvBonFTX3psYd3vOMdtWfPfe5zcc011+Ckk07CVVddhfe85z048cQTPaFNfSUhIWFbkSwgi4SJiQkAwGAwiIaZm5sDAExOTu4UmRKWLnq9Hs4991wAwLe//W2/qpj6UQLHQvuEi9cUN/Wl3QdKKVxwwQUAgLvvvhs//elP/bvUVxISErYViYAsEtqYp9u4aSXsPnjOc54DACjLEvfccw+Aqm88+uij0FqL8VI/2r2w0D5Bf4+NS6kv7V544hOfiNWrVwMA7rrrLv889ZWEhIRtRSIgi4QnPOEJAMyJNaPRSAzjlEwXNmH3Rrfb9b+7PuP6xtzcHH73u9+J8VI/2r2w0D5x6KGH+j7m3reJl/DYhusTdJ5KfSUhIWFbkQjIIuHoo49Gt9vF7OwsfvzjH9feD4dD/OhHPwIAHHvssTtbvIQliJ///Of+9wMPPBCAOUXtcY97HADgxhtvFOO556kf7R5YaJ/odDr+SPDUlxIA4KGHHsKDDz4IoBpzgNRXEhISth2JgCwSVq5c6S9quvzyy2vvr7zySmzatAlr1qzBi170op0sXcJSxCc+8QkAwJFHHokDDjgAgPHTftWrXgVA7kc33XQT7rjjDnS7XfyX//Jfdp6wCYuGbekTr371qwEAn//851EURfBu/fr1/vLUk046aUeInrDEcPHFF0NrjVWrVvl7qRxSX0lISNgWJAKyiPjQhz4EpRQ++9nP4u/+7u/889tuuw1nnHEGAOB973tf42k2CY8dXHfddTjrrLNw7733Bs83btyI008/3feRD3/4w8H7//7f/zt6vR6++c1v4qKLLvJ+/7/+9a/xlre8BQBw2mmn+VXxhMc+Fton/ut//a/Ya6+9cPvtt+OMM87wdz1s2LABr3/96zEajfCyl70Mz3zmM3dugRJ2CH7+85/jne98Z2BdBcwpV+effz4uvPBCAMD73//+2jyU+kpCQsI2QScsKs477zwNQAPQhx12mP6jP/ojnWWZBqBPOOEEPRqNFlvEhJ2Eq666yveFAw44QB9zzDH66U9/uu71ehqAVkrpc845R4z7t3/7t77fHHDAAfroo4/W3W5XA9DPfOYz9ZYtW3ZuYRK2G7773e/qNWvW+J9+v68B6KmpqeD5+vXrg3gL7RPr1q3TExMTGoDee++99TOf+Uw9NTWlAehDDz1U//73v98ZxU5YAObbV2699VY/5ri2pu0NQL/1rW/VZVmK+aW+kpCQsFAkArIE8PWvf10fd9xxetWqVXpqakofddRR+pOf/GQiH7sZ1q9frz/0oQ/p4447Th988MF6cnJST0xM6Mc//vH6jW98o/7+97/fGP/GG2/UJ554ol69erXu9/v6SU96kl67dq2emZnZSSVI2BG44YYbvDLY9HPvvffW4i60T/zsZz/Tp5xyit5nn310r9fTj3/84/UZZ5yhH3744R1UyoTtgfn2lUceeUSfe+65+mUve5l+/OMfr5cvX657vZ4+8MAD9Wte8xr9jW98Y2yeqa8kJCQsBErryDmNCQkJCQkJCQkJCQkJ2xlpD0hCQkJCQkJCQkJCwk5DIiAJCQkJCQkJCQkJCTsNiYAkJCQkJCQkJCQkJOw0JAKSkJCQkJCQkJCQkLDTkAhIQkJCQkJCQkJCQsJOQyIgCQkJCQkJCQkJCQk7DYmAJCQkJCQkJCQkJCTsNCQCkpCQkJCQkJCQkJCw05AISEJCQkJCQkJCQkLCTkMiIAkJCQkJCQkJCQkJOw2JgCQkJCS0xOzsLA455BA8+clPRlmWiy3OglAUBZ74xCfisMMOw2AwWGxxEhISEhJ2QyQCkpCQkNASl156KdavX4+zzz4bWbZrDp95nuOss87Cvffei09/+tOLLU5CQkJCwm4IpbXWiy1EQkJCwlLHpk2bcOihh2LPPffEr371K+R5vtgiLRij0QiHHXYYZmZmcN9992HZsmWLLVJCQkJCwm6EXXMJLyEhIWEn44orrsAjjzyCN7zhDbs0+QCATqeD17/+9XjooYfw93//94stTkJCQkLCboZEQBISEhJa4LLLLgMAvO51r1tkSbYPTjnlFADAZz/72UWWJCEhISFhd0MiIAkJCY8pnHbaaVBK4cUvfjEkD9MPf/jDUErhaU97Gubm5lql+atf/Qq33norDj/8cDzpSU+qvb/vvvuglMKhhx4KwCj1Rx99NKampnDAAQfg9NNPx+bNmwGYTeCf+MQn8JSnPAWTk5M48MAD8YEPfEDcEL527VoopbB27Vps2LAB73znO3HggQdicnISRx11VGC9+PWvf403v/nN2H///TE5OYlnPvOZuOaaa6JlevrTn44DDjgA3//+97F+/fpW9ZCQkJCQkLA9kAhIQkLCYwqf/OQncdhhh2HdunW45JJLgnc/+MEPcP7556PX6+GLX/wi+v1+qzS/853vAACe9axnjQ373ve+F29729uwefNmHH744XjwwQdx6aWX4pWvfCXKssRrXvManHnmmdBa45BDDsHvfvc7XHjhhXjb294WTfORRx7Bs5/9bFx++eXYd999sWbNGvz0pz/F6173OnzhC1/AL3/5SzzrWc/Cl7/8Zey///5Yvnw5fvzjH+MVr3gF1q1bF03XlceVLyEhISEhYWcgEZCEhITHFJYvX47/83/+jz/t6ec//zkAYHp6Gm94wxtQFAXOPfdcHHXUUa3TvOmmmwAAz3zmMxvD/fa3v8Xll1+OdevW4a677sK//du/4dZbb8WaNWtw/fXX46STTsLNN9+MW2+9Fb/4xS9wxx134Prrr0ev18MXvvAF/OIXvxDT/fSnP42DDjoIv/nNb3DLLbfg3//933HBBRcAAD7wgQ/gjW98I4477jjcf//9uPnmm/HAAw/gHe94B4qiwIc+9KGovMcccwwA4Lvf/W7rukhISEhISNhWJAKSkJDwmMNzn/tcvO9978Ps7Cz+/M//HIPBAGeccQbuvPNOvOAFL8CZZ545r/R+/etfAwD222+/xnCj0Qhr167Fn/zJn/hnT33qU/H2t78dAHD11Vfj0ksvxdOf/nT//kUvehFe/epXAwD+7//9v2K6nU4HX/ziF7HPPvv4Z2eeeSYOPPBA/P73v8dvfvMbXH755VixYgUAIMsyXHDBBZiYmMAPf/hDPPzww2K6rjyufAkJCQkJCTsDiYAkJCQ8JvGRj3wERx99NH7yk5/gxBNPxGc+8xmsXLkSX/jCF+Z9h8dDDz0EAFi9evXYsG95y1tqzxzhWL16NV75ylfW3h999NEAgHvuuUdM82Uvexn233//4Fme53ja054GwGyMn5qaCt7vscceePzjHw8AuPfee8V0XXn+8Ic/REqTkJCQkJCw/ZEISEJCwmMS3W4XX/ziFzExMYHrrrsOAPA//+f/xCGHHDLvtGZnZwFg7J6RvffeGytXrhSfA8Dhhx8ejQcAW7ZsEd+Pi7fQdCcnJwEAMzMz4vuEhISEhIQdgURAEhISHrM44ogjcPDBBwMAVq1ahZNOOmlB6ThLwaOPPtoYjlshHJRSrd7H7oXdUek616y99tpLfJ+QkJCQkLAjkAhIQkLCYxYf+tCH8Ktf/QpZlmHjxo14z3ves6B03N6L2F6KXRWuPM5SkpCQkJCQsDOQCEhCQsJjEt/5zndw8cUXY2pqCtdddx322GMPfPazn8XXv/71eafl9nDcfvvt21nKxYU7desZz3jGIkuSkJCQkLA7IRGQhISExxw2bdqEN73pTSjLEhdddBGOO+44/M3f/A0Ac1HhfDdd//Ef/zEA4Oabb97usi4mfvjDHwIAnv/85y+yJAkJCQkJuxMSAUlISHjM4fTTT8d9992Hl7zkJXjnO98JAHj961+P1772tXjwwQf9sbht8dznPhfLli3DzTff7Dek7+rYsmULbrvtNuyxxx6tLlhMSEhISEjYXkgEJCEh4TGFq666Cn/7t3+LPffcE5/73OeCd5/+9Kex//774+qrr669a8KyZctwyimnYOvWrbjmmmu2t8iLgq997WuYm5vD61//+tY3wickJCQkJGwPJAKSkJDwmMEDDzzgrRuf+tSnandnOFKilMJf/uVf4r777mudtkv3iiuu2G7yLib+7u/+DoBxSUtISEhISNiZUDp2PmNCQkJCQoCXvOQluOGGG3DnnXfi0EMPXWxxFoy77roLRx55JF760pc+Ziw6CQkJCQm7DpIFJCEhIaElLrzwQhRFgfPPP3+xRdkm/PVf/zW01rjgggsWW5SEhISEhN0QncUWICEhIWFXwdFHH43LLrsMDz74IMqyRJbtems4RVHgiCOOwGc/+1k87WlPW2xxEhISEhJ2QyQXrISEhISEhISEhISEnYZdb/kuISEhISEhISEhIWGXRSIgCQkJCQkJCQkJCQk7DYmAJCQkJCQkJCQkJCTsNCQCkpCQkJCQkJCQkJCw05AISEJCQkJCQkJCQkLCTsP/ByKrndlJ+tC9AAAAAElFTkSuQmCC", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" }, { "name": "stdout", @@ -14330,8 +3745,12 @@ " observed = sub_problem.shot.observed\n", "\n", " # Pre-process the wavelets and observed\n", - " wavelets = process_wavelets(wavelets, f_max=f_max, filter_relaxation=0.25, runtime=worker)\n", - " observed = process_observed(observed, f_max=f_max, filter_relaxation=0.25, runtime=worker)\n", + " wavelets = process_wavelets(wavelets, f_max=f_max, filter_relaxation=0.75, runtime=worker)\n", + " observed = process_observed(observed, f_max=f_max, filter_relaxation=0.75, runtime=worker)\n", + " processed = process_wavelets_observed(wavelets, observed, f_max=f_max, runtime=worker)\n", + " wavelets = processed.outputs[0]\n", + " observed = processed.outputs[1]\n", + " \n", " # Execute the PDE forward\n", " modelled = pde(wavelets, vp, problem=sub_problem, runtime=worker)\n", "\n", @@ -14342,7 +3761,7 @@ " fun = await loss(traces.outputs[0], traces.outputs[1],\n", " problem=sub_problem, runtime=worker).result()\n", "\n", - " iteration.add_fun(fun)\n", + " iteration.add_loss(fun)\n", " runtime.logger.info('Functional value for shot %d: %s' % (shot_id, fun))\n", "\n", " # Now, we can calculate the gradient by executing the adjoint of the\n", @@ -14359,7 +3778,7 @@ " runtime.logger.info('Done iteration %d (out of %d), '\n", " 'block %d (out of %d) - Total loss_freq %e' %\n", " (iteration.id+1, block.num_iterations, block.id+1,\n", - " optimisation_loop.num_blocks, iteration.fun_value))\n", + " optimisation_loop.num_blocks, iteration.total_loss))\n", " runtime.logger.info('====================================================================')\n", "\n", "# Plot the vp afterwards \n", @@ -14435,7 +3854,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.11.9" } }, "nbformat": 4,