diff --git a/.github/workflows/python-app.yml b/.github/workflows/python-app.yml new file mode 100644 index 0000000..2ff1e65 --- /dev/null +++ b/.github/workflows/python-app.yml @@ -0,0 +1,50 @@ +on: + push: + branches: [ master ] + pull_request: + branches: [ master ] + +jobs: + py310: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: Set up Python 3.10 + uses: actions/setup-python@v2 + with: + python-version: "3.10" + - name: Install dependencies + run: | + pip install nose2[coverage_plugin] + pip install "git+https://${{ secrets.deployment_user }}@github.com/emerald-geomodelling/simpeg.git@simpleem3" + pip install "git+https://${{ secrets.deployment_user }}@github.com/emerald-geomodelling/EmeraldProcessing.git" + pip install utm + pip install pyMKL + pip install -e . + - name: Test with nose2 + run: | + nose2 --coverage-report=xml --with-coverage --plugin nose2.plugins.junitxml --junit-xml -v -s tests pipeline + - name: JUnit version fix + if: always() + run: | + { + echo '' + grep "' + } > x + mv x nose2-junit.xml + cat nose2-junit.xml + - name: Generate badges + if: always() + uses: gaelgirodon/ci-badges-action@v1 + with: + gist-id: 9e15232e12bf2ddf537185b43ca2060f + token: ${{ secrets.GIST_TOKEN }} + - name: Clear badge cache + if: always() + shell: bash + run: | + urls=$(curl -sLk https://${{ secrets.deployment_user }}@github.com/${{github.repository_owner}}/${{ github.event.repository.name }}/tree/${{ steps.branch-name.outputs.current_branch }}|grep -Eo "(http|https)://camo.githubusercontent.com[a-zA-Z0-9./?=_%:-]*") + while IFS= read -r line; do curl -X PURGE $line ; done <<< $urls + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ea3edfe --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +__pycache__ +*~ +*.pyc +.ipynb_checkpoints/ +*.egg-info/ +*.xyz +*.pickle +*.idea/ +docs/data diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f7697d6 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 EMerald Geomodelling + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..4368d0d --- /dev/null +++ b/README.md @@ -0,0 +1,29 @@ +![Endpoint Badge](https://img.shields.io/endpoint?url=https%3A%2F%2Fgist.githubusercontent.com%2Fredhog%2F9e15232e12bf2ddf537185b43ca2060f%2Fraw%2Fcb3a10893e74a0f97e94bcb7051c69270157fe49%2Fexperimental-pipeline-inversion-junit-tests.json) +![Endpoint Badge](https://img.shields.io/endpoint?url=https%3A%2F%2Fgist.githubusercontent.com%2Fredhog%2F9e15232e12bf2ddf537185b43ca2060f%2Fraw%2Fcb3a10893e74a0f97e94bcb7051c69270157fe49%2Fexperimental-pipeline-inversion-cobertura-coverage.json) + +# emerald-beryl-pipeline + +Luigi based pipeline to run inversions using [our simplified SimPEG wrapper](https://github.com/emerald-geomodelling/experimental-simpeg-ext) + +To run this pipeline locally: + +``` +luigi --module beryl_pipeline.inversion Inversion --inversion-name=file:///some/temp/dir +``` + +This assumes you've copied `docs/example-real.yml` to `/some/temp/dir/config.yml`. + + +# Documentation + +* Documentation on how to [run all the pipelines from anotebook](docs/run%20processing%20inversion%20luigi.ipynb) +* Documentation on how to [extract the API documentation](docs/run%20introspection.ipynb) used to generate the front end UI + * This should be used to test any changes / additions to e.g. processing pipeline filters + +# Unit tests + +To run the unit tests, first `pip install nose2` and then run + +``` +nose2 -s tests +``` diff --git a/beryl_pipeline/__init__.py b/beryl_pipeline/__init__.py new file mode 100644 index 0000000..1328bb2 --- /dev/null +++ b/beryl_pipeline/__init__.py @@ -0,0 +1 @@ +# Do NOT import everything here, as importing e.g. the inversion modules is SLOW! diff --git a/beryl_pipeline/file_import.py b/beryl_pipeline/file_import.py new file mode 100644 index 0000000..53b7617 --- /dev/null +++ b/beryl_pipeline/file_import.py @@ -0,0 +1,165 @@ +import luigi +import luigi.contrib.opener +import luigi.format +import libaarhusxyz +import yaml +import tempfile +import shutil +from . import utils +from . import localize +import poltergust_luigi_utils.caching +import poltergust_luigi_utils.logging_task +import typing +import pydantic +import importlib.metadata +import pandas as pd +import os +import copy +import slugify + + +Projection = typing.Annotated[ + int, + {"json_schema": { + "format": "x-epsg", + }}] + +LibaarhusXYZImporterSelf = typing.TypeVar("Self", bound="LibaarhusXYZImporter") +class LibaarhusXYZImporter(libaarhusxyz.Survey): + json_schema = {"hide": True} + api_type = "__init__" + def __init__(self: LibaarhusXYZImporterSelf, + files: typing.Annotated[dict, {"json_schema": + {"type": "object", + "x-format": "multi-url", + "description": "Required: .gex, .xyz | Optional: .alc", + "properties": { + "xyzfile": {"minLength": 5, "pattern": "\.xyz$", "type": "string", "format": "url", "description": "The data itself"}, + "gexfile": {"minLength": 5, "pattern": "\.gex$", "type": "string", "format": "url", "description": "System description / calibration file"}, + "alcfile": {"minLength": 5, "pattern": "\.alc$", "type": "string", "format": "url", "description": "Allocation file (column name mapping)"}, + }}}], + scalefactor = 1e-12, + projection: Projection = None): + """Import SkyTEM data + + Parameters + ---------- + scalefactor : + Data unit, 1 = volt, 1e-12 = picovolt + projection : + EPSG code for the projection and chart datum of sounding locations + """ + xyzfile = files.get("xyzfile") + gexfile = files.get("gexfile") + alcfile = files.get("alcfile") + + assert isinstance(projection, int) and projection > 0, "Invalid projection, please provide a valid projection" + assert isinstance(scalefactor, float) and scalefactor != 0, "Invalid scalefactor, please provide a valid scalefactor" + assert xyzfile is not None, "Missing xyz file" + assert gexfile is not None, "Missing gex file" + + xyz = libaarhusxyz.XYZ(xyzfile, alcfile=alcfile) + if scalefactor: + xyz.model_info['scalefactor'] = scalefactor + if projection: + xyz.model_info['projection'] = projection + xyz.normalize(naming_standard="alc") + + assert "projection" in xyz.model_info + assert "scalefactor" in xyz.model_info + + # Check for None only to support inversion_workbench_import + gex = libaarhusxyz.GEX(gexfile) if gexfile is not None else None + + libaarhusxyz.Survey.__init__(self, xyz, gex) + +importers = {entry.name: entry for entry in importlib.metadata.entry_points()["beryl_pipeline.import"]} + +class Import(poltergust_luigi_utils.logging_task.LoggingTask, luigi.Task): + import_name = luigi.Parameter() + logging_formatter_yaml = True + + def __init__(self, *arg, **kw): + luigi.Task.__init__(self, *arg, **kw) + self._log = [] + + def config_target(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget('%s/config.yml' % (self.import_name,)) + + def run(self): + with self.logging(): + self.log("Read config") + + with self.config_target().open("r") as f: + config = yaml.load(f, Loader=yaml.SafeLoader) + + self.log("Download files") + + with localize.localize(config) as config: + with localize.upload_directory(self.import_name) as tempdir: + self.log("Import data") + + importer_fn = importers[config["importer"]["name"]].load() + importer = importer_fn(**config["importer"].get("args", {})) + + self.log("Write and upload data") + importer.dump( + xyzfile = '%s/out.xyz' % (tempdir,), + gexfile = '%s/out.gex' % (tempdir,), + msgpackfile = '%s/out.msgpack' % (tempdir,), + summaryfile = '%s/out.summary.yml' % (tempdir,), + geojsonfile = '%s/out.geojson' % (tempdir,)) + + for fline, line_data in importer.xyz.split_by_line().items(): + fline = slugify.slugify(str(fline), separator="_") + line_importer = copy.copy(importer) + line_importer.xyz = line_data + line_importer.dump( + xyzfile = '%s/out.%s.xyz' % (tempdir, fline), + gexfile = '%s/out.%s.gex' % (tempdir, fline), + msgpackfile = '%s/out.%s.msgpack' % (tempdir, fline), + summaryfile = '%s/out.%s.summary.yml' % (tempdir, fline), + geojsonfile = '%s/out.%s.geojson' % (tempdir, fline)) + + with self.output().open("w") as f: + f.write("DONE") + + def logfile(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget( + '%s/log.yml' % (self.import_name,)) + + def system_data(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget( + '%s/out.gex' % (self.import_name,), + format=luigi.format.NopFormat()) + + def data(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget( + '%s/out.xyz' % (self.import_name,), + format=luigi.format.NopFormat()) + + def data_msgpack(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget( + '%s/out.msgpack' % (self.import_name,), + format=luigi.format.NopFormat()) + + def summary(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget( + '%s/out.summary.yml' % (self.import_name,)) + + def fl_data(self, fline): + return poltergust_luigi_utils.caching.CachingOpenerTarget( + f'{self.import_name}/out.{fline}.xyz', + format=luigi.format.NopFormat()) + + def fl_data_msgpack(self, fline): + return poltergust_luigi_utils.caching.CachingOpenerTarget( + f'{self.import_name}/out.{fline}.msgpack', + format=luigi.format.NopFormat()) + + def fl_summary(self, fline): + return poltergust_luigi_utils.caching.CachingOpenerTarget( + f'{self.import_name}/out.{fline}.summary.yml') + + def output(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget('%s/DONE' % (self.import_name,)) diff --git a/beryl_pipeline/integration.py b/beryl_pipeline/integration.py new file mode 100644 index 0000000..7c3df61 --- /dev/null +++ b/beryl_pipeline/integration.py @@ -0,0 +1,92 @@ +import luigi +import poltergust_luigi_utils.caching +import yaml +from . import file_import +from . import processing +from . import inversion + +class IntegrationStep(luigi.Task): + integration_name = luigi.Parameter() + step = luigi.Parameter() + + def requires(self): + if self.step == "inversion": + return IntegrationStep( + integration_name=self.integration_name, + step="processing") + elif self.step == "processing": + return IntegrationStep( + integration_name=self.integration_name, + step="import") + else: + return None + + def run(self): + yield self.subtask() + + def subtask(self): + if self.step == "inversion": + return inversion.Inversion(inversion_name=self.integration_name + "/inversion") + elif self.step == "processing": + return processing.Processing(processing_name=self.integration_name + "/processing") + elif self.step == "import": + return file_import.Import(import_name=self.integration_name + "/import") + else: + assert False, 'Unknown step %s' % (self.step,) + + def output(self): + return self.subtask().output() + +class Integration(luigi.Task): + integration_name = luigi.Parameter() + + def config_target(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget('%s/config.yml' % (self.integration_name,)) + + def subtask(self): + return IntegrationStep( + integration_name=self.integration_name, + step="inversion") + + def run(self): + subtask = self.subtask() + inv = subtask.subtask() + pro = subtask.requires().subtask() + imp = subtask.requires().requires().subtask() + + with self.config_target().open("r") as f: + config = yaml.load(f, Loader=yaml.SafeLoader) + + print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA") + print() + print() + print("IMP", imp, imp.config_target().url) + print("PRO", pro, pro.config_target().url) + print("INV", inv, inv.config_target().url) + print() + print() + print("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA") + + with imp.config_target().open("w") as f: + yaml.dump(config["importer"], f) + + with pro.config_target().open("w") as f: + config["processing"]["data"] = { + "name": "emeraldprocessing.pipeline.ProcessingData", + "args": { + "data": imp.data().url, + "sidecar": None, + "system_data": imp.system_data().url, + } + } + yaml.dump(config["processing"], f) + + with inv.config_target().open("w") as f: + config["inversion"]["data"] = pro.data().url + config["inversion"]["system_data"] = pro.system_data().url + yaml.dump(config["inversion"], f) + + yield subtask + + def output(self): + return self.subtask().output() diff --git a/beryl_pipeline/introspect.py b/beryl_pipeline/introspect.py new file mode 100644 index 0000000..3f75738 --- /dev/null +++ b/beryl_pipeline/introspect.py @@ -0,0 +1,32 @@ +import luigi +import luigi.contrib.opener +import luigi.format +import yaml +import poltergust_luigi_utils.caching +import swaggerspect + +class Introspect(luigi.Task): + introspect_name = luigi.Parameter() + + def run(self): + # Hack to add save_iterations flag added to all inversion systems by the pipeline code + inversion = swaggerspect.swagger_to_json_schema(swaggerspect.get_apis("simpeg.static_instrument"), multi=False) + for system in inversion["anyOf"]: + next(iter(system["properties"].values()))["properties"]["save_iterations"] = { + "type": "boolean", + "default": False, + "description": "Save intermediate models and sythentic data for every inversion iteration" + } + + data = { + "Import": swaggerspect.swagger_to_json_schema(swaggerspect.get_apis("beryl_pipeline.import"), multi=False), + "Processing": swaggerspect.swagger_to_json_schema(swaggerspect.get_apis("emeraldprocessing.pipeline_step")), + "Inversion": inversion, + } + + with self.output().open("w") as f: + yaml.dump(data, f, sort_keys=False) + + def output(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget('%s/output.yml' % (self.introspect_name,)) + diff --git a/beryl_pipeline/inversion.py b/beryl_pipeline/inversion.py new file mode 100644 index 0000000..ca841ce --- /dev/null +++ b/beryl_pipeline/inversion.py @@ -0,0 +1,195 @@ +import contextlib +import luigi +import luigi.contrib.opener +import luigi.format +import SimPEG +import libaarhusxyz +import yaml +import numpy as np +import pandas as pd +import copy +from . import utils +from . import localize +from . import processing +import poltergust_luigi_utils.caching +import poltergust_luigi_utils.logging_task +import emerald_monitor +import slugify + +import os +import SimPEG.directives + +class SaveOutputEveryIteration(SimPEG.directives.InversionDirective): + def __init__(self, system, task): + self.system = system + self.task = task + + def endIter(self): + system = self.system + task = self.task + task.save_dataset( + "intermediate_%s_model" % self.opt.iter, + system.inverted_model_to_xyz(system.inv.invProb.model, system.inv.invProb.dmisfit.simulation.thicknesses)) + task.save_dataset( + "intermediate_%s_synthetic" % self.opt.iter, + system.forward_data_to_xyz(system.inv.invProb.dpred, inversion=True)) + +class ReportingDirective(SimPEG.directives.InversionDirective): + def __init__(self, task): + self.task = task + self.log({"step": 0, "status": "start"}) + + def log(self, data): + self.task.log("Inversion step", extra=data) + + def calc_rmse(self, status): + n_data=np.sum(self.invProb.dmisfit.W.diagonal()>0) + status['rmse_d'] = float(np.sqrt((status['phi_d']*2)/n_data)) + status['rmse_m'] = float(np.sqrt((status['phi_m']*2)/n_data)) + status['rmse_m_scaled'] = float(np.sqrt((status['phi_m_scaled']*2)/n_data)) + status['rmse_total'] = float(np.sqrt(status['rmse_d']**2 + status['rmse_m_scaled']**2)) + + def endIter(self): + status={"step" : int(self.opt.iter + 2), + 'iter' : int(self.opt.iter), + 'beta' : float(self.invProb.beta), + "phi_d": float(self.opt.parent.phi_d * self.opt.parent.opt.factor), + "phi_m": float(self.opt.parent.phi_m * self.opt.parent.opt.factor), + 'phi_m_scaled' : float(self.invProb.phi_m * self.opt.factor * self.invProb.beta), + "f": float(self.opt.f), + "|proj(x-g)-x|": float(np.linalg.norm(self.opt.projection(self.opt.xc - self.opt.g) - self.opt.xc)), + "status": "update"} + self.calc_rmse(status) + self.log(status) + + def initialize(self): + self.log({ + "step": 1, + "status": "initialize"}) + + def finish(self): + self.log({ + "step": int(self.opt.iter + 2), + "status": "end"}) + +class Inversion(poltergust_luigi_utils.logging_task.LoggingTask, luigi.Task): + inversion_name = luigi.Parameter() + logging_formatter_yaml = True + logging_formatter_yaml_include = ["time", "msg", "step", "status", "iter", + "beta", "phi_d", "phi_m", "phi_m_scaled", "f", "|proj(x-g)-x|", + "rmse_d", "rmse_m", "rmse_m_scaled", "rmse_total"] + + def config_target(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget('%s/config.yml' % (self.inversion_name,)) + + def requires(self): + with self.config_target().open("r") as f: + config = yaml.load(f, Loader=yaml.SafeLoader) + return luigi.task.externalize(processing.Processing(processing_name=config["data"].rsplit("/", 1)[0])) + + @contextlib.contextmanager + def load(self): + with self.config_target().open("r") as f: + config = yaml.load(f, Loader=yaml.SafeLoader) + + with localize.localize(config) as self.config: + with utils.load_system(self.config["system"]) as self.System: + if self.config.get("system_data", None) is not None: + self.system_data = libaarhusxyz.GEX(self.config["system_data"]) + self.System = self.System.load_gex(self.system_data) + + task = self + class PipelineSystem(self.System): + def make_directives(self): + directives = task.System.make_directives(self) + directives += [ReportingDirective(task)] + if getattr(self, "save_iterations", False): + directives += [SaveOutputEveryIteration(self, task)] + return directives + + self.PipelineSystem = PipelineSystem + + self.data = libaarhusxyz.XYZ(self.config["data"], normalize=True) + + self.inversion = self.PipelineSystem(self.data) + + yield + + def invert(self): + with emerald_monitor.resource_monitor() as monitor: + monitor.start_logging() + try: + self.inversion.invert() + finally: + monitor.stop_logging() + + monitor_info = monitor.get_logs() + self.log("Inversion time(hr): {}".format(self.inversion_time(monitor_info))) + + self.datasets = {"processed": self.inversion.corrected, + "sparse_model": self.inversion.sparse, + "sparse_synthetic": self.inversion.sparsepred, + "smooth_model": self.inversion.l2, + "smooth_synthetic": self.inversion.l2pred} + + self.resource_monitor_data = monitor_info + + # for name, dataset in list(self.datasets.items()): + # if dataset is not None: + # self.datasets[name.replace(".model", ".synthetic")] = self.System(dataset, times=self.inversion.times).forward() + + def save_dataset(self, name, dataset): + # This is just needed because right now simpleem3 uses libaarhusxyz naming standard... + dataset.normalize(naming_standard="alc") + survey = libaarhusxyz.Survey(dataset, self.inversion.gex) + + with localize.upload_directory(self.inversion_name) as tempdir: + survey.dump( + xyzfile = '%s/%s.xyz' % (tempdir, name), + msgpackfile = '%s/%s.msgpack' % (tempdir, name), + summaryfile = '%s/%s.summary.yml' % (tempdir, name), + geojsonfile = '%s/%s.geojson' % (tempdir, name)) + + for fline, line_data in survey.xyz.split_by_line().items(): + fline = slugify.slugify(str(fline), separator="_") + fl_data = copy.copy(survey) + fl_data.xyz = line_data + fl_data.dump( + xyzfile = '%s/%s.%s.xyz' % (tempdir, name, fline), + msgpackfile = '%s/%s.%s.msgpack' % (tempdir, name, fline), + summaryfile = '%s/%s.%s.summary.yml' % (tempdir, name, fline), + geojsonfile = '%s/%s.%s.geojson' % (tempdir, name, fline)) + try: + self.resource_monitor_data.to_csv(path_or_buf='%s/monitor_info.csv' % (tempdir,)) + except: + pass + + def inversion_time(self, monitor_info: pd.DataFrame): + return np.round(monitor_info.iloc[-1].elapsed_time/60/60, 4) + + + def save(self): + for name, dataset in self.datasets.items(): + if dataset is None: continue + self.save_dataset(name, dataset) + + with self.output().open("w") as f: + f.write("DONE") + + def run(self): + with self.logging(): + self.log("Loading...") + with self.load(): + self.log("Inverting...") + self.invert() + self.log("Saving...") + self.save() + self.log("Save done") + + def logfile(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget( + '%s/log.yml' % (self.inversion_name,)) + + def output(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget('%s/DONE' % (self.inversion_name,)) + diff --git a/beryl_pipeline/inversion_workbench_import.py b/beryl_pipeline/inversion_workbench_import.py new file mode 100644 index 0000000..55ce090 --- /dev/null +++ b/beryl_pipeline/inversion_workbench_import.py @@ -0,0 +1,51 @@ +import typing +import pydantic +import emeraldprocessing.pipeline +from . import file_import + +class WorkbenchImporter(object): + """Import a model inverted in Aarhus Workbench. This ignored + the input dataset completely.""" + + gexfile: typing.Annotated[pydantic.AnyUrl, {"json_schema": {"minLength": 5, "pattern": "\.gex$"}}] = None + corrected_xyzfile: typing.Annotated[pydantic.AnyUrl, {"json_schema": {"title": "*.DAT.XYZ", "minLength": 5, "pattern": "\.xyz$"}}] + model_xyzfile: typing.Annotated[pydantic.AnyUrl, {"json_schema": {"title": "*INV.XYZ", "minLength": 5, "pattern": "\.xyz$"}}] + fwd_xyzfile: typing.Annotated[pydantic.AnyUrl, {"json_schema": {"title": "*SYN.XYZ", "minLength": 5, "pattern": "\.xyz$"}}] + scalefactor = 1e-12 + projection: file_import.Projection = None + + @classmethod + def load_gex(cls, gex): + class Cls(cls): + pass + Cls.__name__ = cls.__name__ + Cls.gex = gex + return Cls + + def invert(self): + pass + + def __init__(self, xyz): + corrected = file_import.LibaarhusXYZImporter( + xyzfile=self.corrected_xyzfile, + gexfile=self.gexfile, + scalefactor=self.scalefactor, + projection=self.projection) + if corrected.gex is not None: + self.gex = corrected.gex + self.corrected = corrected.xyz + + fwd = file_import.LibaarhusXYZImporter( + xyzfile=self.fwd_xyzfile, + gexfile=self.gexfile, + scalefactor=self.scalefactor, + projection=self.projection) + self.l2pred = fwd.xyz + model= file_import.LibaarhusXYZImporter( + xyzfile=self.model_xyzfile, + gexfile=self.gexfile, + scalefactor=self.scalefactor, + projection=self.projection) + self.l2 = model.xyz + self.sparsepred = None + self.sparse = None diff --git a/beryl_pipeline/localize.py b/beryl_pipeline/localize.py new file mode 100644 index 0000000..540f698 --- /dev/null +++ b/beryl_pipeline/localize.py @@ -0,0 +1,65 @@ +import luigi.contrib.opener +import contextlib +import poltergust_luigi_utils.caching +import luigi.format +import shutil +import sys +import os +import tempfile + +@contextlib.contextmanager +def localize(config): + """A contextmanager that given a nested structure of dictionaries and + lists, finds all embedded URL:s, downloads them, and returns + the same structure, but with those replaced by the path to the + downloaded file. The local files are deleted after the context + manager exits. + """ + mapping = {} + def localize(config): + if isinstance(config, dict): + return {key: localize(value) for key, value in config.items()} + elif isinstance(config, (list, tuple)): + return [localize(value) for value in config] + elif isinstance(config, str) and "://" in config: + if "file://" in config: + return config.split("file://")[1] + else: + mapping[config] = poltergust_luigi_utils.caching.CachingOpenerTarget(config, format=luigi.format.NopFormat()) + return mapping[config].__enter__() + return config + try: + yield localize(config) + finally: + for key, value in mapping.items(): + value.__exit__() + +@contextlib.contextmanager +def upload_directory(url): + with tempfile.TemporaryDirectory() as tempdir: + yield tempdir + for name in os.listdir(tempdir): + path = os.path.join(tempdir, name) + target = poltergust_luigi_utils.caching.CachingOpenerTarget( + os.path.join(url, name), + format=luigi.format.NopFormat()) + with target.open("w") as outf: + with open(path, "rb") as inf: + shutil.copyfileobj(inf, outf) + +def save_survey(survey, **kw): + files = {key: + poltergust_luigi_utils.caching.CachingOpenerTarget( + url, + format=luigi.format.NopFormat() + ).open("w") + for key, url in kw.items()} + try: + survey.dump(**{k: v.__enter__() for k, v in files.items()}) + except Exception as e: + for key, value in files.items(): + value.__exit__(*sys.exc_info()) + raise + else: + for key, value in files.items(): + value.__exit__(None, None, None) diff --git a/beryl_pipeline/processing.py b/beryl_pipeline/processing.py new file mode 100644 index 0000000..2bbc4e0 --- /dev/null +++ b/beryl_pipeline/processing.py @@ -0,0 +1,105 @@ +import luigi +import luigi.format +import libaarhusxyz +import pandas as pd +import yaml +import tempfile +import shutil +import os.path +import yaml +from . import utils +from . import localize +from . import file_import +import poltergust_luigi_utils.caching +import poltergust_luigi_utils.logging_task +from emeraldprocessing.pipeline import ProcessingData +import copy +import numpy as np +import slugify + +from emeraldprocessing.tem.data_keys import inuse_key_prefix + + +class Processing(poltergust_luigi_utils.logging_task.LoggingTask, luigi.Task): + processing_name = luigi.Parameter() + logging_formatter_yaml = True + + def requires(self): + with self.config_target().open("r") as f: + config = yaml.load(f, Loader=yaml.SafeLoader) + return luigi.task.externalize(file_import.Import(import_name=config["data"]["args"]["data"].rsplit("/", 1)[0])) + + def __init__(self, *arg, **kw): + luigi.Task.__init__(self, *arg, **kw) + + def config_target(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget('%s/config.yml' % (self.processing_name,)) + + def run(self): + with self.logging(): + self.log("Read config") + + with self.config_target().open("r") as f: + config = yaml.load(f, Loader=yaml.SafeLoader) + + self.log("Download files") + + with localize.localize(config) as config: + with localize.upload_directory(self.processing_name) as tempdir: + self.log("Read data") + + data = utils.load_fn(config["data"]["name"])(outdir = tempdir, **config["data"].get("args", {})) + data.orig_xyz = libaarhusxyz.XYZ(config["data"]["args"]["data"], naming_standard="alc", normalize=True) + data.orig_xyz_by_line = data.orig_xyz.split_by_line() + + self.log("Processing") + + data.process(config["steps"]) + + for key in data.xyz.layer_data.keys(): + if inuse_key_prefix in key: + if '_' not in key.split(inuse_key_prefix)[0]: + col_name = f"num_{key}" + data.xyz.flightlines[col_name] = np.abs(data.xyz.layer_data[key]).sum(axis=1, skipna=True) + + self.log("Write data") + + + data.dump( + xyzfile = '%s/processed.xyz' % (tempdir,), + gexfile = '%s/processed.gex' % (tempdir,), + msgpackfile = '%s/processed.msgpack' % (tempdir,), + diffmsgpackfile = '%s/processed.diff.msgpack' % (tempdir,), + summaryfile = '%s/processed.summary.yml' % (tempdir,), + geojsonfile = '%s/processed.geojson' % (tempdir,)) + + for fline, line_data in data.xyz.split_by_line().items(): + sfline = slugify.slugify(str(fline), separator="_") + fl_data = copy.copy(data) + fl_data.xyz = line_data + fl_data.orig_xyz = data.orig_xyz_by_line[fline] + fl_data.dump( + xyzfile = '%s/processed.%s.xyz' % (tempdir, sfline), + gexfile = '%s/processed.%s.gex' % (tempdir, sfline), + msgpackfile = '%s/processed.%s.msgpack' % (tempdir, sfline), + diffmsgpackfile = '%s/processed.%s.diff.msgpack' % (tempdir, sfline), + summaryfile = '%s/processed.%s.summary.yml' % (tempdir, sfline), + geojsonfile = '%s/processed.%s.geojson' % (tempdir, sfline)) + + self.log("Done") + + with self.output().open("w") as f: + f.write("DONE") + + def logfile(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget( + '%s/log.yml' % (self.processing_name,)) + + def data(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget('%s/processed.xyz' % (self.processing_name,)) + + def system_data(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget('%s/processed.gex' % (self.processing_name,)) + + def output(self): + return poltergust_luigi_utils.caching.CachingOpenerTarget('%s/DONE' % (self.processing_name,)) diff --git a/beryl_pipeline/processing_workbench_import.py b/beryl_pipeline/processing_workbench_import.py new file mode 100644 index 0000000..b189d85 --- /dev/null +++ b/beryl_pipeline/processing_workbench_import.py @@ -0,0 +1,22 @@ +import typing +import pydantic +import emeraldprocessing.pipeline +from . import file_import + +def import_from_workbench(processing : emeraldprocessing.pipeline.ProcessingData, + xyzfile: typing.Annotated[pydantic.AnyUrl, {"json_schema": {"minLength": 5, "pattern": "\.xyz$"}}], + gexfile: typing.Annotated[pydantic.AnyUrl, {"json_schema": {"minLength": 5, "pattern": "\.gex$"}}], + alcfile: typing.Annotated[pydantic.AnyUrl, {"json_schema": {"minLength": 5, "pattern": "\.alc$"}}] = None, + scalefactor = 1e-12, + projection: file_import.Projection = None): + """Import a dataset processed in Aarhus Workbench. This replaces + the input dataset completely.""" + imp = file_import.LibaarhusXYZImporter( + xyzfile=xyzfile, + gexfile=gexfile, + alcfile=alcfile, + scalefactor=scalefactor, + projection=projection) + processing.xyz = imp.xyz + processing.gex = imp.gex + diff --git a/beryl_pipeline/utils.py b/beryl_pipeline/utils.py new file mode 100644 index 0000000..be6042c --- /dev/null +++ b/beryl_pipeline/utils.py @@ -0,0 +1,38 @@ +import yaml +import importlib +import numpy as np +import poltergust_luigi_utils # Add GCS luigi opener +import poltergust_luigi_utils.caching +import os +import importlib.metadata +import contextlib +from . import localize + +DB_URL = os.environ.get("DB_URL") + +systems = {entry.name: entry for entry in importlib.metadata.entry_points()["simpeg.static_instrument"]} + +def load_fn(name): + mod, fn = name.rsplit(".", 1) + return getattr(importlib.import_module(mod), fn) + +def load_system_from_base(base, system): + class System(base): pass + for key, value in system.get("args", {}).items(): + setattr(System, key, value) + return System + +@contextlib.contextmanager +def load_system(system): + if system["name"].startswith("/"): + with open(system["name"]) as f: + system_description = yaml.load(f, Loader=yaml.SafeLoader) + with localize.localize(system_description) as system_description: + with load_system(system_description) as base: + yield load_system_from_base(base, system) + else: + yield load_system_from_base(systems[system["name"]].load(), system) + +def iter_to_pcnt(x, a=0.5): + return 100 * a * np.log(1 + x) / (1 + a*np.log(1 + x)) + diff --git a/docs/example-real.yml b/docs/example-real.yml new file mode 100644 index 0000000..ef0aa52 --- /dev/null +++ b/docs/example-real.yml @@ -0,0 +1,6 @@ +system: + name: simpegsimpleem.DualMomentTEMXYZSystem + args: {} + +system_data: gs://experimental-pipeline-inversion/data/real.gex +data: gs://experimental-pipeline-inversion/data/real.xyz diff --git a/docs/example.yml b/docs/example.yml new file mode 100644 index 0000000..9bac51e --- /dev/null +++ b/docs/example.yml @@ -0,0 +1,10 @@ +system: + name: simpegsimpleem.SingleMomentTEMXYZSystem + args: + area: 340 + i_max: 1 + alpha_s: 10000000000 + alpha_r: 100. + alpha_z: 1. + +data: gs://experimental-pipeline-inversion/measured.xyz diff --git a/docs/run introspection.ipynb b/docs/run introspection.ipynb new file mode 100644 index 0000000..f772419 --- /dev/null +++ b/docs/run introspection.ipynb @@ -0,0 +1,1745 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "4a0c505e-ff15-4de0-9643-99d363035078", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a3073236", + "metadata": {}, + "outputs": [], + "source": [ + "import libaarhusxyz\n", + "# import pipeline_inversion.introspect\n", + "import beryl_pipeline.introspect\n", + "import luigi.contrib.opener\n", + "import poltergust_luigi_utils.caching\n", + "import yaml\n", + "import json\n", + "import os.path\n", + "import shutil" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "43f10447-d531-420d-ab24-08c83e02faba", + "metadata": {}, + "outputs": [], + "source": [ + "rootpath = os.path.abspath(\"./data\")\n", + "cachepath = os.path.expanduser(\"~/.cache/poltergust-luigi-utils\")\n", + "\n", + "root = \"file://\" + rootpath" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8fe3c0e5-b7bf-49c4-aabc-1514b077e074", + "metadata": {}, + "outputs": [], + "source": [ + "if os.path.exists(rootpath + \"/introspect\"):\n", + " shutil.rmtree(rootpath + \"/introspect\")\n", + "if os.path.exists(cachepath):\n", + " shutil.rmtree(cachepath)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "61845f1d-8cda-4645-b28d-77a364ebddc2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG: Checking if Introspect(introspect_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/introspect) is complete\n", + "INFO: Informed scheduler that task Introspect_file____home_red_33f0c7be86 has status DONE\n", + "INFO: Done scheduling tasks\n", + "INFO: Running Worker with 1 processes\n", + "DEBUG: Asking scheduler for work...\n", + "DEBUG: Done\n", + "DEBUG: There are no more tasks to run at this time\n", + "INFO: Worker Worker(salt=6955188518, workers=1, host=glittertind, username=redhog, pid=1323237) was stopped. Shutting down Keep-Alive thread\n", + "INFO: \n", + "===== Luigi Execution Summary =====\n", + "\n", + "Scheduled 1 tasks of which:\n", + "* 1 complete ones were encountered:\n", + " - 1 Introspect(introspect_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/introspect)\n", + "\n", + "Did not run any tasks\n", + "This progress looks :) because there were no failed tasks or missing dependencies\n", + "\n", + "===== Luigi Execution Summary =====\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "introspect_task = beryl_pipeline.introspect.Introspect(introspect_name = root + \"/introspect\")\n", + "luigi.build([introspect_task], local_scheduler=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7acfb9eb", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Import:\n", + " title: beryl_pipeline.import\n", + " anyOf:\n", + " - type: object\n", + " title: LibaarhusXYZImporter\n", + " description: Import SkyTEM data\n", + " required:\n", + " - LibaarhusXYZImporter\n", + " additionalProperties: false\n", + " properties:\n", + " LibaarhusXYZImporter:\n", + " properties:\n", + " scalefactor:\n", + " default: 1.0e-12\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Data unit, 1 = volt, 1e-12 = picovolt\n", + " files:\n", + " properties:\n", + " xyzfile:\n", + " minLength: 5\n", + " pattern: \\.xyz$\n", + " type: string\n", + " format: url\n", + " description: The data itself\n", + " gexfile:\n", + " minLength: 5\n", + " pattern: \\.gex$\n", + " type: string\n", + " format: url\n", + " description: System description / calibration file\n", + " alcfile:\n", + " minLength: 5\n", + " pattern: \\.alc$\n", + " type: string\n", + " format: url\n", + " description: Metadata file (column name mapping)\n", + " type: object\n", + " x-format: multi-url\n", + " description: 'Required: .gex, .xyz | Optional: .alc'\n", + " x-python-type: builtins.dict\n", + " projection:\n", + " format: x-epsg\n", + " x-python-type: builtins.int\n", + " description: EPSG code for the projection and chart datum of sounding\n", + " locations\n", + " type: integer\n", + " type: object\n", + " additionalProperties: false\n", + " description: beryl_pipeline.import\n", + "Processing:\n", + " type: array\n", + " title: emeraldprocessing.pipeline_step\n", + " description: emeraldprocessing.pipeline_step\n", + " items:\n", + " title: emeraldprocessing.pipeline_step\n", + " anyOf:\n", + " - type: object\n", + " title: Workbench import\n", + " description: 'Import a dataset processed in Aarhus Workbench. This replaces\n", + "\n", + " the input dataset completely.'\n", + " required:\n", + " - Workbench import\n", + " additionalProperties: false\n", + " properties:\n", + " Workbench import:\n", + " properties:\n", + " scalefactor:\n", + " default: 1.0e-12\n", + " type: number\n", + " x-python-type: builtins.float\n", + " foo:\n", + " x-python-type: types.UnionType\n", + " anyOf:\n", + " - type: object\n", + " x-python-type: builtins.dict\n", + " propertyNames:\n", + " type: string\n", + " x-python-type: builtins.str\n", + " patternProperties:\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " - type: array\n", + " x-python-type: builtins.list\n", + " items:\n", + " type: string\n", + " x-python-type: builtins.str\n", + " projection:\n", + " format: x-epsg\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " xyzfile:\n", + " type: string\n", + " format: url\n", + " pattern: \\.xyz$\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " minLength: 5\n", + " gexfile:\n", + " type: string\n", + " format: url\n", + " pattern: \\.gex$\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " minLength: 5\n", + " alcfile:\n", + " type: string\n", + " format: url\n", + " pattern: \\.alc$\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " minLength: 5\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: 'Classify flightlines: Selection'\n", + " description: \"Function to apply classifications to the flightlines in the dataset.\\\n", + " \\ By default, all flightlines are considered\\n 'Production' until otherwise\\\n", + " \\ set.\"\n", + " required:\n", + " - 'Classify flightlines: Selection'\n", + " additionalProperties: false\n", + " properties:\n", + " 'Classify flightlines: Selection':\n", + " properties:\n", + " lines:\n", + " items:\n", + " type: string\n", + " x-reference: flightline\n", + " type: array\n", + " x-python-type: builtins.list\n", + " description: List of line numbers you like to assign a flight type too.\n", + " flight_type:\n", + " x-python-type: types.UnionType\n", + " anyOf:\n", + " - enum:\n", + " - Production\n", + " - Tie\n", + " - Test\n", + " - High-altitude\n", + " type: string\n", + " x-python-type: builtins.str\n", + " - type: string\n", + " x-python-type: builtins.str\n", + " description: The type of flightline. Can be a custom key\n", + " type: object\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: 'Classify high altitude flightlines: Auto'\n", + " description: 'Filter to find all flightlines where the mean altitude is above\n", + " the height_threshold\n", + "\n", + " and label them as ''High-Altitude'' test lines'\n", + " required:\n", + " - 'Classify high altitude flightlines: Auto'\n", + " additionalProperties: false\n", + " properties:\n", + " 'Classify high altitude flightlines: Auto':\n", + " properties:\n", + " height_threshold:\n", + " default: 500.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: 'The height threshold, in meters above land surface, for\n", + " defining a high altitude flightline.\n", + "\n", + " The mean flight height for each flightline will be compared to this\n", + " value.'\n", + " verbose:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, more output about what the filter is doing\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Correct altitude and topo\n", + " description: Correct altitude and topography\n", + " required:\n", + " - Correct altitude and topo\n", + " additionalProperties: false\n", + " properties:\n", + " Correct altitude and topo:\n", + " properties:\n", + " terrain_model:\n", + " x-url-media-type: image/geotiff\n", + " type: string\n", + " format: url\n", + " description: Path to digital-terrain-model (DTM) GeoTIFF, in meters-above-mean-sea-level\n", + " (m.a.m.s.l.)\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " minLength: 1\n", + " verbose:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, more output about what the filter is doing\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Correct data and tilt for 1D\n", + " description: \"Function to correct the data amplitudes according to the horizontal\\\n", + " \\ source dipole moment.\\n Scaling by (cos(TxRoll) * cos(TxPitch))^2\"\n", + " required:\n", + " - Correct data and tilt for 1D\n", + " additionalProperties: false\n", + " properties:\n", + " Correct data and tilt for 1D:\n", + " properties:\n", + " verbose:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, more output about what the filter is doing\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Disable gates by STD values\n", + " description: Disable data where the STD of the datum is larger than the specified\n", + " std_threshold.\n", + " required:\n", + " - Disable gates by STD values\n", + " additionalProperties: false\n", + " properties:\n", + " Disable gates by STD values:\n", + " properties:\n", + " disable_sounding_tails:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, disables the tails (later timegates) after the\n", + " first disabled timegate\n", + " std_threshold:\n", + " default: 0.15\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Datapoints with STD's higher than std threshold will be\n", + " disabled\n", + " channel_and_gate:\n", + " properties:\n", + " channel:\n", + " x-reference: channel\n", + " type: integer\n", + " description: Channel to perform filter on\n", + " gate:\n", + " x-reference: gate\n", + " type: integer\n", + " description: Timegate index for filter\n", + " type: object\n", + " description: \"The channel and first timegate that you would like evaluated.\\n\\\n", + " \\ Note: All timegates after the first gate will be considered.\"\n", + " x-reference: channel-gate\n", + " default:\n", + " channel: 1\n", + " gate: 7\n", + " x-python-type: builtins.dict\n", + " disable_earlier_gates:\n", + " default: 0\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: 'The number of timegates earlier to disable when the filter\n", + " finds a problem with the data\n", + "\n", + " This may deactivate gates earlier than the gate specified in channel_and_gate.\n", + "\n", + " Note: negative values are allowed and will disable the number of timegates\n", + " after a problem is found'\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Disable gates by curvature max\n", + " description: \"Function to disable datapoints in a transient curve where the\\\n", + " \\ curvature between three datapoints\\nis greater than the maximum_curvature\\\n", + " \\ specified.\\nCurvature is calculated with Central Difference with Finite\\\n", + " \\ Differencing.\\n curvature_1 = (x_2 - 2 * x_1 + x_0) / (y_2 - y_0)^2\\n \\\n", + " \\ ...\\n curvature_(n-1) = (x_n - 2 * x_(n-1) + x_(n-2)) / (y_n - y_(n-2))^2\\n\\\n", + " \\ Where: x is log10(dBdt), y is log10(timegates), and n is the number of\\\n", + " \\ timegates\\n note: there is no curvature for the first and last time gates\\n\\\n", + " \\nInterpreting curvature values:\\n Positive curvature: Indicates a decreasing\\\n", + " \\ decay rate. This suggests a transition to a more conductive layer.\\n Negative\\\n", + " \\ curvature: Indicates an increasing decay rate. This suggests a transition\\\n", + " \\ to a more resistive layer.\\n Curvature close to zero: Suggests a relatively\\\n", + " \\ constant decay rate, implying ~ homogeneous subsurface layer.\"\n", + " required:\n", + " - Disable gates by curvature max\n", + " additionalProperties: false\n", + " properties:\n", + " Disable gates by curvature max:\n", + " properties:\n", + " disable_sounding_tails:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, disable timegates after the first curvature that\n", + " exceeds the max curvature is encountered.\n", + " verbose:\n", + " default: false\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, more output about what the filter is doing\n", + " channel_and_gate:\n", + " properties:\n", + " channel:\n", + " x-reference: channel\n", + " type: integer\n", + " description: Channel to perform filter on\n", + " gate:\n", + " x-reference: gate\n", + " type: integer\n", + " description: Timegate index for filter\n", + " type: object\n", + " description: 'the channel to evaluate and the first gate to consider\n", + " for disabling.\n", + "\n", + " All timegates after the first gate and above the max_curvature will\n", + " be disabled'\n", + " x-reference: channel-gate\n", + " default:\n", + " channel: 1\n", + " gate: 7\n", + " x-python-type: builtins.dict\n", + " disable_earlier_gates:\n", + " default: 0\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: 'The number of timegates earlier to disable when the filter\n", + " finds a problem with the data\n", + "\n", + " This may deactivate gates earlier than the gate specified in channel_and_gate.\n", + "\n", + " Note: negative values are allowed and will disable the number of timegates\n", + " after a problem is found'\n", + " max_curvature:\n", + " default: 10.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Datapoints of the transient curve with curvature > max_curvature\n", + " are disabled.\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Disable gates by curvature min\n", + " description: \"Function to disable datapoints in a transient curve where the\\\n", + " \\ curvature between three datapoints\\nis less than the minimum_curvature specified.\\n\\\n", + " Curvature is calculated with Central Difference with Finite Differencing.\\n\\\n", + " \\ curvature_1 = (x_2 - 2 * x_1 + x_0) / (y_2 - y_0)^2\\n ...\\n curvature_(n-1)\\\n", + " \\ = (x_n - 2 * x_(n-1) + x_(n-2)) / (y_n - y_(n-2))^2\\n Where: x is log10(dBdt),\\\n", + " \\ y is log10(timegates), and n is the number of timegates\\n note: there\\\n", + " \\ is no curvature for the first and last time gates\\n\\nInterpreting curvature\\\n", + " \\ values:\\n Positive curvature: Indicates a decreasing decay rate. This suggests\\\n", + " \\ a transition to a more conductive layer.\\n Negative curvature: Indicates\\\n", + " \\ an increasing decay rate. This suggests a transition to a more resistive\\\n", + " \\ layer.\\n Curvature close to zero: Suggests a relatively constant decay\\\n", + " \\ rate, implying ~ homogeneous subsurface layer.\"\n", + " required:\n", + " - Disable gates by curvature min\n", + " additionalProperties: false\n", + " properties:\n", + " Disable gates by curvature min:\n", + " properties:\n", + " min_curvature:\n", + " default: -10.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Datapoints of the transient curve with curvature < min_curvature\n", + " are disabled.\n", + " verbose:\n", + " default: false\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, more output about what the filter is doing\n", + " disable_sounding_tails:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, disable timegates after the first curvature that\n", + " is less than the min curvature is encountered.\n", + " channel_and_gate:\n", + " properties:\n", + " channel:\n", + " x-reference: channel\n", + " type: integer\n", + " description: Channel to perform filter on\n", + " gate:\n", + " x-reference: gate\n", + " type: integer\n", + " description: Timegate index for filter\n", + " type: object\n", + " description: 'the channel to evaluate and the first gate to consider\n", + " for disabling.\n", + "\n", + " All timegates after the specified timegate and below the min_curvature\n", + " will be disabled'\n", + " x-reference: channel-gate\n", + " default:\n", + " channel: 1\n", + " gate: 7\n", + " x-python-type: builtins.dict\n", + " disable_earlier_gates:\n", + " default: 0\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: 'The number of timegates earlier to disable when the filter\n", + " finds a problem with the data.\n", + "\n", + " This may deactivate gates earlier than the gate specified in channel_and_gate.\n", + "\n", + " Note: negative values are allowed and will disable the number of timegates\n", + " after a problem is found'\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Disable gates by geometry\n", + " description: Function to disable all data within a safety distance from a geometric\n", + " feature defined by a shape file\n", + " required:\n", + " - Disable gates by geometry\n", + " additionalProperties: false\n", + " properties:\n", + " Disable gates by geometry:\n", + " properties:\n", + " distance_dict:\n", + " type: object\n", + " default:\n", + " Gate_Ch01:\n", + " first_gate: 30\n", + " last_gate: 75\n", + " Gate_Ch02:\n", + " first_gate: 50\n", + " last_gate: 150\n", + " x-python-type: builtins.dict\n", + " properties:\n", + " Gate_Ch01:\n", + " properties:\n", + " first_gate:\n", + " type: number\n", + " last_gate:\n", + " type: number\n", + " Gate_Ch02:\n", + " properties:\n", + " first_gate:\n", + " type: number\n", + " last_gate:\n", + " type: number\n", + " description: 'All datapoints with a distance to shape smaller than safety\n", + " distance will be disabled.\n", + "\n", + " You can define a trapeze-like disabling window by defining the distance\n", + " for the first and last gate of the moment.'\n", + " shapefile:\n", + " x-url-media-type: application/zipped-shapefile\n", + " type: string\n", + " format: url\n", + " description: 'DESCRIPTION. example: ''/path/to/my/shape/file.shp''.'\n", + " default: /path/to/my/shape/file.shp\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Disable gates by geometry and misfit\n", + " description: Function to disable data based on proximity to known infrastructure\n", + " (described by .shp files) and high inversion misfits\n", + " required:\n", + " - Disable gates by geometry and misfit\n", + " additionalProperties: false\n", + " properties:\n", + " Disable gates by geometry and misfit:\n", + " properties:\n", + " shapefile:\n", + " x-url-media-type: application/zipped-shapefile\n", + " type: string\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " format: url\n", + " description: 'Example: /your/file/path/to/Pipelines.shp'\n", + " maxRMS:\n", + " default: 5.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: all data with RMS > maxRMS will be disabled\n", + " inversion:\n", + " type: object\n", + " x-python-type: builtins.dict\n", + " properties:\n", + " model:\n", + " type: string\n", + " format: url\n", + " x-url-media-type: application/x-geophysics-xyz-model\n", + " fwd:\n", + " type: string\n", + " format: url\n", + " x-url-media-type: application/x-geophysics-xyz-data\n", + " measured:\n", + " type: string\n", + " format: url\n", + " x-url-media-type: application/x-geophysics-xyz-model\n", + " description: \"model:\\n the inverted model (your_prefix_inv.xyz)\\n\\\n", + " \\ Example: path/to/my/inversion/data/inversion_inv.xyz\\nfwd:\\n\\\n", + " \\ the synthetic (forward) data for the inverted model (your_prefix_inv.xyz)\\n\\\n", + " \\ Example: path/to/my/inversion/data/inversion_syn.xyz\\nmeasured:\\n\\\n", + " \\ the input data (your_prefix_dat.xyz)\\n Example: path/to/my/inversion/data/inversion_dat.xyz\"\n", + " x-reference: inversion\n", + " disable_sounding_tails:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, disables all timegates after the first gate that\n", + " is disabled\n", + " cleanup:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: if false, leave a misfit column in output\n", + " search_dist:\n", + " default: 100\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: buffer around infrastructure defined by .shp file that\n", + " will be considered\n", + " disable_earlier_gates:\n", + " default: 0\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: 'The number of timegates earlier to disable when the filter\n", + " finds a problem with the data\n", + "\n", + " This may deactivate gates earlier than the gate specified in channel_and_gate.\n", + "\n", + " Note: negative values are allowed and will disable the number of timegates\n", + " after a problem is found'\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Disable gates by negative data\n", + " description: Processing filter that disables negative data (sets 'in-use' flag\n", + " to 0 if dB/dt < 0) after the time-gate specified.\n", + " required:\n", + " - Disable gates by negative data\n", + " additionalProperties: false\n", + " properties:\n", + " Disable gates by negative data:\n", + " properties:\n", + " disable_sounding_tails:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, disable sounding tails (later timegates) after\n", + " the first negative data is detected.\n", + " channel_and_gate:\n", + " properties:\n", + " channel:\n", + " x-reference: channel\n", + " type: integer\n", + " description: Channel to perform filter on\n", + " gate:\n", + " x-reference: gate\n", + " type: integer\n", + " description: Timegate index for filter\n", + " type: object\n", + " description: 'Which channel and first timegate to consider when looking\n", + " for negative data\n", + "\n", + " note: All timegates will be considered after the timegate specified'\n", + " x-reference: channel-gate\n", + " default:\n", + " channel: 1\n", + " gate: 7\n", + " x-python-type: builtins.dict\n", + " disable_earlier_gates:\n", + " default: 0\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: 'The number of timegates earlier to disable when the filter\n", + " finds a problem with the data\n", + "\n", + " This may deactivate gates earlier than the gate specified in channel_and_gate.\n", + "\n", + " Note: negative values are allowed and will disable the number of timegates\n", + " after a problem is found'\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Disable gates by noise floor\n", + " description: \"This filter will disable Rx-only normalized data that falls below\\\n", + " \\ an assumed noise floor defined by\\n 't^(noise_exponent)' with an intercept\\\n", + " \\ at 'noise_level_1ms', where t is time.\\n Generally, the accepted slope,\\\n", + " \\ or noise_exponent, for the noise floor is -(1/2).\"\n", + " required:\n", + " - Disable gates by noise floor\n", + " additionalProperties: false\n", + " properties:\n", + " Disable gates by noise floor:\n", + " properties:\n", + " noise_level_1ms:\n", + " default: 1.0e-08\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Ambient noise level for measured data (not normalized by\n", + " the TX dipole) at 1e-3 s, in V/(m^2)\n", + " disable_sounding_tails:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: 'If True, disables the sounding tails (later timegates)\n", + " after the first timegate''s amplitude is less than the\n", + "\n", + " noise floor is encountered.'\n", + " noise_exponent:\n", + " default: -0.5\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: 'Exponent describing the decay of the ambient noise as\n", + " a function of gate-time. '\n", + " channel_and_gate:\n", + " properties:\n", + " channel:\n", + " x-reference: channel\n", + " type: integer\n", + " description: Channel to perform filter on\n", + " gate:\n", + " x-reference: gate\n", + " type: integer\n", + " description: Timegate index for filter\n", + " type: object\n", + " description: 'the channel to evaluate and the first gate to consider\n", + " for disabling.\n", + "\n", + " All timegates after the specified timegate and below the noise floor\n", + " will be disabled'\n", + " x-reference: channel-gate\n", + " default:\n", + " channel: 1\n", + " gate: 7\n", + " x-python-type: builtins.dict\n", + " disable_earlier_gates:\n", + " default: 0\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: 'The number of timegates earlier to disable when the filter\n", + " finds a problem with the data\n", + "\n", + " This may deactivate gates earlier than the gate specified in channel_and_gate.\n", + "\n", + " Note: negative values are allowed and will disable the number of timegates\n", + " after a problem is found'\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Disable gates by slope max\n", + " description: \"Function to disable datapoints in a transient curve where the\\\n", + " \\ slope between two datapoints\\nis greater than (shallower than) the maximum_slope\\\n", + " \\ specified.\\nSlope is d(log10(dBdt))/d(log10(t)), which is equivalent to\\\n", + " \\ t^(slope).\\nFor reference, the slope of a halfsapce is t^(-5/2) and the\\\n", + " \\ accepted slope of background noise is t^(-1/2).\\nInterpreting slope values:\\n\\\n", + " \\ Steeper Slope: Indicates a higher resistivity. This could suggest a more\\\n", + " \\ resistive layer or material\\n Shallower Slope: Suggests a higher conductivity.\\\n", + " \\ This could suggest a more conductive layer or material.\"\n", + " required:\n", + " - Disable gates by slope max\n", + " additionalProperties: false\n", + " properties:\n", + " Disable gates by slope max:\n", + " properties:\n", + " max_slope:\n", + " default: 0.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Datapoints of the transient curve with slope > max_slope\n", + " are disabled.\n", + " disable_sounding_tails:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, disable timegates after the first slope that exceeds\n", + " the max slope is encountered.\n", + " verbose:\n", + " default: false\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, more output about what the filter is doing\n", + " channel_and_gate:\n", + " properties:\n", + " channel:\n", + " x-reference: channel\n", + " type: integer\n", + " description: Channel to perform filter on\n", + " gate:\n", + " x-reference: gate\n", + " type: integer\n", + " description: Timegate index for filter\n", + " type: object\n", + " description: 'the channel to evaluate and the first gate to consider\n", + " for disabling.\n", + "\n", + " All timegates after the first gate and above the max_slope will be\n", + " disabled'\n", + " x-reference: channel-gate\n", + " default:\n", + " channel: 1\n", + " gate: 7\n", + " x-python-type: builtins.dict\n", + " disable_earlier_gates:\n", + " default: 0\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: 'The number of timegates earlier to disable when the filter\n", + " finds a problem with the data\n", + "\n", + " This may deactivate gates earlier than the gate specified in channel_and_gate.\n", + "\n", + " Note: negative values are allowed and will disable the number of timegates\n", + " after a problem is found'\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Disable gates by slope min\n", + " description: \"Function to disable datapoints in a transient curve where the\\\n", + " \\ slope between two datapoints\\nis less than (steeper than) the minimum_slope\\\n", + " \\ specified.\\nSlope is d(log10(dBdt))/d(log10(t)), which is equivalent to\\\n", + " \\ (t^(slope)).\\nFor reference, the slope of a halfsapce is t^(-5/2) and the\\\n", + " \\ accepted slope of background noise is t^(-1/2).\\nInterpreting slope values:\\n\\\n", + " \\ Steeper Slope: Indicates a higher resistivity. This could suggest a more\\\n", + " \\ resistive layer or material\\n Shallower Slope: Suggests a higher conductivity.\\\n", + " \\ This could suggest a more conductive layer or material.\"\n", + " required:\n", + " - Disable gates by slope min\n", + " additionalProperties: false\n", + " properties:\n", + " Disable gates by slope min:\n", + " properties:\n", + " disable_sounding_tails:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, disable timegates after the first slope that is\n", + " less than the min slope is encountered.\n", + " verbose:\n", + " default: false\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, more output about what the filter is doing\n", + " channel_and_gate:\n", + " properties:\n", + " channel:\n", + " x-reference: channel\n", + " type: integer\n", + " description: Channel to perform filter on\n", + " gate:\n", + " x-reference: gate\n", + " type: integer\n", + " description: Timegate index for filter\n", + " type: object\n", + " description: 'the channel to evaluate and the first gate to consider\n", + " for disabling.\n", + "\n", + " All timegates after the specified timegate and below the min_slope\n", + " will be disabled'\n", + " x-reference: channel-gate\n", + " default:\n", + " channel: 1\n", + " gate: 7\n", + " x-python-type: builtins.dict\n", + " min_slope:\n", + " default: -5.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Datapoints of the transient curve with slope < min_slope\n", + " are disabled.\n", + " disable_earlier_gates:\n", + " default: 0\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: 'The number of timegates earlier to disable when the filter\n", + " finds a problem with the data.\n", + "\n", + " This may deactivate gates earlier than the gate specified in channel_and_gate.\n", + "\n", + " Note: negative values are allowed and will disable the number of timegates\n", + " after a problem is found'\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Disable soundings by number of active gates\n", + " description: Disable the entire sounding if the sounding has fewer than min_number_of_gates\n", + " in it.\n", + " required:\n", + " - Disable soundings by number of active gates\n", + " additionalProperties: false\n", + " properties:\n", + " Disable soundings by number of active gates:\n", + " properties:\n", + " channel:\n", + " type: integer\n", + " description: Channel to perform filter on\n", + " x-reference: channel\n", + " default: 1\n", + " x-python-type: builtins.int\n", + " min_number_of_gates:\n", + " default: 4\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Soundings with less than min_number_of_gates datapoints\n", + " will be disabled entirely\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Disable soundings by tilt and altitude\n", + " description: This filter disables soundings where the roll, pitch, or altitude\n", + " exceed the input values.\n", + " required:\n", + " - Disable soundings by tilt and altitude\n", + " additionalProperties: false\n", + " properties:\n", + " Disable soundings by tilt and altitude:\n", + " properties:\n", + " max_roll:\n", + " default: 10.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Maximum Tx roll angle deviation from 0, in degrees.\n", + " max_pitch:\n", + " default: 10.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Maximum Tx pitch angle deviation from 0, in degrees.\n", + " max_alt:\n", + " default: 110.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Maximum Tx altitude, in meters above terrain surface\n", + " verbose:\n", + " default: false\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, more output about what the filter is doing\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Enable/Disable gates by index\n", + " description: 'Function to enable or disable a timegate from the data.\n", + "\n", + " Note: This will overwrite any previous edits.'\n", + " required:\n", + " - Enable/Disable gates by index\n", + " additionalProperties: false\n", + " properties:\n", + " Enable/Disable gates by index:\n", + " properties:\n", + " channel_and_gate:\n", + " properties:\n", + " channel:\n", + " x-reference: channel\n", + " type: integer\n", + " description: Channel to perform filter on\n", + " gate:\n", + " x-reference: gate\n", + " type: integer\n", + " description: Timegate index for filter\n", + " type: object\n", + " description: Dictionary defining which channel and gate to enable or\n", + " disable\n", + " x-reference: channel-gate\n", + " default:\n", + " channel: 1\n", + " gate: 0\n", + " x-python-type: builtins.dict\n", + " action:\n", + " type: string\n", + " enum:\n", + " - enable\n", + " - disable\n", + " default: disable\n", + " x-python-type: builtins.str\n", + " description: Key to denote whether to 'enable' or 'disable' the timegate\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Moving average filter\n", + " description: Moving average filter, averaging Gate values from neighboring soundings\n", + " required:\n", + " - Moving average filter\n", + " additionalProperties: false\n", + " properties:\n", + " Moving average filter:\n", + " properties:\n", + " err_calc:\n", + " type: string\n", + " enum:\n", + " - rms\n", + " - avg\n", + " default: rms\n", + " x-python-type: builtins.str\n", + " description: \"switch for how to compute the STD's inside the averaging\\\n", + " \\ window. Allowed options are:\\n - 'rms' (default) root-mean-square\\\n", + " \\ sum of the STD's inside the averaging window\\n - 'avg' simple\\\n", + " \\ average of the STD's inside the averaging window\"\n", + " verbose:\n", + " default: false\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If True, more output about what the filter is doing\n", + " filter_dict:\n", + " type: object\n", + " default:\n", + " Gate_Ch01:\n", + " first_gate: 3\n", + " last_gate: 5\n", + " Gate_Ch02:\n", + " first_gate: 5\n", + " last_gate: 9\n", + " x-python-type: builtins.dict\n", + " properties:\n", + " Gate_Ch01:\n", + " properties:\n", + " first_gate:\n", + " type: integer\n", + " last_gate:\n", + " type: integer\n", + " Gate_Ch02:\n", + " properties:\n", + " first_gate:\n", + " type: integer\n", + " last_gate:\n", + " type: integer\n", + " description: \"Dictionary describing the filter widths for the first\\\n", + " \\ and the last gate \\nof each moment/channel . The default is {'Gate_Ch01':[3,\\\n", + " \\ 5], 'Gate_Ch02':[5, 9]}.\"\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Rename Column\n", + " description: \"Rename a column in the dataset (data.flightlines).\\n These\\\n", + " \\ are generally attributes in the dataset that are a single value for the\\\n", + " \\ sounding, like:\\n 'tx_altitude', 'utm_x', 'utm_y', etc.\\n Useful\\\n", + " \\ to work around data import and source issues.\\n Warning: This will overwrite\\\n", + " \\ data if the new column exists\"\n", + " required:\n", + " - Rename Column\n", + " additionalProperties: false\n", + " properties:\n", + " Rename Column:\n", + " properties:\n", + " new:\n", + " type: string\n", + " x-python-type: builtins.str\n", + " description: The new name of the column\n", + " orig:\n", + " x-reference: flightline-column-name\n", + " x-python-type: builtins.str\n", + " description: The column name to rename\n", + " type: string\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Rename Data\n", + " description: \"Rename a group of data in the dataset (data.layer_data[]).\\n\\\n", + " \\ These are generally the per-timegate or per-layer dataframes\\n \\\n", + " \\ \\\"Gate_Ch01\\\", \\\"InUse_Ch01\\\", 'STD_Ch01', 'relErr_Ch01'\\n Useful to\\\n", + " \\ work around data import and source issues.\\n Warning: This will overwrite\\\n", + " \\ data if the new group exists\"\n", + " required:\n", + " - Rename Data\n", + " additionalProperties: false\n", + " properties:\n", + " Rename Data:\n", + " properties:\n", + " new:\n", + " type: string\n", + " x-python-type: builtins.str\n", + " description: The new name for the group of data\n", + " orig:\n", + " x-reference: layer-data-name\n", + " x-python-type: builtins.str\n", + " description: The data group to rename\n", + " type: string\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: 'STD error: Add fractional error'\n", + " description: \"Function to add fractional std error to all timegates.\\n Ex:\\\n", + " \\ error_fraction = 0.02 = + 2%. Adds error to the gate range specified\\n \\\n", + " \\ Ex: error_fraction = -0.01 = - 1%; Subtracts error to the gate range specified\"\n", + " required:\n", + " - 'STD error: Add fractional error'\n", + " additionalProperties: false\n", + " properties:\n", + " 'STD error: Add fractional error':\n", + " properties:\n", + " error_fraction:\n", + " default: 0.01\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Fraction of data to use as std error\n", + " channel_and_gates:\n", + " properties:\n", + " channel:\n", + " x-reference: channel\n", + " type: integer\n", + " description: Channel to perform filter on\n", + " start_gate:\n", + " x-reference: gate\n", + " type: integer\n", + " description: Starting timegate index for filter\n", + " end_gate:\n", + " x-reference: gate\n", + " type: integer\n", + " description: Ending timegate index for filter\n", + " type: object\n", + " description: The channel and gate range to add STD error to the data.\n", + " x-reference: channel-gate-range\n", + " default:\n", + " channel: 1\n", + " start_gate: 0\n", + " end_gate: 0\n", + " x-python-type: builtins.dict\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: 'STD error: Replace from GEX'\n", + " description: \"Function to Replace STD error estimates with the estimates from\\\n", + " \\ the gex file.\\n Note: often the errors reported alongside the data are\\\n", + " \\ measured from the raw transient\\n stack and are individually reported\\\n", + " \\ for each sounding's timegates. Consult the data\\n report for more information\\\n", + " \\ on how the STD data are created.\\n Using this function will overwrite\\\n", + " \\ the STD estimates with a single value that comes from the gex file.\"\n", + " required:\n", + " - 'STD error: Replace from GEX'\n", + " additionalProperties: false\n", + " properties:\n", + " 'STD error: Replace from GEX':\n", + " properties:\n", + " channel:\n", + " type: integer\n", + " description: Channel to perform filter on\n", + " x-reference: channel\n", + " default: 1\n", + " x-python-type: builtins.int\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Save intermediate results\n", + " description: Save an intermediate state of your new processing.\n", + " required:\n", + " - Save intermediate results\n", + " additionalProperties: false\n", + " properties:\n", + " Save intermediate results:\n", + " properties:\n", + " name:\n", + " type: string\n", + " x-python-type: builtins.str\n", + " description: Give the intermediate result a dataset name. This will\n", + " appear in the plot editor under Dataset.\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Select flight-types\n", + " description: \"Function to reduce the dataset to the given list of flight-types.\\\n", + " \\ By default, all flightlines are considered\\n 'Production' until otherwise\\\n", + " \\ set.\\n Hint: The processing filter \\\"Classify flightlines\\\" allows you\\\n", + " \\ to set the flight-types\"\n", + " required:\n", + " - Select flight-types\n", + " additionalProperties: false\n", + " properties:\n", + " Select flight-types:\n", + " properties:\n", + " flight_types:\n", + " items:\n", + " anyOf:\n", + " - enum:\n", + " - Production\n", + " - Tie\n", + " - Test\n", + " - High-altitude\n", + " type: string\n", + " x-python-type: builtins.str\n", + " - type: string\n", + " x-python-type: builtins.str\n", + " x-python-type: types.UnionType\n", + " type: string\n", + " x-reference: flight_type\n", + " type: array\n", + " x-python-type: builtins.list\n", + " description: list of line numbers you like to keep in the dataset.\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Select flightlines\n", + " description: Function to select flightlines from the dataset to process.\n", + " required:\n", + " - Select flightlines\n", + " additionalProperties: false\n", + " properties:\n", + " Select flightlines:\n", + " properties:\n", + " lines:\n", + " items:\n", + " type: string\n", + " x-reference: flightline\n", + " type: array\n", + " x-python-type: builtins.list\n", + " description: list of flightlines you would like to keep.\n", + " type: object\n", + " additionalProperties: false\n", + " - type: object\n", + " title: Use manual edits\n", + " description: Apply a manual culling to your dataset.\n", + " required:\n", + " - Use manual edits\n", + " additionalProperties: false\n", + " properties:\n", + " Use manual edits:\n", + " properties:\n", + " diff:\n", + " type: object\n", + " x-python-type: typing.Any\n", + " description: Manual culling to apply. To create manual culling, save\n", + " culling in plot workspace first and it will appear here.\n", + " x-reference: manual-edit\n", + " anyOf:\n", + " - x-url-media-type: application/x-geophysics-xyz-model\n", + " - type: object\n", + " additionalProperties: false\n", + " required:\n", + " - url\n", + " properties:\n", + " url:\n", + " x-url-media-type: application/x-geophysics-xyz-model\n", + " title:\n", + " type: string\n", + " id:\n", + " type: integer\n", + " type: object\n", + " additionalProperties: false\n", + " description: emeraldprocessing.pipeline_step\n", + "Inversion:\n", + " title: simpeg.static_instrument\n", + " anyOf:\n", + " - type: object\n", + " title: DualMomentTEMXYZSystem\n", + " description: \"Dual moment system, suitable for describing e.g. the SkyTEM\\ninstruments.\\\n", + " \\ This class can not be directly instantiated, but\\ninstead, instantiable subclasses\\\n", + " \\ can created using the class\\nmethod\\n\\n```\\nMySurveyInstrument = DualMomentTEMXYZSystem.load_gex(\\n\\\n", + " \\ libaarhusxyz.GEX(\\\"instrument.gex\\\"))\\n```\\n\\nwhich reads a gex file containing\\\n", + " \\ among other things the waveform\\ndescription of the instrument.\\n\\nSee the\\\n", + " \\ help for `XYZSystem` for more information on basic usage.\"\n", + " required:\n", + " - DualMomentTEMXYZSystem\n", + " additionalProperties: false\n", + " properties:\n", + " DualMomentTEMXYZSystem:\n", + " properties:\n", + " directives:\n", + " type: object\n", + " title: directives\n", + " description: directives\n", + " properties:\n", + " beta:\n", + " type: object\n", + " title: beta\n", + " description: beta\n", + " properties:\n", + " beta0_ratio:\n", + " default: 10.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Start ratio for the beta (regularization) schedule\n", + " estimator\n", + " title: beta0_ratio\n", + " seed:\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Random seed for beta (regularization) schedule estimator\n", + " title: seed\n", + " cooling_rate:\n", + " default: 1\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Initial cooling rate for the beta (regularization)\n", + " schedule\n", + " title: cooling_rate\n", + " cooling_factor:\n", + " default: 2\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Cooling factor for the beta (regularization) schedule\n", + " title: cooling_factor\n", + " x-python-type: null\n", + " irls:\n", + " type: object\n", + " title: irls\n", + " description: irls\n", + " properties:\n", + " enable:\n", + " default: false\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: IRLS is used to generate a sparse model in addition\n", + " to and l2 model\n", + " title: enable\n", + " f_min_change:\n", + " default: 0.001\n", + " type: number\n", + " x-python-type: builtins.float\n", + " title: f_min_change\n", + " max_iterations:\n", + " default: 30\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Maximum number of iterations (after l2 model has\n", + " converged)\n", + " title: max_iterations\n", + " fix_Jmatrix:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " title: fix_Jmatrix\n", + " minGNiter:\n", + " default: 1\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " title: minGNiter\n", + " coolingRate:\n", + " default: 1\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " title: coolingRate\n", + " x-python-type: null\n", + " x-python-type: null\n", + " regularization:\n", + " type: object\n", + " title: regularization\n", + " description: regularization\n", + " properties:\n", + " alpha_s:\n", + " default: 1.0e-10\n", + " type: number\n", + " x-python-type: builtins.float\n", + " title: alpha_s\n", + " alpha_r:\n", + " default: 1.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " title: alpha_r\n", + " alpha_z:\n", + " default: 1.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " title: alpha_z\n", + " x-python-type: null\n", + " startmodel:\n", + " type: object\n", + " title: startmodel\n", + " description: startmodel\n", + " properties:\n", + " thicknesses_minimum_dz:\n", + " default: 1\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Thickness of thinnest layer if using 'logspaced' or 'geometric'\n", + " discretization\n", + " title: thicknesses_minimum_dz\n", + " top_depth_last_layer:\n", + " default: 400\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Depth to the top of the last layer if using logspaced\n", + " discretization\n", + " title: top_depth_last_layer\n", + " thicknesses_geomtric_factor:\n", + " default: 1.15309\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Ratio of one layer to the next if using geometric discretization\n", + " title: thicknesses_geomtric_factor\n", + " thicknesses_type:\n", + " type: string\n", + " enum:\n", + " - logspaced\n", + " - geometric\n", + " - time\n", + " default: logspaced\n", + " x-python-type: builtins.str\n", + " description: Type of model discretization\n", + " title: thicknesses_type\n", + " n_layer:\n", + " default: 30\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Number of layers in model discretization\n", + " title: n_layer\n", + " res:\n", + " default: 100.0\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Initial resistivity (ohmm)\n", + " title: res\n", + " x-python-type: null\n", + " uncertainties:\n", + " type: object\n", + " title: uncertainties\n", + " description: uncertainties\n", + " properties:\n", + " noise_level_1ms:\n", + " default: 3.0e-08\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: V/m^2\n", + " title: noise_level_1ms\n", + " std_data:\n", + " default: 0.03\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: Noise as a factor of data\n", + " title: std_data\n", + " noise_exponent:\n", + " default: -0.5\n", + " type: number\n", + " x-python-type: builtins.float\n", + " description: t^uncertainties__noise_exponent\n", + " title: noise_exponent\n", + " std_data_override:\n", + " default: false\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: If set to true, use the std_data value instead of data\n", + " std:s from stacking\n", + " title: std_data_override\n", + " x-python-type: null\n", + " gate_filter:\n", + " type: object\n", + " title: gate_filter\n", + " description: gate_filter\n", + " properties:\n", + " start_hm:\n", + " default: 12\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Lowest used gate (zero based)\n", + " title: start_hm\n", + " end_hm:\n", + " default: 26\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: First unused gate above used ones (zero based)\n", + " title: end_hm\n", + " start_lm:\n", + " default: 5\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Lowest used gate (zero based)\n", + " title: start_lm\n", + " end_lm:\n", + " default: 11\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: First unused gate above used ones (zero based)\n", + " title: end_lm\n", + " x-python-type: null\n", + " optimizer:\n", + " type: object\n", + " title: optimizer\n", + " description: optimizer\n", + " properties:\n", + " max_iter_cg:\n", + " default: 20\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " title: max_iter_cg\n", + " max_iter:\n", + " default: 40\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Maximum number of gauss newton iterations\n", + " title: max_iter\n", + " x-python-type: null\n", + " tx_orientation:\n", + " type: string\n", + " enum:\n", + " - x\n", + " - y\n", + " - z\n", + " default: z\n", + " x-python-type: builtins.str\n", + " description: Transmitter orientation\n", + " simulation:\n", + " type: object\n", + " title: simulation\n", + " description: simulation\n", + " properties:\n", + " n_cpu:\n", + " default: 3\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " description: Number of threads (roughly same as CPU cores) to use\n", + " title: n_cpu\n", + " solver:\n", + " type: string\n", + " enum:\n", + " - LU\n", + " - pardiso\n", + " default: LU\n", + " x-python-type: builtins.str\n", + " description: Equation solver to use. Some solvers might require hardware\n", + " support.\n", + " title: solver\n", + " parallel:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: Use multiple computation threads in parallel. Useful\n", + " to set to false in a notebook for debugging.\n", + " title: parallel\n", + " x-python-type: null\n", + " rx_orientation:\n", + " type: string\n", + " enum:\n", + " - x\n", + " - y\n", + " - z\n", + " default: z\n", + " x-python-type: builtins.str\n", + " description: Receiver orientation\n", + " validate:\n", + " default: true\n", + " type: boolean\n", + " x-python-type: builtins.bool\n", + " description: Validate input data scaling etc. prior to inversion\n", + " save_intermediate:\n", + " type: boolean\n", + " default: false\n", + " description: Save intermediate models and sythentic data for every inversion\n", + " iteration\n", + " type: object\n", + " additionalProperties: false\n", + " x-returntype:\n", + " type: object\n", + " x-python-type: SimPEG.electromagnetics.utils.static_instrument.dual.DualMomentTEMXYZSystem\n", + " description: SimPEG.electromagnetics.utils.static_instrument.dual.DualMomentTEMXYZSystem\n", + " - type: object\n", + " title: Workbench import\n", + " description: 'Import a model inverted in Aarhus Workbench. This ignored\n", + "\n", + " the input dataset completely.'\n", + " required:\n", + " - Workbench import\n", + " additionalProperties: false\n", + " properties:\n", + " Workbench import:\n", + " properties:\n", + " model_xyzfile:\n", + " type: string\n", + " format: url\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " minLength: 5\n", + " pattern: \\.xyz$\n", + " scalefactor:\n", + " default: 1.0e-12\n", + " type: number\n", + " x-python-type: builtins.float\n", + " corrected_alcfile:\n", + " type: string\n", + " format: url\n", + " pattern: \\.alc$\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " minLength: 5\n", + " corrected_xyzfile:\n", + " type: string\n", + " format: url\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " minLength: 5\n", + " pattern: \\.xyz$\n", + " projection:\n", + " format: x-epsg\n", + " type: integer\n", + " x-python-type: builtins.int\n", + " gexfile:\n", + " type: string\n", + " format: url\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " minLength: 5\n", + " pattern: \\.gex$\n", + " fwd_xyzfile:\n", + " type: string\n", + " format: url\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " minLength: 5\n", + " pattern: \\.xyz$\n", + " fwd_alcfile:\n", + " type: string\n", + " format: url\n", + " pattern: \\.alc$\n", + " x-python-type: pydantic_core._pydantic_core.Url\n", + " minLength: 5\n", + " save_intermediate:\n", + " type: boolean\n", + " default: false\n", + " description: Save intermediate models and sythentic data for every inversion\n", + " iteration\n", + " type: object\n", + " additionalProperties: false\n", + " x-returntype:\n", + " type: object\n", + " x-python-type: beryl_pipeline.inversion_workbench_import.WorkbenchImporter\n", + " description: beryl_pipeline.inversion_workbench_import.WorkbenchImporter\n", + " description: simpeg.static_instrument\n", + "\n" + ] + } + ], + "source": [ + "with poltergust_luigi_utils.caching.CachingOpenerTarget(root + \"/introspect/output.yml\").open(\"r\") as f:\n", + " print(f.read())\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1fd6d10b-0bc0-4a3f-8b10-cce60833a347", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "with poltergust_luigi_utils.caching.CachingOpenerTarget(root + \"/introspect/output.yml\").open(\"r\") as f:\n", + " introspection = yaml.safe_load(f)\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "2f1cafb1-56f7-4d98-bdf0-38e8e32def16", + "metadata": { + "scrolled": true + }, + "source": [ + "# Schema testing\n", + "\n", + "Copy the contents of the output of any of the three cells below to the schema input area of [this webpage](https://json-editor.github.io/json-editor/) and then play with the widget built and check that the pipeline is what you expect to be built." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "85a9b341-1021-4df8-98ae-0cee97dcae16", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\"type\": \"array\", \"title\": \"emeraldprocessing.pipeline_step\", \"description\": \"emeraldprocessing.pipeline_step\", \"items\": {\"title\": \"emeraldprocessing.pipeline_step\", \"anyOf\": [{\"type\": \"object\", \"title\": \"Workbench import\", \"description\": \"Import a dataset processed in Aarhus Workbench. This replaces\\nthe input dataset completely.\", \"required\": [\"Workbench import\"], \"additionalProperties\": false, \"properties\": {\"Workbench import\": {\"properties\": {\"scalefactor\": {\"default\": 1e-12, \"type\": \"number\", \"x-python-type\": \"builtins.float\"}, \"foo\": {\"x-python-type\": \"types.UnionType\", \"anyOf\": [{\"type\": \"object\", \"x-python-type\": \"builtins.dict\", \"propertyNames\": {\"type\": \"string\", \"x-python-type\": \"builtins.str\"}, \"patternProperties\": {\"type\": \"integer\", \"x-python-type\": \"builtins.int\"}}, {\"type\": \"array\", \"x-python-type\": \"builtins.list\", \"items\": {\"type\": \"string\", \"x-python-type\": \"builtins.str\"}}]}, \"projection\": {\"format\": \"x-epsg\", \"type\": \"integer\", \"x-python-type\": \"builtins.int\"}, \"xyzfile\": {\"type\": \"string\", \"format\": \"url\", \"pattern\": \"\\\\.xyz$\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\", \"minLength\": 5}, \"gexfile\": {\"type\": \"string\", \"format\": \"url\", \"pattern\": \"\\\\.gex$\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\", \"minLength\": 5}, \"alcfile\": {\"type\": \"string\", \"format\": \"url\", \"pattern\": \"\\\\.alc$\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\", \"minLength\": 5}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Classify flightlines: Selection\", \"description\": \"Function to apply classifications to the flightlines in the dataset. By default, all flightlines are considered\\n 'Production' until otherwise set.\", \"required\": [\"Classify flightlines: Selection\"], \"additionalProperties\": false, \"properties\": {\"Classify flightlines: Selection\": {\"properties\": {\"lines\": {\"items\": {\"type\": \"string\", \"x-reference\": \"flightline\"}, \"type\": \"array\", \"x-python-type\": \"builtins.list\", \"description\": \"List of line numbers you like to assign a flight type too.\"}, \"flight_type\": {\"x-python-type\": \"types.UnionType\", \"anyOf\": [{\"enum\": [\"Production\", \"Tie\", \"Test\", \"High-altitude\"], \"type\": \"string\", \"x-python-type\": \"builtins.str\"}, {\"type\": \"string\", \"x-python-type\": \"builtins.str\"}], \"description\": \"The type of flightline. Can be a custom key\", \"type\": \"object\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Classify high altitude flightlines: Auto\", \"description\": \"Filter to find all flightlines where the mean altitude is above the height_threshold\\nand label them as 'High-Altitude' test lines\", \"required\": [\"Classify high altitude flightlines: Auto\"], \"additionalProperties\": false, \"properties\": {\"Classify high altitude flightlines: Auto\": {\"properties\": {\"height_threshold\": {\"default\": 500.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"The height threshold, in meters above land surface, for defining a high altitude flightline.\\nThe mean flight height for each flightline will be compared to this value.\"}, \"verbose\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, more output about what the filter is doing\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Correct altitude and topo\", \"description\": \"Correct altitude and topography\", \"required\": [\"Correct altitude and topo\"], \"additionalProperties\": false, \"properties\": {\"Correct altitude and topo\": {\"properties\": {\"terrain_model\": {\"x-url-media-type\": \"image/geotiff\", \"type\": \"string\", \"format\": \"url\", \"description\": \"Path to digital-terrain-model (DTM) GeoTIFF, in meters-above-mean-sea-level (m.a.m.s.l.)\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\", \"minLength\": 1}, \"verbose\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, more output about what the filter is doing\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Correct data and tilt for 1D\", \"description\": \"Function to correct the data amplitudes according to the horizontal source dipole moment.\\n Scaling by (cos(TxRoll) * cos(TxPitch))^2\", \"required\": [\"Correct data and tilt for 1D\"], \"additionalProperties\": false, \"properties\": {\"Correct data and tilt for 1D\": {\"properties\": {\"verbose\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, more output about what the filter is doing\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Disable gates by STD values\", \"description\": \"Disable data where the STD of the datum is larger than the specified std_threshold.\", \"required\": [\"Disable gates by STD values\"], \"additionalProperties\": false, \"properties\": {\"Disable gates by STD values\": {\"properties\": {\"disable_sounding_tails\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, disables the tails (later timegates) after the first disabled timegate\"}, \"std_threshold\": {\"default\": 0.15, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Datapoints with STD's higher than std threshold will be disabled\"}, \"channel_and_gate\": {\"properties\": {\"channel\": {\"x-reference\": \"channel\", \"type\": \"integer\", \"description\": \"Channel to perform filter on\"}, \"gate\": {\"x-reference\": \"gate\", \"type\": \"integer\", \"description\": \"Timegate index for filter\"}}, \"type\": \"object\", \"description\": \"The channel and first timegate that you would like evaluated.\\n Note: All timegates after the first gate will be considered.\", \"x-reference\": \"channel-gate\", \"default\": {\"channel\": 1, \"gate\": 7}, \"x-python-type\": \"builtins.dict\"}, \"disable_earlier_gates\": {\"default\": 0, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"The number of timegates earlier to disable when the filter finds a problem with the data\\nThis may deactivate gates earlier than the gate specified in channel_and_gate.\\nNote: negative values are allowed and will disable the number of timegates after a problem is found\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Disable gates by curvature max\", \"description\": \"Function to disable datapoints in a transient curve where the curvature between three datapoints\\nis greater than the maximum_curvature specified.\\nCurvature is calculated with Central Difference with Finite Differencing.\\n curvature_1 = (x_2 - 2 * x_1 + x_0) / (y_2 - y_0)^2\\n ...\\n curvature_(n-1) = (x_n - 2 * x_(n-1) + x_(n-2)) / (y_n - y_(n-2))^2\\n Where: x is log10(dBdt), y is log10(timegates), and n is the number of timegates\\n note: there is no curvature for the first and last time gates\\n\\nInterpreting curvature values:\\n Positive curvature: Indicates a decreasing decay rate. This suggests a transition to a more conductive layer.\\n Negative curvature: Indicates an increasing decay rate. This suggests a transition to a more resistive layer.\\n Curvature close to zero: Suggests a relatively constant decay rate, implying ~ homogeneous subsurface layer.\", \"required\": [\"Disable gates by curvature max\"], \"additionalProperties\": false, \"properties\": {\"Disable gates by curvature max\": {\"properties\": {\"disable_sounding_tails\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, disable timegates after the first curvature that exceeds the max curvature is encountered.\"}, \"verbose\": {\"default\": false, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, more output about what the filter is doing\"}, \"channel_and_gate\": {\"properties\": {\"channel\": {\"x-reference\": \"channel\", \"type\": \"integer\", \"description\": \"Channel to perform filter on\"}, \"gate\": {\"x-reference\": \"gate\", \"type\": \"integer\", \"description\": \"Timegate index for filter\"}}, \"type\": \"object\", \"description\": \"the channel to evaluate and the first gate to consider for disabling.\\nAll timegates after the first gate and above the max_curvature will be disabled\", \"x-reference\": \"channel-gate\", \"default\": {\"channel\": 1, \"gate\": 7}, \"x-python-type\": \"builtins.dict\"}, \"disable_earlier_gates\": {\"default\": 0, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"The number of timegates earlier to disable when the filter finds a problem with the data\\nThis may deactivate gates earlier than the gate specified in channel_and_gate.\\nNote: negative values are allowed and will disable the number of timegates after a problem is found\"}, \"max_curvature\": {\"default\": 10.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Datapoints of the transient curve with curvature > max_curvature are disabled.\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Disable gates by curvature min\", \"description\": \"Function to disable datapoints in a transient curve where the curvature between three datapoints\\nis less than the minimum_curvature specified.\\nCurvature is calculated with Central Difference with Finite Differencing.\\n curvature_1 = (x_2 - 2 * x_1 + x_0) / (y_2 - y_0)^2\\n ...\\n curvature_(n-1) = (x_n - 2 * x_(n-1) + x_(n-2)) / (y_n - y_(n-2))^2\\n Where: x is log10(dBdt), y is log10(timegates), and n is the number of timegates\\n note: there is no curvature for the first and last time gates\\n\\nInterpreting curvature values:\\n Positive curvature: Indicates a decreasing decay rate. This suggests a transition to a more conductive layer.\\n Negative curvature: Indicates an increasing decay rate. This suggests a transition to a more resistive layer.\\n Curvature close to zero: Suggests a relatively constant decay rate, implying ~ homogeneous subsurface layer.\", \"required\": [\"Disable gates by curvature min\"], \"additionalProperties\": false, \"properties\": {\"Disable gates by curvature min\": {\"properties\": {\"min_curvature\": {\"default\": -10.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Datapoints of the transient curve with curvature < min_curvature are disabled.\"}, \"verbose\": {\"default\": false, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, more output about what the filter is doing\"}, \"disable_sounding_tails\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, disable timegates after the first curvature that is less than the min curvature is encountered.\"}, \"channel_and_gate\": {\"properties\": {\"channel\": {\"x-reference\": \"channel\", \"type\": \"integer\", \"description\": \"Channel to perform filter on\"}, \"gate\": {\"x-reference\": \"gate\", \"type\": \"integer\", \"description\": \"Timegate index for filter\"}}, \"type\": \"object\", \"description\": \"the channel to evaluate and the first gate to consider for disabling.\\nAll timegates after the specified timegate and below the min_curvature will be disabled\", \"x-reference\": \"channel-gate\", \"default\": {\"channel\": 1, \"gate\": 7}, \"x-python-type\": \"builtins.dict\"}, \"disable_earlier_gates\": {\"default\": 0, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"The number of timegates earlier to disable when the filter finds a problem with the data.\\nThis may deactivate gates earlier than the gate specified in channel_and_gate.\\nNote: negative values are allowed and will disable the number of timegates after a problem is found\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Disable gates by geometry\", \"description\": \"Function to disable all data within a safety distance from a geometric feature defined by a shape file\", \"required\": [\"Disable gates by geometry\"], \"additionalProperties\": false, \"properties\": {\"Disable gates by geometry\": {\"properties\": {\"distance_dict\": {\"type\": \"object\", \"default\": {\"Gate_Ch01\": {\"first_gate\": 30, \"last_gate\": 75}, \"Gate_Ch02\": {\"first_gate\": 50, \"last_gate\": 150}}, \"x-python-type\": \"builtins.dict\", \"properties\": {\"Gate_Ch01\": {\"properties\": {\"first_gate\": {\"type\": \"number\"}, \"last_gate\": {\"type\": \"number\"}}}, \"Gate_Ch02\": {\"properties\": {\"first_gate\": {\"type\": \"number\"}, \"last_gate\": {\"type\": \"number\"}}}}, \"description\": \"All datapoints with a distance to shape smaller than safety distance will be disabled.\\nYou can define a trapeze-like disabling window by defining the distance for the first and last gate of the moment.\"}, \"shapefile\": {\"x-url-media-type\": \"application/zipped-shapefile\", \"type\": \"string\", \"format\": \"url\", \"description\": \"DESCRIPTION. example: '/path/to/my/shape/file.shp'.\", \"default\": \"/path/to/my/shape/file.shp\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Disable gates by geometry and misfit\", \"description\": \"Function to disable data based on proximity to known infrastructure (described by .shp files) and high inversion misfits\", \"required\": [\"Disable gates by geometry and misfit\"], \"additionalProperties\": false, \"properties\": {\"Disable gates by geometry and misfit\": {\"properties\": {\"shapefile\": {\"x-url-media-type\": \"application/zipped-shapefile\", \"type\": \"string\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\", \"format\": \"url\", \"description\": \"Example: /your/file/path/to/Pipelines.shp\"}, \"maxRMS\": {\"default\": 5.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"all data with RMS > maxRMS will be disabled\"}, \"inversion\": {\"type\": \"object\", \"x-python-type\": \"builtins.dict\", \"properties\": {\"model\": {\"type\": \"string\", \"format\": \"url\", \"x-url-media-type\": \"application/x-geophysics-xyz-model\"}, \"fwd\": {\"type\": \"string\", \"format\": \"url\", \"x-url-media-type\": \"application/x-geophysics-xyz-data\"}, \"measured\": {\"type\": \"string\", \"format\": \"url\", \"x-url-media-type\": \"application/x-geophysics-xyz-model\"}}, \"description\": \"model:\\n the inverted model (your_prefix_inv.xyz)\\n Example: path/to/my/inversion/data/inversion_inv.xyz\\nfwd:\\n the synthetic (forward) data for the inverted model (your_prefix_inv.xyz)\\n Example: path/to/my/inversion/data/inversion_syn.xyz\\nmeasured:\\n the input data (your_prefix_dat.xyz)\\n Example: path/to/my/inversion/data/inversion_dat.xyz\", \"x-reference\": \"inversion\"}, \"disable_sounding_tails\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, disables all timegates after the first gate that is disabled\"}, \"cleanup\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"if false, leave a misfit column in output\"}, \"search_dist\": {\"default\": 100, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"buffer around infrastructure defined by .shp file that will be considered\"}, \"disable_earlier_gates\": {\"default\": 0, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"The number of timegates earlier to disable when the filter finds a problem with the data\\nThis may deactivate gates earlier than the gate specified in channel_and_gate.\\nNote: negative values are allowed and will disable the number of timegates after a problem is found\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Disable gates by negative data\", \"description\": \"Processing filter that disables negative data (sets 'in-use' flag to 0 if dB/dt < 0) after the time-gate specified.\", \"required\": [\"Disable gates by negative data\"], \"additionalProperties\": false, \"properties\": {\"Disable gates by negative data\": {\"properties\": {\"disable_sounding_tails\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, disable sounding tails (later timegates) after the first negative data is detected.\"}, \"channel_and_gate\": {\"properties\": {\"channel\": {\"x-reference\": \"channel\", \"type\": \"integer\", \"description\": \"Channel to perform filter on\"}, \"gate\": {\"x-reference\": \"gate\", \"type\": \"integer\", \"description\": \"Timegate index for filter\"}}, \"type\": \"object\", \"description\": \"Which channel and first timegate to consider when looking for negative data\\nnote: All timegates will be considered after the timegate specified\", \"x-reference\": \"channel-gate\", \"default\": {\"channel\": 1, \"gate\": 7}, \"x-python-type\": \"builtins.dict\"}, \"disable_earlier_gates\": {\"default\": 0, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"The number of timegates earlier to disable when the filter finds a problem with the data\\nThis may deactivate gates earlier than the gate specified in channel_and_gate.\\nNote: negative values are allowed and will disable the number of timegates after a problem is found\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Disable gates by noise floor\", \"description\": \"This filter will disable Rx-only normalized data that falls below an assumed noise floor defined by\\n 't^(noise_exponent)' with an intercept at 'noise_level_1ms', where t is time.\\n Generally, the accepted slope, or noise_exponent, for the noise floor is -(1/2).\", \"required\": [\"Disable gates by noise floor\"], \"additionalProperties\": false, \"properties\": {\"Disable gates by noise floor\": {\"properties\": {\"noise_level_1ms\": {\"default\": 1e-08, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Ambient noise level for measured data (not normalized by the TX dipole) at 1e-3 s, in V/(m^2)\"}, \"disable_sounding_tails\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, disables the sounding tails (later timegates) after the first timegate's amplitude is less than the\\nnoise floor is encountered.\"}, \"noise_exponent\": {\"default\": -0.5, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Exponent describing the decay of the ambient noise as a function of gate-time. \"}, \"channel_and_gate\": {\"properties\": {\"channel\": {\"x-reference\": \"channel\", \"type\": \"integer\", \"description\": \"Channel to perform filter on\"}, \"gate\": {\"x-reference\": \"gate\", \"type\": \"integer\", \"description\": \"Timegate index for filter\"}}, \"type\": \"object\", \"description\": \"the channel to evaluate and the first gate to consider for disabling.\\nAll timegates after the specified timegate and below the noise floor will be disabled\", \"x-reference\": \"channel-gate\", \"default\": {\"channel\": 1, \"gate\": 7}, \"x-python-type\": \"builtins.dict\"}, \"disable_earlier_gates\": {\"default\": 0, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"The number of timegates earlier to disable when the filter finds a problem with the data\\nThis may deactivate gates earlier than the gate specified in channel_and_gate.\\nNote: negative values are allowed and will disable the number of timegates after a problem is found\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Disable gates by slope max\", \"description\": \"Function to disable datapoints in a transient curve where the slope between two datapoints\\nis greater than (shallower than) the maximum_slope specified.\\nSlope is d(log10(dBdt))/d(log10(t)), which is equivalent to t^(slope).\\nFor reference, the slope of a halfsapce is t^(-5/2) and the accepted slope of background noise is t^(-1/2).\\nInterpreting slope values:\\n Steeper Slope: Indicates a higher resistivity. This could suggest a more resistive layer or material\\n Shallower Slope: Suggests a higher conductivity. This could suggest a more conductive layer or material.\", \"required\": [\"Disable gates by slope max\"], \"additionalProperties\": false, \"properties\": {\"Disable gates by slope max\": {\"properties\": {\"max_slope\": {\"default\": 0.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Datapoints of the transient curve with slope > max_slope are disabled.\"}, \"disable_sounding_tails\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, disable timegates after the first slope that exceeds the max slope is encountered.\"}, \"verbose\": {\"default\": false, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, more output about what the filter is doing\"}, \"channel_and_gate\": {\"properties\": {\"channel\": {\"x-reference\": \"channel\", \"type\": \"integer\", \"description\": \"Channel to perform filter on\"}, \"gate\": {\"x-reference\": \"gate\", \"type\": \"integer\", \"description\": \"Timegate index for filter\"}}, \"type\": \"object\", \"description\": \"the channel to evaluate and the first gate to consider for disabling.\\nAll timegates after the first gate and above the max_slope will be disabled\", \"x-reference\": \"channel-gate\", \"default\": {\"channel\": 1, \"gate\": 7}, \"x-python-type\": \"builtins.dict\"}, \"disable_earlier_gates\": {\"default\": 0, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"The number of timegates earlier to disable when the filter finds a problem with the data\\nThis may deactivate gates earlier than the gate specified in channel_and_gate.\\nNote: negative values are allowed and will disable the number of timegates after a problem is found\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Disable gates by slope min\", \"description\": \"Function to disable datapoints in a transient curve where the slope between two datapoints\\nis less than (steeper than) the minimum_slope specified.\\nSlope is d(log10(dBdt))/d(log10(t)), which is equivalent to (t^(slope)).\\nFor reference, the slope of a halfsapce is t^(-5/2) and the accepted slope of background noise is t^(-1/2).\\nInterpreting slope values:\\n Steeper Slope: Indicates a higher resistivity. This could suggest a more resistive layer or material\\n Shallower Slope: Suggests a higher conductivity. This could suggest a more conductive layer or material.\", \"required\": [\"Disable gates by slope min\"], \"additionalProperties\": false, \"properties\": {\"Disable gates by slope min\": {\"properties\": {\"disable_sounding_tails\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, disable timegates after the first slope that is less than the min slope is encountered.\"}, \"verbose\": {\"default\": false, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, more output about what the filter is doing\"}, \"channel_and_gate\": {\"properties\": {\"channel\": {\"x-reference\": \"channel\", \"type\": \"integer\", \"description\": \"Channel to perform filter on\"}, \"gate\": {\"x-reference\": \"gate\", \"type\": \"integer\", \"description\": \"Timegate index for filter\"}}, \"type\": \"object\", \"description\": \"the channel to evaluate and the first gate to consider for disabling.\\nAll timegates after the specified timegate and below the min_slope will be disabled\", \"x-reference\": \"channel-gate\", \"default\": {\"channel\": 1, \"gate\": 7}, \"x-python-type\": \"builtins.dict\"}, \"min_slope\": {\"default\": -5.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Datapoints of the transient curve with slope < min_slope are disabled.\"}, \"disable_earlier_gates\": {\"default\": 0, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"The number of timegates earlier to disable when the filter finds a problem with the data.\\nThis may deactivate gates earlier than the gate specified in channel_and_gate.\\nNote: negative values are allowed and will disable the number of timegates after a problem is found\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Disable soundings by number of active gates\", \"description\": \"Disable the entire sounding if the sounding has fewer than min_number_of_gates in it.\", \"required\": [\"Disable soundings by number of active gates\"], \"additionalProperties\": false, \"properties\": {\"Disable soundings by number of active gates\": {\"properties\": {\"channel\": {\"type\": \"integer\", \"description\": \"Channel to perform filter on\", \"x-reference\": \"channel\", \"default\": 1, \"x-python-type\": \"builtins.int\"}, \"min_number_of_gates\": {\"default\": 4, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Soundings with less than min_number_of_gates datapoints will be disabled entirely\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Disable soundings by tilt and altitude\", \"description\": \"This filter disables soundings where the roll, pitch, or altitude exceed the input values.\", \"required\": [\"Disable soundings by tilt and altitude\"], \"additionalProperties\": false, \"properties\": {\"Disable soundings by tilt and altitude\": {\"properties\": {\"max_roll\": {\"default\": 10.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Maximum Tx roll angle deviation from 0, in degrees.\"}, \"max_pitch\": {\"default\": 10.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Maximum Tx pitch angle deviation from 0, in degrees.\"}, \"max_alt\": {\"default\": 110.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Maximum Tx altitude, in meters above terrain surface\"}, \"verbose\": {\"default\": false, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, more output about what the filter is doing\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Enable/Disable gates by index\", \"description\": \"Function to enable or disable a timegate from the data.\\nNote: This will overwrite any previous edits.\", \"required\": [\"Enable/Disable gates by index\"], \"additionalProperties\": false, \"properties\": {\"Enable/Disable gates by index\": {\"properties\": {\"channel_and_gate\": {\"properties\": {\"channel\": {\"x-reference\": \"channel\", \"type\": \"integer\", \"description\": \"Channel to perform filter on\"}, \"gate\": {\"x-reference\": \"gate\", \"type\": \"integer\", \"description\": \"Timegate index for filter\"}}, \"type\": \"object\", \"description\": \"Dictionary defining which channel and gate to enable or disable\", \"x-reference\": \"channel-gate\", \"default\": {\"channel\": 1, \"gate\": 0}, \"x-python-type\": \"builtins.dict\"}, \"action\": {\"type\": \"string\", \"enum\": [\"enable\", \"disable\"], \"default\": \"disable\", \"x-python-type\": \"builtins.str\", \"description\": \"Key to denote whether to 'enable' or 'disable' the timegate\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Moving average filter\", \"description\": \"Moving average filter, averaging Gate values from neighboring soundings\", \"required\": [\"Moving average filter\"], \"additionalProperties\": false, \"properties\": {\"Moving average filter\": {\"properties\": {\"err_calc\": {\"type\": \"string\", \"enum\": [\"rms\", \"avg\"], \"default\": \"rms\", \"x-python-type\": \"builtins.str\", \"description\": \"switch for how to compute the STD's inside the averaging window. Allowed options are:\\n - 'rms' (default) root-mean-square sum of the STD's inside the averaging window\\n - 'avg' simple average of the STD's inside the averaging window\"}, \"verbose\": {\"default\": false, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If True, more output about what the filter is doing\"}, \"filter_dict\": {\"type\": \"object\", \"default\": {\"Gate_Ch01\": {\"first_gate\": 3, \"last_gate\": 5}, \"Gate_Ch02\": {\"first_gate\": 5, \"last_gate\": 9}}, \"x-python-type\": \"builtins.dict\", \"properties\": {\"Gate_Ch01\": {\"properties\": {\"first_gate\": {\"type\": \"integer\"}, \"last_gate\": {\"type\": \"integer\"}}}, \"Gate_Ch02\": {\"properties\": {\"first_gate\": {\"type\": \"integer\"}, \"last_gate\": {\"type\": \"integer\"}}}}, \"description\": \"Dictionary describing the filter widths for the first and the last gate \\nof each moment/channel . The default is {'Gate_Ch01':[3, 5], 'Gate_Ch02':[5, 9]}.\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Rename Column\", \"description\": \"Rename a column in the dataset (data.flightlines).\\n These are generally attributes in the dataset that are a single value for the sounding, like:\\n 'tx_altitude', 'utm_x', 'utm_y', etc.\\n Useful to work around data import and source issues.\\n Warning: This will overwrite data if the new column exists\", \"required\": [\"Rename Column\"], \"additionalProperties\": false, \"properties\": {\"Rename Column\": {\"properties\": {\"new\": {\"type\": \"string\", \"x-python-type\": \"builtins.str\", \"description\": \"The new name of the column\"}, \"orig\": {\"x-reference\": \"flightline-column-name\", \"x-python-type\": \"builtins.str\", \"description\": \"The column name to rename\", \"type\": \"string\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Rename Data\", \"description\": \"Rename a group of data in the dataset (data.layer_data[]).\\n These are generally the per-timegate or per-layer dataframes\\n \\\"Gate_Ch01\\\", \\\"InUse_Ch01\\\", 'STD_Ch01', 'relErr_Ch01'\\n Useful to work around data import and source issues.\\n Warning: This will overwrite data if the new group exists\", \"required\": [\"Rename Data\"], \"additionalProperties\": false, \"properties\": {\"Rename Data\": {\"properties\": {\"new\": {\"type\": \"string\", \"x-python-type\": \"builtins.str\", \"description\": \"The new name for the group of data\"}, \"orig\": {\"x-reference\": \"layer-data-name\", \"x-python-type\": \"builtins.str\", \"description\": \"The data group to rename\", \"type\": \"string\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"STD error: Add fractional error\", \"description\": \"Function to add fractional std error to all timegates.\\n Ex: error_fraction = 0.02 = + 2%. Adds error to the gate range specified\\n Ex: error_fraction = -0.01 = - 1%; Subtracts error to the gate range specified\", \"required\": [\"STD error: Add fractional error\"], \"additionalProperties\": false, \"properties\": {\"STD error: Add fractional error\": {\"properties\": {\"error_fraction\": {\"default\": 0.01, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Fraction of data to use as std error\"}, \"channel_and_gates\": {\"properties\": {\"channel\": {\"x-reference\": \"channel\", \"type\": \"integer\", \"description\": \"Channel to perform filter on\"}, \"start_gate\": {\"x-reference\": \"gate\", \"type\": \"integer\", \"description\": \"Starting timegate index for filter\"}, \"end_gate\": {\"x-reference\": \"gate\", \"type\": \"integer\", \"description\": \"Ending timegate index for filter\"}}, \"type\": \"object\", \"description\": \"The channel and gate range to add STD error to the data.\", \"x-reference\": \"channel-gate-range\", \"default\": {\"channel\": 1, \"start_gate\": 0, \"end_gate\": 0}, \"x-python-type\": \"builtins.dict\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"STD error: Replace from GEX\", \"description\": \"Function to Replace STD error estimates with the estimates from the gex file.\\n Note: often the errors reported alongside the data are measured from the raw transient\\n stack and are individually reported for each sounding's timegates. Consult the data\\n report for more information on how the STD data are created.\\n Using this function will overwrite the STD estimates with a single value that comes from the gex file.\", \"required\": [\"STD error: Replace from GEX\"], \"additionalProperties\": false, \"properties\": {\"STD error: Replace from GEX\": {\"properties\": {\"channel\": {\"type\": \"integer\", \"description\": \"Channel to perform filter on\", \"x-reference\": \"channel\", \"default\": 1, \"x-python-type\": \"builtins.int\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Save intermediate results\", \"description\": \"Save an intermediate state of your new processing.\", \"required\": [\"Save intermediate results\"], \"additionalProperties\": false, \"properties\": {\"Save intermediate results\": {\"properties\": {\"name\": {\"type\": \"string\", \"x-python-type\": \"builtins.str\", \"description\": \"Give the intermediate result a dataset name. This will appear in the plot editor under Dataset.\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Select flight-types\", \"description\": \"Function to reduce the dataset to the given list of flight-types. By default, all flightlines are considered\\n 'Production' until otherwise set.\\n Hint: The processing filter \\\"Classify flightlines\\\" allows you to set the flight-types\", \"required\": [\"Select flight-types\"], \"additionalProperties\": false, \"properties\": {\"Select flight-types\": {\"properties\": {\"flight_types\": {\"items\": {\"anyOf\": [{\"enum\": [\"Production\", \"Tie\", \"Test\", \"High-altitude\"], \"type\": \"string\", \"x-python-type\": \"builtins.str\"}, {\"type\": \"string\", \"x-python-type\": \"builtins.str\"}], \"x-python-type\": \"types.UnionType\", \"type\": \"string\", \"x-reference\": \"flight_type\"}, \"type\": \"array\", \"x-python-type\": \"builtins.list\", \"description\": \"list of line numbers you like to keep in the dataset.\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Select flightlines\", \"description\": \"Function to select flightlines from the dataset to process.\", \"required\": [\"Select flightlines\"], \"additionalProperties\": false, \"properties\": {\"Select flightlines\": {\"properties\": {\"lines\": {\"items\": {\"type\": \"string\", \"x-reference\": \"flightline\"}, \"type\": \"array\", \"x-python-type\": \"builtins.list\", \"description\": \"list of flightlines you would like to keep.\"}}, \"type\": \"object\", \"additionalProperties\": false}}}, {\"type\": \"object\", \"title\": \"Use manual edits\", \"description\": \"Apply a manual culling to your dataset.\", \"required\": [\"Use manual edits\"], \"additionalProperties\": false, \"properties\": {\"Use manual edits\": {\"properties\": {\"diff\": {\"type\": \"object\", \"x-python-type\": \"typing.Any\", \"description\": \"Manual culling to apply. To create manual culling, save culling in plot workspace first and it will appear here.\", \"x-reference\": \"manual-edit\", \"anyOf\": [{\"x-url-media-type\": \"application/x-geophysics-xyz-model\"}, {\"type\": \"object\", \"additionalProperties\": false, \"required\": [\"url\"], \"properties\": {\"url\": {\"x-url-media-type\": \"application/x-geophysics-xyz-model\"}, \"title\": {\"type\": \"string\"}, \"id\": {\"type\": \"integer\"}}}]}}, \"type\": \"object\", \"additionalProperties\": false}}}], \"description\": \"emeraldprocessing.pipeline_step\"}}\n" + ] + } + ], + "source": [ + "print(json.dumps(introspection['Processing']))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "42632764-1fa2-42ce-b51d-64dcbf1d7261", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\"title\": \"beryl_pipeline.import\", \"anyOf\": [{\"type\": \"object\", \"title\": \"LibaarhusXYZImporter\", \"description\": \"Import SkyTEM data\", \"required\": [\"LibaarhusXYZImporter\"], \"additionalProperties\": false, \"properties\": {\"LibaarhusXYZImporter\": {\"properties\": {\"scalefactor\": {\"default\": 1e-12, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Data unit, 1 = volt, 1e-12 = picovolt\"}, \"files\": {\"properties\": {\"xyzfile\": {\"minLength\": 5, \"pattern\": \"\\\\.xyz$\", \"type\": \"string\", \"format\": \"url\", \"description\": \"The data itself\"}, \"gexfile\": {\"minLength\": 5, \"pattern\": \"\\\\.gex$\", \"type\": \"string\", \"format\": \"url\", \"description\": \"System description / calibration file\"}, \"alcfile\": {\"minLength\": 5, \"pattern\": \"\\\\.alc$\", \"type\": \"string\", \"format\": \"url\", \"description\": \"Metadata file (column name mapping)\"}}, \"type\": \"object\", \"x-format\": \"multi-url\", \"description\": \"Required: .gex, .xyz | Optional: .alc\", \"x-python-type\": \"builtins.dict\"}, \"projection\": {\"format\": \"x-epsg\", \"x-python-type\": \"builtins.int\", \"description\": \"EPSG code for the projection and chart datum of sounding locations\", \"type\": \"integer\"}}, \"type\": \"object\", \"additionalProperties\": false}}}], \"description\": \"beryl_pipeline.import\"}\n" + ] + } + ], + "source": [ + "print(json.dumps(introspection['Import']))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "a4131655-6d17-44a3-82fa-c7f21cd2a53b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\"title\": \"simpeg.static_instrument\", \"anyOf\": [{\"type\": \"object\", \"title\": \"DualMomentTEMXYZSystem\", \"description\": \"Dual moment system, suitable for describing e.g. the SkyTEM\\ninstruments. This class can not be directly instantiated, but\\ninstead, instantiable subclasses can created using the class\\nmethod\\n\\n```\\nMySurveyInstrument = DualMomentTEMXYZSystem.load_gex(\\n libaarhusxyz.GEX(\\\"instrument.gex\\\"))\\n```\\n\\nwhich reads a gex file containing among other things the waveform\\ndescription of the instrument.\\n\\nSee the help for `XYZSystem` for more information on basic usage.\", \"required\": [\"DualMomentTEMXYZSystem\"], \"additionalProperties\": false, \"properties\": {\"DualMomentTEMXYZSystem\": {\"properties\": {\"directives\": {\"type\": \"object\", \"title\": \"directives\", \"description\": \"directives\", \"properties\": {\"beta\": {\"type\": \"object\", \"title\": \"beta\", \"description\": \"beta\", \"properties\": {\"beta0_ratio\": {\"default\": 10.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Start ratio for the beta (regularization) schedule estimator\", \"title\": \"beta0_ratio\"}, \"seed\": {\"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Random seed for beta (regularization) schedule estimator\", \"title\": \"seed\"}, \"cooling_rate\": {\"default\": 1, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Initial cooling rate for the beta (regularization) schedule\", \"title\": \"cooling_rate\"}, \"cooling_factor\": {\"default\": 2, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Cooling factor for the beta (regularization) schedule\", \"title\": \"cooling_factor\"}}, \"x-python-type\": null}, \"irls\": {\"type\": \"object\", \"title\": \"irls\", \"description\": \"irls\", \"properties\": {\"enable\": {\"default\": false, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"IRLS is used to generate a sparse model in addition to and l2 model\", \"title\": \"enable\"}, \"f_min_change\": {\"default\": 0.001, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"title\": \"f_min_change\"}, \"max_iterations\": {\"default\": 30, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Maximum number of iterations (after l2 model has converged)\", \"title\": \"max_iterations\"}, \"fix_Jmatrix\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"title\": \"fix_Jmatrix\"}, \"minGNiter\": {\"default\": 1, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"title\": \"minGNiter\"}, \"coolingRate\": {\"default\": 1, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"title\": \"coolingRate\"}}, \"x-python-type\": null}}, \"x-python-type\": null}, \"regularization\": {\"type\": \"object\", \"title\": \"regularization\", \"description\": \"regularization\", \"properties\": {\"alpha_s\": {\"default\": 1e-10, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"title\": \"alpha_s\"}, \"alpha_r\": {\"default\": 1.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"title\": \"alpha_r\"}, \"alpha_z\": {\"default\": 1.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"title\": \"alpha_z\"}}, \"x-python-type\": null}, \"startmodel\": {\"type\": \"object\", \"title\": \"startmodel\", \"description\": \"startmodel\", \"properties\": {\"thicknesses_minimum_dz\": {\"default\": 1, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Thickness of thinnest layer if using 'logspaced' or 'geometric' discretization\", \"title\": \"thicknesses_minimum_dz\"}, \"top_depth_last_layer\": {\"default\": 400, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Depth to the top of the last layer if using logspaced discretization\", \"title\": \"top_depth_last_layer\"}, \"thicknesses_geomtric_factor\": {\"default\": 1.15309, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Ratio of one layer to the next if using geometric discretization\", \"title\": \"thicknesses_geomtric_factor\"}, \"thicknesses_type\": {\"type\": \"string\", \"enum\": [\"logspaced\", \"geometric\", \"time\"], \"default\": \"logspaced\", \"x-python-type\": \"builtins.str\", \"description\": \"Type of model discretization\", \"title\": \"thicknesses_type\"}, \"n_layer\": {\"default\": 30, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Number of layers in model discretization\", \"title\": \"n_layer\"}, \"res\": {\"default\": 100.0, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Initial resistivity (ohmm)\", \"title\": \"res\"}}, \"x-python-type\": null}, \"uncertainties\": {\"type\": \"object\", \"title\": \"uncertainties\", \"description\": \"uncertainties\", \"properties\": {\"noise_level_1ms\": {\"default\": 3e-08, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"V/m^2\", \"title\": \"noise_level_1ms\"}, \"std_data\": {\"default\": 0.03, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"Noise as a factor of data\", \"title\": \"std_data\"}, \"noise_exponent\": {\"default\": -0.5, \"type\": \"number\", \"x-python-type\": \"builtins.float\", \"description\": \"t^uncertainties__noise_exponent\", \"title\": \"noise_exponent\"}, \"std_data_override\": {\"default\": false, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"If set to true, use the std_data value instead of data std:s from stacking\", \"title\": \"std_data_override\"}}, \"x-python-type\": null}, \"gate_filter\": {\"type\": \"object\", \"title\": \"gate_filter\", \"description\": \"gate_filter\", \"properties\": {\"start_hm\": {\"default\": 12, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Lowest used gate (zero based)\", \"title\": \"start_hm\"}, \"end_hm\": {\"default\": 26, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"First unused gate above used ones (zero based)\", \"title\": \"end_hm\"}, \"start_lm\": {\"default\": 5, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Lowest used gate (zero based)\", \"title\": \"start_lm\"}, \"end_lm\": {\"default\": 11, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"First unused gate above used ones (zero based)\", \"title\": \"end_lm\"}}, \"x-python-type\": null}, \"optimizer\": {\"type\": \"object\", \"title\": \"optimizer\", \"description\": \"optimizer\", \"properties\": {\"max_iter_cg\": {\"default\": 20, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"title\": \"max_iter_cg\"}, \"max_iter\": {\"default\": 40, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Maximum number of gauss newton iterations\", \"title\": \"max_iter\"}}, \"x-python-type\": null}, \"tx_orientation\": {\"type\": \"string\", \"enum\": [\"x\", \"y\", \"z\"], \"default\": \"z\", \"x-python-type\": \"builtins.str\", \"description\": \"Transmitter orientation\"}, \"simulation\": {\"type\": \"object\", \"title\": \"simulation\", \"description\": \"simulation\", \"properties\": {\"n_cpu\": {\"default\": 3, \"type\": \"integer\", \"x-python-type\": \"builtins.int\", \"description\": \"Number of threads (roughly same as CPU cores) to use\", \"title\": \"n_cpu\"}, \"solver\": {\"type\": \"string\", \"enum\": [\"LU\", \"pardiso\"], \"default\": \"LU\", \"x-python-type\": \"builtins.str\", \"description\": \"Equation solver to use. Some solvers might require hardware support.\", \"title\": \"solver\"}, \"parallel\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"Use multiple computation threads in parallel. Useful to set to false in a notebook for debugging.\", \"title\": \"parallel\"}}, \"x-python-type\": null}, \"rx_orientation\": {\"type\": \"string\", \"enum\": [\"x\", \"y\", \"z\"], \"default\": \"z\", \"x-python-type\": \"builtins.str\", \"description\": \"Receiver orientation\"}, \"validate\": {\"default\": true, \"type\": \"boolean\", \"x-python-type\": \"builtins.bool\", \"description\": \"Validate input data scaling etc. prior to inversion\"}, \"save_intermediate\": {\"type\": \"boolean\", \"default\": false, \"description\": \"Save intermediate models and sythentic data for every inversion iteration\"}}, \"type\": \"object\", \"additionalProperties\": false}}, \"x-returntype\": {\"type\": \"object\", \"x-python-type\": \"SimPEG.electromagnetics.utils.static_instrument.dual.DualMomentTEMXYZSystem\", \"description\": \"SimPEG.electromagnetics.utils.static_instrument.dual.DualMomentTEMXYZSystem\"}}, {\"type\": \"object\", \"title\": \"Workbench import\", \"description\": \"Import a model inverted in Aarhus Workbench. This ignored\\nthe input dataset completely.\", \"required\": [\"Workbench import\"], \"additionalProperties\": false, \"properties\": {\"Workbench import\": {\"properties\": {\"model_xyzfile\": {\"type\": \"string\", \"format\": \"url\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\", \"minLength\": 5, \"pattern\": \"\\\\.xyz$\"}, \"scalefactor\": {\"default\": 1e-12, \"type\": \"number\", \"x-python-type\": \"builtins.float\"}, \"corrected_alcfile\": {\"type\": \"string\", \"format\": \"url\", \"pattern\": \"\\\\.alc$\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\", \"minLength\": 5}, \"corrected_xyzfile\": {\"type\": \"string\", \"format\": \"url\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\", \"minLength\": 5, \"pattern\": \"\\\\.xyz$\"}, \"projection\": {\"format\": \"x-epsg\", \"type\": \"integer\", \"x-python-type\": \"builtins.int\"}, \"gexfile\": {\"type\": \"string\", \"format\": \"url\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\", \"minLength\": 5, \"pattern\": \"\\\\.gex$\"}, \"fwd_xyzfile\": {\"type\": \"string\", \"format\": \"url\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\", \"minLength\": 5, \"pattern\": \"\\\\.xyz$\"}, \"fwd_alcfile\": {\"type\": \"string\", \"format\": \"url\", \"pattern\": \"\\\\.alc$\", \"x-python-type\": \"pydantic_core._pydantic_core.Url\", \"minLength\": 5}, \"save_intermediate\": {\"type\": \"boolean\", \"default\": false, \"description\": \"Save intermediate models and sythentic data for every inversion iteration\"}}, \"type\": \"object\", \"additionalProperties\": false}}, \"x-returntype\": {\"type\": \"object\", \"x-python-type\": \"beryl_pipeline.inversion_workbench_import.WorkbenchImporter\", \"description\": \"beryl_pipeline.inversion_workbench_import.WorkbenchImporter\"}}], \"description\": \"simpeg.static_instrument\"}\n" + ] + } + ], + "source": [ + "print(json.dumps(introspection['Inversion']))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "03160752", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "experimental-pipeline-inversion", + "language": "python", + "name": "experimental-pipeline-inversion" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/run processing inversion luigi.ipynb b/docs/run processing inversion luigi.ipynb new file mode 100644 index 0000000..8e6672d --- /dev/null +++ b/docs/run processing inversion luigi.ipynb @@ -0,0 +1,1231 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b81b3b42-55a2-47a7-b106-59a9c1019414", + "metadata": {}, + "source": [ + "# Data preparation\n", + "\n", + "Please clone [this repo](https://github.com/emerald-geomodelling/simpeg-simpleem-examples) next to this one and run the notebook\n", + "[demo_data_download.ipynb](https://github.com/emerald-geomodelling/simpeg-simpleem-examples/blob/master/measured_inversion.ipynb)\n", + "before this notebook to download the demo data to data/IncisedValley." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "16f6ab59", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading S3 module without the python package boto3. Will crash at runtime if S3 functionality is used.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cannot import Pardiso, will use SolverLU\n" + ] + } + ], + "source": [ + "import libaarhusxyz\n", + "import beryl_pipeline.file_import\n", + "import beryl_pipeline.processing\n", + "import beryl_pipeline.inversion\n", + "import luigi.contrib.opener\n", + "import poltergust_luigi_utils.caching\n", + "import yaml\n", + "import shutil\n", + "import os.path" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e3476c99-ebd1-43d3-b048-00dcf4c71d66", + "metadata": {}, + "outputs": [], + "source": [ + "rootpath = os.path.abspath(\"./data\")\n", + "cachepath = os.path.expanduser(\"~/.cache/poltergust-luigi-utils\")\n", + "srcpath = os.path.abspath(\"../../simpeg-simpleem-examples/data/IncisedValley\")\n", + "\n", + "src = \"file://\" + srcpath\n", + "root = \"file://\" + rootpath" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "97808baf-d579-433d-907a-79d8f3562902", + "metadata": {}, + "outputs": [], + "source": [ + "if os.path.exists(rootpath):\n", + " shutil.rmtree(rootpath)\n", + "if os.path.exists(cachepath):\n", + " shutil.rmtree(cachepath)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "45c8bb6c", + "metadata": {}, + "outputs": [], + "source": [ + "with poltergust_luigi_utils.caching.CachingOpenerTarget(root + \"/import/config.yml\").open(\"w\") as f:\n", + " yaml.dump({\n", + " \"importer\": {\n", + " \"name\": \"SkyTEM XYZ\",\n", + " \"args\": {\n", + " \"projection\": 25832,\n", + " \"files\": {\n", + " \"xyzfile\": src + \"/aem_processed_data_foothill_central_valley.100101.0.xyz\",\n", + " \"gexfile\": src + \"/20201231_20023_IVF_SkyTEM304_SKB.gex\"\n", + " }\n", + " }\n", + " }\n", + " }, f)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e71641b3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG: Checking if Import(import_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/import) is complete\n", + "INFO: Informed scheduler that task Import_file____home_red_dec33cd536 has status PENDING\n", + "INFO: Done scheduling tasks\n", + "INFO: Running Worker with 1 processes\n", + "DEBUG: Asking scheduler for work...\n", + "DEBUG: Pending tasks: 1\n", + "INFO: [pid 1322012] Worker Worker(salt=2736033196, workers=1, host=glittertind, username=redhog, pid=1322012) running Import(import_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/import)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "header [General] parsed\n", + "header [Channel1] parsed\n", + "header [Channel2] parsed\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: [pid 1322012] Worker Worker(salt=2736033196, workers=1, host=glittertind, username=redhog, pid=1322012) done Import(import_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/import)\n", + "DEBUG: 1 running tasks, waiting for next task to finish\n", + "INFO: Informed scheduler that task Import_file____home_red_dec33cd536 has status DONE\n", + "DEBUG: Asking scheduler for work...\n", + "DEBUG: Done\n", + "DEBUG: There are no more tasks to run at this time\n", + "INFO: Worker Worker(salt=2736033196, workers=1, host=glittertind, username=redhog, pid=1322012) was stopped. Shutting down Keep-Alive thread\n", + "INFO: \n", + "===== Luigi Execution Summary =====\n", + "\n", + "Scheduled 1 tasks of which:\n", + "* 1 ran successfully:\n", + " - 1 Import(import_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/import)\n", + "\n", + "This progress looks :) because there were no failed tasks or missing dependencies\n", + "\n", + "===== Luigi Execution Summary =====\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Worker Worker(salt=6431882964, workers=1, host=glittertind, username=redhog, pid=1322012) was stopped. Shutting down Keep-Alive thread\n" + ] + } + ], + "source": [ + "import_task = beryl_pipeline.file_import.Import(import_name = root + \"/import\")\n", + "\n", + "luigi.build([import_task], local_scheduler=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bc3f4d61-8253-49f7-b7b5-360938ef1f6b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['out.msgpack',\n", + " 'config.yml',\n", + " 'out.gex',\n", + " 'out.summary.yml',\n", + " 'out.100101.0.gex',\n", + " 'out.100101.0.xyz',\n", + " 'DONE',\n", + " 'log.yml',\n", + " 'out.xyz',\n", + " 'out.100101.0.msgpack',\n", + " 'out.100101.0.summary.yml',\n", + " 'out.geojson',\n", + " 'out.100101.0.geojson']" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "os.listdir(rootpath + \"/import\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "79020af2-0519-4c17-acef-86c85589bee7", + "metadata": {}, + "outputs": [], + "source": [ + "with poltergust_luigi_utils.caching.CachingOpenerTarget(root + \"/processing/config.yml\").open(\"w\") as f:\n", + " f.write(f\"\"\"\n", + "data:\n", + " args:\n", + " data: {root}/import/out.xyz\n", + " sidecar: null\n", + " system_data: {root}/import/out.gex\n", + " name: emeraldprocessing.pipeline.ProcessingData\n", + "steps:\n", + "- 'Classify high altitude flightlines: Auto':\n", + " height_threshold: 500\n", + " verbose: true\n", + "#- 'Classify flightlines: Selection':\n", + "# flight_type: g1\n", + "# lines: [500101, 500102, 500201, 500202, 500301, 500302, 500401, 500402, 500403, 500501, 500502, 500601, 500602, 500603, 500604, 500605, 500606, 500701, 500702, 500703, 500801, 500802, 500803, 500804, 500805, 500901, 500902, 500903, 501001, 501002, 501101, 501102, 501103, 501104, 501105, 501106, 501201, 501202, 501203, 501204, 501301, 501302, 501303, 501304, 501305, 501401, 501402, 501403, 501501, 501502, 501503, 501601, 501602, 501603, 501604, 501605, 501606, 501701, 501702, 501703, 501704, 501705, 501706, 501707, 501801, 501802, 501803, 501804, 501805, 501806, 501807, 501901, 501902, 501903, 501904, 501905, 501906, 501907, 501908, 502001, 502002, 502003, 502004, 502005, 502006, 502007, 502008, 502009, 502101, 502102, 502103, 502104, 502201, 502202, 502203, 502301, 502302, 502303, 502401, 502402, 502403, 502501, 502502, 502601, 502602, 502701, 502702]\n", + "#- 'Classify flightlines: Selection':\n", + "# flight_type: g2\n", + "# lines: [600101, 600102, 600103, 600201, 600202, 600203, 600301, 600401, 600402, 600501, 600502, 600503, 600504, 600601, 600602, 600603, 600604, 600605, 600606, 600701, 600702, 600801, 600901, 601001, 601002, 601101, 601201, 601301, 601401, 601501, 601502, 601601, 601701, 601702, 601703, 601704, 601801, 601901, 602001, 602101, 602201, 602301]\n", + "#- 'Classify flightlines: Selection':\n", + "# flight_type: Production\n", + "# lines:\n", + "# - 300201\n", + "#- 'Classify flightlines: Selection':\n", + "# flight_type: Test\n", + "# lines:\n", + "# - 300101\n", + "#- Replace STD error from GEX:\n", + "# channel: 1\n", + "#- Replace STD error from GEX:\n", + "# channel: 2\n", + "#- Add STD error:\n", + "# channel_and_gates:\n", + "# channel: 1\n", + "# end_gate: 0\n", + "# start_gate: 15\n", + "# error_fraction: 0.01\n", + "#- Add STD error:\n", + "# channel_and_gates:\n", + "# channel: 2\n", + "# end_gate: 0\n", + "# start_gate: 20\n", + "# error_fraction: 0.01\n", + "#- Add STD error:\n", + "# channel_and_gates:\n", + "# channel: 1\n", + "# end_gate: 0\n", + "# start_gate: 20\n", + "# error_fraction: 0.01\n", + "#- Add STD error:\n", + "# channel_and_gates:\n", + "# channel: 2\n", + "# end_gate: 0\n", + "# start_gate: 25\n", + "# error_fraction: 0.01\n", + "#- Correct altitude and topo:\n", + "# terrain_model: /path/to/shapefile\n", + "# verbose: false\n", + "- Disable soundings by tilt and altitude:\n", + " max_alt: 110\n", + " max_pitch: 10\n", + " max_roll: 10\n", + " save_filter_to_layer_data: true\n", + " verbose: false\n", + "- Correct data and tilt for 1D:\n", + " verbose: false\n", + "- Enable/Disable gates by index:\n", + " action: disable\n", + " channel_and_gate:\n", + " channel: 1\n", + " gate: 0\n", + " save_filter_to_layer_data: true\n", + "- Enable/Disable gates by index:\n", + " action: disable\n", + " channel_and_gate:\n", + " channel: 2\n", + " gate: 0\n", + " save_filter_to_layer_data: true\n", + "- Disable gates by STD values:\n", + " channel_and_gate:\n", + " channel: 1\n", + " gate: 7\n", + " disable_earlier_gates: 0\n", + " disable_sounding_tails: true\n", + " save_filter_to_layer_data: true\n", + " std_threshold: 0.15\n", + "- Disable gates by STD values:\n", + " channel_and_gate:\n", + " channel: 2\n", + " gate: 13\n", + " disable_earlier_gates: 0\n", + " disable_sounding_tails: true\n", + " save_filter_to_layer_data: true\n", + " std_threshold: 0.15\n", + "- Disable gates by negative data:\n", + " channel_and_gate:\n", + " channel: 1\n", + " gate: 7\n", + " disable_earlier_gates: 0\n", + " disable_sounding_tails: true\n", + " save_filter_to_layer_data: true\n", + "- Disable gates by negative data:\n", + " channel_and_gate:\n", + " channel: 2\n", + " gate: 13\n", + " disable_earlier_gates: 0\n", + " disable_sounding_tails: true\n", + " save_filter_to_layer_data: true\n", + "- Disable gates by slope max:\n", + " channel_and_gate:\n", + " channel: 1\n", + " gate: 7\n", + " disable_earlier_gates: 0\n", + " disable_sounding_tails: true\n", + " max_slope: 0\n", + " save_filter_to_layer_data: true\n", + " verbose: true\n", + "- Disable gates by slope max:\n", + " channel_and_gate:\n", + " channel: 2\n", + " gate: 13\n", + " disable_earlier_gates: 0\n", + " disable_sounding_tails: true\n", + " max_slope: 0\n", + " save_filter_to_layer_data: true\n", + " verbose: true\n", + "- Disable gates by slope min:\n", + " channel_and_gate:\n", + " channel: 1\n", + " gate: 7\n", + " disable_earlier_gates: 0\n", + " disable_sounding_tails: true\n", + " min_slope: -6.0\n", + " save_filter_to_layer_data: true\n", + " verbose: true\n", + "- Disable gates by slope min:\n", + " channel_and_gate:\n", + " channel: 2\n", + " gate: 13\n", + " disable_earlier_gates: 0\n", + " disable_sounding_tails: true\n", + " min_slope: -6.0\n", + " save_filter_to_layer_data: true\n", + " verbose: true\n", + "- Disable soundings by number of active gates:\n", + " channel: 1\n", + " min_number_of_gates: 4\n", + " save_filter_to_layer_data: true\n", + "- Disable soundings by number of active gates:\n", + " channel: 2\n", + " min_number_of_gates: 4\n", + " save_filter_to_layer_data: true\n", + "\"\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ea11e982", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG: Checking if Processing(processing_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/processing) is complete\n", + "DEBUG: Checking if Import(import_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/import) is complete\n", + "INFO: Informed scheduler that task Processing_file____home_red_ec07bb04b5 has status PENDING\n", + "INFO: Informed scheduler that task Import_file____home_red_dec33cd536 has status DONE\n", + "INFO: Done scheduling tasks\n", + "INFO: Running Worker with 1 processes\n", + "DEBUG: Asking scheduler for work...\n", + "DEBUG: Pending tasks: 1\n", + "INFO: [pid 1322012] Worker Worker(salt=8090251977, workers=1, host=glittertind, username=redhog, pid=1322012) running Processing(processing_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/processing)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=============== Reading SkyTEM xyz data ===============\n", + " - Reading gex file.\n", + "header [General] parsed\n", + "header [Channel1] parsed\n", + "header [Channel2] parsed\n", + " - Reading xyz file.\n", + " - building xyz dictionary\n", + " - Done reading the data package!\n", + " - Time used to read and import the data package: 0.1647651195526123 sec.\n", + "\n", + "\n", + "=============== Processing step 1 ===============\n", + " - Step name: 'Classify high altitude flightlines: Auto'\n", + " - Classifying flightlines with mean altitude ≥ 500 as 'High-altitude'\n", + " - No lines have been found as high altitude.\n", + " - All lines without a previous flight_type classification have been labeled 'Production'.\n", + " - Flight types in dataset: ['Production']\n", + " - Time used to auto-classify the dataset: 0.0042340755462646484 sec.\n", + "\n", + "\n", + "=============== Processing step 2 ===============\n", + " - Step name: 'Disable soundings by tilt and altitude'\n", + " - Disabling based on roll (±10°), pitch(±10°), and altitude (110 m) limits\n", + " - Pre-disable statistics:\n", + " - TxRoll: 0.0 ± 0.0 °\n", + " - TxPitch: 0.0 ± 0.0 °\n", + " - TxAltitude: 41.94 ± 12.57 m\n", + " - Post-disable statistics:\n", + " - TxRoll: 0.0 ± 0.0 °\n", + " - TxPitch: 0.0 ± 0.0 °\n", + " - TxAltitude: 41.94 ± 12.57 m\n", + " - 0.0 % of the data have been deactivated by this filter\n", + " - Time used to disable data based on tilt and altitude: 0.014956951141357422 sec.\n", + "\n", + "\n", + "=============== Processing step 3 ===============\n", + " - Step name: 'Correct data and tilt for 1D'\n", + " - 1D Data and Tilt correction of the data\n", + " - Pre-Correction statistics:\n", + " - TxRoll: 0.0 ± 0.0 °\n", + " - TxPitch: 0.0 ± 0.0 °\n", + " - Post-Correction statistics:\n", + " - TxRoll: 0.0 ± 0.0 °\n", + " - TxPitch: 0.0 ± 0.0 °\n", + " - Time used for 1D correction of the data: 0.030867576599121094 sec.\n", + "\n", + "\n", + "=============== Processing step 4 ===============\n", + " - Step name: 'Enable/Disable gates by index'\n", + " - Disabling gate-0 from channel-1\n", + " - 3.57 % of the data have been disabled by this filter\n", + " - Time used to disable timegate-0 from Channel1: 0.0013155937194824219 sec.\n", + "\n", + "\n", + "=============== Processing step 5 ===============\n", + " - Step name: 'Enable/Disable gates by index'\n", + " - Disabling gate-0 from channel-2\n", + " - 2.7 % of the data have been disabled by this filter\n", + " - Time used to disable timegate-0 from Channel2: 0.001201629638671875 sec.\n", + "\n", + "\n", + "=============== Processing step 6 ===============\n", + " - Step name: 'Disable gates by STD values'\n", + " - Disabling channel-1 after gate-7 based on 0.15 STD threshold\n", + " - 16.62 % of the data have been deactivated by this filter\n", + " - Time used for STD based disabling: 0.003088235855102539 sec.\n", + "\n", + "\n", + "=============== Processing step 7 ===============\n", + " - Step name: 'Disable gates by STD values'\n", + " - Disabling channel-2 after gate-13 based on 0.15 STD threshold\n", + " - 12.93 % of the data have been deactivated by this filter\n", + " - Time used for STD based disabling: 0.003185272216796875 sec.\n", + "\n", + "\n", + "=============== Processing step 8 ===============\n", + " - Step name: 'Disable gates by negative data'\n", + " - Disabling negative data from channel-1 after gate-7\n", + " - 0.0 % of the data have been deactivated by this filter\n", + " - Time used to disable negative data: 0.0042934417724609375 sec.\n", + "\n", + "\n", + "=============== Processing step 9 ===============\n", + " - Step name: 'Disable gates by negative data'\n", + " - Disabling negative data from channel-2 after gate-13\n", + " - 0.0 % of the data have been deactivated by this filter\n", + " - Time used to disable negative data: 0.003775358200073242 sec.\n", + "\n", + "\n", + "=============== Processing step 10 ===============\n", + " - Step name: 'Disable gates by slope max'\n", + " - Disabling slopes greater than 0 on channel-1 after gate-7\n", + " - Slope statistics for all gates:\n", + "\n", + "Pre-disable count mean std min max\n", + "0 0.0 NaN NaN NaN NaN\n", + "1 0.0 NaN NaN NaN NaN\n", + "2 193.0 0.948 0.080 0.847 1.282\n", + "3 193.0 -2.127 0.526 -3.854 -1.289\n", + "4 193.0 -0.833 1.710 -4.485 3.197\n", + "5 193.0 -0.276 0.687 -1.338 1.671\n", + "6 193.0 -1.314 0.371 -2.003 -0.560\n", + "7 193.0 -1.549 0.359 -2.281 -0.132\n", + "8 193.0 -1.640 0.336 -2.296 -0.358\n", + "9 193.0 -1.693 0.337 -2.715 -0.746\n", + "10 193.0 -1.578 0.371 -2.242 -0.020\n", + "11 193.0 -1.755 0.285 -2.517 -0.999\n", + "12 193.0 -1.796 0.393 -3.700 -0.801\n", + "13 193.0 -1.661 0.420 -2.465 -0.051\n", + "14 193.0 -1.934 0.320 -3.673 -0.912\n", + "15 193.0 -1.971 0.323 -3.734 -0.984\n", + "16 193.0 -1.870 0.359 -2.463 -0.152\n", + "17 193.0 -2.227 0.766 -6.565 -0.387\n", + "18 191.0 -1.864 0.710 -3.046 2.122\n", + "19 190.0 -2.077 0.437 -3.370 -0.501\n", + "20 190.0 -2.187 0.715 -6.939 -0.019\n", + "21 187.0 -2.043 0.696 -3.661 2.787\n", + "22 179.0 -2.559 0.942 -6.720 2.035\n", + "23 168.0 -1.907 1.154 -4.455 3.511\n", + "24 122.0 -1.722 0.969 -5.022 0.518\n", + "25 44.0 -1.130 0.908 -3.164 0.649\n", + "26 7.0 0.147 0.547 -0.670 0.832\n", + "27 0.0 NaN NaN NaN NaN\n", + "all 4366.0 -1.621 0.569 -6.939 3.511\n", + "\n", + "Post-disable count mean std min max\n", + "0 0.0 NaN NaN NaN NaN\n", + "1 0.0 NaN NaN NaN NaN\n", + "2 0.0 NaN NaN NaN NaN\n", + "3 193.0 -2.127 0.526 -3.854 -1.289\n", + "4 120.0 -1.811 1.367 -4.485 -0.002\n", + "5 132.0 -0.677 0.302 -1.338 -0.003\n", + "6 193.0 -1.314 0.371 -2.003 -0.560\n", + "7 193.0 -1.549 0.359 -2.281 -0.132\n", + "8 193.0 -1.640 0.336 -2.296 -0.358\n", + "9 193.0 -1.693 0.337 -2.715 -0.746\n", + "10 193.0 -1.578 0.371 -2.242 -0.020\n", + "11 193.0 -1.755 0.285 -2.517 -0.999\n", + "12 193.0 -1.796 0.393 -3.700 -0.801\n", + "13 193.0 -1.661 0.420 -2.465 -0.051\n", + "14 193.0 -1.934 0.320 -3.673 -0.912\n", + "15 193.0 -1.971 0.323 -3.734 -0.984\n", + "16 193.0 -1.870 0.359 -2.463 -0.152\n", + "17 193.0 -2.227 0.766 -6.565 -0.387\n", + "18 184.0 -1.976 0.408 -3.046 -0.405\n", + "19 183.0 -2.048 0.410 -3.344 -0.501\n", + "20 183.0 -2.217 0.693 -6.939 -0.019\n", + "21 178.0 -2.102 0.566 -3.661 -0.210\n", + "22 170.0 -2.572 0.790 -6.720 -0.487\n", + "23 153.0 -2.093 0.862 -4.455 -0.033\n", + "24 111.0 -1.642 0.791 -3.762 -0.001\n", + "25 35.0 -1.480 0.617 -3.164 -0.100\n", + "26 2.0 -0.436 0.330 -0.670 -0.203\n", + "27 0.0 NaN NaN NaN NaN\n", + "all 3960.0 -1.838 0.494 -6.939 -0.001\n", + "\n", + " - 3.61 % of the data have been deactivated by this filter\n", + " - Time used for maximum slope disabling: 0.10160279273986816 sec.\n", + "\n", + "\n", + "=============== Processing step 11 ===============\n", + " - Step name: 'Disable gates by slope max'\n", + " - Disabling slopes greater than 0 on channel-2 after gate-13\n", + " - Slope statistics for all gates:\n", + "\n", + "Pre-disable count mean std min max\n", + "0 0.0 NaN NaN NaN NaN\n", + "1 0.0 NaN NaN NaN NaN\n", + "2 0.0 NaN NaN NaN NaN\n", + "3 0.0 NaN NaN NaN NaN\n", + "4 0.0 NaN NaN NaN NaN\n", + "5 0.0 NaN NaN NaN NaN\n", + "6 0.0 NaN NaN NaN NaN\n", + "7 0.0 NaN NaN NaN NaN\n", + "8 193.0 -3.800 0.429 -5.139 -2.541\n", + "9 193.0 -2.864 0.376 -4.029 -1.991\n", + "10 193.0 -2.665 0.372 -3.718 -1.227\n", + "11 193.0 -2.587 0.322 -3.481 -1.657\n", + "12 193.0 -2.615 0.323 -3.633 -1.805\n", + "13 193.0 -2.431 0.269 -3.103 -1.531\n", + "14 193.0 -2.355 0.227 -2.879 -1.651\n", + "15 193.0 -2.368 0.282 -3.554 -1.754\n", + "16 193.0 -2.324 0.280 -3.812 -1.747\n", + "17 193.0 -2.091 0.377 -2.567 0.635\n", + "18 193.0 -2.150 0.212 -2.970 -1.507\n", + "19 193.0 -2.184 0.295 -3.704 -1.475\n", + "20 193.0 -2.113 0.185 -2.750 -1.615\n", + "21 193.0 -2.158 0.204 -2.950 -1.437\n", + "22 193.0 -2.163 0.343 -3.155 -0.530\n", + "23 193.0 -2.075 0.372 -2.809 -0.478\n", + "24 193.0 -2.498 0.612 -6.218 -1.659\n", + "25 193.0 -2.004 0.596 -2.845 1.671\n", + "26 184.0 -2.415 0.419 -4.968 -1.519\n", + "27 184.0 -2.325 0.229 -3.157 -1.706\n", + "28 184.0 -2.166 0.449 -2.876 0.424\n", + "29 184.0 -2.311 0.364 -4.297 -0.681\n", + "30 184.0 -2.389 0.793 -6.657 0.233\n", + "31 184.0 -2.080 0.851 -4.440 2.943\n", + "32 182.0 -1.981 0.865 -4.526 1.150\n", + "33 179.0 -2.018 1.290 -7.354 0.610\n", + "34 160.0 -1.357 2.070 -9.178 4.301\n", + "35 127.0 -0.835 2.199 -6.272 6.763\n", + "36 112.0 -1.733 2.778 -8.035 7.121\n", + "all 5338.0 -2.275 0.572 -9.178 7.121\n", + "\n", + "Post-disable count mean std min max\n", + "0 0.0 NaN NaN NaN NaN\n", + "1 0.0 NaN NaN NaN NaN\n", + "2 0.0 NaN NaN NaN NaN\n", + "3 0.0 NaN NaN NaN NaN\n", + "4 0.0 NaN NaN NaN NaN\n", + "5 0.0 NaN NaN NaN NaN\n", + "6 0.0 NaN NaN NaN NaN\n", + "7 0.0 NaN NaN NaN NaN\n", + "8 193.0 -3.800 0.429 -5.139 -2.541\n", + "9 193.0 -2.864 0.376 -4.029 -1.991\n", + "10 193.0 -2.665 0.372 -3.718 -1.227\n", + "11 193.0 -2.587 0.322 -3.481 -1.657\n", + "12 193.0 -2.615 0.323 -3.633 -1.805\n", + "13 193.0 -2.431 0.269 -3.103 -1.531\n", + "14 193.0 -2.355 0.227 -2.879 -1.651\n", + "15 193.0 -2.368 0.282 -3.554 -1.754\n", + "16 193.0 -2.324 0.280 -3.812 -1.747\n", + "17 191.0 -2.116 0.281 -2.567 -0.792\n", + "18 191.0 -2.143 0.201 -2.749 -1.507\n", + "19 191.0 -2.178 0.290 -3.704 -1.475\n", + "20 191.0 -2.115 0.184 -2.750 -1.615\n", + "21 191.0 -2.162 0.199 -2.950 -1.437\n", + "22 191.0 -2.170 0.339 -3.155 -0.530\n", + "23 191.0 -2.069 0.368 -2.809 -0.478\n", + "24 191.0 -2.503 0.613 -6.218 -1.659\n", + "25 188.0 -2.045 0.494 -2.845 -0.005\n", + "26 179.0 -2.390 0.350 -4.336 -1.519\n", + "27 179.0 -2.323 0.231 -3.157 -1.706\n", + "28 179.0 -2.196 0.377 -2.876 -0.111\n", + "29 179.0 -2.313 0.368 -4.297 -0.681\n", + "30 177.0 -2.386 0.722 -6.657 -0.389\n", + "31 174.0 -2.153 0.664 -4.440 -0.376\n", + "32 172.0 -2.028 0.792 -4.526 -0.021\n", + "33 160.0 -2.097 1.099 -7.354 -0.050\n", + "34 112.0 -1.956 1.597 -9.178 -0.015\n", + "35 58.0 -1.844 1.484 -4.941 -0.016\n", + "36 32.0 -2.622 2.002 -6.930 -0.070\n", + "all 5054.0 -2.353 0.444 -9.178 -0.005\n", + "\n", + " - 4.66 % of the data have been deactivated by this filter\n", + " - Time used for maximum slope disabling: 0.13388848304748535 sec.\n", + "\n", + "\n", + "=============== Processing step 12 ===============\n", + " - Step name: 'Disable gates by slope min'\n", + " - Disabling slopes less than -6.0 on channel-1 after gate-7\n", + " - Slope statistics for all gates:\n", + "\n", + "Pre-disable count mean std min max\n", + "0 0.0 NaN NaN NaN NaN\n", + "1 0.0 NaN NaN NaN NaN\n", + "2 193.0 0.948 0.080 0.847 1.282\n", + "3 193.0 -2.127 0.526 -3.854 -1.289\n", + "4 193.0 -0.833 1.710 -4.485 3.197\n", + "5 193.0 -0.276 0.687 -1.338 1.671\n", + "6 193.0 -1.314 0.371 -2.003 -0.560\n", + "7 193.0 -1.549 0.359 -2.281 -0.132\n", + "8 193.0 -1.640 0.336 -2.296 -0.358\n", + "9 193.0 -1.693 0.337 -2.715 -0.746\n", + "10 193.0 -1.578 0.371 -2.242 -0.020\n", + "11 193.0 -1.755 0.285 -2.517 -0.999\n", + "12 193.0 -1.796 0.393 -3.700 -0.801\n", + "13 193.0 -1.661 0.420 -2.465 -0.051\n", + "14 193.0 -1.934 0.320 -3.673 -0.912\n", + "15 193.0 -1.971 0.323 -3.734 -0.984\n", + "16 193.0 -1.870 0.359 -2.463 -0.152\n", + "17 193.0 -2.227 0.766 -6.565 -0.387\n", + "18 191.0 -1.864 0.710 -3.046 2.122\n", + "19 190.0 -2.077 0.437 -3.370 -0.501\n", + "20 190.0 -2.187 0.715 -6.939 -0.019\n", + "21 187.0 -2.043 0.696 -3.661 2.787\n", + "22 179.0 -2.559 0.942 -6.720 2.035\n", + "23 168.0 -1.907 1.154 -4.455 3.511\n", + "24 122.0 -1.722 0.969 -5.022 0.518\n", + "25 44.0 -1.130 0.908 -3.164 0.649\n", + "26 7.0 0.147 0.547 -0.670 0.832\n", + "27 0.0 NaN NaN NaN NaN\n", + "all 4366.0 -1.621 0.569 -6.939 3.511\n", + "\n", + "Post-disable count mean std min max\n", + "0 0.0 NaN NaN NaN NaN\n", + "1 0.0 NaN NaN NaN NaN\n", + "2 193.0 0.948 0.080 0.847 1.282\n", + "3 193.0 -2.127 0.526 -3.854 -1.289\n", + "4 193.0 -0.833 1.710 -4.485 3.197\n", + "5 192.0 -0.278 0.689 -1.338 1.671\n", + "6 193.0 -1.314 0.371 -2.003 -0.560\n", + "7 193.0 -1.549 0.359 -2.281 -0.132\n", + "8 193.0 -1.640 0.336 -2.296 -0.358\n", + "9 193.0 -1.693 0.337 -2.715 -0.746\n", + "10 193.0 -1.578 0.371 -2.242 -0.020\n", + "11 193.0 -1.755 0.285 -2.517 -0.999\n", + "12 193.0 -1.796 0.393 -3.700 -0.801\n", + "13 193.0 -1.661 0.420 -2.465 -0.051\n", + "14 193.0 -1.934 0.320 -3.673 -0.912\n", + "15 193.0 -1.971 0.323 -3.734 -0.984\n", + "16 193.0 -1.870 0.359 -2.463 -0.152\n", + "17 191.0 -2.182 0.631 -5.921 -0.387\n", + "18 189.0 -1.902 0.605 -3.046 1.302\n", + "19 188.0 -2.070 0.431 -3.370 -0.501\n", + "20 187.0 -2.168 0.613 -5.583 -0.019\n", + "21 184.0 -2.081 0.591 -3.661 0.030\n", + "22 174.0 -2.508 0.839 -5.715 2.035\n", + "23 166.0 -1.962 1.044 -4.455 1.262\n", + "24 120.0 -1.683 0.920 -3.855 0.518\n", + "25 44.0 -1.130 0.908 -3.164 0.649\n", + "26 7.0 0.147 0.547 -0.670 0.832\n", + "27 0.0 NaN NaN NaN NaN\n", + "all 4344.0 -1.618 0.539 -5.921 3.197\n", + "\n", + " - 0.78 % of the data have been deactivated by this filter\n", + " - Time used for minimum slope disabling: 0.09927654266357422 sec.\n", + "\n", + "\n", + "=============== Processing step 13 ===============\n", + " - Step name: 'Disable gates by slope min'\n", + " - Disabling slopes less than -6.0 on channel-2 after gate-13\n", + " - Slope statistics for all gates:\n", + "\n", + "Pre-disable count mean std min max\n", + "0 0.0 NaN NaN NaN NaN\n", + "1 0.0 NaN NaN NaN NaN\n", + "2 0.0 NaN NaN NaN NaN\n", + "3 0.0 NaN NaN NaN NaN\n", + "4 0.0 NaN NaN NaN NaN\n", + "5 0.0 NaN NaN NaN NaN\n", + "6 0.0 NaN NaN NaN NaN\n", + "7 0.0 NaN NaN NaN NaN\n", + "8 193.0 -3.800 0.429 -5.139 -2.541\n", + "9 193.0 -2.864 0.376 -4.029 -1.991\n", + "10 193.0 -2.665 0.372 -3.718 -1.227\n", + "11 193.0 -2.587 0.322 -3.481 -1.657\n", + "12 193.0 -2.615 0.323 -3.633 -1.805\n", + "13 193.0 -2.431 0.269 -3.103 -1.531\n", + "14 193.0 -2.355 0.227 -2.879 -1.651\n", + "15 193.0 -2.368 0.282 -3.554 -1.754\n", + "16 193.0 -2.324 0.280 -3.812 -1.747\n", + "17 193.0 -2.091 0.377 -2.567 0.635\n", + "18 193.0 -2.150 0.212 -2.970 -1.507\n", + "19 193.0 -2.184 0.295 -3.704 -1.475\n", + "20 193.0 -2.113 0.185 -2.750 -1.615\n", + "21 193.0 -2.158 0.204 -2.950 -1.437\n", + "22 193.0 -2.163 0.343 -3.155 -0.530\n", + "23 193.0 -2.075 0.372 -2.809 -0.478\n", + "24 193.0 -2.498 0.612 -6.218 -1.659\n", + "25 193.0 -2.004 0.596 -2.845 1.671\n", + "26 184.0 -2.415 0.419 -4.968 -1.519\n", + "27 184.0 -2.325 0.229 -3.157 -1.706\n", + "28 184.0 -2.166 0.449 -2.876 0.424\n", + "29 184.0 -2.311 0.364 -4.297 -0.681\n", + "30 184.0 -2.389 0.793 -6.657 0.233\n", + "31 184.0 -2.080 0.851 -4.440 2.943\n", + "32 182.0 -1.981 0.865 -4.526 1.150\n", + "33 179.0 -2.018 1.290 -7.354 0.610\n", + "34 160.0 -1.357 2.070 -9.178 4.301\n", + "35 127.0 -0.835 2.199 -6.272 6.763\n", + "36 112.0 -1.733 2.778 -8.035 7.121\n", + "all 5338.0 -2.275 0.572 -9.178 7.121\n", + "\n", + "Post-disable count mean std min max\n", + "0 0.0 NaN NaN NaN NaN\n", + "1 0.0 NaN NaN NaN NaN\n", + "2 0.0 NaN NaN NaN NaN\n", + "3 0.0 NaN NaN NaN NaN\n", + "4 0.0 NaN NaN NaN NaN\n", + "5 0.0 NaN NaN NaN NaN\n", + "6 0.0 NaN NaN NaN NaN\n", + "7 0.0 NaN NaN NaN NaN\n", + "8 193.0 -3.800 0.429 -5.139 -2.541\n", + "9 193.0 -2.864 0.376 -4.029 -1.991\n", + "10 193.0 -2.665 0.372 -3.718 -1.227\n", + "11 193.0 -2.587 0.322 -3.481 -1.657\n", + "12 193.0 -2.615 0.323 -3.633 -1.805\n", + "13 193.0 -2.431 0.269 -3.103 -1.531\n", + "14 193.0 -2.355 0.227 -2.879 -1.651\n", + "15 193.0 -2.368 0.282 -3.554 -1.754\n", + "16 193.0 -2.324 0.280 -3.812 -1.747\n", + "17 193.0 -2.091 0.377 -2.567 0.635\n", + "18 193.0 -2.150 0.212 -2.970 -1.507\n", + "19 193.0 -2.184 0.295 -3.704 -1.475\n", + "20 193.0 -2.113 0.185 -2.750 -1.615\n", + "21 193.0 -2.158 0.204 -2.950 -1.437\n", + "22 193.0 -2.163 0.343 -3.155 -0.530\n", + "23 193.0 -2.075 0.372 -2.809 -0.478\n", + "24 192.0 -2.479 0.551 -4.532 -1.659\n", + "25 192.0 -2.023 0.535 -2.845 0.116\n", + "26 183.0 -2.401 0.375 -4.336 -1.519\n", + "27 183.0 -2.324 0.229 -3.157 -1.706\n", + "28 183.0 -2.180 0.407 -2.876 -0.111\n", + "29 183.0 -2.310 0.365 -4.297 -0.681\n", + "30 182.0 -2.353 0.709 -5.786 0.233\n", + "31 182.0 -2.116 0.759 -4.440 1.572\n", + "32 182.0 -1.981 0.865 -4.526 1.150\n", + "33 176.0 -1.934 1.128 -5.607 0.610\n", + "34 151.0 -1.239 1.656 -4.779 3.840\n", + "35 118.0 -0.958 1.900 -4.941 4.039\n", + "36 100.0 -1.407 2.660 -5.949 7.121\n", + "all 5295.0 -2.270 0.522 -5.949 7.121\n", + "\n", + " - 0.76 % of the data have been deactivated by this filter\n", + " - Time used for minimum slope disabling: 0.13762927055358887 sec.\n", + "\n", + "\n", + "=============== Processing step 14 ===============\n", + " - Step name: 'Disable soundings by number of active gates'\n", + " - Disabling soundings with too few timegates from channel-1\n", + " - 8.29 % of the data have been deactivated by this filter\n", + " - Time used for sounding disabling: 0.0016138553619384766 sec.\n", + "\n", + "\n", + "=============== Processing step 15 ===============\n", + " - Step name: 'Disable soundings by number of active gates'\n", + " - Disabling soundings with too few timegates from channel-2\n", + " - 0.0 % of the data have been deactivated by this filter\n", + " - Time used for sounding disabling: 0.0010657310485839844 sec.\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: [pid 1322012] Worker Worker(salt=8090251977, workers=1, host=glittertind, username=redhog, pid=1322012) done Processing(processing_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/processing)\n", + "DEBUG: 1 running tasks, waiting for next task to finish\n", + "INFO: Informed scheduler that task Processing_file____home_red_ec07bb04b5 has status DONE\n", + "DEBUG: Asking scheduler for work...\n", + "DEBUG: Done\n", + "DEBUG: There are no more tasks to run at this time\n", + "INFO: \n", + "===== Luigi Execution Summary =====\n", + "\n", + "Scheduled 2 tasks of which:\n", + "* 1 complete ones were encountered:\n", + " - 1 Import(import_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/import)\n", + "* 1 ran successfully:\n", + " - 1 Processing(processing_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/processing)\n", + "\n", + "This progress looks :) because there were no failed tasks or missing dependencies\n", + "\n", + "===== Luigi Execution Summary =====\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "processing_task = beryl_pipeline.processing.Processing(processing_name = root + \"/processing\")\n", + "\n", + "luigi.build([processing_task], local_scheduler=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "09f15845", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['processed.100101.0.geojson',\n", + " 'processed.100101.0.msgpack',\n", + " 'config.yml',\n", + " 'processed.diff.msgpack',\n", + " 'processed.xyz',\n", + " 'processed.100101.0.gex',\n", + " 'processed.100101.0.diff.msgpack',\n", + " 'processed.gex',\n", + " 'DONE',\n", + " 'processed.100101.0.xyz',\n", + " 'processed.msgpack',\n", + " 'log.yml',\n", + " 'processed.100101.0.summary.yml',\n", + " 'processed.geojson',\n", + " 'processed.summary.yml']" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "os.listdir(rootpath + \"/processing\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "f0bd3446", + "metadata": {}, + "outputs": [], + "source": [ + "with luigi.contrib.opener.OpenerTarget(root + \"/inversion/config.yml\").open(\"w\") as f:\n", + " yaml.dump({\n", + " \"system\": {\n", + " \"name\": \"Dual moment TEM\",\n", + " \"args\": {\n", + " \"directives__irls\": True\n", + " },\n", + " },\n", + " \"data\": root + \"/processing/processed.xyz\",\n", + " \"system_data\": root + \"/processing/processed.gex\",\n", + " }, f)" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "2929fbfc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG: Checking if Inversion(inversion_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/inversion) is complete\n", + "DEBUG: Checking if Processing(processing_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/processing) is complete\n", + "INFO: Informed scheduler that task Inversion_file____home_red_81d0cf8e5a has status PENDING\n", + "INFO: Informed scheduler that task Processing_file____home_red_ec07bb04b5 has status DONE\n", + "INFO: Done scheduling tasks\n", + "INFO: Running Worker with 1 processes\n", + "DEBUG: Asking scheduler for work...\n", + "DEBUG: Pending tasks: 1\n", + "INFO: [pid 1306479] Worker Worker(salt=4955174893, workers=1, host=glittertind, username=redhog, pid=1306479) running Inversion(inversion_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/inversion)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No MKL support: cannot access local variable 'MKLlib' where it is not associated with a value\n", + "Could not import PardisoSolver, only default (spLU) available\n", + "header [General] parsed\n", + "header [Channel1] parsed\n", + "header [Channel2] parsed\n", + "Monitoring already in progress.\n", + "Using default (spLU) solver\n", + "model has any nan: 0\n", + "============================ Inexact Gauss Newton ============================\n", + " # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n", + "-----------------------------------------------------------------------------\n", + "x0 has any nan: 0\n", + " 0 1.07e+02 7.07e+06 0.00e+00 7.07e+06 2.94e+05 0 \n", + "\n", + " Default solver: SolverDiag is being used in bfgsH0\n", + " \n", + " 1 5.33e+01 1.28e+06 4.42e+02 1.31e+06 4.72e+04 0 \n", + " 2 2.66e+01 2.05e+05 1.10e+03 2.34e+05 8.16e+03 0 Skip BFGS \n", + " 3 1.33e+01 3.94e+04 2.16e+03 6.82e+04 3.56e+03 0 Skip BFGS \n", + " 4 6.66e+00 6.34e+03 9.79e+02 1.29e+04 1.82e+03 0 Skip BFGS \n", + " 5 3.33e+00 3.95e+03 1.51e+02 4.45e+03 3.91e+02 0 \n", + " 6 1.66e+00 2.15e+03 4.60e+02 2.91e+03 3.33e+02 0 Skip BFGS \n", + "------------------------- STOP! -------------------------\n", + "1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 7.0670e+05\n", + "1 : |xc-x_last| = 1.3886e+01 <= tolX*(1+|x0|) = 3.5142e+01\n", + "0 : |proj(x-g)-x| = 3.3339e+02 <= tolG = 1.0000e-01\n", + "0 : |proj(x-g)-x| = 3.3339e+02 <= 1e3*eps = 1.0000e-02\n", + "0 : maxIter = 40 <= iter = 7\n", + "------------------------- DONE! -------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/redhog/Projects/Emerald/simpeg/SimPEG/electromagnetics/utils/static_instrument/base.py:510: RuntimeWarning: divide by zero encountered in divide\n", + " std = np.abs(1 / self.inv.invProb.dmisfit.W.diagonal() / self.inv.invProb.dmisfit.data.dobs)\n", + "/home/redhog/Projects/Emerald/simpeg/SimPEG/electromagnetics/utils/static_instrument/base.py:510: RuntimeWarning: divide by zero encountered in divide\n", + " std = np.abs(1 / self.inv.invProb.dmisfit.W.diagonal() / self.inv.invProb.dmisfit.data.dobs)\n", + "/home/redhog/Projects/Emerald/simpeg/SimPEG/electromagnetics/utils/static_instrument/base.py:526: RuntimeWarning: invalid value encountered in divide\n", + " xyzresp.flightlines['resdata'] = np.sqrt(np.nansum(derrall**2, axis=1) / (derrall > 0).sum(axis=1))\n", + "INFO: [pid 1306479] Worker Worker(salt=4955174893, workers=1, host=glittertind, username=redhog, pid=1306479) done Inversion(inversion_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/inversion)\n", + "DEBUG: 1 running tasks, waiting for next task to finish\n", + "INFO: Informed scheduler that task Inversion_file____home_red_81d0cf8e5a has status DONE\n", + "DEBUG: Asking scheduler for work...\n", + "DEBUG: Done\n", + "DEBUG: There are no more tasks to run at this time\n", + "INFO: \n", + "===== Luigi Execution Summary =====\n", + "\n", + "Scheduled 2 tasks of which:\n", + "* 1 complete ones were encountered:\n", + " - 1 Processing(processing_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/processing)\n", + "* 1 ran successfully:\n", + " - 1 Inversion(inversion_name=file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/inversion)\n", + "\n", + "This progress looks :) because there were no failed tasks or missing dependencies\n", + "\n", + "===== Luigi Execution Summary =====\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "inversion_task = beryl_pipeline.inversion.Inversion(inversion_name = root + \"/inversion\")\n", + "\n", + "luigi.build([inversion_task], local_scheduler=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "eff50959-642c-42d1-b654-27d3926f9f95", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['processed.100101.0.geojson',\n", + " 'processed.100101.0.msgpack',\n", + " 'smooth_model.summary.yml',\n", + " 'smooth_model.msgpack',\n", + " 'smooth_synthetic.100101.0.msgpack',\n", + " 'config.yml',\n", + " 'monitor_info.csv',\n", + " 'smooth_model.100101.0.xyz',\n", + " 'smooth_synthetic.geojson',\n", + " 'processed.xyz',\n", + " 'smooth_model.geojson',\n", + " 'DONE',\n", + " 'smooth_model.100101.0.msgpack',\n", + " 'smooth_synthetic.summary.yml',\n", + " 'processed.100101.0.xyz',\n", + " 'processed.msgpack',\n", + " 'log.yml',\n", + " 'smooth_synthetic.100101.0.summary.yml',\n", + " 'smooth_model.100101.0.summary.yml',\n", + " 'smooth_synthetic.xyz',\n", + " 'processed.100101.0.summary.yml',\n", + " 'smooth_model.xyz',\n", + " 'processed.geojson',\n", + " 'smooth_synthetic.100101.0.xyz',\n", + " 'smooth_synthetic.msgpack',\n", + " 'smooth_model.100101.0.geojson',\n", + " 'smooth_synthetic.100101.0.geojson',\n", + " 'processed.summary.yml']" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "os.listdir(rootpath + \"/inversion\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dd3b2b32-ee84-4448-9cfe-8b1695d3db7c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65ca1c17-1a7a-4f03-ac98-06bfede4501e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b5bee5d6-4032-4f36-b7a2-5ab3423ce2a2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "5cb5f8e6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "libaarhusxyz.XYZ(rootpath + \"/inversion/processed.xyz\", normalize=True).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "3eff26ac", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAGwCAYAAABfKeoBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydZXwUV9uHr1mN7W7cjQguwd29UKBFKlShrlB/HurupUILpS5QvFjxEtxd4+6e7GZ95v2wNDQPAYLTt3P9fvmye+bMmcnszH/uc5//LUiSJCEjIyMjIyMjI3NeFNd6ADIyMjIyMjIy/xRk4SQjIyMjIyMj00hk4SQjIyMjIyMj00hk4SQjIyMjIyMj00hk4SQjIyMjIyMj00hk4SQjIyMjIyMj00hk4SQjIyMjIyMj00hU13oA/1REUSQ/Px+dTocgCNd6ODIyMjIyMjKNQJIkampqCA0NRaG48PiRLJwukvz8fCIiIq71MGRkZGRkZGQugpycHMLDwy94O1k4XSQ6nQ5wnXi9Xn+NRyMjIyMjIyPTGKqrq4mIiKh7jl8osnC6SP6antPr9bJwkpGRkZGR+YdxsWk2cnK4jIyMjIyMjEwjkYXTBTJjxgxatmxJ586dr/VQZGRkZGRkZK4ygiRJ0rUexD+R6upqDAYDVVVV8lSdjIyMjIzMP4RLfX7LEScZGRkZGRkZmUYiCycZGRkZGRkZmUYiCycZGRkZGRkZmUYiCycZGRkZGRkZmUYiCycZGRkZGRkZmUYiCycZGRkZGRkZmUYiC6cLRPZxkpGRkZGR+fci+zhdJLKPk4yMjIyMzD8P2cdJRkZGRkZGRuYqIQsnGRmZOkx2E3IQWkZGRubsyMJJRkYGSZL4bP9ndJ/TnYl/TCQxJ1EWUDIyMjINIAsnGZl/OXbRzovbXmT2kdlISBwpPcLjfz7OW7veutZDk5GRkbnukIWTjMy/GEmSeGXbKyxLW4ZSUPJClxe4t/W9ACxIXkBmVea1HaCMjIzMdYYsnGRk/sXMS5rH8vTlKAUln/T7hIktJvJUx6foF94PURKZfWT2tR6ijIyMzHXFv1Y4JSUlkZCQUPfn7u7O77//fq2HJSNz1ThUcoj39rwHwNSOU+kf2b/uuwfbPQjAyvSV5NTkXJPxycjIyFyP/GuFU7NmzTh48CAHDx5k69ateHp6Mnjw4Gs9LBmZq0K5pZynE5/GIToYHDWYu1reVe/71v6t6RnWE6fk5Jsj31yjUcrIyMhcf/xrhdPfWbZsGQMHDsTT0/NaD0XmH0CpuZRae+21HsZF4xSdPL/5eYpqi4jWR/N6j9cRBOGMdg+1fQiAJSlL2J6//WoPU0ZGRua65LoVTps3b+bGG28kNDQUQRAanEabMWMG0dHRuLm50bVrV3bv3n1R+5o/fz633HLLJY5Y5v8zkiSxI38H96+9n/7z+9N1TlcGzB/AM5ueYX3WeqxO67UeYqOZcXAGOwt24q5y55N+n+Cl8WqwXUJgAuObjkdC4j9b/kOpufQqj1RGRkbm+uO6FU4mk4l27doxY8aMBr+fN28eTz31FK+88gr79++nXbt2DB06lOLi4ro2CQkJtG7d+oy//Pz8ujbV1dVs376dG2644Yofk8w/E5vTxn+3/pcH1j3AzoKddZ+XmEtYk7mGqYlTGbdsHLk1uddwlI3jYPHBuoTvV7u/SpxP3DnbP9f5OeJ94im3lPPspmeptFRehVHKyMjIXL/8I2rVCYLAkiVLGDNmTN1nXbt2pXPnznzxxRcAiKJIREQEjz/+OC+88EKj+/75559Zs2YNv/zyyznbWa1WrNbTUYXq6moiIiLkWnX/z6m2VTNl4xT2FO5BJaiY0GwCd7W6Cy+1F+lV6WzM3siytGWUWcrwd/dn5qCZNPNtdq2H3SAO0cFtK2/jZPlJxsSN4Y2ebzRqu/TKdG5deStmhxlfN1+e6fQMAyIH4KmWp7ZlZGT+efwra9XZbDb27dvHoEGD6j5TKBQMGjSIHTt2XFBfjZ2me+eddzAYDHV/ERERFzxumX8WSeVJ3LbiNvYU7sFT7cmMgTP4T9f/EOYVhkFroH1ge57q9BTzb5xPvE88peZS7ll9D1vztl7roTfI/KT5nCw/iV6jZ2rHqY3eLsY7hu+GfkecdxzllnL+u/W/9Jjbg/HLx/Pxvo/ZW7gXs8N8BUcuIyMjc/3wj4w45efnExYWxvbt2+nevXtdu+eee45Nmzaxa9euRvVbVVVF06ZNycnJQaPRnLOtHHH691BgLGBlxkq+OvgVNtFGsGcwXwz44pyRpGpbNU/8+QT7ivahEBRM6TCFO1regVqhvoojPztl5jJuXHIjNfYaXuz6Irc0v/CcPrvTzrdHv2VJyhLyTflnfK/T6PDR+qBRatBpdHQK6kSf8D60DWiLQvhHvqPJyMj8P+RSI06qKzCmfwwGg4GioqJGtdVqtWi1WmbMmMGMGTNwOp1XeHQyVwNJkthbtJflacspMBVQXFtMelV63fd9w/vyVq+3MGgN5+xHr9Eze/Bs3tz1JotTFvPxvo9ZkLyAO1veSZx3HF5qL/JN+ZSZy3CIDnQaHYOjBuOmcrvShwjAJ/s+ocZeQwvfFoxrOu6i+lAr1TzU7iEeavcQxbXF7C3cy5a8LWzL20aFtYIaWw01tpq69geKDzD7yGy6Bndlev/pZ01Cl5GRkfkn8Y+MONlsNjw8PFi4cGG9vKe7776byspKli5desXHdKmKVebasyV3CzMOzuBY2bF6nwsIdAjqwKjYUYyJG3NB0RJJkliQvIAZB2dQbik/Z9u2/m35fODn+Lr5XtT4G8vB4oPcuepOAH654RfaBbS7rP1LkoTRbqSktoQqWxVWp5VCUyFb87ayOXczZoeZFr4t+GrQV/i5+13WfcvIyMhcKP/KiJNGo6Fjx45s2LChTjiJosiGDRt47LHHrui+5YhTfUpqS9hfvJ+jpUfJM+ZRVFuE1WHFKTlp7d+aZzo9c95ozdWmpLaE9/a8x5rMNQBolVpujL2RDoEd8HPzo6lvU/zd/S+qb0EQmNBsAiNjRvJb0m9sz99OgbEAo91IiGcIgR6BqBVqdhbs5HDpYe744w4+7f8p8T7xl/MQ63CKzrpivTfH33zZRRO4jlmn0aHT6Op9PiZuDMfLjvPw+oc5UX6Cu1ffzYyBM4jSR13yPkVJ5FDJIdIq08g35tPKvxX9I/pf0SnBKmsVqzNWc7z8OKmVqVgcFkRJpJlvM4ZGDaVnWE80ynNP+V8Jamw1JJUnYXPacEgO4r3jCfEKuerjkJH5t3DdRpyMRiOpqakAtG/fno8//pj+/fvj6+tLZGQk8+bN4+6772bWrFl06dKF6dOnM3/+fE6ePElQUNAVH9+/OeJkdphZk7mGhckLOVRy6Jxtw7zC+Ljfx7T0a3mVRnduCk2F3LLiFsot5SgEBRNbTOS+Nvdd8ajP/5Jelc4j6x8hz5iHWqHm4XYPc0/rey57TtScE3N4Z/c76DQ6Vty04qofJ0BmVSYPrnuQfFM+eo2ej/p9RLeQbhfdX6GpkGlbp7G7sL5vW3Pf5kztMJUeYT0udchnsD1/Oy9tfYlic/FZ2xi0BkbFjmJkzEia+za/oiJOkiQWpixkedpyDpccxinVf5FrH9ieEU1GcEPMDWcIWhmZfzuX+vy+boVTYmIi/fv3P+Pzu+++mx9++AGAL774gg8++IDCwkISEhL47LPP6Nq161UZ379ROEmSxNqstby/+/26B4iAQDPfZrQLaEe0Pppgz2A8VB6YHWY+2PsBecY8VIKKkbEjmdR6Ek0MTa7Z+B2ig8lrJrO/eD8xhhje7f0uLfxaXLPxlJpLeXX7q2zK3QRAtD6ax9o/Rq+wXpjsJkpqS8iozqDSUkmkPpJY71jCvMIa3f+hkkNMWj0Jm2hjWtdp3Nr81it1KOel1FzKkxuf5HDJYZSCkhe6vHBR49mcu5n/bPkP1bZq3FXudAhyRQnXZ62n1uFyc7+l2S083elp3FXulzxus8PM9H3TmXNyDgBR+iiGRA2hmW8zdBodDtHBjvwdrM1cW09UGbQGuoV0Y2TMSHqG9bysgtghOnhz55ssSllU91moZyg6jQ4RkdSKVCRct3V3lTvDoocxruk42vi3adAhXkbm38b/W+F0vfL3qbrk5OR/jXCqtlXz/Obn65bah3qGMr7ZeMbEjTnrtFaVtYpXt7/K+uz1dZ9F6iJp5d+KYM9gvLXexHnH0SmoEx5qjyt+DJ8f+JyvD3+Np9qT+SPnE6mPvOL7PB+SJLEifQXv73mfSmvledsPix7GGz3fOG9SeZ4xj9tX3k65pZx+4f2Y3n86SoXyMo364rA6rby2/TWWpy8HXALn+S7PN1pU5NTkMHbZWMwOM639WvNun3frpv0qLBXMPDSzTuCEeYVxc/zN3NDkBsJ14fX6kSSJpIok8o35+Lr54ufuR4hnCCqFql6bQyWHeHn7y2RUZQBwW/PbmNpxaoOCzCk62Za/jcUpi9mRv6NOxAH4uflxd6u7uaXZLZd8nZsdZp7d9CybcjehEBQ80u4RRsSMqHeMRaYiVmeuZknKEtKq0uo+b+bTjLFNxzIsehg+bj6XNA6Za4NTdFJlq6LSUolSoSRSFymL4YtAFk7XiP8PESdJkqi0VmIX7QgIeGu9USvPfIiVmkt5aN1DJFUkoVFouK/NfUxqMwmtUtuo/RwqOcQ3h78hMTexwe/VCjWdgzszLHoYA6MGotdc3vMpSRJzT87l3d3vIiHxfp/3Gd5k+GXdx6VitBn56fhP/HT8J0x2EwpBgY/Wh2hDNL5uvmRVZ5FWmYZTcpIQkMBnAz4768OvxlbDXavuIrUylea+zflx2I9XRZg2BkmS+O7od3y6/1MkJLoGd+Wjfh+dNw/OKTqZtGYS+4v30zGoI7OHzG5QcG3P386LW1+kxFxS91mUPopOQZ1QCkoqrBUcLD5Y73sAlUJFhC6CQI9A9Bo9R0qPUGgqBCDAPYA3er5Bz7CejTpGu2jnWOkx1matZWX6yrpFAr5uvkxqPYkJzSZcVDTMITqYsnEKm3I3oVVqea/PewyMHHjW9pIkcbDkIAuSFrAmcw020eY6VkFF7/DePN7+8SuWWyfTeMrMZewr2seJ8hMICKgVatRKNWqFGlESqbBWUFpbSmplKmmVaXX/R3Ct5k0ITGBS60l0DOp4DY/in4UsnK4R/zThVG4pJ60yjZSKFNIq00itTCW1MpVqW3VdG5WgIsY7hua+zWnm04wQrxCSypNYkb6CPGMefm5+zBw8k+a+zS9qDFXWKo6VHuN4+XHKzGVUWCs4UHSgnieQWqFmTNwYJrWedEak4GIori3m5W0vsy1/G+CKcrzY7cVL7vdKYRftOEQHbkq3M94k9xTu4cmNT1JjqyFSF8lXg746I2rmEB08tuExtuVvI9A9kF9H/EqwZ/DVPIRGsTF7I89veR6zw0ykLpLPB35OjCHmrO1/OPoDH+37CA+VB4tGLTrntWGym1iXtY4V6SvYU7gHURLPaOOucqeJoQlV1ipKakvqPYz+QqPQMCR6CM93fh5vN++LOk67aGdl+kpmHppJnjEPcEWgJraYyJi4MQR4BDSqH0mSeG3HayxKWYRWqWXmoJl0Cu7U6HFUWatYnracZWnLOFF+AnCJxcmtJ/NA2weuSVL7v52k8iTe2/Meewr3XPC2eo0eq9Nar0bmLc1uYUqHKQ3afvz1mP+nRafSKtMw2U20DWh7WfuVhdNV5p82Vbc1byuf7PuE5Irks7ZRCkpESazLi2iIMK8wZg+eTYT+8jqmS5JERnUGG7I28EfGH6RWptaN6b429/FowqMX/WNfnbmaN3a8QbWtGq1Sy9SOU7mt+W3/aDPGtMo0Hln/CPmmfLy13nw+4HMSAhMA17l8e9fb/Jb0G+4qd74f9j2t/Fpd2wGfg6TyJJ748wnyTfm4q9x5ssOTZ/x/JEnip+M/MX3fdBySg1e7v8rYpmMbvY9qWzX7CvdxuPQwaoUag9ZAE0MTOgV1qhMLoiRSaCokqzqLUnMpFZYKV5vgTpclTwpcAmp52nK+Pvx1nYBSCkpuaHID/+n6n3MmcEuSxPT90/nu6HcoBAUf9/v4nJGm85FakcpnBz5jY85GADoEduCbod9cN2at/98pMBbw84mfmXNiTl1Sf7xPPAkBCWiUGuxOOzbRVm8mwM/djyaGJjT1bkqIl2ta2S7aSS5PZl7SPJakLgFcLwS9wnrRKcglqqtsVewv2s/B4oOolWpiDbF1EarrebpWlER+Pv4zn+3/DH93fxaNWnRZfeBk4XSNuN4jTjk1Oby96+26nCQBgTCvMOK844j1jiXWO5Z4n3ii9dG4qdyQJImi2iJOlp/kZPlJksqTyDflE+cdR1v/tgxrMuyq2ArsK9rH7MOz6yJEN8XdxMvdX66Xf3I+7KKdV7e/yrK0ZQC09GvJO73eIcb77BGNfxKl5lIe2/AYx8qOISDQJaQL7QLasSFrA2lVaQgIfNL/k0t6uF4tyi3lPLPpmbq37nYB7Xiyw5N0Du5MSkUKnx34jMScRABGxY7izZ5v/uPemv+O3WlnVeYqFiYv5EDxAcCV9/dxv48bdKb/30Twl7q9xIRmEy55HJIksT57PS9vexmj3cjk1pOZ0nHKJfcrc3Y2ZG/gl+O/sLdob91ng6MG80ynZwj1Cr2kvnfk7+DtXW+TWZ3ZqPbeWm+e6vgUY+LGXHe/p5yaHF7a9hL7ivYB0CusF2/2fPOyesDJwukacb0KJ6fo5NcTv/LFwS8wO8yoFCpub347D7R94LrzUzoXi1MW89qO1xAlkf4R/fmo70cN5l/9L3annac3Pc3GnI0oBAX3t7mfB9s9+P/ubbrWXsvL21+u86L6CzelG093evqarqC7UERJZEHSAj7e93FdUnWYV1hdZEatUPN85+eZ0GzCdXeTvxQOFh/kuc3PUWAqQK1QMyJmBBNbTCTOOw4Bge352/nh2A/sLtyNQlDwYrcXGd90/GUdw9rMtTy96WkAZg6a2eg8LpnGU2ou5a2db9UtkhEQ6BTcicmtJ1/W8y1JEsfLj7Mucx0ZVRmoFCrcVG609m9Np6BOSEgkVyTz3dHvSKlIAeCGJjfwZs83G3VvvdL8ZbHxwZ4PMDvMeKg8eLbzs4yNH3vZf/eycLrKXM9TdZIk8eqOV1mcshiAzsGdebnby0Qboq/twC6SjdkbeXbzs1idVoZEDeG9Pu+dM/JkcVh4ZtMzbMrdhEahYXr/6fQO730VR3z1ya3JZWX6SpIqkugR2oOh0UP/sb49haZCvjnyDYtTFmMX7SgFJQMiB/BA2wcuOq/ueqfSUsm0bdPYnLu53uduSjcsTgvgyrV6v+/7VyyC+MaON5ifPB9fN1++HfItcT5xV2Q//0YOFB/g8T8fp8pahUpQcVeru7it+W3XNO/QLtr55fgvfLb/MxySgx6hPfi438d4qj2v2ZgOFh9k+v7pdVGmDoEdeLPXm0ToLm9qyF/IwukacT1GnOYnzeeNnW+gEBRM6zqN8U3H/+Pf0LflbePxPx/HLtoZFTuKF7u92GDeSb4xnykbp3Ci/ARapZbPBnxGj9DLb4Qoc+UpMhVxsOQg7QPbE+gReK2Hc1U4WHyQn4//zJ/Zf+KQHIDLC2pkzEgmNJtwzsT5S8XisHDHH3eQVJGEl9qL9/u8///+heNqsDl3M08nPo3FaaG5b3Pe6PnGdfUCsDVvK08lPoXZYSbOO44P+35IrHfsFdmXJEkcKzvGsrRlbMvbhk6jI1wXjs1po9BUWLdgQaPQ8ESHJ7ijxR1X1D5FFk7XiOtNOB0oPsCkNZNwiA6mdpzKpNaTrvWQLhsbsjfwdOLTOCUnHioPBkUNoltIN2K9Y7E5bewp3MPPx3+mwlqBj9aHj/t9fEErjmRkrhf+8umpslYR6hXaaMuPS6XCUsFTiU+xt2gvCkHBy91evqAkfJn6JOYkMnXjVBySg15hvfi438eXbaHB5eRIyREe+/Mxyi3luCndeKbTM4xrOu6yipaS2hJe2v4S2/K2nbWNQlBwU9xNPNTuoasSjZOF0zXiehFOVqeV7458xzdHvsEm2hgSNYQP+374j480/S/rs9bz4d4P6/JeGqKlX0um95su1+mSkbkI7E47b+56k8UpixEQ+KjfRwyOGnyth/WPI6c6hwkrJmC0GxkePZy3er11XeQQnY1ScynTtk5je/52AJoYmvBowqMMihx0yQJqc+5mXtz6IhXWCjQKDYOiBjG8yXCckpO8mjy0Si0BHgE0921+yQnyF4IsnK4RV0M4OUUnqZWpZFZnUmGpIMQzhBCvEByig3JLOdvytrE2ay3Fta5SDz1Ce/BJv0+uG7PDy40kSRwoPsDarLWcLD9JWqVrBVnHoI50C+nG6LjR53XUljk7lpw8kr5egm+/XgT3boNac22dxmWuPpIk8cbON1iQvAC1Qs2Xg768pLqC/zasTit3/nEnJ8pP0D6wPd8O/fYfsTBFlETmnJjDV4e+qvP2C3APYETMCCY0nXBRNjSpFamMXz4eh+SgmU8z3uvz3hWbCrxQZOF0lblayeE1thoeWv8Qh0sOn7dtoHsgz3Z5lqFRQ//fRZpkrg7VRdUs+88KqjSuMLkgQMLgSLrfFCtfU/8ynKKTZzc/y7qsdSgEBTc0uYEH2j5AtD66wWtBkiSOlB5hQ/YGimuLqbZV46X2YnzT8XQM6vivun7e3Pkm85Lm4aP1Yf6N869L89lzUWOr4efjPzPn5ByqrFWAyxvqpW4vcWPsjY3uR5Ik7l93P7sKdtErrBef9v/0ujJZlYXTNeJKRpxMdhMPrHuAwyWHcVe5E+8Tj6+bL4WmQgpNhWgUGjw1nrT1b8uAyAH0CO0hR1pkLprC9CpWfLgTi1OFwlaAEnccWpc5Xq8J8bQbcGVWtshcv1idVl7a9hKrMlbVfeaucifEM4RQr1DCvMJQCkpKzCWcLD9JTk1Og/208mvFy91fpqVfy6s19GvGvqJ93LP6HuCfb+1gd9rZnLeZn4//XLfS7eb4m5naYWqjXPQ3ZG1gSuIUNAoNS8csvSxVIC4nsnC6Rlwp4VRrr+Xh9Q+zv3g/eo2e74Z+16AxnozM5aC6zMz817ZjtQkIlSsxS0moAE+rJ+aAW1CqvBnxWDuiWl0+8zmZfw7Hyo7x5cEv2ZK75ZyVBdxV7vSL6Ecrv1boNDqOlh5lWdoyrE4rYV5hLBm95LpMjr5c2J12JqyYQGplKmPjx/Jqj1ev9ZAuC07RydeHv+arQ18hIeGl9uKulndxZ8s7z+rkbXVaGf37aPKMedzf5n6e6PDEVR71+ZGF0zXiSgmnk+UnuXf1vQB8M+QbWvlfvyUzZP7ZOGxOFr65g7JiG6qqTRjFffW+V0seKHweROuuYuzznfANuXY+LzLXFqvTSqGpkHxjPvnGfPKMeUhI+Lv7E+IZQreQbmfkVpaZy7h15a0UmgqZ1HoSUztOvUajv/J8e+Rbpu+fjo/Wh+U3Lf9HmQ03hj2Fe3h/z/ucLD8JuJzHJ7WexK3Nb60niKusVTy76Vl2FOwg0COQ5WOWX5c5t7JwukZcyam6o6VHcYiOuhpkMjKXG0mSWP/NEZL3lSKYk7FYViAB3cbeSmTLNix+9T84lAoCY26juiIEvb8b41/ojJvX9Z/oerVwVlZS/Ml0bBkZiEYj6ogIdAP649W/P8rrwKLkeiAxJ5HH/3wclaBi3o3zaOrT9FoP6bJTXFvMiMUjsDgtvNXrLUbFjrrWQ7oiiJLI2qy1zDgwo660i06jY1j0MDoGdaTaVs1Px34i15iLu8qd6f2m0yPs+vTSk4XTVeZ6dg6XkWksxzdns3FOKjircFZ+h10h0ax7b0Y8+RyCIPD7TSNJ00BoWDQOj9upLrXgH+FFq95hBEbpMFZYqa2yEhCpJzBKh6D49yQAAzjKysieNBlrUtIZ3yk8PfG7/z5877oLhcf197Z9tZm6cSrrs9fTNqAtPw//+R9dZLshZh6ayYyDM2gb0JZfhv/y/z4Z3iE6WJm+kpmHZpJrzD3j+zCvMD7t/+l1nWIiC6drxPXi4yRz9ZEkCclmQ6ypwVlTg2g0oYmOQqn7Z5Q6KT2Zx8JPjuJAgaJ0FmaVhYDIaG5780PUWtcig5OPPcbK4gwQBEY/9wEbfy7GZnE22J+7Tk1kKz+iWvsR0cIXN8//31Epe2Eh2ZPvw5aWhjLAn6BnnkGh02M+cpiaNWuxpacDoA4NJerXX1CH/Lt9xYpMRYxeOhqT3XTZihRfLzhFJ8MWD6PQVMg7vd9hZMzIaz2kq4Yoiewp3MPytOXkGfPw1noTrgtnUutJ+Lj5XOvhnRNZOF0jZOH070Oy28n75ldOrjiIsqYML2MenrWFCEgo9HqCX5yG/sYbr+s3TmthMfNeWE+NWzCKyt+pldLRengy8Z1P0Gl8qd6QjTZKj2n3EtYun0eRtxdtBgyh29j7Sd5TRNaRMqpKatH5uuHmqaYwveoMQeXprcU/wov4TkHEdghApf7/4wdlPniQnMcfx1lSiio4mKgfvkcTHV33vSSKVP+xiuKPP8KRX4Bbq1ZE/foLCrcrt+rVUVFBzfr1OEtLcVbX4NW/H55dulyx/V0Mv574lXd3v4tOrWPpmKUEeARc6yFdFjbnbubRDY/irfVm/fj1V83pXebSkIXTNUIWTv8uKg4ns+WDVeS6N0f6m6Gdu6WMqJKtBGVsRCna0d9wA6EffoCguP6mIySbjS33vcMRj95I5j1YLVsAGP3Mi8QmdKZ4xiHshSYABLVE0Z5v2WgoQ6lScc/HM/EOOtOTxukQKUirIutoGVlHSqkorK33vdZTRfcxsbTqHXblD/AKU7NxI3lPTkGy2dA2bUr4l1+iCW/4uGy5eWSOG4ezshL9jTcS+v57V0RQmw8fJveJJ3EUFp7+UKEg5I3X8R57/ZRMcYpOJv4xkWNlxxgWPYwP+n5wrYd0WXh8w+Mk5iZyV8u7eLbzs1d8f5IkYU1Owbh5E46iYjQR4Whi4/Ds0f26vOdcr8jC6RohC6d/DxVpBfz+1jZqNb4A+OkdqHy8KSusxWEVAdC7WWm36TXU5ioCn3sOv0n3XsshN0jey6+xOqsFJpURu+l3kER6TriDbmNvpWJJCqZdhSg8VQgaJc4KK6KlmsS0Tynx0NCse29GTnn+vPuwmh1UFJjIOVHO8W35GMutAAy9vzVxHf+5BXsdJSWkj7wRZ1UVXgMHEvb+eyg8z73K0LRzF9mTJ4PTSdj06eiHDb2sY6pc8juFL7+MZLejjozEs2sXHCWlGBMTAa676/BE2QluXXkroiTy5cAv//GFhAtNhQxdNBRRElk6ZukVLcQsms1ULlpM+U8/Yc/OPuN73dChhH38EYLy/09090pyqc9vWaLKyJyDirwqlry3m1qNL262chJ6VeIWsBsvw3YS+peTMNAdN52aaouWE0New6lQU/LJJ1hOnrzWQ69HxW/zOLk5C7PWDbtpBUgiLXv3p+vNt1B7pATTrkIQwPfW5gQ/3QmFlxqFm552thAQBJJ2bCE/+fzHpHVXERxjoPOIJtz5Zg/a9HMZ363/4TiF6VVX+jCvCJIkUfDyKzirqtC2bEH49E/OK5oAPLt1xe/++wAo//77yzomW24eBdOmIdnteA0aSJPFiwh54w3Cv/oS38muAt/F779P9erVl3W/l0ILvxbc0eIOAN7a9RZmh/kaj+jS+OX4L4iSSKegTldMNEl2O+U//UzqgIEUvfkm9uxsBK0Wz7598J00Cd3QoQhqNTVr1lD42uvIcZCrgyycZGTOQt7hPBa+sQ2zQofadBi7aik7l39H2t6dHNu0nq1zv2PnwrfAPgeBJEqr1CT1eQ6nQyLvmWdwVlZe60MAoHbfPvLffofMqGE4zNtBshEcG8/gB59ANNqpXJIKgK5vBG7xPggqBZ6dXNNyhtBuNI1rAUDij7OxWyyN3q9CIdBrQjzRbf1x2kVWfnmY0lzj5T/AK0zV4iUYN24EtZrQd95FUDc++d33jjsQ1GrMhw5Re+DAZRtT5W9zQRTx6NqV8M8+Q+nlMiMUBIGgZ5+tE0+Fr76Gvbj4su33Unk04VGCPYPJM+Yx69Csaz2ciyatMo1fT/wKwKTWk67IPkw7d5F+000Uvf02zooK1OHhBL38Ek13bCdy1iyCnnuW8E+nE/rBB6BQUDl/PoWvvIqzpuaMviRRlEXVZUSeqrtI5Km6M5FEiZKcGvKSKylMr8IQ4E73MbHX7VL1jEMlnNxZiKnSisVkJzjGQLNuwahEG1mJxzhw0ImoUKGp3ouRbYhOJ+46PW0HDUehVFKUkUrWof04HQ4ANLrhKFQt8DWm0/rADDxjIoj49hvUgaenqCRJIi+pgqLMaqJa++EffmVX4tkLC8kYN54cVTzH44dhq/4ZkLj19Q8Ibdqcsp9PYDlehjrUk8Bb9Qi7v4SILjiCh1L4yVEkSUT0PcTvxzbhsFrxCQ1n2MNT0PsH4LDZqCwupLKwAIfNiiAosNaaqCouxGKswT8iiuD4ZoQ3b8eKGccpzqxG66li1BMJBEZdnt+MJErkp1aicVfhH+512fOIKhcvoeDll8HhIGDqVPwffOCC+8ifNo2qRYvRDRtG+PRPLnlMosVCat9+OKuqCP9yBroBA85oI9lsZNx6K9bjJ/Dq25fwmV9dN4sWNmZv5ImNT/xjvZ0kSeK+tfexu3A3/SP689mAzy5r/06jieIPP6Dyt3kAKL29CZgyBe9xYxFUqga3qZg/n8KXX3G19/HBZ+JEVIEBSA4Hpu3bqd2+A7G2FsHdHXVICN4TxuM9dux1vxK4fM4c3Fu2xD0h4bL2K+c4XWVkH6czqS41c2BdNhkHSzBV2ep9121MDB2HRV+bgZ0Fu9XJ1vnJHN9WcN62XjXbqJD24XQ6iO3UlRFPPodac3rljMVkZOtvP3No7UoEhRI3w01IROJlKaL5sR/w1dnxueVWdDcMJ7tIw75VmZTlmeq2D433pm3/cJq080ehrB8ANlVZ2b0ig9yTFeh8tfiGeJEwOAK9X+NKV4hWK1kT78B89Bi7e71OhWUzoj2d+C49GPX0fzEdKKZiXhIoBYLGKVGvvQ3MFa6N3Qzk13yM6AwC23G4vycrP/sAY3lZo/b9dwKimjD62ddZ910aRRnVaNyUjJrSnqDoS/vdlGTXsGluEkUZrmruPsEetO4bRpu+4Zcs1kWLhdJZsyj7aiYA+hEjCH3v3bM+uM6FJSmZjNGjQaEgdu3asyaUN5bKhQspePEl1GFhxK5dc9a8FmtKChljxyHZbAS/+io+t95ySfu9nEzZOIUN2Rto49+GH4f/iFrxz7GwWJWxiuc2P4dWqWXpmKWEeV2+hQ+W48fJffwJ7Hl5AHjfeguBU6eiNJzfidy4eTNF775XZ4dxPhQeHvg//ji+d991XSaW16xfT+7jTyCo1cQsW1pv9eqlIguna4QccQKH3cmBtdnsW52F0+5KklZrlYQ19cZDr+H4tgIEAW58PIGIlr7XeLQu7FYnC9/bS3m+CQRo2zcM74pkjKtWUEgoxQEdEJDQ24vReGWTVXkI0ekktlNXbpz6AkrVmTd4SRT544uPOLltEyqtG+4+t2C3+oEkEViyD621ikpDHDX6KABUaoHgWG/ykysRRdfPz8tHS2zHQCKa+2K3OslPruDEjgIcNrHevnyCPZgwrfN5l/hLkkTBf/5L1e+/UxbZjQMR/bAZFyAoFNzz0VfoVD4UzziIZHWi72hDf/I2zE7Y6zmYGHIIMx2ivHwgtR5TkexGwt8dgtlsZP03M0jdvRMEUKrV6P0C8A4JRevugSRJqLVaDIHBaDw8KMlMJ3XPTsw11YTENWPUM6+y7rsU8lMqcdepGftcRwwBF2cQeXRzHpvnJiFJoNIqkZwSTofrXEW29GXQvS1x1114NXbJ4aBi3jzKZn2N49QUl9/99xMwdcolPVyyJ03GtH07fvffR+DTT190P5IkkXHTzVhPniTw2Wfxm3zuaaKy776n+P33EbRaouf9hlvz5he978tJoamQm5fdTI2thsmtJzOl45RrPaRG4RSd3Pj7jeTU5PBowqM81O6hy9Z31cqVFEx7EcliQR0WRshbb+LZrdsF9SHZ7VQuXkLtnj2IJhOSw4F7+wS8evdBHRKMaDZj2rGDip9/xprimqL36NSJkHfeRhNxZYp5O41Gqv/4A1taOl79++HRpct5f0uW48fJnHgHktmMz+23Efzyy5d1TLJwukb824WT3epkxReHyE+pBCCsmQ/tB0cS3swHpdr1o/jz5xOc2FaA1lPF6CntCYi49mHh7YtSObAuG3edmh7NK6ldMpPiilKq3TS4qzUEde2Oql0bivJzOb5lIwDNe/Zl2CNTGhRNf+Gw21ny7qtkHz2Eu85AZMKDZB111GujdFiIzFlPeF4i+rYtMEx7k+Q0iWNb8jDX2BvsN6iJng5Do7CZHexYkkZttY2Ow6LoNib2nMdZ/tNPFL39DpJCwZGbvyAv/RckZxHthoxgwO33UzzjII5SM5oILQFV48FWyRzP+0kxuXJlWnpWMbBsCaba6Sg8/NAPCUM/wJUAK0lSo6d9SrMzmffaf7AYa4ho1ZaRU15k+edHKc0xYgh0Z+xzHXH3ujCBk7SrkPXfHwcgrmMgvcbHo9IqObmjgJ1L0nDYRbQeKqLa+BHdxp/YDoEoGhGBsiQlU/Df/2I5dgwAVUgIgU9NxXDjjRc0voaoXr2GvClTXFGi9esuetqsdu9esu64E8HNjfjEjSi9vc/ZXhJFch5+GNOmzaijImmyaFFdPtS1Zl3WOp5KfAqAWYNmXbflOf7OX9OMeo2edePWXZY6bM6qKoo/+pjK+fMB8Ozdm7CPPryiZXskSaJywQKK333PNYXn4UHQ88/jPWH8ZZvSlSSJ4vfep+K335D+lhupjowk8Kmp6IcNa3A7e14emRPvwFFYiGfPnkTMmnlRkd5zIQuna8S/WTg5bE5WzDhMXlIFGjcl/e5oTlzHwDN+cA67kyUfHaA4sxq1VsnQB1oT1crvGo0aSnNrmP/2XiRRolnOj2QJeVR6ntuYsOtNE+g54Q4EhQKnyY5pTyHmo6UodRo0kXrcmvmgDvFEEASstbXMe+0FSjLTMQQF033CE5gqdThsTlSSnSjSsf25iqpNm3BKIvrmLYieOwenoCTjUCk5x8vJS65ArVURGmcgsrXLjfuv85p2oJjVs44iKATGv9CJgMiGhag1NZX00WPA6UR45GXWHqzEblqJWuvGpE+/xvJ7PpakCpQGDYE+b6MsTOSQzwiWVDRFoVAgiq7ITbSQT5+9TjSt7kHQQsi0Hig0F77cuTA1mQVvTsNmNhPToTMD73uG3z86RE25hZBYA6Ontkepalw0J/NwKX/MPIIkSrTpH07vCfH1rruyPCNrvjlGRcHp6dCwpt4MntwKT8PZzQmrlq8g/7//BbsdhV5PwJQn8R43DoXmwqNWDSGazST36IlkNhO9YAHubVpfVD+5jz9Ozbr1eI8fR8gbbzRqG0dFBRljx+LIL3AtW5/+yXWT7/TmzjeZlzQPXzdf5o2cR7DnmV5h1xOT10xmd+Huy1a0uHrVKgrffAtnmWsK3O++yQRMnXrVbAVsubkUvPAfavfuBcCjSxe8x4/Dq/8AlF6XVtS7Yt58Cl9x5V1pYmNxb92KmvUbEE2u36ZhzBiCXpxWT8ibdu8mb8pUnOXlaGJiiP5t7hURkLJwukb8W4WTKEqs+uowmUfKUGuVjHoygeAY1/y73WYlZec2co4foSAlCe/gEAY/8BTrvksmL6kCQSEQ1dqPuA4BNEkIQON2ed8izoUkSiz6YB9FGdW4l66kSjiBqFCgUigJbd6SoPhmmKurKMvLQePmTkBUE6LaJBDdrgMAxp0FVK5IB4d4Rt/qYA90/SLwSAjEWFHOby8/S1VxESq1hh633EFEyzZIkkja3l1kHjpASVY6otNJRFk1vYaPJvQCpm5Wf32EtP0l+Ed4Me6FTiiVZwqOnAcfwrhpE579+rO/6b2k75mOJFbRY/xE2kb1p2JRCoJaQUDHvWgOvkyNJogZwj1YrDYGDBhAXFwcX3/9NQC3716IW+wbKDz9MYxogq53+AWdd6fRhKBUkJeRyuK3X8Fht9GsRx+6jXuYJR8ewGZ20LJXKP0mNjvvw9xUaWXu67uw1jpo1i2YgXe1AAHsVgsat9N5X6JTpDC9iswjZRzZlIfD6sRdr6H3hHjiOgSekf9Uk5hI7qOPgdOJ14ABBL/6Sr2E/stF7tSp1Kxajd99kwl85pkL3t6WnU3a0GEgScSsWI42Lq7R25oPHSLzjjvBbido2jR877zjgvd/JbA4LNz+x+2kVKQQrY/m+2Hf4+/uf62H1SBJ5UmMWz4OpaBk9djV5xR5oslE9apVWI6fwJqaitLXF48O7XFv3x635s2RnE6K3nqLygULAdDExBDy2qt4dO58tQ6nDkkUKf/pJ0o+/gTJ5spRFTQa3BMS8OjSBf3QIWjj4y+oT3thIekjb0Q0Ggl4+in87rsPQRAQa2spnT2bsllfgyii0OvxHjsWbVwctfv2UbVsGTgcaFu2IGLGjCtWrkgWTteIf6tw2rUsnb1/ZKJUKxj1RAKh8d7YzLUcWL2C/auWUVtVWa996/6DGTj5MTbNSeLkjtPuxloPFXERNmLVWWgtFaBSoY2Lx61lS7QxTS7rmB125+n9W1KxmJcBENmqLUMfmYLe/9wPyZotuVStzABAHeaFZ5dgJJuINbMKS1I5OFw/IZ8JTfHsEERtdRWrZ3xMxsF95x2b3mzlhkemEjbshkYdS221jTmv7sRa62gw8d60cxfZ99wDKhXWN35h09J1OMyJuOu9mfT+V5R/cQzRZMfQTUB36EaQROaHvcLxvGpCQkK47777UCqVfPPNN+Tm5tLXmEbEES1u7e9GoRUJeKwz6kbkJYk2G6VfzKDs22/B6UQVGkJVm1ZsKclGdDppP+xGYjuPY8WMQyBBn1ub1nk+NYQkSfzxpUuwB4S50767kT3rV1JeXIDVZCIoJp7hjz6FX3j9PI2KQhNrZh+tS8j3DfWkbf9wolr74+mtoWbtOvKffx7JYkE/6kZC3333iiXK1k3XhYcTu27tBUd9Ct94k4pff8WzT28iTwnbC6H8p58pevttUKuJ/uVn3Nu1u+A+rgSFpkLuXnU3+aZ84n3i+X7o9xi050+Gvtq8tO0lfk/9/bzO5/b8fHIefAhrSkqD3wvu7ih1OlcOnSDg99CD+D/88GWLbl4stpwcqpYsofqPVdgyM09/IQgYRo8m4InHUYeGnrcfSZLIffgRjImJuLVrS/ScOWdE0Gr37aPgv9OwZWWdsb1+xAhC3nwDhXvjFsFcDLJwukb8G4VTxuFS/vjyMACD7m1JfOcAjm5cx7Z5v9QJJp2vH/Et2+Gm0bJj42okSWLg5EdIGHIDZXlGUvcXk7Q1h5oqV30zhdNGeF4iUdlrUZ8yxNMNG0bQf/6DOujS3/qry8ysnnWUkuwaJNGOUPYlFpWTVv0GM/TBx8/5kJQkiZoN2VSvdzn16vpHoG9TiZC8BrwjIbY/otKPqnVZmHYUgELA7+6WuDfzRRJFDq5dSdKOrVQW5mO3Wohu24HYzt0Ia9aSysIClr/zClbRiUKU6DFmPJ1vuxOF4vQNRhSdZB8+SGlOFmHNWxEcG4+gUHByZwEbfjiBUqXglhc74xPsCqlLokjmuPFYjh9HNWES60tjqC37BbAz6L5HiayNx7SjAJW/liBhEkJNDikx9/JrujeCIPDggw8SHOx6i962bRvr1q0jyseHbjNn4zngvyh0EShUFvxub4K25dmjHZaUVPKffwXriUMg1a9jV9q+DbtFV1mW/vc8CIq27FiShqAQGHZ/a2LaN1zD7K+8JkF0EJL6Ien+avgf4aHSaOl312TaDhpeT5Q4bE72r8ni0J+52Myn8870jmIik5YRUHIQXb++hH/+2QV5NF0o9abrFi7EvXWrRm/rrKwkpf8AJLOZyO+/w7N79wvevyRJ5D05hZq1a1GFhhCzePF5c6SuFtnV2dy9+m5KzaXEGmL5dMCnRJ1aTHE9kFmVyc3LbsYu2vnlhl9oF9Cw6LQcP07Ogw/hKClBGeCP9+jRaOLicBQWYT5wgNqDBxGrXEawSn9/wj54/6L+l1cSSZKwZWRQu3s3xsRNdU70KJW4t2uHV5/e6EeMaDCZXJIkymbNomT6p6BWE7N40VmjVZLTiXHzZirnzcdprMGjfXs8unXDs0ePKz6VLAuna8Q/TThJkoTd4qS2xoa5xk5lkYmso2XkJVdiszgQnRKGAHfiOwfRvFswhgAPJJuN6lWrqFq2HJNdw2b3UTgEDS3auNFxfCx/fPER+UmuJF3vwCBaanToV61DcSpHJi3Qh6QQXwSFgt43jKFls9ZU/Pwz1ev/pNS3NdnRQ6nSRQOgQMTbUYg+7xDeFcn4OIsJf+s19EOGXNzxihLHtuazfWEydpuE2m7EO/cbcrxFPPQG7v1kFm7nSJKVnCIVi1Op3VcEgL6ThL7sRSg4VL9hdG+kHk9SsT+C2oMlCGoF/ve3QRt5/muiOi+XpVMepljh+gl6BwXTfvho3HU68pNPkrp7O8aK8rr2nt4+DLr/MWI7dmHFF4fIPlZOcIyBm57pgEIhnM4p8NJzeNQH5J34FkksI6JlW0ZPfoGSU9Ed/7jluOXOwu4Tz5fSRCoqq+jevTtDh54uCVJeXs5nn32GIAiMXrQYNzT43PAQdpoCTpQqE0ovBUp/b5RBgQhqBZJDwl5swnKiCEGpRZJElB7g2SsMhZBD/vPPI9bUkJ3QkqOSy/dp1DPTyDqu5+T2AhRKgRGPtCXyf/Lgco6Xs3r2UWxmBx4F31Lu5nrwhJVXE1NShc/IGznkBllHDgLQsnd/Bt3/KGpt/fw1a62do5vzSNmQRFm1EgSXaDZozAyd2o2AJufOv5MkCXNNNSqNBrXW7aJu7rlTplKz+vR0ncPmpKrUjEqtOOcKw9JZX1PyySeom7VA/fbXeHm74Rvqyq0TRSfW2lo0bm4NLmAwVVlx2kUUSgG1ZCXntgnYs7IxjB5F6HvvXfAxXClSK1J5YN0DlJhL0Kl1vNvnXfqE97nWw0KURCavmczeor30DOvJzEEzG2xny8khc9x4l8N8fDwRs2aeEaGRRBFbRga2jAzcO3ZE5eNzNQ7hkjAfPkzxhx9Ru3t3vc89e/XCe+zNePXpg8LTE8lmo/CNN6lcsACAwGefwW/y5Gsx5PMiC6drxD9FOBVlVrNjcSqFGdV1lgHnQ6EQ6NlDhdus/+IsKUUUFOxv/xTV+iboq9IJS/+ao5EB2BUCarWGtgFhBO/aj1Tuesgr/fxQaLXY8vM5HBFInq8riTm40khgdS0ah5PwXn2IeP4F8ouV7FyaVs/bCEAQ7UTlb2TAB3fj3qLFBR2z6BRZ+cUBsk+4HrD6qnSaZP7K3mgdTlFk+GNP07J3/7r2kt2JJaUS0exAcojYC0xY0ypxlJhBAO+WGXilPwmSCEoNxA2G6jwoOHi6j8g+lDpfx5pmROGhIuDhdo2a0rIVFrL57js45qXGoTozIdTNS0dIXFPyko5jM5vRuHtwz8dfAl7MfW0XdquTdgMi6NxJ6fLsMZvJGv8OJzK3IdpO4GHw4c73PsW8IBdrehXuUVb8isaCQs2fCZ+xeX8yOp2Oxx57DK22fvL0V199RVFREd2TU4jcv5+I917EctiKxXT+fAdJciIIp4/HMDwalW8V2ZMn46yu5nibeLIUIiq1hjHPv8KJHQrS9pegVCvoe1szmncPRnRIHFiXxa7lGSCBR/Ueyp2uwsT973mQJiYbhS+9BJKEz733ktsyjs1zfkASRbyDQoho3ZbgmHiaduuFm5cXksNB0XvvU/Hzz9jUXpT0u48MRTNsVtcqvJGPtavL16u7lkSJg+uzSdl9mLKsNZirMwFQqTW06j+YvhPvRe127gUGf6d6zVpyn5xCaZPeFPS4l9L8Wjh1B27TN4zuY+NQ/08CvmgykTp4CJVWd1IGPE9ljRJJNKOQdiCJudjMFYhOV2RPpdUSEBlNVJuOqNxiyDmpoCjjtFu7oBDw9lHgfmQzPhUnafPqw/gN7NXo8V9pSmpLeHrT0xwoPoBCUDDnhjm08m98ZO5KsCh5Ea/ueBV3lTtLRi9p0LfJaTSSddttWFNScWvdmsjvv2uUuaTd5nS9EOg1103C/tmw5+Vh3LKVmnXrMG3fDqekg6DRoAoJxp5fAHY7KBQE/fe/+N4x8RqP+OzIwukS+OSTT/jmm2+QJIlBgwbx6aefNvrivd6Fk9XsYOuCFE5ur2/yqNIq8dCp8TRoCWvmQ1RrPzy9tQgC5CVXcmJbPnnJlSCJNE1ZQJiYSUGf+zlZ7ItK6STCOp8TNa4+vU0WErKL8LCdcs6OiSH4xWl49nAtK7ampFD2088cObyPY1qQ/n5uBYGQ2KY07daTVv0HYzEqyE+pJC+5kvzkijojzYjqA9zw5X2ovBuf87Dz2+3s22NB4bQRm7EM/+AqdqgdWGpNRLRqy/iX3kIQBJwmO8ZteZh2FSCaHGf0I2gU+IYswb1otuuDhIkw+A3wPBWZqMqFnV/B3u/BbkIM6EiJ8z3s+RaUBg2+E1s0KvJkPnqM9LvvJsdNSX5UKNqoaEKbtSC8VRuaJHRCpVbjsNuZ9+rzFKYmE9upG6OfmUba/hLWzD4KQMuaRIL3LaCk550clPywm5YjCAomvPI2fmIIZT8fB5VAsOEFVKYjpLd5hp+PusowjB8/nlatznw4JSYmkpiYSITdTo9Fiwl4+in877sPZ3YKzhO7cGacxFFYhNPhBShxWiUqTtpxliQRfF8/vCY8hXF3ETUbXFOdhhFNUPlWkXP/A9jLyznYogmFGgVqrRs3/+d1Dm10kHm4FHCthCvLM2ExuWwaIoV08vLnY3LT0HbAUAY/+Dhw2gwSIPiVl6lp04oVn76Hufp0XTy11o2WPfrgu3sf2h27UUgQMGUKfg8+gMVk548vD1OYXo1Ko6Dv7c1o1jUYQRCorbax9ptDZB5YjNN2pMH/nU9IKCOeeI6gmMYlaleXGFny/EqMmtNTkho3JTaLS/j4BHvQ57ZmhDc7HYkonvk1e5ecIDP6BiRBiUA65sq1INWef4eCB0p1NGqP1giKcM6420sibfuG0uu2FpftwW3LycGakoLCywuVvz+aJk0uqG+7087Tm55mY85GugZ3ZfaQ2ddMVJSaSxn1+yhqbDU80+kZ7m519xltJFEk97HHMf75J6qAAKIXLkAdFHTOfk1VVg5tyOHo5jzsFidaDxX+ETp6jou7LmxbzoctJ4fK+QuoXrsGe9bposNKb29C3n6rQTf76wlZOF0kJSUldOvWjWPHjqFWq+nTpw8ffvgh3Rs533w9C6eKQhN/fHWEyiLXjbVZt2A6DovCy8cNtfY8xomixKrHvyPDWT9BW5JEQqIPknkwEYCWzdvQsrQae2oqHh064tW/H7p+/RDOkuBYkJrEobV/YKqsoKaslLLc0z82tZs7Tbv1xD88Ep/QcCJatiFpcy6bF2eDIBBBBiM/vwvFefJPJEki48tfWX0oEEmhonXJSryHxZO4eS0Om42gmDhuev4VPL19MCeVU7EgGdHoejArDVpUQR4ISgGVrxsajwK0B55CaUwClRuM+Ahz87Hs37+f48ePo9PpiIyMJD4+ngBnEfx8E5iKcepbUmJ9D0eVAAoBXb9w3Fv5o/J3RzTZEWvtoBBQeqlR6k9HeEy7d5PzwINIFgvaFi3QDRyIbuAA3P4WbSvJzuSXF55EdDoZOeUFmnXvxd5Vmexa6nIKVjqtOJRgrfwRJCNdb7qFnuMmUjR9P45SM7qoDAxFj1Oua8FsxxjMZgvt2rVjzJgxCIKAyZROevrHBAQOJShwJCUlJXz55ZcogBFLlxHUpw/hn06vf9KddsjbhzN9L9lv/YwlpxqvUAvhvcsRYvrA8A+oPuxelyfmc3M86iAr2ffdjyU3l71NginTeaBWqhgwciwWXXd2r8pBOmUM6mlQE1+5lYoTy0gK8cPdw5NJn39bb5q1dOYsSqZPB6WSiJlfoWyfQM7RQxRnppO2bzel2Zl1bZWiiF9QKD5x8fiEhhPeohUBUU3Z8GMy2cdcEdOQOAMadxU5J3Ixl/+O5CwABMJbdMMzoB+Zh42Ijlxw/IndUoXG3YMJr7xDUJNze2tJosTS6QfIS65EZTcRWbKdnjOeRhfuR86Jcjb8eILaUy8MUa39iO0QgEqys3PmJqo9XYnz3gFpFCYvBUDnH4ZvxBDKctXY7e4g2ZGkWkRHLqI9E8mRjSSddvL3j4ymVb8bMAQlUJRSSeraI5i0LgHX/87mtOx5/sTfsx6bJGE5dIiy776nZt06/q7Q9DcMJ/SDDy5oiX2+MZ+RS0ZiF+3MHDSTnmE9L3psl8LTiU+zNmstLf1a8usNv6JSnLkS+K+kf0GjIernn86ZdC+KEofW57BrWXqdYavrEex6cfPy9mTCtC546K9tonhjkSQJW1oajrJyNBHhqIKCrpqVwqUgC6eLpKSkhE6dOnHo0CHc3Nzo06cPc+fOJTb23De/v7hehVNecgUrvzyM3eLEy0fLkMmtCInzPmt7UXS96QqCAkEQqP7jD3KfeprM6BvIjhuB0+ESTTrDdkqzdoMg0P+u++hww+iG+7M5cZSYcZSZXQLkLLXYaspLSdu7m4NrVtQTUeCabojp0IUAfRv271QjKZR01e6l40dPndUITbLZyHvpVTbmxFGtjyZAyMWreSEntm8GoEn7Toyc8jxqrRtVqzIxbs517SvQA/3gSNxj3RAqU6HwKOz/CXJPzef7xsKEn9iXZ2X16tXY7WcaVYaGhtKzXRytdjwJldmIkgcV7m9jrjxHFEIA/ZBo9P1PJ1gat2wl97HHkKzWus90Q4YQ+NTUunID2+b/ys5Fc3HX6bnz/c9wQ8HKyV+RF+QS/PbajTitBzAEhXD3h19g2V1K1Yp0FB4KgqUJOCQL3xieo7jKTGhoKPfeey9qtRpRtLNn780Yja6ctcDAG2je7A1+/fV3MjMzaX7iBJ1KSon7c8MZh2IvLibngQexnjyJwsuLmOf6oU7+CRwWUKiQBr5Kdc1IahJzQQC/O1qgDpRcq8QSE9kX7k+Zzh0kiaYlVYQHJ1AY0o0Aew76Q2vIsxg5GBWEqBAY/uhTtOxT/2327y7pCAL64cPwvvVWVP7+GLdt58SXn5Otd6dM54GtAfsGhVJFcGw8KrcIijIFRKca0Z6F054MkhWNhyc3Tn2B6LbtAUjeU8i6b48DVgy+f1KUdgJ3vYFbX3sf39Czl984uD6bbQtTUWkV9Mj6FtXJvfg9+CCBU6cAYDHa2b0ig2Ob8+oc5f9CJVpoN1THjkUfIToddBg+it4T70WlVuN0iJTmGjFVWqmtsuKh1xIYrcddpyA/6QRJO7dxbNN6HKeuKw+DN+0GD6eZdwC7P1hJesxolDgZP60LfhGNj+xKDgemHTuoXrMG0+YtdU7rANpmzZCsVmy5ueBw4H3LLQS/+soFRY4+2PMBPx3/iWY+zZh/43wUwtUtC5KYk8jjfz6OUlDy28jfaO57puv6353c/R5+iMAnnzxrfzXlFtZ/f7zONNgn2IS1egPl+WmnhKaAUtOGiDajGPN0lwatRmQuD/9vhdPmzZv54IMP2LdvHwUFBSxZsoQxY8bUazNjxgw++OADCgsLadeuHZ9//jldunRp9D4+//xzpk2bhkql4qGHHuLtt99u9LbXo3CyWRzMfW0XxgorofHeDL6nKe4aicL0FHL27qYyJRlTZQUOJGySiMlmxVRby19JFipBgcZixd1mp0mbBFo/PhWz0cjhdX9wYutGBIWCEU88S7PuvV07FEWoyUdyOrDm2DAdc2A+Vg7OU5eUUsD/nla4xZ89AVKSJLKOHCTvxFEqCgsoTE2iqtiVkO2u0xMbN5bUTB/czKUM9t1DwD13oImKqrcayJadTcGLL3GiQE9a7E2oBDMqzTIqC/NAEOgyehw9J9yBQqnEfLSUsl9OAODVIxTD4FCE7R/Ctk9B/JsoUqgh4TYY8hZb9hxiwwaXYAgMDKRz587YbDYyMjJIT0+vM4wcM3IYCSW/w+5ZSKJIrdiPWoZjc8Ygie6ADSVVSKgQcZ0Tw8gYdL1OP2ztRcUYN2/CtHkLNRs2uM6xSoVh5Ej87r8PZWQkc158mpLMdMKat6SfdwgVs75Gat0Ry333kPjDZ0iSyNj/vk5YaHOKPz+AZBPxDtuIV9lHrPa+i52Vfnh6evLggw/WXbuZWbNIS3sfpdITUbQgSU4CAoag1Uxh7ty5qG02bly2nBZrVqMOOz1eR0UFmRNuwZ6Tg9Lfn8jZX7uiZBWZsGYanFzh+j/f9A0VKe2o3VsEKoGASW3QxhhwVFRQtWo1W9etILXWNb0WUG2iXXYxSlEiy1/PyRA/EATiOndn1NP/RbKL1PyZg2lvIQoPFSp/Dzza+1Hx/ftU//FHg9eZZ48eBL/1FtUOK+X5uVQXF1GclUHO8SMYy0rPen36RUQx+plp+ASHIokS9jwjjnIzR/7IJCvPhG87PQVpP1GckYantw+jn32RkLhmZ/RTlmdk/jt7EB0S/SY2I9J6gtzHHkfh4UH89m0o/pYnVVlUy6E/c6gqqKbywAk8jAV0nBDP2k2/Y6wop2nXnoyc+oJrurnaijWtCntRLYKbEqWnGk0TA2r/+ku5LUYjR/5cw4HVK6gpKwFc+XNtY5qRfdiPSp9W6JzlDG5XgkdkGB4dO9b7P/8dR2kp5T/+ROXvS3CWnD53grs7+iFD8J08CbemrsK91avXkDd1KkgS/o88QsATj5/1XP8vlZZKhi8ejtFu5O1eb3Nj7KU7uDcWo83ImKVjKKot4t7W9/JUx6cabFeTmEjuQw8jeHgQt2H9WZO97TYnv72+i+pSCwqVmaDwVDIPbUASz8w7FRTexHUZx/BHb0B9jS0K/r/y/1Y4rVq1im3bttGxY0duvvnmM4TTvHnzuOuuu5g5cyZdu3Zl+vTpLFiwgKSkJAJPmdclJCTgcJyZu7J27Vrc3d259dZbmTt3Lu7u7gwfPpzXX3+dPn0aXsVhtVqx/i0SUF1dTURExHUlnLbMS+bwxlw8VVZ6Ff5ERfpJTgZ6U2y4NAdYcEWkbnjiGZr36AMp6+HQXKS0zdQaW2N03IRdOj21p1CaEdQSTosHgkZJwINt0YQ1rsyDJEkUpaeybvYXFGek4R0UCsIoLFYPmmQsp0nWasA1l66JjsZZVYUtIwOTRxB7Ov0HUaHGL3gHeSd24OXjy4gnnyO8hculWbI7Kfx4H84KK7p+ERjaVcGSh6DYFWXBwx8CmkGTPtDxXkTPANauXcvOnTsB6NWrFwMHDqz31mwymfjzzz/Zt28fgiAwYcIEWvg4YfcsOLII7CYkSUDCHYHauhX01Y7bqHa4kicNNzTBq3fYGW/jluRkij/6CNOmzX/9E/CeMAHtPXfx62svYDPXElFtxr+8CuPg/qSkuARhi979Gf7QVIq/PIg934Q2FPzLRpEthPE94wCYOHEi8aeWCdfWZrBr9whE0UrLFu+jdQvlwIE7EAQNvXvtYdasHygtLSXhwAF6DhxIwBNP1I2x8K23qfj5Z9RhYUR+/x2ayMj6/9C1L8H2z0CpRbprOWWbdFiOlyG4KQl4sB2akNPX5uENa/jzu5k4HXbUSiUOUeSv21O7wcMZcO9D2DJrqFiQjLPSyv9iGBmD2r+GstnfYD5wAKfRiKBS4f/II/jcfluD1hOSJFFVXETO8cMUJJ/EWFGOuaaagKgmNO/Rl/CWrVAolDirrZTNPYntVEHhv3BKEuq2Pqw/+DUl2Rku09MJEwlr3hKtpxfVxUVUFheyb9URakpLcPeSMASq0Hp44ty+E5+SMjq/8S6GQQPPGFvh629QMWcOypbN2dcqlvzkk/iGhjPx7Y9RCRrKfjmBNbXyjO0A3Jr74tUrDG2sod51JTqdpOzezo6Fc+sivQGBoViMQ7FrffArO0qbo7NQSCLa+Dg8+/TBq09ftE3jsRw5gjFxE5WLFtVFRZXe3uhvGI7XgIF4dO6EQnumO3vF3LkUvvY6ABGzZ+PVu/HJ6N8c+YZP93+Kn5sfy25ahl5zde61b+96m7kn5xLuFc7i0YtxV53pKSRJEpm33orl0GF8J08i6Nlnz9rfjt/T2LN8Kzj34rBk1l3Xzbr3ptetd+FhMFCQmszKTz/CXOMqtK1QaYls3RpDQBCe3j44HXZsFjMCAkq1Gk9vH6LatscvPPK6Tyy/3vh/K5z+jiAIZwinrl270rlzZ7744gsARFEkIiKCxx9/nBdeeOG8fS5YsIDExERmzJgBwAcffIAkSTz33HMNtn/11Vd57bXXzvj8ehFOhRlVLHrPZbjY7tBnVKiLSAn2RRIEBEkisNaGwccXr8Ag1BIorTa0FZWoC4sRbHYkARRN43EfdzMVouvmWpSWgrvBgCEwiI4jbiKuiT+s/g9i8hZMzuHUOEYh4kqUFjDjoUzEU7kajSINSVJRan8Nq9gOhZcKn/HNcG/W+EK/xopy5rz4NDWlJfiGx2MyjkCJSJeMb/HIPlyvraRSc6DHNCoVAfgE5lGQNM+VGP3qO4Q3P530XL0+i+r12SgNWoL6HETx5zRw2lyCacRH0GpMXVuLxcKiRYtIOWViN3jwYHr2bDjPQhRFli1bxsGDB1EqlUycOJGYmBiw1kDxCTCVuqJZfvHgHQF2M9K6V6naq8HoHAuAR4IfPmObI6jPfLibDx+m9OuvMa53Rb3UUZFUD+jLxv3b6zcUBLqOGU/3cbdRszoH49Y8FB4qggLfw1m4ha80j1BhU9K+fXtGj3ZNtUqSxMGDd1NesQ1fn14kJPwAwPYdfbFY8mjX9huysvQsX74c99pabti3n9ZrViOoVNgyM0kbeSM4HGf3FhKdMO9OSFoJHv5Ity6k5A8FtsxqFDo1gQ8noPI9HW0pycpg+fT3qMh3TaV6+fjSedRY2g8fhWiyU/jhPiSLA6WnA4NiNgpLPmaxFyany0rBq4sew5i2Z7iDXwqW1ArK5yYhmuwIagXqMC+UnmqqTpSjOTWlpo72YnfFKpIPbj9Pb2fiq3Vn6IuvE9r0dD6bNT2d9BtHIYpOjo0aSk5mKlpPT257/UN8g0Ip+e4YtowqEEAd6oUm3AvJLuKosGLLrKpbqaeN88ZwQxM0ofVfXESnk6OJ69n8y3dYa03Etu5OYX5XnJKCcGsS8bu+QGggGvIXbu3a4nfffej69j1rXuPfKXzzLSp++QVVUBAxy5c1uoyGzWlj7LKxZFZnMqHpBF7q/lKjtrsUDhYf5K5VdyEhMWvwLHqENlxDz7R9O9mTJiNotcStX4cqoGEPsrJ8I3NemoPNuAJwndPQZi3petN4YtrXdwq3GI0snz6T7KN7QDI10NuZ6AMC6X37Pa6X2v9nFKWnUlNeRlynrpe133+lcLLZbHh4eLBw4cJ6Yuruu++msrKSpUuXnrfPnTt38vDDD7Njxw7UajWjRo3igQceqHug/C/XIuJkTc/AfOiQa2VKZATqyIbfLApSK1nz9WFM1Q78CzdjVuym7NQDOKZ9J/rcehe+UWdZ2SJJLvHgsILGC85mCJm1A34Zi9nSigr7Y4i4RJDCS41XrzC8ugSjcJRAaQqUpUD+AcT9SyixvYNdchWHdWvug9LbDcnmROGlRuXrhjbagDq44YhYaU4Wc196BpvZjH/0SIxVTVGqFPS4MYL4CCv2rCzMDhWH8gNIOVCOSl2LzfgztloT3W6+hZ633FnXl6PMTOEn+8Eh4ttkIx4FH7m+aHYDjPocycOPyspKcnNzSU1NJSUlhdraWlQqFWPGjKF163PXFnM6nSxcuJATJ06gVqu56667iDhXtXFRRFr1PMYdBVQ57gOUKL1EDDc0RxXogS2nBlt2DbbsahxVNjRhXggaI5Xz3seRnQxAjq+OPB8d6pgmeISG0WXMeMJbtMaaUUXJLJe49BtgxH37raxV9Ge7mIBer+eRRx7B7dTUUEnJWg4feRiFQkPXLqvx8HCZDp5Meom8vDmEh91JTMw0Pv/8c6qrq9FXVnH70CEEDx9O7uNPULNuHZ59+xA5a1bdodXW1lJUVISnpyd6vR43wQE/jHDZN6g9EUf/SMl6X+yFtSh9tATc37aeeLJbLRSmJmMIDEbnH1B33VYsSsG0pxC1VzUB9ntRCFZXDpV3NMbidlQ57gXAPdqC730DERpZ/+5cGHcXUPl7KoigDvHEd2KLummwgrRKtk8/QEcPJSpBQGnQUBJZQkrWbkqyMrBbLej9gzBWarDbPAlrHkXLnk1Qu7lhMRop2beXo7u34jiVTJswdAS9b78HjZs7OQ89TOnWLSQltCDPbkal0TJu2huExreg7JfjWE6UI2iVBDxwZjTXXmrGuDUP055C17S5AB4JgeiHRqHyrm+dkHFgL4vfew0kiU433sex7QYkUaLL0FCaatIwbd6McfMWnBUVqKMi8WjfAcOoG/Ho3v2CohxibS3pN93k8o+66SZC32l8WsSewj1MWjMJAYGfhv9EQmBCo7e9UOxOOxNWTCC1MpVRsaN4q9dbDbYTrVYyxtyELSMDnzvuIPjFaQ22kySJX6b9THHaAkCiabde9L7tbryDz11K5OTOfNZ/twmnvQg3DwvBsWp0Pl511hdOu43yvFxyjh3BYXctAGg7cBj97rkftebsNRn/CUiSxLFN2zi0bhmFqcdx13vzwJffo7qM5rT/SuGUn59PWFgY27dvr7cK7rnnnmPTpk3s2rWrUf1OmzaNxYsXo1AoGDhwYKPsCGbMmMGMGTNwOp0kJydfEeEk2myUfvUVZbO/gb9NNWrj49CPvBFt03hUfn6YSyo4vLOSY9meIChwMxUi1M6hQgUad3cGTnqYFr371z8mcyWUnIS8fZC6AbK2uZJ4AbyCof0d0OFO8Ik+vU3uPqQfx1FhuotacRAAKn93dP3C8UgIPPsDKj0RceETVFcNwugcBTS82kITocOjUxDaGAMqf/d64z2wejl/fj8LrYcnEW2fIDfJJV7ddWp8gj0pya7BbnUiSRIGn/UUZxwhOK4pt772PspTieROo42SmYdxlJrR+lXjb7wdQamGIW/i6DiZ3Xv2sGPHDmpqauqNS6/Xc8sttxB2llyP/8XhcDBnzhzS09PRarXceOON5xZckgTHl2JZ+j3l1ZPqxOi5ULiLKNQHcRRloHBzQxMbi999k+umoSSHSNHnB3AU1eLZwQefvFsprarhS+FeRAluv/12mp7KP3E6LezcNRSLJZfoqEeIjT1dM6+kZB2HjzyEu3skPbpvpKSkhB++/BKTJOFldxDnbUC7YQNam52I11/D5uNDWVkZmZmZZGRk8PfbStu2bRk1tB+qhfdAxiYQlDgHfkrJjuY4yiwoDVoC7m+Dyv/M6ZC/sOXUUPzlQZAgQPMMWsVJ6PUU9H0e1G6QsxvTwvlUFI0AVGh0ZXj2bY22dQQq7wt7kEiShL3AhGlPocsRHvBoH4hPXyVC6nJXBNFmBJ8m/LGrHaVpEj19tWgdIgjg2SUYz87BqMO8SNpZyIYfT6D1UHHHG91x8zx985fsdo707sVxnZY8X9c9ROcXQIC3L5Y9eyn09kJUCCiUSsY89zJNEjpStS7LZe+gUhAwqRXaGG9wOqA6F0xlYKkAXQgENMdRaadqTSbmQ66cJlQCXl1D8OwagjrwtMfY9gVz2LFwDkq1muh2g8lNbYJa487E17vh5eOG5HQi1tY2ypfoXNTu30/WxDtAkoiYNROvvn0bve2LW19kadpSWvu1Zu7IuZc0jnMx69Asvjj4BT5aH5aOWYqPW8M5S8UffUzZ7NkoA/yJXbECpaHhpPo9K7az+ed3AIm4Ln24cerT9aoDgCuFwF5Yi6PCgjbagPLUirqso2Vs+PE45ho7CoVAk3b+xHYIJCLOgFBhQbKLCIEa9q5dws4l80GS8A4Kocctd9C8e+8rVjroSlKUkcvvH3yMsSz51CcCKrfm3P/5i3joL18ZHlk4XYJwuhSuVHK4NT2d3Mcex5buWmLu1rq1a3VKZiaS3Y4EGD3DKArqRH5oLxwq1w0wuHAXXpr9HBXMqLVu3PHudHxDT9X+yt0HRxZA2p9QmtSIUQgQ2x+aj4Ci4zgPraHMOAWb1BwE0PUJRz8oqsFppTMwV8Cur7FtW4G5th3gRHDTIvp2xk4k1jwB/raCSKHX4NkxCM9uIagMWkTRya//eYrizDRa9hlAaPPx7Pg9rZ6ZZ2CUjrD4InYsmIlSpeLO9z6vq1kmWhyUzDqMvcCEUicQYJ+EiiIY/SUn3TuyevVqKisrXftWKAgODiYqKoqmTZsSGRmJ8gKX1tpsNn799VeyTtVgat26NW3btiUqKuoMg8nT56gScePHGHcWY7SNREKBVpGERpGERkhCKZRgk+KpcYzHIUWgdLMQ8FgPVP5nRuqqE3OoXp2JwlNNcMRnKDJX8qv6NlLswcTHxzNx4mlTuoyML0jP+AStNpju3dahVJ5+mDocRjZv6YQk2enebT0eHk0oOnKEH3/6iVrP8+fMGQwGrFYrFotLlMfHxzNh7E2oVz0Fh1wPPmeXaZScGICjxIzCS43v+Ka4NTCdK9mdFM88jD3PiIdiPb7az+Hmr6HNuPoNnQ4sC7+i7EBTJE4fi8JTgSbCG4W7CgQQq404iisRraBwUyO4uSOhAKeE5BSRbM56vl76XgZ0jlkIh+aeUUKmwhHK3NLPUKBkZGc/SDmdA6UwaMitsFFmdRLVPoAmXYLRxnmj+JvBZd4zz1K9YgXWcWPYU1lEdUlxvf7Dmrei9+33ENasBfZCE0WfHwCnhO/oIDwqZkPGFihLrb+wAUDtCaHtIawDNm1nqg75YM0//bUmSod+SDRusd5Iosjy6e+Ssss1zahQuqN0H0bL3t0ZdE/Ls/2LL4qid9+j/IcfUIeHE7Nieb2k+HNRZi5j0MJBOEQHi0ctJt7nworONob0ynTGLx+PTbTxTu93GBkzssF25qPHyLzlFnA6Cf/ic3SDBjXYzma18NX9D+KwluEX2Z673nu1nmhyVFmpXJKKJbn8rxk8EMCtqQ+aJgaUnmrsDpHkLfkY843olAIGpYDH/0xDq4M9sLQUWbXoM0yVrvwov/BIWvcfTFynbhjLyyjOctXadNfr8QuLIDA65hLP1uVFEkXWfTuPIxvmg2QHlGi9OqDx7IjGw4d73r28dhT/SuF0OabqLpYrHXFyVleTPmIkkiQR/NJL6IcOwekUyTmQR8rqw+Tkipg5/eDyopo2kTWED27K3M/fx2G11tWGA2D3bFj1HEgikgQiOpwerXHq2uH0aYekawZe3ijcVAjlx1BkrkEo3AVISJIHVrE5teIAnFIwgrsSvzta4hbrfeEHZjXC/h9h+xdQc/oO7vRoisn3USyWFtgK7KdX5ClAPygK/YBIClKSmPPSMyBJdL3pFhKGjaG2SqKisNZlHBem4MdnH8VirKHnLXfS7eZbAFf0peTbo9gyqlB4qgjwehV11U5qm97EKu2NHDniMjX08vJiwIABtGnTBvU5wsGSJFJevpWSkrVotIF4GzpiMHREqax/83c6nSQmJrJly5Z6n2s0GnQ6HREREcTExNC6dWsUf38rNJYg7f0BzOUIWk9X7lVgC9CHQXUezgMrKdmbgEOKQKE0oxsUi1fvJggqhctH50Q55XNPItlFfNqk4JkylRRFU34VR6BQKHjkkUfw93dVnq+uPszefbcgSTZatfyE4OBRZxzv/gN3UFGxg6bxLxERcQ8AqU88QVJqKtVNYjBFReLQ67Hb7bi7u+Pr60tQUBDNmzfHz8+V+5aamspvv/2Gw+EgJiaG2267DfWW92Hz+65z1eIeSgvuwl7o8hzz6hGKflh0nbgQzQ5KfzyGLbMaQaglWPMAyp53wZA3zvp/cuzbgGndFqxVYdikeM4W6TwXglqBNlaPp9du3E9Og1N1FO3RA0hSt+JkpZoqYy1miw2t1QNLRV/8VMWM7OvEbumAJakaqQGnfoVOja5fBF5dQhDUCqpXryZvylTUUZEEf/klB6e9QHVuDlJIMC1f+C/RHTojCAKSU6L4q4PYc424BZbhV/swgqMWK2oO0ZI0oQlOhRso1UQ6M+jq3IWW02JKksAqdsDovAGL2LnunLjHazCMTUBp0JC6ewdbf/uJ8vxcENzR6u9hwrTeBEZdvvubaDKRNmIkjsLCC15l9+SfT/Jnzp9Mbj2ZKR2nXLYxgWuKbuIfEzlRfoJeYb34cuCXZ519yLztdswHDqC/YThhH3981j5Xfv4VJ7euRFB4cu/HX+ET4nopkEQJ8+ESKn5PQ7K4BLrCU4VSp6n7HZwPk1NCAryUp8aoEPAcFUVS/nb2LFuEzXzufpp2702/Oyej8/Nv1P6uBH+VMCrPy2HVjK+pLnEFCzQeEQx/dApxnZohWp1IVkc9z7vLwb9SOIErObxLly58/vnngCtBNzIykscee6xRyeGXypW0IzAfOYomMoIai5pDG3JI3Vdc56AMoFIrCG/hS4seITRp609NWQlLP3yL4sw0lzP2i28iIMG6l3Fu/5Eax21Y1T1xOH2R7BeXNKv00eJ/b+t6If6GkCSpbppG0VCo2GF1LVFPWg0pa8FSeXrb6IGYAydjygnHemr1kveYWLy6hZL402z2rXQJYk8fX1r3G0RQbDxlOdns/2OpayVUdAwT3/oYpUqFJElUzE+m9kAxgkYgwPcTNJXrqfWKYpbibqqqaxAEgR49etC3b18050lwLSvbQlLyy5jN9T2nlEovAgOGEhFxNzpdffftnJwcDh48SFpaWl1U6+906tSJkSMbfqs9G86diyhdVotdjAZA4a5AFeiFaHHgOGV4qg0R8S8fjV1QMtPzKcpN9nq16Oz2KnbvGYXFkou//yDatplZ95AwOZx4nir9kpX1Nalp7+Hn15eEdt8BIFosOIqLUUdENDrHJTMzk19//RW73U7z5s2ZMGECigM/w4qpIDmRogZSaXgT0+4y1zn11qIfHIVocWDaXYijqBZBZcdf8SJanxp4dCdozhP1kiRIWYe4+0fsKZnYnRFIuCGhRIEJVYAXCm8DUlE6Uk0F4EQQnOCmQ4hIQKUsRFGwC0655BPVi/0Rk1izJ7leruNfKJ1qPKubEimWMsDwBSdsY8irHYS/WqJFUDkqhQKHSYfT6hLZKp0D7xuCUcdHkNK9B9Lf/MEUXl40WbK4XhHVmk25VK3KQFBYCFY/gEIoZ5P+ZnaYY7DanWeMx8NNS+84HV20aSgLD7t+Z9YasBpx2rRUOyZgcg4HlCi1ZgKf7odSr8HpsPPz809SlpuNUtOKyLYTGPNUexSX0VPo74aRMcuXoYlqXDHfdVnreCrxKYI9g1kzds1l9XWavm863x79Fm+tN4tGLSLQo+EC47UHDpB12+0IajWxG9ajDmy4XWFqMr9OexqQiO1yL2OeHov5WCmmfcVY06vqBJM63AvfcU1d5ruCgL3UjPlgMY4yC2KtHckuovBUo/BUow70QBXsQbnFycm9xSTvKULpEGnjriRc43p5ylArcTb1QBJTKEzdTUHKSXR+AQQ2iUGpUlNbVUneyeNIkoha68awR6fStOvVMxetKS9l00/fUpKdSXVpcZ23mAs10e1HMebpO1GqVVgzqyifn4xSryHggcu74OP/rXAyGo2kpqYC0L59ez7++GP69++Pr68vkZGRzJs3j7vvvptZs2bRpUsXpk+fzvz58zl58iRB57G7vxxcaR8nc42NuW/sxlztSvxz16lp0i6AJm39CW/ug0qjRJIkUvfuZO1Xn2IxGXHz0jHx7U/w9tEjLbqf2uO1VNknI1J/blihU6P0dkPpqUbhoUJyiEhWJ6LFpe5FuwgSCEoBTZgXmmgDHm39UXicGY2RJIny8nJSU1NJTU0lMzOzziQyLCyMCRMmYDjL/D8Om2u11f6fIG0jdUuBAltR7f8W1ftVdYaJbi39SN2zg02/fEdVUeEZXRmCghnz7Ev4R7huwnW5IIKEv/s7uInbwTOQpWEvcCA5B29vb8aNG0d4ePh5/xcFBYs5cfI/SJIDlUpHUNCNOBxGKit3Y7W6xqJQaElo9x0+Pt0aPEcWi4Xa2lrKy8tJT09nx44dAIwePZr27dufdwz1+svdj+n7GVSbRtf5QYGrRIxney/0J29HYc1lTeDD7Ch2Q6fT8eijj+Lm5oYkiRw+8hClpRtwd4ukc+elqNWu6/fHvFL+m5LLqABvPmkeicOSxq5dwxAENT17bEKrvfjfVUZGBr/88gtOp5OOHTsycuRIhNT1MP9usJvAvynmttOp3K4+w2pAobXjLz2FRpEBty+gyNCOxMREkpOTCQsLo2PHjrRq1QrVWcxRMVdAxmaXN5eHL/jFgeff3rQLj8Keb1zT2TZj/W09/JCGvMXmyhA2nqoSbzAYaNOmDSEhrgTfDRs2UH6qTqPWHIhXdSwKyfVb6af/klYe6wCQJBUm50CqHbfXrUb19NiEtfw4lYnHQQKljw8hr71aL//HllND8VcHQQQf1ad4eu5ib6uXWLHfFbn18/Ojffv2eHl5YbVa2bVrV914oqKiuPnmm+v/Bp0OyD+AbcMvlCd1wyGFo/YXCXyyF4JaSX7yCea+/BxIEmqvcXQY1pNe4y/f1JgkSeRMvg/T9u149upFxOyvGyXCrU4r/ef1p8Zew3dDv6NzcOfzbtMYtudv56F1DyEh8Um/TxgU1fDUG5wu0mwYezOhbzWcOC5JEr/85xmKM5JQappx95uvIG7Lw3z4b55Xbkp0vcLQNS1BSF0NeftdU66e/mAIB0PEqb9w159XkOvarD1V9FvtjkXw5dhBB6l7iwivtBKlcp3DSofEEbMTk1ZJeHMDNrNIVakFD52akFhv9H5Gjvw5h/yk4yiUSkZOfYH4zo2rmHEpSJLEwrdeIvtUMe7TJ8MTpTqM3rfdS8cb2iA5RKrWZmHckuv6TRi0BDxYfwHJpfL/VjglJibSv3//Mz6/++67+eGHHwD44osv6gwwExIS+Oyzz+ja9fIuW/xfrkZyuCRJ/PHVETIPl+IT7EHvCU0Ja+Zd99YnOp0k79zK3hVLKEp3icvguKaMfPJ5DB4KnD/fQ0VOXyyi68egCvLAMDgKVaAHKh8tgvrSLPFtNhtpaWmkpaWRmpraYDTlL/R6PXfeeScBZ1mqW0dFJhz4xTW1aKlEkqBS/wmmkngEtYKgJzug8nfHYbdzcmsieUknKEpLRqXR0n74jTTr3hvFqXwk094iKha6kgt9VJ/iqVoHUT3J6PoGP85fDsCkSZOI/F/Pof9BkiSys78mNc01rRQUNIoWzd+qywWSJJGqqv1kZHxGecU2lEoP2if8hMFwfiH0Vx04pVLJvffe2ygBV/98ZSH9chu2EjtOZRRSp0dwa6pDmfgC5O0l268335V1AuonhOfk/EhyyusoFBo6dVxYFyU7UlPLiH0p2E7dDroaPPm+TRMyDt9BZdUeoqIeIi727D41jeH48ePMnz8fgD59+jBgwADIPwhzbgGjS4CKbe6mRjkZc6odpUGB1rodz5KPUQpl0O0REt2GknhKwPydkJAQ7rzzTjw8zl9Y+aw4rJC9AzK3grsvBLfBGdyOVRs2s3fv3rpx9+vXr1401WazsXHjRnbu3IkkSQiiigBVON3i/WnfJB/BVORaueq0g9OGaHZQlRKJqbozoMCg+hadxzrXwowuD4Df6eoFYq2dog+34KxV467Yiq//HIqGfc3sRetxOp0MGDCAXr161RuP0+nkwIEDrF27FpvNhru7OyNHjmywHqFjyVsU70pARI97SwM+t7ZCoVGy4buvOLhmJSj0aHW3MODuzpdUkuV/sWZkkDF6DJLNRsjbb+N9802N2u7V7a+yKGURY+PH8mqPVy95HEtSlvD6ztdxiA7GxI3hjZ5nnwK25eaRNmQIiCJNli7FrVnTBttlHtzHondeAZS07fYcrUxKV2knBXj1CsOjTQBqXyfCxtdg73cXPOZatGQSgREPfAx6AmIT0He/h6rj7hg3ZCHYXFPElQ6JfLuIVgF6hYBScL2amkXQdAqksGwlJ7YmolCqGPX0f4nt2Hjz6IshacdWVkx/F6VKjU/4WKrL3REUOsKbB9Dj5lgCo/Q4ysyUzTmJPc/1AuPRIQDv/noUAZfv2oP/x8LpeudKRpyObs5j05wkFCqB8S90xj/ctdzYbrFweMNq9v2xlJpS10oZlVpDwrCR9Lr1TpQqNbZvHqc0daDrjVbhKuuh6x2GcBlC7SaTiV27drF79+66pF9wTclFRkYSFxdHbGwsBoMBk8nEb7/9RllZGVqtls6dO9O+fXskScJkMqHVatHr9bi7119FR205bPkIds1EcoqUqr7AaopEE6Un4MHzh2stqRWUfncURNAp52Fwmwd9nsXe7Qlmfj2bsrKyRk2RSZJISspb5OT+AEBkxGTi4l5AaGB6wOm0cujwfVRUbEel0tOh/a/odOdOqhVFkd9++43k5GS0Wi233347UY2csqjDXAG/TXStjPwbDq0vX3k8TllFNe3ateOmm1wPJaMphT17RiOKVpo2fYWI8LsA1/TckL3JpJmtdNZ7klRrptohMiLAwLtBaRw+8iAqlZ6ePbagUjXOyPRs7N27lxUrXG7iw4cPd73o1JbDupfhwM+uRoISIrpA7h4QHSAoYNh7FEaNYubMmQC0aNGCrl27kpWVxc6dOzGbzQQFBXHXXXfh2Yjk9cZgMplYsGABmZmZ9cd7FnJzc1n6+zJKSl0J3mq1mo4dO9KjR48G7xHGrVlUrsgGRPzV03BTniokHNoB4ocgWUyU7YnGUtsMpZBPUNw87Dd9zte/LqasrIz4+Hhuu+22hqfEgbKyMhYuXEhBgWu6sUWLFowYMQKvv9X5w2bCOv1OSsofA9QoPFV49QxD08GHX16eSlVRIYLCgNYwgcGTutK0S/B5z1tVcSGlOdl4B4XgHRyMUtVw3mDZN99Q/OFHKHQ6YlYsP29hXDhtTaBT61g1dhUGbeNXWtmddrJrskmrTCOtKo3jpcdJzE0EYHDUYN7q9VaDRpd/8Vdiu2ePHkR+922DbVzRpqkUZ6SidevMmBbDodKKKtAd3wnNXNYRRxbCupdOTwO3HA3RvSGwpes3XZULVTmn/nKprSymwKQgXRlHBhHkO72B+vfBHuxjcEIkYpv7qD7ggelAyel80bNg0mnIdNvB0d3rUSiVDHv0KVr0bPxKxwvBZq7l+6cexlhehpuhJyi64uapZuA9LYhq7QcS1O4vpnJ5GpLVicJdhU93I+7J/3Xlet77B1xGk09ZOF0jrpRwqig0Mf+tPTjsIj3HxZEwKBKnw8HxzX+yff4vGCtcoVoPgzcJQ0fQbvANdcs0nUfWUfxrDU4CUPkq8J3YrtGO3ecjKSmJxYsX1+V3eHt7Ex8fT1xcHNHR0Q2uGDOZTMydO5fc3Nyz9qvX6+v6CQ8PR/fXkueU9TD/ThxWL4rsXyFJWgwjYtD1Prs1gDW7mtJvDyNZJdwVm/CNWIswbjYOn1gWLlzIyZMn8fLy4tFHH8XdveEbpChaKS1NJDfvFyoqXKuM4uP+S2Tk5HOeH6ezlgMH76Gqah9qtS8dO/yGp+e56x5arVbmzp1LZmYmKpWKm2++mZYt6wsuSZJwOBxnT1p3WGHZE3B4nivMH9KO7b7jWbv7JJ6enjz66KN4eHggijb27B2L0XgcP98+tGv3XZ1gfT4phx/zywjRqtnQuRmpJgujDqTirhA42asV+/cMo7Y2g/j4F4mMuPecx9QYNm3axMaNGwG46aabaPdXUdTsnZD4LqRvPN04vDMMeBGpSV9++uknMjIyaNWqFePHj69rUlxczI8//ojJZCIgIICJEyfi/beSPI1BkiSqqqqoqqqisrKS9PR0kpOTMZvNaDQabr75Zpo3P7NW2f8iiiInT55ky5YtdYJFqVQycuTIM6ZkJUmiYkEytfuLUbhJ+AYvxa3wGwCckg9ltmmulazYCeybiWboPaw+5WSv0+l46KGHzisSHQ4HmzdvZsuWLUiShFqtpn379nTt2rUugZ+0PzH/8DaVjvtxSq43e22MAc3oIBa8OY2q4kJQ6FF7DKLDsF70uDmuwZwnm8XMzkW/sW/lUkSnK4dHqVYzcPLDtOk/5Mxz7nCQeftELIcP49W3L+EzvzrvlJ0oiYxZOoaMqgz6RfTjs/6fnem477CQVZ1VJ5DSK9NJq0ojpzoHh3RmJYmH2j3Ew+0ePmfOlKOkhLRhwxFNJiJmf41X794Ntkvdu4ulH7wBqBgU+xR+osvfK/Cx9ihrjsMfz7heCMBVB/PGT7GHdyM9PZ2srCzsdjtOpxOz2YzRaKSiogKj0XjGfgICAvDRe1FZUkBxteslthv7GcomBI0Op0cU5rIYLM7WqIRi1EImCqEGCRUF9nFopDgEQcChUZDqs59DO9eAIDDg3gdpP/TC8i4bw8YfZ7P/j6W4eQQS6XU7Hj4etB8di4deg2h2YNyahy3bZQejCdfg6/YpqtyVro09/OD+jeBzgS+W50AWTleZKz1VZzHZSfw1CWutnY5DNRxYvZzMQ/vrVkkYAoPoMmYCLXv3R/W3hGbJbqXsre+wWFqjcjcR+PwgFG5nyfm4AP6KMm3e7Cr7ERQURN++fWnevPlZ33T/zl/naffu3WRkZKDVavH09KzL+flffHx86N27NwkJCSjyD8Cv4zDWdKbS8TioBHxujnd5R/1P5Ml8rNS1oswhoRGOERD6E8LkFdjVOubNm0dqaipKpZLbb7+9wULOVVUHKChcTFHRShwOV800QVDTssX7Da44awiHo4b9ByZSU3MMjcafli3ex8/v3G9wdru9bnwAzZs3Jy4ujqKioro/q9VKYGAg0dHRdOvWDV/fBvye7BZQu1FbW8tnn32GxWJh1KhRdOjQAYD09E/JyPwMtdqHrl3+QKt1JbUeqallyN5kJGBhQiy9fHRIkkTrbccosztY0j6OCNMykpJews0tjK5d/rjkqJMkSfzxxx/s2eN6gPTr148+ffqcvp4KDkHWdtdbeLDLByspKYm5c+eiVCp57LHH8PmfmmAlJSX8+OOPGI1GvLy8uO22287pv1VTU0NOTg7l5eUUFhaSlZV1ho8XgK+vL7feemtdGaf/PQ6TKRmNxg+Nxv+M79LS0ti8eTPZ2a4FBb169WLAgAH1fjeizUnJzEPY810u0W7xnmAqxlasRHS4Iaid+N0cglv7ZhQWFjJr1iwkSeKOO+4gLu7MItKSJDYYFS0oKGD58uXk57vyogRBoFu3bgwYMMAlypdPQdr7I7UMolJ8AskOnt1DUPXyZv7r/6Gy0CUCBVU4Ov8OtB3YlXYDW+Lmqaa2uoojG9awf9Vyaqtcy+EFhQ+SZALJhkqjZfJns/HyOfO6taamknHTzUh2O/6PP0bAo482/A/7GyfKTjDxj4nYRTv3t7mfaEM0aZWnBVKeMQ9Ratj13FPtSYwhhhhDDLHesXQM6kjbgLbn3Wfe089QvXIlbq1bE71gfoMCT5IkfnnhSYoz02npN442+lhQCQQ+1A6NeRfMu8O1OlPjBb2fwpIwmXWJWzh8+HCDxcP/jre3N1FRUcTExNCkSZN6z5y/R3HbK5IYJq47vaJSa3BFb6O6Q3UBpKyBymySzDcjiveiUwpIbkqygpPZtXEhAN3H3U73cbddtjIu6fv3sOQ9V9WN3uGPEqpu+P4haJToW1bglfYQgr0alBoqEh5G2e1B9AGN89JrLLJwukZcyak6SZJI2b2LPz57F+cpA0wPgzddRo+j3ZARZzioSpJEzfe/UZ0cDtgJfLAlmiZnD6kbjUZKSkowmUzU1taiVCrrIkZ2ux2j0UhpaSkFBQUU/63ieZcuXRgyZMjZk3DPg9PprOeLZLPZyMrKIjk5maysLEpKSupW5IWGhjJ69GiCpGKk70dSWjMFq+jK2VEFeeDVLQS3Zr6ulVc7CzDtLgAE3BR78PX7FcV9yyh3urNo0SLy8vJQqVTcdtttZ4gmp9NCUvKrFBQsqPtMqw0mOGgUISHj8fS8ML8Tm62cAwfuwGhy+WUFB99EWOitGAztEYSGc8scDgeJiYls3769rmDw2fDy8mLSpEkNiydgzZo17Nixg8DAQB566CEUCgUmUxq7do9Ekmy0bvUpQUGuN0pJkhh9IJXdVSZuCvTmq1bRdf08eCyTpcWVPBUdxNORPmzf0R+brRhfn560a/cNCsWlFR8VRZF169bVJck3b96cESNGnI44/g2LxcLs2a5p1p49ezJ48OAG+6ysrGTOnDkUFxcjCALR0dG0atWKoKAgvL29qampoaioiOPHj5Oamsr/3voUCgUGgwG9Xk9YWBjx8fENenmJop3i4j/Iyp6N0XgCQVAREDCUqMj70Ovb/k9bkcTExLoXj27dujFs2LD6bawOqtdmYdyeX7c+AkAV6I7/Xa1Q+bsjiiLff/89OTk5tGzZkgkTJgDgdJrJzv6GwqJl2GylOBw1GPQJxMY9j493/eRpSZLqFib8JdT9/f25+eabCQ0KgN9uh5S1mJUDKTNNBcAwIgZlOy92/z6fA6tX1kWSXKgRBCWSZOMvIyJBYUDl3h9Pn2aYjTZsNb8hOQtoM2AoQx5s2HqgfM4cil535RYFvfgivndMbLDd35l3ch5v7nrzrN/rNXrivONoYmhCrHcssYZYYrxjCPIIumBBYNy6jZz77gOFgugF83FvIFcMIOvwQRa+9SLuSh9uiLgflSDgMzYeT48dsOh+l9dW3CAYPYO0YhNLly6lutq1evivyLunpydKpRI3Nze8vLwwGAwEBASc3QPuFH8XTwYvD4Z3jiWubVdU3mE4RZHi4mKcTiduGjX6Yz+i2fIeWysfxkc5BINSQHBXUdAkj00rfwAgYehI+t9z/xlmnRdKTVkpPz3/BJaaanq2nki4KRxRArdYA+KpleIKrRJ1oAa9czbKE6dyviJ7kNf9Deas2IhOp+Pee+897zm4EGThdI24ksIpbd9uln/8Nk6Hg9hOXek6ZgJBsXENXsT2ggoqf9iItcqVfO3doQyvCWPqtcnNzSUlJYWCggIKCgoafLM+F4GBgfTq1Yu2bc//ZnYpWK1W9u3bR2JiIjabDU9PT+6//368TelIP46jprY/NY5xSDT8xuKpXIV39F6EcbM5lm9k2bJlWK1W3NzcuPXWW4mOjq7XvrY2i6NHH6fGeAxQEBw8mpDgm/Dx6XZWkdMYnE4zaWkf1uVHAajVvhgMHfA2dCQkZCwajd8Z2xUVFbFx40bsdjvBwcEEBf0fe+8dHkX5vf+/tm82vfdGCAk9oTcpSlEB6YqCgNgVe++9F0BEQRCRIiKgKAhSpPcSQkshIb33ZDfZPvP9Y8KGkEJQfPv5/S7v6/KS7O7MzszOPM/9nHOf+/jj5+eHTqcjNzeXPXv2UFpaioeHB7Nnz25y3xUXF7N48WIEQXBEJERRJOHUNKqqjuLtPZTu3ZY6Jo71RRXMSc5Bp5BzsG8sgZoGMrSqoJxnU3Pp6+7Mrz2iqak5Q8Kpadjtdfj53UrH2PdRKpuSHJtNT0npNmqqE1EoXVCrvfHzHYWTU/NC/ISEBDZv3owgCGg0Gm666SZ69erliMrU1dWxcuVKCgsLcXZ25rHHHnO0i2kOJpOJX3/9leTk5JZ/oHoEBATg6+uLj48PYWFhhISEtOrjZbebyS/4gdycZZjMlyI36nriUL9P/3FERT2LVttYzHrq1CmHv9ztt9/eJCULYMk3YDxbitxVjcpPhybS3eHKn5CQwG+//YZKpWLOnDm4u7tTWrqT1AtvYjYXNnu8vr4j6Rj7ASqVR5P3UlNT2bRpEwaDAa1Wy3333YePmxN8fxvkn6BG8yg11bcAoPDW4tIvEHuYgsS9f5B2/CQ1JdlczvJkCn+Umnh8I3owcEoMIR08qCwxsvad3zBW/IBMJmPGxwvwCYto9lhLF3xJWX3fUL/nnsVz+vRmGwZfgiiKvHf0PXbn7ibCLUKKInm0cxAkb633dYmYCCYTGWNvw5qbi9fMGfi/9FKLn93w/utknU6gn//dhOuCJF3m0HxkP01DFAWyI+7kvPetXMzMclQ9enp6MnbsWCIjW2iJdQ24ePEimzZtchTrqNVq/P39KSkpaWShoVKpGBwXRZ/E19hU+DIx2nZ4KuXItAoqOlWxfcNXgJTdiL/5NrreOAK107UXXYiCwE9vv0xe8jliIvvTncHIgJIgF3o8Xp+2FkUpRf/rI1CRIekZh7xIiv9Y1m/4GZvNhr+/P9OnT292UfVX8R9x+h/jn07VFaansvaNF7DbbHToN4hbH3sWOXJEu4BcI0V6RJuA+XwmtXvOYyx0AxTIMOEWlYXL7NnI6lfIFouFnTt3cuzYsSbf4+npiZubGzqdDrvd7niw1Go1Wq0WHx8ffH19CQsLaywm/R9Ar9ezatUqiouL8fPzY/bs2WgrU2HXewhph6i1jcRo74VF7ASIOMkP46zahmbwSGRDXyA9M4tVq1YBEBYWxsSJExtpXgTBQk7Ot2RmLUAQzKhUXnTpPA8vr9b9TErMVr7KLWF9USWeKgXdXHUM9HBhlI873uqmUbiqqhPkF6yhrOxPbLYGsiqXawgKup2ods9eU9pLr9ezbNkyKisr8fb2Zvr06Y6UVXp6OuvWrcNsNhMVFcXdd0t9+goLN5CU/DxyuZZ+fbfh5CRV75VZbAw7nkKpxcbL7QJ5PLyxMDfbaKbvkWSUMkgd1BVnpYLy8v2cPnM/omhFLnfC3+9WXFxiUak8MZpyqa5OoKrqKIJgabQvhcKFbl2/avH6FhQUsHnzZkcaKSgoiBEjRlBVVcWhQ4coLS1Fp9Nx9913OywArobKykrOnTvHxYsXKS8vR6/Xo9PpHPd09+7dHWagbYHNpifx9L1UV0uNtFUqb8JCZxEcfBcmUwE5ucsoKtoIiMjlaoKCphIR/lAjC4ft27dz6NAhNBoNDzzwQIPG6Cqorq7mq6++wmw2O5pN6/XnOXZ8PCCg0QQS1e5p3Ny6IZMpyclZSkHhT4iiHZ0uirju3+Lk1LRvYl1dHT/88AN5eXl4eXlx3333oRNq4esBiIYS9IGfoy/q5PAcQgaaKA9cBgUjD9eiL6tEX1GL1QxeQUFonZUoq8xU/3YRa2EtchcVdSIcztxJSe0RIrr3YNLLbzd7jqIoUvze+1TWP7dKPz98Hn0Uj9unXLeU0V9Bydx5lC9ejDIggHabN6NwaV5TVpqdyYrnH8NbE8TwIOnZ87tdi3rrbaRbfdnrPIbc2oaFiVwup2fPngwfPvyaIymiKGKoTcVkzEGt9kPrFIKmPlVsNpvZu3cviYmJjaQQGo0GrVaL0WjEYpGeT293Z0ZVb+Fg8dP0cHbDWylHppJjirHzx+6vMRmkMcvZ04sR98+55qq7C0cOsGnuh3g6BzIydBaYBXLMAmG9EwnxyJdafWXulSqqAdxCECcu4VC+yI4dkoVH+/btmTJlynWNNsF/xOlfwz8VcbLbbPz+xcfIkDPQbyDGJBuiIE3KcnkdCo0Jq9ENaJiotaozeEyMQRnf4D+Sk5PDxo0bHSubTp06ERYWRmBgIAEBAdf9RrzeqK6uZsmSJRgMBqKiorjrrruklIm+CJI3SW1KLAKoXZCHdYPAbqB1p7Kykm+++Qaj0Uj37t257bbbGqVabLZaEk7dhV5/DgBPz/506vhxkwjBlVhZUMZrafmYhKaPi0IGU/y9+CQmFFUzVX+CYEGvP0d19SmKizdTo5ca8Pr53kKXLguuaWKorKxk+fLlVFdX4+zszIgRI8jOziYxMRFRFAkLC+OOO+6o15EVcvTYrdhsNbSPep7w8AcBaeCdfS6LrWXVxDhr2d6rA5or9GqiKNL7SBJ5Jiuru7XjJm/pHi8r2036xY+orU1r8RidnaPx8R6GINqoqjqGXn8OmUxJbMy7BAVNaXYbQRA4ceIEf/75ZxODSRcXF2bMmNGszqituDJNfC2wWmtIPD2bmppTKJWutI96gYCAiSgUjZ+hmpqzpKW/T1WVtFBRKHTEdHiLwMCJjmP4/vvvycnJwc3NjalTpxIU1Pp9J4oiq1at4uLFiwQFBXHvvfcil8s4cXIKNTWJ+PgMp0vn+U3c6/X6JE6fuR+zuQi12oduXRfj7h7XZP8Gg4ElS5ZQXV1NeHg4kyZNwq3oCPwg/U7C1F+oq+5I3YliLLkN5F/Tzh3Xm8LQhLuBQoY134DhUAF1CSVNvsMk2Pk950tsoolZn3+Nd3Dzza9FQaDqp3WULV6MrV5YH/TZp7iPHt3qNfqnYE5LI2PiJLBaW22tAvDHV3M5v/dPhgfdj7fGC11XZzzy7+DPug4cREqZKhQKunXrRkxMDBEREa1GTptDbW0GxSWbKS7eTF3dxcvekREZ8Rjt2j3heEUQBIqLiykqKsLf35+AgADkcskk88yZM2zfvp3a2lqcNCpuqTvEsdI5xDvr8K9vo6UKd6Hcs5Qjh9ZTWSwtaDreMIwh02fj7NF8/77LIQh2Vjz3GPqCEsZ0eASVWUWFTeBUXTl3+96LXHaZJEHpBJ0nYBn2Jr/t3M+5c9LY3LNnT2699da//Ny2hv+I07+EfzJVZ7fZ0P9yFMPJlvUucqpwck/Hpa8/qgFjQCsdg81mY9euXRw6JFWEubm5MW7cuGYF0X8VZksZtYZUrNZKLNYKrJZKLNZyTKZ8zKZCFEpnnLSheHoOIDBw0l9eMRYUFPDdd99htVrp1asXo0ePbrIvURQdr5WVlbF+/XqKiooICgrinnvuaZJ6SUp+kcLCdSiVHnSIfpWAgPGtHp8oiszPLubDTMlnqIebjifC/VHKZCTU1LKtrIZzBqkdxxhfdxZ1ikDZimWCKIqUl+/hzNmHEEUbHWM/Iihocoufbw41NTWsXr2a4uLiRq/HxcUxZswYlEoloihwKnEmlZWHcHPtRs+ePyGXS9fih8Jynk7JRSWT8UevDnR2aagwNNvsaOqdw59KyWFNYQUPh/ryRvsGcaZUgXaS0tLtmM3FWKzlaNR+uLnH4+nRB2fnDo5rKghmkpNfoqhYSlN16PAmoSF3t3huer2ebdu2kZKSgp+fH+3bt6dnz56NDBxtNj2FRb9QVXkML6+BBAZO+tuaq5ZgNOZy5uxDGAwpKJXuxMevwM215cbNoihSWXmIixmfU1OTCECA/3hiY99HodBQU1PD999/T3l5OUqlknHjxtG1a9cW93f8+HF+//13lEolDz74IL6+vuTnryEl9VUUChf699veojGpyVzE6dP31euwVERHv0xI8N1N7veioiKWLVuGxWJBoVDQvXt3htn24npmKahd4Yanod/D2GrAcLRQ0mLZpGlDppIjd1Fhr2wgu869A3AdFopgtFGxJgVbmZGUmmROl//G4Gn30Pu2Sa1ec8FioeTTT6lcsVJqortly99uMHytEAWB7LtnYDx5EpcbbyT0q4Utfra2qpJvHrkHf3UYgwOmICpk+EV8yaZ8OIdUidmnTx9uuOGGa0o3WSxlVFWdoLo6gYrKwxgMSY735HI1zs4dsFoqHGnjqHbPERHxUJv2bTQaWbVqFfn5+Thp1Iy0JXMkfzphag1dnWXIRYlAyV1UlOoK2XXsewTRhkqjpfe4SfQaMwGVpmXil3xgD1sXfMaw4LvwVYdgwcKuahnBzlsw+dXi5RtAO085XmEdUbS/kXMXMti7dy96vR65XM7NN99M7969/7Fo43/E6V/CP0mcag8kUblZaj/hEbAD3bA+4BaILScXe2k5qrAgFJ16I3NpnGoQBIF169Y59B1xcXGMGjWqxdL7a4EgWMjN+57i4t/R68+2eTtv72F06vhRs5qetiA5OZm1a9cCMGrUKEdT57S0NHbs2EFFRQW+vr4olUpyc3MB0Ol0PPjgg00cy4uLf+fc+ccBGT3iV+Pp2bpZqlUQeT09n+/yJcffp8L9eT4yoMnDvKOsmnvPZWERRcb7efBlx/BWyRNAVtYiLmZ8gkKho3evX69ZhG4ymfj5558pLCwkJiaGLl26EB4e7ji2nNzvSEt7F7ncib59NqHTRQJSCu7G46nU2gVebRfInMtSdEv3Z/DxH6lM7RPKm2M7s7G0ikeSsunkrGVXn6uX4rcEqcLsY7JzvgEgJuYdQoLvuuo2zQ2aubnLuZjxOXZ7reM1rTaEDh1ex9fnpr98jFdCEGyUl+8mKflFbLYqVCpv4uOWX9Wfq+H47WRlfU1m1heIop3goDuJjZXEzEajkZ9//pm0tDRkMhnTp09vdmGTkZHBDz/8gM1m4+abb6Zfv35YLGUcPjISm626TfYQNpuepOQXKS39AwBf35vp0OE1tJrGxSO5ubns2LHDUQHo4eHOTKddeBZKonZc/CFyMIT0weZ/IzXHBUwp5Y5myDIlaN2zcQkvQNOrD4T1B6UGY0oF5cvPI4gCf+R/i3O4P9Pe++Sq10+wWMgcexuW7Gw8p08n4NVXrrrN9UTV+vUUvvoaMp2OqM2bULUSGTy9Yws7l37FiKB78dL44BRt4EDut5yiC3K5jNtuG0dcXFybvtdozKWwcANl5bsdUfFLkMmUeHkNwt9vDL6+wx0aw0utkQDaRz1PWNgDbSIcJpOJlStXkp+fL3mOyWu5mD0cnRxu9EpGpeiCYK6PRHsrOVG5jYsXJSNYF08vBk6dQefBNyK7Ilot2O0sf+ZhPPU+9Pa9BWQW9lQLlCqrMfqex9KKv5SbmxuTJk26dk+7a8R/xOlfwj9FnCwZRZR8kwwocXXbg/szT4GmbTqYS/44CoWCyZMn07Fjx+tyTHpDCklJz2IwNAhudbp2qNW+qFSeqNVeqFSeaDVBaLVB2Gx6DIYUcnKXIggWVCpP/PxG4+11A1ZrFUZTLjabHsFurG+W2wt39/gW9T6HDh1i+/btALi6uqLT6ZpEW0AqsY6OjubGG28kIKDxxFBXl8nxExOw2fRERDxKVLunWz3nUouV+89lcaRamqDfaR/M/aEtu59vrydPVlFksr8n8zuGoWg1kmUn4dTdVFUdRaMJID5uxVV9n9qKurpMjh67FUGwNCIpNkFkwql0jtfU0s/dmQ3x7R3H+MPRHF7+pYEQ39U3jCdviaXXkSQsosiv8e3p6/HXtW6iKJJ+8SNycpYAENPhLUJCpl/TPkpKtnH23CMA6HRR+PgMo6hoIxZLGTKZgs6dPndUDF4rTKYCysv3YjTmUGfMorLyCDbbpYqn7nTtshCttrG+ShRFTtTUYRdFYpy1eKqa6tzKynZz+sz9gNioolEQBDZu3MiZM2dwcnLigQceaGSxcHl/v5iYGO644w7kcjlJSc9RWPQzLi6d6N3rF+Tyxt/ZHOEURZHcvOWkp3+IKNpQKHREhD9CWNh9jijkJWRnZ7Nx40YqKytxc3Njem9vfI99jEx/hRdbSG/EsIHYzD7YCgvR5C9DLjNiQo0eZ9RaV9ynzIeoGyn97hzm1EoK6zLYV7Keh79Z5fCeaw21hw6RM/veq1azXW/Yysu5eOtohOpq/F54Ae97ZrX6+Q3vv44lrYYb/Cdhl0Gty3v8ZJVaL02bNo3o6Nbb1QiClbKyP8kv+JGKigNcLrp3cYnF3b0H7m498PYeglrdfDVtRsY8MrOkvq1enoPo2PEDh/zAbjdTVXUUu92IQumMzinMUaxhMplYu3YtmZmZAARp/TBnR6HFwmiP93H3HUB1zQQEkwgKGZZ2ArtPraSqVEql+reLZtRDj+MbHll/Lnb2rFjKuW3bGR36IBq5E5X2RLZbvdF7SN0cgoODcXNzIysrC6PRWH+eLtxwww306NGjUZagRn8OrSaoxfP+q/iPOP2P8U+Lw8X881Qu3oyIGq+nJyPzaF4PcCUuj8xc7t/zV2E05lJW9ielZTupqjqGKNpRqTxpF/kUvr4jHD5ArUFvSOH8+Sdb1cNcglyuxtv7RgIDxuHjM7yRF40oimzfvt1Rui59Xk6/fv3o3r07FRUV1NbWEh0d3WxfvOqa05w+fR9WawVubvH07LGmyYRxCbU2O8vyy/gqp4RKmx0XhZyFncIZ5XP1gX5LaRUPnM/CJsJkf08+jQlF24pju9lcyqnEu6mtTUOl8iau+9Im5ezXClEUOXVqOpVVR/DyuoG47t85JtJ5WUV8mFmEq0LOrj6xhGql9NYf5wp5eHUCogg3xvqxO7UEUYTHb2xPQZiOVYXlDPd2Y1W3a4uKNXdsaenvk5srlRxHtXuW8PCH2rQ6NtSmceLEJOz2WkJCZtIh+jVkMhl2u5HU1DcoLNpwzeTJbC6hpGQrxSWbqa5OaPK+UulOYOBEoto910TPVGm18UxKLlvKqh2vxbtKadyRPm7ILzunixc/Iyv7KxQKF/r0/hWdLgKQrD++++47CgoK8PX1ZfDgwfj6+nLmzBmOHz+O1Wqlffv2TJ06FaVSSWXlMRJO3QnI6NVznaO1z4FKPd/ll5FaayLbaKGHm463o4Pp7tq4EqpGf44LF95ynKuX50C6dPnS0avQ8bmaGlasWEFZmRRp1Wg0eLuo8FEa8THn0LVqO55UNdomlyDWqyZRbb1E5ER6cJ4bBw9C0+UBiuaeRCbClrwl9JkxnbiRTQ0xm0P+089Qs2ULmpgYItf9hOwqzbivBwpeeIHqX39D07Gj9J2t2K+Y62r56r5pDPefhqcmAL1bFpssZ6lDx8D+/Rgx6uYWtxUEC9k5S8jLW4HF0tDHzstzEAEBt+HlNRiN5iqtquohiiJ5+StJT/8IQTAhkylw1rVHow2kquoYdvvlnnkyQkPvIard0ygUTk0sMxSocKoJR1vnTyen3fT1+BNjwDxMmfWmph4aSgOK2bd3Fea6WuQKBd1H3EpQh1hSD+8n/fgR4ryGEePeBwV5bDAKlHmkgQy6devGbbfd5rC0EQQBq9WKSqVq4gtoqE3j5MmpqNXexMevaBIl/Tv4jzj9S/hHfZwqs8FQhSy0+1U/e6lP1iVS0bt3b0a3Iqa0280YjdmYTHlYbTXYbZIrrUymdESDaqpPOXyILsHHZzixMe+2+UG+BEGwUlF5kJKSP6ipSUSj9kPrFIpK5YlCrqGuLouq6hOYTA0rWg+PvnTq+AlOTo1Nz4xGI2VlZVRVVRESEtLEBLE5lJXt5uy5OQiCCVfXznTv9m2z52AXRdYUVvBhRiFlVmmAiHHWsrRzBNHObRdxbiqp4qGkLOyitP2CjmF0c225lNdiKedU4iwMhiRkMgWhIbMICBiP3V6HXK7GySmiycTWGhpX0f3hqKY6ra9j9MkL2ERY0DGMKQHSCq6y1sKNn+2hss7K3f3CeXtcZ344lsMrv5zD11XDj08O4oZjKQjArt4xdHL5e2lfURTJyJxHVtaXAAQF3k779i+1eo5mcwknE+7EaMzCw6Mv8XHfNyK+oiiQnPIShYXrATmxMe8QHDy1xf1ZrZWkpr5JccnvNKzuZXi498LFtRNO2mDc3eNxc+verC3Fn+U1PJeaS4HZikomw0+tJN/cYGDY2UXLG1HBDPaSUimCYCPh1DSqq0/g6dmf+LiVDrJYXV3NN998Q21tbZPviYqKYurUqahUKgTByrHjY6mtTSMoaCodY9+jzi7w3sUCvs0va7KtDJgR5M3b0cGNhP+iKFJU9AupF97Abq/D2Tma7t2WNKm6MxgMrFu3juzs7Cb7VimVDI/W0dutFLnNSLbRidVpzljqnxu1Wu2o3FJjZlJnZ7xqxmFOqyKxYjdl7mZmfdJ8g9wrYSsrI2PsbdgrK/F+8EH8nnqyTdv9VdQePkzOPbNBJiNi7Y84XcWCJeXgXo598yM3Bt6FTRQ5ov2OFFk4fp4uPPDoky163tXUnCEp+QVqa6UojFrtQ2DgFIICp6DT/fU0VV1dJknJLziqPy9BowlAqw3GZqtxLGSdnCLo1vUrXFxiACk1vGXLFgdhRpCjMXvjZdIxxX85TsOXUPVnFfZqSc+mjHLhVMUukhJ2N/oub10wNwVMQybKyBa2slPrhCi3061bNyZMmNCmhZLRmM/JhNsxm4twc4ujR/xKR4/Q64H/iNO/hH+SOLUFVVVVnDlzhpMnT1JdLa164+LiGDt2bJMqhIqKQ5SUbqWq6kT9Q3P1n1wmU+Du3gtfn+H4+Nz0tx7mq0EURQyGFIqKN5KXtxpBMKJQuNC50yf4+rZtZdocysp2c+bsw4iiFW+vwXTpsqDZdGBarYmHk7IdIu8IJzXPRAQwwc/zqlql5vBneQ1PpuRQapEmku6uTozx9WC0rwftdE2rGa3WalJSX6WkZEuz+1OrffDw6IOnZ3/8/W5t1pcHpHTTseO3YbVWNqqiswgCo05cILnWxFhfD77p3KCFeunns6w5lkMHfxd+f/wGVAo5Jqud7m9tx2wT2PHUYD4pK+e3kiom+XuysNP1uQ9ycpaRlv6e4/wCAydLaV2lO6GhMx36DZOpgIRT0zEas9Fqgujde2OzejlRFEhJfY2Cgh8BiIx4nIiIR64gWJIwPyXlFcwWKdXr7haPn/9o/P1ubVFkfQllFhsvp+XxW0kVAO2cNCzqHE43Vx2lFitLcktZll+GwS4VdYzwduOTmFACNCqMxlyOHB2FIJjp0vkL/P0bFjeVlZWcPHmS1NRUSktLiYqKok+fPkRHRztW4dnZi0m/+DEqlRf9++1AULgx5mQaZ+vv2buDvBnj64GfWsmCnBJ+Lq50HMPSLhFNqib1+vOcPn0/ZksxWm0wfXr/ikrVdCFitVqprKykrKyM8vJy0tLSHDooT09PPD09yc3NxWq1EhkZye23346TkxM5OTn8sX4FBTU2XKhj9g33ULejjBJTLruL1vHINz/g5NY2El6zbTv5Tzwhpex+WI1TG/VC1wrBZCJz3HhJVzVtGgGvvXrVbTbP+wiXC1rau/UgVZnHfmUqMkQefOjhRnKBurpMSsv+pLrqBHpDsmOhqFJ5Ed3+Zfz9x7QYBb8SqbUmNhZXkmk046ZUEKBRMSPIB596SxRRFDFbitHXnMNoysXDvSeurl0vK6LZ7XgGVCovesSvcpAnu93OyZMnOXToUEPzdhHc6vyYFvAnvjPmoT9pQ78/X+qFp5Rj7SAjvS6B0vwsvOz+dJH3AxvI5Uf4VmHBrrDi6xHIg3PubZN5stlSRkLCndTVZaDTtadXzx+bvTf/Dv4jTv8S/g3iVFRURGJiIhkZGY0cvV1dXRk7diwdOjTu1i2KdjIy5pKV/XWj1xUKF3RO4ahUHijqiYQo2lAqXNE6heCsi8Lbe3CLE/Q/ibq6LJKSnqW65hQymYru3RZftW1Jcygr38OZMw8jihb8/G6lc6fPmx2YTlTXcveZDCptdtyUcp6NCOCeYN9mbQVAGpTO5dcgl0OAmxYvZ3WzK6gyi42XLuSxubSqEU3t7KLl0TB/xvt5NErngDSgXcz4FIulDIVCh91uwmJpXN6tVLoSHvYQoaEzUSic6o9JoKBgLWnpH2K3G3BxjqF3718d5/t5VhEfZxbhpVKwr09HxwCbmFvFhK8OIoqw9oF+9G3XQEimLT3CwfRy3hzbiR7d/Bl54gJyYHnXSEa2IW3ZFlRWHiEl9TXq6jIava7RBBId/QpmUwE5ud9hNhei1YbQI35Vs35ElyBFs+aSlSVVQGm1wYSG3oNK6YbFUkZh0S+O1bZO147OnT7Hza3lirbLUWOzM+FUGucNJuTA/aG+PB8RgLOy8SKl3GJjbnYRy/PLsIngqVTwSUwoY/w8yMj8gszM+Wg0AfTrux2lsqknkCAITVIWtbUXOXZ8LIJgpmPHjwgKnMyinBLevFiAl0rBwo7hDPNuPAb9WV7DvecyMQkiI73dWNIMeTKZi0hIuBOjMQcvz0HExS27qvHrJduIHTt2NGoT0q5dO6ZOnYr6slSazWZj4QevUGl3YkiwiuiLgxFFgY05C4i64W5ufWRcq991OfKff56a3zahiW5P5K+/NhEk/12IokjB8y9Qs2kTSl9f2m35/aqVfDarlUX3T+Nm39loFDp+Vu+gUq6gd6cIRt8+C4Dq6kRSUl5uEsEH8Pe/jQ7Rr7apcCbXZGFjcSW/FFeSVGtq8n6Ms5Zf4tvj1YzOrjlYrVWcSpyJXn9OIk89fsDFuUGLJYoiBQUFHD50hHPnJe2j2uLCVNUO2k2YhTXwNqp+u4j5Yn17KrUcubMKe5UZRNBo0zhqPcgJVSgKQcuTz87B1c3Fse+Wok61tekknr4XkykPjSaQXj3XNdEWXg/8R5z+JfwviJPVaiU7O5vi4mLS0tIcXdovITw8nPj4eDp16tRowAKp9UdS8nOUl+8BIDBgIj4+w3F3j0Ot9vtXTeWuBlG0c/780xSXbEYu1xIf9z0eHr3avH119SkSTk1DEMz4+o6iS+f5TUiTKIr8UlLFMyk5GAWReFcdK7pF4qtuedWXmFvFO5uTOJld6XjN303DwCgfbu8dSr92TQfAErOVP8qq+b20mgNVekfD8lhnLcu6RDYbgbocNlstBkMylZVHKCnZ4hiA5XItHu69UKrcqaw8jNUq+XW5ucXTpfPnDvFnSq2REccvYBVFFnUKZ7y/tHIz2+xMWHiIpMIaJsYH8/kdcY2+d+HudD7ZlsqITv4smdGLZ1JyWF1YgZNcxoa49vRwb725bFshCGby89dQW5eBUuFMSek2jMbG6SGdLpL4uJVtHkALCtZzMeOTRrqRS5DLnQgOnkpUu2ccxPNqMAsCd53O4GCVAV+1ktXd2rWafgW4UGtiTlI2Z+ojQq+0C+SREHeOHL0ZkymXoKA7iI15t9m+cpdDFO2cOHk7NTWJDs1apc1O/yPJVNvsfB4byl2BzU+8+yv03H02A5MgMsjDhSVdIpoI2PWGFE6cmIwgGAkPe5D27Z9v0zWpra2luLiYmpoaFAoFsbGxzbqun/1jORuOZKHGyp0ut6AqEzlSsons2jRuuu9p4kY03yz3Stirq0kfMRKhpobgefNwu3lUm7ZrK8qXfUfJxx+DQkHYsmU497262WNm4kkOzP2WYYF3kiwr4KAmGY3czuPPvIhO50R2zhIyMj5HFG3IZCo8Pfri7T0YV9cuuLh0vGoKvsJqY2NxJRtLqjhW3ZDKVcpgmJcb/T1cqLMLrCoop8hiJc5Vx/q4KFyUbfM9slqrOHVqBnrDeRQKFzrGvtesPvDUydNs2vQbAnaUNi2T7TuJ7eyOePNHGPPdqfo9A6GmwfTWOaoGl7xZfCzOwSoX6RTcl9vvvwWTqYDMrIUUFW3Ey2sQ7SKfcFSpiqKdkpI/SEl9FZutBienMOK6L3NUA19v/Eec/sf4p8Xhl1BVVcWqVasa8s1IVWMdO3akc+fOREREtNgZvaxsN8kpL2KxlCGXa+gY+wEBAW1f3f1fgCBYOHPmQcor9l3Vefpy1NVlc+LkZKzWCry9h9Kt69dNPH7Sak28dCGPA1WSvusmLze+6RKOcwtGa6IoMnfHBb7YJfX30qrkuGiUlBkaBgu5DObeEce4uJabUVZabXyfX8ZXuSXU2AQ6u2jZ0rOp+WRLEEWBouLfyMiYh8mU2+g9hcKFdpFPEBo60xE1sIsiYxPSSKipY6S3G993bWjr8Nam83x3MAtPnYrtTw3B17UxgTudW8W4hQdx1So59doIRJmMGWcz2F2hx0ul4KMOoYzxdW9CwK2CyP5KPSdralHKZOgUcoZ4uRLr3DaSYrfXkZ7+McUlv+PiEoOvz3ACAiZek85L2o+R/IIfKS/fiwwZcoUWT8/+BAZMaLZVTEuotNp4LDmHneU1uCjk/BLfnq5XIU2XYBEEPsgo5OvcUgBeigxkmksSp8/cB4Cv7yg6d/qsVQJ3KUWnVLrSt89WtNpAXkvLY0leGZ2ctezoHdNq9ea+Cj33nMuk1i4Q6aRmRdd2TTR7RUW/cT6pvjede08iwh/G23vo9WlZYrez5INnKbS5E+fsQa/ynuRbcjiQvwaQcdO9DxM38tY27etSWxZNbCyRv/x8XY5PtNmoWr+eorffAUFoc688gF8/fQ/3DFci3Lrxo/oQJrmF4b1jGTR6KhfS3iU39zsA/PxuJTbmnTZH8IvMVr7OKWFFQTnG+t6VMqC/hwsT/T0Z7eveiACn1pqYcCqNCqudLi5OfBITSrxbwz0qiiKZRgsKGYRo1Y3uF6u1ktNnHnRoogICJhAaOgtXl86Nrm9hQRHLlizHKppQ2DSMsCTR22UHin73I/Z9DJvZBcFoQ56zG+Wfs9hv788uRR/kdg2PPjKHWtt60tM/btSeCMDVpTPOLtHU1Jymrk6q7HN370G3rov+soVNW/AfcfqX8E9GnEpLS1m5ciVWay6hoZl4edWiVlvo0OENQkJubHXbzMwvycicC0gOzp07fd5m75nWUG21sSCnhBPVtWQazdTYBFyUclwViib/7+bqxCgfd8Kd/p47ud1uJPH0vVRVHa13nn6PwMCJLa7SDYYLnD33CHV1mbi6dqZH/Jom6ZDUWhO3nrxArV1AK5fxWJg/j4f7t5ias9kFXt14jh+PS0RlYo9gnh8VS4C7FpPVzsnsSn44msPvZwuRyeCTyd2Z3DOk1fMqMlu58XgKFVY7D4b48lb0tXX+FkWR2to0KisPYbMZ8PDsi7tb9yYEcXFuCW+kF+CqkLPvsl50288X8cBKaaBcNqsXN8Y21fbYBZH4t7dTY7Kx8dGBxIV6UGuzMzExndN6KYrS192Z2/w86OjsRI7JzIFKAzvLa6iy2RvtS46kwXk+MrDZ1jR/BTZBJNtkJkyrafG3+zswCwIHKw08l5pLvtmKWiZjdbd23ODVQLosNoG1J3IprjahVMjoGOjGsBg/1MrG9+elakaAT2NCuUm+n+TklxBFC+7uPYiPW9Wkag+gouIgiafvRRStDqPUjDozg48lYxPhp+5RDgF6a0g2GJlxNpNckwWdQs5LkYHMDvFpNIFmZX1NRuYXjoktOOhOYmLeuS7kJGPnd6w4kI0cgammweg0On7J2Yyl7gzIZNzx+geEdGrZVPQS7FVVpN94E0JdHSFffYXrjcP+0vHYDQbMyckYz56jcu2PWLMlzZb75EkEvtO2cy7LyWLFc49xW9ijFKgM7FKfw1Vh4fEX36K6en+9BYXkWRYcdGeb9imKIqsLK3gtLQ9jfYeCTs5abg/wYpy/R6NeklfitL6OOxIvUmWzIwNu8XHHV63EXL+QuVS8oJLJ6O7qxPsdQhxRU0GwkZk5j6zsRVzSv0ru/zfi5TUQD4/eyOVqyssq+ObrbzHba5Hb1YRW+zFEt5ZI57PIom+S+syl/I5NFPlU9hQmUSDEqSs3TzOReuF1QCr8CQ2ZSUnpVoqLN3O53lapdCMk5G4iwh9xOOHvqagh1tmJAE3b9F9txX/E6V/CP0WciouLWb58ORZLNX36/oZSaXS8J5dr6NZ1Md7ezYe3LxfchobMIirq+WYH5GuBXRTZVFLFa+n5DrFzW9HDTcfjYU3Ls68FgmAmKel5ikukzt9KpTvu7nG4u8Xj7t4DtdoXs7mI0rI/KShYgyja0WqC6NVrQxPLhFq7nZtPXCCtzkwvNx0LO4W3Su7yq4y8sP4MB9LLkMvgvQldubNP02a1giDy6q/n+OFoDjIZvN/C5y7H9rJqZpyVVljLu0Rys+/10Q1dQrbRzNBjKRgFkU9jQpke5O04p1vn76faaOW+QZG8OqZlUv3AihNsTyrmuVExPDqsPSBdw4U5JXydU+IY3K+Er1rJMC9XVDIZeSYreyulVh1eKgWrurWjh9tfT/PpbXaW55exPL+MfLOVCCc1z0cGNqsZuxaIokhCTR27K/Tsq9RzWl+Huf78Ip3ULOoc0ai832C28fCqk+xPa5wO9HJWMzE+mJkDIgj1avj8p5lFfJpVhIdSweF+HaH2FGfOPIDNVkNw8DRiYxr3cNPrz3My4S7sdgN+fqPp0nk+AHedkaJ+N3q58kN3yferqNrE2uO5nM6rIrVIT49wT14f06lRFLHMYuPB81kcrI+y9nTT8U3nCIK1DZOx2VxMTs635OR+BwhtMiptE+w2vnn/GQrsngwSoom1hFHbJ4AtvyxBsCShdfHgns+/ROfucdVdlXz2GeVLlqLt2pWIH9c4+nK2+NVVVZiSkzElJWE6fx7T+SQsV1QKKry88H7gfrymT2/VeuBy/P7FJ1SczGJY4FS2K8+QoyxlUDtnbrhjJkePjcZqrSA09B46RF9dYA6Sb9yLF/L4vVTSDPVy0/F0RADDvFzbTF5LLVbeSi9gfXFlk/c09YuLS/e0UgbPRATwWJi/owCmquoEuXkrKCvb0ajfpNTvcClOTmFUV9ewdPEy9HVVyAQV7hVdCJPlMcD1ewLUqdTgzGbXGVzQa5Hb1Yy5OYhK87uASET4w0RFPevYr8lUQI3+LLWGNFQqTwICxjUq3jlvMDLm5AXclAp+6xH9txfil+M/4vQv4Z8iTiaTie+//x4f3114eJzAySmciIhHKCn5g/Ly3chkaiLCHyI4+E4HMbBYysjL/4HMTGlwbRf5FJGRc/7WcSQbjKwvruTn4koK61cr7XUaHgvzp4OzFi+Vglq7gN5mR28XMNjs6O12yi029lUaOFJl4FLDmHCtms4uTgRpVVRZ7ZRZbJRYrJRZbbgpFXTQaenhpuPuIG/cmxE3iqJARuZ8cnKWIghNhZGXw9d3JNHtX21iZSCKIo8l57C+uBJ/tZKdvWNa1DOJosiPx3N57/dkDGYbGqWc+VPjublLyz4ioijy1qYklh/KAuCNsZ2YNSCi1UHvlQt5fJtfhlom49suEYy4TqJrURSZkniRA1UGBnq4sD4uCplMhs0uMPWbI5zIrqR7iDvrHhrQODoi2KEkCfw6gVzB94eyeOO38wxs783q+/o1+o4Ck4VVheWc1RtJqTXhq1Yy2NOVIV6u9HF3bhTNOFip55W0fFJqTegUcpZ3iWxTpORKWASBMSfTHLqhyzHAw4XvukQ0e/+0BlEU+bNCzyeZhY5I2iV4qRSM8fXg9aigRrqR4hoT931/grP51ejUCib1CMFss7M7tZRSvVSqLZfBLV0DeWNMJ/zctNgEkREnUkmuNXFfiA/vRodQVr6H06fvBaBzp7kEBNxWX/m3m+SUl7BYyvD06Edc3DLkcg2bSqq4/3wWapmMPX1iaafTsDulhKd+SqSqztro2D11Kt6b0JVbuzbowgRRZFVBOW9fLMBgFwjXqvklvj1B2saRjKzsxVy8+DEymYoe8auuSV/YEg7+9AU7kioIRsYtphuRaRVkeag4enQBolBBYHRXpr79LnJ560TIVl5O+vARiEYjHlMmE/D2245nzFZe3oggmZKSsObnN7sfZVAg2k6d0PXqheeUKchbkD00h8rCfL576mEG+I7Dz7kdqzT7EWQCD0ybQHHtXCoq9tcblK5HLm99sq+02vgqp4SleWUYBQGlDF5uF8RDob5/eSGQUF3LwSoDJkFAEKGXuzMDPFxQy2Xkmiy8c7HAQdBG17eJujxqa7XWUF6+m4qKA5SV78ZqrUSl8qZ79yW4u3WntraWlStXUVRUCCKozV6oLB44e9RQKavEareDKCNAFkCHIXMRRSshwXfTocMbbSaBlVYbo05cIMdkYainK6u7t2s1JX2t+I84/Uv4J1N1ZWVnOXN2MqJoI677d3h7D0YQLJw7/ySlpdsAyXdJqwlCoXSmtjYNUZSiQeFhDxAV9XyrN2iF1UZqrUkiLxYbIlI6xWAXKLFYOVJV6yjNB3BXKrg/xJfHwv3arMe5VJ79XX4ZenvLPfcuh6tCzv2hvswJ80fXjHGkIFgxGJKprj5FdXUC1TWnsNn0aDWBaJ1CCQ2dhZdn/2b3/U1uCa+nF6CQwYa49vRrwQU7v8rIixvOOCIJPcI8+GRKd6J8r+6aLYoi729JZsl+KZLUN9KL18d2onNQ84TIKog8kpTNptIq1DIZX3UKZ4yfx1W/52rYUFTBo8k5OMll7O4TS0T9Su2TbSks3H0RV42S3x+/gTDvy7Q6RWdh05OQfwKiR8HU1VysMHPTZ3tRyGXsemYI4d5/PVJUa7Nzz7lM9lUa/vK5XqoO9FQqeKN9ECN93FmZX84XOcXU2gU6OWtZ0z0K/zaE9SusNn4srGBNYTlpdRLZcZLLGe7txlAvVwZ4uBDh1LRick9qCU//dJqKWgvezmqWzepN91DpPGx2gb0XSll+KMtx/7g7qXhnfBdu6x7Evgo9t5++iEIGu3vH0sFZ6zDHlMlUuLp2QSaTOQwqXVw60rPHGpRKVww2OzccS6HQbOXpCH+ejwxk/s405u6UfIA6B7kxpWcIIZ46PttxgeRCyfX8/Qlduatv4+hnrsnC5FPpZJssRDqp+SU+ulEqRBRFzp1/nJKSLchkavx8RxIUdDvu7r0aRbBFUZR6VBrzMJnyMJuLcXGJxdOzf5N0elVZKfO+XAiiyCxdb5SV7iCDTLWZYylfAja6jZjAiPvuvepvV/PHH+Q//QwIAi433QSCgCkpCVsz3QQAVGFhaDt1uuy/jii9/roT9fbFX5B34Awjg2eSLi9kjzoJb2Udt98/lHPnH0MuV9On9+ZWOwHU2Owszi3hm9xSx/jY3dWJDzs01iddCYtNYFdKCRsS8sitqCPE04koXxfuGRhJgHvb/OZEUWRdcSXPpuRiEUVG+bjxTeemVZcgRSETT9+HwZCEXK4lrvsyPD37YjKZ+PXXXx3tvS6H0uKKa00Hek34E5NsEx4efekRv+qqhRCXYBdFpp3OYE+lnjCtmm29OjTryv938B9x+pfwTxEnURRJPH0PFRX78fEZTvduiy97z05x8e/k5a9qYnDm5tad4KCpBAZOaTLYm+wC+yr1/F5azaEqA7mmxgK95qCSyRju7cbkAE+Ge7u1mTBdiRqbneP1uqhCsxVPpQJftQo/tRIftZJKq53kWiM/FFaQWl9m29FZy9IuEUTprq17eEv4taSSh85nIwJvRAXxcFhT13NRFFl7PJd3L4syPTsyhtmDIlFcg4ZGFEW+2ZfB5zsuYLZJA2KPMA8m9QxhTLcg3J0aT+qXkyeAB0N8eSUqEPVfvN4Gm52BR5Mptth4KTKQJyIk/dKBtDLuXnYUUYQv74pnTLfLem+d/B42PwXiZdqk7nfC+K+Z+d1x9l4oZUrPED6ZcnVD1tZgFgQeTcpmc2k1cuDjy1KIV8Pl1YFfdQpnon+Dr8t5g5E7T1+kxGIjWKNiedfIVgXch6sMPHA+y5F6dpLLmRXszSNhfq1WVV6KwAF0CnTjq2k9iPBpnkyeL6jmhQ1nOJcvEZiPJ3Xj9t6hzDiTwfbyGnq7OfNTXBRauciZs49QVrbTsa1criY05B4iIh52CNkvCcIjnNTs6R3L2dwqpiySTG9n9A/nldEdHc2ZLTaBD7Ym893BLOQy+Hp6T0Z1bhwtzTNZmHAqnVyThU7OUpHC5S73dnsdZ848REXlQcdrMpkKF5dYZMiw2qowm0uajQA7OYUREjydkJC7G+nulsx9j/xqK7doz9Ah+gNqj5eADA5bssnJk/y3Bk9/jN5jr14xV/XLRgpfeqnxizIZ6sjIBoLUuTPajrEormdLLGMdXz94N/09xhKki+I3xWlKVGXc0E6BJmobZnMhkRGP067dE422K7PYSNTXkVhTx6maOo5VGxyEqbOLlucjAxnp7dbigjelqIZ1J/LYeCqf8tqm43eIpxNr7u/XKD18Newqr2F2vWXFQA8XFnUOb/b+t9kMnD03h4qK/SgULvSIX+Ww8SgvL+f48eOUFpVTVyLDXq0ltlNHYvorSM2+DVG00qPHj3h69G7TMdkEkadSc1hXVImTXM7vPaP/tuluc/iPOP1L+KeIU3XNaU6cmIhMpqZf3z9aNJ40GvMwW4qxWWtwcgpvsUnseYORGWcyGjkbA4Rp1QRpVHirlShlMmyiiLNCjr9aRYSThlt83dvsCXI9IIgim0ureflCHmVWGy4KOV91Cv/bnkGHqwzckXgRiyhyT7AP70cHNxmcSmpMPLv+DPsuSNVP8WEefNrGKFNLyK8y8uHWFH4/U8AlKZBaKWdkJ38m9QzhhvY+KOsnKqsg8m5GAYvrq69kgItCTrBWzRAvV270cqOvu3Or7Vsu4e30Ar7KLSHCSc3ePrFo5HJK9WZumb+fMoOZO/uE8cHEy7yLSpJh8RCwm6HjWCnatOkJiUQNe5WEyPuY+NUhFHIZu58Z2jhK9RdgF0VeSM1jVaHUxPq+EB8eC/NvNUqkt9mZXC9Kv7I68BKyjWbuPJ1BhtGMVi7j45hQpvh7Nvqc0S6wNK+UDzMLsYsQrdPwQKgv4/08cb1KCfe+C6XM+u4YggjT+obx2phOaFWtb2O1C3ywJYVlBzPRquRsfmwQChc1I0+korcLjPJx49vOkShkkkGiXn8Os6UYP99bcHJqKDA4VGlgUmI6IrCmWzuGerky6etDJORUcWefUD6Y2NTdWhRFXvr5LD8ez0WjlPPdrN4MaN+4KXiO0cytJ9Mos9qYHezD+x2aFjXU6M+Rn7+G0tIdWK3lzZylDI0mACdtCCq1FxUVB7HbJR2Vs3MHOnX8yNFG6PCBfWzbuYtw8rhn/I2UJ8VjPFOGIsCZ39L+wFB2CFAy+sm3iO1/dZJes2ULtYcPo4nugLZLZ7QxMdeUcvsrOLd7Bye+W8fwoLsxiVZWafeDTGTiaAOl+l/QakPo13cbCoUWURTZVlbD+xmFXKhrSjCjdRqeiwxkjK97s2m5aqOVXxPzWXcij7P5Da19fF01TIwPpk+kF4XVJpbuzyCrvI4gdy2r7+9HZDNk3mITUMhlTRaB+yv0zDyXSZ1dwF+t5MuO4QzydGnyfNntZhJP30NV1VFUKi969vix1YhaSurr5OevxtOjHxFdv+et9AI2l1ahkIGzQsEUf0+ejAholFmwCAIPJ2Xze2k1Chl80zmC0b4eLX7H38F/xOlfwj+ZqquoPExd7cVrboJ6JXaUVfNQUja1dgE/tZKxvh6M9HEnztXpmrUg/ysUma08dF5qrquUwcJO4Yzz+2uusWZBYNDRFHJNFkb7uvNN54gmefLjWRU8sjqBUr0ZtVLOsyM7cO+gdtcUZWoNJTUmNibms+FkPqnFesfrAW5aFt3dk7j6NA/AH6XVPJOaS7m1qQjfSS5jgIcr94X4NDE7vISEmlrGJaRjFUVWdo1khI87giAy87tj7E8rI8bflV/nDGyY8O1WWHoTFJ6G9iNg2jqQyeD4Uvj9GXAJgGdSmPHdcfZdKOWOXqF8NPnv9dKD+pRmRiELciRzT7VMxtRALx4N82siAM02mrn7TCYX6ky4KeXs7RPbYnVRtdXGw0nZ7KqQrnNXFydmh/ggAy7WmVldWE6FVYqqTfT35JOYkBYtKC5HVlktt315gBqTjSk9Q/h4crc2azUEQWTGsmMcSC8jNsCVjY8OJMFg5M4zFzELIncFevF5bMuFBHqbnRuPp5JrsjA90JtPY0P541wRD606iZNKwd7nhuLn1nxk1mYXeGhVAjuTi1HKZbw7vgtTryha2FVew11nJAPSFa2Ym4qiiMmUi16fhFyuRqlyR63yRqsNahRVstvrKCr6lYsZn9d7i8mJiXmLkOC7qK6uZu7cuYDI0547cZ61k6K5pxBNdnQjQlnz43xMNWnIlR7MnvcV7r7/+44MV8PaN18ksiKGIF17Dgv5nNelEOBUQoc+uxBFK926LsLXdwSFZgtPp+Syu6LhmW+v0xDnqiPeTUe8q47ubrpmdTtlBjPfHshk5eFsDGZpLFApZNwU68+UXiEM6eDrWHSBpLm7c8kRMkprUSvlTO0dyuSeIVhsAjkVdWw5W8i+C2XIZBDt70LvCC+eHN7BEf2+UGvivnNZDnIXrdMwzs+TPu7OdHZxclTC2mwGEk5NR68/i1YbSu9eG5q1DKiry+LI0VsQRQvlkWt4K1/X7JgWqlVzf4gPXVx0JNca+S6/jPQ6M2qZjG86R1z3gpnL8R9x+h/jf+Xj9HdgF0XmZhXzeVYRAjDIw4WlXSLwuE5kqdZsQxBFXLXXt0T0EmyCyJMpkpBbDnweG8rUFkz+WsOlcvwAtYqD/WIdk6QoipwvqGH9yTxWHcnGJoh08Hfhq2k9aO93FdFy2g44MA+qc8FYBW6BENILut4O7Vp2OL/8O39NzKeyzkqwhxO/Pz4ID91lbsuCSKXNRo3NzjmDkd3lenZX1FB8WUXjrT7uvBUd7GjSC/B7aRVzkrIx1jtFr6hvyLvgzzQ+23EBrUrOpjmDiPa/7Px2fwB7PwStBzxyRDoXAJsZPooAax08uJ+TllAmfS1Fnb6d2YuhMVdv8NwW/Flew/zsYoe5nxwY7+/JY2F+xDhr+amogrcvFlBhteOvVrK8a7tW9R8g3fvzsopZmFtCXTPauhCtiqfCA7gr0KtN5GdPagkvbDhDcY2Z+DAPfnygnyMlBkBlNqRshou7Qa2DiBsgeiR4NkSKS/Qmbp2/nzKDhUeHRfHcqFi2lVUz+1wmdhG+7xrZbBNpURR5KiWXH4sqCNOq2dU7Bq1Mxsh5+8gorWXOsPY8Oyqm1eM3We08u+40m89I3exnDYjgldEdUV028b6Rls/ivFI8lQrebB/MJP+/1mroclgsFVxIe5vi4k3IZCp699qAq2tnvl3yDbn5BXQmlfETJmE2D6Tq53RkajnOM6P57vUnEGx63AP6M/vzl5C3Icr6v0JVUSErn3qMcWGPIZPJWKE8ilVZy5C48whuCXh49KFH/A/U2gXGJKSRUmtCLZPxcJgfD4f6tmn8PZBWxsOrTqKvJ0wd/F2Y2juM8fHBeDm3bEdQqjcz54cEjmZWtOlcQr2c+PLOHg59Xq3dzpvpBfxUVOGovLuEGzxdmBsbRohWjcVSwYkTkzCacnB370mP+JUOAbzkNr6WtPQPsNsNlLuO4UnDPQhIzubvRQcTqFFx3mDirfT8JlkQADelnG86RzDUS5pTS2pMeLtorttC9hL+I07/Ev7tXnUtocRs5aGkbA7Vlx1PD/Tmgw4hf8vrRhRF9l4o5Ys/00gu1GOsX7UHumuJ9nclxt+FDv6u9I30/tupnEuwiyLPpebyQ6E0EIz2defd6OBWvUwuR7XVRr8jyVTa7HwWE8q0ei3NxVIDT/90mtO5VY7P3tY9iA8ndUXXmseQvkiKwqRsbuEDMrjlI+j74FWPTW+yMnbBAbLK6xjZyZ/Fd/dsdRIXRZGUWhM/FJazLL8MuwjOCjlvREkC6S+yi1lW3+h1mJcr33SOwFWpYO3xHF7YILVLuKSxcSBzP6y4DUQBJn0LXSc3/tIf7oALf8BNr8MNz/DsutOsP5mHTq1gzf39HAPu9cCRKgPzs4sbrc5DtCryTNLA2t3VieVdI9v824Mk/l6SW8r+Sj2uSgXeKiXDvd0Y4+txVVJgMNs4mF7G72cK+e10AQBRvs6sub9f4+jOuQ3w8wMgXLGalikg7k4Y/LyDQP1xrpCHViXgrFaw/4Ub8XJW8+7FAr7MKSFIo2Jfn9gmjs8fZRQyN7sYGfBLvFTQsPxgJm9uSsJTp2Lf88MaL15EEerKwckLrmjsu2BXOp/vkITkPcI8+PKuHgR5SNoRsyBwW0Kao6owwknNhx1CHJPXX4Uoipw9+zClZTvQ6aLo0/tX0tNz+HHNGkQgWFnNHXPexLQ2C0tmDaoQF4pjDOxY+hEAXYY/waj7R/ytY7ieOPjTaoq3naOP760kUcIh7VnUmBk8fD9mSyGdO32Or/9tzDqbyY7yGvzVSjbEt6d9G7WaG0/l8+y609gEkc5Bbjw1vAM3dWx7lwdRFDmcUc5Xuy+SXFiDi1aJh07N4GgfRncLRKtUcK6gmg+3ppBXaUSlkPHplO6NTHtrbHa2llazs7yGc4Y6Mo2SnspdqeCz+tZBtbXpnDg5GZtNj6fnAEJD7sYumMnJWYpefw4AV9d4PpC/xeEaK6N83FjSOaKRbrPWZmdZfhknamo5pzfiplQwPcibOwK8HM9BtdHKuC8PEOnjzLyp8U30oX8H/xGnfwn/F4lTqcXKxFPppNWZ0SnkfNwhhMkBf716RG+ysjO5mB+P5bZ5JRPurWNkJ3/GxQXTOahlsWNbIIgin2QWsSCnGJsopavi3ZyJc9UxyNOFgZ4uyJGxr1JPep2JW309HFGYS1qfDjotu3rHoJDBupN5vPHreYxWeyO90dAOvq0fZ+kFWDVRijLJldD3Ieg0HrTuUHFRmkDPrpM+O/AJuOnNRhNXcziXX83Erw5hsQs8cVM0T43o0OrnLyHZYOTFC3kcvSxKcymuMjvYh7fbB6OUy9hytpA5PyQgiPDA4Ha8dEtswznqi2HxDWAohu53wYSvm37RsSWw5VkIGwCzt2KxCdz7/XH2p5Xh7axm/tR4BkX7NN0OSduTXV4LyFApZAR7ODVKLbSEM/o6FmSXOPr7uSjkPBURwH0hPk2KE0r0Jg6ml9Ex0I3YgL///JUbzGxIyGN3Siknsiuw2huGxdkDI3luVAxO6suITepWWDtdIk2hfaHTOLAa4eIuyK4XVCudYMxciLsTURQZs+AA5wtqeGRoFM/fHEudXWDosRRyTBbuD/HhnWhJYySKInOzi/m43jTznfbB3B/qS36VkZGf76XWYued8V24u199VCtzHxz8AgoSJOLk0wEmL4OAxn34tp0v4tl1p9GbbHjqVHw/uw/dQjwAKeLwXZ7kal9htaOQwfvRIcwMbv43vhyiKLKhuJIPMwu5wdOVDzuEOH4vi6WCo8dGY7GUEBx8F7Ex75CRfJp1a9dgRIuPm5b7ZsyhfOFZRKMNl4FBbD+1ltzzh5DJPbnrvfkEtPvrY9j1gt1mY9mTDxAnH0KALpIflceoVRoY1C4PWchuFAoXbhh0hI+yKvkipwSNXMYv8e3b5FlWqjczb+cFVh+VjDjHdg/i0yndGkc2ryOqjVZeWH+GP84XIZfB/KnxjO0e1OxnM+vMPJKUzSl9HQAvRgbwRLg/FZUHOX16NqJ4hdmt3Imodk9z3mkC95zLRiOXcaBvx0bR8bbALojc+/1x9qSWEuzhxG9zBuLt8p+P0//n8X+NOFVYbUw6lU5yrYkgjYqf4qLavNK5BKtdoFRv5kR2Jb+fKWB3aimW+sowtULOjP7h3NU3DP96X5r0Ej2pRQYuFOs5X1DNqZwqbJeFef3dNLT3cyHMS4e7kxpXrRKFXIZdEEkurOFsfjWCKBLgpqVToBsPD23fbEltssHIs6m5nKypa/S6s0KOSiZzOFWrZDLuCPAipdbIifrPftkumKocPT8cyyGjVCIbA9t7M/f2uBa1IY2QcwTWTAVjJXi3h9tXgv8VppGiCPs/hV3vSn93vR3GLQRl64PFyiPZvLZRWqE9OiyKZ0fGtIloCqLI0rxS3s8oxCSI9HLT8WK7QAZ5Smm4pIIaxi88iMUuMLV3KB9MbOiMjt0GK8dD1n7Jr+m+P6UU05WozIL53aXoyfMZ4OSBwWzjjsWHOV8gVYpN7hnCnX1C6RToTl5lHfvTyjiQXsbRjHJqLQ0DapC7lrv7R3Bnn9BGacmWkF5nYl+FnrF+Hk2qfPQmK9/sy2Dp/kxH5LODvwsPDYliYo/WHdubQ0GVkeWHslh5ONuxP5AWAEM7+DIuPpgeYVdo7M6uh42PSIL6rrfDhEVwuf9Q7jHY8QbkHJL+7nkP3PopO1LLuX/FiUZRpz0VNUw9nYEMGOvnwS0+7izLK+N4jXSvvh4VxCNhfoiiyOzlx9mdWkrPcE/WPdgfuQw4OB/+fEuKHF4OhQZGvQe975N0a/XIKa/jkR9Oci6/Bl9XDRsfHUiwR0PVUq3dzosX8lhXJJkoDvV0bVRAIogi7XVaers746lSkG+ysrqwnB3lNY59XOmpVV5xgMTEmQD06b0ZV9eOVPz2Bt8m1FGLM4MHD6Z/QHfKVyQB4DolkuXznsNm0RMedweTX7r7mn/X640Tm37m8A8/MC5sDvmKKrapE1FhZcyYEspqdhEUdAdlfi8x5fRFgCaVn83BaLGzdH8Gi/ZedDwv9w2K5OVbOyK/WobArAdDCTj7gMat0W/cFgiCVDyw9kQuCrmMz2/v3mK7KKsg8l5GAYvqi1ceCPHlzfZB1NamUlT4MyUlWxFFO0HBdxISPA2UHgw5lkKm0cLjYX68HBWEKIpY7WITV/2W8NEfKXy95yJalZz1Dw2gS/D11Tv9R5z+JfxfIU5WQWRdcQVzs4rJNVnwUyvZGB/dpHmsKIpkl9eRXFhDqcFMSY2ZUr2ZEr2JEr2Z4hoz5bVmrrwb2vk4M6ZbILf3DiXEs/U0nN5k5WB6GZtOF7IzudhRjt9WOKkUPDQkioeHRjV5wC6lqxL1dZysrmNHebVD9+OrVhKqVZNwiViJIuoiE0ElFoqLDY5z0qkVPDqsPQ8Nibp6zlwU4chXsON1KaoQ3BPuWgfOrWitTq2G3x6TKtIiboDbFoBX600ql+zL4L0tkhfK9H5hvDG2cyP9SWvINVkoMlvp5aZzECOzzc64Lw+SUqTnxlg/lszo1XCuogibn4STy0HtAvfvBt9WIl0LekF5Gkz5HjqPB6Q01id/pLDiSHaTe+VyOKsVqJRy6ix2B/l21Sh56daO3Nkn9C9FIussNiZ9fdjhURTp40x+pRFLvZbprr5hvDG2U5tW6gfSyli09yIHL5Y5zqNrsDuTegQzNMaveZsBmxn+eAlOfCv9HTtGujaKZlK8gh32fQJ7PgREGPE24oDHHVGn+2+I5JXREgF/Iz3fUVF5CVq5jJfbBfJAqKQn++10AY+vOYVaIef3xwcR7ecipQnP/iRt0P1OiSS5BUnWEhf+kF4f+S4MeKzRvg1mG5O/PkRKkZ7YAFfWPzwAF03DOYiiyLzsYj6qj3i1BWqZjLuDvFlbVIHBLhDrrGVjfHuHrufsuccpKfmdAP/xdO78GRhKOT9vAutsw5HLZDz08MOojxsw7M9H7qIi2fciibvWIFf68ui3S1Br/71iFn15Gd899RAhqmj6+N7Kb6oEShSV9PcpQ91lD4JgpH33dYxP1VBotjIjyJuPY0Jb3F9lrYVt54uYu/MCxTWSh1j3EHdevrUjfZtpFN6wYbb0u6ZuhawDINRrhDTuMOwlKRJ+Dc+VIIg8u/40PydIJqEz+4fz0q0dW6wWveSFBzDG1515sWHNNhS+dD/7qpXs7RnDznNFLNmXQVqJgQFR3tzRO5RbugQ2S6JEUWTZwSze2SyR6PlTW+//+VfxH3H6l/BvECdBFCmz2Ci0WMkxWthXqWdHWQ1FFukBCtSo+LF7FDGXNfEUBJF5Oy+wISGf/KqmjstXQimXEeat4+bOAYzpFkTHwLZb/l+OWrON1GI9F0sMFFSZqDZaMZitjtL8dr7OdA/xQKOUk19lZMXhbE5mS6vcG6J9WDS9J86algdLQRQ5ozdiEQR61jtV76/Q80NBObmnSjh3vmEi6h7qwR29QrktLqjRBNEiDCVSSX7qFunvTuNh/FegbkOpc9pO+GkGWGulVX+/hyX9kH+XFge1FYezeP1XyR+oT6QXC+6Mx78t0bBm8OHWFBbtvYi3s5ptTw3G5/Lw9oG5sPNNQAZTV0Ps6NZ39sdLEnmMny5F0C7DyewKvt6Twem8Kkr1ZjRKOX0ivRjU3odB0T50DHBDLpdhstrZdLqAbw9kklIkaZj6t/Pm48ndrslzRhRF5qw5xe9nCvFxUfPu+K6M6uxPjcnGdwczmf9nGqIo/dZfTI1r1axz2YFM3vk9yUGY+kZ68eCQdgyLaUVPItil1Nyle2LwczD0pcaRpuZwYplEZDRu8PgpdmbbuW/FCaDxpJBkMPJlTglHqwyM8nHnifAGi4aSGhMj5+2jqs7KU8M78MTwaGnyXDMV5Cq49WMpqiW7jCDv+xR210dAm9Gw5VcZGfflQcoMZkZ08uebZnR2J6prOWswYrYLWEURlUyGAJwzGDlRXUudXSBEq5Y6CoT7E+Os5bzByLTTGRRZrNzs48Z3XSTriJqasxw/MR6ZTEH/frtxcgpG3P0hP+49TypRhAQHcc/M2ZR+mYitxIgmzosVG18B0UbfSc8y6PahrV/nfxCb5n7IhSMHGB45Cw3u/KiVUrHTRovk6Ffh5NSO712X8GtpFe2cNOzo3aFRtWZBlZGjmeUcy6zkRFYFaSUGx3shnk48f3MsY7oGNh9lqimA0z9KUc6S843fUzqB7bIxvec9cOsnoLhCC1SVC6dWSveFX0cI7QPuUnTWLoh8/EcKi/dJlZXtfJ0ZHxfMyM7+RPu5Nllgriuq4OmUXKyiSLROw9IukY3mm2/zSnklTSJiX0SHsHTdeS4UG7gSHQPd+Pz27nQMbJg7bXaBNzedZ9URKWX58NAoXrg5tuk1uQ74jzj9S/iniVNarYlX0/I5XGXARSmX/HgsVmzN/Fo+KiVzwvyYEezTyBdDFEVe/uUca45JN6JKIaNToBuB7k74umrwc9Xg66rB302Ln5v0fy+d+uph4n8Aoijy2+kCXvr5LHUWO/FhHnw3q3ebUjuXYLLaeWR1ArtSpDL3R4dFcWefsKtGyhrh3M+SCNxYAQo1jHq/Sbrjqii9IOmDMvc2vOYSIFXfhfSSIhU+0Y022ZFUzFNrEx3lx9F+Lgxs78OdfcKICWhbe5KNp/J5+qdEBBEWTe/ZuEXMuQ2wfrb071s+bpOInfQ/JW2Xkxc8kShpuppBmcGMi0bZqq+RXRBZfiiLT7alYLIKuGqVvD+ha4vaiiuxaO9FPtyaglIuY80D/egd0Vj3sju1hCfWnKLGZMNZreD1sZ2Y0jO00b1cVWfhk22pDi3J5J4hPHFTdNsI3PZX4dACiQzfsQo6jGzTcSMI8M0QKDoDve+H0Z/yzuYkvj2QiUohY8XsvvSPajnKIIois+pNSDsHufHLIwNRy5E0asXnYOCTMOKt5jaUiO/Rr6X7+K6fIKpxU9zT9SaaFrvAR5O6ckfv1vsrthWn9XWMPZmGRRR5u32QI2qWcGo6lZWHG3q4WWqpnjeQhXW3YEHD0KFD6R8RT+miMwAkKs6Qmr4VnUdHHl78yXU5tmvF2V3b2b74C3RKd8aEPcQZeRbHVReJUBYQPSwZk7kAQ/D7PFgg6Sg39Yimh5szgiCyI7mYVUeym/QzBKnY4M4+YdzdP7z5CGlllpTuTf6tIQ0rk0NoP4i5GWJulcYQS50UAd3+GiBK6fdesyGsP5SlSgu5sz81LmCQK2HMPOjRkALdnVLCM+skR/xLcFIp6ODvwo2x/sweFOEoRDheXcv957IosliRA7f5eTDUy5WUWhPf5JYiAC9FBmK/UMUXu9Lx1Kl4aEgUw2L92HK2kBWHs6motaBSyJgQH0zvCC+Kqk2sT8gju7wOmQxeuiWW+29od12aTDeH/4jTv4R/rFedXWB+djFf5pRgvfTTiCLYRVDKkQF+aiUBGhU93ZwZ7u3GAA+XJuaIl/dOk8vgnfFdmBAf3Hrl2P8BJORUcs93x6k2Wonxd2XFvX3aHH35YEsyi/dloFHKmXdHHLdc1qfrqqgth9+fhqSN0t/+XSXR9BUC2zZDFKUKvFOrJQJlbazPIqArTFwirQDrkV6i55mfTnM6r7rRR/tEeDGpZzA3dwlstrKkzmLjnc1JrDmWC9DU5Tv7sFRBZ7dAv0fg5g8abV9SV8La1LWcLT1Ljj6HB7s9yIToCZLP01f9oDwd+s+RNDN/E9nltTy5NpFTOVWOY33zts4tRhcFQWT+n2nM/zMNoLEo+grkVdbx9E+nOVZfyBAb4Mr9N7RDBJILa/jxWI5DS/LiLbE8OLgNA7MowtFF8MeL0t/NRG9qrbXsytmFIAp08OxAe4/2qC5f9Wfug+/HSnqxRw4jeHfgsTWn+P1sIR46FX8+PaRF4evKw1m89ut5NErJQDPa37WBBGvc4InToGtBPC3YYd0safJVqGH8102OffHei3ywNQVntYI/nhx8TVHA1rAos4i3zueisIlsuKEjfb1dKS/fR+Lpe1AodAwccACVyh1Ofk/ipq/ZyM0ATJ8+He8zIrXHihDdFaxP/BABgcmvLiC8a+tp7+uNk79vZM+KpQDc0uNhXCtd+Ul1FL2ilpFdz2L0TESjCeAHj5X8XFLj8OSqNdt4bM0pxwJOJoNuIR70ifCkd4QXPcM9WxY6C3YpvXtwvqShA6lAI+5OacHV0m+duhU23A8WffPvRw4Gj3AoSIRiqdKWQU/Dja85Clmq6qQU4vbzxRy8WIbJ2iC18HJWM2dYe2b0D0epkFNitvJMam4jbdslTAv04ml/H276fC8mq8DX03o0GotL9WZe+vksO5Obtshx1Sr5dEr3Jk731xv/Ead/Cf8UcTqnr2PkiQsIQB9BhUd+HWeyK6mpszJnZAceH9L+quXU1UYrz/x02nFjfjqlO5N7Xrtw9t/ChWI9d397lOIaMyGeTqy6t2+LrS0u4WxeNeMWHkAQYcmMXozo5N/2L8w5IqVhakulye2GZ6RUzFXE3W2G1SRVPOUnQMZuyNgjrQA9I+CBPeDUWERabjBzPKuSjafy2ZFcjL0+v6lWyokL8SA+zINQLx06tYKz+dVsOJlHjcmGTAaP3RjNEzdFN4TYy9Lh2+GSuD12DNy+olF6qdpczV2/30WOPsfxmlwmZ97QeQwLGyb5Vq2eLK1SHz4Evq37BrXpctgF5u9MY+GedERR0tG9P7ErvcI9G1XfVdVZeOnns2w9J2ltHhzSjhdvjm2V7NgFkW8PZLDgz3SHF87l6BjoxvM3xzCsLV5UJSlS5DBrv/T30Jdg6IuOt002E/MS5vFL2i/U2RqIsbvGnXFR47gj5g7C3OqjOGvulNJ83e6Aid9gstoZv1DSorVkLLrlbCFP/piIxS7wxthO3DMwUhL3f9VXIrPDXoEhz7d+DlYT/Hy/RJ5A0jz1n+OIoNoFkTsWH+ZEdiV9I734dlbvtqWzW4DZZueptYlsOdugj3IOceHMo4ORA8eOj8FgSMHDoy9dOs9Fo/KBrweyqTSIk3TDycmJ+2fci+nbdASDlVO1x7lQsgs3vxhmffoeKs31acN0NZzY/At7V0patn4jbicsPZIKmZ5fNMdQy+sYOPgPbEItQdEfcXNGNGZBZEvPaIJEBbOXHyepsAaNUs6sgRFM6xPeNpsWUYStz8Oxb6S/I4dIEe+ALm076LoKOPOTlJarygHfWGnbuGlSpPvSd+x+H/Z9LP3dbaqUhr9Cp2cXRLLKa0nIruTrPRfJKJOKFbqHuPPZ7d0dfnfn9HUszislz2Qhur5Z+2R/L579KZGNiQX0ifRi7QP9mjyzoiiyL62MQ+llJORUolUpGB8XzC1dAxov7nd/IKUW29/UtmvQRvyrxMlsNqPRXL8Swf81Pv30U7777jtkMhkvvvgi06e33an7n0zVzc8qxsUs8Pnq042qk+Dq1Vfn8qt5ePVJciuMqBVy3p/Y9fqQprJ0OLJQSkOZqqUHLbA7BPeSUgDu15eY5VbUcfe3R8kqr8NZreCO3mHcMzCi2RWx1S4w7suDJBXWMLZ7EAvujG/7F2XslbQi1jrw7ShFmYKuvr1VsJJRlYFNtOGsdCbENQSlvI0Tjr4Yvh0BVdmSY/ddP7VoX1BUbeLnU1KPqua0ApcQ5qXjvQlduCHat+HFcz9LUTRjpSRun7m5UQWdVbDy0I6HOFZ0jCDnIO7tei+nS0/z28Xf0Cq0LBu1jK6+XeGHqXBhK7QbCtN/uarVQltx+GI5T61NpKhGcix20SiJD/OgT4QXGpWcr/ZcpKrOiloh590JXbi9V8uC2ytRVWfhm30Z7EsrxcNJTYC7lps7B1zdF6c6T9KTJG2EglPSa0oniTANfMJBOERR5IV9L7A1aysAEW4R+Dj5cKHyAjUWaRWukquYO3QuQ0KHQN5JWHqjFPl5OgWcvTmRVcHk+n5zPz8ywFG9J4oiq45k8/pv5xFFGN0tkAVT46W045GvpeiXzluKNmnakMYV7LDtZSlyBtD3YSl6WE+gs8pquWX+foxWO546FfcPbsc9AyIb2y+0AYIg8viPpxxmmzq1grr68Wv2hI683rcdlZVHOH3mAez2WlQqL7p0no+XQYF12a18xxQKCCA4OJjJESOo/TMXq5uMn09/CtgIjO7IpJffRKP7Z9uqWE0mFj00A4uxjgFTpuGRHoVrlZnd8gtcVOfSM3IvutAcdLr2nA1awesXC+nkrGV9p0gmfH2I7PI6fFzULJnRi/grKzJbw/7PpQpJkMhM3LRrrpZrMxJ/gF/nSIUssWMk+wpl83O5zS7w04k8PtiajN5kQ62U88qtHZnRP7zZZ+nSfS2TwW+PDqJryF+siDu7HjbcKy1m5xwH75ZbvFwr/qfEaevWrfz444/s37+f3NxcBEHA2dmZ+Ph4Ro4cyT333ENQUNs0C/82zp49y8yZMzl06BCiKDJs2DD++OMPPDw82rT9P0mcTFY7E786RFJhDT3DPXl+VAwnsiv5ZFsqACM6+fP+hK74ujbuVL7mWC5vbjqPxSYQ6uXEV3f1/Os3LUipmoy9kLgazv8CtHKr+HaEblMgbjq4XkO0pxWU6s3cv+IEifVmlZdC3kM7+DK5ZwihXjrsgsg7m6WUpIdOxc6nhzQWRLcEUZRSHr8+CjYTRN0Id6xuvjT/MhwvOs7Xp7/mbOlZTPaG/lMhLiHMHTaXWK82ihkLz0jkyWaS0mej3m91kBRFkYwyaQWYmCsJso1WO+5OKib3DGFwtK80sWYdkCJoOYchvb5xbGB3mLYeXPwa7e+dI++w7sI6dEodK29dSQfPDlgFK4/teoyD+Qfp6tOVH0b/ABUZsLCflDoY9BQMf7Nt59gGVNZaeOf3JHacL242QhQb4Mr7E7s2tQS4njBWSRGZMz81RJdA0pR0uAVufl+KDl6GRacXsTBxIUqZkk+GfMJNYTchk8mwC3YOFhxk+fnlHC86jlKuZO7QuQwNGSJpnQpPw4h3YODjAA5j0dgAV54c3gGFXMbivRc5UV8oMa1vGG+P6yJFEIvOwpIbpZTr6M+h972O4ympK+Fc2TkuVl0kzi+O3gFXNFUVRTj8paTVAuh4m5QqVkkRnH0XSnnjt/Nk1kcW4kI9+H52nzaZDhotdrIravn+UDZrjuWgUshYOrM3Qzr4Mmn1cU6eLUHuquLks8Pw1Kioq8vk7Lk5GAwpKBQ6evf6Bef9y6g8spLF3I0JNQN696fTIWewixyTlZOZuRJEM5FxPZn4UjOaruuIs7u3s33RF7j7B9Cr79N4nynDLhNY67QXEzYGD9iAoDDTpfNC7siOIKXWxNvtAtm1LYMjGRXX3nDXapLsTPbV67hu/lAqKvmnkboVfpopPddh/WHS0lYXwEXVJl78+Qx7UqXCm/FxQXwwsVsjgl1cY2LsggOU6M1M7hnCp3+1MXjROVg6XBK/D3oahr/x1/bTAv4nxOmXX37hhRdeQK/Xc+utt9KnTx+CgoJwcnKioqKCc+fOsX//fg4fPsysWbN455138PX1vdpu/1X89NNP7N27l4ULpWqhBx98kGHDhjF16tQ2bf9PEqfXNp5j5ZFsvJzVbH3iBofGZ82xHF7/9RxWu4inTsWE+BBiAlwoqTGzP62MY1mStmN4Rz8+mxKHu+4anFatJskbRBSgJAnO/wzJm6RoxSV0uAW6TAKdJ5gNUvop+zDkn2gQMMqVknCx5ywI6CZFVfRFUkTHZgaVk1T1kZ8gTe7IpJVESG+Iv7tJyPhSSHfJvgwOpDeILNUKOfcMiuBiiYGdyZKWYN4dcYyPb0PpammqFBLP2CP9HXMrTFne4ooLQG/R8+mJT/k57WfHay4qF3QqHTXmGkx2E1qFljcGvMGYdmOufgwAZ9bBz/dJ/x70tOTS/XdWmEe/ga3PNfx9Ke045PkmlTark1fz4bEPkSFjwY0LpKhIPcqMZdz4042IiGyftJ1Al0BJq/XrI9IHbv0U+tz/14+zGdgFkdQiPcezKjiWVUFBlZGJPUK4s3do8+aZJclS6surHYQPbEQK2wRTjUSWUn6XRPCX9CQgWUl0mQixY8Gl8TgmiiLfnf+OuSfnAvBG/zeY3OEK13WkaN6L+15ke/Z2lHIlq29dTaes47DpcfCMhMcSQC6nzGBm2Kd70Jsak0a1Us4TN0XzyNAoaVVvqZOIV9kF6X6d+gPIZNRZ63jnyDtszmjsaD+943Se6vkUasUV6eaz62HjwxL5ipsmRTbq7zmbXeC30wW8vTmJqjornYPcWDG7D94uGkRRpM5ip9xgITGvihNZFaQW6ckur3NEDEHa1fyp8dxWL/ovMZjo9/FuBIvAgP4h/DBOmkjtdhOnT99LZdURnJ2j6d1tFYolI0iqkPMTYwEYFzIE33Qltkg3Nh0/j0X/AzKZnDnL16LWOvFPYfUrT1OUfoEBfWYRVOKHQibjmHsOZ8xpBHmlEdXlCGq1L9ou2xl7KgOtXMakUthwIg8XjZINDw9oW0GHKEr6x9+flWw/oE0LE7tgJ70qHaPNSKxXLFrl30hfZuyFH6dJ2iitB4z+TDJzvbIyz3HIIt8eyOSDrSnYBZH2fi58MLErvSO8MFnt3PHNEU7nVtHB34WfHxnYkPbN2Atp26HDKAgf1HrUuq5CWiBUZkK7YTB9w9WrV68R/xPi1L9/f1599VVuueUW5K2ccH5+PgsWLMDf35+nnnrqmg/mcuzbt49PPvmEkydPUlhYyC+//ML48eMbfWbhwoV88sknFBUV0b17dxYsWECfPn3atP+kpCSmTJnCwYMHEUWRfv368cADD/DMM8+0aft/ijidzK5k0teScd7ye3o36QuWVFDDs+tOk1TYVJQnl8HzN8fywA3tWq6Mqy2Xqi3KLkBZmkQiyi5IOfHmIkrOvtKD1GMmBLbQ4LWuQlq9JHwPuUev5XQbI7gXTFgMPu2bfbu4xsTe1FJ+OZXP4YyGTu1qpZxPJndrm99HyhZYf48U6VFopPRLM8TichTVFvHwzodJr0oH4PYOtzOt0zQi3CKQy+RUm6t5Yf8LHMyXypSnd5zO072eRiVvA3G95NANEsm58bW/Rp6q82FhH7AYoMPNkpt19Mhm9REH8g/w6J+PIogCz/R8hlldZjX5zMytM0koSeCF3i8wvVN9Cnvvx7D7PUAmRcj6PdzysQqCNBhbakHnc/30YmXpsPONpq1vokdJpdiX9YhrERWZkli+qkHXhW9H6H4HdJkMHs2nBA0WA68ceIVdubsAmNV5Fs/0anm8sAk2ntj9BPvy9jEyfCSfDXgbPusI5mqY/rNDt3E2r5rvD2eRWqSnRG9idNcgHhrSrsGgVRSlyGjiaqk68+FD4OxNemU6T+99mszqTGTIaO/ZHn+dPwfyDwAQ6xXLouGL8Ha6omovfSesniItdsbMg173NHo7ubCG6UuPUl5fYSWXUR9Na3mqcNMqifRxZvagyCbP4St/prB6x0VQytj8zBC6eEqpNrO5lGPHx2KxlBIQMJ5OuonIlo9mM8M4QXd0Wh2TqnqhVWnYJ0DBxQUgGrj99fcJ7fz3m003h5KsDFa+8Djt3ePp6SVVTua7Wthm248gwvAuv2D2MhAWei/vmqayrayGYag5vC0TmQy+ndmLG2OvEnE3VUtR4QNz6xePgIu/VO3aaVyzz5QgChzIP8CPKT+SUJJArVWKDCrlSrr5dOPB7g8yIGjAXzvpigyp2OBSalrrLi2SQ3pJi9+g+CbP75GMcub8cIoyQ4MPVU5FHZV1Vjx0Kn59dKBkCWKqkaKcCd83bOweBoOfgfgZTQlUTQGsmiQt3j3C4IG9LQvi/wb+fysO37p1KwcPHqRnz55MnDixCXFau3YtM2bMYNGiRfTt25d58+axbt06UlNT8fOTyEZcXBw2W9Pw//bt2wkKCmLx4sUsXrwYd3d3wsLCiI+P58knn2z2eMxmM2Zzw6q0pqaG0NDQ606cRFHkx+O5FFWbWmzDYbEJ/H62gLN5NaSV6HFzUtEv0ovBHXyb96+5sE3Su2Qfguqcpu83gkzST3QcA50nSqv55gz+WkLxeTj5veQ9Yq6RDPncgiQPJIVaaktxSU8UMUh6IEtT4cgiaUJROkk6o84TWr1Gu1JK+GBrCkaLnYXTehDXlt5pJ7+XDCBFQVrJjJl7VYPK9Mp0Hv7zYYpqi/B18uXTIZ/Sw79Hk8/ZBTsLExey5OwSALr5duOR7o8wIGjA1Su3Dn0J21+R/h1/tzSZXcs1B1h7txRBCekDs7c1u6ITRIH1F9bz2YnPqLPVMb79eN4e8Hazx7cqaRUfHf+Inv49WX7zculFUZRI3nGp0ojud0khdNcAKZqYe1RqdpuxBwoTG6KQCrVUJh05WCKHTh7Xdm6XYKmTyGF1LiCT0quGYqksH0Clk0hw34ekyGZzKEuD728DfQG4h0rXO3Y0+HdulbDaBBsP7niQY0XHUMlVvNT3JSZHT77qb3uh8gKTfpuEXCZn68StBO2bB8cWS8R2xm+OVFmr2Pcp7HpHSh3e/Qu0G0qVqYoxG8dQba7GT+fHp0M+Jd5P0ubty9vHqwdepdJcSSfvTiwbtQxn1RXjwiVPL4Ua7vkDQno2eju9xMDs5cfJqWhcDapSyIgNcKNXhCddg92J9HEmwtsZz1Ya0NrtAp0/3IlJbyW8XwC7x/VAXn/dKiuPknBqOiAQ1e45ItKLsB74gkWymZSL7vTXdqJzVSDmMDc2HVqB3ZrKoDtn0Hf87Ve/bn8BO5cu5MyObYwLfxyNXEOhRs6Z0GRy8/LooEwlYMBJROzQcRPTUiwoZHBLvp2dZ4u4vVcIH0++LDUlipKIP2s/FCdJC9bSC2C4zFhUoZGi88Nebva5EESBbVnbWHx6MRerLzpe1yl16FQ6yowNUfhpHafxRI8ncFI61X+9SHpVOlszt7I7dzeiKBLiGkIXny7M6jyrcaTKZpFShSeXQ21J44PwiYHp6yUicxmq6ix8sCWFtSdyHa+5apUsnt6TAe19pOd18eCGaFrUTZB3XJoXQEoP3via9CyA5LS/8VFpjnINlO71y6qOryf+deJkt9s5e/Ys4eHheHr+MzoEmUzWhDj17duX3r178+WXXwIgCAKhoaE89thjvPjiiy3sqWXcd999TJgwgdGjmzcFfPPNN3nrraa59X/bObxV2K2w7RVpoL4c7mGSB4hvjPR/nw7Sw+Hsc/3EiHabVDnWlokBJFHuxkfqvY9k9Xn+h666mSCIrftO2W2SsPno4gb9Stx0GDu/VXJiE2ysSFrBwlMLsQgWItwiWDxiMUEurWv4/sz5k1cOvOJYEUa6RzI0ZCj9AvvR0bsjntoWnpETyyT/KFEAv87SZN5xjKRPag3V+ZLQc/e7UmruwX3NRpnKjeU8vedpEkoSAOgb2JevbvqqaSqnHoWGQkZuGIkMGbtu34WPU33PMlGUBMrbX5WEpSDdT3VlTS0XAJDRKJLpEiAZNna87drvtT0fwp4PJMIzfUNDhV9ZGmx6ErKlSAuuQTD0Bel3vvQbX9K0bXlO8ujyjYUZv0qkrw346NhHrEpehU6pY+nIpZJovo24b/t9HC08ysxOM3k2aiIsukGKDMaMhtu/bzXa6RDIQqMU6SfHP2FF0grae7Tn21Hf4qVtvCrPqs5ixtYZVJor6R/Yn4U3LWxskSCKUiVpymZJv/XIkSZk0y6I1BitWOwCoghuTkqcVIq/5K3z6ubzrDqQhd1fy5tTunFvSEMKNCf3O9LSJLPO2Oi3Cd7yDScK7WxmOJ7O7kws74kMGaWWag4VrcSvY0emvPbmNR/D1WAxGVn80Ay8CGRIwBRMokDaDSaOnjiMCiu3h28kJ9yEs3Msbynmckpfx1QfD/74KRmTVWgk8CfxB6kFU01+81/mGigtTAc8Bm5NbVNEUeRgwUHmJ8wnpSIFAGeVM5OiJ3Fb1G2092iPXCYnT5/HiqQV/Jj6IwAahYauPl1x17iTWJJIuam8yb4BOnp15LOhnxHqekV0VbBL0bD0nZKmLu+YFCFzCZCeuWbGlrN51VwsNdDez4X2fi4Nfm6Hv4JtL4GzH0z5TlooW43SWLfrPckkGBpaxpjqbVi8oiTS1Jbo8V/E/5w4Pfnkk3Tt2pV7770Xu93OkCFDOHToEDqdjs2bNzN06NBrPoirHuQVxMlisaDT6Vi/fn0jMjVz5kyqqqr49ddf27TfkpIS/Pz8SE1NZcqUKSQkJKBUNj+Z/q8iTtcN1fnSgHspFNz7PkkbEdqnbZU4/wYEu6Q9uhTR6PuQJKT9K2meglOQsBKSfpUmdZBW7Dc8I5VxtzL4F9cW88zeZzhdehqAgcED+WDQBy2TnitQaChkRdIKNqRtwHi5sy8Q6BxI/6D+DA0ZytDQoY0noeTNsOG+xm7AMaPhxlekiMglCHap9cKRrxuLmQc8JpWbN4M3D73JhrQNOCmdeDz+ce6MvRPFVXQDUzdP5Xz5+eZ1PBl7JIO+ojMNkSUXf6nyrt0wiBgoDZhKjaRzyzshkZ5yKd1Jl8lSxE/bxmenKhe+7C1dmynLm0YkBQHO/CgNyDV50mteUdD/USldePHPBk1bYHcpVeZ89Qa2ABsubODNw28CMG/YPG4KayiNFkUR/bZtlHw+F3tVFSp/P7SdOuMxZTJOPSU37n15+3j0z0dxUbmwc8pOnPMSpHSE3SyVg09Y1Pz9eH6jdD8IVuj3qCRSR7q/Rv8yGqtgZdHwRQwMHtjscZ8rO8fsbbMx2oz0C+zHR4M/akywTNWS6F9fAIOfl+6z6wmrETL3Q1g/zpaJjP3yAKJChnx4EH/0iW3kOJ1+8ROysxcBcrqGv4z7mtf5zDYdCxpuHzgW9/1mRIudUlMu+ys38djyH667OWLCll/Z/f0S+vpNJMI5muM++Zw2SKRlLDsQh8ioFgvJCviYV4qj0CnkPC934cPNybT3c2HHU4OR2a1S1eOltjwKjTTmBsXXL1TrF6utRF3PlJ5h7sm5nCiWHOZdVC7M7DyTaR2n4apufuw+kH+Atw+/TWFtYaPXVXIVA4MHckvELXhoPciszmTx6cVUmitxVbvy+dDP6RfYr+WLUp0v3aulyRLBmfErBDeNuDeB1Sj1ujQUS4vUnrMav1+VI9kiXPijQUfr5AUxt8DwtxzawkpTJe4ad+Sy61PJewn/c+IUEhLCxo0b6dWrFxs3buTRRx9l9+7drFy5kl27dnHw4MFrPoirHuQVxKmgoIDg4GAOHTpE//79HZ97/vnn2bt3L0ePtk1n079/f6qrq3F2dmbRokX07NnzqtssXLiQhQsXYrfbuXDhwv9N4pS8SSo1NVVJN/uExRB76799VG2DKMKBz+HPt6W/g3tKpbJXVDW1CLtVeiAPzMUR6dD5QI8ZUhXSVWwTEooTeHrP05SbynFVufJ8n+cZFzXuLw3SNZYa9uft51DBIRKKE8gz5DV6f2rMVF7u+3LjfRtKJBHlhT8k4fIlUuLsJ4WtzXrJVdhYUb+BDML6SavXXrObjaJVmCoYsW4EFsHCslHLmlZctYClZ5cyP2E+A4IGsHjE4uY/ZKqR0nI6H+n4WrtOl6qH9n8uRas8wiXSEH4VbYYoShqM8z9LqeNZv7f8PVaTtKLd/ynUXbHaVqglgjDwiTaR8UpTJR8c+4CtmZLlwIPdHmRO/BzH+3aDgYJnnsWwd2+z22s7dybkywUoAvwZt3EcWTVZPN/7ee7udDek/gFrp0lR2eaqqE6tht/mSL9/l0lSBVw90X3t4GtsTN9In4A+LB25tNV781D+IZ7c8yRGm7FJSg+QFhY/zZCuzcOHW9QXXhNMNXB8iUTsa0vBvwvizM0M+uIU+VVGLHFeOAU581GHECYHSEROFEVSUl6moPAnZDIlXWz9OH6wmuPE0bFjRyYMHkPJ/AREUWRD9lxmzf8aD//rZ5Jot1lZ+tj9GCurGB/2JMmqfI6qpBTTKPbQwT+LxBgFMpmCd51/JqnWxrMRAez/PZ3TedW8cmtH7h8QLGnHLkXNh74k3WttjboD27O289y+5xBEAbVczZ2xd3Jv13vbtGgTRZHMmkwSiiUNVFefrnTy7tREPF5UW8Qze5/hTOkZVHIVnwz+hJvCW/FJMlZKliS5RyRyM/uPq/u5XSpUcQuBx0+1/LwJdqnSFBEC4xqJwA0WA9O3TKedRzveHfguOtX1MWeFf4E4abVa0tPTCQkJ4YEHHkCn0zFv3jwyMzPp3r07NTVNRct/F/8Ucfo7+L/S5LcRRFES714qaw2Kl5yOr6P/hV2wk63PxmAxEOQShLfW+5+xxU/dCr88JJE/mVxyz+0wUkrT6LwkQXp1rjSxeEZIgsb8BMl/p6jeGbfTeIkwRQ65qmaoylTFl4lfsu7COgRRINozmvnD5jcNZf8NGCwGTpeeZk/uHtamrkVE5OmeT3NPl3ua36A0VQr3p2xuIFCXoPWQRL2977sqGVx8ejFfJn5JZ+/OrBm9ps2/V3ZNNmN+kSoEvxnxDf2D+l9lizYi9xisv7dBb9d5otQ25AoNBSBpp35/RjL1QyalIlsqUrgcZr2UKri4S9LY+XSArlOuSgwqTBXsz9vPntw9HCw4iNFmRC6TM7vLbB6Lf8yx8hXtdvIenYNhzx5kKhXeDzyA66iR2IqKqNm+nZrftyAajSiDAgn79lt+tRznnSPv4Ofkx5ZJW9AoNFL6eOvzUiXqrN8lAlyVI2mPzm2QDqjHDEnzVj+hpFakcvvm2xFEgdW3rqab79WvxeUicpVcxedDP2do6FDpTVGUDE7Td9b7dP389yqYTNWwdISk57kcIb350PdDFh0uxjPclcJYacycGeTNBx1CkMtkiKKdpKTnKSreiAw5oUl2VpfNQCaT8dRTT6Gfdx6xzsaOghX0mjWVrjdeP1PEc3t2su3reYQ6d6eX33DWaA9gxc5wtwz6G37lyKBITOgRA+YwvXgYShlsiArnjoWHUMplHHlpGD7bHpV+N7WrtNhra1ueehzMP8icXXOwCTZGhI/g+d7PE+D8zzhoW+wWXtz/IjuydyCXyXm5z8vcHnN7y2ODWS9pAwsSpFT4vduaf15Bembnx4G+APMtH5Ec2Y/z5eepsdRwd8e7cVG7XPX47IKdJ3Y/wd68vfg6+fLjmB/x011j5Wwr+J8Tp/DwcJYsWcJNN91EZGQkX3/9NaNHj+b8+fMMGjSIysrKq+/kWg/yH0rV/RX8n404XUmaBjwuCe+uQzVTnbWOnTk7+e3ib5wpPdMo/eSqcmVs1Fju6ngX4W7XOSddmS1VE12ejmoLtB5w2xdShcpVYBNsrL+wni8Tv6TaLOXYx7Qbw2v9XruuK5wrsTJpJR8fl9x73xrwFhOjJ7b8YUttg7hU6yFVffl0aFkAffmmdgujNoyizFjGBzd80MQqQRRFyr7+muoNP+PUowcuQ4bgNmokMpWkh3nvyHv8mPojwS7B/Hzbz9fvmhirYMdrUjoVEVTOkvbpctO/yiz4+UFppSuTS5GZtvTYu0YYLAa2ZG5hc8ZmEksSES/TZLX3aM87A9+hi09jbUfJZ59RvmQpMo2G8BXf49S9sRbNWlhIzux7sWRmovD2Jnj1CsYdf4DiumJe6fsKU2OnSs/shnulyVblLDnIG4rru97LpGjF8Dcd1+Nyl/cR4SP4fOjnbT7HOmsdL+1/iV25u1DKlHw4+ENGRYyS3qzIgK/6S5WmAd2k6q7wv0CSBQF+vEvSFLoEwIi3wS9WmnBNVVQHDSIu4yGcNWpm3N2VebklCMADIb681T4I2SXylPw8RUUbkYmQd6IPGcYYunXrxsCK9ljTqzlR9gdCtA8TX/h7lduXIAoCSx97iJqyAm4IvJ9yZwNHVWn4eDjzaNW7XIx0JTtUg0YTwOGANXyWU8EwL1fC0mpZeyKXUZ39WRzwm9QmRa6UtEDthl7TMezK2cUL+17AZDcxKmIUH93w0VVT6X8XNsHGW4ffYmP6RgCGhgzljQFvNOgZr0RtOXx3izQOeUVJkafLbUBEUVqo7HoHCk5R7RbEtIh2ZF/WlaCnf08WDV90VQuF+QnzWXp2KWq5muU3L78mTWFb8D8nTm+++Sbz5s0jMDCQuro6Lly4gEajYdmyZSxZsoTDhw9f80Fc9SBbEIf36dOHBQsWAJI4PCwsjDlz5vwlcfi14h+PONltcHoNpG2TJpDacmnl7Bkupa9C+0mVatY6qXQzfWe9SSUw6gPo/8hf/mq9Rc+Z0jOcKjlFYkkiZ8oakyUnpRNuajdK6kock4wMGYNDBjO903T6BvR1rFwEUaDSVEmttRabaCPcNRyFXEGttZa9uXuxClbC3cKJ9oxuWvlzCZXZUtoq5zDUlklpKq27FH2SK6Ty8rpySbgY2k9KbVzFhNMm2Nibt5evEr/iQuUFAKI9o3mpz0ttTmUBCEYj9qoqlD4+DrLRVlwSHAPMiZvDA90euO7Ru00XN/HygZfxc/Ljj0l/NBIIi1Yrha+9TvXGjY22cR40iNCvFiJTq6m11jLh1wkU1hZyV+xdvNT3pet6fBSekQTbuUekv6NHSU70xio4OE+azDXu0go+evh1+9pqczU7s3eyP19KpV5+f8d6xTI0dChDQ4bS0btjI32FaLVS+sUCypdI1ZNBn3yC+9jmfbts5eXk3Hsf5pQUnAcM4OBzN/H+sQ/w1/mzZeIWSZhvNsDSm6A0pWHDiBsku4fLIms2wcYjOx/hcOFhgpyDWDNmTSO9krW4BGNiIubUVIkAD2qqe7IJNl458ApbMrcgl8lZcOMCBocMlt48ux42Py1VtoKklRvwWOsX0VAiVWHlHZd6L5qqJX2iQgOzt0rjFEiu6d+PAWsd9yveZUdtOxbcGY/RX8vjydKk+lxEAM9EStEVUbSTmDibisoDuOYr2XrxDkTkdPCKYFBBJBk1iSTZknnkm0WtH18bcW7PPrZ9/TFqhTu3hT3IOvUhDHITYwJKiDKu5VQ3T0SZSLeui5iUEcqFOhOvBvgyd+Vp7ILIHxPVxG6p1wCOXyT1lWsjKk2VfHjsQ7ZkbgFgUPAgvhj2RWMh/z8IURRZfn45C04twCpYcVY5MzJ8JGOjxhLnG9f0OKrzYdnNUrQ4oKvUjcDJQ/Lz2/UOZNdLdVTOvNvjVtaWHMVV5Uq8fzwJxQkYrAZuCL6B+cPmt3iOa1LW8P5RSc/X3GLveuBfqapbv349ubm5TJkyhZAQKU3w/fff4+HhwbhxV1/ltwUGg4H0dElIGh8fz+eff86wYcPw8vIiLCyMtWvXMnPmTBYvXkyfPn2YN28eP/30EykpKfj7Xx/n6tbwjxEnUZSM/Xa+1TTc3RaMel8SxLYB1eZqMqszG/9Xk0lOTU6jVTdAqGso49uP56awm4hwi0AhV2C1WzlefJzVyavZl7fP8dkg5yCGhQ3DJtjYnbObEmNDeaurypVO3p2akDEXlQsfDf6oYSD/h1BnrWNF0grWpa5zHJe7xp05cXOY3GFym9qm2EpLqVyzhsp167CXSsJzpZ8fAW+/hes1FEeIosgXp75g6VlJDD+j0wye7fXsdSNPoihyx+Y7SK5I5vH4x7m/W4NppWi1kjfnMUmfo1Dg+/jjCAY9FatWIxqNuI0eTdAnHyOTyzmUf4gHd0qRnvcGvcdtUbddl+NzQLBLq/Xd7zXu4g4SiRg7v0m6eU/uHlYmrUSn0hHmGsaI8BHE+cW16etSKlJ4dOejje7Ldu7tmBg9kZHhIyXDz2ZgLSgg78mnMJ05A4DPI4/g+3jr5MKSnU3G2NsQLRb8Pv6A200LKDGWNESdQNIElSRJOiOtu2Tqedk9IIoiHx77kB9SfsBJ6cSKW1Y4HOrthlqK33mb6l9/a/S9ntOm4ff8c8ivaIllF+y8fuh1frv4G15aLzbctqEhwlBbJqUJT62UjuWhA81rWQS7VK174lvJSPNKjPsK4qc1fm3jI5C4mhO+E5mcOxmVQsabt3XGGKzj1TSp8uz5yACeCvdHJpNRXnGAxMSZKOzgfdiDX8SxCCJE2wLpbHDjz8I1zPnuRzS6vxcBtdusfP3AA5hrS+kTdDc4KflTfRYnrYbprvNJjdEhymX4+o5CFfkZw46nopbJGFto5/fThQyN8WW56yIpahg3DcZ/1abvrTZXszJpJauTV2OwGpDL5MzqPItH4h6R0rjNQBQEjKdOYcnKxlZWBjIZTt26ou3SFYXL32tDk1qRyqsHX3VU8IFUodfFpwvjosYxvv34hnGp/CIsGyXp1xQa0Lg06AkVGuh9L+c7j+bOXY8gIjp0lSeLT/Lgjgcx280MCBrAx4M/xl3T0NlCFEUWn1nMwkTJlPr+rvfzeI/H/9Z5tYT/GXGaMWMG48aNY9SoUbi4XD1H+XexZ88ehg0b1uT1mTNnsnz5cgC+/PJLhwFmXFwcX3zxBX379v1Hj+sfT9XlJ8CS+vN28pTacQR2l8S3NfmSJ0buMcg/KQ1gSo2k8blkeBjRdKWZVZ3FwYKDpFWmkWfIo9JUSWldKZXmltOqIS4hxPvFE+cXR7xfPO092rc6oWdVZ/FDyg/8mv5ro4anl+CsckYQhUZkKcItAn+dPxerL1JmLEMuk/Ncr//H3lvHR3Gu7//vWd9s3D0hIQnB3d2KFyjQlhp1oS2VUz1195Yapa4USgvF3R2CBEkCcfdkk3Wd3x8DCyEJhNo5n9/3XK9XXpDszOzs7MzzXM99X/d1P8YNqTf85ZGXanM120u28+mxTz3eJ4GaQKa2n8qtnW7FX+N/2WO4bTZqFy6k9osvER2O8y8IgkR4Ab+pUwl76knkfm1vdXPhCutfvf/FLZ1uafsHuwTSKtK4dcOtaOQaNs3Y5PmMoihS/tTTNPz+O4JGQ/T8D/AeJjmHG3ftovje+8DpJOjeewidNw+Ad9Pe5dtT3yIX5Hww4oPzGpm/EhUnpKhp9Wkp4tTrFkmXdMG94HQ7+ejoR3x98utmu09Pms4jvR5pMhhfjN2lu3l0+6OYnWZifGKYnDiZoVFD6RjU8dLNgxsbKbjueux5ech8fYl46SV8x13Vpo9Vs2AB1fM/RB4UxJEP5vBqxnxUMhVvD3ubkbEjL7v/h0c+9PiDvTPsHU+KzZqZSelDD2MvLARBQJ2SgjIqCuOWLQBoOnYk5vOFKIKbpl5sLhuz18zmTP0ZBkUNYsGoBec/uyjCollSgULsQEl7daEnmChKEcJD0vkQ1Rs6TZVaZJSmSXq1lqrzcrbAj9MRtUE8GLWYVSelth13DU1A1zGQ1/OlarD7Y0P5d0IEILJv/2gslkI6nDFg0HdmsXUoMlFgtmUQKwo/oN81dzF41p8j8Xt//YV9S7/HXx3L2KjrWa1Mo1LWwJAOmRAqVbWFhFxFp47v8k6hnvcLKxmkUHNkbZ7Uk/e2JFIXD5AI/907m9mHiKJIrbWWzNpMTtaeJKc+h2JDMfkN+Z6WTSkBKbw48EU6BXdqdn4ALoOB+p8Xo1+6FEdxcfMN5HL8p08jZN68Zt+1s66Oht9X0Lh6NaLDgSIiHE1KB4LuuL3ZGOUW3RypPMKqvFVsKdrikS4AXJ14Nc8OePY8qas4AT9MP+/5JMih500w9DHcvpHcsOYGTtaeZGLCRN4Y8obnOLtLd/PwtoexuqxEeUfxaO9H6RTUifyGfBZlLfIswO/tdi/3drv379HP8g8Sp5deeokVK1aQkZHB8OHDmTJlClOmTCEqqg1uzf8/xN+aqvvlZmnVOeihP24WeBbr8tfx793/xuF2tPh6uC6cdr7taOd3/ifRP7H1PPdlYHFa2F+2nx0lO1DIFAyLHka/iH6o5CqcbieZtZmcqj1Fh8AOdAvphiAIONwOXt3/Kr9lS4LYyQmTeab/M39IT2N2mCkyFFFqKOWM/gwZtRlk1GQ0iS5Ee0czt8dcroq7qs0hcUt6OmWPPyFNUoC2WzcC59yCbvBgBKWS6vkfUvfttyCKKEJDCfv3v/EZPQpB3jadwnenvuOdtHcAeGHAC0xPmv6nB415W+extXgrM5Nn8tyA5wBpIK/+YD61CxeCXE70Jx83i5Lpl/9O+VNPIdPpSNq5A5lOIr3P7nmWlbkrUcvVPDfgub8+8nQZFDUW8cyeZzhaJTkcX5dyHYn+iRyrPsaavDWAlEYeGTuSMXFj6BTUiTCvMCxOC9n6bL48/iXbS7YD0De8L++PeB9f1eWfXdHppPieezHt3o0iLIy4n35CFd32cc9tt5M/bTr23Fx8r5vFO8Ma2Vy0Gbkg5+VBLzM5cXKr+35+/HM+OirJEZ7u9zTXd5DSQM7qanLHT8BtNKKIiCDq3Xfw6imViRt37KDsiSdx6fWoEhOJ++7bZhNqTn0O1625DpvLxpN9n+SG1AsiRPoi+KSfJAO42Fl817tnK14FqdKv68y2XQSXE97rAKZqxBt+ZUFpO97ecBpRhK/n9OaMl8ALuWUAzI0N5dnESIqKviI75zW8LXL6HKrkbfk8LC4ZU2y9OVS0GNHXn3sWfNy2928BhtoavnrwblxOG2PjHsAhd7BSnYZC4WZw3x9xKQRifEaT1HsBIgKDD2SRZ7HRP9/KsTO1krYpZgtsf02SCNy+AZCesXX561iUtYg8fR4Gh6HF908OSOaebvcwKnZUq+X2hm3bqHjhRZyVlQDIvL3Rdu+OIiQE0WbFkn4cR6kUsZN5eeE7aRKajh0RXU6M27ZjOnAAHM3HfnlwMOFPP4XP+PEtjjNu0U1BYwEb8jfw2fHPcItuOgd15v0R758XrDusYCiX7hNdiEfvdK4YxVvpzcqpKwnxatq26HTdaeZtm0epsbnHlYDA430eP9+t4G/CP56qKykpYeXKlaxYsYIdO3bQqVMnrr76aqZMmUL37t2v+AT+r+JvJU6i+KeNKEVR5KuTXzH/yHwAuoV0o294X9r5tSNIE0SgNpBYn9i/VQB9JRBFke8zvue9w+/hFt0k+CXw3vD3SPRve0Xg4crDPLDlgRYHKgGBBL8EpiVN4/oO17dq/NgSGteupezJpxDtdokUPf00PleNbTbgmI8cpfzpp7EXFACgCAnBZ/w4dP37o+3RA7m/f6tkSBRF3jr0lkfz1D2kO4/0fqRp6fgVoLixmInLJyIisuLqFST4J2AvKKD8xRcx75P0ROEvv0TAzOYTnyiK5I4bh6OwiIhXXsZ/hqTfcLgdPLr9UbYVbwMkEf2NqTeS6J+IzWUjvyGfjNoMjlYdJUefg0t0IYoiUd5RdA7uTHJAMuG6cKJ9opsZNl4Ov5z+hXfS3sHitKBT6nhx4Ivnxc1INhKvHHiF7PrsJvspZcomiwaZIGNG0gye7Ptkm0iz22ql4qWXaVi2DEGjIe6nH9F2ahoZqC42cHBlZBFVDgABAABJREFUHnXlJixGB1pvJTGpgST1DiMqRSojNx04SNEtt4BMRuyypbxes4gVuStQyBSsvHolMb5Nqzfdopt30t7hh4wfAJpVX5Y/+xz6pUtRd0wl7uuvkV/UnNxeVEThTTfjrKxE1T6RuG++QXFR/9BFmYt4/eDrqOVqfp38K/F+8edf3PcJbHha+n/70ZLre9aa8y2Vxr3ZJoPaJlj7GBz8XPKumr6QV1Zn8OXufEJ91Gx8eCgr6xt5/Ixk2fF5p3jGB8DuPQNxu230PqpntWEi2SQwwJGMvuwwJebT3PzmJ4TEX74oxWG30VBZgb6iHH1lOfqKckoyT1BbUkyC31D6BA5grfooZUIdvZNy0EbsQ+tQMGBMBoJMznelNTxxpgQvh4iwvRyXW2TN/f3otHiQ5AR+zVfQZQYlhhJe3v8ye8v2et5bQCDON45OwZ1IDUwlzjeOWN9Y2vm2a3U8cNbVUfnqazSukRYEythYgu+5B99xVyG7KD1pPnKEytffwHriRIvH0nTpgv+MGSijonCUlVL37XfY8/IA8Js+nYgXnkdQtT4e7i3by+M7H6fB1kCgJpD3h7/fYvcEaOp51lofR5BSlR8f/ZijVUfJ1eeiVWqZkjiFmckzm4z5otOJ0Iq34p/Bf9Q53GAwsG7dOlasWMG6devw8fFh8uTJ3HvvvXTq1HLY8f86/mur6i6AwW7g+b3Ps6lwEwA3dbyJR3s9+rdXafwVSKtI4/Gdj1NtqcZb6c07w95p1eDvQjTaG7lm5TVUmCrwVfkS6xNLvF88nYI60TGoIx0CO1wxSRRdLmo++YSaTxcA4D1yJJFvvoHcp3UDUbfVSs2Cz9AvWYJLr2/ymuDlhTIsDEV4GKr4eILvuQflBXo8t+jms/TP+ObkN54wfu+w3szpNIceYT3aFB05h3PC80FRg/hs9GcYtmyh9OFHEO12BLWa0MceI/DGG1rdv/arr6h6+x00XbvS7pclnr+73C6+OPEFC9IX4D5rkSAgNNPEXQoyQcZdXe/ivm73tSmqtr5gPY/tkJoX9wvvx0uDXmrRwV0URY7XHGdN3hoOVRyioKEApyhpps5Fou7uejft/C7dZuccLOnplD31tGeSifrggybpOZfTzb5luRzfVkxro+jYOzqR1Fv6jkvmPYRhwwa8+vUj+puvuG/Lfewt28v4+PG8Newtzz5mh5nn9j7HhgIpgnExabKeOUP+1GngdhO36CdPpOli2AsLKbz5FpyVlciDgoh4+SV8Rp5PDYqiyN2b7mZf+T66h3Tn23Hfnh8jXE5Y+YBUoNLkuxWktjYjnm7TNWyCogPw9VhQecNjOVhRMfHDXeRWm7i6eyTzr+vBK7llfFxUhU4uY32vZByFz1Fe8Rt+Ln8MewPZIQ4i0RVGRL2C9OoVJPYZy9R/SToYm9nUhBjpK8//31jXsoN2gCqCUZE3USmvZ63qKDKZjDHdv8PsDe19ryau93uUWu0MO5iF0eVmbD3sPFhKn/gAlg4qk6oidaHw8CkKzeXcvO5m6qx1qGQq7uh6B6NjRxPjE3NFjXgb166l4uVXcNXXg0xG4Jw5hDxwPzJt61W0otuNcfsOLEePYM3IRHQ68R4yGO+RI1EnJDTZ1m23U7vwc2oWLAC3G6/evYn66EMUl+j8UWwoZt62eWTXZ6MQFFzd/mpGxY4iJTAFhUxBqaGUXaW7WHh8IW7R7dEn2fLzcZSVoQgMRBkZ2aKEweFyIBNkzeYn0emk6M478erRg+D770e4VGPgK8Q/RpyKioqIiYlpdaBzuVxs376dlStX0qVLF+64444rPpn/S/iv9HFC6o01b+s8SowlKGQKnujzxHkR6v8R1FpqeXTHoxyuPIxMkPFgjweZnTrb04OpJTy+83HW5a8jxieGXyf/+qcjaY7KSsr+9RjmQ4cACJwzh9DH/tXm1Jtot2PcuRPjjp2YDx3yRKEuhDIqithvvkYV29QPpcpcxafHPmVF7gqcF4ilI3QRPNjzwctWmdRYapi0fBImh4nPRn9Gr8ZACmbfgGixoBs4gPAXX0QVc2l/KmdtLdnDR4DDQbvfl6Pp0KHJ60cqj7Dw+EIyazM9WrlQr1CS/JPoHtqdTkGd0Cq0iIjk6nM5UXOCwsZCKs2VVJikXl3XplzLU32fuiShL24sZubqmZgcJm7qeBP/6v2vNrsI2112qsxV+Kv90Sl1bSJpbquVxvXr0f+yFMsRqT2NIiSEiFdfwXvo+cIFURTZ9mMWmXskbU77XqF0GRGNl48KfZWZrH3l5B6pRq6UMe2RnoS188VeUkrehAmIdjtRH86nvHccM1fNRERk8cTFdAruxMHygzy39zlKjaUoZApeGfQKExOatoEquusuTDt34TN2LNEfzr/0NSgspOT+B7BlS5E4/5kzCH/2WU+EodxYzrSV0zA5TC3r6+ry4OCXknN04iipYrWFFiFtgijCB12liqzxb0O/uzhWrGf6p3twi/DWNV2Z3iuaWem57NUbSfbSsKKzluOHr8bpNOBTqmBt7vX4urVcJevN+sz3kcnVhCXEo68ox2K4tIegQq3FyzcEjU8wal0wjkZv+ogJaOUy1vilU2GrpW98PerY1QhuGDzkAEpVEDccz2NrnYHe3l7UbCqmotHKh7M6M2XvDKlB+vCnqOl3BzeuvZFSYykpASm8O/zdP2TPov/9d8qflCpX1cnJRLz6Ctouf20p/jkYd+2i9OFHPOneyDffQNe3b6vbmx1mnt3zLBsLN17yuNPaT+PFgS9iy86mYOYsxLMdNwS1msg338B33Lg2nV/lm29R9803CF5eJKz4/bJj1pXgHyNOcrmc8vJyTwPd/9fx30icsuuzuX3D7dTb6onyjuKdYe8085/5M3CUl+OsqUXu74ciOPiSK6A//V4uBy/ue5EVuZInl6/KlwntJkgic9x0C+nGsOhhONwOvjrxFQuPL0QuyPlu/Hd0C7lMf7fLwLhjB2VPPoWrvh6ZlxfhL76A3+TWdShtgdtiwVlZiaOiEkdFObULPsNeWIgiJITYb75G3b65MWOFqYLvM75nU+EmD9mQCTI+GP4BI2KbF06AFLW6a9NdHCg/QGpgKj/1/4SCWdfiLC9HN2gQMQs/a3Pou+ThhzGsW0/A7NmEP/dsi9uIokidtQ6tQttmsrokawmvHngVEZGUgBTGtxtPr7Be+Kp8CdIGecTdNZYa5m6ZS0ZtBj1De/LVVV+1qerxSiE6nViOHaNx/QYaVq7Efc7EVy7Hb9JEQp98stlq/MiGQvYtz0UQ4Ko7O5PYs+m46HaLrFtwnIITtXj5qpj1dB90/mqq5s+ndsFnyPz8iPv+O16s+pbVeatp798enVLnafMToYvg1cGvNrPGMGzeTMn9D4BCQeKa1ajiLj85u202SYP3zTcgilLE66MPkZ8dt3498ysv7nsRlUzFXV3v4saON7ZuDXLxtRNF0qvTWXx6MZsLNxPjE8OcTnOY0G5Cy6nQHW9LfRUBRjwDQ//Fh1tzeG/TGZRygR9v70dCtC+jDp2myu7kjeRoJqrTOX78LgCyMgdTXd2OG+UjWXHqUxCNTY8veCHI/BHkfshk/ghyf+l3mT8IGgRBQAAilAIpGjm+coFi7wY2ONNQKORMTvyOmjCREHUPypK/4qOiSg43mlEJAi/6BPDi0hME6VTsH1+GcvWDoA3Edv8Bbtp6P5l1mUR7R/PDhB/+kEbUfPgwRXNuRXQ4CLjxRsIef+ySKbS/AracHIrnzsVRWASCQOBttxJ0xx2tRp9EUWRf+T62Fm1lR8kOqs3VuEQXPiof+oT1YWj0UK5ufzUyp5uCWddiy8pCHhQEbjeu+nrJ9+yH79F2vbRxa8Oq1ZQ9JkWZo+bPx/eqKzMTvRz+MeIkk8moqKj4H3E6i/824pRRm8G9m++lzlpHp6BOLByz8JLVRVcCe0kpNR9/TMPKlZLJHYBcjqZDB7x698J75Ci8evdqczSmrRBFkd+yf+OrE181a1cCEOYVhlt0U22RKnTu634f93a7t9l2bYWzvp6aBQuo/17Slag7phL93nuo4uP/8DFbfa/qaopuux1bdjZyf39ivvqymXbmQjTaG3nn0Dssz1mOWq7my7Fftlh+/8XxL/jw6IeEWdV8apwKyzfgqqlB1a4d8UsWeybLtsC0dy9Ft92OoFbTbtlvqBP/Ogf69QXr+feuf2N3Ny9nTw1MJdonmu3F23G4Hfir/Vk6eelf6qJszcqice06rFmZWNKP4244X0GkjIrCf+ZM/KZPQ3nReCeKIulbitnzq2SVMuTaZLqOaNm53W518ttbh6krM5HUJ4yxt3fCbbFQdOttWI4dQx4UhGbhO0w9el8THdbM5Jk82vvRZuTFeuYMhdddj9tsJvD22wg7O7G0FcZduyid9xBusxl1UntivvwKZVgooijy0LaH2Fq8FYAAdQC3d7mda1Ou9aSY7C47+Q355OpzqTBXUGWuIlefS2ZdZpPqq3OI1EXy4cgPSQm8yM7A7YJNz8G+s6LuPnfiHv82Dyw+yprj5QR4Kfl97iA2Wcw8k11KO62K3f1SKch7l4LCBTisGvYfnMFYe3dKFSrKik4hyHzPkiV/BEEiGjKFgFItP/ujQKmWo1bJCHO4CDHYUTmlccytFFgbdoKKmkoGJspRhn+DWy6wMvgXltRK45laJvBqUjTr1+awO6eGB4dG8UjWbKnKeeyrLAkM4ZUDrxCoCeSH8T8Q69uKo/YlYMvOpvDmW3DV1+MzZgxR8z/4S1NTl4LbZKLitddo+G0ZAIJGg9+0qfheNQ5tzx7ILkPezlGICyO6Ve++R+0XXyD39ydh1UrkgYEep315cDDtlixG2UphmfnoUYpuvQ3RaiXorrsIfeSvMTq9EP8ocaqsrCTkIoHh/2v4b9E42V120irT2FWyi12luyhslKq9UgNT+WLsF3+aNDlrajDt2UPD2rWY9uwFp5QyUoSE4DIYEK3WJtvLg4LwGT0an7Fj0PXti6BU4rbbqf9pEeYDB0AUEbRa/KdNRTd0KOZDh6j56GNcjY0oIyLQdu9O0O23tWgi6XK72FGyg0MVhzyffVPhJk+KKMo7irnd5zIpYdIfqkRzlJVR++236Jf+imiR7BICbrqJ0Mf+ddlB48/ApddTdOddWE+cQObtTcznn+PVs3UxuNPtZN62eews2UmwNphVU1d52heIosjvOb/z4r4XSSlw8OzvSuRmKUSujIoi9qsvWyWALocbfZWZwMim6SxRFCm+405Me/agTk0lfsniv/R61Fnr2FK0hU0FmyhsLMTgMGCwNxX2dw3pyhN9nmhTa5G2on7JL1S88kqTaiO5nx+6oUPxmzIF3aCBLU5adquTrd9nkntEIurdRsYweFbSJd+rusjAL68fAhGmPdqDyKQAXI2NFN4yB1tmJsqoKDI/vpedVfvpEy6t2FsiiM66OgpmzsJRWopXv37EfvnFFRuugmRhUHzX3Tirq1F3TCX+hx88VZPr89fzafqnnrEk1CuUbiHdyNXnUthYiEt0tXhMtVzNxIjRXLPdRgUN/BiczVG/erxVPswfMZ++ES2kf9K+llrpiG648TcssSO49vN9HC9pICFYx/d39WN0eg56p4uvO8dzVaCGHTu6IOLm4IFpdDR1Zti4MZhCvVCo5BeQJOlHrjj//bmMdox7yzDtL8dtlsYxmZcC3YBIioMa+HXlMlQqFRM7LKLG34JNaM+dvIkLyR7h7pgQThc2cONXB5AJcGTUafx3vwi+UbjmHmLS6hmUGEt4qu9TzE6dfUXfh8tooubTT6n7/ntwOqXv5McfmwnA/wkYtm6l+uOPsWVkev4maLX4XT2FsCeeaHOGwXTwIEVzbgW3m6gP5+M7VooWuYwmCq+/XlosBgQQ8dqr+FxkOWTYtk3SYlqt6IYMIeazBX/5ghz+YeJ0rjfdpfDee21vA/B/Gf9ExEkURUREj6bD7DCzNn8tO0t2sr98fxNPJIWgYHD0YF4e+HKrnkSiKOLS63GWl+OoqMBRVo6zsgKX0YhotuA2m3FbLDiKiz1l9+egGziAkIcf9uTbHeXlmI8cwbR7D4atW5us2OV+fniPGCGZtV10HABlTEyLfiS6oUOI/uCDNg0adpedrcVbcbldjIkbc0VVcudgy82l9suvaFi1ykMM1R1TCZ03z+Nr9HfDZTRScs+9mNPSkPn6EvfjD2iSk1vd3uwwM2v1LAobC7mt82083Othai21vLD3BbaXbKf3GTePrgC50406NZWgO27Hd+zYVifZ2lIjG748RX25ibB2vgyc3p7IJH/P646qKvKnXI1LryfwttsIe/zKohxXihpLDfvL95PfkM/Q6KFN0q4uo5Har77CtGs3Lr0et9GI4KVF7uePtltX/KdNQ9O1a6vk2V5SSs0nn9CwXHLY1w0ejM+okWhSU9F07nzJFKbL6WbVh8coPaNHJhcYPDOJzsOi2kTUty86zamdpQRF6Zj1dB9kchnOujryp1+Ds6KCsKefIvDmm1t/b6OJ4ttvx5KejjI2lvgli5ukUkS3SE2JEX2VGWO9jahkf0LjWh+T7MXFFFx3Pa7aWryHDSP6k489n93pdrIydyUL0hd40sPn4KPyIck/iUjvSEK9QonxiSE1KJUk/yQav/ia6g/O661qQzS8P85BfqyKd4a907Jf1fqnYf8n4BcL9+2j0qZg+qd7KdVb6BHrT8/R8XxSWk0fXx2reiVxaO84Gq3ZZGUORlXRi6ntRhJyW+tSBEe1GeOuUkxHKsEpTXPyQA0+Q6Lw6hUGCoEFCxZQXV3NkF520C0BUeRg+CLmV2no56djRc8kzHYnV32wk+I6C7f1i+S53Gul1jhTPmJDYBj/2vEv/NX+bLhmQ5vS1S69HtOBgxg2bMC4fTtus+R75z1iBBEvvdis+vFCOO0uLEYHTrsLpVqBd0DLZplNroPdRUlmHaIIfiFa/EK1KJQtkxFRFDEfOEjD8mUY9+zFVSN53qmT2hP1/vstSgqavFdZGfkzZuKqq8Nv2jQiX3+t2evFc+/HlimRM5+xY/GdNBGZlw7jtm3UL14MLhe6YUOJfv/9v41A/qPEacCAAaguseIUBIGtW7de8Un8X8TfRZxqLbW8euBVChsLKTZI5GJCuwkk+ify9cmvPeaNACHaEIZED2FI1BD6R/RvsXmiaLdT9e67GHftxlFe7omoXBaCgDo5GZ/Ro/GdOBF1QuuVSKLDIQ0EGzdi2LwZV12d5zV5SDBBt96G3M8PW3Y29YsXS9EqmYyA667Fe/hwbLl5VM+fj2i1ounalZiFn12ywuPPwnLyFDWfLcC4eYvnb179+hF0551StKENk6HD7iJjVxl1ZUbMjXaCor3peVUcKs2Va3DcFgtFt92O5ehRFGFhxP+8CGVk86qxc9hRvIP7t96PUqbk45Ef8/L+l6mtKWbWXoEJh1wIbhHv0aOIevfdZs7RF+LUrlJ2LcnG5WzaQLjnuDgGTD2fljNs2ULJ3PsBCHnkEYLvupN/EqIoov9lKdXz5ze5t1qCKiEBv2lT8Rk1CnlAAKLdjnn/fgybt2DYskVKNQsCIfPmEXR321rciKLI1u8yydpfgVIjZ8qD3QlPaHtE12p08OPz+7CZnAy9Lpkuw6XUXv2SX6h4/nnkQUG037SxxUnCbbVSfNfdmA8eRObnR/xPPzaZvPSVZjZ/m0Fl/nlhtCBAn0nt6DU+Hpms5c9nSU+n8OZbEG02Am64gfBnn2nyut1lZ03eGhrtjbT3b097//aEeoW27PljNpMzchQuvR5t9+5Ys7IQrVbcMoHFQwQ2DdGxaPJiEvyaVndhN8GnZxsb958L414jp8rANQv20WBxMDg5mJ3t1NiBlT3a41/5HsWl31FWmkJxzkBucg4j6t/9kXk1XRTYChsx7CjBmlnrKQhUxvjgMzQKbadghLPX5NixY/z+++94e0Pf7otxyBxE2xK4wf8DSqwOPk6NZUZ4oMc2IdJPw9ZxdWhW3AHeYYjzTjB7wxxO1p7knm73MLf7+Y4Not2O5dQp3I2NuIxGHKVl2AsLsJ7KwHb6NBeWYari4gh96slLdh2oKTFyfFsxZw5W4nKcf159Q7REpwQQnRJAVEoAXr7S/Gy3Oik9XU/esWpyj1bjsJ6PFqo0cvpOTqDL8Chk8tbTgaIoYtqzl7KnnsRVXYOgVOI9fDi+E8Yj9/fHbTYj9/dHnZyM3McHt9lM4Y03Yc3IkCLUi35qMUrlttupfvdd6r77vsX39Zs2jYiXXvxDEdW24n8ap/8Q/i7iZHFa6PtT65UN0d7RTG0/laHRQ+kQ2OGSA7/bYqFk3jxMO5s2yZUHB6MMD0cZEYEiPBy5ry8yLy2CVotM64UiKBBtt25X5H59DqLTifnwEYxbtyIP8CfgxhuRX+A076ypoXHtWrz69UOTcl7/YDl2jOK778HV0IA6OZnYb75GERR0xe9/yXOz26n++BOpz9jZ295nzGiC7rijWZPWS6H0dD3bfsyiobopCdX5qRg4oz1JvcI8g3Nb4dLrKbjxRuw5ucgDAgicM4eAG2Y3uXaez3G2jPxgyV46FIt0yxcZdULAxyQNqH4zriHihRdajaCIokja2gIOrsoHIK5LEP2vTuTEjhIydkkmhAOmJdLzqvPC4+qPPqbmE6kVQuDttxH6yCN/eQjdbTbjrK1tUj3jrK6m7Ol/Y9ol3cOq+HiC770HZWwscm9vSXRfXU3jhg0YNm5qlkK+GLqBAwi6+x50/Vp/xi6E0+Fi/4o80jcXI8gEJs7tSlynpvelobaGHT98RW1JETazGd+QELqOGkdy/8Eozi40T2wvYefiM+j8VNz4ygAUSjmiw0HuhIk4iosJefQRgu9sSkjdJhMl8x7CtHs3Mp2O2G+/aVJhdWpXKbt/ycbpcKNQywmJ9kamkFF6WkphR3cIYNzdXVBrW74PGjdupPRByRk+6v338B0/vk3X5GLUfvMtVW++iTIulsQ1a3BbLFS88KLHg2hTd4Ft16fw04SfmkdkcjbDj9dITZznrIW4ARwurGP2FwewOd30GRrDLq2bGI2Kz2OKqTtzHyaDP0eOTma4vRN9rhmKrlcYolvEmlmLYWcp9sLzJFLTIRDvIVFYAkUqKiooLy/3/GswSGnhYUOzcHMIncmJIekXbipX46+Qc3RgJ04U6bnu8324Rfjm1j6M2H2T1Fdx2JMcSh3NbRtuQy1Xs3HGRgI1gdiys6n78Sca169vEoW/GKqEBImEXDUWTZcureqZqosNHFyVT8Hx8wtmmVzSb9mtLkR30+lbpVWgUMmwmhy4nedf8wnSoNEpaai2YLdI0fXASB2jbkm9ZHQSpDG77IknMe3Z0+o2gkbjefbkAQG0+3Vpqxqmc7BmZNCwZo303DqdeA8ehPeIkXiPGP63OYafw/+q6v5h/BMap6VnlhLmFUasTyw1lhp+zf6VPH0eUxKncG3KtW0y7nPW1lIybx6WtMMIWi0RL72EtmsXFOHhl4xC/Cdhy8mh8NZbcVXXoEpMJPabr5uJc68ULoMB84EDWM+cwbBxE7YsqReT74QJBM+974oEzzaLk73LcjzkQuevpuPgSNRaBce3l9B4lkgFRXnTfXQMIXE++Id4IVe2TeTpKC+n6I47sefmAlLKM/jBBwi49tomJMhRVkbed59Rv3Qpfhd0t1HFxxP29FNNyuYvhsVo59DqAk5sl8T2fSa1o8/EeM9AdXRjEXuXScLnkTd3IHXg+chX7dffUPWW5Dek6dyZ8Oefa7FU2llfj+1MNq76OlwNjShCQtB0SEEREdHqgGg6eJCyx5/AWVFB0B23E/LQQzSu30Dla6/hqqtDUKsJefghAm+4odWVqMtoxLB+Pfrlv2PNyJCiq4KApmNHdAMHSq7KKa2nQS9G3rFq9vyaTWONNCEMuz6ZzsOaCsEL0o+w9qN3WiyF9w0J5fqX38E7IBCXw82Pz+3DWG9rIig/59Iu9/Oj3bLfPJONo6KC4nvvw5aZiaDVEvvlF3j16uU5dnluA8vePgxATGoAI25KxSdQEnJn7S9nx6LTOO1uwhP8mPxgt1YjoVXvf0DtwoXIdDraLfutWZWeKIoYNm+Weho6HKBQEHDddZ7v3W2zkTt6DM7q6iZmqaIo0vDbb5Q/+xyIIvOnyPCfPJnXB7/e/B4428cOn0ipP54uiPmbs3l/8xmSwn0w9gsm32onVi3nX9bbCRJr2bPnOtQuHTfEjMe/SzjGXaU4ayy4EWmQmzG0E2gIclDVWEt5eTnWVgh1x44iQcE/gijSpyiEeb1/Zl1NI3dFh3BHYABTP91DncnOtB5RvD9UgIVDQaZAnHeCm/Y8Tnp1OtemXMsz/Z/BtG8fxXPvRzybepMHBqIMD0em06EID0cVF4e6fSJevXpdMh0HUF9h4uCqfHIOSx0PBAESeoTSbWQ04Yl+CIKA3eqkLFtPyel6Sk/XU1PctMLQN1hDXJdgknqFevYR3SKZe8vZtzwXq8mBXCFj6HXJpA5q/dk8933asrJoXLMG485dHs2qs7oaZ3m5Zzt5QABRH3zgWZiUZddTnFmPzeRAJpfRZ1I8aq+2R5LcbrHVqOmfwf8iTv8h/LdV1V0Iw7ZtlD/zLK7a2rOi44WtmuT9t8GWn0/RnFsl077AQMKff77NpaiiKCLa7VLZf0mJVF6+alWT9KTcz4/wl1/yCBbbiuLMOrZ8m4GpQaoC6zQ0ioHTElGdXc07HS6ObSrm6MZC7NamIlqZQkClVqDUyNHolPiHeREc403nIVGe/T2fwemkce1aaj5d4PF+UiUk4DN6NOqk9jRu2IBx6zZPdaPNV0PAsJH4DxuJ79gxrZYvWwx2di05Q+7Ratwu6ZEfPCuJbiObe6PsW57LkQ2FaHRKbn5tIEr1+chSw4oVVLz8Cm6jEQQBVWICmtSOCColLn0D9tzcFj2rAGQ+PqhTktF0SEU3eBC6AQOwFxTQsGwZdT/8eL5iE6kIwVktibDVKSlEvfM26qRLC7EvhuhwILpcyDRtNx8EKbW2Y/FpctKkSUvnr2bQjPYeI8tzyD64l5XvvQ6iSEh8AkOuuxm1zpuik+kc27gGU30d7br3YtqTLyAIAid3lLDj54uiTk4neVOnSpFGPz/CnnsWR1ERdT8twlVTgzwoiJhPPkZ7QVcGt8vN0jfSqCk2ktI/nFG3pDab9KqLDKz44Cg2s5OoZH8m3t8Npap5hFB0OimcMwdL2mHUHToQ8fLLaLt0liwajh6lav58LGmHm+wjeHkR983XaLp2pebTT6n56GMUERG037C+2f1X/eFH1Hz6KRYVPHGrnMnD7mreuNVmhM+HS304k8bC9UvQW50MemMrJruLd2/owdsmPQUWOynk8Jz4BAUnhlJcH0eSK4Iwtx+1goFahZE6mRGnu7mIXSaTERISQkREBOHh4URERBAS4s+xtKuwOKuJLrXg0/F9+hhScImwtmsij317mNxqE12i/Fhyd3+81s2Doz9C52vY1Od6Htn+CFqFltXTVqPdf4rShx5CtNvx6tOH4Pvuxatv3yuOyrocbnYuOUPmnjJPNi+pdyh9JyfgH3ZpvY/N7MBicOB0uFCq5fgGa1slQ1ajgy3fZ3oiWcl9wxhybTIa3ZWnx1yNjbgaG5HpdMi9vT0Lm5KsOlZ8cKzJtvFdg5lwb5c2RZRcLjcbPj9JcLQ3fSa17rL+R/CPEafvvvuO6667DvV/abTin8Z/I3ES3W6q33+f2i++BCQDtch33r6k2Pi/EfbiYkrum+sx7fPq3x+vvn3QdOyIIigYuZ8vos2Gq7ER66kMjDt2YElPl0SWbnez46ni49F264a6Qwf8Jk287GrvQoiiyLFNxexbniOJK0O1jLixA1HJLWuwrCYH6VuLKcmso7bM1ERbcDGCY7yZdH83dH7NnynR6aR+yRJqPvwIVwshf69+/Qi4YTY+I0e2yZdp/cIT5B6ViEhonA+9xsWT0KPl6+B2ufnphQM0VlsYPDOJbqOakitndTVV77xDw4qVrb6fMjYWRUgIch8fHGVl2PLyPAJ8DxSKJn/zmzYNr359qXjpZUSzGUGlIvjeewi8/fa/rbpRFEXPZGNusJN7tJrT+8uxGBwIMoEeY2PpPT6+CXkEqMzLYfELT+C02eg4ZARj7nrAk5YDqC0p4ocn5+FyOBh9x310GzOh1aiTo6yMkgfnYT15ssl7qJOSiF6woFlfvOPbitm1JBu1l4IbXuyP1qfla1OZ38iK+UdxWF2XTMs4KirInzZdcqpGIurOqiqJHCOlYQKunYUiNAzj9u2YDx1C5uuLtls3Two17LlnCZzdvKJMdDopmnMr5rQ08sLhqVvk/Kvv49zc6SIxfMVJ+HIUOK0w6jkY8iivrsngi1359I0P5O1betJ/fyYi8Il4O3H5JlYXt2zsq1QqCQ8P9xCk8PBwQkNDUcjl4HKAw4TDUkVu3juUNm5FbXPR3zqaZzo+z7dltQz09yYis5E1x8uJ8NPw+9xBhNmLYcEgcNlwzFnD1Udeo9hQzD3d7uEO3/HkXT0VHA58xowm8t13/9D9KrpFNn2TQfYhqS9du27B9J2cQHB083T9XwHRLXJkYyEHVkgNi3V+KobNTiG+a/CfJik2i5PFLx2QihVSAgiN8+H41hJcTjeDZrSn++hLWza43SKbvz5FdloVcoWM657te1nieCX4R4jT/v376d+/f5sOaDabyc/P//9ty5Vz+G8jTqLdTtm/n6Fx1SpAcroOefih/9q03OXgttup+fRTiQS6WicfLUFQq1FGRKDp3JmA665F26vXHxoIbBYn23/M8oTLOwwIZ9j1KShaWLm3BFEUsZmdOGwu7FYnDqsLi8FOXbmJ9C3FWAwOfIM1TH6ge6uDgquhAcPmLZgPH8aWlYW2ezcCrr/+iqIvZTl6lr9zBEGAqx/u0SrpuxCndpWy/afT6PzV3PTygBbTjc7qaqwZGVgzswARub+/dN27dm0m7hftdmz5+dhOn8Z89CjGbdtxVlQgqFTohg7B/5prPKXJtrw8GlevwW/K5L/FQwsg53AVmXvKqCxsxGZyNns9INyL0bd2bJFo1JYU8+sr/8ZYX0d8t55Me+J5ZC1EFg6vWcH2779AoVYz551P8AsN90SdlGo50x/r5ZkU3TYbla+9jn7pUrz69JF8dMaNaxYtMzXYWPT8fuxWF8Nmp9B56KV1JOU5etYtPOEhgr0nxNNnQnwzDZ4tJ4eahZ9j2LAB0S5FVWW+vviMGU3IAw+gDJcsEtxms1TIcOwYAIJSSfCDDxB0++2t6nQclZXkTZqM22DgtVkyjiXKuLPLndzT7Z6m1bBp38Dqh6T/T/+CirgpDHlrKw6XyC93D+CZmmqOGy3cJ37AlLotlJ4YSKaiA6FeLiK0NsJVZiLkDQSiR+a0SM1nHWZwWMBuRnSY0fvKKAtXUxWsxi2XrkGXqgisk9YxKC0PhyjycUwkj30lWZ+snDuYLhFe8OVoKD8GCcP5qfdM3jj0JkGaINZOX4v+xddo+PU3dAMHEvP5wj/cW23f8hyObChCJhMYf28X4rv8sUbrV4qKvAa2fJeJvlJKMUa096Pv5ASiklvvrXk5bPk2g6z9FfgGa7j2mb6oNArPvS+TCUx9pAcR7f1b3Fd0n3Xl31v+t12Lf4Q4JSUlkZCQwB133MGECRPQ6Zq7ymZkZPDjjz/yzTff8Oabb3LzJcpr//+A/xbiJDocNG7cSO1XX0n+GwoFES+/jP+0qX/p+7icbnIOV1FdaMBQJ+kFItr7EZMa2Mz/56+ELS8f0+7dWNLTseXk4GpokMLCKhUyX1+UkZF4DxmCbtBA5AGByDRqZL6+f/p8ynMb2PzNKRprrMhkAoNntb38vC3QV5lZ9eExGmusqL0UXHVnZ2JSr6zxbVsgukV+feswVQWNdBwcyYgbO1x+J6SUwQ/P7MXUYGfETR3oOKj1Kr8/dF6iiL2gQIpKtSCA/7twsTAeAAHkChlKlZyolACS+4QR1yWoiRcQgMvp5NDK39j/28+4nE6ComO5/uW3UXu17LItut388tLTlGSepMf4yYycczcul5vVH6VTklWPd6CamU/28VRCwaWbmjrsLn5/7yhVBY2ExPow48nebdJ/WAx2di4+41kAJPYMYfScji0uAJz19Zj370cZE4smtUOLqSZXYyMl8+YhOhyEP/tcm3RjFa++Rv0PP1Detx3zRknVwu392/Pq4FfpGNTx7IcXpcbC+z8FmQJmL+HJ9FAWHyomxEfNkLHtWGQ0MFTcylzxc4buKqctT6NVJaMiTE1ZuAaL9vzn0ZndxFqjiBi3nEdKLPxcXsfQAG/a51tYdKCI0alhfHlLb9jyMux6BzT+OO/exVWbb6XKXMWz/Z9leuAIckaOQnQ4iFu06JI+bK2en8nBgZV5nNxRCsCoOal06P8H29r8QTjtLg6uzvdEhUASj6f0Dyd1QESrUc2WkLG7jG0/ZoEA0x/t6SFIoiiy8ctT5ByuQqmRM2lutybWJyClmHf8fJrK/EYEAcbe0Zn2vf56edA/QpwcDgcLFizgk08+IS8vj+TkZCIjI9FoNNTX15OVlYXRaGTatGk8/fTTdPmbeuv8N+HvJE6uxkZMe/dh3L0LV20d2h490HRIwV5SgqOoGNHlQnQ6sBcUYMvI9KRyZF5eRM3/AO8hQ/6S8xDdIvoqM8WZ9RzdVIixztbidqFxPnQdGUNonA86f7VHiFpV2Mih1fmUZutxO0VkcoHEniGkDoyk9Ew9GXvKcNrceAeqCW/nx4ALNEP/KdSUGDm0Jp+8s2ktnyANY+/oRHi7v8aF/UKYG+2sXXBcGiRkAsNvSPnLCUrm3nK2fp+JUi3nhpf6t5gWbA3HNhex59ccvAPUzHiy9xXt+59AlcGKUiYjQNe6zmvvshyy9kn+RN1GxpDcL4ygKO9mJOliuN0uVr//JtkHpa737br3YuzdD+IdeOnKz4L0I/z22nOotFruXvAdKq0XVpOD3946jL7STESiH1Mf7XlZAuR2i6xfeIL89BrUOgXXPNaLgPC2tUU5h6z95Wz7MQu3UyQ03pdJ93dF6/33tvQ4B2tWltSYWKmk9McXeDlrPnXWOnyUPvw44UcS/M9aFbjdsOxOOPkrKHXUz9nJ9UvLyKow4K1VUNs9gEBfA/PFu+gW+gAh5XWg0IDS6+yPFpRa3Ao1tc5sSk17qTWnAxIZkMu8CAudSGTktfj6dUcQBHLNVoYezMIlws8d4rjnk/3YnG6W3NWffsIp+P5qyahz5rds9fFj3rZ5BKgD2DxzM/qPF1C74DO03boRv2TxFV0Tm9nB6QOVpK3Nx2KQzFj7T02g17j4v/DKXxmM9TaOrC8gY2+5x/ZA7aVg+A0d2kRgzlWPAvQaH0f/q5sW39itTtZ+epzSM3oUShl9JrcjONobk95O3rFqCk/UIIqgVMsZfmMKyX3+um4BF+If0zidQ1paGrt376awsBCLxUJwcDA9evRgxIgRBAb+9Svm/zb83VV1trx88iZPvqL0lDwoiIDrryfg+uvaVMLvdos01lhorLFgrLPhcroRRelBNtbbMNZbMdbbaKy14rSdPw8vXxVJfcLwDdbitLsoPaOn5HRdk7JXAIVajtZbiaH20qXhFyMgQsfE+7riF/L39cC7GC6nm7JsPYUnaik4UXPeYkCADv3DGTwz6YqqQK4UToeLbT9mceZAJQgw6pa/ZrVZW2rk4Kp88o5JBLDflAR6T4i/omPYrU6WvHqIxmoLIbE+TH2kxx/yqfor4XaLVOY1UHCylrIz9RjrbZgNdrTeKjIsFswyGNI+mIhgL0JifPAL1WLS26jMb+TUrlKcdjeCAEOvv3ya6xxEUWTLVwtI37QWuULB2LsfJHXIiLZ5QLndfPPofdSXlTDqtnvpfpXUsFdfaWbp64ewW12XjejZLE62/5RFzlm9x9UPdW81zXE5lGXXs/azE9hMTiKT/Jkyr/tlSeNfhfxrZmA9dYqwp55EuHYKD259kGPVx4j2jmbRxEUEaM6md512+HYilByE3rdTP+INbvnmIMdLGhB1CmyDw3hbfIAU7wD69FnR5HswmfIoK/+Fiorl2O3nS/j9/HoTGTmTsNAJyOXn0+IuUeT69Fx21hsZG+RLzyonH2zOplu0H79fF4bw5Wiw6qHbbJi2gHs23cOesj3c2vlWHup4LzkjRuLS61vspyaKoufcRFHEpLdTX26irtxEZUEjeceqPeQkIELH0GuTiO7w18+hDruNvMMHMen1ILrxDgqmfZ/+yC7RXNtmcZKTVsmJ7SXUlpoASdjtG6xBrpARGudLTMdAj9WF0+7i0NoCjqyXDI+7jYxh0Mz2LT4jTruLdQtPUnSqtsX3TuodysBrktpk7vlH8Y8Tp/9Bwt8VcRLdbrKHDEXu74/34MEoIsIxp6Vhz8tHjIgiVxtEckwwOo0CVXQ06uQUNCnJnmqW9GI97246wzMTU0kO8wGgoVqKGtUUG6gpMVJbasRpby6ibgkKlYzgaB/a9w6l0+DIZuF9c6OdjN2lnDlUhbHe2kQMLQiQ3DecbqNi0HgrMdZZObG9hPz0GgKjvOk2MprASB31FWb2LM3G1GBHo1My/t4uRF5mYnC73Kz77AQN1RZ6jYsjuW+4R7dRW2pk6/eZCDKBSfd3a1YpYjHYyT9eQ+HJWooz6nBcQA5lcoF23YLpM6kdQZH/TApJFEV2LcnmxPYSBAFG3pxKSv/wP5QWtBjtHFiZT8auUqkqR4AOAyIYdn1yi27BottNaVYG+qoK2vfuj+aitJm+ysyytw9jMTiISvHnqjs7/2NRiothMdhZu+AEFXmt++NcDqFxPgyYltjmCcrldLB78Q+krVoGgsDkh54guf/gZtuJDheuBjtumwu5rwr5BamNI+tWse3bhQRGxTDn3U893+u5iJ7WR8kNLw1o0W+p9Ew9W77NxFBnvWTqQnS7qS0tpjIvh+DYeMLatW6zUVtm5Le3DuOwuug4JJLhs1P+dt8cgLpFi6h86WXUycm0W/E79bZ6Zq+ZTamxlJ6hPVk4ZqGnNx4FuyXyJFfBvOPoFUH0emUzLreIdWgYt3r9xGj3Srp2WUhg4EAqK9dSVv4LDQ3nKwCVyiAiI64hImImOl1Ci+f0Rl45HxRWopXJWN4lgds+2Uedyc5n0+MZt/9GqMuD6D5wyyqKrTVMWDYBgLXT1qL7fTuVr72GMiaGxPXrEORyMvaUcXp/BQ3VFkwNNtRaBVofFeZGu8c/6UIERuroPDSKjkMikbdiRimKIpV5OeSm7Sf/2GHMDQ24XU7kSiXegcH4hYaR2Ksvib36eQoURFGkpqiAk9s3c2rHZmwmU5NjhsTGM/yWO4ntfGn/OpfLTdqaAg6vK+BipiCTCQTHeBMU7U3p6XqPbUfPq+LoPzXhkveUy+kmfUsxFXkN6CvNKFRy4rsEkdAj9G8Tw1+I/xGn/xD+1lRdQ0Mz88lGq4NrPt1LdpWRe4Yl8uT4lrUqjy1NZ+nhEsZ0DOPzm3pxamcpu5ZmN4sKyZUyfIO1+AZpUKhkgIBKK8c7QIN3gBrvADU+gRr8Qr2QyQTcbpE31mcR6adhzqDWXcTtVifmBjvmRhveARp8g9sWPTLW21j32XGqCg3IFTJGzUltVv59Ic51pz+HoChv4joHodLKSVtTgPPsSu7CVbXL6ebY5iLS1hY0IY5aXxXxnYOI6xJETGrgFUVVRFFEX1GGUq25bNrmksdxi2z/KYuMPZInSmynIIZcm4R/aBvaz1icFGXUUXCihvz0Gs8AndgjhL6TEwiMbJ7ScbtcHFm7gqMbVtNYLWlfvPz8GTHnLlIGDGnasLOwkeXvHcVpc6H1VTHypg7/mHD1HPSVZlZ9nE5jtQWlWhpkYzsH4R/qhdZHRUZeHW8tPoFKFBABX0FgbEQgFr0Nn7P3YWKvUOK7BLWZJBRnnGDzl59SVyppckbMuZue4yc32UYURUwHK2hYm494joALoG7nh65fBF7dQrCZzSy89xYcVgsz/v0KcV27A9Lksfjlg+grzXQfHcOgGecF/1WFjRxclU/hSWlV7husYfScjs0iTVajkYMrf+XE1o1YL/CSSu4/mMHX3URARMtRtYITNaz59DiIl25U/EfhdLg4uaOUrH3ldB0ZQ8dBkbgaG8keMhTRZiPupx/x6tWLXH0uN669EaPDSP+I/nw48kO0irNjxtfjoWivx1X86o93k17SgL1LAIMSjdxjvheVKhSXy4zLdc7DSEZw0HAiI2cSFDQCmazlaLHJ6WJVtZ6HsqTv9oOkaJatyeZgfh3RAVp2Ri9Elr1eagdz5xbwDuX9w+/z9cmvGRQ5iI97v07uuPG4GxoIf+EF/K+dxcFV+aStLWj1mggyAb8QLYEROgIjdcR1CSIs/tJ6TIfNysaFH5G1Z8dlr7lG501oQnvUWi/qykqoLSnyvOYbEkZ4YhIIAoXHj3iIVHK/QQy/5U58gi79PFcVNlJwvAa3S8RmcVKSVe8Rk5+Dd4CaQTOS/hZN0l+N/xGn/xD+SXG4w+Xmtm8PsStbCj3P6BXNOzNbXinc9NUBdmXX4IvAq/HRFB2T9glP8CUyKYDgGG+Co709hKitOFRQx8zP9qGUC5x+efzfYkrmsLvY9NUp8tOlcx44vT3dx8Q0G1jqykwsee0gbqdIUu9QCk/WNvNOikrxp7rQgN3qIr5rMD5BGopO1npScUFR3iR0Dya+azAhMT5X7PTdUFXBrkXfUXgy3TNhBUZG077vAHpNnIqX73niK4oiTpsNhUp1yY7nbrfIoTX5HNlQKGnCFAI9x8bRc1xcMw8efaWZghNS1KwsW+/xZgIIivZmyKykVqvnqgry2LjwQyrzJKNLlVaLxtuXxmqpDLrTsNGMvfuBJpVi1cUGNn2dQX25NOB2HBLJoGvat4lkulxubCYncqWsVRfr1iCKIqcPVLD7l2xsZic+QRomP9Ctmb7ncGEd1yzYR5S/NOmW6i0surMfAxOvnOCZGxvY+ePXnNohteTx8vNn+C13kjqoaf9Ct9VJ7U+Z2LL1AAhKGYJGjttwvnlwwIxkdL3D2PL1Ao5tWEN4YhLXv/KOJ01SeKqW1R+lI5MJ9BwfR0q/cA6vLSBrv6TDEmQCqYMiGDS9fTP937GNa9m9+DvPJKhQqwmOjqUiLwdEEblCwZRH/01Czz4tfs4jGwvZtywXmVxgxhO9CYn1ueJr1RIKTtSwY9FpjPU2z2eYMq870SkBlD7+OI0rVyF4eRH+7LP4Tb2aI1VHuG/zfZidZnqF9eKTUZ+gU+ogZwv8OB0UWnj4JK/tqObznXk4o73w6hrIx65bkIuS+7dWG0tkxCwiIqajVjddcImiSL7FTlqjicMNJg43mskwWji3dLolLJDiPWXsza3FR61g+QQH7dfdIAnU79oB4Z2pMFUwc9VM9DY9H4z4gI7f7Eb/82LUKSnE//Yre5fnk75FImG9xsUR3y0Yb38NdosTi8GOxluJf2jbzXBBGmNWvPsa1QV5yORyEnv3o33v/gRGxSCTy3HabRhqa6jKzyVj93aMtTVN9pcrFLTr0Ycuo8YS362n556zGBrZu3QR6ZvWIrrdKNUaBsycTc/xU5BfQUVgQ7WF6iIDtaVGVFoFnYZENhkPbGYTK999lZLMDAC8AwMZf/+jRHdoe8X93qWLCI6NI7nfoDbv0xb8jzj9h/BPEqcPt2Tz3qYznt+v6hTGwpt6t7jtuHe3E1Bso69VgQoBQSYwYFoi3Uc3JyBXgvc2neHDLZKvUtozown2/nvyz263yO6l2ZzYJjlbdxkWxeBrkz1Rr7oyE9t+zKKqoJG4zkFMnNsVq8lB7pFqqosNNFSZiesUTPfRMRRn1bH64+NN2hJofZQMuqY9yf3+WCpMFEVObN3A9u+/wmGVSJhCqcLldCKK0lCsVGtIGTgEnX8A5gY9+elHpEFNEPDy9SO+aw+SBwwmoUefFomUvtLMriVnKMqQ+rJ5B6iJSg7AP8wLfaWZ8ly9Jyx+Dn6hWtp1lYhgRHv/ZsRWFEXyj6ZxdMNqCo5J6Qy1TsfQG249q9eRcfD3pexfthjR7Saxdz8mznscper89+xpP7KlGESpT1bX4dFEpQSg9VHisLpw2KQfQ52VwpO1lGTVeYSvCBJhjU4OoNPQyMuKmxuqzexcfIaiU9J1CGvny4R7uzapQjuH7aermPPNITpG+BKoU7E7p4b3ZnVjes9LR1JEUcTcoMfcoEdfVUFu2gFyDu7DZjaBINBt9DgGX3dLsxSm2+6i5uuT2AsaQSHDb1w83gMjEWQCznorhh0lmPaXg0JG6H3dsGvtfPPwPdgtZkbdfh/dx07wHGvjV6c83j0XIqlPGH0ntWvRqiLvyCGWv/kiAMExcQy67mbade+FXKGguqiA7d99QdHJdORKJdMef94T5br4s6/7TBKcB4R7MfPpPi2aZF4JDHVWFj2/H6fDjc5fjX+YF6Wn69F4K5n1dB+0oonShx/BfPAgAAGzryf8uec4VnWMezffi9FhpGdoTz4b8xlauQa+GAllR6DTNLZ0fI3bfziKTKfAPDiMOcFmblVvJDRkPP7+fT3Ps8np4qjBzOEGs0SWGk3UOZprRqPUSsYF++E6Wcfig8XoVHK+v60PvTZMg/J06Hs3THgLvVXPLetvIa8hj/b+7fmx/csUzbwW3G5iv/+Oam0Caz45DtCkF+EfhcNq5eDK30hbtQyn3YbW148pDz9FdMfWGxq73S5KszIw1NZgt1hQa7W069kHja71tFd1YT6bv1pA2WmJ2ARFxzL69vsu+T5thSiKrHrvdU8xxTloff248bX38Q25fFRq/7Il7FnyA4JMxq3vLWg1evpH8D/i9B/CP0mcZn+xn725tfSOCyCtsJ6BiUEsurO5r1ZDtYUPXtxLsFMaQOo1cPsDPYlI9P/T5zDt0z0cLdIDsObBwXSK/OurzM5BFEXStxSz57ccEME7UI1MJmA2ODxidZVGzvXP98M74NKu0NlplZw+UEFAmBfB0d7Edwu54qjHORjqati48CMP8Yjq0Ikhs+cQnpiEw2ql8MRRDq38zRPJuRw6DBrGuPsebnGVJ4oieUer2b0027NyvxAyuUBkkj/xXYKJ6xx0WXO4XT9/x8Hfl0q/CALJ/QYxYs5deAc01frkpB1g9Qdv4HI4aN9nAMFX30Wwj4aU8PPRiJLT9Wz5NqPF82oVAp6Gq+d+b98zFJlCoCxb7/EZUmsVRKcEoNEpObGzBLdTRK6Q0XdyO7qPjmm1Kenq42Xcv+gofdsFEhvoxa+HS3jsqhTmjmi5m3v2oX2c2r6F8uwszA36Zq+HxMYz+s77iUxunhIXnW5qf8jAeroeQSMn5M6uqKKaTlCiW6T2+wysWXXIAzWE3d+d9J3r2frNQtReOm59/zN0/lJE0Gh1kHWokqyNxTRUWwiN82HIdcmtVnKaGxv47l9zMTfo6TZ2IiNvvauZ0NfldLLq/TfITduPQqVmyqNP0657r2bHshjtLH75IOYG+5/SO4miyKrj5Th2VVFxso6I9n5MebA7AL+9fZiaYiOhcT5c83gvBERqv/yK6vnzwe0m6qMP8R0zhpM1J7lr410YHAYGRg7ko5EfoSo6AD9MBbcTe6dZpB6ZgkuUYR0eDmo5S7olEqNRkdZoIq1BIkmZRisXKzhVgkBXHy29/HT09tXR28+LCLWK3GojY9/ficst8sPtfRli2Q7L7gCVD8w7hlGp4e5Nd3O85jhhXmH8MP4H7A88jXnffnwnjCfy3XdZ9vYRKvIa6DY6hsEzrszd/mKUncli9QdvYqiVijqiUzsz/v5H8Q1uu2nvlUB0uzm1cys7f/za0zao79UzGDjrxiuKPl2Mcx5mMrmC6U+9gH9YBCvffY2qglxC4xO57qU3UapbH7vTVi1jx49fAzD0hlvpM+WaP3wuLeF/xOk/hL+bOF1YkTHine3k15i4e1gCC3fk0SXKj1UPnBeoim6R3KPVbPsxC7vFiUkQ2aFzcEruYuUDg+ga7f+nzqXB7KDHyxs5F7j5Zk4fRnT4+/PYOYer2PxNhsdXBECpkRMW70vvCfFtMnL8KyCKIlm7t7Plm8+wmUzIlUoGX3czPSdMaTZhnYvslOecxmo0IlcqievSnYikFFwOB/VlpWQf3MuxjWtwu1wk9OzDpIeeaHUQcdhdlGRJwn59pRnfEC0RCX6EJ/i12brh9L5drP7gTQB6jJ9Mz3FT8A9vvXKvOOMEv77yLG6Xkw2hY2iM6My+p0Y2mVBtFicZu8soyaqjLKcBl92FSy7gFCAkQGooGpUcQFznQAIjvFF5KbAY7JRl68k+VOlJx14OMR0DGTIr6bLRqSWHinjitxOM6hBKaoQvH2/L4ab+cbw8tenq2WG3sf27Lzi+ef35PwoCWh9fdH7+xHTqSlLfAUSldmqx6shebKBu6RmcVWYEpYzg2zujjm+Z4LjNDio/PoarzopXz1D8Z7Rn0b8fpTIvh7iuPRg+93F+Sqvgq915mOwutjw0FG+7SFCkd6upY1EUWf3+G5w5sIeg6FhufP2DJo7lF8LpcLDynVfIP0v0e0+ezuDrbkKuaKr7Kc6sY+X8Y4AU1es9IZ64zm3TgoluEYfNxZqsCt7/8QTXmtQIAsz6dx+CoyWy3Vhr4ZdXD2EzOxl7RyePdrHq3feo/eIL5MHBJKxaiSIggKNVR7l7091YnBZGx47m3eHvIstcBUtvBdHFCvVk5jVcT/9hsWzXtF55HKVWniVJXvT21dHJR4u6heju3J+OsOZEOaNTQ/lydhf4uA80FMHIZynoNoN52+aR15CHr8qX78d/T0ReA4WzbwClkvbr11Ft9mL5u0eRK2Tc9OqAP2zZIYoixzdLxNrtcuIbEsawG28lqd+gNhPZNcfLqTPbSQzW0SnSD78rqAa2GA3s+ukbTmzdCEBEcgf6TplBbJduqDRtr3IWRZGMnVvZuPBD3C4XI2+9mx7jJF1gY00VPz71MJbGBiKTU5k47/FmhNBiaGTXom895zFw1g0MuOb6Nr9/W/E/4vQfwt9FnKoardz41QFqjHYOPzMagJRn12N3unn/2m48vCSd+CAvtj82ApfTTfahSo5sKKS+QhLqlcndbPBzMrBLGCvTy1qcPK4U606Uc+9PR9C4rAi4eW5GX67vF3f5HS+Dc2FlL39/NDrvFgcIk95GXYUJpUqO2ktxxdqsP4uGqkp2/PCVJ+QclpDE+LmPEBTdvMfblSDvyCFWvfc6ToedgIhIxtz1ADEd/3r/s6qCPH5+7jGcNhu9J09n2I23tWm/vUsXse/XRZhlGn6Kvo7Vj42jfWjLYX/RLWJxuOj0wgZEEbb9azjtgi9NdGpKDGTsKUetVRCZ5I9fqBZEaKy1UpxRi77KQkq/cNp1a1v7hy935fHKmkymdIukb7tAnvn9JGM6hvHFzVJKWxRFctMOsHvx95JoVhDoNWEKSf0GE9YusVXycSGM+8rQr8wFEWTeSgKvS0HT/tLk3VbYSPVn6SBC0K2daFTWsfi5x3E67NR5hbEseByWs+XxX8/pzcgOrRdEABz4fSm7f/4OmVzO7FfeJSyh5YjaOTjtdrZ//yXpm9YCEBqfyFX3ziM0vmmV2bHNRexfkecpj+8wIJzIMVHszqklq8KAWxR5ZWpndGqJrJ8+UEF2WiUVeQ3YTE5MagGX3YWvKKPD4AhG3Zja5PgHV+dzaHU+IbE+zHyqN4Ig4LbbyZ8+HXtOLr4TJxL17jsA7Cvbx9wtc3G4Hbw2+DUmJ06GE7/Cb7fjFFR0tixkWr8k9kQqOWO2opYJdPX2opefRJJ6nY0mXQ7HS/RM+XgPggDr5g2hQ953sPEZ8Ing4KzPeWjXkxgcBkK1oXw48kM6BXei6I47Me3ejf/MGUS8/DKrPjxGUUYdnYZGMXx2ymXfsyUUZ5xg368/U3xKSvcl9RvIuHsfQqVte4uRM5UGxr6/0/O7t1rBzsdHENiKp1lrOL1vNxsXfojdcrZRsUJBQs++9Js267L3Wl1ZCdu/+8JD1FMGDmXig481eX5Lsk6x/I0XsVvMaLx9GDDjetr16I3b6SL7wB6OrFvpiXz1v+Z6Bs264YrOv634s/N3m5asMpnsD4Vvn3/+eZ577rkr3u+/GRf6OP0d8PdSkVNlxC3CmaxajNVWZHY3ghzah0grOIvZSfqWYo5tLvKkS1QaOYE9gngvo5DYQB3TekaxMr2M7Weq/vC5NFZXUZJ5kiPrdnFDSTaBDj0AZfMXsdDfD9HtRiaTExIXT3hiMikDhxAYeT6/73Q4SFv5G7mHD2BubMBptxOZnEpUSir5xw5TdDLds613YBADZ91Ap2Gjmqz0df5qdP7/rPGioa6Gk9s2kb1/D9VFBQDI5HIGXHM9fafObLG9xpUioWcfrvn3S6yZ/xb15WX88uJT9J48naGz51xSQH4hXl2TwcGCen66ox/e6uaPcl1ZCcveeAGnzUZc1x4MmX1Lk9fPVBoob7AyLLl5GqDftJkc2LYNr9pyhtfs5HB+n1aJkyATKKg1e8qVzfbmZdcXIzjah6HXNhcj+wZriU658kii0Sa9p7dGQYSfFL2raLBKhOnwQfYtXURVgVSFqfX1Y8L9jxLfre2Nr02HK9GvOLt/9xD8Jycib0NDVHWcL94DIzHuKUP/WzZhj/RixrOv8tubLxJoquSaipXs6XwL+fU26k2OVo8jiiK7Fn3LoZW/ATD4upsvO5EBKFQqRt9xH3HderDxsw+pKsjlp6cfpt+0WfSbdq0nHdN9dCxJfcJI31zMsS3FZO2rYNHREraoHZyz5x6QGMSs3jEeG4ULobOJgAyLIKLs3vz76zI8iqMbCqkuMlB6up7oDoHIVCoiX3+dgmuvo3HNGrTduxN4040MiBzAfd3vY/6R+Xx67FPGtRuHsvM1sPkFFA3F9JdlcrggiNWTB1NksZGs06Bq4zMjiiK51Ua2ZFax5JAk5p7aPYoOvk7Y+TYAruFP8eyBVzE4DPQI7cF7w98jWBuM5fhxTLt3g1xO0F13UV1koCijDkGAHmMu3XvtHOwWM4UnjlF0Mh19RTn6ynL0FVIlrUyuYNC1N9JnyjVXPN9WNEiaRy+VHJdbxGhzklttJFB3Zb5QKQMGE57YnrTVv5N/LI2GygqyD+4l++Be4rv1pN/UWU00UOeer7S1Kyg9S/zkSiUDrrme3pOnN/sc0R06cdObH7L6gzepzMtm27efs+3bz5tsExQdy+g7516RiPyfRpuIU35+/uU3agH+/v5/aL//ZsydO5e5c+d6GOtfDZVCRoKvlvblTjbPl27Ee9FQooXKvRUMsSjo1iBj99KzDXB9VXQbFUOnoVGsP12JK7OQMF81PWL8ASius9BodeCrOT/I51Ub+eVQMTd08cNZW47VaMBusWC3WrBbLOgrys4KDaU8u+bsD0gyFcHlaFLBYaitJu/IIfYu/Ym4rj2I69oDjc6bw2t+b1ISC5BzaB85h/ZJvwgCaq0XNrMJY10tGz/7kGPr1zBx3mNNCNg/hdLTmaStWkbu4QOIZ5sFC4KM6I6dGX7zHc1W6X8W0amdmfPeAnb++A3Ht6wnbdUyGmuqGX/fw22KgPx2pJQ6k50dp6uZ2LVp6q22pIhfXnoac4OeoOhYJs57vFnq6Z4fDpNXY2LLo8NIDGlKiuQKJYY+16Bd/wlJ5jxyfv0Cd+8XWyWNudVGz//N9r9nUXEOToeD+vJS9JXluJ0uQMSSW0WYtQFfoxpNvY0EUz4B2Y38+NRSqvIlwqPUaOk5fjK9Jk5F69P2VablVA31v0nFGd6Do/CbeGWd2n2viseSVYer1krD+gKipqbS/ranOfzJywTY6+kvFpBPBPVme4v7mxsb2PL1Z5zZJzXUHXrjbfSZPN3zenGdmd+OlHDX0AS8VC0P6Ul9BhCZ1IHNX35KzqF97Pv1Z+rLy5hw/6Meoq7zUzPwmvYERunY8m0mPa0KUMioj9NwpLSBMxUGMvaUeUhT15HRJPcN5909uRw5XEGkS0au0o2mysBQmjo+a71VpA6K5MT2Eo5uLPL4aGm7dCHkwQep/uADKl99FZlOh//0aczuMJsfMn6gxFjC8uzlzEqZBYkj4ch3DJOl82Jld/QNNjoHXT4q43C5OZhfx5bMKrZkVVJYe76M3lej4OHRybD7NbA2QGhH9oW2o+xkGb4qXxaOWYhWoZUaqH/yCQB+kyahiIpm5ztSZKV97zCPaa/b5aKqII/qwnwaqirxCQrGPyyCmuIC8o4coiTzFG5X04WFXKGg84ix9J06A9/gPyaBMJ1dOHSK9MXpFjlapKfOJN1PbpsLy8kaEEEZ7oUyzAuhBU+3c/ALDWfUbfdIXlDFhaSt/I3MPTsoSD9CQfoRojp0JKZTVzQ6HzJ3b/NoOkUg3yuOHtNvpN/kAZ7jXSg7AfAPC+f6l9/i6PrV5B4+QNnpTEAgrmt3kvsNInXIiD+lr/on0Kazi4v782mZ/6FtqC4yMLkEFC7pq1H6qaDBTrwFTm8tpT8SAfIJ1tDrqjhS+od7jA3PrTrCfTX4e6mI8tdSqrdwsqiORIWB6sJ8qgvz2Z92AldtGb+4Ly3uFWQy/GMS2FKvo1IXycwJQ3lzSz5XxWt44aoEBJkMu9VCVX4uhcePknc0jcLjRyk8ftRzDC8/fwZdexPBMXGASOGJY5SfySK0XXu6jroK35BQ1h0rJH3TOlQntlBVkMvi5x7nmqdfatOK+s9AFEXqy8soOJbG6f17PNUlAGWaCE55d6BD3/48dNPAvy09qPbSMeau+4lK7cSGBfM5s28XhpoqJj74GH6hrbcbEEWRBosUodibW9OEOBWeOMaa+W9hMTQSEteOGc+8gtbbp9n+JfVSVeCRwvpmxAmgQAiiKHQMY6s2oyk6xqr332DCg/9qUml3Dv8Ucdr50zekrVruqWA8BxUwC2A17Acmnv17FRJh6jFuEr0nTbsiwiS6RQzbimncXAgiePUMxW9Cy6TJ5XJhsViw2+34+vqiuGDgl6nkBExLoubLE5gOlKPrF0G1zJfD/j0YUreXwOydCMEz0ZubRpxEUeTM/t1s+fozLI0NCIKM0XfOpeuoq5ps99LqDDZlVOKjUXL74NY91nT+AUx59Gmy9uxg/afvk7VnB2ovHaNuv7fJZ+rQP4LdJyuxpdXR0yhDyHMR6FKi2FbFNrNkk9B9TCwDpydSb3bwe2YFdpWbjt3CKU0v43BhfYvv3310DCd3lFCUUUdFXgPhCdLCM+juu3DV11H33feUP/MMgkqF36SJ3NX1Lt44+AYL0xcyJXEKmvaj4ch3XKXJ4EUjfLg1u1VblnqTne1nqticWcXO09UYbOfJikouo39iEKM6hDKuczhhrko4sFB6ccxLLM2WonpTEqegVWhxNTZS9uRTmHbsBJmMoLvvJn1zMRV5jSg1cgZMk8xGDbU1LH/jBU+UujX4h0fQrkdvQuMS8A0JIzg2rol9yR/Buc/nrVacry6ss9CwoQDj/nLEC8w3BZUMXd8IvIdEobiEJksQBEJi4xl//6MMmHkDaat+4+S2TZRmZVCadX6sdMiUHPfpRKZ/F+pl3oiN0qLPbXVS/dlxnHobqmhv1Il++AyORlDKkCuU9J40jd6TpuGwWkHgkmLx/zZcMa0bOXIky5YtaxZNamxsZOrUqWzduvWvOrf/JxEYqQONnEqrA7/BoWhjvPnq9yyuCvJjRGwQv+4vIkfp5vvHBhLm1/RGq2iUiNO5v3eM9EVZlsn+N35mn0nv2e5cLEMUZARHRePl549Kq0Wl0aLSavHyCyAqpSMRySmsOlXLnqXp9IkPICE6FLdQRKnLqwmpie7QiZ7jp6CvrCBj5xb0FeWY9HUERMYwaNYNTSaryOSLtA/5dcxdchK3GIM2bBaTK9YSZqhmyYtPMe3xZ4np1PUvvLrSZFR86gRnDuyh4FgaDVXny8DlCgUdh45E0XU4H62QwvhZmXrCN5xu1XD0r0LHISPwDghk5buvUZ59mu8ff5CRt95NxyEjWkzdme0uXGfV+vvyJJNEk76e9E3r2PfbzyCKhCUkcc2/X2pGms7tb3dJ5COjWI8rJayJ2zVAUZ2ZHF0irlAZ46s2knNoH0uef5KrH/s3PoFN/ZFyq887E5ttl0/V/RE01lSRtloiTWovHQERkSjOkrjcslpsRgN+GgW+OjU5DW5qlQFcN64/A6666oonJrfZQd0vZ7BmSVYIuj7h+E9t36Jou6CggF9//RWjUSKPXl5eTJo0iY4dO3q20bT3R9slGMuJGvQrcymOlHPSpyODTenIjHWkaLKpN8d7tjfW17HlqwWe6GxQdCzj7n2I8PZNG+q63CL7c6Xv/0Ly2hoEQSB18HAEmYw1H75N+qa1ePn5M3Dm7Cbb5QfJOa61MxYNMouLHijgrGlsl2FRDJyeiCAILE0rxu500znKl9sHt2NlehlHivS43WKzxYZvsJb2vcPIPlTJivePMuS6ZFIHRiAIAqFPPonLaKTht2WU/etf2HKymTH3Hr499S0VpgreSXuHp7reh1yQE+ksJopqlh2B+4YnkhDijSiK5FQZ2ZJVxZbMSg4X1nOBCwnB3ipGpIQyKjWUwUkhTVPbv78JLju0G0pVZFd27HsMgGuSrsF85ChlTzyBo7gYQaUi/IUXMHuFcmDlIQAGz0jCJ1DDj2v3o//9U2wNdai0WsITk/EPi8BQW42+sgKfoGASevahXY8+BEZeWVm96BaxFxuwlxhwlJlwW5yIDheCTEDup0buq8KvykBf5HS0C3gJAj3R0GtdCYaz6wtFkAa5vxpHhRm3yYFxdynGfWV4dQ/FZ1g0yssY7fqHhTP6jrn0n34dGbu20VhdhUlfR2BkDHcd02GRafnw+h48+PNRDubXS8bAq/NwVEjjgi1Hjy1Hj9vkxH9S08i9UtM6YXLWWBC0ijalxf9JXDFx2r59O3Z785Cy1Wpl165df8lJ/b8MuUKG15gIPtiWzQTRSWSDlUqFiLJLACMmdeCBM4UYbS5MLehIKhvPR5zMjQ2kZq2gQ+VRRCTPntD4RELi2rEk10WaQUNi+0SWzL10Q+Bz4d4ofy1hvtIkVdXYcqTKPyycgTPbLuarM9l58OejuEXoHReAw+3PcmEK1zdsxk9fyPI3X2LGMy83I1t/BKLbTWV+LrsWfdtEWyVXKIjq0In47r1IHTQM78AgFmyXUjsRfhrKG6x8tiOXYckhDEj8487gbUFs527c9OaHrP34XcpOZ7D+0/c5sm4lPaddT4fevZHLzz+uNbX1hFsrCLHXEFFVwcK532OsOa9n6zJyLCNuvbvF6BBAvcnGQBSMR8mAg3rKDxxAneSP39h4VDE+uN0iRXVSSqM6MInfZWpmNW6hMi+bHx5/kMTe/Ynt1IWYTl3xDgwit+rvjzgd27AG0e0mplNXZj77apMoya3fHGTb6WremtGVWb1jGPrWNorqzNzdZ8AVkyZ7mZHaHzNx1VlBIRBwdXt0rTQbPXnyJMuXL/doHmUyGWazmV9++YVu3bpx9dVXIztLfP0mtMOSWYc9vwEfhxKnTImu92jMe1bQR38YY1ky5sZYjm1YzZF1K7GZTMjkcvpOnUW/abNQKJtPHhkF9Yy3yeiHFwEnGqhpOIUmJQBdv4hLmrp2GDgUm8nE5i8/Yf9vi0ns3a9Jm5YzlQZOqF3cNqM9sUaRBcsyKZe7+eKxQURGnifie8+SthldQzGnbWRk3RFEt5vVXxcycOwYgmPjm7zv0GuTsZocFGfUse2HLKoKDQy7PhlBEIh46SXkPr7UffsttZ8txHYmm4fnPcAT+//NktNLKDGU8EpED4LL0hgqP87PrlG8uCqDhBAdWzKrPPer5zOG+zAqNZRRqWF0j27ubQaAvgiOL5H+P+p5fs9dgUt00ce/Kz6fLaXw+x9AFFFGRRE1fz7azp1YOf8oLqeb2I6BpA6K4FhmAYU/vI3GbcMvIopZz7z8h1NuF8JtdWI6VIFxX7l0L14CnYD30EH+ue1U4AZVjA8+w6LRdAxCkAmIoojtTD2N20uw5zdgPlyJ+XClpNubmNBs8XQxvAOD6Hv1DM/vVocLy3GpQnVgYhAquYwao42ig+XI06T+m4GzUnA22GhcX4BxTylePUNRtaGdlaPSRPWXJ5D7qgm5owuy/3AD+AvR5jM5fvy45/8ZGRlUVFR4fne5XKxfv56oqL/OoOr/ZcTH+iEKUFhr8njfRJ51RPbRKDDanBiszYlTRYMVRBFNUTrffvMLoqERNwJFkX15783zZoavvreDGrsRmf48AVpxrBR/L1UzofA53YW/l4owX2llUG204XKLyP9E+koURR755RgVjVYSQnR8d1tfjDYnA17fwk9+Y3kh/ABVWcdZ9voLzHz21T+ctjuybiWH1/yOsa4W99nJTa5Q0HHYKBJ79SWmU9dm5bZHi6RUw62D4jlTaeTXwyWsOl7WhDiJbhHLiRrsRY04KkyIbpDrFCjDdXj1DkPh33wV5ba5EB0uZDplqxoZv9Awrn3+dQ6t/I0Dv0v6nPXvvcIKmRqDfwwJvnKc9ZWYG/TMvGA/owkQBEJi4ug9eTodh45s8fiiKOIoN+FYns1bnF1lnr3HbNl6qrKPoesfgXVoJHanG7lMYEzHMJYfdeIY/AChBxZRU1zIyW0bOblNKhn2D48k1uSNRhGIUaGj9piRDFMIGm8ftD6+BEbF8MHOIgprTcy/rgfKVryYLgWH1crxLdIA3Wvi1c2un/GCVAVIi4eiOjPlDS1POG6zA3uJEfFs1E1QyhGdbszHqiQ9iFNEHqAm6MaOzTyaACorK9m6dSunT58GoEOHDkyfPh2ZTMaOHTvYvXs36enpxMXF0bOnJEJXBGjwHR5N4+YiJpY62IScxKFjOXVkM/6WBvx3fsaCnZ953iO0XSJX3dO8Ag6k79GwrRjvrUU8eE6BaBaxZtVhzarDnF5N4IxkFJdoedRtzHiKTh3nzL5dbPnyU65/+W0EmUxya6+QHLk7RPmSGuHLib2nqWx0UOF0cmE74pJ6Mz4OA5ZlH7C3ophzct7sTRlkb1pBWEISw2++nehUSVCs8VYy+f5uHN0kVfGd2llKcLQ3nYdGIcjlhD35BJrUDpQ/+xzGrVvp17cPbw97m2f3PMuesj3crQzkN2CoTCJOO85Us+OMpMU8l4IbnRrKyA6hRAe0oSptz4fgdkK7YbijevLb/n8DcO/vNur2fQ+A37RphD35BHI/P2pLjRRn1iMIMOys59Xx1UvRuG1Uq4JRjb33T5Mm0SViOlhO46ZC3GbpvhY0CtTxviijvJH7qRAUMnCJuBpsuBrtnM6uxVpvJchLBUoZRxvM1KX4MW9OtybPiiAIaFIC0aQEYitqxLC9BGtGLZZj1Viz6vGbEI+ud3ibOylYLzAW9dMq6RbjR1ZBPa51BcgB70FRePWQroejzIjleA365TmE3Nvtku9hLzdR8+UJ3CYHcp3S85z+t6DNxKl79+4IgoAgCIwc2XxQ1mq1fPTRR3/pyf2/ivizgsfCahMqUXpwIs+m33w0CsobaJE4VTZYGV67k7LfpfyzX1Qcn4u9qdOG8Y7s/Fd9ThtTZbBhtjupMdiZt/gYcpnA7/cNokv0+RV6/Vndhb+XkiCdCpkgpQdqTTZCff54Tnpndg3bT1ejVsj4ZHZPdGoFOrWCockhbD9dTWWf64jGSWlWBj8+9RDBsfFEJnVAoVYjVyjoMGjYZcXaB1f8yq5F33p+l8nlnh5eremHRFHkaLEegB6xASSH+fDr4RI2ZVTyytWdkckE7KVG6pdn4yhpnhqxnKylcUsRqlhfFIHS9XFUmnDWWBHPRmJkXgqU0T74DI1G00IzY5lcTr9ps+gy6ipefuVDvIuPonHbUNfl0Fh3fjuDXEedKpBydTjJXTrz3G3jUXu1PFm4Gu00rM/HmqPH3WhHCdgRWYadzTj46NY+BKXXYj5ahWl/ObaCBgIQ8PHX0q9dIMuPlnK4XsaPr39A0cljFJ86QfGpE1Tl56KvKCMJOGf9Z9gI6zaef29BkNGgCsSsCmWFO5t+vToRHBN3RXqjUzu3YjOZ8A+LIKFH8xYixrPGqB7idPZ5OReFvRC2vAZqf8rAbWo9pahJCSDw2hRkF3nhWK1Wtm7dysGzzteCIDBgwABGjx7tiSyNGjUKrVbLxo0b2bp1K506dUKtlhYtPsNisOU3QG4D7+KFXFTjvPkRVv/wI3G2UhQuOyHxCfSbOpOkfgNb7WBv2ldO48ZClEABLlbgwCCIvDGmA6btJdgLGqn44Aje/SPwGR6NvJXGzCNuvoOCY5Lv2PEtG+g2ZjwVjVYarU7kMoGEEMlWIjnMh8pGG9mVBnrGSlVzEgnPZ1bZGsxuK15+/pjie3OgsIHuOjNeFVlU5mXz22vPM+2J54ntLKXdBZlAz6viQIB9y3LZ9csZwuJ9PS1f/K6+GtHhoPyZZ6n5dAGjr15PzPhvuW71dZyR1VEjlzFIPEnfGB2lBjcDE4MYlRrGkKRgj11Cm2CohCMSOWLov/jl9C+Umcpo3+iF975TIAhEL/gUn+HDPbscP9vRIKF7CL7BWuoryqg+LGVadgQNxppWxW2jnC2ex8urM9h+uorf5w7CR9Ny6slebKDu1zM4z/aBU4Ro8RkSjbZ7CLJLuLqvXG5l0YFaHh4YRYiPmueWn2C07NJ98NSxvqhv7oi9xED98hwcpUb0y3IwH64iYHp7lGGXthQBsJwlTkq5gFIuo19MALcW2FBZXShCtPhddV4f7T8pAevpeuzFBho3F+I7Oq4ZeRJFEcvJWvTLs3GbnSijvAm+rfP/3VRdfn4+oiiSkJDAwYMHCQk5H5lQqVSEhoYi/wvKtP8HiA7QkmjOY1DxXvxOG2ivCsG8r4xMfXsibVXU2O3UVVYiJgZ69C9Oh5POuWtINpyRBvMZs+lz9TV89Np2nBYH2ZVGOkdJhOgccQIorDWTczbN4nKL/GtpOisfGIRaIX2X+rMRpwAvFQq5jGBvNVUGG1WNf444fbtHqtSc3S+W1IjzE+iMXtFsP13Nbyeq2fLYc6z78C0K0o9QU1RAzQWiy8xd25jz3gLUXucf7tqSYo5tXIPLYcflcJCxaxsAA2bMpsvIsej8Ay5rJVDWYKXaYEMhE+gc6YdcJuCjVlBtsHG0qJ7EfCOGjYUIIggaObpeYSgjdAhKOS6DHWtGLba8BuyFjdgLG1t8D7fZie1MPbYz9Wg7BeE3McFDsi6El68fJSlj2S10Z1SInZrc00SEBfPCzSM51qDg7iWnkAngFqHcpG2VNIkuyenaXixFEZAL1Ed6cXdxBWVnw00nTFamz0pB2yWYusWnUVeYeRsvvg/Q0CtOmijTixsQZXISevTxkBeryciGrfv5Yc1egux1aF0WYoK8iQ3UYjMZMenrMdbVEmSrIchWQ+HqDApXS6eh8w8gdcgIBs6YfUmdg7lBz+E1ywHoMX5Ki5ovo026p89NWOcsCcobrJwsbeD6L/YTolNzh07HkBIrghvkfipkZ1MTot0NLjfq9v7oeoejjG7uK5abm8vvv/+OwSBdx9TUVEaOHNlkLDyHvn37kpaWRl1dHbt372bUqFGA1M9OeW0ye1/bRy8UCCvyiJ3VnrVh44j0VbL+zu74BIdccsKzFTSgX50HwDdyO1+7rNK3KMLT3YKJ7B5K/bJsbDl6jLtLMR0ox6tXGLo+4c2iZ96BQQyadSPbvvuCXT9/i84/gGIfSWDeLljnGQeSQn3YlV3Dmcrzi4XsrDOMK12F2m0nOK4d0x5/lrQakY+/TaM2RMfq559i/YIPyD+axvK3XmT6ky808SrrMSaW8pwGCo7XsP7zE8x8qg+asxOk37Rp1P20CFtmJjUffUyn554lRJVAtT2PdZogbjJVM5493Prkv1u9Tq3CaYfqLNj3CbhsEN2XbL9w3ln7CADzClOAQ3gPG9aENFmNDk4fkDItXUdKPm77fv0ZRDeF2hjKNRFgdrDoQBF3Dm2+qFuVXkaVwcaJ0oZmPRRFh5vGrUUYdhSDW1pc+Y6JQ9c3AkF++eiP0XrejiPgLNnXt1KleTFU0T6E3tcd474yGjcWYC9spHL+UdSJfmg7BKLtGtJiCs9lcmAtMxKNDJVCjqvBxuRcMzoUmASRdrNTm1TvyX3V+I2LR78iF8PWYuwlRnwGS1kqt82F22jHfLwGe36DdF4xPgTf1vm/KkV3Dm0+o3OVdW73f1fIrC2YNm0a27dvZ9SoUfz6669NXlu9ejWPPvoobrebJ554gjvuuOM/dJYSGqoq2LjwQyZUnk+NhtmrKdiygoIt0AXpJ/ujJXzytY7I5FRkcgVVRQUkGypwIWPi/Y/SabDUkLRjhC/78mrJKGukc5QfVocL+wVO3IW1Jk6VnZ/gT1ca+HBLNo9dJYmh9RdEnFwmB701aqoMThqz6xHDfBAUMmxOF+tPVjA8ObSZW+0XO/PYmFHBv8am0C9BSnUV1JjYfja8fvOA+Cbbj04Nw1ejoLzByuFyC9c8/RLmxgaKT52gpigfl8vFmX27aKiqZNeibxl9x1wMdTXsWfwDGTu3Nau2GjBjdjPh66VwLk2XGuGL9uwKb0SHULaml2H9NRtjjR0ByPSVM/L+3sgv6pvmMzgKR40FR4kBV4MN0SWyOL+aFUV1TBkSx5xBCQi1FkyHKzHtL8dyqhbL6Tp8hkbjMzym2arSLYqIgoyg+CQ212gw+XoTltAe42Fp5dsjNoD0Yj0l9RaK68zEBDYnTw0bCrEXGxA0CoJmd0DdzpetacWUFZd7tjlR2sD0ntFoU4MIvb87RfOP0MEpZ7JdTmKINwqZgMXhosZoI8LvfPpHo/OmLjCRNP/zad87Brdj5qTzwujGmhqmv7iIEFs1cbJG2iuNNFRVYtLXk7ZqGdkH93LVPfOaGYCW1pl4/v0f6FS0DbfVhMbHl87DR7X4vZ2bOHzONhkN89UQiIB3sZE9VbkMtgrMtkK7WikCpe0aTMCM5Euu4s9BFEUOHDjAhg0bEEWRgIAAJk2aRGJiYqv7KBQKxowZw5IlS9i3bx+9e/f22JeUGm08gZlPZd4kW8FvUwlyoM7iumwPL2edldqfssAtYmvvx1c5xfhqFAR7q8mrMVFUZyY2KZjg2ztjO1NPw6ZCHCVGTPvLMe0vR9XOl6DrOiC/oJqq+1WTyNy9nYrcbFa88wryiHaE052U8B6ebZLDJMJ1plIijfUVZWx49yXUbjvVukgefOltlBoNPbTSZJ1XbaLKoWTKI0+z4t1XKTh2mOVvvsTNb32Ef1g4LrfIa2sz6d4nEJ9SI401VtYvPMHkB7sjV8iktN0TT1A0Zw71S5agmzmL+poE8M1jY2AiN5mqGVnzE7ifhFaicgA4LFB5CsqPSf3nyo9DVYYkBj8L66AHeXzXE9hcNoYF9ydiRzpuIOCGpuPGqd2luBxugmO8iWjvR01xIZm7twOwP6AvGqUMq8PN57vyuGlAHJqLSv4brdJYeqFfl9vmwnSgHMOuEk9zaG23EPyntM0n7BzOpap91AoCzppe1rWROAEIcgGfwVFoOwehX5GLNbMOW7YeW7aemnX5BE9M8Ojm3DYXhm1FGHaVonSJLMYbbFD++kF0gAWRR0Qz33jLufhu1vWPQJDL0K/K9Swem0Ehw2doVIvj4X8L2kScVq5c2eYDTpky5Q+fzN+FefPmcdttt/Hdd981+bvT6eSRRx5h27Zt+Pn50atXL6ZNm0ZQ0N8rAr4UlGoNFbk5uGVy0ny7k+ndgTh7OfOSNdTVFZNXUILTakGLHZvJRP7RtPOfR5CzN3YCjw8+38W9U+RZ4lQukaMLo00ABbVmTpVJDH9ESgjbTlezYHsu1/eNJTrAC4fRzjiUpO6qpHxJHk+LADpYX0zZ1jLUSf5847TwyekK7hueyOPjzlefuS1OLNuKudHipubz4+zz05A8NYnvc6oQRRiZHEx4rY3qlfmIVicB05PQhOu4unsUP+wv5Je0EoYkheDl60fKgMGkDJDazLTr3otfXnyK9E3r0Hj7cGzjGk+H+PZ9+hOWkITVZCQ8MYmUAZcWv1+Mc/34esT6A1Jfshvkau7CG/8aOw5EPsDKDgcc8W55YFMGa1Ge1ZYsPljEa9nSKvXU5mx+SS9j0Z39Cbu6Pd79ItCvzMWW14BhazHmw5X4TWiHtuv5iMO5yrngsyu+c6nTc4NwuJ8GAX/SCuvZl1fbjDhZsuow7pRIVuDMJDRn29ScG7y91ZJm7lTpefKsDPFia6SK8UU2+pZacdVa0KrkGKzOFoXf56q55DIBl1vEfFFDVbV/ADm6RHJ0iewD9j81ikC1ZE2x7ZvPaais4LdXn+WG1z8gJDYet8tF5u7tbPj5Z1LrK3ADIfEJl3RTNp1N1enkMkwHKxh0oIbReCMrtAE2JiJ9H42IfI2NF69p3+ZBeePGjezbJ1W3devWjUmTJqFsQah9MTp06EBsbCxFRUUcOXKEESNGAFBSb8EK/BAq4xW9AspN3I2aTx02rA5Xswn3HKw5euoWZeI2O1GEebGunRZyoF9CEC63SF6NicI6E4MJZvuZao4W6Zl3bzcc+Q2YDlViOVmDPb+Ryo+OEnRDKuqzvfBkcjkhM+dRsvo3NGf24CzPZyb5COk51AwJIjgmjqQwKY2WXWmksbqKX195FruhgWpVEPndr/NEDAN0KrrH+HOsWM81C/by2U29uPrRf7P0lWcoO53Bxs/mM/PZV9mfV8dXu/NpF6xj6b29Wfb2YUrP6Nn+UxYjb05FEAR0/fvhPXoUxs1bKL75ZlJ6DubUQCjwMlMvehFHKabjK9B1P+tpZW2EihNnCdLZn5ozILZQrKD2g4iuuDtezYs1e8nR5xCkCeIJ/UCMht0oY2PRDRrk2dxudXJyRykAXUfE4HI6Wf/pByCKyNt1pYpQpnQMJ62gjrIGKyvTy5jZI9oTLbI5XVjPurLXme24zQ6Me8sw7i3z6Jjkfmr8JrXDmeSPSyHnSijDuYWDTq0gwEsaKy62t2gLFP4azgwO4+WcUro7BEajJMUpR78iF+PeMgSVHFe91XPObrUci82JElAhIPNR8qnCzql6F2kF9Uzo0tRfThAEdH3DUcX5oF+Tj7vRDgIIKjkybyWKAA3egyJRXKYH6X8abSJOU6dObfK7IEjq/At/P4e/y1H7z2D48OFs37692d8PHjxIp06dPKL28ePHs3HjRq6//q/vjdNWePn5M+GBf/F1hpUDpwzEIeNxTRTtSgX8Jl3N69V1LDpQxIMjEpjdXkF5dhYIAgV2LU/vrCMxpql2p2OklAY7VdYgef8Ym65CCmpMZJQ20hU5TwYGME5jRWl1Yfoxk0pBxntVIEMLpRIxMSoFKhxOolVKNHYX1lO1XA9EoYXTDRh9y3DbnLga7JiPVTHdKgPOplYanBi/y0Amc3AjKm6rhNpvTnnOpeqTY/hPSeTa3tH8sL+QdSfKqZqYSqhv04copmMXuoy6ihNbNnBg+S8AhCcmMfK2e4ho/8faHpzDuYhTj1h/rGfq0a/IIarWCsjIx8UbWDmFCyyQU20kOax5qf85ZFcaeGGV9Pmu7h7JnpxacqtNfLEzj2cmdUQZriP4zi5YTtbSsCYPl95G3c+nUR+qJPDaFOQ+Ks4FeIN0UoRAb7Y38XDy1SgJ89GQVljPmbOC3nOwZNVR91MmAN4DI9F2Op8eOCf6758QxObMSk6VNTQpIV8r2gnASX+3grpFWUQp5GThxNIScaqS7o2kUG+yKgzN7AicrqZdnXZmVzOrdwxJfQYQ26kbqz94g4L0I6z7+F2ufeFN1sx/09O2wSaoqGo3kIdefshjiieKIq56G7aCBuwFjViLGvnQpaEUNyw8Qb3BgZTAFcjDhRWQC9BjRDyTt2dS73bzkNmBTn158pOVleUhTWPHjmXAgAFtNr8UBIFevXpRVFTEiRMnGD58OIIgUHy2+ssrVEfgmFhqf8hkNmpKcVNvtjeJ6AG47S4MO0owbCsCNyijvAm6qSN7lkvVof0TgjzHLKozI4oijy1Np8ZoZ2BiEP3bB6FpH4Cz1kLtj5k4yk1Uf3ECv4nt8B4YiSAIvL6lgHxTB+ZOG0zF9hWEV55AVnCC7/41l8jkVBIHj0TrMmOqNfDzC09irKlC8Atmpe9ExoQ2dQr/9Iae3Pl9GqfKGpn9xX4+v6k34+97mO8ev5/ijBOkb17PKY30nBptToKjvbnqzs6s+SSdrH0V+IV60Xt8PADhzz1HSUUl1pMneX7HWhaLSpYN0rNQO5wnrWuRbXkRsldKJKkur+UvQhcCEd2a/vjHIQKv7n+F1XmrkQtyXhv8Ko773wVAPvUaTpQ10jnSD5lMYNeSMxjrbXgHqEnqE8qOH76gMi8bjbcP1r5T4GAtQWoFL4YG4WyoJ35ZAaW/FqAM90Kd4I9FBg+jIQiB7pvLKFtdAmcj/4pgLT7DovHqEUq1xc7I17fSJcqPn++SGrnbnC4OF9bTKy7Akzq9GIYLnPMDdOdTdS3ZQlwO7248Q6bDQb2vhiWNJq4RVDyk9MJZbfFsIw/U4D8pgcMKNzd+fZAO4T6smyctbH1WnoJ9Bt5Yl0VRnZlrekYT4tO0ulcZpiPktqatwNafrGD50RLe0sTw97WQ/2vQpvIWt9vt+dm4cSPdu3dn3bp16PV69Ho9a9eupWfPnqxfv/7yB7sIO3fuZPLkyURGSg/w77//3mybTz75hPj4eDQaDf369fMIM/8sysrKmlQCRkVFUVpa+pcc+88gsVdfYmMimYmKr9HRziXd+A1r8kgxSQ+bySESnphEj3GT6XHVJMyh7bHIvQi/iGR0ivQjCIFuxRYq3k5D+1E636HjKTTMQUXQqXreMyv5FB26fRUMsgr0RYGu1IyjxIgMgRxciIMjCf9Xb9YPC2UOJr7q5oP/PV3ZrnbjQmQoSoaW29GvzKVxQyGm/eWIVhf5uHgTCxn9gtmnBTkCc9wq7kGDqsGOoJbjPTgKdXIAosNN/W/ZRO6pZECMP063yE8HippdH5A6ZvuGhCKTy/n/2Hvv8DjKq/3/M7O9r3rvsiRbLnJvYGyKwZiOMSSUQEKHNFIgbxJaCKQSQoAQQqihN4MxvRgbd1tusq3e26rsStv7/P6Y3VW1MSR5k/f3zbkuLuTd2ZnZ2ZnnuZ/73Oc+Sy++nK/94nf/EGiKuIJ4O10oOj1cipq5W/oZeKKG8KAf0aRiXYaSK/HgTR3R/OxssR91f/5QhG+/sBd/KMqJU1L5w9oqfn2hnIp6fW8XwXA00f5BrEgi8wdzMZ9WgKASCTQOYXuwmkDzEJHYAiUlJu4NRyVcgTDOmKGdRaeiKCbgbRkY8VLyVNsYfOYQUiiKtjwJy5ljjRHj+od5hUloVSKeYISWwZHPdzh8/BYfUa2CUI+H33jVVKI4JuM0M1ZUMH6b0LiKmE2xNC2ARq/njBu/j9Zkpr+thSe+dy0t+/agVKvZk76Ep/IvoytvMZ6NXQw8WUPfo/vp/dVOen+zC8fL9Xh29hLp9TIdJaejRnKFUJjVCCtyuQAXV+DhWjy8Nt1E8spCNLHreKz2JvFwu90Jtn3JkiUsWbJkAmj6+IiNTod3so8DMuukUqmw2+2JsSVuPJqXpEdXmYppueyS/yN0uLeOpE+j3hCenb3Yfr8H18cyaNLPTif9+pmEDUp2xe6/RcXJ5MeYxvaYZnEgtkCKHwtAmaIj7YZZ6KrSICoxvL4Zx8v1RAJhumLbPbZnkPWmE3k+Zy3ZVQsQRJHu+iNsfuJhvtX+NF/vegn3QB/WzCyGV1yDV6knxzoW6GVbdbxy/WJOr8wgFJH482dNWDOzOPFrV8q//9+foL6hFRipyiqYnsKJF8seVTvebKZht+yvpkpPp+D553CfdSEAF20Oke6Q2J5RgFfSoHO1wqE3RkCTJQ/KV8Py/4GvvQS31MIPG+Cy1+CU25GmnkOXSsX65re5ZeMtvFz/MgIC9514HzNbJAJHjhBSqDi7MYlzHtrC8t9t5M9PH6B2Wy+CAKd9cxrNe7ax731ZqLfqpltwq0yciJJL9juZ2uBiBkpMsVs+1OvFvbWbyOfdXIia5aiwusMQjqLKNJD8tQoybpmLYX4mglJkU/0A7kCYg13Diev55JZWvv7XHTy9tfWo95lnVFWpVRczoJRGmOnOzk7ef/99/vjHP/Lb3/6WDz/8kKGhoQn76XR42dMmVw2+cv1iosArUhD9zVUkXzqVlCsrSbt+Jpm3zEU3LQVfDPxpVYpE8dg5s7LRqkR8jj6qP3qTX93/IOvWraO6uppwePKCDIcnyI9e2c/7h2y8e7Bn0m3+k+JLq66+973v8eijj3LCCSckXjv99NPR6/Vce+21HDly5Evtz+PxMGvWLL75zW9ywQUXTHj/pZde4pZbbuHRRx9l4cKFPPDAA5x++unU1dWRni5nUKuqqib9QT744AOys7MnvP5VIhAIEAiM6DiczsmFv/+MCHa5WbHTzupYmXGrScG00hS8e/tYViuzUC7/2IHfFiu7Hs3OSKEI6QcHeRkjmohAxO5HAEpQUBIngmNjvl+QSJqRxkf9Lj7pGWL1jEyWVWRw6it7GEDi4Kn5KLWqhCVBnyvAYw02Hgy4KUTkTFSUGrWcVJSCoFagMKlQZBu54vmdSMBdK0uwnlvO3g2NmHb0oUzTkbE0B930VEStUnZp3tSJ84NWvHv7+IVZxTWIPL+znZtWlKJWjsX4WoORy3/1IJFQGEOS9Std56g/jL/OjntbD8FW+ff8QyylQ6cbRDAuycF8aj4nDXg4+GkD3z+tjPdqetnT5mBni53LFk3uqv/LDUeo7XWRalTz+7WzEEWBk8rSSDfJ4vq4Sd/jn7egVYksLk7hByvLKZ+RyuBzRwjbvPQ/fpAlZoE9gF6tRKdS4AtFGPKEEgOiWaekJNZQt3nAgxSKMPROC55t8uCjn51O0popCOMsAOIpvxSDmqlZZva2D1HTNUxJmhFPIJyYeM3XzMD/Uj3JfV7+ggHP2y14T4qgStejsGpwI9Hnkp+L6TkWXt7dOQE4BccBp80NA2PsLAzWJE67+kY2P/wEhpCFkDbI/Gt/yB/W96MCruyL4mwfB6BFAXWuEXWhGWeyltvXHaRYoeQHF05HPzONiAADGw8nrBZOnSo3z00yqOl1+r9Q/+Hz+Vi3bh1er5f09PRJK4n3tjv41tO7KUkz8OH3T5IrLoMDiKIGpVJmIjUaDeXl5dTU1HDw4EFyc3MTQCs3Sb7XzKcX8tLODs70Cug+66J7lw2FWU2ozwuxS6ewarCsKkykcV/e1oonGCHHqmNqpjnRNaDd7mX7KEDfM+RjdIhqBckXl+PONTH8TjPevX34BnxEY79RKCIBEqIhlbW3XoZv2MGhzz6mfvvn9LU0oZZCKKxprL3jPr73Vkvse0xMn+rVSm49o4L3D9nY1zGEPxRh9umrqd/+OV21h0j+9DHS0lYxrBxpajxjeS7D/T72f9zBx08dwZikJavEgqhW03v5jTh3HGROfz3n7oiy/pxWfhi6jm+l1TJ3/hKZRcqcBYaxMgtJkmgebmaPbQ97bHuo7qum19M7Zpu7ltzFGTmncPjacxCBDQWL8Gj06FUKon1+fM39aBCYd2Yhafk63vqd7DI+/9w1FM+Zj2X/Hu5DD4EoCouGD60iz7T1M68ijdvnFBBsddLn9PNyTQ9DSOQWWbnpgkqUqboJQHx7zMzWHQgnnpHW2IKoobGZx+s/ZXhYBlUmk4mFCxcyffr0EY2TVolaKWLSKHEFwjS1dXFkzxYaG8f2FtyyZQtbt27lpJNOYtmyZYmK0A0H5HFjYVEyecl6DGoFnmCEYREKZ4wVtMMI8NWNSi/PzDZy9ywfh2tiWECCffv2sW/fPg4dOsTatWsTVabxeGRjY4I1axvlxyVJEqFQCPVxtKD634wvDZyampom7UFnsVhobW390iewatUqVq1addT377//fq655hquuuoqAB599FE2bNjAE088wW233QbIP8pXiezs7DEMU1dXFwsWLJh02/vuu4+77rrrKx3ny0Sww0XfI/vQS+BC4lH85M3NZ+mpUwg7/NDq5BfoeGVc/toWM6XMNGuJBsJ4dttwb+4iMhRAg0ANYYpOLaJeLfHSO/UsMenBFSQJgQNEkKan8quvT6Xl3Vre7+kn26xgfqmZASSUopAo846bYDb0uROO1Qvn5fDI7g4qzRouuHTErHLYF4rPWxg0CkRRZO7ZZXD2WPdjkEuUzcvz0BSYsb9Qi9YZ5HEM3O/y8+7Bbs6dPbZ3XdjhZ+ipOsIDPjx5JjRFFjQz01jXMcjC4hSKUicvpQ12uHBv7SbQMkxklI9VFBgiigew5JrIn5OJtjwJZYo8uc3ItfCXy+cBYI+Bil2t9gl9mECmnJ/d3gbA/WurEtWHSoXImrm5PLKxiXs2HKErNqn5Q1E+retHp1bwyKVzSb+piqE3GvHu7ePiIQkDWpKanZyn1JARihJ5+jCn+oPsQcSsVVGUaiAbgbmDIXof2kckVspsWp6LeWXhpH4po6slC1MM7G0fShibxo0ErXoV1hwT0Rtnsf6325ntiWLo8mJ/vjaxn4hVzU/Q0qwRyIsR2OOb/IZiqTq1QkSrEhn2hTjQOcSsTDOhXg+hbg/WvSZOz5GfcTJV7PSnUImdb6Fhlh9QClhOL0JhVaMwqFHlGhMapa7uYTYS5pBewe1z5IlYCaSbtPQ6/YgCrCiXF1nJsTSGwzMCnNxuN319fdjtdkKhEG63m927dxMIBFAoFFxwwQVjWqjEI+6WPuxu47M9v0Af3Y7bU4dKlcT0yj+SnCxrZGbOnElNTQ01NTWsXLmSDnuMcYqxRIIg8FGakt42L1cJGqLecEJDosrUo5+dLqfUYpNTKBLlL5/JDMt1JxUjisIYxmlH7LkEuUp0fAiCLARWZRkYfOYwUoeLm9DwuDpMKCoRDEeZkm5CIQoYk5JZeN5FLDzvIu55eRufbt7FSSctxpScSqdDtj3JSZrcK6oo1UCqUcOAO8D+jiEWFqdw1nd/zKv33cFgeysX9qzj3fSVY9JJSy4sZbjfR+uBAd758wEu+fkCDBYNvlCEF8tPYU5/PcsPSLx+whHeU51Kq7iSd04Y0TGGo2Fq7bUySLJVU91XzVBgaMx5KQQF01KmMTdjLivyVjAnYw6DTzyJ2NHGkNrAruUX8vlVJ1D7fju1n8tAwq6XgVP1O+vwDDkwp6WzdO2lSJLEgk75GtuydMy+YTbzBjzc/qCNlvo+vnf+dDJnprGvro/Ha1oBOFEZRZU2uVZv+6jfzu0PY9GrcLuGWKpswdA+QOeobV0uF2+88QYfffQRJ4VDKDUR3n25hT2pKZyoHEQjuVj/kuxwLooi06ZNY9q0aYiiyI4dO2hpaWHjxo3YbDbOP/981Go16w90A3D2LJlwSDKo8QR9OLxBCpk4psbtCHSj9IIff/wxh2vk4qbGSCrtESs/OjGdA9W7aGpq4qmnnuLSSy/FaJQLDrqHfDy9rS3x+bYY822321m/fj06nY61a9dOer3+XfGlgdP8+fO55ZZbePbZZ8nIkAcpm83Gj370o6OCjq8awWCQPXv28JOf/CTxmiiKnHrqqQndwT8SCxYsoKamhq6uLiwWC++++y4///nPJ932Jz/5Cbfcckvi306nk7y8vH/4HMaHKseIusAMRhWX1rRiR+KXSToEpUjKZVNp+91uiv2wvDNA1BvCd8RO1BOiuM3NtWhYcWCYnk07kWJiWYVFzZ+FIM8MeXkyT09fv4fPCWMtMvBZnTeB8n+aJ6dZUmOpjH7XSLd2q37EsDEOAuKT6/QcM2vn5/LS7o7EqicecfpYpRCOmpsfH5oiC+nfmY395Xqod/ATdOx7q4VAshl1vglBEGRztCdqiLrkyS/Y6iTY6sT1aQdWwnyc2snlaypRZRkR1CKSP4Lv4ACe3b0E28fqgBTJWrpzdFx3sB27IPGHi6tYXHVsI9fZ+UkoRYGeYT+dDt8YQbYkSdzxVg0A18xPIxMHg4MiSUlJiKLIRfPyeGRjUwI0XXNiEalGDfe9W5vQD4lqBUlry1Bm6Bl6r5WzUMPnvdwUf1z7fEwHnsaAf5ON6PvdvIwJJIjYvIhGFclry9GWJfHBoV62NA7ImqpRrJPDG0JDCHdPI+aew5yrttN3yEFDVoT2gDxAxidjUavktRw1v64f4IGyXApcYSLDAaLeMIqhIKtRQwB4s40PMeHpjGD7Y3XiWJFsAykIBJUiS0tTebeml7rtXaQfOpK4T+UDCQgKAak3xILebhbEBuoAEjlXTkdbOlZLE4+4MNw0zjsnwyIDp3mFyYlKo7hw1u4JEgwGWb9+PQcPHpx0v+np6ZxxxhlkZk7u+TU8vI+bq/7KrLRDRF0S8UL9UMjB3n1XMqX0NvLzv0VJSQl6vR6Px0Nzc/MExgnAalDzBA6mnFnChSVpRIYCqNL1kxpYvn2gm64hHykGNRfNlceg+D3oCoT5rG4kFdo7PJZxCkWi9Az5CUailBRbSL64nMFnDnMRGlxGDeY5GTzwUQPzCide6/LiXB6vtpPUH0KSpMQ9nJukI9jpYvj9VpSpOoxLc1DF2JSFxclsONDDjhY7C4tTMCanUHX9T3ny7rvI93ey2vYeDdXzKJ8nzx2iKLDyW5W8/rs9DHS42fxSA2dcOx1fMMLBlGK688rI7qhn9fYQTy1/nMaub7GtS8OBgb3sse1hf/9+vOGxqVONQsOstFnMyZjD3Iy5zEydiV418syG+voYiDXwfXLamRQWpLPjqVp6mmRmZ786zEGryK1BPzvflKuyF1/4NRRKFf7GIfI9UYJIdMxOYa5awbRsMwuKktnZYufNfV1cd1LJmKIcu2dytrPD7h2VWpXYf/AgjYf2kdreTmrs1p43bx6zZ89GEASamprYtm0bLpcLS2xt5BgcwDE4IFezxR73yspKTj755DFFTxUVFVRXV/P2229z5MgR7HY7S1eeQ02XE4UosGq6LOpO0qvpdPiO2oB6PONkt9vZtUsGa5dccglrX2zDGQozde4S5sys5LnnnqOnp4fnnnuOq666CrVazR8/aiAYjiZYsrYBN1u3buWTTz4hHA6jVCqx2+0kJydPeg7/jvjSwOmJJ57g/PPPJz8/PwEcOjo6mDJlyqT6pH8kBgYGiEQiCYAWj4yMDGpra4/yqYlx6qmnsn//fjweD7m5ubzyyissXrwYpVLJ73//e1asWEE0GuXHP/7xUSvqNBoNGo2Ghx9+mIcffvhfJoIXREH2rlArUN3bDc5AwjVcYVTTc2IWeR92sNAZpfueHcQbMslNTTVg8yEhG6cZl+agn5NO29/3wBD0OwOJB9iiU1GQqqcmVk1VGRORx0V8A+5AgpWw6kdo0nTzWIr1ltPKEmZubv/kwOlLmdLFvmfqlZX0fthK4NMOqnwC/X/ejyJZC1GJiCsIEQllhp6kC6YQ7vPiO2LHe3iQ6SiZPhCh/1F5xSOoRKSoBHGBskJAX5Uu2/5nGRD1Kl79uIGBgxIXzM7h3C8ATSCvrqbnWNjXMcSm/fUk+brx+Xyo1WqigpIMTyez1C5CB3fxfGxOVqlU5ObmUlBQwIpsic3dUWYVpPLjMyp4a5+8yhutoRYEmYG7a0cLVY4wi3KsdNm97PMFmLMwB/v+fub5BfT2ABIQAfYTJmdOBlVnlqIwqmnsc3HzC3sJhqMsL09ncaGZ7u5uurq6mOGtZrnGxb7NIABJIoRsjTz3XCNacwqpQjophhF/Ir1KQTcSdVPNLIhZSES9IbZuamPTxlaWaDSUhAV0EdBFIdQzopcSezy8jJEPIhGsmRYaavqYt8+BFAXRqEKVbURTaMYwLxMpFMH+cj3BNicuJHYR5jOryN+OAppgoodTPEpSDezvGOL0yhHgkxwDUIODgzz++Lv09cltapKTk0lNTUWtVqNUKikpKaGysjKRwhhzPHcdDY33UchmCmP11ocGKjh17lUU555Ac/Mf6Ol5lYbGe7FYZmOxzKGyspJdu3bx6Web8AQzAGGMNigO6AZDYbkdxVFaUkSjEn/e2ISSCF8vjfLJh+/hdDrx+/2covfTE1DTHrQCIz5W8c9d++xuPq3rT1Rq/vWKeZw2LYPWMjOF9U4ud0CKqGXJNxdQWTDxei+y6LkGDUltPrqeO8JVAQWHgaT9g/R92gERiUDDEJ7tPWinpmA+NZ+FRTJwGq0HrHeEWZ95Jiv7PmKKt5l3H/gVutvuIH+63LBXpVFwyjem8vK9u2mq7qP1wICc/hUEDpx0Ptl//zUr98H6hW4cBQ9y7Udjz9OkMjE7YzZzM+YyJ30OlSmVqBSTFwJI4TA9P/85UY+HwdwSPiyYz3f7IvQ0OVFrFSz9RgW/fWk3eGHXhrfwuZzoUjP5KJTHlFAE54cyU/IWIcpGVYItKJSBU/z6O0eNjY6jAKcdsWtkEXwsVLbxybtyxbQE9ETM1Ei53LF6dWIRm52dzcKFCzlU38wNz+8lJCl44arZDA05eHZrC7v7Inxn9TwuWjqR4QeYM2cOqampvPTSS9hsNt544RkyhEIqSksSz0l8wRFfREuSROugF4XPwcZPP6Gjf5jFShGjV9ZCf/LJJ0SjUUpKSqioqMCk7cbpD+MOhCnNy+Gb3/wmTzzxBD09Pbzxxhucc/6FvFYt82g/P2saD7yxmXJ7DR98IAPIoC4Va+USdMb/LLn4lwZOpaWlHDhwgA8//DABXqZOncqpp5563NUm/9vx0UcfHfW9c84550tZKNx0003cdNNNOJ3OhC/LPzviKYibVpSysa6fRUUjYE5RZOZZgnwDDUQlGonQSAQBCAoC551eSkpJEqocYyJFkx4DQ/3uAE7fCItUkGJIAKdp44BTvyuQ0MEkjfJmSjFoEmXnVXlWVpSnJwYH1zjGKc5AGdRf3sBMEAWyTi/ixkOdzOoLskqhgVH9mtRFFlIvn4qoV6EpMGOYn8l1j27D1OpmvkLFiTotUXcIKVYCrMyQUx6GuROb2cb1QqnGo3cKHx/z0yHbdpiGz3ZNeG9O7HIJgkBqaioOh4NQKERLSwstLS0UAAU6kcrMWXjdroTWJzq6K2ksDqolXsPH82fO5NUd7bx9YJjb0zT8TRtC6w/wp9OmUjo1lVs/reeNgz3clqFhrlFNJCrx41cPJDy7ao8c5vNXNicAfxqAAKlp6fgNGayv97IkPYLZ14PfOchq9SABdxRJmo8gCOhj9+Ro/ZKoV9GbpuUxAtQWmPnJaWV86+GtFOjUPPm1ufJ38ofp+7QdTY+Xs8NKpE96mYkebVT+DdO+NV1uHzEqpEvLOP/eT7EjEQEKFMdunRF30TeOA04/OqOcRcUpXDBnBAxb1QJzlB249+3BI0UxGAysXbs24VN3rIhEvDS3/JGOjieRpAhRSWRr93zebT2VXk8GPnMJt5ZkMrXiV0jRML22dbS3P8GMGXNYunQp+/bto7uzg1KFEqc+Z4ztgDWeQvyCEvKPajpIGaxhgWYQV12U0XdfHpCngjlSJw2KfHZ60+iOsUKdDh8fHekbs6+dLYOcNi2DLZlquupDLJVUOD9oI9ekRjotH2luJogQaBrCvbkLoc4hjzsANYNcHPvb+5GsP9NOS4ForO3L4UH8hwdZVmohD5E9bQ5CkSgqhcjhbidRQcEH6aei6PuAYm8rb/zmbk675mamnShbNqTmmqg6JY+9H7bz2Yt1+E6Q2QZ75Vx0s2bB/v1cuVHHH872Ew2bqLDO4sJpJzI3Yy6l1lIUx/J2GhW2X/8Gz2ebEDQaNpz6DZIHFaiOyGPi0oumMLUqHfWrIkmeHnavfxeA/WkLef+TJhaKavLanISAZwlw/6j7L+GlFANJztGM01HYmx31XSxUtlGu6EcUJESFghOWLuXXu4LUOeTnbtATHDNOqdVqkrPy6I02oVcrKCuT/fufb1bR09uNO3LssTc/P59rrrmGF198kd7eXlZp6jAFvLS2ppOfn58Y++OM09u7GnjurQ+pUI6wmuVKoKufRx5pYWBgAJDJChh5JuOL6tTUVC6++GKeeeYZjhw5gsP1LFOFMAatRP+uNlaq5XtUq9Uya+GJ3PC+A/3OPr595pdv0/SvjK9kySkIAitXrmTlypX/7PMZE6mpqSgUCmw225jXbTbbUenzf3X8qxmn0XHF4sIJBpEmrZLHCdCuFTlveSE3vHeE6Tlm7ji7koJk/YTSfRgLhkYzTvHWLjlWXYJVSjOObDvkm8g4KUSBolQDjX1ubjlNbs5pjJkOBsNRAuFIIi3nGdcG46tEdlkK9/W1YKtK5cdV+QgaBaJOOUFYKUkS220uhgnxaiRIw0+WoYhI3P3Sfj441MuD501jXtHkbGK8Qs2s/eLzDIfDbNy4kdDhLaSLEhFJoC2aREhj5boT8jnQNsC2BhvpyRbuvGo1SUlJRKNR+vv7aW9vp62tjfb2dpxOJ4f276W25gCpxdNRoUgwAWOOF3tNIQgJVsLhDeL0hegiinZmKuo0IwUZRjgILTHdzVNbW6mOeVKZBD+2g3shGsFisZCWmc3fazx0Rq3sv+F8XtndQVvtQUqt6fz06jU88PSrhPtb0Q7W8dlnn7F8+fKEhmG88DuuZzJqFBj0arqRcITDCb8ogCGrkl88soPrlTqmhkUsiDQRIWdVPunKiQNiddsQ/TFtHVFpgp3B+EjcZ+N+vyyLjrXz87DZbOzfv5+Ojg5cXd3MVEZAguLiYs477zzM5i9u/RIKOdi375s4XTKTmZa2kj/sOJ1PG1WcW5XNm/u6Wbe3i1vPqEAQBAoKrqXXto6+/vfx+TqwWvPInz6fpr1bmafsoCdtrLP06N/2aOFyudjyzquUK+WJPSUlhYqKCqxWK2q1mpc+P4zD1kWG6GZqtI0MdR+NoVS6bP00OeRrOCXdyGWLCrjjrUOJKswep59H8fHgrDTmtfuIOAIMvd4ogyWlOMIeCtBkUfLpkBuDXoXKG2GeWk2pSYtpeR76eRkIgkCoz4vz43Z8B/pRNg7zDAZeCgWpabUzuySVIzFPuaig4N30lfzCsIveQ3t596Hf07q/mlO/dQNqnZ75ZxXRWN2Ha9CPuHUQbRT0GiUZP/sprWsvZnGNm4GlP+QRWwZ7EFhoKOFrFWWJcUEKh4m4XERdLiLDTqIuJxGn/F/U6STQ2srwq68BkP2b37D/iJZV3iBE5Sq/qUuyEASBaWI/C3vXE5ZC5E6dzvNiPjrCpG2V56WPtFEG/RJGzQhYS2jpvBOBkz8UxReMJJ4pu93Ozp070dTtZKpSXui0R6ycu+pMTl5Yxg+3fIjMKUPPkH/CAm98n0bgS5lgWq1WUuecwea33qZUOYDL1sFTTz2FRqMhSW3hBFWE3gMDPF73CZ2dnVTEDjNz5kwOew3sq21musaRAE0zZswgK0tO9cWfydEyjoKCAs4++2zWrVtHb2cbc2MLzf4+iCJwJJzODy48j25XBBiiMtv8D/VF/VfEl5rRXC4X9fX1lJeXYzQaqa6u5oEHHsDn83Heeedx6aWX/lNPTq1WM3fuXD7++OOEl1Q0GuXjjz/m5ptv/qce63jjf4NxOlaYtSokYGM4QHlQfhhn5FiYX3j0/G+ccepz+RMmbBadihyrDJxG6xniIMvpDycE51bdCOMUjUa5baGezh4XyUEbDocSs8WaeN8TGAFOCcZJM3b1FwqFaG9vp6WlhXA4jMFgID09nSlTpkxIjcwvSubxz1vY3DHE7RfNOup37HT4xugIHJ4g6WYt2wfddCOxvcV+dOCUqFA7tq9PIBDg5ZdfpqmpCQBlSj6Dlgq21A4RcUvcP3sh27ytbDui48rSQpKS5OsqiiIZGRlkZGQwf/58me5ubeXTTz+lvb0dW8N+LtAoGXaXEAjMHlNxEmehFKKQGAwH3MEEuxc/56JEZZ2bAXeA374vs8HTMo0U2Q9DNEx+fj5XXnklzQMefrZ/ExadCoUoJPbh9IcwGo2EcuexqzvCAlUHGzduRKVSoVfL38U3ztwy/hvr1crEROALRcYIfkNRiT1EuM8i8c4FM3jh5RoeGvZyq81FacxodHS8UxNra5Frobp9iPAXdCtw+QPoCGKJuujp6cFisRAIBGhqaqKmpmZC0cpwVIszZSp3XH4OgXCU2l4nFZlHB09+fw97912J19uISpXEtKm/JTV1BU3vfgp4uWBOLm/u66Zn2I/dEyTZoMZoLCc5+UTs9s288fkfeL72fA51BThbrSNZ9LFEbMTtnp0QyMafsaOZFg4NDfHMM88g+J14JRVzTzqdtSvmjlk8fDag5/kOE6WKAZYbekgO+lggdvDXPz+MypjELIWOPGsFJWnyMZtjILt7WG7ZEp2aTOZFWbi39+D6pD3h2yOoRPTzMjAtzWF3h52nXtoHsQl5dXkSD186Z8y5qtL1pHytgtCKPIbfbYE6B5ehwfP3ekI3GxLACWTwNPfqH+LY9g7bXnmBI5s/ZbjPxtrb70WlUXLyFVPZ8NB+GAhyhaBB546gmzED65oLGXrlVS547xXmZpbQ2mbDtNnH1vvCpIshok4nUY+H44m0H9yC+fSVpH/4IVkRBUqtghWXyQD4yJbPWNL4OgopjK6ggtNv+Rm33vsZt6BF6w2jsGp4JiRrofRqJVu3bpXbk5nSMQoB7G55DHU6h5mvbCdddKMhzAP316BSKlAqlQlbACUwEDXgTpnGxh5YpdAhSdIY0NUz7BvTSxTGtluJx4gJ5hcDJ38owh8+aaYrXMTCJUsoDHdy8OBBuYo80EepAsL9g3Qipw27I2bCaWXcecFZ7H+zht3hMIuXnMBMVS99fX2cdtppiX0nGKdx2YiqqioyMjJ48ePd7K1rIduq5+unLeDXWxzsanPT444kLBnircL+k+K4gdOmTZs466yzcLvdJCUl8cILL7BmzRpycnJQKBS8/vrreL1errnmmi91Am63e0ypZEtLC/v27SM5OZn8/HxuueUWvvGNbzBv3jwWLFjAAw88gMfjSVTZ/b8W8ZYSgXA00TeqMOXYzRjTYoLuAacPMRLAQAB1yE2uJsLPZ4fRSQ088cReudrGZGKhqh93VEVnQ5AKhQPzcIDt232oVCp27dpFb688sbXWyDn4+fPnY1ILuIISbn84kR8fGh6mStlFibOVl1+WqxcHBwcT2rXxkZmZyWmnnTamlUUcEDb0uRl0B0g5Sjot7n4ej8EYcIqXyh8ZZw45OuLAyTIOIPr9fsLhMD6fD7vdzubNm+nu7kalUnHeeedRWSn3gq//wybqbC4OdTlpjq3i481RJwtBECgqKqKwsJD6+nreWP8OuIfROet44IEHmD9/PgsXLsRgMCR8nERRSNDmo32DzDF92ejJ8LU9nfhDUWbmWjgzZYDeIQ8RQckFF1yAKIoTUrDxfcSZt2FfiMORTE4tT8XZvJcPP/wQfblsPzK+Ym60f8xogOwLRRKao1AsXahSimhLrNiqUhn8bJjqdgcXzcvl0c+a8QbD3Li8lM0N/azf340gwCXz82XgdBTGye/3s337dno2b+FibQha4S9/+WzS611RUUFFRQW2sJ5rX6mjLCoXGvzu/Toe/7yFBy6u4rzZE/VtLlctG7dfgV4xiFKVwdw5z2AwlCJJEn0uOXVclGIgL1lHh91Hba8z0YdsULoAgc1YpPdosi0GQY+1YhGKpk30dLbx8MMPc8455zB16tQEqzuecQqHw2zbto3NmzcTDAZxS2o+CJbzk4UzJ0gjClL0gECrlM51N5zPD/7yNjpPL1lKNyG3g9kqB3T0Eu6XtVXtdi+hSDRhZZBtlYtQTCfkYJiXgWeXDQQwzElPNDterB67+Mg9SkUdgCrTQMqVlax//QhZu/rJ8oHtsQPo/BF8CgGrXk2/K0AwKrH4wq+RVzmTN351F911h9ny8t9Z9vUryS1P4sJb5/Hs73dj8QFbBgicHSbt+9/H+f4HhNrayG5rY7TpzHhjGkGvR2E2ozCZEC1mFCYzCrMZ0WxGN3Mm5rNW09kyxBy3vGhbtKYUtR4+eOxPHPz4fRRAi66AmWdcjc0rMRcFFxDTAF04hf5ntgPgHx7ggw/i3a0bWKOBoEPJ44/Xo+7solI5ch8H/HI9RTyMabm80aUjPaeAvGQD9MjaIF8okmCdYUSzNjpGt1uJx/hU4fh4r6aHW187yJkzMrHq1XQN+cg0a7n2tFloVXNYvXo1fX19vL75IO/sb6ciw8Qli4t5bL+fDxudVCIvNBJVdXodpy0/bcJxEoyTf+KCICsrC7uxiE0hkRsrS5g5s4Lc+gPQ5qZt0MvBTnlMn/F/GTj97Gc/46KLLuLuu+/miSee4OKLL+bmm2/m3nvvBeCee+7h4Ycf/tLAaffu3YlWBECicu0b3/gGTz31FBdffDH9/f3cfvvt9Pb2UlVVxXvvvTdBMP6/Ff+bqbrJYjQdG0fkRyu9dzgctLe303ekidXqJlJsXkQkKrSw/4MD7D/KMaYqAAXQ18kiFUQ623mvc6R3XtybZnBwkK6uLnbt2sVKhZ5OpZFNn3yAXhHF5XLR0tpKlVICPxw+3D/mGEajkZKSEgwGA263m9raWnp7e3n22WepqqrizDPPlPP3BjVlGUbqbW52tTo4Y/rkKdqaUS1DAAbdQUKRaGLgqO1xTvYxADweHymCB39fK5s2NdHR0UF7e/sY36546HQ6Lr30UnJzR+wRpmWbqbO5ONzjTKQ/jvabjA5BECgvL2dW0MgfXvyAudo+8PnYtGkTW7duZc6cOSgj8mA+OlXXGivX1akUCX+r+PEGPcGEUd55pSrat++Tr4+iNGEjEhenxidrc6yJZhxAxoWsOVNnMy1dw/bt2/E1bCNbLCE40MH+/bL402g0jrQ60SjQKhUIAkiSnNKLA6e4j5NKKU/0c2IsU3W7g21Ng/z6PZkd+/CwjYHYCv3aZcXMjTGh4w00+/r62Lt3L3v37sXvj4mfJRA1OgwqEY/HgyAI5OXlUVpayqxZsxLs8OFuJ1CPPSZ2rY45xT+5tXUCcBoc3MzeAzeiV3jp8aTTo7iXkwyliWsUZ2/TzRrKM8x02H3U9bpYUpLK45ubuWeDyF2Ls8g19fD7M3Yzf9bdpJk09PaWy2mK3l5eeeUVbrrpplGNWUcmmK6uLl5//XUGB+USdUNSOq/0ZJKflZaYGEfH3ALZzPTkinTSkiwI6VN4v97KvWeUsXHnfkRHG5mii40fbGCxOoPtwTza7d4EcBptnitqlZhOnAgkM8xaStONicbgR7MiiIcgCBQvyuEbu1p5CAN5w0H+hIG/JIm0CBH6XYHEdcytqOT067/D+j/8il1vvkre1OkUzZ5Haq6RhplGMncNkRKA3RtaWLpmCnmPPop740ZEkxGFycwhl8SfdvTiUGgoKMjgV1csITkjBeEL2uNEwlE+fuoICgSaNVFuXJrNhgd/S93WTSAIhGeewobhEjK8Ubp6Xfwk5vV2KEPNKcWW2PlL7Nr8CQB5eXmEotDd2YFaCNPZ2YmAzNTUR1LxSmruOL+KuflWQiGZ5f3lR+10dXRyTklqgmFy+kITWmR1j6uShNHM/mjG6diaufdqehn2hXhhZ0fitVtOK0vo7hQKBVlZWeSXSxyqDmHUJDN//nzu2r55zDF9sd9ON0mbIEmSKDLuZVlOM+FAhEgkA8U4vWJ8LIsv/vNj8pGWgZEeqv+ngdOBAwd47LHHyMnJ4dZbb+XOO+/k4osvTrx/ySWX8Otf//pLn8Dy5cvHtG+ZLG6++eZ/W2pufPy7U3VKhYheLTs4x8uBx0/ScR3O559/nngtLZYBiyAgSaBVK8lITycrK4vk5GTMZjOSJOFyuXh2cx1utwutECEkiczMTyHXosbv95ORkcEJJ5yAwSAfs7GxkTfeeAM8HqYqvTQeGitA7Y0aScou4bzZ2USjUZKTk0lLSyMpKWnMitnj8bBp0yZ27tzJvn376Ozs5OKLLyYtLY0FRcnU29zsbLEfHThNYJwCiUkY5Acx3gfM4XBQX19PY2MjHR0dVPn9VGngyNbDjLdvFUVRBnCxqqtly5aRmjrWCK4y28wbe7s40Dmc8CA5HuAUD5VCSX0kHZ21lHtPTmbLli10d3ezc+dOlqIgWZlGy5H9uHxBTlA1k+52s0QTQRBEHnqokdTUVJKSkjhZ30EwFKLbZSZZnYz9kPz714dT2R8wEY5EUSrExOQ8kXGSXx+tgzvttNPo7++nqamJlep66IQ3OuUJsbCwkIDXQLIQRa9WIIoCOpV8b8rMlMwOxn2c4nYIc2IVW/U2N/e+K19xQYDaGCtYlmHk+6eWYXPKE3pc+yVJEuvXr6e6esTqIDU1lS5dMS82RPnh8gpuWlFKKCSXy09mmhdnQx2x1jXx8u/9HUNjUnZdXS9SW3c7AhFq7aU8su9biMoAN5wSxqhR0h9jm0xaJVqVgqlZJj46YqOu14UvGOE379UBAg7FteRyF5rga6iia4G5ZGZmcs011/Dcc8/R3NzMxx9/TNVJqxLn5ff75Qq8Tz8lGo1iNBrlhsFNAp6eDhYXT55yzk3Ss/Onp6KJgelsa8ys1iex12ulP6jlV4sV1O7dQblow68U2dPqIBiJIghy38PjiSUlKQngdCzGKR5Ts8yozBq+7fTwEAZyEbljADbqFfyWkZJ2gLJFJ1B1+mr2vb+Bdx6+nyt+/SCmlFTcUpRPdCEu8mg48Ekn007IJmnObPRzRhoRnwBoT7Pzzad2Ue8M0/JyHU9/cwE51qMDp4A3xKd/r8Nt8+EVJOpylQQ8Hhp2bAHg/B/fzkZvKtLbh+kd9qNv7yUTkW6ivJ+mYnHc+Vx00N3ViVKpZM2aNSi1Bmbe8S5Wwcdja8v4zWc97OgdWQCEVKYxOt0dLXsBuX1O3MvJ6Q8lWOB49AxNZJwmK45IaOYmYZyi0TC6yEdcPX03h4aWs60zn6lZZi6cmzth29HPC4z4BcbTg3ELlfH9FT2eZmrrfsZs4w5mVwK8yKbNGqaU/pScnK8nxv64rU0cMMUB1OaGAVSCgzOmbEdy1kDGrRPO7d8Zxw2cnE5nwkdBrVaj1+sxmUb6dJlMJrzeo7ce+G/888KkVSZEuoIwctOBLDR89dVX6e6WS9xzc3PJyMrh/i399EsGvGiISgKff2/FpI6/AH+rV7HZMQKALl40h1XjmjXGo7S0lBtvvJHvPbyOfqeHs2dkUp6TjNFo5P1mP+/tHOTK7EIWLqw85ncyGAysWrWKiooKXnvtNQYGBnj66ae5+uqrWVCUwt+3t7OzdXDSz0qSRE2Mfcux6uga8jHgDiYMHQGiksTWfUewNR6krq5uwj68koqCrDSyM9LIyMigsLCQjIwMFIovrs6ZliVPtp839hOKSGiUItmWL55Q4hEXPkaQPVemTZuWmFC7u7uZoexl31Y5PVo67nQGBgYSosx8AAWUKgaRhDbcLhmo7rUVEJXA5gqQY9UlBsGkBOMkTyyeYIRwJJoAUGatCoVCwZo1a/jjn/+KZ9hBWG2iMNVAT08PLS0taIBzNDC4tYmX+oqZpgzQEtLi9gUh5sMUZ4ziwCnVqKEgRU/boJeaLidqpcir1y/m1+/VUtfr4v61VWhVCpSx7UMx4LRz506qq6sTTN3s2bOZMmUK335hHxI9iYnjWA14rTGwGIlK9LsCiVSuQJTXdh3i5pP02Gxv09HxBABbu+fzdts3SLNoaR308uruDq5cWpS4t+L6wfJMeSys7XWxq9VOMBIl26Llu6sv58iRg/T0vs6RIz9hwfz1KBQaFAoFp59+On/+8585fPgwFbPmkiU6qQz18pvfbCca03VNnTqVs88+G71ez/c/2gjA4pKjNyGPg2CATLN8D9bbXPS7AoDA6tNPpaIgi3Xr1jFD0cv2Q7JeL82oGePzdaxYUpLCMzHDwrhO8lihEAXevHkpz+9o5xc7O7jUJbAMFSd7YQoGfO6xrMhJl32L7vpa+lqa2PDgb1h7+334gmFaVVF0BUZ8bW62vNrIWTdP1DzOK0zm1RuW8I0ndtLY5+bCR7by9DcXJH6feHiGA3Q3DLH19Ubc9gAI8L4uSG5qCo27txONREjNK6B4znzqYi1ALL1ecvvle/E+fJiCOjyBMAqizFfJzM0JJ5yAxWJBkiQUSiWDYQOZReXYPnIAXjLNsrfY6BRap8NLh92HQhSYV5AUY0Xl1LlzVIpLLQZJ4m0OHvwbQ8N7iES8WC1zUPnKKEvSYdXJCxJJimDR+Mky9JCkDDAwECUS9RMM9OH3d9HX/z6nZskWAIuzd/OdpZdQXvrjSQXY1lHMVTgSZTC2GI1rLMf7OEmSRFf3C9TX/wJJChKVNByxF1Ka1IcGB3X1t+Ny1VBeficRSZVYuMQBU0GKHpPaxYXFrzMvYy9KMUpXl5rCgmtQq/8P+jjF+9Ac7d//r8S/O1UHYNKqEsg/x6pLiLEbGhp47bXX8Pv9aLVazjnnHKZNmwbAbTvewzOqIspyDCH0+KqN0VV1k4XBYMCbXMI++yBXlVdxQswLaV37IWBwgjj8WFFUVMQNN9zA008/TV9fH8899xxnrZGLDg53O3H6Q2MmB5Dbvwy4g4gCnFCayku7Oxh0j0yKRsHPQmU7mzbsTnymoKCAsrIyioqKOOlPuwlJCnZ8/ZRES5kvE3Erh3jKoSjV8KUaa8a3jWekBEGgpKSE4uJizv7FiySF+lk+JRWFKLCu1kV/1IhHUjE9y8SdZ5YyMDDA8PAwn7cMUdM5RJmiHx1hRFFkzZo1vPr3OtrtXrqHfDHgFCJJ42CudQN7qocwGKYxJ11kf38lLn94pIFw7B7R6XTMOHUNNz9fzbysZO67bgl2u53a2lrWbdqLyjeIKhTgyJEjTAema+D1p+rZmZNDXl4eAyE9GkKoR03Mc/KsRBzd2KN61i4oY2auleeuXjRGVK6K/T8cidLR0cH7778PyC2eFi1alNiXa5KqoqOFVqVItJE42F7DN6a9wKy0GkxqN6IgsXvkFuHd1tW8Wr+S31w4nUAkys/X1fDk1lYuX1yYuLfi90tFbGKu63exsVFOSy8pTUUQBKZM+SmD9k14vU20tf2Z4uLvyZ/NyKCqqop9+/ax4fWXOV0t7zMalZm0pUuXUlVVhSAI2Jx+mvs9CAIsKDq+CSQrxjhtbZIXHOkmDSatiqqqKt7etIewvQOpdRcCFWQdJ9sEMiuiVoqIwvExTgAWNVy7JIfvnDKFQU8As81Pw1MHyQsrcH/SiTQjI+GMrlSrOet7t/L3275LV62sd/KF5CrE7OVZtPy9kbaaQVoPDkzaBqQsw8RrNyzhihh4uvjPW/nDGZUk+yRszcP0tjhxDY4wN+ZULYPTTTTua2e+RUfDDtl2YMpC2fk906IlD5FLBqKAwCsE2EuEWb4QnkCYKmUXRiGI2WxmyZIlgPwMJ+vl9j4OTzDxTBWm6uXXRmnZdjTL/k0zcy0YNMpE6tzlD+H0hdAoApyct5mVhZ9gVrvpG6V6GLRvIpVN3Dpf/vcnnyqQJHmcv0c+ffaPqCwS4QwaaRoqZHZ6DV7Hi9QfrmZ21VNoNGMlMAnGyRNk0BOM2wYmKqh9oQgCUbQKD35/Ny2tD9Hd/ZL82eQT2e+8hvv3DHFuVRa3LN5FY9Nv6e55GYdjO+b0G4lGtWiUysQCJMcK3539F4osssXFcKSCJdOuRak8fgb/fyOOGzhJksQpp5ySaD3g9Xo5++yzE3T40Zr3/f8t/t2pOhgRiMNISmjbtm2JiSU3N5eLLrpozPmlmTR4BmVGUDGqhcpkMb6Tdbzb9rEivj/XKKO3yXLvxxMGg4FLL72Uxx9/nP7+ft5/82WmWzOpGVKwp9XBior0MdvH2abSdGNiILd7gvS7AhSKdk5QNaMUJBBE5s2dw8KFC0lLS0ucY0iSB+zxgOx4w6pXJ5gu+HJpOpD1SzDRx0kQBDpJoSZk5o4zlpFh1nLnnR8k3teYUygtLaW0VNbd9G5t5dnWQwRSyvjlcitWq5Xs7GyyrW0J4BSNBkmOPs0vT3gDjSLE0BAMDe3gpipw+C20tXcSDGUBmjHgWq9RIiEkmM7k5GSWLFnC7/dD9dAgv1mVSzpO3ti8H31oGHU4TFtbG21tMjPxNS0E+pqprbWQm5tLZt9OTlX34JVUXDZnSeI4owFnfAWslQK88sorRKNRpk2bxsKFC8dcp7jw9Hjus0jEy4l5+yg1bUOyHWZZ7lj9VFRIJdlSTKN7Ja/Wp1OabuTCubkEwhF+934dbYNePq3tSwjD000avJEoByIhwnNScKRo+EvAh1ItckKpPKmrVFbKyu6gpubbtLU/RlbWGnQ6OS2yYsUKampqCAQCRCWB2kgaP7rsTI44wJCdklicxtM3ldnmYy56Rkec9YynZkcXLJTNP5Hq917CIniYqeghy3L8PT2tejXPXb0QSfriay5JErt37+aDDz5ArVZz0003kW7Sg0nLM7kqrmoNYh4IMPhiHSmXTk14zyVlZrPyuu/w9gO/Zue6V0jPPxlRLMWaoWfWybK/05ZXG8mbmoxinKWFZziAr8XF/2Rnsq2zG8NQlMNP1489MQFSsg3kTUth/upCfrr+EABZOonW/XLarHyxXBCRGZB4GD3JkkCXUuIv4VilnC9EZ1c3lQqZDY7rMuMR74s46AkmdINFqQa2N9vHME7x33ZRLAUbH4d8ASd+x5P8+sTnMallCUC/N5UFlVeQZJ2PUmnA4djBttqPEUJ1pOgcCdAE4AnpcAZNlKSnoVLqUKtT0Wqz8UbzueFpIyqljitP03PkyI/xeOrZvWcts6ueRq8vHPkO+pHm4vFm3gCiEKG98xVOzXydy4tqUQ142DIwcnFLSn5EQf611O/uAIZw+yMUFFyH0VjB4SO34vO342u/jXuWplHrXIbPNwWNJoP2ph9TZGnHFTTwx+rr+fYZ55CZOTGF+O+O457R7rjjjjH/Pvfccydsc+GFF/7jZ/Tf+MIwjZrgi1INNDY2JkDT3LlzWbVq1YTeWmkmDa0x4GTWKo/JFk4ATl/AOAEYNTH38FFlp54vwQSMD4vFwmWXXcYTTzxBd3c38+gmTWVl09YwxboqcnJy+OGrB9nUMEB8rp2ebUlU3Q24g9icPuapOlAKEj0RE8HsKu4865Qxx4mnpeJ91L5KSFKUWTkioWAfkaiCotTCUe/Jvez8gV4G+j/G4diG21NPMDhISsoysrIuRBBk07roJFq/uL5HFGSwq1IICc3QePuEC+fm0jLgYc3c3DElvHI6xU6fo4U91d+mRCeXBQTEGcyacgku9xGOtKwnSTvMYM/9/GKxjk87lqJTzgfkVEzcxNQ3zsfJEwgjIZKRlcuysjT+eEhJdbuD+88pplDrp6Ojg0P1LQQ9Q2iCTl588UUUCkWCsdULId5b9wrf+ta30OnGshdKhYiWEKer63E6/aSkpHDOOedMuHcTLVeO4sMVjYax2zfRa3uLgYGPuahkRFKwv7+SQel8MpIrePBTG+VZKay/+QRue2AT4ObyRQUoRAG9Wsn5s3N4amsrH9f2IapFIlk6qlMUTN9SgzcShTSZtYnoFEizkllQMsIMpaetIsm6CMfQdhoa72PmDLnFh8ViYc2aNbS2tvL7vREahuHBLTY2NwywoDCZl69fDMC2GGs0mb4pGg0RibhRKq1jrk2ccYpHvPISoCw3nUdD+SxTtzBb1Q3+NGDupNdvsjiW/Uk8gsEgL730UsK+IxQKUVtby5w5sn2By6DiNoZ4SDTgPzTI0JuNWM8rTXyH8sUn0nG4hv0fbKCy/ROyVXvwNBg58cxl1O7oZcjmZd9H7eSWJ9PbPExvyzC9zcNy6i0WVgAEfIJEjyJK5cw0Tjsxn4xCM2rdyP0Sr1az9DcwEAmTnJNHSm4+viODRF+qIxmReiL8MOwlzlU5vQH2bPoQUYABVToVFRVjvn/cy6nL4Us8xwWxlNRoxml7y1jgZNIEObPoA84s+BSt34NWDa5QFq/UncK2nrlsX7aSpBjTaTJV8uCOuby6p5OfnJ7NN5ZkIQpqFAoD0+/8FF8owqYfrRgj5/i0ro9gdBfFyXpSU5Yxb+4r7N33DXy+NnbvuYgZ0x8mKUlugaNVKRLNxWt7ZA1iqbWZy6a+THtzN2WjuANBUKPVZlFedicpKcuAkXkhzgqnpJzEksWf0N7xJI3NfyHT0E+m4TW273gtsZ9wVMVD+66hxVnwHykMh38AOP03/n1h0ioRiRJFIM8o8PrrrwMyaDr77LMn/Uy8xxwcO00HE1N1x7PCNSXKTidhnL6CczjIqYzrr7+ejRs3sn//fgoUQ0jte3nyyb2oNVq6PWY0USshSYFRULGgKDmRVhz0BBiwuTAKQaKCko9CZSQNTgQmIx5OxwaT4yMYHGRwcBMDg59it2/mwhwnF8aKkCQUfLbJSCTiRZJCyE2jJnoR2WxvYbO9haDI4PzSWbR4T5mwzWgfJ0EYKeGGiYadRo2SO8+ZqCXLsWqZk76fvOgLOJ1eAhE9T9Ss5cqTv0lOjnzS33/3RFLEjXxj5hb0qnZWF39E7cEaZs54FLN5xqTO4QCe4FhWUf6/AFozc+ZMY86cOQxtbeXet/ZxTrYHi1P27kpLS+OMM85g3bp1DAwM8Pjjj1NeXk52djYmkwmVSkV7Zxcr1XVYRD9ms5nLL78crXZiSulozGYoNERX1wt0dj1HINCTeN0VSuezjipqhxZxZCCVK5cUctnSKfx1y6cc6nZyx1uHaOhzo1MpOH+U6/i84mT+1mLjFYUfj16JNDOZeqIQgTytGpM9SEPtIKGZSUSTNTzWZ+dOs/x5QRAoK7udnbvOpr//Pez2LYkmwHGrhIcbPofhYTY3yEv3mu7hROoyXv23oCgFj6eRwcHPGLRvxuNpIBDoA6IolSb0+lLSUk8mN/eKCem34lHAqSjVQHM0BWvYx0xlL3Tt57PPklm2bNk/TYKxb98+mpqaUCqV5OTk0NbWxuHDhxPASaMSOUCE/VXJzN5rx7OjF1GvwnJ6YWIfJ191LcnZubz77NMkhYbZ98T9+I7sYs7K89jyahfb1zUDzWOOKwiQnGMks8hMZrGF1AITv9nSyGt7unituQt3iYFvV4xtKRN3WI807wOgfP6JOF5rwLNLZpNqFVG+F/Ek+hFqCFEVbsDlGMIvKeg1jwVNwIQqWKUoJNpnDcYahY/WN1XlqGhpeYho79+4cIqscwpIOTxTczJFuefS5LYTlfx0D/vHGB3Hx1y9NgmtZmx7oa4hH3ZvcAxw6rTHeyXKr+l0ecyd+zL7938Tl+sQe/ddRmnJbeTkXIpCoSFJr0LjH8TjeJX/WfAeJdZW+TqLZj5qX86OrhL+cOlaZuaPzQTAaDuCkXlBodBTVHgTL9Qs4lDzOtZM3U+Suo1IxI0gKNjn+jaNQ4Xo1Yox9+x/Unx1S+f/R+M/QeNkCdm5VFNNGJGBPUcIeL1kZGRwxhlnHPUzo1mkLwJCo7fVqRQTKiYmi8mMzo6nV10g0EdPz2tEo0Fycy9FrR6rWUhKSuL8889n5twF/PivG7DiocwUxuf1ME3pZxojInaxNYJpprxCH3QH8fvbUAHGjHyibSID7gD9rsCY7zfiGn586Y/h4WoaGn/F8HA1sh3cSPjCGpRiGJUYIRweXeUnayMsltmkppyMyTQdhUJHr209NttbhMM2zir+gIj0MYcOb6Ow4EYMBtnLKuHjFJvMkvSqBHA6HkAbjQYo0/2VWVVvyJ8xz+ZX27/GbpuW7xtGroNBo+fztsUsnn4FH+19jbXlb5FOL3uqL6a05FbUKtmjxTPBx2msO/xkACsUiRJARTijku9edQ5tbW2UlZWhVqu57LLLePLJJxkcHGTr1q0Tzj9ZBJ+k5KpLLk3YKYwPVwz8xs8hHHbR3vEk7e1/IxKRpzqVKonMjHPJyDibu96TeKOxO/H53CQdyQY11y4r5vcf1vPsdjm9eG5VNmatCmc4wpOdAzzmGCA0M5m4XFdwhViZauY7lbnMMev56+Zm7u3vghoHoaoUHu3oJ0Ot4obYhGI0lpOT83U6O59l/4FrKSq8mfz8byGK8gRr1Y/9Pb3BCJ0OH+lmDS0DTuZl7MfoepLtO/ZOeh3CYRdO516czr20dzxJYeGNWHVZDPnk32J0qs6iU5Fq1FDtziMsKZij6uLTTz9lcHCQs846a9KKxC8b8T6AixcvZtasWTz00EM0Nzfj8/nQ6XRoY9rM9jQNK84vZej1RlyfdiDqlZhOlNMzoqhgzqqzuXxTlFmDu5jnOkDdts30NNSRUXQNthYfWoOKzGIzGUUWMovNpBeaUY9bVPx6zSzSzToe+rSR+z+sp98V4M5zKlGIApIk0T3sQxfxMtwgN+gudJXhae4FAYwn5PBoSzduWU9NicbNXBrRCyEQRLYFC8nTTUzPx/VBrTGLEotORcq4qs4dTe3MTD3EqcV17Nvzs8S40eNJ56P21UwpPJftPe3MnKIlyyoLy3uGfFTlWRPHiT+T453zrXoVXUMTG/R2xATZ+aOak2vUqcyd8xJHav8Hm+0tGhp/SWPTr9Dri7l1Tj9G1VBi26gk8HnXIlYtvot3NzXh8IbQayfXuh3NABOgeVBiS/cizpj/Lc5fXEg47EaSwuzb2Ac0MC3rP88xPB7HBZzi3ZiPJ0aXCv//Mf7dGqdAIIC6qxoECQURAl4PKpWKNWvWHLOaaDRY+CKH7FSjkhxjN5kGG0aNkaHhNERB/kw47CYYHEAiitFQhsFQgihqEg/taI2TLxAgRWtHLzTjctkBAQQBKRrE6TyA3bGFgYFPkCT5Mx2dT1Jc9D1yc69AEMamzUrycxCyp/Nxm4OTl1Xy3tb9iI5Wys1RdEq56vPw4UM0NTeTK+Yy6BbRKuXJMb+0nAKXl9ZBL3W9rjHXIi7aNH3BNYlGg7S0PEhr21+Is0dG41RSU5aTkroCZ7iEZb/dgkCUbT+ehUkTRKEwIIoqJCmKKGpRqca6U1ut85hS+j/sqnuL3YeeYGpKPb2967DZNlCQfw2FhTcRN82ODyBJeiWz0g6iEkMka5OIRLx4PE0EQ4NYzFWoVFai0SBDw3vo63uXvr530YVk8emOvlXctvwPtL3/GRAYM1HH74nOIT97+2filGbw+9PeYHBwI/UNdyMIv+K7s0tpcRZht5uwWucjiqpR4FieBPUxdnG0UWbCx0khG6xOnz498V5GRgY333xzwhqir68Pt9tNIBAgPT2d9Y1+6iLp3GpJQpKi9Pa+Sf/ARwT83QSC/UhSlJ8vCNIynIfkE2ht66Ct7THC4SH5NzKUk59/Nenpq1Eo5N89yXB4zO+QF5tAvnlCEU9va0vYWFy6sIAWb4CL9zfR7pcnH1UwSrTdjaLHi+iNcP01xcy1yJNm3MpAYfNzrsHIqx43dzV1IwDXx8BTSfEP8HiacDi20tT8O7p7XqGo8CYyMs5NMBRqpUiKQU3PsJ8jvU7sbonvVD3CtJR6vB4QBCVJSYtJSTkJi2UOWm0OSoUJn6+VYec+2tr+gs/XRkPDPXxr+iIe2L2WiKQk39SPzxdM6KuKU40MuO0ciGRz+QmlHN65iQMHDtDb20t5eTmRSISCggLKy8snPA8OhyPBHB4t4v5TKSkppKamkp6eTl9fH3V1dVRVVaGJpcYDoQjGBVlEvWGc77UyvKEFUafEME9mT8KRKB5Jydbkxdz13Uv5+MF7cQ70ccLXQ5x+zRKMSZovnJ8EQeCHp5eTZtJw5/pDPLu9jUFPgPvXVsntTzyDnGV7h2g4REZuCdFWOSGXetV0tGVJpP3dAZ3DlCv6WCS0IyDhiGrJmnUSbbvsVExSABP/PdsGveSZOllVvJdI/1+4Y1EfelWQzzZ5sEa8fDdmvB4Og15fSkrmtVz9qBpBEElLl58ds1ZJtkXHXoYmmGCO2BGMHcOOZknQEWOc8pLHgh2FQkfltPuxmKtoaX2IUMiOx9OAUSWDpU53Ltu657K9Zx7OoJmTFhgTBphHW1ybJmm5Eo92uwwo4+lLpVJml06pgOd3tE1qj/CfEscFnOLtTkB2633kkUeYNm0aixfLq/vt27dz6NAhbrzxxn/JSf6/HqGQA4+3GYt5jtywOOjFFVXzeaSUhy8oJTsr85gDGIwFTuXW/eze83uCwQHCYTd6fRFW63wkKYTTeQCns4a7l4zoQPbs+dNR9yuKGtLTV5GsXMzy3N1M13eya5cHf6CXW2bKzSpDNthpO+ousFjmEI0EcLkPUd/wCwIBG6WlE307TipLY3ebg5f3dLG/T4kglPLb608h3aSlu7ubN998E5vNxgpVI/vD2ajEIAFJwZSSEip62mgd9FLb6+SEKTKrJUkSTu+I7ku+1sP09LxGV/fzRCI+srLWoNcV0NLyJ3x+udIjM+M8Skp+iFY7YtFgBa4/qQSlKJCZnH/M32J0KBQadKbT+N0ePfNzbPx02VYGBz+lte0RbH3vkG+6gMahQhRCFFvfu1xSeB9mlezCTvgpNo4xyhYxGafi9bUlmBYAhTKN3+28kDb3TH4iKBNtGEZr1+Lfv8Mur0a1aguzZj5GR+czdHe/hMfTwMy0w8xMO8zefRtQqZJITV2JVT0FWzg9kY6dlHEKj/VxGh9Go5GqqiqqqqomvHf3TzagFII47JtpOvxQolfc6EjWQrLWQXvTtxOv6fUlFBd9l/T0VRNAePI488h4QYFBo+S7p5Ty8zcPMTvfimhVc87eBvqDYfK0am4tymT3tk5ebBpxoc8wjzxXU7PMKEUBURS4b2YBBT0D/L7Vxp1N3RiVCi7LTkGpNDG76hl6bW/S0PBLfL42Dh/5MQ2N93FGhpXiOVosad/iYH8Wr1d3UdczQER5N9NS6glFtUwpvprcnEvRaCZJixjLMRrLycq8kK7uF2houIdpSdu5Ze4ASlGitbaJdlHD1IpfkZl5DkWpBna2yqB68aKFzJ9axCuvvEJfX1+CLdq+fTs//OEP0etH2Am3282jjz5KIBCgpKSEk046ifz8ifd83CYjJUXW7kybNo2+vj4OHTpEVVVVYrINxJzlTSflEvWGcG/qwvFaA6JOia4ydUybn7yyMqaeuILd61+nec8Opi5dNuG4x4pvLCkkxajmlpf2887BXjz973JekoM1PW+gjQYxp2Vw2pnXEfpwEGWGPtFzMcOsZZ6ynelKeSDrENLZGMzj7JA2ce+Mjmg0RLquk7OL32V+5n5yjPIiLuSD/Nj6KZ60GPQlkZp6MrNKzyY5eQmBMEi8hySN0l7pVInUa884E8zJetXBiHv4eBPMuHdS3iR2NLJx7DfIzb2CQKAXt7uWP23s4YW9WoKRsRIOp2/EBHYyA8zR5zQ6VSdfH4m2mOa2IGXseczKs7Lrp3KT4O1DbmzBEOemj02t/rvjuIDTaH3T1VdfzXe+8x1+8YtfTNimo6Nj/Ef/G18xJEnC6dxLZ9dz9PW9QzQaxGI5n127DIDA1nAhhuR05s2d84X7ghHgtCxnK4usLzM8PKK5GR4eZHh495jt/WENXe5MLDqBPEsUSQojEUWhMKBRpyFJEdyeOsJhJ72960hhHZfLzgc4Y/OKKEA4qkCjTo4xJhKSFEUQBAyGMpKsC0hNPRmTqRJJitDR+QwNDffQ1v4YZnMV6emnjzmnk8rT+P2H9ezvGAJgXkFSQruVnZ3NNddcw6uvvioLUGPgoi2SRGaSgfJME+8d6uXBj2oYHnyLRTmNSMG9WAO9/P4kM1Ehnc+3eMZoYQBaWx9K/K1Wp1FWdgcZ6asmvca3rZqoczieiLNJHa4CZs28iv7+D6ivvwufr5Ufz3uAXbbZ1B34JaGQDbMKPCE9/d4UCiw9CIRRqZJRKs34fK243HJ1kEqVTGrqyWSkn4XWOJ+adz4G5P6DcXH5GOAUZ5wccSCpQhAU5OddRV7ulTiGD/Pj55+iyNLGCXkthEJ2enpe4q4lCt5pOQ2tcgWgPmqqDo4OnMaHJEk4XQcY6P+Iny9cT46xi9YGeR8KhZH8vG9iMk1Fo8lkyBvhm09tZk76Qc4pO4RCaaSw4AYyM89BECYfzMcXO4z2M7tsUQGpJg1NWjinugFPJEqlUcuLs0pIU6tQFfl4ccfIODdaa5Jm0vDXK+ahUYqYtCp+WJhJWII/ttm4tb6DbI2Kk1PMCIJAVuZ5pKWeSlfXc7S1P04oZEeDgxmpgPRjTGmX0pcdJiv8IBqxEX9YQ3P0F5xRfMEXXj9RVJKXezl6XT579t1ARfJIS6toNMChw9/H42mgOPUcQNYEZZi1qJIKue6669i1axfBYJDa2lqGh4c5cuQIc+eOCMe3b9+ecNVvamqiqamJSy+9lClTpiS2CQQCuFzyQBAHTpWVlWzcuJGmpibsdjuqoAsNoYQXkCAIWFYVEfWG8e62MfhCLRnfno1Pp0icp0YpMmXBYhk4Ve8kHAqh/AJn8MR3j0Tob2shp6eWnxr20XL4MKYWJ82AFhg25XDDvb/B91YXIUA3bUSIn4IzAZqUeTNpdSQR8XnpjgEbg1qJz9dJc8sfsNu3EAwOkInEeXLBK6Gogk7vPE6ft5YbnmvAH9Fw35rlXPpEEwha9t5+WgJ8aVUy6xgMR0eeR52KrJg+qnsc4xQHJeOLI+L9D4fHp+oSjNPRPbgEQUCrzUKrzUJS1RCMtCXei5/baIPheJ/K8TG6e8DoBvB9rgCBcBSlKJBjHct8SZLEm31D/Lmjj/0uH8kqBStTLOiOc/z434gvrXF65ZVX2L1794TXL7vsMubNm8cTTzzxTzmx/9T4V2ucIhEvvb1v0tn1HG73WB/r4eE3yM2rIiBeSE+dhbOPs+LA5TqMPvghN876jLkZckVVVtZFZGetQRQ1uN21DA9XI4hKzKZZmM0zOfORdtrtAVbPyOLhVZODs/gE19X1Aj22T6kdsOIIz+S6U1ai0WSy/P7DOPx6tv7kVLK+wBAyPkkH/D20d/yNw0d+hFabhdk8M7HN9GwLyQZ1opT39MrMxDVzuQ6j0+Vx4YUX8sN7HyRJkgft1mgyqQYVZ5QP4htcz/SkLRhUXvyjWtdZNU7ASbzDisFQRl7uFSiVZjo6n8bv7yIn+xLy8781oWXAPyPi+qVIrAIvPf10kpIWUVd3J7a+t1iUtYdQCJRKK+2BM7h382x8YR3PXV3FggIDKpUVAL+/m6Gh3ej1RZhMlWOYliS9Coc3xN6YyFijFMcMdnGNV9xSYbR+ShAEkq2VfNa1go/aJa5avQxt9CD1zX/B4/ycc0veY9vWjzEaK6jQJHPNDDf5opmWlir0hhKkiLxaVCuPb+BraLiHjs6ngJHVuUKZRkb6KRQXfQ+NZoRdHQx6aBzqxuYr5zff/Otx7X8042TWKsd8V0c4wuMhD1tipddLrEaenF6IRSUPlaOryfRqxYRV/mirDEEQuK0ok+5AkFd6HVxzqJWLM5PJ1Kg4K81Ksd5IQcF15OZ+A4+ngVB4GFvvm/T0vk6S9CxXxTKaoaiaB6qv59urFvFlIiXlJLrE3+Ds/zMK7QyuXvkdOjufpa39MVrbHqFEcwiN4iwsenMC1JrNZk45RS5SMBqNfPzxxxw6dIi5c+fi9bZRW3cXvTY7BmMeJyz9OrW1tbS1tdHS0jIGONntMpOl1+sTbFVaWhppaWn09/fz4IMPArJNRbSmnvViCytXrkSj0ZB0/hS6Opwk2Xw41jfjPbdI3pdKIYPO0nIMScl4HHbaa/ZRPHv+pN/f6xymp6GW7vpaeupr6WmqJzyqjZIJiCDSqcuhWV9E7oIT0emMOOrlZ0RXOQKcQl1yerc+nMpZ0+dRvacDkC0+FEKYcv0zbNu+HkkaBVIEDfv6Sqm2zWJf3wyWTyvl6uw5tLrfxx0I8/oBgWBUzbKylAmMlVmrYsAdoDvmFG7WqhK/0YHOIT46bGNxify5o/mYxR3kA6NaFg37QglrhOP14Bq/0ChKMVBnc9E/CjjF9WrjY/Q5uf1hNEZ5u411fYlzUI4CRFFJ4sd1nfy9R07zakSBM1OteCPR/9vASafTsWXLljEPCcCWLVsmrXj5/1v8qzVOgYCN2rqfAXIaLCN9NTk5lzLs3EtDwz0UFe1DoxH524wlVJZUTfh8NBpGkoKIopZw2E1T8+/o6noekJgb8zZzCF/j5IpfJHQBZvMMsrMvGrOfFGM/7fbABMHq6BAEAYt5FhbzLFyaQX773naK0wz8LG05gXAEeyy19WV8nEpKfozTVcPQ0A527T4fs2kmWVkXkpFxFkqlhXOmDuJ1fsRw0Mzy4my6e16lqen3BIPyg6hWp5NdPofu2mwiiCwp3cnOHX8iGOxjYWxOG/Als71nHjeuXMtrB9S8e+AAX5+r5pJFs9Hri1CpRmjhjIzVx33uXzXijNNoHyeVykL51N9z54cpzEqr4bLll1KQvZK/fd6FLywDaqveiEo1cg9qtdlkZp4z6TGyY8aXt78lM1LjO47HTfdGrA4m/mY6lYJQJIwvJJCdtoTk4HR+98Ifubj8LZK1dlyug1hFWBTLYDa3fApAlUbJdTNmkqQ8n2i0GFGcvFEzQGfX8zHQJJCevor7N6Wxz1bMKzedS2m6acL28dX2l7nHRgOn0avuYDTKNw+2sH3Yg04U+WlJFlflpCZ8tkC+jnHPrnTT0b9HPARB4PflefT4Q3w+5OaJLjl99UCbjT9W5HN2uhWFQovZPAOAlOQTSEpeSl39PTTbDVT3zaK6bz7d7mQqs83HOtSksXruqTzwcQGXzStAqzVTWnorBsMUjtT+FAKfcdfSFuzqX0z62crKSj7++GNaWlpwOu3U1n4bl/sQWVmQlXUQjXaI6dNvoq2tDZttbC5+tL5pdCxYsIANGzbI10apRgoHEUNe9uzZgyiKrF69GkEhcIfPye9QQuMQwdoYkImlgwVRpHT+YvZ/sIGGHdsonj2faDTCYEc73fW1dNcfoaehFkdPN+NDozeQVVZB9pQKssum8kq7wFufy6rveclm/I1DSMEoCosaVY6suenq6sJp6yAqwcFIFjck6xJg2+Ee5juzHydLWYskQVLSEooKb8ZgKKG+X8Gf3h8peIgvTpIMKtyBMG/vl8/vlIqJaVezTsmAO5DQB5p1SkI6BcHZKTTqFVzW2oHQ2YVKrSB4UjqCJ8y93X2UOLWYlArS1EqGVCApBHqiEV7ttXPY7WfXoIvg7BSsA4GjskTjI2ncHFCcFgNOsSIVjVI8quGvbOUhG84O+UOkGDV02L3cs0Eewy6eP5LijUoSt9bLoEkEvluQwTdzU0lTfzV/vX9lfGng9L3vfY8bbriB6upqFiyQvR527NjBE088wc9//vN/+gn+vxZ6fRHZ2Zdg0BeTlXVhgk1QKEppb19Hfn4NgUA1BKqpr3ke1bT7UaksNDXfz9DQDqLRkRWPICgTwuuUlJN5bLuBekcJ15xy7heKKdNilgTH4+EEE8tO49VW8OXsCERRyYzpD1JbdzsDAx/jdB3A6TpAfcMv0WqzOTG5FWKL/ra6NxOfUyothMMugsE+5qW/x4ApmYgkkqEfIBiUUzwpKcvIyryAC56I0G4P8PVTZzHo66DNmU9EU47FUnrc5/nPjPhCKjLOxykSldhtm81u22y+f9HpiKJyrKD7Sxh2Zlt1HOp20ucOoMzQcvqpRWyyu1AKAsPhMO1KCUkAIXYKk1Xs6dVKuWN7LA3nCUbYbZtDT2AJH323DKdzP1vqa3n3YC+VWWpWlodwuQ/jdteyIKsaqOazTfeSnLyU4qLvYTJNHbN/h2MH9fV3AVBSfAuFhTey/40PcQRGHIvHh3ucOP14InmUoWt81S3FBu3twx6MCpH1c6Yw1Tj5inxBUTJv7O0aY/FxrFCLIs/MLGadzUGbP8hWh5tdTg/XHGrlFk8GPyrMHOu/lHkemRnn8oN7PmIwxq7q1QqKUr7YWPWI20dPIERIkjAqRBZYjNx7/owx22RlXYBeX8j+A9eTRjvZqlsYGv4zVstYH6fk5GSys7Pp7u5m//47CYYOEQ5rcTjSSUvrweHYSnqabEYa10TF42jAaf78+cycOROlUsnzuzq5e90+VudLWPv2sWvXLiorKyksLKQ9GuFFolyBBvXmLtSM6OcAyhYuiQGnLTgH+uhtrCPom9gANzknj+wyGSRll1WQnJ2LII4wF9+rjLK728v2ZjtTs0z4DsnnrZ02Yj66adMmAFqiKbgkLblJeiw6FUaVm+/OeZRiSztRtMyafj9paSsTn0sxjj2f+DOVrFfTYfclmKJTpk4ETqO9+iQB1rvdPNHvIJo+cs9JQFCS5IIbo4q3BodhcFQ1rxo4NZuXCfPykfaR19O12NO1nLijlluLszg7zXLM+WB0Q2lRGBFzx4HTsQBYOCoh5BgIZmlZerCRZUlGBmoGcQXDzC9I4tplsiO8JEn8tKGLZ7tl0PSnqflcmPmf02JlfHxp4HTbbbdRXFzMH//4R/7+978Dcj+lJ598krVr1/7TT/D/xfB6LkCpMCdAE0BHRwdtrbOJhOeycmUu3T2v4PHUs2//lUfdjySF0euLqCi/h6SkRex6+yP6XYHjKmOfU5DEB4dtzMw9PlbNFDc6SwAn+f86leJLl5Sq1anMnPEIweAAvbb19PS8jtt9GJ+vFVHU4BVPJEkXIODZjSgqKSy8ibzcK5CkKIODn7Fj/x2k6uSVvTdsZd7Mn5ORvirBdGRbt9FuD9Dl8I20F/mKruH/jEik6qITgVM8FAk7gom6pOMJfbKWUJmZSLaegEbB7Z026BzLEghL0lEdHkJ0BCe9HvGJK/7bjlgRqNDp8tDp8qCrig/b9+PXpPK9afKkes8b6/A73+CEvMOoonYGBj5icHATU0pvi1VQyiXhtXU/Q5LCZGScTUHBDYDsfQMjOqnxEQgfu6pnfLR4AxwOBYmkaUEl0Jeu4fu17Wx2uOj0hxCBxyoLjwqaAJaXp/HG3i5KM47fY0avEPl6tgwiwlGJe5q7ebSjn/tbbViVCq7NGzt5CoJAeaYp0S5lapb5mG18dg97+E1LD5sc7jGvJykVnJlm4X+Ks0kZtYCxWOawYP469h+4Frf7CNXVl1FW9nMyM85GqRxh9iorK/H5dhEMfQJAXe0iIpHpLFmcQkPjXTiGnkGhOA2Xy4XH40k0/z4acALQaOTnUKsUCaFkWJfGyXNEqqureeutt7jhhhsIhKI8S5iLtXo0zhA/Rccbo/pG5k6djtZkxu9y0n5wHwAqrY6s0jKyy6eSPaWCzCnl6IwTWcrRoVSIPHXVAna22FlUlMzAe7uAkTRda2trordlqzKPZLXcJcCiE7l+1pMUx1yuo9bfTtBkjl90xlnc0UCkItM0ac9Qk1aJpBGJZOoJFxh4tE9OfZ6aYub6vDRe2tbGm3u6OLEomc8bBxHMKr59fiUDoTCucIROf5C9wx4CgCoKc5IMTDXqsHe72dDUj1hopMkX4NpDrSy2GvjllFymHeWeH83QphpHOgrEgZNWpcATiWCI/T4HXF5e7LFz2O2j1uNnqGzkN9jkcEOOBiE1kyl5aXQGghToNPympZcnuwYQgD/+h4Mm+Io+TmvXrv0vSPoXRXd3Nxs2bCAajbJs2TKWL1+OKIqJ1hWZmXPIzz+LnJyv09D4y1gaTiAr83zy869Bo0lDENREoz4iET9abVZCJDsl3Ui/K0B+8hevXK9bVszaeXkTKpCOFnHGyReSG8V+1XYro0OtTiU/7yry867C5TqC19tMcvLSBKCMRkMIgmKMlic9/QwOBtLp7n4SUYiisVzG2ZmLx+w3bkLXNeQbZYD51YFTRJLY7/Ky2S5PWkuTjFSZ9ChFgWA0yka7iz1OL85whP5giHpPgJ5AkGSVkiyNiqlqDVGLiogvOmG/8YgvkuPtbwQBTJNc23ZfgA8GnXw86MQXiZKmVtEbCLHLEIYieQBLUSmZotcwFI4QliQsSgX1bj8uo4rggjQER4BD6iiOUJgk1cgx4itLbyjOOMWM90axPZOJw+3BQl4/spaCwgoumROgufkPDAx+Qn3D3Xh9LZSX3cnQ0C683mYUCgMV5fckVsBx4BSOTE45xVOLkwnPJUmiKxCi2x+k3hvgpR47u5xyCTRz5IlxGxG29ciTkkYU+OWUXE5OOXZK7JSKdK4+sQilKHLnW4fIT9aztDSVsgzjcdm2KEWBO0tzSFOr+EVTN3c0dpOrVXNmmnXMdhWZ5gRwGp+ms4fC/KWjn21Dbhq9fuyx30QlCJQbtKhFgXZfkIFQmOd67AyGwjw1o3jMPrTabObOeYnDR35If/8H1NX9nLq62zEYplBUeDMZGaspLtbj9mwGoKurHJermLVrzyI3t5DOrqfx+VopLW2mrq6cvr4+ioqKkCQJh6MDk6kfvaEWlysFg6EMURx7v8bBrj8UZeXKlTQ0NGC32/nss88IRKIEgZqpZubsc3CKpGK2HXy1drTlSYgKBWfc8D2a9+wkvaiYrCkVpOYXIIrHzzyOPo+lmRYcfz9C1BNC0CnRFFlobm7mhRdeAGDGjBlce4oMjNRKkXLDS2SIDfjDan67+9v8zzkzJ92vXq1IPAtmrYpgNIrCpCaSpkXwhllREWv9FI6wz+Vl25CbbUMedhWqCRWPVO2mqBT8rCSbSzKTEQQBd34q6ze1UV03iBCKYBVFflCUOeb4f/mskXs/queC6dn84RRZWnP7kRpUDU6uzklFU27l4fY+tg15OHVXHZdlp3BrUdYYgA1jAWCGWZsY6wfcAaJmFV2zrZRuOsgMow69QmT7sGfM55VhCVpc3L2omDdsDnZFgkgaBU/22Xmyz850o44at8zO/aosl4v+w0ET/NcA8z8u0tPTmTt3Lrt27WLTpk10dXVx8cUX094uU63xsl+FQktF+S/IyjwfpdKSMEwciYng6IFLqmgd8Caa0h4rBEE4btAEY1MlnkBkVLuVLz+QTRYm09QJqR1RnBzsJBktPNYsm4Fet8w64f3c0cApYYD55R+FoVCYZ7sH+VvnAL3BUSW/LaAUIEejZjgcYSg8eSGBKxKkzR9kOx5YlM7wUJBmb4Bivbwij07COMVBX6ZZO4aBcITC3Nvcw9+7B5kMYiiARSY938pP57RUS6KBbjw+bx3k4s+OEMkzICVpWBf28eG2w1yZk8r1eWmkqVUJUJRI1U0iSh3xcRr5zgkfJ6WIyTSNmTMfo7PzaeobfkFn59/Jyf4a3T1yY9CM9NUJPxcgIRwNHyVXFx7lERWPnkCQl3rsvNLroMkXGLO9QoAyvZbGHheRYIQluUnMzTCz0GJgodWQWDUfLT5vGOC21w8kurqPjqlZZu46p/K4m/DemJdGmy/AM92D3HS4jdeqVMyxjDy3FVmjmJ94I+lIlEc7+ni4vQ/XKBZOKcDFmcl8tyCDfJ18/0QkiQ8HnFxZ08KHg076AiHSx3n9KJUGZkx/mLa2R+nqfgm/vxOPp56aQ9/B5aqhr+89lMoQw8Np+H2rue66i0lNle08Skt+xMGam0hL34vHE6ar6y3CYQ99/R9QWCRXHg4NvcfOXbJbdFra6Uyb+pvEQicuXvaHI2i1Ws4880xeeukltm/fjhieDqg4YlZiODkb08ed5EREBp86hCrHiGVlASVzF1Ayd8FxXetjhfdgP0NvNBL1hkEpYD2nhMbmJl588UUikQglJSVj+rIODHxKhijfr08f/hpd7uyjpoqtejUuq0Q0RcMfgy5u23SAcAoQY+KeVIR4a/sRmn2Bsc+tKEBUQnCHUHd62X3diehGCbDnF8o6zLhVw2RtrdRKBUJIGsPWxivqSpINfK0oi0uyUri7sZv1/UM80z3ICz12qkx65lr0ZGlUWJVK0gQBCRAAdaqWdyN+QmVmeiUIFxjlhwo4EAM/CgHOTU/i5GQT5QYt9750gG3NLlIWCJQMhjmwv5fzziih16Jik8OVAE23FWXyjZyJTZv/E+O4Zou77777K+18+fLlLFv25Xw2/tPjX11Vp1QqWb16NXl5eaxfv56mpibefvttenrkMvmCgoIx21ssx2dHAHLblePVZXzZ0CgViTJVVyD0hYxTRJKocfs44vbR7A1gVSm5Pi8tkbb6RyLFOAL4xvfdA8iJ6Vq6HCOM0/E2TgVo8wX4a2c/z/fY5R5lgEkhsixZnui2Otw4whHaYqaJ6WolK1MspKmVJKkUlOq15GnVOEJhmnwBNvQO8dHAMBGrmlN21XJVThorkk2UjOo3GE93Zll0/PWKeQlhsiRJvGpzcGdjN4Mh+Zovshg4PdVClkbFQCiMAKxOs5KpOfp3zDFqUR0ZRtnsIpKpI3t6Ku3hMA+39/G3zn4uy05B1I0FRZ5JWuqMME4jvi2hUcAJ4l4xV+IY2kV//3vUN9zD8PAeALKzLx5zXkpFnHGaPFUXigEqpSjiCUd4qL2PP3f04Y+9rhIEsjQqsjUqViSbuSQrmQyNique3Mn25iEeOb1qjKXA0SIalfj1+7X85TO5vUe2RcvJU9MxaJQc7nayq9XOkR4na/+yjfNn5/CTVRVfuF9BELh3Si6d/iCf2F1cfrCFd+ZOoSAGfCoyR4DTtCwLe51evnOkjQavDAYrjVquzU1nmlFLsV4zAfQpBIEz0izMNevZ4/Tyqs3BjZO0xRAEkcLCGyksvJFAcID29r/S3v44be2PAaBW51Bc9EvOOXvxmB6YaWmnYzHPZti5l6LiagLBatpjTg2SBMGgntSUEry+FiIRN729b5CbezkW8yxghHEKxLyAKioqEpqqSmUve8J5DHmD9Ofp+TZu7kpOYqlLItTlZuCpQ6TfPBt1zldvyRFxBxl+uxnvvn4AVNkGki8uJ2pVsu7Bp4lEIlRUVLBmzZrE9/b5ujh0+AcAfNx+Ijt7ZV3YZMDFFY7gqDATssQ80iLyM6EGQq4QkkHJEFGGYuA+W6NikdXIEquR6gO9vPZZK4IEqUb1GNAEkGLUUJJmoKnfc9Tjx1nYMcApBvjjHk55WjV/nV7IFoeLOxq7qXH72OX0jDCzsRBOzIBQlC0WJQR9CfYaIMkdYf0plex3eukLhjkn3UqOdpSkYFQD+O5hP4IEp1jNnDMrm25/kHV9Q1iUCr6e9Z/PNMXjuIBTS0vLV9r5ZIZ2/9fjf8s5fObMmRiNRp555hkOHJBN/ywWy5c6piRJ7HV6eaZ7kEavn7AEEhJKQUApCCgEAY0oMNus56w0K1MN2mOmGvyRKL3BEI5QBIUAU/TaMSWiBp0Sn0nBMz2DDLmDhCosHM7Sk7dxPxalgiSVgmSVEp0oss/lncDEhKIS3y3M+JJXamKkjgJOk01ectPbOON0fKk6SZLY5/Lx544+3u4bSnSem2bQckN+OuemW1HH8mlRSaI3EKLDH0QA5loMYyqzRscCq5EVegML32wgND0JX4qGRzr6eKSjD7NCJFxkRNnuGfO7LK9IlyfbQScPtfexdUhOEZbptfy6PJfF1i8/mcQZNyEQRdnm4ZFVM3AYlfyhzUa108vjnQOQp0LUp7DJ62FlOII7pnEyfAHjdLR0Wknx9+nv/wCHQ648MhimYI5NqvFIpOqOwjiFYuaJYa3I8l11dMTA6jyznsuzU1mdZsE4San0X6+YhzcUOS5tWygS5dZXD/D6Xtkb7IrFBfz4jIoxk5XdE+S379fx4q523tjbxYeHbdy0opSvL8jHcozKVKUo8FhlIeftbaTG7eOyA828NWcKSSolZRkm0kwaJJXAi14nTzUOEpEgTa3kzpJszs9IOq6FxiVZyexxyrqTG/LSjvmMa9SpTCn9CQbDFGprf4ZCoWfO7CcnYbRl4Ddr1t+orv49zS1bMJsDFBYsAGbz2mu1mEypnPn97yNJEQ4cvJGBgY+wD25KAKfRjFN8fyeddBIvvPACFYo+asJZ2D1BvMEIPmBzno7zz5rGp397m0C/h4XvWUn/1owJ5zU+osEIYZuXkM1LyOYhZPMStnmIDMcKaQQwrcjDfHI+glJk48aNeDwekpOTx4CmaDRATc3NhMPDSMppvFx3XuIY+lGLB0mS+Mzh4n/qu3BYlBCVUHR6uHV+IRcUp9PaMcxlf9vJN08s5PSlBXgjUaabdGOqx4brHIlCjaPdowuKko8JnNQJ4DTy7AzFzDDHZxOWJpn4cF6ZzIAPuTno8mEPhekPhtnt9ODXy/tXSHCiUc/mQ31IahFxOMgctY5SvZZS/eQLhdEN4HtjHlTZMTPPbK16UjA/OuKN0v+T4riA05NPPvmvPo//xiRRXFzMCSecwOeffw4wqTvv0cIRCvONgy3sHJdvniw+tbu4v9XGNIOWWwozOTPNMmZADkclnu4e4DctvQyPAjsiUKzXMNWgI0mlwLYghahS5EGbrMugwIgPQJIYCIUZCIWBUT4qCpFZJj1WlYK3+4f5dUsPcy16Tkg6tqDziyLZoEFSi0Qtag4KIYK9dlalWRIr8tGMkz8cIWpVc2eXDbWtH4tSQTAqMRgK44tEUYkCvkiUeq8fZ3hk5bY8ycQN+eksS5qoaxEFgWytmmzt8aU6RREEfwTV7gH+dMtSPhgYZrPDhS0YhjILkQIjT3YN8LXMZF6zObivuSd2LeXQiQK3FGZyXV5aArx92TCNG5wtOjXzUk2cmmJms8PNA202tg65iaZqeTns480tNeRFBEJlZupMAr9r6cUbiSKGokhaBd7ARMZJPQ44GQylZGVdSE/PK4DMNo2+loFolIEMLVFv4OipumgUSS1SnanC4w+Sq1Vxd2kOq1KPXSmkVIiYj8MXxh+KcONz1XxS24dCFPj1hTNZM0kriGSDmvsumMEl8/O4/a1D7O8Y4tfv1fLAR/WcNTObry/MZ06+ddJzMioVPDuziDP3NNDgDXD+3kZemFWMSaFg9YUVPGuz87cu+Zk6L93KvWW5JKuOP7V8bnoStzd0Ue/1s9fpHZMOjMcBl5cuf5AzYtctO2sNKcknIghK1OqJAu94qFQWSkq+w7vviqhUKlad8RP27dtHNNqUEIYLgoLUlOVyUYB9M0VFssP7eMYJoKysjNT0DAb6bExV2hjypicMMnVimJfefIXGoUZQQX5jKuamPLQlVgCkUJRQvzcGkjwxoOQlYh9rGDnm/DMNWC8oRRMzDHO73YmeiSeffHICNEmSRH3DL3G6DqBUWlFn3kdYGjGFNGqUhKISb/Y5+HNHH4fc8jH1EYnwrn7E4RCrz7SSq1WTOyWNz29dQaZZO8bDaHSMXsgdrR3U/MJkXtgpU3zj+9QBqJQTCysSz+IknmqCIFCo01Co03DJiLwKTzjCose34ohE+PncQpbmJHHW6w2J93VTj71QMyXacYUSwCnT8sUs7952B09vbSUUlXj468efWfnfiP9qnP7DY8WKFbS2ttLZ2Ulp6fGXy/+5vY+dwx40osC56VZOS7GgEQUE5E5roahEWJJwhiN8Yney0e7isMfP1YdaKdNrWZOZxEKLgd1OL6/12jnskW94nSiQrFLii0axhyI0egM0xlIHKEUET5gFKUaGA2Ea2odZYNTzwKppuCOy2NgeiuAKRyg3aBMCaoDvHWnnxV471x9q44N5ZccNOiaL+kiIwIkZoBT506ADBh2kNSn5Tn4GaWolLd4A4UIjbr8MmiL5Bj50uL5wv2pB4NwMKzfkpR+1AuWrRJyNEoCz0yyck24lIkn8rcXGHUc6kfRKflLfyd2N3fhizeu0okC+VsNMk44fFWUm0jtfNdRKEZ1KkdBMxFOXgiCwLNnEsmQT333zAK/1OrBMsTIYlWgUJSgysZsou1t7R3Z2UiYhR4C7G7uoNOrwRI/uHF5c9B1strcRBJHMjHPHvPdc9yDdWRpIS+WQz89JsddtgRBPdA3wTv8QXl+YwKI0AiqBXK2Kt2ZP+YfundHhD0W47tk9fFbfj1Yl8silczi54tiM6Kw8K2/csITXqjv52+ct1Pa6eK26k9eqOylJM6BRKnAHwpw9K4sfnFae0KlladQ8P7OYi/c3Uevxs3pPA/7YMwYww6jjf4qzWPEFwvXJwqxUsDrNyqs2Bw+193F6qgVnOIJVpUCvEHmue5BP7PL9//WsZH5bniez0ZrjY3+Tk5NRKpWEQiEcDkeioi6uhZK3kSUbTuc+QiEnKpU5AZzCET/BoB21WhY+V81fzEcb1jFN0UuPQ4NrIMRMRTf6pkM0BkdaQXWJdjLWNaJK1xPq8xIe8I3vu50I0ahClaFHlWFAmaFHlWlAla5H1CkJh8O0tLSg1WrZvXs3wWCQ7Oxspk2blvh8W9uf6ep6DhCorPw9A6F8QAZOkgivOob4e10L3QGZ0dErRL6elUy4dogXhyfKASarpBsdozWXR9NfjjZjPVaqLjhqwRf/e/wi5lhhUCooCgu4Oj2Un6qfcKwv8oOKb99u9xGMRBEEjikZaexz8cNXDrAv1iFCFKB32H9cYOt/K/4LnP7DQ6FQcPnll9PR0UFxcfGE9zv8QSKSRJ5WnZiAneEIT8aM9h6dVsCqcdU64+OKnFSGQmEe6+znrx391Hv93Ns8tvWIRangtuIsrshOQRErH+8Phjns8XHY7afTH2THzi4aawa4+mvZtHo9/P7wEBULTMc1qd9blssBl5fDHj+XHWhm3ZwpmI/iRnu0CEcl3uof4get3aAUET1hTsyx0uwP0uEP8vPGrpGNy8emPNdmJjHbbGAoFEYtiqSoFOgVCsKSlBAUF+s1aL4io3OsGG3XEIlKKBVyGnWV1cwvP7ehKDBimpGCLRjGpBD5UVEmV+WkTRB4/6Nh1ikTwGmy1GWGSoWyxc3XclM5/6RifrixjgP9LmYUJjEzW26JsH/Yy/ZhN9EkDY90yNoRZZEWAnomG6u12mwWzJf9uNTqsRqH9f1D8h9Kkd847LhblBx0+fjM7pL9a+KhU6KJSLw8q/SfBppaBzz8zxsH2do0iE6l4Ikr57O45OjMy+gQRYGL5uWxZm4u1e1DPL+jnbcPdCfSKgAPf9pE66CX+9fOSrShmGrUsX7OFL62v5nmmO6lWKfh1uJMzk6z/kP6v0uyknnV5uCdgWHeGRie8L5CkHVJz/fYcYYjPDyt4LjvdVEUSUtLo6enB5vNNqkVgU6Xg15fgtcrNzhOTz8DQo18veIVFmft5vMtIaZN/S2ZmeeQXVhKf9RAmuihINCC/1ALc1RAUJYrlJSUUF1dTZfSwcx+H+H+EaG+oFPGAJIMjpTp8t8K49Hviw0bNrB3794xr5166qmIse/f0fEUTc2/B2BK6f+QmrKc0LAPCYhm6AiXmflNh+xjlaZWcnVOGlfkpJCkUvKn9pFzG98S5VgxOj13NBlBbpKOLIuWnmH/pPueTON0LMbpWHHbqgo+bxhgaWlqwsIlHjrVsfcVZ8MabDI4TzVqjnr8BpuLr/11OwPuIGqFyFmzsrhySeF/FGiC/wKn/xOh0WgSbJMjFKbJG+CQ28ervY6EiE8rCsy3GPhdeR5v9g3hikQp02s5PfX4NFFWlZIfF2VxXW4aG/qHeatviANuL1UmPSenmDkvPYnUUXl8QRBI16hI16hYniyvgq/e1kMTci7bHZwoHD5W6BUiT80oYnV1A4c9fr55sIVnZxYnNFSSJNHmD7Khf5itDjcVRi1X56aiEkT+0tHHur4hugNB4un8xVotN2RaWTk1k2A0yvM9dp7vGUQviuRq1Xxa1489KoOE1B4/D66oOq7z/FfE6Oq4iCQlHspIVEKQQN/jZ9s10/jU7mSBxfAvc9I1a1XYnAHUSnFSX6R4I09fMEqlUUexM8qROicXl+VyVXkeIIuoi+5+n0iqhjUritnj9spi5sokvjfYj2WbA7UosCzJxNnpVhZYDJPqZ/oCIbYPyfe2MBTEb1Vzf+uI79R8s4Fv5aaypbaPF/d2cWZ2cqIa8R+JIz1O/r69jZd2dRCOSuhUCp68aj6Lio8PNI0OQRCYW5DE3IIkbj9rGtuaB9GqRLqGfNz51iE2HOhh2BviyavmJya5Ap2Gt+ZM4Q+tvUwz6libmfxPAchLrEbWZCRR4/aRqVZhVikYijHAM006vp2fwWGPjxsOtfF2/zANu+u5pzSHE5OPL22ekZFBT08PO3fuTBSyjPdwSkk+Ea+3iUH7JhQKPZ0NV3NKvvwMShIJ0XWIFbwfLKdQYadQ4SBH5aM7qKVs6jRuvHAFw8PDVFdXY1MOoZmZijbdjCpTBkiiSf2l9DA2my0BmgwGA8HgAGVlsxKLVLt9K/UNsrN6UdF3yc//JsFolA+cboJL0pFM8rOYpVbxg6JM1mQkoR21Qoh7NmlVYgIgH0+Mdu4fr3Fq7HPx6/fq6LB7E2zOkDfEs9vbCIajqBUCaSYtUox+8wYjPL21Fb1akUh5f1ngtKQklSUlMoM4nnGabKwIhqO8sVdmXfuc8iKgwSZrMbMmAUGRqMT25kG+++JeBtxBpmWZeeqq+cdVuPHviP8Cp/8j0RsIcU9TN6/ZHGPYaIUASkHAH5XY7HBzxu564uPGtwvSv/Qq1aJS8vXslIRZ35eJ0Z2wPV/Bxylfp+G5mcWcv7eRz4fcFG06gFkpokDAFYkQHvXFP7Y7eayjH6UgJNJXIHvxXJmTyu0l2QkGTi2KXJmTypWjSl1v2jvIhoPyRJyR/tUrc/4ZMVo4PuqrJHycREEGlqu/gDn8MiFJEp0OH3W9LjocXpy+cMJwczJ/KBixnBhvRzD6NxZFAX0EfJ1efpCVRpZVx8Lnd9CVoWZICUMx8XaDN8DfugZYaDHwWGUhGeMq/t4ZGEYCzP4ogd0DzD2zGKtZwwKLgROSjEw3xQT+hwdR9Pow5hz9PvcEwuxssZNh1lKeaZpgyGpz+nlzXxevV3dR2zuSsl1RnsZtq6ZSnvmPae4ALHoVZ0wf8dkpTDFw7TO7+bxxgF9uOMKd51Qm3ktVK/ll2UQd1T8SoiDw0LSCY25TpNfw95kKrj/cSp3Hz0X7m1ibmcQDFflfOI5kZMhpvdbWVgCSkpLIyckZs01yyol0dD7FwMDH9PW9D0Q4NFjO+60n89uzBunpeZlDh3+AKfNuwphpjKTRGEljRdH/x95Zh0dxdu//M+vZuLsnSCC4e3EoLdoCdaXu7u7u7rSlipcWd7cQPO4uG1vf+f3xJJssSSCh0L7v9/fe18VFdkd2dnbmmfs55z73CWTDiTIGR3ZBq9USGBiIp6cntbW11PTREBgfztli3bp1ACQlJTFlai/27p2Fp2c2sjwfSZLIzfsCgNCQ2cTG3EGNzc78lAz21TSApxpsDtzzG9h61dA2rSyaRNidqdoFV7LkoVOyJ7uSjNI6UvIN/LI3r5Xmb9XhYlYdLnZ5r8mi43hxLU81tlpqwiurjjG2ezDjugW1q7NqD1qVArVScorOdSoFDoeMQiFhstr5eW8eH2/MaNWMuGk8y61oYO4nO6husKJWSXi7qTlZUuc01OwR5sXC6we7GIX+p+F/xOm/AAsLK3gyvcBZ+h6qVRPrpuUCP08uDfEjQKPiZL2Je47ncbC2sfO1TsOMIN/T7facoykkW2u2tXCV7twl1stTzxc9Y7j1aA6VVruLIFspiZnzKF9P1lXUsNNQj1WW6e3pxp3RwQzwcidQo+oQWQxv0eDybDyczgY2u4OCaiMNFjtKhURCoAcKheSaqmuRgmryceqs8/rpcKTQwBdbs9iWXk5JjbnNdeotNnZkVLRKTbmdUjHXlo8TCEsCo9VOvcWGSiHhXWKi/Hglz13elx5hXpRZbPxRXs2KMgO7DPVM2HuCD5OiGe7TLLRfUVoNQEi9g1y7zOU6D2YntyYTTcaY6lNm0GabnR0ZFaw4VMQfqUXOY/bUqojw06NRKbDZHZTVmimrM9N02jVKBWO7BXHN8JizijJ1FMMTAnhrbh8WfLePr7dn0zvSm5l9zy1ZOhuM8vNk++DuvNbo5PxzcRWxblruiQmh1mZneVk1/moVw3w88GwRQYmJiQFEU99Ro0YxYMAAF+sCAF+fwSgUGiwWISPw8Ejm3TXXYJPVRMdNQAIKi36mtvhJBodcwa7iAQDORrdNlWuSJBEfH8/BgwfJyMggPr51xLIjyMnJ4eTJk0iSxNixY8nJfg6Hw4zBsJfy8jV4eHSjomJT4/e7BYPNztyUDFJqjXirlJBuwJRRQ7B7ayuIJoS38F3rDFqm51alFvPZZtfK9vHdg5jSM5S/jhSzK6uSQE8tMf569BoVFpuDY8U15FQ068EGRPtitjlILRBp2p/25vPT3nzGdw/i/cv6ddh5H0R0S61UYG205PlyWzZfb88hws+NGqON8sbmv4GeWm4aFUe92cZba5vF5NVGK7uyKlvt11OnYmrPUB6Z2g2fDrb6+rfwP+LUSZxvH6eWsDlknsko4LN8MdAM8NLzfGIEfbxaCwu7e7ixuG8CD57MY0lJNY/FhZ5zDcyZ4Cw7Ndn+lnP4GD8vUof3pNpqp9JqwwF4qRT4qFTO1N0d0cEcqTNitjvo66XvdLlq04AGf881/HQorTWxL7uK48W1pORXsze7ynleAKL89MzpH8H8Qc3Vki3brDSRKOU50FWV1Jh4+LdDbDhR5nxPpZDoEuxJlJ8eD52KtUdLqDZaMVkdzP9sJ70jvJndP4LpfcLxdlOjV7s6h7dlRwDCSbyivplgWe0OJJtMsruOvo0VXZMDvbk72sx1h7M4Xm9izsEMkj3cmB/qx0Bvd6fFQrhJJhdRPdcWmt5vutZlWebttWl8sTXL5VyHeeswGK3Umm0cK6pptZ8B0b7M7BfOtOSw09oHnEtM7BHCHWMTeG99Oo/8nkqXYE96hHUstW61O1h3rBQ3jZLRXQLP6XH5qEXEq6enG/ccz+PVrGI8lEq+KCgj2ygihkoJRvh4clOk8BwLDQ3lrrvuwt3d3WkUeSqUSjd8vAdSWbUNtdqP5J4fYPv9IABmG3Tr9gIgyNMNyd8hSTI7iwZSWC10Qm6a5vugJXECcDgcmEwmjEYjRqORhoYG59/tva6rE9dYv379cHdvoKT0D+f+M7Pexc93GCDj5zcSlS6aWfvTSak14qdW8kufBO7YvYtMm3zaMa5XhDdvXtqbHmHeVNZbKKw2olJKqBQKzDY7JqudwmoTJ4prySqvp85sw2i1u4zd+VVG9BolA2P8iPHXMz4pmJGJ4jef3UaFJ4j7YPGBAu79OYUQLy2/3jKM8jozA55fC8DVQ6NZtCePtcdKufHbvXx65YA2Rd6F1UZ0aiV+7hpMVjvvrkvjsy2ZLhYHIvolk9mo4Qv3cePm0XFcMiASnVrJrswKoJk4TU0OZUrPEHz0amx2mWqjBT93LUPj/DudQvy3cM6IU0pKCv369ftHCMW/ifPt41RltfFDUSUHaxrYX1NPQWOVxkOxIdwdHXxaguCmVPBe92he7xp5XkTMZ0KTQLHObG2Rxjk753ClJOGvUbWy/2+JHn+jss2FOP3NPnUGo5VjRTWcLKmlpMZEvdnOofxqDuRVI7tG1NGpFXhoVdSb7eRWNvDmmpN8vT3bufyKz3dhtTvwc9c4I00mq43SGtNZ5/tlWeaenw6yPaMChQTTeoUxb1AkfSN9XQbLJ5Yc5rudOYT56CirNZOSbyAl38AHG9L54uqBLZzDxW/b4NSxuf7G+sZS+YZGYmW1te3jFKfXsrJ/Is+kF/JTcSWpdUZS05oF/L083fBqbFLdNFAfL64hJa+amX0jhOFqYxS2Kd3w/a5c3lknBukgTy3jk4KZ1Tec/tG+2B0yJ0pqKa+zYLE5UCog0ENHqI+OAI+/r486G9w9vgupBQY2nijjpu/2seKOEaedbRstdr7ansW323MorhGRmAWj4nhocrdzGpkEmB/qzx5DPT8UVToLK8K0arQKiSyjhU1VtWyqqqW7u45H4kKZ4O8DwLaqWo7WmVArJPRKBaN8PZ3mq1HRC7DZ60lIeBi9PhyN8hAWuwOT1Y4kaejW7QUKDSYUDcu4Mfk7JkRtZHPBMLYUDMGthQVDbGwsIDRKr7zyCsY2Gvx2BHq9ntGjR5Ob+ybgwNu7H3V1J6mrO0Z9/UkAIsKv4MPcUg7WNuCrUvJbnwS6e7g5029tESeb3UFOZQP7cqrYm13J+xvSncSis4jx1/PNdYOczXU7AkkSkyJoLjR0GtEqJZ6Z3pNJPUO44Zu9bEkrZ+ALa+kd6U1SqBeh3m7IwLKUQlLyqpEk6B3hQ3WDhezGKJZWpcDcmA24c2wClwyIJLeyAYvdwfD4ABcCdOr5mdQjmIt6h53VufhPwTmNOMmnPiX+h05DBp7LKHS+dlcqeLtbFBcF+XR4H/8GaYIWGiezzSWNU91gYfXREnZmVmBosFJrsjmjKXqNkkAPLXGB7lzcO5wo/9OX6Z4ruKTq3Dp3G1hsDg7kVrElrZwt6eWk5lfTjs0QSaFe9AjzonuoF4Pj/OgW4oVSIdFgsfHn4WI+3JhBemlzY9amUHpL1JntjHh1A/MHRjIlOZTuoV6d0kws2pPH9gwhTF5y23C6hbRd0t50HgZE+/HkRUksO1jINzuyyalo4NJPdnDjSCGYbUrDtqdja+pd10SsTlfJ465U8mrXSB6OC+XX4kqWlVazr6YBGbg0xI8DJ8TDpikSd/eigxwvruWHXbm8N79fc6pOqWBvdiXPLBdajvsnduHWMQkuwnuVUupwRKdNyDJkbYb930DaGvBPgB4zofc88Di9iV97UCok3p7bh4vf30ZuZQN3LjrIV9cMbJME7cys4KHfDjlTMD56NdUNVj7dnElaSS3vzu/byo+rJXIq6qmotxDj746vXt2hKO0LiREcrjVyqM7ItEBv3ugaibdaRbbRzFcF5SwsrOBYvYmrUrMY6uNOucXmdDZvgkaSmBfqx21RQUT7jcDfb4RzmVYtyG/TQ1iSFFjdH2D90VrGRW0mxjuPGO+fCHUvRq9p7jnp4eFBdHQ0OTk5LqRJo9Hg5uaGXq/Hzc3N+a+9115eXkAthY1eYnGx91BVvYvs7PeRZTs6XTg1+mG8dVSQ8ecTw50NoJuJkxKb3cG2jAqWHSxkX04l+VXGNr3Hgjy1OGQRKdUoFbhpRDSnW4gn8YEe+Og16NQKzFYHTyw9TIPFzhPTkjpFmpznQuVqgHmqFcGw+AC+u34wNy/cR1mtmW3pFWxLr3DZR2PnF6c1QLCXlmen9+TzLZnsya4ChLVCpJ/41xZOrfjrbNryPxEdfmLMmjXrtMsNBsN/nLvnfyP81CquDvMnQqehr5eePp76Np2PzxZmm71xFlTF0cIa0kprqTfbsTkcWGwObA4ZX72GywZHMXdgJBV1FtJL63DXKgnzcSPaX99udUgTccqrbCCzXDzwHvk9lcp6S7sGhi3x+uqTDIrxY2KPYMZ1DyY2oPODRUfRkjh1hIQYjFYW789nc1o5OzMrXJyxQZQGN3U6bzpX47oFt1tGq9eomNUvgmm9wvhsSyav/SU6sD84qSs9wr2pqreQWiD0SBqlaGXzzY4cvtkhvGOGxvnz0qxkYs5wjooMRl5ceQyA+yd2bZc0AfSJ9EWSoG+UDwEeWq4bEcvs/hHc/sN+tqSV8+568fAwOlN1rTVOJqvdGWVrcmV39qo7jQjVT61iQWQQCyKDqLDYyDaa6eul5x5lPiDIV3WDxSneTsk3MOWdzc6Hw9fbsvh4k0jbXJgcym0XJJzb8cjhgGW3w8Hvm98r3C/+bX4Nxj4BA6+Hs2gy66PX8PEV/Zn10TY2nyzjww3p3NHYlLUJn2/J5PnG3zHES8d9E7twcZ8w/jpSwgO/pLDhRBnzPt3JV9cObOWRsyuzgk82Z7L+eKnzPV+9msk9Q5ndT0TjWp4rWZYx2xzUm20UGUzcpPKgUKfhlu7RzshejJuWZxLCuTc6mPdyS/k0t5RdJ8txeKpx99Aw2tcTSYI8o4VDdUZnH7QbIgK4JybEaTWiVSmpxeY0uQQw22V+PjmTP7LGc0HkVmYkrGJ0xHZ0SgPQnJa87LLLKCkpQafTodfr0el0rXRVHUFm5kIcDhOensn4+g7F07MH+fnfYLPVEhZ6GQ+cLMTskBnj68ms4GbdaNO4YbU5GPXqhlZiaK1KQe8IH/rH+DIwxpd+Ub6d0u58vT2b1AID0Wc5mXTaETQSplNbHwH0j/Zl5yPjOFlSy4HcajLL6igymKgxWRndJZDpfcKxO2Q2niilwWJnzoAIvHRqFu3Ode5D10EfpyaEep87D7x/Cx2+ypYvX86ECROc1ROn4v96iu6fxCuNpd3nCja7g00ny/h5bx6bTpZhsratF2lCg8XIa3+dcD7MW8LbTc3MvuFcNjjKGQpuQpO/R2pBs4aktLFSoluIJxOTggn3dcNTp0apkJBl8fAtqzWzPaOcrenl7M6uZHd2Jc+vPMYFXQN5bkbPM5rFnQ1UCgm9WkmD1X5aMzhZlvkjtZinlx9xVn0A+LtrGJ4QwMjEAEYkBpz1YKBRKbjtggTeWnMSm0NmZr9w574i/dz4YmsWId5aXprVi+925JBaYKCg2siOzAqmvLOFO8Yl0D/Kl/ggj1bppvTSWu7+6SC1Zht9In24dnjsaY9lQlIwKU9NdElderup+fKagTy59Ag/Ng6WxQYjJqvdeR2ll9byw+5ctqaVc7SoxhkdeuGPYzhksDS6zbdsxHs6tEzRqhTNTX4PNM56w7x1hPu6sSe7ivpGAmtqfDgMjvXj1Tm9zi1pkmVY9aAgTZIS+l8NyZdAyRHY/y0UH4JVD8DuT6DvldDncvDonO4oKcyLF2Ykc98vKby7Po1x3YOdzbjLas28vlrci/MGRvLohd2dv9HFvcOI9tNz3dd7OFJYw+yPtvP+/H70ivCmtNbMU0uP8OcRUW0ljAe1lNSYqWqw8uPuXH7cnUtikAfXj4ilW6gXPzZ6TtVb2hjPG2ytCJ23WsVNQf4cWJvDvqxKdFoln18zkBGx/o2nTmZHdT1v5RSzpaqOj/LK+Km4kqkBPozw9UCtU0IdzogTNEdG6qyeLM+cTK/AI8R55+Ko+xV42LmeVqvtVDeFtiDLdgqLfgYgKvI6JElCrfYmqfvr7C/ZwyOGsWytrkOnkHi5a4TLddVEnPbkVCHLooLuwuRQJvYIJi7QgxAv3d9Kn743vy9ZFfUkBJ1dVWfT/dY0cTG3Y36pVEh0DxVR8fYwb5DrefZoMUa4nUFYfqqreZDXv5MWP5foMHHq3r07s2fP5vrrr29z+cGDB1mxYsU5O7D/4dzgYF41dy864MxNg6h2GBrnT68Ib7qGeOLjpkGtEoJFtVJiX04Vn23J4lhRDR5aFQlBHpisdgqqjBiMVr7ens23O7K5cWQc90zogkapYPGBAl7583irz3//su1PpewAAKEGSURBVL70jvBpN4zbhFvGxFNkMPJHajHrj5ewK7OSDSfKmPjWZub0j8BTp8LHTcPkniFE+umRZZnjxbVoVQriAtu2E6ioM/PT3jy2pZdTVmumst6KzeHA4ZCpMTULh99em8aqw8VY7A5Ka8z0DPfi6Yt74KlT8+SSw6xrnKnHBbhz6cBIRiQEkBTq5ZIG+rtQNMbEXcThjc8SlULB8IQAhicIO4XcigYe+u0QOzIrePXPZnI7JM6P2f0iUCsVHCk08M32HCx2B546Fa/N6dWhQbwtvZdaqeDFmT3x0qn4ZHMmRquDOR9tdy6/9uu9p6wvSpWrGqw8+Nshl/10Fk3O8naHzIEckRoYEu/Pq7N7cTCvmnfXpbE5rZzrhsdw1/gueOlU55Y01RTChhfgwEJAgpkfQ69LxbLoYTDgOtj3Fax7FirSYe1TsOkVGH4XDLsDNB2Pms7qF85fR4pZfbSE+39JYcltw9GoFHy+JROT1UHvSB9empXc6vv1jvTht1uGcfVXu8mpaGD6B9sI9dZRZ7ZRaxKVjZcOjGTByDhiAtwxWe3sz6ni9wMF/JFaRFppHQ//ntrmMfm5awj11nGksKYVoZNlmTVHS3h8yWHnBMlktnPjl3v45Mr+jOoi+uIN8/VgqE886ypreTq9gPQGMwuLKlhYVIGytzfSCVHJ2YSWJAok/swaz619vsRY/RM22x2oVOcuEl1ZuR2zuRiVypvAwEnO95ebe/NkeQA2uQF1YzPmmFOMfLMbo+qyDFOTQ3htTu+zKoZpDzEB7meMKJ8Ozam6pohT21rDs0HLKFIr4mSqgT2fQWUWGKvQ+kSRqEwkzR6Mv7umUxV8/6no8K/cv39/9u/f3y5xOhfs/384d5BlmQ83ZjgjGX7uGmb1DWdWvwi6h3qe9uES7e/OzL7hVDdY8WmhhbA7ZLaklbFwZy5rj5XwyeZMftufT73Z7kzfdAvxdPHCGRTrd1p7/ZYI9Xbj+hGxXD8ilvTSOh75/RB7sqv4dkdzT6gXVx1jUIwfBdVG8quM6NQKNt5/QauU2JtrTvLxxgznbKstNAkcZXA55p2ZlVz47lY0SoWocFFK3DImgVvHxJ+3m77Jy8nFx6mRRJ1K0KL89Xx/w2B+3JPL6iMlZJXXk1fVwM7MSnZmupb5jukayIszkwnz+XvhcUmSuHZ4LJ9szgTgcGFzVLFJcH5Bt0AGx/rz7rqTLNqTz+gugRzMq3ZGItcfK2V4QgChProOD94qZXO/rX25gjj1i/JFpVQwIMYP/8YoW6i3W6e9ck6LqhzY9rYgTPbGZrAXvtFMmpqgUMLAG6DXXDiyGPZ+CYUHYONLsOsT6DoVel0CcWPO+JGSJPHCzGT2ZFdytKiGp5cf4a5xic7r/65x7acfYwLc+fXmYTy59DAbTpRS1Jg26h3hzcuze7lEE3RqJcMSAhiWEMCTFyXx8548vtqWTUmNiZlJntzhvYUQKlHZG1DEjkLuNZebvtvH6qMl3PdLCu/N70NqgYEvt2Y7NXmJQR68cWlvXl99ks0ny7j26z1OMuuhFWR2vL8Xo3092VhZw9aqOv6qMIgqvR6+3F9Uwlch7nRzd3NpEQKwv7QXJfWBBLuXUVj0M1GR13bgB+wYiop+BSAk+GKUSnEtZTaYeSq9EJsM4/29eDYhvJW56sYTpWxJE9XO1w2P4YlpSf9xUpWmyJJDFlmHpvOqPQeVay11Sy2rHbGa4Md5kLPNZf2/1BLrFX04qLsAGvqDvkWXAFmG6hwo2A/lJ6GhAoxV4r5z2EGlhTlf/u1jPpfoMHH6+OOPT5uO6969O1lZWe0u/x/+OciyzFPLjjgH3At7hfLizOROPVgkSWplQKZUSIzpGsSYrkGsPVrCo4tTnTNNnVrBLaMTuH1sAvf+fJClB4XAvbM+Tk1ICPLgpwVDWX6okKNFNZitDtJKa9mWXuHiAWKyOlhztJgrh8Y438sqr+fdxsqqXhHeXDogkhh/d/zcNWhUCiQJfPUafNzUVNRbcMgyh/INeGhVeOpUvLc+jb+OlGB02BkY48uLM5NJDD67cHlH0RQNcvFxarIjaGNAVigkLh8czeWDhalhQbWRX/fms+ZYMe4aFdH+ekZ1CeTC5NBzNqC3rMDrFeHNoXwDCgmW3DacXhE+LdYTv3lSmBdPXpTEuDeEF84ji5ujGp5aFV5uam4ZE88VQ9o3ZmyKOFlsDg7mVgNCl9GE5qq6v/Ed7TaRZtv/LWg8wM0XMtaD3DjeRQ2FMQ+fnvxoPaHfVSJVd3QJrHlKPAwOLhT/5v0A3S4846EEemp5fkYyt/2wnx925bL8YCFGq53kcG8u6Hp6AXqgp5aPruiPyWpnV1YlNruDMV2DThtp9NKpuWFkHNcNj8XRUInq+5mQntK8QsoipC6TnITuWFEN49/c7Fys1yi5ZlgMt49NQK9R8flVA3j4t0P8fqCAz7ZksTyliCcvSmJKzxCRBlNITAjwZkKAN4/HhzHq5z1k+anIwsrkvSd5OiHcqXfSKIVwXEbBXzljuSrpJ/JyvyQi/AoUir9Pkq1WA2XlqwEIDZ3tfP+p9AKssswFfp58lxzb6v7JKKvjzh8PICNSp/+JpAlcI0u2ihxo7DJxLkr+W47rzsmkwwGLFwjSpPWCobc33kvrUJz8k/HKA4yvPwCvvQ1J02HEPVB8GLa8AZUZ7X+Y5t81KG4LHX6qabX/vXnJmTNnsnHjRsaNG8evv/7a4WX/jZBlmWeWH+XbHTlIEjw3vSeXD4465zf2+KRgBsX5kZJXTbiPG1F+eqdw9NnpPckqr8dXrzlj/vt0UCgkpvcJZ3qfZmfg3IoG1h4rIcxHx/HiWt5em8bqoyUuxKlJBDs0zp8fFww57WcEeorrekJSc8TqkysHsDWtHIPRypSeIec0Jdcemj7CNVXXdsSpLYT7uHHX+ETuGu+qQcFmgYZy8Gos/5VlERExVoJCDfVlkL8Xyk+A3SpmeSYDmOugyySY8IwgBeC0IwC4d0IXrvlqD8GeWhfS1HI9o8VOkGfzuBEb4E5BtRGLzUGt2Uat2cYHG9JPe302XVNltWbqLXY8tCoXbZ2tA8LzVpBlSFkEmRtBqRYz3dIjrdeLuwBGPQAxwzu+b0kSlXbdLoLc7bDzIzjxB2x7t0PECcRER6nox8O/p1LdIKJ1d45L7PA9rFN33ttJYaxE8d10KEkFfYAggSmLoLYQcrYT2O1CXpqVzK3f70etVNA91IvhCf5cNzzWGfUD8VB+c24fLuodxlPLjpBb2cCt3+9nZGIAj07tTreQ5mi3WiERW+ug8GgJCROiOGKz8vDJfBJlJbJaQbCnlrxKUTG3vXAgV/U7iMV3Mg6H+ZwQp5KS5TgcFjzcu+Lp2ROA9RU1rKmoQSXBswnhLud8e3o5n2/NYtPJMuwOmb5RPjwzvce/S5qq8yDlR5AU4OYDFZmQtwuQ0fa9lmDgIfUidB9uZRCwRBPHSfMA2JsB3hEQMUCQm07CS+0gXiogSiol+Gga7EkX40jZMVBqYN73ECsaOzN4ATe++SPJlX9yicdhQk3pIjp7ZHHzDhVqCO4BIcngESyOSaUV30v1n8c9/r8wwLzrrru47rrr+Oabbzq17N+CyWrnUL6B3VkVWO0yt14Qj1alpKrewm/780kM9mRQjF8rwzKjxc5jS1L5fb/wXHllVi8uHXhuheYt4aVTO43YWsLbTc3S24aflwElyl/PdSOEyLlLsCdvr01jR0YFBqPVGVFbd0y0Uhmf1LHu7m1hRGLAmVc6G1hNQmScsw1Ce0PiRAhs9uBxtIg4NRtgnuVnGfLh+0sFKfCLh4iB4nMNeR3bfu8XkL4WZn0KUUNQK5tbLVTUifSVRxuaqOaednYXo7y1945GAiobLFTWW7jw3S0UGUzkVRrbtaFoiiQ1mSD2jvR2iaA02xF08FqrrxDVcSf+cH3fzRfGPg7ugULXFDkIwvt3bJ9tQakSD46ALpC2GvJ2QlGK+M07gMk9Q+kT6cvLq47hqVMzvvtpok0lR+DoMiFa9zoLfxxZhp+vEqTJPQiuXg5B3cBULVKPWVug24VM7hnKgScm4q5Vtt2mw2aG+nIwVXOBrorhU2tZcyiHp46EsCWtnCnvbMFLp6JftC9PTEsiPtADnVqJZHFwo86TmhAdz2cUkYYdhgWhqrDhMFpAkjBFeXOz7WV6GN24QHVuIhCFjWm60NA5SJLEyToj9649jsJm44re4SS6N0+m1h0r4cZv9zptRwbH+vHu/L6d6j93zpG7ExZdLiZGbUBVsI9djV9BRtwffRSZ9DFmwgohiEdSQFhfGHob9Jzd5n4AyNkuiHRlJlRlc7Uhn2u0jSdja4v1FGqhA2wiTY0wuMfwZumlKAc/wW3dTbD5VTi6VNxvw+4QWkHt+Y3qn0v8f0GcxowZw8aNGzu97N9Adnk9E9/e7JLnz61s4PkZPbnqy91OTYFGqeCqodE8OLkbGpWC9NJabv/hAMeLa1FI8OLM5PNKms6ETpEmu03ktAHUug7fQHGBHsQHupNRVs/GE6VM7xNOjcnK7sZU3rhuZ+et0ykYqyFzA/jGQlifttfJ2Q7HV4oHcs52qGvsKXX4N1jzJIT2ZjZD+I6hLhEnZ8uVts6lwyFSQlXZkDAOQnpBVRYUHgS1HhQqWHaHiBiACIU3hcM1HuAXK867xl0QhJBk0DRup/MBSx2selikm765CC79DrpORq9RYTBaKWtsq9CWGNbZmsVqdwpTlS1aywR4aAnwEJGqfTlV7MyqaJ84NW7TZPbYL8p1duxM1Z3Ou8xuE0Tp2HI4+ReYDWJWPOQW0HmDSge95oH7eWix4hkCSTPg8K+w61OY9qY4jsBuENLztJuGeOt4e17f0+8/ba0gPdZ62PM5zP4c4i/o3DFmboCcreI8XLMSAruI92NGNhKn5tRcu67qFRnw6RgwN2vfNMCFwJjECdwlPczmtDJqTDY2nigjq3wPy24bgU7dXDK/IDKIoT4eXLr7JFU6JcfClRDe3N/PandQbrVhsNrwVv+9R5fFUo7RmIckqTiunchDKRlsOlmG5kAFGuCXI9UUxBdzxZBowrzduOPHAzhkYXVx78QuxLdTkNIh2Cxw8k/x+/vFdeKg68V2VdlQWwz7vhYR4uCeYuxpqBLXW9QQqC2CHR9AXQlHHNEEX/4R+6s9WL/sW8Z5FzEhwgEVaaKgoWAf/HodNFTCoBtdP9PhgK1vwPoXoEWXVAmok3XkysEkdEtGE9xVELCIgeIYTkGkr57dWZUiWhySAJd+KyLbKt1/ZETpTPjXidPmzZt57bXX2LdvH0VFRSxevJgZM2a4rPPBBx/w2muvUVxcTO/evXnvvfcYNGjQv3PA5xmRfnq0KgXebmr6RPqw/ngpiw8UsDurkoJqI95uajy0KgqqjXy+NYv9uVVE+elZllKIQxYPpffm923VZ+w/EunrRJg5bY2Y3YKYAV3yDSRd3KFdTOwRwkcbM1hztITpfcLZcrIcm0MmLvDvVaScESaDICbH/wCHVcy0Lvkauk8Tyy31UHYctr/nGpIG8AoXIuPiVPFQKkrhcVK4XLMEij4AqydseZMB5YXco0okzz4KLH0FyWmoFKH4jS+JCAbAumdA7S4enqcisBvM+UqQpoJ9ENYPEieAugNi8ZiRsPhmOLESfrocZn2GXuMtiFNtE3FqPeNumaprmgC0FREaHOvHvpwqdmVWcumAtkl+EyFq0tL1i3YlTs0RJ4RWIn2dEJgqVCJlFpAofoPKTNdzMuszCO115nNwLjD4JkGcUn+B3B3NBDZhPAy+GWJHg0oj0qNFKeK6KTsh0qflaSKlMuE5EQU7ulRosdRuQmB74HuhxVK7i8jDdzPF9zMZwDscZn4C/qfp5SbLsPEV8feA65pJE4jfH0TEsr4c3E8ThT2wUJAmSSmid24+goAX7sc9ew2fL3gc6xWTOF5Uy80L95FT0cDdPx1wRombrC2SPfXMqFPybZUBfaQHtbIMSgldtYUvRnXjAj/PTjcubwsaTQAjR2ynpiaVu/IsbKisRV0qyLmbRonRYhcGt2nN0ZwRCQG8Pa/P36tKqykSRDd/t3gdM1KQjZoCqCsVaSqfKFF0YKwGm0mQfGOVIP+WOtf9db9I/MZtVW8Ouol5z33GHks0GwL6UltXySL7WAoDAplwWePzs6YQtr4tNH5/3C8q4bwjxOfWlYiJWN5OsW7yJRA/Dvzi2FHlxfwfMwCJ45dMbrwB28eT05KY3ieMEQktriHdue+88U/hXydO9fX19O7dm+uuu65Nk82ffvqJe++9l48//pjBgwfz9ttvM2nSJE6cOEFQkIgo9OnTB5vN1mrb1atXExZ2bqzdzWYzZnOzj09NTet+V+cCSoXEuntHE+ipRZIkvt+Vw2OLD1NQLSrIvrp2IH0jfVjTWOGyP7ea/Y2i2XHdgnhpVvKZW3NYjUKU5x/vWt1wLlGUIspSIwe1PaPIWA8L2zBVlRuNBsP7iRv4DJiQFMxHGzPYeKIMs83OuuMiTdfpaJPDAR11XJdlWHGveIiB0IQ0lIsBMXmO0BCVn2xeX1KIqquQZPCNgYQJ4kEJgggd/IHS1W8QqyiBZXOcm3kDd6lSoep3ePFu8SBqIpggBJhRQ0QqxVovyFtoL3DYoLYEIgfCxe+JB1lwkhhkOwOdF1z6DSy+SUTHfr2Wd5R9eV2ahrFaj4QDd41KnLucrXDwRyg5zEW1BnprYFntAqz2bkDbGqTBcf58uDGDXVkVrZY1oYlw1TbaR/SN9HFZbnM4kHDQ9+DTkP2L68Y7P2z+W+8PfS4T2qOIAWdlVHnWiBgIoX2g6KAgTTofQTLS14p/Gk/wjYbSY82C9JaoKYAvJ4qoZlUbBTi95sHU12D148LVvEwYZVJbCN/PgevXiO9flCK+d0hy87aZG8WDUaUTFgot4REIQUlQehSytwgi2hZkWUQ/QaR1k5uvYX67EVJ/hs2voZ73PckR3nxyZX9mf7SdDSfK6NFobWC2NX9vh1VGfdzAXVHBvLM+HYvDQay/O+Nmtu8zdDZQKLT4+AzgZuqI1mlYvbOCYuC9eX2JD/Lg5715/Lg7l+oGK4lBHnx4Rb+2SVPT93cPal8P57CLaOfyu6C+VESFrUZxXrO3dPygfWOFDYbeD4J6iHGlvXFLreOYsit2rFjsjmYH/5bfwSsMprwiiNfWN2HnB633o9SKitJ+Vzrf0lIFZCJJHavS89arGXWOeyr+m/jXidOUKVOYMmVKu8vffPNNbrzxRq69VpSgfvzxx6xcuZIvv/yShx8WZmgHDx4878f50ksv8cwzz5z3zwFciM/lg6MpqzXz4+5cnp+R7ExVTOwRwooQTx5fchgvNzV39tfRtXorpO4Qgte+V7Sd8srfC7/f2DgDl4Qgr4k8+URB/FgxAGRuEKJZ2S4e/OEDxMAZ3EMIYE+Hgz/A0tsECVK5iVTSpBfFwwGEzmflfeLvbtNEjjtioFj/y0kiMvL7TXD1srYfcLXFIjeuUNInwodATy1ltWZeXX6Q48dPAF6M7XYGfVNVjiADmRvFrL6hXDxYp7zWTGraw6GfRARBUsKViyF6uCB7KT+KZU1wDxTn7YJH249u6P1g2O1csSma6+s/Z65qo4iW9L2CFDmR4j2LGa46jodc10yafGOFcHvUAyIKYKkXqZKAxI5FkjoDpVpEZzxCYPcnDLIf4GftAUiH57QStiwtvKxymQl7AEkK6FL+JGVH3YGgNk1G+0f7olRI5FcZKag2uvQPBCB7G5OOv0MXdTlarKRq++LjNlUsqy2B/d8yqyaTq9SZRGbvFNfp+GcgZoSYvaf8IH7b5Dkw6CbQ/n1tTIWxAm+tNypFJ4ZOSYIJz8KKu4U9weiHxPW28yNBvutKoOSwWNcrQpDcwK4Q0FWkclJ+EBGdqiyRZh18s4hMVGULLVLfK8VnXPyuiBoZqwQRWrxA3OffzRSTl/w94jNiRsKQW0VafL1orEv/a9pMsRA7ShCnrNMQp+JU8TkqHXSZ7Lps1P0i0nZ8hZishfSkZ7g3L81K5t6fUzjSaGvR0pS3Kf2qVSnx1asprTX/rSKTM2Gojwd+JplvDSa0KuGZ5qZR8tDkbtw1LpHtGeX0i/Jtv6fl7k+FQSpA4iQYcrMY4xrKRaSupgCOrWhO0Qf1gHkLRSQpZZFIq3lHirY9tcVQ3ejKrfMWBMsudF4kjIfIwWcef1ugpZeTxdn66JTtJQnGPSnS9+nrxPij1Ijj8QwVnxuQ4LKJZ2OK3k2t/I+sKDzf6NDdf6Z2Ky3x+++/n/XBnAqLxcK+fft45JFHnO8pFArGjx/Pjh07ztnndASPPPII9957r/N1TU0NkZHnWUOUthaO/M7dkoK7+nog2arAMNQZiYn2d+e76weLG+3jka7RiKocmPKy+FuWxaB58AcR5pftjTOehuYBuwkHFrZ9LJkbYcvr4B0lohxdJgkxYcubxlgNB74TM18ArbfQkxxfIWZVF70L3S8W/jiVmeKmnPGRiGwAoBQP6U9GiQjGxyNEhCawq4jSaNyFueCJP8QAcsVvKLSePB66l/6Wzwg7WIFCkjmkS6B7wMrW30GWhVB32zutfEYAoRkoTxdRlvbSEkUpzaRvzCMQN1r8Pf1DIQSuLxNEKmrI6VMbp8Ck9OAh2wKSZz1AUnwMeEeQk1LIndtjGRrpz49XdBFhde8IkQZpCY37+U07KZQw+UUYdAP7v3uUmMot+El1KCUZpWwCCyL61XMWJE7iYDlk/fU+M5XbCN1wNzcp57NUeUmr3XpoVfQM9yYlr5pdmRXM6ndKhNGQT2LpXyQ2PjNH2w7BOn+hw/j6QqjMZD6AUohfpRkfQ++5zdt3PeUh/jdQaark0S2Psq1wGzqljm5+3UjyT6JHQA9GhY/CR+dz+h3EjYY7DzS/1nmJKNHkV0TbltoikUb1Dm+9bcxw6HeNiAz1nn/666qlzu6K3+GLCcLZHETkQHa0jnIotTD87rb3FzMSdn3sonNqhabIa8L41uQ0sCv0mCHS1ZtfE/cWMKtfBNnl9by7Ph2AY0XNEfym6JNGpcDPXUNprdmlovN8oClSPSze36XoRqdWnn4SVrAf/nqs8YUEaX+Jf23BzU9Mzi54tDm1Nur+c3D07aNpwmKxOVr1qnOBJIlKyn5XdWi/cYEeTEwKJjH4P88q4J9Ah4iTt/e/k4ssLy/Hbre3avMSHBzM8eOtXarbw/jx40lJSaG+vp6IiAh++eUXhg4desZlLaHVatFqtXzwwQd88MEH57/FjKUefrtOaBUAJz2RFOIh3We+eG23CmGfqVpUTgV2E5qUg9/DuCfEzOG7ma4DZfIlYtC2WyFvt8hnO+xigM1YL9JHsSPFoKlxF9GEtDXinyEXUnNF+D1nG0x9XRCyLa+LGXAThtwGE58XxGzlvYK4/XK1iEA1GQpOerEFaWqEf7wICy+5Rcx0S48KorT1Ldf18naJirHooUzPfaPFCYJepMNXE2DO10KAaaqBI78L0ugkipL4jknTIaS3mPUvvlkQttfiBWGLHi78e3wajV0P/gAr7hHnK3o4jGwm0igUrq87iSbhdL1fEniLCKBTHK6QRGTqfKVVOwq/OPre+SNHi2rYUFBBXWUpFyb5EKBTgE+kM9ply67kXqsdky6Q+dYlPKL+kQBZAsaJ9ETpMUH+PEIYEissLXa2RZzC+7Gr6wMsOVxJmFTBHaolIp2w/xthkucdxQpjD8zGOrqPu5qk3q3J2bnA/pL9PLDpAUqNwubCZDdxsOwgB8sOitOi8+OZYc8wJnJM53euUIjU4ZkQOVD86wwCEuGyX8REJmqIiDI5rMIaIX2NuBd13uJh7hXa9j5ihgOSEBKXHoOg7q7LW6bp2otIjXpAEKejS4XGp/Gz7pnQhQ0nykgtMLD+RCkP/XqIBaPjXIwafRrF6KdWEJ9rrD8mfttx3TtRiVtfAb9cI85pt2ki2rn+OZGSdfMTBNc9UKRJIweJaNSZotnnGOoWBrId6RnZUSgVEp9e1YHrthHlxnJ2Fu1Eq9TiqfGkV0Av9Op/pqH7+UCHiNNXX311vo/jvGLt2rVntawt3Hbbbdx2223U1NScX0J56KdGgWekCKM3VAjyU5wq2jr0mClC7eueEaRE5w1X/i4iQu/3FxGdQz8LcpS9RYTRk2aIQbIpSgLNYmZwna2fiv7XCPFq/m4Rzt3xgai4ObkaavKb1/OOhEELRPpNkkQk5NpVsOFFoTmxNXYyTxjf/kDbe54YaMpOiDB33m6hBWmogB6zBNlZdqfwycltbP0x6kHxueYaWDhbpDU+HyuWSQox0waR6hhwLQy+pfXs3u8vQULLjgsSWJUt0nndLxaksqyRrCdOFFqOc6iTOZ2P09/pd3WuIUkSPcK86RHmDbRdEaRTK5FR8BZXMqJvPJEH3uBG6w/wZbaI2LUQsd/q35tPeMjF1NSJgEROxl7JjymC7I5MiqLPyXfFdeATBdes5M3PM8msqefn6NaTnXOB9bnreWDTA1gcFmK9Y3lt1GuolWqOlB/haMVRthZsJbsmmzvW38HYyLFMipnEmMgx/zkPhciBcP0pEZCpr3Z8ezdfYaFQdBA+HAJRw0TqPXKwSNvXFIrKLKVWRKHbQnCPZo1X1iZxfyOupUk9g0ktMCDL8NPePH7el0d0Y3smjUqBb2NT3POZqqust7C/0ZV+bEe0kVaTEFNveUOM0T5RMP0DMRm49N+ztSmoK0BCItS92fS2iSRZWjiHnwsDzI5ClmVWZq3kxV0vUmtp7s7grnZncsxkrulxDTHeMf/Y8ZwrnJXGyWazsXHjRjIyMrjsssvw9PSksLAQLy8vPDzOXeguICAApVJJSUmJy/slJSWEhLSRj/+/AlkWpcsgSqaH3ib+tlvh3b7Ch+fAdyIHvf09sWz6hyJKAjDgelj9mNBQ1JeJ9ya9IFpD/B1oPYQGKn6sKGH/fYEgTUqtCD/3v7ptMzWlGsY/BRc8JsrbDfli+9Plxv3imkt1B94gImI2U3OI2zsCvp0hHsIXviG0HSAErTeshSW3ikHaZhKkKayfEFL2urT9yE1wD7htl9AlFB+CLW8K0pna6HmiUInZ86gHOy4k7yCcPk4tiZP87xKnGksN63PXY7FbCPcIp6tfVwLczpx+dFbVWe3k9riV73cX8LB6UTPJdfMTkSebEXdPHxQS5FQ0UFJjIviUwgZ1i+9uGnwXRPlB9jbxm/tEYXWIVM/fcg5vA7IssyR9Cc/seAa7bOeCyAt4eeTLTkIU5x3HRfEXcY/9Ht7d/y7fHP2G9XnrWZ+3ngSfBH6a9hMa5T8bXThvmPqa6MWXvdV1sgJiUgKNabrT2IjEjRbEKbOZOAHoG20FRiQEoFMrWHuslJzGvppaldLZveB8puo2nSzFIUP3EE/C0n4QUfuWIm+bpTlSZGmA72Y0mkwi9EqzP2udPv+HsT53PfduvBe7bMdP50eERwRGu5EKnwbU1n6YrP2axeH/EHGqMlXx3M7nWJOzBoBY71h8tb4U1hdSXF/Mb2m/8Vf2X7w/7n36B7f2TLM6rPyR+Qc1lhquTLqy1fJ/E50mTjk5OUyePJnc3FzMZjMTJkzA09OTV155BbPZzMcff3zODk6j0dC/f3/WrVvntChwOBysW7eO22+//Zx9Tmfwj6TqsreIyhi1XnRab4JSLSpf/rgfNr8O5kYGP/R218hR38th/fOinBmEyLTfNef2GHvOEsTt6FIR6QlIPPM2SpVIxZ2uPLo9KJSuJbcRA+D2PSKNeOpnuwfA5T8LAtrU86gt4Wt7cA8Q5DDuAuG5k79HfF7sqLNy2e0ImkqsW7ZccTqHd1J8abFbuHP9neTW5hLoFoi72p16az0mu4mR4SOZ123eaQlQXk0eH6R8wJrsNVgcFuf7aoWauV3nckPyDfi7tW934dbSjsDu4GP7xah8I7m/nyR0R2H9xIrmGlRWI12/TONYUQ37cqqYmuyaMqqylAB2QEl8kCfE3yNaNTTCaUdwDons9sLtfHDwAw6VCW3QxfEX88ywZ9oUhGuUGu4feD8XxV/En9l/8vOJn0mvTmdl5kpmJrYTUf1vQ+QguGaFmPAcWyG0Vnm7RTS4KZLb7wwPtrgxQluYtUncl43XtLbRx0mvUfLJlf2Z/9lOZ79FjUqBfyNxOpfNc0/FusY03dXhBUJWgATjnxY2EpteFZPTqCGi+mzdc4I06bxh8suNVW3nv0LTareiVjaL0x2yg1pLLd5abw6WHuTBzQ9ib6zIrDRVUmlqjOAqQRdSwIsph/CiG7rwQg41hGMwP463tvMZE7vDzoHSA3T374672tUCQZZlcmpysMt2MqozeHHXi1SYKlBJKm7qfRM3JN+ASqHCITvYV7KPd/e/y8Gyg9y05iZmJszkQOkBCusK6R3Um+5+3VmRuYKi+iLcVG5cHH/xWR3v+UKnr8a77rqLAQMGkJKSgr9/8+A5c+ZMbrzxxtNs2Tbq6upIT093vs7KyuLgwYP4+fkRFRXFvffey9VXX82AAQMYNGgQb7/9NvX19c4qu38a/0iqbtcn4v/e81vPZPpeIW7mpgqN2FEit94Sbr6ikujAd+L1xOcFaTnXiBkh/v1baE+X0QRJ+nu6IEkSflJn8JTKNGSSWZ2J0WYkxD2E/sH9UUide5A7iVObqbrOHfb6vPVsKxTi97xaV5fwoxVH+fLwl8xOnM1d/e7Co0UfqFpLLQuPLuTz1M+dhCnBJ4EIjwiya7LJrslm4bGFLE5fzDsXvMPg0MEu+5ZlmRpLDXl1OSh0+dhMYRgtYjDfrr8Axp5Sqq3zBp03A6LLOVZUw95sV+K0Pnc9n2c+gjZoALbyCwnwaB3BaZpFq0+tFDoLGMwGXtr9EiszRWGBTqnj2p7XcnPvm8/4e3b160pXv654a7x5Y98bfHPkG2YkzPi/VXHkHSEqxobcLF5bTWIcctjPPBmKHCL0ljUFjRWgokpL1+i8bbY5kCSJ+yZ25ZKPReGPocHCjL7hHCuq5dIBkZisdkpqTET7n1t/tul9wtEoFYzWN4rokYUcYutbzQU32Vvgo2Hib5UOLvtZkKl/AAuPLuSNvW9wUfxFPDzoYbIMWTyw+QHyavOI8IjAYDFgtpsZFTGK10a9Rnp1OmXGMvQqPU+sXE+RYhklphxKyEHtBSdNqVz+xzHeHfsucd4dN+BssDbw4OYH2ZS/iWivaJftbQ4b92y4h435G122ifeO58WRL5Lkn+R8TyEpGBgykM8mfsYDmx5gY/5GFp1Y5Fy+tWArWwuEHbm/zp+relyF+hy02DmX6PTTdMuWLWzfvh2NxnUQi4mJoaCgoNMHsHfvXi64oNnptqly7eqrr+brr79m7ty5lJWV8eSTT1JcXEyfPn34888/WwnG/ymc94hTdW5zO4hBC1ovV7sJ/dCaJ4Seac7XbZOiobcJfU7COGF4+D+cF+TV5jFn2RysDqvzvTD3MK7teS3zus07zZauaKvliuMsU3VL00WV06zEWQwNG4rRasRT44nRZuTnEz9zsOwgi04sYlP+Jhb0WoBDdnC04ih/ZP2BsVGDNiR0CHf1u4se/s29uHYU7uCtfW9xrPIYd6y/gw/GfUC8Tzyb8zezq2gXu4t3U9ogZu/usWCtSaa8vn0fpyYMiPHlu5057Mtx1TnZZTsWuQGN/2bU1jgkaWqrbZtaupzOOdxqt/J72u94aDxI9E0k25DN6pzVGMwGJkRPoH9wfzbnb+b7Y99T0lCCQlIwv9t8bki+oUOpyZaY3WU2Hx/6mAxDBlsLtjIifAQ2h80lWvB/BmpdszzgTNDohS4qewtkbWwmTo3apabGvgNj/HBTKzFa7fx+oID4IA9m9wvny21ZrD1aQrdQL367Zdg5/RoTkoKZkBQMP70h3ogaKiJqpmphwzHuCRFpO7lKpCbnfPmPkaaUshRe3/s6dtnO4vTF7C7eTUlDCTaH8DXLrxP60h7+PXht1Gvo1Xp6BTZX2AYhkZ7RhVmjc8mqrORwnp2AsF3k1ORwxcoreHTIo1wYe+FpCb5DdpBenc7jWx/nWKXwCGva/rnhzzE2aizv7n+XjfkbUUkqPDQeKCUlFydczG19bkOrbNsZXKfS8eYFb/L+gfcpayhjWPgwYr1i2VO8h6OVR+kX1I8ZCTPQqc7gS/gvoNPEyeFwtEka8vPz8fTsfK+ZMWPGILd4WLSF22+//V9LzZ2K8x5x0ngIn5eKDOHR0haG3CqiSnGj228TEdQdHshobJT43zPrdciOTkdr/i5OVp3kkS2PoFVqCfMII8Yrhu5+3enq15Vwj/DTDiq/nfwNq8NKkFsQcT5xHCk/QmF9IS/seoFE38Q2c/dtoamRr73ZzuasUnVlDWVsLxQalOt6Xke0V7TL8oviL2Jn0U6e3v40BXUFPLPDNVoZ5x3HLX1uYVL0pFbfe2jYUPoF9+OuDXexrWAbN625CbtsxyE7XNYLcAugrKEKtVcq32Y/gqS8BI2qfQLSv9EN/EhhDUaL3ZnqmxA9gQjFJPIdfyEFLSKv9lIiPV0tQJwRp9NonD5K+YjPUj9rc9nOop0ur6O9onlhxAv0DuxYT7lT4anxZE7iHL45+g0v7HoBh+yg0lTJY4Mf+0dTd5vzN3O88jjX9LimU1qr+h07KHn5FbymXUjAWWQQTovY0YI4ZW5y6i2bzBNNLVpMeepUGK12tmdUMPPD7S67KKkx0WCxodechwh6YaNdxAWPCt1m3k7od7WI+ve9Qmi8lBqRumwDFruFHYU7yK/LJ9Q9lBjvmE5FdE5FraWWhzY/hF22MyR0CJnVmRTUieDEuKhxPDjwQbIMWWTXZDMtblqbBQkalQIceob6X4pkqORAZT6XDLiEg+Z3OFB6gEe2PMLitMVc0vUSAt0CSfBJcKbE6ix1PLvzWbYWbHUKu/10fjw3/Dm+SP2C/aX7uXvj3cR6x5JlEMasL416ickxHbcBUSvU3NP/Hpf3egT0OKvz9U+i01ffxIkTefvtt/n0UyFeliSJuro6nnrqKaZObT0j/B86Cb2fKIE/HZSqM2sKQMzy/gFUGCtYmrGUMZFjzjhQlNSXsPDYQuK84xgfPR5PjSDb2YZs3tj7BjuKdjC361xu6X2LSxrpfOLNvW9ysko4faeWp7os81B70DuoNy+PeLmVV4/VbmVxumin8ujgRxkXPQ6TzcST255kVfYqvjv6XYeJU9Nz/+9W1a3IXIFDdtAnsE8r0tSEIaFD+P3i3/n40MeklKbgrfUmSB/E5JjJ9A/uf1qiqFVqeeeCd7hz/Z1OgtbdrzsjwkcwOHQwyQHJ6NV6kl/6EDn4a0rMJ9BFLESlfKLdfYb7uBHqraPIYOJgXrVLuyCP+unY5eMo9Tncv+l+vp/6vYvWqLnlSttku6S+hO+OipR1N79u5Nbk4qvzZWL0RHx1vizLWEZGdQb9g/szJXYKF8VfhJvq75mIXpF0Bd8f+975kAN4cvuTZBmyuLPfnc7jt9fVIykVKNxcP6/eWs8XqV/go/VhWNgw4n3iO5Xy+/H4j7y460VATApeHfVqhycjdVu3Yj5xAktS0plX7iziRsOG5wV5anTqb4o4ma2tJ+NeOhWeOjVebmqGxfszrVcofSJ9zk/6s66ssfm1JCoAdV4Q5ZqKbk+W4JAdvL3/bX49+atL5RjA3K5zeXTwoygkBZnVmWQZsugX3A9fnS+Z1Zn8cvIXVAoVd/a70yUdZbabeXTLoxTUFRDuEc6bY97E5rDx6aFPSfBJYFbiLCRJIswjjOHh7biV03xfWO2yc5Lho/Hji9Ff8PWRr/nk0CfsLt7N7mLRAsZN5cYrI19hePhw7t54N7uKhAhep9TRP7g/jw95nAjPCIaEDuGDgx/w4/EfnaTpup7XdYo0/Tej08TpjTfeYNKkSSQlJWEymbjssstIS0sjICCAH3/88Xwc438U/jEfp38AZruZPzL/oH9wf6K8os5qHwV1Bdy4+kbyavP44MAH3N73dmYlzkIpKXFXu7sMcuty1/HU9qcwmIU31fM7nyfWOxadSseRiiPO8PO3R79lZeZKxkSOIdQ9lAEhAzpMQDqL1LJUthVuQykpeXb4s1SbqkmvTud45XHSq9Ops9axrWAbv6b9yg3JrlWJG/I2UGmqJMAtgFGRohu4TqXjpt43sSp7Fetz15NXm4eH2oPD5Yfxd/Mn1D0UH23rwf+0qbp2HhSlDaVkGbLw0njhq/Ml0C2QZRnLAJieMP2031uv1nNv/7PzndIqtbw39j22Fmx1RuVOhc7RhYrsW/CKfx/02dRJqUDbM3VJkugf7cuKQ0Xsy6l0IU6lNTaMNZfhGf8ORyuOsuj4Iq5IugIQmiqro7HJbzsRpw9TPsRkN9E3qC/fTP6m1Xm/psc12GV755zAz4AQ9xCeG/EcqWWpDA0bypGKI3yc8jFfHfmKJelLGBs1lhvjr6B+1jUARLz7Dvr+4vq2OWzct+k+thU0G7R6qD0I9RDXTbW5mhpzDYm+iQwLG8a4qHGEeYQ5z8eXh7/k7f1vO7f9K/svgvRBPDjwwQ4de/12oS9yH3Zu02GAKArQeIqCjeJDENbHKQ43t4g4Nf39+63DSAjqfBbjrNAUbQpIbO0tdwasz13PV4eFZU+gWyA9A3pS0lDCsYpj/HTiJ2ottXhqPPnl5C84ZAcSEtFe0WTXZDv3YbFbeGSwMHo2mA3cuf5O9pfuR6VQ8cqoV5wTzIcGPdSpY9M4iVOzHYFapUCtVHNjrxuZEjuFz1M/J8uQRUFdASUNJdy98W56+PcgtTwVN5Ubb1/wNgNDBjqJnSU3F1VwMPf0v4dre1zLLyd/weawsaBXG9KS/6Po9GgRERFBSkoKixYt4tChQ9TV1XH99ddz+eWX4+b292Zq/w34x3yczjNkWebxrY/zZ/afuKnceHbYs0yO7dxsIdOQyYLVCyhpKEGn1GGym3hz35u8ue9NAMI9wrlvwH0kByTz1r63+CNLaLe6+HbB7rCTYcjgRNUJ5/5Gho9kSuwUPj30Kdk12fyW9ptz2cXxF/PgwAfPeWXFJ4eEEH9a3DQujncVgVsdVn489iOv7X2NpelLub7n9S4P3l9P/grAzISZLrPFeJ94hocPZ1vBNp7Z/gzHq447ySKI2VuEZwQjwkcwKGQQqeWp5Gu2oPaNwWpv1ic0pe0ULSJOsixztPIoC48uZNPxVSisNgzuYrlKocLmsKFVapkU046nzjmCRqlhbNTYdpfrNUrKaoMIU0wgz7GSPPl3HPK1KCQFsixT2lBKWnUaSknJ0LChDGgkTntzqrDYHJwsqaVbiCfFNSZkmzfudRdT57WI9w++z8SYiQTpg7A7ZJp4Zsuqut1Fu0ktT0WlULEkfQkA9/a/t81IhSRJqKTODYO2ykrMaem49UpuFS1qwrS4aUyLE5WuYyLHEOsVyyt7XqHSVMlvab/hWLuF+RWiR1/ONdcS/MjDeE2ewksn3mdbgXAn7xvUl/2l+6mz1pFWleay/5KGErYWbOWtfW9xV7+7mJEwgxd2vsCq7FUALOi1gDjvOB7e8jDfHf0Ok83EHX3vwFfXflWoraIC8zGhYXEfdh58sZQqEbU5uUq0fZr0Ijo3QaZbRpyaDTD/wX6ChfvF/2F9O73piswVAMzrOo+HBz2MsrHKblXWKh7d8qhz3AOI9IwkrzaP7JpsIZIOHsiu4l38cPwH4n3i0av1fHjwQ/Jq8/BUe/LWBW+dddoYXA0wmyJO2hbR2QjPCJ4e9jQgSPtzO5/j97Tfxf0jqXh7zNsMC2sm0ZXfLaTkhRdQeHvjffHFeF98ETf0vB5JoUC225EtFiTN/xEbjtPgrKZZKpWKK6644lwfy//wD+Lz1M/5M/tPAIw2Iw9sfoAPUz6k0lRJoFsgr4x6hS6+XVy2sTqsKFCgVCg5VnGMm9feTKWpkjjvOD6d8CnbC7fz5r43qTZXAyIade/Ge1FICudM6+oeV3NnX5GuyDRkUlxfjNFmJFAf6BwgJsdMZm3uWrIN2WQaMvkr+y+WZSxje+F2fpj6A6EeZ6im6yCOVhxlU/4mFJKCG3u11nOoFWpmJc7ivQPvkV2TTWp5qlN4mWXIYkfRDiQkZiW2bkl0Vfer2FawjV3FItQdrA/GLtspN5ZjsptIr04nvTqdr498LTZQgi7kMB+npdEj+mUSfBNwyDKDio9y4RdfcmK1J/nqOva7lZDiUUnvTJkPDspIksSLt/iT5l7njNhNjZ3qnKH+W2gyLPQ3XkCuai31ylx+OPYDBXUFrMxcSZVZGA4OCB4giFOMqH7ck1XJpLc3k1VeT2KQhzP6oDUPIS7gKIfKD/H6ntd5dfSr2FqkNdUqBaUNpbyy+xVW56x2OZbxUePpE9Tnb3+n2vXrKX39DSyZmQB4jBtH5Afvd2jbqXFTmRgzkT3Fe7hn4z3E7C8CQOnvj72igpJnn6Pk2ecY5gd7L1Zx52UvMy5qHGa7mYK6Aorqiqix1OCt9Uav0pNSlsLanLUcLDvI63tf570D72G2m1FKSu7tfy9X9RCtM8qN5by+93V+OfkLf2atYn7oRSRYfYn1jafrgAkuZLJ+h9B7abt3R+Xfjnby72L0A8JEt/wkfD+HyORrgQkuGqeWLVf+MRQ0Ead+ndrMYDawOV+0o7mk6yVO0gQwJXYKepWeBzc/SJhHGI8OfpSBIQMpqS8htTyV7v7dCfcI55OUT3j/4Ps8t/M557Yh7iF8OO5DEn07YPNyGrgYYJ6hAlWlUPH00KeJ8Ijgl5O/cG//exkW3kyaTEePUvqqME91GAxUffcdVd99h9LXF1VoCJaMTJBl/BcsIOCmBZiOn6D8gw9QhYYQ8uST/6cqTM+KOKWlpbFhwwZKS0txOFyFoU8++eQ5ObD/X1FrqWXhsYXk1eTx4sgXz/n+TTYTPxz/gXcPvAvA44Mfp6ShhM9SP3Pmqg1mAwtWL+CbKd8gIbEicwW7inaRWp6KTqVjWNgwthdsp9ZaS5J/Eh+P/xhfnS8zE2cyI2EGNtmGyWbi26Pf8tXhrzDbzfQP7s+DAx90KUuN94kn3qd1GbNaqWZKbHPj58u7X86jWx8lrzaPJelLuKXPLX/rHMiyzLrcdby+93VAEI329EAeGg/GRY9jZeZKlmUso1dgL2RZ5pU9rwAwOmI0EZ4RrbYbGjaU3oG9OVR2iOuTr+fW3reiVqqx2C2U1JdwrPIYa3LWcKjsEEn+SaRmu1EsryG/4QSXrLiEBb0WUGXuwYKjPxFSU48jG8IQ/6a5fJLMe9UXEnDTA5Q0lFBhrKCLX5dWx/NPwVpSStXChTzy6wo8aivR28wsTo7lx2l5znMGoJSUxHjFEOsdC0C3EE/0GiX1FjtZ5cJZPK20uXGwLCt4fMjjzFs5j1XZqxgdOZpRYROblrI6ZyWv732FWmstSknJ2KixzkrHjqapToeaP/+i4L77oClFL0nUrVtH3ZYteIwc2aF9qBQqhoYNZXbURfTNED0h/d55ja8XPkDfXRWEVUFYJTyQ24MRUeMAkRaN845rpR3sE9SHq5Ku4te0X3ltz2sYbUbCPcJ5ZdQr9A7sTfXvizEsXszI2loGVPtgMlSiNVWjlL9rPGOwY/JAhr75NVJjtK5+u9CsnatoU7mxnFf3vIq3xpseAT1QSkoOlR2iuO9ERtfXMS1lBd6HvyGQAdRbRfGAze6giQ9r/yniJMvNEafwzhGn1TmrsTqsdPHt0mqiCTA6cjSb521Go9A4iUOwezDB7s1V4Qt6LSCtOo2/sv/CT+fHFd2vYG63uXhpOpcybAvqpia/Ntk5CdEo24/kSZLEjb1ubDWRdDQ0UHDf/chWKx5jx+I7fz7Vv/1G/ZYt2KuqsFdVOdctf/99DIsXY21RZe8zZw5uPf7zRd8dRaeJ02effcYtt9xCQEAAISEhLixSkqT/88TpfGucKk2VfJzyMQ7ZweXdLz8nFQZ7ivewtWArVaYqthRsodxYDsD8bvOZ2020WZkSO4XShlJ8dD48ue1JTlad5NLll9Jga3DZl9Vi5a9s0cKhX1A/3h/3vkt0Q5Ik1JIatUbNbX1uY3bibArrCukb1PesZxx9gvpwTY9reG7nc+wu3s0tnB1xKq4vZm3OWv7I+sMpAg/WB3Nbn9tOu93FcRezMnMlq7JW8eDAB9lWsI1tBdtQKVTcN+C+NreRJIlPJ3yK0WZ0MYvUKDVEekUS6RXJxJiJzvev/nI3GZnJ9O+3nhO1O/nw4IfEFsnMrrFjVsHC8Sp6SuH0MHjiU2BAGx6JW9++lH/wAdVLlhB4z92EeYQ59S7/BkrffpuKL74Eq5WWjSsGZxr4XfLBLFfTP7g/NyTfwMCQgS5lyiqlgtn9Ivh5bx7XDI9h/sAoPtyYzs97Rbm1zS7T3b871/W8js9TP+eJbU/wxkh/FJoSNEF/8dSOowD09O/JU8OeoptfOxWpZ4GaNWucpMl7+sUEP/II5R9/QuXXX1Py4ku4Lx3cqfTEJdWJGK1Q7gnPl7zHob4G/hgWyh3mEXR74ReCDxchy/IZ7xdJkrikyyUMCR3CjsIdTImdgqfGE0tODkVPPQVWQRwVQMsykXoPFW51Nnz/3EOe/lEin38RJIn6bUJXdbb6pmpTNTWWGqdectHxRazKEqlDTriuuxF4JzqK3sYGAu1fUOeI4nhlDFEeCc51/rGIU02B6LAgKSEkuVObrsgQabqmtGxbaK8cvwmSJPHKyFe4vPvldPfrfk7L71tqnDpSgdoeSt94E0tWFqqgIEJfeB6Vry8eI0cgW60YDx7EXlODNiEBY+phip991kmalAEB2MvLqVm2/KyIk8NiQW5oQOnj0+ltzyc6TZyef/55XnjhBR56qHMitf8rON8ap2ivaKbFTWNZxjI+TPmQD8Z98Lf2tyV/C7etuw2Z5rRGmHsYN/a60SXFlOib6AwLfzLhE67981qya7KRkBgePpzxUePpH9yfKnMVm/I2YZft3Nrn1jNWIIW4hxDi/vfb4wwKEVqIlLIUTDZTpweXxWmLne0zQAxm1/S4hut6XnfGvmKDQwcTpA+itKGUO9bfQaZBpGrO1GdJr9Z3uGeZUiEh27y4JOIJvAKP8NKulxhxVGhgMrrF8djLC1vpU2S7HcOSJVgLCqhZ9Sc+M2d06LPOB+p37abiY6EXcxvQn58jhrK53M5rWz8iqKGaCR4fcO0FYW3Oypvw7PQePDu92Tfq1Tm9mdU3gnmf7XQO+nf0vYOcmhzW5Kzh/i234x5vBkCDkg+WBhLiriKsjyeco37IstVK8dPPNJKm6YS++AKSUknAbbdiWL4cS1YWFV9/Q8CCtkv3ZasVu8GAKqDZjkGz9QBGYHdXiUPlqWgUGt4b+x7dPRM4+cZybKWlmE+moevaschhpGckkV2bbRpKXnsNrFb0gwbhf+ONKD09UHh6ovDwROnrg0Ol4LlnJnDpz8XU/76UIruM37XXYispQdJonEL1zmBJ+hKe2v4Uo8JH8d440QZqT/EeAIaHDcdsN2OX7fQM6Im3xpvF6YspqCtgk94NKEdFOSX1ZQRrmyNrmnPQjLZDaErTBSU5G1V3aLO6AvaX7kdCYmrs36soVyqU9A3qvL7qTHBp8nuWvepkqxXDUuENF/r8c6h8m8chSa1GP7C5+bQmOhr9wAFU//orHsOHY6usIv/WWzH8sZKgB+4HpRLj/v3oundHoT/92GhOS6Pg/gdQBQYS+eknzsjofwI6TZyqqqq45JLz04X8fxBY0GsBKzNXsjl/M6llqYR7hpNWlcbAkIGd8jjKqcnhoc0PISMzPGw4/YP7E+kZybiocaiVakzHj1P61lvIJjNKb2/chw7BZ+5cAtwC+GbKN2zI3cDQsKEuUYwYYs7LDX4mRHtFE+QWRKmxlJSyFAaHDuan4z+RXp3OnC5z6OrXtd1tN+dvdpKmXoG9mBIzxSkw7giUCiVzEufwYcqHzhL8YH0wNyafO5+bJq8mByL6Ny5yLKlvXQBUUdl/TpuiXkmpxGfuXMrefJOqRT+6EKe6zZuRHQ48hg9HUnfOfLFh/wGKHn0UdXQUvvPn4zFyJNJpwvuyw+HUPvjMm0vo00+T+8N+jqQUYFGo0DhshNTLpyVNQJsRlqZeZc2eVgpeHPEiJQ0lHCo7hCxLOOp78P2Aq5Ffugcj+WTPnk3QQw+h9PFB0mrQDxiAQnv6WX97qN+xA3tFBUp/f0Kff855HpSengTdczdFjz9B2ZtvIlssBNx2q/M7OCwWDL8vpvzTT7AVFhFw6y0E3H472O3UbtgAwK6u4l5+athTzsiyfvAg6jdtpn7rlg4TJ2tJKcZDKej79sWcnk7d2nWgVBLy5BNoExJara8Axt34DO8Zb+GO5Q4MS5dRu3GT+PwB/VHoOh/x6O7XHYfsYGfRTqeJ6qFy4cT92ODHiPRy9d+6IfkGduaspXjxjZhlOx86phLmHu3U4SgVEiqlQng+rX5cNPYefpdoO3WOYdq9DkueDoc9CMe33+I+fDja+DO3hfr+2PcADAod5JJ6+09CE0ky2xzt9qo7U3Sz4cABHHV1KH19cR9x5k4R6uBgAm8TUXzZYkHp44O9rJz6nbuo37KZym++RRMbS+RHH6KJiWm1vWyzUbXoJ0pfew3ZbMZWWoq1oABNZGSrdf8tdJo4XXLJJaxevZqbb775fBzP/4AgCRfGXciyjGU8vOVhyoxlGG1Gruh+xRnLUY9VHOODgx9gk21kVGdQa62lT2Af3h37LpYde6hftQ3rxGAsZgv5t9+Oo65ZR1K7ejW16zcQ9srL+Pn5MbvL7PP9VTsMSZIYGDqQlZkr2V28myB9EM/veh6ARScWMSJ8BM8Me8ZJhmosNRwuO0xObQ5v7XsLu2zn4viLeX7482eVMryp900MCh3E4fLDZBmymJk4s8PRpI6gaXLdRBCs+1PQG6qoU+ko696+7sJn9izK3nsPU8oh6nfvxn3QICq//ZaSF18S+/Xzw2vahfjMmIG2e/czfvf6nTvJu/U25IYGLNnZ1G/ajH7AAKK+/KLddFTNypWYjhxB4e5O4B13AKKqTpYUFOv9iKorxbuytLOnRBy/onnG3ASdSsdH4z9iYeoSXlvqQE8IIQVGihqX2w0Gih591Lm+wtMTrylT8F9wI5qI1nq008GwbDkAXlOmtCKg3rNnY87KovKLLyl//31q16xB27UL9soqGvbvR25oTnOXf/gRDfv2Y6sox2EwoPTzY+asW5mncXOp5vQYPoL6TZup27oV/+uvb/OYZFlGtlpx1NVRtXAhFV9+hWwygUqF0l20I/GdN69N0tSEkeEjWTh+OC+5beP+ZQq0BlH1ebZpui6+XQhxD6G4vphdRbvQKDXYHDZC3UPb1AAqFUqGx05CjhiDdHQpDbZafDXBNJgbheFKBVTlwM9XCQfv4kNwZAlMf++sKt9Oh4qVu6lJ9QOOAcfQdu1K3NIlp93mcPlhfju4kMmHHFwaGUh5zmco3PQovb3Q9eiBNu7sjS9Pha2qCtPhI+gHD0LRyYo1dRt2BBpJCL3rtm6jfutWjCkpuPXqRejzz6GJbq31rN8sxO/uI0ecMepzKgmTNBq8pk6l6ocfKHn5JSzpGQBYsrLImjsPj+HDMGdnIylVuCX3RNJoMaxcgb2svPEzRxL24guoAgM79b3PNzpNnBISEnjiiSfYuXMnycnJqE8ZTO68885zdnD/ifinfJxu6nUTKzNXklub63xv4bGFJPkncVH8Ra3WNyxdisNk5l3fdWwtanbbDXIL4s0xbyJVVFNw5504Ghqo/Oor53L9gAH4zJuHJTeHik8+pX7LFjImTUbXswe6rt1w69MHff9+5+zCtdfUUL9zJ/r+/TtduTMoZBArM1eyp3iPs4llgFsAlaZKthZs5YFND/DlpC/Jr8vnqlVXNTe6BIaGDuXpoU+ftc5KISnoH9z/nPlJOYxGZym7JTeXycs+waBPwCGLyEPNSlHCvC2s12n1Myp/f7ymTKZm2XLybrgRr4svwvCrsHFQeHlhr6yk6tvvqPr2O7SJibj16YMmJgavyZNQh7v6L9Xv3EXeTTcjm824DxuGtmtXqn/6iYa9eyl59TVCHn/MZX1ZlmnYvYfSN98CwOeGm6i16vCRZWdVXZG7P1F1pXhWlpzVeWpKNbQ0BgXw0ngxMXImr1o2o9YrMDWW0fvMn4dCr6dhx05QqbCVlmIrLqb655+pXbuWyM8+RRMZSdnb79Bw4AAqf39UAQEo9HoUXp74zJzpfHg46uupXbcOAO+LWmtYJEki+IEH0MTEUPzMs5hPnMB8olnMowoKwv+GG1Do3Sh+9jkadokKS0mnI+iBB5jfY0arfbqPFDN64959OBoaWqUzatdvoOixx1zEuACq4GBsJSXYDQYUXl4E3H563Z4kSdzd/27mFu3g0auVvPNnOPaCQjzHjz/tdqfb35iIMSw6sYiNeRvx0foAMDBk4GnvOan3fDi6lOnKbUhHfkcl6UiQSqlThTaTpsBuUFcKJanw5WS4O1U0GD9H0I67Bjf+QuHhRf2OXZjT0nBYLO2SFIvdwhPbnmDKbjtztziAJZS1XEGhIPKjD/EYPbrTx2ItKqLklVexV1SgDgvDVlUpvLVsNvSDBhHx4YcoPQQ5li0WrEVFmE6cEIUK27ejjYsn+KEH0SUlITsc+OWlc2PqMiZsPMrFJjNVaj36TVayqlzbGzXs2UPmjJn433A92vgENLEx6LqKKH7d5i0AeIxy/T7FWQbqKs0o1QoqC+vI2F9GeV4tSrUCnbua/lNi6DkqHO+LL6Lqhx+cpMnnkjmYT6ZhTEmh5o9Vzv2ZUpvNh5W+vgTceiu+V1z+H1mNJ8ln6ndyCmJjY9vfmSSR2Viq+38dTRong8GAl9ffr35oC98c+YatBVuZ120eR8qP8FnqZ2iVWr6d8q1LdZq9poaMiZOwV1eTGyjx9XiJaZc+il6lZ1TEKPzd/Cl8+BEMS5agCgrCXlODbDLhOWECYa+/5kxjmE6epOCee7FkZLQ6Fo+xYwl57FHU4eFYcnKw5OYiqdUoff1Om1Io/+wzalb+gTosDEmpFCkksxmljw8hzz2LOiiIiq++xpqbizo6Cl3XbvjOn4eyDf1YXm0eU3+fikpSoZAUWBwWvpn8DV4aL65YdQX11nqu7XEtG/I2kF2TTZBbEN38u9HVtyvXJ1/v7OZtLSykYd9+LHm5yGYLnhMm4Nbzn6n4kO12ip58EsPvi/GZNxef2XPIv+UWbGVlOJDInb+AwbF+lL72OrLVyiPDb2LoJZN5aHL7Ymd7TQ2FDz9C3fr1zvf8rr6aoAfup27rVgxLllK3bh2ytbmfntLHh7iVK5zk1ZyVRfa8+TgMBjwuuIDwd95GodFQu2ED+bfcCkD422/hNVl4fZkzs8i//XYacgo53nU+Br+umFWiSOD610fy9pYMPt6UwU2HljAjcyu5E2Yy6b3mKlF7TQ31u3ah6979tFGggmojw19ej0al4OTzU1yWHSuqYco7Wwjw0PLr8a8x7t1H6Msv4TNjRvP5djho2L2HkldfwXz0GAoPDxR6PbbStiNgkl5P8CMP4zNnDjUrVlD4wIOoo6KI/+vP0w7g1sJCjKmHsWRno9Dr0Q8aiDYx0TlDN6amUvntd+gHDMBr6hSU7bSnkmWZjPETsBYUEPHxR3iOGeNcVrdtG/k33+LyO2piYwm8+248J07AkplJ7dp16AcORN/vzFEZWZa5aMlF5NTk8MbwVxnrP8RFv9JZbCvYxs1rbybQLZAQ9xBSy1N5fvjzTE+YjiUnB3tNDbqePV3Po91K5XNx+FHjsi87CpQ4wM0PbtosGuv++RD4xorececBsixzcuAgHHV1xC5bSl2kH7+c+IU1uWuI9ozmoviL0Cg1/HTiJzbmbeSpnxX0yLCgHzQIdXg4joYGLLm5mI8dQ+njQ+ySxahDOq7vbNi/n/w778JeXt56oUoFNhu63r3wmjKFmpV/YDpyRDiwnwqFArfevQUBbJFRaAlJr8d98GDchw9H1yOJsnfepWGna/uhwHvvxfuiaaRfMBYUChK3bUXl60t5fh3bf08n72hlm/tuidHzu9BjVDgZkyZjzc1Fl5xMzPcLkWWZ6l9/RTYa0cTGIlssGA+lYq+qwnP8ODxGjTqvflB/9/ndaeL0Pwj8E8SpJRyygzvW38Hm/M0k+Sfx44U/OvVOstVK1Y8/UvDuW6jqTAD4XnYZIU+KAcaYkkL2XNFwNuanRWji4oSBX5/erUKvss2G6dhxzCdPYDpyhIb9B8QsWpaR3NxQBwVhyclx2Sb8nXfwmjSRU2HJySFj6oXNJdyNUHh4tHtDg5g9h730Yqu0gSzLTPptEkX1IinTK6AXC6cuRJIklmcs59GtzemZYH0wi6YtatWktXb9egruvgfZYnF5X5vUnZDHHmtXGFu7bh1VPy5C5e+Htnt3fObMQenRsZYwDrMZS1YWSk9Pyt59F8PSZa3WMbl5oDO6npO85CHcHDeL28Z14b6J7Wu4QBCEyi+/pOyDD/GZOYPgJ55weUDZDQbqtmzFkpmBYeVKrDm5eF10EeGvvYrdYCB77jws2dm49e5N1LffuGiCSt94g4rPPkfh7k7CurUofXzIv+NOates4UTSlRQENTc8VWuVzH6wP98fL+LNNSe5OGMLt6QupaLvUEb8+KVzvbotW8m78UY0sbHEr2o2CDwVJTUmBr+4DoUEmS9d6LLsUH41F7+/jTAvDV/99giO+npily5tk8jb6+rIv+VWGvYIwbImOpqA229HtliwVVQgm4zU796Nce8+ADFjt1owp6UTcOutBN55x2nP/7lE0dNPU73oJ7znzCbseZGOrt+5k7ybbxETnokTCX3uWRGxVKv/1oz8zb1v8tWRr7gw7kJeHvny3zpui93CyEUjXSpx/5qxCu0vf1L6zrtgtaKOjMR7+nT8b7jeqaW677mXmGr5iyEROiRLLXJ5Gu6SWVS5XfErxLcwWm1s1XI+sDxjOSx4hIQCOx/NcWdrV4dL824XyDKL3tegqDMS89uvzooxh8VCzrz5mI4exa1fP6K//QZJdebETt2mTeTdfgdYrWi7dsX/umuxFpeAJOE5fjyO+jrybrgRu8Hgsp2k06GJjMB92HDcRwzHsHgJNX803092rY4tAd2oGzGWzdVKlHU1vHbZABJGDnIhJrLDQfWvv1K/bTvW4iJMKYdApcL30ksp+WUpDX0mYpl6NQUnqqgqFr+vQikRHOOF3S7j5qEmtncAkd39kGU4srmAA2tEtmTk3C5Ey2nULllC8EMPtop0/xv4u8/v89Ap8X84H1BICp4Z9gwXLb6IoxVHWZq+1Nk0VFKr8bvqKh5wW0nS0lSmHJDQDxJVaLLDQfELYqbvPWMGbr2FyWR7M1JJJXLNbsk9YbbQOJnT0yl6+mmMe/cJ0qRWo42Lw15bg62wiMpvv22TOJV//AnY7egHDsRzymQcBgPuI0eh65JI2XvvUfH5F6BS4X3RRXiMGY01L5/qn3/GkpND7nXX43XRRfjfcIPzQShJEgNDBjrbilzd42rnQ2Na3DS2Fmzlj6w/0Cl1vDv23VakqXrJEooeexzsdrRdu6JLSsJhNFK3bh3mo8fIveFGor74HLdevTAsXYa1pBj3oUNp2LuXsjfebN7R0mXUrl5D9MLvWhFPh9lMxeef46irJ/Duu0CWyb36GowpKc0rKZUE3HIL1b/+iq24GF1SEt9MuwuWL+bqY38i6XQEP/Qg3+t64NiV16Emv5JCgf8NN+B37bWYjHayUspRqRWExHuj0alQenvjPU0QD48LLiB77jxqli9HGx9P9eLfsebkogoNJeKD91sJqQPvuou6TZsxnzxJ9W+/4T19OrUbNlDlk+gkTZNu7ElEV1+07iokScItozlVB6Ard03VmU8cB0Db9fSEUOVsRQMOh+ziom5t7FMX0lCFo74eSaNBG9d2RFzp4UHk559R9vY7KNzdXR7cTQhwOKj86mvK3n4b09Gjzve92kjTnU94jhtH9aKfMPz6GwqNBqWvH+UffQQOB/LoqeyNvozg9eX0nRiFTvP30hhjo8by1ZGv2Jy3GavD6uKA31lolBqGhw9nTc4aAHraQrDe8RiG3aIPGmo11rw8yt9/H2txkZMU7tEO4bf6Xvw+ZRhmq4PLPtvOSP9avr1+KPid8nueB9JksVt4Zfcr/HzyZ27xd5BQAP7FRqyJCnoF9GJOlzlkGjL5I+sPZFlmXNQ4pmn6o6i7B0mjQdelmagbUyrxvfYZSp69HuP+/eRecy0hzz2L9jSZGntdPUVPPAlWK54TxhP28ssoGrVqLRH17bcU3HcvSg9PvKZNw3P8OFTBwS7E2WPkSPyuuhJzRga6pCR+q9LyyrJjTIwPJj2tHKNbMLq+/VpFcySFAt9LL8X30kuRZZmCO++kav1W1h/2o2q4KPxgU6MvkwQJ/YIYMiMO78C2dZ5DZ8Vjtzk4tCGfLT+dJCVAR++Z9xMacm7Mi/9tdJo42e12vv76a9atW9emAeb6FumC/+HcIsAtgJt738zre1/n7f1vuzTJzavJY3fDUfZOVHPF09/hGS/8SMwnT2I+cQKFXk/gvfecbvftQpuQQPR331G/dSsOkwn3oUNRenhgLS0l/YKxGPftw5yWhjax2eXWkpODYZkgOEEP3I9br14u+wy67z585sxBode76Kd858+j5LXXqP5xETXLl1OzfDmeE8YT/PjjqIODGRI6hGUZywj3CGdco0kgNHqIDX2SaK9ohoUNc6YyG/bto+LzLzAdPYqtRDy8vWfOJPS5Z50zQVtVFYX3P0D9tm3kLbgJVXCwM11Z/u57zs/wuWQOqpAQKr74EuP+/RiWLsN7xnQxSysqRKFzo+LTT6jOq8Sk8xfn3dtLkCa1GglQuLsT8vTTeE2ehN9VV1K/fTvuI0Zi/SOd37qOp+eMScyd2Bt1aCj230XO/0xNfmsrTRzeVEB1aQNVxQ1UFdU3nxeFRGCUJ0NmxBHZTdTouyUn43flFVR+8y1lb78NiChf5McfuZTNO/ehUuF39VUUPfY4VT/8iGyzY3dInEi+FoAeo8JJ6O+qOXHTNBEnsT9dmas3kemEaKqs63YG4tSiJN3mkNG0OBe2RsF4bJXwetImJp62glCh1RL8UPtmmJJCgf/11+E9cwY1q1ZRu3oNuqSk0z70zgVO7Cwi/3gVA6fF4hXghvuIEQTedSdl77xL1Q/N/T+9p1/M3tC5FByvpiDNwOHNBXQfHkpwjBeBkZ54B7ohdaIhNEByQDL+On8qTBXsLd7L0LC/Z345JnKMkzjN26ejYfduJL2ekEcfwWvqVAwrVlD85FMYfvsd37lzcUtORtfYr85ktWO1y8goKNdEtiZN5wGyLHPz2pvZU7wHCYnI5KFwaDvzdCO4asbDToNWwMWzzbB8OYWArnt35zVnr7NQvTIT2WRHM+U19pU1YDLXo31yE+ExWxl491TUbeg6y997D1tpKeqoKMJef73dClBd1y7Er1hxxu/k1qcPbn36AKDemwc0isPbqao7FZIkEfLkk6Tkv0+VX3cAfP1URPQOIaKLL2FdfNC5n55gS5LEiEsT0XtrOLAml5pyE1t+SiN9bykTb+iBh++586r6N9Bp4nTXXXfx9ddfc+GFF9Lz1Hz1/3DecVm3y/j15K9k12Rz14a7uLPvnXT168qvaaJv2uCQwQQnNJMUXbduxP+xEtOJE6iDzl5QKUlSK4dkdVAQnmPHUrtmDVU//Uzwo49Qv2UL1tJSalavRrbb8Rg9qhVpakJbFRwKvZ7Qp57CZ/YcKj7/XFT6rVlL/c5dBD/yCJOnT6PSVMmQ0CHYC4uxmYzO6iF3tTu39rnVuS/Z4aDw4Uew5uU17lyB/3XXEnjvvS6RIpWvLxHvv0fejQto2LsXS10dSh8f9AMHUL9zF46GBoIfeQS/Ky4X50KjoeyNNyl9/XXqt2+nZvly574adAHs7/8AdoUW5cG38arNBZWKqC8+F34nsuz8bKWXl1Mz1MQPDFEJqEPFrMzRKIg+E3Ha/OMJslMrXN7zC3PHZrFTU26iNLsG5SmDZeCdd1K7fgPWvDx85s0l6L772tXdAHhdeCGlr72OtaCA8g8/pCBsJA1Kbzx8tQybKUq313/1CWqtlv7TZjrF4SV6PxxIKE1G7JWVzZqq452LOAHYHA40NH+PpohTVKUgTrokMcjnHKmgPK+WiK5+BEV7dppMqPz88Lv8cvwuF7+3qc5KbaUJJJAksJodOGwOAqM90ej+XtC+psLI+u+O47DLZKaUM/bKbsT3CyLgllvQdOlK2lNvoLSbiX30bmoTh5H39kEUCgmfED2VhfWkrM1z7qv/5GiGzDhzGX1LKBVKxkSO4be031ifu95JnDpiwNkWRoaPdLZYUt96DZ7arQTddZez7Nz30ktp2LuXmmXLKXn+BaJ//MF5rTSY7U63uX/K/FKSJGYnzuZk1UleGvESfdLt5H+/HXVusQtpOhXGQ2JSo2sxtin0anymxlG5MhO12c4Qb3fAHQjCZpE5/vQ2fL3K8Rwei8fIASg9PTEdP07lQuEiH/LEE2dtm2Gqt7J3VTZaNxWJA4LxDnTDUGbEllXHKKOKuGMNlFkVHNbaO+SPVY8HuaGjwAF98hcx7MOPO+2jJEkS/SfH0OuCSI7vKGLnkgyKMgz89Pwexl+bRHTP89TW5x9Ap+/6RYsW8fPPPzN16t8z/PpvxT9RVWc3GLBkZTlnDS2hVqp5bMhj3LLmFvYU7+HKVVe6LL8w7sLW24SHnzGv7HDYqa+qwtO/dcThdPCZN5faNWswLFmCJTOT+u3bMauU7IwPw5oUTdeESFQnjxGa2M05EFuMNsryainLraWquAFDWQNaNzWDLorFP1zohtx69iDi7bcwp6VR+OhjmFJTKXr0Uby2b+fKZ5+hZvVqMp98CtluJ+bHH9okZ/Xbd2DNy0Ph6Unkhx+g7d69XV2Sws2NiI8/puTll1D5+uF/4w0ovbxE2Xd9vYtzrf/VV2P4fTGWrCxBmpRK3IcOxVFbi0dCIoG+YRSk15HS6zb67X+D+Edvx70xdUo7D6MmctSyeswuN3kXtf8AM9ZZyD0iRJpDZsThH+5BcIwXbp4iFF9baaLwZBXB0a55fIW7O7G//oK9traVOLuhxkJZXi3B0V7oPMTMUqHT4XPJHCo++xzZbKYqoCcAfcZHoXFTYSgt5uDqlcgOBwmDhqJvbBdhVaood/MmyFgtuqr7++OwWDBnifY+um6nd/hWKVsSJ1c5pim/hIEmFXpNX9Li9QxK6M6RLQVs/OGE6ClCJlp3FUFRngREeKLRq1AoJIJjvQjv0r4IWnbIFGUYSN9bQn4LTcep0Hmo6TsxiuQxEag1Z9eQdu/KbBx2GYVSwmK08eenh/Hw1RIY5UlFgY6anvehVEmofbpwdLGIgvYYFc7ISxPJOFBG/vFKyvLqqCiowz+iY5q7UzE2aiy/pf3G2ty1yMjsLd7L5NjJ3Ny785YzvjpfLulyCQdLDzKiywS83mptaRJ03/3UrV2HMSUFw7JleOuFT5zBaEXbGH36x9qtIMbMEeEj8NZ6Y5EFEbVkZyPb7e36l5kOCY8qt17JmI02itKqUWmVODzUbKi1ES/LROkUKBAkVCVJ+Lr7gt2Xglc/QrrvNiStFtluB7sdz8mT8Rh5Zo+ktlCYVsWaL49SVyXMYHcvz0KlUWCziAjTYNRgdjAWNUc0dmcbltNhx+J0HA6J0GDod899f8t8Uq1Vkjwmgqgefvz12RHKcmtZ8X4K/SZFM/jiWBT/lNHpOUSniZNGoyHhNP4g/9dxvp3DTceOkXvNtaBWE//nn87S05YYEjqExdMX8/WRr1masRSbw4aH2oPeQb1d2nicio3ffkZtRQVKtRqlSo2yUVhanpdNSUY6bl7e3Pj+F506XvehQyEqivqiAhzbt+Nwc+NA92jq7UJUmbp3J6l7dzLplrvpOWY8B9fmsu3X9Db3lX2onN7jIxl4YSxqrRiwtImJxPz4AxVffEnZu+9Ss2IFDbt2YStrLgAuevwJYn/7tVWapmqRSHN4T5/u4m7bHpQe7k7dRRMktRqljw8Oh0x5Xi3+4R4oNRpCnnyC3BtuROnnS8Sbb7rsP9hkY+lbByjNgf0jnybtmB7VS3tQaZTovTWMmtvFSWya0ESOWhKn5ohT+8ecsa8Uh0MmMMqT/pNjWi339NPRdUjbugKlt7dL9WJFQR1rvz5KeZ4QqYcmeDPr/maxvO/8+VR88SUOGQy+8SBDeFcfAHYv+RXZ4SC6V19CE7py/ERz1VqRuz9BxmoR+evbF0t6OthsKLy8UJ2h6kjdYsC22ZvPzYa31nPiuIMxkhqLWzh5keGU7pcw7xB2AEExXlQX12Out5F3rIq8Y67l+4kDg+k+NJQTu4qpKKwjrk8gXQaFkHGglNSN+dRVml3W13s3/l4yqLRKbGY7DTUWdvyewcG1efSfFE3iwGB0HmoXHZap3oqkkFBrlS7vA1QV13N8hyh0mH53X3IOl3NwTR51VWbnQ1CSwG6T2fi9+F5qrZIBU2OQFBLxvQOI8NZg8q7E4qOGA6WUH6tA5avDZ1rHfYQGhw7GTeVGubGcn078BMDe4r3Qu8O7cMHjQx4/7XJ1cBABt95C6etvUP7e+/hcLzQ01UYrvpK4h//RBr+At1bcB+qwMEFozGas+fltRsVlq9Vpf+GWnEx1aQMrPzzksk5xrBeD7+mDWqNCdsgU7Czk+G9p+CJxPHYavcqOoTKJQh6ljw/Bjzzc7rHZrQ7yjldSnldLeX49SpWEp78Oh02mKKOakqwaZBm8g9zwDtSTd6wSm8WBUq1A7adlZ1UtSTYVWodEiF06Y8SpMK2ajP1lSBKMXjAIt/CzI+SnwjtQz+wH+rPt1zRSNxWw/68cDKUNTFrw35e56jRxuu+++3jnnXd4//33/+u+7H8DtPHxKHy8sebkUvnlFwS244sV4x3D08Oe5v4B92Nz2PDWep/x98hOOUBFfm67y20VDtZ+dYDIpFBiewe0m4Y4uaeY+ioL9dVmHHYHlqGjSTm+HS9Zwi0qmsq8bHQenoy9ZgHZKfvJ3L+H+P4i4uLlL7yLPPy0BEV54RfmjnegG5kHy8hKKefA6lwsJjtjLmtO4UgqFQE3LUDfry/5997rJE1+116LYfFizCdPUvHlVwTctMC5jbW4mLoNGwHwnXvpac9LS9RWlHNs60aOb92IoawErd4D76AQdN4Xkn/Cgpunmm5DQ0ka0Zv4P1eh8vNrJeTU6FRMu703i9/YT1VxA5WF9S7L3b21jLjEteu50imC7lzE6eQeodtKHPj3nIsddocLaUKConQDxZkGQuKaHyo+l15C3roD2GQVWr0KvzAPasrLOLxxLQBDZovqTb26eaZe5O5P7/IMLLliNu/UN3XtesZrVqGQkCTRh9XWwgRTk3sMpO54V6cTUJFKYehwjI0d8vpOiGLorHhBdnPrKM+vpaKwHpvFjsVoI/NAGWl7Skjb0yxYL8+rY/fyrOb965TE9Q0ktncgYQk+zshby/N1YlcJe//IoqbcxNZf0tj6SxpIoNOruerFYai1StZ8cYTcxrJtlVqBWqdErVXiFeCGqd6KLENMrwDCEn0IS/Sh/5QYSrNrKMutwytQR2R3Pw5vKmDnkgxkGfpMiELvpcFabqT0vQPI5taRb1Vw54xZtUotd/a9kz+z/6RnQE8GBA84Z35l7cH3iiso+/AjrAUFxFXmAmoMDRb0jZG7fzLi1BKSUimqjo8dw5yR4UKcHEYjklKJKS0N2WJB4eWFOjoaRUEdQdGeWM12rBY7PkF6xl+bhFojxk9JIRExLBx9rA+L39iPSRvCySs/Zuq8MJQKGaWfv3OCbDbaWP7uQWSHTFzfQBRKBSnr8qivNrd5vE3oNiyUkZcmotGpMNVZMdZZ8A50Y3N6Oc99tQdfs5Joo0S0TXnaXnUOu4PNi8T9mTQizJkBOFdQqhWMmt+V0EQf1n51lIwDZWQdLCeu73+WweWZ0GnitHXrVjZs2MCqVavo0aNHKwPM33///Zwd3P+PkDQagu67j4I776Liy6/wufTS03qBeGg6fmEPnTOfBkM1dqsVu81GQ00DuUfLqS7VoFCFICn8OLGrihO7qlBplcT1DsDdR4taq8QnSO98OG/5KQ1TXXOZrtUo/q6RZGryslEoVUy/7zEiknrSfeQF2G02lI1C7Mgeflz32ohWEZduQ0PJSilj59JMBkxpPcsD0A8cSOxvv1Hx2ee4Dx2C59ixaLt2oejhRyj/4AN03briPmoUkiRR/etvoqJvwAAX0Xp7kGWZg3+tYNN3X2C32ZzvW4xGaivKUGrVqPVjMNZaObA6l9wjFcx7YnC7+3Pz1DD38UGU5dZis9ixWRxUFNaxc0kmR7cVMmhaLBq35tuvrYiT/Qwap5oKI0XpBpAgccDfI06HNxdQnleHVq9i7uOD2L0ii+Pbizi4No/JC5qjUiFPPUXx0BxYnElogg8KhcSeZb/hsNuITEomopsoy3Zrkboq1gstgzVPkHanvukMabomqBUKLHaHS6puwAsLqP3wJ7y//RQfSz1x2lyMV7+Pxk1Jt6GhSJKEUinScsGxrmnKkuwaNiw8jqGkgYSBwYTEenFkSyFlubX4hujpMyGKLoOCUanbT78plAq6Dwuly+Bgjm8v4sDqXAxlRpDBYrah0ogHv83aTPZsVgc2qwNjrZWachFtQILBF7foz6ZTEdHNj4huzc32+k2KJqyLDyVZNfgGG/jwxssJio5jMJNQeqjRdfVDG+8NkoRstiNpO582vCLpCq5IuqLT250tFDodnmNGU/PHKhKO7QbP4VQbrfh7CI2PVnV2qc9zAW0L4uQ5Vlgh2GtryZo1G3t1tTO67Nao8Q2I8OSSR84c0fYLdefiO/uw5M39FGfXs2tbPWMud70HTu4qpiRLeFqV5tQ639d7aYjo5ktAhCeyLFNbYUKWZULivQlL8MEroLnHns5D7ST6TdGlHJWDaJTE2pSnnaykbiygoqAOrbuKwdPPnfv5qUgcEExFfh37/sxhy88nieju+7f1gv8kOn2kPj4+zJw583wcy//QCM8JE3Dr3x/jvn2UvfMuYS+9eOaNOoCuQ13F3TsWp1NnyEWtg56jIwjv6kNxZg1ZB8swlBk5ubt5Rh7Vw89JnOJ6B2CzOnD31tJQayFt9yjs2gEERlThH1ZDXL+BRCT1dG6rbOFjotYo29WDxPYOJKZXwGlvbHVQECGPNfs1eU+fTs3yFaIi7qab0fXqhdLDnZTycLThYxg0t3UpucVkw2ZxoPfSNL42sur9N0jfIwzgfELiqKuJR6EKw2ErwtawGrs5lam3X49Ko+fIlgJiks+sBVOqFM5oDUB0sj8ndhZTVdzAse1F9BgVRnGGgeBY72aNU4uIU1P06VTiVFdlxlhrIW2v+H3Cu/jg4esqKq2rrMDd169DUeF6g5ldS4Vx7ZDpcXj66egzLpLj24vIPFBKTbnROTBLkkRhRg2yLKPVFbLms80caYw2DZ4117lPvcY14gRgyRMiblOju3ZHe7GplBIWu2uqTqtXU3/BGO4v1HJ7bQpX3TILfb+O9bIKjvFi7mMDcThklI0PlqQRYZjqrej06k6JyZVKBT1GhtNjZDh2uwNTnRVzg8153mfe1w+71YHFbMNqsmM12zEbbRhKRSQyINKTgA5ok0JivQmK8uDbB1/CWGMgJ/UA5apM8FSiKtWg3etO4uBh9BwzHne/tkW39QYzkiQ5r/t/G54TJ1HzxyrCU7bD8GFUN1gx2xpbrvxLEScATbwgDE1O1wAVX3zhLDJpMprV9Uru9L4DozyZvCCZZe8e5PiOYgZfHOcyiWxK3Sb0D8JUb8VispM0PJRuQ0JRqjt/Tpr0TGmSlVEoCbVJWM12pxQChA5SoZRAhl3LxTgwdEY8bh6trxOHw86hNX/S84IJqP6mQWX/qTGc3FNCbYWJnYszGD4n8ay+47+BThOnr1q06/gfzg8kSSL4oQfJvnQuhiVL8LvqSnTdu5/zz+k/JYbqUiMDpsYQGCkqquL7BjFsVjzFGQbyjlViMduxme34hjanoy640vVYBl8cR8raPLoMDiYo+u+ZgXY2/StJEuFvv0X5Bx9StWgRpkOHqPGMIre/mD03pHkzrtKEp58O2SFzaGM+OxZnYLc6CIrxIibZn5yUn8lJ2YlCqaLLsNlkHQ5DpZUITfCmsiiYWvMBHPYyqgp2MXjmpcT1CeRsfGMlSaLX2Eg2/XCCA2tySd2Yj6HMiFavQh+uw90hUlJNsDtkwm0KbJl1HLEVYKy1kJVS7jITBegy0DUiaTWZWPjI3fiFRzL19vvwaOdB2oTdy7OwmOwERXuSNFIUEfiHexCZ5Efe0UpWvJ+C1WLH3VvLtNt7U3iyFGv9ClL+ataqxfUbSFTPZlGMTt0WccpFluUWFXUdizg5+9WdYn1itTuo0+jZM3w6N/drv59fW2iKSLV83daDojNQKhW4e2tx93YlsUq1Aje1BrcW/CgswafT+09Z8wcV+bnoPL3oMngYRzatw17VHPktzc5g+y/fM2zOZc6UKYDNamffnzns/ysHSZIYMCWG3uMiyTxYxtGthQTHejFkRnwrDdb5hseokUg6HbryEuINBRiMQc5+av9Wqg5AGy80vObGLhjW0lIqv/kWEJYQNX+tRjaZ0A84c5SpLUR09yUo2pPSnFqObClkwNQYQGgMS3NqUSgkRs1rrYM8GzT1qquUZAySg4EaFUW/nSR8WjxKLw3p+0pZ/flhZFlcp03jYtLwsDb3d/CvlWz4+lP2/7mciQtuJzg+kYKjh1FptC6T5Q4dm0bJqHldWPnBIVI3FXBiVzHx/YIYfkkiWrf/7OjTf/bR/X8Mt1698LrwQhoO7MdeXX1ePkOjUzHlptazJkmSCE3wIbSDg7unn44Rl545HXa+YFMqqR49HMWgftgOHCQ+NBKNwpPd2+spOGngh6d2OiuOmsLgAKXZNRSlHcZaJ3oxKd1mkH04HAnoOSqcUfO7CBfcTVZWf/wW+1cto9+F01FrtKcleIfW/YnGTY9XQBBegUG4e/s4q1K6Dglh59IMp2ZBoZAwN9jQpdUxV6HF3kLHY3fAEJMK45ZSNtIstpYkcPPSCEFogBsJA1xtJvb9sZT66ipUGg06z9MT2YYaC8d3ilnu8EsSXR6efcZHkne00llVVldpZvEbW6gt/RHZXoJSpaLHmPEkDhxKZM/eLudEr2keWpqIk72sHPPJNHE9KxRoEztWZNI0+J/ar87a+Fr9X1iV01kYa2vY/vP3AAy/9Ar6TJzKiHlXYSgtwWG3UVVUSOr6vyg4fpTtv/xA4uBh+EdEkXe0ko0/nqCmzNi4J5ldyzLZszILR2MErzCtmqriBiZe38MlEnG+odDr8Rg9mtq//mJE4SEOGntitnXMa+h8QtsUccrIQJZlyj/6CNloxK13b0JffpnAO+/EnJ6O+/Cza4jcNIFa+9VRDm/Kp+/EKJQqBccao03Ryf7nhDRBc69HJChUO0jQKVAcKsc6IISS0gbWfnXUOVmzWx0oFBJjLuvabtTVKyAIdx9fqgrz+enph1GpNdisogvDxfc+SuLgzp2TmOQAhs1KIGVdLvUGC8e2F2FusDH5pv9swfhZEadff/2Vn3/+mdzcXCyntK7Yv3//OTmw/wGCH38MhZtbK4fj/6EZDrudJa8+S/6xw873AqNjmf3oJGIv0LL266OUZNU4CZNKrWDY7ATi+gSScaCQTd98A4Ba3we9dxxqnZKEfkEMm5WAJAlhctLI0ez87Xtqykr5eMGV+EdE0mP0eJLHTUShcH3QyLLMhm8+w2ZuFnPOfvRZYnqLiIhao2TwRXHsWJxB0vAwBk6LoeBENSt+Oc5BYz29WnADhyxTonTQNciD8AB31FolYQne/6+9Ow+Pqjr/AP6dJTNJIBuEJIRssi+BBBMIYZMlNUSKohVRKYbFWG3SYlEUigK2Cj6tWqqNUG0BlyoKFcQfO5FNZUskQAgiS1gK2ViyAllmzu+PYW5mkkmYSWYyl8z38zx5HnLvzZ0zh8nknfe85xx0HRjQ6HDLjbJSHNpgWNNr2OSpUDexICQA5Oz+H/S1AoH3eEtZECEEbpaVoksvH4ye2htVN2rh4eWGHf/ajMu5WwBxAyq1Jx59daFU01Sfh0nGqULjCREcAsXl/+FCcjIAwx5r1r6upYyTzjzjZCwWVzdR7NpcQghU7LmEGn01ss9vR1lxMRKe/i3a+3W48w87wA9r/oNblRXwD4vAgLGJAAAPL2943A6Mg3v2Qb/7xmLD24tx6uAP2Pv5x5g45xXknylBWfFNtPPRYPhjPaHX6fHdmlO4WV4DD28Nut8bgNzvL+Pc0Sv47LX9ULupcKuyBt3vDcB9Tza9xpY9eCfej/KtWzHi0lHsrvyVLDJOmrAwQK2G/sYN5P9xPkpvr9MW8OILUCgUVi3vcifdYwLww1enUVlajTM/FqFbTAB+PlAAAOgz1H6ra5vOoOusUcJNocBNBZBXfBPf//c0dLV63BPlj4RpfXEtvxJu7ip0DG586Lj7oCEI6ROJPZ+txLGMraitqYbWsx2qblRi8/t/Q4cuIegYEmZTGwfeH4bohFBcyL2GTcuO4mx2MXJ2X0L/UY3vYelsNgdO7777LubPn49p06bh66+/xvTp03HmzBkcOnQIqalN78jdFrTGOk5GLdlw01V8t/pj/O9EDty07ugYGobrly+h+Hwevlj0Mh6d/zp+NScG1woqce1yJSpLqhDR3x++t2cdleTvRvXNq2jfoSOmvf1HaD0tz0ZSqdUY/vhT2LpsKapv3kD+qZPIP3USR3ZsxpjpvzELHnQ1NegxeCjKiotQVlyEimtX4d3JPCPUf1QIIu/rIn2i6jqwE2qLr+FwxmlECvPi8O88ajFxfCjGx1j3JnJg3ZeovnkTARHd0HvoyCavra3WIWePYRuFqLGhOL47A0cztuLqxfOoulEJr46dMCBhHDx9fHH20DFUle8CAChU/oh5KK3RoAkA3N2U0mw4AFC/tgT44x+gKzZsYGptfRMAuN0OnExrnIC6QMoeGafa6mpc/vkELuQcxeWfT8BfEYyelVHQCz0uFRxF0a3zuHb5f3hswWK7BE+iVg9dWTVUXhoo7lDXoautRcFpw0yn0ckpUDaythAADHt8Kk4f2o8zmftx6eQJ3DuuJxRKBaLGhEqTEcIjO6LoXDmCe/hC5aZEj0GB2PT+UbMlGG6WVzf2EHbVbuR9gEaLLpVX4J1/HlW9DXWUzsw4KTQaaMLDUX3mDErXrQMAeP0iwaolTaylUisRObILDn6ThwMbzuLkgUJDMOvlhjA7Lgxp2o/DVIb//zM3dDjziWG4PPAeb/xiZj+4aVRm9ZhNcW/fHvc/8zsMevBX0NXUwK9zF/x38QJcPH4UX7/1OqYs/hu0ng2X0WmKQqlAeGRHDH2ku2GG6tpTCOrqg05hjS/K60w2B07vv/8+PvjgAzzxxBNYtWoVXnrpJXTt2hULFizAtWt33i35bufodZzIeqcP7cehDf8FAIxL/QN6xg3D9YLLWPv6K7iefxmfL3wJk155Ax2DuzT4FKWrrcWFY9kAgLEzf9to0GTUZ/go9BwyDNfzL+PckR+x/6vVKD53FuvefA3PvL9K+nm1RoMH0uq2ZtDV1kJpYfG4+mlopVIBoai3jpNUHG5df5QWFSB760YAwIgp0+64aN3PBw1v1u07aNFtYCdkbSzB5ZN1e7SVXy3G9198YvYzHUOH4lbVYESObLrmTqFQwMNNhRvVt4t9+/RB8Oef4+LTKYbNhKMt75VoiXHblfoLYBpXDm9qerW1vl25HMe+3SZ9fxFHoemkQkT7SAwPegTfV25A4eUz+PJPf7QpeDqxdycKz53FwMRfwicgEDePX0XJhtPQlVUDAlB6quE3qSc8+jT+x1KlVuOJ19/ChaPZZnVklnTsEorI0Qk49u027Fz1T/QaOhI1t27h8JZDUGs0aOfrh4B7uiOkd2fp9dG5mw+eWBiHgrOl0Hqo4d7erW7dKgdTtW8Ht6FDUfLdPvhczZeKw505qw4AOv0uDSVr/wtt9+7wiI6C19ixd/4hG/Ub0QVZm8+j7MotaZZln6GdpQkL9mD8UNEPKnRXqFArBC7U6BEQ7oWwfh0RNTa02Yu3+gXV1UH98vmX8enc53E9/zIOfr0WI55IbtY9B4wJwf9OXse5o1eQ8VEuJs8fbPPK/63B5sDpwoULGHp713oPDw+UlxsKVadOnYohQ4bgH//4h31bSGRBaVEhtrz/NwBAzPiH0DNuGADDL/Pjf/oL1r7+KoReD3cLm2UCt/8Y/fktnM06iO6xjS8rYP4zbvAPDYd/aDj6jhyD71Z/jI5dwpoMulRW7IwO1C1HoK+XcTI9dyc/btoAva4WYf2jETGg6cBECIHsDMMsoQGjQ6FUKdEtNg7tO3SEf1gEfDoF4PSh/Ti+OwNCCHTu3hP3DIxFl979zGajNcU0cHJTK6EJCUHEmi9x4+BBtKu3fU9T1FLGqWFxOGC+n11zhfYbgLOHMxEWGYWQPpEABMqLr0B3TsCtRIPRgZNR6H4Ot25V4PAHX2HEy0/f8Z5CCBxYvwZX/3cBP278Gt1i4xAT9QBQejubowD0N2px9aNctB/eBT7jIqBoJNOiVKoQEW3d2krxk57Eib27UHj2NArPWl5s1s3dA8Mn/xr3PvAQAMN0967RzllLp/OCV5H0t4OoUanxiwpD3zgz4wQA3uPGSdshOYqntwa/TBuA/DOl0Lir4eHthq5R9v0/MAZOD8MwZH+onQLT/3Sf3WvZPL198NCL83F8TwaGTnqy2fdRKBQYm9wH2/6Vg6G/6iHLoAloRuAUFBSEa9euITw8HGFhYdi/fz+ioqKQl5fXrJlGRM3Rzq8D+owYhaK8sxjx5HSzc14d/DF50Zuora6Gp49vo/dQqdU2FzMaeXr74P5nftesn7XYFktbrli5V53RiCnT4RMQiC5NDKEZVVXWwtNbg4rrt9B3uOGTY4fgEHQIrhsS7DtyDPqOHNOwrVZmeDw0KuD22p/GrJDKy8vmT+/GGqb6GSfj0J2bHd5cew0dgd7D7muQCdSVV6PoH9nQlVYhQB0KtAc8B1qecWTJiCen4fCWb3D+6GGcPrQPWk07jP7tDKj93KF0V6N0Sx4qvr+Miu8uQd3RHe3jrb93Y7w6+CPxt8/j533fwU2rhVqrhV6nR211FUqLClB8Lg81t25C286+ixs2V7vgznDz0KKmWoeiMkPmxZr91NqC+mt22ZtGpYQPFBh9O3Da563EJAdNAAjs2h2BXVu+q4h7Ozc8OMv6jLQz2Bw4jRkzBhs2bMDAgQMxffp0/OEPf8DatWuRmZmJRx55xBFtJGpA7eaGsTOeQ211tcWsjqf33TWMWrcAZt0xY+CktjIwULu5SRmEO3Fv74aJfxiIG2XVDpv6a1og3pI/hGplI0N1evvVONUv8jdSeWkQ+Id7UXW6BPpbOuiraqG1cskNhUKBbjGD0S1msCHrtHkD+o9JhDas7ud9J3SDtqsvKrMK0W6w/YqCew8d2WiNm16nw7VLF9HOSYXulvh4uOFGtQ5F5YY6K+1dsp6P3LmpFRgEFbRQ4CR0KPDkRHp7sLkXP/jgA+hvv2GlpqaiY8eO+OGHH/Dggw/iN7/5jd0bSNSUli7CJhfGv/22brnSUo5cDNF0EcyWBDdSxqn+UF3t7cDSwdkJpbsaHpG2bX5dX8eQMPwiJc3iOY9+HeHRr/V2ileqVPAPi2i1x7OGj4cb8ktvofh24OQqGSdHc1MpsQO1OIkKeEMBf7Vt2/GQZTYHTkql0qzY9fHHH8fjjz/exE8Q0Z00vcmvPMf578R0EcwWBU7ScgT1huqkjNPd2T9Ux9fTMJRkzCpqm9juhqxn/N25CMPvyi+cXDvWVjQrb1dSUoKDBw+iqKhIyj4ZPfXUU3ZpGJErsbTlipRxuksDJ/OMU/Ofg7qxBTClWXX8Y3C38/Uwz3wy42QfCoUCGpVhr0eA/WovNgdO33zzDaZMmYKKigp4e3ubFVMqFApZBk4PP/wwdu3ahbFjx2Lt2rXS8YsXL2Lq1KkoKiqCWq3Gq6++ikmTJjmxpeSqjIGT3qw4/PY5Ga+g2xTjRr9qpaJFqwBLs+osbLkCOGYBTGpdxoyTEWuc7Mft9l6PgPNnK7YVNvfiCy+8gBkzZqCiogIlJSW4fv269CXXdZxmzZqFjz/+uMFxtVqNpUuXIjc3F9u2bcPzzz+PyspKJ7SQXF1bHKrzcDN8LmtpRsiYcWowVGdcAPMO61WR/Pl41AucmBmxG9NgiRkn+7C5Fy9duoTf//738LzDgoFyMmrUKHh5NVyBtHPnzoiOjgZgWGbB399ftsEftW1SxqmVi8MdyUNjeHtpaQ2Sm7RUQ72Mk7RX3d3ZP1THhxknhzH94OKm5u+KPdj86kxMTERmZqbdGrBnzx5MmDABwcHBUCgUWL9+fYNr0tPTERERAXd3d8TFxeHgwYN2e3yjrKws6HQ6hIaG2v3eRHeiaoMZJ+NGvy0dHlA1UhxeU2u/BTDJuRrWOLE43F5MAyf2q31YVeO0YcMG6d/jx4/HnDlzkJubi/79+8Ot3iaiDz74oE0NqKysRFRUFGbMmGFxHagvvvgCs2fPxvLlyxEXF4elS5ciMTERJ0+eRECAYQ+w6Oho1NbWNvjZbdu2ITj4zgvKXbt2DU899RQ+/PDDRq+pqqpClcnGrWVlZdY8PSKrKKWMU90xnY1brsiNcR2nlg7VGX++/nIEtcw4tRn1a5xYi2M/pn3JjJN9WBU4TZw4scGxP/3pTw2OKRQKmze/TUpKQlJSUqPn33nnHaSkpGD6dMPq0MuXL8fGjRuxYsUKzJ07FwCQnZ1t02OaqqqqwsSJEzF37lxpKxlLlixZgtdee63Zj0PUFIvrONm45YrcGIvDW17jZHnlcHtu8kvO1aDGiYGT3Zh+sGDtmH1Y1Yt6vd6qL1uDpjuprq5GVlYWEhIS6hqsVCIhIQH79u1r8f2FEJg2bRrGjBmDqVOnNnntvHnzUFpaKn1dvHixxY9PZNQWi8M9pcCpZe1XKZsOnDhUd/erHzgx42Q/ZkN17Fe7kHUvXrlyBTqdDoGBgWbHAwMDUVBQYPV9EhISMGnSJGzatAkhISFS0PX999/jiy++wPr16xEdHY3o6GgcO3bM4j20Wi28vb3xySefYMiQIRjrgN2yyXVZ3KvuLi8Od7fXUJ3S8jpO9tyrjpyrwXIE/ANvN2bF4fyQYRdWr+P07bffIi0tDfv374e3t/leTaWlpRg6dCiWLVuGkSMt74/kTDt27LB4fPjw4Q0W8LyT1NRUpKamoqysDD4+d9d+aCRfxuJw86G62+fu0sDAmHFqcXG4ylgc3tisOv4xuNv5etYrDmfgZDcaZpzszupeXLp0KVJSUhoETQDg4+OD3/zmN/jb3/5m18b5+/tDpVKhsLDQ7HhhYSGCgoLs+lhEzqSwNFQn7u6huh4BXlAogO6d2rfoPsaMUm2js+ruzv6hOu00KrPNrLVqzv6yF7PicH7IsAure/HIkSMYN25co+fvv/9+ZGVl2aVRRhqNBjExMcjIyJCO6fV6ZGRkID4+3q6PZa309HT07dsXgwYNcsrjU9tUt+VK3bG7vTi8V5AXDswbi788OqBF9zHWMNWvcarbq45/DO52CoXCrM6JMyXtx7QvmXGyD6uH6goLCxssPWB2I7UaxcXFNjegoqICp0+flr7Py8tDdnY2OnTogLCwMMyePRvJycmIjY3F4MGDsXTpUlRWVkqz7Fobh+rIEaRZdfqGs+ru1owTAAR4u7f4HtKWK/WXI+BedW2Kj6cbrlZWQ6tWtmiLHjJn+vvB2jH7sDpw6tKlC3JyctC9e3eL548ePYrOnTvb3IDMzEyMHj1a+n727NkAgOTkZKxatQqTJ09GcXExFixYgIKCAkRHR2PLli0NCsZbS3p6OtLT0+0+g5Bcm6VZdcZ/q+/iwMkeGluOoJp71bUpvrczTsyK2Jcbh+rszurA6YEHHsCrr76KcePGwd3d/FPkzZs3sXDhQvzyl7+0uQGjRo2CEKLJa9LS0pCWlmbzvR2BGSdyhCa3XHH1wElpHKprJOPEveraBGOBOLMi9mVWHM7AyS6sDpxeeeUVfPXVV+jZsyfS0tLQq1cvAMBPP/0kZWDmz5/vsIYStWVNbrni4sMW6kaKw6UaJ66G3CYYa5xYGG5fpjVObgxK7cLqwCkwMBA//PADnnvuOcybN0/KEikUCiQmJiI9Pd1pw2etiUN15AhKqTjcUsbJKU2SDWNxeP296qqNs+pcvYPaCB8O1TmEGzNOdmd14AQA4eHh2LRpE65fv47Tp09DCIEePXrAz8/PUe2THQ7VkSNIQ3W3s0xCCBhjKFfPOBk/MevqD9Vxr7o2xbgIJofq7Mt85XD+rtiDTYGTkZ+fH6fjE9mRVBx+O1oyHbK7m2fV2YPx+dc0tnI4P0W3CSwOdwzTQFSj4jCoPfAVSiQDdRknw/emQ3YuXxxuXMfJZDkCIQRn1bUxLA53DO5VZ3/sRRtxAUxyhPrF4aajUi4/VGdpHz+Tf3NWXdswsmcnDO3WEVPiwp3dlDbFfK86134vsZdmDdW5MtY4kSMY//YblyMwzThxqM64V11dn5j+mzOF2oYO7TT4LGWIs5vR5pjOOmXGyT7Yi0QyUH8dJ9OMyt265Yq9uKkaruNUY/JvV18glKgpXMfJ/tiLRDLQcKiOGScjaeVwkyyT6b9ZHE7UONY42R970UascSJHUNQLnMyKw107bqpbAFNvOlRnyDgpFQwsiZrCwMn+2Is2Sk1NRW5uLg4dOuTsplAbUjdUZ/jemHFSKuDyG55KW66YzKqrkWbU8S2MqClmK4fz98Uu2ItEMlB/qM6YcWI2xfImv8ahOtZsEDXNmGVSKFgPaC981yGSAeOsOmPAZAwMXL0wHDDNODUcquMaTkRNM364cFMpXT57bS8MnIhkoP6WK3pmnCTG4Mh0Jp1xOQLuU0fUNOPwnJbZWbthTxLJgKqRLVcYONUNL5gu0WBcmkDDjBNRk4zrnLEw3H7YkzbirDpyBOO2KkIYthNhxqlO3ZYrlobq+BZG1BRjcTgLw+2HPWkjzqojRzDdVkWnFzBOIHP17VaAuoxTjc7CUB0zTkRN8nAzbOzrqeEGv/bCLVeIZMB0I1+dENKwlKtv8AvUBUc6zqojstmAEF88FR+Owfd0cHZT2gwGTkQyYDokp9ebFIcz4yQVgNdYXMeJ/UPUFJVSgT89FOnsZrQp/LhGJANmQ3UmGSfWONXVaFhaOZyz6oiotfFdh0gGTP/+6/RCml3HuKAueDRbAFPPoToicg6+6xDJgGnGSQghrefEobq62UCWt1xh/xBR62KNE5EMmA7JGWbVsTjcqEM7DbY+P9IsSKqbVcfPfkTUuhg42Sg9PR3p6enQ6XTObgq1IQqFAgqFYR0nnagbqmPGyZBx6hXkZXbMmH3iAphE1Nr4cc1GXMeJHMW4L51eb/gCWBzeGBaHE5Gz8F2HSCZMt12RisOZcbKIC2ASkbMwcCKSCWPyRK83KQ5nxsmiur3q+BZGRK2L7zpEMiFlnFgcfkfMOBGRszBwIpIJY5CkE0Jap4hxgWXc5JeInIXvOkQyYRyW0+tF3ZYrzDhZxL3qiMhZ+K5DJBNmxeGscWpShH87jO7VCT0C2zu7KUTkYlwicHr44Yfh5+eHRx991Ox4SUkJYmNjER0djcjISHz44YdOaiGRyVAdM0539GhMCFZOH4wpceHObgoRuRiXCJxmzZqFjz/+uMFxLy8v7NmzB9nZ2Thw4AAWL16Mq1evOqGFRHUZJ70edcXhXI6AiEhWXCJwGjVqFLy8vBocV6lU8PT0BABUVVVBCAEhRIPriFqDSsmhOiIiuXN64LRnzx5MmDABwcHBUCgUWL9+fYNr0tPTERERAXd3d8TFxeHgwYN2e/ySkhJERUUhJCQEc+bMgb+/v93uTWQL4zpOZkN1zDgREcmK0wOnyspKREVFIT093eL5L774ArNnz8bChQvx448/IioqComJiSgqKpKuMdYo1f+6fPnyHR/f19cXR44cQV5eHj777DMUFhZavK6qqgplZWVmX0T2JA3VCYHbs+25jhMRkcw4fZPfpKQkJCUlNXr+nXfeQUpKCqZPnw4AWL58OTZu3IgVK1Zg7ty5AIDs7OwWtyMwMBBRUVHYu3dvgyJyAFiyZAlee+21Fj8OUWNMi8O5yS8RkTw5PePUlOrqamRlZSEhIUE6plQqkZCQgH379rX4/oWFhSgvLwcAlJaWYs+ePejVq5fFa+fNm4fS0lLp6+LFiy1+fCJTphknbrlCRCRPTs84NeXKlSvQ6XQIDAw0Ox4YGIiffvrJ6vskJCTgyJEjqKysREhICNasWYP4+HicP38ezzzzjFQU/rvf/Q79+/e3eA+tVgutVtui50PUFKWlWXUMnIiIZEXWgZO97Nixw+LxwYMH2zzMl56ejvT0dOh0Oju0jKiO6ZYrdcXhzmwRERHVJ+uhOn9/f6hUqgYF24WFhQgKCnJKm1JTU5Gbm4tDhw455fGp7TLuHqLnJr9ERLIl68BJo9EgJiYGGRkZ0jG9Xo+MjAzEx8c7pU3p6eno27cvBg0a5JTHp7ZL2nKFxeFERLLl9KG6iooKnD59Wvo+Ly8P2dnZ6NChA8LCwjB79mwkJycjNjYWgwcPxtKlS1FZWSnNsmttqampSE1NRVlZGXx8fJzSBmqbzIbqWBxORCRLTg+cMjMzMXr0aOn72bNnAwCSk5OxatUqTJ48GcXFxViwYAEKCgoQHR2NLVu2NCgYby2scSJHqdtyRaCWQ3VERLLk9MBp1KhRd9zmJC0tDWlpaa3UoqYx40SOYjHjxKE6IiJZkXWNE5ErsVjjxIwTEZGsMHAikgljkGS65QoDJyIieWHgZCPOqiNHqdtyBXXrODFwIiKSFQZONuI6TuQoxsUuzdZxYo0TEZGsMHAikgmVSXG4TlqOwJktIiKi+vi2bCMO1ZGjKE2Kw/VcAJOISJYYONmIQ3XkKObF4VzHiYhIjhg4EcmEMUjSM+NERCRbDJyIZEIaqhNgxomISKYYONmINU7kKOaz6m4fY+BERCQrDJxsxBonchSzLVc4VEdEJEsMnIhkwmzLFQ7VERHJEgMnIplQmRSHS3vVMW4iIpIVBk5EMmE6VKfTccsVIiI5YuBEJBPGoTrTjBOH6oiI5IWBk404q44cxXTLFb2exeFERHLEwMlGnFVHjlK35QqYcSIikikGTkQyYdzQ13TLFTUDJyIiWWHgRCQTUnG46ZYrDJyIiGSFgRORTFhcx4k1TkREssLAiUgmpHWchICeW64QEckSAycimVCaZpwEM05ERHLEwIlIJoxBkmlxODNORETywsDJRlzHiRxFmlWnh0lxuBMbREREDfBt2UZcx4kcxWzLFRaHExHJEgMnIpkw23KFQ3VERLLEwIlIJsy2XBHccoWISI4YOBHJhNLSOk7MOBERyQoDJyKZMFvHSZgfIyIieWDgRCQTpluu1N5eAZPF4URE8sLAiUgm6rZcAVcOJyKSKZcInB5++GH4+fnh0UcftXj+xo0bCA8Px4svvtjKLSOqI63jZLoAJjNORESy4hKB06xZs/Dxxx83ev6NN97AkCFDWrFFRA1Z3HLFJX5DiYjuHi7xtjxq1Ch4eXlZPHfq1Cn89NNPSEpKauVWEZkz3+TXEDipGTkREcmK09+V9+zZgwkTJiA4OBgKhQLr169vcE16ejoiIiLg7u6OuLg4HDx40G6P/+KLL2LJkiV2ux9Rc6mUDTNO3HKFiEhenP62XFlZiaioKKSnp1s8/8UXX2D27NlYuHAhfvzxR0RFRSExMRFFRUXSNdHR0YiMjGzwdfny5SYf++uvv0bPnj3Rs2dPuz4nouawuI4Ta5yIiGRF7ewGJCUlNTlM9s477yAlJQXTp08HACxfvhwbN27EihUrMHfuXABAdnZ2sx57//79WL16NdasWYOKigrU1NTA29sbCxYsaHBtVVUVqqqqpO/Lysqa9ZhEjbE0VMdZdURE8uL0jFNTqqurkZWVhYSEBOmYUqlEQkIC9u3b1+L7L1myBBcvXsS5c+fw1ltvISUlxWLQZLzWx8dH+goNDW3x4xOZMsZI1TqBap1hPQI1x+qIiGRF1u/KV65cgU6nQ2BgoNnxwMBAFBQUWH2fhIQETJo0CZs2bUJISEizgq558+ahtLRU+rp48aLN9yBqinFY7lRhOWp0Al5aNTp7uzu5VUREZMrpQ3WtYceOHXe8Ztq0aU2e12q10Gq1SE9PR3p6OnQ6nZ1aR2RgHJa7UW14bQ0I9eFedUREMiPrjJO/vz9UKhUKCwvNjhcWFiIoKMgpbUpNTUVubi4OHTrklMentqt+kBQd6uuchhARUaNkHThpNBrExMQgIyNDOqbX65GRkYH4+HintCk9PR19+/bFoEGDnPL41HbVXyV8YKifk1pCRESNcfpQXUVFBU6fPi19n5eXh+zsbHTo0AFhYWGYPXs2kpOTERsbi8GDB2Pp0qWorKyUZtm1ttTUVKSmpqKsrAw+Pj5OaQO1TfVn0EWH+TqnIURE1CinB06ZmZkYPXq09P3s2bMBAMnJyVi1ahUmT56M4uJiLFiwAAUFBYiOjsaWLVsaFIwT3e1M12wK8fOAf3utE1tDRESWOD1wGjVqFMTtVZIbk5aWhrS0tFZqUdNYHE6OYppxGhjGYToiIjmSdY2THLE4nBzFdMkmFoYTEckTAycimTAdqmPgREQkTwycbMRZdeQoxqE6N5UC/YK9ndwaIiKyhIGTjThUR47SI8AL/YK9MSUuHO5uKmc3h4iILHB6cTgRGXhoVNj4+xHObgYRETWBGScbcaiOiIjIdSnEndYCIIuMC2CWlpbC25v1KERERHeDlv79ZsaJiIiIyEoMnIiIiIisxMCJiIiIyEoMnGzE4nAiIiLXxeLwZmJxOBER0d2HxeFERERErYSBExEREZGVGDgRERERWYmBk41YHE5EROS6WBzeTCwOJyIiuvuwOJyIiIiolTBwIiIiIrKS2tkNuFsZRzjLysqc3BIiIiKylvHvdnMrlRg4NVN5eTkAIDQ01MktISIiIluVl5fDx8fH5p9jcXgz6fV6XL58GV5eXlAoFHa9d1lZGUJDQ3Hx4kWXLjxnPxiwHwzYDwbsB/aBEfvBwNZ+EEKgvLwcwcHBUCptr1hixqmZlEolQkJCHPoY3t7eLv3LYMR+MGA/GLAfDNgP7AMj9oOBLf3QnEyTEYvDiYiIiKzEwImIiIjISgycZEir1WLhwoXQarXObopTsR8M2A8G7AcD9gP7wIj9YNDa/cDicCIiIiIrMeNEREREZCUGTkRERERWYuBEREREZCUGTkRERERWYuAkM+np6YiIiIC7uzvi4uJw8OBBZzepRfbs2YMJEyYgODgYCoUC69evNzsvhMCCBQvQuXNneHh4ICEhAadOnTK75tq1a5gyZQq8vb3h6+uLmTNnoqKiwuyao0ePYsSIEXB3d0doaCj+8pe/OPqpWW3JkiUYNGgQvLy8EBAQgIkTJ+LkyZNm19y6dQupqano2LEj2rdvj1/96lcoLCw0u+bChQsYP348PD09ERAQgDlz5qC2ttbsml27duHee++FVqtF9+7dsWrVKkc/PastW7YMAwYMkBapi4+Px+bNm6XzrtAHlrz55ptQKBR4/vnnpWOu0BeLFi2CQqEw++rdu7d03hX6wOjSpUv49a9/jY4dO8LDwwP9+/dHZmamdN4V3icjIiIavB4UCgVSU1MByOz1IEg2Vq9eLTQajVixYoU4fvy4SElJEb6+vqKwsNDZTWu2TZs2ifnz54uvvvpKABDr1q0zO//mm28KHx8fsX79enHkyBHx4IMPinvuuUfcvHlTumbcuHEiKipK7N+/X+zdu1d0795dPPHEE9L50tJSERgYKKZMmSJycnLE559/Ljw8PMQ///nP1nqaTUpMTBQrV64UOTk5Ijs7WzzwwAMiLCxMVFRUSNc8++yzIjQ0VGRkZIjMzEwxZMgQMXToUOl8bW2tiIyMFAkJCeLw4cNi06ZNwt/fX8ybN0+65uzZs8LT01PMnj1b5Obmivfee0+oVCqxZcuWVn2+jdmwYYPYuHGj+Pnnn8XJkyfFH//4R+Hm5iZycnKEEK7RB/UdPHhQREREiAEDBohZs2ZJx12hLxYuXCj69esn8vPzpa/i4mLpvCv0gRBCXLt2TYSHh4tp06aJAwcOiLNnz4qtW7eK06dPS9e4wvtkUVGR2Wth+/btAoDYuXOnEEJerwcGTjIyePBgkZqaKn2v0+lEcHCwWLJkiRNbZT/1Aye9Xi+CgoLEX//6V+lYSUmJ0Gq14vPPPxdCCJGbmysAiEOHDknXbN68WSgUCnHp0iUhhBDvv/++8PPzE1VVVdI1L7/8sujVq5eDn1HzFBUVCQBi9+7dQgjDc3ZzcxNr1qyRrjlx4oQAIPbt2yeEMASgSqVSFBQUSNcsW7ZMeHt7S8/7pZdeEv369TN7rMmTJ4vExERHP6Vm8/PzE//6179csg/Ky8tFjx49xPbt28V9990nBU6u0hcLFy4UUVFRFs+5Sh8IYXivGj58eKPnXfV9ctasWaJbt25Cr9fL7vXAoTqZqK6uRlZWFhISEqRjSqUSCQkJ2LdvnxNb5jh5eXkoKCgwe84+Pj6Ii4uTnvO+ffvg6+uL2NhY6ZqEhAQolUocOHBAumbkyJHQaDTSNYmJiTh58iSuX7/eSs/GeqWlpQCADh06AACysrJQU1Nj1g+9e/dGWFiYWT/0798fgYGB0jWJiYkoKyvD8ePHpWtM72G8Ro6vH51Oh9WrV6OyshLx8fEu2QepqakYP358g/a6Ul+cOnUKwcHB6Nq1K6ZMmYILFy4AcK0+2LBhA2JjYzFp0iQEBARg4MCB+PDDD6Xzrvg+WV1djU8//RQzZsyAQqGQ3euBgZNMXLlyBTqdzuw/HQACAwNRUFDgpFY5lvF5NfWcCwoKEBAQYHZerVajQ4cOZtdYuofpY8iFXq/H888/j2HDhiEyMhKAoY0ajQa+vr5m19bvhzs9x8auKSsrw82bNx3xdGx27NgxtG/fHlqtFs8++yzWrVuHvn37ulQfAMDq1avx448/YsmSJQ3OuUpfxMXFYdWqVdiyZQuWLVuGvLw8jBgxAuXl5S7TBwBw9uxZLFu2DD169MDWrVvx3HPP4fe//z0++ugjAK75Prl+/XqUlJRg2rRpAOT3O6G25ckQUcukpqYiJycH3333nbOb4hS9evVCdnY2SktLsXbtWiQnJ2P37t3OblarunjxImbNmoXt27fD3d3d2c1xmqSkJOnfAwYMQFxcHMLDw/Hll1/Cw8PDiS1rXXq9HrGxsVi8eDEAYODAgcjJycHy5cuRnJzs5NY5x7///W8kJSUhODjY2U2xiBknmfD394dKpWowS6CwsBBBQUFOapVjGZ9XU885KCgIRUVFZudra2tx7do1s2ss3cP0MeQgLS0N//d//4edO3ciJCREOh4UFITq6mqUlJSYXV+/H+70HBu7xtvbWzZ/iDQaDbp3746YmBgsWbIEUVFR+Pvf/+5SfZCVlYWioiLce++9UKvVUKvV2L17N959912o1WoEBga6TF+Y8vX1Rc+ePXH69GmXej107twZffv2NTvWp08fadjS1d4nz58/jx07duDpp5+Wjsnt9cDASSY0Gg1iYmKQkZEhHdPr9cjIyEB8fLwTW+Y499xzD4KCgsyec1lZGQ4cOCA95/j4eJSUlCArK0u65ttvv4Ver0dcXJx0zZ49e1BTUyNds337dvTq1Qt+fn6t9GwaJ4RAWloa1q1bh2+//Rb33HOP2fmYmBi4ubmZ9cPJkydx4cIFs344duyY2Zvj9u3b4e3tLb3pxsfHm93DeI2cXz96vR5VVVUu1Qdjx47FsWPHkJ2dLX3FxsZiypQp0r9dpS9MVVRU4MyZM+jcubNLvR6GDRvWYHmSn3/+GeHh4QBc533SaOXKlQgICMD48eOlY7J7PTSz4J0cYPXq1UKr1YpVq1aJ3Nxc8cwzzwhfX1+zWQJ3m/LycnH48GFx+PBhAUC888474vDhw+L8+fNCCMM0W19fX/H111+Lo0ePioceesjiNNuBAweKAwcOiO+++0706NHDbJptSUmJCAwMFFOnThU5OTli9erVwtPTUzbTbJ977jnh4+Mjdu3aZTbd9saNG9I1zz77rAgLCxPffvutyMzMFPHx8SI+Pl46b5xqe//994vs7GyxZcsW0alTJ4tTbefMmSNOnDgh0tPTZTX1eu7cuWL37t0iLy9PHD16VMydO1coFAqxbds2IYRr9EFjTGfVCeEaffHCCy+IXbt2iby8PPH999+LhIQE4e/vL4qKioQQrtEHQhiWpFCr1eKNN94Qp06dEv/5z3+Ep6en+PTTT6VrXOF9UgjDTPKwsDDx8ssvNzgnp9cDAyeZee+990RYWJjQaDRi8ODBYv/+/c5uUovs3LlTAGjwlZycLIQwTLV99dVXRWBgoNBqtWLs2LHi5MmTZve4evWqeOKJJ0T79u2Ft7e3mD59uigvLze75siRI2L48OFCq9WKLl26iDfffLO1nuIdWXr+AMTKlSula27evCl++9vfCj8/P+Hp6SkefvhhkZ+fb3afc+fOiaSkJOHh4SH8/f3FCy+8IGpqasyu2blzp4iOjhYajUZ07drV7DGcbcaMGSI8PFxoNBrRqVMnMXbsWCloEsI1+qAx9QMnV+iLyZMni86dOwuNRiO6dOkiJk+ebLZ2kSv0gdE333wjIiMjhVarFb179xYffPCB2XlXeJ8UQoitW7cKAA2emxDyej0ohBDCthwVERERkWtijRMRERGRlRg4EREREVmJgRMRERGRlRg4EREREVmJgRMRERGRlRg4EREREVmJgRMRERGRlRg4EREREVmJgRMRtTmLFi1CdHS09P20adMwceJEuz/O1atXERAQgHPnzrXoPo8//jjefvtt+zSKiBxK7ewGEBE52t///ndYu0nCtGnTUFJSgvXr19/x2jfeeAMPPfQQIiIiWtS+V155BSNHjsTTTz8NHx+fFt2LiByLGSciavN8fHzg6+tr13veuHED//73vzFz5swW3ysyMhLdunXDp59+aoeWEZEjMXAiItkqLi5GUFAQFi9eLB374YcfoNFokJGRIR178803ERgYCC8vL8ycORO3bt0yu0/9obq1a9eif//+8PDwQMeOHZGQkIDKykosWrQIH330Eb7++msoFAooFArs2rXLYts2bdoErVaLIUOGSMd27doFhUKBrVu3YuDAgfDw8MCYMWNQVFSEzZs3o0+fPvD29saTTz6JGzdumN1vwoQJWL16dQt6i4haAwMnIpKtTp06YcWKFVi0aBEyMzNRXl6OqVOnIi0tDWPHjgUAfPnll1i0aBEWL16MzMxMdO7cGe+//36j98zPz8cTTzyBGTNm4MSJE9i1axceeeQRCCHw4osv4rHHHsO4ceOQn5+P/Px8DB061OJ99u7di5iYGIvnFi1ahH/84x/44YcfcPHiRTz22GNYunQpPvvsM2zcuBHbtm3De++9Z/YzgwcPxsGDB1FVVdXM3iKi1sAaJyKStQceeAApKSmYMmUKYmNj0a5dOyxZskQ6v3TpUsycOVMaMnv99dexY8eOBlkno/z8fNTW1uKRRx5BeHg4AKB///7SeQ8PD1RVVSEoKKjJdp0/fx7BwcEWz73++usYNmwYAGDmzJmYN28ezpw5g65duwIAHn30UezcuRMvv/yy9DPBwcGorq5GQUGB1C4ikh9mnIhI9t566y3U1tZizZo1+M9//gOtViudO3HiBOLi4syuj4+Pb/ReUVFRGDt2LPr3749Jkybhww8/xPXr121u082bN+Hu7m7x3IABA6R/BwYGwtPTUwqajMeKiorMfsbDwwMAGgzhEZG8MHAiItk7c+YMLl++DL1e3+Kp/yqVCtu3b8fmzZvRt29fvPfee+jVqxfy8vJsuo+/v3+jAZebm5v0b4VCYfa98Zherzc7du3aNQCG4Ukiki8GTkQka9XV1fj1r3+NyZMn489//jOefvpps2xNnz59cODAAbOf2b9/f5P3VCgUGDZsGF577TUcPnwYGo0G69atAwBoNBrodLo7tmvgwIHIzc1txjOyLCcnByEhIfD397fbPYnI/hg4EZGszZ8/H6WlpXj33Xfx8ssvo2fPnpgxY4Z0ftasWVixYgVWrlyJn3/+GQsXLsTx48cbvd+BAwekQvILFy7gq6++QnFxMfr06QMAiIiIwNGjR3Hy5ElcuXIFNTU1Fu+TmJiI48ePN2uYz5K9e/fi/vvvt8u9iMhxGDgRkWzt2rULS5cuxSeffAJvb28olUp88skn2Lt3L5YtWwYAmDx5Ml599VW89NJLiImJwfnz5/Hcc881ek9vb2/s2bMHDzzwAHr27IlXXnkFb7/9NpKSkgAAKSkp6NWrF2JjY9GpUyd8//33Fu/Tv39/3Hvvvfjyyy9b/Dxv3bqF9evXIyUlpcX3IiLHUghrl9MlIiIzGzduxJw5c5CTkwOlsvmfQ5ctW4Z169Zh27ZtdmwdETkClyMgImqm8ePH49SpU7h06RJCQ0ObfR83N7cG6zoRkTwx40RERERkJdY4EREREVmJgRMRERGRlRg4EREREVmJgRMRERGRlRg4EREREVmJgRMRERGRlRg4EREREVmJgRMRERGRlRg4EREREVnp/wEbfk3zGnzKmAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "libaarhusxyz.XYZ(rootpath + \"/processing/processed.xyz\", normalize=True).plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84d5f504-d328-4b07-8ac0-899316dd6f1e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "491955d1-68d6-49c2-9ed6-9812406dbe02", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "c19e1ad0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmoAAAGiCAYAAABXgeo7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB040lEQVR4nO3deZQVxaE/8G/ffRZmBphhBhQQ3BBxwQ2HxIWEJ6iJ4fkLz+P2QI0efZgoIArRAIYYjIrRp/wkJgf1957GLcb41KgT3J+ouKBBhYQIQtBBFJh97tb1+6Oruqvv7elZYKYvzvdzzj1zb3d1bd23p251d5UhhBAgIiIiooITCjoDREREROSNDTUiIiKiAsWGGhEREVGBYkONiIiIqECxoUZERERUoNhQIyIiIipQbKgRERERFSg21IiIiIgKFBtqRERERAWKDTUiIiKiArXPNNSWL1+OAw44AIlEAhMmTMDbb78ddJaIiIiIetU+0VB75JFHMGfOHCxatAjvvfcejjrqKEyZMgVffvll0FkjIiIi6jX7REPt9ttvx6WXXoqLLroIY8eOxYoVK1BcXIyVK1cGnTUiIiL6hmltbcXIkSNxzTXXBJ0VRILOQGdSqRTeffddLFiwwF4WCoUwefJkrF692nObZDKJZDJpfzZNEzt37sTgwYNhGEav55mIiKjQCSHQ1NSEYcOGIRTquN+mvb0dqVSqD3PmFovFkEgk+jTNm266CSeeeGKfptmRgm+offXVV8hms6iurnYtr66uxvr16z23Wbp0KW688ca+yB4REdE+bevWrdh///0917W3t6OyqAgtfZwnXU1NDTZt2tRnjbW///3vWL9+Pb7//e9j3bp1fZKmn4JvqPXEggULMGfOHPtzQ0MDRowYgZP+9TlEoiXWQjNj/Y1YO94IhwEAIu30xBnRuPUmGtuzDMm4cxmRjuMVmfxfLyq8MLPWAvU3nXYCqV9Fpun9GYBIyTKqOtCpZSGPQ0MuM/TyhGW4aFSG8S5rRwwVXsWZtcpklz+rymoijyqb2lbF1dos8yTrN51y59UjDiNeZC+y6zeXx3J7n7RppzFVF7my2vYyz/YxkFN+PR+GKoe+TqWXtfaXftx2dGy7yDhVuV3HW26dyzTs+tN/ead751e2yObUtdex6nU8dhaPLtNu/fWqp9xjJeukr+o689Ume1lk0HBXXC4e3ymRbHGvAyBSbTIfHRw/AEwZBgDM1p3WdqbHPsha54Rs+257kYo33fjPvGVKKFoKAIgNGdthHrpCaPnMNG2zlmWdfEZKhljplVQCAMLFg5w8JeQ5Wu3f4gH2uux2q85F2tp3RtSpb796E9l0XrisrD9o63IZ0WLnQ845UWScMobiA2Q6+cepSDZaYWQZ9XyqfOnbGfLY84qrO0KxIlcaOpWHVPN2vPHyJRgwYEBeGCWVSqEFwNURA/E9ylHPJAHcUV+PVCrVpYbaq6++iltvvRXvvvsuvvjiC/zxj3/EtGnTXGGWL1+OW2+9FfX19TjqqKNw11134YQTTrDXX3PNNbj11lvxxhtv7OXS9EzBN9QqKysRDoexfft21/Lt27ejpqbGc5t4PI54PP+Qih04DpF4mfWhXf5jk/9URVSeFJLOyUTE5T/I6B5WU1j+Y8ua7s8hn8uwpnBvAwDRnH9IafmP3CvPafXPNSdtAIb9D1iLWy1TjT6vxoZHPQj1T1ut0/OoypBbTrUcgIi668JIq3x00EDT82zXY8j9uT3l+mzIuhBeXftqm3jHJ3mvfNtU2ZLayTC3nrIejUw7rPyBEJblz+anYdeRlr7RapVRlc3e34DT0Mo5tl1kuUWxbLCltTyq/KYzntu4yLCGV0M6h2f9S2p7FcbzGM2lypATr29evI55WT+ueHLLqn9/5PctWjLYWTaoSsbVheMIANStGXrjWzV6/X7saA1j0d5qvVGNPb0xqd7rDVzZ0DCbvsxbltvICQ85oJMC+LN/DAIQrbvz8meUVFh/i8vk51ItT7LuE9Y5XBQ7/5wjqs5VPWg/ou0f21qdei2ztTblr5P15fxI92ma6D/cPH5MKWo/GSUDZNxOnoXfDx2/Hxlecn7sGYmiTtMItVm9aF25JSgOIB7ErUPCOu81Nja689PB//mWlhYcddRRuPjii3H22WfnrVcPJ65YsQITJkzAHXfcgSlTpmDDhg0YMmQI/vSnP+GQQw7BIYccwoZaV8ViMRx77LFYtWqV3So2TROrVq3ClVde2a242kaUIlJknRCirdZfM2odeEJ17LQ7v6DS8m026vEPuhtE2NreyIZdn82Q8Ahj5SdkhlzbWPlw/wMKp62TazQZ18KoeGKuz+G08wULmapR4MRlqA64tMxbNP8LKTz+z6p6S8dNjzx6f6lV2fTwZtj6G06FXWXzymtu2rn1Emu1fpGr+lVx6NQ6rzj0/dJRvnPDxlqdfyaZhGy82Psy0mG8Kl2hyp920lDhszGrERjKOusi7XGZrnUyNrQqUI09tQ/VMaDXg1qWKs7kpauOuXDau8dXaO0ItV+86rgjXvXQ2fYhrR2sjkOVj9z4/OLyOuZN2UbRv+e5cerfn0jSOr4ipc65wiyWvTQJpx69vi92fEn1PdUa32l1LOTn3w6nN9ZlQ9qzsa549OKG20d6ZEj1SsvGb3nHPSxdYWh5CSXzGwr2D8pi6zjOFDsHlSp/utgqazrulGFAfJgVf1L2vEf1+pb1pv8QVPnx+AGE5GC5Lv9HrP3jxu9HutePaI8fc3ZdyLjMqP5dy9+vyC2H14+VLvzYV+m4foTl5q+9FF0VMgCPQ7PXqdoaPny4a/miRYuwePHivPCnn346Tj/99A7j0x9OBIAVK1bgmWeewcqVKzF//ny8+eabePjhh/HYY4+hubkZ6XQaZWVlWLhw4d4qUrcVfEMNAObMmYMZM2bguOOOwwknnIA77rgDLS0tdkUTERFR74kY1qvP05V/t27dirKyMnu5V29aZ7rycOLSpUuxdOlSAMD999+PdevWBdpIA/aRhto555yDHTt2YOHChaivr8fRRx+N5557Lu8Bg858OeorhEusLvniBuuXRDZq/TLLRK1fPUXNzr1KLeXWvU7ZyJ7dK6CoHplMVN6XEOr4Eo3qUdJl5XaGjCciw8RbnTynElb5QrJXJHcbfTu9h0atjyWtQyIV97jXwiO/qicsHU+6yua1nUojpPUSpuPtrjDhjJU3Vf5wxn2I6tua4awrbbUu3mbVhynjVPVuavlX2yr6PlZ1ZoaycvuwK/9e9F7N3PyoMuj1p/KSzakvfb+rddlIWsbjrFN5KWko6zBvWXlMq30S0eJWy1JFbXnbq3C5+0vVmV4Or+NUye2BNH2O987i0I9VdcztSXx6nOq7rx8Tuce6Xs5o0uoNKil3elHVeaS92LlvKTcOlW8AiLfGZX6c/3yqNzmdSHe4Ts+/kY3L/MheVe2QVr2Nek+k6jkMt+s9+e7/vKoXMDmgm5fdcui9sUa2WOa94x7dVLxNW2el3VLeKPPk1FvbAOs+r5KGhAyrf6fl9z3r05UJp/dY1Z+eL1WHHfXW60ytNyv/ioi279LuvOpx5l5BseIVOcs67sn3Yl+xCcvzRso5ZzpXaqx0k+mut7zCAfWoqdyXlZW5Gmo90ZOHEwvBPtFQA4Arr7yy25c6czXu9ylCA6zLFi3lVre3UP985D/D5jb90qe8hyHW7o7I7N4N83lkAwBhj+s5SibmDpv7HoDRbpUllHb+YZhRd15VueD6BxXLXyZPrJGUdfJKF7U66ah/1FF5X5RWfiHzZKcb0R9s6OBkn9EuqantVNhs1BXGyHR+z49IqBuzrXy1JNUDI+46FeGObxp27ePc/ZPtPA9qX+TFBQBeZVD/fCI5l4X0upHrjKjV8BN6PPJ4aR+gLt9oDdioO05VbkMrh1pm151HHlTdG0I11NQ9VNo/mpwwQmstGML/eyK8rmfnUHHox4E65lQ+cuPxTdejQWvXRUfHK7TvDIBQ0vq+NQ0uzguXSjjfm9zvix5/tK1ErtO+gzJcRh4/+vcs9weMTv+RkCuSdk7xqkGqL8tt3Kgw6sdGT+k/sHJ/qAHODyP1Q83Uzhv2D5SyHXnxtg/YDQBo3VnlCtsRrx8wuT88Ij4/Nvx+DHg17L1+jOb+UNTz7BU+90dkbhr6dl7UD7uQx/+p3PQy2sMmlG/mzJlBZwHAPtRQIyIiomAE3aO2N/Tk4cRC0K8aamWDNiNcZv0Kbkw0u9ZFItYvyHTG+XUaj1s9atGQ/682XbaTXgQACMsegGg4/yZbtX1a/oIPa70FIdV7JX8ppUqtX/aplPPLPhZzftEDQFjm3dR67IRMI6v1sKj3mbS8HKDFozrZQ/IXnan3AshlUdkrEQu3a+uyrjLkls3aTj5BF7L+ps2Yu4xZOXSCT+9LPNLu2qY9XSLLGXLlNxbtuJdAz7fKU0imqfLkpzXpdMknolYvlSq/Kq++D3KPqdywej5KItaxmtLyofLUUmRdHtL3STgsn3KV6RlGfq+ASk/lVafykDXdPQ3qWNKPSbV/vJid9DyHfHqwcuPIZp1TlTrmVLm6E4/wuMM/rHocfY6xTEa7zCnPEa3p/J4sI+Zcwgvn9ODq/+OSqSLkUZfYVQ+qVma7F9+jd9dIdbwPvHpRPXsc5fFj9y5Gun7O86T3+KieIK9luT3qACKyDssTuwG4j7cmebw3xVvztnPi1p/i9DkGVbhM599v3+319yo9r3TtnmCP/OnhvcLl8itX7pUAr3jk9mZT10dHCxsioIbanj3Mp9ubDyf2pX7VUCMiIqJvrubmZmzcuNH+vGnTJqxduxaDBg3CiBEj9smHE/tVQ+3gko2Illi/gr+I7gYAtGSsx9AT4ba88JWxr1yfI+j4oYJMN6pSxRPx+AWfkb92veJT26l1Sdmrsjs90A4zIGL1AoYNK2xc9lTpPX1JU/YIZJ2eONVbY8pwen2ouJywTk9CLJR0pRMPOb1WcSPpKqcqW1LE88Ik5PbtMh+qjCqPKg96nan4ysNWmdtlvLvSFa78ql/kXvWdW08AkMjJd26evOyKOmkOlMdWR/srNz2dvp9KQq2uv3q9qTw1ynEBM9p2Kt8qPa+0VLlV3DqVjjpOcute7+FQaWRFx3Wj8pZ7HOjHSi4Vnwqr10vu/lT560oevOTG40X/rrTJ93pPq8qT/r2J5ZRPP/52y2NUr0tVxpjcXymPnlw9TdVLmJY9n6KT3nzVY+gVTsVl94J34ypCZ3J71PVlub3XADBYnnfVcaufdxtjXwMA/ulxNUL1Unelh1XXWc9vT3hdWfG6guKVdkf59zpW/MKpnnG/KzfZaCu+zFvbUbzBPPXZ3b3zzjvvYNKkSfZnNfj9jBkzcP/99++1hxP7Ur9qqBEREVH3hUMB3aPWzSufp556KoTw32hvPJzYl/yfYyYiIiKiwPSrHrUR0c8Rk9N3qEs+n6erXZ/1S0Gl8n3C6Pp8hhnZURtBNm+ZotZFPC61ZNQlny50+LYLd1kA5zJg7uU7/dKPirsh69wAry4bqi5xPc7cOLwuszmXMJ3LPareSo1WVxoq33oYVRe55W8OF7vW6/tC5UPtJxW/+hzOucTsVd+5+QCc/aPq0Cvfuft5v0i9b5y52+dehs29PKinn4C8LAwtfVlPzZFdrnzo+VVxqn2S0S4N5h4fXsdrs9lx3efm2+t4zfhcitTjdS2T+VDxtZv5N+x3ZX92JS+52+t1kKtdu+zcIutFX5Zbn4DznfBKr0HtNy28upytbgPw+p61m/ox6L49wO/yrh6HV7y52/pdlu6ujtIAnPOMXg/qfXmoMW/dYFlvXpe7VZ71c5dfnaj668oDYJ3p6PK+zusWBJV22Oj42PO75cY3T7J8ftu3ZzLY2OFat2/CU5/7qn7VUCMiIqLuY0MtOLz0SURERFSg+lWPWpWxGwnDekKqQo5NlXvJrSbsPOmpLjmVGO6R5jNa+zYCM29ZV2U9fiv4dYHnhleX0kqjzpNmFYZ16TP30pp+2U0pNdo6XO+6FNjBZUl3eOuyQynatO2sPJTBGqunxbDGe0pqaam6VZed2g33OFFJw52vuN9laPlrr9LYbcUF97Z6eXMv2ZUbznhCKi9h+VflIQknb/ZlZxmnvm/UOj1OKy2PaZ7gvpysH2t5+dDK0wKrLqtD1lNwSY/9q8rvdUkvN99hLYyKqzK829recOfD67j1utTT0eV7r/zkXV5X24by48rdPu+zx5PBXrckdJQHIL+s+vejPWy9V5eG9W0T2uVOdf7IvZwLABWhprz86JdSrTjzL1npYVTZmkNWPvSngr2ecFaXYpMi/3Ly3qZf9vW7/FjqcelT2S9kPY+ozrEA0CKs4z4Sk+cLj8vPrtsjfI7VjP3d6/jfoL4PvPajE2fEFd4rTlVWr9tQvG7p8KoTP7n17Le9KsuOcNfHkGOPWnD6VUONiIiIum9feerzm4gNNSIiIvIVQjANNZ/55/uNftVQ29/8GkWmVWR1ia1ETh20XViDxg4znEufZcK6PBQWpvxrHTFZo2dHa+72WZ/LpWHZ3a+H6Sh8Y8i5BFMmWl15VpLaJUUVT9JotJfZlwHkuhLkTCwOIGvIy0DaJcAE5LRCsis9rj1hFBfWuoT82y4vt+l5iQhru5jcTtVRSqalwqq4ujKbiNomt77C2iUU57KitSxmalN1wV13poxH5UmPu8i08vVpyBkscbhhTSZdLKxLMVFZRlPLT5vMY8ZwX5JT8enpqfrTt/8qVAoAqDSbXfHpkjnLVH4A5/hQ5fA6tuxjUE67pPZRSjtthNHxcaaouFVYtc9d5H6160OGUZ+TWprqUlhH8enHfm65Mkb+hRS1fe53RtdqOJfY1CXwlrAzdZO6vK9T34XcsnSWhtel7ri8jKrfCqDy0R6Sl2JF/iTxXpdic28J8KLC9lRnadiXheXlOf18U202AABS6nYA08nLzrA1PZw6b+u3I3hR8eqXKzP2MS8vHQtnOq/cfHmx94/H7QZeVNqD5fnWKy86r9sROuJ5+4waVUB9P3xGICiPdO/yapCOP/54hMNhzJo1C7NmzQo6O32qXzXUiIiIqPsCu0dNprlmzRqUlZX5B/6GYkONiIiIfIVC1qvP0+37JAsO64CIiIioQPWrHrVB6RSK03LCWjlKdCysJiG2/o7KfG2HT2TlPTo53b36Uyi567zC5GoPd94+du7V8ruPzQpToo0iHpP3w0Rz7rfJwsmoKe+R0++5MnPa7Ln3aQFAWobX7/tx0nPf86XnIWqaMt1UXpnCOTedqbDpnJ9uYY+520I5y9Q2TSHrXp8Bpnt0db0OYrn1o913mLvfVX21hLR784R76ISRhjO1cUXWfX/fAHnMtbuuG1j367WH3PeM6PWh8uFlQDjpChMWzmjsu6NWPlX9qDhV3eplUvtCrw+1ncpb7j7y2heK1/2bqt794sk9zs2c+zhLtHv3VBp++ehO/lQ8uceTLq2Ndt9uyPtcQ87pc0A2fyT/3HrXzwnqHKCXQR1fXven5t4LCDjf3xZ5b1tLyLmPTt0fZ9/b2UUqzVgPR8NXdhkl9nuv+yiLZL5C8rhLmE56ZRnrfWPEql/9uKnOWPd5DYN1H5vaF64yGPr33Pru6ee6sH1852+r7r9U94pGPe6nVPHr58zcY1LPg4ojkbXKldbykva5b1Gdg73izD1fe/HLu2Jk2vLCdCToS5/9Wb9qqBEREVH3saEWHF76JCIiIipQ7FEjIiIiX+GQ9erzdPs+yYLTrxpqEVMgaqr7Rqy/jWHrPoCBwhoHSb8vSN0bEDXdn+Pa7RtmBwduyOw4jEpbv2epo3vaQh7j+SSyVmBTbh4N5d97lHu/jT7akAoTNfLve/G6HyL3fjn9vgp170w0Z6w5d5zqnfUmod07ocqSDrn7t2MZOS6bXN8asdIuzuj7BzKvkGHkZzkWkro3zK4nMz9v6l6hYu3+LRVOxZ+W+69Yqy+VX5V2hTYOVInMuxqoUZWxOO2kr46JtNx3XvcslaZk2aOGqxwAMCiZcS3Tj8l2ed9lecpdfr2OnXsB1X2E+XWTMFQ9uPeRV1iv+8ZU+I4GrNTLk1D3ZXUwRqG+382cILnpeB2DKl61L6xlKnx+euorpfZTSDs+khGrsqPa16cpagUckNbGcPOJX51n9P1WHFX3clqfy5POhq3yC+zeh9Zxvjtm3U+V1cZyU/d5pbTw9vde23+55yIVprEbUwt5GZd07tlUeYiZzn1+LRHrHFKRyr8XTtVracoq186EcwIdJOt3gLwlMB12tve6X7g5po4N51495/iR4xxq9dEScZ+s9eNFhUuG8+tRbRczPe5RM93fo6w2LZWqdz2d3O+Z531vHt/BhphVp+q7krDPnc52ud/FlnT+/4COhAzr1deCSLPQ8NInERERUYHqVz1qRERE1H2hkIFwAN1bVm9S/55Hig01IiIi8sVLn8FhQ42IiIh88WGC4PAeNSIiIqIC1a961EzDeeLn66gczVuO6v2FMQgA8FXceXpvqLkLAFCWtZ6uskes1x6hVE/W5D7hpZ7UU+l60UelV09S5o54r4+mr0boNg33U5i5o+wD/iP7+43O7sV+ok/dJ6A9tameEkvLvLQb+aN1q59EajTthPYEVnsHjwSWZK00kjk/p/Sn3pI5xcid8UE9UWU/daet7ujpQlf4HPqTViofrWHrKzQg4+w39ZRb7lNX6ilOa3t3POr40fdbY7H13vTIa3HIfZzUx52n9AankzLdkCtuPZ6s4X76Wa9X5wlJ95OYalflPqHrlh+PSj/3qTy9rOopVFWfxXIU9xL5BNv2hFM+tS53dgV1fHody15PWisxjyfo/Kh6iCL/eNgd02btkPGq40E/ruwnabWHK3PrvSGen1f9KU715KSdnnYeUOH0OlZPI+txIOc4TphZGVf+0+bdoX+tVdzpUP4T9Yrr+yg3HtIq8xbNr+emuHqS2tmsKZb/dHTW4yl4VW+qPpqiTj2qJ6XVd2d31PkXmXuebdeqXx2D7bK69dkUdssZFgbI/yM6dQzrcZk53xv1ndKfDFVPnur70p6JRLiP9bjHE6WqjpqjXe+r4aXP4PSrhhoRERF1Hy99BoeXPomIiIgKFBtqRERE5CtkGAiFAnjJS8HHH388xo4di+XLlwdcE32Plz6JiIjIV9D3qK1ZswZlZWV9n4EC0K8aaqUpgRJ5Q/e2uFX0MtN6eGCrvLE/bjh3p5aY1ns1FVE8f7YTW27XZEK7mdRrahMAqMmktTDWe2e6o/xt1Tp1g+wAecOvfkNtOueCvrp/N+GR93gmP2NpecdzVEu4IZEzlZbHrCMqXa+yqgcrvKY9yS2vyq/6rG66HyCn02mKa9uGVDmsv+VyahZ1I7OadkfdeKtPyZM3xZZ273Q8bYXPyLpolTd8F2v3AlfK7Zvj1sIdRc4RUNVmuuKMetyXrfZHe8R9U3+zdnN5fdwqgDoO9WmUFHXjcMxM2stUOXcUuXeGulHa2s7663V85NaNOibUfm/3OGs45cnPW2vUHVbd0BwznfzYD2Com9lzHnLQH9bIfZhBPXji9UBG1HTXmbqxHXCmPWv3+O/THrLCqZvq2w2nECE53VVDqNheVp1pBAA0RZwDNGFmZL6s+NV+BJy60adqUg/bFIetY2pTpMqJ32xwxQUArfJBqIjMY0ab2i2r4hLOcdEUkg8TaOEajSJ3weWqSrMZe2JzIpG3bIdRbr+vElZ5vo5YdVmRzZ+CrTnuPu8AzndZ3ezfpB1bat9mtbOxmuKuJeTUc4mcemtb3Mpjk1YHxRGnvgB3/ewUViMhbljbJ4UT5yCjUaZtVeBA4dRf0nB/AVSeAGCXPIZ2GgOc/Mnp6FQ4tX9jUec7sMsoscoFp55Hmda0XbvlIb4zVAoAqMk22GFUPag6ak52fQopCk6/aqgRERFR9wX2MEH/npQAABtqRERE1AlD3jPW5+myocaHCYiIiIgKVaANtQMOOACGYbheN998syvMhx9+iJNOOgmJRALDhw/HLbfcElBuiYiI+if1MEEQr/4u8EufP//5z3HppZfanwcMcG6qbGxsxGmnnYbJkydjxYoV+Otf/4qLL74YFRUVuOyyy4LILhERUb8TClmvPk+Xlz6Db6gNGDAANTU1nusefPBBpFIprFy5ErFYDIcffjjWrl2L22+/nQ01IiKiPqLGNevzdNlQC76hdvPNN2PJkiUYMWIEzjvvPMyePRsROTfa6tWrcfLJJyMWcx6DnjJlCn71q19h165dGDhwoGecyWQSyaTzmHVjo/Xo9KFbohhQasW9f1kbAGBLpfXoc+3XnwIAyhv08S3kHIKZmPwL118/hvbUsylrORtxr4uk8sOn5dPWatgEw+PpaaHmk5PbR1qcYQ6yCfdPHiEfZze0+d7CcogSQ3s020hb740WWbiEPvmcFV7Ew67PVkat+IUcgsOMO9upcmfkMBGRNms7fZrKrJzPMCt3sQqjyh1KqTf5JwiV50xJ2BVvJmdYipYKOYRFu7M80SDnTZX5DqWdMnkt0/OqC8uhMPQ01bJwu6xTWfftldrQEC3ucqZLZD1o38i2UjmcgpzDMJZyVrYnrA3LdltlL2pw8vr1ftb7A+XwKxk5BEhpo7N97jEca8o/G6YGGK68hjJyXtuYU1ZVV+q41fOfm0ZKDvPSWiyHHdCGh1FDrahlrUVqubXNwF1OxC2yXjLyUIvIcTlUHBmP8WPa5FAPJW3aPLUy7h1lVnh9aJvWiJV5NWxKSDhf1iY5P+IXMef8o+aB3C/Zkpd2say3wc1OeRuLrGWDwm32MjVP6M6IVfiR2a+cMsthFaLaHJxVZpMVv5z7dLc2NIgaTkQNP6THkfW442WgsPL9mTEEADAEjXlhumOXNhRHGFaey9CaF07lRR9GZT87aau+hu7Kz29Kzv+5eZBz3Fa1Wfvos9JYXng1VAoAVKStYVIa5fAcVdkme90X4XKZr7Ar7wBQYlh1mfGoPxW+GNb/HX0+48FZq9yDkmqOWme7liIrr2q4EsAZzqMRcvgXGf5r4YwhNgzWsTFE207NF62GbVHlqg87+yIu81Uk/8awZ3O6Ut8ItKH2k5/8BMcccwwGDRqEN954AwsWLMAXX3yB22+/HQBQX1+PUaNGubaprq6213XUUFu6dCluvPHG3s08ERFRP8FLn8HZ69U+f/78vAcEcl/r168HAMyZMwennnoqjjzySFx++eVYtmwZ7rrrLldvWE8sWLAADQ0N9mvr1q17o2hERET9kmqoBfHq7/Z6j9rcuXMxc+ZM3zCjR4/2XD5hwgRkMhls3rwZhx56KGpqarB9+3ZXGPW5o/vaACAejyMej3e4noiIiGhfsNcbalVVVaiqquo8oIe1a9ciFAphyBDrPona2lpcf/31SKfTiEat6/Z1dXU49NBDO7zsSURERHsXHyYITmCdiqtXr8Ydd9yBDz74AJ9++ikefPBBzJ49GxdccIHdCDvvvPMQi8VwySWX4KOPPsIjjzyCO++8E3PmzAkq20RERP1OyAjo0ifHUQvuYYJ4PI6HH34YixcvRjKZxKhRozB79mxXI6y8vBwvvPACZs2ahWOPPRaVlZVYuHAhh+YgIiKifiGwhtoxxxyDN998s9NwRx55JF577bU+yBERERF5CezSJx8mCH4ctb5U+vjnGBC39rr58S4AwAmjrJkQmjZZY86Ei7WxpuRYYqGY9Tdabo15Y6a0sZjkOF+GHK9MyDGzjJh2dMmxmwy5nQprhp0wImvFk5XjmKkU0q3O+D+G/JKo7dOtVqiWRmfMnkSxlde0zFfF0CJXWQCgdYc1HlCq3Rm7KNVuxdXcbC0bUOaEb9ht5SESkeOLaUVLyHHborK84YjzRY7IZRlVRx5fcvXFj8nx7drluFURmd+MzFdsgHWP4u6tzlhMKs1EubUuK8dVSzZb+U2UWcsrxg2yyr3RGXOoWcYblnFESqL2unCRlXZW7svWL1pdebDCWPltlOvUPtGF5XhbIfnXTDv1nZHhs7JuYjKveiwJua68qigvjWybHJNJhslq64aOtcrbvmGXK4y+vTqG1bGd1I5pkXXfFNK4O5VXfiXVZB17icHWwzv6OVXFrfJaUir3x6CEKw8AIGQe1fdgsAyr8hKRdQAAA3O3aVMDHMrvR8w5dkNyP6l1ZrPzXQkNKwEAHFDV8YNHalxCodVdmxzOatxA50GnRNJaX9Tq1JEaJ7Hoa3msbXXGWBODrToQUafGmva38rpzsPX91Md0bCu2loW0IeLi7Wpbdc5y6rOlVBukUUpFrWM1GXX2b7Mc225gixXXcTFrPMnsHv5zPMp0xof7Qo7HN3y3s14NdafSGdjolLXmI6scYoO1gb1/AYTlcSCGWmOMDRnljJmWiVll2a/YqYd2OX6ePmZfU7Esc7s1YFuVVs87yq19qnZjQhsLMC7fR+W4ffq+aJNpV7TkV1zlDmv/xNqtvOpjYx5eaY1wYGo3Yu0YaCXUGvvaKoPcva0RJ+79G61IBjZp53U5tmIy2gwAGLrDKsT2Smc8vlDOEIO7W7swKKhkBPQEpsGGGidlJyIiIipUbKgRERGRLyNkBPYCgOOPPx5jx47F8uXLA66JvtevLn0SERFR9wU2M4FMc82aNSgrK/MP/A3FhhoRERH54sMEwWEVEBERERUo9qgRERGRL/1+sb5Nt8+TLDhsqBEREZGvoO9R689YBUREREQFql/1qP3jpXqUyoEr/77NGuhvzbPWIJCnDJODIJY6bdeyAXLA1oy1Tg3uqgaV1ZlyIEEhB2zVu4jb5cC0KTlAp7ohM6INDmvK7Vpb3SMSmtrHRMKQ+bE+x2LW5/qvnEELS4ucwR4BoGF3c15eU2krrWTaGWRRpR+PWnG273ASjsllTS3WMlMbDzXakjOCokaVU6Wj4o5o1afqICJHB40nvH87RHen85apQX3RYK1rkmFUWb74pzWY5MD69rxts3Kfql9r+kC9YTmwZMkga4BKNbDwV/90BvFUZVP7S+0LACgqVsdJRKZlhfnn1qQdZujQmCuv2c+tuNu1QYhV3bR/aA3MWVzs1I3aTuWjpMz5KjdutvZ5uxzMMp1yl1WnBg0uH+YMKNsuB7j9qj4py2PtMK/nrXZtt8I0/0MOCqzVQ0zGrdJV3yM/Kj/qe6SO/4HVzqC0amDjNjmwce53z09JmTMgbUm1NeisPQB1yql7tUwNbBzSBrAukcvKyp08heQAvfqAutkGq26SO62/DZ8538WoHHg7Xu4M2Fq8nzUA7wA12K+Wn4EynD6YL9Qg1qrc2jlnkFqmDeQMOXBsdniJU86kHAxZDdT9tTxG0x1/r7tEG8h3zIGlAIBIi3NuCsnvFOQA3+Z2ZyDr3e/tAAB8tt6qr4R2ThhYadWD2ndFcvBkAIiNsAYvHzxQG8BYDapc5Hw/UsOsbSJN1rpsiRP/yDarHtQAx4Z2jjRknQh5Hgu1a+dau77kYL1aeYyBVnpta6zBdLPaQM9DDrWGbzaGl9rLhsr9aCbc/2dc6Uki6uwnlWe7blPWOaWqXRvUVh4Pphy8uqmp65cyeekzOP2qoUZERETdFzICeuqTk7Lz0icRERFRoWKPGhEREfkyQsFchuSlTzbUiIiIqBOhsIFQOIBLn3t4u+Q3AduqRERERAWKPWpERETki099BocNNSIiIvJlhA172Jo+TZeXPtlQIyIiok4E1KPGG7RYBUREREQFiz1qRERE5ItPfQanXzXU4vEQEnJanpFV1vQca76ypgjZ0mD9LU3kT0NTVmFNt+FMN+R0REbkVDBqWhshDyo1bRDgTDkVldPreI3urKYwKi1zp2Fq0+Jk5JQyKqyaQmnk/s40NGoKnkSJlWZaThGjprHSy9GmTVel0lHTBenT8ZTK8qfazbx1uVMZ6V3jKp/xUuswM2UdZbVpWYrkNE0ZOT1KWE49Y8opbbLJrOtzxaEVTtpyKhY19U8kbk2ZkpFlLirOuvKkT6GUkFMJJeU0RLEiZ7qWaImV35iciiZRKWTeWuwwLXLaquoKK0ys1Pkqtey0pmBS09wImfcDtGmIEhVWuVu+sqbsaWm08qGmyNFF5b7T613t51gifzqzr7+04lRTUKmpm2L6NEhl7q++yiMAxOX0MmVyf6uptNRJOqtNLzRITseDz/On6cqljhE1lZo+PZqaekod06mUewqpzDYnfnXMqTC5cejxqrJn1Kw62jZNOdOS6dOIqWNFTTWmH9eq7gcf4kyqtfvTJgDufZTOmTKuqdGZykd9z9q1aZVSTVZ+mndZx8/gUc60QureoFSjk+dwzH1BJKNNMRSRx4XXpap4lTNdmMjK72SbtW260Up7+6aWvO26o2pEcV4+Y9rUTs1bml35a9jhTK+2e7eVF7U/9X22/XMrXPsm67uuprcDgMGVXwNwT4cWlvUQ1qaQysqptIScqssIO/WYtacTk9857Xuh4lDLVN0BQOvn1pRR6tyRlNOwAc4xkZJ1rB+fKlzJNmd6seRX1rEe0af/ApBpcfZ9otqq35B23mrd3OTaLiLLl9GmNYvYZZbH5Gf5Uwx2hPeoBYeXPomIiIgKVL/qUSMiIqLuMwzvHtreTzf/Kld/w4YaERER+Qrs0mcAaRYaXvokIiIiKlBsqBEREZEv1aMWxAsAjj/+eIwdOxbLly8PuCb6Hi99EhERkS8jHHI9Idt36Vp/16xZg7KyMv/A31DsUSMiIiIqUOxRIyIiIl98mCA4bKgRERGRLzbUgsOGGhEREfkyQgE11IKYCL7A8B41IiIiogLVr3rU9juuEmVybs7GjQ0AgMnN1px2nzdaYaoGO1VSfZA1115ivxIAQEjO9WbEnPnVjJz59kQqf2IyIeeNs7eTc8SZbZm8sKFSa15Fr18uZrN7bkI115zrSRy5Xbg8LrdJ5edLzdnY4MxHl5ee9jkk8y3sfDtzCqryq7oJlTrz0xllct5K9VfOIwhtPkREZZ2oelRz6+V8FnLOvmyZE39UzXsof3EVy7kSs5sbXdumd1pz54W1vEW0+Q4BwBiYsN9na6z3htw+JOcDLdLqv1LNqyjzmdnSZK+rkHVvDLeOH1POA1oUd46byJdWngZ8bh1/mR3W3IV6vad3WvMalsl61+crVPMNxmQ5VBkBoKRSzh8q5xFVcw2WDHbmWiwaZh3Tar/n1gcAlKv6kvOvil1JV9qAc2yXjcm68gw4cwyq9NV2ufO46ssyHvOA6nHo1Jyfal5cNQenPj+umqvTi5rbU8Ud0b7LuXP26vGodFK7nLKquWPbtDke1Tys9py3xc7+V/Op6vNzqjlUVXkat7Xa64rk3LCmNs9qSh6Xak7RZm0u0ZLScF6aav7PzFZnfkc9PgBItuSfk3qiXZuT1K67+o7ng41qdb/fCKtuwlE1t6xT94YMpuYd1ulztdrLcubn1Kn5OfXjMFosz2PR/D6MTM75V83NCjhzBjvzGWv7Sea1aIDMi3Z8qny1b2+zl6Vbrbiyaq5Yj/8FzZ81udLTqe3UfKX6uT3dkJTLut9HE/RTn/1Zv2qoERERUffxHrXg8NInERERUYHqtYbaTTfdhIkTJ6K4uBgVFRWeYbZs2YIzzzwTxcXFGDJkCObNm4dMxt31/vLLL+OYY45BPB7HQQcdhPvvv7+3skxERERewkZwr36u1xpqqVQK06dPxxVXXOG5PpvN4swzz0QqlcIbb7yBBx54APfffz8WLlxoh9m0aRPOPPNMTJo0CWvXrsXVV1+NH/3oR3j++ed7K9tERESUI+gppPqzXrtH7cYbbwSADnvAXnjhBXz88cf4y1/+gurqahx99NFYsmQJrrvuOixevBixWAwrVqzAqFGjsGzZMgDAYYcdhtdffx2//vWvMWXKlN7KOhEREVFBCOwetdWrV+OII45AdXW1vWzKlClobGzERx99ZIeZPHmya7spU6Zg9erVvnEnk0k0Nja6XkRERNQz6qnPIF79XWA1UF9f72qkAbA/19fX+4ZpbGxEW1sbOrJ06VKUl5fbr+HDh+/l3BMREfUjoYDuT+OAt91rqM2fPx+GYfi+1q9f31t57bIFCxagoaHBfm3dujXoLBERERF1W7fuUZs7dy5mzpzpG2b06NFdiqumpgZvv/22a9n27dvtdeqvWqaHKSsrQ1FR/gCdSjweRzwe73A9ERERdR3HUQtOtxpqVVVVqKqq2isJ19bW4qabbsKXX36JIUOGAADq6upQVlaGsWPH2mGeffZZ13Z1dXWora3dK3kgIiKiLggbQBD3i4U7nl2kv+i1pz63bNmCnTt3YsuWLchms1i7di0A4KCDDkJpaSlOO+00jB07FhdeeCFuueUW1NfX44YbbsCsWbPs3rDLL78cd999N6699lpcfPHFePHFF/Hoo4/imWee6a1sExERUQ72qAWn1xpqCxcuxAMPPGB/Hj9+PADgpZdewqmnnopwOIynn34aV1xxBWpra1FSUoIZM2bg5z//ub3NqFGj8Mwzz2D27Nm48847sf/+++N3v/sdh+YgIiKifsEQQnzj+xUbGxtRXl6OL144AWUlVts01iAn4l2zAwDQ8rfdAICyk4fZ27WPLbP+WnNrI5mwqioV0ybcjcqJu013qz/kUasqSEQmnWh3upFNNdmwjFt91qNNJN1pZCJWIq0JJz+JVMiVr+I2OWm6mb+dqfViZ2T3svobS+t5c5cxktW3c4dJRoW2Tk44rOb2ltuFtbykcybcVZ/b5U+IdM4TP+3ar6uYnNy4WE76XCrnyC5rDckyWGEr661ImyucvO0u1woBoFmrwwY5P3si48531L0JACArq2nILuc3z66yrIzHSu+rIiv9lOHU6Ug5wfPAFmtZWZOcRLvdKV9czskda5LHhDbpdHKA9b6t1EqjqNlZV/S1lX6oVU7KrCanHxyzw7SXywmvZbYbKpzCqWNH1YnaXyXyeC1tyZ8lWR1f0ZSTj4Sc+zvSZsVnyP1lyImkDX2ybTW5tJoUXE5EDzURfUo7aLI5E1GryzGynl1hU1l3GP3XuVrnMbE1ZJ2pSed1XsMFqHBmmzOzihGz8hNSk9uXOfUPNQm5NtF39vMW62+DNbF7qCi/nsPl+ffeqrRT9c4k7mGZZqTKuZfXzrc2AbpdV7JesjutidPNnAnIuytU5HwfMnIi8KieF7lepaOHN0YOsNbJCeVDzfkTxWfL5cTtDVo+26x6ELucyd8NVecxpy7FV22utI1Y12b9tvMo60po+9qJy+PSoKz3UHksb5WKQ2jHrB4vAIjc413Ls1dvk72uuthasCvp5FPGrfLZlBaomP83NDQ0oKysLD/vcP5/7rrpIJQl+n6G9Mb2LAZev9E3j990nJSdiIiIfAU1ppnBe9Q4KTsRERFRoWKPGhEREflTA94GkW4/x4YaERER+QsH1FDjU5+89ElERERUqNhQIyIiIn9BzPOp9eIdf/zxGDt2LJYvXx5wRfQ9XvokIiIif6GAJkiXaa5Zs6bfDs/BHjUiIiKiAsUeNSIiIvIXDnGuz4CwoUZERET++NRnYNhQIyIiIn8cRy0wvEeNiIiIqECxR42IiIj88dJnYNhQIyIiIn8BD8/Rn/HSJxEREVGB6lc9ah8clkZJmQkAqGmw2qjFBw4BAFRurQYA7KxyWu8N5VkAwKaqrCuetNbCzxrqvfUIcVhYf0M+TxSrMFnDzFum4nbidURNM28ZAOyIxe33JWZavjNkPqxtTC2+9lAYAJAywk6ZtPd6fgAgKrId5smPKX8HhOCdb11u+lm5bathlS0jP5eIZN62JTFrmVlshakpaZVrrDIMHWDlv6HI2WZHwjr0VTkbw87KFplmblpqOQBkZH7jwqrvweWt9rqoadXT7kgCANBuRAEAu4xSJ7LSHQCAf5Za6Q8YlAEAFKedeh+2y10nqahzHDYn3MdZcYWzb2LVVj1Estb2kYy1rrnE2f7LAdY+ScozgH5MN0asha0hq04SsowDMlYeB6TTyNUuL0/o+S+WwUrbrfyk5WP25c3ucgFAyLSWxVIxAIApf0JmIkIud/IXzriPQxU2K8Pq60OmO0w0lZc0InKZ9nVEOGnFJeR2oYyzzjCtdW0Dnd+5pZutY8VIOGUTUSsf6ZgVrrFai1/msagx4YQfM8DKY4uVESPtZCjUau07U4s/92d27KjB9vtMiRUuq+U7G7fSNLWzviqXkZXnpHgFACC+U9uwB7JFTj5VNtNRbR8mVXqG6zMA7Bhpvf+80spDUcqJa0CrPKfI71ii3flOlu40ZFmKnbRV+TJaXZZYFSDKrO9lqNmjrHIfq3rRlymi1KlI+9iRhTXjWvmT1r5LllnhszEnjniDtaHav4A6cwNCfqfsz1r9hdrzjxEV3pT5Uuuy+znntnCLlY7RapVZpLs+9IUIG3YafSmINAtNv2qoERERUQ/w0mdgeOmTiIiIqECxR42IiIh88dJncNhQIyIiIn8hBHMNjtf9WAVEREREhYo9akRERORLhIO5DCnyHxLvd9hQIyIiIn9GQE99dnNYqG8iNtSIiIjIlwgZEAE01IJIs9DwHjUiIiKiAsUeNSIiIvIlQs5MHX2dbn/HhhoRERH5YkMtOKwCIiIiogLFHjUiIiLyxZkJgsOGGhEREfnipc/gsAqIiIiIChR71IiIiMgXe9SCw4YaERER+WJDrXuSySTi8fheiWsfrQIiIiKiwvDnP/8ZM2bMwOjRoxGNRlFcXIyysjKccsopuOmmm/D555/3OO5+1aO2pSSO4hKryGaoHQAQH2ACAJpLrDZrc8K0w39Rai1rD1vbtISiXU4rLITzHlacIbksbXQ8y2zWZ14zFaeKLyXjaTecfLWH3Ls069EWV8uS2naZnHARw6kHlZ5XXN0J4yeJqIwnK+Nx11G7XK/ny97WyNkvMetPVFhxhUqTAIDdUaduWkNWIFWHehytsH4FtRjW34gsm8ojAGRk/koM6zjaHK621x0Y/kKWIeT6W4ykHaYpHHflMR1T9Za2w3w+UK6TVZHUnn5KhazwMdM6JuIJ53iDrMNiGZUpN2vXDo2GmBVpY9iqB/2YVPltleWPCyui9qj1tyWcssOGoY5puU0ka6+Lxq11iSKr/uIZa3ljUQa5oln3X0WVPaQVLywPgUjWKlgyKlzLQ8Kpp1DO4RLOP3zs8JGMs50qhil3i75OxRlvd+L4eqxVj4bphGspzco4rA2aip3E7TgGO+ErGuQ+GW6Vp7zB2WEiZK3LeJyxVVym9tUz9QrLWaavyy1fKirPVcP27Ek7U/uequT0OmwutuomlrYykIk4eVLl+eeAsNzeWTdggLVduaz74qQTZ2txSG7vLIulDLlMPy/lnOtSzvc6m1O/0RTyqKj0np6szL/a/+mYk+dUzJDbyeNBq9rEIHXsOQmbHZxC9f0Wb4/m5a+5TO47mUA0FcnLSyQTlvm01jU1538XO2IaHeetN5kF/tDnH//4R1x33XVoamrCGWecgeuuuw7Dhg1DUVERdu7ciXXr1uEvf/kLlixZgpkzZ2LJkiWoqqrqVhr9qqFGRERE3cdLn95uueUW/PrXv8bpp5+OUCg/s//2b/8GANi2bRvuuusu/Pd//zdmz57drTR6rQpuuukmTJw4EcXFxaioqPAMYxhG3uvhhx92hXn55ZdxzDHHIB6P46CDDsL999/fW1kmIiIiD2YouFchW716Nc4880zPRppuv/32w80339ztRhrQiw21VCqF6dOn44orrvANd9999+GLL76wX9OmTbPXbdq0CWeeeSYmTZqEtWvX4uqrr8aPfvQjPP/8872VbSIiIqKC0WuXPm+88UYA6LQHrKKiAjU1NZ7rVqxYgVGjRmHZsmUAgMMOOwyvv/46fv3rX2PKlCkdxplMJpFMOvcDNTY2djP3REREpAR96fP4449HOBzGrFmzMGvWrL7PSBcIIfD444/jpZdewpdffgnTdN8U+8QTT/Qo3sA7FWfNmoXKykqccMIJWLlyJYR24+jq1asxefJkV/gpU6Zg9erVvnEuXboU5eXl9mv48OG9knciIqL+QAR02VM11NasWYOPP/64YBtpAHD11VfjwgsvxKZNm1BaWupqh5SXl/c43kAfJvj5z3+O73znOyguLsYLL7yA//iP/0BzczN+8pOfAADq6+tRXV3t2qa6uhqNjY1oa2tDUVGRZ7wLFizAnDlz7M+NjY1srBEREVGv+a//+i888cQTOOOMM/ZqvN1qqM2fPx+/+tWvfMN88sknGDNmTJfi+9nPfma/Hz9+PFpaWnDrrbfaDbWeisfje22gOSIiov5OhASEx7AvfZHuvqK8vByjR4/e6/F2q6E2d+5czJw50zfMnmRywoQJWLJkiT2ib01NDbZv3+4Ks337dpSVlXXYm0ZERER7V1BPYBb6U5+6xYsX48Ybb8TKlSv3ahulWw21qqqqbg/U1h1r167FwIED7d6w2tpaPPvss64wdXV1qK2t7bU8EBEREXXXv/3bv+H3v/89hgwZggMOOADRqHsw9vfee69H8fbaPWpbtmzBzp07sWXLFmSzWaxduxYAcNBBB6G0tBT/8z//g+3bt+PEE09EIpFAXV0dfvnLX+Kaa66x47j88stx991349prr8XFF1+MF198EY8++iieeeaZ3so2ERER5WCPWudmzJiBd999FxdccAGqq6th+Mw01B291lBbuHAhHnjgAfvz+PHjAQAvvfQSTj31VESjUSxfvhyzZ8+GEAIHHXQQbr/9dlx66aX2NqNGjcIzzzyD2bNn484778T++++P3/3ud75DcxAREdHeZYaE59RkfZHuvuKZZ57B888/j29/+9t7Nd5ea6jdf//9vmOoTZ06FVOnTu00nlNPPRXvv//+XswZERERdQfn+uzc8OHDUVZWttfj3Yc6FYmIiIgK07Jly3Dttddi8+bNezVeTspOREREvnjps3MXXHABWltbceCBB6K4uDjvYYKdO3f2KF421IiIiMgXHybo3B133NEr8bKhRkRERLSHZsyY0SvxsqFGREREvkwjmBv796WHCTZu3IjHH38cn332GcrKynDSSSfhzDPPxNdff40TTjgBn376aY/iZUONiIiIfFmXPoO4R63Pk+yRZcuWYf78+SgvL8eBBx6IXbt24bbbbsMxxxyD5cuX47PPPutx3PtIFRAREREVnqeeegrXX389fvOb3+Crr77CW2+9hb/97W/45JNPMHToUJx55pl7FD8bakRERORLhJwHCvryJfaBVsptt92GhQsX4uKLL3YtP+SQQ/DUU0/htNNO26P4+9Wlz0/DQ5AIW4/LtpTsAgAkRBoAMLgoCQDYHUnY4XeEB1hhYS1rEc66zkRCWft9GNb7CEwAQManfZxF2PVZbeslgbQrf7qMCMu0wnnrbD692BGfdPU4VTivdNQy9Tdi14MTdzti1l8R901XxdFgtHrmQ992i7ynoTzUDADYWWT9bUXcDtsgSlzb7jYHOHkSVp4SRsozL3raCcM6brZlaux1JdF2Vxp2PQgnvxWGlaew4T42/lnkpDkw0QIASMmvacZwts/KYygst4sI/XizlqljW2kxnPI3GsXWMnns6HlT+0QtS8DKUyJk/Y2HnHhz93887OQ/joz1V+ZD5cvOp3AOwJBcF5PlyOZ8R7LaVCxqu9z4UrJ+9Hhzw4S0dWkj97vmhI0K93Ze+Q6JjL2sJGOFT4ecfLaHQ668Z7XTrSmX6ekkhsiyyyjCNU78UbPjL6uTH2eZng8nTbjy447DykdKbhfewytcevpO3vVIrfXtYeuvvi+q261j6IPoSADOeQ4AyqLW97+oyFoW1Y579T6m1WlIvtfLo/Kj8lic6Xhf+90fpddjbjh9XSJrxd8UDXe4Tj9mc/dP1iMPMdMqq9dx0RIJyTDWupS2L9QytV1LY8fn+VymIWAaAVz6DCDN7nrvvfewfPnyDtf/9re/xWWXXdbj+PeBtioRERFR4RKi4wZlW1sb71EjIiKi3pMNBfcqdOPHj8dTTz3luU4IgRkzZuCiiy7qcfz96tInERERdR8HvO3Y3Llzcc4552C//fZzNcg2bNiAn/zkJ/jwww/3KP59oAqIiIgoSOoetSBehW7atGn4xS9+gcsuuwxVVVU48cQTccghh+Dwww9HY2Mjnn766T2Knz1qRERERHtg3rx5OPvss/Hoo49i8+bNKCsrw8knn4zvfe972L17N04++eQex82GGhEREfkK6n6xfeEeNeXAAw/EggUL8pYPHDgQL730Uo/j3YeqgIiIiIJgwplGqk9fQRe8Ew8//HCXw27duhX/+7//2+002FAjIiIi6oF77rkHhx12GG655RZ88skneesbGhrw7LPP4rzzzsMxxxyDr7/+uttp8NInERER+TIDuvRZ6E99vvLKK3jqqadw1113YcGCBSgpKUF1dTUSiQR27dqF+vp6VFZWYubMmVi3bh2qq6u7nQYbakRERORLXYoMIt1Cd9ZZZ+Gss87CV199hddffx2fffYZ2traUFlZifHjx2P8+PEIhXre4mRDjYiIiGgPVVZWYtq0aXs9XjbUiIiIyFfW8J53tC/S7e/YUCMiIiJfnJkgOKwCIiIiogLFHjUiIiLyxUufwWGPGhEREfkKZLDbgJ407ak9mX3ADxtqRERE5CtrGIG99hVTp07FgQceiF/84hfYunXrXouXDTUiIiKiPbRt2zZceeWVePzxxzF69GhMmTIFjz76KFKp1B7Fy4YaERER+eKlz85VVlZi9uzZWLt2Ld566y0ccsgh+I//+A8MGzYMP/nJT/DBBx/0KF421IiIiMiXGdBlT3MfuvSpO+aYY7BgwQJceeWVaG5uxsqVK3HsscfipJNOwkcffdStuNhQIyIiItoL0uk0Hn/8cZxxxhkYOXIknn/+edx9993Yvn07Nm7ciJEjR2L69OndipPDcxAREZEvDs/RuR//+Mf4/e9/DyEELrzwQtxyyy0YN26cvb6kpAS33XYbhg0b1q142VAjIiIiX9b9Yn3fatqX7lH7+OOPcdddd+Hss89GPB73DFNZWdntYTz6VUMtJWIwRBQAsMsoBQDEjTQAwIxaV4GbQgk7fAOKAQAtoggAkEHY9ddPRGTzlyF/Wa7cuPVtcrfPGlbYdhHrcnyd5aMredTD5Mavf+6onlxhRET+tZZFjGyHYTvaNmJkXOvs5Sqf8oue1OqpHe4689undvwi/+uilh0e3WgvaxAlrjjbRTwvjWaZt9z6ThhR+33SiMntrGMz65NHdRzr4RNyWVim0QLn2FZxNctj21WmnHpsVydK4V4POPtLHYN6/lW6Kh95x7a2r8N2fZiuMniVOdzBMepXP36c77VzJ4jKh/O547wCQDhmyjw4cSTh1IW+nZ5XfVkk4i57iUj65jss07f/CmGvSxlh1zoASMnTfTinbPoylf9Ww/ufTFfFRTpvmZ5uUh4nSZknfd9tKJHr5DGlznMA0K6OL49/3mp/xOE8YedVz7lKYh3Xc8bIP6ZUHenl8VqmFMv92GSo/yPacRYx87ZLdvBvWa+jYlhx6vWcW6eqPvTjMA73fmnOdH6+p65btGgRJk6ciEjEvQ8zmQzeeOMNnHzyyYhEIjjllFO6FS/vUSMiIiJfQY+jdvzxx2Ps2LFYvnx5wDXRsUmTJmHnzp15yxsaGjBp0qQex9uvetSIiIio+7IwkPXqyuyDdAFgzZo1KCsr6/P0u0MIAcPj8vDXX3+NkpKSHsfbaz1qmzdvxiWXXIJRo0ahqKgIBx54IBYtWpQ38NuHH36Ik046CYlEAsOHD8ctt9ySF9djjz2GMWPGIJFI4IgjjsCzzz7bW9kmIiIi6rKzzz4bZ599NgzDwMyZM+3PZ599Nn7wgx9gypQpmDhxYo/j77UetfXr18M0TfzmN7/BQQcdhHXr1uHSSy9FS0sLbrvtNgBAY2MjTjvtNEyePBkrVqzAX//6V1x88cWoqKjAZZddBgB44403cO6552Lp0qX43ve+h4ceegjTpk3De++953qagoiIiHqHGdCYZvvCOGrl5eUArB61AQMGoKjIufc3FovhxBNPxKWXXtrj+HutoTZ16lRMnTrV/jx69Ghs2LAB99xzj91Qe/DBB5FKpbBy5UrEYjEcfvjhWLt2LW6//Xa7oXbnnXdi6tSpmDdvHgBgyZIlqKurw913340VK1Z4pp1MJpFMOjeINjY29lYxiYiIvvGyCLkelunLdAvdfffdBwA44IADcM011+zRZU4vfVoDDQ0NGDRokP159erVOPnkkxGLOU/gTZkyBRs2bMCuXbvsMJMnT3bFM2XKFKxevbrDdJYuXYry8nL7NXz48L1cEiIiov6DMxN0btGiRXu9kQb04cMEGzduxF133WX3pgFAfX09Ro0a5QpXXV1trxs4cCDq6+vtZXqY+vr6DtNasGAB5syZY39ubGxkY42IiIj2qmOOOQarVq3CwIEDMX78eM+HCZT33nuvR2l0u6E2f/58/OpXv/IN88knn2DMmDH2523btmHq1KmYPn36Hl2n7ap4PN7hYHNERETUPSZCMAO4DBlEmt3xgx/8wG5v/OAHP/BtqPVUtxtqc+fOxcyZM33DjB492n7/+eefY9KkSZg4cSLuvfdeV7iamhps377dtUx9rqmp8Q2j1hMREVHv0sc06+t0C9miRYvs94sXL+6VNLrdUKuqqkJVVVWXwm7btg2TJk3Csccei/vuuw+hkLtlXFtbi+uvvx7pdBrRqDV6cl1dHQ499FAMHDjQDrNq1SpcffXV9nZ1dXWora3tbtaJiIiIesWPfvQjXHDBBTj11FP3ary91qe4bds2nHrqqRgxYgRuu+027NixA/X19a57y8477zzEYjFccskl+Oijj/DII4/gzjvvdN1fdtVVV+G5557DsmXLsH79eixevBjvvPMOrrzyyt7KOhEREWnUU59BvPYVO3bswNSpUzF8+HDMmzcPH3zwwV6Jt9ceJqirq8PGjRuxceNG7L///q51Qs5JV15ejhdeeAGzZs3Csccei8rKSixcuNAemgMAJk6ciIceegg33HADfvrTn+Lggw/Gk08+yTHUiIiI+giH5+jcn/70J+zatQuPPfYYHnroIdx+++0YM2YMzj//fJx33nk44IADehRvrzXUZs6c2em9bABw5JFH4rXXXvMNM336dEyfPn0v5YyIiIho7xs4cCAuu+wyXHbZZfjnP/+J3//+91i5ciUWLlyITCbTozg51ycRERH5yhhhZIxwAOmKPk9zb0in03jnnXfw1ltvYfPmzXnDjHXHvtOnSERERIEwYQRyf5oZwETwe+Kll17CpZdeiurqasycORNlZWV4+umn8c9//rPHcbJHjYiIiGgP7bfffti5cyemTp2Ke++9F9///vf3ypiubKgRERGRrwxCyARwES6INHtq8eLFmD59OioqKvZqvGyoERERka8swsii7+9Ry8Ls8zR7qrdmXmJDjYiIiHxlEEYmgIZapsAbameffTbuv/9+lJWV4eyzz/YN+8QTT/QoDTbUiIiIiHqgvLzcnt+zrKysMOb6JCIiov6F96h5u+++++z3999/f6+kUdg1QERERIEz5T1qff0yA7jc2lPf+c53sHv37rzljY2N+M53vtPjeNlQIyIiItpDL7/8MlKpVN7y9vb2Tmdg8sNLn0REROQrI8IIiwAeJhCF/TABAHz44Yf2+48//hj19fX252w2i+eeew777bdfj+NnQ42IiIh8ZRBCOJCnPrN9nmZ3HX300TAMA4ZheF7iLCoqwl133dXj+NlQIyIiIuqhTZs2QQiB0aNH4+2330ZVVZW9LhaLYciQIQiHe97IZUONiIiIfGUQDqhHrfAfJhg5ciQAwDR75zItHyYgIiIiX1k54G1fv4KYDaGnHnjgATzzzDP252uvvRYVFRWYOHEiPvvssx7H26961PbDVyiSRS4y0651CSE/aw3iuGEty6IBAJAxOj5gsrLNG+7CKMoRsWfX3O00ROdhsz5tcT2v6n1YWJGmtLL6lUnF75dOLlc9Gu54Oqs/V90Z7vhUHINEMwCgwSh2b6vd65C3L7UxCnPzYqephcndPi6c4ym3LjKhcN7yvLgVbZ+qMN2pWz1vep4AoATJbm2fNTqohw7y6/kZXStH7n7vbpk74vedVZLynKBPnZz7zyGsHTsRj2PUK79qGxXeXcZMp/ny4iqPUOl0/v3sbFmurpzH/Oj5VMeN//536rdEvh8iz7tex1SLEZdxdu2fuFc4lWZXzuuA/3heuev0+lNxqO+jfpzlnru885CfPxU+aUQ989pZfv3ipp775S9/iXvuuQcAsHr1atx9992444478PTTT2P27NmcmYCIiIh6R0ZEEBJ932TYF576VLZu3YqDDjoIAPDkk0/ihz/8IS677DJ861vfwqmnntrjeHnpk4iIiHwFcdkzqPlFe6q0tBRff/01AOCFF17Av/zLvwAAEokE2traehwve9SIiIjIV0aEEQpkHLV9p6H2L//yL/jRj36E8ePH429/+xvOOOMMAMBHH32EAw44oMfxskeNiIiIaA8tX74ctbW12LFjB/7whz9g8ODBAIB3330X5557bo/jZY8aERER+coghFAgw3PsO/1JFRUVuPvuu/OW33jjjXsULxtqRERE5CsrIsgE8DBBdg9HSehtH374IcaNG4dQKOSaSsrLkUce2aM02FAjIiIi6oGjjz4a9fX1GDJkiD2VlBDOmDLqs2EYyGZ71uhkQ42IiIh8ZUQYBh8myLNp0yZ7yqhNmzb1ShpsqBEREZGvLCIIBdBkyBb4pOxq+qjc93vTvnOXHhEREVGB6q0ppNhQIyIiIl8ZEQ7sta/45S9/iaKiIgDOFFK33HILKisrMXv27B7Hy0ufRERE5CsjQgHdo7bv9CdxCikiIiKiAsUppIiIiCgQWURgBPIwwb7TTOEUUkRERBSIrAgH9tpXcAopIiIiCkRGhAGOo+art6aQYo8aERER0V7w2muv4YILLsDEiROxbds2AMB//dd/4fXXX+9xnGyoERERka+siAT22lf84Q9/wJQpU1BUVIT33nsPyWQSANDQ0IBf/vKXPY6XDTUiIiLyxXHUOveLX/wCK1aswG9/+1tEo1F7+be+9S289957PY631xpqmzdvxiWXXIJRo0ahqKgIBx54IBYtWoRUKuUKYxhG3uvNN990xfXYY49hzJgxSCQSOOKII/Dss8/2VraJiIiIum3Dhg04+eST85aXl5dj9+7dPY631/oU169fD9M08Zvf/AYHHXQQ1q1bh0svvRQtLS247bbbXGH/8pe/4PDDD7c/qyclAOCNN97Aueeei6VLl+J73/seHnroIUybNg3vvfcexo0b11vZJyIiIskUoUCewDT3oQFva2pqsHHjxryhOF5//XWMHj26x/H2WkNt6tSpmDp1qv159OjR2LBhA+655568htrgwYNRU1PjGc+dd96JqVOnYt68eQCAJUuWoK6uDnfffTdWrFjRW9knIiIiKSsiQAD3i+1L96hdeumluOqqq7By5UoYhoHPP/8cq1evxjXXXIOf/exnPY63T2ugoaEBgwYNylt+1llnob29HYcccgiuvfZanHXWWfa61atXY86cOa7wU6ZMwZNPPtlhOslk0r6JDwAaGxv3PPNEREREHZg/fz5M08R3v/tdtLa24uSTT0Y8Hsc111yDH//4xz2Ot88aahs3bsRdd93l6k0rLS3FsmXL8K1vfQuhUAh/+MMfMG3aNDz55JN2Y62+vh7V1dWuuKqrq1FfX99hWkuXLt3jcUuIiIjIkg1oHLV9acBbwzBw/fXXY968edi4cSOam5sxduxYlJaWoq2tzZ6wvbu6ffF3/vz5ng8A6K/169e7ttm2bRumTp2K6dOn49JLL7WXV1ZWYs6cOZgwYQKOP/543Hzzzbjgggtw66239qgwyoIFC9DQ0GC/tm7dukfxERER9WecmaDrYrEYxo4dixNOOAHRaBS33347Ro0a1eP4ut2jNnfuXMycOdM3jH7T3Oeff45JkyZh4sSJuPfeezuNf8KECairq7M/19TUYPv27a4w27dv7/CeNgCIx+OIx+OdpkVERES0J5LJJBYvXoy6ujrEYjFce+21mDZtGu677z5cf/31CIfDmD17do/j73ZDraqqClVVVV0Ku23bNkyaNAnHHnss7rvvPoRCnXfgrV27FkOHDrU/19bWYtWqVbj66qvtZXV1daitre1u1omIiKgHTBGGEchTn4Xfo7Zw4UL85je/weTJk/HGG29g+vTpuOiii/Dmm2/i9ttvx/Tp0xEO97wcvXaP2rZt23Dqqadi5MiRuO2227Bjxw57neoNe+CBBxCLxTB+/HgAwBNPPIGVK1fid7/7nR32qquuwimnnIJly5bhzDPPxMMPP4x33nmnS71zREREtOeyIhTQPWqFPzzHY489hv/3//4fzjrrLKxbtw5HHnkkMpkMPvjgAxiGscfx91pDra6uDhs3bsTGjRux//77u9YJIez3S5YswWeffYZIJIIxY8bgkUcewQ9/+EN7/cSJE/HQQw/hhhtuwE9/+lMcfPDBePLJJzmGGhERUR8xRRiGyR41L//85z9x7LHHAgDGjRuHeDyO2bNn75VGGtCLDbWZM2d2ei/bjBkzMGPGjE7jmj59OqZPn76XckZERES0d2SzWcRiMftzJBJBaWnpXot/3xlJjoiIiAJhBjQ8h+pRO/744xEOhzFr1izMmjWrz/PhRwiBmTNn2g8xtre34/LLL0dJSYkr3BNPPNGj+PtVQ21YugnFae8DLSyvxhYbGXuZKbstQ9ql2r0h3I3osj49pz2Nx2u7cE4Zs1qXbe66jsJ1Je2O5NZ1R2XT85KbtkpHbVthJF1x+/Hax3urfruyD/3C+OXfq/6zcC8Lw6ts1jK/Y7srx39X8qbSUp9z8+eV19wwfunk5s8rbNZnJKK0kX9OyK1Xv+OuM2rbqMh2mg4AmH6jJol03qIQzLw8qmXuuLIdppm7j4pFMi9Md3jVd1jmCQBiwjrPxpFfnhLTmg9a1Zd+/KrjoihkbZfy2Hed5SM3P3q+/LbLXea1nRLT9nXIJ1wa4by4/fKcm7aeB7VdV8qsmKLjvOUyRQgI4H4xNYXUmjVrUFZW1ufpd0XulcELLrhgr8bfrxpqRERERHvTfffd16vxs6FGREREvoQIQwRw6TOINAsNG2pERETkyzTDQBBPfQaQZqEp/AFKiIiIiPop9qgRERGRLyFCEAE8TBBEmoWGDTUiIiLyZZohwAzgqc8A0iw0rAEiIiKiAsUeNSIiIvJlXfoM4qlP9iexoUZERET+AhrwNpA0CwwbakRERORLmCGIAO4XCyLNQsMaICIiIipQ7FEjIiIifwENeBtImgWGDTUiIiLyx3vUAsMaICIiIipQ7FEjIiIif7z0GRg21IiIiMifCKihFsDYbYWGlz6JiIiIChR71IiIiMifaQQy1ydMo+/TLDBsqBEREZEvwwzDCODSZxBpFhpe+iQiIiIqUOxRIyIiIl+GCMMI4Mb+INIsNGyoERERkT8zFNA9arzwx4YaERER+eI9asFhU5WIiIioQLFHjYiIiHwZ2TCMbAA9agGkWWjYUCMiIiJfITOEEO9RCwRrgIiIiKhAsUeNiIiIfBlmKKCHCdifxIYaERER+TJEKJBGkyHYUGMNEBERERUo9qgRERGRr5AZRiiIMc04jhobakREROTPukctgEufvEeNlz6JiIiIClWvNtTOOussjBgxAolEAkOHDsWFF16Izz//3BXmww8/xEknnYREIoHhw4fjlltuyYvnsccew5gxY5BIJHDEEUfg2Wef7c1sExERkcbIhhEK4MUBb3u5oTZp0iQ8+uij2LBhA/7whz/gH//4B374wx/a6xsbG3Haaadh5MiRePfdd3Hrrbdi8eLFuPfee+0wb7zxBs4991xccskleP/99zFt2jRMmzYN69at682sExERkaQGvA3i1d/16j1qs2fPtt+PHDkS8+fPx7Rp05BOpxGNRvHggw8ilUph5cqViMViOPzww7F27VrcfvvtuOyyywAAd955J6ZOnYp58+YBAJYsWYK6ujrcfffdWLFiRW9mn4iIiMB71ILUZzWwc+dOPPjgg5g4cSKi0SgAYPXq1Tj55JMRi8XscFOmTMGGDRuwa9cuO8zkyZNdcU2ZMgWrV6/uMK1kMonGxkbXi4iIiGhf0+tPfV533XW4++670draihNPPBFPP/20va6+vh6jRo1yha+urrbXDRw4EPX19fYyPUx9fX2HaS5duhQ33nhjt/KZNay/pmHYy6KmAACEhZBhDNfnnupOPOEuJBXSwpiGe52Tlh5nfqShvEVdK+PeKkNuevn5yU8vipz9Issez1rLm6LW75D2kHWPQ3E202Ge9Hg7SttPWKv33O2j3dg+qx1/6pgMdaGO9e3UMay2y8L6HBOmlkdrXczMj7t7x7k7jP796cn3ROXVP4y1X8Mw89LsKKznOp/t/MKqOPW4VV50ucv0zynDOiZNLQ6Vhl+evVlxhQ0nfq88KhnD456frldFt+Xur84MFq1yu/xMdWVfe5avh/np7r5QcXodGzGRzQufkv+C9Tx3J02vMuRur4fJwF03GSODrgplQwgFcL+YyLJHrds1MH/+fBiG4ftav369HX7evHl4//338cILLyAcDuPf//3fIfawodOZBQsWoKGhwX5t3bq1V9MjIiL6JuM9asHpdo/a3LlzMXPmTN8wo0ePtt9XVlaisrIShxxyCA477DAMHz4cb775Jmpra1FTU4Pt27e7tlWfa2pq7L9eYdR6L/F4HPF4vDvFIiIiIio43W6oVVVVoaqqqkeJmabVBZtMJgEAtbW1uP766+2HCwCgrq4Ohx56KAYOHGiHWbVqFa6++mo7nrq6OtTW1vYoD0RERNQ9ITOEUACXIQV71HrvYYK33noLd999N9auXYvPPvsML774Is4991wceOCBdiPrvPPOQywWwyWXXIKPPvoIjzzyCO68807MmTPHjueqq67Cc889h2XLlmH9+vVYvHgx3nnnHVx55ZW9lXUiIiLSqKc+g3j1d71WA8XFxXjiiSfw3e9+F4ceeiguueQSHHnkkXjllVfsy5Ll5eV44YUXsGnTJhx77LGYO3cuFi5caA/NAQATJ07EQw89hHvvvRdHHXUUHn/8cTz55JMYN25cb2WdiIiIqCD02lOfRxxxBF588cVOwx155JF47bXXfMNMnz4d06dP31tZIyIiom4IZQ2Esr34eHAHRABpFhpOyk5ERES+gnoCk/eocVJ2IiIiooLFHjUiIiLyFTINhHJHVO8DIoA0Cw0bakREROTLyAYzPIfJmQnYUCMiIiJ/RtaAEcCN/UGkWWjYVCUiIiIqUOxRIyIiIl8hEcw9aiHBHjU21IiIiMgXL30Gh5c+iYiIiAoUe9SIiIjIV1DDcwSRZqFhQ42IiIh8GVnrFUS6/R0vfRIREREVKPaoERERkS9e+gwOG2pERETki5c+g8NLn0REREQFij1qRERE5MswrVcQ6fZ3bKgRERGRL8MUMLIikHT7OzbUiIiIyBd71ILDe9SIiIiIChR71IiIiMiXkQ3o0mcAaRYaNtSIiIjInymsVxDp9nO89ElERERUoNijRkRERL546TM4bKgRERGRP176DAwvfRIREREVKPaoERERkb+sab2CSLefY0ONiIiI/Jmm9Qoi3X6Olz6JiIiIChR71IiIiMifGdClT/aosaFGRERE/gzThBFAoymINAsNG2pERETkjw8TBIb3qBEREREVKPaoERERkT8+9RkYNtSIiIjIX9YEstlg0u3neOmTiIiIqED1akPtrLPOwogRI5BIJDB06FBceOGF+Pzzz+31mzdvhmEYea8333zTFc9jjz2GMWPGIJFI4IgjjsCzzz7bm9kmIiIinbr0GcSrn+vVS5+TJk3CT3/6UwwdOhTbtm3DNddcgx/+8Id44403XOH+8pe/4PDDD7c/Dx482H7/xhtv4Nxzz8XSpUvxve99Dw899BCmTZuG9957D+PGjetWflrDYSBsFTkr26hZw+gwfCxkdfOGhDUpbBj73uSwWXRcPl13ytbVOPdGumHR9XylDPm7Qx7Vpty3LaEYAGefW+m6v/xR4XzuTprq+GkKxe1lFdn2Lm9nf5Z1amrLs134HaXiMbWwKSMMIL+Mermiwjq2o6GuX8owPb4ruXn0+j6ZXQjTWbxe63LL1914MrKevMJkfLZLIpYXJiLzEkF+fYYNa1mJSPqmnURUxhvuOM8eaXYWTsl6xJsR1rKIsXcvaal4O5KbXlirt+Jw0r1OO27t75tRBMCpM8CpN31Zd3WW786ocoW18qn9FDdSeeFbkADg3jc9zYNKuzv7NIl01xPIZgO69BlAmgWmVxtqs2fPtt+PHDkS8+fPx7Rp05BOpxGNOl+mwYMHo6amxjOOO++8E1OnTsW8efMAAEuWLEFdXR3uvvturFixojezT0RERBSoPrtHbefOnXjwwQcxceJEVyMNsC6RDhkyBN/+9rfx1FNPudatXr0akydPdi2bMmUKVq9e3WFayWQSjY2NrhcRERH1jDCzENkAXiZ71Hq9oXbdddehpKQEgwcPxpYtW/CnP/3JXldaWoply5bhsccewzPPPINvf/vbmDZtmquxVl9fj+rqalec1dXVqK+v7zDNpUuXory83H4NHz587xeMiIiovzCzwb36uW431ObPn+/5AID+Wr9+vR1+3rx5eP/99/HCCy8gHA7j3//93yHkPQeVlZWYM2cOJkyYgOOPPx4333wzLrjgAtx66617VKgFCxagoaHBfm3dunWP4iMiIiIKQrfvUZs7dy5mzpzpG2b06NH2+8rKSlRWVuKQQw7BYYcdhuHDh+PNN99EbW2t57YTJkxAXV2d/bmmpgbbt293hdm+fXuH97QBQDweRzwe73A9ERERdQMfJghMtxtqVVVVqKqq6lFipnzMNplMdhhm7dq1GDp0qP25trYWq1atwtVXX20vq6ur67ChR0RERHuZaQZzGZLDc/TeU59vvfUW1qxZg29/+9sYOHAg/vGPf+BnP/sZDjzwQLuR9cADDyAWi2H8+PEAgCeeeAIrV67E7373Ozueq666CqeccgqWLVuGM888Ew8//DDeeecd3Hvvvb2VdSIiItJlM9YriHT7uV5rqBUXF+OJJ57AokWL0NLSgqFDh2Lq1Km44YYbXJcllyxZgs8++wyRSARjxozBI488gh/+8If2+okTJ+Khhx7CDTfcgJ/+9Kc4+OCD8eSTT3Z7DDUiIiKifU2vNdSOOOIIvPjii75hZsyYgRkzZnQa1/Tp0zF9+vS9lTUiIiLqBjVcRhDp9neclJ2IiIj8mRnrFUS6/RwnZSciIiIqUOxRIyIiIn9mQA8TsEeNDTUiIiLyJ7JZiFDfN5p4jxovfRIREREBAHbv3o3jjjsORx99NMaNG4ff/va3QWeJPWpERETUiX7yMMGAAQPw6quvori4GC0tLRg3bhzOPvtsDB48uE/zoWNDjYiIiPxlM0AAlz77+r64cDiM4uJiANYsSkIIe37yoPDSJxEREX0jvPrqq/j+97+PYcOGwTAMPPnkk3lhli9fjgMOOACJRAITJkzA22+/7Vq/e/duHHXUUdh///0xb948VFZW9lHuvbGhRkRERL5ENh3YCwAaGxtdr47mDG9pacFRRx2F5cuXe65/5JFHMGfOHCxatAjvvfcejjrqKEyZMgVffvmlHaaiogIffPABNm3ahIceegjbt2/f+xXaDWyoERERkS+RzQTUULMufQ4fPhzl5eX2a+nSpZ75PP300/GLX/wC//qv/+q5/vbbb8ell16Kiy66CGPHjsWKFStQXFyMlStX5oWtrq7GUUcdhddee23vVWQP8B41IiIi8hfwwwRbt25FWVmZvVifM7yrUqkU3n33XSxYsMBeFgqFMHnyZKxevRoAsH37dhQXF2PAgAFoaGjAq6++iiuuuGIPC7Fn2FAjIiKiglZWVuZqqPXEV199hWw2i+rqatfy6upqrF+/HgDw2Wef4bLLLrMfIvjxj3+MI444Yo/S3VNsqBEREZEvYTr3i/V1un3phBNOwNq1a/s0zc6woUZERET+smnA6PuGGvZi47CyshLhcDjv4YDt27ejpqZmr6Wzt/FhAiIiIvrGi8ViOPbYY7Fq1Sp7mWmaWLVqFWprawPMmT/2qBEREZEvkc1ABNCjJro54G1zczM2btxof960aRPWrl2LQYMGYcSIEZgzZw5mzJiB4447DieccALuuOMOtLS04KKLLtrbWd9r2FAjIiIiX8JMQZjhQNLtjnfeeQeTJk2yP8+ZMwcAMGPGDNx///0455xzsGPHDixcuBD19fU4+uij8dxzz+U9YFBI2FAjIiKib4RTTz210ymfrrzySlx55ZV9lKM9x4YaERER+cumASOAJkMAT5oWGjbUiIiIyJfIpiGMAC59sqHGpz6JiIiIChV71IiIiMiXMFMQ2b7v2+nuwwTfRGyoERERkS+RTUOAlz6DwIYaERER+RLZFEQAd0uJLHvUeI8aERERUYFijxoRERH5EmYKwjACSRcAjj/+eITDYcyaNQuzZs3q83wEiQ01IiIi8mVd+gygoSYvfa5ZswZlZWV9nn4h4KVPIiIiogLFHjUiIiLyZT31GUSPGp/6ZEONiIiIfAkzCQH/OTR7J10+9clLn0REREQFij1qRERE5C+bhBB936MG9qixoUZERET+RDYVSENNmLxHjZc+iYiIiAoUe9SIiIjIl8gmIYTZ9+myR40NNSIiIvLHhlpw+uTSZzKZxNFHHw3DMLB27VrXug8//BAnnXQSEokEhg8fjltuuSVv+8ceewxjxoxBIpHAEUccgWeffbYvsk1ERESQ96hlkwG8+DBBnzTUrr32WgwbNixveWNjI0477TSMHDkS7777Lm699VYsXrwY9957rx3mjTfewLnnnotLLrkE77//PqZNm4Zp06Zh3bp1fZF1IiIiosD0+qXPP//5z3jhhRfwhz/8AX/+859d6x588EGkUimsXLkSsVgMhx9+ONauXYvbb78dl112GQDgzjvvxNSpUzFv3jwAwJIlS1BXV4e7774bK1as8EwzmUwimUzanxsaGgAAbY1Ze1lWtlFNn0lmM8IKH5JPuoQDGOxvT2W7OJJ0d8rW1Tj3RrrhbjxllDLcvzvUvm0LyX1tZrR03V34Ua1LvztpZu00wvayWDbTUfC87ezPsk714zHbhd9RKryphU0Z6nh1l1EvV1oe21GRRVd5fVdy8+gVxswJk1t2L35lV+tyy9fdeDKynkyP4znjs11ShtfDRGReIsivzzDUecQ5LrzSVmesjE+5vNLsLJxieoTPyOM+a3T9OOiKTCeXyHLTC2n11ibc3x/9uFXHTrthXQ5LauFUve1J/0tn+e6MKpdeHrWfBPIv4bXDOm/o+6aneVBpd2efJhutPHXlac50tgWmGe403N6W7cY56htL9KL6+nqx3377iTVr1ohNmzYJAOL999+311944YXiBz/4gWubF198UQAQO3fuFEIIMXz4cPHrX//aFWbhwoXiyCOP7DDdRYsWCQB88cUXX3zxxVcnr61bt3b4/7StrU3U1NQEmr+amhrR1tbW7TbIN0Wv9agJITBz5kxcfvnlOO6447B58+a8MPX19Rg1apRrWXV1tb1u4MCBqK+vt5fpYerr6ztMe8GCBZgzZ479effu3Rg5ciS2bNmC8vLyPSjVvq2xsRHDhw/H1q1bUVZWFnR2AsW6sLAeHKwLC+vB8U2vCyEEmpqaPG9NUhKJBDZt2oRUKrh7xWKxGBKJRGDpB63bDbX58+fjV7/6lW+YTz75BC+88AKampqwYMGCHmeup+LxOOLxeN7y8vLyb+SXrbvKyspYDxLrwsJ6cLAuLKwHxze5LrrSeZFIJPp1Qylo3W6ozZ07FzNnzvQNM3r0aLz44otYvXp1XoPpuOOOw/nnn48HHngANTU12L59u2u9+lxTU2P/9Qqj1hMRERF9U3W7oVZVVYWqqqpOw/3nf/4nfvGLX9ifP//8c0yZMgWPPPIIJkyYAACora3F9ddfj3Q6jWg0CgCoq6vDoYceioEDB9phVq1ahauvvtqOq66uDrW1td3NOhEREdE+pdfuURsxYoTrc2lpKQDgwAMPxP777w8AOO+883DjjTfikksuwXXXXYd169bhzjvvxK9//Wt7u6uuugqnnHIKli1bhjPPPBMPP/ww3nnnHdcQHp2Jx+NYtGiR5+XQ/oT14GBdWFgPDtaFhfXgYF1QITCE6JtZVjdv3oxRo0bh/fffx9FHH20v//DDDzFr1iysWbMGlZWV+PGPf4zrrrvOte1jjz2GG264AZs3b8bBBx+MW265BWeccUZfZJuIiIgoMH3WUCMiIiKi7umTmQmIiIiIqPvYUCMiIiIqUGyoERERERUoNtSIiIiICtQ3vqG2fPlyHHDAAUgkEpgwYQLefvvtoLO0R1599VV8//vfx7Bhw2AYBp588knXeiEEFi5ciKFDh6KoqAiTJ0/G3//+d1eYnTt34vzzz0dZWRkqKipwySWXoLm52RXmww8/xEknnYREIoHhw4fjlltu6e2idcvSpUtx/PHHY8CAARgyZAimTZuGDRs2uMK0t7dj1qxZGDx4MEpLS/F//s//yRs8ecuWLTjzzDNRXFyMIUOGYN68echk3JNCv/zyyzjmmGMQj8dx0EEH4f777+/t4nXLPffcgyOPPNIePb22thZ//vOf7fX9pR5y3XzzzTAMwzUGY3+pi8WLF8MwDNdrzJgx9vr+Ug8AsG3bNlxwwQUYPHgwioqKcMQRR+Cdd96x1/eXcybtw4KbZrT3PfzwwyIWi4mVK1eKjz76SFx66aWioqJCbN++Peis9dizzz4rrr/+evHEE08IAOKPf/yja/3NN98sysvLxZNPPik++OADcdZZZ4lRo0a5JrSdOnWqOOqoo8Sbb74pXnvtNXHQQQeJc889117f0NAgqqurxfnnny/WrVsnfv/734uioiLxm9/8pq+K2akpU6aI++67T6xbt06sXbtWnHHGGWLEiBGiubnZDnP55ZeL4cOHi1WrVol33nlHnHjiiWLixIn2+kwmI8aNGycmT54s3n//ffHss8+KyspKsWDBAjvMp59+KoqLi8WcOXPExx9/LO666y4RDofFc88916fl9fPUU0+JZ555Rvztb38TGzZsED/96U9FNBoV69atE0L0n3rQvf322+KAAw4QRx55pLjqqqvs5f2lLhYtWiQOP/xw8cUXX9ivHTt22Ov7Sz3s3LlTjBw5UsycOVO89dZb4tNPPxXPP/+82Lhxox2mv5wzad/1jW6onXDCCWLWrFn252w2K4YNGyaWLl0aYK72ntyGmmmaoqamRtx66632st27d4t4PC5+//vfCyGE+PjjjwUAsWbNGjvMn//8Z2EYhti2bZsQQoj/+3//rxg4cKBIJpN2mOuuu04ceuihvVyinvvyyy8FAPHKK68IIaxyR6NR8dhjj9lhPvnkEwFArF69WghhNXpDoZCor6+3w9xzzz2irKzMLvu1114rDj/8cFda55xzjpgyZUpvF2mPDBw4UPzud7/rl/XQ1NQkDj74YFFXVydOOeUUu6HWn+pi0aJF4qijjvJc15/q4brrrhPf/va3O1zfn8+ZtO/4xl76TKVSePfddzF58mR7WSgUwuTJk7F69eoAc9Z7Nm3ahPr6eleZy8vLMWHCBLvMq1evRkVFBY477jg7zOTJkxEKhfDWW2/ZYU4++WTEYjE7zJQpU7Bhwwbs2rWrj0rTPQ0NDQCAQYMGAQDeffddpNNpV12MGTMGI0aMcNXFEUccgerqajvMlClT0NjYiI8++sgOo8ehwhTqMZTNZvHwww+jpaUFtbW1/bIeZs2ahTPPPDMvv/2tLv7+979j2LBhGD16NM4//3xs2bIFQP+qh6eeegrHHXccpk+fjiFDhmD8+PH47W9/a6/vz+dM2nd8YxtqX331FbLZrOtEAwDV1dWor68PKFe9S5XLr8z19fUYMmSIa30kEsGgQYNcYbzi0NMoJKZp4uqrr8a3vvUtjBs3DoCVz1gshoqKClfY3LrorJwdhWlsbERbW1tvFKdH/vrXv6K0tBTxeByXX345/vjHP2Ls2LH9rh4efvhhvPfee1i6dGneuv5UFxMmTMD999+P5557Dvfccw82bdqEk046CU1NTf2qHj799FPcc889OPjgg/H888/jiiuuwE9+8hM88MADAPrvOZP2Lb021ydRX5k1axbWrVuH119/PeisBObQQw/F2rVr0dDQgMcffxwzZszAK6+8EnS2+tTWrVtx1VVXoa6uDolEIujsBOr000+33x955JGYMGECRo4ciUcffRRFRUUB5qxvmaaJ4447Dr/85S8BAOPHj8e6deuwYsUKzJgxI+DcEXXNN7ZHrbKyEuFwOO9Jpu3bt6OmpiagXPUuVS6/MtfU1ODLL790rc9kMti5c6crjFccehqF4sorr8TTTz+Nl156Cfvvv7+9vKamBqlUCrt373aFz62LzsrZUZiysrKC+ocXi8Vw0EEH4dhjj8XSpUtx1FFH4c477+xX9fDuu+/iyy+/xDHHHINIJIJIJIJXXnkF//mf/4lIJILq6up+Uxe5KioqcMghh2Djxo396pgYOnQoxo4d61p22GGH2ZeB++M5k/Y939iGWiwWw7HHHotVq1bZy0zTxKpVq1BbWxtgznrPqFGjUFNT4ypzY2Mj3nrrLbvMtbW12L17N9599107zIsvvgjTNDFhwgQ7zKuvvop0Om2Hqaurw6GHHoqBAwf2UWn8CSFw5ZVX4o9//CNefPFFjBo1yrX+2GOPRTQaddXFhg0bsGXLFldd/PWvf3WdhOvq6lBWVmaf3Gtra11xqDCFfgyZpolkMtmv6uG73/0u/vrXv2Lt2rX267jjjsP5559vv+8vdZGrubkZ//jHPzB06NB+dUx861vfyhu2529/+xtGjhwJoH+dM2kfFvTTDL3p4YcfFvF4XNx///3i448/FpdddpmoqKhwPcm0r2lqahLvv/++eP/99wUAcfvtt4v3339ffPbZZ0II61HziooK8ac//Ul8+OGH4gc/+IHno+bjx48Xb731lnj99dfFwQcf7HrUfPfu3aK6ulpceOGFYt26deLhhx8WxcXFBfWo+RVXXCHKy8vFyy+/7BqCoLW11Q5z+eWXixEjRogXX3xRvPPOO6K2tlbU1tba69UQBKeddppYu3ateO6550RVVZXnEATz5s0Tn3zyiVi+fHnBDUEwf/588corr4hNmzaJDz/8UMyfP18YhiFeeOEFIUT/qQcv+lOfQvSfupg7d654+eWXxaZNm8T//u//ismTJ4vKykrx5ZdfCiH6Tz28/fbbIhKJiJtuukn8/e9/Fw8++KAoLi4W//3f/22H6S/nTNp3faMbakIIcdddd4kRI0aIWCwmTjjhBPHmm28GnaU98tJLLwkAea8ZM2YIIazHzX/2s5+J6upqEY/HxXe/+12xYcMGVxxff/21OPfcc0VpaakoKysTF110kWhqanKF+eCDD8S3v/1tEY/HxX777Sduvvnmvipil3jVAQBx33332WHa2trEf/zHf4iBAweK4uJi8a//+q/iiy++cMWzefNmcfrpp4uioiJRWVkp5s6dK9LptCvMSy+9JI4++mgRi8XE6NGjXWkUgosvvliMHDlSxGIxUVVVJb773e/ajTQh+k89eMltqPWXujjnnHPE0KFDRSwWE/vtt58455xzXGOH9Zd6EEKI//mf/xHjxo0T8XhcjBkzRtx7772u9f3lnEn7LkMIIYLpyyMiIiIiP9/Ye9SIiIiI9nVsqBEREREVKDbUiIiIiAoUG2pEREREBYoNNSIiIqICxYYaERERUYFiQ42IiIioQLGhRkRERFSg2FAjIiIiKlBsqBEREREVKDbUiIiIiArU/wcPH4j4PtTPtwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "libaarhusxyz.XYZ(rootpath + \"/inversion/smooth_model.xyz\").plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "34dd77dc", + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '/home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/inversion/sparse_model.xyz'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[79], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mlibaarhusxyz\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mXYZ\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrootpath\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m/inversion/sparse_model.xyz\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mplot()\n", + "File \u001b[0;32m~/Projects/Emerald/experimental-inversion-gui/dependencies/libaarhusxyz/libaarhusxyz/xyz.py:124\u001b[0m, in \u001b[0;36mXYZ.__new__\u001b[0;34m(cls, *arg, **kw)\u001b[0m\n\u001b[1;32m 122\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel_dict \u001b[38;5;241m=\u001b[39m arg[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 123\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 124\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel_dict \u001b[38;5;241m=\u001b[39m \u001b[43mparse\u001b[49m\u001b[43m(\u001b[49m\u001b[43marg\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malcfile\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43malcfile\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 125\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 126\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel_dict \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mflightlines\u001b[39m\u001b[38;5;124m\"\u001b[39m: pd\u001b[38;5;241m.\u001b[39mDataFrame(columns\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mline_no\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124my\u001b[39m\u001b[38;5;124m\"\u001b[39m]),\n\u001b[1;32m 127\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmodel_info\u001b[39m\u001b[38;5;124m\"\u001b[39m: {},\n\u001b[1;32m 128\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlayer_data\u001b[39m\u001b[38;5;124m\"\u001b[39m: {}}\n", + "File \u001b[0;32m~/Projects/Emerald/experimental-inversion-gui/dependencies/libaarhusxyz/libaarhusxyz/xyzparser.py:204\u001b[0m, in \u001b[0;36mparse\u001b[0;34m(nameorfile, **kw)\u001b[0m\n\u001b[1;32m 202\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mparse\u001b[39m(nameorfile, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkw):\n\u001b[1;32m 203\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(nameorfile, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m--> 204\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mopen\u001b[39m(nameorfile, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[1;32m 205\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _parse(f, source\u001b[38;5;241m=\u001b[39mnameorfile, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkw)\n\u001b[1;32m 206\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/docs/data/inversion/sparse_model.xyz'" + ] + } + ], + "source": [ + "libaarhusxyz.XYZ(rootpath + \"/inversion/sparse_model.xyz\").plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d43a2218", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7628db77", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "beryl-gui", + "language": "python", + "name": "beryl-gui" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..00ffbcc --- /dev/null +++ b/setup.py @@ -0,0 +1,48 @@ +#!/usr/bin/env python + +import setuptools +import os + +setuptools.setup( + name='emerald-beryl-pipeline', + version='0.0.23', + description='', + long_description="", + long_description_content_type="text/markdown", + author='Egil Moeller ', + author_email='em@emeraldgeo.no', + url='https://github.com/emerald-geomodelling/emerald-beryl-pipeline', + packages=setuptools.find_packages(), + install_requires=[ + "cython", + "numpy==1.26.4", + "oauth2client>=4.1.3", + "google-api-core>=1.25.0", + "google-api-python-client>=1.12.5", + "swaggerspect >= 0.0.13", + "luigi", + "pyyaml", + "pymkl", + "geojson", + "geopandas", + "msgpack", + "msgpack-numpy", + "libaarhusxyz", + "pydantic", + "poltergust-luigi-utils>=0.0.11", + "emerald-monitor @ git+https://github.com/emerald-geomodelling/emerald-monitor", + "python-slugify" + ], + entry_points = { + 'beryl_pipeline.import': [ + 'SkyTEM XYZ=beryl_pipeline.file_import:LibaarhusXYZImporter' + ], + 'simpeg.static_instrument': [ + 'Dual moment TEM=SimPEG.electromagnetics.utils.static_instrument.dual:DualMomentTEMXYZSystem', + 'Workbench import=beryl_pipeline.inversion_workbench_import:WorkbenchImporter' + ], + 'emeraldprocessing.pipeline_step': [ + 'Workbench import=beryl_pipeline.processing_workbench_import:import_from_workbench', + ] + } +) diff --git a/tests/data/20201231_20023_IVF_SkyTEM304_SKB.gex b/tests/data/20201231_20023_IVF_SkyTEM304_SKB.gex new file mode 100644 index 0000000..531bed7 --- /dev/null +++ b/tests/data/20201231_20023_IVF_SkyTEM304_SKB.gex @@ -0,0 +1,175 @@ +/waveform measured on site 20201130 + + +[General] + +Description=Test geometry file + +GPSDifferentialPosition1= 11.91 2.79 -0.16 +GPSPosition1= 11.91 2.79 -0.16 +GPSPosition2= 10.41 3.95 -0.16 +AltimeterPosition1= 12.94 1.79 -0.12 +AltimeterPosition2= 12.94 -1.79 -0.12 +InclinometerPosition1= 12.91 1.64 -0.12 +InclinometerPosition2= 12.91 1.64 -0.12 +RxCoilPosition1= -13.25 0.00 -2.00 + +LoopType=73 + +FrontGateDelay=2.5E-06 +TxLoopArea=342 + +TxLoopPoint1= -12.55 -2.10 +TxLoopPoint2= -6.03 -8.63 +TxLoopPoint3= 6.03 -8.63 +TxLoopPoint4= 11.34 -3.31 +TxLoopPoint5= 11.34 3.31 +TxLoopPoint6= 6.03 8.63 +TxLoopPoint7= -6.03 8.63 +TxLoopPoint8= -12.55 2.10 + + +NumberOfTurnsLM=1 +NumberOfTurnsHM=4 + +WaveformLMPoint01= -3.1810E-03 -0.0000E+00 +WaveformLMPoint02= -3.1479E-03 -6.8528E-02 +WaveformLMPoint03= -3.1478E-03 -6.8709E-02 +WaveformLMPoint04= -3.0977E-03 -1.4731E-01 +WaveformLMPoint05= -2.9738E-03 -3.1689E-01 +WaveformLMPoint06= -2.5752E-03 -7.6871E-01 +WaveformLMPoint07= -2.3810E-03 -1.0000E+00 +WaveformLMPoint08= -2.3806E-03 -9.1267E-01 +WaveformLMPoint09= -2.3786E-03 -8.2293E-02 +WaveformLMPoint10= -2.3778E-03 1.3222E-02 +WaveformLMPoint11= -2.3761E-03 -0.0000E+00 +WaveformLMPoint12= -8.0000E-04 0.0000E+00 +WaveformLMPoint13= -7.6685E-04 6.8627E-02 +WaveformLMPoint14= -7.1669E-04 1.4733E-01 +WaveformLMPoint15= -5.9284E-04 3.1685E-01 +WaveformLMPoint16= -1.9420E-04 7.6870E-01 +WaveformLMPoint17= 0.0000E+00 1.0000E+00 +WaveformLMPoint18= 2.0360E-07 9.7520E-01 +WaveformLMPoint19= 3.3960E-07 9.4031E-01 +WaveformLMPoint20= 7.5560E-07 7.4996E-01 +WaveformLMPoint21= 1.1396E-06 5.9446E-01 +WaveformLMPoint22= 1.2996E-06 5.0801E-01 +WaveformLMPoint23= 1.4436E-06 4.5183E-01 +WaveformLMPoint24= 1.8276E-06 2.7532E-01 +WaveformLMPoint25= 2.2036E-06 1.3943E-01 +WaveformLMPoint26= 2.4036E-06 8.1246E-02 +WaveformLMPoint27= 2.7076E-06 2.2870E-02 +WaveformLMPoint28= 3.1796E-06 -1.2986E-02 +WaveformLMPoint29= 3.8756E-06 -2.1039E-02 +WaveformLMPoint30= 4.9076E-06 0.0000E+00 + + +WaveformHMPoint01= -2.0667E-02 -0.0000E+00 +WaveformHMPoint02= -2.0657E-02 -4.0599E-02 +WaveformHMPoint03= -2.0655E-02 -7.1136E-02 +WaveformHMPoint04= -2.0629E-02 -6.7215E-01 +WaveformHMPoint05= -2.0623E-02 -7.9585E-01 +WaveformHMPoint06= -2.0619E-02 -8.5786E-01 +WaveformHMPoint07= -2.0613E-02 -8.9403E-01 +WaveformHMPoint08= -2.0592E-02 -9.1530E-01 +WaveformHMPoint09= -1.8916E-02 -9.6575E-01 +WaveformHMPoint10= -1.6667E-02 -1.0000E+00 +WaveformHMPoint11= -1.6626E-02 -9.8028E-03 +WaveformHMPoint12= -1.6623E-02 -0.0000E+00 +WaveformHMPoint13= -4.0000E-03 0.0000E+00 +WaveformHMPoint14= -3.9900E-03 4.0646E-02 +WaveformHMPoint15= -3.9876E-03 7.7566E-02 +WaveformHMPoint16= -3.9846E-03 1.4044E-01 +WaveformHMPoint17= -3.9718E-03 4.4718E-01 +WaveformHMPoint18= -3.9620E-03 6.7123E-01 +WaveformHMPoint19= -3.9562E-03 7.9323E-01 +WaveformHMPoint20= -3.9522E-03 8.5559E-01 +WaveformHMPoint21= -3.9495E-03 8.8104E-01 +WaveformHMPoint22= -3.9463E-03 8.9347E-01 +WaveformHMPoint23= -3.9367E-03 9.1091E-01 +WaveformHMPoint24= -3.9249E-03 9.1535E-01 +WaveformHMPoint25= -3.2829E-03 9.4073E-01 +WaveformHMPoint26= -2.2483E-03 9.6576E-01 +WaveformHMPoint27= 0.0000E+00 1.0000E+00 +WaveformHMPoint28= 5.6160E-07 9.9736E-01 +WaveformHMPoint29= 3.6016E-06 9.2013E-01 +WaveformHMPoint30= 4.0770E-05 1.4475E-02 +WaveformHMPoint31= 4.1490E-05 -1.2607E-04 +WaveformHMPoint32= 4.1954E-05 -5.3289E-03 +WaveformHMPoint33= 4.3618E-05 0.0000E+00 + +RxCoilLPFilter1= 0.99 210E+3 +GateNoForPowerLineMonitor=28 +FreqForPowerLineMonitor=60.00 +CalculateRawDataSTD=0 +GateTime01=7.150E-07 4.300E-07 1.000E-06 +GateTime02=2.215E-06 1.430E-06 3.000E-06 +GateTime03=4.215E-06 3.430E-06 5.000E-06 +GateTime04=6.215E-06 5.430E-06 7.000E-06 +GateTime05=8.215E-06 7.430E-06 9.000E-06 +GateTime06=1.022E-05 9.430E-06 1.100E-05 +GateTime07=1.221E-05 1.143E-05 1.300E-05 +GateTime08=1.472E-05 1.343E-05 1.600E-05 +GateTime09=1.821E-05 1.643E-05 2.000E-05 +GateTime10=2.271E-05 2.043E-05 2.500E-05 +GateTime11=2.821E-05 2.543E-05 3.100E-05 +GateTime12=3.522E-05 3.143E-05 3.900E-05 +GateTime13=4.421E-05 3.943E-05 4.900E-05 +GateTime14=5.571E-05 4.943E-05 6.200E-05 +GateTime15=7.021E-05 6.243E-05 7.800E-05 +GateTime16=8.821E-05 7.843E-05 9.800E-05 +GateTime17=1.107E-04 9.843E-05 1.230E-04 +GateTime18=1.387E-04 1.234E-04 1.540E-04 +GateTime19=1.742E-04 1.544E-04 1.940E-04 +GateTime20=2.197E-04 1.944E-04 2.450E-04 +GateTime21=2.767E-04 2.454E-04 3.080E-04 +GateTime22=3.487E-04 3.084E-04 3.890E-04 +GateTime23=4.397E-04 3.894E-04 4.900E-04 +GateTime24=5.537E-04 4.904E-04 6.170E-04 +GateTime25=6.977E-04 6.174E-04 7.780E-04 +GateTime26=8.792E-04 7.784E-04 9.800E-04 +GateTime27=1.108E-03 9.804E-04 1.235E-03 +GateTime28=1.396E-03 1.235E-03 1.557E-03 +GateTime29=1.760E-03 1.557E-03 1.963E-03 +GateTime30=2.219E-03 1.963E-03 2.474E-03 +GateTime31=2.797E-03 2.474E-03 3.120E-03 +GateTime32=3.516E-03 3.120E-03 3.912E-03 +GateTime33=4.396E-03 3.912E-03 4.880E-03 +GateTime34=5.473E-03 4.880E-03 6.065E-03 +GateTime35=6.791E-03 6.065E-03 7.517E-03 +GateTime36=8.405E-03 7.517E-03 9.293E-03 +GateTime37=1.038E-02 9.293E-03 1.147E-02 + +[Channel1] +RxCoilNumber=1 +GateTimeShift=-1.99e-6 +GateFactor=0.94 +SystemResponseConvolution=0 +RemoveInitialGates=7 +PrimaryFieldDampingFactor=1e-6 +UniformDataSTD=0.03 +MeaTimeDelay=0.000E+00 +NoGates=28 +RepFreq=210.00 +FrontGateTime=-7.700E-07 +TiBLowPassFilter=1 3.00E+5 +TransmitterMoment=LM +TxApproximateCurrent=8.8 +ReceiverPolarizationXYZ=Z + +[Channel2] +RxCoilNumber=1 +GateTimeShift=-1.8e-6 +GateFactor=0.99 +SystemResponseConvolution=0 +RemoveInitialGates=7 +PrimaryFieldDampingFactor=0.01 +UniformDataSTD=0.03 +MeaTimeDelay=6.000E-05 +NoGates=37 +RepFreq=30.00 +FrontGateTime=7.000E-05 +TiBLowPassFilter=1 3.00E+5 +TransmitterMoment=HM +TxApproximateCurrent=113.7 +ReceiverPolarizationXYZ=Z diff --git a/tests/data/CITATION.bib b/tests/data/CITATION.bib new file mode 100644 index 0000000..65d033c --- /dev/null +++ b/tests/data/CITATION.bib @@ -0,0 +1,10 @@ +@misc{https://doi.org/10.25740/vj301kx0276, + doi = {10.25740/VJ301KX0276}, + url = {https://purl.stanford.edu/vj301kx0276}, + author = {Knight, Rosemary and Steklova, Klara and Miltenberger, Alex and Kang, SEOGI and Goebel, Meredith and Fogg, Graham}, + keywords = {Water--Remote sensing, Sustainability}, + title = {Airborne Electromagnetic Data Acquired Over Incised Valley Fill Deposit in California's Central Valley}, + publisher = {Stanford Digital Repository}, + year = {2022}, + copyright = {https://opendatacommons.org/licenses/by/1-0/} +} diff --git a/tests/data/LICENSE.txt b/tests/data/LICENSE.txt new file mode 100644 index 0000000..fde10cc --- /dev/null +++ b/tests/data/LICENSE.txt @@ -0,0 +1,2 @@ +This work is licensed under an Open Data Commons Attribution License +v1.0. diff --git a/tests/data/import/DONE b/tests/data/import/DONE new file mode 100644 index 0000000..0962649 --- /dev/null +++ b/tests/data/import/DONE @@ -0,0 +1 @@ +DONE \ No newline at end of file diff --git a/tests/data/import/config.yml b/tests/data/import/config.yml new file mode 100644 index 0000000..2adf46f --- /dev/null +++ b/tests/data/import/config.yml @@ -0,0 +1,7 @@ +importer: + args: + files: + gexfile: file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/tests/data/20201231_20023_IVF_SkyTEM304_SKB.gex + xyzfile: file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/tests/data/aem_processed_data_foothill_central_valley.100101.0.xyz + projection: 32611 + name: SkyTEM XYZ diff --git a/tests/data/import/log.yml b/tests/data/import/log.yml new file mode 100644 index 0000000..0c15c51 --- /dev/null +++ b/tests/data/import/log.yml @@ -0,0 +1,15 @@ +- msg: Read config + time: 2024-09-08 12:36:14,048 + +- msg: Download files + time: 2024-09-08 12:36:14,050 + +- msg: Import data + time: 2024-09-08 12:36:14,050 + +- msg: Write and upload data + time: 2024-09-08 12:36:14,178 + +- msg: DONE + time: 2024-09-08 12:36:14,460 + diff --git a/tests/data/import/out.100101_0.geojson b/tests/data/import/out.100101_0.geojson new file mode 100644 index 0000000..dcd08e7 --- /dev/null +++ b/tests/data/import/out.100101_0.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "properties": {"Line": 100101.0, "apply_idx": 0, "DateTime": 44167.960527, "UTMX": 240505.7, "UTMY": 4049064.8, "Topography": 67.81, "rx_altitude": 47.755, "rx_altitude_std": 0.065, "TxAltitude": 45.11, "tx_altitude_std": 0.065, "TxPitch": 0.0, "tilt_x_std": 99.0, "TxRoll": 0.0, "tilt_y_std": 99.0, "fieldpolarity": 3.0, "current": 62.6, "tx_area": 342.0, "numgates": 32.5, "xdist": 0.0, "Current_Ch01": 8.8, "Current_Ch02": 113.7, "x_orig": 240505.7, "y_orig": 4049064.8, "x_web": -13347113.2054088, "y_web": 4376815.034356597, "lon": -119.89915791292223, "lat": 36.55179111293999}, "geometry": {"type": "LineString", "coordinates": [[-13347113.2054088, 4376815.034356597], [-13347200.128859026, 4376902.31456012], [-13347260.861560877, 4377011.74327471], [-13347336.581096943, 4377255.717823377], [-13347520.398133783, 4377728.337066866], [-13347790.154430715, 4378465.14417067], [-13347885.227327427, 4378777.005453568], [-13347910.152278764, 4378972.845875871], [-13347934.15835732, 4379051.431088976], [-13347974.83354342, 4379126.012967908], [-13348030.05097581, 4379192.034315483], [-13348160.455785884, 4379301.611255731], [-13348220.223767959, 4379365.87046964], [-13348426.400431953, 4379781.423380539], [-13348488.255382463, 4379993.020071575], [-13348500.256338915, 4380077.473004438], [-13348508.44753027, 4380291.2083679065], [-13348542.373352274, 4380455.070329818], [-13348638.964028995, 4380733.455297829], [-13348734.402395478, 4380961.161054388], [-13348799.21581521, 4381159.071277917], [-13348969.335741105, 4381565.035627603], [-13348995.100458922, 4381651.953968982], [-13349014.99347781, 4381787.402312362], [-13349038.510787647, 4381874.016040562], [-13349235.742766695, 4382229.698537704], [-13349359.015846673, 4382422.595254144], [-13349415.669080956, 4382535.189455758], [-13349626.208675316, 4382750.287496344], [-13349733.570516896, 4382832.345504715], [-13349798.878226414, 4382893.697878105], [-13349853.388834778, 4382960.003514708], [-13349893.927957335, 4383037.3573965635], [-13349921.62038871, 4383166.959658768], [-13349910.499800771, 4383304.873045532], [-13349885.087855574, 4383389.994462153], [-13349797.91867347, 4383592.589861691], [-13349756.065257857, 4383718.202716412], [-13349741.658133272, 4383805.239881515], [-13349747.539019197, 4383892.532150877], [-13349759.662981667, 4383935.397899264], [-13349800.435809903, 4384016.250838931], [-13349881.393976197, 4384117.493639609], [-13350000.735714253, 4384245.304317499], [-13350049.597216278, 4384313.78936063], [-13350106.179521395, 4384476.7630276205]]}}]} \ No newline at end of file diff --git a/tests/data/import/out.100101_0.gex b/tests/data/import/out.100101_0.gex new file mode 100644 index 0000000..7e040cb --- /dev/null +++ b/tests/data/import/out.100101_0.gex @@ -0,0 +1,203 @@ +/2024-09-08 gex file modified by the EmeraldProcessing toolbox + +[General] + + +Description=Test geometry file + + +GPSDifferentialPosition1= 11.91 2.79 -0.16 + + +GPSPosition1= 11.91 2.79 -0.16 +GPSPosition2= 10.41 3.95 -0.16 + + +AltimeterPosition1= 12.94 1.79 -0.12 +AltimeterPosition2= 12.94 -1.79 -0.12 + + +InclinometerPosition1= 12.91 1.64 -0.12 +InclinometerPosition2= 12.91 1.64 -0.12 + + +RxCoilPosition1= -13.25 0.00 -2.00 + + +LoopType=73 + + +FrontGateDelay=2.5e-06 + + +TxLoopArea=342.0 + + +TxLoopPoint1= -12.55 -2.1 +TxLoopPoint2= -6.03 -8.63 +TxLoopPoint3= 6.03 -8.63 +TxLoopPoint4= 11.34 -3.31 +TxLoopPoint5= 11.34 3.31 +TxLoopPoint6= 6.03 8.63 +TxLoopPoint7= -6.03 8.63 +TxLoopPoint8= -12.55 2.1 + + +NumberOfTurnsLM=1 + + +NumberOfTurnsHM=4 + + +WaveformLMPoint01= -3.181000e-03 -0.000000e+00 +WaveformLMPoint02= -3.147900e-03 -6.852800e-02 +WaveformLMPoint03= -3.147800e-03 -6.870900e-02 +WaveformLMPoint04= -3.097700e-03 -1.473100e-01 +WaveformLMPoint05= -2.973800e-03 -3.168900e-01 +WaveformLMPoint06= -2.575200e-03 -7.687100e-01 +WaveformLMPoint07= -2.381000e-03 -1.000000e+00 +WaveformLMPoint08= -2.380600e-03 -9.126700e-01 +WaveformLMPoint09= -2.378600e-03 -8.229300e-02 +WaveformLMPoint10= -2.377800e-03 1.322200e-02 +WaveformLMPoint11= -2.376100e-03 -0.000000e+00 +WaveformLMPoint12= -8.000000e-04 0.000000e+00 +WaveformLMPoint13= -7.668500e-04 6.862700e-02 +WaveformLMPoint14= -7.166900e-04 1.473300e-01 +WaveformLMPoint15= -5.928400e-04 3.168500e-01 +WaveformLMPoint16= -1.942000e-04 7.687000e-01 +WaveformLMPoint17= 0.000000e+00 1.000000e+00 +WaveformLMPoint18= 2.036000e-07 9.752000e-01 +WaveformLMPoint19= 3.396000e-07 9.403100e-01 +WaveformLMPoint20= 7.556000e-07 7.499600e-01 +WaveformLMPoint21= 1.139600e-06 5.944600e-01 +WaveformLMPoint22= 1.299600e-06 5.080100e-01 +WaveformLMPoint23= 1.443600e-06 4.518300e-01 +WaveformLMPoint24= 1.827600e-06 2.753200e-01 +WaveformLMPoint25= 2.203600e-06 1.394300e-01 +WaveformLMPoint26= 2.403600e-06 8.124600e-02 +WaveformLMPoint27= 2.707600e-06 2.287000e-02 +WaveformLMPoint28= 3.179600e-06 -1.298600e-02 +WaveformLMPoint29= 3.875600e-06 -2.103900e-02 +WaveformLMPoint30= 4.907600e-06 0.000000e+00 + + +WaveformHMPoint01= -2.066700e-02 -0.000000e+00 +WaveformHMPoint02= -2.065700e-02 -4.059900e-02 +WaveformHMPoint03= -2.065500e-02 -7.113600e-02 +WaveformHMPoint04= -2.062900e-02 -6.721500e-01 +WaveformHMPoint05= -2.062300e-02 -7.958500e-01 +WaveformHMPoint06= -2.061900e-02 -8.578600e-01 +WaveformHMPoint07= -2.061300e-02 -8.940300e-01 +WaveformHMPoint08= -2.059200e-02 -9.153000e-01 +WaveformHMPoint09= -1.891600e-02 -9.657500e-01 +WaveformHMPoint10= -1.666700e-02 -1.000000e+00 +WaveformHMPoint11= -1.662600e-02 -9.802800e-03 +WaveformHMPoint12= -1.662300e-02 -0.000000e+00 +WaveformHMPoint13= -4.000000e-03 0.000000e+00 +WaveformHMPoint14= -3.990000e-03 4.064600e-02 +WaveformHMPoint15= -3.987600e-03 7.756600e-02 +WaveformHMPoint16= -3.984600e-03 1.404400e-01 +WaveformHMPoint17= -3.971800e-03 4.471800e-01 +WaveformHMPoint18= -3.962000e-03 6.712300e-01 +WaveformHMPoint19= -3.956200e-03 7.932300e-01 +WaveformHMPoint20= -3.952200e-03 8.555900e-01 +WaveformHMPoint21= -3.949500e-03 8.810400e-01 +WaveformHMPoint22= -3.946300e-03 8.934700e-01 +WaveformHMPoint23= -3.936700e-03 9.109100e-01 +WaveformHMPoint24= -3.924900e-03 9.153500e-01 +WaveformHMPoint25= -3.282900e-03 9.407300e-01 +WaveformHMPoint26= -2.248300e-03 9.657600e-01 +WaveformHMPoint27= 0.000000e+00 1.000000e+00 +WaveformHMPoint28= 5.616000e-07 9.973600e-01 +WaveformHMPoint29= 3.601600e-06 9.201300e-01 +WaveformHMPoint30= 4.077000e-05 1.447500e-02 +WaveformHMPoint31= 4.149000e-05 -1.260700e-04 +WaveformHMPoint32= 4.195400e-05 -5.328900e-03 +WaveformHMPoint33= 4.361800e-05 0.000000e+00 + + +RxCoilLPFilter1= 0.990000 210000.000000 + + +GateNoForPowerLineMonitor=28 + + +FreqForPowerLineMonitor=60.0 + + +CalculateRawDataSTD=0.0 + + +GateTime01= 7.150000e-07 4.300000e-07 1.000000e-06 +GateTime02= 2.215000e-06 1.430000e-06 3.000000e-06 +GateTime03= 4.215000e-06 3.430000e-06 5.000000e-06 +GateTime04= 6.215000e-06 5.430000e-06 7.000000e-06 +GateTime05= 8.215000e-06 7.430000e-06 9.000000e-06 +GateTime06= 1.022000e-05 9.430000e-06 1.100000e-05 +GateTime07= 1.221000e-05 1.143000e-05 1.300000e-05 +GateTime08= 1.472000e-05 1.343000e-05 1.600000e-05 +GateTime09= 1.821000e-05 1.643000e-05 2.000000e-05 +GateTime10= 2.271000e-05 2.043000e-05 2.500000e-05 +GateTime11= 2.821000e-05 2.543000e-05 3.100000e-05 +GateTime12= 3.522000e-05 3.143000e-05 3.900000e-05 +GateTime13= 4.421000e-05 3.943000e-05 4.900000e-05 +GateTime14= 5.571000e-05 4.943000e-05 6.200000e-05 +GateTime15= 7.021000e-05 6.243000e-05 7.800000e-05 +GateTime16= 8.821000e-05 7.843000e-05 9.800000e-05 +GateTime17= 1.107000e-04 9.843000e-05 1.230000e-04 +GateTime18= 1.387000e-04 1.234000e-04 1.540000e-04 +GateTime19= 1.742000e-04 1.544000e-04 1.940000e-04 +GateTime20= 2.197000e-04 1.944000e-04 2.450000e-04 +GateTime21= 2.767000e-04 2.454000e-04 3.080000e-04 +GateTime22= 3.487000e-04 3.084000e-04 3.890000e-04 +GateTime23= 4.397000e-04 3.894000e-04 4.900000e-04 +GateTime24= 5.537000e-04 4.904000e-04 6.170000e-04 +GateTime25= 6.977000e-04 6.174000e-04 7.780000e-04 +GateTime26= 8.792000e-04 7.784000e-04 9.800000e-04 +GateTime27= 1.108000e-03 9.804000e-04 1.235000e-03 +GateTime28= 1.396000e-03 1.235000e-03 1.557000e-03 +GateTime29= 1.760000e-03 1.557000e-03 1.963000e-03 +GateTime30= 2.219000e-03 1.963000e-03 2.474000e-03 +GateTime31= 2.797000e-03 2.474000e-03 3.120000e-03 +GateTime32= 3.516000e-03 3.120000e-03 3.912000e-03 +GateTime33= 4.396000e-03 3.912000e-03 4.880000e-03 +GateTime34= 5.473000e-03 4.880000e-03 6.065000e-03 +GateTime35= 6.791000e-03 6.065000e-03 7.517000e-03 +GateTime36= 8.405000e-03 7.517000e-03 9.293000e-03 +GateTime37= 1.038000e-02 9.293000e-03 1.147000e-02 + +[Channel1] +RxCoilNumber=1 +GateTimeShift=-1.99e-06 +GateFactor=0.94 +SystemResponseConvolution=0 +RemoveInitialGates=7 +PrimaryFieldDampingFactor=1e-06 +UniformDataSTD=0.03 +MeaTimeDelay=0.0 +NoGates=28 +RepFreq=210.0 +FrontGateTime=-7.7e-07 +TiBLowPassFilter= 1.00 300000.00 +TransmitterMoment=LM +TxApproximateCurrent=8.8 +ReceiverPolarizationXYZ=Z +ApproxDipoleMoment=3009.6000000000004 + +[Channel2] +RxCoilNumber=1 +GateTimeShift=-1.8e-06 +GateFactor=0.99 +SystemResponseConvolution=0 +RemoveInitialGates=7 +PrimaryFieldDampingFactor=0.01 +UniformDataSTD=0.03 +MeaTimeDelay=6e-05 +NoGates=37 +RepFreq=30.0 +FrontGateTime=7e-05 +TiBLowPassFilter= 1.00 300000.00 +TransmitterMoment=HM +TxApproximateCurrent=113.7 +ReceiverPolarizationXYZ=Z +ApproxDipoleMoment=155541.6 diff --git a/tests/data/import/out.100101_0.msgpack b/tests/data/import/out.100101_0.msgpack new file mode 100644 index 0000000..94f3127 Binary files /dev/null and b/tests/data/import/out.100101_0.msgpack differ diff --git a/tests/data/import/out.100101_0.summary.yml b/tests/data/import/out.100101_0.summary.yml new file mode 100644 index 0000000..d0329fe --- /dev/null +++ b/tests/data/import/out.100101_0.summary.yml @@ -0,0 +1,488 @@ +100101.0: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 48.0 + 50%: 96.0 + 75%: 144.0 + count: 193.0 + max: 192.0 + mean: 96.0 + min: 0.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 +all: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 48.0 + 50%: 96.0 + 75%: 144.0 + count: 193.0 + max: 192.0 + mean: 96.0 + min: 0.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 diff --git a/tests/data/import/out.geojson b/tests/data/import/out.geojson new file mode 100644 index 0000000..bb98604 --- /dev/null +++ b/tests/data/import/out.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "properties": {"Line": 100101.0, "apply_idx": 18907, "DateTime": 44167.960527, "UTMX": 240505.7, "UTMY": 4049064.8, "Topography": 67.81, "rx_altitude": 47.755, "rx_altitude_std": 0.065, "TxAltitude": 45.11, "tx_altitude_std": 0.065, "TxPitch": 0.0, "tilt_x_std": 99.0, "TxRoll": 0.0, "tilt_y_std": 99.0, "fieldpolarity": 3.0, "current": 62.6, "tx_area": 342.0, "numgates": 32.5, "xdist": 0.0, "Current_Ch01": 8.8, "Current_Ch02": 113.7, "x_orig": 240505.7, "y_orig": 4049064.8, "x_web": -13347113.2054088, "y_web": 4376815.034356597, "lon": -119.89915791292223, "lat": 36.55179111293999}, "geometry": {"type": "LineString", "coordinates": [[-13347113.2054088, 4376815.034356597], [-13347200.128859026, 4376902.31456012], [-13347260.861560877, 4377011.74327471], [-13347336.581096943, 4377255.717823377], [-13347520.398133783, 4377728.337066866], [-13347790.154430715, 4378465.14417067], [-13347885.227327427, 4378777.005453568], [-13347910.152278764, 4378972.845875871], [-13347934.15835732, 4379051.431088976], [-13347974.83354342, 4379126.012967908], [-13348030.05097581, 4379192.034315483], [-13348160.455785884, 4379301.611255731], [-13348220.223767959, 4379365.87046964], [-13348426.400431953, 4379781.423380539], [-13348488.255382463, 4379993.020071575], [-13348500.256338915, 4380077.473004438], [-13348508.44753027, 4380291.2083679065], [-13348542.373352274, 4380455.070329818], [-13348638.964028995, 4380733.455297829], [-13348734.402395478, 4380961.161054388], [-13348799.21581521, 4381159.071277917], [-13348969.335741105, 4381565.035627603], [-13348995.100458922, 4381651.953968982], [-13349014.99347781, 4381787.402312362], [-13349038.510787647, 4381874.016040562], [-13349235.742766695, 4382229.698537704], [-13349359.015846673, 4382422.595254144], [-13349415.669080956, 4382535.189455758], [-13349626.208675316, 4382750.287496344], [-13349733.570516896, 4382832.345504715], [-13349798.878226414, 4382893.697878105], [-13349853.388834778, 4382960.003514708], [-13349893.927957335, 4383037.3573965635], [-13349921.62038871, 4383166.959658768], [-13349910.499800771, 4383304.873045532], [-13349885.087855574, 4383389.994462153], [-13349797.91867347, 4383592.589861691], [-13349756.065257857, 4383718.202716412], [-13349741.658133272, 4383805.239881515], [-13349747.539019197, 4383892.532150877], [-13349759.662981667, 4383935.397899264], [-13349800.435809903, 4384016.250838931], [-13349881.393976197, 4384117.493639609], [-13350000.735714253, 4384245.304317499], [-13350049.597216278, 4384313.78936063], [-13350106.179521395, 4384476.7630276205]]}}]} \ No newline at end of file diff --git a/tests/data/import/out.gex b/tests/data/import/out.gex new file mode 100644 index 0000000..7e040cb --- /dev/null +++ b/tests/data/import/out.gex @@ -0,0 +1,203 @@ +/2024-09-08 gex file modified by the EmeraldProcessing toolbox + +[General] + + +Description=Test geometry file + + +GPSDifferentialPosition1= 11.91 2.79 -0.16 + + +GPSPosition1= 11.91 2.79 -0.16 +GPSPosition2= 10.41 3.95 -0.16 + + +AltimeterPosition1= 12.94 1.79 -0.12 +AltimeterPosition2= 12.94 -1.79 -0.12 + + +InclinometerPosition1= 12.91 1.64 -0.12 +InclinometerPosition2= 12.91 1.64 -0.12 + + +RxCoilPosition1= -13.25 0.00 -2.00 + + +LoopType=73 + + +FrontGateDelay=2.5e-06 + + +TxLoopArea=342.0 + + +TxLoopPoint1= -12.55 -2.1 +TxLoopPoint2= -6.03 -8.63 +TxLoopPoint3= 6.03 -8.63 +TxLoopPoint4= 11.34 -3.31 +TxLoopPoint5= 11.34 3.31 +TxLoopPoint6= 6.03 8.63 +TxLoopPoint7= -6.03 8.63 +TxLoopPoint8= -12.55 2.1 + + +NumberOfTurnsLM=1 + + +NumberOfTurnsHM=4 + + +WaveformLMPoint01= -3.181000e-03 -0.000000e+00 +WaveformLMPoint02= -3.147900e-03 -6.852800e-02 +WaveformLMPoint03= -3.147800e-03 -6.870900e-02 +WaveformLMPoint04= -3.097700e-03 -1.473100e-01 +WaveformLMPoint05= -2.973800e-03 -3.168900e-01 +WaveformLMPoint06= -2.575200e-03 -7.687100e-01 +WaveformLMPoint07= -2.381000e-03 -1.000000e+00 +WaveformLMPoint08= -2.380600e-03 -9.126700e-01 +WaveformLMPoint09= -2.378600e-03 -8.229300e-02 +WaveformLMPoint10= -2.377800e-03 1.322200e-02 +WaveformLMPoint11= -2.376100e-03 -0.000000e+00 +WaveformLMPoint12= -8.000000e-04 0.000000e+00 +WaveformLMPoint13= -7.668500e-04 6.862700e-02 +WaveformLMPoint14= -7.166900e-04 1.473300e-01 +WaveformLMPoint15= -5.928400e-04 3.168500e-01 +WaveformLMPoint16= -1.942000e-04 7.687000e-01 +WaveformLMPoint17= 0.000000e+00 1.000000e+00 +WaveformLMPoint18= 2.036000e-07 9.752000e-01 +WaveformLMPoint19= 3.396000e-07 9.403100e-01 +WaveformLMPoint20= 7.556000e-07 7.499600e-01 +WaveformLMPoint21= 1.139600e-06 5.944600e-01 +WaveformLMPoint22= 1.299600e-06 5.080100e-01 +WaveformLMPoint23= 1.443600e-06 4.518300e-01 +WaveformLMPoint24= 1.827600e-06 2.753200e-01 +WaveformLMPoint25= 2.203600e-06 1.394300e-01 +WaveformLMPoint26= 2.403600e-06 8.124600e-02 +WaveformLMPoint27= 2.707600e-06 2.287000e-02 +WaveformLMPoint28= 3.179600e-06 -1.298600e-02 +WaveformLMPoint29= 3.875600e-06 -2.103900e-02 +WaveformLMPoint30= 4.907600e-06 0.000000e+00 + + +WaveformHMPoint01= -2.066700e-02 -0.000000e+00 +WaveformHMPoint02= -2.065700e-02 -4.059900e-02 +WaveformHMPoint03= -2.065500e-02 -7.113600e-02 +WaveformHMPoint04= -2.062900e-02 -6.721500e-01 +WaveformHMPoint05= -2.062300e-02 -7.958500e-01 +WaveformHMPoint06= -2.061900e-02 -8.578600e-01 +WaveformHMPoint07= -2.061300e-02 -8.940300e-01 +WaveformHMPoint08= -2.059200e-02 -9.153000e-01 +WaveformHMPoint09= -1.891600e-02 -9.657500e-01 +WaveformHMPoint10= -1.666700e-02 -1.000000e+00 +WaveformHMPoint11= -1.662600e-02 -9.802800e-03 +WaveformHMPoint12= -1.662300e-02 -0.000000e+00 +WaveformHMPoint13= -4.000000e-03 0.000000e+00 +WaveformHMPoint14= -3.990000e-03 4.064600e-02 +WaveformHMPoint15= -3.987600e-03 7.756600e-02 +WaveformHMPoint16= -3.984600e-03 1.404400e-01 +WaveformHMPoint17= -3.971800e-03 4.471800e-01 +WaveformHMPoint18= -3.962000e-03 6.712300e-01 +WaveformHMPoint19= -3.956200e-03 7.932300e-01 +WaveformHMPoint20= -3.952200e-03 8.555900e-01 +WaveformHMPoint21= -3.949500e-03 8.810400e-01 +WaveformHMPoint22= -3.946300e-03 8.934700e-01 +WaveformHMPoint23= -3.936700e-03 9.109100e-01 +WaveformHMPoint24= -3.924900e-03 9.153500e-01 +WaveformHMPoint25= -3.282900e-03 9.407300e-01 +WaveformHMPoint26= -2.248300e-03 9.657600e-01 +WaveformHMPoint27= 0.000000e+00 1.000000e+00 +WaveformHMPoint28= 5.616000e-07 9.973600e-01 +WaveformHMPoint29= 3.601600e-06 9.201300e-01 +WaveformHMPoint30= 4.077000e-05 1.447500e-02 +WaveformHMPoint31= 4.149000e-05 -1.260700e-04 +WaveformHMPoint32= 4.195400e-05 -5.328900e-03 +WaveformHMPoint33= 4.361800e-05 0.000000e+00 + + +RxCoilLPFilter1= 0.990000 210000.000000 + + +GateNoForPowerLineMonitor=28 + + +FreqForPowerLineMonitor=60.0 + + +CalculateRawDataSTD=0.0 + + +GateTime01= 7.150000e-07 4.300000e-07 1.000000e-06 +GateTime02= 2.215000e-06 1.430000e-06 3.000000e-06 +GateTime03= 4.215000e-06 3.430000e-06 5.000000e-06 +GateTime04= 6.215000e-06 5.430000e-06 7.000000e-06 +GateTime05= 8.215000e-06 7.430000e-06 9.000000e-06 +GateTime06= 1.022000e-05 9.430000e-06 1.100000e-05 +GateTime07= 1.221000e-05 1.143000e-05 1.300000e-05 +GateTime08= 1.472000e-05 1.343000e-05 1.600000e-05 +GateTime09= 1.821000e-05 1.643000e-05 2.000000e-05 +GateTime10= 2.271000e-05 2.043000e-05 2.500000e-05 +GateTime11= 2.821000e-05 2.543000e-05 3.100000e-05 +GateTime12= 3.522000e-05 3.143000e-05 3.900000e-05 +GateTime13= 4.421000e-05 3.943000e-05 4.900000e-05 +GateTime14= 5.571000e-05 4.943000e-05 6.200000e-05 +GateTime15= 7.021000e-05 6.243000e-05 7.800000e-05 +GateTime16= 8.821000e-05 7.843000e-05 9.800000e-05 +GateTime17= 1.107000e-04 9.843000e-05 1.230000e-04 +GateTime18= 1.387000e-04 1.234000e-04 1.540000e-04 +GateTime19= 1.742000e-04 1.544000e-04 1.940000e-04 +GateTime20= 2.197000e-04 1.944000e-04 2.450000e-04 +GateTime21= 2.767000e-04 2.454000e-04 3.080000e-04 +GateTime22= 3.487000e-04 3.084000e-04 3.890000e-04 +GateTime23= 4.397000e-04 3.894000e-04 4.900000e-04 +GateTime24= 5.537000e-04 4.904000e-04 6.170000e-04 +GateTime25= 6.977000e-04 6.174000e-04 7.780000e-04 +GateTime26= 8.792000e-04 7.784000e-04 9.800000e-04 +GateTime27= 1.108000e-03 9.804000e-04 1.235000e-03 +GateTime28= 1.396000e-03 1.235000e-03 1.557000e-03 +GateTime29= 1.760000e-03 1.557000e-03 1.963000e-03 +GateTime30= 2.219000e-03 1.963000e-03 2.474000e-03 +GateTime31= 2.797000e-03 2.474000e-03 3.120000e-03 +GateTime32= 3.516000e-03 3.120000e-03 3.912000e-03 +GateTime33= 4.396000e-03 3.912000e-03 4.880000e-03 +GateTime34= 5.473000e-03 4.880000e-03 6.065000e-03 +GateTime35= 6.791000e-03 6.065000e-03 7.517000e-03 +GateTime36= 8.405000e-03 7.517000e-03 9.293000e-03 +GateTime37= 1.038000e-02 9.293000e-03 1.147000e-02 + +[Channel1] +RxCoilNumber=1 +GateTimeShift=-1.99e-06 +GateFactor=0.94 +SystemResponseConvolution=0 +RemoveInitialGates=7 +PrimaryFieldDampingFactor=1e-06 +UniformDataSTD=0.03 +MeaTimeDelay=0.0 +NoGates=28 +RepFreq=210.0 +FrontGateTime=-7.7e-07 +TiBLowPassFilter= 1.00 300000.00 +TransmitterMoment=LM +TxApproximateCurrent=8.8 +ReceiverPolarizationXYZ=Z +ApproxDipoleMoment=3009.6000000000004 + +[Channel2] +RxCoilNumber=1 +GateTimeShift=-1.8e-06 +GateFactor=0.99 +SystemResponseConvolution=0 +RemoveInitialGates=7 +PrimaryFieldDampingFactor=0.01 +UniformDataSTD=0.03 +MeaTimeDelay=6e-05 +NoGates=37 +RepFreq=30.0 +FrontGateTime=7e-05 +TiBLowPassFilter= 1.00 300000.00 +TransmitterMoment=HM +TxApproximateCurrent=113.7 +ReceiverPolarizationXYZ=Z +ApproxDipoleMoment=155541.6 diff --git a/tests/data/import/out.msgpack b/tests/data/import/out.msgpack new file mode 100644 index 0000000..75d6f30 Binary files /dev/null and b/tests/data/import/out.msgpack differ diff --git a/tests/data/import/out.summary.yml b/tests/data/import/out.summary.yml new file mode 100644 index 0000000..3a103bb --- /dev/null +++ b/tests/data/import/out.summary.yml @@ -0,0 +1,488 @@ +100101.0: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 18955.0 + 50%: 19003.0 + 75%: 19051.0 + count: 193.0 + max: 19099.0 + mean: 19003.0 + min: 18907.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 +all: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 18955.0 + 50%: 19003.0 + 75%: 19051.0 + count: 193.0 + max: 19099.0 + mean: 19003.0 + min: 18907.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 diff --git a/tests/data/inversion/DONE b/tests/data/inversion/DONE new file mode 100644 index 0000000..0962649 --- /dev/null +++ b/tests/data/inversion/DONE @@ -0,0 +1 @@ +DONE \ No newline at end of file diff --git a/tests/data/inversion/config.yml b/tests/data/inversion/config.yml new file mode 100644 index 0000000..96f6ec4 --- /dev/null +++ b/tests/data/inversion/config.yml @@ -0,0 +1,8 @@ +data: file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/tests/data/processing/processed.xyz +system: + args: + directives__irls: true + optimizer__max_iter: 4 + optimizer__max_iter_cg: 2 + name: Dual moment TEM +system_data: file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/tests/data/processing/processed.gex diff --git a/tests/data/inversion/log.yml b/tests/data/inversion/log.yml new file mode 100644 index 0000000..a5a6eed --- /dev/null +++ b/tests/data/inversion/log.yml @@ -0,0 +1,97 @@ +- msg: Loading... + time: 2024-09-08 12:48:02,729 + +- msg: Inverting... + time: 2024-09-08 12:48:03,055 + +- msg: Inversion step + status: start + step: 0 + time: 2024-09-08 12:48:06,894 + +- msg: Inversion step + status: initialize + step: 1 + time: 2024-09-08 12:50:03,649 + +- beta: 53.25634778790044 + f: 7067043.197443786 + iter: 1 + msg: Inversion step + phi_d: 1401431.1488757506 + phi_m: 1073.2530685447264 + phi_m_scaled: 57157.5386828493 + rmse_d: 28.404423148344073 + rmse_m: 0.786051788526474 + rmse_m_scaled: 5.736365963164829 + rmse_total: 28.977873435667092 + status: update + step: 3 + time: 2024-09-08 12:50:12,205 + '|proj(x-g)-x|': 294165.53311823006 + +- beta: 26.62817389395022 + f: 1458588.6875586 + iter: 2 + msg: Inversion step + phi_d: 560990.1958439258 + phi_m: 5528.802080480226 + phi_m_scaled: 147221.90322426122 + rmse_d: 17.97122685652819 + rmse_m: 1.7840852901897382 + rmse_m_scaled: 9.206325052356016 + rmse_total: 20.192112710126153 + status: update + step: 4 + time: 2024-09-08 12:50:26,899 + '|proj(x-g)-x|': 53727.33874206844 + +- beta: 13.31408694697511 + f: 708212.0990681871 + iter: 3 + msg: Inversion step + phi_d: 475338.6646852411 + phi_m: 2110.3810668815536 + phi_m_scaled: 28097.797015711098 + rmse_d: 16.542519745172587 + rmse_m: 1.1022510768043645 + rmse_m_scaled: 4.021945915100086 + rmse_total: 17.024423880513993 + status: update + step: 5 + time: 2024-09-08 12:50:41,174 + '|proj(x-g)-x|': 44599.53355155815 + +- beta: 6.657043473487555 + f: 503436.4617009522 + iter: 4 + msg: Inversion step + phi_d: 269449.00748275203 + phi_m: 10001.432824897884 + phi_m_scaled: 66579.97311251065 + rmse_d: 12.454846656181196 + rmse_m: 2.3995577246602977 + rmse_m_scaled: 6.1911581572328025 + rmse_total: 13.908761431445225 + status: update + step: 6 + time: 2024-09-08 12:51:05,590 + '|proj(x-g)-x|': 17640.85692947163 + +- msg: Inversion step + status: end + step: 6 + time: 2024-09-08 12:51:31,126 + +- msg: 'Inversion time(hr): 0.0584' + time: 2024-09-08 12:51:34,521 + +- msg: Saving... + time: 2024-09-08 12:51:34,521 + +- msg: Save done + time: 2024-09-08 12:51:37,269 + +- msg: DONE + time: 2024-09-08 12:51:37,269 + diff --git a/tests/data/inversion/monitor_info.csv b/tests/data/inversion/monitor_info.csv new file mode 100644 index 0000000..c1d985e --- /dev/null +++ b/tests/data/inversion/monitor_info.csv @@ -0,0 +1,212 @@ +,epoch_time,elapsed_time,memory_rss,cpu_times_user,cpu_times_system,cpu_times_total,gm_year,gm_month,gm_day,gm_time +0,1725792483.056168,0.0,0.3055763244628906,2.98,0.87,3.85,2024.0,9.0,8.0,10:48:03.056 +1,1725792484.0581474,1.0019793510437012,0.3080711364746094,3.98,0.88,4.86,2024.0,9.0,8.0,10:48:04.058 +2,1725792485.0604296,2.0042614936828613,0.3083229064941406,4.98,0.88,5.86,2024.0,9.0,8.0,10:48:05.060 +3,1725792486.0618768,3.005708694458008,0.3085746765136719,5.98,0.88,6.86,2024.0,9.0,8.0,10:48:06.062 +4,1725792487.0662677,4.010099649429321,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:07.066 +5,1725792488.066651,5.010483026504517,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:08.067 +6,1725792489.0668874,6.010719299316406,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:09.067 +7,1725792490.0671213,7.010953187942505,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:10.067 +8,1725792491.0673378,8.011169672012329,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:11.067 +9,1725792492.0675309,9.011362791061401,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:12.068 +10,1725792493.0677526,10.011584520339966,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:13.068 +11,1725792494.0679903,11.01182222366333,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:14.068 +12,1725792495.068263,12.012094974517822,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:15.068 +13,1725792496.0685854,13.012417316436768,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:16.069 +14,1725792497.0688686,14.01270055770874,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:17.069 +15,1725792498.0691435,15.012975454330444,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:18.069 +16,1725792499.069467,16.013298988342285,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:19.069 +17,1725792500.0697389,17.01357078552246,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:20.070 +18,1725792501.070062,18.013893842697144,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:21.070 +19,1725792502.0703366,19.01416850090027,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:22.070 +20,1725792503.0705955,20.014427423477173,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:23.071 +21,1725792504.0708702,21.014702081680298,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:24.071 +22,1725792505.0711644,22.01499629020691,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:25.071 +23,1725792506.0713894,23.01522135734558,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:26.071 +24,1725792507.0716925,24.01552438735962,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:27.072 +25,1725792508.0719304,25.015762329101562,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:28.072 +26,1725792509.0721502,26.015982151031494,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:29.072 +27,1725792510.0724123,27.016244173049927,0.30664825439453125,6.86,0.9,7.760000000000001,2024.0,9.0,8.0,10:48:30.072 +28,1725792511.0726295,28.01646137237549,0.3084526062011719,6.87,0.9,7.7700000000000005,2024.0,9.0,8.0,10:48:31.073 +29,1725792512.0728498,29.016681671142578,0.3084526062011719,6.87,0.9,7.7700000000000005,2024.0,9.0,8.0,10:48:32.073 +30,1725792513.073058,30.016889810562134,0.3084526062011719,6.87,0.9,7.7700000000000005,2024.0,9.0,8.0,10:48:33.073 +31,1725792514.0732856,31.017117500305176,0.3084526062011719,6.87,0.9,7.7700000000000005,2024.0,9.0,8.0,10:48:34.073 +32,1725792515.073655,32.017486810684204,0.3084526062011719,6.87,0.9,7.7700000000000005,2024.0,9.0,8.0,10:48:35.074 +33,1725792516.0739107,33.01774263381958,0.3084526062011719,6.87,0.9,7.7700000000000005,2024.0,9.0,8.0,10:48:36.074 +34,1725792517.0742497,34.01808166503906,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:37.074 +35,1725792518.0744925,35.01832437515259,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:38.074 +36,1725792519.0746984,36.01853036880493,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:39.075 +37,1725792520.074988,37.01881980895996,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:40.075 +38,1725792521.0752232,38.019055128097534,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:41.075 +39,1725792522.0754988,39.019330739974976,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:42.075 +40,1725792523.0757675,40.01959943771362,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:43.076 +41,1725792524.0760398,41.01987171173096,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:44.076 +42,1725792525.076304,42.0201358795166,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:45.076 +43,1725792526.0765712,43.020403146743774,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:46.077 +44,1725792527.076803,44.02063488960266,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:47.077 +45,1725792528.0770547,45.02088665962219,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:48.077 +46,1725792529.0773,46.02113199234009,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:49.077 +47,1725792530.0775397,47.021371603012085,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:50.078 +48,1725792531.077792,48.021623849868774,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:51.078 +49,1725792532.0780678,49.021899700164795,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:52.078 +50,1725792533.0782728,50.02210474014282,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:53.078 +51,1725792534.0785615,51.022393465042114,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:54.079 +52,1725792535.078823,52.02265501022339,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:55.079 +53,1725792536.07909,53.02292203903198,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:56.079 +54,1725792537.0793943,54.023226261138916,0.3084526062011719,6.87,0.91,7.78,2024.0,9.0,8.0,10:48:57.079 +55,1725792538.0796824,55.02351427078247,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:48:58.080 +56,1725792539.0800543,56.02388620376587,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:48:59.080 +57,1725792540.0803576,57.024189472198486,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:00.080 +58,1725792541.0805953,58.02442717552185,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:01.081 +59,1725792542.0809405,59.02477240562439,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:02.081 +60,1725792543.0813127,60.02514457702637,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:03.081 +61,1725792544.0816107,61.025442600250244,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:04.082 +62,1725792545.081912,62.02574396133423,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:05.082 +63,1725792546.0822008,63.02603268623352,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:06.082 +64,1725792547.0825865,64.0264184474945,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:07.083 +65,1725792548.082879,65.02671098709106,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:08.083 +66,1725792549.0831943,66.02702617645264,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:09.083 +67,1725792550.0834475,67.02727937698364,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:10.083 +68,1725792551.083692,68.0275239944458,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:11.084 +69,1725792552.0840552,69.02788710594177,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:12.084 +70,1725792553.0843606,70.0281925201416,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:13.084 +71,1725792554.0846186,71.02845048904419,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:14.085 +72,1725792555.084859,72.02869081497192,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:15.085 +73,1725792556.0851376,73.0289695262909,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:16.085 +74,1725792557.0854113,74.0292432308197,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:17.085 +75,1725792558.0856705,75.02950239181519,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:18.086 +76,1725792559.0859072,76.02973914146423,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:19.086 +77,1725792560.0862021,77.03003406524658,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:20.086 +78,1725792561.0864258,78.03025770187378,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:21.086 +79,1725792562.0866916,79.03052353858948,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:22.087 +80,1725792563.086985,80.03081703186035,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:23.087 +81,1725792564.087249,81.03108096122742,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:24.087 +82,1725792565.0874724,82.03130435943604,0.3100090026855469,6.89,0.91,7.8,2024.0,9.0,8.0,10:49:25.087 +83,1725792566.0877156,83.03154754638672,0.3105659484863281,6.9,0.91,7.8100000000000005,2024.0,9.0,8.0,10:49:26.088 +84,1725792567.087985,84.0318169593811,0.31131744384765625,6.9,0.91,7.8100000000000005,2024.0,9.0,8.0,10:49:27.088 +85,1725792568.0882807,85.03211259841919,0.31131744384765625,6.9,0.91,7.8100000000000005,2024.0,9.0,8.0,10:49:28.088 +86,1725792569.0885453,86.03237724304199,0.31131744384765625,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:29.089 +87,1725792570.0887682,87.03260016441345,0.31131744384765625,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:30.089 +88,1725792571.0891225,88.032954454422,0.31131744384765625,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:31.089 +89,1725792572.0894392,89.03327107429504,0.31131744384765625,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:32.089 +90,1725792573.0896628,90.03349471092224,0.31131744384765625,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:33.090 +91,1725792574.0899134,91.03374528884888,0.31131744384765625,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:34.090 +92,1725792575.090192,92.03402400016785,0.31131744384765625,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:35.090 +93,1725792576.0904994,93.03433132171631,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:36.090 +94,1725792577.0907652,94.034597158432,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:37.091 +95,1725792578.0910208,95.0348527431488,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:38.091 +96,1725792579.0912192,96.03505110740662,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:39.091 +97,1725792580.0914285,97.03526043891907,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:40.091 +98,1725792581.0916734,98.0355052947998,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:41.092 +99,1725792582.0919178,99.03574967384338,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:42.092 +100,1725792583.0921624,100.03599429130554,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:43.092 +101,1725792584.0924218,101.0362536907196,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:44.092 +102,1725792585.092668,102.03649997711182,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:45.093 +103,1725792586.0928843,103.03671622276306,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:46.093 +104,1725792587.0931091,104.03694105148315,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:47.093 +105,1725792588.0933394,105.03717136383057,0.3115653991699219,6.91,0.91,7.82,2024.0,9.0,8.0,10:49:48.093 +106,1725792589.09359,106.0374219417572,0.3120689392089844,6.91,0.92,7.83,2024.0,9.0,8.0,10:49:49.094 +107,1725792590.0938332,107.03766512870789,0.3139381408691406,6.93,0.93,7.859999999999999,2024.0,9.0,8.0,10:49:50.094 +108,1725792591.0942717,108.03810358047485,0.31394195556640625,6.94,0.93,7.87,2024.0,9.0,8.0,10:49:51.094 +109,1725792592.0945342,109.03836607933044,0.3139495849609375,6.95,0.93,7.88,2024.0,9.0,8.0,10:49:52.095 +110,1725792593.0948296,110.03866147994995,0.3139495849609375,6.96,0.93,7.89,2024.0,9.0,8.0,10:49:53.095 +111,1725792594.0950754,111.038907289505,0.31426239013671875,6.96,0.96,7.92,2024.0,9.0,8.0,10:49:54.095 +112,1725792595.09559,112.03942203521729,0.31426239013671875,6.96,0.96,7.92,2024.0,9.0,8.0,10:49:55.096 +113,1725792596.0959158,113.03974771499634,0.3142662048339844,6.96,0.97,7.93,2024.0,9.0,8.0,10:49:56.096 +114,1725792597.0961685,114.04000043869019,0.3142662048339844,6.96,0.97,7.93,2024.0,9.0,8.0,10:49:57.096 +115,1725792598.096538,115.0403699874878,0.3142662048339844,6.97,0.97,7.9399999999999995,2024.0,9.0,8.0,10:49:58.097 +116,1725792599.096786,116.04061794281006,0.3144035339355469,6.98,0.97,7.95,2024.0,9.0,8.0,10:49:59.097 +117,1725792600.0970972,117.04092907905579,0.3144035339355469,6.98,0.97,7.95,2024.0,9.0,8.0,10:50:00.097 +118,1725792601.0973835,118.04121541976929,0.3144035339355469,6.98,0.97,7.95,2024.0,9.0,8.0,10:50:01.097 +119,1725792602.0976844,119.04151630401611,0.3146553039550781,6.99,0.97,7.96,2024.0,9.0,8.0,10:50:02.098 +120,1725792603.0979548,120.04178667068481,0.3146553039550781,6.99,0.97,7.96,2024.0,9.0,8.0,10:50:03.098 +121,1725792604.0982883,121.04212021827698,0.3222541809082031,7.15,1.02,8.17,2024.0,9.0,8.0,10:50:04.098 +122,1725792605.098675,122.04250693321228,0.3222541809082031,7.16,1.02,8.18,2024.0,9.0,8.0,10:50:05.099 +123,1725792606.0988944,123.04272627830505,0.3222541809082031,7.18,1.02,8.2,2024.0,9.0,8.0,10:50:06.099 +124,1725792607.099185,124.04301691055298,0.32225799560546875,7.18,1.02,8.2,2024.0,9.0,8.0,10:50:07.099 +125,1725792608.0994756,125.0433075428009,0.32346343994140625,7.52,1.73,9.25,2024.0,9.0,8.0,10:50:08.099 +126,1725792609.0998654,126.04369735717773,0.32346343994140625,7.53,1.73,9.26,2024.0,9.0,8.0,10:50:09.10 +127,1725792610.100137,127.04396891593933,0.32346343994140625,7.54,1.74,9.28,2024.0,9.0,8.0,10:50:10.10 +128,1725792611.1003766,128.04420852661133,0.32346343994140625,7.54,1.74,9.28,2024.0,9.0,8.0,10:50:11.10 +129,1725792612.1006489,129.04448080062866,0.32346343994140625,7.55,1.74,9.29,2024.0,9.0,8.0,10:50:12.101 +130,1725792613.1009474,130.0447793006897,0.3234710693359375,7.84,2.44,10.28,2024.0,9.0,8.0,10:50:13.101 +131,1725792614.1014946,131.04532647132874,0.3234710693359375,7.84,2.44,10.28,2024.0,9.0,8.0,10:50:14.101 +132,1725792615.101789,132.04562091827393,0.3236236572265625,7.85,2.45,10.3,2024.0,9.0,8.0,10:50:15.102 +133,1725792616.102096,133.0459280014038,0.3236236572265625,7.85,2.45,10.3,2024.0,9.0,8.0,10:50:16.102 +134,1725792617.1023767,134.0462086200714,0.3236236572265625,7.85,2.45,10.3,2024.0,9.0,8.0,10:50:17.102 +135,1725792618.102678,135.0465099811554,0.3238639831542969,7.87,2.45,10.32,2024.0,9.0,8.0,10:50:18.103 +136,1725792619.1029832,136.04681515693665,0.3238639831542969,7.87,2.45,10.32,2024.0,9.0,8.0,10:50:19.103 +137,1725792620.1032763,137.04710817337036,0.3238639831542969,7.87,2.45,10.32,2024.0,9.0,8.0,10:50:20.103 +138,1725792621.1035643,138.04739618301392,0.3241119384765625,7.88,2.45,10.33,2024.0,9.0,8.0,10:50:21.104 +139,1725792622.1038375,139.04766941070557,0.3241119384765625,7.88,2.45,10.33,2024.0,9.0,8.0,10:50:22.104 +140,1725792623.1041598,140.0479917526245,0.3247032165527344,8.0,2.5,10.5,2024.0,9.0,8.0,10:50:23.104 +141,1725792624.1045108,141.04834270477295,0.3247032165527344,8.01,2.5,10.51,2024.0,9.0,8.0,10:50:24.105 +142,1725792625.1048,142.0486319065094,0.3247032165527344,8.02,2.5,10.52,2024.0,9.0,8.0,10:50:25.105 +143,1725792626.1051233,143.04895520210266,0.3247032165527344,8.02,2.5,10.52,2024.0,9.0,8.0,10:50:26.105 +144,1725792627.1053667,144.04919862747192,0.3247337341308594,8.25,3.25,11.5,2024.0,9.0,8.0,10:50:27.105 +145,1725792628.1058195,145.04965138435364,0.3247337341308594,8.25,3.25,11.5,2024.0,9.0,8.0,10:50:28.106 +146,1725792629.1060698,146.0499017238617,0.3247337341308594,8.25,3.25,11.5,2024.0,9.0,8.0,10:50:29.106 +147,1725792630.1062877,147.050119638443,0.324737548828125,8.27,3.25,11.52,2024.0,9.0,8.0,10:50:30.106 +148,1725792631.1066165,148.05044841766357,0.324737548828125,8.27,3.25,11.52,2024.0,9.0,8.0,10:50:31.107 +149,1725792632.1100652,149.05389714241028,0.324737548828125,8.28,3.25,11.53,2024.0,9.0,8.0,10:50:32.110 +150,1725792633.1102993,150.05413126945496,0.324737548828125,8.28,3.25,11.53,2024.0,9.0,8.0,10:50:33.110 +151,1725792634.110678,151.05450987815857,0.324737548828125,8.28,3.25,11.53,2024.0,9.0,8.0,10:50:34.111 +152,1725792635.1109352,152.05476713180542,0.324737548828125,8.29,3.25,11.54,2024.0,9.0,8.0,10:50:35.111 +153,1725792636.1112475,153.05507946014404,0.324737548828125,8.29,3.25,11.54,2024.0,9.0,8.0,10:50:36.111 +154,1725792637.1149137,154.0587456226349,0.3249855041503906,8.42,3.29,11.71,2024.0,9.0,8.0,10:50:37.115 +155,1725792638.1153193,155.05915117263794,0.3249855041503906,8.44,3.29,11.73,2024.0,9.0,8.0,10:50:38.115 +156,1725792639.1156116,156.05944347381592,0.3249855041503906,8.44,3.29,11.73,2024.0,9.0,8.0,10:50:39.116 +157,1725792640.1158628,157.0596947669983,0.3249855041503906,8.45,3.29,11.739999999999998,2024.0,9.0,8.0,10:50:40.116 +158,1725792641.1161497,158.05998158454895,0.3249855041503906,8.45,3.29,11.739999999999998,2024.0,9.0,8.0,10:50:41.116 +159,1725792642.1163945,159.0602264404297,0.3249702453613281,8.71,4.01,12.72,2024.0,9.0,8.0,10:50:42.116 +160,1725792643.1168623,160.06069421768188,0.3249702453613281,8.71,4.01,12.72,2024.0,9.0,8.0,10:50:43.117 +161,1725792644.1171563,161.06098818778992,0.32497406005859375,8.73,4.01,12.74,2024.0,9.0,8.0,10:50:44.117 +162,1725792645.11746,162.0612919330597,0.32497406005859375,8.73,4.01,12.74,2024.0,9.0,8.0,10:50:45.117 +163,1725792646.1176987,163.06153059005737,0.32497406005859375,8.73,4.01,12.74,2024.0,9.0,8.0,10:50:46.118 +164,1725792647.1179955,164.06182742118835,0.32497406005859375,8.75,4.01,12.76,2024.0,9.0,8.0,10:50:47.118 +165,1725792648.1183465,165.0621783733368,0.32497406005859375,8.75,4.01,12.76,2024.0,9.0,8.0,10:50:48.118 +166,1725792649.118625,166.06245684623718,0.32497406005859375,8.75,4.01,12.76,2024.0,9.0,8.0,10:50:49.119 +167,1725792650.1190536,167.0628855228424,0.32497406005859375,8.77,4.01,12.78,2024.0,9.0,8.0,10:50:50.119 +168,1725792651.119572,168.06340384483337,0.32497406005859375,8.77,4.01,12.78,2024.0,9.0,8.0,10:50:51.120 +169,1725792652.1200206,169.06385254859924,0.32497406005859375,8.77,4.01,12.78,2024.0,9.0,8.0,10:50:52.120 +170,1725792653.120407,170.06423902511597,0.32497406005859375,8.77,4.01,12.78,2024.0,9.0,8.0,10:50:53.120 +171,1725792654.1208863,171.06471824645996,0.32497406005859375,8.77,4.01,12.78,2024.0,9.0,8.0,10:50:54.121 +172,1725792655.121244,172.0650758743286,0.32497406005859375,8.77,4.01,12.78,2024.0,9.0,8.0,10:50:55.121 +173,1725792656.1217642,173.0655961036682,0.32561492919921875,9.05,4.1,13.15,2024.0,9.0,8.0,10:50:56.122 +174,1725792657.122456,174.06628799438477,0.32561492919921875,9.05,4.1,13.15,2024.0,9.0,8.0,10:50:57.122 +175,1725792658.1228933,175.06672525405884,0.32561492919921875,9.05,4.1,13.15,2024.0,9.0,8.0,10:50:58.123 +176,1725792659.1232893,176.06712126731873,0.3257026672363281,9.08,4.1,13.18,2024.0,9.0,8.0,10:50:59.123 +177,1725792660.123763,177.0675950050354,0.3257026672363281,9.08,4.1,13.18,2024.0,9.0,8.0,10:51:00.124 +178,1725792661.124233,178.0680649280548,0.3257026672363281,9.11,4.11,13.219999999999999,2024.0,9.0,8.0,10:51:01.124 +179,1725792662.1248097,179.06864166259766,0.3257026672363281,9.11,4.11,13.219999999999999,2024.0,9.0,8.0,10:51:02.125 +180,1725792663.125225,180.06905698776245,0.3257026672363281,9.11,4.11,13.219999999999999,2024.0,9.0,8.0,10:51:03.125 +181,1725792664.1257405,181.06957244873047,0.3257026672363281,9.12,4.11,13.23,2024.0,9.0,8.0,10:51:04.126 +182,1725792665.1261597,182.06999158859253,0.3257026672363281,9.12,4.11,13.23,2024.0,9.0,8.0,10:51:05.126 +183,1725792666.1265283,183.07036018371582,0.3257102966308594,9.44,4.94,14.379999999999999,2024.0,9.0,8.0,10:51:06.127 +184,1725792667.1272519,184.0710837841034,0.3257102966308594,9.44,4.94,14.379999999999999,2024.0,9.0,8.0,10:51:07.127 +185,1725792668.1276703,185.07150220870972,0.3257102966308594,9.44,4.94,14.379999999999999,2024.0,9.0,8.0,10:51:08.128 +186,1725792669.1281435,186.07197546958923,0.3257102966308594,9.44,4.94,14.379999999999999,2024.0,9.0,8.0,10:51:09.128 +187,1725792670.1285877,187.0724196434021,0.3257102966308594,9.45,4.94,14.39,2024.0,9.0,8.0,10:51:10.129 +188,1725792671.1290736,188.0729055404663,0.3257102966308594,9.45,4.94,14.39,2024.0,9.0,8.0,10:51:11.129 +189,1725792672.1295066,189.07333850860596,0.325714111328125,9.48,4.94,14.420000000000002,2024.0,9.0,8.0,10:51:12.130 +190,1725792673.1300166,190.07384848594666,0.325714111328125,9.48,4.94,14.420000000000002,2024.0,9.0,8.0,10:51:13.130 +191,1725792674.1306615,191.07449340820312,0.325714111328125,9.48,4.94,14.420000000000002,2024.0,9.0,8.0,10:51:14.131 +192,1725792675.1316984,192.07553029060364,0.325714111328125,9.48,4.94,14.420000000000002,2024.0,9.0,8.0,10:51:15.132 +193,1725792676.1323195,193.0761513710022,0.325714111328125,9.48,4.95,14.43,2024.0,9.0,8.0,10:51:16.132 +194,1725792677.1327753,194.07660722732544,0.325714111328125,9.48,4.95,14.43,2024.0,9.0,8.0,10:51:17.133 +195,1725792678.1333625,195.07719445228577,0.325714111328125,9.48,4.95,14.43,2024.0,9.0,8.0,10:51:18.133 +196,1725792679.139378,196.08320999145508,0.325714111328125,9.51,4.95,14.46,2024.0,9.0,8.0,10:51:19.139 +197,1725792680.141494,197.0853259563446,0.325714111328125,9.51,4.95,14.46,2024.0,9.0,8.0,10:51:20.141 +198,1725792681.141887,198.08571887016296,0.325714111328125,9.51,4.95,14.46,2024.0,9.0,8.0,10:51:21.142 +199,1725792682.1423786,199.08621048927307,0.325714111328125,9.51,4.95,14.46,2024.0,9.0,8.0,10:51:22.142 +200,1725792683.1429164,200.08674836158752,0.325714111328125,9.52,4.95,14.469999999999999,2024.0,9.0,8.0,10:51:23.143 +201,1725792684.1436229,201.0874547958374,0.325714111328125,9.52,4.95,14.469999999999999,2024.0,9.0,8.0,10:51:24.144 +202,1725792685.1442063,202.08803820610046,0.325714111328125,9.52,4.95,14.469999999999999,2024.0,9.0,8.0,10:51:25.144 +203,1725792686.1448207,203.0886526107788,0.325714111328125,9.54,4.95,14.489999999999998,2024.0,9.0,8.0,10:51:26.145 +204,1725792687.1453626,204.0891945362091,0.325714111328125,9.54,4.95,14.489999999999998,2024.0,9.0,8.0,10:51:27.145 +205,1725792688.1458924,205.08972430229187,0.325714111328125,9.54,4.95,14.489999999999998,2024.0,9.0,8.0,10:51:28.146 +206,1725792689.1464238,206.0902557373047,0.325714111328125,9.54,4.95,14.489999999999998,2024.0,9.0,8.0,10:51:29.146 +207,1725792690.1468143,207.09064626693726,0.325714111328125,9.54,4.95,14.489999999999998,2024.0,9.0,8.0,10:51:30.147 +208,1725792691.1477346,208.0915665626526,0.3257026672363281,9.59,4.96,14.55,2024.0,9.0,8.0,10:51:31.148 +209,1725792692.1554961,209.09932804107666,0.325714111328125,10.6,4.96,15.559999999999999,2024.0,9.0,8.0,10:51:32.155 +210,1725792693.1622336,210.1060655117035,0.3262748718261719,11.6,4.96,16.56,2024.0,9.0,8.0,10:51:33.162 diff --git a/tests/data/inversion/processed.100101_0.geojson b/tests/data/inversion/processed.100101_0.geojson new file mode 100644 index 0000000..a8d6195 --- /dev/null +++ b/tests/data/inversion/processed.100101_0.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "properties": {"Line": 100101.0, "apply_idx": 0, "DateTime": 44167.960527, "UTMX": 240505.7, "UTMY": 4049064.8, "Topography": 67.81, "rx_altitude": 47.755, "rx_altitude_std": 0.065, "TxAltitude": 45.11, "tx_altitude_std": 0.065, "TxPitch": 0.0, "tilt_x_std": 99.0, "TxRoll": 0.0, "tilt_y_std": 99.0, "fieldpolarity": 3.0, "current": 62.6, "tx_area": 342.0, "numgates": 32.5, "xdist": 0.0, "x_orig": 240505.7, "y_orig": 4049064.8, "x_web": -13347113.2054088, "y_web": 4376815.034356597, "lon": -119.89915791292223, "lat": 36.55179111293999, "disable_reason": "none", "Current_Ch01": 8.8, "Current_Ch02": 113.7, "DipoleMoment_Ch01": 3009.6000000000004, "DipoleMoment_Ch02": 155541.6, "num_inuse_ch01": 21, "num_inuse_ch02": 30, "resdata": null}, "geometry": {"type": "LineString", "coordinates": [[-13347113.2054088, 4376815.034356597], [-13347200.128859026, 4376902.31456012], [-13347260.861560877, 4377011.74327471], [-13347336.581096943, 4377255.717823377], [-13347520.398133783, 4377728.337066866], [-13347790.154430715, 4378465.14417067], [-13347885.227327427, 4378777.005453568], [-13347910.152278764, 4378972.845875871], [-13347934.15835732, 4379051.431088976], [-13347974.83354342, 4379126.012967908], [-13348030.05097581, 4379192.034315483], [-13348160.455785884, 4379301.611255731], [-13348220.223767959, 4379365.87046964], [-13348426.400431953, 4379781.423380539], [-13348488.255382463, 4379993.020071575], [-13348500.256338915, 4380077.473004438], [-13348508.44753027, 4380291.2083679065], [-13348542.373352274, 4380455.070329818], [-13348638.964028995, 4380733.455297829], [-13348734.402395478, 4380961.161054388], [-13348799.21581521, 4381159.071277917], [-13348969.335741105, 4381565.035627603], [-13348995.100458922, 4381651.953968982], [-13349014.99347781, 4381787.402312362], [-13349038.510787647, 4381874.016040562], [-13349235.742766695, 4382229.698537704], [-13349359.015846673, 4382422.595254144], [-13349415.669080956, 4382535.189455758], [-13349626.208675316, 4382750.287496344], [-13349733.570516896, 4382832.345504715], [-13349798.878226414, 4382893.697878105], [-13349853.388834778, 4382960.003514708], [-13349893.927957335, 4383037.3573965635], [-13349921.62038871, 4383166.959658768], [-13349910.499800771, 4383304.873045532], [-13349885.087855574, 4383389.994462153], [-13349797.91867347, 4383592.589861691], [-13349756.065257857, 4383718.202716412], [-13349741.658133272, 4383805.239881515], [-13349747.539019197, 4383892.532150877], [-13349759.662981667, 4383935.397899264], [-13349800.435809903, 4384016.250838931], [-13349881.393976197, 4384117.493639609], [-13350000.735714253, 4384245.304317499], [-13350049.597216278, 4384313.78936063], [-13350106.179521395, 4384476.7630276205]]}}]} \ No newline at end of file diff --git a/tests/data/inversion/processed.100101_0.msgpack b/tests/data/inversion/processed.100101_0.msgpack new file mode 100644 index 0000000..8cf969b Binary files /dev/null and b/tests/data/inversion/processed.100101_0.msgpack differ diff --git a/tests/data/inversion/processed.100101_0.summary.yml b/tests/data/inversion/processed.100101_0.summary.yml new file mode 100644 index 0000000..59c120a --- /dev/null +++ b/tests/data/inversion/processed.100101_0.summary.yml @@ -0,0 +1,578 @@ +100101.0: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 48.0 + 50%: 96.0 + 75%: 144.0 + count: 193.0 + max: 192.0 + mean: 96.0 + min: 0.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 +all: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 48.0 + 50%: 96.0 + 75%: 144.0 + count: 193.0 + max: 192.0 + mean: 96.0 + min: 0.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 diff --git a/tests/data/inversion/processed.geojson b/tests/data/inversion/processed.geojson new file mode 100644 index 0000000..1202ed6 --- /dev/null +++ b/tests/data/inversion/processed.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "properties": {"Line": 100101.0, "DateTime": 44167.960527, "UTMX": 240505.7, "UTMY": 4049064.8, "Topography": 67.81, "rx_altitude": 47.755, "rx_altitude_std": 0.065, "TxAltitude": 45.11, "tx_altitude_std": 0.065, "TxPitch": 0.0, "tilt_x_std": 99.0, "TxRoll": 0.0, "tilt_y_std": 99.0, "fieldpolarity": 3.0, "current": 62.6, "tx_area": 342.0, "numgates": 32.5, "xdist": 0.0, "x_orig": 240505.7, "y_orig": 4049064.8, "x_web": -13347113.2054088, "y_web": 4376815.034356597, "lon": -119.89915791292223, "lat": 36.55179111293999, "disable_reason": "none", "Current_Ch01": 8.8, "Current_Ch02": 113.7, "DipoleMoment_Ch01": 3009.6000000000004, "DipoleMoment_Ch02": 155541.6, "num_inuse_ch01": 21, "num_inuse_ch02": 30, "resdata": null}, "geometry": {"type": "LineString", "coordinates": [[-13347113.2054088, 4376815.034356597], [-13347200.128859026, 4376902.31456012], [-13347260.861560877, 4377011.74327471], [-13347336.581096943, 4377255.717823377], [-13347520.398133783, 4377728.337066866], [-13347790.154430715, 4378465.14417067], [-13347885.227327427, 4378777.005453568], [-13347910.152278764, 4378972.845875871], [-13347934.15835732, 4379051.431088976], [-13347974.83354342, 4379126.012967908], [-13348030.05097581, 4379192.034315483], [-13348160.455785884, 4379301.611255731], [-13348220.223767959, 4379365.87046964], [-13348426.400431953, 4379781.423380539], [-13348488.255382463, 4379993.020071575], [-13348500.256338915, 4380077.473004438], [-13348508.44753027, 4380291.2083679065], [-13348542.373352274, 4380455.070329818], [-13348638.964028995, 4380733.455297829], [-13348734.402395478, 4380961.161054388], [-13348799.21581521, 4381159.071277917], [-13348969.335741105, 4381565.035627603], [-13348995.100458922, 4381651.953968982], [-13349014.99347781, 4381787.402312362], [-13349038.510787647, 4381874.016040562], [-13349235.742766695, 4382229.698537704], [-13349359.015846673, 4382422.595254144], [-13349415.669080956, 4382535.189455758], [-13349626.208675316, 4382750.287496344], [-13349733.570516896, 4382832.345504715], [-13349798.878226414, 4382893.697878105], [-13349853.388834778, 4382960.003514708], [-13349893.927957335, 4383037.3573965635], [-13349921.62038871, 4383166.959658768], [-13349910.499800771, 4383304.873045532], [-13349885.087855574, 4383389.994462153], [-13349797.91867347, 4383592.589861691], [-13349756.065257857, 4383718.202716412], [-13349741.658133272, 4383805.239881515], [-13349747.539019197, 4383892.532150877], [-13349759.662981667, 4383935.397899264], [-13349800.435809903, 4384016.250838931], [-13349881.393976197, 4384117.493639609], [-13350000.735714253, 4384245.304317499], [-13350049.597216278, 4384313.78936063], [-13350106.179521395, 4384476.7630276205]]}}]} \ No newline at end of file diff --git a/tests/data/inversion/processed.msgpack b/tests/data/inversion/processed.msgpack new file mode 100644 index 0000000..24014ed Binary files /dev/null and b/tests/data/inversion/processed.msgpack differ diff --git a/tests/data/inversion/processed.summary.yml b/tests/data/inversion/processed.summary.yml new file mode 100644 index 0000000..9afa91b --- /dev/null +++ b/tests/data/inversion/processed.summary.yml @@ -0,0 +1,560 @@ +100101.0: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 +all: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 diff --git a/tests/data/inversion/smooth_model.100101_0.geojson b/tests/data/inversion/smooth_model.100101_0.geojson new file mode 100644 index 0000000..d852da0 --- /dev/null +++ b/tests/data/inversion/smooth_model.100101_0.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "properties": {"Line": 100101.0, "apply_idx": 0, "DateTime": 44167.960527, "UTMX": 240505.7, "UTMY": 4049064.8, "Topography": 67.81, "rx_altitude": 47.755, "rx_altitude_std": 0.065, "TxAltitude": 45.11, "tx_altitude_std": 0.065, "TxPitch": 0.0, "tilt_x_std": 99.0, "TxRoll": 0.0, "tilt_y_std": 99.0, "fieldpolarity": 3.0, "current": 62.6, "tx_area": 342.0, "numgates": 32.5, "xdist": 0.0, "x_orig": 240505.7, "y_orig": 4049064.8, "x_web": -13347113.2054088, "y_web": 4376815.034356597, "lon": -119.89915791292223, "lat": 36.55179111293999, "disable_reason": "none", "Current_Ch01": 8.8, "Current_Ch02": 113.7, "DipoleMoment_Ch01": 3009.6000000000004, "DipoleMoment_Ch02": 155541.6, "num_inuse_ch01": 21, "num_inuse_ch02": 30, "doi_lower": 500, "doi_upper": 300, "resdata": null, "restotal": null, "numdata": null}, "geometry": {"type": "LineString", "coordinates": [[-13347113.2054088, 4376815.034356597], [-13347200.128859026, 4376902.31456012], [-13347260.861560877, 4377011.74327471], [-13347336.581096943, 4377255.717823377], [-13347520.398133783, 4377728.337066866], [-13347790.154430715, 4378465.14417067], [-13347885.227327427, 4378777.005453568], [-13347910.152278764, 4378972.845875871], [-13347934.15835732, 4379051.431088976], [-13347974.83354342, 4379126.012967908], [-13348030.05097581, 4379192.034315483], [-13348160.455785884, 4379301.611255731], [-13348220.223767959, 4379365.87046964], [-13348426.400431953, 4379781.423380539], [-13348488.255382463, 4379993.020071575], [-13348500.256338915, 4380077.473004438], [-13348508.44753027, 4380291.2083679065], [-13348542.373352274, 4380455.070329818], [-13348638.964028995, 4380733.455297829], [-13348734.402395478, 4380961.161054388], [-13348799.21581521, 4381159.071277917], [-13348969.335741105, 4381565.035627603], [-13348995.100458922, 4381651.953968982], [-13349014.99347781, 4381787.402312362], [-13349038.510787647, 4381874.016040562], [-13349235.742766695, 4382229.698537704], [-13349359.015846673, 4382422.595254144], [-13349415.669080956, 4382535.189455758], [-13349626.208675316, 4382750.287496344], [-13349733.570516896, 4382832.345504715], [-13349798.878226414, 4382893.697878105], [-13349853.388834778, 4382960.003514708], [-13349893.927957335, 4383037.3573965635], [-13349921.62038871, 4383166.959658768], [-13349910.499800771, 4383304.873045532], [-13349885.087855574, 4383389.994462153], [-13349797.91867347, 4383592.589861691], [-13349756.065257857, 4383718.202716412], [-13349741.658133272, 4383805.239881515], [-13349747.539019197, 4383892.532150877], [-13349759.662981667, 4383935.397899264], [-13349800.435809903, 4384016.250838931], [-13349881.393976197, 4384117.493639609], [-13350000.735714253, 4384245.304317499], [-13350049.597216278, 4384313.78936063], [-13350106.179521395, 4384476.7630276205]]}}]} \ No newline at end of file diff --git a/tests/data/inversion/smooth_model.100101_0.msgpack b/tests/data/inversion/smooth_model.100101_0.msgpack new file mode 100644 index 0000000..0d47caf Binary files /dev/null and b/tests/data/inversion/smooth_model.100101_0.msgpack differ diff --git a/tests/data/inversion/smooth_model.100101_0.summary.yml b/tests/data/inversion/smooth_model.100101_0.summary.yml new file mode 100644 index 0000000..710e0ec --- /dev/null +++ b/tests/data/inversion/smooth_model.100101_0.summary.yml @@ -0,0 +1,650 @@ +100101.0: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 48.0 + 50%: 96.0 + 75%: 144.0 + count: 193.0 + max: 192.0 + mean: 96.0 + min: 0.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + doi_lower: + 25%: 500.0 + 50%: 500.0 + 75%: 500.0 + count: 193.0 + max: 500.0 + mean: 500.0 + min: 500.0 + std: 0.0 + doi_upper: + 25%: 300.0 + 50%: 300.0 + 75%: 300.0 + count: 193.0 + max: 300.0 + mean: 300.0 + min: 300.0 + std: 0.0 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + restotal: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 +all: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 48.0 + 50%: 96.0 + 75%: 144.0 + count: 193.0 + max: 192.0 + mean: 96.0 + min: 0.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + doi_lower: + 25%: 500.0 + 50%: 500.0 + 75%: 500.0 + count: 193.0 + max: 500.0 + mean: 500.0 + min: 500.0 + std: 0.0 + doi_upper: + 25%: 300.0 + 50%: 300.0 + 75%: 300.0 + count: 193.0 + max: 300.0 + mean: 300.0 + min: 300.0 + std: 0.0 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + restotal: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 diff --git a/tests/data/inversion/smooth_model.geojson b/tests/data/inversion/smooth_model.geojson new file mode 100644 index 0000000..c5adbd2 --- /dev/null +++ b/tests/data/inversion/smooth_model.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "properties": {"Line": 100101.0, "apply_idx": 18907, "DateTime": 44167.960527, "UTMX": 240505.7, "UTMY": 4049064.8, "Topography": 67.81, "rx_altitude": 47.755, "rx_altitude_std": 0.065, "TxAltitude": 45.11, "tx_altitude_std": 0.065, "TxPitch": 0.0, "tilt_x_std": 99.0, "TxRoll": 0.0, "tilt_y_std": 99.0, "fieldpolarity": 3.0, "current": 62.6, "tx_area": 342.0, "numgates": 32.5, "xdist": 0.0, "x_orig": 240505.7, "y_orig": 4049064.8, "x_web": -13347113.2054088, "y_web": 4376815.034356597, "lon": -119.89915791292223, "lat": 36.55179111293999, "disable_reason": "none", "Current_Ch01": 8.8, "Current_Ch02": 113.7, "DipoleMoment_Ch01": 3009.6000000000004, "DipoleMoment_Ch02": 155541.6, "num_inuse_ch01": 21, "num_inuse_ch02": 30, "doi_lower": 500, "doi_upper": 300, "resdata": null, "restotal": null, "numdata": null}, "geometry": {"type": "LineString", "coordinates": [[-13347113.2054088, 4376815.034356597], [-13347200.128859026, 4376902.31456012], [-13347260.861560877, 4377011.74327471], [-13347336.581096943, 4377255.717823377], [-13347520.398133783, 4377728.337066866], [-13347790.154430715, 4378465.14417067], [-13347885.227327427, 4378777.005453568], [-13347910.152278764, 4378972.845875871], [-13347934.15835732, 4379051.431088976], [-13347974.83354342, 4379126.012967908], [-13348030.05097581, 4379192.034315483], [-13348160.455785884, 4379301.611255731], [-13348220.223767959, 4379365.87046964], [-13348426.400431953, 4379781.423380539], [-13348488.255382463, 4379993.020071575], [-13348500.256338915, 4380077.473004438], [-13348508.44753027, 4380291.2083679065], [-13348542.373352274, 4380455.070329818], [-13348638.964028995, 4380733.455297829], [-13348734.402395478, 4380961.161054388], [-13348799.21581521, 4381159.071277917], [-13348969.335741105, 4381565.035627603], [-13348995.100458922, 4381651.953968982], [-13349014.99347781, 4381787.402312362], [-13349038.510787647, 4381874.016040562], [-13349235.742766695, 4382229.698537704], [-13349359.015846673, 4382422.595254144], [-13349415.669080956, 4382535.189455758], [-13349626.208675316, 4382750.287496344], [-13349733.570516896, 4382832.345504715], [-13349798.878226414, 4382893.697878105], [-13349853.388834778, 4382960.003514708], [-13349893.927957335, 4383037.3573965635], [-13349921.62038871, 4383166.959658768], [-13349910.499800771, 4383304.873045532], [-13349885.087855574, 4383389.994462153], [-13349797.91867347, 4383592.589861691], [-13349756.065257857, 4383718.202716412], [-13349741.658133272, 4383805.239881515], [-13349747.539019197, 4383892.532150877], [-13349759.662981667, 4383935.397899264], [-13349800.435809903, 4384016.250838931], [-13349881.393976197, 4384117.493639609], [-13350000.735714253, 4384245.304317499], [-13350049.597216278, 4384313.78936063], [-13350106.179521395, 4384476.7630276205]]}}]} \ No newline at end of file diff --git a/tests/data/inversion/smooth_model.msgpack b/tests/data/inversion/smooth_model.msgpack new file mode 100644 index 0000000..65689d2 Binary files /dev/null and b/tests/data/inversion/smooth_model.msgpack differ diff --git a/tests/data/inversion/smooth_model.summary.yml b/tests/data/inversion/smooth_model.summary.yml new file mode 100644 index 0000000..1c34535 --- /dev/null +++ b/tests/data/inversion/smooth_model.summary.yml @@ -0,0 +1,650 @@ +100101.0: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 18955.0 + 50%: 19003.0 + 75%: 19051.0 + count: 193.0 + max: 19099.0 + mean: 19003.0 + min: 18907.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + doi_lower: + 25%: 500.0 + 50%: 500.0 + 75%: 500.0 + count: 193.0 + max: 500.0 + mean: 500.0 + min: 500.0 + std: 0.0 + doi_upper: + 25%: 300.0 + 50%: 300.0 + 75%: 300.0 + count: 193.0 + max: 300.0 + mean: 300.0 + min: 300.0 + std: 0.0 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + restotal: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 +all: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 18955.0 + 50%: 19003.0 + 75%: 19051.0 + count: 193.0 + max: 19099.0 + mean: 19003.0 + min: 18907.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + doi_lower: + 25%: 500.0 + 50%: 500.0 + 75%: 500.0 + count: 193.0 + max: 500.0 + mean: 500.0 + min: 500.0 + std: 0.0 + doi_upper: + 25%: 300.0 + 50%: 300.0 + 75%: 300.0 + count: 193.0 + max: 300.0 + mean: 300.0 + min: 300.0 + std: 0.0 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + restotal: + 25%: null + 50%: null + 75%: null + count: 0.0 + max: null + mean: null + min: null + std: null + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 diff --git a/tests/data/inversion/smooth_synthetic.100101_0.geojson b/tests/data/inversion/smooth_synthetic.100101_0.geojson new file mode 100644 index 0000000..888000c --- /dev/null +++ b/tests/data/inversion/smooth_synthetic.100101_0.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "properties": {"Line": 100101.0, "apply_idx": 0, "DateTime": 44167.960527, "UTMX": 240505.7, "UTMY": 4049064.8, "Topography": 67.81, "rx_altitude": 47.755, "rx_altitude_std": 0.065, "TxAltitude": 45.11, "tx_altitude_std": 0.065, "TxPitch": 0.0, "tilt_x_std": 99.0, "TxRoll": 0.0, "tilt_y_std": 99.0, "fieldpolarity": 3.0, "current": 62.6, "tx_area": 342.0, "numgates": 32.5, "xdist": 0.0, "x_orig": 240505.7, "y_orig": 4049064.8, "x_web": -13347113.2054088, "y_web": 4376815.034356597, "lon": -119.89915791292223, "lat": 36.55179111293999, "disable_reason": "none", "Current_Ch01": 8.8, "Current_Ch02": 113.7, "DipoleMoment_Ch01": 3009.6000000000004, "DipoleMoment_Ch02": 155541.6, "num_inuse_ch01": 21, "num_inuse_ch02": 30, "resdata": 8.378624187262508}, "geometry": {"type": "LineString", "coordinates": [[-13347113.2054088, 4376815.034356597], [-13347200.128859026, 4376902.31456012], [-13347260.861560877, 4377011.74327471], [-13347336.581096943, 4377255.717823377], [-13347520.398133783, 4377728.337066866], [-13347790.154430715, 4378465.14417067], [-13347885.227327427, 4378777.005453568], [-13347910.152278764, 4378972.845875871], [-13347934.15835732, 4379051.431088976], [-13347974.83354342, 4379126.012967908], [-13348030.05097581, 4379192.034315483], [-13348160.455785884, 4379301.611255731], [-13348220.223767959, 4379365.87046964], [-13348426.400431953, 4379781.423380539], [-13348488.255382463, 4379993.020071575], [-13348500.256338915, 4380077.473004438], [-13348508.44753027, 4380291.2083679065], [-13348542.373352274, 4380455.070329818], [-13348638.964028995, 4380733.455297829], [-13348734.402395478, 4380961.161054388], [-13348799.21581521, 4381159.071277917], [-13348969.335741105, 4381565.035627603], [-13348995.100458922, 4381651.953968982], [-13349014.99347781, 4381787.402312362], [-13349038.510787647, 4381874.016040562], [-13349235.742766695, 4382229.698537704], [-13349359.015846673, 4382422.595254144], [-13349415.669080956, 4382535.189455758], [-13349626.208675316, 4382750.287496344], [-13349733.570516896, 4382832.345504715], [-13349798.878226414, 4382893.697878105], [-13349853.388834778, 4382960.003514708], [-13349893.927957335, 4383037.3573965635], [-13349921.62038871, 4383166.959658768], [-13349910.499800771, 4383304.873045532], [-13349885.087855574, 4383389.994462153], [-13349797.91867347, 4383592.589861691], [-13349756.065257857, 4383718.202716412], [-13349741.658133272, 4383805.239881515], [-13349747.539019197, 4383892.532150877], [-13349759.662981667, 4383935.397899264], [-13349800.435809903, 4384016.250838931], [-13349881.393976197, 4384117.493639609], [-13350000.735714253, 4384245.304317499], [-13350049.597216278, 4384313.78936063], [-13350106.179521395, 4384476.7630276205]]}}]} \ No newline at end of file diff --git a/tests/data/inversion/smooth_synthetic.100101_0.msgpack b/tests/data/inversion/smooth_synthetic.100101_0.msgpack new file mode 100644 index 0000000..06bc2f4 Binary files /dev/null and b/tests/data/inversion/smooth_synthetic.100101_0.msgpack differ diff --git a/tests/data/inversion/smooth_synthetic.100101_0.summary.yml b/tests/data/inversion/smooth_synthetic.100101_0.summary.yml new file mode 100644 index 0000000..e81143e --- /dev/null +++ b/tests/data/inversion/smooth_synthetic.100101_0.summary.yml @@ -0,0 +1,578 @@ +100101.0: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 48.0 + 50%: 96.0 + 75%: 144.0 + count: 193.0 + max: 192.0 + mean: 96.0 + min: 0.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: 11.969121198557469 + 50%: 12.419304151459885 + 75%: 12.858740592208077 + count: 193.0 + max: 20.999359421153233 + mean: 12.380160316821648 + min: 7.5363849440922115 + std: 1.365465620838824 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 +all: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 48.0 + 50%: 96.0 + 75%: 144.0 + count: 193.0 + max: 192.0 + mean: 96.0 + min: 0.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: 11.969121198557469 + 50%: 12.419304151459885 + 75%: 12.858740592208077 + count: 193.0 + max: 20.999359421153233 + mean: 12.380160316821648 + min: 7.5363849440922115 + std: 1.365465620838824 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 diff --git a/tests/data/inversion/smooth_synthetic.geojson b/tests/data/inversion/smooth_synthetic.geojson new file mode 100644 index 0000000..74584cf --- /dev/null +++ b/tests/data/inversion/smooth_synthetic.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "properties": {"Line": 100101.0, "DateTime": 44167.960527, "UTMX": 240505.7, "UTMY": 4049064.8, "Topography": 67.81, "rx_altitude": 47.755, "rx_altitude_std": 0.065, "TxAltitude": 45.11, "tx_altitude_std": 0.065, "TxPitch": 0.0, "tilt_x_std": 99.0, "TxRoll": 0.0, "tilt_y_std": 99.0, "fieldpolarity": 3.0, "current": 62.6, "tx_area": 342.0, "numgates": 32.5, "xdist": 0.0, "x_orig": 240505.7, "y_orig": 4049064.8, "x_web": -13347113.2054088, "y_web": 4376815.034356597, "lon": -119.89915791292223, "lat": 36.55179111293999, "disable_reason": "none", "Current_Ch01": 8.8, "Current_Ch02": 113.7, "DipoleMoment_Ch01": 3009.6000000000004, "DipoleMoment_Ch02": 155541.6, "num_inuse_ch01": 21, "num_inuse_ch02": 30, "resdata": 8.378624187262508}, "geometry": {"type": "LineString", "coordinates": [[-13347113.2054088, 4376815.034356597], [-13347200.128859026, 4376902.31456012], [-13347260.861560877, 4377011.74327471], [-13347336.581096943, 4377255.717823377], [-13347520.398133783, 4377728.337066866], [-13347790.154430715, 4378465.14417067], [-13347885.227327427, 4378777.005453568], [-13347910.152278764, 4378972.845875871], [-13347934.15835732, 4379051.431088976], [-13347974.83354342, 4379126.012967908], [-13348030.05097581, 4379192.034315483], [-13348160.455785884, 4379301.611255731], [-13348220.223767959, 4379365.87046964], [-13348426.400431953, 4379781.423380539], [-13348488.255382463, 4379993.020071575], [-13348500.256338915, 4380077.473004438], [-13348508.44753027, 4380291.2083679065], [-13348542.373352274, 4380455.070329818], [-13348638.964028995, 4380733.455297829], [-13348734.402395478, 4380961.161054388], [-13348799.21581521, 4381159.071277917], [-13348969.335741105, 4381565.035627603], [-13348995.100458922, 4381651.953968982], [-13349014.99347781, 4381787.402312362], [-13349038.510787647, 4381874.016040562], [-13349235.742766695, 4382229.698537704], [-13349359.015846673, 4382422.595254144], [-13349415.669080956, 4382535.189455758], [-13349626.208675316, 4382750.287496344], [-13349733.570516896, 4382832.345504715], [-13349798.878226414, 4382893.697878105], [-13349853.388834778, 4382960.003514708], [-13349893.927957335, 4383037.3573965635], [-13349921.62038871, 4383166.959658768], [-13349910.499800771, 4383304.873045532], [-13349885.087855574, 4383389.994462153], [-13349797.91867347, 4383592.589861691], [-13349756.065257857, 4383718.202716412], [-13349741.658133272, 4383805.239881515], [-13349747.539019197, 4383892.532150877], [-13349759.662981667, 4383935.397899264], [-13349800.435809903, 4384016.250838931], [-13349881.393976197, 4384117.493639609], [-13350000.735714253, 4384245.304317499], [-13350049.597216278, 4384313.78936063], [-13350106.179521395, 4384476.7630276205]]}}]} \ No newline at end of file diff --git a/tests/data/inversion/smooth_synthetic.msgpack b/tests/data/inversion/smooth_synthetic.msgpack new file mode 100644 index 0000000..f5806c7 Binary files /dev/null and b/tests/data/inversion/smooth_synthetic.msgpack differ diff --git a/tests/data/inversion/smooth_synthetic.summary.yml b/tests/data/inversion/smooth_synthetic.summary.yml new file mode 100644 index 0000000..76143f6 --- /dev/null +++ b/tests/data/inversion/smooth_synthetic.summary.yml @@ -0,0 +1,560 @@ +100101.0: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: 11.969121198557469 + 50%: 12.419304151459885 + 75%: 12.858740592208077 + count: 193.0 + max: 20.999359421153233 + mean: 12.380160316821648 + min: 7.5363849440922115 + std: 1.365465620838824 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 +all: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_inuse_ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_inuse_ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + resdata: + 25%: 11.969121198557469 + 50%: 12.419304151459885 + 75%: 12.858740592208077 + count: 193.0 + max: 20.999359421153233 + mean: 12.380160316821648 + min: 7.5363849440922115 + std: 1.365465620838824 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 diff --git a/tests/data/processing/DONE b/tests/data/processing/DONE new file mode 100644 index 0000000..0962649 --- /dev/null +++ b/tests/data/processing/DONE @@ -0,0 +1 @@ +DONE \ No newline at end of file diff --git a/tests/data/processing/config.yml b/tests/data/processing/config.yml new file mode 100644 index 0000000..349f719 --- /dev/null +++ b/tests/data/processing/config.yml @@ -0,0 +1,7 @@ +data: + args: + data: file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/tests/data/import/out.xyz + sidecar: null + system_data: file:///home/redhog/Projects/Emerald/experimental-inversion-gui/dependencies/emerald-beryl-pipeline/tests/data/import/out.gex + name: emeraldprocessing.pipeline.ProcessingData +steps: [] diff --git a/tests/data/processing/log.yml b/tests/data/processing/log.yml new file mode 100644 index 0000000..99756aa --- /dev/null +++ b/tests/data/processing/log.yml @@ -0,0 +1,21 @@ +- msg: Read config + time: 2024-09-08 12:38:02,131 + +- msg: Download files + time: 2024-09-08 12:38:02,132 + +- msg: Read data + time: 2024-09-08 12:38:02,132 + +- msg: Processing + time: 2024-09-08 12:38:02,408 + +- msg: Write data + time: 2024-09-08 12:38:02,411 + +- msg: Done + time: 2024-09-08 12:38:02,883 + +- msg: DONE + time: 2024-09-08 12:38:02,883 + diff --git a/tests/data/processing/processed.100101_0.diff.msgpack b/tests/data/processing/processed.100101_0.diff.msgpack new file mode 100644 index 0000000..403f3eb Binary files /dev/null and b/tests/data/processing/processed.100101_0.diff.msgpack differ diff --git a/tests/data/processing/processed.100101_0.geojson b/tests/data/processing/processed.100101_0.geojson new file mode 100644 index 0000000..4f54927 --- /dev/null +++ b/tests/data/processing/processed.100101_0.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "properties": {"Line": 100101.0, "apply_idx": 0, "DateTime": 44167.960527, "UTMX": 240505.7, "UTMY": 4049064.8, "Topography": 67.81, "rx_altitude": 47.755, "rx_altitude_std": 0.065, "TxAltitude": 45.11, "tx_altitude_std": 0.065, "TxPitch": 0.0, "tilt_x_std": 99.0, "TxRoll": 0.0, "tilt_y_std": 99.0, "fieldpolarity": 3.0, "current": 62.6, "tx_area": 342.0, "numgates": 32.5, "xdist": 0.0, "x_orig": 240505.7, "y_orig": 4049064.8, "x_web": -13347113.2054088, "y_web": 4376815.034356597, "lon": -119.89915791292223, "lat": 36.55179111293999, "Current_Ch01": 8.8, "Current_Ch02": 113.7, "disable_reason": "none", "DipoleMoment_Ch01": 3009.6000000000004, "DipoleMoment_Ch02": 155541.6, "num_InUse_Ch01": 21, "num_InUse_Ch02": 30}, "geometry": {"type": "LineString", "coordinates": [[-13347113.2054088, 4376815.034356597], [-13347200.128859026, 4376902.31456012], [-13347260.861560877, 4377011.74327471], [-13347336.581096943, 4377255.717823377], [-13347520.398133783, 4377728.337066866], [-13347790.154430715, 4378465.14417067], [-13347885.227327427, 4378777.005453568], [-13347910.152278764, 4378972.845875871], [-13347934.15835732, 4379051.431088976], [-13347974.83354342, 4379126.012967908], [-13348030.05097581, 4379192.034315483], [-13348160.455785884, 4379301.611255731], [-13348220.223767959, 4379365.87046964], [-13348426.400431953, 4379781.423380539], [-13348488.255382463, 4379993.020071575], [-13348500.256338915, 4380077.473004438], [-13348508.44753027, 4380291.2083679065], [-13348542.373352274, 4380455.070329818], [-13348638.964028995, 4380733.455297829], [-13348734.402395478, 4380961.161054388], [-13348799.21581521, 4381159.071277917], [-13348969.335741105, 4381565.035627603], [-13348995.100458922, 4381651.953968982], [-13349014.99347781, 4381787.402312362], [-13349038.510787647, 4381874.016040562], [-13349235.742766695, 4382229.698537704], [-13349359.015846673, 4382422.595254144], [-13349415.669080956, 4382535.189455758], [-13349626.208675316, 4382750.287496344], [-13349733.570516896, 4382832.345504715], [-13349798.878226414, 4382893.697878105], [-13349853.388834778, 4382960.003514708], [-13349893.927957335, 4383037.3573965635], [-13349921.62038871, 4383166.959658768], [-13349910.499800771, 4383304.873045532], [-13349885.087855574, 4383389.994462153], [-13349797.91867347, 4383592.589861691], [-13349756.065257857, 4383718.202716412], [-13349741.658133272, 4383805.239881515], [-13349747.539019197, 4383892.532150877], [-13349759.662981667, 4383935.397899264], [-13349800.435809903, 4384016.250838931], [-13349881.393976197, 4384117.493639609], [-13350000.735714253, 4384245.304317499], [-13350049.597216278, 4384313.78936063], [-13350106.179521395, 4384476.7630276205]]}}]} \ No newline at end of file diff --git a/tests/data/processing/processed.100101_0.gex b/tests/data/processing/processed.100101_0.gex new file mode 100644 index 0000000..7e040cb --- /dev/null +++ b/tests/data/processing/processed.100101_0.gex @@ -0,0 +1,203 @@ +/2024-09-08 gex file modified by the EmeraldProcessing toolbox + +[General] + + +Description=Test geometry file + + +GPSDifferentialPosition1= 11.91 2.79 -0.16 + + +GPSPosition1= 11.91 2.79 -0.16 +GPSPosition2= 10.41 3.95 -0.16 + + +AltimeterPosition1= 12.94 1.79 -0.12 +AltimeterPosition2= 12.94 -1.79 -0.12 + + +InclinometerPosition1= 12.91 1.64 -0.12 +InclinometerPosition2= 12.91 1.64 -0.12 + + +RxCoilPosition1= -13.25 0.00 -2.00 + + +LoopType=73 + + +FrontGateDelay=2.5e-06 + + +TxLoopArea=342.0 + + +TxLoopPoint1= -12.55 -2.1 +TxLoopPoint2= -6.03 -8.63 +TxLoopPoint3= 6.03 -8.63 +TxLoopPoint4= 11.34 -3.31 +TxLoopPoint5= 11.34 3.31 +TxLoopPoint6= 6.03 8.63 +TxLoopPoint7= -6.03 8.63 +TxLoopPoint8= -12.55 2.1 + + +NumberOfTurnsLM=1 + + +NumberOfTurnsHM=4 + + +WaveformLMPoint01= -3.181000e-03 -0.000000e+00 +WaveformLMPoint02= -3.147900e-03 -6.852800e-02 +WaveformLMPoint03= -3.147800e-03 -6.870900e-02 +WaveformLMPoint04= -3.097700e-03 -1.473100e-01 +WaveformLMPoint05= -2.973800e-03 -3.168900e-01 +WaveformLMPoint06= -2.575200e-03 -7.687100e-01 +WaveformLMPoint07= -2.381000e-03 -1.000000e+00 +WaveformLMPoint08= -2.380600e-03 -9.126700e-01 +WaveformLMPoint09= -2.378600e-03 -8.229300e-02 +WaveformLMPoint10= -2.377800e-03 1.322200e-02 +WaveformLMPoint11= -2.376100e-03 -0.000000e+00 +WaveformLMPoint12= -8.000000e-04 0.000000e+00 +WaveformLMPoint13= -7.668500e-04 6.862700e-02 +WaveformLMPoint14= -7.166900e-04 1.473300e-01 +WaveformLMPoint15= -5.928400e-04 3.168500e-01 +WaveformLMPoint16= -1.942000e-04 7.687000e-01 +WaveformLMPoint17= 0.000000e+00 1.000000e+00 +WaveformLMPoint18= 2.036000e-07 9.752000e-01 +WaveformLMPoint19= 3.396000e-07 9.403100e-01 +WaveformLMPoint20= 7.556000e-07 7.499600e-01 +WaveformLMPoint21= 1.139600e-06 5.944600e-01 +WaveformLMPoint22= 1.299600e-06 5.080100e-01 +WaveformLMPoint23= 1.443600e-06 4.518300e-01 +WaveformLMPoint24= 1.827600e-06 2.753200e-01 +WaveformLMPoint25= 2.203600e-06 1.394300e-01 +WaveformLMPoint26= 2.403600e-06 8.124600e-02 +WaveformLMPoint27= 2.707600e-06 2.287000e-02 +WaveformLMPoint28= 3.179600e-06 -1.298600e-02 +WaveformLMPoint29= 3.875600e-06 -2.103900e-02 +WaveformLMPoint30= 4.907600e-06 0.000000e+00 + + +WaveformHMPoint01= -2.066700e-02 -0.000000e+00 +WaveformHMPoint02= -2.065700e-02 -4.059900e-02 +WaveformHMPoint03= -2.065500e-02 -7.113600e-02 +WaveformHMPoint04= -2.062900e-02 -6.721500e-01 +WaveformHMPoint05= -2.062300e-02 -7.958500e-01 +WaveformHMPoint06= -2.061900e-02 -8.578600e-01 +WaveformHMPoint07= -2.061300e-02 -8.940300e-01 +WaveformHMPoint08= -2.059200e-02 -9.153000e-01 +WaveformHMPoint09= -1.891600e-02 -9.657500e-01 +WaveformHMPoint10= -1.666700e-02 -1.000000e+00 +WaveformHMPoint11= -1.662600e-02 -9.802800e-03 +WaveformHMPoint12= -1.662300e-02 -0.000000e+00 +WaveformHMPoint13= -4.000000e-03 0.000000e+00 +WaveformHMPoint14= -3.990000e-03 4.064600e-02 +WaveformHMPoint15= -3.987600e-03 7.756600e-02 +WaveformHMPoint16= -3.984600e-03 1.404400e-01 +WaveformHMPoint17= -3.971800e-03 4.471800e-01 +WaveformHMPoint18= -3.962000e-03 6.712300e-01 +WaveformHMPoint19= -3.956200e-03 7.932300e-01 +WaveformHMPoint20= -3.952200e-03 8.555900e-01 +WaveformHMPoint21= -3.949500e-03 8.810400e-01 +WaveformHMPoint22= -3.946300e-03 8.934700e-01 +WaveformHMPoint23= -3.936700e-03 9.109100e-01 +WaveformHMPoint24= -3.924900e-03 9.153500e-01 +WaveformHMPoint25= -3.282900e-03 9.407300e-01 +WaveformHMPoint26= -2.248300e-03 9.657600e-01 +WaveformHMPoint27= 0.000000e+00 1.000000e+00 +WaveformHMPoint28= 5.616000e-07 9.973600e-01 +WaveformHMPoint29= 3.601600e-06 9.201300e-01 +WaveformHMPoint30= 4.077000e-05 1.447500e-02 +WaveformHMPoint31= 4.149000e-05 -1.260700e-04 +WaveformHMPoint32= 4.195400e-05 -5.328900e-03 +WaveformHMPoint33= 4.361800e-05 0.000000e+00 + + +RxCoilLPFilter1= 0.990000 210000.000000 + + +GateNoForPowerLineMonitor=28 + + +FreqForPowerLineMonitor=60.0 + + +CalculateRawDataSTD=0.0 + + +GateTime01= 7.150000e-07 4.300000e-07 1.000000e-06 +GateTime02= 2.215000e-06 1.430000e-06 3.000000e-06 +GateTime03= 4.215000e-06 3.430000e-06 5.000000e-06 +GateTime04= 6.215000e-06 5.430000e-06 7.000000e-06 +GateTime05= 8.215000e-06 7.430000e-06 9.000000e-06 +GateTime06= 1.022000e-05 9.430000e-06 1.100000e-05 +GateTime07= 1.221000e-05 1.143000e-05 1.300000e-05 +GateTime08= 1.472000e-05 1.343000e-05 1.600000e-05 +GateTime09= 1.821000e-05 1.643000e-05 2.000000e-05 +GateTime10= 2.271000e-05 2.043000e-05 2.500000e-05 +GateTime11= 2.821000e-05 2.543000e-05 3.100000e-05 +GateTime12= 3.522000e-05 3.143000e-05 3.900000e-05 +GateTime13= 4.421000e-05 3.943000e-05 4.900000e-05 +GateTime14= 5.571000e-05 4.943000e-05 6.200000e-05 +GateTime15= 7.021000e-05 6.243000e-05 7.800000e-05 +GateTime16= 8.821000e-05 7.843000e-05 9.800000e-05 +GateTime17= 1.107000e-04 9.843000e-05 1.230000e-04 +GateTime18= 1.387000e-04 1.234000e-04 1.540000e-04 +GateTime19= 1.742000e-04 1.544000e-04 1.940000e-04 +GateTime20= 2.197000e-04 1.944000e-04 2.450000e-04 +GateTime21= 2.767000e-04 2.454000e-04 3.080000e-04 +GateTime22= 3.487000e-04 3.084000e-04 3.890000e-04 +GateTime23= 4.397000e-04 3.894000e-04 4.900000e-04 +GateTime24= 5.537000e-04 4.904000e-04 6.170000e-04 +GateTime25= 6.977000e-04 6.174000e-04 7.780000e-04 +GateTime26= 8.792000e-04 7.784000e-04 9.800000e-04 +GateTime27= 1.108000e-03 9.804000e-04 1.235000e-03 +GateTime28= 1.396000e-03 1.235000e-03 1.557000e-03 +GateTime29= 1.760000e-03 1.557000e-03 1.963000e-03 +GateTime30= 2.219000e-03 1.963000e-03 2.474000e-03 +GateTime31= 2.797000e-03 2.474000e-03 3.120000e-03 +GateTime32= 3.516000e-03 3.120000e-03 3.912000e-03 +GateTime33= 4.396000e-03 3.912000e-03 4.880000e-03 +GateTime34= 5.473000e-03 4.880000e-03 6.065000e-03 +GateTime35= 6.791000e-03 6.065000e-03 7.517000e-03 +GateTime36= 8.405000e-03 7.517000e-03 9.293000e-03 +GateTime37= 1.038000e-02 9.293000e-03 1.147000e-02 + +[Channel1] +RxCoilNumber=1 +GateTimeShift=-1.99e-06 +GateFactor=0.94 +SystemResponseConvolution=0 +RemoveInitialGates=7 +PrimaryFieldDampingFactor=1e-06 +UniformDataSTD=0.03 +MeaTimeDelay=0.0 +NoGates=28 +RepFreq=210.0 +FrontGateTime=-7.7e-07 +TiBLowPassFilter= 1.00 300000.00 +TransmitterMoment=LM +TxApproximateCurrent=8.8 +ReceiverPolarizationXYZ=Z +ApproxDipoleMoment=3009.6000000000004 + +[Channel2] +RxCoilNumber=1 +GateTimeShift=-1.8e-06 +GateFactor=0.99 +SystemResponseConvolution=0 +RemoveInitialGates=7 +PrimaryFieldDampingFactor=0.01 +UniformDataSTD=0.03 +MeaTimeDelay=6e-05 +NoGates=37 +RepFreq=30.0 +FrontGateTime=7e-05 +TiBLowPassFilter= 1.00 300000.00 +TransmitterMoment=HM +TxApproximateCurrent=113.7 +ReceiverPolarizationXYZ=Z +ApproxDipoleMoment=155541.6 diff --git a/tests/data/processing/processed.100101_0.msgpack b/tests/data/processing/processed.100101_0.msgpack new file mode 100644 index 0000000..10a1539 Binary files /dev/null and b/tests/data/processing/processed.100101_0.msgpack differ diff --git a/tests/data/processing/processed.100101_0.summary.yml b/tests/data/processing/processed.100101_0.summary.yml new file mode 100644 index 0000000..60ddbe5 --- /dev/null +++ b/tests/data/processing/processed.100101_0.summary.yml @@ -0,0 +1,560 @@ +100101.0: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 48.0 + 50%: 96.0 + 75%: 144.0 + count: 193.0 + max: 192.0 + mean: 96.0 + min: 0.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_InUse_Ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_InUse_Ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 +all: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 48.0 + 50%: 96.0 + 75%: 144.0 + count: 193.0 + max: 192.0 + mean: 96.0 + min: 0.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_InUse_Ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_InUse_Ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 diff --git a/tests/data/processing/processed.diff.msgpack b/tests/data/processing/processed.diff.msgpack new file mode 100644 index 0000000..403f3eb Binary files /dev/null and b/tests/data/processing/processed.diff.msgpack differ diff --git a/tests/data/processing/processed.geojson b/tests/data/processing/processed.geojson new file mode 100644 index 0000000..46a1dd3 --- /dev/null +++ b/tests/data/processing/processed.geojson @@ -0,0 +1 @@ +{"type": "FeatureCollection", "features": [{"id": "0", "type": "Feature", "properties": {"Line": 100101.0, "apply_idx": 18907, "DateTime": 44167.960527, "UTMX": 240505.7, "UTMY": 4049064.8, "Topography": 67.81, "rx_altitude": 47.755, "rx_altitude_std": 0.065, "TxAltitude": 45.11, "tx_altitude_std": 0.065, "TxPitch": 0.0, "tilt_x_std": 99.0, "TxRoll": 0.0, "tilt_y_std": 99.0, "fieldpolarity": 3.0, "current": 62.6, "tx_area": 342.0, "numgates": 32.5, "xdist": 0.0, "x_orig": 240505.7, "y_orig": 4049064.8, "x_web": -13347113.2054088, "y_web": 4376815.034356597, "lon": -119.89915791292223, "lat": 36.55179111293999, "Current_Ch01": 8.8, "Current_Ch02": 113.7, "disable_reason": "none", "DipoleMoment_Ch01": 3009.6000000000004, "DipoleMoment_Ch02": 155541.6, "num_InUse_Ch01": 21, "num_InUse_Ch02": 30}, "geometry": {"type": "LineString", "coordinates": [[-13347113.2054088, 4376815.034356597], [-13347200.128859026, 4376902.31456012], [-13347260.861560877, 4377011.74327471], [-13347336.581096943, 4377255.717823377], [-13347520.398133783, 4377728.337066866], [-13347790.154430715, 4378465.14417067], [-13347885.227327427, 4378777.005453568], [-13347910.152278764, 4378972.845875871], [-13347934.15835732, 4379051.431088976], [-13347974.83354342, 4379126.012967908], [-13348030.05097581, 4379192.034315483], [-13348160.455785884, 4379301.611255731], [-13348220.223767959, 4379365.87046964], [-13348426.400431953, 4379781.423380539], [-13348488.255382463, 4379993.020071575], [-13348500.256338915, 4380077.473004438], [-13348508.44753027, 4380291.2083679065], [-13348542.373352274, 4380455.070329818], [-13348638.964028995, 4380733.455297829], [-13348734.402395478, 4380961.161054388], [-13348799.21581521, 4381159.071277917], [-13348969.335741105, 4381565.035627603], [-13348995.100458922, 4381651.953968982], [-13349014.99347781, 4381787.402312362], [-13349038.510787647, 4381874.016040562], [-13349235.742766695, 4382229.698537704], [-13349359.015846673, 4382422.595254144], [-13349415.669080956, 4382535.189455758], [-13349626.208675316, 4382750.287496344], [-13349733.570516896, 4382832.345504715], [-13349798.878226414, 4382893.697878105], [-13349853.388834778, 4382960.003514708], [-13349893.927957335, 4383037.3573965635], [-13349921.62038871, 4383166.959658768], [-13349910.499800771, 4383304.873045532], [-13349885.087855574, 4383389.994462153], [-13349797.91867347, 4383592.589861691], [-13349756.065257857, 4383718.202716412], [-13349741.658133272, 4383805.239881515], [-13349747.539019197, 4383892.532150877], [-13349759.662981667, 4383935.397899264], [-13349800.435809903, 4384016.250838931], [-13349881.393976197, 4384117.493639609], [-13350000.735714253, 4384245.304317499], [-13350049.597216278, 4384313.78936063], [-13350106.179521395, 4384476.7630276205]]}}]} \ No newline at end of file diff --git a/tests/data/processing/processed.gex b/tests/data/processing/processed.gex new file mode 100644 index 0000000..7e040cb --- /dev/null +++ b/tests/data/processing/processed.gex @@ -0,0 +1,203 @@ +/2024-09-08 gex file modified by the EmeraldProcessing toolbox + +[General] + + +Description=Test geometry file + + +GPSDifferentialPosition1= 11.91 2.79 -0.16 + + +GPSPosition1= 11.91 2.79 -0.16 +GPSPosition2= 10.41 3.95 -0.16 + + +AltimeterPosition1= 12.94 1.79 -0.12 +AltimeterPosition2= 12.94 -1.79 -0.12 + + +InclinometerPosition1= 12.91 1.64 -0.12 +InclinometerPosition2= 12.91 1.64 -0.12 + + +RxCoilPosition1= -13.25 0.00 -2.00 + + +LoopType=73 + + +FrontGateDelay=2.5e-06 + + +TxLoopArea=342.0 + + +TxLoopPoint1= -12.55 -2.1 +TxLoopPoint2= -6.03 -8.63 +TxLoopPoint3= 6.03 -8.63 +TxLoopPoint4= 11.34 -3.31 +TxLoopPoint5= 11.34 3.31 +TxLoopPoint6= 6.03 8.63 +TxLoopPoint7= -6.03 8.63 +TxLoopPoint8= -12.55 2.1 + + +NumberOfTurnsLM=1 + + +NumberOfTurnsHM=4 + + +WaveformLMPoint01= -3.181000e-03 -0.000000e+00 +WaveformLMPoint02= -3.147900e-03 -6.852800e-02 +WaveformLMPoint03= -3.147800e-03 -6.870900e-02 +WaveformLMPoint04= -3.097700e-03 -1.473100e-01 +WaveformLMPoint05= -2.973800e-03 -3.168900e-01 +WaveformLMPoint06= -2.575200e-03 -7.687100e-01 +WaveformLMPoint07= -2.381000e-03 -1.000000e+00 +WaveformLMPoint08= -2.380600e-03 -9.126700e-01 +WaveformLMPoint09= -2.378600e-03 -8.229300e-02 +WaveformLMPoint10= -2.377800e-03 1.322200e-02 +WaveformLMPoint11= -2.376100e-03 -0.000000e+00 +WaveformLMPoint12= -8.000000e-04 0.000000e+00 +WaveformLMPoint13= -7.668500e-04 6.862700e-02 +WaveformLMPoint14= -7.166900e-04 1.473300e-01 +WaveformLMPoint15= -5.928400e-04 3.168500e-01 +WaveformLMPoint16= -1.942000e-04 7.687000e-01 +WaveformLMPoint17= 0.000000e+00 1.000000e+00 +WaveformLMPoint18= 2.036000e-07 9.752000e-01 +WaveformLMPoint19= 3.396000e-07 9.403100e-01 +WaveformLMPoint20= 7.556000e-07 7.499600e-01 +WaveformLMPoint21= 1.139600e-06 5.944600e-01 +WaveformLMPoint22= 1.299600e-06 5.080100e-01 +WaveformLMPoint23= 1.443600e-06 4.518300e-01 +WaveformLMPoint24= 1.827600e-06 2.753200e-01 +WaveformLMPoint25= 2.203600e-06 1.394300e-01 +WaveformLMPoint26= 2.403600e-06 8.124600e-02 +WaveformLMPoint27= 2.707600e-06 2.287000e-02 +WaveformLMPoint28= 3.179600e-06 -1.298600e-02 +WaveformLMPoint29= 3.875600e-06 -2.103900e-02 +WaveformLMPoint30= 4.907600e-06 0.000000e+00 + + +WaveformHMPoint01= -2.066700e-02 -0.000000e+00 +WaveformHMPoint02= -2.065700e-02 -4.059900e-02 +WaveformHMPoint03= -2.065500e-02 -7.113600e-02 +WaveformHMPoint04= -2.062900e-02 -6.721500e-01 +WaveformHMPoint05= -2.062300e-02 -7.958500e-01 +WaveformHMPoint06= -2.061900e-02 -8.578600e-01 +WaveformHMPoint07= -2.061300e-02 -8.940300e-01 +WaveformHMPoint08= -2.059200e-02 -9.153000e-01 +WaveformHMPoint09= -1.891600e-02 -9.657500e-01 +WaveformHMPoint10= -1.666700e-02 -1.000000e+00 +WaveformHMPoint11= -1.662600e-02 -9.802800e-03 +WaveformHMPoint12= -1.662300e-02 -0.000000e+00 +WaveformHMPoint13= -4.000000e-03 0.000000e+00 +WaveformHMPoint14= -3.990000e-03 4.064600e-02 +WaveformHMPoint15= -3.987600e-03 7.756600e-02 +WaveformHMPoint16= -3.984600e-03 1.404400e-01 +WaveformHMPoint17= -3.971800e-03 4.471800e-01 +WaveformHMPoint18= -3.962000e-03 6.712300e-01 +WaveformHMPoint19= -3.956200e-03 7.932300e-01 +WaveformHMPoint20= -3.952200e-03 8.555900e-01 +WaveformHMPoint21= -3.949500e-03 8.810400e-01 +WaveformHMPoint22= -3.946300e-03 8.934700e-01 +WaveformHMPoint23= -3.936700e-03 9.109100e-01 +WaveformHMPoint24= -3.924900e-03 9.153500e-01 +WaveformHMPoint25= -3.282900e-03 9.407300e-01 +WaveformHMPoint26= -2.248300e-03 9.657600e-01 +WaveformHMPoint27= 0.000000e+00 1.000000e+00 +WaveformHMPoint28= 5.616000e-07 9.973600e-01 +WaveformHMPoint29= 3.601600e-06 9.201300e-01 +WaveformHMPoint30= 4.077000e-05 1.447500e-02 +WaveformHMPoint31= 4.149000e-05 -1.260700e-04 +WaveformHMPoint32= 4.195400e-05 -5.328900e-03 +WaveformHMPoint33= 4.361800e-05 0.000000e+00 + + +RxCoilLPFilter1= 0.990000 210000.000000 + + +GateNoForPowerLineMonitor=28 + + +FreqForPowerLineMonitor=60.0 + + +CalculateRawDataSTD=0.0 + + +GateTime01= 7.150000e-07 4.300000e-07 1.000000e-06 +GateTime02= 2.215000e-06 1.430000e-06 3.000000e-06 +GateTime03= 4.215000e-06 3.430000e-06 5.000000e-06 +GateTime04= 6.215000e-06 5.430000e-06 7.000000e-06 +GateTime05= 8.215000e-06 7.430000e-06 9.000000e-06 +GateTime06= 1.022000e-05 9.430000e-06 1.100000e-05 +GateTime07= 1.221000e-05 1.143000e-05 1.300000e-05 +GateTime08= 1.472000e-05 1.343000e-05 1.600000e-05 +GateTime09= 1.821000e-05 1.643000e-05 2.000000e-05 +GateTime10= 2.271000e-05 2.043000e-05 2.500000e-05 +GateTime11= 2.821000e-05 2.543000e-05 3.100000e-05 +GateTime12= 3.522000e-05 3.143000e-05 3.900000e-05 +GateTime13= 4.421000e-05 3.943000e-05 4.900000e-05 +GateTime14= 5.571000e-05 4.943000e-05 6.200000e-05 +GateTime15= 7.021000e-05 6.243000e-05 7.800000e-05 +GateTime16= 8.821000e-05 7.843000e-05 9.800000e-05 +GateTime17= 1.107000e-04 9.843000e-05 1.230000e-04 +GateTime18= 1.387000e-04 1.234000e-04 1.540000e-04 +GateTime19= 1.742000e-04 1.544000e-04 1.940000e-04 +GateTime20= 2.197000e-04 1.944000e-04 2.450000e-04 +GateTime21= 2.767000e-04 2.454000e-04 3.080000e-04 +GateTime22= 3.487000e-04 3.084000e-04 3.890000e-04 +GateTime23= 4.397000e-04 3.894000e-04 4.900000e-04 +GateTime24= 5.537000e-04 4.904000e-04 6.170000e-04 +GateTime25= 6.977000e-04 6.174000e-04 7.780000e-04 +GateTime26= 8.792000e-04 7.784000e-04 9.800000e-04 +GateTime27= 1.108000e-03 9.804000e-04 1.235000e-03 +GateTime28= 1.396000e-03 1.235000e-03 1.557000e-03 +GateTime29= 1.760000e-03 1.557000e-03 1.963000e-03 +GateTime30= 2.219000e-03 1.963000e-03 2.474000e-03 +GateTime31= 2.797000e-03 2.474000e-03 3.120000e-03 +GateTime32= 3.516000e-03 3.120000e-03 3.912000e-03 +GateTime33= 4.396000e-03 3.912000e-03 4.880000e-03 +GateTime34= 5.473000e-03 4.880000e-03 6.065000e-03 +GateTime35= 6.791000e-03 6.065000e-03 7.517000e-03 +GateTime36= 8.405000e-03 7.517000e-03 9.293000e-03 +GateTime37= 1.038000e-02 9.293000e-03 1.147000e-02 + +[Channel1] +RxCoilNumber=1 +GateTimeShift=-1.99e-06 +GateFactor=0.94 +SystemResponseConvolution=0 +RemoveInitialGates=7 +PrimaryFieldDampingFactor=1e-06 +UniformDataSTD=0.03 +MeaTimeDelay=0.0 +NoGates=28 +RepFreq=210.0 +FrontGateTime=-7.7e-07 +TiBLowPassFilter= 1.00 300000.00 +TransmitterMoment=LM +TxApproximateCurrent=8.8 +ReceiverPolarizationXYZ=Z +ApproxDipoleMoment=3009.6000000000004 + +[Channel2] +RxCoilNumber=1 +GateTimeShift=-1.8e-06 +GateFactor=0.99 +SystemResponseConvolution=0 +RemoveInitialGates=7 +PrimaryFieldDampingFactor=0.01 +UniformDataSTD=0.03 +MeaTimeDelay=6e-05 +NoGates=37 +RepFreq=30.0 +FrontGateTime=7e-05 +TiBLowPassFilter= 1.00 300000.00 +TransmitterMoment=HM +TxApproximateCurrent=113.7 +ReceiverPolarizationXYZ=Z +ApproxDipoleMoment=155541.6 diff --git a/tests/data/processing/processed.msgpack b/tests/data/processing/processed.msgpack new file mode 100644 index 0000000..6af39e2 Binary files /dev/null and b/tests/data/processing/processed.msgpack differ diff --git a/tests/data/processing/processed.summary.yml b/tests/data/processing/processed.summary.yml new file mode 100644 index 0000000..7f48cc7 --- /dev/null +++ b/tests/data/processing/processed.summary.yml @@ -0,0 +1,560 @@ +100101.0: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 18955.0 + 50%: 19003.0 + 75%: 19051.0 + count: 193.0 + max: 19099.0 + mean: 19003.0 + min: 18907.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_InUse_Ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_InUse_Ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 +all: + Current_Ch01: + 25%: 8.8 + 50%: 8.8 + 75%: 8.8 + count: 193.0 + max: 8.8 + mean: 8.799999999999999 + min: 8.8 + std: 1.7809767609590393e-15 + Current_Ch02: + 25%: 113.7 + 50%: 113.7 + 75%: 113.7 + count: 193.0 + max: 113.7 + mean: 113.70000000000003 + min: 113.7 + std: 2.849562817534463e-14 + DateTime: + 25%: 44167.96136 + 50%: 44167.962193 + 75%: 44167.963027 + count: 193.0 + max: 44167.963964 + mean: 44167.962218119166 + min: 44167.960527 + std: 0.0010030505819809692 + DipoleMoment_Ch01: + 25%: 3009.6000000000004 + 50%: 3009.6000000000004 + 75%: 3009.6000000000004 + count: 193.0 + max: 3009.6000000000004 + mean: 3009.5999999999995 + min: 3009.6000000000004 + std: 9.118601016110281e-13 + DipoleMoment_Ch02: + 25%: 155541.6 + 50%: 155541.6 + 75%: 155541.6 + count: 193.0 + max: 155541.6 + mean: 155541.60000000003 + min: 155541.6 + std: 2.91795232515529e-11 + Line: + 25%: 100101.0 + 50%: 100101.0 + 75%: 100101.0 + count: 193.0 + max: 100101.0 + mean: 100101.0 + min: 100101.0 + std: 0.0 + Topography: + 25%: 68.15 + 50%: 68.77 + 75%: 69.36 + count: 193.0 + max: 72.06 + mean: 68.57813471502591 + min: 64.52 + std: 1.3646556504324965 + TxAltitude: + 25%: 34.965 + 50%: 38.59 + 75%: 43.82 + count: 193.0 + max: 97.855 + mean: 41.94391191709845 + min: 27.55 + std: 12.568332968280876 + TxPitch: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + TxRoll: + 25%: 0.0 + 50%: 0.0 + 75%: 0.0 + count: 193.0 + max: 0.0 + mean: 0.0 + min: 0.0 + std: 0.0 + UTMX: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + UTMY: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + apply_idx: + 25%: 18955.0 + 50%: 19003.0 + 75%: 19051.0 + count: 193.0 + max: 19099.0 + mean: 19003.0 + min: 18907.0 + std: 55.85845206113992 + current: + 25%: 62.55 + 50%: 62.55 + 75%: 62.55 + count: 193.0 + max: 62.6 + mean: 62.55932642487045 + min: 62.55 + std: 0.019527282628144738 + fieldpolarity: + 25%: 3.0 + 50%: 3.0 + 75%: 3.0 + count: 193.0 + max: 3.0 + mean: 3.0 + min: 3.0 + std: 0.0 + lat: + 25%: 36.5653985933453 + 50%: 36.57864793881271 + 75%: 36.592527042713215 + count: 193.0 + max: 36.60706094089141 + mean: 36.5790258322267 + min: 36.55179111293999 + std: 0.01620101403221542 + lon: + 25%: -119.91950722322856 + 50%: -119.91222983323851 + 75%: -119.9058982285617 + count: 193.0 + max: -119.89915791292223 + mean: -119.91283806918024 + min: -119.92604425682542 + std: 0.007961536506246448 + num_InUse_Ch01: + 25%: 21.0 + 50%: 21.0 + 75%: 21.0 + count: 193.0 + max: 21.0 + mean: 21.0 + min: 21.0 + std: 0.0 + num_InUse_Ch02: + 25%: 30.0 + 50%: 30.0 + 75%: 30.0 + count: 193.0 + max: 30.0 + mean: 30.0 + min: 30.0 + std: 0.0 + numgates: + 25%: 32.5 + 50%: 32.5 + 75%: 32.5 + count: 193.0 + max: 32.5 + mean: 32.49740932642487 + min: 32.0 + std: 0.035990787537434725 + rx_altitude: + 25%: 37.435 + 50%: 41.035 + 75%: 46.165 + count: 193.0 + max: 101.58 + mean: 44.440621761658036 + min: 29.75 + std: 12.702146610618575 + rx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07466062176165802 + min: 0.0365 + std: 0.013697821588780664 + tilt_x_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tilt_y_std: + 25%: 99.0 + 50%: 99.0 + 75%: 99.0 + count: 193.0 + max: 99.0 + mean: 99.0 + min: 99.0 + std: 0.0 + tx_altitude_std: + 25%: 0.067 + 50%: 0.0755 + 75%: 0.083 + count: 193.0 + max: 0.105 + mean: 0.07467098445595854 + min: 0.0365 + std: 0.013685046871675868 + tx_area: + 25%: 342.0 + 50%: 342.0 + 75%: 342.0 + count: 193.0 + max: 342.0 + mean: 342.0 + min: 342.0 + std: 0.0 + x_orig: + 25%: 238821.2 + 50%: 239425.7 + 75%: 239947.9 + count: 193.0 + max: 240505.7 + mean: 239372.69274611396 + min: 238285.4 + std: 658.3832724064364 + x_web: + 25%: -13349378.480270095 + 50%: -13348568.364922099 + 75%: -13347863.533913571 + count: 193.0 + max: -13347113.2054088 + mean: -13348636.073437413 + min: -13350106.179521395 + std: 886.2741898073857 + xdist: + 25%: 1637.8383060753656 + 50%: 3262.4751809246022 + 75%: 4946.130377226554 + count: 193.0 + max: 6844.576430631833 + mean: 3334.2207008648616 + min: 0.0 + std: 1996.7831167283996 + y_orig: + 25%: 4050593.0 + 50%: 4052080.4 + 75%: 4053640.3 + count: 193.0 + max: 4055270.9 + mean: 4052124.0191709846 + min: 4049064.8 + std: 1819.2583364048303 + y_web: + 25%: 4378700.849883008 + 50%: 4380537.351904023 + 75%: 4382461.483236966 + count: 193.0 + max: 4384476.7630276205 + mean: 4380589.971036045 + min: 4376815.034356597 + std: 2245.8514821985545 diff --git a/tests/test_pipeline.py b/tests/test_pipeline.py new file mode 100644 index 0000000..66ec14f --- /dev/null +++ b/tests/test_pipeline.py @@ -0,0 +1,151 @@ +import unittest +import tempfile +import os +import yaml +import luigi +import poltergust_luigi_utils.caching + +import beryl_pipeline.introspect +import beryl_pipeline.file_import +import beryl_pipeline.processing +import beryl_pipeline.inversion +import beryl_pipeline.integration + +datadir = "file://" + os.path.join(os.path.dirname(__file__), "data") + +update_results = False + +class Base(unittest.TestCase): + def setUp(self): + self.cachedir = tempfile.TemporaryDirectory() + poltergust_luigi_utils.caching.cachedir = self.cachedir.__enter__() + self.tmpdir = tempfile.TemporaryDirectory() + root = self.tmpdir.__enter__() + if update_results: + self.root = datadir + else: + self.root = root + + def tearDown(self): + self.cachedir.__exit__(None, None, None) + self.tmpdir.__exit__(None, None, None) + +class Pipeline(Base): + def test_import(self): + with poltergust_luigi_utils.caching.CachingOpenerTarget(self.root + "/import/config.yml").open("w") as f: + yaml.dump({ + "importer": { + "name": "SkyTEM XYZ", + "args": { + "files": { + "xyzfile": datadir + "/aem_processed_data_foothill_central_valley.100101.0.xyz", + "gexfile": datadir + "/20201231_20023_IVF_SkyTEM304_SKB.gex" + }, + "projection": 32611 # Not 100% sure this is correct; the dataset does not specify... + } + } + }, f) + + import_task = beryl_pipeline.file_import.Import(import_name = self.root + "/import") + luigi.build([import_task], local_scheduler=True) + + assert import_task.logfile().exists(), "Logfile not written" + assert import_task.data().exists(), "Data not written" + assert import_task.system_data().exists(), "System data not written" + assert import_task.data_msgpack().exists(), "Msgpack binary not written" + assert import_task.output().exists(), "Done marker file not written" + + def test_processing(self): + with poltergust_luigi_utils.caching.CachingOpenerTarget(self.root + "/processing/config.yml").open("w") as f: + yaml.dump({ + "steps": [], + "data": { + "name": "emeraldprocessing.pipeline.ProcessingData", + "args": { + "data": datadir + "/import/out.xyz", + "sidecar": None, + "system_data": datadir + "/import/out.gex", + } + } + }, f) + + processing_task = beryl_pipeline.processing.Processing(processing_name = self.root + "/processing") + luigi.build([processing_task], local_scheduler=True) + + for name in ['log.yml', + 'processed.msgpack', + 'processed.gex', + 'processed.xyz', + 'DONE']: + assert poltergust_luigi_utils.caching.CachingOpenerTarget(os.path.join(processing_task.processing_name, name)).exists() + + def test_inversion(self): + with luigi.contrib.opener.OpenerTarget(self.root + "/inversion/config.yml").open("w") as f: + yaml.dump({ + "system": { + "name": "Dual moment TEM", + "args": { + "directives__irls": True, + "optimizer__max_iter": 4, # Don't make a good model, that takes way too long time + "optimizer__max_iter_cg": 2 + } + }, + "data": datadir + "/processing/processed.xyz", + "system_data": datadir + "/processing/processed.gex", + }, f) + + inversion_task = beryl_pipeline.inversion.Inversion(inversion_name = self.root + "/inversion") + luigi.build([inversion_task], local_scheduler=True) + + assert luigi.contrib.opener.OpenerTarget(self.root + "/inversion/processed.xyz").exists(), "Corrected data not writen" + assert luigi.contrib.opener.OpenerTarget(self.root + "/inversion/smooth_model.xyz").exists(), "L2 model not writen" + assert luigi.contrib.opener.OpenerTarget(self.root + "/inversion/smooth_synthetic.xyz").exists(), "L2 synthetic data not writen" + assert inversion_task.output().exists(), "Done marker file not written" + + def test_introspection(self): + introspect_task = beryl_pipeline.introspect.Introspect(introspect_name = self.root + "/introspect") + luigi.build([introspect_task], local_scheduler=True) + with introspect_task.output().open("r") as f: + introspection = yaml.load(f, Loader=yaml.SafeLoader) + + assert len(introspection["Import"]["anyOf"]) > 0, "No importers available" + assert len(introspection["Processing"]["items"]["anyOf"]) > 0, "No processing pipeline steps available" + assert len(introspection["Inversion"]["anyOf"]) > 0, "No inversion kernels available" + +class PipelineIntegration(Base): + def test_integration(self): + with poltergust_luigi_utils.caching.CachingOpenerTarget(self.root + "/integration/config.yml").open("w") as f: + yaml.dump({ + "importer": { + "importer": { + "name": "SkyTEM XYZ", + "args": { + "files": { + "xyzfile": datadir + "/aem_processed_data_foothill_central_valley.100101.0.xyz", + "gexfile": datadir + "/20201231_20023_IVF_SkyTEM304_SKB.gex" + }, + "projection": 32611 # Not 100% sure this is correct; the dataset does not specify... + } + } + }, + "processing": { + "steps": [] + }, + "inversion": { + "system": { + "name": "Dual moment TEM", + "args": { + "directives__irls": True, + "optimizer__max_iter": 4, # Don't make a good model, that takes way too long time + "optimizer__max_iter_cg": 2 + } + } + } + }, f) + + import_task = beryl_pipeline.integration.Integration(integration_name = self.root + "/integration") + luigi.build([import_task], local_scheduler=True) + +if __name__ == '__main__': + import nose2 + nose2.main()