From 1b88ae9d6aa598ceb046ad36479c972835e49dc6 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Thu, 22 Dec 2022 11:49:19 -0600
Subject: [PATCH 01/19] added check for variable in dataset for omsa.run

also test for intake-axds
---
 ocean_model_skill_assessor/main.py | 111 +++++++++++++++++++----------
 tests/test_main_axds.py            |  73 +++++++++++++++++++
 2 files changed, 147 insertions(+), 37 deletions(-)

diff --git a/ocean_model_skill_assessor/main.py b/ocean_model_skill_assessor/main.py
index 991973a..1581189 100644
--- a/ocean_model_skill_assessor/main.py
+++ b/ocean_model_skill_assessor/main.py
@@ -3,13 +3,14 @@
 """
 
 import mimetypes
-import pathlib
+from pathlib import PurePath
 import warnings
 
 from collections.abc import Sequence
 from typing import Any, DefaultDict, Dict, List, Optional, Union
 
 import cf_pandas as cfp
+from cf_pandas import Vocab
 import cf_xarray
 import extract_model as em
 import intake
@@ -86,8 +87,8 @@ def make_local_catalog(
 
     # create dictionary of catalog entries
     entries = {
-        pathlib.PurePath(source._urlpath).stem: LocalCatalogEntry(
-            name=pathlib.PurePath(source._urlpath).stem,
+        PurePath(source._urlpath).stem: LocalCatalogEntry(
+            name=PurePath(source._urlpath).stem,
             description=source.description if source.description is not None else "",
             driver=source._yaml()["sources"][source.name]["driver"],
             args=source._yaml()["sources"][source.name]["args"],
@@ -115,7 +116,7 @@ def make_catalog(
     metadata: Optional[dict] = None,
     kwargs: Optional[Dict[str, Any]] = None,
     kwargs_search: Optional[Dict[str, Union[str, int, float]]] = None,
-    vocab: Optional[Union[cfp.Vocab, str, pathlib.PurePath]] = None,
+    vocab: Optional[Union[cfp.Vocab, str, PurePath]] = None,
     return_cat: bool = True,
     save_cat: bool = False,
 ):
@@ -172,7 +173,7 @@ def make_catalog(
 
     if isinstance(vocab, str):
         vocab = cfp.Vocab(omsa.VOCAB_PATH(vocab))
-    elif isinstance(vocab, pathlib.PurePath):
+    elif isinstance(vocab, PurePath):
         vocab = cfp.Vocab(vocab)
 
     if description is None:
@@ -244,12 +245,12 @@ def make_catalog(
 
 
 def run(
-    catalog_names: Union[Sequence, str, pathlib.PurePath],
+    catalog_names: Union[str, Catalog, Sequence],
     project_name: str,
     key_variable: str,
     model_path: str,
-    vocabs: Union[str, list, cfp.Vocab],
-    ndatasets: int = -1,
+    vocabs: Union[str, Vocab, Sequence],
+    ndatasets: Optional[int] = None,
 ):
     """Run the model-data comparison.
 
@@ -257,31 +258,38 @@ def run(
 
     Parameters
     ----------
-    catalog_names : str, Path, list
-        Catalog name(s) or path(s). Datasets will be accessed from catalog entries.
+    catalog_names : str, list, Catalog
+        Catalog name(s) or list of names, or catalog object or list of catalog objects. Datasets will be accessed from catalog entries.
     project_name : str
         Subdirectory in cache dir to store files associated together.
     key_variable : str
         Key in vocab(s) representing variable to compare between model and datasets.
     model_path : str, Path
         Where to find model output. Must be readable by xarray.open_mfdataset() (will be converted to list if needed).
-    vocabs : str, list, optional
+    vocabs : str, list, Vocab, optional
         Criteria to use to map from variable to attributes describing the variable. This is to be used with a key representing what variable to search for. This input is for the name of one or more existing vocabularies which are stored in a user application cache.
     ndatasets : int, optional
         Max number of datasets from each input catalog to use.
     """
 
     # After this, we have a single Vocab object with vocab stored in vocab.vocab
-    if isinstance(vocabs, str):
-        vocab = cfp.Vocab(omsa.VOCAB_PATH(vocabs))
-    elif isinstance(vocabs, Sequence):
-        if isinstance(vocabs[0], str):
-            # vocabs = []
-            # for v in vocabs:
-            #     vocabs.append(cfp.Vocab(omsa.VOCAB_PATH(v)))
-            vocab = cfp.merge([cfp.Vocab(omsa.VOCAB_PATH(v)) for v in vocabs])
-        elif isinstance(vocab[0], cfp.Vocab):
-            vocab = cfp.merge(vocabs)
+    vocabs = cfp.always_iterable(vocabs)
+    # vocabs = cfp.astype(vocabs, list)
+    if isinstance(vocabs[0], str):
+        vocab = cfp.merge([Vocab(omsa.VOCAB_PATH(v)) for v in vocabs])
+    elif isinstance(vocabs[0], Vocab):
+        vocab = cfp.merge(vocabs)
+    else:
+        raise ValueError("Vocab(s) should be input as string paths or Vocab objects or Sequence thereof.")
+    #     vocab = cfp.Vocab(omsa.VOCAB_PATH(vocabs))
+    # elif isinstance(vocabs, Sequence):
+    #     if isinstance(vocabs[0], str):
+    #         # vocabs = []
+    #         # for v in vocabs:
+    #         #     vocabs.append(cfp.Vocab(omsa.VOCAB_PATH(v)))
+    #         vocab = cfp.merge([cfp.Vocab(omsa.VOCAB_PATH(v)) for v in vocabs])
+    #     elif isinstance(vocab[0], cfp.Vocab):
+    #         vocab = cfp.merge(vocabs)
 
     # read in model output
     dsm = xr.open_mfdataset(cfp.astype(model_path, list), preprocess=em.preprocess)
@@ -295,10 +303,17 @@ def run(
         dam[lkey] = dam[lkey] - 360
 
     # Open catalogs.
-    cats = [
-        intake.open_catalog(omsa.CAT_PATH(catalog_name, project_name))
-        for catalog_name in cfp.astype(catalog_names, list)
-    ]
+    # catalog_names = cfp.astype(catalog_names, list)
+    catalog_names = cfp.always_iterable(catalog_names)
+    if isinstance(catalog_names[0], str):
+        cats = [
+            intake.open_catalog(omsa.CAT_PATH(catalog_name, project_name))
+            for catalog_name in cfp.astype(catalog_names, list)
+        ]
+    elif isinstance(catalog_names[0], Catalog):
+        cats = catalog_names
+    else:
+        raise ValueError("Catalog(s) should be input as string paths or Catalog objects or Sequence thereof.")
 
     # Warning about number of datasets
     ndata = np.sum([len(list(cat)) for cat in cats])
@@ -346,6 +361,27 @@ def run(
                 min_time = cat[source_name].metadata["minTime"]
                 max_time = cat[source_name].metadata["maxTime"]
 
+            # Combine and align the two time series of variable
+            with cfp.set_options(custom_criteria=vocab.vocab):
+                print("source name: ", source_name)
+                dfd = cat[source_name].read()
+                if key_variable not in dfd.cf:
+                    warnings.warn(
+                        f"Key variable {key_variable} cannot be identified in dataset {source_name}. Skipping dataset.",
+                        RuntimeWarning,
+                    )
+                    maps.pop(-1)
+                    continue
+                    
+                dfd.cf["T"] = pd.to_datetime(dfd.cf["T"])
+                dfd.set_index(dfd.cf["T"], inplace=True)
+                if dfd.index.tz is not None:
+                    warnings.warn(
+                        f"Dataset {source_name} had a timezone {dfd.index.tz} which is being removed. Make sure the timezone matches the model output.",
+                        RuntimeWarning,
+                    )
+                    dfd.index = dfd.index.tz_convert(None)
+
             # Pull out nearest model output to data
             kwargs = dict(
                 longitude=min_lon,
@@ -392,16 +428,17 @@ def run(
 
             # Combine and align the two time series of variable
             with cfp.set_options(custom_criteria=vocab.vocab):
-                print("source name: ", source_name)
-                dfd = cat[source_name].read()
-                dfd.cf["T"] = pd.to_datetime(dfd.cf["T"])
-                dfd.set_index(dfd.cf["T"], inplace=True)
-                if dfd.index.tz is not None:
-                    warnings.warn(
-                        f"Dataset {source_name} had a timezone {dfd.index.tz} which is being removed. Make sure the timezone matches the model output.",
-                        RuntimeWarning,
-                    )
-                    dfd.index = dfd.index.tz_convert(None)
+            #     print("source name: ", source_name)
+            #     dfd = cat[source_name].read()
+            #     import pdb; pdb.set_trace()
+            #     dfd.cf["T"] = pd.to_datetime(dfd.cf["T"])
+            #     dfd.set_index(dfd.cf["T"], inplace=True)
+            #     if dfd.index.tz is not None:
+            #         warnings.warn(
+            #             f"Dataset {source_name} had a timezone {dfd.index.tz} which is being removed. Make sure the timezone matches the model output.",
+            #             RuntimeWarning,
+            #         )
+            #         dfd.index = dfd.index.tz_convert(None)
 
                 # import pdb; pdb.set_trace()
                 df = omsa.stats._align(dfd.cf[key_variable], model_var)
@@ -423,9 +460,9 @@ def run(
             count += 1
 
     # map of model domain with data locations
-    if CARTOPY_AVAILABLE:
+    if CARTOPY_AVAILABLE and len(maps) > 0:
         figname = omsa.PROJ_DIR(project_name) / "map.png"
         omsa.plot.map.plot_map(np.asarray(maps), figname, dam)
     else:
-        print("Not plotting map since cartopy is not installed.")
+        print("Not plotting map since cartopy is not installed or no datasets to work with.")
     print(f"Finished analysis. Find plots in {omsa.PROJ_DIR(project_name)}.")
diff --git a/tests/test_main_axds.py b/tests/test_main_axds.py
index 528b06e..1e054bc 100644
--- a/tests/test_main_axds.py
+++ b/tests/test_main_axds.py
@@ -2,7 +2,14 @@
 
 from unittest import mock
 
+import cf_pandas as cfp
 import intake
+import pandas as pd
+import pytest
+import numpy as np
+import xarray as xr
+from intake.catalog import Catalog
+from intake.catalog.local import LocalCatalogEntry
 
 import ocean_model_skill_assessor as omsa
 
@@ -99,3 +106,69 @@ def test_make_catalog_axds_platform2(mock_requests, mock_cat_path, tmpdir):
         cat3["test_platform_parquet"].describe()
         == cat2["test_platform_parquet"].describe()
     )
+
+
+@mock.patch("intake.source.csv.CSVSource.read")
+@mock.patch("xarray.open_mfdataset")
+def test_run_variable(mock_ds, mock_read):
+    """Test running with variable that is not present in catalog dataset."""
+    
+    # make catalog
+    entries = {
+        "test_source": LocalCatalogEntry(
+            "test_source",
+            description="",
+            driver="csv",
+            args={"urlpath": "fake.csv"},
+            metadata={"minLongitude": 0,
+                      "maxLongitude": 9,
+                      "minLatitude": 0,
+                      "maxLatitude": 9,
+                      "minTime": "0",
+                      "maxTime": "9"},
+        )
+    }
+    # create catalog
+    cat = Catalog.from_dict(
+        entries,
+        name="test_cat",
+        description="",
+        metadata={},
+    )
+    
+    vocab = cfp.Vocab()
+    vocab.make_entry("temp", "temp", attr="name")
+    
+    ds = xr.Dataset()
+    ds["lon"] = (
+        "lon",
+        np.arange(9),
+        {"units": "degrees_east", "standard_name": "longitude"},
+    )    
+    ds["temp"] = (
+        "lon",
+        np.arange(9),
+        {"standard_name": "sea_water_temperature", 
+         "coordinates": "lon"},
+    )
+    mock_ds.return_value = ds
+    
+    df = pd.DataFrame(
+        columns=[
+            "salt",
+            "longitude",
+            "latitude",
+            "time",
+        ]
+    )
+    mock_read.return_value = df
+
+    with pytest.warns(RuntimeWarning):
+        omsa.run(
+        catalog_names=cat,
+        project_name="projectB",
+        key_variable="temp",
+        model_path="fake.nc",
+        vocabs=vocab,
+        ndatasets=None,
+        )

From b66b0b7b06109ea47820f5b5a96d4b9157fdfb76 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Thu, 22 Dec 2022 11:53:49 -0600
Subject: [PATCH 02/19] moved run test to test_main.py

---
 tests/test_main.py      | 78 +++++++++++++++++++++++++++++++++++++++++
 tests/test_main_axds.py | 74 +-------------------------------------
 2 files changed, 79 insertions(+), 73 deletions(-)
 create mode 100644 tests/test_main.py

diff --git a/tests/test_main.py b/tests/test_main.py
new file mode 100644
index 0000000..aa917b9
--- /dev/null
+++ b/tests/test_main.py
@@ -0,0 +1,78 @@
+
+
+
+import pandas as pd
+import pytest
+import numpy as np
+import xarray as xr
+from intake.catalog import Catalog
+from intake.catalog.local import LocalCatalogEntry
+import cf_pandas as cfp
+from unittest import mock
+import ocean_model_skill_assessor as omsa
+
+
+@mock.patch("intake.source.csv.CSVSource.read")
+@mock.patch("xarray.open_mfdataset")
+def test_run_variable(mock_ds, mock_read):
+    """Test running with variable that is not present in catalog dataset."""
+    
+    # make catalog
+    entries = {
+        "test_source": LocalCatalogEntry(
+            "test_source",
+            description="",
+            driver="csv",
+            args={"urlpath": "fake.csv"},
+            metadata={"minLongitude": 0,
+                      "maxLongitude": 9,
+                      "minLatitude": 0,
+                      "maxLatitude": 9,
+                      "minTime": "0",
+                      "maxTime": "9"},
+        )
+    }
+    # create catalog
+    cat = Catalog.from_dict(
+        entries,
+        name="test_cat",
+        description="",
+        metadata={},
+    )
+    
+    vocab = cfp.Vocab()
+    vocab.make_entry("temp", "temp", attr="name")
+    
+    ds = xr.Dataset()
+    ds["lon"] = (
+        "lon",
+        np.arange(9),
+        {"units": "degrees_east", "standard_name": "longitude"},
+    )    
+    ds["temp"] = (
+        "lon",
+        np.arange(9),
+        {"standard_name": "sea_water_temperature", 
+         "coordinates": "lon"},
+    )
+    mock_ds.return_value = ds
+    
+    df = pd.DataFrame(
+        columns=[
+            "salt",
+            "longitude",
+            "latitude",
+            "time",
+        ]
+    )
+    mock_read.return_value = df
+
+    with pytest.warns(RuntimeWarning):
+        omsa.run(
+        catalog_names=cat,
+        project_name="projectB",
+        key_variable="temp",
+        model_path="fake.nc",
+        vocabs=vocab,
+        ndatasets=None,
+        )
diff --git a/tests/test_main_axds.py b/tests/test_main_axds.py
index 1e054bc..89b3697 100644
--- a/tests/test_main_axds.py
+++ b/tests/test_main_axds.py
@@ -2,14 +2,8 @@
 
 from unittest import mock
 
-import cf_pandas as cfp
+
 import intake
-import pandas as pd
-import pytest
-import numpy as np
-import xarray as xr
-from intake.catalog import Catalog
-from intake.catalog.local import LocalCatalogEntry
 
 import ocean_model_skill_assessor as omsa
 
@@ -106,69 +100,3 @@ def test_make_catalog_axds_platform2(mock_requests, mock_cat_path, tmpdir):
         cat3["test_platform_parquet"].describe()
         == cat2["test_platform_parquet"].describe()
     )
-
-
-@mock.patch("intake.source.csv.CSVSource.read")
-@mock.patch("xarray.open_mfdataset")
-def test_run_variable(mock_ds, mock_read):
-    """Test running with variable that is not present in catalog dataset."""
-    
-    # make catalog
-    entries = {
-        "test_source": LocalCatalogEntry(
-            "test_source",
-            description="",
-            driver="csv",
-            args={"urlpath": "fake.csv"},
-            metadata={"minLongitude": 0,
-                      "maxLongitude": 9,
-                      "minLatitude": 0,
-                      "maxLatitude": 9,
-                      "minTime": "0",
-                      "maxTime": "9"},
-        )
-    }
-    # create catalog
-    cat = Catalog.from_dict(
-        entries,
-        name="test_cat",
-        description="",
-        metadata={},
-    )
-    
-    vocab = cfp.Vocab()
-    vocab.make_entry("temp", "temp", attr="name")
-    
-    ds = xr.Dataset()
-    ds["lon"] = (
-        "lon",
-        np.arange(9),
-        {"units": "degrees_east", "standard_name": "longitude"},
-    )    
-    ds["temp"] = (
-        "lon",
-        np.arange(9),
-        {"standard_name": "sea_water_temperature", 
-         "coordinates": "lon"},
-    )
-    mock_ds.return_value = ds
-    
-    df = pd.DataFrame(
-        columns=[
-            "salt",
-            "longitude",
-            "latitude",
-            "time",
-        ]
-    )
-    mock_read.return_value = df
-
-    with pytest.warns(RuntimeWarning):
-        omsa.run(
-        catalog_names=cat,
-        project_name="projectB",
-        key_variable="temp",
-        model_path="fake.nc",
-        vocabs=vocab,
-        ndatasets=None,
-        )

From 490daac472b52421dc73f72fc286dcc6a954502f Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Thu, 22 Dec 2022 12:03:11 -0600
Subject: [PATCH 03/19] testing valueerrors raised in run

---
 ocean_model_skill_assessor/main.py | 22 +++++++++++-----------
 tests/test_main.py                 | 27 +++++++++++++++++++++++++++
 2 files changed, 38 insertions(+), 11 deletions(-)

diff --git a/ocean_model_skill_assessor/main.py b/ocean_model_skill_assessor/main.py
index 1581189..248cb8e 100644
--- a/ocean_model_skill_assessor/main.py
+++ b/ocean_model_skill_assessor/main.py
@@ -291,17 +291,6 @@ def run(
     #     elif isinstance(vocab[0], cfp.Vocab):
     #         vocab = cfp.merge(vocabs)
 
-    # read in model output
-    dsm = xr.open_mfdataset(cfp.astype(model_path, list), preprocess=em.preprocess)
-
-    # use only one variable from model
-    dam = dsm.cf[key_variable]
-
-    # shift if 0 to 360
-    if dam.cf["longitude"].max() > 180:
-        lkey = dam.cf["longitude"].name
-        dam[lkey] = dam[lkey] - 360
-
     # Open catalogs.
     # catalog_names = cfp.astype(catalog_names, list)
     catalog_names = cfp.always_iterable(catalog_names)
@@ -324,6 +313,17 @@ def run(
     else:
         print(f"Note that there are {ndata} datasets to use. This might take awhile.")
 
+    # read in model output
+    dsm = xr.open_mfdataset(cfp.astype(model_path, list), preprocess=em.preprocess)
+
+    # use only one variable from model
+    dam = dsm.cf[key_variable]
+
+    # shift if 0 to 360
+    if dam.cf["longitude"].max() > 180:
+        lkey = dam.cf["longitude"].name
+        dam[lkey] = dam[lkey] - 360
+
     # loop over catalogs and sources to pull out lon/lat locations for plot
     maps = []
     count = 0  # track datasets since count is used to match on map
diff --git a/tests/test_main.py b/tests/test_main.py
index aa917b9..70b4bb8 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -76,3 +76,30 @@ def test_run_variable(mock_ds, mock_read):
         vocabs=vocab,
         ndatasets=None,
         )
+
+
+def test_run_errors():
+    
+    # incorrect vocab type
+    with pytest.raises(ValueError):
+        omsa.run(
+        catalog_names="",
+        project_name="projectB",
+        key_variable="temp",
+        model_path="fake.nc",
+        vocabs=[dict()],
+        ndatasets=None,
+        )
+    
+    vocab = cfp.Vocab()
+    vocab.make_entry("temp", "temp", attr="name")
+    # incorrect catalog type
+    with pytest.raises(ValueError):
+        omsa.run(
+        catalog_names=[dict()],
+        project_name="projectB",
+        key_variable="temp",
+        model_path="fake.nc",
+        vocabs=vocab,
+        ndatasets=None,
+        )

From be5bd8a013a2c5f2c66e6afc715933a975e2f9a1 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Thu, 22 Dec 2022 12:25:37 -0600
Subject: [PATCH 04/19] updated docs

---
 docs/cli.md                        |  2 +-
 ocean_model_skill_assessor/CLI.py  |  2 +-
 ocean_model_skill_assessor/main.py | 65 ++++++++++++-------------
 tests/test_main.py                 | 77 +++++++++++++++---------------
 tests/test_main_axds.py            |  1 -
 5 files changed, 71 insertions(+), 76 deletions(-)

diff --git a/docs/cli.md b/docs/cli.md
index a256fca..5093e73 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -154,7 +154,7 @@ Note that if any datasets have timezones attached, they are removed before compa
 
 #### Available options
 
-    omsa run --project_name test1 --catalog_names CATALOG_NAME1 CATALOG_NAME2 --vocab_names VOCAB1 VOCAB2 --key KEY --model_path PATH_TO_MODEL_OUTPUT --ndatasets NDATASETS
+    omsa run --project_name test1 --catalogs CATALOG_NAME1 CATALOG_NAME2 --vocab_names VOCAB1 VOCAB2 --key KEY --model_path PATH_TO_MODEL_OUTPUT --ndatasets NDATASETS
 
 * `project_name`: Subdirectory in cache dir to store files associated together.
 * `catalog_names`: Catalog name(s). Datasets will be accessed from catalog entries.
diff --git a/ocean_model_skill_assessor/CLI.py b/ocean_model_skill_assessor/CLI.py
index 14b447f..9feda6d 100644
--- a/ocean_model_skill_assessor/CLI.py
+++ b/ocean_model_skill_assessor/CLI.py
@@ -111,7 +111,7 @@ def main():
     elif args.action == "run":
         omsa.main.run(
             project_name=args.project_name,
-            catalog_names=args.catalog_names,
+            catalogs=args.catalog_names,
             vocabs=args.vocab_names,
             key_variable=args.key,
             model_path=args.model_path,
diff --git a/ocean_model_skill_assessor/main.py b/ocean_model_skill_assessor/main.py
index 248cb8e..f8fa455 100644
--- a/ocean_model_skill_assessor/main.py
+++ b/ocean_model_skill_assessor/main.py
@@ -3,14 +3,13 @@
 """
 
 import mimetypes
-from pathlib import PurePath
 import warnings
 
 from collections.abc import Sequence
+from pathlib import PurePath
 from typing import Any, DefaultDict, Dict, List, Optional, Union
 
 import cf_pandas as cfp
-from cf_pandas import Vocab
 import cf_xarray
 import extract_model as em
 import intake
@@ -18,6 +17,7 @@
 import pandas as pd
 import xarray as xr
 
+from cf_pandas import Vocab
 from intake.catalog import Catalog
 from intake.catalog.local import LocalCatalogEntry
 from tqdm import tqdm
@@ -245,7 +245,7 @@ def make_catalog(
 
 
 def run(
-    catalog_names: Union[str, Catalog, Sequence],
+    catalogs: Union[str, Catalog, Sequence],
     project_name: str,
     key_variable: str,
     model_path: str,
@@ -258,7 +258,7 @@ def run(
 
     Parameters
     ----------
-    catalog_names : str, list, Catalog
+    catalogs : str, list, Catalog
         Catalog name(s) or list of names, or catalog object or list of catalog objects. Datasets will be accessed from catalog entries.
     project_name : str
         Subdirectory in cache dir to store files associated together.
@@ -274,35 +274,28 @@ def run(
 
     # After this, we have a single Vocab object with vocab stored in vocab.vocab
     vocabs = cfp.always_iterable(vocabs)
-    # vocabs = cfp.astype(vocabs, list)
     if isinstance(vocabs[0], str):
         vocab = cfp.merge([Vocab(omsa.VOCAB_PATH(v)) for v in vocabs])
     elif isinstance(vocabs[0], Vocab):
         vocab = cfp.merge(vocabs)
     else:
-        raise ValueError("Vocab(s) should be input as string paths or Vocab objects or Sequence thereof.")
-    #     vocab = cfp.Vocab(omsa.VOCAB_PATH(vocabs))
-    # elif isinstance(vocabs, Sequence):
-    #     if isinstance(vocabs[0], str):
-    #         # vocabs = []
-    #         # for v in vocabs:
-    #         #     vocabs.append(cfp.Vocab(omsa.VOCAB_PATH(v)))
-    #         vocab = cfp.merge([cfp.Vocab(omsa.VOCAB_PATH(v)) for v in vocabs])
-    #     elif isinstance(vocab[0], cfp.Vocab):
-    #         vocab = cfp.merge(vocabs)
+        raise ValueError(
+            "Vocab(s) should be input as string paths or Vocab objects or Sequence thereof."
+        )
 
     # Open catalogs.
-    # catalog_names = cfp.astype(catalog_names, list)
-    catalog_names = cfp.always_iterable(catalog_names)
-    if isinstance(catalog_names[0], str):
+    catalogs = cfp.always_iterable(catalogs)
+    if isinstance(catalogs[0], str):
         cats = [
             intake.open_catalog(omsa.CAT_PATH(catalog_name, project_name))
-            for catalog_name in cfp.astype(catalog_names, list)
+            for catalog_name in cfp.astype(catalogs, list)
         ]
-    elif isinstance(catalog_names[0], Catalog):
-        cats = catalog_names
+    elif isinstance(catalogs[0], Catalog):
+        cats = catalogs
     else:
-        raise ValueError("Catalog(s) should be input as string paths or Catalog objects or Sequence thereof.")
+        raise ValueError(
+            "Catalog(s) should be input as string paths or Catalog objects or Sequence thereof."
+        )
 
     # Warning about number of datasets
     ndata = np.sum([len(list(cat)) for cat in cats])
@@ -372,7 +365,7 @@ def run(
                     )
                     maps.pop(-1)
                     continue
-                    
+
                 dfd.cf["T"] = pd.to_datetime(dfd.cf["T"])
                 dfd.set_index(dfd.cf["T"], inplace=True)
                 if dfd.index.tz is not None:
@@ -428,17 +421,17 @@ def run(
 
             # Combine and align the two time series of variable
             with cfp.set_options(custom_criteria=vocab.vocab):
-            #     print("source name: ", source_name)
-            #     dfd = cat[source_name].read()
-            #     import pdb; pdb.set_trace()
-            #     dfd.cf["T"] = pd.to_datetime(dfd.cf["T"])
-            #     dfd.set_index(dfd.cf["T"], inplace=True)
-            #     if dfd.index.tz is not None:
-            #         warnings.warn(
-            #             f"Dataset {source_name} had a timezone {dfd.index.tz} which is being removed. Make sure the timezone matches the model output.",
-            #             RuntimeWarning,
-            #         )
-            #         dfd.index = dfd.index.tz_convert(None)
+                #     print("source name: ", source_name)
+                #     dfd = cat[source_name].read()
+                #     import pdb; pdb.set_trace()
+                #     dfd.cf["T"] = pd.to_datetime(dfd.cf["T"])
+                #     dfd.set_index(dfd.cf["T"], inplace=True)
+                #     if dfd.index.tz is not None:
+                #         warnings.warn(
+                #             f"Dataset {source_name} had a timezone {dfd.index.tz} which is being removed. Make sure the timezone matches the model output.",
+                #             RuntimeWarning,
+                #         )
+                #         dfd.index = dfd.index.tz_convert(None)
 
                 # import pdb; pdb.set_trace()
                 df = omsa.stats._align(dfd.cf[key_variable], model_var)
@@ -464,5 +457,7 @@ def run(
         figname = omsa.PROJ_DIR(project_name) / "map.png"
         omsa.plot.map.plot_map(np.asarray(maps), figname, dam)
     else:
-        print("Not plotting map since cartopy is not installed or no datasets to work with.")
+        print(
+            "Not plotting map since cartopy is not installed or no datasets to work with."
+        )
     print(f"Finished analysis. Find plots in {omsa.PROJ_DIR(project_name)}.")
diff --git a/tests/test_main.py b/tests/test_main.py
index 70b4bb8..1b2d5e7 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -1,14 +1,14 @@
+from unittest import mock
 
-
-
+import cf_pandas as cfp
+import numpy as np
 import pandas as pd
 import pytest
-import numpy as np
 import xarray as xr
+
 from intake.catalog import Catalog
 from intake.catalog.local import LocalCatalogEntry
-import cf_pandas as cfp
-from unittest import mock
+
 import ocean_model_skill_assessor as omsa
 
 
@@ -16,7 +16,7 @@
 @mock.patch("xarray.open_mfdataset")
 def test_run_variable(mock_ds, mock_read):
     """Test running with variable that is not present in catalog dataset."""
-    
+
     # make catalog
     entries = {
         "test_source": LocalCatalogEntry(
@@ -24,12 +24,14 @@ def test_run_variable(mock_ds, mock_read):
             description="",
             driver="csv",
             args={"urlpath": "fake.csv"},
-            metadata={"minLongitude": 0,
-                      "maxLongitude": 9,
-                      "minLatitude": 0,
-                      "maxLatitude": 9,
-                      "minTime": "0",
-                      "maxTime": "9"},
+            metadata={
+                "minLongitude": 0,
+                "maxLongitude": 9,
+                "minLatitude": 0,
+                "maxLatitude": 9,
+                "minTime": "0",
+                "maxTime": "9",
+            },
         )
     }
     # create catalog
@@ -39,24 +41,23 @@ def test_run_variable(mock_ds, mock_read):
         description="",
         metadata={},
     )
-    
+
     vocab = cfp.Vocab()
     vocab.make_entry("temp", "temp", attr="name")
-    
+
     ds = xr.Dataset()
     ds["lon"] = (
         "lon",
         np.arange(9),
         {"units": "degrees_east", "standard_name": "longitude"},
-    )    
+    )
     ds["temp"] = (
         "lon",
         np.arange(9),
-        {"standard_name": "sea_water_temperature", 
-         "coordinates": "lon"},
+        {"standard_name": "sea_water_temperature", "coordinates": "lon"},
     )
     mock_ds.return_value = ds
-    
+
     df = pd.DataFrame(
         columns=[
             "salt",
@@ -69,37 +70,37 @@ def test_run_variable(mock_ds, mock_read):
 
     with pytest.warns(RuntimeWarning):
         omsa.run(
-        catalog_names=cat,
-        project_name="projectB",
-        key_variable="temp",
-        model_path="fake.nc",
-        vocabs=vocab,
-        ndatasets=None,
+            catalogs=cat,
+            project_name="projectB",
+            key_variable="temp",
+            model_path="fake.nc",
+            vocabs=vocab,
+            ndatasets=None,
         )
 
 
 def test_run_errors():
-    
+
     # incorrect vocab type
     with pytest.raises(ValueError):
         omsa.run(
-        catalog_names="",
-        project_name="projectB",
-        key_variable="temp",
-        model_path="fake.nc",
-        vocabs=[dict()],
-        ndatasets=None,
+            catalogs="",
+            project_name="projectB",
+            key_variable="temp",
+            model_path="fake.nc",
+            vocabs=[dict()],
+            ndatasets=None,
         )
-    
+
     vocab = cfp.Vocab()
     vocab.make_entry("temp", "temp", attr="name")
     # incorrect catalog type
     with pytest.raises(ValueError):
         omsa.run(
-        catalog_names=[dict()],
-        project_name="projectB",
-        key_variable="temp",
-        model_path="fake.nc",
-        vocabs=vocab,
-        ndatasets=None,
+            catalogs=[dict()],
+            project_name="projectB",
+            key_variable="temp",
+            model_path="fake.nc",
+            vocabs=vocab,
+            ndatasets=None,
         )
diff --git a/tests/test_main_axds.py b/tests/test_main_axds.py
index 89b3697..528b06e 100644
--- a/tests/test_main_axds.py
+++ b/tests/test_main_axds.py
@@ -2,7 +2,6 @@
 
 from unittest import mock
 
-
 import intake
 
 import ocean_model_skill_assessor as omsa

From e71c3a441448ecfe30717e76ef74a0c2c9c27df8 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Thu, 22 Dec 2022 15:43:10 -0600
Subject: [PATCH 05/19] some small fixes

---
 ocean_model_skill_assessor/CLI.py  | 6 +++++-
 ocean_model_skill_assessor/main.py | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/ocean_model_skill_assessor/CLI.py b/ocean_model_skill_assessor/CLI.py
index 9feda6d..4a674ee 100644
--- a/ocean_model_skill_assessor/CLI.py
+++ b/ocean_model_skill_assessor/CLI.py
@@ -57,6 +57,10 @@ def main():
         help="Input keyword arguments for the search specification. Dictionary-style input. More information on options can be found in `omsa.main.make_catalog` docstrings. Format for list items is e.g. standard_names='[sea_water_practical_salinity,sea_water_temperature]'.",
     )
 
+    parser.add_argument(
+        "--vocab_name", help="Vocab file name, must be in the vocab user directory."
+    )
+
     parser.add_argument(
         "--catalog_name", help="Catalog name, with or without suffix of yaml."
     )
@@ -95,7 +99,7 @@ def main():
             description=args.description,
             kwargs=args.kwargs,
             kwargs_search=args.kwargs_search,
-            vocab=args.vocab_names,
+            vocab=args.vocab_name,
             save_cat=True,
         )
 
diff --git a/ocean_model_skill_assessor/main.py b/ocean_model_skill_assessor/main.py
index f8fa455..d19aa92 100644
--- a/ocean_model_skill_assessor/main.py
+++ b/ocean_model_skill_assessor/main.py
@@ -238,7 +238,7 @@ def make_catalog(
     if save_cat:
         # save cat to file
         cat.save(omsa.CAT_PATH(catalog_name, project_name))
-        print(f"Catalog saved to {omsa.CAT_PATH(catalog_name, project_name)}.")
+        print(f"Catalog saved to {omsa.CAT_PATH(catalog_name, project_name)} with {len(list(cat))} entries.")
 
     if return_cat:
         return cat

From 1bed2017e0c0fc932f902028701b650a73687135 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Fri, 23 Dec 2022 10:31:19 -0600
Subject: [PATCH 06/19] updated CLI docs with more erddap catalog examples

---
 docs/cli.md | 70 +++++++++++++++++++++++++++++++++++------------------
 1 file changed, 46 insertions(+), 24 deletions(-)

diff --git a/docs/cli.md b/docs/cli.md
index 5093e73..60bdfe3 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -15,7 +15,7 @@ Make a catalog with known local or remote file(s).
 
 #### Available options
 
-    omsa make_catalog --project_name PROJ_NAME --catalog_type local --catalog_name CATALOG_NAME --description "Catalog description" --kwargs filenames="[FILE1,FILE2]"
+    omsa make_catalog --project_name PROJ_NAME --catalog_type local --catalog_name CATALOG_NAME --description "Catalog description" --kwargs filenames="[FILE1,FILE2]" 
 
 * `project_name`: Will be used as the name of the directory where the catalog is saved. The directory is located in a user application cache directory, the address of which can be found for your setup with  `omsa proj_path --project_name PROJ_NAME`.
 * `catalog_type`: Type of catalog to make. Options are "erddap", "axds", or "local".
@@ -30,19 +30,19 @@ Make a catalog with known local or remote file(s).
 
 
 
+    
 
 
 
+   
 
 
 
+    
 
 
 
-
-
-
-
+    
 
 
 
@@ -52,7 +52,7 @@ Make a catalog with known local or remote file(s).
 #### Examples
 
 ```{code-cell} ipython3
-!omsa make_catalog --project_name test1 --catalog_type local --catalog_name example_local_catalog --description "Example local catalog description" --kwargs filenames="[https://researchworkspace.com/files/8114311/ecofoci_2011CHAOZ_CTD_Nutrient_mb1101.csv]"
+!omsa make_catalog --project_name test1 --catalog_type local --catalog_name example_local_catalog --description "Example local catalog description" --kwargs filenames="[https://researchworkspace.com/files/8114311/ecofoci_2011CHAOZ_CTD_Nutrient_mb1101.csv]" 
 ```
 
 ### ERDDAP Catalog
@@ -70,11 +70,11 @@ Make a catalog from datasets available from an ERDDAP server using `intake-erdda
 * `metadata`: Metadata for catalog.
 * `kwargs`: Keyword arguments to make the ERDDAP catalog. See `intake-erddap.erddap_cat()` for more details.
   * `server`: ERDDAP server address, for example: "http://erddap.sensors.ioos.us/erddap"
-  * `category_search`:
-  * `erddap_client`:
-  * `use_source_constraints`:
-  * `protocol`:
-  * `metadata`:
+  * `category_search`: 
+  * `erddap_client`: 
+  * `use_source_constraints`: 
+  * `protocol`: 
+  * `metadata`: 
   * other keyword arguments can be passed into the intake `Catalog` class
 * `kwargs_search`: Keyword arguments to input to search on the server before making the catalog.
   * `min_lon`, `min_lat`, `max_lon`, `max_lat`: search for datasets within this spatial box
@@ -84,7 +84,7 @@ Make a catalog from datasets available from an ERDDAP server using `intake-erdda
 
 #### Examples
 
-Select a box and time range over which to search catalog:
+Select a spatial box and time range over which to search catalog:
 
 ```{code-cell} ipython3
 !omsa make_catalog --project_name test1 --catalog_type erddap --catalog_name example_erddap_catalog --description "Example ERDDAP catalog description" --kwargs server=https://erddap.sensors.ioos.us/erddap --kwargs_search min_lon=-170 min_lat=53 max_lon=-165 max_lat=56 min_time=2022-1-1 max_time=2022-1-2
@@ -96,6 +96,40 @@ Input model output to use to create the space search range, but choose time sear
 !omsa make_catalog --project_name test1 --catalog_type erddap --catalog_name example_erddap_catalog --description "Example ERDDAP catalog description" --kwargs server=https://erddap.sensors.ioos.us/erddap --kwargs_search model_path=https://thredds.cencoos.org/thredds/dodsC/CENCOOS_CA_ROMS_FCST.nc min_time=2022-1-1 max_time=2022-1-2
 ```
 
+Narrow your search by variable. For `intake-erddap` you can filter by the CF `standard_name` of the variable directly with:
+
+```{code-cell} ipython3
+!omsa make_catalog --project_name test1 --catalog_type erddap --catalog_name cat1 --kwargs server=https://erddap.sensors.ioos.us/erddap standard_names="[sea_surface_temperature,sea_water_temperature,surface_temperature]"
+```
+
+You can return equivalent results in your catalog by searching with a variable nickname (the keys in the dictionary) along with a dictionary defining a vocabulary of regular expressions for matching what "counts" as a particular variable. To save a custom vocabulary to a location for this command, use the `Vocab` class in `cf-pandas` ([docs](https://cf-pandas.readthedocs.io/en/latest/demo_vocab.html#save-to-file)). A premade set of vocabularies aimed at use by ocean modelers is also available to use by name; see them with command `omsa vocabs`. Suggested uses:
+* axds catalog: vocab_name standard_names
+* erddap catalog, IOOS: vocab_name erddap_ioos
+* erddap catalog, Coastwatch: vocab_name erddap_coastwatch
+* local catalog: vocab_name general
+
+This is more complicated than simply defining the desired standard_names as shown in the previous example. However, it becomes useful when using other data files or model output which might have different variable names but could be reocgnized with variable matching through the vocabulary.
+
+The example below uses the pre-defined vocabulary "erddap_ioos" since we are using the IOOS ERDDAP server, and will search for matching variables by standard_name and matching the variable nickname "temp". The "erddap_ioos" vocabulary can be investigated as shown here and contains exactly the same standard_names as in the previous example. The regular expressions are set up to match exactly those standard_names. This is why we return the same results from either approach.
+
+```{code-cell} ipython3
+import ocean_model_skill_assessor as omsa
+import cf_pandas as cfp
+
+vocab = cfp.Vocab(omsa.VOCAB_PATH("erddap_ioos"))
+vocab
+```
+
+```{code-cell} ipython3
+!omsa make_catalog --project_name test1 --catalog_type erddap --catalog_name cat3 --kwargs server=https://erddap.sensors.ioos.us/erddap category_search="[standard_name,temp]" --vocab_name erddap_ioos
+```
+
+You can additionally narrow your search by a text term by adding the `search_for` and `query_type` keyword inputs. This example searches for datasets containing the varaible "sea_surface_temperature" and, somewhere in the dataset metadata, the term "Timeseries". If we had wanted datasets that contain one OR the other, we could use `query_type=union`.
+
+```{code-cell} ipython3
+!omsa make_catalog --project_name test1 --catalog_type erddap --catalog_name cat2 --kwargs server=https://erddap.sensors.ioos.us/erddap standard_names="[sea_surface_temperature]" search_for="[Timeseries]" query_type=intersection
+```
+
 ### Catalog for Axiom assets
 
 Make a catalog of Axiom Data Science-stored assets using `intake-axds`.
@@ -136,18 +170,6 @@ Input model output to use to create the space search range, but choose time sear
 !omsa make_catalog --project_name test1 --catalog_type axds --catalog_name example_axds_catalog --description "Example AXDS catalog description" --kwargs standard_names='[sea_water_practical_salinity,sea_water_temperature]' verbose=True --kwargs_search model_path=https://thredds.cencoos.org/thredds/dodsC/CENCOOS_CA_ROMS_FCST.nc min_time=2022-1-1 max_time=2022-1-2
 ```
 
-Alternatively, filter returned datasets for variables using the variable nicknames along with a vocabulary of regular expressions for matching what "counts" as a variable. To save a custom vocabulary to a location for this command, use the `Vocab` class in `cf-pandas` ([docs](https://cf-pandas.readthedocs.io/en/latest/demo_vocab.html#save-to-file)). A premade set of vocabularies is also available to use by name; see them with command `omsa vocabs`. Suggested uses:
-* axds catalog: vocab_name standard_names
-* erddap catalog, IOOS: vocab_name erddap_ioos
-* erddap catalog, Coastwatch: vocab_name erddap_coastwatch
-* local catalog: vocab_name general
-
-```
-omsa make_catalog --project_name test1 --catalog_type axds --vocab_name standard_names --kwargs keys_to_match="[temp,salt]"
-```
-
-+++
-
 ## Run model-data comparison
 
 Note that if any datasets have timezones attached, they are removed before comparison with the assumption that the model output and data are in the same time zone.

From 1150dbe95800870abea24aa995b46cd9e4d4cf05 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Fri, 23 Dec 2022 10:50:48 -0600
Subject: [PATCH 07/19] removed old demo notebooks

---
 docs/Demo-AK.ipynb        | 178 --------
 docs/Demo-AK.md           |  80 ----
 docs/Demo-CA.ipynb        | 219 ----------
 docs/Demo_workflows.ipynb | 883 --------------------------------------
 4 files changed, 1360 deletions(-)
 delete mode 100644 docs/Demo-AK.ipynb
 delete mode 100644 docs/Demo-AK.md
 delete mode 100644 docs/Demo-CA.ipynb
 delete mode 100644 docs/Demo_workflows.ipynb

diff --git a/docs/Demo-AK.ipynb b/docs/Demo-AK.ipynb
deleted file mode 100644
index 0b7e3c7..0000000
--- a/docs/Demo-AK.ipynb
+++ /dev/null
@@ -1,178 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "a9da2fa8-9a25-497e-8ec6-d08609ad38ca",
-   "metadata": {},
-   "source": [
-    "# Demonstration of `ocean-model-skill-assessor`: Alaska example\n",
-    "\n",
-    "Here we demonstrate how to use `ocean-model-skill-assessor` as a Python package."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "3b2011cd-01e0-454c-af6f-d968522f5385",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import xarray as xr\n",
-    "import ocean_data_gateway as odg\n",
-    "import cf_xarray\n",
-    "import pandas as pd\n",
-    "import extract_model as em\n",
-    "import ocean_model_skill_assessor as omsa\n",
-    "import numpy as np\n",
-    "from IPython import display\n",
-    "from glob import glob"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "07a7bb3c-38d8-45a1-8444-ff0ea7aac52f",
-   "metadata": {},
-   "source": [
-    "## Definitions\n",
-    "\n",
-    "These dictionaries are not required for every type of run, but are required for identifying variables in both datasets and models, and for running QC. They can be complicated if desired, but do not have to be. Once they are written they do not need to be modified much. More information about these dictionaries is available in the [`ocean_data_gateway` docs](https://ocean-data-gateway.readthedocs.io/en/latest/details.html#Configure-custom-criteria-and-variable-definitions). We posted online pre-populated definitions to make this easy."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "571d37a7-bd3c-4629-9931-e293bc609ce0",
-   "metadata": {},
-   "source": [
-    "Here are `criteria`, which map identifying features of different variables to a variable nickname we can generically refer to:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "ed628da3-09dd-4b3a-bfd0-cd52b154399b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "url = 'https://gist.githubusercontent.com/kthyng/c3cc27de6b4449e1776ce79215d5e732/raw/18f18f33ccc71144842bd9fbf87611f1f6f4a67e/my_custom_criteria.py'\n",
-    "criteria = odg.return_response(url)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0b502c01-3e4a-4d22-916f-9579eb6193c0",
-   "metadata": {},
-   "source": [
-    "Here are `var_def` which give some rules for QC for different variables (referring to the variables by the same nicknames as in `criteria`):"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "da532c82-28e2-4224-b4ce-8260cee9de57",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "url = 'https://gist.githubusercontent.com/kthyng/b8056748a811479460b6d5fc5cb5537b/raw/6b531cc5d3072ff6a4f5174f882d7d91d880cbf8/my_var_def.py'\n",
-    "var_def = odg.return_response(url)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "dd29ad0d-e2b7-4424-b1be-489b29e6b921",
-   "metadata": {},
-   "source": [
-    "## Search for Data over a Region\n",
-    "\n",
-    "This example demonstrates performing a search in time and space for data to compare with your model output. By default this would search in the spatial bounding box of the model output, but here we instead input a smaller bounding box so as to limit the number of datasets found and used. For several of the datasets, the model output isn't available (must be determined to be on land). "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "c24752b9-3eb1-4e25-a5a0-387ea9bb72e0",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CPU times: user 17.4 s, sys: 4.81 s, total: 22.2 s\n",
-      "Wall time: 2min 9s\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 800x700 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4IAAAFlCAYAAAC+11ZyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAACRE0lEQVR4nOzdd3QU5dfA8e8l9CIgTZBelBrpSAdpCsHeXgvEAtjBjoqIXVEEu6D+ACtiFxAEQSlSAyJNFFR6770l9/3j2U2WkLJJdjMp93POnN2derPZnZ07TxNVxRhjjDHGGGNM7pHH6wCMMcYYY4wxxmQuSwSNMcYYY4wxJpexRNAYY4wxxhhjchlLBI0xxhhjjDEml7FE0BhjjDHGGGNyGUsEjTHGGGOMMSaXsUTQmCxARKqLyBERURGpmcTyCBEZICIrROSYiOwWkZ9FpHyi9eqJyFQROeRbZ7SInJ1onV99x0lqmhKw3pgU1ludzr/zVxGZE8R6Q0TE87FtRKSkiHwgIrtE5LDvPW+Qjv38n+992xSOOLMaEWkjInNF5KiIbBOR10SkUBq27y4is3yf4wMiEiMiF6Ujjqq+9z06rduGg4hUEpGvRGS/7+/6RkQqp2M/j/n+rlS/SzlJMOe3ZLZrIiJTRGSz7/y5TUR+FJGWmRF3ViQi9UVkpIgsFpETwZ5vfe+jishzQa7/gu9/tjsrfRezAhHJ4/sur/N9Lv8QkauC3Da53+cRYQ7b5DB5vQ7AGAPAO8B+ILmL5Y+BbsALQAxQHGgPFPSvICIVgF+B1cDVQAngFWCiiLRR1TjfqncBZyXaf0vgNeCHgHnPAu8lWq8q8Hmi9cLhA2BKqmuFkYgI7u+sBtwL7AUeA34RkYaqGlRSJyIlgOHAtjCFmqWISCQwDfgJiMK9f68A5wLXBbF9P+At3/Qs7oZlQ6BwOsLZivts/5OObUNKRAoDM4DjQG9Agedwn6dIVT0c5H6qA08AO8IVa1aUhvNbUkoAa4ExuM9EWeB+YKZv24VhCzzragJ0x/2eHMd9T1IkIv8HXJDG49wLLAUmAr3SuG1O9yzwEO77vBi4HvhSRKJU9ccgtt8JXJpo3tbQhmhyPFW1ySabPJyAG4DtwADcxWHNRMuvB04BTVLZz3BgH1AiYF473z6vTGXbD3EXA2enst6Tvv3VS+ff+iswx+v3PMhYL/P9rR0D5hUH9gBvpGE/o3BJ0Rhgk9d/VzIxFkjPsmTW/xZYA+QLmNfL9142TmXbqsBRYIDX70kY3uP+QGzg9xuXJJ8CHkjDfn4CRman71KI3r90n9+S2V8x3znvTa//No/ezzwBz59zl4Mprl8CdzPr/3zv+XNpOQ5Q07dddIj/DgHye/1+piPusr7P39OJ5k8HlgWxfZb9PbEpe01WNdRkWyLS1FcVok3AvHsTV1sRkVq+ed19r6N9r1uJyHgROSgi20XkMd/yi0Xkd19VwEUi0iTRcUVE7heRv3xVaraKyFsikriULZi/oSSuJO4h3EVOUu4CZqrq4lR2dykwSVXj96Oqs4ANuKQmuRgKAdcAE1R1TyrH6AUsVtWVqayXIhG5TFw11+MislpErk20/IyqoSJyj4jME5E9IrJPROaLSI9E6+QVkWdF5B9fVZtdIjIn8DOSBpcCW1T1F/8MVd0PTCCF9zNRPK2Bm4C703H8pPZ3hYj8JglVJheKyKUBy8/yfRa3+N7bv3yfVQlYp4Pv83+liLwvIjtxNyLiq+6KSE/fd+A47vMXbHz5gIuB8ap6MmDReOAEqb9vtwJxnFkSnS6STNVQEbnJVw3L/xn5WM6sZn29iMwQkZ2+9/t3EemdgXAuBear6lr/DFX9D/iN4D9PNwCNcSXTGeKrjvaJiNzs+5wcFZHZvvNlEXHVBnf7zo3DRCRvwLZFReRNEdng+5xtF1dtunbAOnnFVXtb7Vtni28/BZOOKFXpOr+l4DDuQvxkaismxf87IyIPish63+/FJBEp65vGi6sCvFFEHk207TkiMjbge7pVRCaKSFnf8lCex5KkKZegJmUosFJVPw/zcVIU8Lm9VVwThRNAD8n473o3cdXZ9/u+73+JyOBE61wgIj+IyF7f9+U3EWmbzj+lG5Af+CTR/E+ABiJSLZ37NSZNLBE02dkSXPIU2HboIlyJQuJ5scDsRNuPBZYDVwDfAS+IyMu46kYv46qxFQG+E5H8Ads9j0vepgE9cT+Q0cAkEUnrd2oosFpVP05qoe/CugWwUkSG+i4ITorIAgloMyUumasGrEhiNyuBuinEcCXu7vjYlAIVl9TUTGo934/zryltH6Am8AYwzHfstcA4EemYynZVcVVGr8H9b2Jw1cIuCVjnUVyVrzdwP7S34O6wxrcjEl+SKSJVUzlePZJ/PyuLSNGUNvb970YBrwRe/KeXiNwLfIOrEtgb9z58i3tf8H32JuH+5mG4z+YU3Gf1+SR2+SbubvrNuM+v33m49+9N3Hs43bf/YP7HNXDVlU9731T1GK56ZkqfQ4A2uKp/1/sugk+JyFoRCUkiDSAifXFVrf/Eff4G4v7OmYn+p9WBr4AbgctxNwA+EJE7Eu1vjATXviqlz1Nq74v/ptFw4JEgbtgEqx0u0X8U95mqAXwNfAocxNVGGAU8APQN2G44cC3wNNAFuANX/a9EwDqfAIOAz4AewIvAbb59B/5dv4rIupSCzOD5LXA/eUQkn7h2mW/5Zn8QzLbJuBn3+3IXrgpkW+Aj3PdyGXAV8CPwkvhuRPp8jKuK+TDu/bsP2ERC9edQnscyzJeA9iINN4XCrCPuM/k07sbTsoBlaf5dF1fd+gfgP9/yS3HnzSL+nYpIY2Au7n/QB/e/3Q38HJhUSsKNtuhU/oZ6uBsRiX8b/DdZg/lMl/VdE5wSkb9F5FERiQhiO2MSeF0kaZNNGZmA74FffM/z4KrtDcPd5S3qmz8Odyfev000rorK4IB5eXEX2CeBagHzL/Wt2973+mzgGDAmURw3+da7NA2xt8H9ENRNFFdg1bFzfPMO4C60rsC16/gFdye0qW+9Cr717kjiOJ8A/6QQx0+4EqG8qcQ70nfM0kksWwtMD+Jv/tUX54UB8yJwF/+zA+YNIYWqSr7/dV5gKvB9wPyJwDepxDAYVx2vSirr/Q2MS2L+7b6/oVIq2w/yvS8Ffa/HkM6qPLg2nQdT+ttw7fHOqHqFu9A97v+/AR18632bzP8nDmiYnv8x0Mq374uTWDYniO1X+z7rO3EXWxcB7/r22T8d71vVwPfE91nbju+cEbBeG99696XyeXsf+CPRsg+BU0HEcgJ4KYn5zwW5/Qe4m1kS8L9Kd9VQYB3ufFk8YN59vvfhg0TrLgl8z3AJ2Wsp7Lutbz+9Es2/0Te/YcC86cDaVGJN9/kt0bpf+fajvs9Bmwy8f4o7R+QNmPeab/6ggHn+35bRAfMOJfdZ8y0P2XksyL8l2aqhQD5ccvJcwLygq4YGbBOSqqG+z+0R4JxE86NJ/+/61b7XZ6Vw3Om4m0f5A+ZF+OZ9FzCvve//0iuVv2MUsC2F9+nmVLYfgLv5cBHumuB93Ln7g5S2s8mmxJOVCJrs7hegpa+6UUPcHemhuAtff5WNDrhOGhKb7H+iqqdwF7p/q6uu5efvHbOS7/FCoABnVucYhzv5tw8maN+dyJHAcFVdlcKq/u9oPqC7qn6rrhF5T1xp6MP+Xfr/lKQOl0IcFYDOwKe+9yC59QrgSgAmququxMtVtaaqdkrh7wi0UVXnB2wbC3wJNE+pRFVcz38TRWQ77r0+ibubfn7AaouA7iLyvLieK/Mn3o+qPqOqeVV1fSpxCml8PwNirYnrAOAedaVhGdUKKIq7eEhOO9yFQOKqW5/gqiAl7gzi22T2s05VlyaeGeT/OF2fwwB5cKXT/VT1fVWdoap34ko2HxORYPaRkvNxbXNOK5VS1TnAegK+v+KqSH4uIptxn7WTuJsA5yfa9jZVDbbjtfR+ntriSmTuVNVgSh+DNU9ddWc///nup0TrrSbhHAjuexYtIo+Lq6KfuBTiYlzi+7WvmmNecVVLp/qWt/OvqKqdVPWMnpITyejnyu8RoDmuNGcFrkZB0zRsn9i0ROfNM96/gN+WxO/fwyLSX0QaJPG5Dtl5LPD9l4DqvWnwKK4Ts6RqFXhlvqom1/lWen7Xl+K+3+NE5GrxVdH185VIt8f9TsUFvJcC/Mzpn+eZvv/LR6n8Den+ffEdZ4Sqvuk7R/6oqn2A14HbRKRWMPswBqxqqMn+ZuASs1a46iJ/qOp2XOlDRxGpB5TDJYyJ7U30+kQy8yChd05/1ZzTeuby/eDsDliemgG+dd8QkRLiepb0VwsqJiLFAmJUYJWqbgk43iFgHtAo0XpJHb8k7s5/Um7CnQdSrBaKa4NTIoj1grE9mXn5gTJJbSAilUioGnUv7v/dDJcgBLY5egF4CnfHdzbg72K+dDri3EPy7yec+VkJ9Abuszk/4P+b3/0pUkLSMJSCTynfY0o9lZ4N7FHV44nmbwtYHii53uUy0uuc/3OW1s+h327f47RE86fivsflyZgkv78+2/zLfVVEp+F6SByIu6nUDPgf7nyTHntJ/n1J6bME7qbRh8CmgM9TXiDC9zojMQU6kcL8wO/Zvb6YbsUlLTtEZLi4nlHBJdv5cSVfJwMmf0+npUib9J7fTqOq/6rqIlX9BrjEF09QwyCkEFegYN+/63BVER/BVWvcLCKDA26EheQ85qs2Gvj+n0xLVVJfFdoncJ2EFQj47BHw2ouqiCmdo9L8u66u6n433G/hx8A2X/ML/42hs3Glf0+S6P0E7gFKpnQTMxl7fNslTvxKBixPK/9NwIzc3DC5jA0fYbK75cAuXPWIRiSU/M3AlWBtxJ30fwvR8fwn53NIqMuP7+5gKRIuZFNT17ePzUksWwL8gas+dVRE/iX5O4dxAKp6xNfOpl4yx5qZTBy9cMnzH6nE2xv3PgfTpXVqyiUz7wSuSmBSLsb12HmtBgzbEHDhCYC6DkpeBl4WkXNw1SVfwyXZqQ5dkMhKoGsS8+sCG3zJeHLqAlVI+gJ/L+7O7YA0xOIvhT2XpNtJgS9xFZH8qnoiYP45vsfEn83kSpYyUuL0D640/rTPoa/EvjrujnpKVuJK3RPzXyxltOOJwO9vYufg2p2CKz2tArT1lRa6INJXouK3kuS/nynVCgCo45vuSGLZXlx7shEZiC1NfJ/9x3CltFVwVetewn2HH8V91o6RUCsjsS3JzE/ueOk9v6W0zxMisgxXkyRTqeoOXAdSd4vI+bjz69O489+7ITyPbcHdwEg8L1jVcclS4how4Do4ewj3u7s0DfsMhVCWirsduk7BfvHdVGkNPINr918VV/smDngb1wY0qe3Tem5aibupVIPT2wn62wamdk5ISkol58YkyUoETbbmqyY1E1dFsC2nJ4KNcG3qFqjqkRAdcj7uQvf6RPOvw91YCfaC5CVcCWbg9LJv2U24Kmh+3wL1RaSif4avxLAl7m683w+43tOKB6zXBndBe8a4f74qUfVIvZOYcriE6DM9vSfI9KokIvEX+747ytcAC1P4MfUnfPHHF5HzcD/YSVLVbar6Aa7qTv10xPkDcG7AXWHE9Qzbk9THUbyeM/+/P+ESuo4kdFQRrLm40pW+KawzE3dOvybR/BtxF+jzz9gixHwJ6BTg2kRJ09W4i57U3jd/ddVuieZ3w7WvzOhYjH/hSp9P+/6KSCvc98T//U3q81aS9PVO6fcDcKGvYwr/PqviPsOpvS+JP0sdcTeLVvief5WBuDJEVder6jDcTTn/98xfUl9cVWOSmNKUCPqk6fyWGt9NpKZ4PMakqv6lqo/jEvozzlMZOY+p6okk3vsTqW8ZbylJf/bAJYcdObOzk2xNVY+r6gxcE5MiuLaFh3ElsxcAS5L6TKfjUFNw5+UbE82/CViRqCprsG7AJYGLUlvRGD8rETQ5wQzcnbrAnkGX4Dqd6Ii7sxcSqrpHRF7D3Qk/jCshq4OrXjQH12tjMPtZTUI7BSD+ohBc4hr44/oqrne6H0XkGdyPx0O4i9WXAtZ7Bfcj8oOIvIgrQRsKLCTp9mC9cG3tPksl3Btx54pkE0YRWQusD7Kd4HbgCxF5CncH/E5cT5V3prDNz75YPxKRYbgqgk/juo6Pv6ElIt/jLpCX4C6sGuFKE0cGrDMY19FCjVTa1/yAq377iYg8TMKA8oJ7X+OJyClgrKreBhDYBjJgnWjguKr+msIxk6SqB8V1g/6miAT26tgQOKaqb+LaxswB3hORMrg7zt1xNxVeTKptZ1qk4X88BPe+jReRt3EdtrwCfKUBQ6CISC9cVctOqupPwH7EVeMe6asG9y8uieyK6zkxQ1Q11vf/Hykin+AuZs/FtX9aA4z2rToXd/542/c5LYLr/GcX7nsVT0Q+BHoH0U7wfVw1su9FZBDugu1ZXK2FwM9nFVxy8oyqPuOL+9fEOxORfbiOSs5YFm4iMg/3/ViOu0HRHneRPBZcvCLyOfCV73y5EFeiUhX3mXxUVf/27Ws6rsOT1NoJBnV+8924mQ7c6m+nJSIjcaXBMbj/YRXc/6I87tyaaXyJ7M+47/Bq3M2Gy3BVAqf61gnleSy5OArj/hcAtX3zrva9XudLcPbhOiVKvC24c8GvAfPO+Nz65rfHVfn3l8I3FZFDAKrq2Q2MQOJ6Am6HO/9sBErjzvVbSKiB8QAwC/jJ953f6luvMRChqgN9+zrj85cUVd0hIsNx1xIHcf/r63C1m0674ZT4O+J7rz/G9U2wFneT7QpchzkjVdXTmxsme7FE0OQE/vZ/Map6AFw1DRGZhWtjkVT7wIx4ApfA3IHrTns3rrrIY+moHpIqVd0uIu1wvaGOxiU+83A9nq0MWG+zuCEYXsN1AX8C16vqg4njEje0wf8BU3xtKlPSG3eHckkK6+TFtaEIxlrcBdwLQC1cL3D/pwHj9SWmqitF5EZcUv8D7oJjIO7iqEPAqrNwJWJ34xLlDb5jBXZ0kMcXa4qN8n2foShcIv4OroRjHtBRVTcmWj2C4P/+dFHVt0RkG66DoE9xF5B/4pIJf7w9cO/ro7iqyutwFzAjQhBCUP9jVV0qIt1wJdyTgP2478fjiVY94/+gqioil+OGGngad3G8GrhRVVO7YREUVR0lIkdw7+P3uETmR9ywDP4L1J0icgXuO/cV7oLwdVxboacS7TKo/72qHhY35Mtw3EWc4C4YBySqZiy+/WXlGjuzcFXvB+I+F/8C96vqGwHr3IRrS3gr7px5HPd59PdS7BdBENciaTi/JfX+LcDdEOmLS+o3++bdpqrLg/qLQ+cY7qK/Dy4hjcOVVN+oqt/71gnZeSwFZTmzqrb/9VhOH1ImGMl9bp/m9E7U7iZhXNWMdv4UKn/g2oy+iHtf9uBuqt2oqkcBVHWJiDTDff/fwN2I2In7XwaOe5qW7+8TuPNPf1yi/Beu+cOEROsl/o4c9MX4KK5ZheJ+C+7D/VYZEzR/N9TGGGOMMcYYY3KJrHzH0RhjjDHGGGNMGFjVUGNCzNeNdEo3WVTd2HnGGGOMMcZ4wkoEjQm9/3HmWEOB03TvQjPGGGOMMcbaCBoTcr7eP1Ma+Pegqv6VSeEYY4wxxhhzBksEjTHGGGOMMSaXybFtBEuXLq1Vq1b1OgxjjDHGGGOM8cTixYt3qWqZpJbl2ESwatWqxMTEeB2GMcYYY4wxxnhCRNYnt8w6izHGGGOMMcaYXCZTE0ERKS8iY0Vkp4gcE5FVItI+hfU7iMj3IrJVRI6IyDIRuTUzYzbGGGOMMcaYnCbTqoaKSAngN2AO0APYCVQHdqSwWStgOTAU2Ap0A0aJyDFV/SysARtjjDHGGGNMDpWZbQQfAbaqaq+Aef+ltIGqvpBo1rsi0hG4CrBE0BhjjDHGmCzm5MmTbNq0iWPHjnkdSq5RsGBBKlasSL58+YLeJjMTwcuBKSLyBdAR2AJ8ALytaRvD4ixgU+jDM8YYY4wxxmTUpk2bKFasGFWrVkVEvA4nx1NVdu/ezaZNm6hWrVrQ22VmG8HqwF3Av7gqnq8DLwF3B7sDEYkCOgGjklneV0RiRCRm586dGY/YGGOMMcYYkybHjh2jVKlSlgRmEhGhVKlSaS6BzcxEMA+wRFUfU9XfVXU08AZBJoIi0hpXHfQ+VV2Y1DqqOkpVm6pq0zJlkhwuwxhjjDHGGBNmlgRmrvS835mZCG4FViWa9ydQObUNRaQNMBkYrKrvhiE2Y4wxxhhjTA61bt066tev73UYLF26lB9//DH+9Q8//MBLL73kSSyZmQj+BpyfaN55QLKDHAKISDtcEvi0qo4IT2jGmAyJi4M0NfU1xhhjjMneTp06leZtEieCl156KQMHDgxlWEHLzERwOHChiDwhIjVF5BrgPuBt/woi8qKITA943QGXBL4HfCoi5/gmq/dpTFagCu+8A2efDSVLwoUXQnQ0vPQSfPcdrF4NJ096HaUxxhhjcpnXXnuN+vXrU79+fUaMGAG4xK13795ERkZy9dVXc+TIEQAGDhxI3bp1iYyM5KGHHgJg586dXHXVVTRr1oxmzZrx22+/ATBkyBD69u1L165d6dWrFy1atGDlypXxx+3QoQOLFy9m4cKFtGrVikaNGtGqVSv++usvTpw4weDBg/niiy9o2LAhX3zxBWPGjOGee+4BYP369XTq1InIyEg6derEhg0bAIiOjua+++6jVatWVK9ena+++io0b5KqZtqEGz/wD+AY8DcuEZSA5WOAdYleaxLTutSO1aRJEzXGhNG2bao9eqi6dDD5KSJC9bzzVC+/XHXUKNVdu7yO3BhjjDFhtGrVqvjnyVzLZ3hKSUxMjNavX18PHTqkBw8e1Lp16+qSJUsU0Dlz5qiq6i233KKvvPKK7t69W8877zyNi4tTVdW9e/eqqur//d//6ezZs1VVdf369Vq7dm1VVX3qqae0cePGeuTIEVVVfe2113Tw4MGqqrplyxatVauWqqru379fT548qaqq06ZN0yuvvFJVVUePHq133313fKyBr6OionTMmDGqqvrhhx/qZZddpqqqvXv31quvvlpjY2N15cqVWqNGjVTf94D3P0aTyZcyc/gIVHUSMCmF5dFJvI5Oal1jjIcmTYJbboGdO11J4MiR0L69KwFMPK1bB3//7abvvoO77oJu3eD66+Gyy6BYMa//GmOMMcbkIHPmzOGKK66gSJEiAFx55ZXMnj2bSpUq0bp1awBuuukm3njjDQYMGEDBggW5/fbb6dGjB1FRUQD8/PPPrFqV0L3JgQMHOHjwIOCqcxYqVAiAa6+9li5duvD0008zfvx4rrnmGgD2799P7969WbNmDSLCySBqSM2bN49vvvkGgJtvvplHHnkkftnll19Onjx5qFu3Ltu3b8/oWwRk7jiCxpjs7sgRePhhVx0U4KKLYOxYqFjRvS5bFtq1O32bo0dhzRpYtAi++AKmT3eJ5KRJULAgREW5pLB7d/CdVI0xxhiTM6gHfQgkd8zEPWuKCHnz5mXhwoVMnz6dcePG8dZbbzFjxgzi4uKYN29efMIXyJ9gApx77rmUKlWKZcuW8cUXXzBy5EgAnnzySTp27Mi3337LunXr6NChQ5r/jsB4CxQokOrfl1aZ2UbQGJOd/f47NGniksB8+eCVV2DatIQkMDmFCkFkJNx2G0ydClu3wttvQ5s2cOwYfPUVXH01lCsHt98OBw5kzt9jjDHGmBypXbt2fPfddxw5coTDhw/z7bff0rZtWzZs2MC8efMA+Pzzz2nTpg2HDh1i//79dO/enREjRrB06VIAunbtyltvvRW/T//8pFx//fUMHTqU/fv306BBA8CVCJ577rkAjBkzJn7dYsWKxZcsJtaqVSvGjRsHwKeffkqbNm3S+xYExRJBY0zK4uJg6FBo0cJV9axTBxYsgIcegjzpOIWULeuqh86eDRs2wKuvugTz4EH48EO3zBhjjDEmnRo3bkx0dDTNmzenRYsW3H777ZQsWZI6deowduxYIiMj2bNnD3feeScHDx4kKiqKyMhI2rdvz/DhwwF44403iImJITIykrp16/Lee+8le7yrr76acePGce2118bPe+SRR3jsscdo3bo1sbGx8fM7duzIqlWr4juLCfTGG28wevRoIiMj+fjjj3n99ddD/M6cTrwors0MTZs21ZiYGK/DMCZ7i42FSy8FfzfHd9/tksLChUN/rCVLoG1bV/103Di47rrQH8MYY4wxYffnn39Sp04dr8PIdZJ630Vksao2TWp9KxE0xiRv7lyXBJYsCRMnwltvhScJBGjcGF57zT2/4w7YtCk8xzHGGGOMMZYIGmNS8MMP7vGWW6BHj/Afr29f13nMvn1uPMK4uPAf0xhjjDEmF7JE0BiTvAkT3OOll2bO8UTggw+gTBnXu+gbb2TOcY0xxhhjchlLBI0xSfvrLzeVLAm+MXcyRblyLhkEGDgQVqzIvGMbY4wxxuQSlggaY5LmLw3s3h3yZvKQo5de6oaSOH4cbrrJPRpjjDHGmJCxRNAYkzR/+8DMqhaa2PDhUKMG/PEHDB7sTQzGGGOMMTmUJYLGmDPt3g2//eYGju/WzZsYihaFjz92YxW+8grMnOlNHMYYY4zJtapWrcquXbsyvE5WZImgMeZMP/7oeuxs3x6KF/cujpYt4YknQBV69YL9+72LxRhjjDEmB7FE0BhzJq+rhQZ68klo1gw2bIB77/U6GmOMMcZkcevWraN27drcfvvt1K9fnxtvvJGff/6Z1q1bU6tWLRYuXMiePXu4/PLLiYyM5MILL2TZsmUA7N69m65du9KoUSP69euHqsbv95NPPqF58+Y0bNiQfv36ERsb69WfGBKWCBpjTnf8OEyZ4p737OltLOCqp378MRQq5B6//NLriIwxxhgTLJHwTKlYu3Yt/fv3Z9myZaxevZrPPvuMOXPm8Oqrr/LCCy/w1FNP0ahRI5YtW8YLL7xAr169AHj66adp06YNv//+O5deeikbNmwA4M8//+SLL77gt99+Y+nSpURERPDpp5+G9a0Lt0zuCtAYk+X9+iscOgSRkVC1qtfROOefD8OGwV13Qb9+0LWrt1VWjTHGGJOlVatWjQYNGgBQr149OnXqhIjQoEED1q1bx/r16/n6668BuOiii9i9ezf79+9n1qxZfPPNNwD06NGDkiVLAjB9+nQWL15Ms2bNADh69Chly5b14C8LHUsEjTGny+xB5IN1xx0wdiwsWAA//wxXXeV1RMYYY4xJTUDVysxUoECB+Od58uSJf50nTx5OnTpF3iSGxhJfSaMkUeKoqvTu3ZsXX3wxTBFnPqsaaoxJoJrQPjArVAsNJJKQnP70k7exGGOMMSZba9euXXzVzl9//ZXSpUtz1llnnTZ/8uTJ7N27F4BOnTrx1VdfsWPHDgD27NnD+vXrvQk+RCwRNMYk+OMP2LgRzjkHmjb1Opoz+YeymDrVszuMxhhjjMn+hgwZQkxMDJGRkQwcOJCxY8cC8NRTTzFr1iwaN27M1KlTqVy5MgB169blueeeo2vXrkRGRtKlSxe2bt3q5Z+QYaI59GKqadOmGhMT43UYxmQvzzwDTz0FffrAqFFeR3OmuDgoVw527YLVq13bQWOMMcZkKX/++Sd16tTxOoxcJ6n3XUQWq2qSd/etRNAYkyCrtg/0y5MHunRxz6dO9TYWY4wxxphszBJBY4yzeTPExLhhGjp18jqa5HXt6h6tnaAxxhhjTLplaiIoIuVFZKyI7BSRYyKySkTap7JNAxGZKSJHRWSziAyWpLryMcZkzMSJ7rFLF5cMZlX+RPCXX9yYh8YYY4wxJs0yLREUkRLAb4AAPYA6wL3AjhS2OQuYBmwHmgH3AQ8DD4Q5XGNyH39voVm1WqhfhQpQvz4cOQJz53odjTHGGGOSkFP7Icmq0vN+Z2aJ4CPAVlXtpaoLVfU/VZ2uqn+msM2NQGGgt6quUNWvgZeBB6xU0JgQOnwYpk93QzRERXkdTeoCew81xhhjTJZSsGBBdu/ebclgJlFVdu/eTcGCBdO0XWYOKH85MEVEvgA6AluAD4C3NflPSUtgtqoeDZj3E/AsUBX4L2zRGpObTJvmqlm2aOF65czqunaFYcNcO8EcNLCrMcYYkxNUrFiRTZs2sXPnTq9DyTUKFixIxYoV07RNZiaC1YG7gOHAS0BD4E3fsreS2eYcYFOiedsDlp2WCIpIX6AvED/mhzEmCNmlWqhf27ZQsCD8/jvs2AFly3odkTHGGGN88uXLR7Vq1bwOw6QiM6uG5gGWqOpjqvq7qo4G3gDuTmW7xKWFksx8VHWUqjZV1aZlypTJeMTG5AaxsQkdxWSXRLBQIWjXzj2fNs3bWIwxxhhjsqHMTAS3AqsSzfsTSKnobhuu5C+Q/9b/dowxGbdgAezcCdWqQb16XkcTPGsnaIwxxhiTbpmZCP4GnJ9o3nnA+hS2mQe0FZHAlo9dcO0L14U0OmNyK/8g8j17us5isgv/MBJTp4I1RjfGGGOMSZPMTASHAxeKyBMiUlNErsENB/G2fwUReVFEpgds8xlwBBgjIvVF5EpgIPBaCh3MGGPSIru1D/SrV88NJbFtGyxf7nU0xhhjjDHZSqYlgqq6CNdz6LXACuB54EngnYDVygM1ArbZjysBrADE4JLGYcBrmRK0MTnd2rWwahUUL57Q5i67EDm9VNAYY4wxxgQtM0sEUdVJqnqBqhZU1fNU9Y3Akj1VjVbVqom2Wa6q7XzblFfVp6000JgQ8VcLveQSyJfP21jSw58I/vSTt3EYY4wxxmQzmZoIGmOyGH8imN2qhfp16eJKBmfPhiNHvI7GGGOMMSbbsETQmNxq716YNQsiIuDii72OJn1Kl4bGjeH4cfe3GGOMMcaYoFgiaExu9dNPbgzBtm2hZEmvo0k/G0bCGGOMMSbNLBE0JrfyVwuNivI2joyydoLGGGOMMWlmiaAxudGpUzB5snves6e3sWRUy5ZQtKjr/XTTJq+jMcYYY4zJFiwRNCY3mjvXtRE87zw3ZWf580PHju65VQ81xhhjjAmKJYLG5EY5pVqon7UTNMYYY4xJE0sEjcmNJk50j9m9Wqifv53gtGmuAxxjjDHGGJMiSwSNyW3WroXVq6F4cWjd2utoQqNmTahWDfbsgSVLvI7GGGOMMSbLs0TQmNzGXxp4ySWQL5+3sYSKiPUeaowxxhgT6OjRFBdbImhMbuNvH5hTqoX6WTtBY4wxxpgE77yT4mJLBI3JTfbvh1mzICICLr7Y62hCq2NH93fNmwcHDngdjTHGGGOMt+bOTXGxJYLG5CY//eTGEGzdGs4+2+toQqtECWjRwv19v/zidTTGGGOMMd5RtUTQGBMgpw0bkZhVDzXGGGOMgXXrYNu2FFcJOhEUkYIicrWIPCoiJXzzaohIDitWMCaHio2FH390z3Na+0A/f4cxP/4IcXHexmKMMcYY45VUSgMhyERQRGoCfwLvAc8D/uTvTmBoOsMzxmSmefPc8Ao1a8L553sdTXg0awaVKrm7YF9/7XU0xhhjjDHeCFUiCIwApgHlgMB+SH8AOqY1LmOMB/zDRkRFueEWcqKICHj8cff86aetVNAYY4wxuVMIE8FWwKuqGpto/gagQhrDMsZ4IacOG5HYLbe4UsGVK61U0BhjjDG5z8GDsGyZu0GegrR0FpPUyNOVgf1picsY44F//4VVq+Css6BtW6+jCa8CBeCJJ9xzKxU0xhhjTG6zcKG7/mnUKMXVgk0EpwIPBLxWETkLeBqYlL4IjTGZxl8t9OKLIV9S93RyGCsVNMYYY0xuNW+ee2zVKsXVgk0EHwTaiMhfQEHgC2AdcA4wMJgdiMgQEdFEU4p9mopINxGZJyIHRWSXiHwvIucFGbMxxi+3VAv1y5/fSgWNMcYYkzv52weGIhFU1c1AQ+BlYCQQAzwCNFbVnWkI6y+gfMDUILkVRaQa8D0wG2gEdAYKAT+m4XjGmAMHYOZMyJMHLrnE62gyT2Cp4FdfeR2NMcYYY0z4xcWFrkRQRPL5Su6qq+r/VPUeVb1LVT9Q1aOpbZ/IKVXdFjCllEQ2wbVLfExV16rqUuBFoIaIlE7jcY3JvaZOhZMn3cmgVCmvo8k8VipojDHGmNxm9WrYtw8qVnQ3xFOQaiKoqieBk4CGILTqIrJZRP4TkXEiUj2FdWN8x71dRCJEpBjQG1ikqrtCEIsxuUNuqxYa6JZboHJl11GOlQoaY4wxJqcLslooBN9G8E3gMRHJm+6gYAEQDVwC9MG1L5wrIkkWUajqOqALrkOa47jeSRsAUckdQET6ikiMiMTs3JmWGqvG5FCxsfCjrzZ1VLJfnZzLSgWNMcYYk5ukIREU1dQL+kRkAtAeN5j8CuBw4HJVvTStMYpIUeBf4CVVfS2J5ecAs4DvgM+BYsAzvsUXqWqKV3RNmzbVmJiYtIZlTM4ydy60bg3Vq8PatTl3IPmUnDgBtWrBhg3wxRdw7bVeR2SMMcYYEx61a8Nff8GCBdC8OSKyWFWbJrVqsCWCu4CvcR21bAB2J5rSTFUPASuBWsmscjdwWFUfUdXfVXUWcBMuIU09xTXGJAwbERWVO5NAOLNUMDbW23iMMcYYY8Jh1y6XBBYsCA0bprp6UFU9VfWWjMaVmIgUBGoDvySzSmEg8RWb/3WwCawxuVtubh8YKDoaXnghoa3gddd5HZExxhhjTGjNn+8emzVzN8JTkWkJlYi8KiLtRaSaiLQAvgKKAGN9y18UkekBm0wCGovIUyJSS0QaA6OBjcDizIrbmGxr3TpYsQKKFYN27byOxluBpYLPPGOlgsYYY4zJeYIcNsIvqERQRJaLyLLkpiBDq4hr6/cX8A2uA5gLVXW9b3l5oIZ/ZVWdAdwAXAb8DvyE60X0YlU9rY2iMSYJ/mqh3boFdVcox+vdG6pUsR5EjTHGGJMzpaGjGAiyaiiu9C5QPtwA862Bt4PZgapen8ry6CTmjQPGBRWhMeZ0kya5x9zYW2hS/KWCffu6UsGrr4aICK+jMsYYY4zJuJMnYeFC97xly6A2CbaN4NNJzReRh4EqwUVnjMk0R4/Cr7+655dc4mkoWUrv3vD889ZW0BhjjDE5y7JlcOSI6ym9TJmgNsloG8FvgBszuA9jTKjNng3HjkGjRlC2rNfRZB2BbQUffBC2b/c2HmOMMcaYUEhjtVDIeCLYDjiSwX0YY0Ltp5/cY7du3saRFUVHu7EVN2+G66+HU6e8jsgYY4wxJmPSkQgGVTVURH5IPAvXuUsjIMlqo8YYD1kimLx8+eDLL6FxY1d9duBAePVVr6MyxhhjjEk/fyIYZPtACL5EcA+nDyC/A/gZuERVn0lLjMaYMNu8GVauhCJF0nRXKFcpX94lg3nzwrBhMH681xEZY4wxxqTPpk2wYQOcdRbUrRv0ZsF2FhOd3riMMZls6lT32LGjDRuRkjZtXBLYvz/ceivUq+cmY4wxxpjsxD9+4IUXpqlH9GDHEZwhIiWSmH+WiMwI+mjGmPCzaqHBu/deuOEGOHwYrrwS9u/3OiJjjDHGmLRJ40DyfsFWDe0AJFW0UBBom6YjGmPCJzYWpk1zzy0RTJ0IjBoFDRrA33+7jmTi4ryOyhhjjDEmeOnoKAZSSQRFpLGINPa9jPS/9k3NgL7A5rRHa4wJi8WLYc8eqFYNatb0OprsoUgR+OYbKF4cvvsOXn7Z64iMMcYYY4Jz9CgsWeJubrdokaZNU2sjGAOob5qa1KGBe9N0RGNM+ARWCxXxNpbspGZN+OQT6NkTBg2CJk2ga1evozLGGGOMSdnixXDyJERGus5i0iC1qqHVgBq44SKa+177p3OBs1T1f2mP2BgTFtY+MP2iomDwYFc19P/+D9at8zoiY4wxxpiUpbNaKKRSIqiq631PMzrwvDEm3Pbvh/nz3ZAIF13kdTTZ01NPwaJFMHkyXHUVzJkDhQp5HZUxxhhjTNLSMX6gX1DDRwCISF5cqWBlEnUco6ofpfnIxpjQmjHDdRbTtm2aqwYYnzx5XBXRpk1dffuaNaFvX+jTBypU8Do6Y4wxxpgEqhkqEQx2+IjawJ/ALOBT4ANgDPA+8Faaj2qMCT2rFhoaZ58NP/wAderAli0wZAhUrgxXX+2SbVWvIzTGGGOMgX/+gZ07oUwZqFEjzZsHW+VzBLAYKA4cAeoATYGlwFVpPqoxJrRUExJB6+Qk4+rXh5UrYfp0lwACfP01dOrkEsTXX4d9+zwN0RhjjDG5XOD4genoJDDYRLAZ8JyqHgbigLyqugR4BBiW5qMaY0JrzRrXuUmpUtC4caqrmyCIuLaWX34JGzbA00+76qF//QUDBrjnffrA7t1eR2qMMcaY3CgD1UIh+ERQcCWBADtxPYYCbAJssDJjvOYvDezSBSIivI0lJ6pQwfUoum6dKxns3NmN2/PBB9CuHWy24VSNMcYYk8kyKRFcAVzge74QeFRE2gNPA2vTdWRjTOhY+8DMkS8fXHklTJsGf/4J9erBqlXQujX8/bfX0RljjDEmtzhwAJYvd9cmTZqkaxfBJoLP40oFAQYBlYBfgK7Afek6sjEmNI4fh19+cc+tfWDmqV0bZs2CCy+E9euhTRv4/XevozLGGGNMbrBggesjonHjdA91FWwiOBv4HkBV/1XVukBpoJyq/pquIxtjQuO33+DIEWjQwIY4yGxnnw0//+wS8J07oUMHmDnT66iMMcYYk9P9+qt7bN063btINREUkQhgP3B+4HxV3aNq/agb47mpU92jVQv1RpEiMGECXHutq6bRrZsbfsIYY4wxJlxmzHCPnTqlexepJoKqGgusJ9Eg8mklIkNERBNN21LZRkRkgIisFpHjIrJVRF7KSBzG5DjWPtB7+fPDZ59Bv36uqu6VV8JHH3kdlTHGGGNyogMHYNEi10Fg27bp3k3eINd7FnhJRG5S1V3pPhr8BXQIeB2byvrDgCjgYWA5bhzD8hk4vjE5y/btsHSpqxvepo3X0eRuERHw7rtuUNfnnoPevd3QEvff73VkxhhjjMlJZs2C2Fho2RKKFUv3boJNBB8CqgGbRWQTcDhwoapGBrmfU6qaYimgn4icD9wLRKrqnwGLrDcGY/z81ULbt4eCBb2NxbixB5991o3neP/98MADLhl89tl0DfRqjDHGGHMGf7XQiy7K0G6CTQS/ytBRElQXkc3ACWAB8Liq/pvMupcB/wIXi8gkXDXWmcDDqrojRPEYk71ZtdCsacAA15HMrbfC88/Dli0wcqTr4tkYY4wxJiNC0D4QQDKrvxcRuQQoBqwGyuKGoagN1FPV3Ums/x4QDfyBqxqqwKu+xS1VNS6JbfoCfQEqV67cZP369aH/Q4zJKuLi4JxzXG+Vq1ZBnTpeR2QSmzjRdSJz9KhL1r/8MkNVOIwxxhiTy+3a5ZqhFCgA+/alWiNMRBaratOklgU7fAQiUlBErhaRR0WkhG9eDRE5O5jtVXWyqo5X1WWq+jOu7V8eoHcym+QBCgA3q+osVZ0N3Aw0B5olc4xRqtpUVZuWKVMm2D/NmOxp6VKXBFaq5Ma0M1lPVJTr3rlMGVd62749bN3qdVTGGGOMya4Ch43IYLOgoBJBEamJK8l7Dze4vD/5uxMYmp4Dq+ohYCVQK5lVtuLaFP4dMG8NcAqonJ5jGpOjBA4bYe3Psq7mzWHuXKhZ0w0437Il/Pln6tsZY4wxxiQ2fbp7zGD7QAi+RHAEMBUoBxwNmP8D0DE9BxaRgriqocndHv8NyCsiNQLmVce1a7Q6n8ZY+8Dso2ZNlww2bw7r17u7eHPmeB2VMcYYY7KbEHUUA8Engq2AV31jCgbaAFQIZgci8qqItBeRaiLSAtcBTRFgrG/5iyIyPWCTn4ElwP9EpJGINAL+h+tkJibIuI3JmQ4dgt9+gzx5MtxQ2GSSMmXgl1+gZ0/Yuxc6d4avv/Y6KmOMMcZkF5s2wd9/u/4GmiXZUi5Ngm4jCCTV3V1lYH+Q21cEPseNJfgNcBy4UFX9pXvlgfjSP19nMFHADmAW8BOwCbgsqY5ijMlVfvkFTp6EFi2gZEmvozHBKlwYvvkG7rzTDTx/zTXw+uteR2WMMcaY7OCXX9xju3aQN9jBH5IX7B6mAg8At/leq4icBTwNTApmB6p6fSrLo5OYtxW4JsgYjck9/NVCu3b1Ng6TdnnzwttvQ+XK8NhjbqiJdevglVdCclI3xhhjTA4VwmqhEHyJ4ANAGxH5CygIfAGsA84BBoYkEmNM8Kx9YPYmAgMHwscfu7EFR4xwVXytR1FjjDHGJEU1pB3FQJCJoKpuARoCLwMjcW30HgEaq+rOkERijAnOv//C2rVQokRI6ocbD910kzuply8Ps2ZBo0Ywc6bXURljjDEmq/nnH9i4EUqVgsjIkOwy6DaCqnpUVf+nqveo6l2q+oGqHk19S2NMSPlLAzt3tqqEOUHbtrBkCXToANu3u7t8L78McdYU2hhjjDE+/mqhHTu6zgJDIC0DyjcWkY9EJMY3fSwijUMShTEmeFYtNOc55xyYNs21GYyLc9VGr7jC9S5qjDHGGBPi9oEQ/IDyNwKLcD17/uibygELReSmkEVjjEnZyZMJJwJLBHOWvHnhhRdgwgRX7feHH6BJE1daaIwxxpjcS9W7RBB4HnhSVbuo6mDf1BV4EnguZNEYY1I2bx4cPAh16kClSl5HY8IhKsolf40bw3//QatW8P777kfAGGOMMbnPihWwcydUqADnnRey3QabCJYBxicx/0ugbMiiMcakzF8t9OKLvY3DhFe1avDbb9CvnxtvsG9fV13UGGOMMbmPvzSwUyfX83iIBJsI/gJ0SGJ+B8C6uDMms0yZ4h6tWmjOV7AgvPcefPSRqzY6bJjrLdYYY4wxuUsYqoVC8IngZOBFEXlPRKJ903vAC8AEEbnSP4U0OmNMgh07XJXBggWhXTuvozGZ5eaboVcviI11bQiNMcYYk3ucOgW//uqed+wY0l2LBtHuRESC7cdcVTUiYyGFRtOmTTUmJsbrMIwJnU8/dePOde2aUEXU5A7//APnn++er1njqo4aY4wxJudbuBBatIAaNdJVM0hEFqtq06SWBTugfJ4gpyyRBBqTI9mwEblXjRpw442uVPDFF72OxhhjjDGZJbB9YIiFZjRCY0x4xcXB1KnuuSWCudPjj7sBZMeMgfXrvY7GGGOMMZkhTO0DAfIGu6KINAI64noJPS2BVNVHQhyXMSbQsmWwfTucey7Uret1NMYL558P118Pn30GL70E777rdUTGGGOMCafjx2HOHPe8Q4eQ7z7YAeUfARYD9+J6Cm0bMLUJeVTGmNMFVgsNYbfBJpsZNMj9/z/8EDZu9DoaY4wxxoTTggVw9CjUrw/lyoV898FWDb0fuFNVq6nqharaMmBqFfKojDGns/aBBqBOHbj2Wjh5EoYO9ToaY4wxxoTT9OnuMQzVQiH4RDAPMD0sERhjUnbokKsWkCcPdO7sdTTGa4MGucf334ctW7yNxRhjjDHhE8aOYiD4RPBd4JawRGCMSdmvv7oSoGbN4OyzvY7GeK1+fbjqKtduwEoFjTHGmJzp8GGYP98VBIRp/OhgE8GngcYislREPhaR/wVOYYnMGONYtVCTmL9UcORI2LbN21iMMcYYE3pz5rjB5Js0gRIlwnKIYBPB54GuwEmgJFAm0WSMCRdLBE1iDRvCZZfBsWPw6qteR2OMMcaYUAvjsBF+oqqprySyD+inql+ELZIQa9q0qcbExHgdhjEZ899/UL06FC8Ou3ZB3qBHfDE53ZIl7i5h4cLuc1K2rNcRGWOMMSZUmjaFxYvdONJduqR7NyKyWFWbJrUs2BLBo8Dv6Y7ABTFERDTRFFSdJhGpJSIHReRQRmIwJtvxlwZ27mxJoDld48YQFQVHjsBrr3kdjTHGGGNCZc8ed8M3Xz5o3Tpshwk2ERwODBDJ8ABmfwHlA6YGqW0gIvmBccCsDB7bmOzHqoWalDz5pHt86y1XYmyMMcaY7O/DD0HVDSJfuHDYDhNsItgWuBFYJyKTReSHwCkNxzulqtsCpp1BbPMysAz4Mg3HMSb7O3kyYfwYSwRNUpo3h4svdj2LDR/udTTGGGOMyagTJ+D1193zAQPCeqhgE8FdwDfADGAbsDvRFKzqIrJZRP4TkXEiUj2llUWkBxAF3JeGYxiTM8yfDwcPQu3aULmy19GYrGrwYPf45puuKokxxhhjsq/x42HzZqhTx93sDaOgGh2paijGEFwARAOrgbLAIGCuiNRT1TOSSREpD7wPXKmqB4OplSoifYG+AJXtwtlkd1Yt1ASjZUvXiHzaNHjjDRgyxOuIjDHGGJMeqjBsmHv+4INuDMEwStPeRaSpiFwnIkV8r4uISLDJ5GRVHa+qy1T1Z1xJXx6gdzKbfAK8q6rzg41PVUepalNVbVqmjI1qYbK5KVPcoyWCJjWPP+4eR450VYqNMcYYk/3MmAFLl7qewG+8MeyHCyoRFJFyIrIAWAh8BpTzLXoNGJaeA6vqIWAlUCuZVS4CnhKRUyJyCvgQKOJ73Tc9xzQm29i50/UWVaAAtG/vdTQmq2vf3lUh2bYNfkhLs21jjDHGZBn+0sB774WCBcN+uLT0GroNKAUcCZj/JW6g+TQTkYJAbWBrMqs0ABoGTINxw1g0xDqOMTndtGmuekDbtmHtLcrkECJwxx3u+bvvehuLMcYYY9Ju5UqYPBkKFYI778yUQwabCHYCnlDVvYnm/wME1RhPRF4VkfYiUk1EWgBfAUWAsb7lL4rIdP/6qroicAI2A3G+14njMCZnsfaBJq169XI/HtOnw99/ex2NMcYYY9LCPyZwdDSUKpUphww2ESwEnEhifhngWJD7qAh8jhtL8BvgOHChqq73LS8P1AhyX8bkXKowdap7bomgCVaJEvB//+eejxrlaSjGGGOMSYNt2+CTT1wNn/vvz7TDBpsIzsL1+OmnIhIBPApMT3KLRFT1elWtoKr5VfVcVb1KVVcFLI9W1aopbD9GVYsGGa8x2deyZe6EUKEC1K/vdTQmO/FXDx09Go4e9TYWY4wxxgTnrbfc+IGXXQa1kus+JfSCTQQfAfqIyDSgAK6DmFVAa+CxMMVmTO70pa8J7CWXuDtDxgSraVNo3NiNJ/jVV15HY4wxxpjUHD6c0L7/oYcy9dBBJYK+krsGwFxgKlAQ12FLI1X9J3zhGZPLxMbC2LHu+c03exuLyX5EEhqYv/eet7EYY4wxJnVjxrgbuC1aQKtWmXpoUdXUVxKpDGzUJFYWkcqquiEcwWVE06ZNNSYmxuswjEmbn392g4NXrQr//BP2gURNDnToEJx7Lhw4AH/8AZGRXkdkjDHGmKTExsL557trvi+/hKuvDvkhRGSxqjZNalmwV5n/4TqGSbzjUr5lxphQ8JcG9u5tSaBJn6JFE0qTrVTQGGOMybq+/94lgdWqwRVXZPrhg73SFCCposOiBN9rqDEmJQcOwNdfu+e9enkbi8ne/J3GfPwxHDzobSzGGGOMSZp/APn774eIiEw/fIqJoIi8ISJv4JLAF/2vfdPbuLEAl2ZCnMbkfF9+6Xp6bN8eqlf3OhqTndWvD23auGqin3/udTTG7733XLXv33/3OhJjjDFemzcP5s51wz/dcosnIaRWItjANwlQJ+B1A6AmsITTh5UwxqTXmDHuMTrayyhMTuEvFXz3XTc2pfHWoUPw+OOwfr3r0CcuzuuIjDHGeMlfGnjnna5ZhweC7SxmNNBfVQ+EP6TQsM5iTLaydq0bN6ZwYTeGYLFiXkdksrtjx6BiRdi9G+bPd72RGe+MGHH6IMEffWQ9AxtjTG71zz/uui9vXli3zo0dHSYZ7ixGVW/JTkmgMdnORx+5x6uvtiTQhEbBgnDrre65dRrjrRMn4LXX3PPrrnOPjz7qSgmNMcbkPiNGuNo6N94Y1iQwNTm3W8LYWK8jMCY4cXEJvYVatVATSn37usdx42DvXm9jyc0+/xw2boQ6deDTT6F5c9i6FV580evIjDHGZLb33ksYQP6BBzwNJecmgn/84bLsn3+2pNBkbb/+Chs2QJUqrqMYY0KlZk03LuWxYwk3G0zmiouDoUPd80cecb3Cvf66ez1sGPz7r3exGWOMyTyxsTBggGsTGBsLgwdDgwaehpRzE0FV+OwzdxFUrRoMGgRr1ngdlTFnsrEDTTjdead7fO896zTGC5MmwapVrr3mDTe4eRde6NoHHj8ODz3kbXzGGGPC78ABuPRSdyMwXz7XQeDTT3sdVXCdxWRHTRs00Jirr3Zv9Lp1CQvatHHV7665Bs46y6PojPE5eBDOOQeOHHEdxtSo4XVEJqc5edINWbBlC/zyC3To4HVEuUubNvDbb670L7AK0JYtcN55cPiwq7nSqZN3MRpjjAmfdeugZ09YsQJKlYJvvoF27TLt8OnqLEZEGgc7hS/0DChQAJ56yvXK88svrrSlcGGYMwduvx3Kl3d3Z//3P1c1J4cmxCaL++orlwS2bWtJoAmPfPncOQ8S2iSYzDFnjksCS5SAPn1OX1ahAjzxhHs+YACcOpXZ0RljjAm3efNcu/AVK6B2bViwIFOTwNQkWyIoInG4geQllX2oqkaEOrCMSnL4iIMH4euvXSnhzJmnL6tY0bXP8k+1aoGk9qcbk0Ht28OsWfDhhwk9PBoTaps2uTaoefK45+XKeR1R7tCzJ0yc6BK+5547c/mxY1CvnrsZ+dZbcPfdmR+jMcaY8PjsM3dtd/y4a6o2fry7MZjJUioRTCkRrBLsAVR1fTpjC5tUxxH891+YMMElhLNmubG2ApUv7zL2tm3d+FuRkZA/f3iDNrnLv/+6UkAbO9Bkhssvh++/h/79XbfVJrxWrHCdABQs6AaRL1s26fW++w6uuAJKlnTt2EuVytQwjTHGhFhcHAwZAs8+617fdZdrG5g3ryfhpCsRzO7SNKB8XBysXOmSQv+0c+fp6xQoAI0aueLdFi3cY40aVmpo0m/IENdQ+OabE8YRNCZcfv8dmjVz57u5c12HJSZ8evd23+u77oK3305+PVV3p3j6dFci+NZbmRejMcaY0Nq3D267zbUDzJPHJYD33ONpSCFLBEWkAlAZOK1oTFVnZSjCMEhTIpiYKqxe7RLCefNcfd6//jpzvbPPdglh06bQpImbKla05NCkLi7O3UhYt846ijCZ57HH4KWXoG5dWLLE3eAyobdhg/t+x8W5Ur7q1VNef8UKuOAC93zpUs+7EzfGGJMOixbBddfBf/+5Dim/+AIuvtjrqDKeCPoSwM+AdiS0G4zfMNu0EcyIffsgJsYlhQsXusft289cr0wZaNw4ITFs3Ni1zbHk0AT69Vfo2BEqVXLJoA0bYTLD0aPQsCH8/Tc8+SQ884zXEeVMAwa4u8DXX+8Gkw/GPfe4ksOLLnI3h+w3wxhjsgdV1+Ti0UddT91NmrgkMIt0AhiKRHA8UAq4G1gEXAyUA54B7lfVaaELNzRCnggmpgobN7qkMCYGFi920969Z65bqpS72xsZmfBYt65rO2Jyp1tucZ0WDRqUUIfcmMwwe7Zr/5w3rztnRUZ6HVHOsns3VK7segNessQ1KQjGnj2uk7I9e+Dbb12bTmOMMVnb7t3umm7CBPe6f394+eUsVeMmFIngdqCHqsaIyAGgqar+LSI9gCdVNcs1Ngl7IpgUVdcpgD8p9E+JO6IBiIiA8893F2H+qX59dwFhd4JztkOH3NiBhw+7amM1a3odkclt7r4b3nnHVWufN8+zBuw50jPPuKGLunWDKVPStu3bb7uSwYoVYfBgN/iw9fBqjDFZ02+/wf/9nysYKlECRo/OkjfxQpEIHgAiVXWdiKwDblLVOSJSDVipqoWD2McQ4KlEs7er6jnJrN8BuB9oDhQH1gIjVPV/qQaMR4lgUvwlh3/8AcuWJUx//+3ajyRWtKgrLaxf33UrXq+ee16hgiWIOcXYsRAd7Qaanj3b62hMbnTggDuvbNwIr7wCDz3kdUQ5w5EjrinArl0wY4ar/p0Wp065zsiWLHGvRaB1a9er6BVXQLVqoY/ZGGNM2sTFwdChrlZXbKzrfG3cOHf+z4JCkQguBAar6hQR+Q44BDwB3Atcpqq1gtjHEOB6oEPA7FhV3ZnM+o8DhYHJwFagG/Am0EtVP0vteFkmEUzOkSOwatXpyeHKlbBjR9LrFy/uOhBo1sx1UNO8ubsosOQw++nY0bURfP/9hIG+jclsP/4IPXq4KurLl1vJdCi89Rbce687Ty9YkL7z84EDbqypb791bQVPnEhYdsEFCUlhgwZ2/jfGmMy2dau7mT91qnv9yCNunNh8+TwNKyWhSARvBPKp6hgRaQxMwbUZPA70VtUvg9jHEOBqVa2fluAT7WM8EKGqV6W2bpZPBJOzc6dLCP3TihXucc+eM9ctVSohKWze3F18lCmT+TGb4K1b5xL4QoXcyaR4ca8jMrnZzTfDJ59A+/auBMs6LUq/kyddG7/16+Grr+CqVH+mUnfgAEye7JLCSZNctXK/qlXhkkvcdNFFUKRIxo9njDEmaceOuQ5hnn/enYtLl3ZDBF1yideRpSrk4wiKSGGgNrBBVXcFuc0Q4BFgL3ACWAA8rqr/puG4U4BNqppqMUq2TQSToup6KF261HVN6++1NPFYh+C6Kb/wQmjZ0k2RkVn6LkWu428/dMMN8OmnXkdjcrtdu1xV9J07YeRI6NvX64iyL3+V71q14M8/XTvwUDp2zI01+O238MMPp5//8+d3HQD5E8Pata200BhjQkHVnXcfesgNCwHQsye8+y6ce663sQUpSwwoLyKXAMWA1UBZYBAumaynqkn0pnLG9lHAt0BrVV2YzDp9gb4AlStXbrJ+/foQRZ8FqbqxqhYuTJhiYlyV00CFCrmSwsDk0Dof8Iaqq37377+uSkGXLl5HZIzr4vr6692YRytXuo5KTNocOuQ6/9qyxfUG3Lt3eI8XG+vO95Mnu2nRInd+8ata1Y1d1aWLK+0tVSq88RhjTE60dCncf79rzgOu347hw7Pd9Vu6EkEReQN4TFUP+54nS1XvS0dQRYF/gZdU9bVU1m2Nayv4qKq+G8z+c1SJYLBOnXIXcvPmJUxr1py5Xq1a0Lmzmzp2hJIlMz/W3MjfbX/Fiq6KaKhLDIxJD1XXy9kPP0BUlHu00qS0efxxePFFd9Nt/vzMr2K7c6e7uTR5Mvz0kyvp9RNxNUM6doQOHdw5yM75xhiTvB07XEcwH3zgfiNLlXI1uvr2zZa9bKc3EfwFuEJV9/meJ0tV09g12mnHWK2qd6awThvgR1xnNSOC3XeuTASTsmuXq0bqTwwXLjy9nYmIG/jSnxi2bm3jG4bLbbfB//4Hjz0GL7zgdTTGJNiyxVUR3b/fDYB+/fVeR5R9rF3r7hKfOOGSwBYtvI0nNtYNWzRlimv3OW/e6R3OiEDDhi4x7NjRlRgWK+ZZuMYYk2Xs2uWGgHjuOddGO29eN9zSU09l6xtoWaJq6BkHFikI/Ae8q6rPJLNOO2ASMERVh6Vl/5YIJuPUKXeR8PPPbvrtN9fJgV/Bgm5Yg+7dXSmBdVceGocPQ/nycPAgrF7tqpGF2cmTJ9m/fz+lS5cO+7FMDvDBB9Cnj2sAv2iRq15oUnfppW4g4ehodwGR1Rw96hLUX3+FX35xzwPP+XnzQqtWbtzDrl2hcWPrNMgYkzuoujbdEya4ad68hKHdLrkEXnvNtbnO5kLRa+hg4FVVPZJofiHg4eQSuUTrvgpMADbg2gg+CbQDGqjqehF5EWiuqp1863fAJYHvAIFJYLJDTgSyRDBIhw/DnDkJieHSpacvj4x0XZVffrnrutyqjKXPJ5+4HhovvNCdaDLBrbfeyieffMLChQtp2LBhphzTZGOqrt3D9Omu+vK0aTniBzCspkxxFwvFirmxYc9JcljcrOXIEXcO+vVX979esOD0MW1LlXKfA39iWKGCZ6Eak6kOHnR9L2zY4MZY9T/fsMHVlihVyvXMXrp00o/ly8PZZ9t1UlZ34oRrquNP/v4N6LMyXz5Xhf7++7NFb6DBCkUiGAuUV9UdieaXAnaoaqqNnURkHC7xKw3sBOYDT6rqKt/yMUAHVa0a8DqpFvfr/eukxBLBdNq50yWEP/zguis/eDBhWdWqLiG8/HJXhTQb1pP2TJcu7n197z3o1y/sh9u0aRNVq1YlNjaW/v37M2LEiLAf0+QA+/e7doJz5riLm59+ciVE5kwnTrgbZX/9Ba+84nqUy4727XMJ4dSp7v+duJO1Bg3cBVH37q7k0HqhNjnBzp2uhNx/M2T9evddyKizznI1qapXP/OxalVrepOZVF1bvzVr3PT3365G1owZrtqnX+nSbkzdnj3dtdpZZ3kXc5iEIhGMA8olLokTkc7A56qa5Qavs0QwBI4fdyfK776D77+HbdsSlpUq5UoKr7vO3T2xpDB5GzdClSqui/dt26BEibAf8sknn+S5554DoEKFCmzcuJE8Vt3LBOPIETcG3pQp7gdx4kRo29brqLKeYcNc8nfeebB8uft+Z3eq7mLJnxT+8svpPVEXL+5KCbt3d72SZocSUJMz/f03vPGGu06pUcMlWv6pZMkzS+UOHICZM10SMGMGLFt25j4LFYLKlaFSJfcYOBUv7sZz3rnTTbt2nf64cyds2nR6HwxJ8ZccnnNO0o/lyrnrqdhY15QnNjbpCRJ6Cg68jg+cl9LkXyc21tUISDz554u4quIREck/5svnzn8FCrhH/+R/nS/f6ftNalJN2F/iyT8/Ls6djw4fdlNSzzdvdp8Nf/IXWJgRqF49l/j17OnadefwzvvSnQiKyEFAgSLAEd9zvwigIPCeqt4dunBDwxLBEIuLc3fNvvvOjacS2Btp6dLuwvG661yPdDn8C5VmL7wATzzh3p9x48J+uOPHj1O5cmV27NhB4cKFOXLkCLNnz6ZNmzZhP7bJIU6cgJtugi+/dHewv/kmR1WTybBt21wCePAg/Phjzn1vjh93pcOTJ7u/888/T1/epIlLCqOiXI+pViXOhNumTfD00649rj8hSqx48YSk8Jxz3FArMTGnr+/vD+Gii9zN7Fq13A3ujHyGVWH3bjfW3L//usfA5+vXu+TOZJ7ixd25ulathKllS/fZyEUykgj2BgT4HzAA2B+w+ASwTlUzp8FTGlkiGEaqbpiKL790Y5D99VfCsnLlXFJ47bXuJJvbk0JV1zHMmjWZdsH42WefceONNxIZGUnXrl159dVXuffee3njjRRHgTHmdLGxrhrzhx+6O9Sffuq+1wZuvdVdiEZFuTYmucW//yYkhTNmuEHu/erXd5+Xm292F1/GhNKuXW6IlrffdjcoIiLgllugUSP3ufRP//yTdKlc3rzQvDl06uSSv5YtXYlVZoqNdSWHW7e6m0lbt57+fNs2N8XFnVkqljfv6a/9CWvix8Tzkpv8ywNL3ZKa/HEHlhIGPsbGus6nTpxImI4fP/31iRNnliImfi6S9L4DX4tAkSIJU+HCZz4vW/b0pK90abtBRWiqhrYH5qrqyVRXziIsEcwkqq5a1BdfuOmffxKWlS/vuqG/6SZ3ss6NX8Z581y7mvLlXYPzTKhC27p1a+bOncvIkSNp3LgxzZo1o3z58mzcuJGI3J6Ym7RRhYcfdtUgRWDUKLj9dq+j8tbCha4qUf787oZYzZpeR+SNo0ddhzOTJsH48e4CF1z1uv/7P5cUWimhyaiDB13PjcOGJVTzu/ZaN6ZbUr1v+0vl/Inhpk1uaJy2bW2YFJNrhWz4CBGpgOvx87TGRqq6JEMRhoElgh5Qhd9/dxcFX3zhBk33q1PHJYQ33JC7uqXv189dPD/8MAwdGvbD/f777zRu3JjixYuzefNmChcuTI0aNfjvv/+YOXMm7dq1C3sMJodRddWbBw1yr199FR580NuYvBIX527sLFgAjz4KL73kdURZw4kTrtnAyJGupNCvYUN3DrzxRrsIN2lz7Bi8844rBdy1y827+GJ4/nnrwMqYNEopEQyq9wgRaSQiK4GNwBIgJmBaFKpATTYn4k7QL73k7sTNmwf33OOK5v/807WTq1bNtSMcNco1vM7Jjh51CTFA76Q6wA29t99+G4BbbrmFIkWKICJc66vON378+EyJweQwIu67++ab7vVDD8HAgaePRZdbfPyxSwLLl3fviXHy53elNNOnu6YCDz3k2lstXQp33unerz59YO7c0zu2MCYxVdcm+fzz3Q2nXbvczZeZM121ZEsCjQmpYKuGLgJ2A88AWzi90xhUdX1S23nJSgSzkJMnXS90n3zieh89etTNz5fPdTRw3XWu56aiRb2NM9TGjXNVpJo2dQN0h9mePXs499xzOXbsGH///Te1atUCYMmSJTRp0oRy5cqxefNmqx5q0u+jj1z7uNhYN67oBx+4z3ducOCA63Rg+3aXEN50k9cRZW3HjrkL+pEjYdashPm1akF0tGtLWKmSZ+GZLOivv+C++9z1ArihS1580V0nWBVjY9ItwyWCQF3gPlWdq6rrVHV94BS6UE2OlC+fG6Pl88/dRdTYsW6slthYlxjecINr4HvNNa4DmsDuyrOzsWPdY3R0phxu9OjRHDt2jG7dusUngQCNGjWiRo0abN++ndmzZ2dKLCaH6tXLDStQtSr88YdrK3f//al3mZ4TPPusO3+1bOmqOpqUFSzozu0zZ7oaIY884koG16xxpalVqrihKD77LOec8036HDrkahk0aOCSwBIl4K23XFOTHj0sCTQmjIItEZwPPKKqs1JdOYuwEsFsYMsW+OorV31y7tyE+YULuxLC665zbQIKFfIuxvTassXd7Y6IcL2BlSoV1sPFxcVRq1Yt/v33X3744Qd69ux52vLHHnuMl156iTvvvJN33nknrLGYXODwYRgyxHXiEBfnxtl691135z4nmjULOnd2Xb8vWuSGTUiHOXPmMGLECGKT6/bep2LFigwcOJBzzz03XcfJsk6dgmnTYMwY16bwxAk3/6yz3Pm+Vy9o3dou/HMLVXfz98EHXacuALfd5koBy2S54amNyZbmzZtHq1atki0RRFVTnYCLgPlAZ6AccHbgFMw+Mntq0qSJmmxkwwbVYcNUW7Q4fdjTokVVb7xRddIk1RMnvI4yeC+/7OK/6qpMOdykSZMU0CpVquipU6fOWL5kyRIFtGzZsnry5MlMicnkAosXqzZunPB9vf561W3bvI4qtCZNUi1Y0P1999yT7t3s2rVLy5Urp7imFalORYsW1aFDh+rx48dD+MdkIXv2qL777pnn/GrVVJ98UvWvv7yO0ITTqlWqnTol/N+bNFGdP9/rqIzJUY4cOaLnnXeeAjGaTL4UbIlgXGDuGLjI5ZKa5RodWYlgNrZuXcIYhYsXJ8wvXdp1SHDDDa56Vp5gazZnMlWoV89Vh/rhB1e6GWY9evTgxx9/5OWXX+aRRx5JIiTlvPPOY+3atUyfPp2LLroo7DGZXOLUKXj9dRg82FXxK1HC9Sx6663Zv2Rn3DjXlu3UKejb1/VimM42tjfccAOff/45rVu35sEUel1VVT755BO+/fZbAM4//3zefPNNunTpkq7jZgt//ulKCT/9FDZvTpjfvLl7/6+7zkqIcoLYWFe6/sknrr3xqVNw9tmuV+Lbb7dxh40JsQcffJDXXnsNIMMlgu1TmoLZR2ZPViKYQ6xdq/rcc6p16px+17hKFdWBA1WXLfM6wjMtWOBiLFs2U0ox165dqyKiBQoU0J07dya73uOPP66A9uvXL+wxmVzo339Vu3VL+I42a6Y6frxqdi2BHjlSVcT9LY88ohoXl+5dffXVVwpo4cKFde3atUFtM2XKFK1Vq1Z8CeFVV12l69evT3cM2cKpU6rTp6tGR7vaIP7PUt68qlFRql98oXrggNdRmrSIi1ONiVF94AHVChUS/qciqv36qe7a5XWExuRIs2fPVhHRiIiIFEsEPU/YwjVZIpjDxMWpLl3qLsgqVTo9KaxfX3XIEFdNLQMXayFz110urvvvz5TDPfjggwpodHR0iustXbpUAS1durRVDzXhERen+umnqmXKJHw/q1ZVHT5cdf9+r6MLnr9qN6i++GKGdrVjxw4tU6aMAvrWW2+ladtjx47pSy+9pEWKFFFACxUqpM8995wePXo0QzFlC4cPq37+uWr37qoREQn/j4gI1ZYtVZ94wiWNR454HalJyl9/qT71lGqtWqf/Xler5v53f/7pdYTG5FiHDh3SmjVrKqCDBg0KTSIINADeAiYD5X3zLgcaBbuPzJwsEczBYmNVZ850dxPPPvv0H5kKFVT79FH97jvVQ4cyP7Zjx1RLlnSx/PFH2A93+PBhLVmypAK6aNGiFNeNi4vz1xXXadOmhT02k4sdOqT6zjunXwSedZbqgw+qZuVSrbg4V9PAX2LxzjsZ3uU111yjgHbs2FFjY2PTtY+NGzfqtddeG186WKNGDZ0xY0aGY8s2tm9Xff11lwAGJoWgWqCAaseOqs8+q/rbb9mrLXl2d+SI6t9/u4R8zBjVZ55xv7+B7YZBtVw51fvuc20As8LNWmNyuPvuu08BjYyM1OPHj4ekjWBX4AdfEtgdqKOq/4rIg0BbVb08mLqqmcnaCOYSJ07Azz+7tngTJ57evqRAAejYEaKiXBfUVauGP56vvnLDYDRs6Lq+DrMPP/yQ22+/nebNm7NgwYJU13/yySd57rnn6NOnD6NGjQp7fCaXi4tz38vXXnPDCIBrB3TNNfDAA9CsmbfxBYqLg7vvhvfeczGOHZvhYSLGjx/PddddR9GiRVm+fDlVM3gOmjFjBvfeey+rVq2iaNGibN26laI5bfzV1Bw4ALNnw4wZblq69PTlRYpA/fqunXbgY/ny2b/NamY5dcoNlbJ1q5u2bUt4vnUrbNzopp07k9/HWWfBVVe5sXQ7doS8eTMvfmNysZkzZ9KhQwfy5s3LwoULadSoUYrjCAabCC4AxqrqOyJyELjAlwg2ASaoaoXQ/hkZZ4lgLqTqxjabONFNCxe6eX7nnuu6fW/SBBo3do/ly4fmuOvXQ0wMvPyyexwxAvr3z/i+Uzys0rhxY5YuXcpHH33EzTffnOo2y5cvJzIyklKlSrF161by5csX1hiNiRcTA8OHu06g/MMnXHCB6wDqmmvcQONeOXnSjff52WfuBtKXX2a4k6ft27dTr149du/ezXvvvUe/fv1CFOpJWrduzaJFi/j888+5/vrrQ7LfbGvXLneTwZ8Yrl6d9HolSriEsH59qFPHDXlSqZKbypTJPUmiqkvg1q8/fdqwwT1u2eKWB3FtSN68ULGiew8D38/q1aFDBzeWpDEm0xw6dIjIyEj+++8/nnrqKYYMGQKkPKB8sIngIaC+qq5LlAhWA/5U1Sz3bbdE0LB9O0ye7JLCadPcneTEypdPSAwvuMD1TFqsmLub6Z8KFEhYX9X9UMbEnD7t2pWwToEC7m5pmHu5mzt3Lq1bt6Z06dJs3LiRgkH86KoqdevWZfXq1fz000907do1rDEac4aNG91g0aNGwb59CfMbNnQJYWYmhfv3u3PEe++5ZKJoUZgwwV3EZoCqctVVV/Htt9/SuXNnpk6dioQw0Xj99dcZMGAAV1xxBd98803I9psj7NoFK1fCihUJjytWwN69yW9ToEBCEuOfKlZ0Nw8rVHBT2bJZu1fLuDj3t2/f7krwtm07/fm2bW6svg0b4OjRlPcl4v7e8uXhnHPcY+BUsaJL/MqVy7q9dxuTC91999288847NGzYkAULFpA/f34gNIngRuB6Vf0tUSJ4FfCyqtYM4d8REpYImtPExcGaNW44isWLYckSNyWVHCaWP79LCIsVcz+g27aduU7p0q6aW9Omripq8+ah/xsSufHGG/nss8947LHHeOGFF4Le7qmnnuKZZ57htttu44MPPghjhMak4PhxmDrVlb59//3p30V/UnjVVVCjRmirlW3e7KqSf/cd/PKLKw0E1439lCkhqa76+eefc8MNN1CsWDGWL19OlSpVMrzPQJs3b6ZixYoUKFCAnTt3UqxYsZDuP8dRdedtf3L4118J1Rs3bkw5SfSLiHBJkT8xrFDBlTIWLOimAgXOfF6ggEuq/NdZp7ecc1NcnPsuHDvmfl+OHUuY/K+PHnVDsxw+nPzjgQMJJe2pKVECqlRJejr3XJcEWlVOY7KV6dOn07lzZ/Lly8eiRYu44IIL4peFIhF8GWgLXAusApoC5YExwGhVfSbjf0JoWSJoUhUXB//84xLCxYth1Sr3Yxo47d/v2ksEKlHCJXyBU+XKmVq1aPv27VSqVInY2Fj+++8/KleuHPS2K1eupH79+px99tls27bNqoca76WUFIq4JK1cOXeBmngqXRoKFz59KlTo9Ndr1rjE77vvXJVxvzx5oG1buPxyN1ZdCKqKb926lXr16rF3717ef/99br/99gzvMylt27Zlzpw5fPrpp9xwww1hOUaucejQ6Ynhxo3uhsHmza4GiL+6ZFZ39tkuWS1X7vRH//Nzz3XJ3llneR2pMSaEDhw4QIMGDdiwYQPPPvssgwYNOm15KBLBfLik73rcIPJxvsfPgGhVDfI2VOaxRNCEhKq7SD140F2c5snjOp3xuD3Jyy+/zMCBA7nsssv47rvv0rx9vXr1WLVqFVOmTKFbt26hD9CY9ApMCqdOhR07gmuvFKxChaBrV5f8RUW5RDJEVJXLLruMCRMm0K1bNyZPnhzSKqGB3nzzTe677750nwNMGp044UoVA5PDAwcSSvP8U+Dr48fdZ1ck4TfD/zxwKljQfS79JYpJvS5SxE2FCyf9WKyYq71ijMl1+vXrx6hRo2jSpAnz5s074wZ/hhPBgB1VBxoDeYDfVXVNBuIOK0sETU7mLw34+uuvufLKK9O8/dNPP82QIUO49dZb+fDDD8MQoTEhEhsLu3e7hHDHDtfuyf98xw637MiR0yd/VTr/VLKk6/zl8suhSxd38RwGH3/8Mb169aJ48eKsWLGCihUrhuU4AFu2bKFixYrky5ePnTt3cpaV8hhjTK4zdepUunXrRv78+Vm8eDH169c/Y51QlAgOBl5V1SOJ5hcCHg6maqiIDAGeSjR7u6qek8I2/rELmwN7gJHAsxpE0JYImpxq//79lCpVChFh165dFC9ePM37WLVqFfXq1aNkyZJs27YtvkGxMTmO/+cijKX4R44cYfr06fTq1Yt9+/YxevRooqOjw3Y8v/bt2zNr1iw+/vhjbrrpprAfzxhjTNZw/PhxZs2axW233cbGjRt58cUXGThwYJLrppQIBtvd01NAUoMVFebM5C4lf+HaFvqnBsmtKCJnAdOA7UAz4D7gYeCBNBzPmBxn+vTpxMbG0rJly3QlgQB169alfv367N27l+nTp4c4QmOykMBqeSG0adMm3nvvPaKioihVqhSXXnop+/bto0ePHvTu3Tvkx0vKtddeC7jxCo0xxuRsO3bsYMyYMVx11VWULl2arl27snHjRpo3b85DDz2Urn0G2y2UAEmVwjXCldQF65SqJtHlYpJuxCWavVX1KLBCROoAD4jIa8GUChqTE02ZMgWAiy++OEP7ufbaa1mxYgXjx4/nkksuCUVoxuRYcXFxLFq0iIkTJzJx4kSWJhrIvFmzZvTs2ZMBAwaErV1gYldddRX33nsvP/30E/v27aNEiRKZclxjjDHhp6r88ccf8b87CxcuJDD9iYyMJCoqivvvv5+86ezpN8Wqob6hIhQoAhzh9GQwAigIvKeqd6d6IFc19BFgL3ACWAA8rqr/JrP+R0ApVe0RMK8ZsBCorqr/pXQ8qxpqciJVpUqVKmzcuJGYmBiaNGmS7n2tXr2aOnXqkCdPnlS7n69evTo9evSgZ8+eNG3alDxhGDtqxIgRPPvss8QG2wV6NlGiRAm6detGVFQUnTp1onCY2qeZ8Pnnn3/o0qUL//2X8LNTpEgRunTpQlRUFD169OCcc5Jt5RBWHTt25Ndff2Xs2LH06tXLkxiMMcaE1o4dO+jcuTPLly+Pn1egQAEuuugioqKiiIqKCrrH+HS3ERSR3rjSwP8BA4D9AYtPAOtUdV6QQVwCFANWA2WBQUBtoJ6q7k5i/anAJlW9NWBeZWA90Cqp44pIX6AvQOXKlZusX78+mNCMyTb+/PNP6tatS5kyZdi2bVuGE7KLL76Yn376KU3blC1bNj4p7Ny5c0jGMPv9999p3rw5pxIP1ZHDFCxYkE6dOsWfxMPZmYgJjdjYWNq3b89vv/1GxYoVueyyy4iKiqJDhw4ULFjQ6/B49913ueuuu+jRowcTJ070OhxjjDEZpKpcc801fP3115QtW5ZLL72UqKgoOnfuTJEiRdK8v1B0FtMemKuqJ9N89OT3WRT4F3hJVV9LYvlUYKOq3hYwrwqwDmipqvNT2r+VCJqcaPjw4TzwwAPcdNNNfPzxxxnen6qyf//+FNeJjY2NrxI3YcIENmzYEL8sf/78dOjQgaioqPjeEtPqxIkTNG3alOXLl3PXXXfx/PPPp3kfWdk///zDpEmTmDBhAonPSQ0bNox/72rVquVRhCYl/u/cOeecw8qVKzn77LO9Duk027dvp0KFCkRERLB9+3ZKlizpdUjGGGMyYNy4cfzf//0fxYoVY/ny5VSpUiVD+wvJ8BEiUgDXbq8uroroSuBzVT2egcB+AVar6p1JLLOqocYk4i/B86qXQFVlxYoV8Unh/Pnz4+urR0ZGMmfOnDSXED755JM899xz1KhRgz/++CNdd7uyi61bt/Ljjz8yceJEpk6dypEjriPmokWLsnTpUmrUqOFxhCbQ33//zQUXXMCxY8f44Ycf6Nmzp9chJalTp07MmDEj03orNcYYEx7btm2jXr167Nmzh1GjRtGnT58M7zPDvYaKSF1gDfAa0AK4EBgB/O3rwCU9QRXEVQ3dmswq84C2vvX8ugBbcKWCxuQqR48eZebMmQB07drVkxhEhAYNGvDYY48xd+5ctm/fztixY6lZsybLli3jxhtvTFMbv5iYGF588UVEhNGjR+foJBCgfPny3HbbbXz77bfs3r2byZMnc9FFF3Ho0CFuvfVW4uLivA7R+MTGxhIdHc2xY8fo1atXlk0CwXoPNcaYnEBVueOOO9izZw9du3bl9ttvD/sxg21g9DrwO1BZVduqalugMvAHLiFMlYi8KiLtRaSaiLQAvsJ1QjPWt/xFEQnsx/4zXAc1Y0SkvohcCQwErMdQkyvNnDmTY8eO0aRJE8qWLet1OACUKVOGXr168eOPP1KyZEkmTJiQ7Dg2iR0/fpzevXsTGxtL//79adu2bZijzVoKFizIxRdfzPjx4ylXrhyzZs3irbfe8jos4zN8+HDmzZtHhQoVGDFihNfhpOjKK68kT548TJs2jT170tKRtzHGmKzi008/5fvvv+ess87igw8+yJQeqINNBFvjevg84J/he/4E0CbIfVQEPseNJfgNcBy4UFX9PbqUB+LrRanqflwJYAUgBngbGIYrlTQm1/F36tKtWzePIzlTrVq1+Prrr8mbNy+vvvoqH374YarbDBkyhFWrVlGrVq0c1y4wLUqVKsXIkSMBGDhwIGvWrPE4IvPnn38yaNAgAN5///0s3+6uTJkyXHTRRZw6dYrvv//e63CMMcak0ZYtW7jvvvsA14t6pUqVMuW4wSaCx4ASScwv7luWKlW9XlUrqGp+VT1XVa9S1VUBy6NVtWqibZarajtVLaiq5VX1aSsNNLlVqMYPDJeOHTvyzjvvAHDnnXfGV2NNysKFCxk6dCgiwpgxY3L9kAqXXXYZN910E0ePHuWWW27JcUNoZCenTp0iOjqa48ePc+utt9K9e3evQwqKVQ81xpjsSVXp168fe/fupXv37pna1jvYRHAC8L6ItBaRCN/UBhgJ/BC+8IwxAOvXr2f16tUUK1aMCy+80OtwktWnTx/uv/9+Tp48yZVXXsk///xzxjrHjh2jd+/exMXF8eCDD9KqVSsPIs16Xn/9dcqXL89vv/3G66+/7nU4udarr77KwoULqVixIq+9ln0qoFxxxRVERETw888/s3v3GSMyGWOMyaI++ugjJk6cSIkSJRg1alSmVAn1CzYR7I/rLGY2rgTwGDAT+Bs3vqAxJoz81UI7d+5Mvnz5PI4mZa+88go9evRgz549REVFsW/fvtOWDx48mNWrV1O7dm2eeeYZb4LMgs4++2xGjRoFwBNPPMFff/3lcUS5z4oVK3jqqacA+PDDD9M1HIpXSpcuTadOnTh16hTfffed1+EYY4wJwqZNm+jfvz8Ab7zxBueee26mHj+oRFBV96nqZcD5wJXAVcD5qnqFry2fMSaMsnq10EARERF89tln1K9fn9WrV3PdddfFDxQ/d+5cXn31VfLkycOYMWMoVKiQx9FmLVFRUfE9VUZHR1sV0Ux08uRJoqOjOXHiBH379vWsZ96MsOqhxhiTfagqffr0Yf/+/Vx66aWeDAsWbIkgAKq6BvgFmKGqa8MTkjEm0MmTJ5k+3XWomxU7iknKWWedxYQJEyhTpgxTp05lwIABHDlyhOjoaFSVRx55hBYtWngdZpY0fPhwzj33XObPn5+tqiZmd0OHDmXx4sVUqVKFV1991etw0uXyyy8nb968TJ8+nV27dnkdjjHGmBT873//Y8qUKZx99tmMHDkyU6uE+gWdCIrIABHZAOwH9ovIRhG5X7yI2phcZP78+Rw4cIDatWtTpUoVr8MJWtWqVfnuu+/Inz8/b7/9Nu3atWPNmjXUq1ePIUOGeB1ellWiRAnef/99AJ588klWrVqVyhYmo5YtW8bTTz8NuCqhxYoV8zii9ClVqhSdO3cmNjaWb7/91utwjDHGJGPDhg3cf//9ALz11lucc845nsQR7IDyQ4EhuM5huvim94DBwMvhCs4Yk1AtNLuUBgZq1apV/FASixcvJiIigjFjxlCgQAGPI8vaLrnkEm677TaOHz9OdHR0fNVaE1pr165lxIgRXHXVVZw8eZK77rqLTp06eR1Whlj1UGOMybo2bNjAu+++S8+ePTl48CBXXnkl119/vWfxSDCjMYjIHqCvqn6VaP7VwEhVLRWm+NKtadOmGhMT43UYxmRY06ZNWbx4MZMnT84WbQSTMmTIEJ555hmeffZZnnjiCa/DyRb2799PgwYN2LhxIy+88AKPPfaY1yFleydPnmTu3LlMmDCBiRMnntYhz/nnn09MTAxFixb1MMKM27t3L+XKlSM2NpZt27ZRpkwZr0MyxphcKzY2lkWLFjFx4kQmTJjAsmXL4peVL1+e33//nXLlyoU1BhFZrKpNk1yWhkTwQlX9O9H884AFqprlRtvNTomgqrJu3ToqVapE3rx5vQ7HZCE7duygXLlyFCxYkD179mTrzlX27t2b5QfmzmqmTZtG165dyZcvH99//32Gq44UKFCA888/n4iIiBBFmH7//fffGT3KhoOqsnr1aiZMmMCUKVNOO2aJEiW45JJLiIqKomfPntm2SmhiPXr04Mcff+Tpp5+mZ8+eya4XERFB7dq1yZ8/fyZGZ4wx2deGDRuCGqLn33//ZeLEiUyaNImdO3fGzy9atChdu3YlKiqKyy67jLPPPjuc4QKhSQRH+Nbtn2j+cCBCVe8LRaChlJ0Sweeff55BgwZRsmTJ+IuSiy++2C6aDZ9++ik33XQTXbt2jR9CwuQud9xxByNHjgzZ/sqUKUP37t2Jioqia9eunHXWWSHbd7C+++47rrjiikw/LkDt2rWJiooiKiqK1q1b58ibb2PHjg16QOJixYrFX5R0796dsmXLhjc4Y4zJxvr27Rvfjj9YVatWpWfPnkRFRdG+fftMbx4TikTwXeAGYCsw3ze7BVAB+BSIb8CSVZLC7JII/v777zRv3vyMNkARERG0adMm/k71eeed50lvQsZbN998M5988gmvvfZafKNik7scPHiQm2++mfXr12d4X7t372bjxo3xr/Ply0f79u3jE6MaNWpk+Bip2blzJ/Xq1WPnzp3Url2bggULhv2YZcuWjb/JVrNmzbAfz2uHDx/mxhtvTPUzc+jQIdauTegAXERo0aJF/OchMjLSfneMMSbAs88+yzfffJPqeiVLlqRbt25ERUVRt25dT8+loUgEfwnyWKqqF6UluHBJLRGcNm0ar7/+Ot98841n1WJOnDhB06ZNWb58Offeey/33HMPEydOZOLEicyaNeu0McRq1qzJNddcw+DBgzPlwsl4Ly4ujnPOOYedO3eycuVK6tat63VIJptTVVatWhV/npk7dy5xcXHxy+vUqcP111/PY489Rr58+cISw3XXXcf48ePp0KED06dPJ0+eNI1iZEJs3bp1TJo0iYkTJzJjxgxOnDgRv6xSpUpcccUVPPPMMxQvXtzDKI0xxqRXhhPB7CilRPDkyZPUqVOHf/75h0GDBvHss89mcnTOk08+yXPPPUeNGjX4448/KFKkSPyyffv28dNPPzFx4kR+/PFH9uzZA0D//v0ZMWKEJ/GazLVkyRKaNGlCpUqVWL9+vd2ZNyG3e/duJk+ezMSJE5kyZQr79+8H4KmnngrLEB/jx4/nuuuuo0iRIixfvpxq1aqF/Bgm/Q4dOsTPP/8cf6Ng+/btgEvex40b53F0xhhj0sMSwSTMnj2b9u3bkydPHubPn0/Tpkm+P2ETExPDhRdeSFxcHDNnzqRt27bJrnvq1Cl++uknLrvsMmJjY/n1119p3759JkZrvPDCCy/wxBNP0KdPH0aNGuV1OCaHO3nyJN988w3XX389efPmZcGCBTRu3Dhk+9++fTv16tVj9+7dvPvuu9xxxx0h27cJvbi4OH777TcuueQSDh8+zPjx47nmmmu8DssYY0wapZQI5to6OW3btqV///7ExsbSu3dvjh8/nmnHPn78OL179yY2NpYBAwakmAQC5M2blx49esR3u3/rrbdy6NChzAjVeMjfOUx2HD/QZD/58uXjuuuu47777uPUqVNER0eH7Lyoqtx5553s3r2bzp07069fv5Ds14RPnjx5aNu2La+88goAd911Fzt27PA4KmOMMaGUaxNBcL111qpVi1WrVoWlGlRyhgwZwqpVqzjvvPN47rnngt7uiSee4IILLuDff/9l4MCBYYzQeG3//v3MnTuXiIiIbD/AtcleXnjhBWrWrMny5ctDVm1+3LhxfPvttxQrVowPPvjAqjlnI/369aNTp07s2rWLu+66i5xai8gYY3KjXJ0IFi5cmDFjxiAiDB06lIULF4b9mAsWLGDo0KHkyZOHMWPGULhw4aC3zZ8/P2PGjCFv3ry8/fbb/PJLsH34mOxmxowZnDp1ipYtW1KiRAmvwzG5SJEiRRg9ejQiwksvvURGe1/etm0b99xzDwCvvfYaVapUCUWYJpPkyZOHDz/8kKJFi/L1118zfvx4r0MyxhgTIrk6EQRo1aoVDz74IHFxcfTu3Ztjx46F7VjHjh0jOjqauLg4HnzwQVq2bJnmfTRs2JAnn3wScFVEDx48GOowTRZg1UKNl9q0acOAAQMyXHVeVbnjjjvYs2cP3bp147bbbgtxpCYzVKlShWHDhgGuiui2bds8jsgYY0wo5PpEEOCZZ56hdu3arF69msGDB4ftOIMHD2b16tXUrl2bZ555Jt37eeyxx2jUqBHr1q3jkUceCWGEJitQVaZMmQLAxRdf7HE0Jrd67rnnOO+88zJUdf7TTz/l+++/p3jx4lYlNJvr06cPXbp0Yc+ePdxxxx1WRdQYY3KAXNtraGILFiygVatWqCpz5syhVatWIY1n7ty5tGnTBhFh3rx5NG/ePEP7W758OU2aNOHkyZNMnTqVLl26hChS47XVq1dTp04dSpcuzfbt222cNeOZefPm0aZNG8Cdw1q0aBH0tlu2bKFevXrs27eP0aNHEx0dHaYoTWbZuHEj9evX58CBA3zyySfceOONXodkjDEmFdZraBBatGjBI488gqoSHR3NkSNHQrbvI0eOEB0djaryyCOPZDgJBGjQoEH8XfrbbruNAwcOZHifJmv44IMPALjkkkssCTSeatmyZXzV+ejoaI4ePRrUdqpK37592bdvHz169KB3795hjtRkhkqVKjF8+HAA7r33XrZs2eJxRMYYYzLCrjIDDBkyhHr16rFmzRoGDRoUsv0OGjSINWvWUK9evZD2TvrII4/QtGlTNm7cyIMPPhiy/Rrv7N69m/feew+A/v37exyNMemrOj927FgmTZpEiRIlGDlypFUJzUFuueUWLrnkEvbu3Uu/fv2siqgxxmRjniWCIvK4iKiIvJXKet1EZJ6IHBSRXSLyvYicF46YChQowJgxY4iIiGDEiBHMmTMnXftRVVatWsXLL79M27ZtGT58OBEREYwZM4YCBQqELN68efMyduxY8ufPzwcffBDfwYjJvt544w0OHz5Mt27daNKkidfhGEPBggUZO3YsefLkYdiwYcydOzfJ9TZs2MC7775Ljx494scJfOONNzj33HMzM1wTZiLC+++/T/HixZk4cSIff/yx1yEZY4xJL1XN9Am4EPgP+AN4K4X1qgHHgKFATaAhMBVYm9oxmjRpouk1aNAgBbRmzZp66NChoLY5duyY/vTTT3rvvfdqtWrVFIif8uXLpyNGjEh3PKl5+eWXFdBzzz1X9+7dG7bjmPDav3+/lihRQgGdNWuW1+EYc5rHHntMAa1Vq5YePnxYT506pfPmzdPHH39cIyMjTzvniYj27dtX4+LivA7bhMnYsWMV0OLFi+umTZu8DscYY0wygBhNJl/K9M5iRKQ4sAToAwwGVqjqPcmsezXwBZBfVWN98zoCM4AyqrorueOktbOYQCdOnKBZs2YsW7aMK664Ir6zhKTExsYyf/58pk6dyqFDh+LnlylThh49ehAVFUWXLl0466yz0hVLMGJjY2nTpg3z58+ne/fuqQ5AXrVqVTp37hzWmEzavfzyywwcOJC2bdsya9Ysr8Mx5jTHjx+nSZMmrFy5kqZNm7J+/Xp27twZv7xo0aJ07dqVqKgounfvTrly5TyM1oSbqnLZZZcxYcIE2rZty+WXX57i+hUqVKBr166cffbZmRNgBixevJi///6bzp07U6ZMGa/DMcaYDEmpsxgvEsEvgHWq+qiI/ErKiWBVYDXQH/gAKAy8CdRV1RR7XMlIIgjw+++/07x5c06dOhX0NpGRkfTs2ZOoqCiaNWtGREREuo+fVn/99RcNGzYMehzEfPny0b59+/h4q1evHuYITUqOHj1K1apV2bFjB1OmTLHxA02WtHjxYlq0aEFsbCzgbir5zyHt27cPadV3k/Vt3bqVevXqsXfv3qDWz5MnD61bt47/zNSuXTvLtR/9559/iIyM5MiRI4gIF154YXy89evXz3LxGmNMarJMIigifYA7gJaqeiK1RNC3TVvgS6A0rk3j78AlqrojiXX7An0BKleu3GT9+vUZinfixInMmDEj1fVq1apFjx49qFy5coaOl1HTpk1j8uTJKa4TFxdHTEwM8+bNIy4uLn5+nTp1iIqKomfPnrRs2ZK8efOGO1wT4K233uLee++lSZMmLFq0yC42TJY1adIkVq9ezcUXX0zdunXts5rLzZs3j6+++irFTmNUlWXLljFr1qzTbq5Wr149/nenXbt25M+fPzNCTlZcXBwdOnRg9uzZVKlSha1bt3LixIn45ZUrV46Pt0OHDhQsWNDDaI0xJjhZIhEUkfOBOUBbVV3tm/crKZcIngPMAr4DPgeKAf6R2C9S1biktoOMlwjmdLt27WLy5MlMnDiRKVOmnDb8RMmSJRk6dCi33367hxHmHidOnKBmzZps3LiRr7/+miuvvNLrkIwxJuT279/P1KlTmTBhAj/++CO7d++OX1asWDGeeOIJHn30Uc/ie/311xkwYADlypVj5cqV5M+fn59//pkJEyYwadIkduxIuP9cuHBhHnzwQZ555pkU9miMMd7LKolgNDAaiA2YHYHrXCAOKKKqxxNt8ywQpaqNAuZVBDbiEspku/W0RDB4J0+eZPbs2UycOJEJEyawdu1a8ubNy6JFi2jYsKHX4eV4//vf/7jtttuoW7cuy5cvt7EDjTE5XmxsLAsWLIj/3VmxYgXgarZ07tw50+P5+++/adiwIUePHuW7777jsssuO225vzaNP96lS5cC8O2336baPtIYY7yUVRLBEkDFRLNHA2uAF4CVmigYERkGtA8MXkTKA1t885PtUcMSwfS75557ePvtt4mMjGTRokWeV9fJyWJjY6lTpw5r1qzh448/5qabbvI6JGOMyXTPP/88gwYNonLlyixfvjxTOzOLjY2lXbt2zJ07l5tvvpmPPvoo1W3eeOMN+vfvT9myZVm5ciWlS5fOhEiNMSbtUkoEM63oQVX3qeqKwAk4DOzxvVYReVFEpgdsNgloLCJPiUgtEWmMSx43AoszK/bc5qWXXqJ69eosW7aM5557zutwcrSvvvqKNWvWUL16da6//nqvwzHGGE88+uijNGnShA0bNvDQQw9l6rFff/115s6dS/ny5Xn99deD2uaee+6hXbt27Nixg3vvvTfMERpjTHhktTpo5YEa/heqOgO4AbgM10nMT8BJ4GJVPexJhLlA0aJFGT16NAAvvPACS5Ys8TiinElVeeGFFwB3EWQd9Bhjcqu8efMyduxY8ufPz/vvv8/UqVMz5birV6/miSeeAOD999+nZMmSQW2XJ08eRo8eTZEiRRg3bhxfffVVOMM0xpiw8DQRVNUOgR3FqGq0qlZNtM44VW2sqkVVtYyq9lTVVZkebC7Trl07+vfvT2xsLL179+b48eOpb2TSZOLEiSxbtowKFSrQu3dvr8MxxhhP1atXL77zldtuu439+/eH9XixsbFER0dz7NgxoqOj6dGjR5q2r169OkOHDgXgzjvvPK0zGWOMyQ6yWomgyUJeeOEFatasyYoVK6xntBBTVZ5//nkAHnroIRt/zRhjgAcffJAWLVqwadMmHnjggbAea9iwYSxYsIBzzz2X4cOHp2sfd9xxBxdddBG7du3irrvuSnEYDWOMyWoyfUD5zGKdxYTGb7/9Rtu2bRER5s+fT7NmzbwOKUeYMWMGnTp1onTp0qxbt44iRYp4HZIxxmQJq1evpmHDhhw/fpxJkybRvXv3kB9j1apVNGrUiBMnTjB58mQuvvjidO9r3bp1NGjQgEOHDjFu3Diuu+66EEZqjDEZkyU6izHZU+vWrXnggQeIi4ujd+/eHDt2zOuQcgR/aeCAAQMsCTTGmAC1a9eOP0f26dOHvXv3hnT/p06donfv3pw4cYLbb789Q0kgQNWqVRk2bBgAd999N9u3bw9FmMYYE3aWCJpUPfvss5x//vn8+eefPPXUU16Hk+3Nnz+fGTNmcNZZZ3H33Xd7HY4xxmQ5AwYMoFWrVmzZsoUBAwaEdN9Dhw4lJiaGSpUqxSdwGdWnTx+6dOnC7t27ufPOO62KqDEmW7BE0KSqUKFCjBkzhjx58vDqq68yb948r0PKtk6cOBHf3vLuu++mRIkS3gZkjDFZUEREBKNHj6ZQoUJ89NFH/PDDDyHZ7/z58xkyZAgAH374YcjGKxSR+P19++23fP755yHZrzHGhJMlgiYoF154IQ8//DBxcXFER0dz9OhRr0PKNnbs2MHYsWO5+uqrKV26NJMnT6ZQoULcf//9XodmjDFZ1nnnnceLL74IQL9+/di9e3ea93Hy5ElmzpzJQw89RO3atWnZsiUnT56kX79+dOnSJaTxVqpUKb7TmXvuuYetW7eGdP/GGBNq1lmMCdqxY8do0qQJq1at4oEHHghZlZqcRlVZvnw5EyZMYOLEiSxYsOC0akINGjRgyJAhXHnllR5GaYwxWV9cXBwdOnRg9uzZ3HDDDXz66aepbrNnzx6mTJnChAkTmDJlCvv27YtfVqJECa6++mqGDx9O0aJFQx6vqtKjRw8mT55Mz549+f777xGRkB/HGGOClVJnMZYImjRZtGgRLVu2JC4ujksuuYQ8eZIvVC5UqBAdO3akR48eVK5cOROjTLtFixbx4osvcvLkyQztR1VZtmwZGzdujJ+XP39+LrroIqKiooiKiqJKlSoZDdcYY3KNf/75h8jISI4cOUKXLl1SHG5n9+7dLFiwgLi4uPh5tWvXJioqip49e9KqVSvy5s0b1ng3b95MvXr12L9/Px07dkyxQzBV5eTJk5w4cSLFafTo0WHpPdUYk/NZImhC6sknn+S5555L0zYXXHBBfCLUvHnzFBPIzHbw4EEaNGjA+vXrQ7bPc845hx49etCzZ086deoUljvPxhiTW7z99tvcc889Qa2bN29e2rdvT8+ePenRowc1a9YMc3Rn+uijj+jdu3fI9jd+/HiuueaakO3PGJN7WCJoQiouLo5ffvmFI0eOpLjetm3b+PHHH5k2bRqHDx+On1+mTBl69OhBVFQUXbt2pVixYuEOOUV33HEHI0eOpFGjRjz99NMZ3l+FChVo1KhRlkp2jTEmO1NV5syZc1o1z6Tkz5+fCy+8kOLFi2dOYCmYN28eu3btSnW9/Pnzpzjly5ePkiVLplgSaowxybFE0Hjq2LFjzJw5k4kTJzJhwoTTSt7KlCnD3LlzPbljCzB16lS6detGvnz5WLJkCfXr1/ckDmOMMcYYY0LNBpQ3nipYsCDdunXjzTff5L///mP58uW8+OKLNGjQgJ07d3LLLbec1p4js+zfv5/bb78dgKefftqSQGOMMcYYk2tYImgylYhQv359Bg4cyC+//MI555zDnDlzeOONNzI9lgcffJCNGzfSrFkzHn744Uw/vjHGGGOMMV6xRNB4plSpUowcORKAxx57jL///jvTjj158mQ+/PBD8ufPz5gxY8Lei5wxxhhjjDFZiSWCxlOXXnopvXr14tixY0RHRxMbGxv2Y+7bt48+ffoA8Oyzz1K3bt2wH9MYY4wxxpisxBJB47kRI0ZQoUIF5s2bx/Dhw8N+vPvvv5/Nmzdz4YUX8uCDD4b9eMYYY4wxxmQ1lggaz5UsWZL3338fgEGDBrF69eqwHWvixImMGTOGggULMmbMGCIiIsJ2LGOMMcYYY7IqSwRNltC9e3duvfVWjh8/Tu/evTl16lTIj7Fnzx769u0LwPPPP8/5558f8mMYY4wxxhiTHVgiaLKM1157jYoVK7Jw4UKGDRsW8v3379+frVu30rp1a/r37x/y/RtjjDHGGJNdWCJosozixYvzwQcfADB48GBWrlwZsn1/9913fPLJJxQqVIjRo0dblVBjjDHGGJOreZYIisjjIqIi8lYq64mIDBCR1SJyXES2ishLmRWnyVzdunWjT58+nDhxgt69e3Py5MkM7e/o0aNMmjSJO+64A4CXXnqJWrVqhSJUY4wxxhhjsi1PEkERuRDoAywLYvVhwF3Ao0AdoDswK3zRGa+9+uqrVK5cmcWLFzN06NA0b79582ZGjhxJz549KVWqFFFRUWzfvp127dpxzz33hCFiY4wxxhhjshdR1cw9oEhxYAkuERwMrFDVJK/OReR8YAUQqap/puU4TZs21ZiYmIyGazzy888/06VLF/Lly0dMTAyRkZHJrhsXF8fixYuZMGECEydO5Pfffz9tedOmTYmKiqJ///6UKFEizJEbY4wxxhiTNYjIYlVtmtSyvJkdDDAK+EpVZ4jI4FTWvQz4F7hYRCbhSjBnAg+r6o4wx2k81LlzZ+68807effddmjRpQoECBZJd99SpUxw/fjz+deHChenSpQs9e/ake/fulC9fPjNCNsYYY4wxJtvI1ERQRPoANYGbg9ykOlAFuB6IBhR4FZggIi1VNS7R/vsCfQEqV64coqiNV4YOHcqsWbNYuXJlqsNJVK5cmZ49exIVFUWHDh0oWLBgJkVpjDHGGGNM9pNpiaCvmucLQFtVPRHkZnmAAsDNqvq3bz83A38BzYAFgSur6ihciSNNmzbN3DqvJuSKFi3KsmXLOHLkSKrrFilSBBHJhKiMMcYYY4zJ/jKzRLAlUBpYEXDBHgG0E5E7gCKqejzRNluBU/4k0GcNcAqoTKJE0OQ8efLkoWjRol6HYYwxxhhjTI6SmYngd0Di3ltG4xK7F4CkSgl/A/KKSA1V/cc3rzou7vVhitMYY4wxxhhjcrRMSwRVdR+wL3CeiBwG9qjqCt/rF4HmqtrJt8rPuB5G/yciA3zzRuBKAq1LUGOMMcYYY4xJB88GlE9GeaCG/4WvM5goYAdu7MCfgE3AZYk7ijHGGGOMMcYYExwvho+Ip6odEr2OTmKdrcA1mRSSMcYYY4wxxuR4Wa1E0BhjjDHGGGNMmFkiaIwxxhhjjDG5jCWCxhhjjDHGGJPLWCJojDHGGGOMMbmMJYLGGGOMMcYYk8uIqnodQ1iIyEHgL6/jMCaHKA7s9zoIY3IA+y4ZEzr2fTImdeerarGkFng6fESY/aWqTb0OwpicQERGqWpfr+MwJruz75IxoWPfJ2NSJyIxyS2zqqHGmGBM8DoAY3II+y4ZEzr2fTImA3Jy1dAYKxE0xhhjjDHG5FYp5UQ5uURwlNcBGGOMMcYYY4yHks2JcmyJoDHGGGOMMcaYpOXkEkFjjDHGGGOMMUmwRNAYE09E7hKR/0TkmIgsFpG2vvn5RORlEVkmIodFZKuIfCYilb2O2ZisKLnvkm/ZsyKy2vdd2isi00WklZfxGpOVpfR9SrTeKBFREXkos2M0JjuyRNAYA4CIXAe8DrwANALmApN9yV5hoDHwvO/xMqASMEVEcvIwNMakWSrfJXBj3N4NNADaAP/hvkvlPAjXmCwtiO+Tf72rgWbAlkwP0phsKtu3ERSRu4CHgfLASmCAqs72LbsS6Ie7cC0NdFTVXz0K1ZgsTUQWAMtUtU/AvDXAV6r6WBLr/3979xorV1nFYfz5c1OsbbCFUtBw+WBiRAlEMdEU5GKTBjHywWgwIFC8gcEIEhIj0TZoDERBIoJYgZIqBIiXWBQoIg1REZGEIAkVlTvlTkOpcitZfti7MozntKeFM2f2meeXnJzMXmvPrPnwZrL2++53v5tmzO1bVX8bXKXScNuKsTSL5qHYC6vq+sFVKg2/iYynJHvSNIgfAa4Fzq+q705FvVKXdHpGcAJXiWa0x06dmgqlbkiyA/A+YGVfaCUw3pK1We3/tZNVl9Q1WzqW2vzPA+uAOya7PqlLJjKe2lUpVwDfqqq7B1uh1G2dbgRpGrxlVbW0qu6uqpOBR4ETAapqeVUtobk6JGl8OwPbAo/3HX8cmNef3P44fw9YUVUPT355UmdMaCwlOSLJeuAF4BRgQVX1nyONuomMpyXA01V14SALk6aDzjaCWzmDIWnT+teKp/9Ye/X1p8BOwPGDKUvqnM2NpZuA/Wh+r64Drkqy22BKkzpnzPGU5MPAccCigVckTQOdbQTZwhkMSZv0FPAK/z925tIzxnqW4OwLHFZVTw+sQqkbJjSWqurfVfXPqvpzVZ0AvAx8dnBlSp2wufF0CM0eEY8m2ZBkA7AncFYSV6tIm9HlRnCjzc5gSNq0qnoJuB1Y0BdaQHOfLUm2B66kaQIPqarHBlqk1AETGUvj2AZ402TVJXXRBMbTBTS/Sfv1/K0BzgUOG1CZUmd1edv3CV11lTRh5wDLk/wF+CPwRWB34EftTODVNFtzf4xmSc7GsfdsVT0/FQVLQ2pTY2kWcDqwguae9l1oHiXxDuCqqSlXGmrjjqeqegJ4ojc5ycvAY1X194FXKnVMZxvBqnopycarRFf3hBYAP5+aqqTuqqork8wBzqBZanMXcHhVPZBkL5pnB0JzdbbX8cCyQdUpDbvNjKW3APvQ3NM0B3gauA04qKrunKqapWG1qfE0tZVJ3dfp5wi2j49YDpzEq1eJTgD2aX9wZwN70GxqcRPwOeCvNFeKXNYmSZIkaSR1uhGE/z1Q/nRevUp0SlXd3MaOAy4d47QlVbV4UDVKkiRJ0jDpfCMoSZIkSdoy02HXUEmSJEnSFrARlCRJkqQRYyMoSZIkSSPGRlCSJEmSRoyNoCRJkiSNmE40gkmWJakkPxkjdnYbu2YqapMkSZKkrulEI9h6CPhUkhkbDyTZDjgGeHDKqpIkSZKkjulSI3gn8A/gkz3HPgq8AKzaeCDJAUlWJnkqybokf0jywZ74Jf2zh0m2SfJgklMn9ytIkiRJ0tTrUiMIcDGwqOf1IuBSoHqOzQSWAwcCHwDuAH6bZOc2vhRYmGS3nnMWAPPa8yRJkiRpWutaI3g58P4k70wyD1gILOtNqKrfV9Xyqrq7qlYDJ9PMGi5s47cAq4Fje05bBPy6qp4cwHeQJEmSpCnVqUawqtYCv6Rp3I4FVlXVa+4PTDI3yUVJ7knyLPAcMBfYoydtKXB8mz8b+DjNbKMkSZIkTXvbTXUBW+ES4DJgPfCNMeKXAbsCpwD3Ay8CNwI79OQsB85KMh/YH3gKWDl5JUuSJEnS8OhiI3gj8BKwM/CrMeLzgS9X1W8AkuwK9N4PSFU9k+QXNDOL+wPLquqVySxakiRJkoZF5xrBqqok+wKpqhfHSLkHODrJrcAM4GyaxrHfUuA6YHvgE5NVryRJkiQNm841ggBV9dwmwouAHwO3A2uAxcAuY+StAh4GHqiqf73BJUqSJEnS0EpVbT5rGkqyI/AIcHJV/Wyq65EkSZKkQenkjODrkWQbXt1M5nng6qmtSJIkSZIGa+QaQZrHSNxHsyz0+Koa6/5BSZIkSZq2RnZpqCRJkiSNqk49UF6SJEmS9PrZCEqSJEnSiBnaRjDJ15LclmRdkieTrEjynr6cJFmcZE2S55OsSrJPT3x2kh8kWd3GH0pyYZI5PTl7Jbk4yb1tzr1JvtPuKipJkiRJ087QNoLAwcAFwIeAQ4ENwO+SzO7JOR34KnAycADwBHBDkpltfHfg7W3ee4GjgYOAK3re413AtsCJwD7te30GOG8yvpQkSZIkTbXObBaT5K3As8CRVbUiSWgeGH9+VX27zdmRphk8raouGud9DgeuAXaqqnXj5JwEnFlVc8aKS5IkSVKXDfOMYL+ZNPWubV/vDcwDVm5MqKrngZtpZhHHMwt4EfjPZnLWbiIuSZIkSZ3VpUbwPOAO4Jb29bz2/+N9eY/3xF4jyU7AmcDSqtowTs4ewGk0y1IlSZIkadrpxAPlk5wDzAfmV9UrfeH+ta0Z4xhJZgArgEdo7hkc63N2Ba4HbgDOfZ1lS5IkSdJQGvoZwSTnAkcBh1bVvT2hx9r//bN/c+mbJWzvL7y2fXlEVb0wxufMA24C7gKOqa7cPClJkiRJW2ioG8Ek5wGfpmkCV/eF76NpBhf05L8ZOBD4U8+xmcB1NDuDHl5V68f4nN2AVcDdwFHjLRuVJEmSpOlgaJeGJvkhcAxwJLC2nbEDWF9V66uqknwf+HqS1cA9wBnAeuDy9j1m0mwmM6t9nxntElGAZ6rqpSS70zSBa4CvADs3G5IC8OQYS1ElSZIkqdOG9vERScYrbElVLW5zAnwT+ALwNuBW4EtVdVcbP5hmuedYDqmqVUmOAy4dJ2fvqrp/K8qXJEmSpKE1tI2gJEmSJGlyDPU9gpIkSZKkN56NoCRJkiSNGBtBSZIkSRoxNoKSJEmSNGJsBCVJkiRpxNgISpIkSdKIsRGUJEmSpBFjIyhJkiRJI8ZGUJIkSZJGzH8BO9pnG9WpAH8AAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%%time\n",
-    "\n",
-    "omsa.set_criteria(criteria)\n",
-    "\n",
-    "# model_url = 'https://thredds.aoos.org/thredds/dodsC/NOAA_COOPS_OFS_CIOFS.nc'\n",
-    "model_url = 'https://www.ncei.noaa.gov/thredds/dodsC/model-ciofs-agg/Aggregated_CIOFS_Fields_Forecast_best.ncd'\n",
-    "bbox = [-154.7, 57.5, -153.7, 58.0]\n",
-    "search = omsa.run(\n",
-    "                  loc_model=model_url,\n",
-    "                  approach='region',\n",
-    "                  bbox=bbox,\n",
-    "                  criteria=criteria,\n",
-    "                  horizontal_interp=False,\n",
-    "                  var_def=var_def,\n",
-    "                  xarray_kwargs={'chunks': {'ocean_time': 1, 's_rho': 1},\n",
-    "                                 'drop_variables': ['ocean_time', 'time_run']},\n",
-    "                  time_range=['2022-5-1','2022-5-4'], \n",
-    "                  variables=['temp'],\n",
-    "                  readers=[odg.erddap],\n",
-    "                  erddap={\n",
-    "                      'known_server': 'ioos'\n",
-    "                  },\n",
-    ")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/docs/Demo-AK.md b/docs/Demo-AK.md
deleted file mode 100644
index f78f86f..0000000
--- a/docs/Demo-AK.md
+++ /dev/null
@@ -1,80 +0,0 @@
----
-jupytext:
-  text_representation:
-    extension: .md
-    format_name: myst
-    format_version: 0.13
-    jupytext_version: 1.14.1
-kernelspec:
-  display_name: Python 3 (ipykernel)
-  language: python
-  name: python3
----
-
-# Demonstration of `ocean-model-skill-assessor`: Alaska example
-
-Here we demonstrate how to use `ocean-model-skill-assessor` as a Python package.
-
-```{code-cell} ipython3
-import xarray as xr
-import ocean_data_gateway as odg
-import cf_xarray
-import pandas as pd
-import extract_model as em
-import ocean_model_skill_assessor as omsa
-import numpy as np
-from IPython import display
-from glob import glob
-```
-
-## Definitions
-
-These dictionaries are not required for every type of run, but are required for identifying variables in both datasets and models, and for running QC. They can be complicated if desired, but do not have to be. Once they are written they do not need to be modified much. More information about these dictionaries is available in the [`ocean_data_gateway` docs](https://ocean-data-gateway.readthedocs.io/en/latest/details.html#Configure-custom-criteria-and-variable-definitions). We posted online pre-populated definitions to make this easy.
-
-+++
-
-Here are `criteria`, which map identifying features of different variables to a variable nickname we can generically refer to:
-
-```{code-cell} ipython3
-url = 'https://gist.githubusercontent.com/kthyng/c3cc27de6b4449e1776ce79215d5e732/raw/18f18f33ccc71144842bd9fbf87611f1f6f4a67e/my_custom_criteria.py'
-criteria = odg.return_response(url)
-```
-
-Here are `var_def` which give some rules for QC for different variables (referring to the variables by the same nicknames as in `criteria`):
-
-```{code-cell} ipython3
-url = 'https://gist.githubusercontent.com/kthyng/b8056748a811479460b6d5fc5cb5537b/raw/6b531cc5d3072ff6a4f5174f882d7d91d880cbf8/my_var_def.py'
-var_def = odg.return_response(url)
-```
-
-## Search for Data over a Region
-
-This example demonstrates performing a search in time and space for data to compare with your model output. By default this would search in the spatial bounding box of the model output, but here we instead input a smaller bounding box so as to limit the number of datasets found and used. For several of the datasets, the model output isn't available (must be determined to be on land).
-
-```{code-cell} ipython3
-:tags: []
-
-%%time
-
-omsa.set_criteria(criteria)
-
-# model_url = 'https://thredds.aoos.org/thredds/dodsC/NOAA_COOPS_OFS_CIOFS.nc'
-model_url = 'https://www.ncei.noaa.gov/thredds/dodsC/model-ciofs-agg/Aggregated_CIOFS_Fields_Forecast_best.ncd'
-bbox = [-154.7, 57.5, -153.7, 58.0]
-search = omsa.run(
-                  loc_model=model_url,
-                  approach='region',
-                  bbox=bbox,
-                  criteria=criteria,
-                  horizontal_interp=False,
-                  var_def=var_def,
-                  xarray_kwargs={'chunks': {'ocean_time': 1, 's_rho': 1},
-                                 'drop_variables': ['ocean_time', 'time_run']},
-                  time_range=['2022-5-1','2022-5-4'],
-                  variables=['temp'],
-                  readers=[odg.erddap],
-                  erddap={
-                      'known_server': 'ioos'
-                  },
-)
-```
diff --git a/docs/Demo-CA.ipynb b/docs/Demo-CA.ipynb
deleted file mode 100644
index 343094e..0000000
--- a/docs/Demo-CA.ipynb
+++ /dev/null
@@ -1,219 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "a9da2fa8-9a25-497e-8ec6-d08609ad38ca",
-   "metadata": {},
-   "source": [
-    "# Demonstration of `ocean-model-skill-assessor`: California example\n",
-    "\n",
-    "Here we demonstrate how to use `ocean-model-skill-assessor` as a Python package."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "3b2011cd-01e0-454c-af6f-d968522f5385",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import xarray as xr\n",
-    "import ocean_data_gateway as odg\n",
-    "import cf_xarray\n",
-    "import pandas as pd\n",
-    "import extract_model as em\n",
-    "import ocean_model_skill_assessor as omsa\n",
-    "import numpy as np\n",
-    "from IPython import display\n",
-    "from glob import glob"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "07a7bb3c-38d8-45a1-8444-ff0ea7aac52f",
-   "metadata": {},
-   "source": [
-    "## Definitions\n",
-    "\n",
-    "These dictionaries are not required for every type of run, but are required for identifying variables in both datasets and models, and for running QC. They can be complicated if desired, but do not have to be. Once they are written they do not need to be modified much. More information about these dictionaries is available in the [`ocean_data_gateway` docs](https://ocean-data-gateway.readthedocs.io/en/latest/details.html#Configure-custom-criteria-and-variable-definitions). We posted online pre-populated definitions to make this easy."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "571d37a7-bd3c-4629-9931-e293bc609ce0",
-   "metadata": {},
-   "source": [
-    "Here are `criteria`, which map identifying features of different variables to a variable nickname we can generically refer to:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "ed628da3-09dd-4b3a-bfd0-cd52b154399b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "url = 'https://gist.githubusercontent.com/kthyng/c3cc27de6b4449e1776ce79215d5e732/raw/af448937e4896535e36ef6522df8460e8f928cd6/my_custom_criteria.py'\n",
-    "criteria = odg.return_response(url)\n",
-    "# criteria"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0b502c01-3e4a-4d22-916f-9579eb6193c0",
-   "metadata": {},
-   "source": [
-    "Here are `var_def` which give some rules for QC for different variables (referring to the variables by the same nicknames as in `criteria`):"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "da532c82-28e2-4224-b4ce-8260cee9de57",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'temp': {'units': 'degree_Celsius',\n",
-       "  'fail_span': [-100, 100],\n",
-       "  'suspect_span': [-10, 40]},\n",
-       " 'salt': {'units': 'psu', 'fail_span': [-10, 60], 'suspect_span': [-1, 45]},\n",
-       " 'u': {'units': 'm/s', 'fail_span': [-10, 10], 'suspect_span': [-5, 5]},\n",
-       " 'v': {'units': 'm/s', 'fail_span': [-10, 10], 'suspect_span': [-5, 5]},\n",
-       " 'ssh': {'units': 'm', 'fail_span': [-10, 10], 'suspect_span': [-3, 3]}}"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "url = 'https://gist.githubusercontent.com/kthyng/b8056748a811479460b6d5fc5cb5537b/raw/6b531cc5d3072ff6a4f5174f882d7d91d880cbf8/my_var_def.py'\n",
-    "var_def = odg.return_response(url)\n",
-    "var_def"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "dd29ad0d-e2b7-4424-b1be-489b29e6b921",
-   "metadata": {},
-   "source": [
-    "## Search for Data over a Region\n",
-    "\n",
-    "This example demonstrates performing a search in time and space for data to compare with your model output. By default this would search in the spatial bounding box of the model output, but here we instead input a smaller bounding box so as to limit the number of datasets found and used. For several of the datasets, the model output isn't available (must be determined to be on land). "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "61d02b88-9bd5-44a2-9c65-54993e18fdf7",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CPU times: user 18.4 s, sys: 3.39 s, total: 21.8 s\n",
-      "Wall time: 5min 7s\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhwAAALBCAYAAAATXniNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAACTZElEQVR4nOzdeXxbV5k38N/RLlmS9zWOY2dz0iTN0ixN0zZpmqQbbWlL9zIzwMAAA8PSGWAGpnTKsM0wfQu8LO0MLwN0oQVKS4HuaUpXmqZJm7RJHMexE++rJGvfzvuHFmzH9rUd2fdK+n0/H30SX11dPVdXy3PPPec5QkoJIiIiotmkUzsAIiIiyn1MOIiIiGjWMeEgIiKiWceEg4iIiGYdEw4iIiKadUw4iIiIaNYx4SAiIqJZx4SDiIiIZh0TDiIiIpp1TDiIiIho1mVlwiGEuFAI8YQQolMIIYUQ7x9xn1EI8W0hxEEhhC+5zs+FEDUj1qlPPm682/WTPO+d46zfPWadKiHEk8nn/aEQQpdc/i0hxOEx6y5PbuMXY5Z/UAgREULY5+L1GLHuZiHE7uR6LiHEHiGEdcz9B4QQbUKIj45Y/roQ4kdjtvWJZCwfGbP8J0KIV6eyX5nev+T6Inl8Rm1ngnVz9ngLIe4VQhwXQgSEEH1CiMeFEMvGrDPnxztD+/ax5HvXk9xG0RSeV5PHOoOviVkI8X0hRH9yvd8JIWrHrKOp4528/1ohxNPJuKUQYs0426gSQvxCCNGd3Le3hBAfUHheTR7vM309xBR/29Q41kCWJhwACgC8DeBT49xnA7AOwNeS/14LYCmA341Y5xSA6jG3rwLwAXhS4bnfHfO4VWPu/3cAewFcBqAewM3J5S8AWCaEqBqx7rZkLBeN2cY2AG9IKb0KsaSc6esBIcRmAE8BeAbARgAbAPxfAPERq/2/5HZuBvBFIUTdiH0bbx8m2rcXprhfKWe8fyN8FsB0JhDKyeMNYB+ADwFYDuASAALAM0II/Yh11Djemdg3GxLv5W9M43kBbR5rIDOvyT0ArgFwE4DzAdgB/F7jxzt1/ysAvjTJNn4BoBHAVUgcs0cBPCyEWKvw3Fo83mf6ekz1t02d73IpZVbfkPjxeL/COhuS69VNss5+AD9R2M6dAA4orPNrADcikcz9AMAnk8sLAIQB3DRi3YcBfBGAG8DiEcuPA/j3uXw9ALwO4GsKj2sD0JDcl70Azkou35XcXvWIdbsBfAJA+4hl85Pr7VDjeANYjcQHp2qK28nZ4z3OOmcn11mkleN9pvuGxBeiBFA0hefS/LGe6WsCoDAZ340j1qkBEANwSTYcbyR+8CWANePc5wXwwTHLBgB8JJuP90xfj3HWPe23Ta1jna0tHNNViMSL4xrvTiHEOQDWAPjJFLa1JNncdUII8UshxMIx938LwPcAhACsBfBzAJBS+pA4sCOzxK0AnkciY70oGct8AAsx/VaA6Rj1egghKgBsAtArhHhVCNEjhHhRCHH+mMfdBeAwEh+q16WU7yWXvwIggsQXPIQQZwGwIpFFO4UQS5LrXYTEB3VazXAzcNrxFkLYADwE4FNSyu4JHjeenDveYwkhCpBo7TiBREKWkg3He9J9m6ZcONbA6a/JOQCMSLReIhlzJ4BDAM4b8bhsON7jeRnAjUKIEiGETghxEwAzgD0Kj8uV4z2hSX7bVDnWOZ9wCCEsSLxxHpRSeiZY7SMADksplV68PwP4KySaoD+KxJnyq0KI0tQKUso3AcwDMF9KeZ4c3ZS2B6cfyP0AXkwtR+JAhjBLH9oJXo/UB+1OAP8N4FIAbwF4fsQbDFLKnwAoBVAupfz0iOWpD2BqH7YBeFlKGULiDTxy+Z+llP4M71baJMf7/wB4VUr5+DQ2l6vHO3XfJ4UQXiTOEC8FsFNKGU7dr/XjPcXP9lRl/bFOPvd4r0kVgLCUcmjM6j3J+wBo/3hP4kYABiRaNUIA7gVwjZTy+CSPyYnjPQXj/rapdaxzOuEQQhgB/BKJ/fzkBOtYAdyCKbRuSCmflFL+Rkp5UEr5HIArknf99Zj1ohOcRb8AYKlIdOjahsSBjGH0m3QbEhlnQCme6Zrk9Ui9D+6VUv5USrlfSvk5AEcBfHjkNqSUvnG+uIDEvm1L/n8b/nJ2MXbfdp/JPkxmov0TQlwFYDsS/TemLIePd8oDSJy5bQVwDMAjyR+sNK0e76l8tqcj2481MKPXRGBMfyatHm8F/w6gGMAOAOsB3A3gV0KIsX0y0nLheCtR+m1T41jnbMKR/PA9gsR1qp2TnAF9AImOVz+f7nMks8GDAJYorZv0ChLNUNuQyH5fTC5/E0ChEGJpcnnGm+AUXo+u5L/vjXnYYQB1mJrUB3AeEj9gqX17EcC2ZKekBsxS86LC/m0HsAiASwgRFUJEk8t/I4TYM9XnyKHjDQCQUrqllMeklH9C4nOwDImOhVOh2vGexmd7xrLpWAOKr0k3AJMQonjMwyqQaOWYClU/3xMRQixCooPlh6WUz0sp35ZS/hsSr/vfT3U72Xa8p2imv22zdqxzMuEY8eFbgkSnloFJVv8IgN9JKftm8DxmJHr5dymtCwDJTPfPSLxJL0Qyc5RSRpFodvsrJDoDZfRNOoXXoxVAJxI9vUdaikTnoql4FYnmw08i0by4L7n8TSSuKf8dgCASnVMzagr79y0kOkWuGXEDgM8h0Xdhqs+TK8d7wocice17KlQ53mewb9N9nqw41slYlV6TfUhcl9854jHVAFZi6s39qn2+FdiS/8bHLI9hGr9v2XS8p2Gmv22zd6zlDHtLq3lDYkjXmuRNIvHDsQaJs3EDgMeR6Py2Golrc6mbacx2FiPxRr10gud5HolOhqm/v4NExteARCfLJwB4ACyYRuz/lnyMB4BhxPIvJ5f5AZjn+vVA4nKDG4mseDESQ6YCGDFqYQpxvJjchyfHLH82ufx5NY/3mG2e1gM8X443En12/hmJzoR1ADYDeAyJa+AVah7vDL2Xq5KP+dvkNi5I/l2Sbcc6g6/Jj5LrXIzEZbTnARwAoNfq8U7eX5L8+/Lk/Tcm/65K3m9E4nLgn5AYzr8IwO1IfK9fnm3H+0xfjxHbmfS3TY1jLaXM2oRjW/LFHnv7X/xluNB4t21jtvON5IdQN8HztAK4c8Tfv0SiJSAMoAPAb5AcTjSD2MceyPOTy59T8fX4UvL18CGR5Z4/zTjuTG73i2OWfyW5/CtqHu8x2xwv4ciL443EkMg/ItGcHk4e8wcANKp9vDNxrEfENfb2N9l2rDP4mlgAfB+JpNKPxA/sfC0f7+T9fzPB/SOP3ZLk8epB4rvrbZw+TDYrjncmXo/kepP+tqlxrKWUEMmNEBEREc2anOzDQURERNrChIOIiIhmHRMOIiIimnVMOIiIiGjWMeEgIiKiWceEg4iIiGYdEw4iIiKadQa1A8i05ORTJrXjICIiynFhKWVwqivnVOEvIYSlqqoq0N093uR+RERElEHdABqmmnTkWsLhBOA+deoUnE5nxrYbCCRmF7ZarRnbZjbIx/2e6j4//fTTqKiomIuQ5kQkEgEAGI1GlSOZW9xv7neum6199vl8uOKKKwCgUE5xxuacu6QCAE6nM6MJR+pA5dMPL5Cf+z3VfY5EIrBardDr9XMR1qwLh8MAAJMpv65Gcr+537lOS/vMTqNE0zQ0NISFCxfmTLJBRDQXmHAQTdNLL72UbgmJx+MqR0NElB2YcBBNk8/nAwBIKaHT8SNERDQV/LYkmoaOjg4sXboUACCEUDkaIqLswYSDaBpeeOGF9P/j8ThisRgApP8lIqLxMeEgmqLW1lYsX748/bdOp0u3crADKRHR5JhwEE3Ryy+/nP5/qrOoTqdDNBpNL8+lujZERJmUk3U4iDKpvb0de/bsOa11I8Vg+MvHiP06iIjGxxYOIgV/+tOf0NjYqHYYRERZjS0cRJN4++23mWwQEWUAWziIJjF2vhQW+iIimhkmHESTqK6uxuDgYPpvFvoiIpoZfnsSKfB4pjQRIhERTYIJB9Ek4vE4ysvL1Q6DiCjrMeEgmsSJEydQUFCgdhhERFmPCQfRJI4dO6Z2CEREOYEJB9EkBgcHR1USJSKimWHCQTQJIQRHphARZQC/SYkmUVFRwYSDiCgD+E1KNIFYLIaioiK1wyAiyglMOIgm8Nprr6kdAhFRzmDCQTSBzs5OljInIsoQJhxEEwiHw0w4iIgyhAkH0QTMZjMMBk6oTESUCUw4iMYRj8dRVlamdhhERDmDCQfROJqamuB0OtUOg4goZ7C9eJqOHz+Ojo4O1NbWYuHChQASwydfeeUVAMB5552XboZvbW3FyZMnUVNTg8WLF6e38ac//QkAcO6558JkMgEATp48idbWVlRWVqKxsTG97iuvvIJYLIYNGzbAarUCADo6OnD8+HGUl5dj+fLl6XVfe+01RCIRrFu3Dna7HQDQ1dWFY8eOoaSkBCtXrkyv+8YbbyAYDGLNmjXpH9be3l4cOXIERUVFOPvss9Prvvnmm/D7/Vi1ahWKi4sBAAMDA3j33XfhcDiwdu3a9Lr79+/H8PAwVqxYgdLSUgDA0NAQDh48CJvNhvXr16fXfeedd+ByubBs2TJUVFQASMzMeuDAAVgsFmzcuDG97qFDhzA4OIglS5aguroaAOD1evHWW2/BaDRi8+bN6XUPHz6Mvr4+LFq0CPPmzQMABAIB7N27F3q9Hlu2bEmve/ToUfT09KC+vh51dXUAEn03jh49CrPZPGriNq/Xi0AgAJvNlp5fJR6PY2BgAABQVlYGIQQAwOfzwe/3w2q1po+FlBL9/f0AgNLS0nR9D7/fD5/PB4vFAofDkX6+/v5+SClRUlICvV4/al2z2TwqIRoYGEA8HkdxcXH6/RcIBOD1eidct6ioCEajEQAQCoXg9Xphs9lQWFiYXndwcDA9PHjkuh6PB0ajcdSw4aGhIUSjURQWFqbf1+FwGG63GwaDIf3eAQCXy4VIJAKn0wmz2QwAiEQicLlc0Ov1KCkpSa/rdrsRDofhcDhgsVhGravT6dLvMyDx/gmFQrDb7enPSzQaxdDQ0Ljr+nw+2Gy2dLyxWAyDg4MQQoxq4RoeHkYwGERBQQFsNtukx36898lEx3689wkA9PX1nbbudN4nSse+oKAg/T4JBoMYHh6GyWRSPPapdady7Cd6n4x37JXeJ+Md+6m8TyY79mPfJzM99tnyHaEFTDgUxGIxhEIh6HQ6WK3W9IcoFAqNWm+8KcxT6478UIxcd2SHxHA4DI/HM+oDn1o3FouNu+7ILygg8WYPhUKj1o1EIvB4POkP4Mh1/X4/YrHYaeumvlxSfD4fhoeHR60bjUbh8XhOK4rl8/ng8XhGlQOPxWLweDyQUo67biQSOW3dseXE/X7/aevG43F4PJ70l1ZKIBCAx+NBOBw+bd3UhzIlGAyetm4sFoNerz8thlgshmg0elpH0vFKn2di3ZH7OnI/otHoaccoEomc9vqm1h3bD2W850qtO/IYp9aNxWKjtp1aN/XFOXLdsdtOrTvWeOtKKRGNRk/bj8ley7Hvv8nWHRtvKrapHKPJXp/ZXHe81328daWU46470bEfb92xn43xjn3qGI193VPHc7x1J3qfjLfuWKnjOd66U3mfTBTvZOuOjXeydSeKV0vfEan3hpTytH2ba2LsQctmQggnALfb7c5YZtfZ2Yk33ngDJSUluPDCC9MZ7FSyUqWzl/Gy0kycvYx3ljuTs5dAIJBePtHZy9gzktSZzmydvUz1zHWmZy+plpDU6zcymUl9Aev1+vT9Usp0smIymdIf6Jmsq9PpRiUSqaR2Ousajcb0+y/1JTWVdQOBAGKxGMxm86h1w+EwpJTjblcIkX4/TLRuPB5HJBKZcF2DwZB+X0+0biQSQTweH3fdscdouuumTiZSZ64jj9F4252tYz9y3ZHHaKbvE6VjL6WETqeDyWSacN3Jjv101p2tYz+T90nqGAghTlt3psde698RPT09CIfDKC0tTb/PM8Hr9WLbtm0AUCilPP2MexxMOBSMTTjySSrhSP1o54NAIIBHHnkEy5Yty6sRKiO/5PIJ95v7neu0lHDkzzfqDNXU1OCSSy5ROwyaI9FoFOXl5XmVbBBR7kr1n9FCksVRKkQj/OlPfxp12YeIKJsJIdI3tTHhIEqKx+Pw+/2sLkpENAuYcChwu904cuQITp48qXYoNMtefPFF1NbWcjp6IsoZgUAAw8PDo0biqYXfrAp8Ph/a2trQ09Ojdig0y/r7+08bckhElM2CwSD8fv+4w23nGnvGKbDb7WhoaMho717Snt///vdYuHChJs4CiIgyxWKxwGAwaKIjvPoRaJzT6cTSpUvVDoNmkc/nS1cvJSLKJamyBhylQqQBBQUF6Onp4eUUIqJZxIRDQTweRywW449Rjrv88stx7NgxHmciyikjS5urjQmHgu7ubjz33HN466231A6FZtnI8sBERLnA5XKht7c3XTlaTUw4iJIWLlzIIbFERLOEnUYVVFVV4eKLL+aZbx5YtWoV/vSnP3FEEhHljNSknWNn1VYDT+cU6HS6UTMKUu4ymUwIhUJoa2tTOxQioozQ6XTQ6XSaOGlmCwfRCNu3b0dPTw8GBgbUDoWIKKewhUOBx+NBU1MT2tvb1Q6F5khlZSVOnDjBEStElPWCwSC8Xi8ikYjaoTDhUOL1enHixAl0dXWpHQrNobPPPhuDg4OcyI2IslogEIDP52PCkQ0KCgqwYMECVFZWqh0KzaGlS5diy5Yt6O3tVTsUIqIZM5vNsFqtLG2eDQoLC7Fs2TK1wyAVOBwODA0NoaysTBMfViKi6UqNumNpcyKNKykpYbJBRJQBTDiIJsGOo0REmcGEQ0FnZyeefvpp7N27V+1QSAVlZWVqh0BENGMulws9PT3w+/1qh8KEg2gy9fX1aodARDRjWpi0LYUXpxVUVlZi27ZtmqjSRnPvxIkTmigJTEQ0E4WFhZBSauJ7jC0cCvR6PcxmsyZ6+NLc6+zsZC0OIspaOp0Oer1eExNTqh8BkYax0ygRUWYw4VAwPDyM48ePo7OzU+1QaI719/dzynoiymqhUIiVRrPF8PAwmpub0dHRoXYoNMf6+/uZbBBRVvP7/ZxLJVvYbDbMmzePwyPzUEtLi9ohEBGdEZPJBIvFAr1er3YoHKWipKioCCtXrlQ7DFJBJBJBPB5nKwcRZa2CggIALG1OpGlaKJRDRJQrmHAQTcBut7N1g4goQ/htqqCzsxPPPfcc3nzzTbVDoTnG+htElO3cbjd6e3s10WLLhGMKYrGYpsrD0tzQQicrIqIzEY/HNfP7xU6jCioqKnDBBRewaT0PeTwelJeXc3p6IspaTqcTUkpYLBa1Q2HCocRgMMBms6kdBqkgHo9zDh0iymqpllotnDSrHwGRRlVVVfGyChFRhjDhUOD1etHa2oquri61Q6E5tmPHDrS0tLDzKBFlrVAoBL/fz0qj2cDj8eDo0aNob29XOxRSQTgcVjsEIqIZ8/v9GB4e1kTCwT4cCqxWK6qqqmC329UOhVQghGA/DiLKWiaTCUIITVweZsKhoLi4GKtXr1Y7DFKJlJIJBxFlLZY2J8oSN998M44cOYJYLKZ2KEREWY0JB9EkdDodiouLNdEcSUSUzZhwKOju7sbu3buxf/9+tUMhlSxatEjtEIiIZsTtdqOvrw+BQEDtUJhwKInH44hEIohGo2qHQippbGxEZ2en2mEQEU1bPB7XTHlzdhpVUF5ejvPOO49N6nlOC1X6iIimy+FwQEoJs9msdihs4VBiNBrhcDhY3jzPDQ0NseMoEWUdg8EAo9GoiZNmJhxEU8ChsUREZ4YJhwKfz4dTp06ht7dX7VBIRdXV1dDr9SxzTkRZJRwOIxAIaKIf4hklHEKIfxZCSCHEPcm/jUKIbwshDgohfEKITiHEz4UQNWMe1yiEeEUI0S6EuGPMfa3JbZ47Zvk9Qog9ZxLvTLjdbrz33ntoa2ub66cmDdm+fTtOnjzJvhxElFV8Ph88Ho8mpmmY8benEGIDgI8BeGfEYhuAdQC+lvz3WgBLAfxuzMN/AOAXAK4GcKUQYsuY+4MAvj3T2DLJYrGgvLwcRUVFaodCKrvmmmtw+PBh9uUgoqxhNBphMpk0cbI0owiEEHYADwD4KICh1HIppVtKuVNK+YiU8qiU8nUAnwZwjhCibsQmigDsRyJZ6QRQOOYp7gVwrhDi8pnEl0klJSVYt24dlixZonYopAFXXXUVenp6AEATw8yIiCZjt9tRXFwMi8WidigzbuH4AYA/SCmfm8K6hQAkANeIZXcAeBaAH0AcwNNjHtMK4McAvimEUD8tI0pyOp247LLL0N7eDiklkw4ioimadh0OIcRNSFwu2TCFdS0AvgXgQSmlJ7VcSvlHIUQ5AKeUsm+Ch/87gA8BuBWJyy9TFggEYDQap/MQxe3lo3zc76nu865du/DCCy/AarXCbDZn/SgWLUxdrQbud37Jx/2erX2eyXan1XoghJgP4LsAbpNSBhXWNQL4ZfI5Pjn2fillaJJkA8n7vgPgLiGEatPc9fb24tVXX8WhQ4fUCoE06qKLLkJHRwdHrhCRZg0PD2NgYADB4KQ/2XNiui0c5wCoALBvxBmdHsCFQohPATBLKWPJZOMRAA0Ato9s3Zimu5FIVk5LWCZjtVphtVpn+JSjGY3G9HCiTG0z2+Tjfk91n5csWQKDIXcK9mphCms1cL/zSz7ttxACQggYDIaM7vdMRr1M95vyeQCrxiz7KYAjAL49JtlYAuAiKeXAtKNKklJ6hRBfA3AngCdmup0zUVZWhk2bNmmiShtpj9PphN/vVzsMIqJx2e12ANBEafNpJRxSymEAo64tCCF8AAaklIeEEAYAv0aij8f7AOiFEFXJVQellDMZCHwfgM8BuBnAn2fw+DNiMpk4JJYm1N/fz7L3RKRZqf6MWjhpzvQIkFoAVyX/PQCga8TtvJlsUEoZAfCvANQf00M0hscz06uFRET55YwvPkspt434fyuAM+quL6WsH2fZQwAeOpPtzpTf70dXVxfMZjNqa2vVCIE0zO/3Ix6Pa6KoDhHRWJFIBLFYDDqdTvX+ZvyWVOByuXDw4EG0tLSoHQppUCgU4igVItIsr9cLt9utidLmudO9fpaYTCaUlJTA6XSqHQppkF6v18S1USKi8RgMBkgpNdEKy4RDQVlZGTZsUKxxRnkoGo2iuro664t+EVHucjgcALQxFFj9lIcoS73xxhvpDzMREU2OCQfRDEQiEbS1tXHmWCKiKWLCoaC3txcvv/wyDh48qHYopCGPPvooli5dyv4bRKRpWiptzoRDQTQahc/n08TBIu3hCBUi0rJoNIpoNKqJ7yomHApKS0uxfv16NDY2qh0Kacj111+Pvr4+hEIhAEw8iEib7HY7ioqKNFHanAmHArPZjNLSUg6LpVF0Oh0uvfRSmM1m9PT0oK+vD1JKtcMiIhrFaDTCbDZr4vIvh8USnYHUkOmhoSEcPXo0PW8BERGNxhYOBYFAAD09PRgaGlI7FNKw4uJitLW1sZWDiDQlEokgFAppYkQdEw4FQ0NDOHDgAJqbm9UOhTQuGo1q4kNNRJTi9XrhcrnS/c3UxEsqCoxGI4qKimC329UOhTROCMGqo0SkKQaDQTMTTDLhUFBeXo5NmzapHQZlgbVr18Lv96sdBhFRGkubE+Wg5cuXo6WlhUNkiYjGwYSDKIOKi4s10XRJRKQ1/GZU0NfXh9deew3vvfee2qFQFti8ebPaIRARpQ0PD2NwcFAT1bLZh0NBJBKBx+OBwcCXipRxWCwRaUk0GkUkEtHEpV7+iiooKSnB2rVrNdHhhrTPbrfj+PHjqK+v10RlPyLKb3a7HbFYTBO/YbykosBisaCiogJFRUVqh0JZ4txzz4Ver2drBxGpzmg0wmKxaKKVngkHUYalEg3W5CAi+gsmHAqCwSD6+/vhdrvVDoWyRE1NDaLRqNphEBEhEokgEoloogoyEw4Fg4OD2LdvH5qamtQOhbKE0WhEX1+f2mEQEcHr9WJwcFATpc2ZcCgwGAxwOBywWq1qh0JZxOVyaeKMgojym16vh16v18QlXvV7kWhcRUUFzjvvPLXDoCxjMpk08QEnovzmdDoBsLQ5Uc7SyhkFEZFWMOEgmgXBYJCXVIiIRmDCoaC/vx9vvPEGjhw5onYolEWEEJxThYhU5/V6MTQ0xNLm2SAcDmNoaIjN4zQt5eXlTDiISHWRSAThcJilzbNBcXExzj77bE10uKHs0N/fj5KSErXDICJCQUEBLBaLJn7DeAqmwGq1orq6GqWlpWqHQlmiubn5jLdhf/NNnLN+PfTDwxmICFhw551YdPvtGdmWGs89ldej9IknsHrbtjN6nqmqvvdeLL/lljl5LqIzYTKZYLVaWdqcKBf19/erHQJhZknBOevXo3DPntkJiCjPMeFQkOrDMZyhM03KfcPDwyxtTkSakJqeXguj5tRvY9G41CiVkpISVFRUqB0OZQEp5ekdRqVE5c9/jvJHH4Wxvx/Bujp0feQjcO3YAQBwvvwy5t99N0w9PfCtXImB971v1MOr770XRS++iMMPPpheVvHgg6h46CEceuKJKcdW+YtfoPL++yGiUQzu2oVTt98OJJtaN593Hpq/8x24R1yWWL1tG9pvvx0DV14JU2cnVl11FVq++U2UP/wwCg4fRmDRIpz42teg93pR961vwdLaCu+aNWi96y5Ei4tH78N996H8V7+CLhxOPPcXvgBpNAIARDiM2u9+F8XPPAO9zwf/8uU49fnPw79ixYT7UvrEE6j58Y9hcLng3rwZ3jVrRt/33/8NINFqAQCtX/0qBq68csLtrUzet/gf/xEAEKquTr+2lf/7v6h88EHogkEM7dhx2r4tuPNOGIaH4W9snHAfidQwPDyMcDiM0tJS2Gw2VWNhwqFAr9fDarXCbDarHQplgVgshtra2tMSjpof/hBFL7yAk1/6EoLz58Oxfz8a7rgDx4qLEZo3D4u+8AX0XXcd+q67DgWHD6P2nnsyHpvjzTcRKSvD0XvvheXUKTT88z8jsHQp+q+5Zlrbqb73XrTffjvCVVVYcNddaPjylxEvKMCp229H3GLBwn/+Z9T8+Mc4+c///Jfn3rsXcZMJTT/+MUxdXaj/t39DtKgInX//9wCAed/7Hop270brnXciXF2Nyp//HEs+/Wkc+u1vESssPC0G26FDWHDXXej4+7+H66KL4HztNdTce2/6/sGdO2E5fhyFr76Kph/+EAAQs9sn3a8jP/85Vu/cidavfhXuzZsBvR4AUPzss6i5916c/OIX4V2zBqV//CMqHn4YoXnzRr++CvtIpAadTgedTqeJkZZMOBRUVlbiwgsvVDsMyhKHDh1CQUHBqGW6QACVDz6Iph/9CL6zzwYADNTWwn7gAMoffRShmhqE5s1D++c/DwiBUH09rM3NqPrZzzIaW9TpxMkvfAHQ6xGqr4f7/PPheOONaSccPbfdBs/mzQCA3ptuwsIvfzmxb8kWhv6rr0bZmFYXaTSi9atfhbRYEFy0CJ1/93eo/d730PmJT0AXCqH8179G6513wrNlCwCg7StfgfPKK1H2+OPo+au/Oi2GyocegmfzZvT8zd8AAPoWLID97bfhfO21xPNZLIhbrZAGA6JlZVN7fZKtFlGHY9RjKh56CANXXYWB978fAND5yU/C8cYb0IXDU95HcIg0qaQwmbBrYZQKEw6iDDp27BgWLFgwqoXD0tICXSiEJWPOdEUkgkBjI0QoBN/KlcCIMxDvqlUZjy24cGH6rB0AImVlsM5gRE1gyZK/bCM5eiuweHF6WbSkBIahoVGP8S9ZAmmxpP/2nX029H4/TD090Hu90EWj8K1e/ZcHGAzwrVgBy4kT48ZgOXECrosuGrXMd/bZ6YQjkywnTqDv2mtHP9eqVXDs2zdq2WT7GK6uznhcRNmGCQdRBgWDQUgpRy9M/t18zz2IjOkHFDcaUfef/6m8YZ0uvZ0UMc2OqXLssDghIEYUA5JCQEzhOU7bzthlQgBTLDIkhUjvlxzT5CukHJWEZaux+0WUr9jOp2BgYAD79u3D0aNH1Q6FNC4ej6OsrAz6Ea0IABBsaEDcZIKpuxuh+fNH3SJVVQgsXIiCQ4dGPWbs35HiYhgHBkYlHdampozGHykqgnHEkF7zyZPQZ6gcsu3YMYgR2yo4eBAxmw2RigqE5s9H3GiE/cCBvzwgGoXt8GEEGxrG3V6woQEFBw+OWjb2b2k0QkyzZ37cYDjtMcGGBsXjA0y+j0Rq8fl8cLlcCIVCaofCFg4loVAI/f39migLS9q2d+9elJeXn7Y8XlCAnttuw/y77wakhHfNGui9XtjfeQcxmw19112HyvvvR+3dd6Pv2mthO3LktD4Q3nPOgWFoCJU/+xmGduxA4auvovDVVxEb01/kTHjOOQfljzwC76pVEPE45n3/+4hnqFiQiERQ/7WvoesjH4Gpqws1992H3htuAHQ6xK1W9H3gA6j97ncRczoRrqpC5c9/Dl0wiP6rrx53e7033YTGD38YlT/7GVzbtsH5+uunXU4J1dTA1NkJ69GjCFdWIm6zQSpcxw7X1MCxdy+8q1dDmkyIOZ3ovekm1N95J/zLl8O7Zg1KnnoK1paW0zqNTraPRGoJh8MIh8McFpsNioqKsHLlSk10uCHtOnLkCDweD5xO57gV/To/8QlESkpQ/dOfwtTRgZjDAf+yZej+0IcQqapCy3/8B2rvvhvlv/41fCtWoOPv/x71d92VfnywoQEnv/hFVP/0p6j+yU/g2r4dPbfdhrLf/jZj+9D66U9jyTe/icaPfhSR8nKcuv122A4fzsi2hzdsQLCuDo0f/ShEJILBXbvQ9bGPpe/v+NSnIOJx1N9xB/R+P/zLl+PY97+PmNM57vZ8q1ah7StfQc1996Hmvvvg2bgRXR/5CKr/53/S67i2b0fx7t1Y+vGPwzA8rDgsFgDaP/tZ1P6f/4Py3/4W4YoKHHriCQzt2gVzezvmff/70IXDGNq+HX3XXQfn669Pax+J1GCz2WA2m2HUwPBscdr15iwmhHACcLvdbjgn+KKaiUAgACBR5jyf5ON+z3SfH7r/fqzz+WDs70ekrAzetWtHddDUunByxEW+JdaZ2u9UHY7j//VfmQhr1vF4589+z9Y+e71ebEvU7CmUUnqm8hi2cBCdqUcfxdWf/SxsAwPpReGKCpz6x3+Ea/t2FQMjItIOJhwKwuEwPB5PugAY0SiPPgp84AOwjmkpNPb2YuEXvoCW//iPOUk61lxwwYT3NX/ve4kWlzxX8uSTqPvGN8a9L1xdjfceeWSOIyKafbFYDFJKGAyG0ysgzzFeUlHQ2dmZLm2ebwXAeElFQSwG1NcD7e3j3i0BxG02HHjhhVm/vGI+dSr9/4avfAWBhgZ0f+QjAIBwefmo+hDjGdvsWvrEE6j9r//C25NMZDZeufWpsL/5Jho//nEceOEFxByOaT32TOh8Pqz4wAcwcOWV6b4ckUgEAGCwWs+4VsZMX4/pWHnllei9+Wb0nuFMtfl4aQHIz/3u6emZldLmM7mkwu7TCnQ6HUwmkyY63JDGvPTShMkGAAgAer8f9v37p7zJmU5LP3KobdxsRszhQGj+fFT95CdY+OUvT2tbMzV2GnqtTUsfLyhIVB4tKkq/VsHaWgRra7HqyitVmyU2EzPUTvRaj3xtln7sY6jNkj4mlDlaKWsOMOFQVFVVhYsuughrRkwMRQQA6Oqa0mpGTlc/p2YyLf0ZkRLIwtmB1157LSqm2hoTi025mBtpS2FhISoqKlSfuA1gwkE0c1Nsgi968UWs3r4dZ19yCaqTE4yZOjtxzvr1sI4oKKcfHkbjxz+e/jt1du987TUsv+UWrN2yBUs+/nEYBgfhfOUVnPWBD2DN1q1o+Jd/GVVwCkhUCJ3/7W+j5Kmn4HzlFdT88IejiobpPR7U33EHVl90EdZu2YJln/88LCMuy4yn8n//F2fv2oU1F16IBXfdNWoukep770XZ73+PohdfxDnr1+Oc9esVE62Ct9/G8ptvxtrzzsOyv/5rWEaUWde7XGj4l3/Bwi99CQDQ+OEPo/ipp9L3l/z+91h98cUQY+YzWfhP/4SiF16Y9Hl1fj8avvxlrLngApxz1VWo+tWv0vdNdFzOWb8e9jffBDD6uCz74AexdvPm0UXLUtvq6MCK978fdd/8JhCPQ0QimPfd72LVZZdhzfnnY9lf/3V6mylFzz+Ps264AWs3b8bKK69Exf33T7ovFfffj7NuvBGlTz4J5+uvY/63vgWd35+Os/7f/g0GrxfnrF8Px1tvpYuj6T0eGF0uzPvBD7B2yxYs/od/gPnkyfR2Uy0jhS+9hLOuvx7rzjsPpikm2EQTYadRopm64AKgthbo6Dit7DiQ6MMBIaB3uxG3WmEYGED1f/83EI9jIFnQqmD/fiz8539OTEu/bNm4T7Pwn/4Jx/7v/03PxNr44Q/D1NuLI//v/0EfCGDRP/4jKn75y/REZgBQ+oc/oP/qq+E+/3yYurtR+fOfo/zhhwGDAYO7dsHU3Q1zezuO3303Gj/6URgHBrDs9tvx3q9/DRgMmP+tbyHVCJuall7q9QjV1EA/PAznq69C7/MhUl6OZR/8ICwnTiBcWorgwoU48bWvAUjMAGvw+U6bln5oxw4AQO13v4v2z3wGJU8+ieLdu3HWTTfBd/bZOHX77YiUl8O/fDk8Gzag/utfx8D73oeGr34VodpaWE+cQM2PfgS9242lf/u3GNq1C0AiSSn605/SlUInmpa+6he/QNeHPoTOj30MBS+/jPrvfQ8AYHC5UPf1rwMAFn3+8zj1hS/AvXVr+nGLP/tZHHj55fTfdd/4BsxdXTj42GOI2e2oue8+WNraUPr445j3wx/CMDCAQGMjTn7hC6j8xS8Ss9nGYhh43/vQ/aEPofiFF7DkH/4BQKIVbOmHP5woBudwoP0f/gFxux113/oWYoWF8C1fjvnf+U6ioNgPfwjLiRNo/9znAJ0OJ//pn1D+yCMw9ffDuXcv8L3voeMzn0HZY48hbjRCRKPo/Nu/ReHrr8Pf2AgAWHvjjaOqyBa++irMn/kM3v3Vr4BkHRldMIiqn/4UbV/5CqKFhYiWlIz7/iSaKrZwKBgcHMSBAwfQPINJrijH6fXAd7+b+P+Ya6Sp9CPqdMLU24u2r3wF7/761wjX1KD6pz+FLXmmOf+ee+DesgXvPfAABq+4YtyniZSVwbdmDQLLlqH/6qthaW9HpLAQgWXL4F27FkMXX3zaRGLhykq0f/7ziNntsJw6heDChYgWF6P1zjtR+vjjKHrpJbR95Svp0SudN94IU18fiibpSxCz2XDqC1/A4QcfTHSwlBLGvj6cuv12HP2f/4E+EIC5vR3RsrLEbKs6HRx798Jy4gSafvxjtHz96yjaswelySqqXR/9KJyvvw7HW2/hxL/9G6TJhLjBgCWf/jTiZjN6PvhBhObPBwD0X3stPOeei4pf/hIL7roLvTfcgMFLLoE+EED1T34CACh98kmEKyvRfeutCCxciLefegpvP/UUBnfuHLUf3tWr0fM3f4PQggXovv56DCT7ONT893/Dff75iXXWrEHDv/4r9G73hK/H4CWXJF7r2lrEiooAACIcRsmTT0KEQhi48kpYWlqw+LOfhbWlBSISQcc//APKH38cxqEh9Hzwg/AmL9XO+9GPIGIx+FavRt8NN2D+PffAt3Ilem+4AZU/+xmWfPrTiDkciJSVYeB974PzjTcw/z/+A7233ALv+vWI22yIFhej4xOfQMmzz2Led78Lx/796L3xRsStVhQcOQLr8eOQRiPMJ0/C6HYjXFyMjo9/HG8/9RQOPfIITL29o46/LhrFyS99Cb7VqxGqr0c8jzqP5xKfzwe3262J0uZMOBQEg0H09PRgaMzsl0QAgGuvBX79a2BMmetIZSWC9fUwDA+j7Y474Nm8GeHaWgQWL0aothalTz8NIFGvo/3zn0eovh5DY34YU+IjetRHS0oS5cZHVDONlJbCODg46jEjZ5+NOp3o/Nu/hbmrC+7zzoN/+XJIIRLrpJ6joADBujpYJ5idFQCGLroIns2bEWxoQO9NN0EfDCJSWppOhoJ1dTC4XKMeI8JhFL78Mpb9zd8kpmr/u79LX/LwL12K8l//Gu2f+Qxcu3YhWF8P77p1iJvNKPvtb1H1k5+gPtlasuqyy+B8/XXY9+9PT0vf88EPwnLyJIaTP9qlTzyB/quuQtxmg87vx8prrsHKa67B6p07R3Xc9Y2ZiXc4+ToMvO996RaNvhtvhC4QQMG77074egSTydAoUqLg0CF0ffSjaPvqVzG8fj0sbW1wbdkCISVqfvxjSCGw9GMfw5oLLkgnikM7dkAXjcKzaRM6P/EJ+JYvR/nDD8O7ejUsJ09CFwyi9a67II1GhOrqcPKf/gmlf/wjCp9/Hks++UkUP/ssCl9+GQ1f/SoMbjfKHnsM7Z/5DIKLFkHqdGi98850y4/lxAnE9XrETaZEolJWhtDChQguWDDq+MeNxlEzA1N2CofDCAaDLG2eDZxOJ5YvXw6z2ax2KKRV114LXH01Tj7wAKKnTqUrjS7767+GiMdHTUuvC4UAKRFPvp8CixenE4MJZ38d2XoixPhDbCcZ3h5cuHDUfB6TDUWdbGbTSGXlX/6fnJZ+5Nwk0myGSA4zTfGddRba/u3fEvcbDNAPD0OfPNMydXWdPi29Xg/fihUofv55mDs70Xfttaj+6U9x9H/+BzU//jHs+/enE4bAsmXwL1mSmFU2FoO1uRnNd9+NsscfR8xux7Ef/Si92fA4c9yM5V+yBDL5OqV+jA2DgxMel/HmZZFGI/wrVqDkmWfQf/XViJaUIKjTQQCQej0O/+IXqL/jDgQXLUL3hz8MAFh5zTXwrlqV6F+RfP19q1bB1tQEz7nnJvZ1yZJRLQzeNWsg4nEs/MpX0PeBDyBuNCYuWV16Keq/9jXoolF4zz47cYkFQKywEMEFC5JBTvxeGXn842ZzTszWm+9sNptmRlqyhUOB3W5HXV0dKkd82RKdRq/Ha2YzBnbtgnf9+kRSMGJa+sMPPojDDz6I4fXr4dq2Dce/9S0AievkKdaJZiSeYLr7yYyczVQaDCg4dAjBujpAr0e0qAgieSYOJH5k9D4fLCdPIlhfDwDjzrJqGa/1Y8QPkhyxz+llJlN6COrYOhe2Y8f+8vweD8zJ5xdSwjg4CNfWrfBs2gQgUZjLMqJTY0r/+9+PgnffTbQObNyISFVV4g6dbtRQ4ZF1SMbOKutItmKkhswCiT4VUggIKSc8LuMmIjodmu+5B3GzGUs+/WkgFoM0GOBvbISIxWAcGoK0WBCz29OxpQQWLhzV+VQKAfvbbyPmcKQTodNiiMfR/rnPIVpcjLjNBmNf36j740YjxJjRJcGFC6GLxUYlh3qXC5a2tvTxp9xhNptRUFDAhIMol1it1lHj3eNWK6RON2pa+rjVilhBAcILFiBcXg7722/D0tIC+1tvYd6IM/KRjIODo3/IpzA80dTTg9q774be64WxtxcVDz+M3ptuApBo4YgUFmLB17+OggMHEHU4MO/++xEuL4dr2zaYT56Ebpwf06IXX0Tp44/D3NaW7ocxUrSoCCIeh7m1FXqXC4jHx5+yPdm6U/rEE4jr9Sh++mnU33knokVFcJ1/PmyHDyNUXQ3nn/8My/HjAID5d98N48AA4gUFoxKGwUsvhcHthohEMHDVVQCUp6W3v/02Kn/2M5jb2lD5m9+gdMSoFmmxwLtqFap+9jMgHoe5rS19XHTBIHTJwnAAYE0mTGPFrVY033MPpF4P55//DMRiCC1YgIHLLkP9V78Kw9AQdF4vbO++i8r//d/E63LoEHpuuw2OvXtR9T//A3vyUkvFI4/AdcEFsDU1jXpu+4EDiYQoFkPFww9D5/PB2NOD8kcfTcSg18N+8CDC1dXQ+/0o3LMH5rY2IBpFqK4OgxdcAKPHA9OpU7A2NaHhjjsQrqiAawr1TIhmigmHgmg0Cq/Xm65ASTSeAwcOYN68eaML7Oh08C9bhvl3342S3/8epvZ26LxeWFpbUfL73+NEcmjpWTffjLpvfAOeDRvG3bbB5ULlz34GU3s7HG+8MfGllxEGrrgCulAIhS+/DOuxY+i98Ub0X3tt+v7gggXwL1uGxZ/9LAxeL8zd3Wj7+7+HrakJdd/8JuLjnFH3X3MN5n3/+1j+wQ/COGLemJThdesgdTos/6u/wpodO2AcHExP2W5paUkMz73vvvSPWkdyJEbt978PS2srTn3+86j79rcT/RXuvDPx2iVHkERKSuDatg2hefPgfO21dMJQ+oc/pM/+U9sdOS293uU6behsz223wXbkCJbfeitqf/pTtH7qU6Pub7vjDohoFHq/HyVPPYWOT3wCQOIyS80PfgBTshWhJNkPZzxxmw3NydjtBw9CFwgkRstccQXMHR0o+8MfsPjzn0/3ESl+7jnYjh7Fqc9/HhW//CVsTU2wtLai8+Mfx8kvfQlxkwn1X/0qRCQC86lTqPvP/8TAFVfg1Oc+h8qf/QzFL74IU08POpKX7wYvvxzzvvtd6EIhDO7YgYVf+hL0oRAKkrP/Nn/5y4gWFqLi0Uex7EMfggiH0fzd747qG0S5IR6PIxaLIa6BOiosba6Apc1Z2nxSsRjw0kt4+Ve/QvnZZ58+S6yUKH/4YVT86lenTUvvXbcOhS+9hNq7704Mi12xAgNXXon6u+4aVfa77Ne/RvVPfwq9xwPX9u0ILliAst/+FofGaWUYa7xZTGv/679gO3oUTffdBwAw9vWh7qtfhePgwfS09A1f/jLab78dA1demR4W+94DDyCQHFY5XnnyseXQU8/tX7oUFY88kp6y/dQXvpDu/yBCIdR+73sofvrp9LT0pz7/efhXrJj4eR5/HDX33QeDywXPxo2wtLXB1NWF/a+9lthmOIyGr3wFjr17FaelT5W63nzeeWj+znfgHnGGv3rbtvRrAACFe/ag9rvfham3F56NG+G+8EIs+PrXsS9ZS2O80ubjvf5LP/Yx+Bsb0Z6sDHrO+vU4+cUvomjPHtj370ektBQdn/oUhpKjYADA0tyM+d/5DuwHDyJusWBo+3a0f+5ziCeLOY19Hp3fj7pvfhNFL7yAeEEBem69FYUvv5x+3nA4DPuhQ1j0n/8JS1sbdOFwej9yGUubq1vanAmHgq6uLuzbtw9FRUU4PzlkLl8w4VDw6KPAZz4zqrx5apbYga1boef09LNK73bD+frraPjXf8W7jzyC0Az6H2TjfmcC9zt/9ru3txehUEgTCQfbzxRUV1fj4osvVjsM0ppHHwWuu+60xalZYjFHs8Tms+W33QaDx4OOT396RskGUT4oSnaE1kKSxYSDaLpiMeBjHxv3LoFE0a+6r38drq1bZ32W2Hyeln4ql5SAyaelD1VV4e0HHshkWEQ0ASYcRNO1Zw8wTqfJFAHA6HbDvm8fvBs3zmook02FPpXaE/nAdeGFo4qcjRTSQEc6onzBhEPB0NAQjh07hoKCAqxIdmSjPDfFqcQdc5BwhMardkmjxAsKECooGPe+8JgRLES5xu/3IxqNwul0qn5ZhcNiFQQCAXR2dmJgkjNaonHlUIdsIspOoVAIgUAA0SkMp59tTDgUOBwOLFmyBPPGzJVBeWyKxZGGk7OVEhGpxWq1aqbSKC+pKHA4HFi4cKHaYZCWbNuGoN0Os9eL8WaakACihYXwnnPOXEdGRDSKJVnWXwsJB1s4iKYpEA6j4447APxlGvqU1N8nv/zlWR+hQkSUTZhwKIjFYggGg+xcRmmPPfYYXNu3o+U//gORMSNBIhUVaGENDiLSiHg8jng8Di0U+eQlFQU9PT15W9qcTtfb24sFyWm+Xdu3w7V1K+z798PY35+elp4tG0SkFW63e1ZKm88EE44pGDUhF+W15557Do3J+UQAAHp9Yjp6IiKaFBMOBTU1Ndi1a5faYZBGzJ8/H/F4HLpxZlMlItIaljYnykLvvPOO6k2SRETTkWqh10JLPU/TiKbo3XffRSwWUzsMIqKsxIRDgcvlwnvvvYfW1la1QyEV7d27F0uXLs2qKeeJiAKBAIaHhzUx0pIJhwK/349Tp06hr69P7VBIRUePHtVEaWAioukIBoPp+VTUxj4cCux2OxYuXMhr93nM7/ejrq4OBgM/LkSUXSwWCwwGgya+v9SPQOOcTieWLFmidhikoqeffhrzOSsrEWUhq9UKQBujVHhJhUiBz+dDPB5XOwwioqzGFg4F8XgckUhEE0OKSB1ms5l1N4goK6VKmkspVf8d47eogu7ubuzevRv79+9XOxRSwcmTJ1FfX6/6B5WIaCZcLhd6e3sRCATUDoUJB9FkXn75ZU1MekRElO14SUVBdXU1du7cqXYYpBJeSiGibFZUVAQpJcxms9qhsIVDiRACOp2OPzx56uyzz+axJ6KslfoN08JlYX6TEk3irLPOwpEjR1jSnIjoDDHhUODxeHD06FGcOnVK7VBIJZdffjlCoZDaYRARTVswGITX62Vp82zg9XrR2tqK7u5utUMhlZSUlMDj8agdBhHRtAUCAfh8Pk2UNmfCoaCgoAD19fWoqqpSOxRSkcfj4WUVIso6FosFVquVpc2zQWFhIRobG9UOg1RWXl7OmWKJKOtYrVZYrVaWNifKFj6fj/U4iIjOABMOBVJKxONxzqWR54aHh3lJhYjoDDDhUNDV1YVnn30W+/btUzsUUpFer2c9DiLKOkNDQ+jp6YHf71c7FCYcRFNRUVEBAGzpIiKaISYcCqqqqrB9+3asXbtW7VBIRRdffDEGBwchpWRfDiLKGoWFhSgrK4PValU7FCYcSnQ6HYxGoyaGFJG6LrnkEvT19SEajbKlg4iygk6ng16vZ2lzomxzxRVXQKfTsS4HEdE0MeFQ4PF4cOzYMXR0dKgdCmnExo0bsWTJErS1takdChHRpILBIHw+HyKRiNqhMOFQ4vV60dLSgs7OTrVDIQ2pq6vDtddei8OHD/PyChFpViAQgNfrZcKRDWw2G+bPn4/y8nK1QyGN0ev1uPHGG9HW1sbLK0SkSWazGRaLRROVkplwKCgqKsJZZ52F+vp6tUMhDTIajdiyZQuamprg9/s5ioWINMVms6GwsBBms1ntUJhwEJ2p6upq3HbbbTjnnHNw/PhxTfQGJyLSmjNKOIQQ/yyEkEKIe0YsE0KIO4UQnUKIgBBijxBixZjHNQohXhFCtAsh7hhzX2tym+eOWX6PEGLPmcRLNJtsNhtuvPFG9usgIhrHjBMOIcQGAB8D8M6Yu74A4PMAPgVgA4BuAM8KIRwj1vkBgF8AuBrAlUKILWO2EQTw7ZnGlkmdnZ145plnsHfvXrVDoSyxfv16lkEnIk1wuVzo7e3N3tLmQgg7gAcAfBTA0IjlAsBnAXxdSvmolPIQgL8GYANwy4hNFAHYj0Sy0gmgcMxT3AvgXCHE5TOJL9N4TZ6mw+l0qh0CEREAaKpf2UxPw34A4A9SyufGLG8AUAXgmdQCKWUIwIsAzhux3h0AngXgBxAH8PSY7bQC+DGAbwohVD1VrKysxIUXXoizzz5bzTAoi1RWVqaHUXP0ChGpyel0orS0FBaLRe1QMO163UKImwCsQ+JyyVhVyX97xizvAbAg9YeU8o9CiHIATill3wRP9e8APgTgViQuv0xZIBCA0WiczkMUxeNxBAKBjG5T6/Jtf4HM7fOmTZuwd+9e6PV6OBwOzV9i0cIYfTVwv/NLPu53qj9ZNBrN6HZn8lpO61tQCDEfwHcB3CalDE6y6tj2GzF2mZQyNEmygeR93wFwlxDCNJ04idTmcDiwfft2mM1mjlohIsL0WzjOAVABYN+IL1E9gAuFEJ8C0JhcVgWga8TjKnB6q8dU3A3gk8nblFmt1ozNjOf1etHd3Q2LxYKSkpKMbDPbaGGWwbmWqX2+6KKL8PDDD2Px4sUZ2d5sM5nyM7fnfueXfNrvUCiEWCwGk8mU0Zb/cDg87cdMt533eQCrAKwZcXsTiQ6kawC0IDEqZWfqAcnWia0AXp1ucFJKL4CvAfgyAFV64nk8HjQ1NaG9vV2Np6cckBoqm+kmTSIiJX6/H8PDw5q4nDStFg4p5TCAQyOXCSF8AAaSI1KQrMnxL0KIYwCOAfgXJDqHPjjDGO8D8DkANwP48wy3MWNWqxU1NTUoKCiY66emHLJ+/XoMDw+rHQYR5RmTyQQhRM6WNv8PAPcA+CESrR/zAOxKJivTJqWMAPhXAKp0sS0uLsaqVauwcOFCNZ6ecsSyZcvQ2tqqmeFpRJQfCgoKUFRUpInS5iKXvgCFEE4AbrfbndFaCKmRC/nWlyEf93u29/n+++/HkiVLYDBMe4DYrEpdj82na9sA95v7nftma5+9Xi+2bdsGAIVSSs9UHqOtbz2iHLd8+XK1QyAiUoW2iwNoQFdXF55//nns27dP7VAoB5xzzjmca4WI5ozb7UZfX1/2ljbPJ1JKRKNR/kBQxtx44404evQo+3MQ0ayLx+Oa+f1iwqGgoqICW7ZswcqVK9UOhXKE0WjEbbfdhiNHjnCoLBHNKofDgZKSkuwsbZ5vDAYD7Ha72mFQDpo3b57mOo8SUW5JfcdoYXoF9SMgylNLly5VOwQiojnDhEOB1+vFyZMn0dMzk8rsRBPLp+HGRKSOcDiMQCCgicu3TDgUeDweHD58GCdPnlQ7FMoxJSUlTGSJaFb5fD54PJ4ZzX2SaUw4FFgsFlRWVqK4uFjtUCgHud1uzfQgJ6LcYzQaYTKZNFHanD3WFJSUlGDNmjVqh0E5au3atWhpaUF5ebkmOnURUW5JDXrQQnVVfsMRqWjZsmUAtNGDnIhoNvFbjkhlqaSDiCiXMeFQ0N3djRdeeAEHDhxQOxTKUfX19YjFYmqHQUQ5yOPxoL+/Pz0xpZqYcCiIx+MIh8OIRCJqh0I5SqfTQQihdhhElINisRhisZgmplJgp1EFZWVl2Lx5syZ6+BIREU2Hw+GAlBJms1ntUJhwKDGZTHA6nWqHQTnO5/PB4XCoHQYR5ZhUaXMtnDTzkgqRBrS3t7MfBxHlNCYcCvx+Pzo6OtDX16d2KJTDqqqqNHEGQkS5JRKJIBgMsrR5NnC5XDh06BBaW1vVDoVyWG9vL1s4iCjjvF4v3G63Jkqbsw+HArPZjNLSUl5fp1kTCATYwkFEs8JoNEJKqYnigkw4FJSWlmL9+vVqh0E57Nlnn8W8efPUDoOIchBLmxNRmtfr5QRuRJTzmHAQqcjn86G+vl4TzZ1ERLOJ33IKenp68NJLL+Gdd95ROxTKQQcPHtREQR4iyk0ejwcDAwMsbZ4NYrEY/H4/QqGQ2qFQDnK73WqHQEQ5LBaLIRqNsrR5NigtLcXGjRvT1dqIMsnv96sdAhHlMLvdztLm2cJsNqO4uFjtMChHhcNhxGIxDoklollhNBoBsLQ5Ud7TyiyORESzjQmHgkAggK6uLgwMDKgdCuUgKSWnpieiWROJRBAKhVjaPBsMDQ3hnXfeQUtLi9qhUA7asmWLJr4IiCg3eb1euFwuTZQ2Z8KhwGQyobi4mKXNaVbU19ejp6eHl1WIaFYYDAYYjUZN1Pphp1EFZWVl2Lhxo9phUA7z+/2Ix+Oa6NRFRLkldbLM0uZEBIPBwGSDiHIeEw4ilV1zzTWauL5KRDSbmHAo6O3txauvvopDhw6pHQrlKJPJhK6uLrXDIKIcNDw8jMHBQQSDQbVDYcKhJBqNYnh4WBN16Cl3+f1+jlYhooyLRqOIRCKamJGanUYVlJSU4JxzzklXayOaDfPmzWP5fCLKOLvdjng8zk6j2cBisaCsrAyFhYVqh0I57MILL8Tx48cRi8XUDoWIcojRaITZbNbECQ0TDiIN0Ov1OPfcczXR7ElENBuYcCgIBoPo7e2Fy+VSOxTKcXV1dRgcHGQrBxFlTCQSSU8SqTb121g0bnBwEPv370dJSQmqq6vVDodyXGVlpdohEFEO8Xq9CIfD0Ol0sNlsqsbCFg4FRqMRTqcTBQUFaodCeWDt2rVwu91qh0FEOUKv18NgMGhikki2cCgoLy/H5s2b1Q6D8oROp0NnZycKCgo00cmLiLKb0+kEwNLmRDSOsrIyJhtElHOYcBBpTGNjo9ohEBFlHBMOBf39/fjzn/+Mw4cPqx0K5YnS0lK1QyCiHOH1elnaPFuEw2G4XC54vV61Q6E88frrr6sdAhHliEgkwtLm2aK4uBhr1qzRRIcbyn3xeBxDQ0MoKirilPVEdMbsdjtisZgmfsOYcCiwWq2sjUBzIhqN4pFHHmEfDiLKGKPRCKPRqImO6LykQqQRQ0NDTDaIKGcx4VAQCoUwMDAAj8ejdiiU48rLy3H48GFIKdUOhYhyRGp6ei2UNmfCoWBgYABvvvkmjh49qnYolAdKS0shpdREBy8iyn7Dw8MYHBxEKBRSOxQmHEoMBgMKCgpgsVjUDoXywGWXXYZgMIh4PM6WDiI6Y3q9Hnq9XhOlzZlwKKioqMD555+PVatWqR0K5YkLLrgAbrebrRxEdMacTifKyspgtVrVDoUJB5EW7dq1C8eOHdPEdVciokxgwkGkUZdccgk6OjqYdBBRTmDCoaC/vx979+5lp1Gac2VlZbj44otx8uRJJh1ENCNerxdDQ0PsNJoNwuEwBgcHOSyWVOF0OnH++eeju7tb7VCIKAtFIhGEw2FNnLQw4VBQVFSEVatWoaGhQe1QKE9VVVXhiiuu4ASCRDRtBQUFcDqdmihtzoRDgc1mQ01NDcrKytQOhfKYXq/HzTffjMOHD2viTIWIsoPJZILVamVpcyKaOr1ej61bt8Ln87FGBxFlHSYcCsLhMNxuN6enJ02YP38+1q9fj2PHjqkdChFlgVRpcy3U9WHCoaC/vx+vv/46r5+TZjgcDtx8881oampSOxQi0rhUafNgMKh2KEw4lOj1elgsFk10uCEa6cYbb+Rkb0Q0KZ1OB51OGz/16vci0bjKykps3bpV7TCITqPT6bB161YcPHgQZWVl0Ov1aodERBpTWFgIAJo4adZG2kNEMzJ//nw4HA4mG0SkeUw4iLLcli1bcOTIEQ6XJSJNY8KhYHBwEG+99RZHBZBm6XQ6XH311ejv72d/DiIaxefzweVyaaK0OftwKAgGg+jr6+PZI2ma3W6H1WqF3++H1WrVTCcxIlJXOBxmafNsUVhYiLPOOgsLFixQOxSiSV100UVob29nKwcRpdlsNjgcDhiNRrVDYcKhpKCgAPPnz0dFRYXaoRApuuSSS1ifg4jSzGYzbDYbEw4iyqzS0lLccsstaG5uRjweZ2sHEWkGEw4FkUgEw8PD8Pv9aodCNCU6nQ433ngjent7IYTQREljIlJHLBZDNBrVxPcAEw4FfX19ePXVV/Huu++qHQrRtFxxxRUYGhpCR0cHAGjiC4eI5pbH48HAwIAmSptzlIoCnU4Ho9HIwkqUlXbs2IF4PI7du3djeHgYtbW1HMFClEeEEBBCqB0GACYciqqqqrB9+3a1wyCaMZ1Ohx07diASieDhhx/G8uXL1Q6JiOZIUVERAJY2J6I5ZDQaccstt6ClpUUTY/KJKL8w4SDKIzqdDjU1NbysQkRzjt86CoaGhvD222/j+PHjaodClBGce4Uof/j9frjdbk2UNmfCoSAQCKC7uxuDg4Nqh0KUMdu2bWPCQZQHQqEQgsGgJj7vTDgUOJ1ONDY2ora2Vu1QiDKmtrYWx48fRzQaVTsUIppFVqsVdrtdE5VGOUpFgd1uR319vdphEGWcXq/XzHA5IpodFosFADSRcLCFgyhPxWIx1pchojnDhENBNBqF3+/XRJU2okwqLCxUOwQimmXxeByxWEwT8yox4VDQ29uLl156CQcPHlQ7FKKM2rlzJ44ePQohBFpaWtQOh4hmgdvtRn9/PwKBgNqhsA/HVOh0Ol7rppxjsVhwyy23AACWLl2Kxx57DEuXLuVlFiKaFUw4FNTU1GDnzp1qh0E0q/70pz9h0aJFTDaIckxxcTEAljYnIo2w2Wxqh0BEOY4JBxFh06ZNOHbsWPpvLRQJIqLcwoRDgcvlwrvvvosTJ06oHQrRrFq9enX6/7y0QpQbAoEAPB4PwuGw2qEw4VDi9/vR3t6O/v5+tUMhmlWLFy/mnEFEOSYYDCIQCGiiqjA7jSpwOBxYvHgxrFar2qEQzSqdTodIJIJoNAqdTgedTod4PJ6xmWVjsZgqI74yuQ9E2cZqtcJoNMJgUP/nXv0INM7hcGDRokVqh0E0JywWy6iS55n4oY7H45BSIhqN4sSJE6ivr4fRaJzyZZtYLIZ4PI7+/n5UV1dP+/mZbFA+S5U25ygVItKMtrY21NfXZ7wFYmBgAE1NTaioqMCtt96Kuro6NDU1AcCUqh/q9fr0jJczMfY5tFBxkSgfTSvhEEJ8QgjxjhDCk7y9JoS4bMT9diHE/xVCtAshAkKIw0KIT4zZRqMQ4pXkOneMua9VCCGFEOeOWX6PEGLPDPbvjMViMYRCIUQiETWenmjOvPXWW4jH4xnf7vnnn4/bbrsNixcvBgDMnz8ft912G9rb2xWTm1gshpaWFpx//vkzbqkY+xws4kf5REqZbmVU23Q/we0AvgRgffK2G8DjQogVyfv/D4BLAdwGYHny7+8LIa4esY0fAPgFgKsBXCmE2DLmOYIAvj3NuGZNT08P9uzZgwMHDqgdCtGsMhqN6R/jTA6L9Xq94y6/8sorceTIkQkfF4vF0NfXh3PPPReHDx+G3W5Pd95OdYBLfZkCiUs3IxOm2UieiLKNy+VCX1+fJkqbTyvhkFI+IaX8o5SyKXn7MgAvgFSLxGYAP5NS7pFStkop7wPwNhLJSUoRgP0A3gHQCWDsDFL3AjhXCHH59HeHiGaiqakJtbW16YQjE8NipZRoa2tDVVXVuPfrdDrU19dP+Hi9Xo9IJILOzk6EQiGUlpairKwMANId4IQQ0Ol0aG1txfHjx0e1goxtEZkoiWJiQjQ3ZtyHQwihF0LcBKAAwGvJxS8DuEoIMU8kXARgKYCnRzz0DgDPAvADiI+5DwBaAfwYwDeFEKr3MampqcEll1yCDRs2qB0K0axJteCNbHY901YOIcSk24hEIujv75+0VaKmpmbC3vUjY9Xr9YjH4zh8+PCU40s9FzuVUi4rKipCRUWFJkZaTnuUihBiFRIJhgWJ1o1rpJTvJe/+BwD/jcSllygSCcXfSilfTj1eSvlHIUQ5AKeUsm+Cp/l3AB8CcCsSl1+mJRAIwGg0Tvdhk24vH+XjfufjPnd2dqKhoSE9JPbkyZNwOBzweDxYtGgRYrHYjFs8ysrK8NBDD+HKK6+EXq/HH/7wBxQVFaGrqwtVVVUoLy8ftz7AyKGsU0l8KioqEIvFYDAYJi1wlHquVEtOJBJJJy5Syrzp35GvfdLycb/HvuczZSav5UxS+6MA1iBxGeVHAH4mhDgred8/JJdfBeAcALcD+KEQYsfIDUgpQ5MkG0je9x0Adwkh1B/LQ5TDXn45fT4Ag8GABQsWYOfOnbjuuutgMBjOqMquxWJBfX09fv/73wMAfD4fCgoK0NDQALvdPuGX4HRbHYQQU6ozIISYsBOpFjrVEeUycaYfMiHEcwCOA/gsADcSLR5/GHH//wColVJeOoVttQK4R0p5jxDCDqAZwLcA1ANYI6XcpvB4JwC32+2G0+mc0f6M5Xa70dLSApvNhsbGxoxsM1ukzva10BQ3V/Jxnzs6OvDGG28gGAwiFovhiiuuSM8wmXL//fdj+fLl0952qtXg1KlTCAaDWLJkyRm1mGRaqjVECzUK5hL3O3/22+12IxqNwuFwZHS/vV4vtm3bBgCFUkrPVB6TicJfAoAZgDF5G9sDK4YZtKRIKb1CiK8BuBPAE2cY44z5fD60tbWhpKQk7xIOyg/z5s3DpZcmzgcmSrRuueUW/OEPf0BVVdW0Wh+EEJg/f/6oZVpJNojyQTAYRDgchtVqVT3Rmm4djm8IIS4QQtQLIVYJIb4OYBuAB5IZzosA/lMIsU0I0SCE+BsAfwXgtzOM7z4kWk1unuHjz5jdbkdDQ8OMKhwS5QqdTger1Qop5bQ7k7rd7ml15iSizLFYLLDZbJoobT7dlodKJDpxHgXwPIBNAC6VUj6bvP8mAHsBPADgPSRqdnwZiVEn0yaljAD4VyQ6qKrC6XRi6dKlqK2tVSsEIk3YsWMHjEYjurq6pjWU9PDhw7jsssvQ1tY2i9ER0XisVmvGL6fM1LRSHinlRxTu70ZidMmMSCnrx1n2EICHZrpNIsqctWvXYnBwcEqXVVIjTebNm4eXX34ZpaWl8Hq9sFqt0Ov1murLQUSzjwPQFcTjccRisYxWXiTKZhdffDFMJhOOHDmChoYGtLa2Aph8+KrRaMTWrVuxdetWrFu3Dq2trUw2iOaAlDJ9UxsTDgXd3d147rnn8NZbb6kdCpFmrFq1CrfeeitKSkpw3XXXYWhoCL29vaOSjpHDT0fWxTEYDHlT74JIbS6XC729vZqoMcSEg4jO2I4dO7BhwwY0NTWlz6RSScWRI0ewc+fOUetv3rwZAMuKE+WTM67DoSWzUYcjHo/D5/NBCAG73Z6RbWaLfKxJkY/7DGRuv6PRKH75y1+OqtnR3NycbtK99NJLodPp0NzcDGB0RVE15GNdBoD7nU/7HQwGAQBmszmjLYtq1eHIaTqdThPDiYiygcFgwLXXXosnnngCsVgMjY2NWLx4MWKxGIQQePrpp1FYWIiKigoAnMeEaLalPmNauIzJX1IiyiibzQYAaGxsTI9ESXUQXbJkCYqLizE0NAQgv+YvIcp3PL1Q4PF40NTUhPb2drVDIcoakUhkwmGvR44cgcvlAjB6HhP25yDKvGAwCK/Xq4mJ65hwKPB6vThx4gS6urrUDoUoa+j1+nGH4aWGmK9duxZr165FT08PgETiwcsrRJkXCATg8/mYcGSDgoICLFiwAJWVlWqHQpQ1HA7HuH2f9Ho9ampq8Nprr0Gn02Hnzp3weDyaqBFAlIvMZjOsVqsm+iKqH4HGFRYWYtmyZWqHQZRVli9fnr5sMpbP58P5558PIFGfQ6/XIxgMwmq1qj5qhSjXpPpUaWFkDj/ZRJRxDQ0NExYaqq+vR2FhYfrvCy+8EJWVlThy5AiTDaIcxk83EWWcTqfDwMDAuPft27fvtGVLlizBrbfeygneiHIYEw4FnZ2dePrpp7F37161QyHKKhPNrRIKhSZ8zNVXXz3p/UQ0PS6XCz09PfD7/WqHwoSDiGbHyPlTRlqyZAk6OzvHvU+v16dHrhDRmdNSh2wmHAoqKyuxbds2rF69Wu1QiLLGO++8g5qamtOWp778XnrppXTJ5bF8Ph9nZybKkMLCQpSVlcFisagdCkepKNHr9TCbzWqHQZRVWlpaMH/+/NOWpwp9LV68GG+++Sbcbjfq6+uxfPnydIfRiWp4ENH0pT5XWuiQrX4ERJRzotGoYtJgNptRVVWFYDCIBx98ML28qqpKEzUDiCizmHAoGB4exvHjxye85kxEpwsGg4qlykeecS1ZsgT3338/mpubcdFFF+Ho0aO8rEKUAaFQiJVGs8Xw8DCam5vR0dGhdihEWcNqtY47j8pEDAYDli9fjlOnTgEANm/ePK3HE9H4/H6/ZuZSYbulApvNhnnz5qGgoEDtUIiyxkRFvyYTj8fhdDpx//33w+l0Qq/Xo7y8nIkH0RkwmUzQ6XSa+Bwx4VBQVFSElStXqh0GUVY577zz0lPQT7VceWqdpUuXQq/Xo6+vD62traioqIDNZtPEFyZRtkmdLLO0ORHlpIULF8JqtaK0tHTC4a8TSSUW5eXlKCkpQWdnJ5MNohzAhIOIZsVZZ52F+vp69Pf3z+jx8XgcdrsdxcXFGY6MiNTAhENBZ2cnnnvuObz55ptqh0KUlfx+v+KIlfHodDoYjUZUVFTMQlRE+cHtdqO3t5elzbNFLBZjISKiGSoqKtJE0SGifBSPxzXz+8VOowoqKipwwQUX8AuTaIYuvvhivPrqq6OmpCeiueF0OiGl1ERpc/6KKjAYDLDZbJo4WETZyGKxoLu7e0aXVYjozOj1ehgMBk2cNKsfARHlvA0bNmjiC4+I1MNvAAVerxetra3o6upSOxSirLVkyRKEw2G1wyDKO6FQCH6/XxOVRplwKPB4PDh69Cja29vVDoUoaw0PD2ui8BBRvvH7/RgeHtZEwsFOowqsViuqqqpgt9vVDoUoa/X09KgdAlFeMplMEEJoongeEw4FxcXFWL16tdphEGW1wcFBTXzhEeUbljYnorzS1tbGUSpEeY4JBxHNulAoxISDKM8x4VDQ3d2N3bt3Y//+/WqHQpS1CgsLYTDwCi7RXHO73ejr60MgEFA7FCYcSuLxOCKRCKLRqNqhEGWts88+W+0QiPJSPB7XTHlznnIoKC8vx3nnnccOb0RnoLa2FocPH0Z5ebnaoRDlFYfDASklzGaz2qGwhUOJ0WiEw+GAzWZTOxSirKXX61FXV4fDhw9r4kyLKF8YDAYYjUZNnDSzhYOI5sRZZ50Fu92Ozs5O6PV6ljonyjP8xCvw+Xw4deoUent71Q6FKOvV1dWho6ODyQbRHAmHwwgEAproh8hPvQK324333nsPbW1taodClBPOO+88nDx5Em63G7FYTO1wiHKaz+eDx+PRxFxGTDgUWCwWlJeXo6ioSO1QiHJCdXU1rrnmGmzYsAHd3d1MOohmkdFohMlk0kSrIvtwKCgpKcG6devUDoMo5zgcDpSXl2uiMxtRrkrNA8bS5kSU1zZv3ozDhw+rHQYRzQEmHESkqltuuQVHjx5l6XOiHMeEQ0FPTw9efPFFvP3222qHQpSTdDodNmzYgFOnTrE/B1GGeTwe9Pf3s7R5NojFYggGg5ro4UuUq5YsWYJdu3ahtbWVSQdRBsViMcRiMU0U3GPCoaCsrAybNm3CsmXL1A6FKKfZ7Xa8733vQ3NzMwCcdollvC9MJidEk7Pb7SgpKWFp82xgMplQVFQEh8OhdihEOc9ms+GWW25BZ2cnenp6Rt0nhEBnZyfC4TBOnjyJwsJCdHV1MekgmoTRaGRpcyKiiVx55ZWIx+NoamrCiRMnEIlEsHTp0vTyVE0Bs9mMY8eOweFwaKLOABFNjAmHAr/fj66uLpjNZtTW1qodDlHe0Ol0WLZs2WmXM0cmFvPnz8ehQ4dQWFg41+ERZYVIJIJYLAadTgeDQd2ffJ4SKHC5XDh48CBaWlrUDoWIxrFr1y50dnZyWC3ROLxeL9xutyYGPrCFQ4HJZEJJSQmcTqfaoRDROPR6PYQQvKRCNA6DwQAppSY+H+pHoHFlZWXYsGEDGhsb1Q6FiCZw6aWXoru7m60cRGM4HA6UlJTAYrGoHQoTDiLKfgaDAdFoVBNncUQ0Pn46iSgn7Nq1Cz6fT+0wiGgCTDgU9Pb24uWXX8bBgwfVDoWIJmG1WuH3+9UOg0hThoeHMTAwgGAwqHYo7DSqJBqNwufzaaJKGxFNrKenB+Xl5WqHQaQp0WgU0WhUE/2bmHAoKC0txfr162E0GtUOhYgm0dbWpolqikRaYrfbEY/HNXHSzEsqCsxmM0pLSzkslkjjurq60v/XwtkckRYYjUaYzWZNJONMOIgoJ3i9XrVDIKJJ8JKKgkAggJ6eHphMJlitVrXDIaIJSCnT86xweCxRQiQSQTweh16vV72Vg59KBUNDQzhw4EB6ymwi0p54PI6SkhImGkRjeL1euFwuhEIhtUNhC4cSo9GIoqIi2O12tUMhoqShoSEAQHFxMQDg9ddfR2VlpZohEWmSwWAYNcOyqrGoHYDWlZeXY9OmTWqHQUQjvPrqqygqKkI0GsX555+PU6dOoaGhQfUmYyKtcTgcABLzgqmNCQcRZZUHHnggPWV9PB7HY489hkWLFkEIoXJkRDQZ9dtYiIimqLe3N51sAImOonV1dUw2iLIAEw4FfX19eO211/Dee++pHQpR3nvuuedG/a3X6zVxbZpIq4aHhzE4OKiJ0ub8pCqIRCLweDycFIpIA9atW5eeL4XFvYiURaPR9NBYtbEPh4KSkhKsXbtWEx1uiPLdsmXLUFhYiM7OTrZsEE2B3W5HLBbTxG8YP7EKLBYLKioqUFRUpHYoRATghRdeUDsEoqxhNBphsVhgMKjfvsCEg4iyypIlS9QOgYhmgAmHgmAwiP7+frjdbrVDISIADQ0NmrgeTZQNIpEIIpEIYrGY2qEw4VAyODiIffv2oampSe1QiAhAWVkZWltbNfEFSqR1Xq8Xg4ODmihtzoRDgcFggMPh4MRtRBpiNBrZaZRoClKTtmmhVo36vUg0rqKiAuedd57aYRDRCDt37sS7777LUuZECpxOJwBtlDbnKQIRZZ2CggIMDQ1BSql2KEQ0RUw4iCgr9fX1sR8HURZhwqGgv78fb7zxBo4cOaJ2KEQ0gslkYj8OIgVerxdDQ0OaKG3OPhwKwuEwhoaGNNHhhoj+YsGCBUw4iBREIhGEw2FNDCVnwqGguLgYZ599tiY63BDRX9TV1aGzs1PtMIg0raCgABaLRRO/YUw4FFitVlRXV6sdBhGNMTg4CCAxRT1bIInGl0o0WNqciGiGli9fjra2NsTjcXYeJcoCTDgUpPpwDA8Pqx0KEY2g0+lw7bXXAkh8TonodKnp6bWQlDPhUMBRKkTatnHjRpY6J5rA8PAwS5tnC71eD6vVCrPZrHYoRDSByy67DMePH0c8HtdEb3wirdDpdNDpdJro56R+LxKNq6ysxIUXXqh2GEQ0idLSUtx8883w+Xx47LHHsHTpUkgpWfqc8l5hYSEAljYnIsqogoIC3HrrrYjH4xgYGOBlFiINYcJBRDln06ZN2LhxIzo6Oph0EGkEEw4FAwMD2LdvH44ePap2KEQ0DaWlpbj44ovZoZTyms/ng8vlYqfRbBAKhdDf3w+Px6N2KEQ0TU6nE1u3boXP52NnUspL4XAYoVBIE0k3Ew4FRUVFWLlyJerr69UOhYhmoLKyEgA47wrlJZvNBofDAaPRqHYo00s4hBCfEEK8I4TwJG+vCSEuG7POciHE74QQbiHEsBDidSFE3Yj7G4UQrwgh2oUQd4x5bKsQQgohzh2z/B4hxJ4Z7N8Zs9lsmDdvHsrLy9V4eiLKgIsuuihdlZQon5jNZthstuxLOAC0A/gSgPXJ224AjwshVgCAEGIRgJcBHAGwDcBqAF8DMHJe3B8A+AWAqwFcKYTYMuY5ggC+Pc24iIgm5XQ6odPpIKVUOxSivDSthENK+YSU8o9Syqbk7csAvABSLRJfB/BHKeUXpJT7pZQtUso/SCl7R2ymCMB+AO8A6ARQOOZp7gVwrhDi8pnsUKaFw2F4PB74fD61QyGiM7Bjxw4cPnyYrRyUV2KxGKLRqCbe9zO+qCmE0AshbgJQAOA1IYQOwBUAmoQQTwsheoUQfxZCvH/MQ+8A8CwAP4A4gKfH3N8K4McAvpncpqr6+/vx2muv4b333lM7FCI6Q+vXr0csFmMrB+UNj8eDgYEBBINB5ZVn2bQrjQohVgF4DYAFidaNa6SU7wkhqgDYkbjk8hUAXwRwKYBHhRAXSSlfBAAp5R+FEOUAnFLKvgme5t8BfAjArUhcfpmWQCCQsetV4XA43dksEAhkZJvZIt/2F8jPfQbyZ78XLFiAY8eOQQiB0tJSBIPBvKxGGolE1A5BFfm436nZlCORSEYnOZzJazmT0uZHAaxB4tLIdQB+JoTYCsCVvP9xKeX/Sf7/gBDiPAAfB/BiagNSyhCAiZINSCn7hBDfAXCXEOLhGcSYMZWVlTj//PPVDIGIMmjHjh0AgKamJrS1taGyslITHeqIZoPT6QQATbzHp51wSCnDAJqTf74phNgA4DMAPg0gCmDstYfDAGbyi303gE8mb9NitVphtVpn8JTK281H+bjf+bjPQH7t9+rVq9HR0QGLxaKJeSbUwP3OH5ne55m0lmSij4QAYE4mInsBNI65fymAtuluVErpRWKEy5cBOM80SCKisZYtW6Z2CER5Y7p1OL4hhLhACFEvhFglhPg6EsNfH0iu8p8AbhRCfFQIsVgI8SkAVwL44Qzjuw+AG8DNM3z8GRscHMSBAwfQ3NysvDIRZZXq6mq43W61wyCaNT6fD263OytLm1ci0YnzKIDnAWwCcKmU8lkAkFL+Fon+Gl8AcBDA3wK4Tkr58kyCk1JGAPwrEh1UVREMBtHT04OhoSG1QiCiWdTT06OJss9EsyEcDiMYDGriPT6tPhxSyo9MYZ3/B+D/zSQYKWX9OMseAvDQTLaXCU6nE8uXL4fZbFYrBCKaRdXV1Xk5UoXyg81mg8lk0kSnUdXrXGid3W5HXV1dej4GIsota9euxalTpzRxBkiUaWazGQUFBUw4iIjUZrfbsWXLFrS1TbtvOxFNAxMOBdFoFF6vN28KIxHlo/Lyclx33XVoa2tjSwfllFThr6wubZ4vent78corr+DQoUNqh0JEs0in02H9+vUYGhpi0kE5w+12o7+/XxOlzZlwKBBCwGAwpMubE1Huqqurw4YNG9Da2qqJM0KiMyWEUDuEtJmUNs8r1dXVuPjii9UOg4jmSElJCa644grs3r0bVVVVPNmgrFZUVARAG9VV+UkiIhqjoKBAE4WSiHIJEw4ionGUlJSwdYMog/hpUjA0NISDBw+ipaVF7VCIaA7V1dWpHQLRGfP7/fB4PBmdmn6mmHAoCAQC6OzsxMDAgNqhENEcWrx4MQ4fPszOo5TVQqEQAoEAotGo2qEw4VDicDiwZMkSzJs3T+1QiGiO7dixg5dVKKtZrVZWGs0WDocDCxcuRE1NjdqhENEcKy8vx5EjRzA4OAgArM9BWcdiscButzPhICLSMr1ej1tvvRXbtm2Dy+VCe3u72iERZS3W4VAQi8UQDAah0+lgtVrVDoeIVGA0GnHxxRcjHA5jz5496O3tRWNjIy+3kOal+iBJKVUvAsZPi4Kenh68+OKLePvtt9UOhYhUZjKZsGvXLrz//e/nDLOUFdxuN/r6+jQxHxgTjilQOyskIm2x2+3YtGkTR7AQTQMvqSioqanBrl271A6DiDRm3rx5eOGFF7B06VLo9Xq1wyEaF0ubExHlgAsuuABer5ctHaRZQoj0TW1MOIiIZmjBggVwOByIRqOQUqodDpGmMeFQ4HK58N5776G1tVXtUIhIgzZs2IDh4WEmHKRJgUAAw8PDLG2eDfx+P06dOoW+vj61QyEijdq1axdrdJAmBYNB+P1+ljbPBna7nZVGiUjRNddcg2PHjqX7c6SGzLLlg9RksVhgs9lgMKg/RkT9CDTO6XRiyZIlaodBRFngpptugs/nQ2trKw4cOACdToeamhpYrVaOZCFVpApWamGUChMOIqIMKigowIoVK7BixQoAwOuvv85kgwi8pKIoHo8jEolo4voXEWWfc889F93d3WqHQXlKSpm+qY0Jh4Lu7m7s3r0b+/fvVzsUIspSLIFOanG5XOjt7WVpcyKifKCF6+dEamMfDgXV1dXYuXOn2mEQURbTQpVHyk9FRUWQUsJsNqsdChMOJUIITkFNRDPm8/lQVlamdhiUp1janIgoT7z44otqh0CkCUw4FHg8Hhw9ehSnTp1SOxQiykKBQICTu5FqgsEgvF4vS5tnA6/Xi9bWVg5rI6IZKS0t5WVZUk0gEIDP59NEaQf24VBQUFCA+vp62Gw2tUMhoizU3d0Nm83G4l+kCovFAr1ez9Lm2aCwsBCNjY1qh0FEWWrdunXo6upieXNShdVqhdVq1cTQbLbzERHNoqVLl6KoqAjDw8Psy0F5jQmHAikl4vE4vyiIaMZWr16NDRs2oKWl5bTEg1VIKV8w4VDQ1dWFZ599Fvv27VM7FCLKYk6nEzfeeCNWr16N1tZWAMCRI0fQ1NQEADypoVkxNDSEnp4e+P1+tUNhHw4iorlUXFyMa665Br29vTjnnHMQj8fx29/+FsXFxbDb7eznQTmLCYeCqqoqbN++XRNV2ogoNxgMBtTU1AAAdDodrrvuOjzzzDNMNijjCgsLIaWExWJROxReUlGi0+lgNBo1MaSIiHLXsmXL1A6BcpBOp4Ner9fESTMTDiIiDZg3bx47kFJOY8KhwOPx4NixY+jo6FA7FCLKcVo4C6XcEgwG4fP5EIlE1A6FCYcSr9eLlpYWdHZ2qh0KEeWwwcFBlkCnjAsEAvB6vZpIONgxQYHNZsP8+fNZ2pyIZtWRI0f4PUMZZzab0/041MaEQ0FRURHOOusstcMgohzX3t6ORYsWaeKHgXJHKollaXMiIgIAGI1GXlKhnMZ3NxGRygYGBlBXV8dOo5TTmHAo6OzsxDPPPIO9e/eqHQoR5ag33niDl1JoVrhcLvT29mqitDkTjimQUqodAhHlsIGBAbVDoBwlpdTMbxg7jSqorKzEhRdeyGurRDRrUpdSYrEYWzooo5xOJ0ubZwu9Xg+r1Qqz2ax2KESUo6699locPXqUyQZlnF6vh8Fg0MRJs/oREBHlOavViuuvvx5Hjx7lNPWUs5hwKPB6vThx4gS6urrUDoWIcpjRaITZbOZIFcqoUCgEv9+viUqjTDgUeDweNDU1ob29Xe1QiCjHhUIhTuBGGeX3+zE8PKyJhIOdRhVYrVbU1NSgoKBA7VCIKMfp9XpNXGun3GEymSCE0ET/ICYcCoqLi7Fq1Sq1wyCiHOfxeDB//nwmHJRRqZNlljYnIiIAwNtvv83RcJTTmHAQEWnAhg0b0NHRwVEqlLOYcCjo6urC888/j3379qkdChHlMIvFAovFwksqlFFutxt9fX0sbZ4NpJSIRqM86yCiWbdjxw4MDg6qHQblkHg8rpnfL3YaVVBRUYEtW7ZooocvEeW2UCjEEXGUUQ6Hg6XNs4XBYIDdbofValU7FCLKcS+88AI7jlJGGQwGGI1GTVyqUz8CIiICkCjSpJXmb6JMY8KhwOv14uTJk+jp6VE7FCLKYUeOHEFDQ4MmzkQpd4TDYQQCAUSjUbVDYcKhxOPx4PDhwzh58qTaoRBRDtu/fz/LmlPG+Xw+eDwehMNhtUNhp1ElFosFlZWVsNvtaodCRDmMyQbNBqPRCACaGPjAhENBSUkJ1qxZo3YYRJTjVqxYgXA4jFgslp4xlpdX6EylTpZZ2pyIiAAAa9euhV6vR0tLC5qbmxEMBiGlVDssooxhCwcRkUasX78e69evBwAMDAxg9+7dqK2t1cTZKdGZYguHgu7ubrzwwgs4cOCA2qEQUR4pLS3F9ddfj9bWVg6VpRnzeDzo7+9HIBBQOxQmHEri8TjC4TAikYjaoRBRHtq1a9eUOpRKKdNlrOPxOGKxGKLRKDuj5rlYLIZYLKaJy3O8pKKgrKwMmzdv1kQPXyLKP6WlpXjyySexbNkyxONxSClhMPzlq3toaAiDg4OIRqOQUp72wyKEwOLFi0c9BgBbTfJEqrS5FirYMuFQYDKZ4HQ61Q6DiPLY+vXrcfjwYUgpEQwG4XA4UFNTg8WLF6OwsFDx8f39/RgaGkJ1dTV6e3vx1ltvIRaLYfHixQASyQdHxOSmVKKphZNmJhxERBq3bNkyLFu2bMaPLysrQ1lZGYDEMMnq6mrEYjG88sorGB4eRllZWfpMODUkFxidiIyXlMTjcQghRj2GaCJMOBT4/X50dnbCZDKhrq5O7XCIiDJCr9fjkksuAZAYEfPkk0/CYDBAr9ejpKQEgUAAwWAQDQ0NABIlsvv6+mCxWFBVVYWenh709fVh6dKl6e2R9kQiEcRiMeh0utMuq801JhwKXC4XDh06hJKSEiYcRJSTSktLcdttt4173+HDh9Ha2op169Zhy5Ytp92/b98+NDU1YcGCBTCbzbw8ozFerxfhcBgGg4EJh9aZzWaUlpbC4XCoHQoR0Zxbvnw5li9fPuH955xzDs455xycOnUKL774IpYvX45YLMYWD40wGo2QUmoiCWTCoaC0tDRdiIeIiMY3f/583HbbbXjhhRcQj8fhcDiYdGgAS5sTEVFOuuiii7Bw4UJ4PB4AHH5Lf8GEg4iIMqqhoQFr167F0NAQIpGIJopOkfqYcCjo6enBSy+9hHfeeUftUIiIskZpaSl27NgBn88Ht9sNAKx6qgKPx4OBgQGWNs8GsVgMfr8foVBI7VCIiLLOzp07sXLlSrS0tDDhUEGqxL0WWpmYcCgoLS3Fxo0bz6joDhFRPqusrMT111+Pvr4+9umYY3a7HcXFxZoobc6EQ4HZbEZxcTGHxRIRnaFUR1KaO0ajESaTSRMjhphwEBHRnNi6dSsvq+QxJhwKAoEAurq6MDAwoHYoRERZbf78+WhubmbSMYcikQhCoRCi0ajaoTDhUDI0NIR33nkHLS0taodCRJT1tmzZoonm/Xzh9XrhcrkQDofVDoUJhxKTycQ+HEREGdLQ0IDjx4+rHUbeMBgMMBqNLG2eDcrKyrBx40a1wyAiyhk33HADotEoHn74YY4AnGWpk+WsK20uhPiEEOIdIYQneXtNCHHZBOveK4SQQojPjlneKIR4RQjRLoS4Y8x9rcnHnDtm+T1CiD3TiZWIKJcdP348I0NMu7q68Morr+DkyZNz2rfCYDDg1ltvhcvlGrWcw2Zz13TbWNoBfAnA+uRtN4DHhRArRq4khHg/gE0AOsfZxg8A/ALA1QCuFEKMne84CODb04yLiCgveDwePPXUU3C5XHjwwQfPaFvRaBT79u2DxWJBX18f3njjDTzwwAM4cuQI3nzzTezbtw/BYHDCx3d3d59xZ8SLL74YK1asgNlshtfrRXNzMwKBADuW5qBpJRxSyieklH+UUjYlb18G4AWQbpEQQswD8H8B3AogMs5migDsB/AOEglJ4Zj77wVwrhDi8unENlt6e3vx6quv4tChQ2qHQkR5LBwO4+GHH8axY8dQXl4OIDF1/AMPPIDBwUHFxwcCAezZsweRyF++lnt7e1FdXZ3+22QyYcmSJfD5fBBCAADeffdd3H///ejs/Mv54zPPPIM//OEP6OjowFNPPYXnn3/+jPbNYrFg5cqV2Lp1K26++WbU1taiqakJLpcL8XhcE1Uys9Xw8DAGBwcnTRznyoz7cAgh9ACuB1AA4LXkMh0SrRf/KaV8N/WGHeMOAM8CsAL4PYCnx9zfCuDHAL4phHhKSqlq+1o0GsXw8DCMRqOaYRBRnnvyySexePHi05YvW7YMTz75JG699dZRyz0eD373u98BSBQwlFJi0aJFeOaZZ7B9+3YAQE1NDQKBAF5//fV0X4rxRpAsXboUR48excsvv4zy8nJYLBaUlJQAAKqrqxGPxzEwMIDS0tKM7Gt9fT3q6+vh9/vxxBNPQKfToaysDE6nE0CiXPfIOKWUkFJO2jEyX1tMotEoIpGIJi5VTTvhEEKsQiLBsCDRunGNlPK95N1fBBAF8L2JHi+l/KMQohyAU0rZN8Fq/w7gQ0i0kvxiujEGAoGMJQhWqxUrV66EwWDQxOQ3cynf9hfIz30GuN/Z4LzzzsNTTz2FeDwOnU43KvmIxWLweDx47LHH0NDQgMHBQRQVFaGhoSH9QxyPxxEOh9Hf3z9qv2tqarB06VLFYZNGoxHz588HkOhnMbKlpKOjAytXrsz46ymEwFVXXZX+e3h4GIcPH0ZXVxcWLFgAIHFZx+v1wmQyQUqJ0tJSNDQ0wOv1oqioCDabDQMDA3jzzTdRV1eHCU6Ec5bZbE7/HmZyaOzI4z9VM2nhOApgDRKXRq4D8DMhxFYkWiw+A2CdVGj/klKGAEyUbEBK2SeE+A6Au4QQD88gxowZmckTEanFbrfjAx/4QPrvtrY2FBcXw2g04uyzz8bAwAAWLVoEnU6HioqK0x6v1+sRj8dRW1uLxx9/HFJKXHHFFXA6nbBarRgeHp70+fV6/ahLG6lWhq6uLuzcuTNzOzoJh8OBjRs3Ynh4GLt370YkEsH73vc+WCwWxcfNnz8fjzzyCBYtWjQnsWpFKtkwGNQflCrO9NqYEOI5AMcBHAZwN4CR7Tb65N+npJT1U9hWK4B7pJT3CCHsAJoBfAtAPYA1UsptCo93AnC73e5001smpLJ2q9WasW1mg3zc73zcZ4D7nSv7/dZbb8Hv9086d4aUEsFgEHq9Hn6/HxdffDEA4IEHHsCyZctOu1wBIN2qMjQ0hO7ubgCJBKSmpgbr1q3LmjpFw8PDeOqpp7BgwYK8KT6WatXI9LBYr9eLbdu2AUChlHJKk+RkIuURAMxIXPp4bsx9TyeX/3S6G5VSeoUQXwNwJ4AnzjDGGQsGg+jt7YXJZMqZLyUiyk3r1q3D7t27J/2uEkKkf2y7urrSy2+++WY8+eSTGBoaQnl5OcxmMywWS7rlw+Vy4fLLL0dBQcHs7sQsMhgMqK+vz6tOqJFIBFJK6PV61ZOsaSUcQohvAHgSwCkADgA3AdgG4FIp5QCAgTHrRwB0SymPzjC++wB8DsDNAP48w22ckcHBQezfvx8lJSWjenMTEWnR9u3bcf/992Pp0qXj/sDEYjGEw2H4fL5Rzew6nQ5XXHHFaeuq/SOVaStXrsRvfvObCV+fXOP1ehEOh6HT6WCz2VSNZbotHJVItFhUA3AjMbT1Uinls5kODACklBEhxL8COLPB5mfAaDTC6XRmdVZPRPll27ZtOHjwIMrLyyGEQCwWgxACOp0OLS0tOPfcc1FZWanYapurP8i1tbU5u29j6fV6GAwGTXSWPeM+HFrCPhyZlY/7nY/7DHC/c3G/g8Egfve732HRokWIRCJoaWlBY2Mj1qxZk76un4v7PZnU8TaZTHj++eczNoxXy3KtDwcREWmMxWLBDTfcgI6ODsTjcZx77rnKD8oTer0e/f39KCoqypuWDi1gwkFElMPmzZundgiatHnzZgwMDCivSBmj/ny1Gtff348///nPOHz4sNqhEBFRhjQ0NKC1tTXnR6x4vd7sL22eL8LhMFwu16Qlc4mIKLv09fXB4XBoojPlbIpEItlb2jzfFBcXY82aNRnvcENEROqIx+PYs2cPGhoa1A5l1tntdsRiMU38hjHhUGC1WlFZWal2GERElCE9PT1YuHDhhPenKqvmAqPRCKPRqInS5rnxihIREU1RdXU1jh8/PuH9Y5ON/v5+APk742ymMOFQEAqFMDAwAI9nSsOMiYgoC9TV1cHn86X7NkzWebS+vh5utxtdXV1Z18k0NT29FpIl9dtYNC41rXFJSQkvrRAR5YhUXZJwOIxHH30UTqdz1Hf8yZMncfnll6OzsxMNDQ1obGxENBrFL3/5SyxbtixrOpsODw8jHA6jtLRU9dLmbOFQYDAYUFBQoDj9MRERZR+TyYSbbroJu3btwsDAAI4ePYr58+fjmmuugdlsHtWx1GAw4Oabb8aRI0eypqUjNWmbFhIktnAoqKiowPnnn692GERENIsMBgN27dqluJ5er8dNN92UNS0dqWk+tDBKhS0cRERE02AwGHDTTTfhyJEjmqhvkS2YcBAREU2TwWDAjTfeiKamJgCTdzqlBCYcCvr7+7F3714cPXpU7VCIiEhDjEYjbr75Zpw8eRKhUEgTI0HG8nq9GBoaQigUUjsUJhxKwuEwBgcHOSyWiIhOo9PpcM0116CmpgbNzc3o7+/XVGtHJBJBOBzWRDLETqMKioqKsGrVKk10uCEiIm1qaGhAQ0MDotEofvOb32DBggXQ6XTQ6/WqxpUaZamF3zC2cCiw2WyoqalBWVmZ2qEQEZHGpfp2OBwO9PT0qN6yYDKZYLVaWdqciIgoF61YsQJbt27FsWPHNHWJRU1MOBSEw2G43W54vV61QyEioizidDpx0003obm5WbWWjlRpcy0M31W/jUXj+vv78cYbb6CkpATl5eVqh0NERFNw9OhR7N27N/231WrF5ZdfPudx6PV6bN++HQcOHEBRUdGc9+nQUmlzJhwK9Hq9ZjrcEBHR1HR2dmL58uUAEjUyhBB45JFHsGbNGqxevXpOY6moqMCCBQtw4MABLF68OB3PXNDpdKfNfqsWkUvXloQQTgBut9udLueaCYFAAEAiQ84n+bjf+bjPAPeb+52b7r///nTSASQukQNAa2srSkpKsHnz5oz+ViiJx+N46qmnYDab4XA45qS1I7XPmT5p9nq92LZtGwAUSimnVDdCG2kPERFRhl1zzTU4cuQI/H7/qOWLFi1CWVkZDhw4gPvvvx/d3d1zEo9Op8Pll1+OlStXoqurS/URLHONCQcREeWkgoIC3Hrrrdi8eTMqKysxODiIeDyeblkoKCjA8uXLsXv37jmNq7KyEhs3bkRfX19eJR1MOBQMDg7irbfewrFjx9QOhYiIZsBgMKC2thb9/f2n9WeQUqKxsRFHjhyZ05iqq6uxcuVKDA0NzWrS4fP54HK5WNo8GwSDQfT19cHlcqkdChERnaGxw0OFEIjFYujp6cGJEyfmNJYFCxZg7dq1OH78+Kw9Rzgc1sw8L0w4FBQWFuKss87CggUL1A6FiIjOgBBi3CJcer0eVqsVra2tc15zqaKiAjfccEO6Vkem62XYbDY4HA4YjcaMbncmmHAoKCgowPz581FRUaF2KEREdAZ27tyJoaEhxONxRKNRxGIxRKNRAImkw+l04s0335zzuPR6PW688cZ0ka5Mjh41m82w2WxMOIiIKLudPHlyzi9FzFRRURFWrFiB1tZWHDt2DC0tLWhubh7VqmG321WL77zzzkNPT8+c1eiYayz8pSASiWB4eDjd5EZERMCjjz6KefPmwWAwIBqN4sCBA7jwwgtRWlqqdmiTqq6uxvXXXz9qWVdXF1555RXU1dVh48aNKkWWcPXVV+Ohhx7CkiVLMlKnIxaLQUoJg8GgegEwtnAo6Ovrw6uvvop3331X7VCIiDQjHA6nZyA1GAyoq6tDc3MzHnzwQU3M2zEd1dXV+MAHPqB6sgEkanVcdtll6Us/Z8rj8WBgYADBYDAD0Z0ZJhwKdDodjEbjnNe/JyLSsnPPPRfBYHDUj6LBYEBjYyN+9atfqRhZ9ispKUFRUVFG+nIIITRziYYJh4Kqqips374d69atUzsUIiLNqK+vh8ViQXt7e3pZqgOmFoZgZrtNmzahpaXljJOOoqIiVFRUqD5xG8CEg4iIZuicc87BNddcA7PZjJaWFhw7dgzNzc3YunWr2qHlhOuvvx7Hjx/PmQSOnUaJiOiMrFy5EitXrlQ7jJyj1+uxZcsWNDc3o6CgQPVOn2cqu6OfA0NDQ3j77bdntRIcERHReGpraxGNRmecbPj9frjdbpY2zwaBQADd3d0YHBxUOxQiIspDO3bswNGjR2d0aSUUCiEYDGrisgwvqShwOp1obGyE2WxWOxQiIspTmzZtQl9f37RHTFqtVphMJlYazQZ2ux319fWorq5WOxQiIspTixYtQnNzc3ok0FRZLBYUFBQw4SAiIqKpmT9/frrYWjZiwqEgGo3C7/drokobERHlr40bN06782c8Hk+XN1db9qZKc6S3txdvvPEGSkpKcOGFF6odDhERTcFzzz0Hk8mEgYEBLF++HMuWLVM7pDNmtVrR1taGRYsWTbkvh9vtRjgcRmlpqerFv9jCMQU6nU4zpWGJiEhZd3c3CgoKUFdXh7feeivr5neZSGNjY9bW48jOqOdQTU0Ndu7cifXr16sdChERTdGmTZvQ2dkJIPEj/corr6gcUWasW7cObW1tU75EUlxcjMrKStVbNwAmHERElIOWLFmSbtWIx+Pw+Xzo7u5WOarMCAQCmqirMV1MOIiIKCdt2rQJQ0NDABIzsL766qs5cWmloKAgK2cwZ8KhwOVy4d1338WJEyfUDoWIiKahqqoKFosFOp0Oer0eCxcuxKOPPpr1ow5ramqm3K8wEAjA4/EgHA7PclTKmHAo8Pv9aG9vR39/v9qhEBHRNK1YsWLU5YfFixfjsccem3YBLS1ZunTplNcNBoMIBAKa2F8mHAocDgcWL16MefPmqR0KERFNU3Fx8WmTby5evBgPP/wwAoGASlGdmeLi4vSlIiVWqxUFBQWaKBjGhEOBw+HAokWLUFNTo3YoREQ0AzfccANOnDiRbukQQmDp0qV44okn0NfXp3J0s8tiscBut8NkMqkdChMOIiLKbXq9HqWlpaM6Wup0OtTX1+Ott95CU1OTitFN3/3334/i4mK1w5g2JhwKYrEYQqEQIpGI2qEQEdEMbd26Fc3NzYhEIumRKnq9HmVlZRgeHkZvb6/KEU5NPB7H8uXLp7y+lBLxeFwTpc2ZcCjo6enBnj17cODAAbVDISKiGdLpdPjABz4AKeW4IzZaW1vnPqgZ0Ol0aGpqmnIdDpfLhb6+Pk30V1G/FwkREdEc2bhxI3p6evDqq6/Cbrfjfe97H0KhEKxWq9qhTVltbW1W1uFgwqGgpqYGl1xyidphEBFRhtTX16O+vj79dzYlGwCwZcsW7N69e0r9OIqKigBAE51GmXAQERFlEZ1ON+Vp6lMFwrQwASn7cBAREWWZVIvFyPlitI4JhwK3240jR47g5MmTaodCREQE4C+XSlJT1U80ZX0gEMDw8DBLm2cDn8+HtrY29PT0qB0KERERgIlbNMYOfw0Gg/D7/Sxtng3sdjsaGhpQXV2tdihEREQAkJ5QtKWlBS0tLenlY/tqWCwW2Gw2TZQ2Vz8CjXM6ndOaKIeIiGi23XTTTWhubsZ1110HANi/f/+466VG4GhhlApbOIiIiLLQ4sWLodPpoNPp4PF40su1UFV0PEw4FMTjccRisSlXdSMiIppr559/fvr/I/t3SCnTN7Ux4VDQ3d2N5557Dm+99ZbaoRAREY3LaDSmWzlGViF1uVzo7e3VRGlzJhxEREQ5wOVyqR3CpNhpVEFVVRUuvvhiTVRpIyIimojP50MsFhvVwlFYWAgAMJvNaoWVxoRDgU6n08RwIiIiosno9frT+mqkCoJp4aSZl1SIiIhygBBCE4nFRJhwKPB4PGhqakJ7e7vaoRAREU3IaDSeVuI8GAzC6/UiEomoFNVfMOFQ4PV6ceLECXR1dakdChER0YQcDsdpLRyBQAA+n48JRzYoKCjAggULUFlZqXYoREREE1q1atVp09abzWZYrVZN9EVkwqGgsLAQy5YtQ11dndqhEBERAQBeeeUVPPPMM6OWVVdX48SJE6MKVdpsNjidTpY2JyIioulzuVwoLS1Fa2vrqOUXX3zxhDPJqo0JBxERUZZxOBzo6Og4rb5GVVUVjh8/rsnpONS/qKNxnZ2deOONN1BSUoILL7xQ7XCIiIgm/T2qrq5OF/9yuVwIhUIoLS2FzWabq/DGxRYOIiKiHLJ161Z0dXVpZtK2FLZwKKisrMS2bds0XUyFiIgoRa/Xp4fBFhYWQkqpidLmbOFQoNfrYTabNdHDl4iIaCp27doFr9cLnU4HvV5/WkEwNagfAREREWVUQUEBOjs7NdV5lAmHguHhYRw/fhydnZ1qh0JERDRlV155Jdrb29OVRtUeLsuEQ8Hw8DCam5vR0dGhdihERERT5nA4MH/+fHi9XvT398Pv96uadLDTqAKbzYZ58+ahoKBA7VCIiIimpaSkBAaDAYsWLcJ7772nal8OJhwKioqKsHLlSrXDICIimrb6+noAgNVqxYUXXojf/e53qKmpUWXkJS+pEBER5YlAIKBabQ4mHERERHli06ZNql1WYcKhoLOzE8899xzefPNNtUMhIiKalnfeeQe7d+9Ge3s7gMQllra2NlVaOZhwTEEsFtNUeVgiIqKpiEajiEQio+px+P1+VepzTCvhEEJ8QgjxjhDCk7y9JoS4LHmfUQjxbSHEQSGETwjRKYT4uRCiZsw2GoUQrwgh2oUQd4y5r1UIIYUQ545Zfo8QYs8M9/GMVFRU4IILLsCqVavUeHoiIqIZW758ObZs2YKamr/8FKcmdptr023haAfwJQDrk7fdAB4XQqwAYAOwDsDXkv9eC2ApgN+N2cYPAPwCwNUArhRCbBlzfxDAt6cZ16wxGAyw2WywWCxqh0JERDQtVqsVdrsdRqNx1DKDYe4HqU7rGaWUT4xZ9GUhxCcAnCul/AmAnSPvFEJ8GsAbQog6KeXJ5OIiAPsBvAOgE0DhmG3eC+ATQojLpZR/nE58RERENDmHw6HK8864D4cQQi+EuAlAAYDXJlitEIAE4Bqx7A4AzwLwA4gDeHrMY1oB/BjAN4UQqvcx8Xq9aG1tRVdXl9qhEBERTUtfXx9OnTqF4eHh9LKKigpVYpl2m4oQYhUSCYYFgBfANVLK98ZZzwLgWwAelFJ6UsullH8UQpQDcEop+yZ4mn8H8CEAtyJx+WVaAoHAqOajM9Hb24t3330XxcXFqK6uzsg2s0UgEFA7hDmXj/sMcL/zDfc7f7S0tKC/vx8A0pdRFi5ciKeeegqVlZUz7s8RiUSm/ZiZtCAcBbAGwLkAfgTgZ0KIs0auIIQwAvhlcvufHLsBKWVokmQDyfu+A+AuIYSq88JbrVZUVFSguLhYzTCIiIimrbCwEOXl5bBarellOp0ONTU1kFIiGo3OWSzTbuGQUoYBNCf/fFMIsQHAZwD8HZBONh4B0ABg+8jWjWm6G4lk5bSERYnVah314p4Jq9WKoqKi9P/zUT7udz7uM8D9zjfc79y3bNkyAKfv8+bNm/HKK6/gxIkTsFqtKCwshNPpnHKLRzgcnnYsmeimKgCYgVHJxhIAF0kpB2a6USmlVwjxNQB3AhjbWZWIiIjOwJYtW7BlS2Kg6B//+MdZHy473Toc3xBCXCCEqBdCrBJCfB3ANgAPCCEMAH6NxHDZWwHohRBVydtML4vcB8AN4OYZPp6IiIgUzEXph+n24ahEohPnUQDPA9gE4FIp5bMAagFclfz3AICuEbfzZhKclDIC4F+R6KCqiu7ubuzevRv79+9XKwQiIqIZOXToEPbs2YOOjo5J1ystLQUwu5W1p1uH4yOT3NeKxOWVGZNS1o+z7CEAD53Jds9EPB5HJBKZ0441REREmRAOhxEKhRR/w1avXo23334bTU1NqKiogMPhyPgllv/f3t09tVH9cRz/LHkC8kBJE7zB0t+0Wr3CcXQ6Y73xwguneuWVf6DjP+A/4OiMc1QoFAtYodBSIs0DhGXzULJJfhfMriwFQ2jWFHm/7nrmu9uznMPhm+x5+Pe3Grtk8vm8Pvnkk6FtBQsAwEXduXNHt27dOtdKy9nZWc3Ozmp1dVXlclljY2NyXXdgu5IOfWOtN10sFlM6ndb4+PiwqwIAQF+SyaQmJiaUSCTOfc17772nd999Vzs7O1pfX1en0xlIXUg4AABAwNTUlO7fv69cLqeRkcGkCiQcPdRqNW1tbalYLA67KgAA9KVSqahQKMhxnAtdX6/XB1YX5nD0sL+/r+XlZWWzWc3MzAy7OgAAnNvTp09VKpUUjUaVSqX6vt5xnIHN4yDh6GF0dFT5fH5op+sBAHBRmUxGnU6n5+6q7XZb3313tCD05s2b+vTTT2Xbtqanpwc2aZSEo4dsNqsPP/xw2NUAAKBvt2/fltR7O3fLsvT+++/7//72229lWZZ//SCQcAAAcMWNjIyo2WwqFospEon4Z7AM9P8Y+B0BAMClc+/ePZVKJW1ubqrdbg9sOayHhKOHFy9e6IcfftDi4uKwqwIAQF+Wl5f1448/qlAonCv+/v37+vrrr7W3tzew5bAeEo4e2u22ms3mhY7iBQBgmJrNpur1ulqtVl/Xff755wNdEisxh6OnXC6nu3fvsrU5AODSeeedd3Tz5k3/cLbzevbs2cB32Cbh6CEej+vatWvDrgYAAH3ztnTo9/j5+fl53bhxQ5b1WmeyBvBKBQAABLRarYEmGxIJR0/1el2FQkGVSmXYVQEAoC97e3va2dnpaz7G0tLSQPff8JBw9FCtVrW0tKQnT54MuyoAAPRlY2NDi4uLKpVK577mrbfekiR1u92B1oWEo4d4PK5sNqtMJjPsqgAA0JdkMqnJycm+5nBMTU2pWCzKdd2BJh1MGu0hl8vp448/HnY1AADo2507dyT13tr8pC+++ELff/+98vm8RkZGBrInB99wAACAV3z55ZdyXXdgO46ScAAAgFPdu3dPf/75pyS9duJBwtFDsVjUTz/9pKWlpWFXBQCAvvzxxx/6+eef9ddff134Ht98840KhYIODw/VbrcvfB8Sjh5c11WtVlOz2Rx2VQAA6EutVpNt2691PEckEtFXX32l6elpbW9vXzjpYNJoD9evX9dHH32kWCw27KoAANCX27dv6+2331Y+n3/te83MzMiyLK2srCgej/d9PQlHD4lEou896AEAeBN4Wzr0u0rlLDdu3ND6+vqFVq3wSgUAAJzbZ599dqHNMEk4emg0Gnrx4oX29vaGXRUAAPpi27ZKpZIajcZA73vr1q2+r+GVSg97e3taWFhQNpvV9evXZdu2otGoJicnAzGu6yqTySiRSEiSDg8Ptb+//0pstVpVq9VSOp32d35rtVqqVquKRCLKZrN+7P7+vg4PD5VKpfyvw1zX1d7enkZGRgKvemzb1suXLwOx7XZbu7u7sixLuVzOjz04OFCz2VQymfSPH/ZiJQXe9TmOI8dxND4+rmQyKeloaZR3tkwul/MP+HEcR41GQ2NjY0qlUpKOtsYtl8uSjubDeF/D1Wo11et1jY6O+qcZSlK5XFa321U2m1UkEpF0dJ5NrVZTIpEI7PjqxU5OTioaPerKjUZDjuO8ElupVNTpdHTt2jV/Pk6z2dTBwYHi8bgmJiYC7ek4jiYmJvz3lC9fvpRt24rFYoHTg722Px7bq+1P6ydntf1p/eQ8be/1k5Nt78WebPtyuSzLsjQ9Pe3Hev0krLY/HivJ33r5tLY/Tz/p1fan9ZNOpxOI3d3dVbvdPrWfnKftvX7ypo8RnkGNEY1G40qNEV4/uQxjxNramiqVimZnZzUzM6NB+eCDD/q+hm84evA6TyqVUrValTFGjx49CsQ8evRIxpjAtyC2bcsYo4cPHwZiV1ZWZIwJHAbnOI6MMVpYWAjEPn78WMaYwB749XpdxhjNz88HYtfW1mSM0c7Ojl/WbDZljNGvv/4aiH3y5ImMMSoUCn5Zq9WSMUbGmEDs1taWjDF6/vy5X9bpdPzY4+uyvdinT58G7uHFuq7rl21vb8sYo42NjUDsL7/8ImNMYEb1zs6OjDFaX18PxM7NzckYE1hBVCwWZYzR48ePA7EPHjyQMUa1Ws0vK5fLMsZodXU1EPv777/LGKODgwO/bHd3V8YYLS8vnxpbrVb9Mq+fnFxKvby8LGOMP2hLRwO7MUaLi4uB2NXVVRlj/IFY+rvtHzx4EIj1+kmxWPTLvLafm5sLxK6vr8sYE1gid3h4qLm5uVf61MbGhowx2t7e9stc1z21nzx79kzGGG1tbfllx/vJ8Vntz58/lzFGm5ubgXt4sa1Wyy8rFAoyxrzy9e1vv/32Stt7/WRtbS0QOz8/L2NM4PCqUqkkY4y/v4BnYWFBxhg5juOXVSoVGWO0srISiH348KGMMbJt2y+7imPE5ubmpRojvN/71xkjFhcXL80YMT09HUj6holvOHrI5/O6e/eupKPGzGQyfhbvSSaT6nQ6fgYtHS0jymQy/qeD47GtViuw6sWLPbnX/djYmDKZTCB2ZGTklbLjscdnDnux3qcAz+jo6JmxJ3mfArxs2/NPsSefw4s93uG92JMTmdLptLrdbiA2Ho+fGeu6bmDyUiwWOzM2Ho8HfhZe7GltNDo6eu7YbrcbaPtoNKpMJhP4JOnFuq57auzJ+o6Pj5/Z9ifb4p9ij/9f0t/95Pg9LMtSOp1+ZUA6K/Yi/eS0tj+rnxxvT6/tT8am02m12+1TY0/+LFOplBKJxKmxJ9szlUopGo2eq+1TqZQsywrEeu15lcYIL/ayjBFn/c71M0akUilFIpFLMUZMTU3JcRxNTU1p2KxBnwY3TJZlZSTt7+/vD/SwNe/d16Bm+V4WV/G5r+IzSzw3z301XMXnDuuZbdv2XjNNdLtdu1e8xCsVAADwLyDhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoSPhAAAAoYsOuwJhsG17oPdrNBqSpFarNdD7vumu4nNfxWeWeG6e+2q4is8d1jNf5O+s1e12B1qJYbIsKyGpOex6AABwBexI+l+32z3X393/VMIh+UlHYtj1AADgP+7wvMmG9B9MOAAAwJuHSaMAACB0JBwAACB0JBwAACB0JBwAACB0JBwAACB0JBwAACB0JBwAACB0/wcw3ZRXvAKbVAAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<Figure size 800x700 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%%time\n",
-    "\n",
-    "omsa.set_criteria(criteria)\n",
-    "\n",
-    "model_url = 'https://thredds.cencoos.org/thredds/dodsC/CENCOOS_CA_ROMS_FCST.nc'\n",
-    "bbox = [-124.5, 40, -123.5, 42]\n",
-    "search = omsa.run(\n",
-    "                  loc_model=model_url,\n",
-    "                  approach='region',\n",
-    "                  bbox=bbox,\n",
-    "                  criteria=criteria,\n",
-    "                  horizontal_interp=False,\n",
-    "                  var_def=var_def,\n",
-    "                  xarray_kwargs={'chunks': {'time': 1, 'depth': 1}},\n",
-    "                  time_range=['2021-9-1','2021-9-8'], \n",
-    "                  variables=['salt'],\n",
-    "                  readers=[odg.erddap],\n",
-    "                  erddap={\n",
-    "                      'known_server': 'ioos'\n",
-    "                  },\n",
-    "                  figname_map='nonlocal_library_region.png',\n",
-    "                  figname_data_prefix='nonlocal_library_region_'\n",
-    ")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/docs/Demo_workflows.ipynb b/docs/Demo_workflows.ipynb
deleted file mode 100644
index 56e1b46..0000000
--- a/docs/Demo_workflows.ipynb
+++ /dev/null
@@ -1,883 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "a9da2fa8-9a25-497e-8ec6-d08609ad38ca",
-   "metadata": {},
-   "source": [
-    "# Demo workflows\n",
-    "\n",
-    "Below are demonstrated the use of this library as a Python package and from the command line interface. Note that one step demonstrated below is to save datasets you need to run the local examples."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "3b2011cd-01e0-454c-af6f-d968522f5385",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import xarray as xr\n",
-    "import ocean_data_gateway as odg\n",
-    "import cf_xarray\n",
-    "import pandas as pd\n",
-    "import extract_model as em\n",
-    "import ocean_model_skill_assessor as omsa\n",
-    "import numpy as np\n",
-    "from IPython import display\n",
-    "from glob import glob"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "07a7bb3c-38d8-45a1-8444-ff0ea7aac52f",
-   "metadata": {},
-   "source": [
-    "## Definitions\n",
-    "\n",
-    "These dictionaries are not required for every type of run, but are required for identifying variables between datasets and models, and for running QC. They can be complicated if desired, but do not have to be. Once they are written they do not need to be modified much. More information about these dictionaries is available in the [`ocean_data_gateway` docs](https://ocean-data-gateway.readthedocs.io/en/latest/details.html#Configure-custom-criteria-and-variable-definitions)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "b0e38fa9-0318-4c0b-9be8-d622db151d97",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "criteria = {\n",
-    "    \"salt\": {\n",
-    "        \"name\": \"sea_water_practical_salinity$\",\n",
-    "    },\n",
-    "}\n",
-    "\n",
-    "var_def = {\n",
-    "    \"salt\": {\"units\": \"psu\", \"fail_span\": [-10, 60], \"suspect_span\": [-1, 45]},\n",
-    "}\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "571d37a7-bd3c-4629-9931-e293bc609ce0",
-   "metadata": {},
-   "source": [
-    "A more complicated example of `criteria` is shown here, as it can be brought it from a nonlocal source:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "ed628da3-09dd-4b3a-bfd0-cd52b154399b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'ssh': {'standard_name': 'sea_surface_height$|sea_surface_elevation|sea_surface_height_above_sea_level$',\n",
-       "  'name': '(?i)sea_surface_elevation(?!.*?_qc)|(?i)sea_surface_height_above_sea_level_geoid_mllw$|(?i)zeta$|(?i)Sea Surface Height(?!.*?_qc)|(?i)Water Surface above Datum(?!.*?_qc)'},\n",
-       " 'temp': {'name': '(?i)temp$|(?i)temperature$|(?i)tem$|(?i)s.sea_water_temperature$|(?i)temperature(?!.*(skin|ground|air|_qc))'},\n",
-       " 'salt': {'standard_name': 'sea_water_salinity$|sea_water_practical_salinity$',\n",
-       "  'name': '(?i)salinity(?!.*(soil|_qc))|(?i)sea_water_salinity$|(?i)sea_water_practical_salinity$|(?i)salinity$|(?i)salt$|(?i)sal$|(?i)s.sea_water_practical_salinity$'},\n",
-       " 'u': {'standard_name': 'eastward_sea_water_velocity$|sea_water_x_velocity|surface_eastward_sea_water_velocity',\n",
-       "  'name': '(?i)eastward_sea_water_velocity(?!.*?_qc)|(?i)sea_water_x_velocity(?!.*?_qc)|(?i)uo(?!.*?_qc)'},\n",
-       " 'v': {'standard_name': 'northward_sea_water_velocity$|sea_water_y_velocity|surface_northward_sea_water_velocity',\n",
-       "  'name': '(?i)northward_sea_water_velocity(?!.*?_qc)|(?i)sea_water_y_velocity(?!.*?_qc)|(?i)vo(?!.*?_qc)'},\n",
-       " 'wind_speed': {'standard_name': 'wind_speed$'}}"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "url = 'https://gist.githubusercontent.com/kthyng/c3cc27de6b4449e1776ce79215d5e732/raw/af448937e4896535e36ef6522df8460e8f928cd6/my_custom_criteria.py'\n",
-    "criteria = odg.return_response(url)\n",
-    "criteria"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6a4dced1-5652-4521-9c67-509861debee3",
-   "metadata": {},
-   "source": [
-    "## Python library\n",
-    "\n",
-    "This package can be used as a Python package or from the command line. Here we demonstrate its use as a Python package."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b936240d-ba13-4c23-bd7e-4b8510b7d551",
-   "metadata": {},
-   "source": [
-    "### Nonlocal reader: stations\n",
-    "\n",
-    "This demonstrates the case in which your data files for comparing with model output are not available locally, but you know their names and where to find them (in this case, at the IOOS ERDDAP server). More information about these inputs is available in the [API docs](https://ocean-model-skill-assessor.readthedocs.io/en/latest/api.html)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "39dda472-993b-47b2-b932-a6bcb8da53b5",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 800x700 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# omsa.set_criteria(criteria)\n",
-    "\n",
-    "model_url = 'https://thredds.cencoos.org/thredds/dodsC/CENCOOS_CA_ROMS_FCST.nc'\n",
-    "\n",
-    "dataset_ids = ['edu_humboldt_tdp','bodega-bay-bml_wts']\n",
-    "\n",
-    "search = omsa.run(\n",
-    "                  loc_model=model_url,\n",
-    "                  approach='stations',\n",
-    "                  criteria=criteria,\n",
-    "                  var_def=var_def,\n",
-    "                  xarray_kwargs={'chunks': {'time': 1, 'depth': 1}},\n",
-    "                  time_range=['2021-9-1','2021-9-8'], \n",
-    "                  variables=['salt'],\n",
-    "                  readers=[odg.erddap],\n",
-    "                  erddap={\n",
-    "                      'known_server': 'ioos'\n",
-    "                  },\n",
-    "                  stations = dataset_ids,\n",
-    "                  figname_map='nonlocal_library.png',\n",
-    "                  figname_data_prefix='nonlocal_library_'\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f9b51f1d-f999-4243-afc0-f66c38cdb39b",
-   "metadata": {},
-   "source": [
-    "#### Save local data files\n",
-    "\n",
-    "Here we save the data files to use for the local examples."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "61751f35-3240-4af8-90fa-9b9322805ffa",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "search['edu_humboldt_tdp'].squeeze().to_dataframe().to_csv('edu_humboldt_tdp.csv')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "e6339657-ddae-4893-b786-64b1c266901c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "search['bodega-bay-bml_wts'].to_netcdf('bodega-bay-bml_wts.nc')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "dd29ad0d-e2b7-4424-b1be-489b29e6b921",
-   "metadata": {},
-   "source": [
-    "### Nonlocal reader: region\n",
-    "\n",
-    "This demonstrates the case in which your data files for comparing with model output are not available locally, and you want to perform a search in time and space. By default this would search in the spatial bounding box of the model output, but here we instead input a smaller bounding box so as to limit the number of datasets found and used. For several of the datasets, the model output isn't available (must be determined to be on land). "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "3c63654c-58ae-47bb-ae63-c0b01c10b88c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 800x700 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# omsa.set_criteria(criteria)\n",
-    "\n",
-    "model_url = 'https://thredds.cencoos.org/thredds/dodsC/CENCOOS_CA_ROMS_FCST.nc'\n",
-    "bbox = [-124.5, 40, -123.5, 42]\n",
-    "search = omsa.run(\n",
-    "                  loc_model=model_url,\n",
-    "                  approach='region',\n",
-    "                  bbox=bbox,\n",
-    "                  criteria=criteria,\n",
-    "                  var_def=var_def,\n",
-    "                  xarray_kwargs={'chunks': {'time': 1, 'depth': 1}},\n",
-    "                  time_range=['2021-9-1','2021-9-8'], \n",
-    "                  variables=['salt'],\n",
-    "                  readers=[odg.erddap],\n",
-    "                  erddap={\n",
-    "                      'known_server': 'ioos'\n",
-    "                  },\n",
-    "                  figname_map='nonlocal_library_region.png',\n",
-    "                  figname_data_prefix='nonlocal_library_region_'\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8d45f569-ec8e-47c7-a180-d72a44a76581",
-   "metadata": {},
-   "source": [
-    "### Local reader\n",
-    "\n",
-    "This demonstrates the case in which your data files for comparing with model output are available locally."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "8d04581c-d1f1-4fac-b8eb-488e8b6e289f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 800x700 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1080x360 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# omsa.set_criteria(criteria)\n",
-    "\n",
-    "model_url = 'https://thredds.cencoos.org/thredds/dodsC/CENCOOS_CA_ROMS_FCST.nc'\n",
-    "filenames = [\n",
-    "             'edu_humboldt_tdp.csv',\n",
-    "            'bodega-bay-bml_wts.nc',\n",
-    "            ]\n",
-    "\n",
-    "skip_units = True\n",
-    "\n",
-    "search = omsa.run(\n",
-    "                  loc_model=model_url,\n",
-    "                  approach='region',\n",
-    "                  criteria=criteria,\n",
-    "                  var_def=var_def,\n",
-    "                  skip_units=skip_units,\n",
-    "                  xarray_kwargs={'chunks': {'time': 1, 'depth': 1}},\n",
-    "                  time_range=['2021-9-1','2021-9-8'], \n",
-    "                  variables=['salt'],\n",
-    "                  readers=[odg.local],\n",
-    "                  local={'filenames': filenames},\n",
-    "                  figname_map='local_library.png',\n",
-    "                  figname_data_prefix='local_library_'\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9d9e80d6-314e-4586-ba1f-c67ac67e10d5",
-   "metadata": {},
-   "source": [
-    "## Command line interface\n",
-    "\n",
-    "Here we demonstrate the use of the command line interface mode of the package. The config yaml file must be modified for the necessary inputs. These are the same examples as above, but accomplished via the command line interface instead of the Python package.\n",
-    "\n",
-    "### Local reader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "2157fb08-fd79-4036-80bc-53a2e89229fd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "config_file = 'config_local.yaml'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "1b8d86f4-53c2-4c1b-baa8-3eff5c759dbd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# %load config_local.yaml\n",
-    "---\n",
-    "approach: \"stations\"\n",
-    "loc_model: \"https://thredds.cencoos.org/thredds/dodsC/CENCOOS_CA_ROMS_FCST.nc\"\n",
-    "axds:\n",
-    "bbox:\n",
-    "criteria:\n",
-    "  salt:\n",
-    "    name:\n",
-    "      \"sea_water_practical_salinity$\"\n",
-    "erddap:\n",
-    "figname_map: \"local_cli.png\"\n",
-    "figname_data_prefix: \"local_cli_\"\n",
-    "local:\n",
-    "  filenames:\n",
-    "    - \"../data/edu_humboldt_tdp.csv\"\n",
-    "    - \"../data/bodega-bay-bml_wts.nc\"\n",
-    "only_search: false\n",
-    "only_searchplot: false\n",
-    "parallel: true\n",
-    "readers:\n",
-    "  - \"local\"\n",
-    "run_qc: false\n",
-    "skip_units: true\n",
-    "stations:\n",
-    "time_range:\n",
-    "  - \"2021-9-1\"\n",
-    "  - \"2021-9-8\"\n",
-    "var_def:\n",
-    "  salt:\n",
-    "    units: \"psu\"\n",
-    "    fail_span:\n",
-    "      - -10\n",
-    "      - 60\n",
-    "    suspect_span:\n",
-    "      - -1\n",
-    "      - 45\n",
-    "variables:\n",
-    "  - \"salt\"\n",
-    "xarray_kwargs:\n",
-    "  chunks:\n",
-    "    time:\n",
-    "      1\n",
-    "    depth:\n",
-    "      1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "d32c140b-0fe5-4e05-9a01-5b80fa81062d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!python ../ocean_model_skill_assessor/CLI.py $config_file"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "4320e0ab-3cb5-400d-9c4b-4b56e4a4cac5",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "display.Image(\"local_cli.png\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "b91db430-46fd-40ac-a6e8-f6d16ece8640",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABOwAAAHVCAYAAABCCGRHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAADIaklEQVR4nOzdd1RURxsG8Gfp0gWkiDQVG0ZFsVfUqIlRYydWsHeNLVFjifHTGGKPJooR1Bh7b7Fj1MQu9hKJKNhQKaJ0dr4/PHvDugvswiKLPr9z9igzc2fm7t29e/fduTMyIYQAERERERERERER6QWDou4AERERERERERER/YcBOyIiIiIiIiIiIj3CgB0REREREREREZEeYcCOiIiIiIiIiIhIjzBgR0REREREREREpEcYsCMiIiIiIiIiItIjDNgRERERERERERHpEQbsiIiIiIiIiIiI9AgDdkRERERERERERHqEATsiHQsPD4dMJkOzZs0+qLZ1KTAwEDKZDGFhYe+kvWbNmkEmkyE8PFyr7WbMmAGZTIYZM2YUSr90ydPTEzKZDFFRUUXdlWIjLCwMMpkMgYGBWm0XFRUFmUwGT0/PQukXEf2nOJ2HiYiIiLTBgB0RkY5FRERgxowZ2LFjh07q27FjB2bMmIGIiAid1EdUUPv27UPLli1hZ2cHCwsL1KxZE0uWLIFcLtdJ/StXroRMJoNMJsOAAQN0Uifl7LfffkODBg1gY2MDa2trNGjQAOvWrStQnVlZWQgJCUHTpk3h4OAAMzMzeHh44PPPP8fOnTt11PP3R0JCAsaPH49y5crBzMwMLi4u6NmzJ27evJmv+sLDwzFnzhx07NgRrq6u0vspJiZGxz0nXR67pKQk/Pbbb+jVqxcqVKiAEiVKwNzcHD4+PpgwYQIeP35cCHtAbzt+/Dg6d+6M0qVLw9jYGNbW1qhbty7mz5+P9PT0HLeTy+VYvHgxfH19YWFhATs7O7Rs2RL79+/Pd1/u3r2LAQMGwMPDA6ampnByckLnzp1x9uzZfNdJ+ZOamoqZM2eiSpUqKFGiBEqVKoUOHTrg9OnTOqlfCIEmTZpI5+uTJ0/qpF4q5gQR6dSxY8cEANG0adMPqm1d6tu3rwAgQkND30l7TZs2FQDEsWPHtNpu+vTpAoCYPn26UnpoaKgAIPr27auT/uni+fDw8BAAxL1793TSpw9Bfo9jTEyMqFixomjevHnhdKyIzZkzRwAQAETZsmVFtWrVhIGBgQAg2rdvL7KysgpUf2xsrLCzs5Pa6N+/v456TuoMHjxYeq4rVaokKleuLP09fPjwfNUZFxcn6tWrJwAImUwmKlasKGrVqiVcXFwEANG5c2ed9X/JkiWiYsWKYsmSJTqr8117/Pix8PT0FACEubm5qFmzpihVqpQAIEqUKCGOHz+udZ02NjbSccz+iI6OLoQ9+HDp+tj16tVLOlZWVlaiRo0awtvbWxgaGgoAwt7eXpw9e7aQ9oaEEGL+/PnSMbC1tRU1a9aUrqEAiDp16ohXr16pbJeZmSnatm0rAAgDAwNRrVo14eXlJW0XHBysdV8OHz4sLC0tBQBhaWkp/Pz8hLu7uwAgDA0NxW+//aaLXSYNvHr1StSqVUsAECYmJsLX11e4urpKx2L9+vUFbiMkJETpfH3ixAkd9JyKO46wIyIi0iFXV1fcunULR44cKequ6Nzff/+NyZMnw8DAAL///jsiIyNx+fJlXLx4EU5OTti1axfmz59foDa+/PJLJCQkoG3btjrqNeVkw4YNWL58OSwsLHDkyBHcvHkTN27cwOHDh2FhYYGlS5diy5YtWtUpl8vRvn17nD59Gp06dcKDBw9w69YtnD9/Ho8ePUJ0dDRGjRqls30YMWIEbt26hREjRuisznctMDAQUVFRaNSoER48eIALFy7g4cOHGDlyJFJSUtCtWze8fv1aqzp9fHwQGBiIZcuW4fz584XUcyqMY/f555/j8OHDiIuLw6VLl3Dnzh3cvn0bderUwYsXL9C5c2ekpKQU0h592O7du4eJEycCAL777jvExsbiwoULiIqKwl9//QUHBwecPXsWwcHBKtsGBwdj7969cHJywsWLF3H58mX8+++/WLduHQwMDDBx4kScO3dO474kJCSgW7duePXqFbp3747Hjx/j3LlzuH//Pn7//XfIZDL069cPkZGROtt/ytm4ceNw4cIFVKpUCXfu3MHFixfx4MEDzJ07F1lZWejXrx+io6PzXf+zZ8/w1VdfwdfXF2XKlNFhz6m4Y8COiIiINDJr1iwIITBgwAB88cUXUnr16tWlQN3333+PjIyMfNV/+PBhrFu3DoMHD4afn59O+kw5mzVrFgBgypQpaN68uZTeokULTJ48GcCbL63aWLFiBU6ePAl/f39s3rxZ5YtHmTJl0KRJkwL2/P1x/vx5HDhwAEZGRli3bh3s7e0BAMbGxliwYAEqV66Mp0+fYsWKFVrVe+rUKYSGhmLo0KGoVatWYXT9g1cYx27RokXYvn07WrRoASMjIym9XLly2LJlC0xMTBAdHY0//vhD5/tDwMGDB5GZmYmaNWvim2++gbGxsZRXv359fPPNNwCgcotreno6fvjhBwDAggULUL16dSmvR48e6N+/P4QQ0jlXE6tXr0ZcXBxKlSqFkJAQWFpaSnlffPEFBgwYgPT0dMyePTtf+0qae/z4MX799VcAwKpVq+Dh4QEAUiD2448/RkpKCn788cd8t/Hll18iPj4ey5Ytg6GhoU76Te8HBuzog5eZmYlffvkFjRo1gq2tLczMzFCpUiV88803ePnyZY7bbd++HQ0aNICFhQXs7e3x2Wef5fordl4T2Ot6wQi5XI5FixahatWqMDMzg5OTE/r3749nz57prG/Z07OysjB37lxUrlwZJUqUgKenJ2bMmIHMzEwAQEpKCqZOnYry5cvDzMwM5cqVww8//AAhRK77cefOHXTv3h2Ojo4oUaIEfH19sWrVqly32bt3L9q0aQMHBweYmprCy8sLw4YNy9cvX5mZmfjhhx9QqVIlmJmZwdXVFQMHDsTTp0/Vlvf09ERQUBCANxdbinko8nNsFYsXrF69GgAQFBSkVN/bk6zfv38fvXr1gqOjI8zNzVGtWjUsXbo01+c4+2IUBw4cQLNmzaR5rD7++GOcOHFCqz5nd+jQIXTq1AmlS5eGqakpSpcuDX9/fyxduhRpaWlSOSEE1qxZgyZNmsDW1hYmJiZwdnZGrVq1MHHiRGnOpfj4eJiamsLIyCjH5x8AOnfuDJlMhsWLF+e7729LSkrC2LFj4enpCTMzM5QtWxZTpkxBcnKyStncFp24du0apk+fjvr168PFxQUmJiZwcXFBp06d8Ndff+XY/u7du9G6dWs4ODjA2NgYpUqVQrVq1TBy5Mh8z3GlrZcvX+Lw4cMAgP79+6vkd+3aFdbW1njx4gWOHTumdf2pqakYOnQoHB0d38kXkNu3b2PQoEEoX748SpQoAXt7e9SqVQvTp09XO0/U9evX0bt3b5QpUwYmJibSPEI5zV2TffGce/fuITAwEK6urjAyMpLeu9kXvImIiECXLl3g5OQEAwODQl905/bt27h+/ToAoF+/fir5irQrV67gzp07Gte7aNEiAG8CfQYGhX+ZmdeiE3/99Rc6deoEJycnmJiYoEyZMujTp0+O75snT55gyZIlaN26tfR+L1myJJo2bYq1a9fqvP9bt24FAHz88cdwd3dXyjM0NETfvn0BAJs3b9Z527qk+FwC/rs+srS0hJOTE/r27YsnT55IZUNDQ1GrVi1YWFjA0dERQ4YMQWJiotp683PuO3DgANq3bw8nJyeYmpqiTJkyCAoK0vlIpMI4dnZ2djnmubm5oVKlSgCg1XsyL/pw7F6/fo2ZM2eiWrVqsLCwgJmZGdzc3NCsWbMC/QikLcXIxbJly6rNL1euHABI17YKx44dQ3x8PKytrdGlSxeV7RSfmQcOHEBSUpJGfTl16hQAoHXr1rCyslLJ79y5M4A3x+zt/uSXJp9J2a8bjx8/jpYtW8LW1hZ2dnbo2LEj/vnnH6m+Xbt2oXHjxrC2tkbJkiXxxRdf4NGjR2rbPnnyJDp27AhnZ2cYGxvDzs4OlStXxoABA3L8nD179iwCAgLg6uoqfS537doVly5d0snzkX0/MjMzUblyZdSvX18lX3F8tR2RrqD4sXLAgAGoV69egfpK76EivSGXqIglJiaKJk2aSPNNeHh4iKpVqwoTExMBQFSuXFk8ffpUZbu5c+dK8wu4uLiIWrVqCUtLS2Fqaiq+++47tfPI5TUfli7mn8teR48ePQQA4e3tLXx8fISRkZEAIHx8fERqaqpO+pY9vXPnztJzVrFiRSGTyQQAERQUJFJSUkTdunWFoaGhqFatmjTfCwAxbdo0lfYUc7ZNnjxZ2NjYCFNTU5U5REaOHKm2r19//bVUpkyZMqJWrVrC3NxcABAlS5YU586dU9kmpznsMjMzRbt27aT6KlSoIKpXry4MDQ2Fu7u7GDFihMocdl26dBHe3t4CgHB0dBQNGzaUHiNGjFDb55w8fvxYNGzYUDg6OkrHMnt9v/76q1T2xo0bwt7eXgAQZmZmolatWtI8J8OGDctxDjtF+pw5c4RMJhN2dnbCz89PqsvAwEBs2rRJq34LIcTw4cOl583e3l74+fkJDw8Paa6z7P0YN26cVNbd3V3Url1beHl5Se/D7du3S2UVx2Px4sVq201MTBRmZmbC0NBQPH78WAjx3+vbw8NDq31QbBcQECB8fX2FTCYTPj4+omrVqtLru169euL169dK2927dy/H9lq0aCHNi1O5cmVRs2ZN4eDgIM2Bsm7dOpVtlixZIj0/zs7Ows/PT3h7ewszMzMBQCxYsEBt++qOd0GEh4dLr6+MjAy1ZRT7N3PmTK3rnzJligAgVq9eLYT4b47IwpjD7rfffpNeXyVKlBA1a9YUlSpVEqampmrni9y5c6eUZ2trK/z8/KR5qgwMDMSKFStU2lCcx77++mtha2srnccqVaokZsyYIYT479zz7bffClNTU2FpaSlq1aolypYtK/VBcZ7V9SVbWFiYACDKly+fY5ly5coJAGLNmjUa1Xnnzh0BQNjZ2Qm5XC527NghevbsKZo3by66d+8uQkJCVD5/CiqnuUSFEGLZsmXSe9XR0VH4+fkJW1tb6XW8Z88elW0Un+ElSpQQ5cqVU5ozCoAYMmRIrv3Q9jO8WbNmAoCYNWuW2vwTJ05IcyZlZmZqVXd2iv4X1hx2ivoXL14sff5Wr15det9UqVJFpKSkiFGjRknzX2a/NmnatKmQy+VKdWp77hNCiNGjR0vbODo6Cl9fX2FtbS0ACGtra3Hq1CmVbfT92GVXoUIFAUAsWrRIJ/UJUfTHLiMjQ5rz0sDAQFSsWFH4+fmJ0qVLS9cM8fHxSvXn95jl5ciRIwKA8PLyEmlpaSr5imvMwYMHK6XPmDFDABAtW7ZUW29GRoa073/++adGfWnZsqUAIL766iu1+Tdu3JCe42vXrmlUZ140+UxSXDfOnz9fGBoaCkdHR1GzZk1hYWEhfS96/PixNBfg26+nihUripSUFKV2d+zYIR1re3t76bNSUefo0aNV+jp//nzp/G5nZyd8fX2la1djY2OxdetWlW3yez0YGBgoAIgBAwaozY+OjpaOxYMHD7SqOyUlRZQvX17Y29uLFy9eCCH+e445hx0JIQQDdvRBCwgIEABEixYtRGRkpJQeFxcnOnXqJACILl26KG1z8eJFYWhoKGQymfjpp5+ki5SkpCTRvXt3YWxsXOQBO2NjY1G6dGlx5swZKe/27duiTJkyAoD4+eefddK37O2VKVNGXLp0ScoLDw8XJiYmQiaTifbt24uPPvpI6Tlet26dACBMTU1FXFycUr2KL7pGRkbC399fxMbGSnmbN2+WnuO3v2zt3r1b2i77RLyJiYmiY8eOAoDw9PQUycnJStvlFLBbtGiRFOjL/qF57949UbVqVakfRb3ohFwuFzVr1hQAROvWraUPfCGEWL9+vTA2NpYurHMK2BkZGYmxY8eK9PR0IcSbi8uJEydKX3IePXqkcX8XLlwogDcTcK9du1ZpEYIXL16IefPmScc0NjZWGBgYCBsbG3Hy5EmlelJSUsT69evF5cuXlfYHgKhfv77athVBiOwXzQUN2BkZGQlXV1cREREh5V29elW4ubkJAGL8+PFK2+UWsNu8ebO4cuWKUpoisGFpaSmsra3Fy5cvpbyMjAxRsmRJYWRkpBS4VOTt3r1bZVLzwgrYKSZDrlChQo5lBg4cKACI3r17a1X3jRs3hImJiWjcuLGUVlgBu3Pnzknv3YkTJypNHp6eni7Wr1+v9H5/+PCh9IV/9OjR0pe4rKws8b///U86B2Z/nQrx3/vW0NBQtG/fXul9qfiyojj3GBoaikGDBikFfxXnqcIK2CkCpK1atcqxzMcffywAiKlTp2pUp+L92aBBA9GzZ0+p39kflSpVElFRUbrajRwDdpcuXZLOez/88IN0HkpNTRXDhg0TAISNjY3Kue3EiRPi6NGjKgGWy5cvSwtyhIeH59gPbT/DFZOW//7772rzHz58KD132T9DtfWuAnYWFhZK+xIdHS3Kly8vAIjPP/9c2NjYiMOHD0v5V65ckRaZ2bdvn5Sen3PfL7/8IgVbsn+eZ2ZmilmzZknBg7eDBfp+7BQiIiKk+s6fP1/g+hSK+tht2bJFABDVq1dXeX3GxsaKhQsXqvwwVlgBOyH+++Gpffv24tKlSyI5OVnExMSI4OBgYWRkJFxcXFSCMorz3aBBg3KsV/FjbvYfW3Oj+CG8V69eavMPHTokHTt1wan80OQzSXHdaGxsLObNmyedW+Pj46XAa9u2bYW5ubnSj5APHjwQZcuWFQDEsmXLlNqtWrWqlJ793CuXy8WxY8fErl27lMrv379fyGQy4eDgoLLvK1euFEZGRsLKykrl/J7f68GGDRsKAGL27Nlq8+VyufQj4JEjR7SqW/FZvHLlSimNATvKjgE7+mBdvnxZOmln/4Ks8Pr1a+Hm5iZkMpnSlwvFCl5du3ZV2SYlJUUaDVWUAbucPrwVv562b99eJ33L3t7bF2VCCPHFF18I4M0qgRcvXlTJV3ywb9u2TSld8UXX1NRUGiWV3dixYwUA0aRJE6V0xQequl/iXr9+LY1kevtiSV3ATi6XS6Mqli5dqlLfhQsXpH0v6oDd4cOHBfBmRMizZ89U8hW/iucWsKtevbrauhWBQHUjIdVJTk6WfuHUZFTO33//LQCIjh07alT/69evpRXT1AWjWrdurXKMN23aJFxdXUW9evU0akNBcRzVvUaFEGLXrl3Sl5zs55DcAna5+eabbwQApQvcx48fCwDC19dX43qio6OFq6urcHV11emX8x9++EEAEHXr1s2xjCLI+9lnn2lcr1wuF40bNxZGRkbi6tWrUnphBew+/fRTAUD069dPo/KKi+kaNWrkWt/bQUrF+9bZ2VntioJC/HfuqV69eo6r6/7111/S8dQlRdCqe/fuOZbp1q2bAKDx6GDFiApFQHTAgAEiKipKpKamisOHD0tf1mrVqlXg1YQVcgrYKb5Ad+jQQWUbuVwufHx8tApGCvHfuXbgwIEqefPmzROurq4qP/LlRTECfP/+/Wrzk5OTdRKkeVcBO3Wfv8uXL5fy1Y2KU4xaGjVqlJSm7bkvLS1NODs7C0NDQ7XXG0L8FwB5+7NJ34+dEG+Cjo0bNxYAdL4CeVEfO8XK49qMGszvMdNESkqKmDBhgtJq5YpHUFCQ2veQ4nMgp9FwQghRp04dAUD8+OOPGvXj+++/FwCEk5OTSEpKUskfOnSo1K/swZ6C0OQzSXHdqO7ceuDAgVxfT4qg+tvfQ0xNTUXJkiU17qfi2nTnzp1q8xV3brw92j+/14NVqlQRgOqAh+wU3/+2bNmicb2KHysbNGigNEqVATvKjnPY0Qdr+/btAIBu3bqpnRvC3NwcLVu2hBBCaR6vgwcPAgCGDh2qso2ZmZnauYDetZIlS6JTp04q6bVr1wYA/Pvvvzptz87ODp9//rlKeo0aNQAAvr6+8PX1VclXpOXUn06dOsHZ2VklfdiwYQDezO+hWH3t1atX+PvvvwEAI0eOVNnG3NwcAwcOBPDfMczNzZs38eDBA5iZmamd269mzZp6M8/EgQMHALyZQ8zBwUElX/F85SanMop0RRt5OXXqFF68eIHSpUujZ8+eeZZ3c3MDAJw5cwYPHjzIs7y5uTk6dOgA4M0Kl9k9e/YMR44cgampqTS3C/DmeYmJiZFeH9pydXWV2szus88+g7u7O16/fi3NNaOJBw8e4Pvvv0e3bt3QvHlzNGrUCI0aNcLGjRsBAJcvX5bKlipVCqamprhz545Sem7KlCmDmJgYxMTE6HSlsdTUVACAiYlJjmVMTU0BQKsVDH/99VecOHECY8aMQdWqVQvWyTykpKTg0KFDACCtBJgXxfkip1VIR48erVTubZ07d4aFhUWubfTq1SvH+d7q168vHU9dKozjqTgfZ2RkoHHjxggJCYGHhwdMTU3RokULbNu2DTKZDBcuXMDevXsLuAe5UxwPdZ8HMplMWqlW3XFLSkpCSEgI+vbti1atWqFx48Zo1KgRvv76awBQ+14cO3YsYmJitJ5rLq/joDgGgHbvq6Kibn5LxbUAoH6+RHXXAtqe+/7++288efIENWvWVHu9AQDt27cHABw/flwpvTgcu8mTJ+PEiROwsrLSegESTRXVsVNcB+zdu1ftvLDq5PeYaSIuLg4xMTF4/fo1LC0tUaNGDZQuXRrAm7nM1LVZGOfTvn37wtzcHE+fPkWfPn2U5tVetWoVQkJCpL91fW7I7TNJIa/Xi7r8nK773dzckJCQIH0+5+b+/fu4ePEiHB0dpff023J6r+f3erAwjq8QAoMHD0ZWVhaWLVsmzSNJ9DajvIsQvZ+uXr0K4E3gLqfJ3u/fvw8AePjwIYA3S6zHxsYCACpXrqx2m5zS3yXFpLhvc3R0BPAmuPUu2itVqpRG+Tn1J6fnsmzZsjA1NUVaWhoiIyNRrVo13L17F3K5HKampjlOFuzj4wNAs8maFWU8PDxgbm6eY/9ymgj3XVL0Nafny9vbG0ZGRrlOSpzX61nTCa4VE0nXqVNHownnXV1d0bVrV2zevBnly5eHv78/mjVrhsaNG6NevXpKq+Qp9OjRA+vWrcP69eulL9DAm4m9MzMz8dlnn8HGxkaj/mqiYsWKavdFJpOhYsWKePDgAe7cuYM2bdrkWdfq1asxZMgQ6eJPnbi4OOn/hoaGGDVqFIKDg1GzZk00bNgQ/v7+UgDBzMwsfzuVD4q20tPTcyyjWEykRIkSGtX57NkzfPXVVyhTpgymT59e8E7m4e7du8jIyICtrS0qVqyo0TaK136VKlXU5ivOK0+fPsXLly9hbW2tlK/JZ0JRfG4UxvHM/npUBDKzq169Ovz9/XH06FH88ccfaNeunTZd1lhCQoK0wFJex+3tc9ulS5fw2Wef5TgxOqD8Hi0oMzMzJCcn53gcsi/Qo+lxKErqPu8Vn/WlSpVSeX9kz89+LaDtuU9xTRcVFYVGjRqp7VtCQgKA/67pCupdHbtffvkFP/zwA4yMjLB+/focr6kKqqiO3eeffw5PT08cPHgQpUuXRps2bdC4cWM0a9ZMep++K8+ePUPdunURExOD6dOnY8qUKdJKseHh4QgICMDYsWORlZWF8ePHS9sVxvnU2dkZq1evRo8ePbB9+3bs27cPFStWxKNHj/D8+XP4+voiPT0d169fV1pBVhc0+UzK7fWSV/7b1/1ffvklhg8fjlatWqFWrVpo2bIlGjVqhKZNm6oMqlC811NTU3N8ryuusXT5Xgd0e3wVP1aOHj1aaVVhorcxYEcfLMWqVnfv3sXdu3dzLav4tST7B0z2D6XsnJycdNTD/MtpNIci6CDyWJlVWzkFtBS/FuWVn1N/FAFGdduVKlUKMTEx0mpbimNTqlSpHH+lUhwbTVboyl5fTvThWAN599XAwAAODg5KK729LafnWpvnDID0C7Ctra1G5QFgzZo1qFKlClauXImDBw9KI15KlSqFiRMnYuzYsUoBs1atWsHBwQFXrlzBjRs3pC/k69evB/AmoKdLOT03gHbPT2RkJAYOHIiMjAyMGzcOvXr1Qrly5WBpaQmZTIaVK1dK+dl9//33cHV1xdKlS3HixAlpxK+1tTWGDRuGGTNmKI3kyC91F74uLi7SaIKSJUsCeLNab04UeYqyeZk4cSLi4uKwfPlynX/hUCc/r0/F+yuv9wjw5nXw9pfavEbXaVpGG0+ePFG7UqGvry+WLFkCoHCOZ/ZyitUs31a5cmUcPXoUUVFRGtWZH9k/q7U5t2VlZaFbt2549OgRPv30U3z11Vfw8fGBra0tDA0NcffuXXh7e+t0xcqSJUsiOTk5x+OQPV3T41CU1H3e5/daQJtzn+Ka7tmzZ1KwNie6Go30Lo7dxo0bMXz4cGnF6bZt2+arHk0U1bGzsLDAiRMnMG3aNGzZsgUbN26URpxXqVIFc+fOxWeffVbg/du/fz/+97//qaT369dPGj04Z84cxMTEoE2bNiorTzdr1gwLFixAjx498N1332HEiBFSIKcwzqcA0KVLF5QrVw7ff/89jh8/jps3b8LV1RX9+/fH1KlTpR+e1N2NUhCafCbl9nrJK//t18uwYcNgZWWFefPm4cKFC7hw4QLmzp0LMzMz9O7dG8HBwdIPsYr3+suXL/O8u0GX73Ug5+MrhJB+ENDk+MbHx+Orr76Ci4sLZs6cqZM+0vuLt8TSB0vx5TAkJATizXyOOT4UH9rZv1DmdEGoGIH3tryCU4pbiYqCvvYtp+dYCCHlKX55UxybZ8+e5bgfT58+VdomN9nry0lOx/pdy6uvcrkcL168yLWOvF7Pmjxn2cspLlw0YWZmhhkzZiAmJgY3b97E8uXL0a5dO7x48QITJkzA/PnzlcobGRlJwQhFkC46OhqnTp2ClZWVTi7ss9PkNaDJ87Np0yZkZGQgICAAP/74I2rUqAErKyvp/RcdHa12OwMDA4wePRp37tzBvXv3sHr1agQEBCA1NRXff/89xo0bl4+9UnXq1CmVx7lz56R8b29vAG9u6c1ptKbiNhdF2bxcunQJwJvbTZ2dnZUeP/74IwDg999/l9IKKj+vT8X7K6f3u+K8kr3+opaamqr2eCpGJgD/HaPcpkjQ9nhmH7WYUxBZkZ6VlaVRnfmR/bM6r+OW/ZidPXsWd+/ehYeHB7Zt24YmTZrA3t4ehoaGAHJ+jxZEXsdBkW5iYgIPDw+dt6/PtDn3KY55z54987ymCw8P10n/CvvY7du3D71794ZcLsdPP/2k0TQT+kLbz60yZcpg1apViIuLw+nTp/H999/Dz88PN27cwOeff44zZ84UuE9Pnz5Ve17MPh3HyZMnAQAtWrRQW0fLli0BvAkW/fPPP1J6Xq+FzMxMqR1Nz6cKvr6+2LhxI548eYL09HTcu3cP33//PZKSkqQRZDVr1tSqTn3Uu3dvRERE4PHjx9iwYQP69+8PIyMjhISEoFevXlI5xXu9YcOGeb7XdfXDUF7H9+HDh9LoO02O7/379xEXF4eEhARUqFBB5fpH8VnToUMHODs7qx2xTh8OBuzog6UYlXPt2jWNt7G1tZV+rb9165baMopbAt+m+LUqpy//eY3yK0z62recnst79+4hLS0NBgYG0pD78uXLw8DAAGlpaTl+oF6/fh0AUKFChTzbVpR58OBBjnOq5NQ/Xc9DkVd9ir7m9JpU3AaYm5z2RZGuyXMG/Heb2blz5yCXyzXaJrtKlSph0KBB2LVrF5YtWwYASvO0KChG0SkCduvXr4cQAp9//rnObxu7ffu22n0RQuD27dsANHt+FBeODRo0UJuvyVw/np6e6NOnD9avX49du3YBeDOXTX6e67fldbHr6+sLY2NjpKam4uLFiyrbZ2RkSAG+unXratX206dPVR6KHwpSUlKktILy9vaGiYkJEhISpGOXF8WxvXHjhtp8xXnFyclJ7S1jRcHT0zPPQIXiGN29e1ftc/vkyRNERkYqlc2Lr6+vNOIkryCGq6urxvujLVtbW2nEcV7HLft7V/F6r1WrltqAo6bzSGpD8dzmNFJEkV6rVi0pcPghyuvcl59ruoIqzGP3559/okuXLsjIyMCcOXM0motWX2nzuWVkZIS6deviq6++wrlz5xAQEICsrCysWrWqwP0IDAzM9Ud5QPO7CQAoTW2heC2cPXtW7fXWhQsXkJaWBhMTE6V53gpi69atAN5MQZLbnQDFjbOzM7p3746VK1fizJkzMDAwwJ49e/D48WMA/73Xb968qZNrH01o+l4vXbq0NCejJrJf32R/KPYrLi4OT58+lUYV0oeJATv6YHXs2BEA8Ntvv+U5+ii7jz/+GMCbOUXelpaWluNFhWJetYiICJXRKXK5HKGhoRr3Qdf0tW9bt25V+0VSEchp2LChFGy0tLSUAiGKW76yS0lJwcqVKwEArVu3zrPtSpUqwc3NDSkpKVizZo1KfkRERI6T1ioCRroaip9Xfa1atQLwZg43da9lxfOVm5zKKNIVbeSlYcOGcHBwwMOHD6VgWn4pFvVQN5dUo0aN4O7ujsjISJw9e1Zq64svvihQm+rExMRg9+7dKul79+7F/fv3YWFhgYYNG+ZZj+I4qntN37p1S20buVE8PykpKbnehqMr1tbW0uiCX3/9VSV/8+bNePnyJezt7dGsWTON6oyIiMjxl3HFnHb9+/eX0gqqRIkS0mtZMYIvL4rzxU8//aQ2f/HixUrliotKlSpJ8xSp+9xSpH300UcaB+wtLCzw6aefAngzX+Pbnjx5Ii1g07x583z1W1OK46Hu80AIIaVnP265vUczMjKwcOFCnfdTsUDUoUOHVBbeycrKkp5Hdbc4f6jUnfsaN24MBwcHXL58WWcj6PJSWMfuwoULaNeuHVJSUjBp0iSluVqLO20/t3K7DigMitFRR44cUZuvWBTBwMAA5cuXl9L9/f1RsmRJvHz5Elu2bFHZTvGZ2bp1a52MxE5MTMT3338PQP3COu+LKlWqSLfCKl4D3t7eqFq1KuLi4tRenxeG9u3bw8jICDdv3lR77a84vtkXPMtNjRo1ch0ZqBiRe+LECQghEBYWprN9oWKoIEvMEhV33bp1k5aev3jxolJeZmamOHbsmOjRo4dITU2V0s+fPy8MDAyETCYTP//8s7QM96tXr0SPHj2EsbGxACCaNm2qUl/p0qUFADF58mRpu5SUFDFy5Mgct9PGsWPHcq3j3r17AoDw8PDQSd/yai80NFQAEH379lWbP336dAFATJ8+XSm9b9++AoAwMjISLVq0EM+ePZPytm3bJkxMTAQAsWvXLqXtdu/eLQAIY2NjsW7dOin95cuXokuXLgKA8PT0FMnJyUrbKZaxP3bsmFL6ggULBABhZ2cnTp06JaVHRUWJatWqSc/L2/0/d+6cACC8vLzE69ev1e67NoKDgwUAERAQoLTsu4JcLhe+vr4CgPjkk09EXFyclLdx40ZhYmIijIyMBABx7949pW0VS8cbGRmJCRMmiPT0dCGEEBkZGWLSpEkCgLCyshIPHz5U2m7z5s3Cw8NDNGzYUKU/ixYtEgCEhYWF+P3335X6HBcXJ+bPny9iY2OFEEIcPnxYjB8/Xly/fl2pjqSkJNGzZ08BQDRp0kTt8zJx4kRpnwEIBwcHkZGRoVIut77mRvH6NTIyEm5ubuLKlStS3vXr16Xnbty4cUrb5fQ+27x5swAgSpYsKS5duiSl3759W1StWlWYmZmpvF+uX78uBg0aJM6ePav0PKampooJEyaobSc6Olp4eHgIDw8PER0drdU+5+XkyZNCJpMJAwMD8fvvv0vpERERwsnJSQAQc+fOVdluwYIFwsPDQ3Tv3l3jthTnh/79++uk7wrnzp2T3ruTJk1Seo+mp6eLDRs2iBMnTkhpDx8+FNbW1gKAGDNmjEhLSxNCCJGVlSXmzp0rnXMuX76s1I7iPBYaGppjX3I692T3999/S8dT19atWye9V48cOSKlHzlyRFhYWAgAYuPGjSrbjRs3Tnh4eKi89oV481owNDQUBgYGIiwsTEqPj48XrVu3FgBE2bJlpeexoHL6HLl06ZJ03vvxxx9FVlaWEEKItLQ0MXLkSAFA2NjYiMePH0vbPH78WNpm9erVUnpCQoLo2rWr9B5Vdyzy8xpX+PjjjwUA0ahRI/H8+XMhxJvXoqKfjo6OIikpSWU7xevi77//zrMNAAKAzs8Jb9evTk7nRAV11xL5OfctW7ZM+izYtm2byufl1atXxcSJE8XJkyeV0vXp2N26dUs4ODgIAGLYsGFa9yc/ivrYzZ8/XyxYsEA8efJEqe779++LqlWrCgBi2rRpSnkFOWa52bBhg/R8TJ8+XbomUuyr4nOuXbt2Ktv+73//EwCEs7OziIiIkNLXrVsnfW84ffq0ynbdu3cXHh4eYsGCBSp5GzduFNeuXVNKu379uqhTp44AIFq0aFGAvVWlyWeS4trn7etJBW1fT4mJiaJ79+7i2LFj0nlaiDffTbJfT2Z/H+3du1fIZDJhbm4uQkJCVK79IiMjxaxZs8TWrVuV0vN7PSiEEAMHDhQARKVKlURUVJQQ4s319w8//CAACDMzM3H//n2V7Ro2bCg8PDzE5s2bNW5L8RxnvxahDxcDdvRBS0pKki62AAh3d3dRt25d8dFHH4kSJUpI6SkpKUrbzZ49W8orXbq08PPzE1ZWVsLU1FR89913OQax1q5dK21XqlQp4efnJ6ytrYWlpaX48ccfiyxgl9++FXbAbtKkScLGxkaYmZmJWrVqCU9PT6mPOV3Ifv3111IZNzc34efnJ33xLFmypDh79qzKNjldoGRmZopPP/1Uqq9SpUqiRo0awsjISLi7u4sRI0ao7X9WVpbw9vYWAIS9vb2oX7++aNq0qRg9erTaPufl7t27UpDSw8NDNG7cWDRt2lQpEHDt2jVhZ2cnAIgSJUoIPz8/6QN/2LBhOV5gKdLnzJkjZDKZsLe3F7Vr15a+MBgYGIj169er9ElxbNW9luRyuRg6dKj0vDk4OIjatWsLT09PYWhoqNSP7du3q7zuqlevLszNzaUv1BcuXFD7vEREREjbAhBDhw5VWy63vuZGsV1AQIDw9fUVMplMVK1aVXz00UdCJpMJAKJ27dri1atXStvl9D7LyMgQ9erVEwCEoaGhqFy5sqhataqQyWTCxcVFzJo1S+X9cunSJWn/bG1tRc2aNYWvr6+wsbERAISJiYnYt2+f2vZzu6AuCEU/FYGXatWqCQMDAwFAtG3bVmRmZqpso3iva3N+K6yAnRBvzneKoJ25ubmoWbOmqFy5shSQeTvItnPnTuk9WLJkSVG7dm3h6OgovUeWL1+u0oauAnaK82xOX4AKSvElBICoXLmyqFy5svT3kCFD1G6j2Leczu0///yz9B5xd3cXfn5+0nvawcFBKWBdUDl9jgjxJoCj6IeTk5OoXbu2sLW1FQCEqamp2LNnj8o248ePV7omqFWrlihRooQwNjYWP//8c47nkvy8xhUePnwonYvNzc1FrVq1RKlSpaQvgTm9PhT9VJc/YsQIYW9vLz0UZUuWLCmltW/fXuu+5kTXQZ/8nPuEUL4GsLOzE7Vr1xY1a9aUPh8BiP379ytto0/HrlWrVgKAkMlkokGDBqJhw4ZqH7/++qvWfc1JUR+70aNHS+U9PT1FnTp1RKVKlaTrhapVq4qEhASldgtyzHIjl8tFYGCg1B8rKytRo0YN4erqKqV5eXmpDXxnZGSINm3aSJ8L1apVE2XLlpW2mzNnjto2FZ8D6s5hHTp0kK6PatWqJcqXLy/V17hxY5GYmKjT/S+KgF18fLy0jYWFhahevbrw8/OTrkNlMpkICQlRqeunn36SXiNWVlaiVq1aws/PTwqqAhA///yz0jb5vR4U4s2P/4ofx01MTISvr6/0ujA0NBS//fab2u0Uz1du1wI5bcOAHQkhBG+JpQ+apaUl/vjjD6xbtw6tW7dGcnIyLl68iOfPn6NatWr46quvcPbsWZUl6CdNmoQtW7agbt26iI+PR2RkJBo3boyTJ0/muMQ4APTq1QubNm1CrVq1kJSUhH///RctWrTAmTNnUKtWrcLe3VzpY98qVKiAs2fPol27dnjw4AEeP36M6tWrY8WKFTnenjZnzhzs3r0bH3/8MV69eoUrV67AwcEBQ4YMweXLl1G7dm2N2zc0NMSOHTswZ84cVKhQAf/++y+ePn2Kvn374uzZs7C3t1e7nYGBAfbu3YsuXbrA0NAQZ8+exfHjxxEREZGfpwHlypXD7t270bRpU8THx+PkyZM4fvy40vxiPj4+OH/+PHr06AFzc3Ncu3YN1tbWWLJkSY7PVXYBAQHYv38/fHx8cOvWLaSmpqJ58+Y4duwYAgICtOqvTCbDsmXLsHfvXnz22WeQyWS4fPkyMjIy0LRpUyxbtgylS5cG8OY2psWLF6Ndu3awtLTEjRs3EBUVhfLly2PixIm4detWjpMpV69eXZrLBND96rAKpqamOH78OEaPHo2XL1/i9u3bcHd3x9dff41jx45pvMKnkZERDhw4gJEjR8LJyQl3795FQkIC+vfvjwsXLqid08vb2xshISHo2rUrSpUqhTt37uCff/6Bq6srhgwZghs3buCTTz7R9S7nasqUKdi9ezeaN2+OFy9e4O7du/joo4+wcOFC7Ny5s1jMs9WrVy9EREQgKCgIDg4OuHbtGp49ewYfHx/MmDEDbdq0USrfvn17XLhwAT179oSZmZl0K2/Hjh1x8uRJDBo0qIj2pOBWrFiB1atXo169eoiOjkZ0dDTq1auHNWvW4Oeff85XnUOGDMHx48fRrl07JCcn48qVK3B0dMTw4cMRERGhszmc8jJ06FCcOHECn3/+OeRyOSIiImBubo5evXrh4sWLalfc/OGHH7Bw4UJUqlQJT548wf3799GyZUucOHFC5XWhK6VLl8alS5fw5ZdfwsnJCVevXoVMJkNAQAAuXLig8S3m2SUlJeHFixfSQyE+Pl5K0+d5kfJ77pszZw5OnTqFHj16wMLCApcvX0ZUVBTKlCmDfv36Ye/evTkuKJAfuj52aWlpAAAhBP766y+1iyS8vVCCvtH22A0ZMgQzZsxAkyZNkJGRgYiICMTHx6N27dpYsmQJzp49K90WWdhkMhlCQ0OxefNmfPLJJzAzM8O1a9eQmJgIX19fzJgxA5cuXUKZMmVUtjUyMsKePXuwcOFCfPTRR7h79y5evHiB5s2bY8+ePfm6tblPnz5o166d1I+4uDg0bdoUK1euRHh4uN7Mm1oQVlZWWLt2LXr37g03NzdERUXh+vXrsLOzQ69evXDp0iUMGDBAZTvF58mAAQNQqlQpXL9+Hf/88w8cHBzwxRdfYPPmzejTp49O+3nq1CnMmDEDXl5euHHjBlJTU9GuXTucOHGiWC0KQ8WLTAgdTApDRETFkqenJ+7fv4979+7B09OzqLtDRERERERE4KITREREREREREREeoUBOyIiIiIiIiIiIj1iVNQdICL1Vq1ahVWrVmlc/uTJk4XYG9KV3OY4fFu/fv3Qr1+/QuwNERERERER6SMG7Ij01IMHD3Dq1Kmi7gbpmDbHtGXLloXYEyIiIiIiItJXXHSCiIiIiIiIiIhIj+jdHHYJCQkYNWoU6tevD2dnZ5iamsLV1RXNmzfH1q1bkVd88d69e7C0tIRMJsOQIUO0bv/cuXP49NNPUbJkSVhYWKBOnTr4/fff87s7REREREREREREWtG7W2KfP3+OVatWoV69evj8889hZ2eH2NhY7N69G126dMHAgQOxYsUKtdsKIRAUFJTvtsPDw9G6dWuYmJggICAANjY22LZtG3r27ImoqChMnjxZq/rkcjkePXoEKysryGSyfPeLiIiIiIiIiIiKNyEEkpKSULp0aRgY5DGGTuiZzMxMkZGRoZL+8uVLUaVKFQFAXLt2Te22ixYtEkZGRmL+/PkCgBg8eLDG7WZkZIhy5coJU1NTcfHiRaV2fXx8hJGRkbhz545W+xIdHS0A8MEHH3zwwQcffPDBBx988MEHH3zwwYcAIKKjo/OMKendCDtDQ0O16VZWVmjdujVu3LiBu3fvwsfHRyn/7t27mDRpEiZOnAhfX1+t2z169CgiIyMRFBSktL2VlRWmTp2KgIAAhIaGYvbs2RrXaWVlBQCIjo6GtbW11n0iIiIiIiIiIqL3w8uXL+Hm5ibFi3KjdwG7nKSmpuLo0aOQyWSoUqWKUp5cLkdQUBA8PDwwbdo0/P3331rXHx4eDgBo1aqVSp4i7fjx41rVqbgN1tramgE7IiIiIiIiIiLSaNo0vQ3YJSQkYOHChZDL5YiNjcW+ffsQHR2N6dOnw9vbW6nswoUL8ddff+HkyZMwNTXNV3v//PMPAKjUDQAlS5aEg4ODVIaIiIiIiIiIiKiw6HXA7ttvv5X+NjY2RnBwMMaNG6dU7s6dO/jmm28wevRo1K9fP9/tJSYmAgBsbGzU5ltbWyMmJibXOtLS0pCWlib9/fLly3z3h4iIiIiIiIiIPkx5LElRdDw9PSGEQGZmJu7du4eZM2diypQp6Ny5MzIzMwG8uRU2MDAQpUuXxqxZs4q4x8CcOXNgY2MjPdzc3Iq6S0REREREREREVMzo7Qg7BUNDQ3h6euLrr7+GoaEhJk6ciJCQEAwdOhSLFy/G6dOncfToUZibmxeoHcXIOsVIu7e9fPkyx9F3CpMmTcLYsWOVtmHQjoiIiIiIiOjDkJWVhYyMjKLuBhURY2PjHBdT1ZbeB+yya9WqFSZOnIjw8HAMHToUEREREELA399fbfnly5dj+fLl6NChA3bs2JFr3Yq56/755x/UqlVLKS8+Ph7Pnz9HgwYNcq3D1NQ033PoEREREREREVHxJITAkydPkJCQUNRdoSJma2sLZ2dnjRaWyE2xCtg9evQIAGBk9KbbTZs2lf6f3ePHj7Fv3z5UqlQJDRs2hK+vb551N23aFHPmzMHBgwcREBCglHfw4EGpDBERERERERFRdopgnaOjI8zNzQscrKHiRwiB5ORkxMbGAgBcXFwKVJ9MCCF00TFdiYiIgJeXl8rtp3FxcWjRogUiIiKwdu1a9OrVK8c6wsPD4e/vj8GDB+OXX35RysvIyEBkZCSMjY1Rrlw5KT0zMxMVK1bEw4cPcfr0adSoUQMAkJSUhPr16+P27du4fv06KlSooPG+KG6jTUxMhLW1tcbbEREREREREVHxkJWVhTt37sDR0RH29vZF3R0qYi9evEBsbCwqVKigcnusNnEivRthFxYWhpUrV8Lf3x8eHh6wsLDA/fv3sXfvXrx69QqdO3dGjx498l3/w4cPUblyZXh4eCAqKkpKNzIywsqVK9G6dWs0btwYX3zxBaytrbFt2zbcu3cPs2bN0ipYR0RERERERETvP8WcdQWdW5/eD4rXQUZGRoHms9O7gF2XLl2QmJiI06dP488//0RycjLs7OzQqFEj9OnTBwEBAYU2tNTf3x8nT57E9OnTsWnTJqSnp8PHxwffffcdevbsWShtEhEREREREVHxx9tgCdDd60Dvbol9n/CWWCIiIiIiIqL3W2pqKu7duwcvLy+YmZkVdXeoiOX2etAmTmRQmJ2k94sQAs+fPy/qbhARERERERFRIQsPD4dMJnuvVr4NDAzE559/XtTd0AgDdqSx5cuXo2LFili/fj04MJOIiIiIiIiI9FFUVBRkMhkiIiKU0hctWoSwsLAi6ZO2GLAjjdy7dw/jx49HXFwcevToga5du0pLFRMRERERERERFVR6enqh1m9jYwNbW9tCbUNXGLAjjVhZWeGzzz6T/t66dSt8fHywZcuWIuwVEREREREREeVXWloaRo0aBUdHR5iZmaFRo0Y4d+6cUplTp06hevXqMDMzQ926dXH16lUp7/79+2jXrh1KliwJCwsL+Pj4YN++fVL+jRs38Omnn8LS0hJOTk7o3bu30lRbzZo1w4gRIzB27Fg4ODjg448/xhdffIGAgAClPmRkZMDBwQGhoaEAgD/++AONGjWCra0t7O3t8dlnnyEyMlIq7+XlBQDw9fWFTCZDs2bNAKjeEpvX/ituCz5y5Aj8/Pxgbm6OBg0a4Pbt2/l8xjXHgB1pxMHBARs2bMCmTZvg4OAAAHj+/Dm6du2KgIAAzm1HREREREREVMxMnDgRW7duxerVq3Hx4kWUL18erVu3RlxcnFRmwoQJ+PHHH3Hu3Dk4Ojqiffv2yMjIAAAMHz4caWlp+PPPP3H16lXMnTsXlpaWAIDHjx+jadOmqFGjBs6fP48//vgDT58+Rbdu3ZT6sHr1ahgZGeHUqVNYvnw5evbsiV27duHVq1dSmQMHDuD169fo3LkzAOD169cYO3Yszp07hyNHjsDAwAAdO3aEXC4HAJw9exYAcPjwYTx+/Bjbtm3L9/4DwJQpUzBv3jycP38eRkZG6NevX0Gedo1wldhC9L6uEhsbG4uhQ4cqveAdHR2xfPnyYjN5IxEREREREZEu5LQqqJ+fH548efJO++Ls7Izz589rVPb169coWbIkwsLC0KNHDwBvRrJ5enpizJgxqF27Nvz9/bFhwwZ0794dABAXF4cyZcogLCwM3bp1Q7Vq1dC5c2dMnz5dpf5p06bhzJkzOHDggJQWExMDNzc33L59GxUqVECzZs2QmJiIS5cuSWUyMjJQunRpzJ8/H7179wYA9OjRA5mZmdi0aZPafXn27BkcHR1x9epVVK1aFVFRUfDy8sKlS5dQo0YNqVxgYCASEhKwY8eOPPd/woQJCA8Ph7+/Pw4fPowWLVoAAPbt24e2bdsiJSVF7arAulol1ijXXCI1HB0dsWXLFmzcuBHDhw9HXFwcYmNj0bFjR/Ts2RNffvklDA0Nc9ze09Oz2NwzTkRERERERJQfT548wcOHD4u6GzmKjIxERkYGGjZsKKUZGxujTp06uHnzJmrXrg0AqF+/vpRvZ2eHihUr4ubNmwCAUaNGYejQoTh48CBatmyJzp07o1q1agCACxcu4NixY9KIu7fbrlChAoA3gc3sjI2N0bVrV6xbtw69e/fG69evsXPnTvz+++9K20+dOhWnT5/G8+fPpZF1Dx48QNWqVXWy/9kp9gkAXFxcALwZzOTu7q5RW/nBgB3li0wmQ0BAAJo1a4bBgwdj165dAIB169Zh3bp1uW5rYmKCGTNmYMKECTAy4kuQiIiIiIiI3j/Ozs563abihkuZTKaS/nba2xT5AwYMQOvWrbF3714cPHgQc+bMwbx58zBy5EjI5XK0a9cOc+fOVdleEfQCAAsLC5X8nj17omnTpoiNjcWhQ4dgZmaGTz75RMpv164d3NzcEBISgtKlS0Mul6Nq1apaLVqhzf4bGxur7LsiSFhYGC2hAnF2dsaOHTuwbt06jBw5EgkJCXluk56ejsmTJ2P79u1YvXo1KleuXPgdJSIiIiIiInqHNL01taiUL18eJiYmOHnypNItoefPn8eYMWOkcqdPn5ZGksXHx+POnTuoVKmSlO/m5oYhQ4ZgyJAhmDRpEkJCQjBy5EjUrFkTW7duhaenp9aDdRo0aAA3Nzds3LgR+/fvR9euXWFiYgIAePHiBW7evInly5ejcePGAICTJ08qba8om5WVVeD9LyoM2FGByWQy9OrVC82bN8fy5csRGxubY9mEhARs2rQJcrkc586dg6+vL7777juMHTs219toiYiIiIiIiEh3LCwsMHToUEyYMAF2dnZwd3fHDz/8gOTkZPTv3x+XL18GAMycORP29vZwcnLClClT4ODgIM1fP2bMGHzyySeoUKEC4uPjcfToUWlQzvDhwxESEoIvvvgCEyZMgIODA+7evYsNGzYgJCQk1xiATCZDjx498Msvv+DOnTs4duyYlFeyZEnY29tjxYoVcHFxwYMHD/D1118rbe/o6IgSJUrgjz/+QJkyZWBmZgYbGxut9r+oMWBHOlO6dGl8++23eZYbNWoUAgMDcefOHaSlpWHixInYvn07QkNDUbFixXfQUyIiIiIiIiL6/vvvIZfL0bt3byQlJcHPzw8HDhxAyZIllcqMHj0a//zzD6pXr45du3YpjWAbPnw4YmJiYG1tjTZt2mDBggUA3sQITp06ha+++gqtW7dGWloaPDw80KZNGxgYGOTZt549e2L27Nnw8PBQmmfOwMAAGzZswKhRo1C1alVUrFgRixcvRrNmzaQyRkZGWLx4MWbOnIlp06ahcePGCA8Pz9f+FxWuEluI3tdVYnUhJSUF33zzDRYsWCDdN25mZobZs2dj1KhRHG1HRERERERExUJuq4LSh0dXq8QyYFeIGLDL28mTJxEUFIS7d+9KaX5+frmOtDMzM0OPHj3QvHlzrdt7/fo1lixZgmvXruVazt7eHsOHD5dWrSEiIiIiIiJShwE7yo4Bu2KAATvNJCcnY/LkyVi0aJFW2w0ePBjBwcGwsrLSqPyJEycQFBSEyMhIjcpzxB8RERERERHlhQE7yk5XAbu8bxomKmTm5uZYuHAhwsPDUb58eY23W758OT766CMcOXIk13LJyckYO3YsmjZtqnGwDnjzJhs7diyaNWumNAKQiIiIiIiIiKgwcYRdIeIIO+3J5XLcv38fcrk8xzIHDx7EhAkT8Pr1aylt2LBhmDt3LiwtLZXK/v3339ICFwoNGjTAwoULYWdnl2Mfli5dqjTir0SJEpg7dy6GDx+u0eSYRERERERE9GHgCDvKjrfEFgMM2BWee/fuoV+/fkqrvHh5eSE0NBRNmzZFamoqpk2bhnnz5knBP1NTU8yePRujR4/W6BbX48ePo1+/fvj333+ltKZNm2LVqlUoW7aszveJiIiIiIiIih8G7Cg73hJLHzQvLy8cOXIES5Ysgbm5OYA3QbxmzZph0KBB8PX1RXBwsBSsq1u3LiIiIjB27FiN56Nr2rQpLl++jOHDh0tpx48fR7Vq1fDzzz/nOgqQiIiIiIiIiCi/GLCjYsvAwAAjRozA5cuX0ahRIyk9JCQEt27dAgCYmJhg7ty5OHnyJCpVqqR1G5aWlvjpp59w5MgReHh4AHiz0uywYcNQtWpVBAcH48mTJ7rZISIiIiIiIiIiMGBH74Hy5cvj+PHjWLBggdJwUz8/P1y8eBETJ06EkZFRgdpo3rw5rl69isGDB0tpN2/exMSJE1GmTBm0a9cO27ZtQ3p6eoHaISIiIiIiIiJiwI7eCwYGBhgzZgwuX76MoUOHYvHixfj777/h4+OjszasrKzwyy+/4NChQ0oj+rKysrBnzx507twZpUuXxujRoxEREaGzdomIiIiIiIjow8KAHb1XKlSogGXLlmHkyJEFHlWXk5YtW+LEiRO4c+cOJk+ejDJlykh5L168wOLFi+Hr6wtfX18sWrQIz58/L5R+EBERERERERUHzZo1w5gxYzQuHxYWBltb20LrT3HAgB1RPnl7e+N///sfoqKicODAAQQEBMDU1FTKj4iIwJgxY1C6dGl07twZu3fvRmZmZhH2mIiIiIiIiIiKAwbsiArI0NAQrVq1wvr16/H48WP8/PPPqFOnjpSfkZGBbdu2oX379ihTpgwmTJiAGzduFGGPiYiIiIiIiEifMWBHpEMlS5bEkCFDcObMGVy7dg3jx4+Hk5OTlP/06VP8+OOP8PHxQd26dfHzzz8jPj6+CHtMREREREREH6pmzZph5MiRGDNmDEqWLAknJyesWLECr1+/RlBQEKysrFCuXDns379f2ub48eOoU6cOTE1N4eLigq+//lrpbrLXr1+jT58+sLS0hIuLC+bNm6fSbnp6OiZOnAhXV1dYWFigbt26CA8Pfxe7XGwwYEdUSHx8fBAcHIyYmBjs3r0bnTp1grGxsZR/9uxZDBs2DC4uLvjiiy9w8OBBZGVlFWGPiYiIiIiI6EOzevVqODg44OzZsxg5ciSGDh2Krl27okGDBrh48SJat26N3r17Izk5GQ8fPsSnn36K2rVr4/Lly/j555/x66+/YtasWVJ9EyZMwLFjx7B9+3YcPHgQ4eHhuHDhglKbQUFBOHXqFDZs2IArV66ga9euaNOmDf755593vft6SyaEEEXdiffVy5cvYWNjg8TERFhbWxd1d0gPPH/+HL///jtCQ0PVriRbpkwZ9OnTB4GBgfD29n73HSQiIiIiIiKtpKam4t69e/Dy8oKZmdl/GX5+wJMn77Yzzs7A+fMaF2/WrBmysrJw4sQJAEBWVhZsbGzQqVMnrFmzBgDw5MkTuLi44O+//8bu3buxdetW3Lx5EzKZDACwbNkyfPXVV0hMTERycjLs7e2xZs0adO/eHQAQFxeHMmXKYNCgQVi4cCEiIyPh7e2NmJgYlC5dWupLy5YtUadOHcyePRthYWEYM2YMEhISdPTEvDs5vh6gXZyocJbRJCK1HBwcMGrUKIwaNQoREREIDQ3FunXr8OLFCwBATEwMZs+ejdmzZ6Nhw4YICgpCt27dYGVlVcQ9JyIiIiIiIq08eQI8fFjUvchTtWrVpP8bGhrC3t4eH330kZSmmOYpNjYWN2/eRP369aVgHQA0bNgQr169QkxMDOLj45Geno769etL+XZ2dqhYsaL098WLFyGEQIUKFZT6kZaWBnt7e53vX3HFgB1REalRowYWLVqE4OBg7NmzB6Ghodi/f790W+ypU6dw6tQpjBo1Cl26dEFQUBCaNGkCAwPeyU5ERERERKT3nJ2LRZvZp24CAJlMppSmCM7J5XIIIZSCdQCguHFTJpNBk5s45XI5DA0NceHCBRgaGirlWVpaat3/9xUDdkRFzMTEBJ06dUKnTp3w5MkT/PbbbwgNDZVWkk1OTsaaNWuwZs0aeHl5oW/fvujbty88PT2LtuNERERERESUMy1uTS0uqlSpgq1btyoF7v766y9YWVnB1dUVJUuWhLGxMU6fPg13d3cAQHx8PO7cuYOmTZsCAHx9fZGVlYXY2Fg0bty4yPZF33GoDpEecXZ2xvjx43Ht2jWcOXMGQ4cOha2trZR/7949zJgxA15eXmjevDnWrl2L5OTkouswERERERERfTCGDRuG6OhojBw5Erdu3cLOnTsxffp0jB07FgYGBrC0tET//v0xYcIEHDlyBNeuXUNgYKDSnWIVKlRAz5490adPH2zbtg337t3DuXPnMHfuXOzbt68I906/MGBHpIdkMhnq1KmDZcuW4fHjx1i/fj1atWqlNPT42LFj6NOnD5ydnTFw4ED89ddfGg0/JiIiIiIiIsoPV1dX7Nu3D2fPnkX16tUxZMgQ9O/fH998841UJjg4GE2aNEH79u3RsmVLNGrUCLVq1VKqJzQ0FH369MG4ceNQsWJFtG/fHmfOnIGbm9u73iW9xVViCxFXiSVdi46Oxtq1axEaGoq7d++q5FeoUAGBgYHo06cPXF1di6CHREREREREH5bcVgWlD4+uVonlCDuiYsTNzQ2TJ0/GnTt3cOLECfTr109pUs47d+5g8uTJcHd3R5s2bbBx40akpqYWYY+JiIiIiIiISFsM2BEVQzKZDI0aNcKvv/6KJ0+eYPXq1WjWrJmUL5fLceDAAQQEBKB06dIYPnw4zp07x1tmiYiIiIiIiIoBBuyIijkLCwv06dMHx44dQ2RkJKZPnw4PDw8pPz4+HsuWLUOdOnXw0UcfYd68eXj69GkR9piIiIiIiIiIcsOAHdF7pGzZspgxYwb+/fdfHDlyBL169UKJEiWk/OvXr2P8+PFwdXVFhw4dsH37dqSnpxdhj4mIiIiIiIjobQzYEb2HDAwM0Lx5c6xduxZPnjxBSEgIGjRoIOVnZWVh165d6NSpE1xdXfHll1/i8uXLRdhjIiIiIiKi4o1TEBGgu9cBA3ZE7zlra2sMGDAAp06dwq1btzBp0iSlFWSfP3+OhQsXokaNGqhZsyaWLFmCFy9eFGGPiYiIiIiIig9jY2MAQHJychH3hPSB4nWgeF3kl0wwBFxotFmul+hdysrKwqFDhxAaGoodO3ao3BZrYmKC9u3bIzAwEK1bt4aRkVER9ZSIiIiIiEj/PX78GAkJCXB0dIS5uTlkMllRd4neMSEEkpOTERsbC1tbW7i4uKiU0SZOxIBdIWLAjoqDuLg4bNiwAaGhoTh//rxKvouLC3r37o3AwEBUrly5CHpIRERERESk34QQePLkCRISEoq6K1TEbG1t4ezsrDZoW6wDdgkJCZg2bRrOnTuHe/fuIT4+Hg4ODqhYsSKGDx+OTp06Ke10SEgIdu3ahWvXriE2NhZGRkbw9PREhw4dMGbMGNjZ2Wnctlwux7Jly7Bq1SrcunULRkZG8PX1xbhx49C+fXut94UBOypurl27hrCwMKxduxaxsbEq+XXr1kVQUBACAgJgY2NTBD0kIiIiIiLSX1lZWcjIyCjqblARMTY2hqGhYY75xTpgd/fuXdSoUQP16tVD+fLlYWdnh9jYWOzevRuxsbEYOHAgVqxYIZVv0qQJ4uPj4evrCxcXF6SlpeH06dM4c+YM3N3dcebMGTg7O+fZrhACXbt2xdatW1GuXDl88sknSEtLw86dOxEbG4slS5ZgxIgRWu0LA3ZUXGVkZGD//v0IDQ3Fnj17kJmZqZRvZmaGTp06ITAwEM2bN8/1hERERERERERExTxgl5WVBSGEypxZSUlJqFevHm7cuIFr167Bx8cHAJCamgozMzOVeqZOnYpZs2Zh/PjxCA4OzrPdLVu2oGvXrmjYsCEOHTqEEiVKAHgzIb+fnx+ePHmCW7duwdPTU+N9YcCO3gfPnj3DunXrEBoaiitXrqjku7m5oW/fvujbty/Kly9fBD0kIiIiIiIi0n/axIn0bpVYQ0NDtRPcW1lZoXXr1gDejMJTUBesA4CuXbuqlM3Njh07AACTJ0+WgnUA4ODggC+//BJpaWkIDQ3VqC6i90mpUqUwZswYRERE4OLFixg5cqTSrebR0dGYNWsWvL290aRJE4SGhuLVq1dF2GMiIiIiIiKi4k3vAnY5SU1NxdGjRyGTyVClSpU8y+/duxcAULVqVY3qf/r0KQDAy8tLJU+RdvToUU27S/Tekclk8PX1xeLFi/Ho0SNs3rwZbdu2hYHBf6eREydOoF+/fnB2dkZQUBCOHz8OPRvES0RERERERKT3VIey6YmEhAQsXLgQcrkcsbGx2LdvH6KjozF9+nR4e3urlA8LC0NUVBSSkpJw8eJFhIeHw9fXF2PHjtWovVKlSgEA7t27p7IS5r179wAAd+7cybWOtLQ0pKWlSX+/fPlSo7aJihtTU1N06dIFXbp0wePHj7F27VqEhobi1q1bAIDXr18jLCwMYWFhKFu2LAIDA9GnTx94eHgUcc+JiIiIiIiI9J/ezWGnEBUVpTTazdjYGLNnz8a4cePULo3brFkzHD9+XPq7VatWWLt2LRwdHTVqb+3atejTpw8aN26MgwcPSrfavnjxAn5+foiKioKJiYlSQO5tM2bMwLfffquSzjns6EMghMDZs2cRGhqK9evXqwSsZTIZmjdvjqCgIHTs2BHm5uZF1FMiIiIiIiKid69YLzrxtqysLERHR2PDhg2YPn062rZti02bNqmd5w54s0jEmTNnMHHiRCQmJmLfvn2oVq1anu1kZmaiVatWOHbsGMqXL482bdogIyMDO3bsgJOTE65cuYISJUogOTk5xzrUjbBzc3NjwI4+OCkpKdi+fTvCwsJw+PBhldtira2tERAQgMDAQNSrV09tEJ6IiIiIiIjoffJeBeyyCw4OxsSJE7Fs2TIMHTo017LR0dHw9vZG9erVcebMGY3qT0tLw/fff4/ff/8dUVFRsLGxQceOHTF+/HhUqFAB7u7uuH//vsb95SqxRMCDBw+wZs0ahIWFITIyUiW/UqVKCAwMRO/evVG6dOki6CERERERERFR4XtvA3aXL19GjRo10K1bN2zcuDHP8r6+vrh8+TJevXpVoNvvwsPD4e/vj06dOmHr1q0ab8eAHdF/hBA4efIkQkNDsWnTJrx+/Vop38DAAK1bt0ZQUBDat28PU1PTIuopERERERERke5pEycqNqvEAsCjR48AIMfbYd/2+PFjyGQyGBoaFqjddevWAQACAgIKVA/Rh0wmk6Fx48ZYtWoVnjx5gtDQUDRt2lTKl8vl2L9/P7p16wYXFxeMGDECFy5c4CqzRERERERE9MHRu4BdREQEEhMTVdLj4uIwefJkAMAnn3wC4M2CENevX1cpK4TAjBkz8PTpU/j7+yuN1MnIyMCtW7fU3pqnblXXLVu2YNWqVahduzY6deqU7/0iov9YWloiMDAQ4eHhuHv3LqZOnQp3d3cpPz4+HkuXLoWfnx+qV6+OBQsWIDY2tgh7TERERERERPTu6N0tsWPGjMHKlSvh7+8PDw8PWFhY4P79+9i7dy9evXqFzp07Y9OmTTAwMEBERAR8fX1Rp04dVKlSBc7Oznj+/DlOnDiB27dvw9nZGeHh4ahYsaJUv2L1WQ8PD0RFRSm1XblyZbi5uaFy5cowMzPD2bNnER4ejrJly+Lo0aPw8PDQal94SyyR5uRyOY4dO4bQ0FBs3boVqampSvlGRkZo27YtgoKC8Omnn8LY2LiIekpERERERESkvWI9h93Jkyfx66+/4vTp03j06BGSk5NhZ2eHmjVrok+fPggICJBWlIyPj0dwcDDCw8MRGRmJuLg4mJmZwdvbG23btsWYMWNgb2+vVH9uAbsZM2Zg27ZtiIqKQkZGBry8vNC5c2dMmDAhXwE3BuyI8icxMREbN25EWFgY/v77b5X8UqVKoVevXggKCsJHH31UBD0kIiIiIiIi0k6xDti9TxiwIyq4W7duISwsDGvWrMHjx49V8mvVqoWgoCB88cUXsLOzK4IeEhEREREREeWNATs9wYAdke5kZmbi0KFDCA0Nxc6dO5Genq6Ub2Jigg4dOiAoKAitWrUq8GIzRERERERERLrEgJ2eYMCOqHC8ePEC69evR1hYGC5cuKCSX7p0afTu3RtBQUFKc1gSERERERERFRUG7PQEA3ZEhe/KlSsICwvDb7/9hmfPnqnk169fH0FBQejWrRtsbGyKoIdEREREREREDNjpDQbsiN6djIwM7Nu3D6Ghodi7dy8yMzOV8kuUKIFOnTohKCgI/v7+MDAwKKKeEhERFV+RkZHYtWsX6tSpg/r16/PzlIiISAsM2OkJBuyIikZsbCzWrVuH0NBQXL16VSXfw8MDffv2Rd++fVG2bNki6CEREVHxIpfLsXjxYkyaNAmpqakAAFdXV3Tt2hXdunVD3bp1GbwjIiLKAwN2eoIBO6KiJYTAxYsXERoait9//x3x8fEqZZo2bYqgoCB07twZlpaWRdBLIiIi/Xb37l3069cPJ06cyLGMm5ubFLyrU6cOZDLZO+whERFR8cCAnZ5gwI5If6SmpmL37t0IDQ3FgQMHIJfLlfItLS3RtWtXBAUFoVGjRvyikY0QAuvXr8fGjRuRlpaWa1lTU1NYWFhID3Nzc63+trCwgJGR0TvaMyIiyo1cLsfSpUvx9ddfIzk5WUrv168fnj59ioMHDyIjI0NlOw8PDwwePBjjx4+HsbHxu+wykc7J5XKsWbMGf/75J8aOHYuqVatqXUdCQgKmTp2KUqVKYfLkybzWIfqAMWCnJxiwI9JPDx8+xNq1axEWFobbt2+r5JcrVw6BgYHo27cv3NzciqCH+uPRo0cYPHgw9uzZ887aNDY2LlDQL7e/zc3NYWho+M72hYiouPr333/Rr18/HD9+XEorW7YsVq1ahaZNmwIA4uPjsXPnTmzatAmHDh1SmT+2Ro0aWL16NapVq/ZO+06kK/fv30f//v1x5MgRAICTkxMuX74MJycnjeuQy+Vo37499u7dCwCYNm0avv3220LpLxHpPwbs9AQDdkT6TQiB06dPIzQ0FBs2bEBSUpJSvkwmQ8uWLREUFITPP/8cJUqUKKKevntCCPz+++8YOXKk2luJi7OCjgLM7e8SJUpwDiciKtbkcjmWL1+OCRMm4PXr11L68OHD8f333+c4fURcXBx27NiBzZs349ChQ8jKygLw5keY6dOn46uvvuKoIio2hBD49ddfMXbsWJXrw5YtW+KPP/7Q+AfAefPmYfz48dLfMpkMhw4dQosWLXTaZyIqHhiw0xMM2BEVH8nJydi+fTtCQ0Nx9OhRvH1qtLGxQUBAAIKCgt77uXmePn2KIUOGYMeOHVKas7MzfvnlFzRr1izH7YQQSE1NxevXr5GcnIzXr19Lj4L+re6WK31lbm6u0yBg9r/NzMze69ceERWt169fo2vXrti/f7+U5uHhgVWrVqF58+Ya13PhwgX07dsX169fl9Jq1aqF1atXw8fHR6d9JtK1mJgYDBgwAAcOHJDSypQpg8zMTDx58gQAMGvWLEyZMiXPuk6fPo3GjRurjD7Nz0g9Ino/MGCnJxiwIyqe7t+/jzVr1iAsLAz//vuvSn7lypURGBiI3r17w8XFpQh6WDiEENi4cSNGjBiBFy9eSOk9evTA4sWLYW9vX2R9y8jIUAri6TogqBgJou8MDAwKNSBoYmLCgCDRByo5ORmfffYZjh07JqUNHjwYwcHBsLKy0rq+tLQ0fPvtt5g7d640b6yJiQlmzpyJcePGcbQd6R0hBFavXo0xY8YgMTFRSu/Xrx/mz5+PS5cuoUWLFpDL5TAwMMCxY8fQpEmTHOuLj4+Hr68v7t+/DwCYOHEiLl++LAUCtR2pR0TvBwbs9AQDdkTFm1wux4kTJxAaGorNmzcrTbgNAIaGhmjTpg2CgoLQrl07mJiYFFk///33X6Smpua7jvT0dMyePRtbt26V0kqVKoVffvkFnTp10kU39ZYQAhkZGbkG9AoaFCwuH7WGhoY6CQAqHpUrVy6y94UmkpOT1QbltWFiYgJvb28GOqlYS05ORrt27XD06FEAb0aVb9y4Ea1bty5w3WfPnkVgYCBu3rwppdWpUwdLliyBl5cXbG1tuTAFFblHjx5h0KBB0jxzAFC6dGmEhITg008/ldK+/fZbzJgxQ8qPiIhAqVKlVOoTQqBTp07S3QoNGzZEeHg44uLiUKNGDTx+/BiA5iP1iOj9wYCdnmDAjuj9kZSUhC1btiA0NBQnTpxQya9QoQLCwsJQv379Qu9LYmIizpw5g7/++gt///03zpw5o/RLsC507doVS5cuVXsRStpR3Cqs61GBir/fDiTrEycnJ/zyyy/4/PPPi7orSoQQWLlyJcaPH4+XL18WuL6PPvoIYWFhqFmzpg56R/RupaSkoH379jh8+DAAwNraGocOHUKdOnV01kZqaiqmT5+OH3/8UWWVduDNVAK2trYoWbIkbG1t1T5yyrOxseFoPco3IQTWrVuHkSNHIiEhQUrv27cvFixYgJIlSyqVz8rKwscffyyNRP3kk0+wZ88elflrlyxZglGjRgEA7OzsEBERIS1kFh4ertVIPSJ6vzBgpycYsCN6P929exerV6/G6tWrER0dLaUbGBhg3LhxmDlzJszMzHTW3rNnz7Bnzx78/fff+Ouvv3Djxo1CG7Flb2+PZcuWoVu3boVSP+meXC5HSkpKoQUECzJyU6Fnz55YvHgx7OzsdLDHBRMdHY2BAwcqzU2kC4aGhpgyZQqmTJmi16MKibJLSUlBhw4dcOjQIQCAlZUVDh06hLp16xZKe3///TcCAwNx584dndZraWmZa7Avt4CftbU1b0n8QD158gRDhgzBzp07pTRnZ2esWLEC7dq1y3G7x48fo0aNGoiNjQUA/PDDD5gwYYKUf+HCBTRo0ADp6ekAgF27dqnUN3PmTEyfPh1A7iP1iOj9w4CdnmDAjuj9lpWVhaNHj2Lq1Kk4c+aMlF6pUiWsXr26wKMTbt26hQULFmDNmjW5Bk2cnZ1Rr149ODg4FKg9FxcXDB8+nBMgk5KsrCwkJydrHfC7evWqNGIH0OxLUGESQiAsLAxjxoxRGlXXvn17ODo65rveM2fO4OrVq9Lf1atXx+rVq1G9evUC9ZeosKWmpuLzzz+XgtdWVlY4cOBAoY8UT0lJwdKlSxEREYGEhASlR3x8fJGMGra2ts53wM/KyoqrgxczQghs2LABI0aMQFxcnJTeo0cPLFmyRKMflw4dOoTWrVtDCAFDQ0OcOHEC9evXR2JiImrWrClNtzB27FjMmzdPZfusrCy0atVKug09p5F6RPT+YcBOTzBgR/RhyMzMxPz58zF16lTp11QDAwN89dVXmD59OkxNTTWuSwiBY8eOYf78+UrzqCgYGhqiRo0aqF+/Pho0aID69evDw8OD82eR3sntNqOFCxfC1tb2nfXl4cOHGDRoEPbt2yelubq6YuXKlWjTpk2B6s7IyMDs2bMxa9YsaRVAIyMjTJs2DV9//TXn5iK9lJqaio4dO+KPP/4A8GaE2oEDB9CgQYMi7tmbOVUTExNVgnmKgJ669Oz5uhgVrA2ZTAYbG5t8B/wsLS35Gf4OxcbGYujQodi2bZuU5ujoiF9++QUdO3bUqq4pU6Zg9uzZAAB3d3dcunQJQ4cOxaZNmwC8mavxxIkTOY66zmukHhG9nxiw0xMM2BF9WK5fv47AwECcP39eSvPx8UFYWBj8/Pxy3TY9PR0bN27E/PnzERERoZRnZWWFgQMHon379vDz84OFhUVhdJ+oUDx69AgDBw5UCpapm8i7MAgh8Ntvv2HUqFFKQcPAwEAsWLBAp0HDS5cuoW/fvkqj7WrWrInVq1ejatWqOmuHqKDS0tLQqVMn6T1pYWGBAwcOoGHDhkXcM91ITU0tUMBP8cPbu2JoaJhroC+vuf3Mzc0Z8NPQ5s2bMWzYMDx//lxK6969O3766ad83aWQmZkJf39/nDx5EgBQrlw5REZGAnizcMulS5fg5eWVax05jdQjovcXA3Z6ggE7og9PZmYmfvjhB8yYMQMZGRkA3lyMd+rUCebm5mq3kcvlOHLkCB49eqSU7u7ujtGjR2PAgAE8h1CxJoTA6tWrMXr0aKXbUdu2bZvrlyQ7OzsMGTIEFSpU0LrNJ0+eYPDgwdi1a5eU5uzsjJCQEHz22Wda16eJ9PR0fPfdd5gzZw6ysrIAvFlFNiAgAHZ2dvladZdza3045HI51qxZg+PHjxfqytK3bt2SpnGwsLDA/v370bhx40JrrzhRLBKUW0Avr4CfYqTtu2JsbFyggJ+ZmZleB/yePn2Kbdu24dy5c2oXLNHUo0ePpLkaAcDBwQHLli1D165dC9S/mJgY1KhRAy9evFBK37p1Kzp16qRRHdlH6pUpUwZ9+vSBo6MjSpUqpfSvg4MDR20TvQcYsNMTDNgRfbiuXLmCwMBAXLp0Setta9eujXHjxqFz585c+Y7eK/lZ8MHMzAxz5szBqFGjNJrbJ6e5iXr16oVFixa9k4Uvzp8/j759++LGjRsFrsvU1FSrAJ82f5ubm3O+JD0RGRmJfv364c8//3xnbZqbm2P//v1cnVKHhBBITk7Od8AvISFBCva/KyYmJvm+ndfW1laraT809ezZM2zbtg2bNm1CeHh4gQJ16nTq1Ak///xzgeYvzW7v3r1KPwSNGDECS5Ys0Xj7t0fq5aZkyZIqgbyc/rW3t+d1JJEeYsBOTzBgR/Rhy8jIwJw5c/C///0vz1tsZDIZOnTogHHjxqFhw4Z6/Ws3UUEIIfDrr79i3LhxSqPt8tK4cWOsWrUK5cuXz7GMLucmKqjU1FR8++23CA4OfudfwLVRokSJQgsIlihRgueyPMjlcvz888+YOHHiO11soVSpUti8eTOaNm36ztqkvAkh8OrVqwIF/N71V7sSJUrkO9hna2srjRh7/vw5tm/fjk2bNuHo0aM6D9IBgL29PZYsWYKAgACdn5sUq742bdoUf/zxB8zMzLTaPiYmBvXr10dMTIzO+iSTyWBnZ6dxgM/Ozo6juoneAQbs9AQDdkQEvDkXPH78ONcy9vb2BV7llag4SU1Nxf3793PMF0Lgl19+waJFi6Q0c3NzzJ07F8OGDVMZGaZubqKAgAAsWbKkSN9bcXFxiImJ0WqF3bz+fte33OWXTCaDubl5oQUETU1Ni3VAMCoqCv369cOxY8ekNC8vL/z0008oV65cobbt6elZKCOjqGjJ5XIkJSXlO+CXmJj4zvtsYWEBGxsbPH36VO2PG+XLl0f37t3Rvn172NjYFKgtLy+vHBeA0IUXL17A1tY230Gv1NRU3Lp1C8+ePUNsbGyu/2rzg5emDAwMYG9vr3GAr2TJkhylTZQPDNjpCQbsiIiICub48ePo168f/v33XymtWbNmWLVqFby8vPD8+XMMHz5cWpUPeDM30c8//4wuXboURZcLXXp6ulIQr6ABwLf/LoyRLYXBwMBApwHAt/8urC/2QgisWLEC48ePx6tXr6T0YcOGYe7cubC0tCyUdonykpWVhZcvX+Y5T19OeUlJSTrpR9myZdG9e3d069YN1atXL9aB+cKSlpamUWBP8W/2c42uGBoawsHBQeMAn62tLY8lERiw0xsM2BERERXcq1ev8PXXX2Pp0qVSmoWFBUaMGIHQ0FDExsZK6Z07d8ayZct0NjfRh0YIgfT0dJ0GAN8OLhaXS08jI6M8A3zaBgPT0tLw5ZdfKk1+7+7ujlWrVqFFixZFuLdEBZeZmZnjCr15BfwsLS3RoUMHdOvWDTVr1mRgR8dSUlI0DvDFxsYiJSVF530wMjJCqVKlNA7wWVtb83VQyLKyshAfH1+obShuzc7vsczIyMCaNWsQGBj43tyyzYCdnmDAjoiISHeOHj2Kfv36qb2V1s7ODkuXLkX37t15ga/HFKtwFlZAsDC+ZBamQYMGITg4mNeJRKRXXr9+rVWALy0tTed9MDEx0SrAZ2lpyc9/Ldy5cwf+/v549OhRobdVpUoVrFixAg0bNtRqu6tXr6Jv3764dOkSFixYgDFjxhROB98xBuz0BAN2REREupWUlIQJEyZg+fLlUlqHDh3wyy+/wNnZuQh7RvpALpcjJSWl0AKCuvpSWqZMGaxcuRKtW7fWSX1EREVFsViKNrfo5rUYW36YmppqFNhT/GthYaHzPhQXKSkpqFevHq5cufLO2pTJZBg7diy+++47lChRIteymZmZCA4OxvTp05GRkQEAsLKywoMHD2Bra/sOelu4GLDTEwzYERERFY7Dhw9j3bp1aNOmDbp168Zf1emdyMzMLHBA0MfHBxMmTCjwBPpERMWREAIvX77UKsBXGIstlShRQqsAX15BpuJk6NCh+OWXXwC8+QGpRo0ahdbW/fv3cfXqVenvihUrYvXq1ahbt67a8jdu3EBgYCDOnTsnpVWpUgWrV6+Gn59fofXzXWLATk8wYEdERERERESUP0IIJCQkaBzge/78udoVhwvKwsJC4wBfqVKlYGZmpvM+6MKmTZvQvXt3AG+ClufOnYOPj0+htZeVlYUFCxbgm2++kUapGxgYYMKECZgxY4b0PGVlZWH+/PmYOnWqUrmJEydi+vTpevt85gcDdnqCATsiIiIiIiKid0MulyM+Pl7jAN+LFy8KZXV0KysrrQJ8hbUyeXaRkZHw9fWVVnReuXIl+vfvX+jtAsDNmzfRt29ftSPnrKysEBgYiNOnT0t5lSpVQlhYWI4j8YozBuz0BAN2RERERERERPopKysLcXFxGt+e++LFi0Lph42NjUogr1y5chgwYADs7e0LXH9aWhoaNGiAixcvAgB69uyJtWvXvtMpRTIzM/Hjjz9i+vTp0jyGhoaGMDY2RmpqKoA3c92NGzcOM2fOfK9uQ86OATs9wYAdERERERER0fshMzMTL1680DjAFx8fX6D2nJycsHz5cnTo0KFA9YwePRqLFy8GAFSoUAHnz5+HlZVVgerMr2vXrqFv375S8FDB29sbYWFhaNCgQZH0611hwE5PMGBHRERERERE9GHKyMjA8+fPNQ7wJSYmqq2nZ8+eWLx4Mezs7LTuw/bt29GpUycAb1bTPX36dKEuNKGJjIwMzJ07FzNnzkRmZiZGjx6N//3vfzA3Ny/Sfr0LDNjpCQbsiIiIiIiIiEgTaWlpeP78OR49eoTvvvsOu3fvlvKcnZ0REhKCzz77TOP6oqKi4Ovri4SEBADAsmXLMHToUF13O9+ePn2KtLQ0uLu7F3VX3hlt4kQG76hPRERERERERESUA1NTU7i6uqJ27drYuXMnVq9eDRsbGwDAkydP0K5dOwQGBkoBuNykp6cjICBAKtu1a1cMGTKkEHuvPScnpw8qWKctBuyIiIiIiIiIiPSITCZDnz59cP36dXzyySdS+urVq1G1alXs378/1+0nT56MM2fOAADKli2LkJCQd7rIBBUcb4ktRLwlloiIiIiIiIgKQgiB0NBQfPnll3j58qWUbmhomOM2WVlZAABjY2P89ddf8PPzK/R+Ut54SywRERERERER0XtAJpOhX79+uHbtGlq1aiWlZ2Vl5fhQCA4OZrCumDIq6g4QEREREREREVHu3Nzc8Mcff2DVqlVYvXo1kpOTcywrk8nQpk0bjBo16h32kHSJt8QWIt4SS0REREREREREAG+JJSIiIiIiIiIiKrYYsCMiIiIiIiIiItIjehewS0hIwKhRo1C/fn04OzvD1NQUrq6uaN68ObZu3Yq37+ANCQlBu3bt4OXlBQsLC9jY2KB69eqYNm0a4uLitGpbCIFt27bB398fLi4uMDc3R8WKFTF48GD8+++/utxNIiIiIiIiIiIitfRuDru7d++iRo0aqFevHsqXLw87OzvExsZi9+7diI2NxcCBA7FixQqpfJMmTRAfHw9fX1+4uLggLS0Np0+fxpkzZ+Du7o4zZ87A2dlZo7bHjRuH+fPnw8XFBR06dIC1tTUuX76MgwcPwtLSEn/99ReqVq2q8b5wDjsiIiIiIiIiIgK0ixPpXcAuKysLQggYGSkvYJuUlIR69erhxo0buHbtGnx8fAAAqampMDMzU6ln6tSpmDVrFsaPH4/g4OA8233y5AlcXV3h7u6Oy5cvKz1xCxcuxJdffomgoCCsWrVK431hwI6IiIiIiIiIiIBivuiEoaGhSrAOAKysrNC6dWsAb0bhKagL1gFA165dVcrmJioqCnK5HA0bNlR50tq2bQsAiI2N1aguIiIiIiIiIiKi/NK7gF1OUlNTcfToUchkMlSpUiXP8nv37gUAjW9h9fb2homJCU6dOoWkpCSlvH379gEAmjdvrmWviYiIiIiIiIiItKM6lE1PJCQkYOHChZDL5YiNjcW+ffsQHR2N6dOnw9vbW6V8WFgYoqKikJSUhIsXLyI8PBy+vr4YO3asRu3Z29vjf//7HyZMmIDKlSujffv2sLKywtWrV3H48GEMGjQII0eO1PVuEhERERERERERKdG7OewUoqKi4OXlJf1tbGyM2bNnY9y4cZDJZCrlmzVrhuPHj0t/t2rVCmvXroWjo6NW7f7+++8YPHgwXr16JaU1aNAA33//PRo3bpzrtmlpaUhLS5P+fvnyJdzc3DiHHRERERERERHRB65Yz2Gn4OnpCSEEMjMzce/ePcycORNTpkxB586dkZmZqVI+PDwcQgg8e/YMe/bsQUxMDGrWrIkrV65o3OasWbMQGBiISZMmITo6Gq9evcLJkyeRmZkJf39/bNu2Ldft58yZAxsbG+nh5uam9X4TEREREREREdGHTW9H2KkTHByMiRMnYtmyZRg6dGiuZaOjo+Ht7Y3q1avjzJkzedZ99OhRtGjRAl9++SXmz5+vlPfs2TOULVsWdnZ2uH//fo51cIQdERERERERERGp816MsFOnVatWAN6MpsuLm5sbKleujHPnziE5OTnP8opFKvz9/VXySpUqhY8++ggPHjzA8+fPc6zD1NQU1tbWSg8iIiIiIiIiIiJtFKuA3aNHjwAARkaarZXx+PFjyGQyGBoa5lk2PT0dwJvRdOoo0k1NTTVqm4iIiIiIiIiIKD/0LmAXERGBxMRElfS4uDhMnjwZAPDJJ58AAF68eIHr16+rlBVCYMaMGXj69Cn8/f2VgmwZGRm4desWIiMjlbZp2LAhAGD+/Pkq7a9evRp3795FrVq1YGVlVbAdJCIiIiIiIiIiyoVmQ9XeobCwMKxcuRL+/v7w8PCAhYUF7t+/j7179+LVq1fo3LkzevToAeDNPHW+vr6oU6cOqlSpAmdnZzx//hwnTpzA7du34ezsjKVLlyrV//DhQ1SuXBkeHh6IioqS0rt27Yrly5cjPDwc3t7eaN++PUqWLInLly/j0KFDMDU1xcKFC9/hM0FERERERERERB8ivQvYdenSBYmJiTh9+jT+/PNPJCcnw87ODo0aNUKfPn0QEBAAmUwGAPDw8MCkSZMQHh6Offv2IS4uDmZmZvD29sY333yDMWPGwN7eXqN2DQ0N8ccff2DRokXYuHEj1q9fj/T0dDg5OaFHjx6YNGkSqlatWpi7TkREREREREREVLxWiS1utFn9g4iIiIiIiIiI3l/v7SqxRERERERERERE7zsG7IiIiIiIiIiIiPQIA3ZERERERERERER6hAE7IiIiIiIiIiIiPcKAHRERERERERERkR5hwI6IiIiIiIiIiEiPMGBHRERERERERESkRxiwIyIiIiIiIiIi0iMM2BEREREREREREekRBuyIiIiIiIiIiIj0CAN2REREREREREREeoQBOyIiIiIiIiIiIj3CgB0REREREREREZEeyXfAbufOnZDL5brsCxERERERERER0Qcv3wG7jh07wt3dHVOmTMG///6ryz4RERERERERERF9sPIdsBs/fjyysrIwZ84cVKhQAS1btsTGjRuRnp6uy/4RERERERERERF9UGRCCJHfjTMzM7F7926sXLkSBw8ehFwuh52dHXr37o3+/fvDx8dHl30tdl6+fAkbGxskJibC2tq6qLtDRERERERERERFRJs4UYECdtk9evQIq1atQmhoKO7duweZTIa6deti0KBB6NatG8zNzXXRTLHCgB0REREREREREQFFFLDLbv/+/Rg4cCAeP34MALC0tESfPn0wYcIEuLu767o5vcWAHRERERERERERAdrFifI9h506t27dwvjx4xEYGIhHjx6hRIkSCAgIgJubG5YuXYoqVapg//79umySiIiIiIiIiIjovVLggF1KSgrCwsLQqFEj+Pj4YP78+XB2dsaSJUvw6NEjrFu3DteuXcOePXtgbm6Or776Shf9JiIiIiIiIiIiei8Z5XfDCxcuICQkBBs2bEBSUhLMzMzQp08fDB48GPXq1VMp/+mnn2LAgAH48ccfC9RhIiIiIiIiIiKi91m+A3a1a9cGAFStWhWDBg1C7969YWNjk+s27u7ucHV1zW+TRERERERERERE7718LzoRGBiIwYMHo379+rru03uDi04QERERERERERGgXZwo3yPsZs6cCVtb21zLJCUlIT4+/oNaGZaIiIiIiIiIiKgg8r3ohJeXFxYtWpRrmWXLlsHLyyu/TRAREREREREREX1w8h2wE0Igr7tp83m3LRERERERERER0Qcr3wE7TcTExMDKyqowmyAiIiIiIiIiInqvaDWH3cyZM5X+Dg8PV1suKysLMTEx2LBhA+rWrZvvzhEREREREREREX1otFol1sDgvwF5Mpksz1teS5cuje3bt6N27dr572ExxlViiYiIiIiIiIgIKMRVYo8dOwbgzdx0zZs3R2BgIPr27atSztDQEHZ2dqhUqZJSkI+IiIiIiIiIiIhyp1XArmnTptL/p0+fDn9/fzRp0kTnnSIiIiIiIiIiIvpQaXVLLGmHt8QSERERERERERFQSLfEPnjwAADg6uoKQ0ND6W9NuLu7a1yWiIiIiIiIiIjoQ6ZxwM7T0xMymQw3b95EhQoVpL/zIpPJkJmZWaBOEhERERERERERfSg0Dtj16dMHMpkMNjY2Sn8TERERERERERGR7nAOu0LEOeyIiIiIiIiIiAjQLk5k8I76RERERERERERERBpgwI6IiIiIiIiIiEiPaDyHnTo3btzATz/9hHPnziEhIQFZWVkqZWQyGSIjIwvSDBERERERERER0Qcj3wG748ePo02bNkhLS4ORkRGcnJxgZKRaHafIIyIiIiIiIiIi0ly+b4n9+uuvkZmZiZUrVyIlJQXR0dG4d++e2oc2EhISMGrUKNSvXx/Ozs4wNTWFq6srmjdvjq1bt6oEAENCQtCuXTt4eXnBwsICNjY2qF69OqZNm4a4uDiN2w0LC4NMJsv10aJFC632hYiIiIiIiIiISFv5XiXW3NwcnTt3xtq1a3Xaobt376JGjRqoV68eypcvDzs7O8TGxmL37t2IjY3FwIEDsWLFCql8kyZNEB8fD19fX7i4uCAtLQ2nT5/GmTNn4O7ujjNnzsDZ2TnPdiMiIrBjxw61eVu2bMH169cxd+5cTJw4UeN94SqxREREREREREQEaBcnynfAzsnJCb169cK8efPy1cmcZGVlQQihcnttUlIS6tWrhxs3buDatWvw8fEBAKSmpsLMzEylnqlTp2LWrFkYP348goOD892f9PR0lC5dGomJiYiJiYGTk5PG2zJgR0REREREREREgHZxonzfEtu2bVucOHEiv5vnyNDQUO1ceFZWVmjdujWAN6PwFNQF6wCga9euKmXzY/v27Xjx4gU+++wzrYJ1RERERERERERE+ZHvgN0PP/yAxMREjBo1CsnJybrsk1qpqak4evQoZDIZqlSpkmf5vXv3AgCqVq1aoHZ//fVXAMCAAQMKVA8REREREREREZEm8n1LbPPmzZGQkIDLly/DwsIC3t7esLGxUW1AJsORI0e0rj8hIQELFy6EXC5HbGws9u3bh+joaEyfPh0zZsxQKR8WFoaoqCgkJSXh4sWLCA8Ph6+vL44cOYKSJUvmZxdx//59lC1bFi4uLrh//z4MDQ1zLZ+Wloa0tDTp75cvX8LNzY23xBIRERERERERfeC0uSVW9d5TDYWHh0v/f/XqFS5duqS2nEwmy1f9CQkJ+Pbbb6W/jY2NERwcjHHjxqktHxYWhuPHj0t/t2rVCmvXrs13sA4AQkNDIZfLERQUlGewDgDmzJmj1GciIiIiIiIiIiJt5XuE3buSlZWF6OhobNiwAdOnT0fbtm2xadMmtfPcAcDz589x5swZTJw4EYmJidi3bx+qVaumdbtyuRxeXl6Ijo5GZGQkvLy88tyGI+yIiIiIiIiIiEidd7JKbFEIDg7GxIkTsWzZMgwdOjTXstHR0fD29kb16tVx5swZrds6cOAA2rRpgxYtWuDw4cP56i9XiSUiIiIiIiIiIuAdrRJbFFq1agVA+XbcnLi5uaFy5co4d+5cvhbF4GITRERERERERERUFDSew27NmjUAgI4dO8LKykr6WxN9+vTRvmdqPHr0CAByvB32bY8fP4ZMJtNo/rnsXrx4gZ07d8LOzg4dO3bUup9ERERERERERET5pXHALjAwEDKZDPXq1YOVlZX0d26EEJDJZFoF7CIiIuDl5aWy4mxcXBwmT54MAPjkk08AvAmsPXnyBD4+Pirtfvvtt3j69ClatGgBU1NTKS8jIwORkZEwNjZGuXLl1PZh7dq1SE9PR69evZS2JSIiIiIiIiIiKmwaB+xWrVoFmUwGFxcXAG9WUC0MYWFhWLlyJfz9/eHh4QELCwvcv38fe/fuxatXr9C5c2f06NEDwJt56nx9fVGnTh1UqVIFzs7OeP78OU6cOIHbt2/D2dkZS5cuVar/4cOHqFy5Mjw8PBAVFaW2D7wdloiIiIiIiIiIioreLTpx8uRJ/Prrrzh9+jQePXqE5ORk2NnZoWbNmujTpw8CAgKkkX3x8fEIDg5GeHg4IiMjERcXBzMzM3h7e6Nt27YYM2YM7O3tleqPioqCl5dXjgG7s2fPom7duqhTp06+FqvIjotOEBERERERERER8B6vElvcMGBHRERERERERETAe7xKLBERERERERER0ftO4znsypYtm68GZDIZIiMj87UtERERERERERHRh0bjgJ1cLs9zVVh1eMctERERERERERGR5jQO2OW0oioRERERERERERHpDuewIyIiIiIiIiIi0iMM2BEREREREREREekRjW+JzUlMTAyOHTuGR48eIS0tTSVfJpNh6tSpBW2GiIiIiIiIiIjogyATBVgVYsKECVi0aBGysrKkNCGEtDiF4v/Z8z8kL1++hI2NDRITE2FtbV3U3SEiIiIiIiIioiKiTZwo37fEhoSEYN68efD398eWLVsghEDfvn2xfv16DBkyBEZGRujSpQuOHj2a3yaIiIiIiIiIiIg+OPm+JXbFihXw9PTE/v37YWDwJu7n6emJ7t27o3v37ujWrRs+/vhjdOvWTWedJSIiIiIiIiIiet/le4TdrVu30KZNGylYBwCZmZnS/5s2bYq2bdvixx9/LFgPiYiIiIiIiIiIPiAFWiXW1tZW+r+FhQVevHihlF+xYkVcv369IE0QERERERERERF9UPIdsHN1dUVMTIz0d7ly5XDmzBmlMteuXYOFhUX+e0dERERERERERPSByXfArmHDhjh9+rT0d4cOHXDp0iUMGTIEe/fuxaRJk7B//340adJEJx0lIiIiIiIiIiL6EMiEECI/G4aHh2Pu3Ln45Zdf4OHhgVevXqFp06a4dOkSZDIZhBDw9PTEsWPH4OHhoet+FwvaLNdLRERERERERETvL23iRPkO2KmTkZGBnTt3IjIyEh4eHmjXrt0HfUssA3ZERERERERERARoFycy0mXDMpkM5cqVQ7ly5VC1alUYGxvrsnoiIiIiIiIiIqL3nlZz2N27dw+rVq3CnTt3VPL27NkDV1dX+Pn5wc/PDy4uLti0aZPOOkpERERERERERPQh0CpgFxISgoEDB8LU1FQp/e7du+jWrRuePXsGd3d3VKpUCfHx8ejZsycuXbqk0w4TERERERERERG9z7QK2J08eRLVq1dXWURi0aJFSE1NxfDhw3Hv3j1cv34dmzdvRlZWFn766SeddpiIiIiIiIiIiOh9pvUtsT4+Pirpf/zxB0xMTDB79mwprVOnTmjcuDFOnDhR8F4SERERERERERF9ILQK2D1//hxubm5KaQkJCYiMjETdunVhZWWllFejRg08fPiw4L0kIiIiIiIiIiL6QGgVsDMyMkJCQoJSmmKOOj8/P5XylpaW+e8ZERERERERERHRB0irgF2FChVw5MgRpbSDBw9CJpOhQYMGKuUfPXoEFxeXgvWQiIiIiIiIiIjoA6JVwK5z5874559/MHjwYFy5cgXbtm3Dzz//DEtLS7Rp00al/KlTp1C+fHmddZaIiIiIiIiIiOh9p1XA7ssvv8RHH32EkJAQ+Pr6omvXrnj58iWmTZsGCwsLpbLnz5/H3bt38fHHH+u0w0RERERERERERO8zI20KlyhRAqdOncKCBQtw+vRp2NnZoWvXrmjfvr1K2YsXL6JDhw5q84iIiIiIiIiIiEg9mRBCFHUn3lcvX76EjY0NEhMTYW1tXdTdISIiIiIiIiKiIqJNnEirW2KJiIiIiIiIiIiocDFgR0REREREREREpEcYsCMiIiIiIiIiItIjDNgRERERERERERHpEQbsiIiIiIiIiIiI9AgDdkRERERERERERHqEATsiIiIiIiIiIiI9woAdERERERERERGRHmHAjoiIiIiIiIiISI8wYEdERERERERERKRHGLAjIiIiIiIiIiLSIwzYERERERERERER6RG9C9glJCRg1KhRqF+/PpydnWFqagpXV1c0b94cW7duhRBCqXxISAjatWsHLy8vWFhYwMbGBtWrV8e0adMQFxeXrz5s374dH3/8Mezt7VGiRAl4eXnhiy++QHR0tC52kYiIiIiIiIiIKEcy8XYErIjdvXsXNWrUQL169VC+fHnY2dkhNjYWu3fvRmxsLAYOHIgVK1ZI5Zs0aYL4+Hj4+vrCxcUFaWlpOH36NM6cOQN3d3ecOXMGzs7OGrUthMCQIUOwYsUKlCtXDq1bt4aVlRUePXqE48ePY926dWjUqJHG+/Ly5UvY2NggMTER1tbWWj8XRERERERERET0ftAmTqR3AbusrCwIIWBkZKSUnpSUhHr16uHGjRu4du0afHx8AACpqakwMzNTqWfq1KmYNWsWxo8fj+DgYI3aXrx4MUaPHo3hw4dj0aJFMDQ0VMrPzMxU6VduGLAjIiIiIiIiIiJAuziR3t0Sa2hoqDYoZmVlhdatWwN4MwpPQV2wDgC6du2qUjY3KSkp+Pbbb1G2bFksXLhQJVgHQKtgHRERERERERERUX4UmwhUamoqjh49CplMhipVquRZfu/evQCAqlWralT/oUOHEBcXh8DAQGRlZWHXrl24c+cObG1t0bJlS5QvX75A/SciIiIiIiIiItKE3gbsEhISsHDhQsjlcsTGxmLfvn2Ijo7G9OnT4e3trVI+LCwMUVFRSEpKwsWLFxEeHg5fX1+MHTtWo/bOnz8P4M0ouurVq+P27dtSnoGBAb788kv8+OOPudaRlpaGtLQ06e+XL19q1DYREREREREREZGCXgfsvv32W+lvY2NjBAcHY9y4cWrLh4WF4fjx49LfrVq1wtq1a1GyZEmN2ouNjQUAzJs3DzVr1sTZs2dRuXJlXLp0CYMGDcK8efNQrlw5DB06NMc65syZo9RnIiIiIiIiIiIibendHHYKnp6eEEIgMzMT9+7dw8yZMzFlyhR07twZmZmZKuXDw8MhhMCzZ8+wZ88exMTEoGbNmrhy5YpG7cnlcgCAiYkJduzYgdq1a8PS0hKNGzfGli1bYGBggHnz5uVax6RJk5CYmCg9oqOjtd9xIiIiIiIiIiL6oOltwE7B0NAQnp6e+PrrrzFr1ixs374dISEhOZZ3cHBA27Zt8ccff+D58+cYOHCgRu3Y2NgAAPz8/FC6dGmlPB8fH5QtWxaRkZFISEjIsQ5TU1NYW1srPYiIiIiIiIiIiLSh9wG77Fq1agXgzWi6vLi5uaFy5co4d+4ckpOT8yxfsWJFAICtra3afEV6SkqKRn0lIiIiIiIiIiLKj2IVsHv06BGANwtDaOLx48eQyWQwNDTMs6y/vz8A4ObNmyp5GRkZuHv3LiwsLFCqVCktekxERERERERERKQdvQvYRUREIDExUSU9Li4OkydPBgB88sknAIAXL17g+vXrKmWFEJgxYwaePn0Kf39/mJqaSnkZGRm4desWIiMjlbYpV64cWrVqhbt372LlypVKed9//z0SEhLQsWNHjYOFRERERERERERE+SETQoii7kR2Y8aMwcqVK+Hv7w8PDw9YWFjg/v372Lt3L169eoXOnTtj06ZNMDAwQEREBHx9fVGnTh1UqVIFzs7OeP78OU6cOIHbt2/D2dkZ4eHh0u2uABAVFQUvLy94eHggKipKqe3IyEg0aNAAsbGxaNu2LSpVqoRLly7h6NGj8PDwwOnTp+Hs7Kzxvrx8+RI2NjZITEzkfHZERERERERERB8wbeJEejdcrEuXLkhMTMTp06fx559/Ijk5GXZ2dmjUqBH69OmDgIAAyGQyAICHhwcmTZqE8PBw7Nu3D3FxcTAzM4O3tze++eYbjBkzBvb29hq3Xa5cOZw/fx7Tpk3DH3/8gYMHD8LZ2RnDhw/HtGnT4OjoWFi7TUREREREREREBEAPR9i9TzjCjoiIiIiIiIiIAO3iRHo3hx0REREREf2/vTsPj6q8+z/+OTPZSEKAQCCggbBECKAQlU1wQayouFWUCraVolis1aJtqVirYn3UytNW+6tLRS3UpYJaqxSs2gUFgYAgCLImbGGNQDYSs83cvz/OM5MMZxIIJDOT5P26rnPNds6Z+3DxnUk+uRcAANCaEdgBAAAAAAAAEYTADgAAAAAAAIggBHYAAAAAAABABCGwAwAAAAAAACIIgR0AAAAAAAAQQQjsAAAAAAAAgAhCYAcAAAAAAABEEAI7AAAAAAAAIIIQ2AEAAAAAAAARhMAOAAAAAAAAiCAEdgAAAAAAAJHim2+k0tJwtwJhFhXuBgAAAAAAALQ4Ho9UUCAdORJ8O3o0+PPl5ZJlSeeeK40da28jRkjR0eG+otA4fFjasEH68kt7u/BCafLkcLcq5AjsAAAAAAAA6mKM3eOtIaHbkSNSYeHpveeaNfb2+ONS27bSpZfWBHi9ejXa5YVNZaW0eXNgOPfll9KBA4H7HTtGYAcAAAAAQMgcOCAdPGj3HIqJqdmOf+x2h7ulaCmqqpwhW32hm++1ysqmbVdMjNSxo5ScbN8WFtrhlU9JifTee/YmSRkZ0siR0tCh0pAh0jnn2OeIZIcPS8uX29tnn0mrV0sVFSc+bsOGpm9bBCKwAwAAAAA0Pa9X2rLF/kV92TJ727Hj5I6Nj5eSkuxeRklJzvsJCfY+dW0dO0ppafatZTXtdSI0jJGKixsevBUXN33bOnSoCd6CbcFeS0hw/t88cED6+GPpn/+0bw8frnlt+3Z7mzvXfhwTIw0ebId3vhDvrLPCF3Z7PNK2bYEB3datJz4uOdkOH33b2WdLAwY0fXsjkGWMMeFuREtVXFysdu3aqaioSElJSeFuDgAAAACETkWFPZzPF8599pkdmoRTmzbSmWfa4V3tLT3dDjfS0ujNFw4VFQ0L3Xz3q6ubtl1t2jQ8eOvQoWn+D3m90tq10ocf2tuKFSe+/uhoqWdPqU8fqXdv+9Z3v2fPxuuRV1pq94Jbt65m+/JLe/GM+vTqJQ0fLg0aVBPQde3aokP1huREBHZNiMAOAAAAQKtRWGj3pPEFdKtW1T/cLTbW7gmUmWn3xqmqsocd+jbf4/JyezhgcXHNrcfTNNcQG2sHGmed5dxSUlp0kNAovF77/0FDgrcjR5p+RVSXyw7SGhK8dexoB3aR6ptv7GBs9Wq71lavtnu0nSyXS+rcuaaXart2Nfd9W5s2dijoq8WqqsD7JSXSxo32+54oWoqOthfRGDnS3i64QEpNPa1/guaIwC5CENgBAAAAaLH27KkJ55Yts39xr+/Xy+Rk+xf1UaPs7bzz7ICsoYyxwwpfeFdcLJWVBW6lpYH3Dx2S8vJqtmPHGv6+HTpI/fo5t169pKgWONtUWVnDQrcjR+wVUb3epm1XQkLDQreOHe0wyuVq2nZFgsJCu1frqlX27bZtUk7OiXu6NYXeve0huuefb9f9+edHdgAaIgR2EYLADgAAAECL4PFIX30VGNDl5dV/TK9eNeHcqFFS376REZoYIxUVBQZ4O3fa4cbWrXbA0ZAFBqKj7V55ffvaW79+NfeTk5vuOk6Wx2MHaQ0J3o4csXs2NqWoqOAh24mGoJ5KyNuaGWMv7JKTI+XmBt7m59eE3qcatMbG2vPMDR5sD20dPNge2koGEhSBXYQgsAMAAADQLH3zjT3EzhfOLV9uh1x1cbnsX9R94dzIkVK3biFrbqPyeOzeg9u21Wxbt9rbnj0NO1enTjXhXd++drCXkWH3PoqPb9i5jLF7CzYkdDtyxO511dSSkhoevCUlMcQ4Uvj+b/nCu6Ii+/abb+xA2rdqc+3b6GgpLs6e97El9jBtIgR2EYLADgAAAECzcPiwvSiEbwXXzz+356iqS3y8PVm8L6AbPtxetbWlKy21A7wtWwK3rVvrn68vmDPOqAnw+vSxw70TDUFtSM+/UxETc/Khm+/15GQ7vAFwQgR2EYLADgAAAEDEMUbasSNweOuWLfUf07lz4PDWwYMJaWrz9crz9cTburUmyNu/Pzxtqr3IwsmudJqQQK83oAk1JCei3yIAAAAAtGTV1dL69YEB3cGD9R/Tt2/g8NY+fQhy6uN2Sz172tsVVwS+VlJi98rbvt3ecnJqbr/++sTnbtOm4cFbhw52mwA0WwR2AAAAANCSHDsmZWfXhHMrVthDOesSFWWv2OoL6C64wO5Rh8bRtq3973veec7XCgvtBQC2b7fnDQsWyLGyJtAqEdgBAAAAQHN28GDN3HPLlklffGEP0axL27Z2KOcL6IYObfgCCGgc7dvXHeYBaNUI7AAAAACguTDGHl5Ze3hrTk79x3TrJl14YU1Ad/bZDJcEgAhHYAcAAAAAkaqyUlq71g7mfL3oDh+u/5gBAwIXiOjRg/nnAKCZIbADAAAAgEhRVGTPOefrPZedLZWX171/TIw0ZEjg/HPJyaFrLwCgSRDYAQAAAEC47N0bOLz1yy/tYa916dDBXrXVF9Cdd54UFxe69gIAQoLADgAAAABCweuVNm0KDOh2767/mPT0wOGtmZmSyxWS5gIAwofADgAAAACaQnm59PnnNeHcZ59JhYV1729Z0qBBNeHcyJHSmWeGrLkAgMhBYAcAAAAAjeHoUWn58pqAbvVqe9GIurRpIw0bVhPQDR8utWsXuvYCACIWgR0AAAAANJQx0q5dgb3nvvqq/mNSUmp6zo0aJWVl2YtGAABwHAI7AAAAADgRj8deEKL2/HP799d/TEZG4PxzGRn2sFcAAE6AwA4AAAAAjldaKq1aVRPOrVghlZTUvb/bLZ17buD8c126hK69AIAWhcAOAAAAAPLz7WGtvoBu7Vqpurru/RMTpREjagK6YcOkhITQtRcA0KIR2AEAAABoXYyRcnICh7du21b/MV27Bg5vPeccKYpfpwAATYNvGAAAAAAtW1WVtG5dYECXn1//MZmZgQFdz57MPwcACBkCOwAAAAAtS3GxtHJlTTiXnS2VldW9f3S0NGRITTh3wQVSx46hay8AAMchsAMAAADQvO3fH9h7bv16yeute/927exFIXwB3fnnS23ahK69AACcQMQFdoWFhXrooYe0evVq7dy5UwUFBerUqZP69u2ru+66SzfccIOsWl3R58yZo/fff18bN25Ufn6+oqKilJ6eruuuu07Tp09XcnLySb93enq6du/eHfS1H/7wh3rhhRdO+/oAAADQilRXSxs32r29Vq2yh2Z27y716GHf+rbExHC3tPnweqUtWwIDup076z+me/fA4a0DBkguV2jaCwDAKbCMMSbcjagtJydHgwcP1vDhw9WnTx8lJycrPz9fCxcuVH5+vqZOnaoXX3zRv/9FF12kgoICZWVlqWvXrqqoqNDKlSuVnZ2t7t27Kzs7W6mpqSf13unp6SosLNT06dMdr51//vm6+uqrG3QtxcXFateunYqKipSUlNSgYwEAANAMHTxoh3O+bfXq+odi+iQn26FSerrUp4+9ZWTY2xlntO5wqaJCWrOmJpz77DPp6NG697cs6eyza8K5kSPtf1sAAMKsITlRxAV2Ho9HxhhFHbfiUklJiYYPH65NmzZp48aNGjBggCSpvLxccXFxjvP86le/0mOPPaaf/exnmj179km9d3p6uiRp165dp3UNPgR2AAAALVhFhfTFF4EBXR2jNU5LXJzUu7cd3vmCPN9tSwzzCgqkFStqArpVq+x/67rExUlDh9YEdCNGSO3bh6y5AACcrIbkRBE3JNbtdgd9vm3btho7dqw2bdqknJwcf2AXLKyTpJtuukmPPfaYcnJymqytAAAAaCWMscO42uHcF19IlZX1H9ejhzR8eM2WlCTt2VOz7d5dc3/vXnsI7fHKy6WvvrK349UO83xBXkqKPcQ22BYXF3krne7ZEzi8deNG+9+7Lh07Bg5vPfdcKSYmdO0FACAEIi6wq0t5ebn+85//yLIs9e/f/4T7L1q0SJI0cODABr1PRUWF5s2bp3379qlDhw664IILNGjQoFNqMwAAAJqpY8ekzz8PDOgOHar/mPh4e6VRXzg3bJjUtatzv7p+lvV47NBu+3YpJ8e+9d3PzQ0eDtYX5gXjckkdOtg983xbt26Bj32roxpjzxfnu/XdN8YOyGJjA7eoqMAw0OuVvvnGHhJcWmrf+u5v3FgT0O3dW3+be/cODOj69o280BEAgEYWcUNifQoLC/X000/L6/UqPz9fixcvVl5enh5++GE98sgjjv3nzp2rXbt2qaSkRGvXrtWSJUuUlZWlf//73+rQocNJvWddi05cccUVevXVV9WpU6d6j6+oqFBFre76xcXFSktLY0gsAABAJPN6pW3bAsO5DRvqX2VUsoOj2r3nBg60Q6um4PFIeXk1AV7tQG/HjhP39AsFy6oJ8qqq7LCuoVwuKSsrcP65YKEnAADNULOew85n165d6tmzp/9xdHS0Hn/8cf30pz8NWCXW55JLLtEnn3zif3z55Zfr1VdfVefOnU/6PR999FFdfPHFGjBggGJjY7Vp0ybNmjVLH3zwgUaMGKHPPvss6Hv7PPLII5o1a5bjeQI7AACACHL0qD0vmi+cy86WCgvrP6Z9e7vHnC+cGzrUXigiEvjCPF+QV1ho92I7dixwKy2VSkqkr7+W9u+3Q7Vwi4+355zzBXTDhklt24a7VQAANIkWEdj5eDwe5eXl6c0339TDDz+scePGacGCBY5FKXwOHz6s7OxszZgxQ0VFRVq8eLHOOeecU35/r9eriy++WMuWLdM//vEPjRs3rs596WEHAAAQYaqr7eGXtXvPbd1a/zEul73KaO3ec2ed1bIWd/B6pcOH7eBu377AraDA7i3nctVstR9Ldo++iorArfZzMTF2GBcfLyUk1Nz3Pe7Wze49N2iQFB0d3n8LAABCpEUFdrXNnj1bM2bM0HPPPac777yz3n3z8vKUkZGhQYMGKTs7+7Te95VXXtFtt92mmTNn6vHHHz/p41glFgAAIMQOHgwM51avtudNq0+XLoHh3Pnn2ws0AAAANKJmvUpsfS6//HLNmDFDS5YsOWFgl5aWpszMTK1evVplZWWKj48/5ff1zV1XdqIf9gAAABA6FRX2Sq21A7og8xEHiImxVxWtHdB1784iBgAAIKI0q8Bu//79klTncNjjHThwQJZlye12n9b7+nropaenn9Z5AAAAcIqMscO42uHcF1+ceLGF9PTAcG7wYHtRBAAAgAgWcYHdunXr1LNnT7Vr1y7g+aNHj+qBBx6QJF155ZWSpCNHjujgwYMaMGBAwL7GGM2aNUuHDh3SmDFjFFvrh7Kqqirl5uYqOjpavXv39j+/adMmdevWTe3btw8417Jly/S73/1OsbGxuuGGGxrzUgEAAFCXY8ekzz8PDOgOHar/mPh4ezEIXzg3bJiUmhqa9gIAADSiiAvs5s6dq5deekmjR49Wjx49lJCQoN27d2vRokU6duyYxo8fr0mTJkmy56nLysrS0KFD1b9/f6Wmpurw4cNaunSptm7dqtTUVD377LMB59+3b58yMzPVo0cP7dq1y//8ggUL9NRTT2nMmDFKT09XbGysNm7cqI8++kgul0svvPCCunfvHsp/CgAAgNbB65W2bQsM5zZssJ+vT79+gb3nBgyQTnIkBgAAQCSLuJ9obrzxRhUVFWnlypX69NNPVVZWpuTkZI0aNUrf//73dfPNN8v6vzlGevTooZkzZ2rJkiVavHixjh49qri4OGVkZOjBBx/U9OnT1bFjx5N639GjR2vz5s1au3atPvnkE5WXl6tLly76zne+o3vvvVdDhw5tyssGAABoPY4elVatqgnnsrOlwsL6j2nfPjCcGzpU6tAhFK0FAAAIuWa1SmxzwyqxAACg1auuljZuDOw9t3Vr/ce4XNI55wQGdBkZ9vMAAADNVItdJRYAAAAR7uDBwHBu9WqprKz+Y7p0kUaMqAnnzjtPSkwMTXsBAAAiEIEdAAAATk1Fhb1Sa+2Abvfu+o+JiZHOPTew91z37tL/TXkCAAAAAjsAAACcDGPsMK52OPfFF1JlZf3HpacHhnODB0uxsaFoMQAAQLNFYAcAAACnY8ekzz8PDOgOHar/mPh4ezEIXzg3bJiUmhqa9gIAALQgBHYAAACtndcrbdsWGM5t2GA/X59+/QJ7zw0YIEXx4yUAAMDp4icqAACA1uboUWnVqppwLjtbKiys/5j27QPDuaFDpQ4dQtFaAACAVofADgAAoCWrrpY2bgzsPbd1a/3HuFzSOecEBnQZGfbzAAAAaHIEdgAAAC3JgQN2jzlfOLd6tVRWVv8xXbpII0bUhHPnnSclJoamvQAAAHAgsAMAAGiuKirslVpr957bvbv+Y2JipHPPDew91727ZFmhaTMAAABOiMAOAACgOTDGDuNqh3NffCFVVtZ/XHp6YDg3eLAUGxuKFgMAAOAUEdgBAABEomPHpM8/DwzoDh2q/5iEBGnIkJpwbtgwKTU1NO0FAABAoyGwAwAACDev114Iovbccxs22M/Xp1+/wN5zAwZIUfx4BwAA0NzxEx0AAECoHT0qrVolrVhhh3PZ2VJRUf3HtG8fGM4NHSp16BCS5gIAACC0COwAAACaUnW13Vuu9tDWbdvqP8blks45JzCgy8iwnwcAAECLR2AHAADQ2Pbtk/72N+ndd+3ec2Vl9e/fpYs0YkRNOHfeeVJiYmjaCgAAgIhDYAcAqF9VlVRaKhUX2xPeHzhgbwcP1tw/cEDKz7fnzmrb1rklJp7884mJ9CJC87R3r/TOO9Jbb0mffVb3fjEx0rnnBvae695dsqzQtRUAAAARjcAOJ++JJ6TNm6Wbb5a+9S0pOjrcLQIihzF2sFVRIVVW2re1t+pqe/J43+bxOB9XV9vnqK6u2Wo/9nhqNt8xJ7vVPp/vnL77vq2iwg7mysrsW99WVRX6f8+EhIaFfPU9n5BAAIjgfHXgctVsllWz1WZMYO36auvIEem99+yQbvny4O/To0dg77nBg6XY2Ca/PAAAADRfljHGhLsRLVVxcbHatWunoqIiJSUlhbs5p8cYqU8faccO+3FysjR+vDRxonTRRZLbHd72AU2ppETKywvc9uypub9vnx1yteaPU8uSOna0A4ySEjsIiSQJCacf/PmeJwCMTB6PtH+/tGuXtHOnfbt7t1RQIB07VrOVlNTcLy+v+3yWVRPgeTwNr+/+/aWbbpJuvNFeuZXecwAAAK1eQ3IiArsm1KICu9277cmvi4udr6WmShMm2D3vhg/nlxI0LxUVduB2fAhX+35hYbhbGToxMXYgFR9v39a+n5hoz7PVtatd91271tzv3Lmm160xdi/DkhLn5gtMGvp8JAWAlhUYAJ5uT8CEBD43T5bXa9fmpk32tmVLTTi3Z0/4/58MGGCHdDfdZAd2AAAAQC0EdhGiRQV2kt0T4cMPpTfflN5/P/gE2j162MHdpEl2wAeEk8djz7MWLITzPT506PTeIzFROvNMO3iJja17i44OHHbnctk9U2s/jo6254CLigq879vc7prNd3ztx8fv49t8z/vOe/zmez421r4faYyxg9XTCf6Of83jCfdV1bAs+/9RYw0Bjo9v/gFgRYUdxG3fXhPObdpkT8tQWnrq542Pr/m39m0xMTXDXX3b8Y/rqj2Xyz5+2DC7J11mZuP9GwAAAKDFIbCLEC0usKuttFT6xz/s8G7xYrs3zfEGDrSDu4kTpfT0kDcRLZwx0tGjwUO42kNVT6fHTXS0lJYWuHXvHvi4ffvmH460NsbYf4CoL+RraCDo9Yb7qmr4AsDGGgLcFAGg12vP/bZrl5Sba0+3kJtbc3/v3oYNQU1Kknr2tL9rfLfp6fYfkTp3tq8lIYHpGwAAABBWBHYRokUHdrUVFkp//7sd3v3rX8F7rlxwgR3eTZggpaSEuoVojo4dq7tXnO/+N9+c+vktyx7OeXwAV/tx587MVYYTOz4AbIwhwJEUALpcgaHeyQZ/iYn298P+/XZ4vm9fzf39+xu+mIllSb162cNO+/e3t8xMe37V9u2b4soBAACARkVgFyFaTWBX29dfSwsWSG+8EXy1PLdbGjtWuuMOady4yBx+h6ZXWWn3oAkWwvnun+68cR071t0rrnt3qVs3VjpGZDLGDqMbI/jzbc3pq75jRzuY693b3nzhXN++Ups24W4dAAAAcMoI7CJEqwzsatu50+519/rr0ldfOV8/4wzp9tvt7cwzQ98+NA2Px54Xrq4FHPLy7HnlTkdCQv0949LS7GF8AOywrqyscYI/33On86NDx4725/8ZZ9if/b5grndvO6hr167xrh0AAACIIAR2EaLVB3a1bdhg97p74w07vKnN5ZKuvlqaNk26/HLmGIpkvnnj6huq2hjzxp15Zv2BHPPGAeHj9Tp7ANYV8LVtWxPOdetmb3Fx4b4CAAAAICwI7CIEgV0QHo/00UfSn/4kLVzonKepRw9p6lTplltYqCIcfPPG1RfINca8ccFCON995o0DAAAAALRABHYRgsDuBPbulV56yd727XO+PnSo9J3vSDfdZAc5OD3HzxsXLJQrKDi996g9b1ywYapnnMG8cQAAAACAVonALkIQ2J2k6mpp0SLphRekDz8MPjfSyJF2eHfjjXYPLQTyzRtX1wIOeXn266dT7gkJdfeKS0uzh7EmJDTeNQEAAAAA0IIQ2EUIArtTsHOn9Ne/2ivNrl/vfN2ypIsusleavfBC6fzzW/58SLXnjatrqGpjzRtX14qqzBsHAAAAAMBpIbCLEAR2p2nLFju4mz9f2rQp+D4xMdKQIXZ4N2qUdMEFUocOoW3n6ao9b1ywQC4vz17h8VTVN2+c7zHzxgEAAAAA0KQI7CIEgV0j2rixJrzbtq3+fQcOlLKypD597K13b/s2OTn0PcQqK+3eb3Ut4NAY88YlJ9e/omq3bnawCQAAAAAAwobALkIQ2DUBY+zAbtmymi0n5+SObd++JsDr2TNw7rW0NHvBhIYEel6vdPBg8BDOd7+x5o2ra+445o0DAAAAAKBZILCLEAR2IXLwYGCA98UXdpjWUHFxdgB25plSSopUVSVVVNi95CoqarbKSqm0VDpwoPHmjatrqCrzxgEAAAAA0CIQ2EUIArswKSuTduywe97V3nJz7Z5vpxLmNZRlSampda+ompYmdenCvHEAAAAAALQSDcmJokLUJiB04uPteewGDnS+VlEh7dol7d5tD1ndu9d5W1xc97ljY+0tLs5eyKGuueOYNw4AAAAAAJwiAju0LrGxUt++9laX4mLp6FE7cPMFdLGxUlQUw1MBAAAAAECTI7ADjpeUZG8AAAAAAABhwARaAAAAAAAAQAQhsAMAAAAAAAAiCIEdAAAAAAAAEEEiLrArLCzUPffcoxEjRig1NVWxsbE644wzdOmll+qdd96RMSZg/zlz5uiaa65Rz549lZCQoHbt2mnQoEF66KGHdPTo0dNqy1NPPSXLsmRZllauXHla5wIAAAAAAABOhmWOT8DCLCcnR4MHD9bw4cPVp08fJScnKz8/XwsXLlR+fr6mTp2qF1980b//RRddpIKCAmVlZalr166qqKjQypUrlZ2dre7duys7O1upqakNbsfmzZuVlZWlqKgolZaWasWKFRo+fHiDzlFcXKx27dqpqKhISSxiAAAAAAAA0Go1JCeKuMDO4/HIGKOoqMAFbEtKSjR8+HBt2rRJGzdu1IABAyRJ5eXliouLc5znV7/6lR577DH97Gc/0+zZsxvchhEjRsiyLJ111ll67bXXCOwAAAAAAABwyhqSE0XckFi32+0I6ySpbdu2Gjt2rCS7F55PsLBOkm666SbHvifrN7/5jdavX69XXnlFbre7wccDAAAAAAAApyriAru6lJeX6z//+Y8sy1L//v1PuP+iRYskSQMHDmzQ+2zcuFGzZs3Sgw8+6O/FBwAAAAAAAISKsytbhCgsLNTTTz8tr9er/Px8LV68WHl5eXr44YeVkZHh2H/u3LnatWuXSkpKtHbtWi1ZskRZWVm67777Tvo9q6urNXnyZGVmZur+++9vcJsrKipUUVHhf1xcXNzgcwAAAAAAAKB1i+jAbtasWf7H0dHRmj17tn76058G3X/u3Ln65JNP/I8vv/xyvfrqq+rQocNJv+fjjz+u9evXKzs7W9HR0Q1u8xNPPBHQZgAAAAAAAKChInZIbHp6uowxqq6u1s6dO/Xoo4/ql7/8pcaPH6/q6mrH/kuWLJExRl9//bX+8Y9/aO/evTr33HP15ZdfntT7rV+/3r9IxbnnnntKbZ45c6aKior8W15e3imdBwAAAAAAAK1XxPaw83G73UpPT9f9998vt9utGTNmaM6cObrzzjuD7t+pUyeNGzdO55xzjjIyMjR16lRlZ2ef8H1uvfVW9e7dW4888sgptzU2NlaxsbH+x74FeBkaCwAAAAAA0Lr58iFfXlQfy5zMXhFi/fr1Gjx4sCZMmKD58+efcP+srCytX79ex44dU3x8fL37WpZ1Um149913df3115/Uvnv37lVaWtpJ7QsAAAAAAICWLy8vT2eeeWa9+0R8D7va9u/fL0mKijq5Zh84cECWZcntdp9w39tuuy3o859++qm2b9+ua6+9VikpKUpPTz/p9nbr1k15eXlq27btSQeCaBmKi4uVlpamvLw8JSUlhbs5QESgLgAn6gJwoi4AJ+oCCK651YYxRiUlJerWrdsJ9424wG7dunXq2bOn2rVrF/D80aNH9cADD0iSrrzySknSkSNHdPDgQQ0YMCBgX2OMZs2apUOHDmnMmDEBw1SrqqqUm5ur6Oho9e7d2//8Sy+9FLQ9kydP1vbt2zVz5kwNHz68QdficrlOmJiiZUtKSmoWHxpAKFEXgBN1AThRF4ATdQEE15xq4/i8qy4RF9jNnTtXL730kkaPHq0ePXooISFBu3fv1qJFi3Ts2DGNHz9ekyZNkmR3IczKytLQoUPVv39/paam6vDhw1q6dKm2bt2q1NRUPfvsswHn37dvnzIzM9WjRw/t2rUrDFcIAAAAAAAA1C3iArsbb7xRRUVFWrlypT799FOVlZUpOTlZo0aN0ve//33dfPPN/uGlPXr00MyZM7VkyRItXrxYR48eVVxcnDIyMvTggw9q+vTp6tixY5ivCAAAAAAAADh5ERfYjRo1SqNGjTqpfTt06KDHH3+8QedPT08/qdU4fObOnau5c+c26D2A2NhYPfzwwwHDsYHWjroAnKgLwIm6AJyoCyC4llwbzWqVWAAAAAAAAKClc4W7AQAAAAAAAABqENgBAAAAAAAAEYTADgAAAAAAAIggBHYAAAAAAABABCGwAwAAAAAAACIIgR0AAACAkDHGhLsJAABEPAI7AMAp2b9/f7ibAEScffv2qbKyMtzNACLOf//7Xz300EMqLy+XZVnhbg4AABGPwA6ox+7duzV69GjNmTNHEn8RBiQpNzdXl1xyie68807t2rUr3M0BIsLOnTs1ZcoUjRkzRo8++mi4mwNEjNzcXF1zzTUaM2aMFi5cqJKSknA3CQi7/fv3a+7cuVqwYIH++c9/hrs5QEQ4fPiwcnNzlZ+fL4/HI0nyer1hblV4EdgBdcjLy9O1116rTz75RI899pgKCgr4izBaterqak2fPl1nnXWWtm/frosuukhJSUnhbhYQVsYYPf7448rMzNSSJUuUkZGhTp06hbtZQNj5vjMyMjK0Zs0aJSYmaseOHf6fpfgjKFojj8ej+++/X2effbbuvvtu3Xzzzbrqqqv0k5/8RPn5+ZKoDbQ+Ho9HP//5z3XuuedqyJAhGjhwoG6//Xbt2bNHLpcdWbXWuiCwA+rQpk0b7dy5U3369FFeXp6efPJJSa33wwKt25///GelpKTo5Zdf1rRp0zR//nzdc889Sk5ODnfTgLB66aWXNHv2bI0fP15z5szRW2+9penTp4e7WUBYvfjii/7vjDvvvFOLFy/WmDFjVFJSomXLlkkSfwRFq7Nt2zaNGTNGc+bM0fXXX69nnnlGf/rTnzRixAi98sor1AZapbVr12rIkCF6/vnnNWTIEH3/+9/XwIEDNW/ePF1//fV69913JbXeuogKdwOASHXo0CGlpqZqypQpeuWVV/T000/r1ltvVf/+/cPdNCBkPB6PLrroIq1YsUIXX3yx7r//fmVlZalz586OfY0xrfbLFK2PMUb5+fn63//9X/Xr10+/+93v1KVLl3A3Cwir3Nxc3XDDDdqwYYOuvfZaTZ48WRdddJGSk5M1cuRIvffee/59vV6vv+cE0BrMnz9fy5cv16OPPqof/OAH/u+Mzp0769vf/rYKCwsl8fMUWpeXX35Zmzdv1pNPPqlJkyYpJSVFJSUlmj17tp566ik9+OCDSklJ0ahRo1rl9waBHVCHuLg45eTk6Oabb1Z8fLymT5+uRx55RAsWLAh304CQ8Hq9crvdGjt2rFasWKH09HSNHTtWklReXq6KigoVFRWpqKhI/fv3l9vtDnOLgdCxLEvr169XTk6O5s+fry5duqisrEwbNmxQXl6eNm7cqLPOOkuXXXZZ0IAbaIl27dqlrKws3XHHHbr22muVlpbm2GflypW6/vrrW90vXWjdcnNz9Yc//EGZmZm6//77A17zer3q1KmTevToIan19iRC67NhwwbNmTNHo0aN0k9+8hNJdmeBtm3bauLEiVq1apU++ugjPfLII/rXv/7VKr83Wt8VA7XUN7x127ZtSkpKksfj0cSJEzVixAi9/fbb+uCDD054LNCc+f5v+35gfOihh5Senq533nlHH3/8sb7++mv9/ve/17hx49SnTx+NHj1ao0aN0ltvvRXOZgNNKthn/pYtW2SMUWJioiR76Pgtt9yiCRMm6NFHH9V3v/tdXXfddXrnnXckMXEyWiZjjL8+Ro8erdmzZ+uuu+7yh3VVVVWSpEsvvVSStGPHDpWVlYWnsUCIHP+dkZycrOjoaFmWpS1btkiyg4k1a9bo6aefVmxsrKqqqrR69WqVl5dL4jsDLc/xdeHxeBQbG6uePXtKkiorK/0dAPr166c2bdpIkj755BO9+OKLklpfXRDYoVU6cOCApMC/YPk+QHy38fHxKi0tlcfjUUpKiu68805J0q9+9Sv/sb7zAC3B8XVhWZYqKyslSb///e917NgxPfnkk/rBD36gX/7yl3K5XLr55pt1/vnnKzs7Wz/4wQ80b948/zFASxDs+8K3cpmv59yePXv09ttv67777lNGRoaWLl2q9957T/fee6+ys7M1bdo0HTp0SC6Xiz/2oMWoXRu++nC5XEpJSZFU8/NUdHS0/7Zr164qKChQfHw8tYAWKdh3hiRFRUXp6quv1pdffqmHHnpI7733nh577DHdeeedWrp0qVJSUvSd73xHw4YN08SJE3X48GG+M9Bi1FUX5eXlcrlcWrlypSQpJiYmoOOA73vD4/Fo3rx5Ki4ubn297AzQiqxZs8ZcddVVJjMz0/Tp08dMmzbNLF261BhjjNfrDdj3pZdeMsnJyebQoUPGGGPKy8vNxIkTjWVZZsaMGWbgwIFm1KhRprCwMOTXATSm+urC4/H497v00kuNZVmmX79+5u9//3vA688995xJS0szgwcPNqtXrw79RQCN7GS+L5YtW2batWtnJk2aZMaNG2cuuugix3mmTZtmLMsyt912W0jbDzSVhvwsVduRI0dM586dTZs2bcyePXtC1VwgJOqrC5/t27ebsWPHGsuyTExMjP9nqvfff9/s3bvXZGdn+3/X+MEPfmCMqb+mgEh3MnVx5ZVXGsuyzOOPP25KS0uNMcYcPnzY/OEPfzBt2rQxr732mrniiitMhw4dzCeffBKOywgrAju0eF6v13g8HvPMM8+Y2NhYk5mZaa6++mpz4YUXGrfbbRITE82HH37o37+qqsoYY8zzzz9v2rdvb/bt2+d/beHChSYuLs64XC6TkpJi7r33XnP48OGQXxNwuhpaF8YYs2nTJnP++eeb9evX+5+rrq42xhhz9OhR84tf/MK43W7z8ssv+98DaE4aWhfbt283w4cPN26321iWZZ599lljjDEVFRX+2sjPzzeJiYmmU6dOZseOHWG5LuB0ncp3Rm2+P+6MHz/eJCcnm1WrVoWq6UCTOZW6KCoqMlu2bDHPPvusufLKK82BAwcCXj9y5IhJSUkxlmWZDRs2hPJygEZxsnXh+z1h6dKl5swzzzRRUVFm9OjR5t577zXXX3+9ad++vRk7dqzZvXu3eeSRR4xlWf56ak2/YxDYoVXIy8szZ511lhkyZIhZvny5//kXX3zRJCYmmrS0NPPPf/4z4JgZM2aYXr16+R8/+eSTJi4uzv+L2Q033BCy9gNN4VTqYtOmTXV+Sb7++uvGsiwzZcqUJm030JQaWhePPPKISU5ONpZlmQcffDDgXOXl5cYYY66//nrTpUsXs3Xr1tBcBNAETuU7o7aKigpz2223GcuyzH/+8x9jTGAvbqA5amhdeDweU1paas455xwzefJkY0xN+FBWVmaMsXtmu93uekNwIJKdTF188MEH/uf/9re/mauuuspYlmWSkpJMx44dzT333OP/Oeq5554zlmWZP/7xjyG/lnBrZQOA0Vq9/vrr2r59u+6++26NGDHC//zUqVM1e/ZslZSU6KmnntKXX37pf83tdqtDhw7661//qj59+mjmzJm68MIL9cQTTygjI0Pvv/++NmzYIIkFKNA8nUpdZGZmOuafqK6uliT/xPu+Vc6A5uhk6+KLL76QJE2ZMkVnn322JGndunXKzc2VZE+0HxsbK0nau3evSktL1bZt2xBfDdB4GvqdUftnI2OMYmJidNZZZ0mSlixZIkmtby4itDgNrQuXy6X8/Hzt2rVLAwcOlGRPou/1ev0T7O/Zs0der9c/HyTQ3JxMXcyePVvr1q2TJH3729/We++9p23btum9997Thg0b9Mwzz/h/jvJ9n2RlZYX8WsKNb0m0aMevIpORkSHJnjDcV/jjx4/XlClTtGTJEv3973/3r1x25MgRrV27Vt///vfldrv15JNP6oUXXtDPf/5zTZ8+XR6PR3fccYckll9H83IqdfHNN9/UeZ6oqCgdPXpUzz//vCzL0mWXXdbEVwA0vobWxcKFC1VaWqq0tDTddddd6tevn/7973/rpZdekmRPsF9UVKRnn31WX331laZOnaquXbuG9qKARnCq3xnBfjYaMmSIoqKi/CvHtrbV/tBynM7PUkePHlWbNm301ltv6dChQ3K73XK5XCooKNAf//hHLVmyRBMnTmyV4QSat4bWxfvvv++vC8uy1KdPH11yySUBPy8VFBRo3rx56tGjh3r16tXqvjcI7NCiHf+XW1+PuNormqWkpGjSpEnKzMzU/PnztXHjRknSPffco6ysLE2dOlWvvfaaZsyYoV69ekmSJkyYoCuuuELjx48P4dUAjeNU6uKrr74Keh6Px6OlS5dq+vTp+s9//qMf//jHGjZsWNNfBNDITqcubrjhBs2aNUudOnXSb37zG33nO9/RL3/5S91999164IEH1KdPH02cODG0FwQ0ksb4zqgd3lVXV/tXBKSHHZqr0/kdY+DAgbrwwgu1atUqffe739Ubb7yh1157TQ8++KAeeOABpaena9q0aaG9IKARnM73hdvtDjjWGKPly5dr+vTp2rx5s2bMmKHU1NTW970RpqG4QEj45kZZtmyZsSzLXHrppf75IWrPw1VWVmZ+/etfG5fLZZ5//nn/81u2bDEVFRUB5/NNJO67BZqb06kLr9drKisrzY4dO8xLL71kbrvtNtO7d29jWZa57777/OcBmpvT/b7wHTtu3DhjWZaJi4szHTt2NLfffrspLi4O3YUAjex0vzNqq6qqMpZlmV69ejkm2weak9P9zli+fLm57rrrjGVZ/i0mJsZMmTKF7ww0W431fTF79mxz6623moyMDBMVFWVmzpwZ8Dt5a9LK4km0Nr4EfuTIkRo5cqRWrVqlhQsXOvZr06aNRo4cqbZt2+rdd9/1P9+3b1/FxMT4u966XC5/+n/8XwGA5uJ06sKyLEVHR+udd97Rz372My1cuFADBgzQunXr9Nvf/tY//wrQ3Jzu94Xv2H/84x/asWOHVq5cqbVr12rOnDnMXYdm7XS/M2orLCzUww8/rPfff1+pqalN33igiZzud8aIESM0f/58vfjii/rDH/6g2bNna+PGjXr55Zf5zkCz1VjfF5999pk+/vhjDRw4UGvWrNHjjz+umJiY0FxEhLGMYbZ8tA5vvvmmJk2apHHjxmnOnDlKTU2V1+v1f7BUV1dr4MCBOnbsmFatWqVu3bqFucVA0zvVujhw4IA+//xzpaWlafDgwWG8AqDx8X0BBEdtAE6nUhe1XwdaolOpC4/HI7fbrZKSEh04cMC/UFFrxqcEmhVjjD7//HPl5OTo6NGjJ9y3trFjx+rqq6/WokWL9PLLL0uy/wrgW5kpKipKaWlpSkxMZGJwNCvhqIuuXbvqmmuuIaxDxOL7AgiO2gCcQl0XhHVoDkJdF74RbG3btiWs8wnHOFzgVLzyyismIyPDJCUlmdjYWJOVlWX+8pe/mNLSUmNMzZj54+dL2bt3r9m9e7cxxphVq1aZtm3bmpiYGLN48eKA/ZYuXWratm1rbrjhBuPxeBznASIRdQE4URdAcNQG4ERdAE7URWQgsEPEKygoMNOmTTOWZZnLLrvM3HvvvWb69Ommbdu2Jjo62tx9993+yVlrLwRx9OhR884775grr7zS3Hrrrf7JjefNm2csyzJJSUlm1qxZZuXKlebPf/6zueSSS0ynTp3Mxx9/HJbrBBqCugCcqAsgOGoDcKIuACfqIrIQ2CHiLVq0yCQmJpqbbrrJbNmyxf/8v//9b5OVlWUsyzIPPPCAMcZO+Kurq83SpUvNHXfcYZKSkkybNm3MG2+8EXDOV155xZx33nnGsiwTGxtroqKiTGpqqpk/f35Irw04VdQF4ERdAMFRG4ATdQE4UReRhcAOEc3j8ZirrrrKuFwuk5ub63/OGGPKy8vNs88+618KfdWqVcYYY7Zv326uvPJKY1mW+elPfxrQvbb2XwG+/vpr89prr5lnnnnGvPLKK3TDRbNBXQBO1AUQHLUBOFEXgBN1EXmiwj2HHlAXY4x/Ysr27dursrIy4LnY2FilpKQoNjZWFRUV+vnPf64lS5aoT58+mjBhgv70pz8pLS1Nkr0KTVRUlH8iS2OMOnXqpFtuuSWclwg0GHUBOFEXQHDUBuBEXQBO1EVkYnkaRIRDhw6puLhY33zzTcDzZWVl6tKliwoKCpSTkyPLsvwfHJK9kkxCQoISExP16aefavHixZKkyZMnKy0tTR6Px78KTW2WZYXmwoDTQF0ATtQFEBy1AThRF4ATddF8ENghrIqLizVt2jSNGDFC/fv31wUXXKDnnntOxhhZlqX4+HhdeOGFkqTHHntMn3/+uSzLksfj0b/+9S/9/Oc/1+TJk/X73/9ekvTRRx/5z22MkdvtZtl0NDvUBeBEXQDBURuAE3UBOFEXzQ9DYhE2K1as0K233qrCwkJdfPHFiouL06effqof//jHWr9+vR599FF16dJFkyZN0meffaa//OUvuuqqq3TllVeqpKRE69atU1lZmb71rW+pR48eSk5O1tdffy1J8nq9fFigWaIuACfqAgiO2gCcqAvAibpoppp2ijygbnfccYdp06aNmTdvnikpKTHGGLN582Yzbtw4Y1mWuffee83+/fuNMcbk5OSYJ554wnTo0MF07tzZdOjQwVx11VVm8+bNxhhj9uzZY7p162aGDh0atusBGgN1AThRF0Bw1AbgRF0ATtRF80Rgh7DYtGmT6dixo7n88sv9z/lWkVm/fr254oorTHx8vPnDH/4QcNy+ffvMpk2bzFdffRXw/MGDB0379u3N1KlTjTGGVWfQLFEXgBN1AQRHbQBO1AXgRF00X/RbRFjExsbq2LFjOuOMM+T1elVdXe1fRebss8/WzJkzFRsbq3nz5mn9+vWSJI/Ho27duikzM1P9+/cPON+zzz6roqIiXXbZZZKY2BLNE3UBOFEXQHDUBuBEXQBO1EXzRWCHsKioqFCnTp2Um5srl8sVsJKMZVkaNmyYfvjDH2rt2rVatGiRfxLL423evFm/+c1v9MILL+jb3/62rrvuulBeBtCoqAvAiboAgqM2ACfqAnCiLpqxcHbvQ+tVWVlpzjvvPGNZllm6dKkxpqZbrs+6detM9+7dzSWXXOIfT+/z3//+13zve98zQ4YMMS6Xy1x++eUmNzc3ZO0HmgJ1AThRF0Bw1AbgRF0ATtRF80UPO4Scx+NRdHS0br/9dknS888/L0mOFL979+665JJLtHz5ch07dkySvQKNJB08eFCrV69WfHy85s+frw8//FC9evUK4VUAjYu6AJyoCyA4agNwoi4AJ+qimQt3YojWx+PxGGOMKS8vN2eddZaJjY017777rjHGmfTPmjXLWJZl5s2bZ4wJnNAyJycnNA0GQoC6AJyoCyA4agNwoi4AJ+qieaOHHU7bvn37Tmo/Y4wkyeWy/9vFxsbq4YcfVmVlpZ544gkVFxfL7XarurpaVVVVkqSMjAxJduIvBU5o2bt370a7BqCxUReAE3UBBEdtAE7UBeBEXbQuBHY4ZWvXrtWIESN0zz33aM+ePZJqPhiOZ4zxF3xhYaHWr1+v6upqTZo0Sdddd51Wr16te++9V5WVlYqKilJ0dLS+/vprvfrqq0pMTPR/aACRjroAnKgLIDhqA3CiLgAn6qKVCnWXPjR/FRUV5sUXXzTt27c3lmWZrl27mj//+c8nPK6ystIsXbrU3HHHHWbQoEHmb3/7mzHGmAMHDpihQ4cay7LMZZddZt5++23z5ptvmjvuuMPExcWZn/3sZ018RcDpoy4AJ+oCCI7aAJyoC8CJumjdCOzQIOXl5ebll1827dq1M0lJSWb69Ommffv2ZvTo0earr74yxgSOdffJyckxs2bNMr179zaWZZnp06f7x9MbY8yXX35p7r77buN2u41lWcbtdpvY2Fjzi1/8ImA/IBJRF4ATdQEER20ATtQF4ERdgMAODTZlyhQzdOhQs2XLFmOMMffcc49xu93miSeeMJWVlY79KyoqzNNPP+1P8WsvAX38B8KSJUvMggULzJw5c0xeXl7TXgjQiKgLwIm6AIKjNgAn6gJwoi5aN8uYOgY+o9Uztca+S/aS0G63W7t27VJ1dbX69OkjY4xWrFihW2+9VbGxsXrhhRc0atQox7mys7MlScOGDfOfy7Is/ySYx78XEKmoC8CJugCCozYAJ+oCcKIuEAyLTiCoyspKFRcXq6Kiwv+c2+2WJKWnp6tPnz6S7JVjBg8erNtvv12bNm3SW2+9pcLCQkmBk2AOGzYs4APD7Xb7PzB85wEiHXUBOFEXQHDUBuBEXQBO1AXqQmAHh2effVaXXnqpLr74YvXr109PPvmkdu/eLcku+OPFx8fruuuu0wUXXKAFCxbov//9r6S6Pwh8Hz5Ac0JdAE7UBRActQE4UReAE3WB+hDYwW/VqlUaNmyYpk+fruLiYrVt21Yej0cPPPCApk2bJqnugu/Tp4+mTZumgoICvfHGG/4Pmerq6pC1H2gK1AXgRF0AwVEbgBN1AThRFzgpoZosD5Ft6dKlZtCgQaZfv37mhRde8E86uWfPHpOZmWksyzLvvPOOMcY5WaXP3r17zYQJE0ybNm3Mc88953++uLjYHD58uN5jgUhEXQBO1AUQHLUBOFEXgBN1gZNFYAdTWFhoxo0bZxISEsyCBQv8z1dVVRljjHn77beNZVnmnnvuOeG5Fi9ebFJSUszFF19s1q5da/773/+ayZMnm/vuu48PDDQr1AXgRF0AwVEbgBN1AThRF2gIhsS2Ul6v13+/Xbt26ty5s/785z/rpptukmRPWunrgtu9e3dJUvv27f2vHc83vv6yyy7TlClTtGLFCt19992aMGGC5s2bp+jo6ID3BCIRdQE4URdAcNQG4ERdAE7UBU5VVLgbgNA6fPiwOnXq5F8lxrdqzBNPPKGEhAT/frUnrSwqKpIkdezY0fGaj+8D5uuvv1ZlZaWqqqq0fPlyjRgxQosXL9b555/fZNcEnC7qAnCiLoDgqA3AiboAnKgLnC4Cu1Zi//79+tWvfqUvv/xSLpdLgwYN0l133aVBgwZJkjp37lznyjJr166VJJ199tl1nt/r9erDDz/Ub37zG3366adKTU3V008/rQkTJjT+xQCNhLoAnKgLIDhqA3CiLgAn6gKNhSGxLZiv++xf//pXDRgwQB988IESExNVUVGhefPm6fLLL9f8+fMlBU/ufavMLF++XGeccYYyMzMlKWj32qqqKq1cuVLZ2dn6xS9+of379/OBgYhEXQBO1AUQHLUBOFEXgBN1gSYR6knzEFrHjh0z5513nsnMzDQffPCB8Xg8prq62rzxxhsmOjratG3b1nz66afG6/UGPb66utokJyeb8ePHG4/HE7Cf777vdtu2bf4VaYBIRl0ATtQFEBy1AThRF4ATdYHGRg+7Fu7tt9/W2rVrNXnyZF1xxRVyuVyyLEsTJ07U7373O1mWpQcffFBbtmwJevxnn32mgoICXXDBBf5ji4qKtGDBAv9fCHwyMjL8Y+2BSEZdAE7UBRActQE4UReAE3WBxkZg10L5us5WVVVJkgYPHhzwWJK++93v6rbbbtPSpUv11ltvqbS01HH8v//9b0nSpZdeKklaunSpHnroId1yyy267777VFBQUOf4eyDSUBeAE3UBBEdtAE7UBeBEXaCpENi1ENu3b1d+fr6/8H0r0fger1y5UpIUHR3tf619+/a6+eabNXjwYM2bN0+5ubn+85n/G4P/6aefqm/fvjp27JiefPJJ3Xrrrfp//+//6a677tKuXbvUoUOHkF0j0FDUBeBEXQDBURuAE3UBOFEXCJlwjsfF6fvb3/5mRowYYbp162bi4+PNqFGjzF//+lf/69u2bTOWZZkxY8aYAwcOGGNMwFj46upq8+tf/9pYlmV++9vf+p8zxpgjR46Y5ORk06NHDzNy5EhjWZb51re+ZbZv3x7CKwQajroAnKgLIDhqA3CiLgAn6gKhRmDXTO3fv99873vfMy6Xy5x33nnmhhtuMNdff72xLMvExMSYjz76yHi9XlNRUWGuvfZa065dO/P6668HnMP34bF8+XLTvn17M3jw4IDX33vvPWNZlrEsy2RkZJj3338/ZNcHnArqAnCiLoDgqA3AiboAnKgLhAuBXTN04MABc8stt5iOHTuamTNnmk2bNvlfe+qpp0x0dLS55pprjDHGVFZWmjfffNPExcWZ6667zuTm5hpjjPF4PAHnHDJkiOnSpYvZunWr/7n9+/ebzMxM88c//jEEVwWcHuoCcKIugOCoDcCJugCcqAuEE4FdM/Tqq68ay7LMjBkz/F1offLz803fvn1NTEyMvxtuXl6emThxoomJiTH/8z//40/3q6qqTFVVlTHGmG9/+9umW7dupqyszBhT0zXX9zoQ6agLwIm6AIKjNgAn6gJwoi4QTiw60Qz1799fTzzxhJ588km53W7/JJUej0cpKSnq3r27unXr5l9B5swzz9SPfvQjdevWTb/73e/0+uuvS5KioqIUFRWlnJwcrVq1Sr169ZLL5ZLX65Xb7fbvAzQH1AXgRF0AwVEbgBN1AThRFwgn/kc0Q1lZWUpPT5dlWTLG+D8c3G63PB6PcnNzlZCQoMTERP8xo0aN0m9/+1vdeOONmjJlig4fPqyLL75Ye/bs0dy5c1VSUqIf/ehHio2NDddlAaeFugCcqAsgOGoDcKIuACfqAmEVno59aCo7d+40ycnJ5tZbbzXGOMfLv/DCC2bw4MHGsizTpk0b06ZNGxMfH29+//vfh76xQIhQF4ATdQEER20ATtQF4ERdoKnRw66F8Hq9crlcWr9+vQoKCjR8+PCA532mTp2qm2++Wa+//rqKi4vldrs1ZcoUdezYMVxNB5oMdQE4URdAcNQG4ERdAE7UBUKFwK6F8H0wLFmyRDExMRo6dKikmnHwFRUVioqKktvtVrt27fSjH/0obG0FQoW6AJyoCyA4agNwoi4AJ+oCoWIZ83+zJqLZq66u1rBhw1RWVqbNmzdLkiorK7Vs2TKtXLlSo0eP1ogRI8LcSiC0qAvAiboAgqM2ACfqAnCiLhAK9LBrQbZu3aqcnBxNmTJFkrR27VotWrRIL774ovbt26eFCxeGuYVA6FEXgBN1AQRHbQBO1AXgRF0gFAjsWgDzf6vVrFmzRqWlperYsaPmzZunP/7xj1qzZo2uueYaLV26VOnp6eFuKhAy1AXgRF0AwVEbgBN1AThRFwglArsWwLe09CeffCKv16vFixdrzZo16t27tz7++GONGTMmzC0EQo+6AJyoCyA4agNwoi4AJ+oCoeQ68S5oDsrLy7Vnzx5Jdvfc2bNna9OmTXxgoFWjLgAn6gIIjtoAnKgLwIm6QKiw6EQL8swzz+jIkSP65S9/qdjY2HA3B4gI1AXgRF0AwVEbgBN1AThRFwgFArsWxDeeHkAN6gJwoi6A4KgNwIm6AJyoC4QCgR0AAAAAAAAQQZjDDgAAAAAAAIggBHYAAAAAAABABCGwAwAAAAAAACIIgR0AAAAAAAAQQQjsAAAAAAAAgAhCYAcAAAAAAABEEAI7AAAAAAAAIIIQ2AEAAAAAAAARhMAOAAAAAAAAiCAEdgAAAAAAAEAEIbADAAAAAAAAIsj/B+FxQxyFcwkGAAAAAElFTkSuQmCC\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "display.Image('local_cli_edu_humboldt_tdp.csv_salt.png')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "adaf8a2c-8b85-47df-8256-306ecc94aa16",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "display.Image('local_cli_bodega-bay-bml_wts.nc_salt.png')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "61ef1543-af4a-4059-b4a8-543a2a8b3ffd",
-   "metadata": {},
-   "source": [
-    "### Nonlocal workflow: stations"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "6211707b-d967-4bdd-8139-0f310fa7f489",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "config_file = 'config_nonlocal.yaml'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "21e4899d-45df-4ffe-9ba3-f5da34894913",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# %load config_nonlocal.yaml\n",
-    "---\n",
-    "approach: \"stations\"\n",
-    "loc_model: \"https://thredds.cencoos.org/thredds/dodsC/CENCOOS_CA_ROMS_FCST.nc\"\n",
-    "axds:\n",
-    "bbox:\n",
-    "criteria:\n",
-    "  salt:\n",
-    "    name:\n",
-    "      \"sea_water_practical_salinity$\"\n",
-    "erddap:\n",
-    "  known_server:\n",
-    "    \"ioos\"\n",
-    "figname_map: \"nonlocal_cli.png\"\n",
-    "figname_data_prefix: \"nonlocal_cli_\"\n",
-    "local:\n",
-    "only_search: false\n",
-    "only_searchplot: false\n",
-    "parallel: true\n",
-    "readers:\n",
-    "  - \"erddap\"\n",
-    "run_qc: false\n",
-    "skip_units: true\n",
-    "stations:\n",
-    "  - \"edu_humboldt_tdp\"\n",
-    "  - \"bodega-bay-bml_wts\"\n",
-    "time_range:\n",
-    "  - \"2021-9-1\"\n",
-    "  - \"2021-9-8\"\n",
-    "var_def:\n",
-    "  salt:\n",
-    "    units: \"psu\"\n",
-    "    fail_span:\n",
-    "      - -10\n",
-    "      - 60\n",
-    "    suspect_span:\n",
-    "      - -1\n",
-    "      - 45\n",
-    "variables:\n",
-    "  - \"salt\"\n",
-    "xarray_kwargs:\n",
-    "  chunks:\n",
-    "    time:\n",
-    "      1\n",
-    "    depth:\n",
-    "      1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "043027af-3c10-4409-82d7-40aafb1a0e0c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!python ../ocean_model_skill_assessor/CLI.py $config_file"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "5fe74744-4c9c-47d2-8d78-b7538bc4cd9e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "display.Image(\"nonlocal_cli.png\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "71277ce0-9c23-46e3-9b89-fa5bfe989b23",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABOwAAAHVCAYAAABCCGRHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAADFd0lEQVR4nOzdd1QU19sH8O/SOwgWFGkqNmwo9oqxJUZ97USjgok9ltgSTSwxRmOMsSX2CGiMLWrsXTFqFCt2NCAoVqSDdPa+f3B2fq67wC4ssur3c84e2Lkzd57Z2Z2dfebOvTIhhAARERERERERERHpBYPSDoCIiIiIiIiIiIj+hwk7IiIiIiIiIiIiPcKEHRERERERERERkR5hwo6IiIiIiIiIiEiPMGFHRERERERERESkR5iwIyIiIiIiIiIi0iNM2BEREREREREREekRJuyIiIiIiIiIiIj0CBN2REREREREREREeoQJO6K3QHBwMGQyGdq1a/derVuX/Pz8IJPJEBgY+EbW165dO8hkMgQHB2u13OzZsyGTyTB79uwSiUuX3NzcIJPJEBUVVapxREVFQSaTwc3NTetl9WUbiN5178p3CREREdGbwoQdEdFbIDQ0FLNnz8bff/+tk/r+/vtvzJ49G6GhoTqpj/TTnTt3MHDgQFSsWBFmZmaoWrUqJk+ejMTERJ3Vb2JiAplMhmrVqumkTsrfuXPn0KNHD5QrVw7m5uaoXbs2vv/+e2RkZBSr3qNHj6J3796oVKkSTE1N4ejoiHbt2mHhwoU6ivzdIZfLsWzZMnh5ecHS0hL29vbo0KEDDh48WKT6bt++jV9//RWDBw9GzZo1YWBgAJlMhj/++EPHkZMu911ubi4OHz6MsWPHomHDhrC2toapqSlcXV0xePBgXLlypQS2gF53//59jBo1CtWqVYOZmRnMzc1Rq1YtTJw4Ec+ePStw2QMHDqBDhw6wt7eHpaUlGjZsiOXLl0MulxcplqSkJMycORN16tSBhYUF7Ozs0KZNG2zevLlI9VHx/PHHH2jRogVsbW1hY2ODFi1aYNOmTTqr/9tvv4VMJoNMJsPcuXN1Vi+RCkFEeu/kyZMCgGjbtu17tW5dGjJkiAAgAgIC3sj62rZtKwCIkydParXcrFmzBAAxa9YspekBAQECgBgyZIhO4tPF6+Hq6ioAiMjISJ3EVFSRkZECgHB1ddV62fbt24saNWqIR48e6T6wUnbixAlhbm4uAIhy5cqJhg0bCgsLCwFAVKlSRTx79qxY9cvlctG6dWsBQAAQVatW1VHkpM4ff/whDA0NBQDh5OQkvLy8hLGxsQAgGjduLF6+fKl1nXK5XIwcOVLah5UrVxaNGzcWbm5uwsjISDg4OOgs/pCQEFGjRg0xaNAgndX5puXk5IiuXbsKAMLAwEDUq1dPuLu7S6/fwoULta6zR48e0vKvPjZu3FgCW/D+0vW+W7dunbSskZGRqF27tqhfv750zDUyMhKrV68uoa0hIYQ4c+aMsLS0FACEmZmZqFOnjqhRo4Z0XCxbtqy4deuW2mXnz58v7b8qVaqIevXqCQMDAwFAdO/eXeTm5moVy6NHj4SHh4cAIAwNDUX9+vVF7dq1hUwmEwDEyJEjdbHJpKERI0ZI+7dmzZqiVq1a0vMxY8YUu/7bt28LExMTqc7vv/9eB1ETqccWdkRE9N46fvw4wsLC4OTkVNqh6FRKSgr69++P9PR0jBs3Do8fP8bly5fx8OFDtGzZEvfv38dnn31WrHX8/vvvOH36NLp3766jqCk/UVFR+Oyzz5Cbm4uffvoJ0dHRuHLlCv777z/UqFEDFy9exNSpU7Wu95tvvsGqVatQp04dXLhwAdHR0bhw4QIiIyMRFxeHgIAAnW1DkyZNEBYWhg0bNuiszjdt4cKF2L9/PypUqIArV67g2rVruH//PjZt2gQDAwNMnToVFy9e1KpOJycn9O7dGz/++CNOnDiBZs2alVD07zdd7zshBBo2bIiNGzciMTERt27dQmhoKJ49ewY/Pz/k5ORg9OjRuH79eglu1ftLCAE/Pz+8fPkSPXv2xOPHj3Hjxg2EhYUhPDwczZo1Q2xsLEaPHq2y7Llz5zB9+nQYGBjgzz//REREBK5du4YrV66gQoUK2LNnD3755Ret4hk0aBD+++8/eHp6Ijw8HKGhobh16xauXr2KSpUqYdWqVdi4caOuNp8KsGXLFqxevRqWlpY4fvw47ty5g9u3b+PYsWOwtLTEb7/9hr/++qvI9QshMGLECBgbG6N9+/Y6jJwoH6WcMCQiDbCFXfGxhZ0ytrB7t/30008CgKhVq5bIyclRKnvw4IEwMjISAMTly5eLVH9MTIywt7cXdevWFUePHmULuxI2evRoAUB06tRJpezs2bMCgDA2Ntaq1eSNGzeEoaGhKFeunHj+/Lkuw30nZWZmijJlyggA4s8//1QpHzZsmNQ6pzgU3x1sYac7JbHv4uPjhVwuV1uWnZ0t6tSpIwCIcePGFTluyl9YWJjUWjIhIUGlPDQ0VAAQMplMpfXxRx99JACI4cOHqyy3adMmAUA4ODiIrKwsjWJRrAuAOHfunEr5li1bpJZ8VPI8PT0FADFv3jyVsh9++EEAEPXq1Sty/WvXrhUAxIIFC6Rzabawo5LEFnZEJSAnJwerVq1Cq1atYGdnBzMzM9SsWRPffvstkpOT811u165daNGiBSwtLeHg4ICPP/4Yly5dynf+wMBAyGQy+Pn5qS3XdSffcrkcS5cuRZ06dWBmZoYKFSrgs88+w4sXL3QW26vTc3NzsWDBAtSqVQvm5uZwc3PD7NmzkZOTAwBIT0/HjBkzpL5Lqlatip9++glCiAK34969e+jfvz/Kly8Pc3NzeHl5Yf369QUus3//fnTp0gVly5aFqakp3N3dMXr0aERHRxe4nDo5OTn46aefULNmTZiZmcHJyQnDhg3D8+fP1c7v5uYGf39/AEBQUJDUZ0ZR9q1igIagoCAAgL+/v1J9rw928eDBA3z66acoX748LCwsUK9ePfz2228FvsavDuRw+PBhtGvXTupDpGPHjjh9+rRWMWtDCIHly5ejbt26sLCwQPny5TFo0CA8fPiw0Fhf9ezZMyxfvhydO3eGm5sbzMzMUKZMGbRt27bAq+Q3b97EwIED4ezsDBMTE9jZ2cHDwwMDBgzAoUOHdLmpBdq5cyeAvMFWDA0NlcpcXFzQoUMHACjyVeYvv/wSCQkJWLlyJYyMjIoXbCHi4+Mxa9YseHl5wcbGBlZWVqhVqxZGjhyJq1evqswfFxeHqVOnokaNGjA3N0eZMmXQrl07bNq0Se379tVj1cuXLzF9+nRUr14dZmZm0ufr1cFgXrx4gS+++AJubm4wNjbO9xinK0II7Nq1CwDUtops0aIFatasiezsbOzevVvjen/99Vfk5uZi/PjxKF++vM7izU9h30cPHz7EqFGj4O7uDlNTU5QtWxYffvhhvv2LpaenY/PmzfD19UWNGjVgZWUFKysrNGjQAHPnzsXLly91Gv/JkyeRkJAAGxsb9OnTR6VcsW8OHz6MlJQUna5bl14dEOn69evo0aMHypYtCxsbG3To0EHpnOP06dPo0qUL7O3tYW1tja5duyIsLExtvUU59oWFhWHo0KFwc3ODqakpHBwc0LVrV5w4cUKn21wS+65MmTKQyWRqy4yMjKSWN/fu3Sti1Kr0Yd8JIbBhwwa0adMGdnZ2MDExgaOjIxo1aoSpU6fi0aNHOtvegqSnpwMA7O3tYWdnp1JetWpVKV7FOSMAJCcn49ixYwDUH0/79u0LGxsbxMXF4eTJkxrFcvbsWQBA5cqV1baQ7dmzJwwMDHD//n1cvnxZozoLo8l30quDrSnO5SpUqAArKys0b94cR48eleq7ceMGevfuLZ3rtWnTBufPn1e77gcPHmDEiBGoUqUKTE1NYW1tjSpVqqBnz57YsmWL2mUePXqEcePGoXr16jA3N4ednR18fHyK1dJNnbt37+LWrVsAgKFDh6qUK6Zdv369SJ/NFy9e4KuvvkLt2rXx5ZdfFi9YIk2VYrKQ6J2UlJQk2rRpI135c3V1FXXq1JH6OqhVq5ba1gwLFiyQrtBVrFhRNGrUSFhZWQlTU1Px/fffq23lVlirK120jnu1jgEDBggAwsPDQ3h6ekqtdDw9PUVGRoZOYnt1eu/evaXXrEaNGlJfIP7+/iI9PV00bdpUGBoainr16gk3Nzfp9Zs5c6bK+hRXwaZPny5sbW2FqampaNiwodRKDIAYO3as2li//vprpT6eGjVqJPUFVqZMGXHx4kWVZfJrYZeTkyO6desm1Ve9enVRv359YWhoKFxcXMQXX3yh0sKuT58+Ut8o5cuXFy1btpQeX3zxhdqY8/P06VPRsmVLUb58eWlfvlrf77//Ls17+/Zt4eDgIPUP06hRI+Hi4iIAiNGjR+fbwk4xff78+UImkwl7e3vh7e0t1WVgYCC2bdumEpuipZy6Ogvyagu7UaNGCQDCxcVFNGrUSJiZmUl9uIWFhaksm982KD5z5ubmomrVqsLb21vaduTTH01ISIjUf5Gtra2oX7++qFOnjrC1tRUARI8ePfJdvy5bfmZnZ0t9+Jw5c0btPIrta9++vdb1K1rU+fv7CyH+95ktiRZ2oaGholKlStL7pnbt2qJBgwbCxsZG7fHlv//+E87OzgKAMDExEQ0bNhRVqlSR9tvgwYNVWsUojlX9+vUTDRs2FDKZTNSqVUt4eXlJLdoULV9Hjx4tXFxcpONOvXr1xNChQ6W6FOvRtmVtQaKioqR68+tr8bPPPhMAlGIpjOJ1DQ0NFZcvXxajR48WHTp0EN27dxc//PCDzlvdFfR9dP78eWFnZycACEtLS9GoUSNRuXJlabtnzJihsszp06elvsIqV64svL29hYeHh/S91LBhQ5GWlpZvHNqeAs+ePVsAEB06dFBbnp2dLR1v/vnnH63qflVJt7BT1P/jjz8Kc3NzYWdnJxo1aiQdp6ytrcXNmzfFtm3bhJGRkShfvrxS/5flypVTaclZlGPf1q1bpfMia2tr0aBBA+Ho6Ci1ilq2bJnKMvq+7141fPhwAUD07NlTJ/UJoR/7btKkSdI+cHFxEY0bNxbu7u7Svty1a5fS/EXdZ4VJTU2V4r53755K+aFDhwQAUaNGDaXpwcHB0jlNdna22ro/+OADAUDMmTNHo1jmzp0rAIimTZvmO4/inOvXX3/VqM7CaPKdpDjvnTlzpihbtqx0bC1btqx07Dx+/Lg4ffq0sLS0VHk/WVhYiJs3byqtNzIyUlrewsJC1K1bVzRo0EDY29sLAKJ+/foqsQYHB0t1mpubi7p160rf0wDEpEmTVJYp6vlgYGCgACCqVauW7zxVq1YVAMSGDRs0rldh4MCBAoAIDg4WQgi2sKM3ggk7Ih3z9fUVAMQHH3wgIiIipOnx8fGiV69eAoDo06eP0jJXrlwRhoaGQiaTiV9//VX6QZmSkiL69+8v/fguzYSdsbGxqFSpkggJCZHK7t69K/2oWrlypU5ie3V9lStXFlevXpXKgoODhYmJiZDJZKJ79+6ibt26Sq+x4lYGU1NTER8fr1Sv4kvVyMhI+Pj4iJiYGKls+/bt0mu8b98+peX27t0rLffHH39I05OSkkTPnj0FAOHm5qbywzC/hN3SpUulRN/p06el6ZGRkaJOnTpSHKV9S6xcLhcNGzYUAETnzp1FXFycVLZ582ZhbGws/TDOL2FnZGQkJk6cKN1Wkp2dLaZOnSoACBsbG/HkyROl5YqbsDMyMhLGxsZi8+bNUllsbKzo0KGDACCaNGmikqzJL2F3+vRpceLECZXbSa9duyZ1Xqw4YVP4+OOPBZCXFM7MzFQqu3jxoti0aZNK7CWRsPvvv/+k1/H111hB8VlxdnbWqu709HRRrVo1UaZMGekzVFIJu6SkJClJ2qVLFxEdHa1U/s8//yh9JuVyufD29paOK6/+MD148KDUOfmKFSuU6lF8tgwNDUX16tXF7du3lbZXiP/9ODI0NBTNmzdXikUxjxAlk7BTJEhNTU3zvQVPcZtP69atNarz6dOnUmJk8eLF0mAWrz5sbGzE0aNHdbYd+R3zX758Ke3nfv36ieTkZKksMDBQiu3AgQNKy0VFRYlt27aJlJQUlW3r06ePACBmz56dbxzaJhAUP9TU3UanoLiw8uqFD229qYSdsbGxmDhxonSsysjIkAbAaNeunbCzsxOLFi2SOt9PSEgQTZo0EQDE1KlTlerU9th37do1YWpqKszMzMSaNWuUOvjfs2ePsLGxEYaGhiI0NFRpOX3fdwrp6elS8vHnn38udn0Kpb3vYmJihIGBgbC1tVW5GJSeni42b94srl27pjS9pBJ2QggxZ84cAUDUrl1bHDlyRCQlJYnY2Fixfft2UalSJWFsbCz279+vtIzidsbq1avnW6/iFmlNB8hZvny5APIu6KqTmZkpDWiR34VhbWnynaQ4zzM2Nha+vr7SsTU3N1fqZqF+/frCzc1N5f2kuLDcr18/pfUqLioPGTJE5dh7584dlYFWHj9+LOzt7YVMJhPz5s1Turh/9uxZ4eTkJACIvXv3Ki1X1PPBb775RgDqu49Q6NixowDUXwgqyLFjxwQA8emnn0rTmLCjN4EJOyIdunbtmgDyWvq8+qND4eXLl8LZ2VnIZDIRFRUlTf/0008FANG3b1+VZdLT06Urc6WZsAMgduzYoVK+bNkyAaj2/VLchJ26K7VCCPHJJ59IPzSvXLmiUt6sWTMBQOzcuVNpuuJL1dTUVDx9+lRluYkTJwoAok2bNkrTW7ZsKQCI8ePHqyzz8uVL6Urj6yf56hJ2crlc+mH622+/qdR3+fJladtLO2GnODExNzcXL168UCkfN25cvidTiiSUuiutQggpEfh6S8jo6Gjh5OQknJycVJIzBXn1xE5df0HPnz+XWk+cOHFCbazanBAqXpthw4YpTa9Ro4YAIJKSkjSuq1mzZsLJyUlti8OiunDhgvR6vJpMetWBAwcEAGFlZaVV3YqT4VWrVknTSiph92o/fK+34FXn1cSWus+4oj5XV1elxJfiswXk36ef4seRqampePz4cb4xKN6///77rwZbqJlt27YJAKJChQr5zrNixQoBQNSpU0ejOq9cuSKAvFaLBgYGonnz5uLKlSsiMzNT3Lp1S/pBY2NjIx4+fKiT7cjvmK/4AV2hQgW171fFD0tNk5FCCJGWliZMTEyEh4eHStm///4r7SdtKPq9+uqrr/KdR5EUKU6S5k0l7Ly8vFQSwHfv3pU+C+paxSlaLb3e/5O2xz7FxculS5eqLVckQF5vMarv+05h2rRpAoCwt7dX279aUZX2vjt37pwAtGs1WNR9pqnVq1eLatWqqVxwaNOmjdr+5BTfAwW1hlNcWPz44481iuH8+fPSel+9qK2wdetWqfzVZE9xaPKdpDjPq1ixoko/fomJidJ5kbr3k6KPQBsbG6XpnTt3FgBUErP5UZxbf/nll2rLFRfFX2/tX9TzQcX3Rf/+/fOdp1+/fgKAVneoKC5W2traKl0MZMKO3gT2YUekQ4p+hvr16wdra2uVcgsLC3To0AFCCKV+vI4cOQIAGDVqlMoyZmZmavtheNPKlCmDXr16qUxv3LgxAOD+/fs6XZ+9vT3+7//+T2V6gwYNAABeXl7w8vJSKVdMyy+eXr16wdHRUWW6YiSxs2fPSn0fpaam4ty5cwCAsWPHqixjYWGBYcOGAfjfPizInTt38PDhQ5iZmant96phw4Z6M0Lg4cOHAeT151K2bFmVcnUjr2k6j2K6Yh0KlStXxqNHj/Do0SNUrlxZ25ABAGPGjFGZVr58eanfotfXWZCUlBSsXbsWQ4YMQadOndC6dWu0atUKX3/9NQDg2rVrSvM7OzsDALZt26bxOs6dO4dHjx6hb9++Gi9TmIyMDOl/ExMTtfOYmpoC+F8/QJq4c+cOFi5ciCZNmkjv+5Kk6I9t/PjxUrwFUXwG+/btq/YzPnLkSJiamuLBgwe4e/euSrmnpycaNmxY4Do6dOiASpUq5VuueP82b9680Hg1pdif+e1LQPv9qTjGyeVyWFlZYf/+/fDy8oKJiQlq166N3bt3o1KlSkhOTsaSJUuKtwGFUOy3YcOGwczMTKV8/PjxAIB///1XpV86uVyO3bt3Y8yYMfjwww+lz2jHjh0hk8nw33//IS0tTWmZ5s2bS/tJGyWxH0qTov/SV1WvXh0WFhYA1Pfvld/3qzbHvqysLBw4cACGhob59v+oGHn61KlTStPfhn23f/9+/PjjjwCAVatWqe1frbhKa98p5g0JCcm3X9jXFXWfaSIrKwuRkZFITEyUjl3VqlWDoaEhzp8/j3Xr1qnsz5J4LzRt2hSNGjUCkNdv3Kt9o4WEhCj1dabrY0Nh30kA8Mknn0jvDQVbW1u4u7sDUP9+UvQBm5ycjLi4OGm64j3w119/FdpfNPC//nQ///xzteVdunSBiYkJ/v33X6W+Bot6PlhSn/W5c+ciPDwcP/zwAypUqKDxckS6ULI9RRO9Z27cuAEgL3H377//qp3nwYMHAIDHjx8DABITExETEwMAqFWrltpl8pv+Jik68H2dorPy1NTUN7K+cuXKaVSeXzz5vZaKznMzMzMRERGBevXqITw8HHK5HKampqhSpYra5Tw9PQFo1rG0Yh5XV1eVk6dX48uvo983SRFrfq+Xh4cHjIyMlE6wXlfY+1mXnXEDgLGxMapVq6aTdV69ehUff/wxnjx5ku888fHxSs8nTJiAY8eOYdiwYVi0aBE6d+6MVq1awcfHBw4ODhpuRfG9mvTIyspSmwTJzMwEAJibm2tUpxACI0aMQE5ODlasWAEDg5K/3nfnzh0A0DiJrdi3tWvXVltubW0NZ2dnhIeH4969e6hZs6ZSuSbH2dI4Fiv2X1ZWVr7zaLs/X31PDB48GGXKlFEqNzc3x8iRIzFz5kwcOnQIixYt0jZsjRW23zw8PGBiYoKsrCzp2AzkfXd+9NFH0kWV/CQkJOR7vNVGSeyH0pTfd2jZsmXx8OFDteX5fb9qc+y7d+8eMjIyYGJigo8++khtDIpEgOI8qbje1L67dOkSfH19IYTAtGnTdHoh5lWlte+cnJzQt29fbN++HdWqVYOPjw/atWuH1q1bo1mzZiU+ANHrunfvjsOHD6NHjx5Yu3attI2RkZEYMGAAfv/9dzx9+hT79++Xlimp98KmTZvQrl073LlzB7Vq1UK1atWQlZWFqKgo2NnZoVu3bti7dy+srKyKsqn50uQ7qaDz5Tt37hRY/vDhQ6SmpkrvhTFjxiAoKAjff/89NmzYgC5duqB169bw8fFRSRympqZKA3oNHz68wBgzMjIQFxdX7GRYSexfxcXKhg0bqm1YQVTSmLAj0qGkpCQAQHh4OMLDwwucV3Fl59WTJ8XJxuv04WqOpaWl2umKH+6aXGnTRn4/sBRXAQsrzy+e/EZDlMlkKFeuHB49eiSNEqfYN+XKlct3NDjFvtFkZLlX68uPPuxroPBYDQwMULZsWTx79izfOvJ7rbV5zbTh4OCQbyJJm3Xm5uaiX79+ePLkCT766CN89dVX8PT0hJ2dHQwNDREeHg4PDw9kZ2crLde1a1fs378fP/zwA86fP4+wsDAsXboURkZG6NmzJxYvXgwnJ6dib+fYsWPVjo76119/wdHRUSn5kpCQgIoVK6rMm5CQAAAqiZr8bNiwAadPn8aYMWOklgQlTTGitqYtVBTv2YJGPK1QoQLCw8PVvg/yO8ZpO4+2+vbti6dPn6pMP3PmDID/7aPExEQIIdQei7Tdn6/O93riUkHxQ/D1EZR1rbD9pjg2P378WGm/TZw4EefOnUONGjUwb948NGvWDGXLlpVaVlSuXBmPHz9W+ZwWleI1U7zW6mi7H0pTUb5j8/se1ObYpzhPysrKkkbXzM+rrYWL403suzt37uDDDz9Eamoqhg8fjnnz5hWpHk2U1r4D8r4LateujXXr1uHIkSNSC9ly5cph6tSpmDhxYrEv6Dx79kztaL5eXl5Yvnw5AGDPnj04fPgwypUrh40bNyrd1eLu7o4tW7bAw8MDBw4cwLlz56RWzyX1XqhRowauXr2KH3/8EXv37kVUVBRsbW0xcOBAfP/995gxYwYAqG39XRyafCfp8ny6QYMG+OeffzBr1iycOHECq1evxurVqyGTydCxY0csWbJE+u5QfNYBFPpZB3TT+rAk9u/o0aORk5ODlStXvpGLlUSvY8KOSIcUV87Wrl2bb/Pv/JYB8oYLV/dlrmiB97rCklOv3z70JulrbC9evFA7XQghlSlO/BT75sWLF/n+UH7+/LnSMgV5tb785Lev37TCYpXL5Uq3Sajz4sUL1KhRQ2W6Yhs1ec20ERcXB7lcrvaESpt1XrhwAeHh4XB1dcXOnTtVbseMjo7Od9mPPvoIH330EeLj43H69GkcP34cmzdvxvbt2xEeHo6QkBAYGxtruWXKbty4ofbkV/Hj1s3NDcbGxsjOzsb9+/fVJuwUt0V5eHhotE5FgnDz5s3466+/lMoUV7KjoqKk49fOnTvRokULDbdIPWtrayQkJCAxMRGurq6Fzq94zxb0GdLm8/qmXLx4UWp5rY5iH2VmZuLJkydqk77a7k83NzepRXF+txsrpufm5mpUZ1EVtt/UHZtzcnKkW/h2796tcpzJyckp8GJCUShe2/y6W8jJyZFuE9R0P7xLND32Kfa3k5NTidwmqU5J77uoqCh07NgRsbGx8PX1xcqVK4sebCnQ5nvLzMwMs2fPxuzZsxEWFoZ//vkH+/btw/79+zFlyhQAwOTJk4sVT0ZGhtrvuFdb8CkuaDRp0kTt8dzV1RUeHh64ffs2Ll26JCXsFPv34cOHyMnJUdsqUNvjqYKjoyOWLFmithuBS5cuAcAbu+BVkpo1a4bDhw8jNTUVZ8+excmTJ/Hnn3/iyJEj6NixI27evAk7Ozul3zdZWVnFPvfRRGGf9VfLtDn/kclk0q36r1IkJRcsWIBff/0Vzs7OuHjxorZhExWIaWIiHVLc0nPz5k2Nl7Gzs5NaFoSFhamdR3Fr2OsUV9byS6oU1sqvJOlrbPm9lpGRkcjMzISBgYF0e0C1atVgYGCAzMzMfL/8b926BSCv/5jCKOZ5+PChSr9KhcWX39XxoiqsPkWs+b0nw8PDC225kt+2KKZr8pppIzs7GxEREcVep6JFUaNGjdQmM17vu04de3t79OjRA8uWLcPNmzdha2uLq1evSiftxREcHAyRN2iU0sPNzQ1A3o8aRV9s+V3VVkxv2rSpVuuOj4/H8+fPlR6Kq9W5ubnStIJuR9GU4nZzTW8RV+zb27dvqy1PSUmRkq26fu8VR1RUlNr9qeDi4iIlQnW1Pw0NDQvtf1QxXRetQgtS2H7777//kJWVBUNDQ+nY/OLFC7x8+RL29vZqLwrcvHlT54lGxWt74cIFtce+y5cvIzMzEyYmJlJfq++jwo59Hh4eMDY2xtOnT1W6FSgpJbnvnj17hg4dOuDx48f4+OOPsWHDhre2FY6231s1a9bE8OHDsWfPHqxYsQJA3gXr4nJzc1N7TAwODpbm0aS1vOI4+mpLTS8vLxgbGyMjIwNXrlxRWSY7O1tKuGj7/ZifW7du4e7duzAzM0OHDh10Uqc+sLKyQufOnfHjjz8iLCwMVatWxePHj3Hw4EEAef3kKW6TVZwrlzTFPgsPD5cu0L3q2bNn0nmiNvv31fObVx+K91ZqaiqeP39e4AV5oqJ6O79RiPRUz549AQB//PFHoa2PXtWxY0cAeR0Uvy4zMxPr169Xu5yiX7XQ0FCVvsTkcjkCAgI0jkHX9DW2HTt2qP0SV5xstmzZUko2WllZSa2EFLdhvCo9PR3r1q0DAHTu3LnQddesWRPOzs5IT0/Hhg0bVMpDQ0Pz7Y9J0deGrjosLqy+Tp06AQC2b9+u9r2seL0Kkt88iumKdeiSunW+ePEC27dv13iditdG3fskOztb6074K1SoIHXuXFCfeLqkGCAmMDBQJXHx8OFDHDt2DADQu3dvjepbsmSJ2h9QQgicPHkSQF4/OYpp7dq1K/Y2KAadWb58uUYJQMVncPv27WpbV61evRqZmZlwdXVVm+TRVzKZTPpu+f3331XK//33X4SFhcHY2FhtC4D89OvXD0Beq0l1SYygoCAAQPv27YsStsYU+23t2rVqb4FctmwZAOVjs+IzmpycrPYY9tNPP+k8Th8fH5QpUwbJyckqrUyB/+2bzp0761ULztKk7thnYWGBzp07Qy6XS/u2pJXUvouPj0fHjh0REREBHx8fbN++/Y20InoTtP3eUvQ1+qa+4xStoy5cuKA2effgwQP8999/AJQv0NjY2EhJM3XH0+3btyM5ORkODg46+R5T9GcIAAMHDnwrbpcvCgsLC9StWxeA8ntAcS5S0oMXKdSsWVO6JVfdbyfFtLp162p84U7RHYW6x5AhQwAA33//PYQQJd6FBL2nSmLoWaL3mWK4cC8vL3HlyhWlspycHHHy5EkxYMAAkZGRIU2/dOmSMDAwEDKZTKxcuVIaXj01NVUMGDBAGBsbCwCibdu2KvVVqlRJABDTp0+XlktPTxdjx47NdzltnDx5ssA6IiMjBQDh6uqqk9gKW19AQIAAIIYMGaK2XDHU/axZs5SmK4ZeNzIyEh988IF48eKFVLZz505hYmIiAIg9e/YoLacYct7Y2Fhs2rRJmp6cnCz69OkjAAg3NzeRlpamtFzbtm0FAHHy5Eml6YsXLxYAhL29vTh79qw0PSoqStSrV096XV6P/+LFiwKAcHd3Fy9fvlS77dpYuHChACB8fX2lffMquVwuvLy8BADx4Ycfivj4eKls69atwsTERBgZGQkAIjIyUmlZV1dX6bWeMmWKyMrKEkIIkZ2dLaZNmyYACGtra/H48WOl5aKjo4Wrq6twdXUV0dHRGm+L4j1oZGQkTExMxLZt26SyuLg40alTJwFAeHt7q2yrItZXt+Hp06fStgUFBUnTExMTRd++fYWZmZna93z//v3Fvn37RGZmptL07du3C0NDQyGTyURERIRSWcuWLYWrq6vYvn27xturiaSkJFG2bFkBQIwbN07aB7GxsaJly5bSfn3duXPnpH2gKcVntmrVqroKXwiR9xlT7J+uXbuKR48eKZWfPn1a/PHHH9JzuVwuGjduLACIdu3aiefPn0tlhw8fFlZWVgKAWLlypVI9hR1ThMj/uPI6xWt37tw5zTdUA/fv35eOUT/99JP0Po6KihI1atQQAMSoUaNUltu+fbtwdXUVLVu2VClLS0sTzs7O0rKK921OTo6YPn26ACBMTEzErVu3dLIN+R3bX758KVxcXAQA0b9/f5GSkiKVbdy4UfosHjhwQGk5T09PAUCMGDFCKfYff/xRGBgYSK/X68enorzHFX744QcBQDg6OorQ0FBp+qZNm6Tv8PPnz6ss179/f+Hq6ioWL15c6DoU3x0bN27UOj5N5PfdpKDumPgqAOL1nw/aHvuuXr0qTE1NhaGhoZg/f77K9+eTJ0/EkiVLVD6r+rTvUlNTRbNmzQQA0bRpU6X3bUkp7X137NgxMXnyZJVjQkpKihg4cKAAINq0aaNUVpx9VpAHDx5In/EePXqImJgYqez+/fvSvqlQoYLKOdOZM2eETCYTBgYG4s8//5Smh4aGigoVKggAYsGCBSrrXLx4sXB1dRX9+/dXKTt9+rQ4duyY0jlGbGysdO5ZoUIFpfPO4tLkO0mx7oCAALXlRXk/jRw5UmzZskXlNT116pSwtrYWAMSJEyek6dHR0cLe3l4AEF9++aVISEhQWi4uLk78/vvv4vvvv1eaXtTzQSHyPtMAhKWlpTh+/Lg0/fjx48LS0lIAEFu3blVZbtKkScLV1VVMmjRJ43UpXuPX4yfSJSbsiHQsJSVFdOzYUToxcnFxEU2bNhV169YV5ubm0vT09HSl5ebNmyeVVapUSXh7ewtra2thamoqvv/++3yTWBs3bpSWK1eunPD29hY2NjbCyspK/Pzzz6WWsCtqbCWdsJs2bZqwtbUVZmZmolGjRsLNzU2KcfTo0Wrr/Prrr6V5nJ2dhbe3t/SlX6ZMGXHhwgWVZfI7EcrJyREfffSRVF/NmjVFgwYNhJGRkXBxcRFffPGF2vhzc3OFh4eHACAcHBxE8+bNRdu2bcX48ePVxlyY8PBw6WTX1dVVtG7dWrRt21bpxO7mzZvSiZa5ubnw9vaWTuBGjx6d748DxfT58+cLmUwmHBwcROPGjaUEkoGBgdi8ebNKTIr3UkE/ONR59T04atQo6X9vb2/pM+fg4CBu376tsmx+2zB58mSlz3CjRo2Eubm5MDY2FitXrlT7nre1tRUAhKmpqahTp45o3LixqFixolTPjBkz8l1/fifUxXHs2DEpuViuXDnRqFEjYWFhISWZnz59qrKM4vOnzfW8kkrYCZH3A8rR0VF633h6eooGDRpIr/Xrx4H//vtPVK5cWdoPDRs2FNWqVZO2adCgQSpJW10m7BTrye8HUHEEBQUJAwMDAUA4OTkJLy8vKcHfqFEjkZqaqrKMYtvy+7F88eJFYWNjIx3LGjduLMqVKycACENDQxEYGKiz+As6tp8/f17ap5aWlsLb21tKJgIQ3377rcoye/bsETKZTLoA4u3tLR1jZsyYke9nuyjvcYXs7GzRpUsX6f1Yr149UaVKFam++fPnq11O8X2g7v2zefNm4eDgID0UCUorKyul6bpSEkmfohz7du7cKR2PzMzMRIMGDUSTJk2U9vtXX32ltIw+7btXz9nq1KkjWrZsqfbxxRdfaB1rfkp73+3atUvlnK5+/frSfrS1tRWXL19Wqr84+6ww69atE4aGhgLIu7hQu3Zt4eHhIU2zsLAQR44cUbvs3LlzpbiqVKki6tWrJx1fu3btKnJyclSWUXwPqDuGKS7GWltbi3r16om6detKn2UnJydx48YNnW57aSXs6tevL4C8C6S1atUSTZo0keYDID799FOVes6cOSMdm42NjUXdunVF06ZNRZUqVaRj+OtJ0KKeDyoMGzZMWr5WrVqiVq1a0vORI0eqXUbxehV0LpDfMkzYUUniLbFEOmZlZYVDhw5h06ZN6Ny5M9LS0nDlyhXExsaiXr16+Oqrr3DhwgVp6HGFadOm4a+//kLTpk2RkJCAiIgItG7dGmfOnEGrVq3yXd+nn36Kbdu2oVGjRkhJScH9+/fxwQcfICQkpNQ7t9XH2KpXr44LFy6gW7duePjwIZ4+fYr69etjzZo1+PXXX9UuM3/+fOzduxcdO3ZEamoqrl+/jrJly2LkyJG4du2a1BeUJgwNDfH3339j/vz5qF69Ou7fv4/nz59jyJAhuHDhAhwcHNQuZ2BggP3796NPnz4wNDTEhQsXcOrUKYSGhhblZUDVqlWxd+9etG3bFgkJCThz5gxOnTql1Jzf09MTly5dwoABA2BhYYGbN2/CxsYGy5cvz/e1epWvry8OHjwIT09PhIWFISMjA+3bt8fJkyfh6+tbpLgL89tvv2Hp0qWwtrbGzZs3YWlpiYEDB+Ly5cvSbRKa+Omnn7BkyRLUrFkTz549w4MHD9ChQwecPn0aXbp0UbtMUFAQhg8fDg8PDzx58gTXr1+HhYUFevbsiVOnTmHOnDm62kyNfPDBB7h06RJ8fX0hk8lw48YNVKhQARMnTsSVK1d0PlpdSahfvz5u3ryJadOmoVatWoiMjERERAQqVaqEUaNG4csvv1Sav1q1arh69SomT54MFxcX3Lp1CzExMWjTpg02btyIoKAgnfcH+aYMHjwYp0+fxscff4z09HTcvn0bVapUwezZs3HmzJkijWDr7e2N69ev4/PPP4elpaV0POnVqxf+/fdf6Xafkta0aVNcu3YNI0aMQNmyZXH9+nWkpqaiU6dO2L9/P77//nuVZbp164aDBw+iRYsWSE9Px927d1GtWjX88ccfJfZZMzIywr59+7BkyRLUrVsX4eHhiIuLQ/v27bFv3z58/fXXWteZkZGBuLg46aHoQiI1NVVpuj4ryrGvZ8+euH37NsaPHw83NzfcvXsXt2/flpYLCgoq0uuZH13vu8zMTOn/mzdv4uzZs2ofN27c0Nk2lARt9l3r1q2xbNkydOvWDVZWVrh9+zaioqJQrVo1TJ06FWFhYVL/qW/CZ599hvPnz+PTTz9FxYoVER4ejocPH6JKlSoYOXIkQkNDpS5nXvfNN99g7969aN++PeLi4hAeHo66detiyZIl2L17NwwNDbWKpV27dhg8eDAcHR0RERGByMhI1K5dG7Nnz8bt27dRp04dXWxyqVu8eDHGjx+PevXqITY2VvrO6Ny5M/bs2aO2u5eWLVvi9u3b+Oabb1C7dm1ERkbi+vXrMDAwQJcuXbBixQosXbpUp3GuWbMGQUFBaNasGaKjoxEdHY1mzZphw4YNb92gMEQyIfIZwpGIiKgI3Nzc8ODBA0RGRkoDIRAREREREZHm2MKOiIiIiIiIiIhIjzBhR0REREREREREpEeMSjsAInpz1q9fr3aY8/ycOXOmBKMhXSmoj8PXDR06FEOHDi3BaIiIiIiIiKi4mLAjeo88fPgQZ8+eLe0wSMe02acdOnQowUiIiIiIiIhIFzjoBBERERERERERkR7Ruz7sEhMTMW7cODRv3hyOjo4wNTWFk5MT2rdvjx07dqCw/GJkZCSsrKwgk8kwcuRIrdd/8eJFfPTRRyhTpgwsLS3RpEkT/Pnnn0XdHCIiIiIiIiIiIq3o3S2xsbGxWL9+PZo1a4b/+7//g729PWJiYrB371706dMHw4YNw5o1a9QuK4SAv79/kdcdHByMzp07w8TEBL6+vrC1tcXOnTsxcOBAREVFYfr06VrVJ5fL8eTJE1hbW0MmkxU5LiIiIiIiIiIiersJIZCSkoJKlSrBwKCQNnRCz+Tk5Ijs7GyV6cnJyaJ27doCgLh586baZZcuXSqMjIzEL7/8IgCIESNGaLze7OxsUbVqVWFqaiquXLmitF5PT09hZGQk7t27p9W2REdHCwB88MEHH3zwwQcffPDBBx988MEHH3zwIQCI6OjoQnNKetfCztDQUO10a2trdO7cGbdv30Z4eDg8PT2VysPDwzFt2jRMnToVXl5eWq/3xIkTiIiIgL+/v9Ly1tbWmDFjBnx9fREQEIB58+ZpXKe1tTUAIDo6GjY2NlrHRERERERERERE74bk5GQ4OztL+aKC6F3CLj8ZGRk4ceIEZDIZateurVQml8vh7+8PV1dXzJw5E+fOndO6/uDgYABAp06dVMoU006dOqVVnYrbYG1sbJiwIyIiIiIiIiIijbpN09uEXWJiIpYsWQK5XI6YmBgcOHAA0dHRmDVrFjw8PJTmXbJkCf7991+cOXMGpqamRVrff//9BwAqdQNAmTJlULZsWWkeIiIiIiIiIiKikqLXCbvvvvtOem5sbIyFCxdi0qRJSvPdu3cP3377LcaPH4/mzZsXeX1JSUkAAFtbW7XlNjY2ePToUYF1ZGZmIjMzU3qenJxc5HiIiIiIiIiIiOj9VMiQFKXHzc0NQgjk5OQgMjISc+bMwTfffIPevXsjJycHQN6tsH5+fqhUqRLmzp1byhED8+fPh62trfRwdnYu7ZCIiIiIiIiIiOgto7ct7BQMDQ3h5uaGr7/+GoaGhpg6dSrWrl2LUaNGYdmyZTh//jxOnDgBCwuLYq1H0bJO0dLudcnJyfm2vlOYNm0aJk6cqLQMk3ZERERERERE74fc3FxkZ2eXdhhUSoyNjfMdTFVbep+we1WnTp0wdepUBAcHY9SoUQgNDYUQAj4+PmrnX716NVavXo0ePXrg77//LrBuRd91//33Hxo1aqRUlpCQgNjYWLRo0aLAOkxNTYvchx4RERERERERvZ2EEHj27BkSExNLOxQqZXZ2dnB0dNRoYImCvFUJuydPngAAjIzywm7btq30/6uePn2KAwcOoGbNmmjZsiW8vLwKrbtt27aYP38+jhw5Al9fX6WyI0eOSPMQEREREREREb1KkawrX748LCwsip2sobePEAJpaWmIiYkBAFSsWLFY9cmEEEIXgelKaGgo3N3dVW4/jY+PxwcffIDQ0FBs3LgRn376ab51BAcHw8fHByNGjMCqVauUyrKzsxEREQFjY2NUrVpVmp6Tk4MaNWrg8ePHOH/+PBo0aAAASElJQfPmzXH37l3cunUL1atX13hbFLfRJiUlwcbGRuPliIiIiIiIiOjtkJubi3v37qF8+fJwcHAo7XColMXFxSEmJgbVq1dXuT1WmzyR3rWwCwwMxLp16+Dj4wNXV1dYWlriwYMH2L9/P1JTU9G7d28MGDCgyPU/fvwYtWrVgqurK6KioqTpRkZGWLduHTp37ozWrVvjk08+gY2NDXbu3InIyEjMnTtXq2QdEREREREREb37FH3WFbdvfXo3KN4H2dnZxerPTu8Sdn369EFSUhLOnz+Pf/75B2lpabC3t0erVq0wePBg+Pr6lljTUh8fH5w5cwazZs3Ctm3bkJWVBU9PT3z//fcYOHBgiayTiIiIiIiIiN5+vA2WAN29D/Tulth3CW+JJSIiIiIiInq3ZWRkIDIyEu7u7jAzMyvtcKiUFfR+0CZPZFCSQdK7RQiB2NjY0g6DiIiIiIiIiEpYcHAwZDLZOzXyrZ+fH/7v//6vtMPQCBN2pLHVq1ejRo0a2Lx5M9gwk4iIiIiIiIj0UVRUFGQyGUJDQ5WmL126FIGBgaUSk7aYsCONREZGYvLkyYiPj8eAAQPQt29faahiIiIiIiIiIqLiysrKKtH6bW1tYWdnV6Lr0BUm7Egj1tbW+Pjjj6XnO3bsgKenJ/76669SjIqIiIiIiIiIiiozMxPjxo1D+fLlYWZmhlatWuHixYtK85w9exb169eHmZkZmjZtihs3bkhlDx48QLdu3VCmTBlYWlrC09MTBw4ckMpv376Njz76CFZWVqhQoQIGDRqk1NVWu3bt8MUXX2DixIkoW7YsOnbsiE8++QS+vr5KMWRnZ6Ns2bIICAgAABw6dAitWrWCnZ0dHBwc8PHHHyMiIkKa393dHQDg5eUFmUyGdu3aAVC9Jbaw7VfcFnz8+HF4e3vDwsICLVq0wN27d4v4imuOCTvSSNmyZbFlyxZs27YNZcuWBQDExsaib9++8PX1Zd92RERERERERG+ZqVOnYseOHQgKCsKVK1dQrVo1dO7cGfHx8dI8U6ZMwc8//4yLFy+ifPny6N69O7KzswEAY8aMQWZmJv755x/cuHEDCxYsgJWVFQDg6dOnaNu2LRo0aIBLly7h0KFDeP78Ofr166cUQ1BQEIyMjHD27FmsXr0aAwcOxJ49e5CamirNc/jwYbx8+RK9e/cGALx8+RITJ07ExYsXcfz4cRgYGKBnz56Qy+UAgAsXLgAAjh07hqdPn2Lnzp1F3n4A+Oabb7Bo0SJcunQJRkZGGDp0aHFedo1wlNgS9K6OEhsTE4NRo0YpveHLly+P1atXvzWdNxIRERERERHpQn6jgnp7e+PZs2dvNBZHR0dcunRJo3lfvnyJMmXKIDAwEAMGDACQ15LNzc0NEyZMQOPGjeHj44MtW7agf//+AID4+HhUrlwZgYGB6NevH+rVq4fevXtj1qxZKvXPnDkTISEhOHz4sDTt0aNHcHZ2xt27d1G9enW0a9cOSUlJuHr1qjRPdnY2KlWqhF9++QWDBg0CAAwYMAA5OTnYtm2b2m158eIFypcvjxs3bqBOnTqIioqCu7s7rl69igYNGkjz+fn5ITExEX///Xeh2z9lyhQEBwfDx8cHx44dwwcffAAAOHDgALp27Yr09HS1owLrapRYowJLidQoX748/vrrL2zduhVjxoxBfHw8YmJi0LNnTwwcOBBffvklDA0N813ezc3trblnnIiIiIiIiKgonj17hsePH5d2GPmKiIhAdnY2WrZsKU0zNjZGkyZNcOfOHTRu3BgA0Lx5c6nc3t4eNWrUwJ07dwAA48aNw6hRo3DkyBF06NABvXv3Rr169QAAly9fxsmTJ6UWd6+vu3r16gDyEpuvMjY2Rt++fbFp0yYMGjQIL1++xO7du/Hnn38qLT9jxgycP38esbGxUsu6hw8fok6dOjrZ/lcptgkAKlasCCCvMZOLi4tG6yoKJuyoSGQyGXx9fdGuXTuMGDECe/bsAQBs2rQJmzZtKnBZExMTzJ49G1OmTIGREd+CRERERERE9O5xdHTU63UqbriUyWQq01+f9jpF+eeff47OnTtj//79OHLkCObPn49FixZh7NixkMvl6NatGxYsWKCyvCLpBQCWlpYq5QMHDkTbtm0RExODo0ePwszMDB9++KFU3q1bNzg7O2Pt2rWoVKkS5HI56tSpo9WgFdpsv7Gxscq2K5KEJYXZEioWR0dH/P3339i0aRPGjh2LxMTEQpfJysrC9OnTsWvXLgQFBaFWrVolHygRERERERHRG6TpramlpVq1ajAxMcGZM2eUbgm9dOkSJkyYIM13/vx5qSVZQkIC7t27h5o1a0rlzs7OGDlyJEaOHIlp06Zh7dq1GDt2LBo2bIgdO3bAzc1N68Y6LVq0gLOzM7Zu3YqDBw+ib9++MDExAQDExcXhzp07WL16NVq3bg0AOHPmjNLyinlzc3OLvf2lhQk7KjaZTIZPP/0U7du3x+rVqxETE5PvvImJidi2bRvkcjkuXrwILy8vfP/995g4cWKBt9ESERERERERke5YWlpi1KhRmDJlCuzt7eHi4oKffvoJaWlp+Oyzz3Dt2jUAwJw5c+Dg4IAKFSrgm2++QdmyZaX+6ydMmIAPP/wQ1atXR0JCAk6cOCE1yhkzZgzWrl2LTz75BFOmTEHZsmURHh6OLVu2YO3atQXmAGQyGQYMGIBVq1bh3r17OHnypFRWpkwZODg4YM2aNahYsSIePnyIr7/+Wmn58uXLw9zcHIcOHULlypVhZmYGW1tbrba/tDFhRzpTqVIlfPfdd4XON27cOPj5+eHevXvIzMzE1KlTsWvXLgQEBKBGjRpvIFIiIiIiIiIi+vHHHyGXyzFo0CCkpKTA29sbhw8fRpkyZZTmGT9+PP777z/Ur18fe/bsUWrBNmbMGDx69Ag2Njbo0qULFi9eDCAvR3D27Fl89dVX6Ny5MzIzM+Hq6oouXbrAwMCg0NgGDhyIefPmwdXVVamfOQMDA2zZsgXjxo1DnTp1UKNGDSxbtgzt2rWT5jEyMsKyZcswZ84czJw5E61bt0ZwcHCRtr+0cJTYEvSujhKrC+np6fj222+xePFi6b5xMzMzzJs3D+PGjWNrOyIiIiIiInorFDQqKL1/dDVKLBN2JYgJu8KdOXMG/v7+CA8Pl6Z5e3sX2NLOzMwMAwYMQPv27bVe38uXL7F8+XLcvHmzwPkcHBwwZswYadQaIiIiIiIiInWYsKNXMWH3FmDCTjNpaWmYPn06li5dqtVyI0aMwMKFC2Ftba3R/KdPn4a/vz8iIiI0mp8t/oiIiIiIiKgwTNjRq3SVsCv8pmGiEmZhYYElS5YgODgY1apV03i51atXo27dujh+/HiB86WlpWHixIlo27atxsk6IO9DNnHiRLRr106pBSARERERERERUUliC7sSxBZ22pPL5Xjw4AHkcnm+8xw5cgRTpkzBy5cvpWmjR4/GggULYGVlpTTvuXPnpAEuFFq0aIElS5bA3t4+3xh+++03pRZ/5ubmWLBgAcaMGaNR55hERERERET0fmALO3oVb4l9CzBhV3IiIyMxdOhQpVFe3N3dERAQgLZt2yIjIwMzZ87EokWLpOSfqakp5s2bh/Hjx2t0i+upU6cwdOhQ3L9/X5rWtm1brF+/HlWqVNH5NhEREREREdHbhwk7ehVviaX3mru7O44fP47ly5fDwsICQF4Sr127dhg+fDi8vLywcOFCKVnXtGlThIaGYuLEiRr3R9e2bVtcu3YNY8aMkaadOnUK9erVw8qVKwtsBUhEREREREREVFRM2NFby8DAAF988QWuXbuGVq1aSdPXrl2LsLAwAICJiQkWLFiAM2fOoGbNmlqvw8rKCr/++iuOHz8OV1dXAHkjzY4ePRp16tTBwoUL8ezZM91sEBERERERERERmLCjd0C1atVw6tQpLF68WKm5qbe3N65cuYKpU6fCyMioWOto3749bty4gREjRkjT7ty5g6lTp6Jy5cro1q0bdu7ciaysrGKth4iIiIiIiIiICTt6JxgYGGDChAm4du0aRo0ahWXLluHcuXPw9PTU2Tqsra2xatUqHD16VKlFX25uLvbt24fevXujUqVKGD9+PEJDQ3W2XiIiIiIiIiJ6vzBhR++U6tWrY8WKFRg7dmyxW9Xlp0OHDjh9+jTu3buH6dOno3LlylJZXFwcli1bBi8vL3h5eWHp0qWIjY0tkTiIiIiIiIiI3gbt2rXDhAkTNJ4/MDAQdnZ2JRbP24AJO6Ii8vDwwA8//ICoqCgcPnwYvr6+MDU1lcpDQ0MxYcIEVKpUCb1798bevXuRk5NTihETERERERER0duACTuiYjI0NESnTp2wefNmPH36FCtXrkSTJk2k8uzsbOzcuRPdu3dH5cqVMWXKFNy+fbsUIyYiIiIiIiIifcaEHZEOlSlTBiNHjkRISAhu3ryJyZMno0KFClL58+fP8fPPP8PT0xNNmzbFypUrkZCQUIoRExERERER0fuqXbt2GDt2LCZMmIAyZcqgQoUKWLNmDV6+fAl/f39YW1ujatWqOHjwoLTMqVOn0KRJE5iamqJixYr4+uuvle4me/nyJQYPHgwrKytUrFgRixYtUllvVlYWpk6dCicnJ1haWqJp06YIDg5+E5v81mDCjqiEeHp6YuHChXj06BH27t2LXr16wdjYWCq/cOECRo8ejYoVK+KTTz7BkSNHkJubW4oRExERERER0fsmKCgIZcuWxYULFzB27FiMGjUKffv2RYsWLXDlyhV07twZgwYNQlpaGh4/foyPPvoIjRs3xrVr17By5Ur8/vvvmDt3rlTflClTcPLkSezatQtHjhxBcHAwLl++rLROf39/nD17Flu2bMH169fRt29fdOnSBf/999+b3ny9JRNCiNIO4l2VnJwMW1tbJCUlwcbGprTDIT0QGxuLP//8EwEBAWpHkq1cuTIGDx4MPz8/eHh4vPkAiYiIiIiISCsZGRmIjIyEu7s7zMzM/lfg7Q08e/Zmg3F0BC5d0nj2du3aITc3F6dPnwYA5ObmwtbWFr169cKGDRsAAM+ePUPFihVx7tw57N27Fzt27MCdO3cgk8kAACtWrMBXX32FpKQkpKWlwcHBARs2bED//v0BAPHx8ahcuTKGDx+OJUuWICIiAh4eHnj06BEqVaokxdKhQwc0adIE8+bNQ2BgICZMmIDExEQdvTBvTr7vB2iXJyqZYTSJSK2yZcti3LhxGDduHEJDQxEQEIBNmzYhLi4OAPDo0SPMmzcP8+bNQ8uWLeHv749+/frB2tq6lCMnIiIiIiIirTx7Bjx+XNpRFKpevXrS/4aGhnBwcEDdunWlaYpunmJiYnDnzh00b95cStYBQMuWLZGamopHjx4hISEBWVlZaN68uVRub2+PGjVqSM+vXLkCIQSqV6+uFEdmZiYcHBx0vn1vKybsiEpJgwYNsHTpUixcuBD79u1DQEAADh48KN0We/bsWZw9exbjxo1Dnz594O/vjzZt2sDAgHeyExERERER6T1Hx7dina923QQAMplMaZoiOSeXyyGEUErWAYDixk2ZTAZNbuKUy+UwNDTE5cuXYWhoqFRmZWWldfzvKibsiEqZiYkJevXqhV69euHZs2f4448/EBAQII0km5aWhg0bNmDDhg1wd3fHkCFDMGTIELi5uZVu4ERERERERJQ/LW5NfVvUrl0bO3bsUErc/fvvv7C2toaTkxPKlCkDY2NjnD9/Hi4uLgCAhIQE3Lt3D23btgUAeHl5ITc3FzExMWjdunWpbYu+Y1MdIj3i6OiIyZMn4+bNmwgJCcGoUaNgZ2cnlUdGRmL27Nlwd3dH+/btsXHjRqSlpZVewERERERERPTeGD16NKKjozF27FiEhYVh9+7dmDVrFiZOnAgDAwNYWVnhs88+w5QpU3D8+HHcvHkTfn5+SneKVa9eHQMHDsTgwYOxc+dOREZG4uLFi1iwYAEOHDhQilunX5iwI9JDMpkMTZo0wYoVK/D06VNs3rwZnTp1Ump6fPLkSQwePBiOjo4YNmwY/v33X42aHxMREREREREVhZOTEw4cOIALFy6gfv36GDlyJD777DN8++230jwLFy5EmzZt0L17d3To0AGtWrVCo0aNlOoJCAjA4MGDMWnSJNSoUQPdu3dHSEgInJ2d3/Qm6S2OEluCOEos6Vp0dDQ2btyIgIAAhIeHq5RXr14dfn5+GDx4MJycnEohQiIiIiIiovdLQaOC0vtHV6PEsoUd0VvE2dkZ06dPx71793D69GkMHTpUqVPOe/fuYfr06XBxcUGXLl2wdetWZGRklGLERERERERERKQtJuyI3kIymQytWrXC77//jmfPniEoKAjt2rWTyuVyOQ4fPgxfX19UqlQJY8aMwcWLF3nLLBEREREREdFbgAk7orecpaUlBg8ejJMnTyIiIgKzZs2Cq6urVJ6QkIAVK1agSZMmqFu3LhYtWoTnz5+XYsREREREREREVBAm7IjeIVWqVMHs2bNx//59HD9+HJ9++inMzc2l8lu3bmHy5MlwcnJCjx49sGvXLmRlZZVixERERERERET0OibsiN5BBgYGaN++PTZu3Ihnz55h7dq1aNGihVSem5uLPXv2oFevXnBycsKXX36Ja9eulWLEREREREREbzd2QUSA7t4HTNgRveNsbGzw+eef4+zZswgLC8O0adOURpCNjY3FkiVL0KBBAzRs2BDLly9HXFxcKUZMRERERET09jA2NgYApKWllXIkpA8U7wPF+6KoZIIp4BKjzXC9RG9Sbm4ujh49ioCAAPz9998qt8WamJige/fu8PPzQ+fOnWFkZFRKkRIREREREem/p0+fIjExEeXLl4eFhQVkMllph0RvmBACaWlpiImJgZ2dHSpWrKgyjzZ5IibsShATdvQ2iI+Px5YtWxAQEIBLly6plFesWBGDBg2Cn58fatWqVQoREhERERER6TchBJ49e4bExMTSDoVKmZ2dHRwdHdUmbd/qhF1iYiJmzpyJixcvIjIyEgkJCShbtixq1KiBMWPGoFevXkobvXbtWuzZswc3b95ETEwMjIyM4Obmhh49emDChAmwt7fXeN1yuRwrVqzA+vXrERYWBiMjI3h5eWHSpEno3r271tvChB29bW7evInAwEBs3LgRMTExKuVNmzaFv78/fH19YWtrWwoREhERERER6a/c3FxkZ2eXdhhUSoyNjWFoaJhv+VudsAsPD0eDBg3QrFkzVKtWDfb29oiJicHevXsRExODYcOGYc2aNdL8bdq0QUJCAry8vFCxYkVkZmbi/PnzCAkJgYuLC0JCQuDo6FjoeoUQ6Nu3L3bs2IGqVaviww8/RGZmJnbv3o2YmBgsX74cX3zxhVbbwoQdva2ys7Nx8OBBBAQEYN++fcjJyVEqNzMzQ69eveDn54f27dsXeEAiIiIiIiIiorc8YZebmwshhEqfWSkpKWjWrBlu376NmzdvwtPTEwCQkZEBMzMzlXpmzJiBuXPnYvLkyVi4cGGh6/3rr7/Qt29ftGzZEkePHoW5uTmAvA75vb298ezZM4SFhcHNzU3jbWHCjt4FL168wKZNmxAQEIDr16+rlDs7O2PIkCEYMmQIqlWrVgoREhEREREREek/bfJEejdKrKGhodoO7q2trdG5c2cAea3wFNQl6wCgb9++KvMW5O+//wYATJ8+XUrWAUDZsmXx5ZdfIjMzEwEBARrVRfQuKVeuHCZMmIDQ0FBcuXIFY8eOVbrVPDo6GnPnzoWHhwfatGmDgIAApKamlmLERERERERERG83vUvY5ScjIwMnTpyATCZD7dq1C51///79AIA6depoVP/z588BAO7u7iplimknTpzQNFyid45MJoOXlxeWLVuGJ0+eYPv27ejatSsMDP53GDl9+jSGDh0KR0dH+Pv749SpU9CzRrxEREREREREek+1KZueSExMxJIlSyCXyxETE4MDBw4gOjoas2bNgoeHh8r8gYGBiIqKQkpKCq5cuYLg4GB4eXlh4sSJGq2vXLlyAIDIyEiVkTAjIyMBAPfu3SuwjszMTGRmZkrPk5OTNVo30dvG1NQUffr0QZ8+ffD06VNs3LgRAQEBCAsLAwC8fPkSgYGBCAwMRJUqVeDn54fBgwfD1dW1lCMnIiIiIiIi0n9614edQlRUlFJrN2NjY8ybNw+TJk1SOzRuu3btcOrUKel5p06dsHHjRpQvX16j9W3cuBGDBw9G69atceTIEelW27i4OHh7eyMqKgomJiZKCbnXzZ49G999953KdPZhR+8DIQQuXLiAgIAAbN68WSVhLZPJ0L59e/j7+6Nnz56wsLAopUiJiIiIiIiI3ry3etCJ1+Xm5iI6OhpbtmzBrFmz0LVrV2zbtk1tP3dA3iARISEhmDp1KpKSknDgwAHUq1ev0PXk5OSgU6dOOHnyJKpVq4YuXbogOzsbf//9NypUqIDr16/D3NwcaWlp+dahroWds7MzE3b03klPT8euXbsQGBiIY8eOqdwWa2NjA19fX/j5+aFZs2Zqk/BERERERERE75J3KmH3qoULF2Lq1KlYsWIFRo0aVeC80dHR8PDwQP369RESEqJR/ZmZmfjxxx/x559/IioqCra2tujZsycmT56M6tWrw8XFBQ8ePNA4Xo4SSwQ8fPgQGzZsQGBgICIiIlTKa9asCT8/PwwaNAiVKlUqhQiJiIiIiIiISt47m7C7du0aGjRogH79+mHr1q2Fzu/l5YVr164hNTW1WLffBQcHw8fHB7169cKOHTs0Xo4JO6L/EULgzJkzCAgIwLZt2/Dy5UulcgMDA3Tu3Bn+/v7o3r07TE1NSylSIiIiIiIiIt3TJk/01owSCwBPnjwBgHxvh33d06dPIZPJYGhoWKz1btq0CQDg6+tbrHqI3mcymQytW7fG+vXr8ezZMwQEBKBt27ZSuVwux8GDB9GvXz9UrFgRX3zxBS5fvsxRZomIiIiIiOi9o3cJu9DQUCQlJalMj4+Px/Tp0wEAH374IYC8ASFu3bqlMq8QArNnz8bz58/h4+Oj1FInOzsbYWFham/NUzeq619//YX169ejcePG6NWrV5G3i4j+x8rKCn5+fggODkZ4eDhmzJgBFxcXqTwhIQG//fYbvL29Ub9+fSxevBgxMTGlGDERERERERHRm6N3t8ROmDAB69atg4+PD1xdXWFpaYkHDx5g//79SE1NRe/evbFt2zYYGBggNDQUXl5eaNKkCWrXrg1HR0fExsbi9OnTuHv3LhwdHREcHIwaNWpI9StGn3V1dUVUVJTSumvVqgVnZ2fUqlULZmZmuHDhAoKDg1GlShWcOHECrq6uWm0Lb4kl0pxcLsfJkycREBCAHTt2ICMjQ6ncyMgIXbt2hb+/Pz766CMYGxuXUqRERERERERE2nur+7A7c+YMfv/9d5w/fx5PnjxBWloa7O3t0bBhQwwePBi+vr7SiJIJCQlYuHAhgoODERERgfj4eJiZmcHDwwNdu3bFhAkT4ODgoFR/QQm72bNnY+fOnYiKikJ2djbc3d3Ru3dvTJkypUgJNybsiIomKSkJW7duRWBgIM6dO6dSXq5cOXz66afw9/dH3bp1SyFCIiIiIiIiIu281Qm7dwkTdkTFFxYWhsDAQGzYsAFPnz5VKW/UqBH8/f3xySefwN7evhQiJCIiIiIiIiocE3Z6ggk7It3JycnB0aNHERAQgN27dyMrK0up3MTEBD169IC/vz86depU7MFmiIiIiIiIiHSJCTs9wYQdUcmIi4vD5s2bERgYiMuXL6uUV6pUCYMGDYK/v79SH5ZEREREREREpYUJOz3BhB1Rybt+/ToCAwPxxx9/4MWLFyrlzZs3h7+/P/r16wdbW9tSiJCIiIiIiIiICTu9wYQd0ZuTnZ2NAwcOICAgAPv370dOTo5Subm5OXr16gV/f3/4+PjAwMCglCIlIiJ6e0VERGDPnj1o0qQJmjdvzu9TIiIiLTBhpyeYsCMqHTExMdi0aRMCAgJw48YNlXJXV1cMGTIEQ4YMQZUqVUohQiIioreLXC7HsmXLMG3aNGRkZAAAnJyc0LdvX/Tr1w9NmzZl8o6IiKgQTNjpCSbsiEqXEAJXrlxBQEAA/vzzTyQkJKjM07ZtW/j7+6N3796wsrIqhSiJiIj0W3h4OIYOHYrTp0/nO4+zs7OUvGvSpAlkMtkbjJCIiOjtwISdnmDCjkh/ZGRkYO/evQgICMDhw4chl8uVyq2srNC3b1/4+/ujVatW/KHxCiEENm/ejK1btyIzM7PAeU1NTWFpaSk9LCwstHpuaWkJIyOjN7RlRERUELlcjt9++w1ff/010tLSpOlDhw7F8+fPceTIEWRnZ6ss5+rqihEjRmDy5MkwNjZ+kyET6ZxcLseGDRvwzz//YOLEiahTp47WdSQmJmLGjBkoV64cpk+fznMdovcYE3Z6ggk7Iv30+PFjbNy4EYGBgbh7965KedWqVeHn54chQ4bA2dm5FCLUH0+ePMGIESOwb9++N7ZOY2PjYiX9CnpuYWEBQ0PDN7YtRERvq/v372Po0KE4deqUNK1KlSpYv3492rZtCwBISEjA7t27sW3bNhw9elSl/9gGDRogKCgI9erVe6OxE+nKgwcP8Nlnn+H48eMAgAoVKuDatWuoUKGCxnXI5XJ0794d+/fvBwDMnDkT3333XYnES0T6jwk7PcGEHZF+E0Lg/PnzCAgIwJYtW5CSkqJULpPJ0KFDB/j7++P//u//YG5uXkqRvnlCCPz5558YO3as2luJ32bFbQVY0HNzc3P24UREbzW5XI7Vq1djypQpePnypTR9zJgx+PHHH/PtPiI+Ph5///03tm/fjqNHjyI3NxdA3kWYWbNm4auvvmKrInprCCHw+++/Y+LEiSrnhx06dMChQ4c0vgC4aNEiTJ48WXouk8lw9OhRfPDBBzqNmYjeDkzY6Qkm7IjeHmlpadi1axcCAgJw4sQJvH5otLW1ha+vL/z9/d/5vnmeP3+OkSNH4u+//5amOTo6YtWqVWjXrl2+ywkhkJGRgZcvXyItLQ0vX76UHsV9ru6WK31lYWGh0yTgq8/NzMze6fceEZWuly9fom/fvjh48KA0zdXVFevXr0f79u01rufy5csYMmQIbt26JU1r1KgRgoKC4OnpqdOYiXTt0aNH+Pzzz3H48GFpWuXKlZGTk4Nnz54BAObOnYtvvvmm0LrOnz+P1q1bq7Q+LUpLPSJ6NzBhpyeYsCN6Oz148AAbNmxAYGAg7t+/r1Jeq1Yt+Pn5YdCgQahYsWIpRFgyhBDYunUrvvjiC8TFxUnTBwwYgGXLlsHBwaHUYsvOzlZK4uk6IahoCaLvDAwMSjQhaGJiwoQg0XsqLS0NH3/8MU6ePClNGzFiBBYuXAhra2ut68vMzMR3332HBQsWSP3GmpiYYM6cOZg0aRJb25HeEUIgKCgIEyZMQFJSkjR96NCh+OWXX3D16lV88MEHkMvlMDAwwMmTJ9GmTZt860tISICXlxcePHgAAJg6dSquXbsmJQK1balHRO8GJuz0BBN2RG83uVyO06dPIyAgANu3b1fqcBsADA0N0aVLF/j7+6Nbt24wMTEptTjv37+PjIyMIteRlZWFefPmYceOHdK0cuXKYdWqVejVq5cuwtRbQghkZ2cXmNArblLwbfmqNTQ01EkCUPGoVatWqX0uNJGWlqY2Ka8NExMTeHh4MNFJb7W0tDR069YNJ06cAJDXqnzr1q3o3Llzseu+cOEC/Pz8cOfOHWlakyZNsHz5cri7u8POzo4DU1Cpe/LkCYYPHy71MwcAlSpVwtq1a/HRRx9J07777jvMnj1bKg8NDUW5cuVU6hNCoFevXtLdCi1btkRwcDDi4+PRoEEDPH36FIDmLfWI6N3BhJ2eYMKO6N2RkpKCv/76CwEBATh9+rRKefXq1REYGIjmzZuXeCxJSUkICQnBv//+i3PnziEkJETpSrAu9O3bF7/99pvak1DSjuJWYV23ClQ8fz2RrE8qVKiAVatW4f/+7/9KOxQlQgisW7cOkydPRnJycrHrq1u3LgIDA9GwYUMdREf0ZqWnp6N79+44duwYAMDGxgZHjx5FkyZNdLaOjIwMzJo1Cz///LPKKO1AXlcCdnZ2KFOmDOzs7NQ+8iuztbVlaz0qMiEENm3ahLFjxyIxMVGaPmTIECxevBhlypRRmj83NxcdO3aUWqJ++OGH2Ldvn0r/tcuXL8e4ceMAAPb29ggNDZUGMgsODtaqpR4RvVuYsNMTTNgRvZvCw8MRFBSEoKAgREdHS9MNDAwwadIkzJkzB2ZmZjpb34sXL7Bv3z6cO3cO//77L27fvl1iLbYcHBywYsUK9OvXr0TqJ92Ty+VIT08vsYRgcVpuKgwcOBDLli2Dvb29Dra4eKKjozFs2DClvol0wdDQEN988w2++eYbvW5VSPSq9PR09OjRA0ePHgUAWFtb4+jRo2jatGmJrO/cuXPw8/PDvXv3dFqvlZVVgcm+ghJ+NjY2vCXxPfXs2TOMHDkSu3fvlqY5OjpizZo16NatW77LPX36FA0aNEBMTAwA4KeffsKUKVOk8suXL6NFixbIysoCAOzZs0elvjlz5mDWrFkACm6pR0TvHibs9AQTdkTvttzcXJw4cQIzZsxASEiINL1mzZoICgoqduuEsLAwLF68GBs2bCgwaeLo6IhmzZqhbNmyxVpfxYoVMWbMGHaATEpyc3ORlpamdcLvxo0bUosdQLMfQSVJCIHAwEBMmDBBqVVd9+7dUb58+SLXGxISghs3bkjP69evj6CgINSvX79Y8RKVtIyMDPzf//2flLy2trbG4cOHS7yleHp6On777TeEhoYiMTFR6ZGQkFAqrYZtbGyKnPCztrbm6OBvGSEEtmzZgi+++ALx8fHS9AEDBmD58uUaXVw6evQoOnfuDCEEDA0Ncfr0aTRv3hxJSUlo2LCh1N3CxIkTsWjRIpXlc3Nz0alTJ+k29Pxa6hHRu4cJOz3BhB3R+yEnJwe//PILZsyYIV1NNTAwwFdffYVZs2bB1NRU47qEEDh58iR++eUXpX5UFAwNDdGgQQM0b94cLVq0QPPmzeHq6sr+s0jvFHSb0ZIlS2BnZ/fGYnn8+DGGDx+OAwcOSNOcnJywbt06dOnSpVh1Z2dnY968eZg7d640CqCRkRFmzpyJr7/+mn1zkV7KyMhAz549cejQIQB5LdQOHz6MFi1alHJkeX2qJiUlqSTzFAk9ddNfLddFq2BtyGQy2NraFjnhZ2Vlxe/wNygmJgajRo3Czp07pWnly5fHqlWr0LNnT63q+uabbzBv3jwAgIuLC65evYpRo0Zh27ZtAPL6ajx9+nS+ra4La6lHRO8mJuz0BBN2RO+XW7duwc/PD5cuXZKmeXp6IjAwEN7e3gUum5WVha1bt+KXX35BaGioUpm1tTWGDRuG7t27w9vbG5aWliURPlGJePLkCYYNG6aULFPXkXdJEELgjz/+wLhx45SShn5+fli8eLFOk4ZXr17FkCFDlFrbNWzYEEFBQahTp47O1kNUXJmZmejVq5f0mbS0tMThw4fRsmXLUo5MNzIyMoqV8FNceHtTDA0NC0z0Fda3n4WFBRN+Gtq+fTtGjx6N2NhYaVr//v3x66+/FukuhZycHPj4+ODMmTMAgKpVqyIiIgJA3sAtV69ehbu7e4F15NdSj4jeXUzY6Qkm7IjePzk5Ofjpp58we/ZsZGdnA8g7Ge/VqxcsLCzULiOXy3H8+HE8efJEabqLiwvGjx+Pzz//nMcQeqsJIRAUFITx48cr3Y7atWvXAn8k2dvbY+TIkahevbrW63z27BlGjBiBPXv2SNMcHR2xdu1afPzxx1rXp4msrCx8//33mD9/PnJzcwHkjSLr6+sLe3v7Io26y7613h9yuRwbNmzAqVOnSnRk6bCwMKkbB0tLSxw8eBCtW7cusfW9TRSDBBWU0Css4adoafumGBsbFyvhZ2ZmptcJv+fPn2Pnzp24ePGi2gFLNPXkyROpr0YAKFu2LFasWIG+ffsWK75Hjx6hQYMGiIuLU5q+Y8cO9OrVS6M6Xm2pV7lyZQwePBjly5dHuXLllP6WLVuWrbaJ3gFM2OkJJuyI3l/Xr1+Hn58frl69qvWyjRs3xqRJk9C7d2+OfEfvlKIM+GBmZob58+dj3LhxGvXtk1/fRJ9++imWLl36Rga+uHTpEoYMGYLbt28Xuy5TU1OtEnzaPLewsGB/SXoiIiICQ4cOxT///PPG1mlhYYGDBw9ydEodEkIgLS2tyAm/xMREKdn/ppiYmBT5dl47Ozutuv3Q1IsXL7Bz505s27YNwcHBxUrUqdOrVy+sXLmyWP2Xvmr//v1KF4K++OILLF++XOPlX2+pV5AyZcqoJPLy++vg4MDzSCI9xISdnmDCjuj9lp2djfnz5+OHH34o9BYbmUyGHj16YNKkSWjZsqVeX+0mKg4hBH7//XdMmjRJqbVdYVq3bo3169ejWrVq+c6jy76JiisjIwPfffcdFi5c+MZ/gGvD3Ny8xBKC5ubmPJYVQi6XY+XKlZg6deobHWyhXLly2L59O9q2bfvG1kmFE0IgNTW1WAm/N/3TztzcvMjJPjs7O6nFWGxsLHbt2oVt27bhxIkTOk/SAYCDgwOWL18OX19fnR+bFKO+tm3bFocOHYKZmZlWyz969AjNmzfHo0ePdBaTTCaDvb29xgk+e3t7tuomegOYsNMTTNgREZB3LHj69GmB8zg4OBR7lFeit0lGRgYePHiQb7kQAqtWrcLSpUulaRYWFliwYAFGjx6t0jJMXd9Evr6+WL58eal+tuLj4/Ho0SOtRtgt7PmbvuWuqGQyGSwsLEosIWhqavpWJwSjoqIwdOhQnDx5Uprm7u6OX3/9FVWrVi3Rdbu5uZVIyygqXXK5HCkpKUVO+CUlJb3xmC0tLWFra4vnz5+rvbhRrVo19O/fH927d4etrW2x1uXu7p7vABC6EBcXBzs7uyInvTIyMhAWFoYXL14gJiamwL/aXPDSlIGBARwcHDRO8JUpU4attImKgAk7PcGEHRERUfGcOnUKQ4cOxf3796Vp7dq1w/r16+Hu7o7Y2FiMGTNGGpUPyOubaOXKlejTp09phFzisrKylJJ4xU0Avv68JFq2lAQDAwOdJgBff15SP+yFEFizZg0mT56M1NRUafro0aOxYMECWFlZlch6iQqTm5uL5OTkQvvpy68sJSVFJ3FUqVIF/fv3R79+/VC/fv23OjFfUjIzMzVK7Cn+vnqs0RVDQ0OULVtW4wSfnZ0d9yURmLDTG0zYERERFV9qaiq+/vpr/Pbbb9I0S0tLfPHFFwgICEBMTIw0vXfv3lixYoXO+iZ63wghkJWVpdME4OvJxbfl1NPIyKjQBJ+2ycDMzEx8+eWXSp3fu7i4YP369fjggw9KcWuJii8nJyffEXoLS/hZWVmhR48e6NevHxo2bMjEjo6lp6drnOCLiYlBenq6zmMwMjJCuXLlNE7w2djY8H1QwnJzc5GQkFCi61Dcml3UfZmdnY0NGzbAz8/vnbllmwk7PcGEHRERke6cOHECQ4cOVXsrrb29PX777Tf079+fJ/h6TDEKZ0klBEviR2ZJGj58OBYuXMjzRCLSKy9fvtQqwZeZmanzGExMTLRK8FlZWfH7Xwv37t2Dj48Pnjx5UuLrql27NtasWYOWLVtqtdyNGzcwZMgQXL16FYsXL8aECRNKJsA3jAk7PcGEHRERkW6lpKRgypQpWL16tTStR48eWLVqFRwdHUsxMtIHcrkc6enpJZYQ1NWP0sqVK2PdunXo3LmzTuojIiotisFStLlFt7DB2IrC1NRUo8Se4q+lpaXOY3hbpKeno1mzZrh+/fobW6dMJsPEiRPx/fffw9zcvMB5c3JysHDhQsyaNQvZ2dkAAGtrazx8+BB2dnZvINqSxYSdnmDCjoiIqGQcO3YMmzZtQpcuXdCvXz9eVac3Iicnp9gJQU9PT0yZMqXYHegTEb2NhBBITk7WKsFXEoMtmZuba5XgKyzJ9DYZNWoUVq1aBSDvAlKDBg1KbF0PHjzAjRs3pOc1atRAUFAQmjZtqnb+27dvw8/PDxcvXpSm1a5dG0FBQfD29i6xON8kJuz0BBN2REREREREREUjhEBiYqLGCb7Y2Fi1Iw4Xl6WlpcYJvnLlysHMzEznMejCtm3b0L9/fwB5ScuLFy/C09OzxNaXm5uLxYsX49tvv5VaqRsYGGDKlCmYPXu29Drl5ubil19+wYwZM5Tmmzp1KmbNmqW3r2dRMGGnJ5iwIyIiIiIiInoz5HI5EhISNE7wxcXFlcjo6NbW1lol+EpqZPJXRUREwMvLSxrRed26dfjss89KfL0AcOfOHQwZMkRtyzlra2v4+fnh/PnzUlnNmjURGBiYb0u8txkTdnqCCTsiIiIiIiIi/ZSbm4v4+HiNb8+Ni4srkThsbW1VEnlVq1bF559/DgcHh2LXn5mZiRYtWuDKlSsAgIEDB2Ljxo1vtEuRnJwc/Pzzz5g1a5bUj6GhoSGMjY2RkZEBIK+vu0mTJmHOnDnv1G3Ir2LCTk8wYUdERERERET0bsjJyUFcXJzGCb6EhIRira9ChQpYvXo1evToUax6xo8fj2XLlgEAqlevjkuXLsHa2rpYdRbVzZs3MWTIECl5qODh4YHAwEC0aNGiVOJ6U5iw0xNM2BERERERERG9n7KzsxEbG6txgi8pKUltPQMHDsSyZctgb2+vdQy7du1Cr169AOSNpnv+/PkSHWhCE9nZ2ViwYAHmzJmDnJwcjB8/Hj/88AMsLCxKNa43gQk7PcGEHRERERERERFpIjMzE7GxsXjy5Am+//577N27VypzdHTE2rVr8fHHH2tcX1RUFLy8vJCYmAgAWLFiBUaNGqXrsIvs+fPnyMzMhIuLS2mH8sZokycyeEMxERERERERERFRPkxNTeHk5ITGjRtj9+7dCAoKgq2tLQDg2bNn6NatG/z8/KQEXEGysrLg6+srzdu3b1+MHDmyBKPXXoUKFd6rZJ22mLAjIiIiIiIiItIjMpkMgwcPxq1bt/Dhhx9K04OCglCnTh0cPHiwwOWnT5+OkJAQAECVKlWwdu3aNzrIBBUfb4ktQbwlloiIiIiIiIiKQwiBgIAAfPnll0hOTpamGxoa5rtMbm4uAMDY2Bj//vsvvL29SzxOKhxviSUiIiIiIiIiegfIZDIMHToUN2/eRKdOnaTpubm5+T4UFi5cyGTdW8qotAMgIiIiIiIiIqKCOTs749ChQ1i/fj2CgoKQlpaW77wymQxdunTBuHHj3mCEpEu8JbYE8ZZYIiIiIiIiIiICeEssERERERERERHRW4sJOyIiIiIiIiIiIj2idwm7xMREjBs3Ds2bN4ejoyNMTU3h5OSE9u3bY8eOHXj9Dt61a9eiW7ducHd3h6WlJWxtbVG/fn3MnDkT8fHxWq1bCIGdO3fCx8cHFStWhIWFBWrUqIERI0bg/v37utxMIiIiIiIiIiIitfSuD7vw8HA0aNAAzZo1Q7Vq1WBvb4+YmBjs3bsXMTExGDZsGNasWSPN36ZNGyQkJMDLywsVK1ZEZmYmzp8/j5CQELi4uCAkJASOjo4arXvSpEn45ZdfULFiRfTo0QM2Nja4du0ajhw5AisrK/z777+oU6eOxtvCPuyIiIiIiIiIiAjQLk+kdwm73NxcCCFgZKQ8gG1KSgqaNWuG27dv4+bNm/D09AQAZGRkwMzMTKWeGTNmYO7cuZg8eTIWLlxY6HqfPXsGJycnuLi44Nq1a0ov3JIlS/Dll1/C398f69ev13hbmLAjIiIiIiIiIiLgLR90wtDQUCVZBwDW1tbo3LkzgLxWeArqknUA0LdvX5V5CxIVFQW5XI6WLVuqvGhdu3YFAMTExGhUFxERERERERERUVHpXcIuPxkZGThx4gRkMhlq165d6Pz79+8HAI1vYfXw8ICJiQnOnj2LlJQUpbIDBw4AANq3b69l1ERERERERERERNpRbcqmJxITE7FkyRLI5XLExMTgwIEDiI6OxqxZs+Dh4aEyf2BgIKKiopCSkoIrV64gODgYXl5emDhxokbrc3BwwA8//IApU6agVq1a6N69O6ytrXHjxg0cO3YMw4cPx9ixY3W9mUREREREREREREr0rg87haioKLi7u0vPjY2NMW/ePEyaNAkymUxl/nbt2uHUqVPS806dOmHjxo0oX768Vuv9888/MWLECKSmpkrTWrRogR9//BGtW7cucNnMzExkZmZKz5OTk+Hs7Mw+7IiIiIiIiIiI3nNvdR92Cm5ubhBCICcnB5GRkZgzZw6++eYb9O7dGzk5OSrzBwcHQwiBFy9eYN++fXj06BEaNmyI69eva7zOuXPnws/PD9OmTUN0dDRSU1Nx5swZ5OTkwMfHBzt37ixw+fnz58PW1lZ6ODs7a73dRERERERERET0ftPbFnbqLFy4EFOnTsWKFSswatSoAueNjo6Gh4cH6tevj5CQkELrPnHiBD744AN8+eWX+OWXX5TKXrx4gSpVqsDe3h4PHjzItw62sCMiIiIiIiIiInXeiRZ26nTq1AlAXmu6wjg7O6NWrVq4ePEi0tLSCp1fMUiFj4+PSlm5cuVQt25dPHz4ELGxsfnWYWpqChsbG6UHERERERERERGRNt6qhN2TJ08AAEZGmo2V8fTpU8hkMhgaGhY6b1ZWFoC81nTqKKabmppqtG4iIiIiIiIiIqKi0LuEXWhoKJKSklSmx8fHY/r06QCADz/8EAAQFxeHW7duqcwrhMDs2bPx/Plz+Pj4KCXZsrOzERYWhoiICKVlWrZsCQD45ZdfVNYfFBSE8PBwNGrUCNbW1sXbQCIiIiIiIiIiogJo1lTtDQoMDMS6devg4+MDV1dXWFpa4sGDB9i/fz9SU1PRu3dvDBgwAEBeP3VeXl5o0qQJateuDUdHR8TGxuL06dO4e/cuHB0d8dtvvynV//jxY9SqVQuurq6IioqSpvft2xerV69GcHAwPDw80L17d5QpUwbXrl3D0aNHYWpqiiVLlrzBV4KIiIiIiIiIiN5Hepew69OnD5KSknD+/Hn8888/SEtLg729PVq1aoXBgwfD19cXMpkMAODq6opp06YhODgYBw4cQHx8PMzMzODh4YFvv/0WEyZMgIODg0brNTQ0xKFDh7B06VJs3boVmzdvRlZWFipUqIABAwZg2rRpqFOnTkluOhERERERERER0ds1SuzbRpvRP4iIiIiIiIiI6N31zo4SS0RERERERERE9K5jwo6IiIiIiIiIiEiPMGFHRERERERERESkR5iwIyIiIiIiIiIi0iNM2BEREREREREREekRJuyIiIiIiIiIiIj0CBN2REREREREREREeoQJOyIiIiIiIiIiIj3ChB0REREREREREZEeYcKOiIiIiIiIiIhIjzBhR0REREREREREpEeYsCMiIiIiIiIiItIjTNgRERERERERERHpkSIn7Hbv3g25XK7LWIiIiIiIiIiIiN57RU7Y9ezZEy4uLvjmm29w//59XcZERERERERERET03ipywm7y5MnIzc3F/PnzUb16dXTo0AFbt25FVlaWLuMjIiIiIiIiIiJ6r8iEEKKoC+fk5GDv3r1Yt24djhw5ArlcDnt7ewwaNAifffYZPD09dRnrWyc5ORm2trZISkqCjY1NaYdDRERERERERESlRJs8UbESdq968uQJ1q9fj4CAAERGRkImk6Fp06YYPnw4+vXrBwsLC12s5q3ChB0REREREREREQGllLB71cGDBzFs2DA8ffoUAGBlZYXBgwdjypQpcHFx0fXq9BYTdkREREREREREBGiXJypyH3bqhIWFYfLkyfDz88OTJ09gbm4OX19fODs747fffkPt2rVx8OBBXa6SiIiIiIiIiIjonVLshF16ejoCAwPRqlUreHp64pdffoGjoyOWL1+OJ0+eYNOmTbh58yb27dsHCwsLfPXVV7qIm4iIiIiIiIiI6J1kVNQFL1++jLVr12LLli1ISUmBmZkZBg8ejBEjRqBZs2Yq83/00Uf4/PPP8fPPPxcrYCIiIiIiIiIiondZkRN2jRs3BgDUqVMHw4cPx6BBg2Bra1vgMi4uLnBycirqKomIiIiIiIiIiN55RR50ws/PDyNGjEDz5s11HdM7g4NOEBERERERERERoF2eqMgt7ObMmQM7O7sC50lJSUFCQsJ7NTIsERERERERERFRcRR50Al3d3csXbq0wHlWrFgBd3f3oq6CiIiIiIiIiIjovVPkhJ0QAoXdTVvEu22JiIiIiIiIiIjeW0VO2Gni0aNHsLa2LslVEBERERERERERvVO06sNuzpw5Ss+Dg4PVzpebm4tHjx5hy5YtaNq0aZGDIyIiIiIiIiIiet9oNUqsgcH/GuTJZLJCb3mtVKkSdu3ahcaNGxc9wrcYR4klIiIiIiIiIiKgBEeJPXnyJIC8vunat28PPz8/DBkyRGU+Q0ND2Nvbo2bNmkpJPiIiIiIiIiIiIiqYVgm7tm3bSv/PmjULPj4+aNOmjc6DIiIiIiIiIiIiel9pdUssaYe3xBIREREREREREVBCt8Q+fPgQAODk5ARDQ0PpuSZcXFw0npeIiIiIiIiIiOh9pnHCzs3NDTKZDHfu3EH16tWl54WRyWTIyckpVpBERERERERERETvC40TdoMHD4ZMJoOtra3ScyIiIiIiIiIiItId9mFXgtiHHRERERERERERAdrliQzeUExERERERERERESkASbsiIiIiIiIiIiI9IjGfdipc/v2bfz666+4ePEiEhMTkZubqzKPTCZDREREcVZDRERERERERET03ihywu7UqVPo0qULMjMzYWRkhAoVKsDISLU6dpFHRERERERERESkuSLfEvv1118jJycH69atQ3p6OqKjoxEZGan2oY3ExESMGzcOzZs3h6OjI0xNTeHk5IT27dtjx44dKgnAtWvXolu3bnB3d4elpSVsbW1Rv359zJw5E/Hx8RqvNzAwEDKZrMDHBx98oNW2EBERERERERERaavIo8RaWFigd+/e2Lhxo04DCg8PR4MGDdCsWTNUq1YN9vb2iImJwd69exETE4Nhw4ZhzZo10vxt2rRBQkICvLy8ULFiRWRmZuL8+fMICQmBi4sLQkJC4OjoWOh6Q0ND8ffff6st++uvv3Dr1i0sWLAAU6dO1XhbOEosEREREREREREB2uWJipywq1ChAj799FMsWrSoSEHmJzc3F0IIldtrU1JS0KxZM9y+fRs3b96Ep6cnACAjIwNmZmYq9cyYMQNz587F5MmTsXDhwiLHk5WVhUqVKiEpKQmPHj1ChQoVNF6WCTsiIiIiIiIiIgK0yxMV+ZbYrl274vTp00VdPF+GhoZq+8KztrZG586dAeS1wlNQl6wDgL59+6rMWxS7du1CXFwcPv74Y62SdUREREREREREREVR5ITdTz/9hKSkJIwbNw5paWm6jEmtjIwMnDhxAjKZDLVr1y50/v379wMA6tSpU6z1/v777wCAzz//vFj1EBERERERERERaaLIt8S2b98eiYmJuHbtGiwtLeHh4QFbW1vVFchkOH78uNb1JyYmYsmSJZDL5YiJicGBAwcQHR2NWbNmYfbs2SrzBwYGIioqCikpKbhy5QqCg4Ph5eWF48ePo0yZMkXZRDx48ABVqlRBxYoV8eDBAxgaGhY4f2ZmJjIzM6XnycnJcHZ25i2xRERERERERETvOW1uiVW991RDwcHB0v+pqam4evWq2vlkMlmR6k9MTMR3330nPTc2NsbChQsxadIktfMHBgbi1KlT0vNOnTph48aNRU7WAUBAQADkcjn8/f0LTdYBwPz585ViJiIiIiIiIiIi0laRW9i9Kbm5uYiOjsaWLVswa9YsdO3aFdu2bVPbzx0AxMbGIiQkBFOnTkVSUhIOHDiAevXqab1euVwOd3d3REdHIyIiAu7u7oUuwxZ2RERERERERESkzhsZJbY0LFy4EFOnTsWKFSswatSoAueNjo6Gh4cH6tevj5CQEK3XdfjwYXTp0gUffPABjh07VqR4OUosEREREREREREBb2iU2NLQqVMnAMq34+bH2dkZtWrVwsWLF4s0KAYHmyAiIiIiIiIiotKgcR92GzZsAAD07NkT1tbW0nNNDB48WPvI1Hjy5AkA5Hs77OuePn0KmUymUf9zr4qLi8Pu3bthb2+Pnj17ah0nERERERERERFRUWmcsPPz84NMJkOzZs1gbW0tPS+IEAIymUyrhF1oaCjc3d1VRpyNj4/H9OnTAQAffvghgLzE2rNnz+Dp6amy3u+++w7Pnz/HBx98AFNTU6ksOzsbERERMDY2RtWqVdXGsHHjRmRlZeHTTz9VWpaIiIiIiIiIiKikaZywW79+PWQyGSpWrAggbwTVkhAYGIh169bBx8cHrq6usLS0xIMHD7B//36kpqaid+/eGDBgAIC8fuq8vLzQpEkT1K5dG46OjoiNjcXp06dx9+5dODo64rffflOq//Hjx6hVqxZcXV0RFRWlNgbeDktERERERERERKVF7wadOHPmDH7//XecP38eT548QVpaGuzt7dGwYUMMHjwYvr6+Usu+hIQELFy4EMHBwYiIiEB8fDzMzMzg4eGBrl27YsKECXBwcFCqPyoqCu7u7vkm7C5cuICmTZuiSZMmRRqs4lUcdIKIiIiIiIiIiIB3eJTYtw0TdkREREREREREBLzDo8QSERERERERERG96zTuw65KlSpFWoFMJkNERESRliUiIiIiIiIiInrfaJywk8vlhY4Kqw7vuCUiIiIiIiIiItKcxgm7/EZUJSIiIiIiIiIiIt1hH3ZERERERERERER6hAk7IiIiIiIiIiIiPaLxLbH5efToEU6ePIknT54gMzNTpVwmk2HGjBnFXQ0REREREREREdF7QSaKMSrElClTsHTpUuTm5krThBDS4BSK/18tf58kJyfD1tYWSUlJsLGxKe1wiIiIiIiIiIiolGiTJyryLbFr167FokWL4OPjg7/++gtCCAwZMgSbN2/GyJEjYWRkhD59+uDEiRNFXQUREREREREREdF7p8i3xK5ZswZubm44ePAgDAzy8n5ubm7o378/+vfvj379+qFjx47o16+fzoIlIiIiIiIiIiJ61xW5hV1YWBi6dOkiJesAICcnR/q/bdu26Nq1K37++efiRUhERERERERERPQeKdYosXZ2dtL/lpaWiIuLUyqvUaMGbt26VZxVEBERERERERERvVeKnLBzcnLCo0ePpOdVq1ZFSEiI0jw3b96EpaVl0aMjIiIiIiIiIiJ6zxQ5YdeyZUucP39eet6jRw9cvXoVI0eOxP79+zFt2jQcPHgQbdq00UmgRERERERERERE7wOZEEIUZcHg4GAsWLAAq1atgqurK1JTU9G2bVtcvXoVMpkMQgi4ubnh5MmTcHV11XXcbwVthuslIiIiIiIiIqJ3lzZ5oiIn7NTJzs7G7t27ERERAVdXV3Tr1u29viWWCTsiIiIiIiIiIgK0yxMZ6XLFMpkMVatWRdWqVVGnTh0YGxvrsnoiIiIiIiIiIqJ3nlZ92EVGRmL9+vW4d++eStm+ffvg5OQEb29veHt7o2LFiti2bZvOAiUiIiIiIiIiInofaJWwW7t2LYYNGwZTU1Ol6eHh4ejXrx9evHgBFxcX1KxZEwkJCRg4cCCuXr2q04CJiIiIiIiIiIjeZVol7M6cOYP69eurDCKxdOlSZGRkYMyYMYiMjMStW7ewfft25Obm4tdff9VpwERERERERERERO8yrW+J9fT0VJl+6NAhmJiYYN68edK0Xr16oXXr1jh9+nTxoyQiIiIiIiIiInpPaJWwi42NhbOzs9K0xMREREREoGnTprC2tlYqa9CgAR4/flz8KImIiIiIiIiIiN4TWiXsjIyMkJiYqDRN0Uedt7e3yvxWVlZFj4yIiIiIiIiIiOg9pFXCrnr16jh+/LjStCNHjkAmk6FFixYq8z958gQVK1YsXoRERERERERERETvEa0Sdr1798Z///2HESNG4Pr169i5cydWrlwJKysrdOnSRWX+s2fPolq1ajoLloiIiIiIiIiI6F2nVcLuyy+/RN26dbF27Vp4eXmhb9++SE5OxsyZM2Fpaak076VLlxAeHo6OHTvqNGAiIiIiIiIiIqJ3mZE2M5ubm+Ps2bNYvHgxzp8/D3t7e/Tt2xfdu3dXmffKlSvo0aOH2jIiIiIiIiIiIiJSTyaEEKUdxLsqOTkZtra2SEpKgo2NTWmHQ0REREREREREpUSbPJFWt8QSERERERERERFRyWLCjoiIiIiIiIiISI8wYUdERERERERERKRHmLAjIiIiIiIiIiLSI0zYERERERERERER6REm7IiIiIiIiIiIiPQIE3ZERERERERERER6hAk7IiIiIiIiIiIiPcKEHRERERERERERkR5hwo6IiIiIiIiIiEiPMGFHRERERERERESkR5iwIyIiIiIiIiIi0iN6l7BLTEzEuHHj0Lx5czg6OsLU1BROTk5o3749duzYASGE0vxr165Ft27d4O7uDktLS9ja2qJ+/fqYOXMm4uPjixTDrl270LFjRzg4OMDc3Bzu7u745JNPEB0drYtNJCIiIiIiIiIiypdMvJ4BK2Xh4eFo0KABmjVrhmrVqsHe3h4xMTHYu3cvYmJiMGzYMKxZs0aav02bNkhISICXlxcqVqyIzMxMnD9/HiEhIXBxcUFISAgcHR01WrcQAiNHjsSaNWtQtWpVdO7cGdbW1njy5AlOnTqFTZs2oVWrVhpvS3JyMmxtbZGUlAQbGxutXwsiIiIiIiIiIno3aJMn0ruEXW5uLoQQMDIyUpqekpKCZs2a4fbt27h58yY8PT0BABkZGTAzM1OpZ8aMGZg7dy4mT56MhQsXarTuZcuWYfz48RgzZgyWLl0KQ0NDpfKcnByVuArChB0REREREREREQHa5Yn07pZYQ0NDtUkxa2trdO7cGUBeKzwFdck6AOjbt6/KvAVJT0/Hd999hypVqmDJkiUqyToAWiXriIiIiIiIiIiIiuKtyUBlZGTgxIkTkMlkqF27dqHz79+/HwBQp04djeo/evQo4uPj4efnh9zcXOzZswf37t2DnZ0dOnTogGrVqhUrfiIiIiIiIiIiIk3obcIuMTERS5YsgVwuR0xMDA4cOIDo6GjMmjULHh4eKvMHBgYiKioKKSkpuHLlCoKDg+Hl5YWJEydqtL5Lly4ByGtFV79+fdy9e1cqMzAwwJdffomff/65wDoyMzORmZkpPU9OTtZo3URERERERERERAp6nbD77rvvpOfGxsZYuHAhJk2apHb+wMBAnDp1SnreqVMnbNy4EWXKlNFofTExMQCARYsWoWHDhrhw4QJq1aqFq1evYvjw4Vi0aBGqVq2KUaNG5VvH/PnzlWImIiIiIiIiIiLSlt71Yafg5uYGIQRycnIQGRmJOXPm4JtvvkHv3r2Rk5OjMn9wcDCEEHjx4gX27duHR48eoWHDhrh+/bpG65PL5QAAExMT/P3332jcuDGsrKzQunVr/PXXXzAwMMCiRYsKrGPatGlISkqSHtHR0dpvOBERERERERERvdf0NmGnYGhoCDc3N3z99deYO3cudu3ahbVr1+Y7f9myZdG1a1ccOnQIsbGxGDZsmEbrsbW1BQB4e3ujUqVKSmWenp6oUqUKIiIikJiYmG8dpqamsLGxUXoQERERERERERFpQ+8Tdq/q1KkTgLzWdIVxdnZGrVq1cPHiRaSlpRU6f40aNQAAdnZ2assV09PT0zWKlYiIiIiIiIiIqCjeqoTdkydPAOQNDKGJp0+fQiaTwdDQsNB5fXx8AAB37txRKcvOzkZ4eDgsLS1Rrlw5LSImIiIiIiIiIiLSjt4l7EJDQ5GUlKQyPT4+HtOnTwcAfPjhhwCAuLg43Lp1S2VeIQRmz56N58+fw8fHB6amplJZdnY2wsLCEBERobRM1apV0alTJ4SHh2PdunVKZT/++CMSExPRs2dPjZOFRERERERERERERSETQojSDuJVEyZMwLp16+Dj4wNXV1dYWlriwYMH2L9/P1JTU9G7d29s27YNBgYGCA0NhZeXF5o0aYLatWvD0dERsbGxOH36NO7evQtHR0cEBwdLt7sCQFRUFNzd3eHq6oqoqCildUdERKBFixaIiYlB165dUbNmTVy9ehUnTpyAq6srzp8/D0dHR423JTk5Gba2tkhKSmJ/dkRERERERERE7zFt8kR611ysT58+SEpKwvnz5/HPP/8gLS0N9vb2aNWqFQYPHgxfX1/IZDIAgKurK6ZNm4bg4GAcOHAA8fHxMDMzg4eHB7799ltMmDABDg4OGq+7atWquHTpEmbOnIlDhw7hyJEjcHR0xJgxYzBz5kyUL1++pDabiIiIiIiIiIgIgB62sHuXsIUdEREREREREREB2uWJ9K4POyIiIiIiIiIiovcZE3ZERERERERERER6hAk7IiIiIiIiIiIiPcKEHRERERERERERkR5hwo6IiIiIiIiIiEiPMGFHRERERERERESkR5iwIyIiIiIiIiIi0iNM2BEREREREREREekRJuyIiIiIiIiIiIj0CBN2REREREREREREeoQJOyIiIiIiIiIiIj3ChB0RERERERERkb5ITwdeviztKKiUGZV2AERERERERERE75zcXCAhAYiLU/+Ij1c/PSMDkMmAhg2Bzp3zHs2bA8bGpb1Fb0ZsLHDjBnD9et6jdWvAz6+0o3rjmLAjIiIiIiIiIsqPEHkt3rRJusXFAYmJxVvn5ct5j3nzAGtroH37/yXwqlTR2eaVmqws4M4d5eTc9evA06fK86WmMmFHRERERERE9MY8fQo8e5bXcsjE5H+P158bGpZ2pPSuyM5WTbIVlHRTlGVllWxcJiaAgwNgb5/3NzExL3mlkJIC7N6d9wAADw+gZUugSROgcWOgXr28OvRZbCzw7795j7NngYsXgczMwpe7caPkY9NDTNgRERERERFRyZPLgbCwvB/qZ87kPe7f12xZCwvAxiavlZGNjer/lpZ58+T3cHAAnJ3z/spkJbud9GYIASQna594S04u+djKlPlf4k3dQ12ZpaXqe/PpU+DoUeDQoby/sbH/K/vvv7xHYGDecxMToEGDvOSdIolXvXrpJbtzc4F795QTdHfvFr6cvX1e8lHxqFsX8PQs+Xj1kEwIIUo7iHdVcnIybG1tkZSUBBsbm9IOh4iIiIiI6M3JzMy7nU+RnDt7Ni9pUprMzYHKlfOSd68+3NzykhvOzmzNVxoyM7VLuin+z8kp2bjMzbVPvJUpUzLvIbkcuHIFOHw473HuXOHbb2wMuLsD1aoBVavm/VX87+6uuxZ5L1/mtYILDf3f4/r1vMEzClKlCtCsGVC//v8SdBUrvtNJdW3yREzYlSAm7IiIiIiI6L2R+P/t3Xl4VOXd//HPmclGCFsgEFAgAhECKERkE1wQ64Y7SgVbQRSLtVq0SsUd66MoT91+ohZcoC4V1FqlYNWqCAgEFEWQNZElrGHLAjHbzP374zwzyXAmgUAyM0ner+s612znnLkPF9+Z5JN7ybV70vgCuuXLqx7uFhtr9wRKS7N745SW2sMOfZvvcVGRPRwwP7/81uOpnWuIjbUDjVNPdW5JSfU6SKgRXq/9/6A6wdv+/bW/IqrLZQdp1QneWra0A7tI9csvdjC2YoVdaytW2D3ajpXLJbVuXd5LtVmz8vu+rVEjOxT01WJpaeD9ggJpzRr7fY8WLUVH24toDBpkb2edJSUnn9A/QV1EYBchCOwAAAAA1FvbtpWHc4sX27+4V/XrZWKi/Yv64MH21qePHZBVlzF2WOEL7/LzpcLCwO3w4cD7e/ZI2dnl26FD1X/fFi2kbt2cW6dOUlQ9nG2qsLB6odv+/faKqF5v7barcePqhW4tW9phlMtVu+2KBLm5dq/W5cvt240bpczMo/d0qw2dO9tDdM880677M8+M7AA0RAjsIgSBHQAAAIB6weORfvopMKDLzq76mE6dysO5wYOlrl0jIzQxRsrLCwzwNm+2w40NG+yAozoLDERH273yuna1t27dyu8nJtbedRwrj8cO0qoTvO3fb/dsrE1RUcFDtqMNQT2ekLchM8Ze2CUzU8rKCrzNySkPvY83aI2NteeZ693bHtrau7c9tJUMJCgCuwhBYAcAAACgTvrlF3uInS+cW7LEDrkq43LZv6j7wrlBg6R27ULW3Brl8di9BzduLN82bLC3bduqd65WrcrDu65d7WAvNdXufRQfX71zGWP3FqxO6LZ/v93rqrY1bVr94K1pU4YYRwrf/y1feJeXZ9/+8osdSPtWba54Gx0txcXZ8z7Wxx6mtYTALkIQ2AEAAACoE/btsxeF8K3g+u239hxVlYmPtyeL9wV0AwbYq7bWd4cP2wHe+vWB24YNVc/XF8xJJ5UHeF262OHe0YagVqfn3/GIiTn20M33emKiHd4AOCoCuwhBYAcAAAAg4hgj/fxz4PDW9eurPqZ168Dhrb17E9JU5OuV5+uJt2FDeZC3c2d42lRxkYVjXem0cWN6vQG1qDo5Ef0WAQAAAKA+KyuTVq0KDOh27676mK5dA4e3dulCkFMVt1s65RR7u/jiwNcKCuxeeZs22VtmZvnt3r1HP3ejRtUP3lq0sNsEoM4isAMAAACA+uTQISkjozycW7rUHspZmagoe8VWX0B31ll2jzrUjCZN7H/fPn2cr+Xm2gsAbNpkzxsWLJBjZU2gQSKwAwAAAIC6bPfu8rnnFi+Wvv/eHqJZmSZN7FDOF9D161f9BRBQM5o3rzzMA9CgEdgBAAAAQF1hjD28suLw1szMqo9p1046++zygO600xguCQARjsAOAAAAACJVSYm0cqUdzPl60e3bV/UxPXoELhDRsSPzzwFAHUNgBwAAAACRIi/PnnPO13suI0MqKqp8/5gYqW/fwPnnEhND114AQK0gsAMAAACAcNm+PXB4648/2sNeK9Oihb1qqy+g69NHiosLXXsBACFBYAcAAAAAoeD1SmvXBgZ0W7dWfUxKSuDw1rQ0yeUKSXMBAOFDYAcAAAAAtaGoSPr22/Jw7ptvpNzcyve3LKlXr/JwbtAg6eSTQ9ZcAEDkILADAAAAgJpw4IC0ZEl5QLdihb1oRGUaNZL69y8P6AYMkJo1C117AQARi8AOAAAAAKrLGGnLlsDecz/9VPUxSUnlPecGD5bS0+1FIwAAOAKBHQAAAAAcjcdjLwhRcf65nTurPiY1NXD+udRUe9grAABHQWAHAAAAAEc6fFhavrw8nFu6VCooqHx/t1s644zA+efatAldewEA9QqBHQAAAADk5NjDWn0B3cqVUllZ5fsnJEgDB5YHdP37S40bh669AIB6jcAOAAAAQMNijJSZGTi8dePGqo9p2zZweOvpp0tR/DoFAKgdfMMAAAAAqN9KS6UffggM6HJyqj4mLS0woDvlFOafAwCEDIEdAAAAgPolP19atqw8nMvIkAoLK98/Olrq27c8nDvrLKlly9C1FwCAIxDYAQAAAKjbdu4M7D23apXk9Va+f7Nm9qIQvoDuzDOlRo1C114AAI4i4gK73NxcPfzww1qxYoU2b96sgwcPqlWrVuratatuv/12XXPNNbIqdEWfMWOGPv74Y61Zs0Y5OTmKiopSSkqKrrzySk2YMEGJiYnH/N4pKSnaunVr0Nd+97vf6ZVXXjnh6wMAAEADUlYmrVlj9/Zavtwemtmhg9Sxo33r2xISwt3SusPrldavDwzoNm+u+pgOHQKHt/boIblcoWkvAADHwTLGmHA3oqLMzEz17t1bAwYMUJcuXZSYmKicnBzNnTtXOTk5GjdunKZPn+7f/5xzztHBgweVnp6utm3bqri4WMuWLVNGRoY6dOigjIwMJScnH9N7p6SkKDc3VxMmTHC8duaZZ+qyyy6r1rXk5+erWbNmysvLU9OmTat1LAAAAOqg3bvtcM63rVhR9VBMn8REO1RKSZG6dLG31FR7O+mkhh0uFRdL331XHs5984104EDl+1uWdNpp5eHcoEH2vy0AAGFWnZwo4gI7j8cjY4yijlhxqaCgQAMGDNDatWu1Zs0a9ejRQ5JUVFSkuLg4x3keeughPf7447rnnns0derUY3rvlJQUSdKWLVtO6Bp8COwAAADqseJi6fvvAwO6SkZrnJC4OKlzZzu88wV5vtv6GOYdPCgtXVoe0C1fbv9bVyYuTurXrzygGzhQat48ZM0FAOBYVScnirghsW63O+jzTZo00UUXXaS1a9cqMzPTH9gFC+sk6brrrtPjjz+uzMzMWmsrAAAAGghj7DCuYjj3/fdSSUnVx3XsKA0YUL41bSpt21a+bd1afn/7dnsI7ZGKiqSffrK3I1UM83xBXlKSPcQ22BYXF3krnW7bFji8dc0a+9+7Mi1bBg5vPeMMKSYmdO0FACAEIi6wq0xRUZG+/PJLWZal7t27H3X/efPmSZJ69uxZrfcpLi7WrFmztGPHDrVo0UJnnXWWevXqdVxtBgAAQB116JD07beBAd2ePVUfEx9vrzTqC+f695fatnXuV9nPsh6PHdpt2iRlZtq3vvtZWcHDwarCvGBcLqlFC7tnnm9r1y7wsW91VGPs+eJ8t777xtgBWWxs4BYVFRgGer3SL7/YQ4IPH7ZvfffXrCkP6LZvr7rNnTsHBnRdu0Ze6AgAQA2LuCGxPrm5uXruuefk9XqVk5Oj+fPnKzs7W4888ogeffRRx/4zZ87Uli1bVFBQoJUrV2rBggVKT0/XF198oRYtWhzTe1a26MTFF1+sN998U61atary+OLiYhVX6K6fn5+v9u3bMyQWAAAgknm90saNgeHc6tVVrzIq2cFRxd5zPXvaoVVt8Hik7OzyAK9ioPfzz0fv6RcKllUe5JWW2mFddblcUnp64PxzwUJPAADqoDo9h53Pli1bdMopp/gfR0dH64knntCf/vSngFVifc477zx9/fXX/scXXnih3nzzTbVu3fqY3/Oxxx7Tueeeqx49eig2NlZr167V5MmT9cknn2jgwIH65ptvgr63z6OPPqrJkyc7niewAwAAiCAHDtjzovnCuYwMKTe36mOaN7d7zPnCuX797IUiIoEvzPMFebm5di+2Q4cCt8OHpYICae9eaedOO1QLt/h4e845X0DXv7/UpEm4WwUAQK2oF4Gdj8fjUXZ2tt5991098sgjGjZsmObMmeNYlMJn3759ysjI0MSJE5WXl6f58+fr9NNPP+7393q9Ovfcc7V48WL9+9//1rBhwyrdlx52AAAAEaaszB5+WbH33IYNVR/jctmrjFbsPXfqqfVrcQevV9q3zw7uduwI3A4etHvLuVzlW8XHkt2jr7g4cKv4XEyMHcbFx0uNG5ff9z1u187uPderlxQdHd5/CwAAQqReBXYVTZ06VRMnTtRLL72k2267rcp9s7OzlZqaql69eikjI+OE3vf111/XzTffrEmTJumJJ5445uNYJRYAACDEdu8ODOdWrLDnTatKmzaB4dyZZ9oLNAAAANSgOr1KbFUuvPBCTZw4UQsWLDhqYNe+fXulpaVpxYoVKiwsVHx8/HG/r2/uusKj/bAHAACA0CkutldqrRjQBZmPOEBMjL2qaMWArkMHFjEAAAARpU4Fdjt37pSkSofDHmnXrl2yLEtut/uE3tfXQy8lJeWEzgMAAIDjZIwdxlUM577//uiLLaSkBIZzvXvbiyIAAABEsIgL7H744QedcsopatasWcDzBw4c0P333y9JuuSSSyRJ+/fv1+7du9WjR4+AfY0xmjx5svbs2aOhQ4cqtsIPZaWlpcrKylJ0dLQ6d+7sf37t2rVq166dmjdvHnCuxYsX65lnnlFsbKyuueaamrxUAAAAVObQIenbbwMDuj17qj4mPt5eDMIXzvXvLyUnh6a9AAAANSjiAruZM2fq1Vdf1ZAhQ9SxY0c1btxYW7du1bx583To0CENHz5co0aNkmTPU5eenq5+/fqpe/fuSk5O1r59+7Ro0SJt2LBBycnJmjZtWsD5d+zYobS0NHXs2FFbtmzxPz9nzhw9/fTTGjp0qFJSUhQbG6s1a9bos88+k8vl0iuvvKIOHTqE8p8CAACgYfB6pY0bA8O51avt56vSrVtg77kePaRjHIkBAAAQySLuJ5prr71WeXl5WrZsmRYuXKjCwkIlJiZq8ODBuvHGG3X99dfL+r85Rjp27KhJkyZpwYIFmj9/vg4cOKC4uDilpqbqwQcf1IQJE9SyZctjet8hQ4Zo3bp1Wrlypb7++msVFRWpTZs2+vWvf6277rpL/fr1q83LBgAAaDgOHJCWLy8P5zIypNzcqo9p3jwwnOvXT2rRIhStBQAACLk6tUpsXcMqsQAAoMErK5PWrAnsPbdhQ9XHuFzS6acHBnSpqfbzAAAAdVS9XSUWAAAAEW737sBwbsUKqbCw6mPatJEGDiwP5/r0kRISQtNeAACACERgBwAAgONTXGyv1FoxoNu6tepjYmKkM84I7D3XoYP0f1OeAAAAgMAOAAAAx8IYO4yrGM59/71UUlL1cSkpgeFc795SbGwoWgwAAFBnEdgBAADA6dAh6dtvAwO6PXuqPiY+3l4MwhfO9e8vJSeHpr0AAAD1CIEdAABAQ+f1Shs3BoZzq1fbz1elW7fA3nM9ekhR/HgJAABwoviJCgAAoKE5cEBavrw8nMvIkHJzqz6mefPAcK5fP6lFi1C0FgAAoMEhsAMAAKjPysqkNWsCe89t2FD1MS6XdPrpgQFdaqr9PAAAAGodgR0AAEB9smuX3WPOF86tWCEVFlZ9TJs20sCB5eFcnz5SQkJo2gsAAAAHAjsAAIC6qrjYXqm1Yu+5rVurPiYmRjrjjMDecx06SJYVmjYDAADgqAjsAAAA6gJj7DCuYjj3/fdSSUnVx6WkBIZzvXtLsbGhaDEAAACOE4EdAABAJDp0SPr228CAbs+eqo9p3Fjq27c8nOvfX0pODk17AQAAUGMI7AAAAMLN67UXgqg499zq1fbzVenWLbD3XI8eUhQ/3gEAANR1/EQHAAAQagcOSMuXS0uX2uFcRoaUl1f1Mc2bB4Zz/fpJLVqEpLkAAAAILQI7AACA2lRWZveWqzi0dePGqo9xuaTTTw8M6FJT7ecBAABQ7xHYAQAA1LQdO6R//lP68EO791xhYdX7t2kjDRxYHs716SMlJISmrQAAAIg4BHYAgKqVlkqHD0v5+faE97t22dvu3eX3d+2ScnLsubOaNHFuCQnH/nxCAr2IUDdt3y598IH03nvSN99Uvl9MjHTGGYG95zp0kCwrdG0FAABARCOww7F78klp3Trp+uulX/1Kio4Od4uAyGGMHWwVF0slJfZtxa2szJ483rd5PM7HZWX2OcrKyreKjz2e8s13zLFuFc/nO6fvvm8rLraDucJC+9a3lZaG/t+zcePqhXxVPd+4MQEggvPVgctVvllW+VaRMYG166ut/fuljz6yQ7olS4K/T8eOgb3neveWYmNr/fIAAABQd1nGGBPuRtRX+fn5atasmfLy8tS0adNwN+fEGCN16SL9/LP9ODFRGj5cGjlSOuccye0Ob/uA2lRQIGVnB27btpXf37HDDrka8sepZUktW9oBRkGBHYREksaNTzz48z1PABiZPB5p505pyxZp82b7dutW6eBB6dCh8q2goPx+UVHl57Os8gDP46l+fXfvLl13nXTttfbKrfSeAwAAaPCqkxMR2NWiehXYbd1qT36dn+98LTlZGjHC7nk3YAC/lKBuKS62A7cjQ7iK93Nzw93K0ImJsQOp+Hj7tuL9hAR7nq22be26b9u2/H7r1uW9bo2xexkWFDg3X2BS3ecjKQC0rMAA8ER7AjZuzOfmsfJ67dpcu9be1q8vD+e2bQv//5MePeyQ7rrr7MAOAAAAqIDALkLUq8BOsnsifPqp9O670scfB59Au2NHO7gbNcoO+IBw8njsedaChXC+x3v2nNh7JCRIJ59sBy+xsZVv0dGBw+5cLrtnasXH0dH2HHBRUYH3fZvbXb75jq/4+Mh9fJvved95j9x8z8fG2vcjjTF2sHoiwd+Rr3k84b6qcpZl/z+qqSHA8fF1PwAsLraDuE2bysO5tWvtaRkOHz7+88bHl/9b+7aYmPLhrr7tyMeV1Z7LZR/fv7/dky4treb+DQAAAFDvENhFiHoX2FV0+LD073/b4d38+XZvmiP17GkHdyNHSikpIW8i6jljpAMHgodwFYeqnkiPm+hoqX37wK1Dh8DHzZvX/XCkoTHG/gNEVSFfdQNBrzfcV1XOFwDW1BDg2ggAvV577rctW6SsLHu6hays8vvbt1dvCGrTptIpp9jfNb7blBT7j0itW9vX0rgx0zcAAAAgrAjsIkS9Duwqys2V/vUvO7z773+D91w56yw7vBsxQkpKCnULURcdOlR5rzjf/V9+Of7zW5Y9nPPIAK7i49atmasMR3dkAFgTQ4AjKQB0uQJDvWMN/hIS7O+HnTvt8HzHjvL7O3dWfzETy5I6dbKHnXbvbm9pafb8qs2b18aVAwAAADWKwC5CNJjArqK9e6U5c6R33gm+Wp7bLV10kXTrrdKwYZE5/A61r6TE7kETLITz3T/ReeNatqy8V1yHDlK7dqx0jMhkjB1G10Tw59vq0ld9y5Z2MNe5s735wrmuXaVGjcLdOgAAAOC4EdhFiAYZ2FW0ebPd6+7tt6WffnK+ftJJ0i232NvJJ4e+fagdHo89L1xlCzhkZ9vzyp2Ixo2r7hnXvr09jA+AHdYVFtZM8Od77kR+dGjZ0v78P+kk+7PfF8x17mwHdc2a1dy1AwAAABGEwC5CNPjArqLVq+1ed++8Y4c3Fblc0mWXSePHSxdeyBxDkcw3b1xVQ1VrYt64k0+uOpBj3jggfLxeZw/AygK+Jk3Kw7l27ewtLi7cVwAAAACEBYFdhCCwC8LjkT77TPrb36S5c53zNHXsKI0bJ91wAwtVhINv3riqArmamDcuWAjnu8+8cQAAAACAeojALkIQ2B3F9u3Sq6/a244dztf79ZN+/WvpuuvsIAcn5sh544KFcgcPnth7VJw3Ltgw1ZNOYt44AAAAAECDRGAXIQjsjlFZmTRvnvTKK9KnnwafG2nQIDu8u/Zau4cWAvnmjatsAYfsbPv1Eyn3xo0r7xXXvr09jLVx45q7JgAAAAAA6hECuwhBYHccNm+W/vEPe6XZVaucr1uWdM459kqzZ58tnXlm/Z8PqeK8cZUNVa2peeMqW1GVeeMAAAAAADghBHYRgsDuBK1fbwd3s2dLa9cG3ycmRurb1w7vBg+WzjpLatEitO08URXnjQsWyGVn2ys8Hq+q5o3zPWbeOAAAAAAAahWBXYQgsKtBa9aUh3cbN1a9b8+eUnq61KWLvXXubN8mJoa+h1hJid37rbIFHGpi3rjExKpXVG3Xzg42AQAAAABA2BDYRQgCu1pgjB3YLV5cvmVmHtuxzZuXB3innBI491r79vaCCdUJ9Lxeaffu4CGc735NzRtX2dxxzBsHAAAAAECdQGAXIQjsQmT37sAA7/vv7TCtuuLi7ADs5JOlpCSptFQqLrZ7yRUXl28lJdLhw9KuXTU3b1xlQ1WZNw4AAAAAgHqBwC5CENiFSWGh9PPPds+7iltWlt3z7XjCvOqyLCk5ufIVVdu3l9q0Yd44AAAAAAAaiOrkRFEhahMQOvHx9jx2PXs6XysulrZskbZutYesbt/uvM3Pr/zcsbH2FhdnL+RQ2dxxzBsHAAAAAACOE4EdGpbYWKlrV3urTH6+dOCAHbj5ArrYWCkqiuGpAAAAAACg1hHYAUdq2tTeAAAAAAAAwoAJtAAAAAAAAIAIQmAHAAAAAAAARBACOwAAAAAAACCCRFxgl5ubqzvvvFMDBw5UcnKyYmNjddJJJ+n888/XBx98IGNMwP4zZszQ5ZdfrlNOOUWNGzdWs2bN1KtXLz388MM6cODACbXl6aeflmVZsixLy5YtO6FzAQAAAAAAAMfCMkcmYGGWmZmp3r17a8CAAerSpYsSExOVk5OjuXPnKicnR+PGjdP06dP9+59zzjk6ePCg0tPT1bZtWxUXF2vZsmXKyMhQhw4dlJGRoeTk5Gq3Y926dUpPT1dUVJQOHz6spUuXasCAAdU6R35+vpo1a6a8vDw1ZREDAAAAAACABqs6OVHEBXYej0fGGEVFBS5gW1BQoAEDBmjt2rVas2aNevToIUkqKipSXFyc4zwPPfSQHn/8cd1zzz2aOnVqtdswcOBAWZalU089VW+99RaBHQAAAAAAAI5bdXKiiBsS63a7HWGdJDVp0kQXXXSRJLsXnk+wsE6SrrvuOse+x+qpp57SqlWr9Prrr8vtdlf7eAAAAAAAAOB4RVxgV5mioiJ9+eWXsixL3bt3P+r+8+bNkyT17NmzWu+zZs0aTZ48WQ8++KC/Fx8AAAAAAAAQKs6ubBEiNzdXzz33nLxer3JycjR//nxlZ2frkUceUWpqqmP/mTNnasuWLSooKNDKlSu1YMECpaen6+677z7m9ywrK9OYMWOUlpam++67r9ptLi4uVnFxsf9xfn5+tc8BAAAAAACAhi2iA7vJkyf7H0dHR2vq1Kn605/+FHT/mTNn6uuvv/Y/vvDCC/Xmm2+qRYsWx/yeTzzxhFatWqWMjAxFR0dXu81PPvlkQJsBAAAAAACA6orYIbEpKSkyxqisrEybN2/WY489pgceeEDDhw9XWVmZY/8FCxbIGKO9e/fq3//+t7Zv364zzjhDP/744zG936pVq/yLVJxxxhnH1eZJkyYpLy/Pv2VnZx/XeQAAAAAAANBwRWwPOx+3262UlBTdd999crvdmjhxombMmKHbbrst6P6tWrXSsGHDdPrppys1NVXjxo1TRkbGUd9n9OjR6ty5sx599NHjbmtsbKxiY2P9j30L8DI0FgAAAAAAoGHz5UO+vKgqljmWvSLEqlWr1Lt3b40YMUKzZ88+6v7p6elatWqVDh06pPj4+Cr3tSzrmNrw4Ycf6qqrrjqmfbdv36727dsf074AAAAAAACo/7Kzs3XyySdXuU/E97CraOfOnZKkqKhja/auXbtkWZbcbvdR97355puDPr9w4UJt2rRJV1xxhZKSkpSSknLM7W3Xrp2ys7PVpEmTYw4EUT/k5+erffv2ys7OVtOmTcPdHCAiUBeAE3UBOFEXgBN1AQRX12rDGKOCggK1a9fuqPtGXGD3ww8/6JRTTlGzZs0Cnj9w4IDuv/9+SdIll1wiSdq/f792796tHj16BOxrjNHkyZO1Z88eDR06NGCYamlpqbKyshQdHa3OnTv7n3/11VeDtmfMmDHatGmTJk2apAEDBlTrWlwu11ETU9RvTZs2rRMfGkAoUReAE3UBOFEXgBN1AQRXl2rjyLyrMhEX2M2cOVOvvvqqhgwZoo4dO6px48baunWr5s2bp0OHDmn48OEaNWqUJLsLYXp6uvr166fu3bsrOTlZ+/bt06JFi7RhwwYlJydr2rRpAeffsWOH0tLS1LFjR23ZsiUMVwgAAAAAAABULuICu2uvvVZ5eXlatmyZFi5cqMLCQiUmJmrw4MG68cYbdf311/uHl3bs2FGTJk3SggULNH/+fB04cEBxcXFKTU3Vgw8+qAkTJqhly5ZhviIAAAAAAADg2EVcYDd48GANHjz4mPZt0aKFnnjiiWqdPyUl5ZhW4/CZOXOmZs6cWa33AGJjY/XII48EDMcGGjrqAnCiLgAn6gJwoi6A4OpzbdSpVWIBAAAAAACA+s4V7gYAAAAAAAAAKEdgBwAAAAAAAEQQAjsAAAAAAAAgghDYAQAAAAAAABGEwA4AAAAAAACIIAR2AAAAAELGGBPuJgAAEPEI7AAAx2Xnzp3hbgIQcXbs2KGSkpJwNwOIOF999ZUefvhhFRUVybKscDcHAICIR2AHVGHr1q0aMmSIZsyYIYm/CAOSlJWVpfPOO0+33XabtmzZEu7mABFh8+bNGjt2rIYOHarHHnss3M0BIkZWVpYuv/xyDR06VHPnzlVBQUG4mwSE3c6dOzVz5kzNmTNH//nPf8LdHCAi7Nu3T1lZWcrJyZHH45Ekeb3eMLcqvAjsgEpkZ2friiuu0Ndff63HH39cBw8e5C/CaNDKyso0YcIEnXrqqdq0aZPOOeccNW3aNNzNAsLKGKMnnnhCaWlpWrBggVJTU9WqVatwNwsIO993Rmpqqr777jslJCTo559/9v8sxR9B0RB5PB7dd999Ou2003THHXfo+uuv16WXXqo//vGPysnJkURtoOHxeDy69957dcYZZ6hv377q2bOnbrnlFm3btk0ulx1ZNdS6ILADKtGoUSNt3rxZXbp0UXZ2tqZMmSKp4X5YoGF74403lJSUpNdee03jx4/X7NmzdeeddyoxMTHcTQPC6tVXX9XUqVM1fPhwzZgxQ++9954mTJgQ7mYBYTV9+nT/d8Ztt92m+fPna+jQoSooKNDixYsliT+CosHZuHGjhg4dqhkzZuiqq67S888/r7/97W8aOHCgXn/9dWoDDdLKlSvVt29fvfzyy+rbt69uvPFG9ezZU7NmzdJVV12lDz/8UFLDrYuocDcAiFR79uxRcnKyxo4dq9dff13PPfecRo8ere7du4e7aUDIeDwenXPOOVq6dKnOPfdc3XfffUpPT1fr1q0d+xpjGuyXKRoeY4xycnL0v//7v+rWrZueeeYZtWnTJtzNAsIqKytL11xzjVavXq0rrrhCY8aM0TnnnKPExEQNGjRIH330kX9fr9fr7zkBNASzZ8/WkiVL9Nhjj+mmm27yf2e0bt1aV199tXJzcyXx8xQaltdee03r1q3TlClTNGrUKCUlJamgoEBTp07V008/rQcffFBJSUkaPHhwg/zeILADKhEXF6fMzExdf/31io+P14QJE/Too49qzpw54W4aEBJer1dut1sXXXSRli5dqpSUFF100UWSpKKiIhUXFysvL095eXnq3r273G53mFsMhI5lWVq1apUyMzM1e/ZstWnTRoWFhVq9erWys7O1Zs0anXrqqbrggguCBtxAfbRlyxalp6fr1ltv1RVXXKH27ds79lm2bJmuuuqqBvdLFxq2rKwsvfDCC0pLS9N9990X8JrX61WrVq3UsWNHSQ23JxEantWrV2vGjBkaPHiw/vjHP0qyOws0adJEI0eO1PLly/XZZ5/p0Ucf1X//+98G+b3R8K4YqKCq4a0bN25U06ZN5fF4NHLkSA0cOFDvv/++Pvnkk6MeC9Rlvv/bvh8YH374YaWkpOiDDz7Q559/rr179+rZZ5/VsGHD1KVLFw0ZMkSDBw/We++9F85mA7Uq2Gf++vXrZYxRQkKCJHvo+A033KARI0boscce029+8xtdeeWV+uCDDyQxcTLqJ2OMvz6GDBmiqVOn6vbbb/eHdaWlpZKk888/X5L0888/q7CwMDyNBULkyO+MxMRERUdHy7IsrV+/XpIdTHz33Xd67rnnFBsbq9LSUq1YsUJFRUWS+M5A/XNkXXg8HsXGxuqUU06RJJWUlPg7AHTr1k2NGjWSJH399deaPn26pIZXFwR2aJB27dolKfAvWL4PEN9tfHy8Dh8+LI/Ho6SkJN12222SpIceesh/rO88QH1wZF1YlqWSkhJJ0rPPPqtDhw5pypQpuummm/TAAw/I5XLp+uuv15lnnqmMjAzddNNNmjVrlv8YoD4I9n3hW7nM13Nu27Ztev/993X33XcrNTVVixYt0kcffaS77rpLGRkZGj9+vPbs2SOXy8Ufe1BvVKwNX324XC4lJSVJKv95Kjo62n/btm1bHTx4UPHx8dQC6qVg3xmSFBUVpcsuu0w//vijHn74YX300Ud6/PHHddttt2nRokVKSkrSr3/9a/Xv318jR47Uvn37+M5AvVFZXRQVFcnlcmnZsmWSpJiYmICOA77vDY/Ho1mzZik/P7/h9bIzQAPy3XffmUsvvdSkpaWZLl26mPHjx5tFixYZY4zxer0B+7766qsmMTHR7NmzxxhjTFFRkRk5cqSxLMtMnDjR9OzZ0wwePNjk5uaG/DqAmlRVXXg8Hv9+559/vrEsy3Tr1s3861//Cnj9pZdeMu3btze9e/c2K1asCP1FADXsWL4vFi9ebJo1a2ZGjRplhg0bZs455xzHecaPH28syzI333xzSNsP1Jbq/CxV0f79+03r1q1No0aNzLZt20LVXCAkqqoLn02bNpmLLrrIWJZlYmJi/D9Tffzxx2b79u0mIyPD/7vGTTfdZIypuqaASHcsdXHJJZcYy7LME088YQ4fPmyMMWbfvn3mhRdeMI0aNTJvvfWWufjii02LFi3M119/HY7LCCsCO9R7Xq/XeDwe8/zzz5vY2FiTlpZmLrvsMnP22Wcbt9ttEhISzKeffurfv7S01BhjzMsvv2yaN29uduzY4X9t7ty5Ji4uzrhcLpOUlGTuuusus2/fvpBfE3CiqlsXxhizdu1ac+aZZ5pVq1b5nysrKzPGGHPgwAHz5z//2bjdbvPaa6/53wOoS6pbF5s2bTIDBgwwbrfbWJZlpk2bZowxpri42F8bOTk5JiEhwbRq1cr8/PPPYbku4EQdz3dGRb4/7gwfPtwkJiaa5cuXh6rpQK05nrrIy8sz69evN9OmTTOXXHKJ2bVrV8Dr+/fvN0lJScayLLN69epQXg5QI461Lny/JyxatMicfPLJJioqygwZMsTcdddd5qqrrjLNmzc3F110kdm6dat59NFHjWVZ/npqSL9jENihQcjOzjannnqq6du3r1myZIn/+enTp5uEhATTvn1785///CfgmIkTJ5pOnTr5H0+ZMsXExcX5fzG75pprQtZ+oDYcT12sXbu20i/Jt99+21iWZcaOHVur7QZqU3Xr4tFHHzWJiYnGsizz4IMPBpyrqKjIGGPMVVddZdq0aWM2bNgQmosAasHxfGdUVFxcbG6++WZjWZb58ssvjTGBvbiBuqi6deHxeMzhw4fN6aefbsaMGWOMKQ8fCgsLjTF2z2y3211lCA5EsmOpi08++cT//D//+U9z6aWXGsuyTNOmTU3Lli3NnXfe6f856qWXXjKWZZkXX3wx5NcSbg1sADAaqrffflubNm3SHXfcoYEDB/qfHzdunKZOnaqCggI9/fTT+vHHH/2vud1utWjRQv/4xz/UpUsXTZo0SWeffbaefPJJpaam6uOPP9bq1aslsQAF6qbjqYu0tDTH/BNlZWWS5J9437fKGVAXHWtdfP/995KksWPH6rTTTpMk/fDDD8rKypJkT7QfGxsrSdq+fbsOHz6sJk2ahPhqgJpT3e+Mij8bGWMUExOjU089VZK0YMECSWp4cxGh3qluXbhcLuXk5GjLli3q2bOnJHsSfa/X659gf9u2bfJ6vf75IIG65ljqYurUqfrhhx8kSVdffbU++ugjbdy4UR999JFWr16t559/3v9zlO/7JD09PeTXEm58S6JeO3IVmdTUVEn2hOG+wh8+fLjGjh2rBQsW6F//+pd/5bL9+/dr5cqVuvHGG+V2uzVlyhS98soruvfeezVhwgR5PB7deuutklh+HXXL8dTFL7/8Uul5oqKidODAAb388suyLEsXXHBBLV8BUPOqWxdz587V4cOH1b59e91+++3q1q2bvvjiC7366quS7An28/LyNG3aNP30008aN26c2rZtG9qLAmrA8X5nBPvZqG/fvoqKivKvHNvQVvtD/XEiP0sdOHBAjRo10nvvvac9e/bI7XbL5XLp4MGDevHFF7VgwQKNHDmyQYYTqNuqWxcff/yxvy4sy1KXLl103nnnBfy8dPDgQc2aNUsdO3ZUp06dGtz3BoEd6rUj/3Lr6xFXcUWzpKQkjRo1SmlpaZo9e7bWrFkjSbrzzjuVnp6ucePG6a233tLEiRPVqVMnSdKIESN08cUXa/jw4SG8GqBmHE9d/PTTT0HP4/F4tGjRIk2YMEFffvml/vCHP6h///61fxFADTuRurjmmms0efJktWrVSk899ZR+/etf64EHHtAdd9yh+++/X126dNHIkSNDe0FADamJ74yK4V1ZWZl/RUB62KGuOpHfMXr27Kmzzz5by5cv129+8xu98847euutt/Tggw/q/vvvV0pKisaPHx/aCwJqwIl8X7jd7oBjjTFasmSJJkyYoHXr1mnixIlKTk5ueN8bYRqKC4SEb26UxYsXG8uyzPnnn++fH6LiPFyFhYXmL3/5i3G5XObll1/2P79+/XpTXFwccD7fROK+W6CuOZG68Hq9pqSkxPz888/m1VdfNTfffLPp3LmzsSzL3H333f7zAHXNiX5f+I4dNmyYsSzLxMXFmZYtW5pbbrnF5Ofnh+5CgBp2ot8ZFZWWlhrLskynTp0ck+0DdcmJfmcsWbLEXHnllcayLP8WExNjxo4dy3cG6qya+r6YOnWqGT16tElNTTVRUVFm0qRJAb+TNyQNLJ5EQ+NL4AcNGqRBgwZp+fLlmjt3rmO/Ro0aadCgQWrSpIk+/PBD//Ndu3ZVTEyMv+uty+Xyp/9H/hUAqCtOpC4sy1J0dLQ++OAD3XPPPZo7d6569OihH374QX/961/9868Adc2Jfl/4jv33v/+tn3/+WcuWLdPKlSs1Y8YM5q5DnXai3xkV5ebm6pFHHtHHH3+s5OTk2m88UEtO9Dtj4MCBmj17tqZPn64XXnhBU6dO1Zo1a/Taa6/xnYE6q6a+L7755ht9/vnn6tmzp7777js98cQTiomJCc1FRBjLGGbLR8Pw7rvvatSoURo2bJhmzJih5ORkeb1e/wdLWVmZevbsqUOHDmn58uVq165dmFsM1L7jrYtdu3bp22+/Vfv27dW7d+8wXgFQ8/i+AIKjNgCn46mLiq8D9dHx1IXH45Hb7VZBQYF27drlX6ioIeNTAnWKMUbffvutMjMzdeDAgaPuW9FFF12kyy67TPPmzdNrr70myf4rgG9lpqioKLVv314JCQlMDI46JRx10bZtW11++eWEdYhYfF8AwVEbgFOo64KwDnVBqOvCN4KtSZMmhHU+4RiHCxyP119/3aSmppqmTZua2NhYk56ebv7+97+bw4cPG2PKx8wfOV/K9u3bzdatW40xxixfvtw0adLExMTEmPnz5wfst2jRItOkSRNzzTXXGI/H4zgPEImoC8CJugCCozYAJ+oCcKIuIgOBHSLewYMHzfjx441lWeaCCy4wd911l5kwYYJp0qSJiY6ONnfccYd/ctaKC0EcOHDAfPDBB+aSSy4xo0eP9k9uPGvWLGNZlmnatKmZPHmyWbZsmXnjjTfMeeedZ1q1amU+//zzsFwnUB3UBeBEXQDBURuAE3UBOFEXkYXADhFv3rx5JiEhwVx33XVm/fr1/ue/+OILk56ebizLMvfff78xxk74y8rKzKJFi8ytt95qmjZtaho1amTeeeedgHO+/vrrpk+fPsayLBMbG2uioqJMcnKymT17dkivDThe1AXgRF0AwVEbgBN1AThRF5GFwA4RzePxmEsvvdS4XC6TlZXlf84YY4qKisy0adP8S6EvX77cGGPMpk2bzCWXXGIsyzJ/+tOfArrXVvwrwN69e81bb71lnn/+efP666/TDRd1BnUBOFEXQHDUBuBEXQBO1EXkiQr3HHpAZYwx/okpmzdvrpKSkoDnYmNjlZSUpNjYWBUXF+vee+/VggUL1KVLF40YMUJ/+9vf1L59e0n2KjRRUVH+iSyNMWrVqpVuuOGGcF4iUG3UBeBEXQDBURuAE3UBOFEXkYnlaRAR9uzZo/z8fP3yyy8BzxcWFqpNmzY6ePCgMjMzZVmW/4NDsleSady4sRISErRw4ULNnz9fkjRmzBi1b99eHo/HvwpNRZZlhebCgBNAXQBO1AUQHLUBOFEXgBN1UXcQ2CGs8vPzNX78eA0cOFDdu3fXWWedpZdeeknGGFmWpfj4eJ199tmSpMcff1zffvutLMuSx+PRf//7X917770aM2aMnn32WUnSZ5995j+3MUZut5tl01HnUBeAE3UBBEdtAE7UBeBEXdQ9DIlF2CxdulSjR49Wbm6uzj33XMXFxWnhwoX6wx/+oFWrVumxxx5TmzZtNGrUKH3zzTf6+9//rksvvVSXXHKJCgoK9MMPP6iwsFC/+tWv1LFjRyUmJmrv3r2SJK/Xy4cF6iTqAnCiLoDgqA3AiboAnKiLOqp2p8gDKnfrrbeaRo0amVmzZpmCggJjjDHr1q0zw4YNM5Zlmbvuusvs3LnTGGNMZmamefLJJ02LFi1M69atTYsWLcyll15q1q1bZ4wxZtu2baZdu3amX79+YbseoCZQF4ATdQEER20ATtQF4ERd1E0EdgiLtWvXmpYtW5oLL7zQ/5xvFZlVq1aZiy++2MTHx5sXXngh4LgdO3aYtWvXmp9++ing+d27d5vmzZubcePGGWMMq86gTqIuACfqAgiO2gCcqAvAibqou+i3iLCIjY3VoUOHdNJJJ8nr9aqsrMy/isxpp52mSZMmKTY2VrNmzdKqVaskSR6PR+3atVNaWpq6d+8ecL5p06YpLy9PF1xwgSQmtkTdRF0ATtQFEBy1AThRF4ATdVF3EdghLIqLi9WqVStlZWXJ5XIFrCRjWZb69++v3/3ud1q5cqXmzZvnn8TySOvWrdNTTz2lV155RVdffbWuvPLKUF4GUKOoC8CJugCCozYAJ+oCcKIu6rBwdu9Dw1VSUmL69OljLMsyixYtMsaUd8v1+eGHH0yHDh3Meeed5x9P7/PVV1+Z3/72t6Zv377G5XKZCy+80GRlZYWs/UBtoC4AJ+oCCI7aAJyoC8CJuqi76GGHkPN4PIqOjtYtt9wiSXr55ZclyZHid+jQQeedd56WLFmiQ4cOSbJXoJGk3bt3a8WKFYqPj9fs2bP16aefqlOnTiG8CqBmUReAE3UBBEdtAE7UBeBEXdRx4U4M0fB4PB5jjDFFRUXm1FNPNbGxsebDDz80xjiT/smTJxvLssysWbOMMYETWmZmZoamwUAIUBeAE3UBBEdtAE7UBeBEXdRt9LDDCduxY8cx7WeMkSS5XPZ/u9jYWD3yyCMqKSnRk08+qfz8fLndbpWVlam0tFSSlJqaKslO/KXACS07d+5cY9cA1DTqAnCiLoDgqA3AiboAnKiLhoXADsdt5cqVGjhwoO68805t27ZNUvkHw5GMMf6Cz83N1apVq1RWVqZRo0bpyiuv1IoVK3TXXXeppKREUVFRio6O1t69e/Xmm28qISHB/6EBRDrqAnCiLoDgqA3AiboAnKiLBirUXfpQ9xUXF5vp06eb5s2bG8uyTNu2bc0bb7xx1ONKSkrMokWLzK233mp69epl/vnPfxpjjNm1a5fp16+fsSzLXHDBBeb999837777rrn11ltNXFycueeee2r5ioATR10ATtQFEBy1AThRF4ATddGwEdihWoqKisxrr71mmjVrZpo2bWomTJhgmjdvboYMGWJ++uknY0zgWHefzMxMM3nyZNO5c2djWZaZMGGCfzy9Mcb8+OOP5o477jBut9tYlmXcbreJjY01f/7znwP2AyIRdQE4URdAcNQG4ERdAE7UBQjsUG1jx441/fr1M+vXrzfGGHPnnXcat9ttnnzySVNSUuLYv7i42Dz33HP+FL/iEtBHfiAsWLDAzJkzx8yYMcNkZ2fX7oUANYi6AJyoCyA4agNwoi4AJ+qiYbOMqWTgMxo8U2Hsu2QvCe12u7VlyxaVlZWpS5cuMsZo6dKlGj16tGJjY/XKK69o8ODBjnNlZGRIkvr37+8/l2VZ/kkwj3wvIFJRF4ATdQEER20ATtQF4ERdIBgWnUBQJSUlys/PV3Fxsf85t9stSUpJSVGXLl0k2SvH9O7dW7fccovWrl2r9957T7m5uZICJ8Hs379/wAeG2+32f2D4zgNEOuoCcKIugOCoDcCJugCcqAtUhsAODtOmTdP555+vc889V926ddOUKVO0detWSXbBHyk+Pl5XXnmlzjrrLM2ZM0dfffWVpMo/CHwfPkBdQl0ATtQFEBy1AThRF4ATdYGqENjBb/ny5erfv78mTJig/Px8NWnSRB6PR/fff7/Gjx8vqfKC79Kli8aPH6+DBw/qnXfe8X/IlJWVhaz9QG2gLgAn6gIIjtoAnKgLwIm6wDEJ1WR5iGyLFi0yvXr1Mt26dTOvvPKKf9LJbdu2mbS0NGNZlvnggw+MMc7JKn22b99uRowYYRo1amReeukl//P5+flm3759VR4LRCLqAnCiLoDgqA3AiboAnKgLHCsCO5jc3FwzbNgw07hxYzNnzhz/86WlpcYYY95//31jWZa58847j3qu+fPnm6SkJHPuueealStXmq+++sqMGTPG3H333XxgoE6hLgAn6gIIjtoAnKgLwIm6QHUwJLaB8nq9/vvNmjVT69at9cYbb+i6666TZE9a6euC26FDB0lS8+bN/a8dyTe+/oILLtDYsWO1dOlS3XHHHRoxYoRmzZql6OjogPcEIhF1AThRF0Bw1AbgRF0ATtQFjldUuBuA0Nq3b59atWrlXyXGt2rMk08+qcaNG/v3qzhpZV5eniSpZcuWjtd8fB8we/fuVUlJiUpLS7VkyRINHDhQ8+fP15lnnllr1wScKOoCcKIugOCoDcCJugCcqAucKAK7BmLnzp166KGH9OOPP8rlcqlXr166/fbb1atXL0lS69atK11ZZuXKlZKk0047rdLze71effrpp3rqqae0cOFCJScn67nnntOIESNq/mKAGkJdAE7UBRActQE4UReAE3WBmsKQ2HrM1332H//4h3r06KFPPvlECQkJKi4u1qxZs3ThhRdq9uzZkoIn975VZpYsWaKTTjpJaWlpkhS0e21paamWLVumjIwM/fnPf9bOnTv5wEBEoi4AJ+oCCI7aAJyoC8CJukCtCPWkeQitQ4cOmT59+pi0tDTzySefGI/HY8rKysw777xjoqOjTZMmTczChQuN1+sNenxZWZlJTEw0w4cPNx6PJ2A/333f7caNG/0r0gCRjLoAnKgLIDhqA3CiLgAn6gI1jR529dz777+vlStXasyYMbr44ovlcrlkWZZGjhypZ555RpZl6cEHH9T69euDHv/NN9/o4MGDOuuss/zH5uXlac6cOf6/EPikpqb6x9oDkYy6AJyoCyA4agNwoi4AJ+oCNY3Arp7ydZ0tLS2VJPXu3TvgsST95je/0c0336xFixbpvffe0+HDhx3Hf/HFF5Kk888/X5K0aNEiPfzww7rhhht099136+DBg5WOvwciDXUBOFEXQHDUBuBEXQBO1AVqC4FdPbFp0ybl5OT4C9+3Eo3v8bJlyyRJ0dHR/teaN2+u66+/Xr1799asWbOUlZXlP5/5vzH4CxcuVNeuXXXo0CFNmTJFo0eP1v/7f/9Pt99+u7Zs2aIWLVqE7BqB6qIuACfqAgiO2gCcqAvAibpAyIRzPC5O3D//+U8zcOBA065dOxMfH28GDx5s/vGPf/hf37hxo7EsywwdOtTs2rXLGGMCxsKXlZWZv/zlL8ayLPPXv/7V/5wxxuzfv98kJiaajh07mkGDBhnLssyvfvUrs2nTphBeIVB91AXgRF0AwVEbgBN1AThRFwg1Ars6aufOnea3v/2tcblcpk+fPuaaa64xV111lbEsy8TExJjPPvvMeL1eU1xcbK644grTrFkz8/bbbwecw/fhsWTJEtO8eXPTu3fvgNc/+ugjY1mWsSzLpKammo8//jhk1wccD+oCcKIugOCoDcCJugCcqAuEC4FdHbRr1y5zww03mJYtW5pJkyaZtWvX+l97+umnTXR0tLn88suNMcaUlJSYd99918TFxZkrr7zSZGVlGWOM8Xg8Aefs27evadOmjdmwYYP/uZ07d5q0tDTz4osvhuCqgBNDXQBO1AUQHLUBOFEXgBN1gXAisKuD3nzzTWNZlpk4caK/C61PTk6O6dq1q4mJifF3w83OzjYjR440MTEx5n/+53/86X5paakpLS01xhhz9dVXm3bt2pnCwkJjTHnXXN/rQKSjLgAn6gIIjtoAnKgLwIm6QDix6EQd1L17dz355JOaMmWK3G63f5JKj8ejpKQkdejQQe3atfOvIHPyySfr97//vdq1a6dnnnlGb7/9tiQpKipKUVFRyszM1PLly9WpUye5XC55vV653W7/PkBdQF0ATtQFEBy1AThRF4ATdYFw4n9EHZSenq6UlBRZliVjjP/Dwe12y+PxKCsrS40bN1ZCQoL/mMGDB+uvf/2rrr32Wo0dO1b79u3Tueeeq23btmnmzJkqKCjQ73//e8XGxobrsoATQl0ATtQFEBy1AThRF4ATdYGwCk/HPtSWzZs3m8TERDN69GhjjHO8/CuvvGJ69+5tLMsyjRo1Mo0aNTLx8fHm2WefDX1jgRChLgAn6gIIjtoAnKgLwIm6QG2jh1094fV65XK5tGrVKh08eFADBgwIeN5n3Lhxuv766/X2228rPz9fbrdbY8eOVcuWLcPVdKDWUBeAE3UBBEdtAE7UBeBEXSBUCOzqCd8Hw4IFCxQTE6N+/fpJKh8HX1xcrKioKLndbjVr1ky///3vw9ZWIFSoC8CJugCCozYAJ+oCcKIuECqWMf83ayLqvLKyMvXv31+FhYVat26dJKmkpESLFy/WsmXLNGTIEA0cODDMrQRCi7oAnKgLIDhqA3CiLgAn6gKhQA+7emTDhg3KzMzU2LFjJUkrV67UvHnzNH36dO3YsUNz584NcwuB0KMuACfqAgiO2gCcqAvAibpAKBDY1QPm/1ar+e6773T48GG1bNlSs2bN0osvvqjvvvtOl19+uRYtWqSUlJRwNxUIGeoCcKIugOCoDcCJugCcqAuEEoFdPeBbWvrrr7+W1+vV/Pnz9d1336lz5876/PPPNXTo0DC3EAg96gJwoi6A4KgNwIm6AJyoC4SS6+i7oC4oKirStm3bJNndc6dOnaq1a9fygYEGjboAnKgLIDhqA3CiLgAn6gKhwqIT9cjzzz+v/fv364EHHlBsbGy4mwNEBOoCcKIugOCoDcCJugCcqAuEAoFdPeIbTw+gHHUBOFEXQHDUBuBEXQBO1AVCgcAOAAAAAAAAiCDMYQcAAAAAAABEEAI7AAAAAAAAIIIQ2AEAAAAAAAARhMAOAAAAAAAAiCAEdgAAAAAAAEAEIbADAAAAAAAAIgiBHQAAAAAAABBBCOwAAAAAAACACEJgBwAAAAAAAEQQAjsAAAAAAAAgghDYAQAAAAAAABHk/wPuEHPZGWnkMwAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "display.Image('nonlocal_cli_edu_humboldt_tdp_salt.png')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "6bafb68c-1f6f-4504-b01b-17230f151b84",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "display.Image('nonlocal_cli_bodega-bay-bml_wts_salt.png')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "dfbe9394-c2c0-42f8-b203-e489dd50a2bf",
-   "metadata": {},
-   "source": [
-    "### Nonlocal reader: region"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "c2054461-ab60-4f47-b6fd-fc3b3198e5c0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "config_file = 'config_nonlocal_region.yaml'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "a00d05bf-1fa2-4134-95e3-018afc2f25e9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# %load config_nonlocal_region.yaml\n",
-    "---\n",
-    "approach: \"region\"\n",
-    "loc_model: \"https://thredds.cencoos.org/thredds/dodsC/CENCOOS_CA_ROMS_FCST.nc\"\n",
-    "axds:\n",
-    "bbox:\n",
-    "  - -124.5\n",
-    "  - 40\n",
-    "  - -123.5\n",
-    "  - 42\n",
-    "criteria:\n",
-    "  salt:\n",
-    "    name:\n",
-    "      \"sea_water_practical_salinity$\"\n",
-    "erddap:\n",
-    "  known_server:\n",
-    "    \"ioos\"\n",
-    "figname_map: \"nonlocal_cli_region.png\"\n",
-    "figname_data_prefix: \"nonlocal_cli__region\"\n",
-    "local:\n",
-    "only_search: false\n",
-    "only_searchplot: false\n",
-    "parallel: true\n",
-    "readers:\n",
-    "  - \"erddap\"\n",
-    "run_qc: false\n",
-    "skip_units: true\n",
-    "stations:\n",
-    "time_range:\n",
-    "  - \"2021-9-1\"\n",
-    "  - \"2021-9-8\"\n",
-    "var_def:\n",
-    "  salt:\n",
-    "    units: \"psu\"\n",
-    "    fail_span:\n",
-    "      - -10\n",
-    "      - 60\n",
-    "    suspect_span:\n",
-    "      - -1\n",
-    "      - 45\n",
-    "variables:\n",
-    "  - \"salt\"\n",
-    "xarray_kwargs:\n",
-    "  chunks:\n",
-    "    time:\n",
-    "      1\n",
-    "    depth:\n",
-    "      1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "bb8f67ca-f638-4f8d-9c1d-381300a93100",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!python ../ocean_model_skill_assessor/CLI.py $config_file"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "cd5e067b-03ce-4496-aeb6-549e6e2bd15c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "display.Image(\"nonlocal_cli_region.png\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "cebded2b-4f29-4018-a8d1-443fb5c0aa59",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABPgAAAHICAYAAADTBVSQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAADNEklEQVR4nOzdd1hT5/s/8HfYQ4aIA5DhFsWCCoqtCmrddQsf96p71do66q62dbeuure1dVtrnVVR6xZnUalCHQgiigKyR57fH/xyvsQECBAIyPt1XV6Ss5775Iyc3HmGTAghQERERERERERERCWSnq4DICIiIiIiIiIiovxjgo+IiIiIiIiIiKgEY4KPiIiIiIiIiIioBGOCj4iIiIiIiIiIqARjgo+IiIiIiIiIiKgEY4KPiIiIiIiIiIioBGOCj4iIiIiIiIiIqARjgo+IiIiIiIiIiKgEY4KPiIiIiIiIiIioBGOCj6gY27p1K2QyGQYNGqTrUIo9mUwGmUym6zAon1xcXCCTyfDkyRNdh1Is5Pd89vX1hUwmw9mzZ7UfFFEpN2jQIMhkMmzdulXXoRARERGpYIKPiLTi999/x5w5c3D79m1dh0KFJCMjAydOnMC4cePQoEEDWFhYwNjYGM7OzhgwYABu3ryp6xCJiCgbSUlJOHjwIL755hu0atUKVlZWkMlkqF69eoG3HRMTg6+//hrVqlWDiYkJ7Ozs0LdvXzx48EALkRMREZEmDHQdABF9GH7//Xds27YNLi4u8PDwKPLya9WqVeRlljZbt27F0KFDAQAGBgaoWbMmDA0N8fDhQ+zYsQO//fYbfv75ZwwfPlzHkZZeTk5OqFWrFszMzHQdCtEHx87ODrVq1YKVlZWuQ8mXf//9F927d9f6diMjI9GkSRM8efIEZmZmqFu3LsLCwvDrr7/i4MGDOH78OJo3b671comIiEgZa/AR0QchODgYwcHBug7jgyaEQIMGDbBjxw7ExMTg3r17uH37NiIjIzFo0CCkp6dj9OjRuHv3rq5DLbW2b9+O4OBgNGrUSNehEH1w5s+fj+DgYHTr1k3XoeSLoaEhvL29MW7cOOzYsQObN2/WynYHDRqEJ0+eoGnTpnj27Blu3LiB8PBwjBs3DklJSfD390dCQoJWyiIiIqLsMcFHREQa6dGjBwIDA9GvXz+Ym5tL0y0tLbFhwwa4ubkhIyMDmzZt0mGURESkTt26dXH58mWsWLEC/fr1Q5UqVQq8zcDAQJw4cQIGBgbYuXMnypUrByAzmfjTTz/B1dUVL1++xPr16wtcFhEREeWMCT4q9dLT07F27Vo0bdoU1tbWMDExQe3atTFjxgzExcUpLfvLL79AJpOhUqVKePXqlcq2zpw5Az09PZibm+PRo0fS9Kwdcz98+BD/+9//UKFCBZiamqJ+/fr5/hX93r176N+/PypXrgwjIyNUrFgRPXr0wJUrV9QunzWOx48fY9CgQXBwcICBgQHmzJkDILOftUOHDmHIkCGoW7curKysYGZmBldXV0yePBmvX79W2uaTJ08gk8mwbds2AMDgwYOlAQJkMpm0XYXo6GhMnjwZtWrVgqmpKcqWLQtfX1/s3LkTQgiVmLMONJKQkIBp06ahZs2aMDExga+vr7RcdoMS5DZYQXaDO2Sdfu7cOXz66aewtraGjY0NunXrpnR8//jjDzRr1gyWlpYoW7YsevfujYiIiGzLzI7ivXRxcYEQAitXrkS9evVgZmaGChUqoH///nj27Fm266enp2PDhg1o0aIFypUrBxMTE1StWhU9evTAoUOHVJZPS0vDypUr0ahRI1haWsLc3Bzu7u74/vvvkZiYqLJ82bJls30vDQwM0LJlSwDAw4cP87zvWZ04cQK+vr6wsrKCpaUlWrdujb///lvtsrkNzpHToBN52f/jx49DJpPho48+yjbu1NRUlCtXDjKZDPfu3dN4f3Pz66+/olGjRihTpgxsbGzQtWtXBAUFqV02u/2NiYnBpk2b0KVLF1SvXh2mpqawsrJC48aNsWLFCqSnp6vd3tOnTzFixAhUrVoVxsbGsLCwQNWqVdGtWzfs2rVLa/uYNe7g4GD4+fnB1tYWpqamaNiwIfbs2aN2vcjISKxcuRJt27aFi4sLTExMULZsWfj4+GDHjh1q18l6nQGZ93VPT0+YmZnBxsYGfn5++O+//7S2bwpCCOzduxcdOnRAhQoVYGxsDCcnJ7Rv317toA1CCPzyyy/w8fGBtbU1TE1NUbt2bUyZMgVv3rxRW0bW+93+/fvRvHlzWFtbS9fI+/u+YcMGeHl5wcLCQiuDFGX9jImIiMCQIUNgZ2cHExMT1K1bFz///LPa9fJ7fmbd32PHjqF58+awsLCAlZUV2rdvj1u3bhV4n7LbP3WOHDmCdu3awdbWFsbGxqhSpQpGjx6NsLAwtcv/999/WLhwIXx9feHo6AhjY2OUL18e7dq1w5EjR7Qae2HZv38/AKB169ZwcnJSmqevr4+BAwcCAPbu3auV8t4/hzdu3Ij69evDzMwMDg4OGD9+PN69ewcg83lm6dKlqFu3LkxNTVG5cmVMnToVqampKtsVQmD79u3SNWNkZIRKlSqhYcOGmDx5Mp4/f652nV27dqF169YoV64cjI2NUbVqVYwfPx6RkZFa2V+FD/3ayvoZcPfuXXTp0gW2trawtLTEp59+isDAQGnZv//+G+3atYONjQ0sLCzQsWPHbFtwBAUFoW/fvnB0dISRkRGsra1Ro0YN9OnTB8ePH1daNj/nQH6cPXsWMpkMvr6+kMvlWL58Odzc3GBiYoKKFSvi888/V/sdAwD++usvjB07Fu7u7rCxsYGJiQmqVauGUaNGZft8mN9zJ780eW6fM2eO9B0hOjoao0ePRuXKlWFqagp3d3el54unT59i8ODBsLe3l54Jsrs/RkdH4+uvv0bt2rVhYmICc3NzuLi4oF27dli9erXadd68eYPp06fDzc0N5ubmsLCwgLe3NzZs2AC5XK7V9ya/11VQUBBmz56NJk2awM7ODkZGRrCzs0P37t1x6dIltetkPQ4pKSmYM2cOqlevDhMTEzg6OmLixImsWf2hEkSlWGxsrGjevLkAIPT09ISzs7Nwc3MTRkZGAoBwdXUVL1++VFrH399fABBdunRRmv727VtRuXJlAUCsWbNGad7AgQMFADFt2jRhZWUljI2NRYMGDYSzs7MAIACIcePGqcS3ZcsWAUAMHDhQZd6hQ4eEsbGxACCsra2Fp6enKF++vLQv69evV1lHEcfUqVOFtbW1FEft2rXFnDlzhBBChIWFSduws7OT5puYmAgAwsXFRURGRkrbfPHihfjkk09EhQoVBABRo0YN8cknn0j/Nm3aJC376NEj4ejoKAAIIyMj0aBBA1G1alXpPRgwYICQy+Vq3wN/f3/RoEEDIZPJhKurq6hfv75o06aNtJxiG+/LbrqC4hg8fvxY7fQff/xR6OvriwoVKogGDRoIc3NzAUDY2dmJFy9eiB9//FEAEJUrVxbu7u7SMalVq5ZISkrKtlx1Hj9+LAAIZ2dnMWrUKAFAODk5iYYNG0rvf/ny5UVwcLDKum/evBGffPKJtL/Ozs7C09NTOi7Ozs5KyycmJoqWLVtKy7u6uoqPPvpI6OnpCQDCw8NDvH79Ok/xDx8+XAAQ3bp1y9N6Qvzf+z1//nwhk8mEjY2N8PT0FOXKlZPOxz179mS73vvHT8HHx0cAEAEBAUrT87r/GRkZ0rl748YNtWXt27dPABCenp7SNMX23y8/N4r1Fi5cKACISpUqCU9PT2FhYSEACFNTU/H3339rvL87duyQrjtnZ2fh5eUlqlatKu1vx44dRUZGhtI6jx8/Fra2tgKAMDMzE/Xq1RMeHh7CxsZGABDu7u7Zlj979uw87a9ivSVLlogyZcoICwsL0bBhQ+meBkDs2LFDZb158+ZJ70e1atWEp6encHJyktYZOXKkyjpZr7OpU6dKf2e9fu3s7MSrV6/ytA85SUlJEd26dZPisrOzE15eXsLBwUHIZDKVe5RcLhd9+vSRlq9atapo0KCB9Nnk7OwsQkNDVcpRLL9gwQIBQFSsWFF4eXmJ8uXLi8ePHyvt+8iRIwUA4ejoKDw9PYW1tbW0HcVnhbrPnpwo1pszZ46oVKmSMDExEQ0aNBD29vZSbN99953Kevk5P7Pu75o1a4RMJpM+sxT36TJlyogHDx7kaR802b8tW7aozFOcS4rPg4YNGwozMzMBQJQtW1Zcv35dZZ3PP/9cirNmzZrC09NT2NnZKR3HnOLI6/F5X0BAgAAgqlWrlu9t+Pr6ZntchRDi77//lo5tenp6vstRyHoOT5w4UYrfzc1NGBgYCACiZcuWIiMjQ3Tt2lW6v9eqVUu61gYMGKCy3a+++kp6352cnISXl5eoUqWKdM0dPHhQafnU1FTh5+cnrWNvby/c3d2lY25nZyf+/fdflXJ4bamn+AxYsGCBMDU1FdbW1qJhw4bCyspKABAWFhYiKChI7NmzRxgYGEjPZIr3u3z58krPpkIIcfXqVWFqaioACCsrK+Hu7i7c3Nykbb7/HJ/Xc0Bx/eT167RiPR8fH+k+X6NGDVG3bl3pHK5bt65ITk5WWVdfX1/IZDJRoUIF4eHhIdzc3KRjUq5cOXHv3j2VdfJ77uSXJs/ts2fPFgDE+PHjRfXq1aXvBA4ODlJM27ZtE8HBwaJChQrCzMxMNGzYUHom0dfXF3/99ZdSuTExMaJatWrS+V6nTh3RoEEDUaFCBSGTyYSVlZVKrEFBQVKZinWqVasm3St69uyp8r1EiII/2+X1umrVqpUAMr/vubq6igYNGii9Fzt37sz2OPTp00c0b95cyGQyUbduXVGrVi3p+m/dunWe4qeSgQk+KtV69eolAIhWrVopfVl68+aN6N69u3Rzzyo6Olr6UNy4caM0vXfv3gKA6NChg0o5ig9XAwMD0aJFCxEVFSXN27t3rzA0NBQAxJ9//qm0XnYJvvDwcGFpaSkAiC+++EKkpKQIITKTEN9//70AIAwNDcWdO3fUxqGvry86d+4soqOjpXmKZFRMTIzYunWr0jwhMhOYY8eOFQDEoEGDst1HdV98hMj8wurp6Sk91GR9EDt27Jj04bZ69Wq174G+vr6oWbOmuH//vkrMQhRegs/Q0FAsXbpUegB++/at8Pb2lh6MzczMlD5Ynz17JiUt39+X3Ci+uBgYGAhDQ0Px22+/SfNev34tPv30UwFANGrUSOWBQ/FFplq1auLKlStK8x49eiQWLVqkNE3xIGtvb6+UsHr06JGoXbu29HCmqaSkJFGpUiUpSZNXivfbwMBATJw4UaSmpgohhEhLSxOTJ08WAISlpaWIiIhQu15eE3z52f/p06dLD6TqdOrUSQAQq1atkqYV9CHw/fMvISFB9O3bV/qCm5iYqNH+3rlzR/z5558qXxhCQ0OlHzm2bt2qNE9xvQ8cOFC8e/dOad6DBw/EunXrVOIuaILP0NBQjB07Vrq25XK5mDJlinSs3k8Q/P333+LMmTMq0+/cuSNcXV0FAHH27FmleVmvM0tLS3H06FFp3osXL8RHH30kAIgpU6bkaR9yMmHCBAFA2NraimPHjinNCw8PV3m/Vq5cKX2pPXnypFJ8ikR+48aNVcpRnDdGRkZi/fr10n0iLS1NpKWlSfuur68vzM3NxaFDh6R1s55LBU1CGBoaip49e4q3b99K81avXi0ACBMTE6XpQuTv/My6v2ZmZkqfPXFxcdIXov/973952gdN9u/9z7nDhw9L59Qvv/wiTY+NjZUSuy4uLirX69GjR8WVK1dU7ufnz58XdnZ2Ql9fX4SEhGQbR3FI8Cm+HP/6669q54eHh0vHSV1SOq+yXr9WVlbi1KlT0rx//vlH+lGoa9euonLlyuLWrVvS/ICAAClZkzUREhUVJfT09ISVlZW4cOGCUnlJSUnit99+U3meUiR069evr1RGYmKiGD16tACUf+xR4LWlXtbPgIkTJ0rPtcnJyaJLly4CgPD19RXW1tYqz2SNGjUSAMTkyZOVtvnZZ58JIPPHdcX2FK5fv6707Jafc6CgCT5DQ0Nhb28vrl69Ks37999/s60sIIQQ69atE+Hh4UrTEhMTpWd/X19flXXye+7klybP7YoEn6GhoWjRooVSZQrFD1R2dnaiUaNGolevXiIuLk4Ikfk9Z8SIEdKzcFZLliwRAESbNm1UvsM8ffpU/PTTT0rT4uPjpYTg+PHjRWxsrDTv3r17om7duirPdAoFfbbL63W1d+9ecffuXaVpcrlc/P7776JMmTLC0tJSeo8UFMfB0NBQ1KlTR+kHh8uXL0vfI99/JqGSjwk+KrXu3LkjfUl+/6YoROYXaUdHRyGTycSTJ0+U5p04cULIZDJRpkwZERISInbt2iV9eXvx4oXKthQfrsbGxmrnK36Fbt68udL07BJ8ikSDh4eH2n3r0KGDACD69++vNo5KlSqJ+Ph4tevmxtHRUZiZmYm0tDS1284uwffXX3/l+B4sWrRIOh5Zv+wo3gMg+5pTQhRegu/9X3iFyDz+iu1+8cUXKvPXrl0rAIjOnTtnW646ii8u2SWRXr58KdXkO3PmjDT92rVr0nv78OHDXMuJjY2VfvV+/xfprNuTyWRqv1yq88033wgAwsbGJl8PiYr3W12tMCGEaNCggQAgZs2apXa9vCT48rv/oaGhQiaTCVtbWykBqRAVFSUMDAyEkZGR0oOlg4ODcHBwEJcuXcr5DXiP4jxQdw6lpKRIydTNmzfnur+5CQkJEYDqL7lt27YVAFS+1OSkZ8+ewsHBQSxdulTjdYT4v7jd3d1VapOkpqZK+3vz5k2Nt3nq1CkBQAwbNkxpetbrTF2cf/zxhwAgPvroozztQ3bCw8OlH3HOnz+f6/JyuVyqLfr+FxIhhHj+/LmUpDh9+rTSPMV+qasRLkTu+67w5ZdfCgcHB/Hll1/mGm9WuX3GKK7jAwcOaLzN7M5PIXLe37t37woAamtt5Fd2n3OKpKu6z4OEhASppkXWGu252bhxowAgvv/+e5V5+T0+79NGgk9xL83uS2JiYqJ0nAIDA/NdjkLWc1jd9aH4LMru/q74YffHH3+Upl2+fFkAmtc+j4qKEsbGxsLS0lKEhYWpzM/IyBBeXl5qr3leW+opPgPq16+vkvD+999/pXjUPZMdP35c7T27Vq1aAoBS4iY7eT0HhBDi0qVL0md8XmRNDO7fv19l/ooVK/L1DNm0aVMBQDx//lxpemGcOznR5LldkeAzNTVVSVimp6dLSU47OzuRkJCgNP/t27fSs3DW5y1F4i/rD1c5UbzP2R3zO3fuCJlMJqpWraoyr6DPdtq8rmbMmCEAqNTiUxwHmUymtga54rtndj9aU8nFPvio1Dp48CAAwN/fHxYWFirzzczM8Omnn0IIodL/V5s2bTB69GjEx8ejV69eGDVqFABg/fr1qFSpUrZldu/eXe380aNHAwAuXryoUX8IJ0+eBACMHTtW7fwvvvhCabn39ejRQ2mQBHXOnDmDL7/8Eh07dkTz5s3RtGlTNG3aFLGxsUhMTFTqg04Tilj8/PzUvgcjR46EsbExnj59in///Vdlft26ddGgQYM8lakNn3/+uco0Dw+PHOfXr18fAArUj9eYMWNUplWoUAE9e/YEkNlPnYKif71u3bqhRo0auW77woULSExMhJOTE7p06aIy38vLC02aNIEQAn/99Veu2zty5AgWLFgAAFi7di2sra1zXSc7imshu+lZ9zu/8rv/VatWRfPmzfH69WscPXpUaZ2dO3ciPT0dnTt3ho2NjTT9+fPneP78OZo0aZKvWNWdB0ZGRhg6dCiAvL0fKSkp+PXXXzFs2DC0bdsWzZo1Q9OmTaU+su7cuaO0vKOjIwBg3759avvHVGfv3r14/vw5Jk6cqHFcWQ0ZMgR6esqPJoaGhnB3dweg/pp69+4dNmzYgIEDB6JNmzbSfk2dOhWA6n5lpe769fLyyras/Dh69CjS0tLg7e2NZs2a5br8gwcPEBYWBhMTEwwbNkxlvoODA3r06AEg+3v8gAEDci0np2V+/PFHPH/+HD/++GOu21Gnd+/eaj9jcnpv83p+ZqW4HrKqV68eTExMEBsbi+jo6Hzthybi4+Nx+fJlAMC4ceNU5puZmUnHUd3xevXqFZYvX44+ffrg008/lT5rly1bBkD9fhf0+GhTcnIygMz7kjrGxsbS30lJSVote8iQISrTFJ/Piv5K36fu81lxr7t69WqO/dwqHD16FCkpKWjbti0qV66sMl9PTw+fffYZAODcuXNK83ht5UzRj3NWNWvWhJmZGYC8PXMpjmt2fbiqW1bTcwAAmjRpIn3G50fZsmXRvXt3lem5fQYFBgZi6tSp6Ny5M3x8fKR7hqL/47t376pdLz/nTkFo8tzevn172NvbK03T19dHvXr1AGTGrDj2CtbW1tIAQY8fP5amK47hwYMHs+1bMqsDBw4AUH+OA8BHH30EFxcX/PfffyrHuKDPdvm5rp49e4YFCxbA398fLVu2lI777t27AWR/HXt4eMDT01NlemEdd9I9A10HQKQr//zzD4DMD4LsOih9+vQpACA8PFxl3uLFi3Hq1Cmp499BgwahW7duOZbp6uqqdrqiA/uUlBSEhobm2JE/8H+DGNSpU0ft/Lp16wIAXr58ibi4OFhaWmoUB5A5UMD//vc//P777znGkF0n79nJLWYLCws4OjoiJCQEDx8+RO3atTWOuTBVq1ZNZVr58uU1mh8fH5+vMg0NDVG9enW18xTvQ9aBLB48eAAA8Pb21mj7inVr166dbcf6itEWcxswIzAwEL169YIQAt988w38/Pw0iiE72R1ndfudXwXZ/yFDhuDcuXPYtm2bUnJQMcjMoEGDChxfVtp6P549e4Y2bdqoTZ4rvH9NjxkzBtu2bcO8efOwfft2tGvXDs2aNUOLFi1UHsi1Rd31BGQmtwHVa+rWrVv47LPPchzUJrt7la2tLaysrDQuK7/ye306OTll+0OM4h6f3fHP7X5pa2sLW1tbjeLJj7wex/ycn5qUV758eYSFhSE+Pl4a3VXbQkJCIJfLpQEW1MnueJ08eRL+/v6IjY3Ndvt5/awtaiYmJkhMTFQ7cAWQmVxSMDU11Vq55cuXV3m2UUwHcj4nAOVz0MHBAX5+fti7dy+qV6+OFi1awNfXF82aNYO3tzcMDJS/LimeH69cuYKmTZuqLefly5cA1D8/FsSHfm1lV56trS2ePXuWp2euCRMm4NSpUxg2bBiWLl2Ktm3bomnTptJAZFnl9RzQhrweSyEExo4dm+1gEQrZHc+8lldQmjy353ad5jT/wYMHSjEPHjwYixcvxtatW3Hs2DGlZxZ192bFdTxr1iz88MMPastRDCwYHh6uNpmfX3m9rrZt24aRI0dKP6ioU1yOO+kea/BRqaV4oA4JCcHFixfV/lP8YqPuV2dTU1OlL2zqfkl+n+Jm+j6ZTCZ9mClGf8uJ4mac3fYqVqwo/a1ueznV3luwYAF+//13VKpUCdu3b8eTJ0+QnJwMkdmkH5988gmAzBFI8yK3mLPGndeYC9P7vxwCUEoK5TQ/a62nyMhI6de2rP/U1fgoV66cSi0mBXXvkWK0Z01rzhX0WCg8ePAA7du3R3x8PIYPH57tA5Kfn5/afVcnt3Nak+sjNwXZ/549e8LS0hJ//vmn9Avr3bt3cfv2bVSqVAnt2rUrcHxZaev9GDRoEP799180btwYx48fR2RkJFJTUyGEkK7l93/x9vDwwPnz59GmTRuEh4dj3bp16NevHypXroy2bdtKiSttyu46V1wPWa+pjIwM+Pv7IyIiAh06dMC5c+fw+vVrpKenQwgh1TLO7l6VW1naoovrM7f7ZWHfT/NyHIH8nZ8FKU+bFMerfPny2f5goO54xcTEoFevXoiNjcWAAQNw5coVvH37FhkZGUq1h/P6WVvUypYtCwB4+/at2vlZpyuW1QZ1n73A/33+5jb//XNi+/btmD17NipUqICTJ09i2rRpaNasGezt7bFkyRKl0TQVz49hYWHZPj+GhIQA0H6txQ/92srPcc3uuuvYsSOOHDmCjz/+GA8fPsTy5culViT+/v4qyde8nAPakNf3dseOHVi9ejXMzc2xevVqPHr0CImJidLzed++fQHk/zNP28dSk88ZbV7H9vb2uHz5Mnr06IHY2Fhs27YNQ4cORbVq1dCkSROpprWC4jq+ceNGttex4p6ty+s4NDQUw4YNQ3JyMr766ivcunULcXFxkMvlEEJgw4YNAIrPcSfdYw0+KrXKlCkDANiwYUO21bNzcuTIEWzbtg16enqQy+UYNWoUbty4odQc5X3ZDXsvhJDmqWsurC722NhYREVFqf1lRvHLsabby2rnzp0AModXb9u2rcr8sLCwPG1PQfF+R0VFZbuMIu68xqwJIYTah8CiGiI+OTkZFy9eVJmu7lfh6OhoyOVytYkGxfuX9T1S/B0TE6NRLNo4Fk+ePEHr1q3x+vVr9OrVC2vWrMl2W9evX5dqw+bm1atXqFWrlsp0dfsNZP9lTUHd8S3I/puZmeF///sfNmzYgN9++w1jx46Vau/169cP+vr62W4zP169eqX2V+Ps3g91IiIiEBAQADMzMxw9elSpCTGQ8zXt7e2NEydOID4+HhcvXkRAQAB+/fVXnDx5Eq1bt0ZQUFCBmmQXxLVr1xASEgJnZ2ccOHBA5d6b33uVtuni+ixJCnJ+FgeK4/Xq1atsP2fUHa9jx47h7du3aNKkCbZu3aqyXnHfb4UaNWogPDw822ZeiulGRkZwdnYuytDyxMTEBHPmzMGcOXMQHByM8+fP488//8SRI0cwadIkAMDXX38N4P+O+fTp0/Hdd9/pLObclPRrSxs6dOiADh064M2bN/j7779x+vRp/Pbbb9i7dy9CQkJw9epVGBoaAsjbOaALiufzpUuXYsSIESrzS8PxzI2rqyv27duHlJQUXL58GefOncOuXbtw5coVtGnTBv/88w9cXFwAZF7HMTExePToUbatZoqDPXv2IC0tDb169cKSJUtU5vO40/tYg49KLUVT0aCgoDyv+/r1aykpuHnzZjRu3Bj37t3DtGnTclwvuxovjx8/RkpKCvT09LKtSp1VzZo1AQD3799XO//evXsAMmsNqGvCkpMnT54AAD7++GOVedHR0dk2N8nuF1SF3GJ+9+6d9CGlWFYbFL9cqUuuxsbGStXvC5uLi4v0K2vWf2fPnlVZNi0tDaGhoWq3oziHsr5HiuZfV65c0SgWxboPHjzINjGmOIfUHYvIyEh8+umnCA8Px2effYbt27fnWOvpyZMnavddneyuEXX7DeR8fAGofR8Luv+K2rpbt25Fenq69NCt7ea5ihhzmq7JtaJIrtauXVvlCx6Qc/9LCmXKlEHbtm2xYMECBAcHo1q1aggPD8exY8dyXbewKO5VDRs2VPvDiib7VRTye30+e/Ys26YzOZ2fJY02zk9dql69OvT09JCSkpJtkkvd8VKcv02aNFH7+Vnc91uhcePGAKD2B6ys0xs2bKj1H0AKS+3atTF8+HD88ccfUnNIRS0ZoGDPj0WppF9b2mRjY4MuXbpgxYoVCAoKgpWVFW7duiV1s/O+3M4BXcjp+TwtLa1QatWXVMbGxvD19cXs2bMRFBSETz75BPHx8fjtt9+kZUrKdZzTcQdK13VMmmGCj0otRX95v/zyS547CR4xYgQiIyPRs2dPDBw4EDt27ICZmRl++ukntQkbhf379yvVrlNQPDx88sknGlVpV9SsW7Vqldr5K1asUFouLxR95KiLc+nSpcjIyMhxveyqsSti2bt3LyIjI1Xmr1u3DikpKXB2dlZbgyu/FP1uXL9+XWXexo0btVaOtqnrY+XVq1fYu3cvgMyBXhQUHYn//vvv2SYGs2ratCnMzMwQFhYmDdCRVWBgIC5fvgyZTIbWrVsrzXvz5g1at26N0NBQtGjRAnv37pV+/daG7PqWUUzPut9Azsd3//79apuNFWT/gcxabXXq1MGNGzewZMkSvHz5Ep6enlIiR5vUvR+pqanYtGkTANX3Qx3FtRkVFaU2oblo0aI8xWRmZiZ1gJ1T33eFLad7VVpamjRIga516NABhoaGuHLlSrZJkKxcXV3h5OSE5ORktfeoiIgI7N+/H0D+7vHFjbbPz6JWpkwZ6YvXypUrVeYnJSVJxzHr8crp/I2Ojpau8eJOMUjAX3/9pTI4QUZGhlTDWTFAVEmj6Iol672uY8eOMDIywtGjR/M84FhRKunXVmGpWLGiNEiDJp9h6s4BXcjpnrFly5Zsf+gs7fT19aUBJbIeQ8W9a8WKFcW6mWpOxz04OBiHDx8u6pComGOCj0otT09P+Pv7Izo6Gq1bt8atW7eU5mdkZODs2bPo27evUifRW7duxYEDB2BnZ4e1a9cCyGyismTJEgghMHDgQKnPpfdlZGSgb9++SrXGDh48KH0pUDQByM2oUaNgaWmJ27dv48svv5Q6t5bL5Vi0aBGOHDkCQ0NDfPXVV5q/If+fom+0r776Sqo9IoTA9u3bsWTJEpiYmKhdT5FoOX/+vNoPypYtW8LLywspKSno3bu3UvOzkydP4ttvvwUATJ06NdfagHnRvn17AMCMGTOUPhyPHz+OuXPnFkrHyQVlYGCA1atXS8k8IDOx1q9fPyQnJ8PT0xMtWrSQ5jVs2BDdunVDcnIy2rdvr5LsCgkJUarWb2lpKY38PHbsWKVzPzQ0VBpZz9/fX6lGaUJCAjp27IigoCA0btwYf/zxR7bnQ34FBQVh8uTJSn0DTZs2DTdu3ICFhQVGjhyptLzi+C5atEjpi9b169cxfvx4tcnH/O5/VoMHDwYAzJw5E0D2tfdcXFzg4uKice2t9x05cgTLly+XrqmkpCQMGzYMERERcHR0RK9evXLdRt26dVG2bFk8f/4c33//vbSt5ORkfPHFFyr3PoVRo0Zh9+7dSExMVJp+/vx5nD59GgBURsjr1asXXFxciiS5puj4/OLFi9i+fbs0PTY2Fn379lX7MKwLdnZ20ojn3bt3VxlJNSIiAnPnzpVey2Qy6bNg9uzZ0nsNZD7g9+rVC6mpqfD29la6D2jT119/DRcXlyJpjpbf87M4mTJlCoDMhPyvv/4qTX/37h0GDBiAV69ewcXFRel6VYyovGfPHpw6dUqa/uLFC/To0SPHftGK8vgAmSNGKu5l748m2ahRI7Ru3Rrp6eno27ev9INpWloavvzySzx48AAVKlTA8OHDiyTW/Dh9+jQmTZqk0sIgPj4eixcvBqB8r7O3t8eECROQlpaGtm3bqvywK4TAtWvXMGrUKJVanby2ik6vXr1w5MgRlQFg9u3bh3/++QcymUwagTev5wCQWStbcV0UBcXz+YwZM5SSecePH8ekSZO0/jxW0kyfPh2bNm1S6Q4jKChIGkk56zEcMWIEqlatioCAAPTt2xcvXrxQWi8+Ph579uzBxIkTVcoq6LNdXiiO++rVq3H79m1p+sOHD+Hn55ftCOZUigmiUuzdu3eidevWAoAAIJycnETjxo1FvXr1hKmpqTQ9KSlJCCHEkydPhKWlpQAgjh49qrK99u3bCwBiwIABStMHDhwoAIhvvvlGWFlZCRMTE9GwYUPh4uIilTF69GiV7W3ZskUAEAMHDlSZd+jQIWFkZCQAiLJlywovLy9RoUIFAUDo6emJdevWqayjiGPLli3ZvieBgYHC2NhYABCWlpaiYcOGwt7eXgAQ/fv3Fz4+PgKACAgIUFovJCREisfZ2Vk0a9ZM+Pj4KJX16NEjUblyZQFAGBsbiwYNGojq1atL70H//v2FXC7X+D3ISrGN90VFRYlKlSpJZXp4eEjv+9SpU4Wzs7MAIB4/fqy0XnbTcytPCCEeP34svQ95kXW9UaNGSX97enpK52O5cuXE/fv3VdZ98+aNaNKkiRSXi4uL8PT0FBUrVlQbS2JiomjRooW0fJ06dYS7u7vQ19cXAIS7u7t4/fq10jo//PCDtLybm5v45JNP1P4bO3ZsnvZbiP97v+fPny9kMpkoV66c8PLyEra2ttI5/dtvv6msl5SUJOrWrSsACAMDA+Hm5iZq1qwpAIhevXple77mZ/+zevnypTA0NBQAhJGRkYiOjla7nGL775efG8V6CxcuFABEpUqVhJeXl3T/MTExEefOnVNZL7v9XbVqlbTNSpUqCU9PT2FpaSlkMpnYsGGD2vPZ3d1del9dXV1Fo0aNpOMEQPTr1y/b8mfPnp2n/c0uboXs7l1ff/210v27YcOGwtTUVBgaGoo1a9aoPfc1uT5zur7zIzk5WXTp0kXarr29vfDy8hKVK1cWMplMpSy5XC769OkjLV+9enXRoEED6R7r5OQkQkND8xy3pvcmxfud2303u/Wy+4yZPXu22vMjP+enELnvb2738bzKaf+mTp0qxePo6Cg8PT2Fubm59Bl97do1lXV69uypdIw9PDyEgYGBsLCwEMuWLRMAhI+PT7Zx5PX4CCFE/fr1Rbly5US5cuWk+4menp40rVy5cmLhwoVK6yjOm+zey/DwcOm9NjMzEw0bNhTly5eX7lV5vf/lJLdzOCAgINv3TQj1zxQHDx6U9q98+fLC09NTuLu7CzMzMwFAWFlZiRs3bihtJy0tTfTr10/pvG3UqJFwd3cXFhYW0vQHDx4orcdrS73cPgPy80xmZWUlPfu5ubkJLy8vYWdnJy07c+ZMadn8nAOKcy2vnxW5naPZneNPnz4VNjY2AoAwNTVVep5t0aKF6Nu3r9pzJL/nTn5p8tyeW5m5xazufFF8xurp6Ynq1auLRo0aKX3HaNGihUhLS1PazoMHD0SVKlWk9VxdXUXjxo1FzZo1pefBxo0bq5Rf0Ge77Kg7z9PS0oS3t7cAIPT19YWrq6twc3MTMplM2NnZie+++07t+53bccjtPKSSizX4qFQrU6YMjh8/jp07d6Jt27ZITEzEzZs38fr1a3z00UeYMmUKrl27BhMTE8jlcgwYMABxcXEYMWKEVHMoq82bN6NcuXLYvn271IQqq5o1a+LatWvo1KkTnj17hhcvXsDd3R3r16/Ptrltdjp37owbN26gb9++MDExwe3btyGEQLdu3XDhwoV8/1resGFDnD9/Hq1bt4ZcLkdwcDAqVKiAFStWSE1t1KlWrRoOHz4MHx8fvH37FhcuXMC5c+ekviOAzL6Kbt26ha+//hpOTk64d+8eoqKi0Lx5c+zYsQPbtm3Tau09IHNkw4sXL8LPzw9mZmb4999/UbZsWWzZsgXz58/Xalna9PPPP2P58uWwsLBAUFAQzM3N0bdvX9y4cQOurq4qy5ctWxbnzp3Dzz//jE8++QRv375FUFAQzMzM0LNnT5Xzy9TUFCdOnMDy5cvh6emJp0+f4uHDh6hTpw6+++47XLp0CeXKlVNaJ2tN1qCgoGxHHfvnn3/yvd+9evXCsWPHULduXQQHByM5ORktW7ZEQECA2tpqJiYmOHPmDD7//HPY2Njg0aNH0NPTw5IlS6S+8dTJz/5nVaFCBeke0LlzZ7X9G2nD5MmTsXPnTjg6OuLevXuQyWTo3Lkzrl69iubNm2u8nTFjxuCXX36Bh4cH3rx5g5CQEHh6euLo0aPZDjL0008/4YsvvsBHH32E169fS78ct23bFn/88YdSrTldWbRoEZYtW4batWsjMjIST58+xaeffoq///5b6yMaF4SxsTEOHjyInTt3olWrVkhOTsadO3egp6eHDh06qLyXMpkMv/zyC7Zv345mzZohKioK9+7dg7OzMyZNmoSbN29KtaY/BPk5P4ub+fPn4/Dhw2jdujXi4+Nx9+5d2NraYuTIkbhz547URCyrnTt3YubMmXBxccHTp0+lrj+uX78Od3f3QonzzZs3iI6ORnR0tNTaQC6XS9Oio6NVau3mxt7eHrdu3cKXX36JihUrSrWjevXqhRs3bsDX17cQ9kR7mjVrhhUrVqBTp04oU6YM7t+/jydPnqB69eqYPHkygoODVWpvGRgYYMeOHThy5IjUTcatW7fw4sUL1KxZE2PHjsXZs2d13k/mh3Bt5de2bdswfPhw1KhRAxEREbh79y7MzMzQrVs3nDt3TqnmdH7OgaLm5OSEy5cvo3v37jAyMkJwcDBMTEzw7bff4vjx48WyRUpRmjFjBqZOnQovLy/Ex8fj9u3bSEpKgo+PD7Zv346TJ0+qvEe1a9fGnTt3sGDBAnh5eSE8PBy3b99GamoqfHx8sGTJEuzatUtHe5TJwMAAJ06cwLhx41CxYkWEhIQgJiYGn3/+OW7cuAEHBwedxkfFj0yIYtzonOgDMWjQIGzbtg1btmwplI746cPw5MkTVKlSBc7OzkqJUSqevL29cfXqVfz555/o2LGjrsMhIiIiIqJSjDX4iIiI8ujevXu4evUq7OzsilVNMSIiIiIiKp2Y4CMiIsqDjIwMTJ8+HQAwfPhw6Ovr6zgiIiIiIiIq7ZjgIyIi0sDx48fh6+uLKlWq4NChQ6hYsSK++OILXYdFRERERETEBB8REZEmIiMjce7cObx58wYtWrTAyZMnUbZsWV2HRURERERExEE2iIiIiIiIiIiISjLW4CMiIiIiIiIiIirBDHQdAP0fuVyOiIgIWFhYQCaT6TocIiIiIiIiIiLSISEE3r17B3t7e+jpZV9Pjwm+YiQiIgKOjo66DoOIiIiIiIiIiIqRsLAwVK5cOdv5TPAVIxYWFgAyD5qlpaWOoyEiIiIiIiIiIl2Ki4uDo6OjlDPKDhN8xYiiWa6lpSUTfEREREREREREBAC5duXGQTaIiIiIiIiIiIhKMCb4iIiIiIiIiIiISjAm+IiIiIiIiIiIiEow9sFXAmVkZCAtLU3XYZCOGBoaQl9fX9dhEBEREREREVExwQRfCSKEQGRkJGJiYnQdCumYtbU1KlWqlGsnm0RERERERET04WOCrwRRJPcqVKgAMzMzJndKISEEEhMTERUVBQCws7PTcUREREREREREpGtM8JUQGRkZUnKvXLlyug6HdMjU1BQAEBUVhQoVKrC5LhEREREREVEpx0E2SghFn3tmZmY6joSKA8V5wL4YiYiIiIiIiIgJvhKGzXIJ4HlARERERERERP+HCT4iIiIiIiIiIqISjAk+0qmzZ89CJpN9UCMDDxo0CF27dtV1GERERERERESlTnJysq5D0AkOskGUT0+ePEGVKlVw69YteHh4SNOXL18OIYTuAiMiIiIiIiIqBeLj43Hr1i1cv34dgYGBCAwMRFJSEsLCwnQdWpFjgo9KndTUVBgZGRXa9q2srApt20RERERERESlUXJyMu7cuaOUzHvw4AHkcrnKsi9evICdnZ0OotQdNtGlQpeSkoLx48ejQoUKMDExQdOmTXH9+nWlZS5evAh3d3eYmJigcePG+Oeff6R5T58+RadOnVC2bFmYm5ujbt26OHr0qDT//v376NChA8qUKYOKFSuif//+eP36tTTf19cXY8eOxcSJE2Fra4vWrVujd+/e6NWrl1IMaWlpsLW1xZYtWwAAx48fR9OmTWFtbY1y5crhs88+Q2hoqLR8lSpVAAD169eHTCaDr68vANUmurntv6KZ8unTp+Hp6QkzMzN8/PHH+Pfff/P5jhMRERERERGVXGlpabh58ybWr1+P4cOHo379+rCwsIC3tzfGjRuHbdu24d69eyrJPRMTE3h7eyM6OlpHkesOE3xU6CZPnoz9+/dj27ZtuHnzJqpXr462bdvizZs30jKTJk3CkiVLcP36dVSoUAGdO3dGWloaAGDMmDFISUnB+fPn8c8//2DhwoUoU6YMgMysvI+PDzw8PBAYGIjjx4/j5cuX8Pf3V4ph27ZtMDAwwMWLF7Fu3Tr07dsXf/zxB+Lj46VlTpw4gYSEBPTo0QMAkJCQgIkTJ+L69es4ffo09PT00K1bN+kGcu3aNQDAqVOn8OLFCxw4cCDf+w8A06dPx9KlSxEYGAgDAwMMGTKkIG87ERERERERUbGXkZGBoKAgbN26FWPGjEHjxo1hYWGBhg0bYsSIEdiwYQNu376N9PR0pfUMDAzQoEEDaZlbt24hLi4Oly9fhpubm472RnfYRLeE8/T0RGRkZJGWWalSJQQGBmq0bEJCAtasWYOtW7eiffv2AIANGzbgr7/+wqZNm+Dl5QUAmD17Nlq3bg0gMxlXuXJlHDx4EP7+/nj27Bl69OiBevXqAQCqVq0qbX/NmjVo0KABfvjhB2na5s2b4ejoiIcPH6JmzZoAgOrVq2PRokXSMtWqVYO5uTkOHjyI/v37AwB+/fVXdOrUCZaWlgAgJfoUNm3ahAoVKuD+/ftwc3ND+fLlAQDlypVDpUqV8rX/kyZNkpb9/vvv4ePjAwCYOnUqOnbsiOTkZJiYmGj0XhMREREREREVZ3K5HCEhIQgMDJSa2t68eROJiYk5rqenp4c6derAy8sLnp6e8PT0xEcffcTvy1kwwVfCRUZGIjw8XNdhZCs0NBRpaWn45JNPpGmGhoZo1KgRHjx4ICX4mjRpIs23sbFBrVq18ODBAwDA+PHjMWrUKJw8eRKffvopevTogY8++ggAcOPGDQQEBEg1+t4vW5Hg8/T0VJpnaGgIPz8/7Ny5E/3790dCQgIOHTqEX3/9VWn9mTNn4sqVK3j9+rVUc+/Zs2ca/xqQ2/5npdgnAFJfAVFRUXByctKoLCIiIiIiIqLiQgiBp0+fKvWZd+PGDcTGxua6bs2aNaVknpeXFzw8PGBubl4EUZdcTPCVcNnVHCsuZSpGk5XJZCrT35/2PsX8oUOHom3btjhy5AhOnjyJ+fPnY+nSpRg3bhzkcjk6deqEhQsXqqyftUNNdTeCvn37wsfHB1FRUfjrr79gYmIi1bIDgE6dOsHR0REbNmyAvb095HI53NzckJqaWij7b2hoqLLv6joLJSIiIiIiIipuIiIilJJ5gYGBSv3jZ8fFxUUpmdegQQMOXpkPTPCVcJo2ldWV6tWrw8jICBcuXECfPn0AZHaWGRgYiAkTJkjLXblyRaqp9vbtWzx8+BC1a9eW5js6OmLkyJEYOXIkvvnmG2zYsAHjxo1DgwYNsH//fri4uMDAIG+n88cffwxHR0fs3r0bx44dg5+fnzS6bnR0NB48eIB169ahWbNmAIALFy4ora9YNiMjo8D7T0RERERERFTS3L59G99++y2uXr2KFy9e5Lq8vb29UjNbT09P2NraFkGkHz4m+KhQmZubY9SoUZg0aRJsbGzg5OSERYsWITExEZ9//jnu3LkDAJg7dy7KlSuHihUrYvr06bC1tZVGop0wYQLat2+PmjVr4u3btzhz5gxcXV0BZA7AsWHDBvTu3RuTJk2Cra0tQkJCsGvXLmzYsAH6+vrZxiaTydCnTx+sXbsWDx8+REBAgDSvbNmyKFeuHNavXw87Ozs8e/YMU6dOVVq/QoUKMDU1xfHjx1G5cmWYmJio/MqQ2/4TERERERERlUTPnz+Hj48P4uLi1M63tbVVqpnXsGFD2NvbF3GUpQcTfFToFixYALlcjv79++Pdu3fw9PTEiRMnULZsWaVlvvjiCzx69Aju7u74448/lGrIjRkzBs+fP4elpSXatWuHn376CUBm9v/ixYuYMmUK2rZti5SUFDg7O6Ndu3bQ08t9kOi+ffvihx9+gLOzs1I/eXp6eti1axfGjx8PNzc31KpVCytWrICvr6+0jIGBAVasWIG5c+di1qxZaNasGc6ePZuv/SciIiIiIiIqKYQQGDVqlJTcs7KykmrkKZJ6Tk5OuXbNRdojE4pOwkjn4uLiYGVlhdjYWGkkV4Xk5GQ8fvwYVapU4SgxxPOBiIiIiIiIdGbXrl3o3bs3gMx++u/fv89KLIUkp1xRVrlXcSIiIiIiIiIiIgLw+vVrjBs3Tnr9888/M7lXDDDBR0REREREREREGvniiy+k0XF79OiB7t276zgiApjgIyIiIiIiIiIiDfz555/49ddfAQDW1tZYtWqVjiMiBSb4iIiIiIiIiIgoR3FxcRg5cqT0+qeffkKlSpV0GBFlxQQfERERERERERHlaMqUKQgPDwcAtGnTBgMHDtRxRJQVE3xERERERERERJStc+fOYe3atQAAc3NzrFu3DjKZTMdRUVZM8BERERERERERkVpJSUkYOnSo9Hr+/PlwcXHRXUCkFhN8RERERERERESk1uzZsxESEgIA+PjjjzF69GgdR0TqMMFHREREREREREQqAgMDsXTpUgCAkZERNm7cCH19fR1HReowwUcfDF9fX0yYMEHj5bdu3Qpra+tCi4eIiIiIiIiopEpNTcWQIUMgl8sBZNbkc3V11XFUlJ1il+CLiYnB+PHj0aRJE1SqVAnGxsZwcHBAy5YtsX//fgghpGXT0tKwf/9+DBo0CK6urjA3N4eFhQUaN26M1atXIyMjQ+Nyt27dCplMluO/Vq1a5biNx48fo0yZMpDJZEpDRxMRERERERERlSSLFi3CP//8AwBwd3fHpEmTdBwR5cRA1wG87/Xr19i8eTO8vb3RtWtX2NjYICoqCocPH0bPnj0xbNgwrF+/HgAQGhqKnj17wsLCAi1btkTnzp0RGxuLw4cPY8yYMTh+/DgOHTqk0cguHh4emD17ttp5+/btw71799C2bdts1xdCYPDgwfnbaSIiIiIiIiKiYuL+/fuYN28eAEBfXx+bN2+GoaGhjqOinBS7BF+VKlUQExMDAwPl0N69ewdvb29s2LABX3zxBerWrQsLCwusXr0aAwcOhJmZmbTs0qVL4evri8OHD2Pfvn3w8/PLtVwPDw94eHioTE9NTcWqVatgYGCAgQMHZrv+ypUrcfHiRSxatAgTJ07UfIdLAV9fX9SrVw/6+vrYtm0bjIyMMG/ePPTt2xdjx47Fvn37UKFCBaxatQrt27cHkDkE96RJk3Dnzh3Y2Nhg4MCB+O6776TzIiEhAaNGjcKBAwdgYWGBr7/+WqXc1NRUzJgxAzt37kRMTAzc3NywcOFC+Pr6FuXuExEREREREZUYGRkZGDp0KFJTUwEAX3/9NRo0aKDjqCg3xa6Jrr6+vkpyDwAsLCykGnSK0VscHBwwatQopeQeAJibm0tJtnPnzhUonoMHDyI6OhqfffYZKlasqHaZkJAQfPPNN5g8eTLq169foPI+VNu2bYOtrS2uXbuGcePGYdSoUfDz88PHH3+Mmzdvom3btujfvz8SExMRHh6ODh06wMvLC3fu3MGaNWuwadMmfPfdd9L2Jk2ahICAABw8eBAnT57E2bNncePGDaUyBw8ejIsXL2LXrl24e/cu/Pz80K5dOzx69Kiod5+IiIiIiIioRFi1ahUuX74MAKhRo0a2rR2peCl2Nfiyk5ycjDNnzkAmk6FOnTq5Lq+oOqouWZgXmzZtAgAMHTpU7Xy5XI7BgwfD2dkZs2bNki6CIuPpCURGFm2ZlSoBgYF5WsXd3R0zZswAAHzzzTdYsGABbG1tMWzYMADArFmzsGbNGty9exeHDx+Go6MjVq1aBZlMhtq1ayMiIgJTpkzBrFmzkJiYiE2bNmH79u1o3bo1gMwEYuXKlaXyQkND8dtvv+H58+ewt7cHkPmrw/Hjx7Flyxb88MMP2ngniIiIiIiIiD4Yjx8/xrRp06TXmzZtgqmpqQ4jIk0V2wRfTEwMli1bBrlcjqioKBw9ehRhYWGYPXs2atSokev6mzdvBgC0adMm3zE8ffoUp0+fhoODA9q1a6d2mWXLluHSpUu4cOECjI2N87T9lJQUpKSkSK/j4uLyHmRkJBAenvf1ithHH30k/a2vr49y5cqhXr160jRF7cioqCg8ePAATZo0Ueo78ZNPPkF8fDyeP3+Ot2/fIjU1FU2aNJHm29jYoFatWtLrmzdvQgiBmjVrKsWRkpKCcuXKaX3/iIiIiIiIiEoyIQSGDx+OxMREAMDo0aPRrFkzHUdFmirWCb5vv/1Wem1oaIjFixfjq6++ynXd9evX49ixY2jZsiU6dOiQ7xi2bNki1dDT19dXmf/w4UPMmDEDX3zxhVKySVPz589X2sd8qVSpYOsXUZnvd8Ypk8mUpimSeXK5HEIIlYFRFKMny2QypZGUsyOXy6Gvr48bN26oHLsyZcrkOX4iIiIiIiKiD9nWrVtx6tQpAICjoyPmz5+v44goL4ptgs/FxQVCCGRkZCAsLAy7du3C9OnTcenSJezZsyfbprdHjhzB2LFj4ezsjF9++SXf5cvlcmzZsgUymQxDhgxRO3/QoEGwt7dX6hsuL7755hulATni4uLg6OiYt43ksalsSVCnTh3s379fKdF36dIlWFhYwMHBAWXLloWhoSGuXLkCJycnAMDbt2/x8OFD+Pj4AADq16+PjIwMREVF8RcHIiIiIiIiohy8ePFCKT+xdu1aWFpa6jAiyqtiN8jG+/T19eHi4oKpU6fiu+++w8GDB7Fhwwa1y544cQI9evRAxYoVcebMGdjZ2eW73L/++gvPnj1Dy5YtUaVKFZX5K1aswJUrV7Bx40aVQT40ZWxsDEtLS6V/lFkNOCwsDOPGjUNwcDAOHTqE2bNnY+LEidDT00OZMmXw+eefY9KkSTh9+jSCgoIwaNAg6On93+lcs2ZN9O3bFwMGDMCBAwfw+PFjXL9+HQsXLsTRo0d1uHdERERERERExcvYsWMRExMDAOjXr1+BWkOSbhT7BF9Wiv70zp49qzLv+PHj6Nq1K2xtbREQEICqVasWqKzcBte4ffs2hBBo0aIFZDKZ9K9FixYAgHXr1kEmk6Fr164FiqM0cnBwwNGjR3Ht2jW4u7tj5MiR+Pzzz6VBOgBg8eLFaN68OTp37oxPP/0UTZs2RcOGDZW2s2XLFgwYMABfffUVatWqhc6dO+Pq1at5ryVJRERERERE9IHat28fDhw4AAAoX748fvrpJx1HRPkhE5p0aFZMHDt2DB06dECfPn2wc+dOaboiuWdjY4Nz585pNAhHTqKjo2Fvb48yZcogIiJC7eAZW7ZswcWLF1Wmv3jxAkePHkXt2rXxySefoH79+hgzZoxG5cbFxcHKygqxsbEqtfmSk5Px+PFjVKlSBSYmJvnbMfpg8HwgIiIiIiKignrz5g1cXV0RFRUFANi9ezf8/f11HBVllVOuKKti1wff7du3UaVKFVhZWSlNf/PmjTRUc/v27aXpiuRe2bJlERAQkGtyLy0tDaGhoTA0NES1atXULrNjxw6kpqaiX79+2Y6MO3jwYAwePFhl+tmzZ3H06FH4+Phg7dq1OcZCRERERERERKQrEydOlJJ7Xbp0gZ+fn44jovwqdgm+rVu3YuPGjWjRogWcnZ1hbm6Op0+f4siRI4iPj0ePHj3Qp08fAEBwcDC6du2KlJQU+Pr64rffflPZnouLCwYNGiS9Dg8Ph6urK5ydnfHkyRO1MeTWPJeIiIiIiIiIqCQ7ceIEtm3bBgCwsrLC6tWrpYEuqeQpdgm+nj17IjY2FleuXMH58+eRmJgIGxsbNG3aFAMGDECvXr2kEy4yMhIpKSkAgF27dqndno+Pj1KCLzfXrl1DUFAQGjVqhHr16hV4f4iIiIiIiIiIipN3795h+PDh0uslS5bA3t5ehxFRQZWoPvg+dOyDjzTF84GIiIiIiIjya9y4cVi1ahUAoGXLljh16hRr7xVTmvbBV6JG0SWA+VgCeB4QERERERFR/ly4cAE///wzAMDU1BQbNmxgcu8DwARfCWFoaAgASExM1HEkVBwozgPFeUFERERERESUm+TkZAwdOlSqNPL999+jatWqOo6KtKHY9cFH6unr68Pa2loa3cbMzIwZ9lJICIHExERERUXB2toa+vr6ug6JiIiIiIiISoh58+bh33//BQA0atQI48eP13FEpC1M8JUglSpVAgApyUell7W1tXQ+EBEREREREeXm9u3bWLhwIYDM1mCbNm1ipZEPCBN8JYhMJoOdnR0qVKiAtLQ0XYdDOmJoaMibMBEREREREWksPT0dQ4YMQUZGBgBg+vTpcHNz03FUpE1M8JVA+vr6TPAQERERERERkUaWLFmCW7duAQDc3NzwzTff6Dgi0jYOskFERERERERE9IH6999/MWfOHACAnp4eNm3aBCMjI90GRVrHBB8RERERERER0QdILpdj6NChSElJAQB8+eWXaNSokY6josLABB8RERERERER0Qdo7dq1uHDhAgCgatWqmDt3ro4josLCBB8RERERERER0Qfm2bNnmDJlivR648aNMDMz02FEVJiY4CMiIiIiIiIi+oAIITBy5EjEx8cDAIYNG4YWLVroOCoqTEzwERERERERERF9QH755RccO3YMAGBvb4/FixfrOCIqbEzwERERERERERF9IF6+fIkJEyZIr9euXQsrKyvdBURFggk+IiIiIiIiIqIPxPjx4/HmzRsAQK9evdCpUycdR0RFgQk+IiIiIiIiIqIPwO+//449e/YAAMqVK4fly5frOCIqKkzwERERERERERGVcDExMRg9erT0evny5ahQoYIOI6KixAQfEREREREREVEJN2nSJLx48QIA0LFjR/Tp00fHEVFRYoKPiIiIiIiIiKgEO336NDZu3AgAsLCwwJo1ayCTyXQcFRUlJviIiIiIiIiIiEqohIQEDBs2THq9aNEiODo66jAi0gUm+IiIiIiIiIiISqiZM2fi8ePHAIDmzZtj+PDhOo6IdIEJPiIiIiIiIiKiEujKlStYtmwZAMDExAQbNmyAnh5TPaURjzoRERERERERUQmTkpKCzz//HEIIAMC3336LmjVr6jgq0hUm+IiIiIiIiIiISpj58+fj/v37AICGDRti4sSJOo6IdIkJPiIiIiIiIiKiEuSff/7B999/DwAwMDDApk2bYGBgoOOoSJeY4CMiIiIiIiIiKiHS09MxZMgQpKenAwCmTp0Kd3d3HUdFusYEHxERERERERFRCbF8+XIEBgYCAGrXro0ZM2boOCIqDpjgIyIiIiIiIiIqAV6/fo2ZM2cCAGQyGTZv3gxjY2MdR0XFARN8REREREREREQlwP79+5GUlAQAGDFiBJo0aaLjiKi4YIKPiIiIiIiIiKgE2Lt3r/T3sGHDdBgJFTdM8BERERERERERFXOvXr1CQEAAAKBq1aqoX7++jiOi4oQJPiIiIiIiIiKiYu7AgQOQy+UAAH9/f8hkMh1HRMUJE3xERERERERERMVc1ua5fn5+OoyEiiMm+IiIiIiIiIiIirGoqCipeW61atXYPJdUMMFHRERERERERFSMHTx4UGqe6+fnx+a5pIIJPiIiIiIiIiKiYozNcyk3TPARERERERERERVTbJ5Lmih2Cb6YmBiMHz8eTZo0QaVKlWBsbAwHBwe0bNkS+/fvhxBCWjYtLQ379+/HoEGD4OrqCnNzc1hYWKBx48ZYvXo1MjIyNC5369atkMlkOf5r1apVoZRNRERERERERKQOm+eSJmQia8asGAgJCYGHhwe8vb1RvXp12NjYICoqCocPH0ZUVBSGDRuG9evXAwCCg4Ph6uoKCwsLtGzZErVq1UJsbCwOHz6MiIgIdOrUCYcOHdLo5L99+zZ+//13tfP27duHe/fuYeHChZg8ebLWy1aIi4uDlZUVYmNjYWlpqfF6RERERERERPRhatWqFc6cOQMAuHnzJmvwlTKa5oqKXYIvIyMDQggYGBgoTX/37h28vb1x//59BAUFoW7duggPD8cff/yBgQMHwszMTFo2ISEBvr6+CAwMxJ49ewrUPj01NRX29vaIjY3F8+fPUbFiRQAolLKZ4CMiIiIiIiIihaioKNjZ2UEul6NatWp49OgRa/CVMprmiopdE119fX2V5B4AWFhYoG3btgAya/kBgIODA0aNGqWUYAMAc3NzTJw4EQBw7ty5AsVz8OBBREdH47PPPpOSe0VVNhERERERERGVXgcOHGDzXNJIsUvwZSc5ORlnzpyBTCZDnTp1cl3e0NAQANQmC/Ni06ZNAIChQ4dqvI62yiYiIiIiIiKi0ivr6Ln+/v46jISKu2KbgYqJicGyZcsgl8sRFRWFo0ePIiwsDLNnz0aNGjVyXX/z5s0AgDZt2uQ7hqdPn+L06dNwcHBAu3btNF5P07JTUlKQkpIivY6Li8tfoERERERERET0QYmKisLZs2cBZI6e6+HhodN4qHgr1gm+b7/9VnptaGiIxYsX46uvvsp13fXr1+PYsWNo2bIlOnTokO8YtmzZArlcjsGDB0NfX1+jdfJS9vz585X2kYiIiIiIiIgIUG6e6+/vz+a5lKNiN8jG+zIyMhAWFoZdu3Zh9uzZ6NixI/bs2ZNt89cjR46gW7dusLe3x+XLl2FnZ5evcuVyOapUqYKwsDCEhoaiSpUqua6T17LV1eBzdHTkIBtEREREREREpRxHzyVA80E2im0NPgV9fX24uLhg6tSp0NfXx+TJk7FhwwaMGjVKZdkTJ06gR48eqFixIs6cOZPv5B4A/PXXX3j27BlatWqlUXIvP2UbGxvD2Ng43zESERERERER0Ycna/Pc6tWrs3ku5arEDLIB/F+fdoqTPKvjx4+ja9eusLW1RUBAAKpWrVqgsvIyuIa2yyYiIiIiIiKi0ouj51JelagEX0REBADV0WkVCbayZcsiICAA1atXL1A50dHROHToEGxsbNCtW7ccl9V22URERERERERUuu3Zs0f628/PT4eRUElR7BJ8t2/fRmxsrMr0N2/eYNq0aQCA9u3bS9PfT7DlNsJuWloagoODERoamu0yO3bsQGpqKvr165djE9q8lk1ERERERERElJOoqCicO3cOAJvnkuaKXR98W7duxcaNG9GiRQs4OzvD3NwcT58+xZEjRxAfH48ePXqgT58+AIDg4GB07doVKSkp8PX1xW+//aayPRcXFwwaNEh6HR4eDldXVzg7O+PJkydqY9CkeW5+yiYiIiIiIiIiygmb51J+FLsEX8+ePREbG4srV67g/PnzSExMhI2NDZo2bYoBAwagV69e0skdGRkpjUK7a9cutdvz8fHJU5Lt2rVrCAoKQqNGjVCvXr1slyuMsomIiIiIiIiodMvaPNff31+HkVBJIhNCCF0HQZk0HfqYiIiIiIiIiD48L1++hL29PeRyOapXr46HDx+yBl8pp2muqNj1wUdEREREREREVBqxeS7lFxN8RERERERERETFwN69e6W/2TyX8oIJPiIiIiIiIiIiHXv58qXS6Lnu7u46johKEib4iIiIiIiIiIh0LGvzXH9/fzbPpTxhgo+IiIiIiIiISMeyNs/18/PTYSRUEjHBR0RERERERESkQ2yeSwXFBB8RERERERERkQ6xeS4VFBN8REREREREREQ6tGfPHulvNs+l/GCCj4iIiIiIiIhIR16+fInz588DAGrUqMHmuZQvTPAREREREREREelI1ua5fn5+bJ5L+cIEHxERERERERGRjmRtnuvv76/DSKgkY4KPiIiIiIiIiEgHIiMjlZrnfvTRRzqOiEoqJviIiIiIiIiIiHSAzXNJW5jgIyIiIiIiIiLSgb1790p/s3kuFQQTfERERERERERERSwyMhLnzp0DwOa5VHBM8BERERERERERFbEDBw5ACAEgs/Yem+dSQTDBR0RERERERERUxLI2z/Xz89NhJPQhYIKPiIiIiIiIiKgIsXkuaRsTfERERERERERERYjNc0nbmOAjIiIiIiIiIipCe/bskf5m81zSBib4iIiIiIiIiIiKSGRkJM6fPw8AqFmzJpvnklYwwUdEREREREREVET2798vNc/18/Nj81zSCgNdB0BERCXL0qVL8fPPP8PAwADm5uYoU6ZMtv/nNC/rMqampnywISIiIqJSIevouf7+/jqMhD4kTPAREZHG1q5di6+//lrr25XJZDA3Ny9wovD9aWZmZtDTY2V1IiIiIioe3m+eW69ePR1HRB8KJviIiEgjhw8fxpgxY6TX1tbWSExMRGpqaoG3LYRAfHw84uPj8fLlywJvLyszM7MCJwrV/a+vr6/VOImIiIjow8fmuVRYmOAjIqJcXb16Ff/73/8gl8sBAJMnT8bChQsBAKmpqUhISEBCQgLi4+Oz/T+neeqWTUlJ0UrsiYmJSExMxKtXr7SyPQUTExOtNE/OOs3c3ByGhoZajZOIiIiIig82z6XCIhOK1DHpXFxcHKysrBAbGwtLS0tdh0NEBAAICQlBkyZN8Pr1awBA79698csvvxR609f09PQcE4eaJgrfn5aUlFSocReUkZGRVponv/+/kZGRrneNiIiIqFR78eIFHBwcIIRAzZo1ERwczBp8lCtNc0WswUdERNl69eoV2rVrJyX3WrRogS1bthRJv3YGBgawsrKClZWVVrebkZGBxMTEAicK1f2vDampqXjz5g3evHmjle0pGBoaam1QlKzTjI2N+WBKREREpIEDBw5IzXP9/f35DEVaxQQfERGplZiYiM8++wyhoaEAADc3Nxw4cADGxsY6jqxg9PX1YWFhAQsLC61uVy6XIykpqcCJQnXTtFHZPi0tDTExMYiJiSn4zmahr6+vtUFRsv7PkZWJiIjoQ5O1ea6fn58OI6EPERN8RESkIj09Hb169cK1a9cAAA4ODjh69Cisra11G1gxpqenJ/Wjp01CCCQnJ2slUfj+/xkZGQWOLyMjA3FxcYiLi9PC3v4fmUymtebJWf82NTXlyMpERERU5F68eMHRc6lQMcFHRERKhBAYO3YsDh8+DACwtLTEsWPH4OjoqOPISieZTAZTU1OYmpqifPnyWtuuEAIpKSlaSRS+/3d6erpW4nv37h3evXunhb1VpkjEarPWoZmZGUdWJiIiomyxeS4VNib4iIhIyYIFC7Bu3ToAmf22HTx4kL8wfoBkMhlMTExgYmKCcuXKaXXbipGVtdlMOSEhQWsjKysGb4mKitLK9hRMTU21XuvQ3NwcBgZ8XCMiIirp9uzZI/3N5rlUGPjESEREkh07dmDatGnS661bt6Jly5Y6jIhKIiMjIxgZGaFs2bJa3a5iZGVtNlOOj49HcnKyVuJLSkpCUlISXr16pZXtKRgbG2ttUJSs/xsaGmo1TiIiIlLvxYsX+PvvvwEAtWrV4o/nVCiY4CMiIgDAqVOnMGTIEOn1ggUL0KdPHx1GRKSsMEdWVtTq02atw8TERK3El5KSgpSUFERHR2tlewqGhoZaGxQl6/9GRkZsdkRERJTF/v37pea5fn5+/JykQsEEHxER4c6dO+jevbvUd9ro0aMxefJkHUdFVDT09fVhaWkJS0tLrW5XLpcjMTFR67UOExIStDay8tu3b/H27Vst7O3/MTAwKFDCMLt5JiYm/EJEREQlEkfPpaIgE9p4QtSimJgYzJo1C9evX8fjx4/x9u1b2NraolatWhgzZgy6d+8uPdylpaXhjz/+wOHDh3H16lU8e/YMenp6qFOnDgYOHIgRI0Zo3OH11q1bMXjw4ByXadmyJU6fPq00LS4uDnPmzMH+/fsRGRmJSpUqoUePHpgzZ06evyjExcXBysoKsbGxWv+SQUSUnWfPnqFJkyaIiIgAAHTp0gX79+/ngAFExZQQAklJSVodHEXxv1wu1/XuZUsxUnVeaxTmtoyZmRkTh0REVGhevHgBBwcHCCFQq1YtPHjwgJ87lCea5oryXYPv0KFD6NSpE/T09PK7CbVev36NzZs3w9vbG127doWNjQ2ioqJw+PBh9OzZE8OGDcP69esBAKGhoejZsycsLCzQsmVLdO7cGbGxsTh8+DDGjBmD48eP49ChQxpdPB4eHpg9e7baefv27cO9e/fQtm1bpekJCQnw8fHB7du30bp1a/Tu3Rt37tzBTz/9hICAAFy4cAHm5uYFf1OIiArJ27dv0b59eym55+3tjV9//ZXJPaJiTCaTwczMDGZmZlrdrmJkZW0NipL1f22MrCyXywtlZGWZTKZ2ZOWC9nloZmam9edkIiIqedg8l4pKvmvw6enpwd7eHgMHDsTnn3+OqlWraiWgjIwMCCFURox79+4dvL29cf/+fQQFBaFu3boIDw/HH3/8gYEDByo95CYkJMDX1xeBgYHYs2dPgarApqamwt7eHrGxsXj+/DkqVqwozZs9ezbmzp2LyZMnY+HChSrTZ82ahW+//VbjsliDj4iKUkpKCtq2bYtz584BAGrUqIFLly7B1tZWx5ER0YcmNTVV64OjJCQkIDU1Vde7liMzMzOtD45ibm7OH2GIiEoQHx8fnD9/HgBw9+5dDrBBeaZprijfCb7Jkydjx44dePnyJfT09ODr64thw4ahW7duMDIyynfgOZk4cSJ++ukn/P777+jSpUuOy/7222/o06cPxowZg1WrVuW7zN27d6NXr17o2rUrDh48KE0XQqBy5cqIi4tDZGSkUk295ORk2Nvbw8zMDGFhYRpn6JngI6KiIpfL0adPH+zevRsAUL58eVy+fBnVqlXTcWRERJpLS0vTejPlhIQErY2sXFhMTEy0NjiK4m9zc3OOrExEpGVsnkvaUOhNdBctWoQffvgBhw8fxsaNG3Hy5EkEBATAxsYG/fv3x+eff466devmd/MqkpOTcebMGchkMtSpUyfX5RUPKO/XBMyrTZs2AQCGDh2qNP3Ro0eIiIhA27ZtVZrhmpiYoHnz5jh06BBCQkJQo0aNAsVARKRtU6ZMkZJ7ZmZmOHLkCJN7RFTiGBoawtraGtbW1lrdbnp6OhITE7Ve6zApKUkr8SUnJyM5ORmvX7/WyvYUjIyMtNI8Wd3IykREpVHW5rn+/v5M7lGhKlD2y8DAAN26dUO3bt0QERGBzZs3Y8uWLVi2bBmWL1+Oxo0bY/jw4fD3989zPzExMTFYtmwZ5HI5oqKicPToUYSFhWH27NkaJcw2b94MAGjTpk2+9g0Anj59itOnT8PBwQHt2rVTmvfo0SMAyDYWxfRHjx4xwUdExcqKFSuwZMkSAJndLezZswdeXl46joqIqPgwMDAolJGVMzIylEZW1matQ21ITU3Fmzdv8ObNG61sT8HAwEBrzZOzLmNsbMwvy1RiCSHw7NkzBAYGIjAwEPHx8ejVqxc++eQTXYdGWrRnzx7pb46eS4WtYNXbsrC3t8eMGTMwY8YMHDt2DMOGDcPVq1dx9epVfPHFFxgwYAAmTZoEJycnjbYXExOj1H+doaEhFi9ejK+++irXddevX49jx46hZcuW6NChQ773acuWLZDL5Rg8eLBKXyexsbEAACsrK7XrKh4IFcupk5KSgpSUFOl1XFxcvmMlItLE/v37MWHCBOn1mjVr0LFjR90FRERUiujr68PCwgIWFhZa3a5cLkdSUpLWB0eJj49HPnvzUZKeno6YmBjExMQUfGez0NfX19qgKFn/NzU1ZeKQtC4yMhLXr19HYGCg9P+rV6+Ullm1ahXatWuH7777Dg0bNtRRpKQtL168wIULFwAAtWrVgpubm44jog+d1hJ8ABAcHIyNGzdix44dePXqFczMzNClSxfcuXMHP//8M7Zs2YK9e/eiffv2uW7LxcUFQghkZGQgLCwMu3btwvTp03Hp0iXs2bMn26a3R44cwdixY+Hs7Ixffvkl3/sil8uxZcsWyGQyDBkyJN/bycn8+fPzNAgHEVFBXLx4EX379pW+rM2YMQPDhw/XcVRERFRQenp6Uj96FSpU0Np2hRBITk4ucKJQ3bIZGRkFji8jIwNxcXFa/5FcMbKytmsdmpqacmTlUiI6OlqqmadI5oWHh2u07vHjx3H8+HF0794d3377LZNCJRib51JRK3CCLykpCbt378bGjRtx+fJlCCFQr149zJo1C/3795dqsh09ehSDBg3ClClTNErwKejr68PFxQVTp06Fvr4+Jk+ejA0bNmDUqFEqy544cQI9evRAxYoVcebMGdjZ2eV7v/766y88e/YMrVq1QpUqVVTmK2ruZVdDT/GgkV0NPwD45ptvMHHiRKV1HB0d8x0zEVF2goOD0blzZ6nW8MCBAzF37lwdR0VERMWZTCaDqakpTE1NUb58ea1tVwghjayszWbK8fHxSEtL00p8inK0TZGI1WatQzMzM46srEOxsbG4efOmUjLv8ePHua5Xrlw5eHp6wtPTE15eXnj9+jXmzZuHp0+fAgAOHDiAgwcPonfv3pgzZw67fSqB2DyXilq+E3w3btzAhg0bsGvXLrx79w4mJiYYMGAARowYAW9vb5XlO3TogKFDh0r9PuVHmzZtMHnyZJw9e1YlwXf8+HF069YNtra2CAgIQNWqVfNdDpD94BoKWfvYUye3PvoAwNjYGMbGxgUJk4goV5GRkWjfvr3Up1Lr1q2xYcMG/opIREQ6IZPJpOfgcuXKaXXbqamp+apRmNsyWbvVKYiEhAQkJCQgKipKK9tTMDU11XqtQ3Nz8wIPWPihSUxMxK1bt5SSef/++2+u61laWqJhw4bw8vKSknouLi4qz2L9+vXDpk2b8N133+HFixcQQuDXX3/F7t27MWjQIMyaNUvjLq9ItyIiIqTmubVr12ZNTCoS+b5jKzpkd3Nzw/Dhw9G/f/8ca6sBgJOTExwcHPJbJCIiIgCojox7/PhxdO3aFTY2NggICED16tXzXQaQWaX60KFDsLGxQbdu3dQuU6NGDdjb2+PixYtISEhQGkk3OTkZ58+fh729fYFjISIqiHfv3qFjx4548uQJAMDDwwP79u2TRhonIiL6kBgZGcHIyAhly5bV6nbT09MLZXAUbY2snJSUhKSkJK2PrGxsbKy1QVGy/l8SnkNSUlJw9+5dpWTevXv3IJfLc1zP1NQUDRo0UErm1ahRQ6Pm2cbGxhg9ejQGDRqENWvWYP78+YiOjkZGRgY2bdqEHTt2YPjw4Zg2bVqBWqtR4cvaPNfPz48/rFORyHeCT1Fbr0mTJhqvM3LkSIwcOTLHZW7fvo0qVaqoJAvfvHmDadOmAYBSE19Fcq9s2bIICAjItepyWloaQkNDYWhoiGrVqqldZseOHUhNTUW/fv2yrWEnk8kwdOhQzJ07F3PnzsXChQulefPnz8fbt28xbtw4XshEpDNpaWnw9/fHzZs3AWT+yHLkyBGtjwpJRET0oTMwMICVlVWuFRrySjGysrYHR0lMTNRKfIpBAaOjo7WyPQVDQ0OtDYqS9X8jI6N8ff9KT0/HvXv3lJJ5d+/ezbXJt5GREdzd3ZWSea6urgWu+WhmZoavvvoKw4cPx/Lly7FkyRLExsYiNTUVq1atwqZNmzB27FhMmTJF67VgSTv27t0r/c3muVRUZCKfQ2M9e/YM1tbWOX5RfPfuHd6+fZunasQTJkzAxo0b0aJFCzg7O8Pc3BxPnz7FkSNHEB8fjx49emDPnj3Q09NDcHAwPDw8kJKSgl69eqFWrVoq23NxccGgQYOk10+ePEGVKlXg7Ows1Wh5X7169RAUFIS7d++iXr162caakJCApk2b4vbt22jdujUaNmyIO3fu4NixY/Dw8MCFCxeUavblJi4uDlZWVoiNjeUXcCIqECEEhg4dis2bNwMArK2tcfHiRdSpU0fHkREREVFhk8vlSExMLJRah9oYWbmwGBgY5ClRGBUVhcDAQNy6dQvJyck5bltfXx/16tVT6jfPzc0NRkZGhb5fb968wZIlS7B8+XKl5K2FhQW+/PJLTJw4UevJZ8q/iIgIVK5cGUII1K5dG/fv32fFHyoQTXNF+U7w6evrY86cOZg5c2a2yyxcuBDTpk3L0yhZFy5cwKZNm3DlyhVEREQgMTERNjY2aNCgAQYMGIBevXpJF8fZs2fRokWLHLfn4+ODs2fPSq9zS/Bdu3YNjRs3RqNGjXD16tVc442NjcW3336Lffv2ITIyEpUqVULPnj0xe/bsPN9kmeAjIm2ZM2eONEq3kZERTp06hWbNmuk4KiIiIirJhBBISkrS+uAo8fHxuTZ9LUoymQyurq5KyTx3d3eYmprqNK6oqCgsWLAAq1evVuoXsmzZspg8eTLGjRuXpwomVDhWrlyJ8ePHAwBmzpzJge2owAo9waenp4c5c+Zg1qxZ2S6zYMECTJ8+PU8JvtKMCT4i0oZNmzYpDRC0Z88eNg0gIiKiYksIgZSUFK0PjhIfH4/09PRcy69evbqUyPP09ET9+vVhYWFRBHueP8+fP8f333+PjRs3Ku1fhQoVMG3aNIwYMQImJiY6jLB0a968Of7++28AwD///MMBNqjANM0VFeqwSM+fPy/WN0Yiog/NsWPHMGLECOn1jz/+yOQeERERFWsymQwmJiYwMTGBra2tVredmpqabRJQMSCGtgdlKWyVK1fGmjVrMGnSJMydOxc7duyAXC5HVFQUJkyYgCVLlmDmzJkYPHhwiRjQ5EPy/ui5devW1XFEVJrkKcH3ftXSrE1fs8rIyMDz58+xa9cuNG7cON/BERGR5m7cuAE/Pz+p1vSECRPw5Zdf6jgqIiIiIt0xMjKCjY0NbGxsdB2K1lWtWhVbt27FlClTMGfOHOzZswdAZkWbESNGYOHChZgzZw769OkDfX19HUdbOnD0XNKlPDXRzTq0t0wmy7WDVXt7exw8eBBeXl75j7AUYRNdIsqvx48fo0mTJnj58iWAzAeKXbt2Kd23iYiIiOjDdfv2bcycORN//vmn0nRXV1fMnTsX3bt357NhIWvWrJlUg4/Nc0lbCqUPvnPnzgHI7COhZcuWGDRoEAYOHKiynL6+PmxsbFC7dm3eQPKACT4iyo/o6Gh8/PHHePjwIQCgadOm+Ouvv9j3ChEREVEpdOXKFcycOROnTp1Sml6/fn3MmzcPHTp0YM2yQsDRc6mwFEoffD4+PtLfs2fPRosWLdC8efP8R0lE9J6QkBCUL18+z6NQl1ZJSUno3LmzlNyrXbs2Dh06xOQeERERUSnl7e2Nv/76C2fPnsX06dNx6dIlAMCtW7fw2WefoUmTJvjuu+/QsmVLHUf6YcnaPNff35/JPSpy+a5eN3v2bCb3iEirVq9ejRo1aqB27dp49OiRrsMp9jIyMtC3b1/poa1SpUo4duzYB9nHDBERERHlja+vLy5cuICjR4+iQYMG0vTLly+jVatWaNWqFS5fvqzDCD8sij4QAXCQO9IJjZvoPnv2DADg4OAAfX196bUmnJyc8hddKcMmulSahYWFoXbt2khMTAQAVKtWDZcvX0b58uV1HFnxJITAF198gZUrVwIAypQpg/Pnz6N+/fo6joyIiIiIihshBA4ePIiZM2fi/v37SvM6dOiA7777js+RBRAeHg5HR0cIIeDq6op79+6xBh9pjaa5Io1r8Lm4uKBKlSoIDQ1Vep3bv6pVqxZ8b4jogzdhwgQpuQcAoaGh6Ny5M5KSknQYVfG1dOlSKblnYGCA/fv386GMiIiIiNSSyWTo3r077t69i19++QXVqlWT5ilq+Pn5+akk/0gzHD2XigONa/ANGjQIMpkMCxYsQMWKFaXXmtiyZUuBgiwtWIOPSqvjx4+jffv2AIAKFSrAwMAAERERAIBu3bph79690NfX12WIxcquXbvQu3dv6fWWLVswaNAg3QVERERERCVKWloatm3bhrlz5yIsLEyaLpPJ0LdvX8yfPx+VK1fWYYQlC0fPpcJUKKPoUuFigo9Ko+TkZLi5uUm1g7dv34569eqhWbNmiI+PB5BZu++nn37SZZjFxtmzZ9G2bVukpqYCAObOnYuZM2fqOCoiIiIiKomSk5OxYcMGfP/993j58qU03dHREYGBgahQoYIOoysZwsPDpWQom+dSYdB6E10iosKwaNEiKbnXvHlz9OvXDx4eHti3b59Ua2/ZsmVYtmyZDqMsHoKCgtC1a1cpuTds2DDMmDFDx1ERERERUUllYmKCcePGITQ0FAsXLpQGawsLC4Ofnx/S0tJ0HGHxt3//fulvNs8lXWINvmKENfiotAkNDUXdunWRkpICfX193L59W6k6+6ZNmzB06FAAmc0F9u3bh+7du+sqXJ0KDw+Ht7c3nj9/DiCzM+RDhw7BwMBAx5ERERER0YciIiICnp6eePHiBQBgzJgxWLVqlY6jKt6yNs8NCgpC3bp1dRwRfWiKpAbf/fv3MXr0aHh5eaFGjRqoWrWqyr+snXcSESkIITB+/HikpKQAAL788kuVvio+//xzqfmpEAJ9+/bF5cuXizxWXYuKikK7du2k5J6npyd2797N5B4RERERaZW9vT0OHDgAIyMjAMDPP/+MTZs26Tiq4is8PFxK7rm6ujK5RzqV7wTfuXPn0LBhQ6xduxZ37txBcnIyhBAq/+RyuTbjJaIPxKFDh3D06FEAgIODA2bPnq12uW+//Rb9+/cHkNlHSKdOnfDo0aMii1PXnj17hmbNmiEoKAgAULVqVfz5558oU6aMjiMjIiIiog+Rt7c31qxZI70ePXp0qfyRXRPvN88l0qV8N9Ft0qQJAgMDsW7dOgwcOJAjXGoBm+hSaZGQkIA6derg2bNnAIA9e/bk+IGYmpqKdu3aISAgAABQvXp1XLp0CeXLly+SeHXl4cOH+PTTT6WRzSpXrowzZ86gRo0aOo6MiIiIiD5048aNk5rn2tnZITAwEPb29jqOqnhp2rQpLl68CIDNc6nwFHoT3Tt37qBXr14YMmQIk3tElCffffedlNxr3bo1evbsmePyRkZGOHDggPSBGRISgs6dOyMpKanQY9WVO3fuoFmzZlJyr0aNGrhw4QKTe0RERERUJH788Uf4+PgAAF68eIHu3btL3etQZvNcRXKPzXOpOMh3gs/CwoJDZhNRngUHB2Pp0qUAMhN3q1at0mikKWtraxw9ehR2dnYAgCtXrqBfv37IyMgo1Hh14dKlS/D19UVUVBQA4KOPPsLff/8NZ2dnHUdGRERERKWFoaEh9u7dCycnJwDA1atXMXr0aHCczkz79u2T/vb399dhJESZ8p3g69ixI/7++29txkJEHzghBMaMGYO0tDQAwOTJk1GzZk2N13dycsKRI0ek/ucOHDiASZMmFUqsunLq1Cm0bt0aMTExADL7QDl79iwqVqyo28CIiIiIqNQpX748Dh48CFNTUwDA5s2bsXr1ah1HVTzs3btX+pv971FxkO8E36JFixAbG4vx48cjMTFRmzER0Qdq9+7dOHPmDADAxcUF33zzTZ63Ub9+fezdu1fqGuCnn37C8uXLtRqnrhw8eBAdO3aU7qmtWrXCX3/9hbJly+o4MiIiIiIqrRo0aICNGzdKrydMmIBz587pMCLdY/NcKo4M8ruiv78/zM3N8fPPP2Pr1q2oUaMGrKysVJaTyWQ4ffp0gYIkopIvLi4OEydOlF6vWLECZmZm+dpWu3btsHbtWgwbNgwA8OWXX8LJyQndunXTSqy6sH37dgwZMkRqcty1a1f89ttvMDEx0XFkRERERFTa9enTB7du3cKSJUuQnp6Onj174saNG1Lz3dKGzXOpOMr3KLp6eppV/pPJZB9kH1mFgaPo0ofsyy+/xLJlywAAnTt3xqFDhwq8zZkzZ+K7774DAJiYmCAgIADe3t4F3m5RW7lyJcaPHy+97t+/PzZv3gwDg3z/BkNEREREpFUZGRno0KEDTp48CSCzZc2FCxfy/aN9ScbRc6koaZoryneCj7SPCT76UN29excNGjRARkYGTE1Ncf/+fbi4uBR4u0IIDBw4EDt27AAA2Nra4vLly6hevXqBt10UhBD4/vvvMXPmTGna2LFjsXz5co1/RCEiIiIiKipv3ryBl5cX/vvvPwCZNft++eUXjQbN+1A8f/4cjo6OAIA6derg3r17Oo6IPnSa5or4DZKICpVcLseoUaOkmrzTp0/XSnIPyKwhvHHjRrRo0QIA8Pr1a7Rv3x6vX7/WyvYLkxACkydPVkruzZgxAytWrGByj4iIiIiKJRsbGxw6dAjm5uYAgF9//RVLly7VcVRFa//+/dLfHFyDihN+iySiQrVt2zZcunQJAFCzZk18/fXXWt2+kZERDhw4IFWLDwkJQefOnZGUlKTVcrQpIyMDw4cPx5IlS6Rpixcvxrx580rVr59EREREVPK4ublh+/bt0uspU6ZIzXZLA46eS8WVxk10FRdwt27dYGFhoXRB52bAgAH5i66UYRNd+tC8efMGtWrVkmrUnTx5Eq1bty6Usp49ewZvb2+8ePECANCjRw/s2bOn2NWGS01NRf/+/bFnzx4AmbUQ161bJw0YQkRERERUEsyaNQvz5s0DAJQtWxbXr19HtWrVdBxV4WLzXNIFrffBp6enB5lMhgcPHqBmzZrS65wIITjIRh4wwUcfmlGjRmHt2rUAMkeX2r17d6GWd+vWLTRr1gwJCQkAgIkTJxarJgOJiYno2bMnjh07BgAwMDDAL7/8gv/97386joyIiIiIKG/kcjm6du2Kw4cPAwDq1q2LK1euoEyZMjqOrPAsX74cEyZMAADMnj0bc+bM0Wk8VDpoPcG3detWyGQydO/eHRYWFti2bZvGwQwcOFDjZUszJvjoQ3L9+nU0btwYQgiUKVMGwcHBcHBwKPRyjx07hk6dOkk/LCxfvlxphFpdiYuLQ6dOnXD+/HkAmaP+7tu3Dx07dtRxZERERERE+RMXF4fGjRsjODgYANC9e3fs3bu32LWi0ZZPPvlE6n6Io+dSUeEouiUQE3z0ocjIyEDjxo1x48YNAMCSJUvw1VdfFVn5GzZswPDhwwFkNoE9cOAAunbtWmTlv+/169do166d9H5YWFjg8OHD8PHx0VlMRERERETa8PDhQ3h5eSEuLg4AMG/ePMyYMUPHUWkfm+eSrnAUXSLSmfXr10vJLDc3tyKvQTds2DBMnz4dQGZXAb1798aVK1eKNAaF8PBwNG/eXHo/ypUrhzNnzjC5R0REREQfhJo1a+K3336TuvCaOXOm1Gz3Q7Jv3z7pb39/fx1GQqQeE3xEpFVRUVGYNm2a9Hr16tUwNDQs8jjmzZuHfv36AQCSk5PRqVMnhIaGFmkMoaGhaNq0KR48eAAAsLe3x/nz5+Hp6VmkcRARERERFaYOHTrg+++/l1737dtXarb7oeDouVTcadxEt2rVqvkrQCYr8i/VJRWb6NKHYPDgwdi6dSuAzBG089Jfp7alpqaiXbt2CAgIAADUqFEDly5dgq2tbaGXHRQUhNatWyMyMhJA5j301KlTqFKlSqGXTURERERU1IQQ+N///iclwmrWrImrV6/C2tpat4Fpwd27d+Hu7g6AzXOp6Gm9ia5cLocQIs//5HK5VnaIiIq/CxcuSMk9KysrLFq0SKfxGBkZ4cCBA6hTpw4A4NGjR+jSpQuSkpIKtdxr166hefPmUnKvbt26+Pvvv5ncIyIiIqIPlkwmw5YtW1CvXj0AmX3z9e3bVxr8riRKSUnB3Llz4eXlJU1j81wqrjjIRjHCGnxUkqWnp6NBgwb4559/AAA///wzRo8ereOoMj179gze3t548eIFAKBHjx7Ys2dPoYzuFRAQgM6dOyM+Ph4A4OXlhWPHjqFcuXJaL4uIiIiIqLh5/PgxPD098ebNGwDAtGnTlJrvlhTnzp3DiBEj8O+//0rTatSogcuXL/PZnooUB9kgoiK1cuVKKbnXsGFDjBgxQscR/R8nJyccOXIE5ubmAID9+/dj8uTJWi/n8OHDaN++vZTc8/HxwenTp/kAQERERESlRpUqVZR+TP/hhx+U+q8r7qKjozFkyBD4+vpKyT19fX1MmTIFt2/f5rM9FVtM8BFRgYWHh2PWrFkAMqvmr169Gvr6+jqOSln9+vWxd+9eKa6lS5di5cqVWtv+r7/+im7duiElJQUA8Nlnn+HYsWOwsLDQWhlERERERCVBq1atsGTJEun1oEGDcPfuXR1GlDshBHbs2IHatWtjy5Yt0nRvb2/cvHkTCxYsgJmZmQ4jJMpZgZvoPn/+HAEBAYiIiJC+2CoVIJNh5syZBSmi1GATXSqpevXqhd27dwMAhg8fjnXr1uk4ouytX79eql0ok8lw8OBBdOnSpUDbXLNmDcaMGQPF7bR3797Ytm2bTkYPJiIiIiIqDoQQGDhwIHbs2AEgs2bf9evXi2UNuEePHmHkyJE4c+aMNM3S0hILFizAiBEjCqVrHyJNaZorKlCCb9KkSVi+fLlSp5lCCMhkMqW/89KpZkxMDGbNmoXr16/j8ePHePv2LWxtbVGrVi2MGTMG3bt3l7aflpaGP/74A4cPH8bVq1fx7Nkz6OnpoU6dOhg4cCBGjBiRr1pEBw8exOrVq3Hz5k0kJiaiUqVK8Pb2xqJFi+Do6Ki07KNHj/DDDz/gwoULeP78OWxsbFCnTh2MGzcOnTt3zlO5TPBRSXT69Gl8+umnAABbW1sEBwcXyw/trKZPn44ffvgBAGBqaoqAgAA0btw4X9tasGABvvnmG+n1iBEj8PPPPxe7GoxEREREREUtKSkJzZs3R2BgIIDMmn3Hjx+HgYGBjiPLlJKSgkWLFuH7779XqrDk7++PZcuWwc7OTofREWUq9ATfhg0bMGLECLRu3RojR45Ejx49MGjQILRt2xbnz5/Hxo0b0aVLF4wZMwY+Pj4abzckJAQeHh7w9vZG9erVYWNjg6ioKBw+fBhRUVEYNmwY1q9fDwAIDg6Gq6srLCws0LJlS9SqVQuxsbE4fPgwIiIi0KlTJxw6dEhKCOZGCIGRI0di/fr1qFatGtq2bQsLCwtERETg3Llz2LlzJ5o2bSotf/XqVbRo0QJpaWno3LkzatSogaioKBw4cACxsbGYM2cOZs+erfG+M8FHJU1KSgrc3d2lvik2bdqEIUOG6Diq3Akh0K9fP/z6668AgPLly+Py5cuoVq1anrYxbdo0LFiwQJo2efJkLFiwQON7DhERERHRhy4sLAyenp6IiooCAEycOBFLly7VcVTA33//jREjRuDBgwfSNGdnZ6xevRodOnTQYWREyjTOFYl88vT0FFWqVBEZGRlCCCFkMpn49ttvpflnz54VhoaGYu/evXnabnp6ukhLS1OZHhcXJ+rUqSMAiKCgICGEEM+fPxerV68WCQkJSsvGx8cLT09PAUDs2bNH47KXL18uAIgxY8aI9PR0lfnvx9W+fXsBQBw6dEhp+tOnT4WlpaUwNTUVycnJGpcfGxsrAIjY2FiN1yHSpR9++EEAEABEkyZNpPtBSZCcnCx8fX2l+GvUqCFevXql0boZGRli5MiR0roAxPz58ws5YiIiIiKikun8+fPCwMBAenbevn27zmKJjo4Wn3/+udKzvL6+vpg0aZKIj4/XWVxE2dE0V5TvhuTBwcFo166dUlv09PR06W8fHx907NhRqWNNTejr66utrmthYYG2bdsCyKzlBwAODg4YNWqUSkeX5ubmmDhxIoDMoa01kZSUhG+//RZVq1bFsmXL1Davez+u//77DzKZDO3atVOa7uTkBDc3NyQlJeHdu3calU9U0jx58gTz5s0DAOjp6WH16tUlqm8KY2NjHDhwAHXq1AGQ2dy+S5cuSEpKynG9tLQ09O/fH2vXrpWm/fzzz5g6dWqhxktEREREVFI1a9ZMaYC7YcOGSc12i4oQAjt37kTt2rWxadMmaXqjRo1w48YNLFq0CObm5kUaE5E2FejbuLW1tfS3ubk5oqOjlebXqlUL9+7dK0gRkuTkZJw5cwYymUz6Qp4TRef2mrbt/+uvv/DmzRt07doVGRkZOHDgABYsWIC1a9dKCcX31a1bF0IInDx5Uml6WFgYgoKCUK9ePdja2mpUPlFJM2HCBCkZNm7cOHh4eOg2oHwoW7Ysjh49ikqVKgEALl26hIEDB0Iul6tdPjk5GT169JCa9urr62PHjh0YPXp0kcVMRERERFQSjRgxAsOGDQOQ2dVPt27d8PLlyyIpOyQkBG3atEG/fv3w6tUrAJmViFatWoVLly7B3d29SOIgKkz57tnSwcEBz58/l15Xq1YNV69eVVomKCgo3xnwmJgYLFu2DHK5HFFRUTh69CjCwsIwe/Zs1KhRI9f1N2/eDABo06aNRuUpfj0wMDBQ6lMMyKyd9OWXX6rURpw3bx4uXLiA7t27o0uXLqhevTpevXqFAwcOwNnZGXv27NF0d4lKlCNHjuDQoUMAgEqVKuHbb7/VcUT55+zsjCNHjqB58+ZISEjA3r174ezsjMWLFyst9+7dO3Tp0gUBAQEAACMjI+zZs6fAI/ASEREREZUGMpkMK1euxL1793Dp0iU8f/4cPXv2xOnTp2FkZFQoZaampmLx4sWYN2+e0iAaPXv2xPLly2Fvb18o5RLpRH7bAA8ZMkTUqFFDej1r1iyhp6cnRowYIf78808xdepUoaenJ/z8/PK1/cePHyu1iTc0NBSLFy8Wcrk813XXrVsnAIiWLVtqXN6IESOktvdeXl7i2rVr4t27d+L8+fOidu3aAoBYvXq1ynr//fefaNiwoVKsZcuWFT/++KPafvyySk5OFrGxsdK/sLAw9sFHxV5iYqKoUqWKdL7v3LlT1yFpxdGjR4W+vr60XytXrpTmRUdHi0aNGknzzM3NxalTp3QYLRERERFRyRQRESHs7e2lZ+tRo0YVSjl///231I+/4p+Tk5M4fPhwoZRHVFg07YMv3wm+gIAA0a5dO/HkyRMhhBDv3r0TDRo0EDKZTOjp6QmZTCaqVKkizc+v9PR08fjxYzF//nxhZGQkunXrpnYQDoU///xTGBoaCmdnZxEREaFxOcOGDRMAhKmpqQgPD1eaFxQUJPT09ES1atWUpl+/fl3Y29uL1q1bixs3boiEhATx33//ia+//loAEN26dcuxzNmzZyvdbBT/mOCj4mzmzJnSudqiRQuNku4lheLHAQBCT09P/P777yIiIkK4ublJ062trcXly5d1HSoRERERUYl19epVYWRkJD1jr1+/XmvbfvPmjfT9XvFPX19ffPXVV+Ldu3daK4eoqGia4JMJIYS2agOmpaXh0KFDCA0NhbOzMzp16qTVTioXL16MyZMnY/Xq1Rg1apTK/BMnTqBLly4oX748zp07h6pVq2q87UmTJmHJkiVo1qwZzp8/rzK/Ro0aCAkJwdu3b2FtbY20tDTUrl0bKSkpePjwocpAH7169cLu3btx5swZtGjRQm2ZKSkpStWE4+Li4OjomPvQx0Q68ujRI7i5uSE1NRUGBga4e/cuXF1ddR2WVk2bNg3z588HAJiamqJixYp48uQJAKBixYo4efIkPvroIx1GSERERERU8m3duhWDBw8GkNmH/tmzZ/Hxxx/ne3tCCOzatQsTJkxAVFSUNN3Lywvr1q1D/fr1CxwzkS7ExcXBysoq11yRVoe8lMlkqFatGtq0aYMePXpofQQaRX96Z8+eVZl3/PhxdO3aFba2tggICMhTcg/IHBAEUB44JCvFdMWgAsHBwfjvv//QuHFjleQeALRs2RIAcOPGjWzLNDY2hqWlpdI/ouJKCIFx48YhNTUVAPDVV199cMk9APjuu+/Qp08fAJnXuyK55+zsjAsXLjC5R0RERESkBYMGDcL48eMBZFYW6tGjB8LDw/O1rdDQULRr1w59+vSRknsWFhZYsWIFLl++zOQelQp5SvA9fvwYmzdvxsOHD1Xm/fnnn3BwcICnpyc8PT1hZ2en9UEmIiIiAKiOjKtI7pUtWxYBAQGoXr16nretqGX34MEDlXlpaWkICQmBubk5ypcvDwBSkkMxAs/7FNONjY3zHAtRcXTgwAGcOHECAODo6IiZM2fqOKLCoaenh82bN8PHx0eaVrt2bVy4cCFf9xYiIiIiIlJvyZIl0nfxyMhIdO/eHcnJyRqvn5qaivnz58PNzQ0nT56Upnfv3h3379/HuHHjoK+vr/W4iYqjPCX4NmzYgGHDhqkkrUJCQuDv749Xr17ByckJtWvXxtu3b9G3b1/cunUrTwHdvn0bsbGxKtPfvHmDadOmAQDat28vTX8/uZfbCLtpaWkIDg5GaGio0nRFzcOQkBBs3LhRad6CBQsQExODbt26SclFNzc3WFlZ4eLFi0o3EiAzEbl69WoAgK+vr2Y7TlSMxcfH44svvpBeL1u2TOs1dIsTY2NjHDx4ECNGjMCwYcNw/vx5VK5cWddhERERERF9UAwNDbF79244OzsDAK5du4ZRo0ZBk57ELl68iAYNGmDatGlSUtDR0RGHDh3C/v37+fxOpU6e+uBr3rw54uPjcfPmTaXp48aNw88//4wxY8Zg5cqVADJr+/Ts2RODBw/Gpk2bNA5owoQJ2LhxI1q0aAFnZ2eYm5vj6dOnOHLkCOLj49GjRw/s2bMHenp6CA4OhoeHB1JSUtCrVy+pmW1WLi4uGDRokPT6yZMnqFKlCpydnaWmdwqhoaH4+OOPERUVhY4dO6J27dq4desWzpw5A2dnZ1y5cgWVKlWSlt+0aROGDh0KPT09dOzYEa6urnj58iUOHjyIuLg4jBkzBqtWrdJ43zVtV01U1CZPnozFixcDyEywHzlyBDKZTMdRERERERHRh+D27dv4+OOPpS6xVqxYgXHjxqld9u3bt5g6dSrWr18vTdPT08MXX3yBuXPnokyZMkUSM1FR0TRXlKcEn6OjI3x9fbFjxw6l6TVq1EBYWBhevXoFCwsLabqPjw9evHihtklvdi5cuIBNmzbhypUriIiIQGJiImxsbNCgQQMMGDAAvXr1khILZ8+ezXYAi6wxZO2zL6cEHwCEhYVh1qxZOH78OKKjo1GpUiV07twZs2bNQoUKFVSWP336NJYtW4arV6/izZs3MDc3h7u7O4YOHYoBAwZovN8AE3xUPN27dw8eHh5IT0+HsbEx7t27h2rVquk6LCIiIiIi+oDs2rULvXv3BgDo6+vj1KlTSi3ihBDYvXs3JkyYgJcvX0rTGzZsiPXr16NBgwZFHTJRkdA0V2SQ7Rw1Xr9+DUdHR6VpMTExCA0NRbNmzZSSewDg4eGBwMDAvBSBpk2bomnTphot6+vrq1HV3axcXFxyXMfR0RFbtmzReHutWrVCq1at8hQDUUkhhMCYMWOQnp4OAJg6dSqTe0REREREpHW9evXCrVu3sGjRImRkZMDPzw+BgYFwdnbGf//9h9GjR0t9ggNAmTJl8P3332PMmDHsZ48IeeyDz8DAADExMUrTFH3seXp6qizPqrFEJdvOnTtx7tw5AEDVqlUxZcoUHUdEREREREQfqh9++AFt27YFkFnBqGvXrtIgGlmTe127dsX9+/cxfvx4JveI/r881eCrWbMmTp8+rTTt5MmTkMlk+Pjjj1WWj4iIgJ2dXcEiJCKdiImJwddffy29XrVqFUxNTXUYERERERERfcj09fXx22+/oVGjRggJCcHt27dx+/ZtaX7lypWxcuVKdO3aVWcxEhVXearB16NHDzx69AgjRozA3bt3ceDAAaxZswZlypRBu3btVJa/ePEiqlevrrVgiajozJo1S+rbolu3bkqjVxMRERERERWGsmXL4vfff1dqEagYROP+/ftM7hFlI0+DbCQlJcHb2xv//POPNNCFEAKLFy/GV199pbRsYGAgGjVqpHYeqcdBNqi4uHXrFjw9PSGXy2FmZoYHDx7AyclJ12EREREREVEpcfz4cQwdOhRVq1bFjz/+qLZbMKLSoFAG2TA1NcXFixfx008/4cqVK7CxsYGfnx86d+6ssuzNmzfRpUsXtfOIqPiSy+UYNWoU5HI5AGDmzJlM7hERERERUZFq164dnj9/ruswiEqMPNXgo8LFGnxUHGzcuBHDhg0DANSuXRt37tyBkZGRjqMiIiIiIiIiKn00zRXlqQ8+IvqwRUdHY+rUqdLr1atXM7lHREREREREVMwxwUdEkm+++QbR0dEAgN69e6NFixY6joiIiIiIiIiIcsMEHxEBAK5cuYINGzYAACwsLLB06VIdR0REREREREREmmCCj4iQkZGB0aNHS6/nzZsHOzs7HUZERERERERERJpigo+IsGbNGty6dQsA4O7ujjFjxug4IiIiIiIiIiLSFBN8RKVcZGQkZsyYIb1evXo1DAwMdBgREREREREREeUFE3xEpdw333yD2NhYAMDgwYPx8ccf6zgiIiIiIiIiIsoLJviISrHHjx9jx44dAICyZcti4cKFOo6IiIiIiIiIiPKKCT6iUuynn35CRkYGAGDChAkoX768jiMiIiIiIiIiorySCSGEroOgTHFxcbCyskJsbCwsLS11HQ594F6/fg0nJyckJSXBzMwMz549Q7ly5XQdFhERERERERH9f5rmiliDj6iUWr16NZKSkgAAQ4cOZXKPiIiIiIiIqIRigo+oFEpMTMTKlSsBAPr6+vjyyy91HBERERERERER5RcTfESl0NatW/H69WsAwP/+9z+4uLjoNiAiIiIiIiIiyjcm+IhKmfT0dCxZskR6PWnSJB1GQ0REREREREQFxQQfUSmzf/9+PH78GADQpk0beHh46DYgIiIiIiIiIioQJviIShEhBBYtWiS9njx5sg6jISIiIiIiIiJtYIKPqBQ5c+YMbt68CQBo2LAhWrZsqeOIiIiIiIiIiKigmOAjKkXer70nk8n+X3t3Hh7T2f4B/PtkEbIjCEoisQWvta3SxFZrW6q0aKtEUVTRommrtetiK9ralVfflr5IqdauKIp6bW2tkQhijYgsskkm9+8Pv5kmTVT2c87M93NdrmZmzszcJ9+eZM6d5zyPhtUQERERERERUVFgg4/IRpw4cQLbt28HAPj5+aFHjx4aV0RERERERERERYENPiIbkXX03pgxY+Dg4KBhNURERERERERUVNjgI7IBkZGRWLNmDQDAy8sLwcHB2hZEREREREREREWGDT4iGzBnzhyYTCYAwIgRI+Ds7KxxRURERERERERUVJSIiNZF0H0JCQnw8PBAfHw83N3dtS6HrERMTAyqV6+OlJQUODs74/LlyyhfvrzWZRERERERERHRQ+S1V8QRfERWbsGCBUhJSQEADBo0iM09IiIiIiIiIivDBh+RFUtOTsYXX3wBALC3t8fbb7+tcUVEREREREREVNTY4COyYitWrEBMTAwAoHfv3vD19dW2ICIiIiIiIiIqcmzwEVmpjIwMzJ4923L7nXfe0bAaIiIiIiIiIioubPARWanQ0FBERkYCADp27IjGjRtrWxARERERERERFQs2+IiskIhgxowZltshISEaVkNERERERERExYkNPiIrtGvXLhw7dgwA0KxZM7Rr107jioiIiIiIiIiouOiuwRcXF4eRI0eiRYsW8Pb2hpOTE6pWrYp27dohNDQUImLZNj09HaGhoQgODkZAQABcXFzg5uaG5s2bY8GCBTCZTAWqYf369ejQoQPKly+PMmXKoEaNGnjppZcQFRWV6/aRkZEYPHgwfHx84OTkhEqVKqFt27ZYu3Ztgd6fqLD+PnpPKaVhNURERERERERUnJRk7ZjpQHh4OBo3bownnngCNWvWRLly5RAdHY0ff/wR0dHRGDx4MJYsWQIAOHv2LAICAuDm5oZ27dqhTp06iI+Px48//ohr166ha9eu+OGHH/Lc3BARDB06FEuWLIG/vz86deoENzc3XLt2Db/88gu+/fZbBAYGZnvOjh070L17dwBA165d4efnhzt37uCPP/5AgwYNsHjx4jzve0JCAjw8PBAfHw93d/c8P48oq+PHj6Np06YAAD8/P5w7dw4ODg4aV0VERERERERE+ZXXXpHuGnwmkwkikqMhkZiYiCeeeAKnT5/GyZMnUb9+fVy9ehUbN25E//794ezsbNk2KSkJbdq0wZEjR7BmzRq8+OKLeXrvzz//HKNGjcLw4cMxb9482NvbZ3s8IyMjW11RUVFo0KABKlWqhJ07d6J69er/uP3DsMFHReHll1/G6tWrAQDz58/HG2+8oXFFRERERERERFQQee0V6e4SXXt7+1ybYm5ubujUqROA+6P8AKBq1aoYNmxYtuYeALi4uGD06NEAgF9++SVP75uSkoLJkyfDz88Pc+fOzdHcA5Cjro8//hgJCQlYtGhRjuZebtsTFbfIyEisWbMGAODl5YXg4GBtCyIiIiIiIiKiYmeYDlRqaip27doFpRTq1av30O0dHR0B5L3JtmPHDsTGxiI4OBgmkwkbN25EWFgYPD090b59e9SsWTPb9iKCNWvWoHz58mjXrh2OHj2KX375BZmZmWjcuDHatWsHOzvd9U/Jys2ZM8cy9+SIESNyNL+JiIiIiIiIyProtsEXFxeHuXPnIjMzE9HR0di8eTOioqIwceJE1KpV66HPX758OQCgY8eOeXq/I0eOALjfEGzUqBHOnTtneczOzg5vv/02Zs2aZbkvMjISsbGxeOyxxzBs2DAsWrQo2+s1adIEGzduxCOPPPLA90xLS0NaWprldkJCQp5qJcpNTEwMli1bBgBwdnbG8OHDNa6IiIiIiIiIiEqCboeYxcXFYfLkyZg6dSoWL16MGzduYObMmZg4ceJDn7tkyRJs2bIF7dq1w9NPP52n94uOjgYAzJ49G+7u7jh8+DASExOxd+9e1K5dG7Nnz8bChQtzbH/s2DF88803WLFiBWJjYy0r6h4/fhwvvPDCP77nJ598Ag8PD8u/atWq5alWotwsWLAAKSkpAIBBgwahfPnyGldERERERERERCVBd4ts/J3JZEJUVBS+++47TJw4Ec888wzWrFnzwEtvN23ahOeffx5VqlTBwYMHUbly5Ty9z+uvv46lS5eiTJkyCA8PR5UqVSyPnTp1Cg0bNkSNGjUs8/8dOHAATz75JID7l0W+9dZb2V7viSeewG+//YZ9+/blWHnXLLcRfNWqVeMiG5RvycnJ8PHxQUxMDOzt7REeHg5fX1+tyyIiIiIiIiKiQjDsIht/Z29vD19fX7z33nuYNm0a1q9fj6VLl+a67bZt29CzZ09UqlQJu3btynNzDwA8PDwAAI8++mi25h4A1K9fH35+foiIiEBcXFy27QGgW7duOV6va9euAP669Dc3Tk5OcHd3z/aPqCBWrFiBmJgYAEDv3r3Z3CMiIiIiIiKyIbpv8GVlnk9vz549OR7bunUrunfvDi8vL+zevRt+fn75eu06deoAADw9PXN93Hy/+RLImjVrWlbaze05f9+eqLhkZGRg9uzZltvvvPOOhtUQERERERERUUkzVIPv2rVrAHKujGtu7pUtWxa7d+/OseJtXrRt2xYAcObMmRyPpaenIzw8HC4uLqhQoQKA+6PvWrZsCQA4ffp0jueY7+NIKipuoaGhiIyMBHC/Cd64cWNtCyIiIiIiIiKiEqW7Bt+JEycQHx+f4/7Y2FiMGzcOANClSxfL/X9v7j1shd309HScPXsWERER2e739/dHx44dER4eblmJ1OzTTz9FXFwcnn/++WzNxWHDhgEAJk2alG0uvbNnz+Lf//433Nzc0Llz5zzuOVH+iQhmzJhhuf3uu+9qWA0RERERERERaUF3i2y89dZbWLZsGdq2bQsfHx+4uLjg0qVL2LRpE+7evYuePXtizZo1sLOzw9mzZ9G4cWOkpaWhT58+lstss/L19UVwcLDl9sWLF1GjRg34+Pjg4sWL2baNiIhAy5YtER0djWeeeQZ169bF8ePHsWvXLvj4+ODQoUPw9va2bC8i6NWrF9atW4c6deqgU6dOiI+PR2hoKJKTk/H111/jlVdeyfO+53XiRCKzn3/+Ge3btwcANGvWDP/73/+glNK4KiIiIiIiIiIqCnntFeW+FK2GXnjhBcTHx+PQoUPYu3cvkpOTUa5cOQQGBqJfv37o06ePpYFx48YNy8i57777LtfXa926dbYG3z/x9/fHkSNHMGHCBGzduhXbt2+Ht7c3hg8fjgkTJqBixYrZtldKYfXq1WjZsiW++uorLF682HLp7rhx49C6deuCfyOI8iDr6L2QkBA294iIiIiIiIhskO5G8NkyjuCj/Dh+/DiaNm0KAPDz88O5c+dyzE9JRERERERERMaV116R7ubgI+uSkZGBsLAwrcuwSjNnzrR8PWbMGDb3iIiIiIiIiGwUG3xUbFatWoV69erhqaeeQmpqqtblWJXIyEisWbMGAODl5ZXny9CJiIiIiIiIyPqwwUfFZvXq1Th//jyuXLmSY2ViKpw5c+bAZDIBAEaMGAFnZ2eNKyIiIiIiIiIirXAOPh2xtjn4ss4RV7lyZURERKBMmTIaV2V8MTExqF69OlJSUuDs7IzLly+jfPnyWpdFREREREREREWMc/CR5po0aYLnn38eAHD9+nUsWrRI44qsw4IFC5CSkgIAGDRoEJt7RERERERERDaOI/h0xNpG8AHAn3/+iYYNGwIAKlasiAsXLsDFxUXjqowrOTkZPj4+iImJgb29PcLDw+Hr66t1WURERERERERUDDiCj3ThX//6F3r16gUAiI6Oxvz58zWuyNhWrFiBmJgYAEDv3r3Z3CMiIiIiIiIijuDTE2scwQcAZ86cQf369SEiKF++PCIjI+Hm5qZ1WYaTkZGB2rVrIzIyEsD9OQ4bN26sbVFEREREREREVGw4go90IyAgAC+//DIA4Pbt2/j88881rsiYQkNDLc29jh07srlHRERERERERAA4gk9XrHUEHwCcP38eAQEBMJlM8PT0RGRkJDw9PbUuyzBEBI8++iiOHTsGAPj555/Rrl07jasiIiIiIiIiouLEEXykK7Vq1cKrr74KAIiLi8PcuXO1Lchgdu3aZWnuNWvWDG3bttW4IiIiIiIiIiLSCzb4qMSMHz8eDg4OAIA5c+YgNjZW44qMY/r06ZavQ0JCoJTSsBoiIiIiIiIi0hM2+KjE+Pn5YcCAAQDuDzGdPXu2xhUZw/Hjx7Fjxw4A97+HPXr00LgiIiIiIiIiItITNvioRH344YdwdHQEAMybNw+3bt3SuCL9mzlzpuXrMWPGWEZBEhEREREREREBbPBRCatevToGDx4MAEhKSsrWvKKcIiMjsWbNGgCAl5cXgoODtS2IiIiIiIiIiHSHDT4qcePGjYOTkxMA4Msvv8SNGzc0rki/5syZA5PJBAAYOXIknJ2dNa6IiIiIiIiIiPSGDT4qcVWrVsXQoUMBACkpKdkWkKC/xMTEYNmyZQAAZ2dnvPHGGxpXRERERERERER6xAYfaeK9995DmTJlAAALFy7E1atXNa5If+bPn4+UlBQAwKBBg1C+fHmNKyIiIiIiIiIiPWKDjzTh7e2N4cOHAwDS0tLwySefaFyRviQnJ+OLL74AANjb2+Ptt9/WuCIiIiIiIiIi0is2+EgzISEhcHFxAQAsXboUly9f1rgi/VixYgVu374NAOjduzd8fX21LYiIiIiIiIiIdIsNPtJMhQoVMHLkSADAvXv38NFHH2lckT5kZGRg9uzZltvvvPOOhtUQERERERERkd6xwUeaGjt2LNzc3AAAy5cvx4ULFzSuSHuhoaGIjIwEAHTs2BGNGzfWtiAiIiIiIiIi0jU2+EhT5cqVs8wvl5GRgWnTpmlckbZEBDNmzLDcfvfddzWshoiIiIiIiIiMgA0+0tzbb78NT09PAMDXX3+N8+fPa1uQhnbt2oVjx44BAJo1a4a2bdtqXBERERERERER6R0bfKQ5T09PjBkzBgBgMpkwZcoUjSvSzvTp0y1fh4SEQCmlYTVEREREREREZARKRETrIui+hIQEeHh4ID4+Hu7u7lqXU6ISExPh6+uL2NhY2NnZ4eTJkwgICNC6rBJ1/PhxNG3aFADg5+eHc+fOwcHBQeOqiIiIiIiIiEgree0VcQQf6YKbmxtCQkIAAJmZmZg8ebLGFZW8mTNnWr4eM2YMm3tERERERERElCccwacjtjyCDwCSkpJQo0YN3Lp1C0op/P777/jXv/6ldVklIjIyErVq1YLJZIKXlxcuXboEZ2dnrcsiIiIiIiIiIg1xBB8ZjouLC9577z0A91eTnTRpkrYFlaA5c+bAZDIBAEaOHMnmHhERERERERHlGUfw6Yitj+ADgJSUFPj5+eHGjRsAgGPHjqFJkyYaV1W8YmJiUL16daSkpMDZ2RmXL19G+fLltS6LiIiIiIiIiDTGEXxkSGXKlMG4ceMstydOnKhhNSVj/vz5SElJAQAMGjSIzT0iIiIiIiIiyheO4NMRjuC7LzU1FbVq1cKVK1cAAIcPH8Zjjz2mcVXFIzk5GdWrV8ft27dhb2+P8PBw+Pr6al0WEREREREREekAR/CRYZUuXRoffPCB5faECRM0rKZ4rVixArdv3wYA9O7dm809IiIiIiIiIso3juDTEY7g+8u9e/dQu3ZtXLp0CQDw66+/omXLlhpXVbQyMjJQu3ZtREZGAgCOHz+Oxo0ba1sUEREREREREekGR/CRoZUqVQrjx4+33LbGUXyhoaGW5l7Hjh3Z3CMiIiIiIiKiAmGDj3SrX79+8Pf3BwD8/PPP+OWXXzSuqOiICGbMmGG5/e6772pYDREREREREREZme4afHFxcRg5ciRatGgBb29vODk5oWrVqmjXrh1CQ0OR9Yri9PR0hIaGIjg4GAEBAXBxcYGbmxuaN2+OBQsWwGQyFaiG9evXo0OHDihfvjzKlCmDGjVq4KWXXkJUVNQ/Pi8yMhKurq5QSmHo0KEFem/6i6OjY7aRexMmTIC1XFH+888/49ixYwCAZs2aoW3bthpXRERERERERERGpbsGX0xMDJYvXw4XFxd0794dY8aMQZcuXXDq1Cm88MILGDJkiGXbiIgIvPDCC/j+++9Rp04dvPnmm3jllVdw5coVDB8+HM8//3y+GkIigiFDhqBHjx6IjIxEnz59MGrUKAQFBeHAgQOW+eAe9NwBAwYUat8pp5dffhl16tQBAOzduxe7du3SuKLCy8zMxMcff2y5HRISAqWUhhURERERERERkZHpbpENk8kEEYGDg0O2+xMTE/HEE0/g9OnTOHnyJOrXr4+rV69i48aN6N+/P5ydnS3bJiUloU2bNjhy5AjWrFmDF198MU/v/fnnn2PUqFEYPnw45s2bB3t7+2yPZ2Rk5Kgr63PHjBmDGTNmYPTo0RgyZAgWLVqUr33nIhu5W716NV5++WUAQIsWLfDrr78atiGWnp6O4OBgrFq1CgDg5+eHc+fOPfD/KyIiIiIiIiKyXYZdZMPe3j7XZoebmxs6deoEAAgPDwcAVK1aFcOGDcvW3AMAFxcXjB49GgDyPG9bSkoKJk+eDD8/P8ydOzdHcw/AA5sw4eHheP/99xESEoImTZrk6f0o73r16oX69esDAA4ePIht27ZpXFHBpKamomfPnpbmnr29PebOncvmHhEREREREREViu4afA+SmpqKXbt2QSmFevXqPXR7R0dHAA9uyv3djh07EBsbi+7du8NkMuH777/Hp59+ikWLFlkairnJzMzEgAED4OPjY5UrveqBvb09Jk2aZLk9fvx4w83Fl5iYiKeffho//vgjAMDJyQnr169H165dNa6MiIiIiIiIiIxOt0OH4uLiMHfuXGRmZiI6OhqbN29GVFQUJk6ciFq1aj30+cuXLwcAdOzYMU/vd+TIEQD3G4KNGjXCuXPnLI/Z2dnh7bffxqxZs3I8b+7cuThw4AD2798PJyenPL2XWVpaGtLS0iy3ExIS8vV8W9KjRw80atQIv//+O44cOYKffvrJMM2x2NhYdOnSBYcPHwYAuLq6YuPGjVxYg4iIiIiIiIiKhG5H8MXFxWHy5MmYOnUqFi9ejBs3bmDmzJmYOHHiQ5+7ZMkSbNmyBe3atcPTTz+dp/eLjo4GAMyePRvu7u44fPgwEhMTsXfvXtSuXRuzZ8/GwoULsz0nLCwMH374IUaNGoUWLVrkex8/+eQTeHh4WP5Vq1Yt369hK+zs7DB58mTL7QkTJiAzM1PDivLm+vXraN26taW5V7ZsWezcuZPNPSIiIiIiIiIqMrpt8Pn6+kJEkJGRgcjISEyZMgUffPABevbsiYyMjAc+b9OmTXjzzTfh4+ODb775Js/vZ24WlSpVChs2bMBjjz0GV1dXBAUFYd26dbCzs8Ps2bOzbR8cHIwqVapg2rRpBdrH999/H/Hx8ZZ/UVFRBXodW9GtWzc0a9YMAHDixAls2LBB24IeIjIyEoGBgTh58iQAwNvbG3v37kXz5s01royIiIiIiIiIrIluG3xm9vb28PX1xXvvvYdp06Zh/fr1WLp0aa7bbtu2DT179kSlSpWwa9cuVK5cOc/v4+HhAQB49NFHUaVKlWyP1a9fH35+foiIiEBcXByA+6vmHjp0CMuWLcuxyEdeOTk5wd3dPds/ejClFKZMmWK5PXHiRN2O4jtz5gyCgoJw4cIFAICPjw/27duHBg0aaFwZEREREREREVkb3Tf4sjLPp7dnz54cj23duhXdu3eHl5cXdu/eDT8/v3y9dp06dQAAnp6euT5uvj8lJQXA/RFkIoK2bdtCKWX5Z770cvHixVBKoXv37vmqg/5Zly5d8MQTTwAATp48ibVr12pcUU5Hjx5FUFAQrl69CgCoW7cu9u/fj5o1a2pcGRERERERERFZI90uspGba9euAci5Mq65uVeuXDns3r27QI0Uc2PuzJkzOR5LT09HeHg4XFxcUKFCBQBA69atc12h9/r169i8eTPq1q2LJ598Ek2aNMl3LfRg5lF85mbvpEmT8MILL8De3l7jyu7bu3cvnn32WSQmJgIAmjZtiq1bt1r+vyEiIiIiIiIiKmq6a/CdOHECNWrUsFwyaxYbG4tx48YBuD+Ky8zc3Ctbtix279790BV209PTERERAUdHR/j7+1vu9/f3R8eOHbF9+3YsW7YMgwYNsjz26aefIi4uDn379rU09QYMGIABAwbkeP09e/Zg8+bNaN26NRYtWpT/bwA9VPv27REUFIR9+/bh7NmzWL16Nfr27at1WdiyZQt69OiB1NRUAEBQUBB+/PHHHP8vExEREREREREVJd01+P79739j2bJlaNu2LXx8fODi4oJLly5h06ZNuHv3Lnr27ImXX34ZAHD27Fl0794daWlpaNOmDVavXp3j9Xx9fREcHGy5ffXqVQQEBMDHxwcXL17Mtu2CBQvQsmVLDB48GBs2bEDdunVx/Phx7Nq1Cz4+Ppg5c2Zx7jrlkXkUn3nU5eTJk9GnT59cR1SWlDVr1uCVV16xLADTpUsXrFu3rsDzMxIRERERERER5ZXuGnwvvPAC4uPjcejQIezduxfJyckoV64cAgMD0a9fP/Tp0wdKKQDAjRs3kJaWBgD47rvvcn291q1bZ2vw/RN/f38cOXIEEyZMwNatW7F9+3Z4e3tj+PDhmDBhAipWrFgk+0iF16ZNG7Rt2xa7d+9GeHg4/vOf/+Q6orIkLFu2DK+//jpEBADw4osv4ptvvkGpUqU0qYeIiIiIiIiIbIsSc1eCNJeQkAAPDw/Ex8dzRd082L9/P4KCggDcH6kZFhYGR0fHEq1h9uzZGDt2rOX2wIEDsXjxYt3MCUhERERERERExpXXXpGhVtElyiowMNCy2MbFixexYsWKEntvEcGECROyNfdGjx6NpUuXsrlHRERERERERCWKDT4ytClTpli+njZtmuWS7eKUmZmJUaNGYerUqdnqmDVrluXycSIiIiIiIiKiksIGHxla8+bN8cwzzwAAoqKisGzZsmJ9v4yMDLz22mv44osvLPfNmzcP48ePZ3OPiIiIiIiIiDTBBh8ZXtZRfB9//DFSUlKK5X3S0tLQq1cvrFy5EgBgZ2eHf//73xg5cmSxvB8RERERERERUV6wwUeG17RpU3Tv3h0AcO3aNSxevLjI3yMpKQldu3bF+vXrAQCOjo5Yu3Yt+vfvX+TvRURERERERESUH2zwkVWYPHmy5etPPvkESUlJRfbacXFx6NChA3bs2AEAcHZ2xk8//YQePXoU2XsQERERERERERUUG3xkFRo2bIgXX3wRABAdHY0FCxYUyevevHkTbdq0wcGDBwEAHh4e2LFjh2X1XiIiIiIiIiIirbHBR1Zj0qRJloUupk+fjsTExEK93uXLlxEUFITff/8dAFChQgXs2bMHLVu2LHStRERERERERERFhQ0+shr16tXDSy+9BAC4fft2tpVu8+vcuXMIDAzE+fPnAQDVqlXDvn370Lhx46IolYiIiIiIiIioyLDBR1Zl4sSJsLO7/7/1rFmzEB8fn+/XOHHiBIKCghAVFQUAqFWrFvbv3486deoUaa1EREREREREREWBDT6yKrVr18arr74KALhz5w7mzp2br+cfOHAAbdq0wa1btwDcn9tv3759qF69elGXSkRERERERERUJNjgI6szYcIE2NvbAwA+++wz3LlzJ0/P27FjBzp06GAZ9deiRQvs2bMHlSpVKrZaiYiIiIiIiIgKiw0+sjp+fn4YMGAAACAhIQGzZ89+6HO+//57PPvss0hOTgYAtG/fHtu3b0fZsmWLtVYiIiIiIiIiosJig4+s0ocffghHR0cAwLx58xATE/PAbVeuXIkXX3wR9+7dAwA8//zz+Omnn+Dq6loitRIRERERERERFQYbfGSVfHx8MGjQIADA3bt3MXPmzFy3+/zzzxEcHIzMzEwAQL9+/bBmzRo4OTmVWK1ERERERERERIXBBh9ZrXHjxlkadV9++SVu3rxpeUxEMHXqVIwaNcpy34gRI7BixQo4ODiUeK1ERERERERERAXFBh9ZrUceeQRDhgwBACQnJ2P69OkA7jf33nnnHUyYMMGy7Ycffoh58+bBzo6HBBEREREREREZixIR0boIui8hIQEeHh6Ij4+Hu7u71uVYhRs3bsDPzw8pKSkoXbo0zp8/j0mTJuGrr76ybDNz5kyMHTtWwyqJiIiIiIiIiHLKa6+Iw5XIqnl7e+ONN94AAKSmpqJZs2aW5p5SCkuWLGFzj4iIiIiIiIgMjQ0+snrvvvsuXFxcAADR0dEAAAcHB6xevRqDBw/WsjQiIiIiIiIiokJjg4+sXoUKFTBixAjL7dKlS+OHH35A7969NayKiIiIiIiIiKhosMFHNuHdd99FixYtUKNGDWzduhVPP/201iURERERERERERUJB60LICoJnp6eOHDggNZlEBEREREREREVOY7gIyIiIiIiIiIiMjA2+IiIiIiIiIiIiAyMDT4iIiIiIiIiIiIDY4OPiIiIiIiIiIjIwNjgIyIiIiIiIiIiMjA2+IiIiIiIiIiIiAyMDT4iIiIiIiIiIiIDY4OPiIiIiIiIiIjIwNjgIyIiIiIiIiIiMjA2+IiIiIiIiIiIiAyMDT4iIiIiIiIiIiIDY4OPiIiIiIiIiIjIwBy0LoD+IiIAgISEBI0rISIiIiIiIiIirZl7ROae0YOwwacjiYmJAIBq1appXAkREREREREREelFYmIiPDw8Hvi4koe1AKnEZGZm4tq1a3Bzc4NSqsCvk5CQgGrVqiEqKgru7u5FWCEVFWZkDMzJGJiT/jEjY2BOxsCc9I8ZGQNzMgbmpH/MqPiJCBITE1GlShXY2T14pj2O4NMROzs7PPLII0X2eu7u7jzAdI4ZGQNzMgbmpH/MyBiYkzEwJ/1jRsbAnIyBOekfMype/zRyz4yLbBARERERERERERkYG3xEREREREREREQGxgafFXJycsLEiRPh5OSkdSn0AMzIGJiTMTAn/WNGxsCcjIE56R8zMgbmZAzMSf+YkX5wkQ0iIiIiIiIiIiID4wg+IiIiIiIiIiIiA2ODj4iIiIiIiIiIyMDY4CMiIiIiIiIiIjIwNviIiIiIiIiIiIgMjA0+IiIiIiIiIiIiA2ODzwAuXbqEhIQErcsgIipxXOidqOBu3ryJsLAw3Lt3T+tSiIiKHc+ZiMjWscGnYykpKRg8eDAaNmyItWvXal0OPUBqaiqWLFmCGTNmYM6cOTh58qTWJdHfpKen4/bt2wDYMNKztLQ0bN26FYcPH8b58+cBAEopjauiv7t37x52796NI0eO4PDhw1qXQ7lISUnB2LFjERQUhIEDB+K3337TuiTKRVpaGvbs2YM//vgDly9f1roceoB79+7hzz//xMWLF3Hr1i2ty6Fc8JzJGHjOZAw8bzI2Nvh0at68eahYsSLWrl2L1157Dc2bN9e6JMrFkiVL4Ovri5CQELz//vsYM2YMOnfujB9++AEAkJmZqXGFtGDBAgQEBGDp0qUA2DDSq4ULF8LX1xc9evRAYGAggoKCMGfOHFy9ehUAjyW9WLBgARo1aoRu3brhySefRGBgID766CPcuHFD69Lo/23YsAE1a9bE8uXL0bRpU3To0AHNmjXTuiz6m/nz56NmzZp45pln8Nhjj6FVq1ZYuHAhbt68CYA/8/Ri/vz5aNy4MVq3bo169eqhQ4cO+PHHH7Uui7LgOZMx8JzJGHjeZAWEdGXXrl1Sq1YtsbOzk549e8qPP/4o8fHxWpdFf5OSkiKjR48WDw8P6d69u6xYsUIOHTokc+bMEaWUdOzYUdLT07Uu06ZdunRJBg8eLEopUUpJu3bt5OjRoyIikpmZqXF1lNX48ePFyclJevToIbNnz5bp06dLgwYNRCklPXr0kLS0NK1LtHnHjx+X1q1bi6Ojo3Tt2lU+/PBDmT59utSpU0dcXV3lP//5j9YlkohERERI/fr1pVmzZrJ27VqJjY21PMafe/pw584dGTRokNjZ2cmzzz4rEydOlPHjx0v16tVFKSW9evWSe/fuaV2mzTt16pR06tRJHB0dpX379jJw4EB56aWXRCklFStWlB9++EHrEm0ez5mMgedMxsDzJuvBBp+OLFmyRJRSUq5cOQkNDZULFy7kuh0PMu0dPnxYXF1dpWvXrnL+/PlsjzVq1EieeOIJSUhIEJPJpFGFtu3q1auWX1JPPvmk9O/fX5RSMn78eElOThYRHkd6ERUVJZUqVZKgoKBsP/NiY2Olc+fOopSS0aNHiwgz08qvv/4qTZo0kYCAAJk1a5ZcvHjR8ti6detEKSVjxowREWakFfP3fezYsaKUkn379uV4jPRhy5YtUrp0aendu7eEh4db7j958qQ89thjopSSkJAQEWF2WgkPD5fOnTtL5cqVZcaMGXLp0iXLY7NnzxZXV1cJDg4WEWakFZ4zGQfPmfSP503WhZfo6oD8/7Xtjz/+OOrUqYPk5GS0atUKNWrUQEZGBq5evYqIiAhs3rwZ169f51BZjZlMJnz//fdISkrCRx99hJo1a1qGld+9exdOTk4ICAiAm5sb7Ox4iGkhLS0NBw8exNChQ7F//35MmjQJDRo0wKpVq/Drr78C4JBzvTh79iyio6MxZMgQ1KhRAyaTCenp6ShbtiwWLlyIOnXqYM6cOfjll1+YmUYyMzNx4sQJTJgwAWPGjIGPj4/l91b16tUB/PV7jBlpQymF5ORk7Nq1C61atUJgYCAyMzPx+++/45tvvsGoUaPw+uuvY9u2bYiPjwfAeXW0kJGRga+//hppaWmYPn06/P39kZmZCRFB/fr1MXr0aADAzJkzsW/fPh5PGhARbNu2Ddu2bcP777+Pd955B9WrV7d8zuvWrRs8PT2xbds2pKamMqMSxnMmY+E5kzHwvMm68EjSAfMB06hRIwwaNAhpaWl4++23AQBfffUVXn31VTRs2BDPPvssfHx88Oqrr+L48eNalmzT7O3tLSt07dy5EwBgZ2eHCxcuYOrUqfjf//6HChUqYN26dTh27JiWpdqsGjVqYMWKFfjkk08AAF5eXnj99dcRGRmJ7777DtHR0QB4gqsH5sU0rl27BuD+seTo6IjMzEz4+vrinXfeAQCMHz9esxptmYggMDAQN2/eRJ8+fSz3K6Vw9uxZTJ06FV5eXnjllVdw584dDSulpKQkREdHw8vLCwCwb98+DB06FP3798f8+fOxbNkydOnSBcOGDQPAD+tacHBwQHx8POzt7S1z7WU9qfX09ISnpycAYMKECVqUaPOUUqhRowYWLVqEESNGALj/c9DOzg4igpo1a6JChQqoUKECkpOT+TmihPGcyVh4zmQMPG+yMpqMG7RxGRkZOe4zD0uOjY2VVq1aiVJKevfuLaVLl5b69evLuHHjZPTo0dK0aVOxs7OTtm3byqlTp0q6dJvyTzkdPXpUlFLi7Owsn376qXzwwQfSsWNHUUpJzZo1pXHjxqKUEicnJ/n6669LunSbER0dLRkZGZKammq5L7fcRO7PTdWpUycpW7asfPvttyVVIsn9eT2uX7+ebW4c87x6R44cEaWUDBw4MNvj5ksBUlNTpWvXrqKUkg0bNoiI8DKOYpJbTlnnxTGZTJKZmSkJCQmyevVqSy41a9YUX19fKV++vIwdO1bOnTunRfk2IbeMzD/zEhISpHz58lK/fn05fPiwNG3aVPz8/GTHjh0SFhYmO3bskLp164pSSj7++GPObVmMHpTTvXv3ZPTo0eLg4CArV67MMdfe6tWrxcXFRSpVqiRKKdm+fbuI8NKo4vL3zwvm73NSUpIkJSXl+pzbt29LlSpV5PHHHy/2+ojnTEbBcyZj4HmTbWCDrwTdunVLnnvuORk/fnyuj5t/EK5evVqcnJzE3d1dpk+fnm2bixcvypAhQ7LNeURF62E5mT8Afvnll1KrVi1xdHQUpZR4enrKwoULJTU1VaKjoyU0NFS8vLzE29tbTpw4UZK7YPVu3rwpw4YNkyZNmkidOnWkVatWsnLlSsvjWU+GzF+bTCYJDQ0VV1dXefrppyUsLCzHtlS0oqOjpW/fvuLt7S3lypWTunXryqRJk7J9zyMjI6Vp06ZSr149OXnyZLbnm38m/vDDD5aJmKno5SWnrC5evChKKSlbtqzMmTNHjhw5Iv/5z3+kb9++opSSPn36lPAeWL+8ZtS7d2/x8vKS4OBg8fT0tPzuMX+A37lzp/j7+4u3t7dERkaW9G5YvbzktGrVKilXrpw0bdpUNm3aJCL3J6HfvHmz1KpVS95//31Zvny5KKUs87xR0XrY57x/cuLECXF1dbXMDfugk2MqHJ4zGQPPmYyB5022hQ2+EvL9999bVkhzd3fPdYRD1gNm+PDh2VYlNI+iMJlMEh4eLlWrVpXmzZvL5cuXi794G5LfnO7cuSPnz5+Xtm3bSmhoaI5tJ02aJEopmTBhgohw5FFRmD9/vnh6ekq5cuXk8ccfl8cff1zc3NxEKSVLliwRkQd/4L5586YMHDhQHB0d5bPPPmMexejAgQNSo0YNqVq1qvTr109GjRolderUEaWU9O3b19LMS0pKkjFjxohSSqZPn/7AUUUNGjSQGjVqZJuUngrvYTmdPn1aRP76uWf+76pVq3IcP/fu3ZOAgABxcnKSXbt2leyOWLGHZWQemZKRkSHLli2TMmXKWCbKvnfvXo6cRo0aJUop+fzzz0WEH9aLysNy+vPPP0VEJD4+Xt59912xt7cXe3t7ef7556VDhw5StWpVqVixouzcuVOio6OlYsWK0q1bN0lLS+PvqiKUl895uTF/rvjqq69EKSXff/99tvup6PCcyRh4zmQMPG+yPWzwFbP09HRZsWKFVK1aVZydnS1Dkvv165fr9uYD59q1a5ZVa/7u9u3b8vjjj0v58uXlxo0bxVa7LclvTlnNmjVLXF1dJS4uTkTu/zIzX3bz66+/ilJKunbtyh+KhZSWliafffaZeHl5Sbdu3WTLli2W7/OGDRtEKSUVK1aUu3fv/uPr/PLLL1KtWjVp2rSpHDx40HL/jRs3+EG9CA0ZMkQcHR1l1apVlkudwsLCZNCgQZYT3mvXronI/VFFfn5+4uvrK//73/+yvY454/79+4u7u7tcuXKlZHfEyuUlJ/PvGfMlulmZT6TMl3u89dZb4uTkJFu2bCnBvbBuecno+vXrIiJy7NgxeeaZZ0QpJTVq1LD83sn6e2nTpk2ilJIPPvhAmx2yUvn5mXfr1i2ZP3++1KxZU6pVqyaVK1eWXr16WVZrvXbtmvj7+0uTJk002x9rU5jPeVkNGDBAypQpk21lXRGRxMRENssLiedMxsBzJmPgeZPtYoOvBLz88svi6Ogohw4dkuTkZGnZsqUopWTnzp35ep2sP+yqVq0qvr6+PNktQllzSkpKynNOPXv2lOrVq8vZs2dFJPucVevXr7csM06Fc/DgQSlXrpw8+eSTlmHiIn99v3v06CFKKdmxY8c/vk58fLyMHz/eksuFCxdk8eLF0qNHD84xUUQiIiKkSpUq0r59e8t95p9fV65ckeeff16UUjJlyhTL4+PHjxc7Ozt5+eWXLflmnZ+qc+fOUrZsWc7vVoTymtPUqVP/8XWyntR26dJFlFKyd+/e4inaxhQkoyVLlki1atVEKSVLly4VEck2386iRYtEKSXLly8vob2wfgU9lmJjYyUiIkIuXLiQ4353d3cZOHBg8RdvQwr7efzOnTsSEBCQbf69hIQE2bBhg4wbN0727NlTXKXbDJ4zGQPPmfSP5022iw2+EnD+/Hn57bffLLeXLVsmdnZ2EhgYmO1D94Nk/SV17949+fTTT7MNYaaikd+czCe148aNk1KlSsnnn39u+QtiWlqabN++XRo0aCBVq1a1XOZGBXfmzBl57rnn5ObNm9nuNx8f5l8+f5/HLbdtIyMjpVmzZlK5cmV54oknRCklHh4esnnz5uLbARty+fJlsbOzkxdeeEGSk5NzjGo4ffq0uLm5iY+Pjxw+fFhE7uf70ksviVJK+vfvL9HR0SJy/4PIjz/+KO7u7tK/f/+S3hWrlp+cjh49KiLZfx9l/To1NdXSOMrviBh6sIIcS1euXLH8PKxcuXK23z87d+6UevXqSUBAgNy+fbtE98WaFeRYynpim1VGRoYlv7Vr1xZ77bakoJ/HzXnu379fSpUqJTNmzBARkb1798pbb70lLi4u4uHhwT9sFAGeMxkDz5n0j+dNtosNPg2kpKRYuubmv67nxdGjR2XixIlSvnx5ad68ueWvH1Q88prThg0bxNfXVxwdHWXQoEGydOlSGTlypPj6+oqrq6ssXLiQl20Ukvn7Z55/Lbeh+/369RMHBwc5c+bMQ19v37590rZtW1FKiVJKRowYISkpKUVbtA27cuWK1K1bVwIDA0Uk9zm+pk6dKkopefvtty33hYWFWUaAtWjRQj744AMZMWKE+Pv7S+XKlS1/ZeTxVDTyk5N5QvncHD16VKZMmSLe3t7SoEEDy0kucyq8gh5LSUlJ8tprr4lSSqpWrSrPPfecdO/eXapXry6urq6ybNmyB74e5V9RHUsnTpyQKVOmSIUKFaRnz578vVTM8vo5z/yZY/bs2aKUkjlz5sjMmTPF399flFIybNiwB14iSoXDcyZj4DmTvvC8ybaxwVfCzAfYtm3bpFy5cuLr65ujs55VdHS0rFy5Ul555RVp1KiRKKWkS5cuXP2umOUlJ/MPz7t378rq1avFy8vL8oPPyclJOnTokKcfmlQ4JpNJMjIypGHDhtKoUSNJTEx84LZ37tyRGTNmiK+vryilpHPnzrzksxgkJSVZ5mTZv3+/iOScwPfatWvi4+MjTZs2zfbBOyYmRkaPHi1ly5YVJycn8fT0lE6dOjGnYpDfnMwZZGZmyrVr1ywr55p/N3Xq1CnHpYZUOIU5lu7evSuLFy+WevXqSeXKlaVatWrSrVs3/l4qBgU9lsx+/vln6d27t9SrV88yB1VUVFSJ1W+L8vt5XETkxRdfFKWUNG/eXJRS0qZNG442KkY8ZzIGnjMZC8+brB8bfBp68803RSkl7733nojc/+H39w772bNnpUOHDuLp6SlPPfUUh8JqIC85idyf3Hzjxo2ycuXKHAsFUPExmUxy69YtKVWqlAwdOlRE7p9Y5fYXwPDwcGnfvr1UqVJFNm7cWNKlGlpe/6JqPjaWLFli+XCdm9TUVBk5cqQ4Oztbjpesl6xdv35dwsPDLStPUt6URE4iIkeOHJFWrVpJlSpVpGPHjvzdlA8lkVHW5lJiYqLExcVxBep8KomczO/x3//+V1q3bi1PP/20bNq0qQiqtx1FMdonL5/zbt68KS1atBCllNSuXTvXVUApdyWVEc+ZCqekchLhOVNhFDYnnjdZPzb4CqGgK/yYn/fnn39K7dq1pXTp0nL8+PFsj6elpVm+PnPmjBw5cqTQ9dqq4swp6yIAVHCFXS3rp59+EqWUrFq16qHbnjhxolDvZYv+/kv/nz5cZH2sZs2aopSynAj9fc4p8+VOK1asKLpibVhJ5pSRkSFhYWHyxx9/FEHltkOLY4mXO+VfSeWU9XcfFwDIv/zklJv8fM5LTU2VTz75RBYsWFC4om1MSWTEc6bCK8ljiQqusDmZ8bzJutmB8uXbb7/F559/DgCwsyvYt8/8vAYNGmDAgAFIS0vDjBkzAABHjx5FSEgItm3bBpPJBDs7O9StWxfNmjUrmh2wESWV09atW5GZmVk0RduYosjIbMOGDXByckLDhg0t90VEROCLL77AqVOnAAAiAgBo1KhRod7L1qxevRpDhgzB0KFD8e677yIsLAxKKQB/fU+zUkohIyMDADBz5kwAwNixY3H37l04ODhARJCeng4A8PHxAQBUrFixJHbFqpV0Tvb29qhVqxb+9a9/Fet+WROtjiXze1DelGROWX/3Va1atfh2ygrlN6fc5PVzXnp6OpycnBASEoJhw4YVzw5ZoZLKiOdMhVOSxxLPmQquKHIy43mTldOiq2hEp06dkqCgIFFKSePGjXNdUTA/zH/VjYuLk3bt2olSSgYNGmSZM+LNN9/kXzoKgDnpX1FmlJ6eLvfu3ZNatWpJq1atRETk1q1b8t1331kWaxg7dmyR1m8rDh06JI0bNxYHBwdxcXGR0qVLi1JK6tevL1u2bMnz6/Tt21eUUtK3b1+5fPmy5f6rV69Kly5dxMPDQ86fP18cu2ATmJP+MSNjYE7GUFQ5mfFzXtFjRsbAnIyhKHPieZNtYIPvITIzM2X37t2WCXXr1asn9vb2MmbMGEtDorCXv5jnKzCvdrd69eqiKN2mMCf9K66MLl68KI6OjvLmm2/K3r17pX///uLk5CTe3t7yzTffFPVuWD2TyST//e9/xd/fX5o0aSLz58+XP/74Q2JjY2XUqFHi4uIiXbt2fejlZOY5wC5fvizdunWzNHS//vprWbZsmQwYMEBKlSolISEhvISwAJiT/jEjY2BOxlBUOf0Tfs4rHGZkDMzJGIorJ543WT82+B4iNjZWXn31VVFKyccffywXLlyQevXqSdWqVWXr1q0iUvDG0Y4dOywf+Ozt7eWjjz4qytJtCnPSv+LKaPny5aKUkpYtW4qfn5/Y29vLBx98UNTl24ywsDDx9fUVX1/fHH8ZvHTpknTr1k08PDzytCqdOc+oqCgZN26cuLm5iVJK7OzsxM3NTaZMmVIcu2ATmJP+MSNjYE7GUJQ5/R0/5xUNZmQMzMkYiisnnjdZPzb48mDJkiXZVo5ZuHChKKXkpZdekjt37ohIwRoTvXr1EqWUvPjii3L9+vWiKtdmMSf9K+qMMjMzLU1DpZT06NFDrl69WtRl25QjR45Iy5Yt5ZdffrHcl/Xy6X79+olSSnbt2pXv1/7zzz9ly5Yt8t///ldu3bpVJPXaKuakf8zIGJiTMRRnTvycVzSYkTEwJ2Mojpx43mQb2ODL4u9zgJnnEkhLS7NceiFy/1r1p556SlxcXAq0+qP5fY4ePSoHDhwoeME2ijnpX0lkZG4ELliwQB5//HE5dOhQ4Yq2QbnNe5iQkCB//vmnpKWliclksnyfzfOmDB06VNzc3OTSpUt5fh9ejlY4zEn/mJExMCdjKKmc+Dmv4JiRMTAnYyiJnHjeZDuUSD6XXbFCMTExmDdvHhITE1GhQgW0bt0agYGB//icrVu3olu3bnjyySfx1Vdfwc/PD5mZmYVeDZQejDnpX0lmJCJcHbKACpKTWevWrXH27FmEhYXBzc2Nx1IxYk76x4yMgTkZA3PSP2ZkDMzJGEoyJ5432RBt+4vaW7Rokbi5uYmHh4d4eHhYhqxOmzbNMmllbl31pKQkee2110QplW1+gYKu1kr/jDnpn1YZcaRE/hQ0JxGRK1euSJUqVaRbt24lWbJNYk76x4yMgTkZA3PSP2ZkDMzJGLTKiedN1s+mG3wHDhyQcuXKSYcOHWTz5s0SFxcn27dvlzZt2oiDg4O88cYbkpSUJCK5H2DHjh2TihUrSr169eTgwYMlXb7NYE76x4yMobA5/fzzz6KUkq+++uqB21DhMSf9Y0bGwJyMgTnpHzMyBuZkDMyJipNNN/iGDx8uSik5fvx4tvsjIiIkMDBQlFIya9YsEcm9252eni5TpkwRpZSMGjVKRETi4+Pl66+/tkx4yQOu8JiT/jEjYyhoTubv/cSJE0UpJSdPnrQ8lpCQIPv27bPcx78MFh5z0j9mZAzMyRiYk/4xI2NgTsbAnKg42WyD7+7du/L444+Lt7e33L17V0T+WghAROTUqVOilJIKFSrIuXPnRESyLQ4gcv8gi4qKkiZNmkilSpVk/Pjx0qtXL7Gzs5OuXbtaJsGkgmNO+seMjKGwOaWlpUlQUJBUr15dRO5P8vvbb7/JW2+9JZUqVZI33ngj2+tRwTAn/WNGxsCcjIE56R8zMgbmZAzMiYqbzTb4RETat28vvr6+cubMmWz3m7vj48aNE6WUvP766zmem7UrPmnSJLGzs7NcO//6669bhtVS4TEn/WNGxlCYnCIiIqR8+fLy2muvyY0bN2TWrFlSu3ZtUUpJcHCwJCcnl8g+2ALmpH/MyBiYkzEwJ/1jRsbAnIyBOVFxstkGX1pamowaNUqUUrJ582YR+eugMv83LS1NvLy8pGLFinL06FERyd6MuHDhgnz00Ufi7+8vSinp1KmTnD59uoT3xLoxJ/1jRsZQ0JzMfzVct26dKKXklVdekfbt24tSSoKCgrJdHkCFx5z0jxkZA3MyBuakf8zIGJiTMTAnKm42u+51qVKl0LRpUwDA/PnzAcCyvLSdnR1MJhNKlSqFt956C7du3cKRI0cAwLK8dEJCApYuXYoPP/wQIoINGzZg69atCAgI0GBvrBdz0j9mZAwFzcne3h4AcOjQIQDAqlWrcObMGaxbtw579+5F/fr1S3pXrBpz0j9mZAzMyRiYk/4xI2NgTsbAnKi4WV2DLzMz86HbiAgAoEePHmjcuDE2b96MnTt3AgBMJhOAvw6ioKAglC5dGlFRUdle39XVFY0aNcJnn32GiIgIdOvWrcj3xZoxJ/1jRsZQEjmZTCZUqlQJzs7OmDFjBq5cuYIePXoUx+5YLeakf8zIGJiTMTAn/WNGxsCcjIE5kW5oMWywOMTFxeVpO/Nlgeb/rly5UpRSUr9+/WwT+Zsnp/zjjz9EKSX9+vV74GtQ3jEn/WNGxlCSOYmIXL161TIZMOUdc9I/ZmQMzMkYmJP+MSNjYE7GwJxIbww/gm/fvn3o2bMnnnvuObRp0wZffvklLl26BCBnJ11ELJcFJiYmAgD69euH5557DqdPn8a4ceMQGxsLAHBwcAAA3LlzBwDQpEkTy+uYX8P8X3o45qR/zMgYSjon+f+/NlapUgUuLi7FvHfWgznpHzMyBuZkDMxJ/5iRMTAnY2BOpFsl3FAsMomJiTJ8+HBRSkn16tWlSZMmUqlSJVFKyaOPPirh4eGWbbOODkpNTZU9e/bI66+/LqGhoSIicuzYMQkMDJRSpUrJsGHD5Pr165KcnCw///yztGzZUnx8fCQsLKzE99EaMCf9Y0bGwJyMgTnpHzMyBuZkDMxJ/5iRMTAnY2BOpHeGbfAtW7ZM7O3tZeDAgXL48GERuT9kdeDAgaKUkrZt28qlS5eyPefEiRMydepUeeSRR0QpJfPmzbM8dvDgQencubMopcTFxUVq1aol3t7e4urqKkuWLCnRfbMmzEn/mJExMCdjYE76x4yMgTkZA3PSP2ZkDMzJGJgT6Z0hG3x37tyRgIAAqVmzpty6dSvbY0lJSVKlShVRSklISIjcuHFDRESOHz8u9erVE6WUdO/eXa5cuZLjdZOSkmTp0qXSp08fefbZZ+WNN96Qq1evlsg+WSPmpH/MyBiYkzEwJ/1jRsbAnIyBOekfMzIG5mQMzImMQPcNvtwm3//zzz9FKSVPP/20ZZvMzEzLBJXvv/++KKWkUqVKsmHDBhERiYyMlFdeeUV27NhheZ2MjIwHTvKfnJxcLPtjrZiT/jEjY2BOxsCc9I8ZGQNzMgbmpH/MyBiYkzEwJzIqXS+yYTKZsk2+b56wslq1anB3d8f169cRFhYGpRQyMjLg6OgIALh9+za8vLxw69YtfPvtt0hKSoKPjw+++eYbtG/fHiICk8kEe3v7B07yX6ZMmRLaS+NjTvrHjIyBORkDc9I/ZmQMzMkYmJP+MSNjYE7GwJzIyHTb4Pvyyy8RHByMN954A/Pnz8edO3dgZ/dXud27d8epU6cQGhoKAJYD6+DBg9i8eTOeeuopNGrUCN9//z1iYmKglIKIIDMzE0op2Nvba7Jf1oY56R8zMgbmZAzMSf+YkTEwJ2NgTvrHjIyBORkDcyLDK8nhgnlx8OBBqV+/vpQuXVqqVKkiLi4uopSSoKAg2bZtm2W7bdu2iY+PjyilZNy4cbJp0yaZMWOGNGvWTPz9/SUmJkZCQkJyTGRJRYM56R8zMgbmZAzMSf+YkTEwJ2NgTvrHjIyBORkDcyJroasGX0pKinTq1Em8vb1lxYoVEhUVJbGxsfLBBx9ImTJlxN/fX/bt22fZ9ocffhAPDw9RSln+1a1b13IQ7t+/X5RSsnjxYi13y+owJ/1jRsbAnIyBOekfMzIG5mQMzEn/mJExMCdjYE5kTXTV4Nu9e7copWTKlCk5Hvvss89EKSWPPvpotvvPnj0r69atk8WLF0toaGi2x9auXStKKVm5cmWx1m1rmJP+MSNjYE7GwJz0jxkZA3MyBuakf8zIGJiTMTAnsia6avAtWLBAlFKWg8S8Io3Zs88+K0opmTFjhoiImEymf3y9N998U5RScuLEieIp2EYxJ/1jRsbAnIyBOekfMzIG5mQMzEn/mJExMCdjYE5kTXTR4DMvD/3111+LUkpmzZqV7fGMjAwRETl69Kg4OzuLu7u7xMTEiMhfB1jWJaZv3Lghn332mbi4uMhbb71VErtgE5iT/jEjY2BOxsCc9I8ZGQNzMgbmpH/MyBiYkzEwJ7JGumjwmf3666/i6ekpffv2laSkpFy3MXfEcxtCe/nyZfnkk0+kT58+Urp0aQkMDJTTp08Xd9k2hznpHzMyBuZkDMxJ/5iRMTAnY2BO+seMjIE5GQNzImuiqwZfZGSkPPnkk+Lq6irHjx/P9pi5S37x4kVRSknbtm0tHXQRkejoaBk8eLC4urrKI488ItOmTSvJ0m0Kc9I/ZmQMzMkYmJP+MSNjYE7GwJz0jxkZA3MyBuZE1kRXDT4RkY8++kiUUtKvX78cj5kPsM6dO0utWrUkPj4+2+MnT56Un376SeLi4kqkVlvGnPSPGRkDczIG5qR/zMgYmJMxMCf9Y0bGwJyMgTmRtdBdgy8qKkoeffRRUUrJ+vXrLde1m6+BFxHp1KmTuLi4yKVLl0Qk+7XvVDKYk/4xI2NgTsbAnPSPGRkDczIG5qR/zMgYmJMxMCeyFnbQmUceeQQjRoyAu7s7xo8fj7179wIA7O3tAQDp6emIiIhAw4YN4enpCQBQSmlVrs1iTvrHjIyBORkDc9I/ZmQMzMkYmJP+MSNjYE7GwJzIamjdYcxNWlqaTJ06VZydnaVBgwaydu1auXfvnhw9elRGjhwpDg4OsmDBAq3LtHnMSf+YkTEwJ2NgTvrHjIyBORkDc9I/ZmQMzMkYmBNZA102+EREYmNjZd68eaKUEqWUVKpUSapVqyZKKRk4cGCOa99JG8xJ/5iRMTAnY2BO+seMjIE5GQNz0j9mZAzMyRiYExmdEhHRehThPzl06BA2btyIK1euQEQwePBgtGrVSuuy6G+Yk/4xI2NgTsbAnPSPGRkDczIG5qR/zMgYmJMxMCcyKt03+IiIiIiIiIiIiOjBdLfIBhEREREREREREeUdG3xEREREREREREQGxgYfERERERERERGRgbHBR0REREREREREZGBs8BERERERERERERkYG3xEREREREREREQGxgYfERERERERERGRgbHBR0REREREREREZGBs8BERERERERERERkYG3xEREREREREREQGxgYfERERERERERGRgbHBR0REREREREREZGBs8BERERERERERERkYG3xEREREREREREQG9n+srqaOIrwsowAAAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "display.Image('nonlocal_cli__regionexploratorium-pco2-buoy_salt.png')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "c532aacb-bad0-45e6-ba52-a14cd3e09833",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABOwAAAHVCAYAAABCCGRHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC4CklEQVR4nOzdd1gUV/s38O/SpTepUhQboIJiFxRsaIzG3rsS9YlRY0lssT9qookaE38ajN1ETeyxJkHsGisGEQsBBCyICFKkz/uH787Dugvs0nbB7+e69lJmzsyc2Z2dmb3nPudIBEEQQERERERERERERBpBS90VICIiIiIiIiIiov9hwI6IiIiIiIiIiEiDMGBHRERERERERESkQRiwIyIiIiIiIiIi0iAM2BEREREREREREWkQBuyIiIiIiIiIiIg0CAN2REREREREREREGoQBOyIiIiIiIiIiIg3CgB0REREREREREZEGYcCO3muhoaGQSCTw9/dXd1UqjKbso6bUoyrYtm0bJBIJRo8ere6qUCVatGgRJBIJFi1apNJy/G4RVZyYmBhIJBK4urqquypERET0nmHAjoiIiIiomoqIiMD333+PkSNHomHDhtDS0oJEIsGuXbvKvO7jx4+jc+fOsLS0hJGREZo1a4b169ejoKCgHGpORET0ftNRdwWIiEiWmZkZGjRoAHt7e3VXhaoAQ0NDNGjQAM7OzuquClG1o6uriwYNGsDR0VHdVSm1uXPn4vDhw+W+3pUrV2LOnDkAgDp16sDY2BhhYWGYMmUK/vzzTxw8eBBaWswNICIiKi0G7IiINEyfPn3Qp08fdVeDqoiWLVsiMjJS3dUgqpYcHR2r/PfL0dER/fr1Q4sWLdCyZUvMnTsXV65cKdM6L1++jLlz50JLSwu7du3CkCFDAABhYWEIDAzEkSNH8O2332LmzJnlsQtERETvJQbsiIiIiIiqqR9++EHmb319/TKvc9myZRAEAUFBQWKwDgC8vLzw7bffYtiwYVi5ciWmTp0KXV3dMm+PiIjofcQ8dapS8vLysHHjRvj6+sLc3BwGBgZo2LAh5s+fj9evXxe53MGDB9G2bVsYGRnBysoKH374Ia5fv15k+ZI6/S/PTt6Tk5OxcOFCNG3aFKampjA2Noa7uzsmTpyIW7duyZQNDw/HwoUL0aZNG9jb20NPTw/29vbo27cvLl26pNJ2C3ekLQgC1q9fj8aNG8PQ0BA2NjYYMWIEHj9+XOTyL1++xOeff44GDRqgRo0asLCwgL+/P3bv3g1BEJSqw8mTJyGRSNCkSZMiy+Tk5MDKygoSiQR3795VaR+lJBIJJBIJgP8dC8bGxrC1tcWoUaPw7NkzsezWrVvh4+MDIyMj2NjYYOLEiUhNTZVbZ35+Pg4fPoyxY8fC09MTZmZmMDQ0hLu7Oz7//HMkJSUprIu/vz8kEglCQ0Nx+/Zt9O/fH7a2ttDS0sK2bdsAFH38FT7uCgoKsG7dOjRq1AgGBgawtbXFuHHj8OLFiyLfh+TkZMybNw+NGjWCkZERTExM0Lp1awQHB5e5v6HRo0dDIpFg27ZtiI2NxfDhw2FrawtjY2O0adMGf/zxh1j2n3/+Qb9+/WBjYwNDQ0O0b9++2GwPVY+1wu9fRkYG5s6di/r168PAwED8zhYe4OHFixeYPHkyXF1doaurK/O+5+bmYv369WjZsiVMTU1hZGQELy8v/Pe//0VmZmaZ3rPiPHv2DOPGjYODgwMMDAzg7u6O1atXIy8vT65sceejK1eu4PPPP0fz5s1hY2MDfX19ODk5YcSIEUV+nwRBwI4dO9C+fXuYm5tDT08PdnZ28PHxweeff474+Phy2ceyHM9//PEHJk+eDC8vL1haWsLAwABubm6YNGlSkeetwsfokydPMHbsWNjb28PAwACenp5yQY3ykpCQgOnTp8PDwwNGRkYwMzND48aNMXPmTDx8+FCu/OPHjzFp0iTUrl0b+vr6sLa2Rvfu3XHixAmF61fmWC6879HR0Rg9ejQcHR2ho6Oj8iAn73p3UIZdu3ahefPmMDQ0hKWlJQYMGIB///1X4bKlOT4L729qaiqmTZsGZ2dn6Ovro27duli6dKnC70l57d+7VD0/lfbaoUlev36NP//8EwAwbtw4ufkDBgyAqakpXr58iTNnzpTLNivqGhMbG4sJEyagTp060NfXh4mJCerUqYM+ffpgz549CpeJj4/HlClTUL9+fdSoUQPm5uYICAjAb7/9Vi77KlXdv1uFrwH5+fn46quv4O7ujho1asDV1RWLFi0St/fmzRt8+eWXqFu3rni+//rrrxV+x/Ly8rBu3Tq0bNkSJiYm0NfXh4ODA9q2bYuFCxciJSVFpnxpjoHSKHz/FxkZiQEDBsDa2ho1atSAj48P9u3bp3C5Z8+eYf369QgMDISrqysMDAxgYWGBDh06YOfOnQqXKcuxU1qurq6QSCSIiYnBmTNn0L17d1hbW4v7DFTM/TgAHD16FIGBgbC2toauri5q1qyJJk2a4NNPP8W9e/cULnPq1Cn06tULtra20NfXR61atTBmzBhERUWV6/tS2u/Vmzdv8Msvv2Dw4MFo0KABjI2NYWxsDG9vbyxbtgwZGRkKt1f4c7hy5Qq6d+8OCwsLGBkZwc/PDyEhIeW6f1QJBKIqIjU1VWjfvr0AQNDS0hJcXFyERo0aCXp6egIAwd3dXXj+/Lnccl999ZUAQAAg2NvbCz4+PoKxsbGgr68vLF26VAAgdOjQQWaZrVu3CgCEUaNGKazLmTNnFC6nqtu3bwsODg7iPnl4eAje3t6Cqampwu136tRJACCYm5sL7u7uQrNmzQRra2sBgKCtrS3s3r1b6bpGR0cLAAQXFxdh0qRJAgDB2dlZ8PHxEQwMDAQAQs2aNYXIyEi5dT58+FBwcnISAAh6enpCs2bNhDp16ojv88iRI4WCgoIS65Gfny+u58aNGwrfo99++00AIDRv3ly5N1UBab2+++47AYBQq1YtwcvLS9DX1xcACB4eHsKbN2+EKVOmCACEOnXqCJ6enoKOjo5Y53f3Jy4uTvzc7O3thWbNmgkNGzYU3ztXV1fh2bNncnXp0KGDAEBYvHixoK+vLxgbGws+Pj5CnTp1hK1btwqCUPTxV/g9HDp0qABAqFevnkxdPT09haysLLnthoeHC46OjuJn5uHhIbi5uQkSiUQAIPTv319uH1UxatQoAYCwYMECwdraWjAyMhJ8fHzE41NHR0f466+/hPPnzwtGRkaCubm54OPjI5iZmQkABENDQyE8PFxuvaU51qTv38CBA4VmzZoJEolEcHd3F5o2bSp07dpVEARBWLhwoQBA+M9//iM4OzsL2traQpMmTYQmTZoIY8eOFQRBEDIzM4WOHTuK23J3dxeaNGkiaGlpCQAEb29vISkpSa7O0nWren6QLjd58mTByclJ0NbWFry9vYX69euLdejdu7eQn58vs1xx5yM3NzcBgGBlZSU0atRI8PLyEt/zGjVqCGfOnJFbZsaMGeL2nJ2dhRYtWgi1a9cWz7UHDx5UuH1VbynKcjxra2sLEolEsLGxEby9vYVGjRoJRkZG4r7evXtXbhnpMbpo0SLBzs5OMDAwEJo1ayaegwEIy5YtU2kfSvLnn3+K53NdXV2hSZMmQqNGjQRDQ0MBgLBw4UKZ8leuXBHMzc0FAOJ3qFatWmL9vvzyS7ltKHMsS/d99uzZgrm5uaCvry+esxYtWiQIwv+uCQCE6Ohopfex8LVk9uzZ4v8Ln2Pt7e2FFy9eyC1bmuNTur/Tpk0T3N3dBR0dHcHb21twdXUV6z9+/Hil66/K/r2rNOen0l47Svv5KCK9Du3cubNUy4eGhgoABAMDAyE3N1dhGen9ypIlS8pSVVFFXGOio6PF5Q0NDYXGjRsL3t7egqWlpQBA8PLyUrjvhY/Rxo0bi8cAAGHGjBlyy/C7pVjha0C/fv3E62yDBg3Ee5MxY8YIb968EVq1aiWe2wrXZ8GCBXLrla4LgODm5ia0aNFCvKYCEG7duiXzHqt6DEi/P++ev0siXW716tWCsbGxYGJiIvj4+Ag1a9YU66voOyn9rVKjRg3Bzc1NaN68ueDs7CwuM3HiRLllynLslJaLi4sAQFi+fLmgpaUlWFhYCC1atBBq1aolHm8VcT++fv16cb12dnZC8+bNhXr16onn1DVr1sjVderUqeIyNjY2QtOmTcVrtampqXDx4kW5Zcp6b6fq9+r8+fPiua1WrVrifknfi2bNmgmZmZlFfg7r168XdHV1BSsrK5lzoY6OjsLvP2kuBuyoyhg8eLAAQOjUqZMQFRUlTk9OThb69u0rBh0Ku3nzpvjD7vvvvxdP8mlpacKgQYMEXV1dhSffygjYpaamihfcbt26CXFxcTLzz507J+zatUtm2q+//ircuXNHZlpBQYFw6NAhwdjYWDA1NRVev36tVF2lF3MdHR1BV1dX+OWXX8R5SUlJQufOnQUAQsuWLWUujgUFBULz5s3FdRb+YXHixAnxR/OGDRuUqse8efMEAMKUKVMUvk89e/YUAAjff/+9wvnKkF4QjYyMhJ9//lmcHhcXJ9StW1cMhJiZmQl//vmnOP/OnTviTdvx48dl1pmSkiJs27ZNePnypcz0V69eCZMnTxYACKNHj5ari/SGTVtbW/j444+FjIwMcZ70wltSwE5XV1dwcHAQrl69Ks67f/+++MP+//7v/2SWS09PF2/ep0yZIqSmporz7t69K3h6epb5PZb+mNLV1RUGDx4sHof5+fnCf/7zH/HG19XVVZg+fbqQnZ0tCIIgZGVliZ/xwIEDZdZZ2mNN+v5pa2sL9evXFyIiIsR5b968EQThfzdQ2traQps2bWS+f9Iy0sCVg4ODTED54cOHQsOGDRXWufC6S3tTp6OjIzRu3Fjmh93Zs2fFm613P6fizkfbt2+XOV8KgiDk5uYKmzdvFnR0dIQ6derIBAATExMFLS0twczMTLhw4YLMcm/evBF++eUXISwsTOH2gdIF7FQ9ngVBEDZt2iQkJCTITMvMzBT++9//CgAEf39/uWUKH6P9+/cXXr16Jc7bsGGDGIAoPL0sYmNjxc9s5MiRMueK/Px84ffffxeOHDkiTsvIyBCvCQMHDpQ5l2/btk38sfnuuUiZY1m679ra2kKvXr1k6iItU9aggo6OjmBqaipTv6dPnwpNmjQRAAhffPGF3LKqHp+F91dXV1do3769zHFw5MgR8X26d++e0vugzP69G7Ar7fmptNcOTQrYBQcHCwCE+vXrF1kmKChIACCMGDGitNWUURHXGOn7PWrUKCEtLU1m3r1794RNmzbJTEtISBAsLS0FiUQiLF++XOZhwsWLF8WHYkePHpVZjt8txQpfA2rVqiUTSAsNDRX09PQEiUQi9OrVS2jcuLHM/uzevVsAIOjr6wvJycni9OvXrwsABCcnJ5lrvyC8ve8ODg4WHj9+LE5T9RgQhLIH7HR1dYXJkyeL596CggLhiy++EO838vLyZJY7f/68EBISIjc9LCxMcHd3FwAIoaGhMvPKcuyUljRQpK2tLSxevFgM5hcUFIjflfK+H8/NzRUsLCwEHR0duYeJubm5wtGjR4WzZ8/KTN+4caMAQKhdu7ZM4CovL09YtmyZGEiUfj5SZb23U/V7FRMTI+zbt0/uuHz69KnQv39/AYD4wK0w6eegq6srrFixQjxucnJyhGHDhgkAhFatWqm0D6ReDNhRlRAWFibeML8bkBKEtz90nJycBIlEIsTExIjThw8fLgAQBgwYILfMmzdvBBsbG7UF7L7++msBePs0UVEGiarmz58vAJDLsispYFdUsOz58+fi06mQkBBx+h9//CHeJD19+rTI/XJxcZEJ9BVVj6ioKEEikQjW1tZCTk6OzLzExERBR0dH0NPTk/txowrpfk6dOlVu3qZNm8T5ip7CSZ9MFhVQLIqTk5NgaGgol30gvWHz8vKSu1mWKilgB0DYv3+/3HLSJ5a9evVSOL1Pnz4KtxcWFiZIJBKhTp06KuyhLOmPKXt7e5kgpCC8/YEqPZaaNm0q93Q0MjJSAN4+1SystMea9P0Dis7clN5A6evrywV+BOHtjb00C+rdm0BBEIS///5bACBIJBLh0aNHMvO++eYbwdHRUe4BQkmkdSqq3tLP0dXVVanvVkmk58fCT5IvX75c7LGiyKVLlwRHR0fB0dFRpe2X9nguia+vrwBAiI+Pl5kuPUbt7OyE9PR0ueWaNWsmABAOHDig0vaKIg0idOrUSansVWkQxNbWVu6HQuH1+fn5yUwv6VgWhJL3XRDe/mCSfo7vPkAqTuFryTfffCM3/8iRIwIAoUmTJkqvUxAUH5+C8L/9rVGjhsJ6Sh/gffvttyptryhFBexKe34qSVHXjtJ+PoqUNWAn3bfifvR9/vnnAgDhww8/LG01ZVTENSYwMFAAIPcQoijTp08XAAifffaZwvlHjx4VAAgdO3aUmc7vlmKFrwGKrrNDhgwRr7M3b96Um9+6dWu5c/Yvv/xS7Gf0LlWPAUEQhP79+wuOjo4KP5PiFHf/l5OTI9jZ2QkAFO5rUf78808BgBAUFCQzvaKOneJIA0U9e/Ysskx5348/ffpU/N4rIzs7W7CzsxO0tbWLfJ+lGZo7duyQmV7We7vy/F5lZmYKenp6Qr169eTmFfc5vHjxQsxmLBzoJs3GPuyoSjh48CAAYODAgTAxMZGbb2hoiM6dO0MQBJw/f16cfvr0aQDApEmT5JYxMDDA2LFjK6jGJTt8+DAAYOrUqSp1AP348WOsXLkSAwcORMeOHeHr6wtfX1/s3bsXwNsR2lT1ySefyE2zsbFB//79Abzt50FK+p4OGDAAdnZ2cstNnDgR+vr6iI2Nxf3790vcdp06ddC+fXskJSXh+PHjMvN2796NvLw89OrVC5aWlirtkyKK+trx9vYW/6/oeGjatCkAFNnXR0hICD777DP06NED7du3Fz+P1NRUZGZmKuyjCgCGDx8OLa3SnYItLCzQt29fuektWrRQWNcDBw4AAMaPH69wfU2aNIGrqyv+/fffMvdPNmTIEBgaGspMMzMzQ+3atQEAY8aMEfsvkZL2/fT69Wu8fPlSnF7WY83T0xPNmjUrtr6dO3eGg4OD3PQLFy4gMzMTzs7O+Oijj+Tmt2jRAm3atIEgCDJ9JwHA9OnTER8fj19//bXYbRelTZs2Cus9duxYGBgYICYmRqnvllRkZCQWLlyIvn37wt/fXzxGz549C0D2nOHk5AQAuHr1arF9WL5b3/j4+FIfO6oez1LXr1/H7Nmz0atXL3To0EHcrwcPHgAA7ty5o3C5IUOGwMjISOXtqUp6jp81a5bcMa+I9HgPCgqCgYGB3PypU6cCAC5duqSw75qijuXC+vXrp3DfAaBWrVri51irVq0S66uIonNsSe+rKsdnYd26dVNYz/L+HItS1vOTqteO8vh8yktWVhYAQE9Pr8gy0vuaN2/elOu2y/MaIz3f/fbbb0r1vVvStbRbt27Q09PDpUuXZPqk4nereJaWlujdu7fcdOn9WdOmTcV7scIU3Z9JP9O//voLycnJJW5b1WMAAH799VfEx8dj+vTpSpV/19ixY+Xu/3R1deHl5QVA8fublpaG4OBgjBo1Cl27doWfnx98fX0xe/ZsAMXf+5fm2CmLkSNHllimvO7Ha9asCX19fTx48ECp3z+XL1/Gs2fP0KxZM4XHFAD06tULAMTviVRZ7+1K870qKCjA4cOH8cknn6B79+7i596lSxdIJBI8fPiwyP6UFZ2nrK2txX4NK/oaSeWHo8RSlfDPP/8AeBu4K2pwhdjYWABvO/gGgJSUFCQmJgIA3N3dFS5T1PTKIO0EtXXr1kovs337dkycOFG8WVZEmRuUwnR1dVG3bl2F86Tvj/QHcOH/e3h4KFzGxMQETk5OePToER48eICGDRuWWIexY8fi7Nmz2L59u0xwZPv27QBQ5OAfqnJzc5ObVrNmTfFfU1PTIuenp6fLTM/JycGgQYNw6NChYrdZ1OdRlmNP0X4Ab4OsgHxdpd+fBQsWYPny5QqXlXZ0npCQUKYfg0XVrWbNmrh3716x8x8/foz09HRYWVkBKPuxpsx7XFQZ6bYbNmxYZLDF09MTly9flvl+lIei6mRkZAQnJyc8fPhQ6e/WihUrMH/+/GIHFSl8jDo6OmLAgAH49ddfUbduXQQEBMDf3x9+fn5o3bo1dHTK/7ZB1eNZEARMnjwZGzZsKHa9RX33VN1eaaSlpYnXImXP8SUd7/Xq1YOenh5ycnIQFRUlN1hPWY738mBtbQ0zMzO56cW9r6oen4VVxudYnNKen8p67dAE0oByTk5OkWWys7MBADVq1CjXbZfnNeaTTz7B9u3bsXTpUuzYsQPdunWDn58fAgIC5ILf6enpiImJAQB8/PHHxdYxKysLL1++hK2trYp7p1h1/24V95kpM79wfdq0aYNWrVrh6tWrcHJyQpcuXdC+fXt06NABzZo1k7ueq3IMlBdV399bt27hww8/xJMnT4pcZ1GfZWmOnbJS5jpTXvfj2tramDJlClatWoVmzZqhXbt2CAgIEANb7z78kt4Px8TEwNfXV2HdpIOSSK/h5UXVzz0lJQUffPABLl++XOx6X716JfcQo6Tt3b9/v8KvkVR+mGFHVYJ0VKBHjx7h4sWLCl/S7A7p09zCJyLpSf5d5XUzVRrSUW3Nzc2VKh8VFYWgoCBkZWVhxowZuHXrFl6/fo2CggIIgoDg4GAAb0e1VIWVlVWRmV7S9yctLU2cJn1fpRcYZZcrTv/+/WFqaorff/9dfPp9584d3L59G3Z2dujWrZtS6ymJogua9OZN0bzC89998rpy5UocOnQIdnZ22LFjB2JiYpCVlQXhbVcDaNeuHYCiP4+islyUUdSy0s/x3bpKvz83btwo8vsj/azKmg1R0vuoyvtc1mNNmfe4qDIVcZwrq7y2ee7cOcydOxcSiQQrVqzA3bt3kZ6eLp4z5s2bB0D+GN2xYwcWLlwIGxsbnD59GnPnzoWfnx8cHBywevXqMo8o/C5Vj+edO3diw4YNMDIywoYNG8QnzNLv3rBhwxTuV2m3VxqFRy1X9GNJkZKOOYlEIl7Lyvt4Lw8lva/vKu3xqez2yuNzLE5pzxFlvXZoAgsLCwBvfygWRTpPWra8lOc1xtvbG+fOnUPXrl2RkJCATZs2Yfjw4ahVqxYCAwNlRpcsPDplUdfRixcvikHM8swsrO7frfL8TLW0tHDixAlMnToVNWrUwOHDhzFjxgw0b94ctWvXxrZt22TWocoxUF5UeX/z8/MxcOBAPHnyBB988AHOnj2LpKQk5OXlQRAEMRO3tJ9lRVDmOlPe9+Nr166Fm5sbzp8/jyVLlqBLly6wtbXFnDlzxIcHwP++xy9evCjyOywdRbm8s4NV/V5Nnz4dly9fRoMGDbB//34kJCQgOztbvFY4OjoC0JzvMVUcBuyoSjA2NgYABAcHiyeqol6LFi2SWQZ4e2JWRJqB966iLgpSRQ2lrQpp0953h5cvyr59+5Cbm4vBgwdj9erV8Pb2homJiVjXuLi4UtXj5cuXRf4Al74/hZshS9/Xot47AHj+/LnccsUxNDTEoEGDkJubi19++QXA/7Lrhg8fDm1tbaXWU5l2794NANi2bRtGjBgBFxcXmabNpf08KoL0M3v48GGJ3x9/f3/1VraQijjWqsK2izpfFa6PMtuUHqOzZs3C7Nmz4eHhASMjoxLPGQYGBli0aBHi4+Nx7949bNq0CT179sTLly8xa9YsfPvtt6ruUrmS7tc333yDSZMmoW7dujJZPJrw3Sv8+RT+oV+cko45QRDEY6O8jzl1KO3xqSlKe46oSteOotSrVw/A2y46Cjf9LEza3EpaVlO1bt0ap06dwqtXr3Dy5El88cUXqFWrFk6fPo0uXbqI92iF7ylzcnJKvJZKm52pQ1X/bpWVhYUF1q5dixcvXuDWrVtYt24dAgICEBsbizFjxuC3336TKa/sMaAOf//9Nx49egQXFxccOHAA7du3h5WVlXhfXN0/S2VoaWlh6tSpePDgAaKjo7F9+3YMHjwYWVlZWLlyJWbMmCGWlX6Phw0bVuJ3ODQ0VE17BOTl5WHfvn0A3nav0bdvXzg4OIjdEOTl5eHZs2dqqx9VLgbsqEqQNjkJDw9Xehlzc3PxyXdkZKTCMkU9OZM+lSjqh/OjR4+UrkdRPD09AQBXrlxRqry0KUbbtm0Vzi9N33XA2yczUVFRCudJ35/69euL06T/j4iIULhMWlqaeANReLmSSPur2LZtG/Ly8sQbzvJqDlveivs8Xr58We6p9GVRmu+PJqioY02Vbd+7d6/IwL30KWx5b7uo81JmZqbYr5wy2yyPc0bDhg3x8ccf48iRI2ITVGk2r7oUt1+5ubkVkhGhKlNTU7FpubLn+JKO94cPHyInJwfa2tpFNnWpSirqmlZZSnt+qkrXjqI0bdoUurq6yMrKws2bN+Xm5+bm4tq1awCAVq1aVXb1SsXY2BiBgYFYuXIlIiMj4ebmhoSEBJw4cQLA20xZaRNJ6blfU1X171Z5kUgk8Pb2xpQpUxASEiL291bUNaykY0AdpJ+lj4+Pwv6u35fPUlmurq4YOXIkfvnlFxw5cgQAsGXLFjExoarcD7948QIZGRmwtLREgwYN5OaHh4cjPz9fDTUjdWDAjqqEPn36AAB27dol02FwSbp06QIA2Lhxo9y87OxsbNmyReFyderUAQDcvn1b7ulxQUEBtm7dqnQdiiLtYHf9+vXF9gMjJc0gkT6xLywyMhJHjx4tdV0U9QX14sULsWPVrl27itMDAwMBvO10V9HTnU2bNiE7OxsuLi4KLzJFad26NTw8PHDjxg2sXr0az58/R/PmzcXApqYp7vP45ptvNOpCKu3Q/7vvvqtSKfAVdawpw9fXF4aGhoiLixMHDyjs+vXruHz5MiQSiXieKS+XLl3C7du35aZv2bIFWVlZSu9vccfo6dOnVb7Rl/bFVlw/OpWhuP3aunVrsRmKlUl6jv/mm2+UKi893oODgxX2U/rdd98BANq1a1ehTVsrS3kfn5WttOenqnTtKIqpqSk6d+4MAPjpp5/k5v/66694/fo1rKysNCprW1mGhoZo3LgxANnznfRaunbtWnVUS2lV/btVUVS5hhV1DFS24j7L3NxcjT8W1Un6eb9580Zsou/n5wdra2uEhYWpNYOuJNLP/fXr1wqb5n799deVXSVSIwbsqEpo3rw5Bg4ciJcvX6JLly64deuWzPz8/HyEhoZi2LBhMn0VfPbZZ9DS0sK+ffuwceNGMViRkZGBsWPHFtlJq5eXFxwcHPD06VMsXLhQXC4rKwvTpk0r8om6Kj7++GO4uLjg7t276Nu3r9xT9QsXLohZZgDEzlE3bNgg82P+wYMHGDBgQLGjtRVHR0cHGzZskBn1KDk5GcOHD0dWVhaaN2+OgIAAcV7Hjh3RokULZGdnY8iQITLNgU6fPo3FixcDAGbPnq3UyIiFjRkzBgDw5ZdfAtDc7Drgf5/HjBkzxL6MBEHAjh07sHr1aoWjPKrLhAkTUKdOHZw5cwbDhg3D06dPZeanp6dj3759pR7xrKJU5LFWElNTU3F06cmTJ8ucc6KiojBq1CgAb0eufjfbae3atXB1dcXgwYNLtW0dHR2MHj1aHEgHeHs+WLBgAQBg5syZSu2v9BhduXIloqOjxenXrl0TR5x9119//YVZs2bJnePS09OxatUqAJAbwfbKlStwdXWttCZg0v2aP3++THDu5MmTmDVrlsZ892bNmgUzMzP88ccfGDdunEx/XwUFBTh+/Dh+//13cdqQIUPg7OyM58+fY/To0TL9sO7atQubNm0CADFLpLzFx8eLn2NZR4tWRmmOT01S2vNTaa8dlf35AG/PNa6urpg5c6bcvHnz5kEikWDz5s1iVxbA24wf6bXk888/L/W9SWWYNGkS9u7dKzfK4rlz5/DXX38BkD3fffHFF7C0tMT27dsxffp0uaaSycnJ2LJlC5YtWyYznd+tyrN7924sXbpUzEyTevnypfjQo/BnquoxAACDBw+Gq6trpQTLpIM9Xbx4ETt27BCnp6amYtiwYQoDee+TiIgITJgwAdeuXZN5IJ2dnY3//ve/AAAXFxdxoBkDAwMsWbIEwNsRvg8ePCj3IDs8PBxffPEFLl68KDO9rPd2qjA3N4enpyfy8vLw2WefiYkd+fn5+Oqrr7B3716NPrdS+WLAjqqMn376SQzWNWvWDC4uLmjdujWaNGkCExMTBAQE4Oeff5Y58fr4+GDZsmUQBAGTJk1CrVq10KJFC9jb22P//v3iD+B3aWtr46uvvgIALF++HLa2tmjRogVsbW2xdetWrFixosz7Y2JigsOHD8POzg7Hjh2Ds7MzGjVqhKZNm8Lc3Bx+fn74448/xPK9e/dG69at8erVKzRv3hweHh5o3LgxGjZsiJcvX2L+/PmlqoejoyPGjRuHgQMHwtXVFS1atBD77rCyssKOHTtkfmxIJBL8/PPPqFWrFkJDQ+Hs7AwfHx/Uq1cPgYGBSE9Px4gRIzBhwgSV6zJy5Ejo6uoiLy8Penp6GDJkSKn2qTIsXrwY+vr6OHLkCBwdHdG8eXPUqlULo0aNwuDBgzWqGZCxsTGOHTuG2rVr45dffkGtWrXg4eGB1q1bo0GDBjA3N8egQYOKHIFZXSryWFPG0qVLERAQgISEBDRr1gyenp7w9vZGgwYNEBERAS8vL/zwww9yy6WkpCA2NrbU/YtMmDABycnJqFu3Lpo2bYqGDRvCz88Pr169Qs+ePfGf//xHqfV8/PHHqFOnDqKiotCwYUM0adIEDRs2RMuWLWFmZqZwPWlpaVi9ejU8PT1hY2ODFi1awNvbG7a2tti9ezfMzMywZs0amWWysrIQGxsrE2CsSJ9//jksLS1x9epVuLi4oGnTpqhduza6d+8OHx8f9OvXr1LqURJnZ2f89ttvMDExwZYtW2Brawtvb280adIEpqam6NGjB65fvy6WNzQ0xL59+2BmZoa9e/fCzs4OLVq0gLOzM0aMGIG8vDzMnz8f3bt3r5D65uXliZ9jUf2SlafSHJ+apLTnp9JeO8ry+ezZswfW1tbiS/pDdNKkSTLT35WUlITY2FhxFPHC2rVrh6VLl6KgoABDhw6Fm5sbvLy80KxZMzx//hw9evSQ6TtKE12+fBmDBw+GmZkZPDw80KpVK7i6uqJDhw5IS0vD8OHDZR5Y1qpVC0eOHIG1tTXWrFkDGxsbNGnSBK1bt4abmxusra0xbtw4ueZ2/G5VnhcvXmDBggWoXbs2atWqhZYtW6Jx48ZwcHBASEgIHB0dsXTpUrG8qscAADx79gyxsbGV0rednZ0dpk2bBgAYNWoUXFxc0Lx5c9jb2+PQoUNy1+P3TU5ODn788Ue0bNkSlpaW8PHxQbNmzWBra4tVq1ZBT08P//d//yezzKRJkzB79mwkJSWhb9++sLa2RsuWLeHj4wMrKys0btwYX3/9tdzgTmW9t1PVihUrIJFIsGnTJtjb26NFixaws7PD7NmzMW/ePNjb21dKPUj9GLCjKsPY2BgnT57E7t27ERgYiMzMTNy8eRNJSUlo0qQJvvjiC/z9999yTw7nzJmD3377Da1atcKrV68QFRUFPz8/XLhwocghvYG3gx3s27cPPj4+SEtLw7///otOnTrh6tWr8PHxKZd98vLyQnh4OObMmQN3d3dER0cjKioKDg4OmDRpEj777DOxrI6ODk6dOoVPP/0Utra2ePToEVJSUjBu3DjcuHFDHC2oNH744QesW7cOJiYmCA8Ph5GREYYNG4YbN24oHJ69bt26uHXrFmbOnAlnZ2fcvXsXiYmJaN++PXbu3Int27eXKuPJxsZG/DHaq1cvWFpalnqfKpqPjw/OnTuHLl26oKCgAJGRkbCxscF3330nDpihSRo2bIiwsDCsXLkSLVq0QEJCAm7fvo2cnBx06NABq1evxp49e9RdTTkVdawpo0aNGjh16hTWrVuH5s2bIzY2Fg8ePICHhweWLVuGS5cuiU9ty5O1tTX+/vtvjBw5Es+fP0d0dDQaNGiAr776CgcOHFB6dDdTU1NcuHABI0eOhKmpKe7fv4+cnBxx5DFFAxf4+fnhu+++Q8+ePWFsbIyIiAjExMSgbt26+PzzzxEZGSmXbVDZnJ2dcfnyZfTt2xd6enqIjIyEgYEBFi9ejJMnT0JHR0et9Susc+fOCA8Px+TJk+Hi4oLIyEjExcXBzc0Ns2bNwogRI2TKt2rVCmFhYZgwYQKsra1x584dpKeno2vXrjh27JjMD82qrjTHp6YpzflJHdeOrKwsvHz5UnxJg0bp6eky01U1b948HD16FB07dsTLly/x6NEjNG7cGGvXrsXhw4c1csCowtasWYOpU6eiSZMmSEpKElsvBAYG4siRIzIZTVLt2rVDREQE5s2bBw8PD0RHR+POnTvQ0tJCt27dsGHDBqxbt66S90RWdfhulVa/fv3w1VdfoUuXLtDW1sY///yDp0+folGjRli2bBnCw8Ph7Owsli/NMVDZvv76a6xduxYNGzYUg4WdO3fG+fPn0a1bN3VXT63q1auH4OBgDBgwADVr1sSDBw/w8OFDODo6YuLEiYiIiFD4kGvFihW4ePEihg4dCiMjI4SFhSEmJga1atXC2LFjcezYMXTq1EkNe/Q/PXv2xIkTJ9C2bVu8efMG9+/fR926dbFr1y4xS5DeDxKhKnVoRETlJiYmBrVr14aLi4tc0wF1at26Na5evYrff/8dPXr0UHd1iIiIiIiIiCodM+yISGPcvXsXV69ehb29/Xv/1JCIiIiIiIjeXwzYEZFGyM/Px7x58wC87X9F05vSEBEREREREVUUzenohagK27JlC7Zs2aJ0+QsXLlRgbaqWkydPYuXKlfj3338RFxcHW1tbTJ06VWHZW7du4dNPP1V63evXr0fTpk3Lq6rvjQEDBsiNJFuUDz74AHPnzq3gGhEREREREb1fGLAjKgePHz+WG/6blPPs2TOcPXsWRkZGCAgIwNq1a2FhYaGwbGpqqkrvc2pqanlV871y7do1pUf8rFu3bgXXhoiIiIiI6P3DQSeIiIiIiIiIiIg0CPuwIyIiIiIiIiIi0iBsEluBCgoK8OTJE5iYmEAikai7OkREREREREREpCaCICAtLQ0ODg7Q0io+h44Buwr05MkTODk5qbsaRERERERERESkIeLi4lCrVq1iyzBgV4FMTEwAvP0gTE1N1VwbIiIiIiIiIiJSl9evX8PJyUmMFxWHAbsKJG0Ga2pqyoAdEREREREREREp1W0aB50gIiIiIiIiIiLSIAzYERERERERERERaRAG7IiIiIiIiIiIiDQI+7BTs4KCAuTk5Ki7GqRGurq60NbWVnc1iIiIiIiIiEhDMGCnRjk5OYiOjkZBQYG6q0JqZm5uDjs7O6U6niQiIiIiIiKi6o0BOzURBAFPnz6FtrY2nJycoKXF1snvI0EQkJmZicTERACAvb29mmtEREREREREROrGgJ2a5OXlITMzEw4ODjA0NFR3dUiNatSoAQBITEyEjY0Nm8cSERERERERveeY1qUm+fn5AAA9PT0114Q0gTRom5ubq+aaEBEREREREZG6MWCnZuyzjAAeB0RERERERET0PwzYERERERERERERaRAG7KhchYaGQiKRICUlRd1VKTejR49G79691V0NIiIiIiIiInpPMGBH9P/FxMRAIpHg9u3bMtPXrVuHbdu2qaVOREREVPn++ecfTJ8+HaNHj8bTp0/VXR0iIiJ6D3GUWKrycnJyKnTwDjMzswpbNxEREWmGtLQ07N27F8HBwfj777/F6dbW1li9erUaa0ZERETvI2bYkcqys7MxZcoU2NjYwMDAAL6+vrh27ZpMmYsXL8LLywsGBgZo1aoV/vnnH3FebGwsevbsCQsLCxgZGcHT0xPHjx8X50dEROCDDz6AsbExbG1tMWLECCQlJYnz/f39MXnyZEyfPh3W1tbo0qULhgwZgsGDB8vUITc3F9bW1ti6dSsA4OTJk/D19YW5uTmsrKzw4YcfIioqSixfu3ZtAEDTpk0hkUjg7+8PQL5JbEn7L20W/Ndff6F58+YwNDRE27Ztcf/+/VK+40RERFQRBEHA33//jaCgIDg4OCAoKEgmWAcAN27cUFPtiIiI6H3GgB2p7PPPP8f+/fuxfft23Lx5E3Xr1kVgYCCSk5PFMrNmzcLq1atx7do12NjYoFevXsjNzQUAfPLJJ8jOzsa5c+fwzz//4KuvvoKxsTEA4OnTp+jQoQO8vb1x/fp1nDx5Es+fP8fAgQNl6rB9+3bo6Ojg4sWL2LRpE4YNG4YjR44gPT1dLHPq1ClkZGSgX79+AICMjAxMnz4d165dw19//QUtLS306dMHBQUFACDeoP/55594+vQpDhw4UOr9B4B58+bhm2++wfXr16Gjo4OxY8eW5W0nIiKicvLq1SusX78eXl5eaNWqFTZv3ixzD+Hl5QVTU1MAwN27d9VVTSIiInqPSQRBENRdierq9evXMDMzQ2pqqnjTJ5WVlYXo6GjUrl0bBgYGAIDmzZvj2bNnlV5POzs7XL9+XamyGRkZsLCwwLZt2zB06FAAbzPZXF1dMW3aNLRo0QIBAQHYs2cPBg0aBABITk5GrVq1sG3bNgwcOBBNmjRBv379sHDhQrn1L1iwAFevXsWpU6fEafHx8XBycsL9+/dRv359+Pv7IzU1Fbdu3RLL5ObmwsHBAd9++y1GjBgBABg6dCjy8vKwb98+hfvy4sUL2NjY4J9//kGjRo0QExOD2rVr49atW/D29hbLjR49GikpKTh06FCJ+z9r1iyEhoYiICAAf/75Jzp16gQAOH78OHr06IE3b96In3dhio4HIiIiKj+CIODcuXMIDg7Gb7/9huzsbJn5JiYmGDp0KMaPHw8fHx907twZISEhAIDnz5/DxsZGHdUmIiKiaqS4ONG72IedBnn27BkSEhLUXY1iRUVFITc3F+3atROn6erqomXLlrh37x5atGgBAGjTpo0439LSEg0aNMC9e/cAAFOmTMGkSZNw+vRpdO7cGf369UOTJk0AvG12cubMGTHj7t1t169fH8Db4GZhurq6GDBgAHbv3o0RI0YgIyMDhw8fxs8//yyz/JdffokrV64gKSlJzKx7/PgxGjVqVC77X5h0nwDA3t4eAJCYmAhnZ2eltkVERERl9/z5c2zfvh2bN2/Gw4cP5ea3adMG48ePx8CBA2XuPxo1aiQG7O7evcuAHREREVUqBuw0iJ2dncZvV5qQKZFI5Ka/O+1d0vnjx49HYGAgjh07htOnT2PFihX45ptv8Omnn6KgoAA9e/bEV199Jbe8NOgFAEZGRnLzhw0bhg4dOiAxMRF//PEHDAwM0L17d3F+z5494eTkhODgYDg4OKCgoACNGjVCTk5Ohey/rq6u3L5Lg4RERERUcfLz8/HHH38gODgYR44cQV5ensx8S0tLjBw5EuPGjSvyoZ2np6f4/7t37yIgIKBC60xERERUGAN2GkTZZqnqVLduXejp6eHChQsyTUKvX7+OadOmieWuXLkiZpK9evUKDx48QMOGDcX5Tk5OmDhxIiZOnIg5c+YgODgYn376KZo1a4b9+/fD1dUVOjqqHZ5t27aFk5MT9u7dixMnTmDAgAHi6LEvX77EvXv3sGnTJvj5+QEALly4ILO8tGx+fn6Z95+IiIgqX1xcHLZs2YItW7bg8ePHcvM7duyI8ePHo0+fPiV2QVE4kMd+7IiIiKiyMWBHKjEyMsKkSZMwa9YsWFpawtnZGV9//TUyMzMxbtw4hIWFAQCWLFkCKysr2NraYt68ebC2thZHWp02bRq6d++O+vXr49WrVwgJCYG7uzuAtwNSBAcHY8iQIZg1axasra3x6NEj7NmzB8HBwdDW1i6ybhKJBEOHDsXGjRvx4MEDnDlzRpxnYWEBKysr/Pjjj7C3t8fjx48xe/ZsmeVtbGxQo0YNnDx5ErVq1YKBgQHMzMxU2n8iIiKqXLm5ufj999+xefNmnDx5Ui6b3dbWFmPGjMG4ceNQt25dpdfr4eEh/j88PLzc6ktERESkDAbsSGUrV65EQUEBRowYgbS0NDRv3hynTp2ChYWFTJmpU6fi4cOH8PLywpEjR2Qy2D755BPEx8fD1NQU3bp1w5o1awAADg4OuHjxIr744gsEBgYiOzsbLi4u6NatG7S0Sh7UeNiwYVi+fDlcXFxk+pnT0tLCnj17MGXKFDRq1AgNGjTAd999B39/f7GMjo4OvvvuOyxZsgQLFiyAn58fQkNDS7X/REREVLEePXqEn376Cdu2bZMbtEtLSwvdunVDUFAQevToIdNNhbLMzc3h6OiIhIQE3L17V6nuP4iIiIjKC0eJrUCqjhJL7y8eD0RERCXLysrCwYMHERwcLJNJL+Xs7Ixx48ZhzJgxcHJyKvP2unXrJo5c/+TJE5n+dImIiIhUxVFiiYiIiKjaCA8Px+bNm7Fz504kJyfLzNPR0cFHH32EoKAgdO7cudjuM1Tl6ekpBuzCw8MZsCMiIqJKw4AdEREREWmc9PR07Nu3D8HBwbhy5Yrc/Pr162P8+PEYNWoUbGxsKqQO744U26VLlwrZDhEREdG7GLAjIiIiIo0gCAJu3LiB4OBg/PLLL0hLS5OZb2BggP79+yMoKAh+fn4V3qdc4ZFiOfAEERERVSYG7IiIiIhIrVJSUrB7924EBweLI84X1qRJEwQFBWHYsGGVOshT4ZFi7969W2nbJSIiImLAjoiIiIgqnSAIuHDhAoKDg/Hrr78iKytLZr6xsTGGDBmC8ePHo0WLFmoZodXY2BguLi6IjY3lSLFERERUqRiwIyIiIqJK8+LFC2zfvh2bN2/G/fv35ea3atUKQUFBGDRoEIyNjdVQQ1mNGjVCbGws0tLSEBcXB2dnZ3VXiYiIiN4DDNgRERERUYUqKCjAn3/+ic2bN+PQoUPIzc2VmW9hYYERI0Zg/PjxaNy4sZpqqZinpyeOHTsG4G2zWAbsqDjPnz/HnTt3xFeNGjWwcuVKmJubq7tqRERUxTBgR0REREQVIj4+Hlu3bsVPP/2E2NhYufn+/v4YP348+vbtixo1aqihhiV7d6TY7t27q7E2pClycnIQGRmJsLAw3LlzR/z3+fPncmXT09Oxa9cuNdSSiN53T548gaGhIR8aVFEM2BERERFRucnLy8OxY8ewefNmHD9+HAUFBTLzbWxsMHr0aIwfPx716tVTUy2Vx5Fi6fnz53KBuXv37sllihZl9+7d+Pjjj9G+ffsKrikRvc8KCgpw7949nD9/XnzFxcXBxMQEFy5cQJMmTdRdRVIRA3akkfz9/eHt7Y21a9cqVX7btm2YNm0aUlJSKrReREREpNi///6Ln376CVu3bsXTp09l5kkkEnTr1g3jx49Hz549oaurq6Zaqq5hw4aQSCQQBIEjxVZzOTk5uHfvnkxgLiwsDImJiUotb2VlBS8vL3h5eaFJkyaIjY3FokWLAACffvopbty4AR0d/vwi5aWlpUFHR0djM5BJvXJzc3Hr1i2cP38e586dw8WLF/Hy5Uu5cmlpafjyyy9x+PBhNdSSyoJXDCIiIiIqlezsbBw6dAjBwcH466+/5OY7OTlh7NixGDt2bJXt+83Q0BB16tRBVFQUIiIiUFBQAC0tLXVXi8ro2bNncoG5e/fuIS8vr8RltbW10bBhQzEwJ/3X3t5eZhTh/Px8HDlyBDdv3sSdO3ewceNGTJ48uSJ3i6ooQRAQExODsLAwhIWF4fbt2wgLC0N0dDRMTExw8uRJtG3bVt3VJDXLzMzElStXxOy5y5cvIzMzs8jyNWrUgJaWFjIyMnDkyBH8888/GtdPLBWPATsiIiIiUklERAQ2b96MHTt2yD3N19HRQc+ePREUFISuXbtCW1tbTbUsP40aNUJUVBQyMzMRExODOnXqqLtKpCRp1ty7TVqVzZqztraWC8x5eHhAX1+/xGW1tbXx/fffi4GWL7/8EoMGDULNmjXLtE9Utb158wbh4eEywbk7d+7g9evXCsunpaVh6NChCAsLg5mZWSXXltQpOTkZFy5cEAN0N27cKPahgoWFBXx9feHn5wc/Pz80a9YMGzZswGeffQYAWLFiBX7++efKqj6VAwbsSCX+/v5o3LgxtLW1sX37dujp6WHp0qUYNmwYJk+ejN9++w02Njb4/vvvxU6Zz549i1mzZiEsLAyWlpYYNWoUli1bJjYJyMjIwKRJk3DgwAGYmJhg5syZctvNycnB/PnzsXv3bqSkpKBRo0b46quv4O/vX5m7T0RE9N7KyMjAr7/+iuDgYFy6dEluft26dTF+/HiMGjUKdnZ2aqhhxfH09BSbEt29e5cBOw0kCEKRfc0pkzWno6ODhg0bygTmvLy8YGdnJ5M1p6o2bdpg1KhR2L59O1JSUjB37lwEBweXen1UdQiCgKdPn4qBOenr/v37cn17KmJoaAhjY2MkJiYiNjYWn376KXbs2FEJNSd1iY+Pl+l/rqR+Ux0dHdG+fXsxQOfh4SGXAR4UFIT//ve/SEpKwt69e7FkyRLUrVu3IneDyhEDdqSy7du34/PPP8fff/+NvXv3YtKkSTh06BD69OmDuXPnYs2aNRgxYgQeP36MV69e4YMPPsDo0aOxY8cOREZGIigoCAYGBmKfHrNmzcKZM2dw8OBB2NnZYe7cubhx4wa8vb3FbY4ZMwYxMTHYs2cPHBwccPDgQXTr1g3//PNPleiwmoiIqKq6efMmgoOD8fPPP8tlgOjr66Nfv34ICgpChw4dyhTY0GTvDjzRs2dPNdaGsrOzFfY19+LFC6WWl2bNFQ7Mubu7K5U1VxorV67EwYMH8fr1a/z0008ICgpCy5YtK2RbpB65ubmIjIwUm7JKX8oek05OTuIxKX25ubkhPj4eTZo0wevXr7Fz50706NEDgwYNquC9ocogCALu378vE6CLiYkpdpkGDRqIwTk/Pz+4urqWeN01MjLCZ599hnnz5qGgoAArV67E5s2by20/7t+/j8ePH6N9+/YVdg59n0kEQRDUXYnq6vXr1zAzM0NqaipMTU1l5mVlZSE6Ohq1a9eGgYHB24nNmwPPnlV+Re3sgOvXlSrq7++P/Px8nD9/HsDbvjnMzMzQt29f8YnPs2fPYG9vj8uXL+Po0aPYv38/7t27J55MNmzYgC+++AKpqanIzMyElZUVduzYIV58kpOTUatWLXz88cdYu3YtoqKiUK9ePcTHx8PBwUGsS+fOndGyZUssX768yg86ofB4ICIiUpPU1FT8/PPPCA4Oxq1bt+TmN2rUCEFBQRg+fDgsLS3VUMPKdefOHXh5eQEAhg0bhl27dqm5Ru8HQRAU9jUXGRmpUtbcu01ay5o1Vxpr1qzB9OnTAQAtWrTAlStX2BdiFZWcnCzX11xERARycnJKXFZPTw+enp5ywbnizqO7d+/G8OHDAQDm5ua4c+cOnJycym1/qHLk5eUhLCxMJkBXXEBXS0sLTZs2FYNzvr6+sLGxKdW2U1NT4ezsjNevX0NXVxdRUVHlcgxFRESgRYsWyMzMhL29PT799FNMnDgRFhYWZV53dVZcnOhdzLDTJM+eAQkJ6q5FiQoPB62trQ0rKyuZzittbW0BAImJibh37x7atGkjc1PUrl07pKenIz4+Hq9evUJOTg7atGkjzre0tESDBg3Ev2/evAlBEFC/fn2ZemRnZ8PKyqrc94+IiOh9JAgCLl26hODgYOzbtw9v3ryRmW9kZITBgwdj/PjxaNWqVbXNplOkQYMG0NbWRn5+PkeKrSDSrLl3m7Qqm6FUs2ZNucBcRWbNqWry5MnYvHkzIiIicO3aNWzduhXjxo1Td7WoGAUFBXj06JFccC4+Pl6p5aXHpLe3txiYa9iwocqjZA8dOhS///479uzZg5SUFIwaNQp//vknA74a7s2bN/j777/F4NylS5eQnp5eZHl9fX20atUKfn5+aN++Pdq0aQMTE5NyqYuZmRkmT56M5cuXIzc3F6tXr8a6devKvN45c+aIg148ffoUc+fOxX//+1+MHTsW06ZNY/cR5YABO02irv5eVNzuuxcZiUQiM016A19QUABBEORu6KVJnRKJBMokeBYUFEBbWxs3btyQ67ja2NhYpboTERGRrKSkJOzYsQObN2/GvXv35Oa3aNECQUFBGDx4cLn9eKhq9PX1Ua9ePURGRuLevXvIz8+vFoNpqIM0a+7dwJwqWXPu7u5yfc3Z2tpqdBBZV1cX69evR6dOnQAAs2fPRt++fZmJoiHS09PF41H6unPnTrEjcEppaWmhQYMGcsG58srklEgk2LBhAy5evIi4uDicOXMGa9aswYwZM8q8bio/KSkpuHTpEs6dO4fz58/j+vXrxWZdmpmZoV27dmIGXfPmzSv0AcO0adOwdu1aZGZmIjg4GPPmzSt1xh4AXLhwAUeOHAHw9oFeZmYmBEFARkYG1q9fjx9++AH9+vXDN998w4zQMmDATpMo2Sy1KvHw8MD+/ftlAneXLl2CiYkJHB0dYWFhAV1dXVy5cgXOzs4AgFevXuHBgwfo0KEDAKBp06bIz89HYmIi/Pz81LYvRERE1UVBQQFCQkKwefNmHDx4UO5Hhbm5OYYPH47x48eLTUHfd56enoiMjER2djaioqLkMv9JXnZ2NiIiIuSatCYlJSm1vDRDqXBgrmHDhhqTNaeqjh07YuDAgdi3bx+SkpIQGBiIo0ePiq1TqOIJgoC4uDi5vuaioqKUSiQwNTUVj0lpcM7T0xM1atSo0HpbWFhg+/bt6NSpEwRBwNy5c9G5c2een9Xo6dOnMs1b79y5U+wxZGdnJzNARKNGjSr1wU/NmjXFLqfevHmDNWvWYMWKFaValyAImD17tvj3unXr4O/vj7Vr12LLli3IzMxEQUEBfv31V4SGhmLv3r0ICAgor115r2hcwC4lJQULFizAtWvXEB0djVevXsHa2hoNGjTAJ598gr59+8o8qQgODsaRI0cQHh6OxMRE6OjowNXVFR999BGmTZumUr8qrq6uiI2NVThvwoQJ2LhxY5n3733zn//8B2vXrsWnn36KyZMn4/79+1i4cCGmT58OLS0tGBsbY9y4cZg1axasrKxga2uLefPmyaR4169fH8OGDcPIkSPxzTffoGnTpkhKSkJISAgaN26MDz74QI17SEREVHU8efIEW7duxU8//YTo6Gi5+e3bt8f48ePRv3//Cv8BWtV4enpi//79AN6OFMuA3f9IR8NU1Ndcfn5+ictLs+YU9TVX3axevRqnT59GSkoKrl27htatW+PYsWPw8PBQd9WqnaysLERERMg0Zw0LC1O6z+s6derI9DPn7e0NFxcXtWVyBgQEYObMmVi1ahVycnIwdOhQXL58ucQ+sKjsBEHAo0ePZAJ0UVFRxS5Tt25dmQEi3Nzc1J4FPHPmTPzwww/Izc3FDz/8gC+++ALm5uYqr+fo0aO4ePEiAMDd3R2jRo2Cjo4O1q9fj8WLF2Pjxo347rvv8Pz5c7x48QKdO3fGV199hRkzZqj9PahqNC5gl5SUhC1btqB169bo3bs3LC0tkZiYiKNHj6J///4ICgrCjz/+KJbfuXMnXr16BT8/P9jb2yM7OxtXrlzB0qVLsX37dly9elWli72ZmRmmTZsmN7158+blsXvvHUdHRxw/fhyzZs0SO1QdN24c5s+fL5ZZtWoV0tPT0atXL5iYmGDGjBlITU2VWc/WrVuxbNkyzJgxAwkJCbCyskKbNm0YrCMiIipBXl4eTpw4gc2bN+PYsWNyAZSaNWti1KhRGD9+vEwfsiTr3ZFi+/Tpo8baqE9WVpbCvuaUzZqzsbFR2Necnp5eBddcMzg5OeHcuXPo0aMH4uLiEBMTg7Zt2+LgwYPMQCmD58+fy2TM3b59W+mAcY0aNdC4cWOZ4FyTJk00MhC2dOlS/PHHH7h9+zYiIiLQoEEDrFq1CsOGDWMgpBzl5+fjn3/+kQnQPStmcEiJRAIvLy+ZASLs7e0rscbKcXR0xOjRoxEcHIy0tDR8//33Mr/LlZGfn485c+aIfy9fvhw6Ov8LK1laWmLu3LmYMGEChg0bhlOnTqGgoACzZs3C33//jZ9++um97V6jNDRulNj8/HwIgiDzoQNAWloaWrdujYiICISHh8PT0xPA25sGRaNqfvnll1i2bJn4FEIZrq6uAFDicMrKUnmUWHpv8XggIqLyFh0djS1btmDLli148uSJzDyJRIKuXbti/Pjx6NWr13sTLCmLiIgI8f5z0KBB2LNnj5prVLGkWXOK+ppTNmvOw8NDYV9z9Dbb9cMPPxRHYdbV1cXmzZsxcuRINddMs+Xl5eH+/ftywbnnz58rtbyDg4NMP3NeXl6oV69eleqTMiIiAm3atMHr16/Fae3atcP69evRtGlTNdas6srOzsa1a9fE4NzFixdl3t936enpoUWLFuIAEW3btoWZmVkl1rj0pF06FBQUwMrKCkuXLkW9evVQr149ODk5lTiYydatWzF27FgAQJs2bXDx4sUig8X5+flYtGgRli1bJk7z8PDAgQMH3usHhKqMEqtxAbviTJ8+HWvWrMGhQ4fw0UcfFVv2zp078PLyQu/evXHw4EGl1s+AHakLjwciorJ78+YNEhISEB8fj4SEBGhra6N///5yDwGrs5ycHBw+fBjBwcH4888/5frTcXR0xNixYzF27FjxvoeUk5ubCyMjI+Tm5sLT0xPh4eGVun1BEPDq1SsYGRmVex9u0qaD7zZpffnypVLL29raygXmGjZsyEBwCdLT0zF48GAcO3ZMnLZgwQJ8/vnnMDIyUmPNNENKSgru3Lkj05w1PDwc2dnZJS6rq6sLd3d3ueCctbV1JdS84kVHR2P69Ok4dOiQOE1LSwsTJkzA0qVLYWVlpXC57Oxs3L17Fzdv3hRfubm5GDx4MIKCgkrVPLIqev36NS5fviwOEPH3338Xe1yZmJigbdu2YgZdy5Ytq/RvtuHDh2P37t1y0/X19eHm5oYWLVpg/vz5qFu3rsz8N2/eoH79+uJIyefOnVOqj/kjR45gxIgRYhDUyMgInTt3RqtWrdCqVSs0b95cIzNaK0q1DNhlZWWhdevWuHPnDu7fv4969eoVW37FihWYO3cu5s+fj6VLlyq1DVdXV2RnZ2PlypVISEiAhYUF2rZtW+rOPBmwI2XxeCAiKpo0UCENxEn/Lfz/+Ph4vHr1Sm7ZRYsWYeHChWqodeWKjIzE5s2bsX37drmmidra2vjwww8RFBSEbt26ValMEk3TuHFjhIeHQ1dXFxkZGdDV1a3Q7cXExOCvv/5CSEgIQkJCxCZZhoaGsLCwgIWFBSwtLWFtbY0WLVrA398fPj4+RdZLEAQ8efJELjB3//59pbLmpEGQd5u0Mmuu9PLy8jB16lRs2LBBnKarq4tWrVqhY8eO6NixI1q3bg19fX0IgoCkpCRERUUhKioKjx49wsuXL2FhYQErKyuZl6WlJUxMTGBsbIwaNWpodHPJgoICREdHy/U1V1Tf4u+ysrKSGwjifWlmferUKUyZMgUPHjwQp+no6MDU1BRGRkYwNjYW/01NTUV4eDhyc3MVrsvIyAjjxo3DtGnTULt2bbn5GRkZCAsLQ1ZWFtq1a1elBn9JTEyUad56+/ZtFBQUFFm+Zs2aMgNENGnSpFo9/Hvw4AFatGhRYhbhrFmzMGfOHPEBwurVqzFr1iwAQI8ePfD777+rtM2+ffvi7t27cvMkEgnc3d3Rrl07TJ48GU2aNFFxj6qWahGwS0lJwdq1a1FQUIDExEQcP34ccXFxWLhwIRYtWiRXftu2bYiJiUFaWhpu3ryJ0NBQNG3aFH/99ZfSw6UXNehEt27dsHPnzhKfyGRnZ8tE5l+/fg0nJycG7KhEPB6I6H2Vl5eHZ8+eyQXf3g3IZWVllWr9AwcOxN69e1Ve7s2bN4iJiUF0dDSePn2K/Px8FBQUyLwEQYCenh50dXWhp6cnvgwMDODs7IzatWtXaJZMZmYmfvvtNwQHB+PChQty8+vUqYPx48dj9OjRGtmXTlU0ePBg8Xi6e/cuPDw8kJGRgXPnzuGPP/4QR7Tv1auXSu95Tk4OYmJixCBMWFgYQkJCFA4MUhIjIyP4+vrC398fLVq0wOPHj2UCdKpkzb0bmGPWXMUQBAFr1qzBzJkzFY4yaWBggLp16+Lx48fF/sAuinSgNxMTE5iYmMDS0hKWlpYywb1atWqhd+/eFd6sLzMzE//8849Mc9Y7d+4gPT29xGUlEgnq168vF5xzcHDQ6IBkRcvJycG6deuwZMkSpd7HkmhpaaFPnz4YPHgw/v33X9y6dQu3bt3CgwcPxOPT2dkZCxYsEAcb0CSCICA6OlomQFc4oKlI7dq1ZQaIqF+/frU/plJTU8XP9eHDh3j48CEePHiAqKgomZHjnZyc8O2336JTp05wc3PDq1evIJFIEBYWhsaNG6u0zfT0dMyYMQN79uwp8lwmkUgwePBgLF68uMQkraqqWgTsYmJiZCL7urq6WL58eZEji/j7++Ps2bPi3127dsXOnTthY2Oj9DaXLFmCDh06wNPTE/r6+oiIiMDixYtx4sSJEttnA2+f4i9evFhuOgN2VBIeD0RUHWVkZIiBt6ICcc+ePSv2Kbcy9PT04OjoCEdHR9SqVQtmZmbYtGkTAKBPnz44cOBAieu4cOECNm3ahH///Rf//vtvsZ1Lq8LGxgZ16tRBnTp1ULt2bbi6usLZ2Vl8GRoaqrzO27dvIzg4GLt375YbpElPTw99+/ZFUFAQ/P39S+yLhlSzdOlSLFiwAMDbfuwSExNx8eJFmR83Ui1btsRHH32Ejz76CB4eHnjz5g3+/fdfPHr0SOYVFRWFx48fl/g9MDY2RosWLZCXl4fk5GS8evUKr169wps3b8q0T4Wz5qSBOWbNqceFCxewa9cuhISE4OHDh5W+fUdHR/z0008IDAws87oEQUBCQoJMX3NhYWEyQZ/iGBsbyzRl9fLyQqNGjdhUuBhPnjzBkiVLcOXKFWRkZCAjIwPp6enIyMhAQUEBtLS00LBhQzRr1gzNmjWDj48PvL298ezZM6xduxbbtm1T+XxSt25dLF68GIMGDVJb9nZBQQHu3r0rBufOnTsn12/ruxo3biwToHN0dKyk2mq+9PR0/Pe//8U333wjk43p4OAgvq8jR47E9u3bS72NgoICPHjwAFevXsXVq1fx999/IywsDHl5eWIZbW1tjBkzBgsWLICTk1Ppd0gDVYuAnVR+fj7i4uKwZ88eLFy4ED169MC+ffuKjOQnJSXh6tWr+Pzzz5Gamorjx4+XKaWyoKAAHTp0wIULF/D777+jR48eRZYtTYadq6sratSoUer6UfUgzeRgwI6IqgJBEPDy5UuFzVILT0tJSSnztszMzFCrVi2ZgNy7/7e2tpZ5oPby5UsxK16ZJhu5ubmws7NDcnJymeurKmtra7i6uqJjx44YOHAgmjVrpvDh4OvXr/HLL78gODgYN27ckJvv4eGBoKAgDB8+vNr00aSJDh48iL59+6q8nLm5ucrfB319fbRt21ZsFtmiRQuFTV2zsrIQGxuLc+fOITQ0FGfOnMHTp08VrtPOzk6ur7kGDRowa04DxcfH48yZMwgJCcGZM2cQHx8PFxcXuLm5wc3NDXXr1oWbmxtsbW2RkpKCly9fyrxevXqF9PR0pKenIy0tTfx/amoq0tLSit32hAkTsGrVKqVHcszJycG9e/dkmrOq0geii4uLXF9ztWvX5gOHciIIArKysiCRSIr9nZGUlIRNmzbh+++/l3topaenh8aNG6Np06aIj4/HyZMnZeZ7enpiyZIl6NOnT4VnpuXk5ODGjRsyA0Qo6hJDSkdHB82bNxeDc+3atYOlpWWF1rE6ePDgAaZMmYJTp07JTNfT08ODBw/g4uJSrtvLzMzEpk2bsHz5cpmuPfT09DBp0iTMnTtXpWQsTVatAnaFrVq1Cp9//jk2bNiASZMmFVs2Li4O9erVg5eXF65evVqm7W7ZsgXjxo3DnDlzsHz5cqWXK+6DyM3NxaNHj+Dg4FBlRpShivPy5UskJiaifv367FuIiNQqNzcXz549K7KfOOk0ZTr9Lo5EIoGdnZ1c8K1wQM7R0RHGxsYqr1t6/QWALl264PTp08WWT05Olumg287ODrVr1xZftWrVgr6+PrS0tGRewNv3KycnR+aVnp4uNqf9999/S3zSX1idOnUwcOBADBw4EN7e3rhy5QqCg4Oxd+9eZGZmypQ1NDTEoEGDEBQUhNatW1f75juaIDY2Vm6wDldXV3Tt2hVdunSBo6Mjjh8/jsOHD+Off/5Rap3m5uZi8EUaiKlXrx58fHxK9VBXEAQ8fPgQoaGhCA8Ph4uLixicqy4/dt5HgiCU23c8NzcXycnJSE5OxsuXL5GUlIQNGzbgjz/+EMvUrl0b27ZtQ/v27WWWTUpKkutr7t69e0X2i1aYvr4+GjVqJBOca9KkyXsz0EFVkZ2djV9//RX37t1DgwYN0LRpUzRs2FDmgcHFixcxf/58hIaGyizbr18/7Nixo1TZ40VJT0/HlStXxAEirl69WmwmoJGREdq0aSMG6Fq1alWu9XmfCIKAI0eOYNq0aeLAnNOnT8c333xTYdtMS0vDunXrsGrVKplms5aWlnj8+HG1yLKttgG7sLAweHt7K90fTdOmTREWFob09PQyfUmPHDmCjz76CFOnTsXatWuVXq64D0IQBDx+/Bi5ublwcHDgE6T3lCAIyMzMRGJiIszNzdnHEBFVqPT09GKbp0qbqJb11kBfX7/IbDjp/+3s7Cqsw/6srCwx0OHv748zZ84UW/7Zs2fi+bdXr144fPhwudZHmkX977//Ii4uDo8fP8bjx48RGxuLx48fIz4+XmFzSAsLC4VZAz4+PggKCsKQIUPeq1HVNMXGjRtx6dIltGnTBl26dIGbm5vCQEp0dDSOHDmCw4cP4+HDh3ByckLdunVlXm5ubkWO5khUmQRBwKZNmzBz5kxkZGQAePtgZdKkSTAzMxMDdMo+gLCzs5Pra65+/foa198ZlU1ISAjmzZuHK1euiNN8fHxw5MgRODg4lGqdSUlJuHDhgphBd/PmzWIHxbGysoKvr684SIS3t3eFDwj0vnnz5g22bNmC9PR0TJ8+vVLe3+TkZHz99df47rvv8ObNG3z66af47rvvKny7laHaBuxOnDiBDz74AEOHDlU4DPG77Ozs8OLFC2RmZpZpFJt58+Zh+fLlWLNmDaZNm6b0ciV9EDk5OYiOji5z3z1U9Zmbm8POzo7ZEURUKtKRA4sbQTUhIUGuv7PSMDc3VxiIKzzNyspKreez/Px88Udh27ZtcfHixWLLx8XFwdnZGQAwYMAA7Nu3r8LrWFhSUhIOHjyIffv2ISQkROF9gampKYYPH47x48ejadOmlVo/Inp/REVFYcyYMTh//rxS5bW1tWX6QJQG55jN+f4QBAEHDhzAmDFjxObWjo6OOHLkCJo1a1bi8rGxsTIDRNy7d6/Y8s7OzjL9zzVs2JDJL9XY06dPsXLlSsyZMwd2dnbqrk65UCVgp3GPOG7fvo3atWvLNRNNTk7G3LlzAQDdu3cH8LYZ4bNnz+Dp6SlTVhAELF68GM+fP0enTp1kgnW5ubmIioqCrq4u3NzcxOkRERFwcHCQS8m+cOECvv32W+jr65eqz5Li6OnpoV69ego7Kqb3h66uLpvBElGRcnNz8fTp02JHUE1ISCjztURLS0upJqpVoSmCtrY2tLS0UFBQoFQzrcLvnTqeyltbWyMoKAhBQUFITEwUg3fXr19H48aNERQUhAEDBrBJDxFVODc3N5w5cwbr1q3D3LlzZbo/sLCwkBsIwsPDg/0vv+ckEgn69euHBg0a4MMPP0RsbCwSEhLg5+eH3bt3o3fv3mJZQRBw7949mQDd48ePi12/h4eHTIBO+oCN3g/29vZYt26duquhNhoXsNu2bRs2b96MgIAAuLi4wMjICLGxsTh27BjS09PRr18/DB06FMDbJ+JNmzZFy5Yt4eHhATs7OyQlJeH8+fO4f/8+7Ozs8MMPP8isPyEhAe7u7nBxcRHbYQPAvn378PXXX6NTp05wdXWFvr4+wsPDcfr0aWhpaWHjxo0VcnLQ0tLiRY6I6D2VlpZW4sANiYmJZW6iamBgUGQTVem/dnZ21aqpkp6eHrKyspQKZBYO6qm7830bGxtMmDABEyZMUGs9iOj9pa2tjenTp6N3794ICQmBra0tvLy84OTkxNYgVKRGjRrh77//Ru/evXH58mVkZmaib9++WLBgAUxMTHD+/HlcuHCh2MFItLW10axZMzE45+vry4GU6L2mcXfm/fv3R2pqqtixZGZmJiwtLeHr64uRI0di8ODB4oXCxcUFc+bMQWhoKI4fP47k5GQYGBigXr16mD9/PqZNm6Z0vyABAQG4d+8ebt68ibNnzyIrKwu2trYYNGgQPvvsM7Rs2bIid5uIiKqZ5ORkxMTEFNtnXOHOdEvLwsJCYTZc4f9bWlq+dz+ydHV1lQ7YFS6j7oAdEZGmqFOnDurUqaPualAVYmNjg5CQEIwbNw4///yz2PKtKDVq1EDr1q3FAF3r1q1LNdgUUXWlcQE7X19f+Pr6KlXWwsJCpVFbgbcjeSnKVOjQoQM6dOig0rqIiIgUWbNmDWbMmFGmzDgtLS3Y29sXmxnn4ODAZpJFkAbeqkKTWCIiourCwMAAu3btQoMGDbBw4UKZeebm5vD19RUDdD4+PnxQRlQMjQvYERERVWV3797FF198UWywrkaNGkX2Eyf9v62tbbVqolrZpD8AqlqTWCIioqpOIpFgwYIF8PHxwdGjR9GkSRP4+fnB09OTA0QQqYC/BIiI3pGUlIRdu3YhOTlZnCZtTljUvxUx731ft6mpKTp16lSl+vnMz8/H+PHjxQBQYGAg2rRpIxecMzc3f++aqFY2aaacqhl2DNgRERGVjx49eqBHjx7qrgZRlcWAHRHR/ycIAn799VdMnjwZL168UHd1CG9Hhpo5cyYmTJhQJUYn3bBhA65cuQIAaNCgAQ4dOlSlAo7ViSoZdmwSS0RERESahgE7qjZycnIQGhqKQ4cO4fTp08jKyoKhoSGMjIxgaGgo9yrLdDZTq36ePXuG//znPzh48KC6q0KFPH36FDNmzMCKFSvw2Wef4ZNPPoGZmZm6q6XQ48ePMWfOHPHv4OBgBuvUSJUMOzaJJSIiIiJNw6gDVWmvX7/GyZMncejQIRw7dqxcRlxUhq6ubrkE/oqbrqurW62azBUUFCAkJAR37twRh2vX1tZWd7UgCAJ27tyJadOm4dWrV+L0vn374uOPP4aWlpbYF9m7/yqapsw8Lq/c8mfPnsWBAwcAvG2mPG/ePHz99deYMmUKZs6cCVNTU2gKQRAwadIkZGRkAAAmTpwIPz8/Ndfq/VbaDDsG7IiIiIhIEzBgR0pLTk5GSkqKwldqaipycnLEV25uLnJycpCXlwd9fX2Fwam6devC29sb1tbWJW47Pz8fUVFRCA8PF1///PMPHj58iPz8fLny+vr6sLa2RmZmJjIyMpT6waaK3NxcpKamIjU1tVzXW5i2tnaxAb7yCArq6+tXeFDwxYsX2LZtG3788Uc8evRInG5vb4/+/ftj4MCBaNu2rUod0AqCgDdv3kBPT69U2Y6CIODff//FjRs3sH37dhw/flycV7NmTfzwww8YMGCAyuul8jVlyhTcvXsXK1aswC+//IKCggKkpqZi6dKl2L17N/bu3YvmzZsXuXxeXh7Wr1+PQ4cOQSKRiN8B6feg8Peh8P/19fWRkZGB1NRUvH79Wvyu5+bmomvXrujXr59csHnPnj3iceTg4ICVK1dW6HtDJZNm2LFJLBERERFVRRKhuGHsqExev34NMzMzpKamalQmSGmZmJggPT293Nfr6OiIpk2bwtvbG40aNUJGRgYeP36Mx48fIzY2Fo8fP0ZcXByys7OLXY+FhQU+/PBDfPTRRwgMDISxsbE4Ly8vD2/evEFmZqb4ysjIkPm7rNOzsrLK/b2paIWDGOUdEIyJicGmTZvw22+/lfiD2dHREX369IGFhQVyc3ORl5eH3NxcMfCbnJyMpKQkvHz5UnxJm7AZGBjAyMgIxsbG4svCwgKWlpawsrIS/zUyMsK9e/dw48YN3Lx5U2GwdciQIfjuu++UCiJT5Xr48CFWrlyJHTt2IC8vD8DbwMrKlSsxbdo0uYDv9evXERQUhNu3b5d7Xdzd3TF//nwMGjQI2traSEpKgru7O5KSkgAAhw4dwkcffVTu2yXVtGvXDpcuXQLw9hpQXEbv7t27MXz4cADA+vXrMXny5EqpIxERERG9X1SJEzFgV4GqW8DOyckJ8fHx6q6GSF9fH+7u7vDz80Pv3r3h5+en1syIgoICmaBgeQcEpa+qrFOnTujZsyfOnDmDEydOlHvmY2nZ2dlh48aNDLJUAVFRURg2bBiuXr0qTvvggw+wbds21KxZE+np6fjyyy/x3XffoaCgoELrUr9+fcybNw9//PEHdu3aBQDo378/fv311wrdLiknICAAoaGhAIA3b94U25/g1q1bMXbsWADAxo0bMWHChMqoIhERERG9Z1SJE7FJLCmtZ8+eSElJgbm5ufgyMzODubk5TE1NUaNGDejq6kJPTw96enrQ1dWFjo4OsrOzxWCTNKCVkpKC8PBw3L59G7dv3y62aamJiQmcnZ3RsGFDNGrUCI0aNULjxo3h5uamUYM/aGlpic3tKoogCMjKyqrQgGBGRgbKM45vZWWFMWPG4OOPP0a9evUAAFOnTkVqaiqOHDmCffv24dSpU0p1DF+jRg1YW1vDysoK5ubmyMnJQUZGBtLT08WXtA+x4jg4OKBZs2bw8fGBj48PAgICZDIySXO5ubnh/Pnz+PLLL/HVV18BAI4fPw5vb2/MmjULa9aswePHj8XyTZo0wY8//ggvLy/x+JYe84q+ExkZGcjKyoKRkRHMzMxgZmYGU1NTmJmZ4fnz51ixYgXOnz8PAHjw4AFGjRolbsvc3Bzr16+v3DeEilT4AU5ubm6xATv2YUdEREREmkZzoh2k8TZs2FAh6xUEAbGxsbh16xYiIyNhZmYGZ2dnODs7w8XFRWNHhFQHiUSCGjVqoEaNGrCysqqQbQiCIAbCyhL4k0gk6NmzJ/r376/wh7KZmRlGjBiBESNGICUlBdeuXQMA6OjoiMFeXV1d6OrqwsLCAlZWVjA0NCyx/vn5+UhNTcXLly+RnJyM5ORkvHz5EqmpqXB1dYWPjw/s7OzK/X2jyiNtChsQEIARI0bgxYsXePLkCT777DOxjIGBARYtWoTp06eLgRsDAwNYWlqWadvdu3dHaGgolixZgjNnzsjMW716NY8tDVI48FZSNi9HiSUiIiIiTcOAHamdRCKBq6srXF1d1V0VwtvPQ19fH/r6+mUObijL3NwcXbp0KZd1aWtrw9LSstLqTuoTGBiIsLAwjBgxAn/99Zc4vXPnzti4cSPc3NwqZLv+/v7w9/fH+fPnsWTJEvz5558YOnSo2KSSNEPhDLuSAnYcdIKIiIiINA0DdkREVGXZ29vj1KlTWLduHU6ePIkRI0Zg+PDhFT76MQD4+fnhjz/+QE5ODnR1dStlm6S8wplyJTW5Z4YdEREREWkaBuyIiKhK09bWxvTp0zF9+nS1bJ8BHs2kSpNY9mFHRERERJpGS90VICIiIipv7w46URw2iSUiIiIiTcOAHREREVU7HHSCiIiIiKoyBuyIiIio2ilthh0DdkRERESkCRiwIyIiomqntH3YsUksEREREWkCBuyIiIio2ikceGOTWCIiIiKqahiwIyIiomqncOCNTWKJiIiIqKphwI6IiIiqHTaJJSIiIqKqjAE7IiIiqnZUGXSCTWKJiIiISNMwYEdERETVDjPsiIiIiKgqY8COiIiIqh1VBp1gH3ZEREREpGkYsCMiIqJqR5VBJ9gkloiIiIg0DQN2REREVO2wSSwRERERVWUM2BEREVG1o8qgEwzYEREREZGmYcCOiIiIqh1VMuykAT0dHR1oafHWiIiIiIjUj3elREREVO2UJsOO2XVEREREpCkYsCMiIqJqpzQZdhxwgoiIiIg0BQN2REREVO0UzpZTdtAJBuyIiIiISFMwYEdERETVTuHgG5vEEhEREVFVw4AdERERVTtsEktEREREVRkDdkRERFTtlGbQCQbsiIiIiEhTMGBHRERE1Y4qGXZsEktEREREmoYBOyIiIqp2VBl0gk1iiYiIiEjTaFzALiUlBVOmTEGbNm1gZ2cHfX19ODo6omPHjti/fz8EQZApHxwcjJ49e6J27dowMjKCmZkZvLy8sGDBAiQnJ6u8/WvXruGDDz6AhYUFjIyM0LJlS/z888/ltXtERERUCZQddEIQBGbYEREREZHG0VF3Bd6VlJSELVu2oHXr1ujduzcsLS2RmJiIo0ePon///ggKCsKPP/4olt+5cydevXoFPz8/2NvbIzs7G1euXMHSpUuxfft2XL16FXZ2dkptOzQ0FIGBgdDT08PgwYNhZmaGAwcOYNiwYYiJicHcuXMrareJiIioHCnbJDYvL0/hMkRERERE6iQR3k1ZU7P8/HwIggAdHdlYYlpaGlq3bo2IiAiEh4fD09MTAJCVlQUDAwO59Xz55ZdYtmwZZs6ciVWrVpW43by8PDRs2BDx8fG4fPkymjZtKm63TZs2uH//PiIiIlCvXj2l9+X169cwMzNDamoqTE1NlV6OiIiIyubZs2ewt7cHAPTu3RsHDx5UWC4zMxNGRkYAgI4dO+Kvv/6qtDoSERER0ftFlTiRxjWJ1dbWlgvWAYCJiQkCAwMBAI8ePRKnKwrWAcCAAQPkyhYnJCQEUVFRGDp0qBisk273yy+/RF5eHrZu3ar0fhAREZH6KJthV3gem8QSERERkabQuIBdUbKyshASEgKJRAIPD48Syx87dgwA0KhRI6XWHxoaCgDo2rWr3DzptLNnzypZWyIiIlKnwsG34vqwKxywY5NYIiIiItIUGteHnVRKSgrWrl2LgoICJCYm4vjx44iLi8PChQsVNkvdtm0bYmJikJaWhps3byI0NBRNmzbF9OnTldrew4cPAUDhui0sLGBtbS2WKUp2djays7PFv1+/fq3UtomIiKh8KZthVziYx4AdEREREWkKjQ7YLV68WPxbV1cXq1atwowZMxSW37Ztm0wGXNeuXbFz505YWFgotb3U1FQAgJmZmcL5pqamiI+PL3YdK1askKkzERERqUfhDDs2iSUiIiKiqkZjm8S6urpCEATk5eUhOjoaS5Yswbx589CvXz+ZEd2kQkNDIQgCXrx4gd9//x3x8fFo1qwZ7ty5U2l1njNnDlJTU8VXXFxcpW2biIiI/kdLSwva2toAim8Syww7IiIiItJEGhuwk9LW1oarqytmz56NZcuW4eDBgwgODi6yvLW1NXr06IGTJ08iKSkJQUFBSm1HmlknzbR7l3Qkj+Lo6+vD1NRU5kVERETqIQ3AKZthx4AdEREREWkKjQ/YFSYd/EE6QERxnJyc4O7ujmvXriEzM7PE8tK+6xT1U/fq1SskJSUp7N+OiIiINJO0iauyg06wSSwRERERaYoqFbB78uQJAEBHR7mu954+fQqJRCI2iSlOhw4dAACnT5+WmyedJi1DREREmk+ZDDs2iSUiIiIiTaRxAbvbt28rbJaanJyMuXPnAgC6d+8OAHj58iXu3r0rV1YQBCxatAjPnz9HQEAA9PX1xXm5ubmIjIxEVFSUzDKdOnVCnTp18PPPP+P27dvi9LS0NCxduhQ6OjoYPXp0OewhERERVQZpxhwHnSAiIiKiqkbjRondtm0bNm/ejICAALi4uMDIyAixsbE4duwY0tPT0a9fPwwdOhQAEBcXh6ZNm6Jly5bw8PCAnZ0dkpKScP78edy/fx92dnb44YcfZNafkJAAd3d3uLi4ICYmRpyuo6ODzZs3IzAwEH5+fhgyZAhMTU1x4MABREdHY9myZahfv35lvhVERERUBtKMOWWbxDLDjoiIiIg0hcYF7Pr374/U1FRcuXIF586dQ2ZmJiwtLeHr64uRI0di8ODBkEgkAAAXFxfMmTMHoaGhOH78OJKTk2FgYIB69eph/vz5mDZtGqysrJTedkBAAC5cuICFCxdi3759yMnJgaenJ5YuXYphw4ZV1C4TERFRBWCTWCIiIiKqqjQuYOfr6wtfX1+lylpYWGD58uUqrd/V1RWCIBQ5v2XLljhx4oRK6yQiIiLNw0EniIiIiKiq0rg+7IiIiIjKgzIZdmwSS0RERESaiAE7IiIiqpaUybBjk1giIiIi0kQM2BEREVG1JA3AFRQUID8/X2EZNoklIiIiIk3EgB0RERFVS4UDcEU1i2WTWCIiIiLSRAzYERERUbVUOABXVLNYNoklIiIiIk3EgB0RERFVS4UDcMpk2LFJLBERERFpCgbsiIiIqFoqHIBjhh0RERERVSUM2BEREVG1pGqGHQN2RERERKQpGLAjIiKiaknVQSfYJJaIiIiINAUDdkRERFQtcdAJIiIiIqqqGLAjIiKiaomDThARERFRVcWAHREREVVLygw6wT7siIiIiEgTMWBHRERE1ZIyGXZsEktEREREmogBOyIiIqqWOOgEEREREVVVDNgRERFRtaTMoBNsEktEREREmogBOyIiIqqWlMmwY5NYIiIiItJEDNgRERFRtaRqhh2bxBIRERGRpmDAjoiIiKolZQadYJNYIiIiItJEDNgRERFRtVQ4Y66oDDs2iSUiIiIiTcSAHREREVVLqmbYsUksEREREWkKBuyIiIioWlJm0Ak2iSUiIiIiTcSAHREREVVLygw6IZ2upaUFbW3tSqkXEREREVFJGLAjIiKiakmVJrFsDktEREREmoQBOyIiIqqWVBl0gs1hiYiIiEiTMGBHRERE1RIz7IiIiIioqmLAjoiIiKolVQadYIYdEREREWkSBuyIiIioWlJl0AkG7IiIiIhIkzBgR0RERNWSKhl2bBJLRERERJqEATsiIiKqlpTJsGOTWCIiIiLSRKUO2B0+fBgFBQXlWRciIiKicqPMoBNsEktEREREmqjUAbs+ffrA2dkZ8+bNw7///luedSIiIiIqs8LNXEvKsGOTWCIiIiLSJKUO2M2cORP5+flYsWIF6tevj86dO2Pv3r1FPsEmIiIiqkwlZdjl5+eLrQWYYUdEREREmqTUAbuvv/4acXFx2L9/PwIDA3H27FkMHToUjo6OmD59Ou7evVue9SQiIiJSSUmDThTOumPAjoiIiIg0SZkGndDR0UGfPn1w7NgxxMbGYvHixTA1NcXatWvRpEkTtG3bFtu2bUNmZmZ51ZeIiIhIKSUNOlE4iMcmsURERESkScptlFgHBwfMnz8fUVFROHbsGOzt7XH16lWMGzcO9vb2+PTTT/H48eMS15OSkoIpU6agTZs2sLOzg76+PhwdHdGxY0fs378fgiCIZXNzc7F//36MHj0a7u7uMDIygomJCVq1aoUNGzYgPz9fpX1wdXWFRCJR+Jo4caLK7wkRERGpT0lNYgtPY4YdEREREWkSnfJcWWRkJDZv3oydO3fixYsXMDQ0xEcffYSwsDD88MMP2Lp1K3799Vd07969yHUkJSVhy5YtaN26NXr37g1LS0skJibi6NGj6N+/P4KCgvDjjz8CAKKiotC/f3+YmJigY8eO6NWrF1JTU3H06FF88sknOHnyJA4fPgyJRKL0PpiZmWHatGly05s3b67y+0FERETqU9KgE2wSS0RERESaSiIUTlkrhTdv3mDv3r3YvHkzLl++DEEQ0LhxY3z88ccYMWIETE1NAQDHjx/H6NGjYWdnhzt37hS5vvz8fAiCAB0d2VhiWloaWrdujYiICISHh8PT0xMJCQk4cuQIRo0aBUNDQ7FsRkYG/P39cf36dezbtw8DBgxQal9cXV0BADExMaq9CUV4/fo1zMzMkJqaKr4PREREVDlycnKgr68PAGjfvj3Onj0rMz82Nla89g8cOBB79+6t7CoSERER0XtElThRqZvE3rhxAxMnToS9vT3GjRuHW7duYeTIkbh06RLCwsLwySefyGz8gw8+wPjx4xEZGVnserW1teWCdQBgYmKCwMBAAMCjR48AAI6Ojpg0aZJMsA4AjIyMMH36dACQuzknIiKi9wMHnSAiIiKiqqrUTWJbtGgBAGjUqJGYTWdmZlbsMs7OznB0dCzV9rKyshASEgKJRAIPD48Sy0tv0hUF/4qTnZ2N7du3IyEhARYWFmjbti28vLxKVWciIiJSH4lEAh0dHeTl5XHQCSIiIiKqUkodsBs5ciQmTJiANm3aKL3MxIkTlR68ISUlBWvXrkVBQQESExNx/PhxxMXFYeHChahXr16Jy2/ZsgUA0LVrV6XrBwDPnj3D6NGjZaZ169YNO3fuhLW1dbHLZmdnIzs7W/z79evXKm2biIiIypeuri7y8vI46AQRERERVSmlDtgtWbIE5ubmxZZJS0vDq1ev4OzsrPL6U1JSsHjxYvFvXV1drFq1CjNmzChx2R9//BEnTpxAx44d8cEHHyi9zbFjx6JDhw7w9PSEvr4+IiIisHjxYpw4cQK9evXCxYsXix3AYsWKFTJ1JiIiIvXS09PDmzdvOOgEEREREVUppe7Drnbt2li3bl2xZTZs2IDatWuXav2urq4QBAF5eXmIjo7GkiVLMG/ePPTr1w95eXlFLnfs2DFMnjwZLi4u2LVrl0rbXLBgATp06ABra2uYmJigVatW+P333+Hr64vLly/j+PHjxS4/Z84cpKamiq+4uDiVtk9ERETlSxqIKynDjk1iiYiIiEiTlDpgJwgCShpgtowD0AJ4OwiFq6srZs+ejWXLluHgwYMIDg5WWPbUqVPo168fbG1tERISAnt7+zJvX0tLC2PGjAEAXLx4sdiy+vr6MDU1lXkRERGR+kgDcSX1YccMOyIiIiLSJKUO2CkjPj4eJiYm5bY+aX90oaGhcvNOnjyJ3r17w9raGmfOnEGdOnXKbbvSvusyMzPLbZ1ERERU8YrLsGOTWCIiIiLSVCr1YbdkyRKZvxUFzgAgPz8f8fHx2LNnD1q1alXqyr3ryZMnAORHfpUG6ywtLXHmzBnUrVu33LYJAFevXgXwtpkuERERVR3SDDs2iSUiIiKiqkSlgN2iRYvE/0skEoSGhhYZtAMABwcHfPXVVypV6Pbt26hduzbMzMxkpicnJ2Pu3LkAgO7du4vTpcE6CwsLnDlzpsQRZHNzcxEVFQVdXV24ubmJ0yMiIuDg4CA3kMaFCxfw7bffQl9fH3379lVpX4iIiEi9pJlzbBJLRERERFWJSgG7M2fOAHjbN13Hjh0xevRojBo1Sq6ctrY2LC0t0bBhQ2hpqdbqdtu2bdi8eTMCAgLg4uICIyMjxMbG4tixY0hPT0e/fv0wdOhQAEBkZCR69+6N7Oxs+Pv745dffpFbn6urK0aPHi3+nZCQAHd3d7i4uCAmJkacvm/fPnz99dfo1KkTXF1doa+vj/DwcJw+fRpaWlrYuHFjqUa7JSIiIvVhk1giIiIiqopUCth16NBB/P/ChQsREBCA9u3bl2uF+vfvj9TUVFy5cgXnzp1DZmYmLC0t4evri5EjR2Lw4MGQSCQAgGfPniE7OxsAsGfPniLrXDhgV5SAgADcu3cPN2/exNmzZ5GVlQVbW1sMGjQIn332GVq2bFlu+0hERESVo/CgE4IgiPcQAJvEEhEREZHmUilgV9jChQvLsx4iX19f+Pr6KlXW399f5ZFoXV1dFS7ToUMHmYAkERERVX3SzDlBEJCfny/TDy6bxBIRERGRplI6YPf48WMAgKOjI7S1tcW/lcGmpERERKQOhTPncnJyZAJ2bBJLRERERJpK6YCdq6srJBIJ7t27h/r164t/l0QikSAvL69MlSQiIiIqjcKBuHcHnmCTWCIiIiLSVEoH7EaOHAmJRCKO3ir9m4iIiEhTvZthVxibxBIRERGRplI6YLdt27Zi/yYiIiLSNMVl2BX+mxl2RERERKRJtNRdASIiIqKKUjhgxww7IiIiIqoqGLAjIiKiaqtw5lxxGXYM2BERERGRJlG6SawiERER+P7773Ht2jWkpKQgPz9froxEIkFUVFRZNkNERERUKspm2LFJLBERERFpklIH7M6ePYtu3bohOzsbOjo6sLW1hY6O/OoEQShTBYmIiIhKi4NOEBEREVFVVOqA3ezZs5GXl4fNmzdj1KhR0NbWLs96EREREZWZsoNOMGBHRERERJqk1AG7sLAwDB48GGPHji3P+hARERGVGzaJJSIiIqKqqNSDTpiYmMDGxqY860JERERUroobdIJNYomIiIhIU5U6YNejRw+cP3++POtCREREVK6Ky7Bjk1giIiIi0lSlDth9/fXXSE1NxZQpU5CZmVmedSIiIiIqF8oOOsEmsURERESkSUrdh93AgQNhZGSEH374Adu2bUO9evVgZmYmV04ikeCvv/4qUyWJiIiISqO4QSfYJJaIiIiINFWpA3ahoaHi/9PT03Hr1i2F5SQSSWk3QURERFQmxWXYsUksEREREWmqUgfsCgoKyrMeREREROVO2Qw7NoklIiIiIk1S6j7siIiIiDRdcYNOsEksEREREWkqBuyIiIio2iqcOfduhl3hv3V0St3ogIiIiIio3Cl9d7pjxw4AQJ8+fWBiYiL+rYyRI0eqXjMiIiKiMlImw05XV5d97hIRERGRRlE6YDd69GhIJBK0bt0aJiYm4t/FEQQBEomEATsiIiJSC2UGnWBzWCIiIiLSNEoH7LZs2QKJRAJ7e3sAwNatWyusUkRERETlQZlBJzjgBBERERFpGpUy7AobNWpUedeFiIiIqFwp0ySWGXZEREREpGk46AQRERFVW8oMOsGAHRERERFpGgbsiIiIqNpSdtAJIiIiIiJNonST2Dp16pRqAxKJBFFRUaValoiIiKgsiht0gk1iiYiIiEhTKR2wKygoKHFUWEUEQVB5GSIiIqLyUNygE2wSS0RERESaSumAXUxMTAVWg4iIiKj8KZNhxyaxRERERKRp2IcdERERVVtFZdgJgoC8vDy5MkREREREmoABOyIiIqq2ihp0onDwjgE7IiIiItI0SjeJLUp8fDzOnDmDJ0+eIDs7W26+RCLBl19+WdbNEBEREamscHPXwkG6wsE7NoklIiIiIk1TpoDdrFmzsG7dOuTn54vTBEEQB6eQ/p8BOyIiIlKHojLsCv+fGXZEREREpGlK3SQ2ODgY33zzDQICAvDbb79BEASMGjUKv/zyCyZOnAgdHR30798fISEh5VlfIiIiIqUVNehE4Ww7ZtgRERERkaYpdYbdjz/+CFdXV5w4cQJaWm/jfq6urhg0aBAGDRqEgQMHokuXLhg4cGC5VZaIiIhIFUUNOsEMOyIiIiLSZKXOsIuMjES3bt3EYB0AcbQ1AOjQoQN69OiB1atXl62GRERERKXEQSeIiIiIqCoq0yix5ubm4v+NjIzw8uVLmfkNGjTA3bt3VVpnSkoKpkyZgjZt2sDOzg76+vpwdHREx44dsX//fgiCIJbNzc3F/v37MXr0aLi7u8PIyAgmJiZo1aoVNmzYINO3nrKuXbuGDz74ABYWFjAyMkLLli3x888/q7weIiIiUj8dnf81JuCgE0RERERUVZS6SayjoyPi4+PFv93c3HD16lWZMuHh4TAyMlJpvUlJSdiyZQtat26N3r17w9LSEomJiTh69Cj69++PoKAg/PjjjwCAqKgo9O/fHyYmJujYsSN69eqF1NRUHD16FJ988glOnjyJw4cPi4NglCQ0NBSBgYHQ09PD4MGDYWZmhgMHDmDYsGGIiYnB3LlzVdoXIiIiUi+JRAJdXV3k5uZy0AkiIiIiqjJKHbBr164dzp8/L/790UcfYdmyZZg4cSJ69uyJCxcu4MSJE+jXr59K661duzZSUlJknogDQFpaGlq3bo3g4GBMnToVnp6eMDExwYYNGzBq1CgYGhqKZb/55hv4+/vj6NGj+O233zBgwIASt5uXl4fx48dDIpHg3LlzaNq0KQBg4cKFaNOmDRYuXIgBAwagXr16Ku0PERERqZeigB2bxBIRERGRJit1k9gRI0bAzc0NsbGxAIBZs2bB29sbP/74I3r16oWvvvoKLi4uWLVqlUrr1dbWlgvWAYCJiQkCAwMBAI8ePQLwNstv0qRJMsE64G3z3OnTpwMAzp49q9R2Q0JCEBUVhaFDh4rBOul2v/zyS+Tl5WHr1q0q7QsRERGpnzQgxyaxRERERFRVlDrDzt/fH/7+/uLfxsbGuHLlCg4fPoyoqCi4uLigZ8+eKjeJLUpWVhZCQkIgkUjg4eFRYnnpzbei4J8ioaGhAICuXbvKzZNOUzb4R0RERJpDek/AJrFEREREVFWUOmCniEQigZubG9zc3NCoUaMyPbFOSUnB2rVrUVBQgMTERBw/fhxxcXFYuHChUs1St2zZAkBxAE6Rhw8fAoDCdVtYWMDa2losQ0RERFWHogw7NoklIiIiIk2mUsAuOjoaZ86cga+vL+rXry8z7/fff8e4ceOQlJQE4G2Qa8OGDRg4cGCpKpaSkoLFixeLf+vq6mLVqlWYMWNGicv++OOPOHHiBDp27IgPPvhAqe2lpqYCAMzMzBTONzU1lRlkQ5Hs7GxkZ2eLf79+/VqpbRMREVHFkQbkisqwY5NYIiIiItI0KvVhFxwcjKCgIOjr68tMf/ToEQYOHIgXL17A2dkZDRs2xKtXrzBs2DDcunWrVBVzdXWFIAjIy8tDdHQ0lixZgnnz5qFfv37Iy8srcrljx45h8uTJcHFxwa5du0q17dJasWIFzMzMxJeTk1Olbp+IiIjkSQNyRfVhxww7IiIiItI0KgXsLly4AC8vL7i4uMhMX7duHbKysvDJJ58gOjoad+/exa+//or8/Hx8//33ZaqgtrY2XF1dMXv2bCxbtgwHDx5EcHCwwrKnTp1Cv379YGtri5CQENjb2yu9HWlmnTTT7l2vX78uMvtOas6cOUhNTRVfcXFxSm+fiIiIKoaiDDs2iSUiIiIiTaZSwC46Ohqenp5y00+ePAk9PT0sX75cnNa3b1/4+fnh/PnzZa/l/yftj046QMS7dejduzesra1x5swZ1KlTR6V1S/uuU9RP3atXr5CUlFRi33n6+vowNTWVeREREZF6lTToBJvEEhEREZGmUSlgl5SUJNfMMyUlBVFRUWjVqhVMTExk5nl7eyMhIaHstfz/njx5AkB+5FdpsM7CwgJnzpxB3bp1VV53hw4dAACnT5+WmyedJi1DREREVUfhQScEQQDAJrFEREREpNlUCtjp6OggJSVFZpq0j7rmzZvLlTc2Nla5Qrdv31bYLDU5ORlz584FAHTv3l2c/m6wrqQsuNzcXERGRiIqKkpmeqdOnVCnTh38/PPPuH37tjg9LS0NS5cuhY6ODkaPHq3y/hAREZF6FQ7ISfvBLdwklhl2RERERKRpVBoltn79+vjrr79kpp0+fRoSiQRt27aVK//kyROV+pEDgG3btmHz5s0ICAiAi4sLjIyMEBsbi2PHjiE9PR39+vXD0KFDAQCRkZHo3bs3srOz4e/vj19++UVufa6urjKBtoSEBLi7u8PFxQUxMTHidB0dHWzevBmBgYHw8/PDkCFDYGpqigMHDiA6OhrLli2TGxmXiIiINF/hgFxubi50dXWZYUdEREREGk2lgF2/fv0wf/58TJgwAZ988gkePXqE//u//4OxsTG6desmV/7ixYsqN0/t378/UlNTceXKFZw7dw6ZmZmwtLSEr68vRo4cicGDB0MikQAAnj17huzsbADAnj17FK6vQ4cOSmfGBQQE4MKFC1i4cCH27duHnJwceHp6YunSpRg2bJhK+0FERESaoXBALicnB4aGhgzYEREREZFGUylg99lnn2Hv3r0IDg7G5s2bAQCCIGDVqlUwMjKSKXv9+nU8evQIEyZMUKlCvr6+8PX1Vaqsv7+/2BeNslxdXYtdpmXLljhx4oRK6yQiIiLNVTjDThqoY5NYIiIiItJkKgXsatSogYsXL2LNmjW4cuUKLC0tMWDAAPTq1Uuu7M2bN/HRRx8pnEdERERUWQpn0EkDdcywIyIiIiJNplLADng7kMSXX35ZYrmPP/4YH3/8cakqRURERFReSsqwY8COiIiIiDSNSqPEEhEREVU1JWXYsUksEREREWkaBuyIiIioWnt30InC/747n4iIiIhIEzBgR0RERNVa4Qw6aYYdm8QSERERkSZjwI6IiIiqtZIy7NgkloiIiIg0DQN2REREVK0pGnSCTWKJiIiISJMxYEdERETVmqJBJwo3iWWGHRERERFpGgbsiIiIqFrjoBNEREREVNUwYEdERETVmqJBJxiwIyIiIiJNxoAdERERVWuKMuzYJJaIiIiINBkDdkRERFStcdAJIiIiIqpqGLAjIiKiak3RoBMM2BERERGRJmPAjoiIiKo1RRl2bBJLRERERJqMATsiIiKq1orLsNPW1oaWFm+HiIiIiEiz8A6ViIiIqrXiBp1gc1giIiIi0kQM2BEREVG1VrjJ67sZdmwOS0RERESaiAE7IiIiqtYUZdhJ/2WGHRERERFpIgbsiIiIqForbtAJBuyIiIiISBMxYEdERETVWnGDTrBJLBERERFpIgbsiIiIqFpjk1giIiIiqmoYsCMiIqJqTdGgE9J/mWFHRERERJqIATsiIiKq1phhR0RERERVDQN2REREVK29O+iEIAgM2BERERGRRmPAjoiIiKq1dwedyM/PF/9mk1giIiIi0kQM2BEREVG19m6GnTS7DmCGHRERERFpJgbsiIiIqFp7N8OOATsiIiIi0nQM2BEREVG19u6gE9IRYgE2iSUiIiIizcSAHREREVVrbBJLRERERFUNA3ZERERUrb3bJLZwhh0DdkRERESkiRiwIyIiomqtuAw7NoklIiIiIk3EgB0RERFVazo6OuL/OegEEREREVUFDNgRERFRtSaRSMTA3LuDTjBgR0RERESaiAE7IiIiqvakTV/fzbBjk1giIiIi0kQM2BEREVG1VzjDjk1iiYiIiEjTaVzALiUlBVOmTEGbNm1gZ2cHfX19ODo6omPHjti/fz8EQZApf/v2bcydOxeBgYGoWbMmJBIJ/P39S7VtV1dXSCQSha+JEyeWw94RERGROkgz6d5tEssMOyIiIiLSRDolF6lcSUlJ2LJlC1q3bo3evXvD0tISiYmJOHr0KPr374+goCD8+OOPYvlDhw5hxYoV0NPTQ/369ZGUlFSm7ZuZmWHatGly05s3b16m9RIREZH6SDPpOOgEEREREVUFGhewq127NlJSUmRGdAOAtLQ0tG7dGsHBwZg6dSo8PT0BAAMGDECvXr3QuHFjvHz5Evb29mXavrm5ORYtWlSmdRAREZFmKZxhx4AdEREREWk6jWsSq62tLResAwATExMEBgYCAB49eiRO9/T0RLNmzdikhYiIiIpUOMOOTWKJiIiISNNpXIZdUbKyshASEgKJRAIPD48K2052dja2b9+OhIQEWFhYoG3btvDy8qqw7REREVHF46ATRERERFSVaGzALiUlBWvXrkVBQQESExNx/PhxxMXFYeHChahXr16FbffZs2cYPXq0zLRu3bph586dsLa2LnbZ7OxsZGdni3+/fv26IqpIREREKmKTWCIiIiKqSjQ6YLd48WLxb11dXaxatQozZsyosG2OHTsWHTp0gKenJ/T19REREYHFixfjxIkT6NWrFy5evAiJRFLk8itWrJCpMxEREWkGaWAuLy9PJmDHJrFEREREpIk0rg87KVdXVwiCgLy8PERHR2PJkiWYN28e+vXrh7y8vArZ5oIFC9ChQwdYW1vDxMQErVq1wu+//w5fX19cvnwZx48fL3b5OXPmIDU1VXzFxcVVSD2JiIhINYUDcxkZGeL/mWFHRERERJpIYwN2Utra2nB1dcXs2bOxbNkyHDx4EMHBwZW2fS0tLYwZMwYAcPHixWLL6uvrw9TUVOZFRERE6lc4MMeAHRERERFpOo0P2BXWtWtXAEBoaGilblfad11mZmalbpeIiIjKR1EBOzaJJSIiIiJNVKUCdk+ePAEA6OhUbtd7V69eBfC2mS4RERFVPWwSS0RERERVicYF7G7fvo3U1FS56cnJyZg7dy4AoHv37qVef25uLiIjIxEVFSUzPSIiAikpKXLlL1y4gG+//Rb6+vro27dvqbdLRERE6sMmsURERERUlWjcKLHbtm3D5s2bERAQABcXFxgZGSE2NhbHjh1Deno6+vXrh6FDh4rlIyMjsXLlSgDAmzdvxGmjR48G8LY56+rVq8XyCQkJcHd3h4uLC2JiYsTp+/btw9dff41OnTrB1dUV+vr6CA8Px+nTp6GlpYWNGzfC2dm54t8AIiIiKneFM+zS09MVTiciIiIi0hQaF7Dr378/UlNTceXKFZw7dw6ZmZmwtLSEr68vRo4cicGDB0MikYjlnz17hu3bt8us4/nz5+I0FxcXmYBdUQICAnDv3j3cvHkTZ8+eRVZWFmxtbTFo0CB89tlnaNmyZfnuKBEREVUaZtgRERERUVWicQE7X19f+Pr6Kl3e398fgiAoXd7V1VVh+Q4dOqBDhw5Kr4eIiIiqjqL6sGOGHRERERFpIo3rw46IiIiovDHDjoiIiIiqEgbsiIiIqNorHJgr3IcdA3ZEREREpIkYsCMiIqJqj01iiYiIiKgqYcCOiIiIqj02iSUiIiKiqoQBOyKi/9fefYdHVed7HP+cTEhCC6ELirAICCIKIghekKY0C1HUpbiiKIiLsKhXVmFFUe+CoteKsIAgFhSkWFZsKy2IosIFlaKELr2E0EybfO8f7MwSmsAPpmTer+fhgZw5c/I7PJ85c+Y7vwKg0DteDzsKdgAAAIhEFOwAAEChd3hh7rfffgv+myGxAAAAiEQU7AAAQKF3vJ509LADAABAJKJgBwAACr3j9aSjYAcAAIBIRMEOAAAUescrzDEkFgAAAJGIgh0AACj0jlWY8zxPPp8vDK0BAAAAToyCHQAAKPSO1cMuISFBnueFoTUAAADAiVGwAwAAhd6xetgxHBYAAACRioIdAAAo9I7Xww4AAACIRBTsAABAoXes4hw97AAAABCpKNgBAIBC71jFOXrYAQAAIFJRsAMAAIUeQ2IBAAAQTSjYAQCAQo9FJwAAABBNKNgBAIBCjx52AAAAiCYU7AAAQKFHwQ4AAADRhIIdAAAo9BgSCwAAgGhCwQ4AABR69LADAABANKFgBwAACr1j9aajYAcAAIBIRcEOAAAUescqzjEkFgAAAJGKgh0AACj0GBILAACAaELBDgAAFHoMiQUAAEA0oWAHAAAKPYbEAgAAIJpQsAMAAIUePewAAAAQTSjYAQCAQs/n88nzvALb6GEHAACASEXBDgAAFHqe5x1VoKOHHQAAACIVBTsAABATjizQUbADAABApKJgBwAAYsKRBTqGxAIAACBSUbADAAAxgSGxAAAAiBYU7AAAQExgSCwAAACiBQU7AAAQE47sYceQWAAAAESqiCvY7dmzR/3791fTpk11zjnnKDExUeeee65at26tadOmycwK7L9kyRINGjRI7dq1U/ny5eV5nlq2bHnav/+7775Tx44dVbp0aRUvXlyNGzfWpEmTHM8KAACEGz3sAAAAEC3iw92AI+3cuVPjx49XkyZNlJqaqjJlymj79u366KOPdPPNN6tXr14aM2ZMcP/3339fw4YNU0JCgmrVqqWdO3ee9u+eM2eO2rVrp4SEBHXp0kWlSpXS9OnT1b17d61bt06DBg06E6cIAADCgIIdAAAAooVnR3ZZCzO/3y8zU3x8wVrivn371KRJEy1fvlw//fST6tatK0latmyZsrOzVa9ePe3atUuVKlVSixYtNGfOnFP6vXl5eapdu7Z+/fVXff3112rQoEHw9zZt2lQ///yzli9frpo1a570Mffu3atSpUopMzNTycnJp9QeAABwZl1++eVatGhR8Od//OMf6t27dxhbBAAAgFhyKnWiiBsS6/P5jirWSVLJkiXVrl07SVJ6enpwe926dXXZZZc5z0Mza9YsrV69Wt26dQsW6wK/99FHH1VeXp4mTJjg9DsAAED40MMOAAAA0SLiCnbHk5WVpVmzZsnzPF100UVn/PiBHnlt27Y96rHAtrlz557x3wsAAELjyC/3KNgBAAAgUkXcHHYBe/bs0QsvvKD8/Hxt375dM2fO1MaNG/XYY4+d0rDUk7Vq1SpJOuaxS5curXLlygX3AQAA0efIAh2rxAIAACBSRXTBbujQocGfixQpohEjRujBBx88K78vMzNTklSqVKljPp6cnKxff/31hMfIzs5WdnZ28Oe9e/eeuQYCAAAn9LADAABAtIjYIbHVqlWTmSkvL09r167VE088ocGDB6tz587Ky8sLd/OOadiwYSpVqlTwT5UqVcLdJAAA8G/0sAMAAEC0iNiCXYDP51O1atX08MMP66mnntKMGTM0duzYM/57Aj3rAj3tjhRYyeNEHnnkEWVmZgb/bNy48Yy3EwAAnB4WnQAAAEC0iPiC3eECiz8EFog4kwJz1x1rnrqMjAzt3Lnzd+fOS0xMVHJycoE/AAAgMjAkFgAAANEiqgp2mzdvliTFx5/5qfdatGghSfr888+PeiywLbAPAACIPgyJBQAAQLSIuILdkiVLjjksdffu3Ro0aJAkqUOHDqd9/NzcXK1cuVKrV68usL1NmzaqXr26Jk2apCVLlgS379u3T08++aTi4+N1xx13nPbvBQAA4UUPOwAAAESLiFsl9vXXX9e4cePUqlUrVa1aVcWLF9f69ev18ccfa//+/ercubO6desW3H/lypUaPny4JOm3334LbgsU18qVK6dnn302uP+mTZtUp04dVa1aVevWrQtuj4+P17hx49SuXTs1b95cXbt2VXJysqZPn661a9fqqaeeUq1atc7+fwAAADgrmMMOAAAA0SLiCnY333yzMjMz9c0332jevHk6ePCgypQpo2bNmun2229Xly5d5HlecP+tW7dq4sSJBY6xbdu24LaqVasWKNidSKtWrTR//nw99thjmjJlinJyclS3bl09+eST6t69+5k7SQAAEHIMiQUAAEC0iLiCXbNmzdSsWbOT3r9ly5Yys5Pev1q1aifcv3Hjxvrkk09O+ngAACA6MCQWAAAA0SLi5rADAAA4GxgSCwAAgGhBwQ4AAMSEI3vYMSQWAAAAkYqCHQAAiAn0sAMAAEC0oGAHAABiAnPYAQAAIFpQsAMAADGBVWIBAAAQLSjYAQCAmEDBDgAAANGCgh0AAIgJhxfo4uPj5XleGFsDAAAAHB8FOwAAEBMO72HH/HUAAACIZBTsAABATDi8hx0FOwAAAEQyCnYAACAmHF6kY/46AAAARDIKdgAAICYwJBYAAADRgoIdAACICQyJBQAAQLSgYAcAAGICQ2IBAAAQLSjYAQCAmEAPOwAAAEQLCnYAACAmMIcdAAAAogUFOwAAEBMO72HHkFgAAABEMgp2AAAgJtDDDgAAANGCgh0AAIgJLDoBAACAaEHBDgAAxAQWnQAAAEC0oGAHAABiQlJS0jH/DQAAAEQaCnYAACAmVKxYUR07dlRCQoK6desW7uYAAAAAxxUf7gYAAACEyj//+U8dOHBAJUqUCHdTAAAAgOOihx0AAIgZnudRrAMAAEDEo2AHAAAAAAAARBAKdgAAAAAAAEAEoWAHAAAAAAAARBAKdgAAAAAAAEAEoWAHAAAAAAAARBAKdgAAAAAAAEAEoWAHAAAAAAAARBAKdgAAAAAAAEAEoWAHAAAAAAAARBAKdgAAAAAAAEAEoWAHAAAAAAAARJD4cDegMDMzSdLevXvD3BIAAAAAAACEU6A+FKgXnQgFu7No3759kqQqVaqEuSUAAAAAAACIBPv27VOpUqVOuI9nJ1PWw2nJz8/X5s2bVbJkSXmeF+7mQIeq2VWqVNHGjRuVnJwc7uYgCpEhuCJDcEWG4IoMwQX5gSsyBFfRnCEz0759+1S5cmXFxZ14ljp62J1FcXFxOu+888LdDBxDcnJy1L2wEVnIEFyRIbgiQ3BFhuCC/MAVGYKraM3Q7/WsC2DRCQAAAAAAACCCULADAAAAAAAAIggFO8SUxMREPfbYY0pMTAx3UxClyBBckSG4IkNwRYbggvzAFRmCq1jJEItOAAAAAAAAABGEHnYAAAAAAABABKFgBwAAAAAAAEQQCnYAAAAAAABABKFgBwAAAAAAAEQQCnYAAAAAAABABKFgBwAAAACQJJlZuJsAABAFOwAAgLDavHlzuJuAKLdp0ybl5OSEuxmIYrNnz9aQIUOUlZUlz/PC3RwAgCjYIUplZGRo165dyszMDG7Lz88PY4sQbXbu3KkVK1Zow4YN2rVrlyQyhFOzfv16tWrVSmPHjpVEjwScutWrV6tly5a69957tW7dunA3B1Fo7dq16tmzp9q0aaMnnngi3M1BFFq9erWuv/56tWnTRh999JH27dsX7iYhymzevFmvv/66pkyZok8//TTczUEU2rlzp1avXq3t27fL7/dL4nNZAAU7RBW/36/BgwerRYsWatiwoS655BI9/PDD2rt3r+LiiDN+n9/v19/+9jc1b95cV155pS666CLdeOONWrNmDRnCSdu4caNuuOEGzZ07V0899ZQyMjLokYCTlpeXpwEDBqhWrVpatWqVrrrqKiUnJ4e7WYgiZqa///3vqlOnjubMmaOaNWuqXLly4W4WokjgOlSzZk0tWrRIJUqU0Jo1a4LvZXwJhd/j9/v18MMPq169eurXr5+6dOmijh076i9/+Yu2b98uiRzhxPx+vx566CFddtllatSokS6++GLdfffd2rBhQ/BzWaxniE+niBr//Oc/Vbt2bb344otKSUlR3bp1VaRIET3zzDPq27dvuJuHKDBjxgzVqFFDL730kmrXrq0777xTbdq00fz589W3b1/l5uaGu4mIEkWLFtXatWtVo0YNbdy4UcOHD5fETQV+34QJE1S+fHm99tpr6tOnjyZPnqz+/furTJky4W4aosi4ceM0YsQIde7cWWPHjtV7772nAQMGhLtZiBJjxowJXofuvfdezZw5U23atNG+ffs0f/58SeJLKJzQL7/8ojZt2mjs2LFKTU3Viy++qH/84x9q2rSpxo8fT47wuxYvXqxGjRpp1KhRatSokW6//XZdfPHFmjhxolJTUzVjxgxJZEgGRIEPP/zQ/vCHP1ijRo3snXfesd27d5uZWXp6utWpU8c8z7OvvvrKzMzy8/PD2VREoNzcXBs1apSde+65dtVVV9nbb79tO3bsMDOzzMxMa9++vXmeZz/88EOYW4po8dNPP1nNmjVt2LBhVrNmTUtISLBly5aFu1mIYHl5eXbllVea53nWsmVL+/TTT23btm3H3Jf3MRxPfn6+bd261WrVqmVNmjSxrVu3hrtJiCLp6el2ySWXmOd51qlTJ5sxY4bt2rXLzMxGjBhhnufZjBkzzMzM7/eHsaWIdE888YQVKVLEhg0bVuA69P7775vnefbaa6+ZGe9nOL4///nPlpSUZC+88IJt377dzMz27t1rjz76qCUmJtpFF11kaWlpZhbb1yN62CHibdu2Tc8995wOHjyo5557Tl26dFHp0qWVm5urCy64INi77pNPPpFEFR5Hy83N1aJFi1S8eHH97//+r7p16xYcOpScnKxatWrJ5/MxJBYnLSkpSenp6erSpYvuu+8+5ebm6vHHHw93sxCh8vPz5fP51K5dO0lStWrV1K5dO1WoUEFZWVnKzMzUhg0b9OOPP8rv9/M+huPyPE9Lly5Venq6HnzwQVWsWFEHDx7UwoULNXXqVD3++OOaNGlScDgacLh169apQYMGevnll/Xyyy8rNTX1qN6933zzjSRxT4TjWr16tV566SXVqVNHDz/8sCpWrBh8LD8/X+XKlVPVqlUl8bkMx/bjjz9q7Nixatq0qf7yl7+ofPny8vv9KlmypLp27aqWLVtqxYoVwXvrWL4exe6ZI6LZYcPKkpOTVbduXU2dOlXNmzcPPh4fHy9JuuyyyyQp+GZhDEmDCuagaNGiGjhwoJYvX66GDRsW2G/WrFmaNGmSbrzxRlWvXp1hsQg60bXkl19+UXJysvx+v7p27aqmTZtq6tSpwS8OuA5B+k8OAh9YhgwZomrVqmnatGn64osvtGPHDj3//PO69tprVaNGDbVq1UrNmjXTe++9F85mI4Ic61qycuVKmZlKlCgh6dAw6+7du+vWW2/VE088odtuu02dOnXStGnTJDFxd6wzs2COWrVqpREjRqhv376qUqWKJAXve1q3bi1JWrNmjQ4ePBiexiIiHXkdKlOmjIoUKSLP87Ry5UpJh+YiW7RokV544QUlJiYqNzdX3333nbKysiRxHYp1R2bI7/crMTFRf/jDHyRJOTk58vl8kqTatWuraNGikqS5c+dqzJgxkmI3QxTsEFG2bNkiqeC3MUWLFtWgQYN0xRVXBLd5nhfcZ9WqVZKkYsWKHfVcxJ5jZUiSatasKZ/PF1x5aNOmTRo1apQeeOAB7dq1S1u3blXdunV1yy23aP78+crLywt52xEZjpWhwI1G4O9ixYrpwIED8vv9Kl++vO69915J0qOPPhp8buA4iD1HZsjzPOXk5EiSnn/+ee3fv1/Dhw/XnXfeqcGDBysuLk5dunTR5ZdfroULF+rOO+/UxIkTg89B7DnWdSjw/lWhQgVJ0oYNGzR16lQ98MADqlmzptLS0vTBBx/o/vvv18KFC9WnTx9t27ZNcXFxfIkQgw7PUCBHcXFxKl++vKT/vJ8VKVIk+HelSpWUkZGhYsWKkRkc9546Pj5e1113nX744QcNGTJEH3zwgZ566inde++9SktLU/ny5fXHP/5RV1xxhbp27aqdO3dyHYpRx8tQVlaW4uLigj16ExISCnzJGbge+f1+TZw4MbYXmAztCFzg2BYtWmQdO3a0OnXqWI0aNaxPnz7BMevHExjLPmDAAEtKSrLFixeHoqmIUCfK0JHzZ+Tm5tro0aPN8zyrW7eujR8/3iZPnmz33HOPpaSkWI0aNeyDDz4Ix2kgjE4lQ+PGjbMyZcoE5yDLysqyrl27mud5NnDgQLv44outWbNmtmfPnpCfB8LnRBk6fP6V1q1bm+d5Vrt2bXv//fcLPP7qq69alSpVrH79+vbdd9+F/iQQVidzHZo/f76VKlXKunXrZtdee61dddVVRx2nT58+5nme3XXXXSFtP8LvVN7LDrdr1y6rUKGCFS1a1DZs2BCq5iICncznslWrVlm7du3M8zxLSEgIvqd9+OGH9uuvv9rChQuD90V33nmnmTGfXSw5mQx16NDBPM+zv//973bgwAEzM9u5c6e99NJLVrRoUXvrrbesffv2Vrp0aZs7d244TiMiULBD2OTn55vf77cXX3zREhMTrU6dOnbddddZ8+bNzefzWYkSJeyzzz4rsP/hcnNzzczsyiuvtLp161pmZqb5/X7eDGKIS4YWLVpkr7/++lHHGzt2rCUkJNg999wTfPNA4XWqGQpcd0aNGmUpKSm2adOm4GMfffSRJSUlWVxcnJUvX97uv/9+27lzZ8jPCaF1qhkyM1u+fLldfvnltnTp0uC2vLw8MzPbvXu3/fWvfzWfz8ek3THiVDO0atUqa9Kkifl8PvM8z0aOHGlmZtnZ2cEcbd++3UqUKGHlypWzNWvWhOW8EDqncx06XOALg86dO1uZMmXs22+/DVXTESFOJ0OZmZm2cuVKGzlypHXo0MG2bNlS4PFdu3ZZ+fLlzfM8+/HHH0N5OgiDk81Q4J4mLS3NzjvvPIuPj7dWrVrZ/fffb6mpqZaSkmLt2rWz9evX2+OPP26e5wWzF4v3QxTsEFYbN260WrVqWaNGjWzBggXB7WPGjLESJUpYlSpV7NNPPz3u8wM3pHfccYeZFXwRBz5Yo3A71Qwd60If+IBjZrZ06VIrXbq0NW/ePKZXJIolp3MdGjhwoFWvXj348/Dhwy0pKSn4Afqmm24KWfsRfqeToeXLlx/3xvPtt982z/OsZ8+eZ7XdiBynmqHHH3/cypQpY57n2d/+9rcCx8rKyjIzs9TUVKtYsaL9/PPPoTkJhJXrPXV2drbddddd5nmezZo1y8xie2XGWHSqGfL7/XbgwAG75JJLjvosdvDgQTM71NvX5/OdsGCMwuNkMvTJJ58Et0+fPt06duxonudZcnKylS1b1vr37x98H3v11VfN8zx75ZVXQn4ukYKCHcJq+PDh5nmevfHGG0c9FujB0qZNm2AvhCM/3EyaNMk8z7OxY8cGt23ZssXGjRtn7777bvDFjsLrZDLUunXr42YoIFC027x5s3meZ61atQrebKBwO9UMmZk98sgj1rBhQ5s0aZJdcMEF5nmeXXPNNfbMM89YrVq1LD4+3n744Qczi81vA2PN6WToWAJfNH3wwQfmeZ4NHTr0rLQXkedkMxSY/mPDhg3WokUL8zzPrrvuOktPTzczs5ycnODzLr/8citRooRt3rw5NCeBsHK5Hwr8++mnnzbP82zIkCGhaTQiyum8l61du9aSk5Pt2WefNbND99OHF3oDxRimLooNJ5uh//u//wtuz83NtVWrVtns2bOPer8aOXKkeZ5nX3311dluesSK0Zn7EG5HrvJSs2ZNSYcmVLZ/TzjZuXNn9ezZU7Nnz9b777+v3377LThhZWDi5S+//FKlS5dW27ZtlZ2drZkzZ+rBBx9Ur169NGrUKGVnZ4fwrBBKp5KhOXPmFMiQHTbpbeA4Pp9PO3fu1ODBgyVJvXr1Cq5QhMLpdDIUWDlv165dWrx4sW6//Xb5fD4NHz5co0eP1kMPPaQBAwbI7/erd+/eklgIpzA73evQ8Y4THx+v3bt3a9SoUfI8T1dfffVZPgOE26lm6KOPPtKBAwdUpUoV9e3bV7Vr19aXX36pcePGSTq0cEBmZqZGjhypZcuWqVevXqpUqVJoTwoh5XI/dKRGjRopPj4+uHJsrK7KGGtc3st2796tokWL6r333tO2bdvk8/kUFxenjIwMvfLKK5ozZ466du2qBg0ahPakEFKnmqEPP/wwmCHP81SjRg21bNmywPtVRkaGJk6cqKpVq6p69eoxez2iYIewOHKVlx9//FFSwZWsypcvr27duqlOnTqaPHmyli1bFtw/sM+iRYtUrVo1rVmzRoMGDdLtt9+u6dOna/jw4ZozZ46Sk5NDdEYINZcMHX6TGhcXJ7/fr7S0NA0ePFiTJ09W9+7ddc0114ToTBAup5Ohn376SZLUv39/NWjQQL169dJbb72lgQMHqnr16pKkW2+9Ve3bt1fnzp1DeDYIB9f3ssOPE7gODRgwQLNmzdJ9991XYHV0FE4uGbrppps0dOhQlStXTk8//bT++Mc/avDgwerXr58GDRqkGjVqqGvXrqE9IYTcmbgOHX5flJeXF1y5MWZXZYwxLvdDF198sZo3b65vv/1Wt912myZNmqS33npLf/vb3zRo0CBVq1ZNffr0Ce0JIeRcrkM+n6/Ac81MCxYs0IABA7RixQoNHDhQ55xzTuxej8LVtQ+xLdBVev78+eZ5nrVu3To4/PDwLvoHDx60J5980uLi4mzUqFEFHl+xYoWVKFHCzj//fGvYsKF5nmc9evSwzMzMEJ8NwsE1Qzk5OZaenm4TJkywnj17Boc19uvXj6GwMcIlQ2ZmK1eutOzs7ALHCwytPnxeRBReZ+I6tGbNGhs3bpzdddddwevQAw88wHUoRrhehwLPvfbaa83zPEtKSrKyZcva3XffbXv37g3diSBszsQ9dUBubq55nmfVq1c/agEBFF6u16EFCxZYp06dzPO84J+EhATr2bMn16EYcaauQyNGjLAePXpYzZo1LT4+3h555JEC99qxiIIdwq5Zs2ZWokQJmzx5spkdffMwa9YsK1WqlLVt27bA9tdffz34ptC8eXPmRohhp5uhwYMHW0pKip133nmWmpoanHMMsed0M2TGpNw45HQzNGLECEtJSbEKFSrYDTfc8Lvz3KHwcrkOmR2aS2rJkiW2fv36s95WRCbXDO3YscMef/xx++mnn856WxGZTjdDWVlZNnbsWHv55Zft2WeftV9++SVkbUZkcbkOpaamWuXKle3GG2/kfujfKNgh7N55553gpMmBb/MO/wCcm5trF154oZ177rm2adOm4Pbvv//e2rRpYzNmzAh1kxFhTjdDmzZtss8++4xCHU47Q0DA6WZo8+bN9uGHHxaYgBmxiesQXJEhuDqdDPHFJQ53OhkKjEzZu3cvK5sfIUYHAuNMMzN9//33Sk9P1+7du39338O1a9dO1113nT7++GO99tprkg6Ng8/Pz1d+fr7i4+NVpUoVlShRosBElA0bNtS//vUvpaamnvHzQeiFI0OVK1dW27ZtVa9evTN/Qgi5cGQIhUs4MlSpUiVdf/31ql+//hk/H4Qe1yG4IkNwFeoMxezcYoVYqDMUmMeuZMmSqlWr1lk4oygW+hohCpvx48dbzZo1LTk52RITE61Bgwb2xhtv2IEDB8zsPxX1I7vD/vrrr8FhG99++62VLFnSEhISbObMmQX2S0tLs5IlS9pNN91kfr//qOMg+pEhuCJDcEWG4IoMwRUZgisyBFdkKLJQsMNpy8jIsD59+pjneXb11Vfb/fffbwMGDLCSJUtakSJFrF+/fsGJRg+fgH337t02bdo069Chg/Xo0SPYVXbixInmeZ4lJyfb0KFD7ZtvvrEJEyZYy5YtrVy5cvbFF1+E5Txx9pAhuCJDcEWG4IoMwRUZgisyBFdkKDJRsMNp+/jjj61EiRJ2yy232MqVK4Pbv/zyS2vQoIF5nmeDBg0ys0MV+Ly8PEtLS7PevXtbcnKyFS1a1CZNmlTgmOPHjw+u+JqYmGjx8fF2zjnnBCetROFChuCKDMEVGYIrMgRXZAiuyBBckaHIRMEOp8Xv91vHjh0tLi7OVq9eHdxmdmiVoJEjRwZXcP3222/NzGzVqlXWoUMH8zzPHnzwwQLdXw+v0u/YscPeeuste/HFF238+PF0ky2kyBBckSG4IkNwRYbgigzBFRmCKzIUuSjY4ZQFXmTt27e3MmXK2IoVK4LbAi/sKVOmWFJSknmeZy1atAg+d8KECbZhw4bgz7m5ucc8Ngo3MgRXZAiuyBBckSG4IkNwRYbgigxFNpZ0wQlt27ZNe/fu1W+//VZg+8GDB1WxYkVlZGQoPT1dnufJzIKrBPl8PhUvXlwlSpTQvHnzNHPmTEnSHXfcoSpVqsjv9wdXiTmc53mhOTGEDBmCKzIEV2QIrsgQXJEhuCJDcEWGog8FOxzT3r171adPHzVt2lQXXXSRrrzySr366qsyM3mep2LFiql58+aSpKeeekrff/+9PM+T3+/Xv/71Lz300EO644479Pzzz0uSPv/88+CxzUw+n48lwAs5MgRXZAiuyBBckSG4IkNwRYbgigxFr/jf3wWx5uuvv1aPHj20Z88etWjRQklJSZo3b57uu+8+LV26VE888YQqVqyobt266auvvtIbb7yhjh07qkOHDtq3b5+WLFmigwcP6pprrlHVqlVVpkwZ7dixQ5KUn5/PizkGkCG4IkNwRYbgigzBFRmCKzIEV2QoyoVu9C2iRe/eva1o0aI2ceJE27dvn5mZrVixwq699lrzPM/uv/9+27x5s5mZpaen27Bhw6x06dJWoUIFK126tHXs2NFWrFhhZmYbNmywypUrW+PGjcN2Pgg9MgRXZAiuyBBckSG4IkNwRYbgigxFNwp2KGD58uVWtmxZa9u2bXBbYJWXpUuXWvv27a1YsWL20ksvFXjepk2bbPny5bZs2bIC27du3WopKSnWq1cvM2PiyVhAhuCKDMEVGYIrMgRXZAiuyBBckaHoR/9FFJCYmKj9+/fr3HPPVX5+vvLy8uTz+SRJ9erV0yOPPKLExERNnDhRS5culST5/X5VrlxZderU0UUXXVTgeCNHjlRmZqauvvpqSUw8GQvIEFyRIbgiQ3BFhuCKDMEVGYIrMhT9KNihgOzsbJUrV06rV69WXFxcgZVePM/TFVdcoXvuuUeLFy/Wxx9/HJxk8kgrVqzQ008/rdGjR+vGG29Up06dQnkaCCMyBFdkCK7IEFyRIbgiQ3BFhuCKDBUC4evch0iUk5NjDRs2NM/zLC0tzcz+0202YMmSJXb++edby5Ytg+PdA2bPnm1/+tOfrFGjRhYXF2dt27a11atXh6z9CD8yBFdkCK7IEFyRIbgiQ3BFhuCKDEU/etghyO/3q0iRIrr77rslSaNGjZKko6rs559/vlq2bKkFCxZo//79kg6tECNJW7du1XfffadixYpp8uTJ+uyzz1S9evUQngXCiQzBFRmCKzIEV2QIrsgQXJEhuCJDhUS4K4aIHH6/38zMsrKyrFatWpaYmGgzZswws6Mr8UOHDjXP82zixIlmVnDCyfT09NA0GBGHDMEVGYIrMgRXZAiuyBBckSG4IkOFAz3sCrFNmzad1H5mJkmKizsUh8TERD322GPKycnRsGHDtHfvXvl8PuXl5Sk3N1eSVLNmTUmHKvJSwQknL7jggjN2DggvMgRXZAiuyBBckSG4IkNwRYbgigzFqPDVCnG2LFq0yJo0aWI33XSTrV+/3syOv+Ty4dszMjJsyZIllpuba2Zmqamp5nme9ezZ07Kzs4P7bd++3Tp06GAlS5ZkDHshRYbgigzBFRmCKzIEV2QIrsgQXJGh2EbBrhDJzs62MWPGWEpKinmeZ5UqVbIJEyb87vNycnIsLS3NevfubZdeeqlNnz7dzMy2bNlijRs3Ns/z7Oqrr7apU6fau+++a71797akpCT77//+77N8Rgg1MgRXZAiuyBBckSG4IkNwRYbgigzBjIJdoZGVlWWvvfaalSpVypKTk23AgAGWkpJirVq1smXLlpnZsSvx6enpNnToULvgggvM8zwbMGBAcLy7mdkPP/xg/fr1M5/PZ57nmc/ns8TERPvrX/9aYD9EPzIEV2QIrsgQXJEhuCJDcEWG4IoMIYCCXSHSs2dPa9y4sa1cudLMzPr3728+n8+GDRtmOTk5R+2fnZ1tL7zwQrDKfngX2CNfsHPmzLEpU6bY2LFjbePGjWf3RBA2ZAiuyBBckSG4IkNwRYbgigzBFRmCmZln9u9ZCRE1zKzARJB+v18+n0/r1q1TXl6eatSoITPT119/rR49eigxMVGjR49Ws2bNjjrWwoULJUlXXHFF8Fie5wUnqTzyd6FwIENwRYbgigzBFRmCKzIEV2QIrsgQTihUlUGcGdnZ2bZnzx7Lysr63X0PHDhgw4cPN8/zrH///paRkWFmx5+k8sjlnVE4kSG4IkNwRYbgigzBFRmCKzIEV2QIvycu3AVDnLyRI0eqdevWatGihWrXrq3hw4dr/fr1kg5Vz49UrFgxderUSVdeeaWmTJmi2bNnS9Jxq+o+n+/sNR4RgQzBFRmCKzIEV2QIrsgQXJEhuCJDOCnhrhji9y1cuNAaN25s8fHxVq9ePWvWrJlVqVLFPM+z9u3bn/C5ubm59uabb1piYqLdfPPNtm7duuB2xA4yBFdkCK7IEFyRIbgiQ3BFhuCKDOFUULCLcGlpaXbppZda7dq1bfTo0cFJITds2GB16tQxz/Ns2rRpZnb0ZJIBv/76q916661WtGhRe/XVV4Pb9+7dazt37jzhcxH9yBBckSG4IkNwRYbgigzBFRmCKzKEU0XBLoLt2bPHrr32WitevLhNmTIluD1QQZ86dWpwDPvvmTlzppUvX95atGhhixcvttmzZ9sdd9xhDzzwAC/oQowMwRUZgisyBFdkCK7IEFyRIbgiQzgdzGEXYfLz84P/LlWqlCpUqKAJEybolltukXRoZZfAePTzzz9fkpSSkhJ87EiB8e9XX321evbsqa+//lr9+vXTrbfeqokTJ6pIkSIFfieiHxmCKzIEV2QIrsgQXJEhuCJDcEWG4Co+3A3AITt37lS5cuWCSy4HlnMeNmyYihcvHtzv8EklMzMzJUlly5Y96rGAwAVgx44dysnJUW5urhYsWKCmTZtq5syZuvzyy8/aOSG0yBBckSG4IkNwRYbgigzBFRmCKzKEM4WCXZht3rxZjz76qH744QfFxcXp0ksvVd++fXXppZdKkipUqHDclV8WL14sSapXr95xj5+fn6/PPvtMTz/9tObNm6dzzjlHL7zwgm699dYzfzIICzIEV2QIrsgQXJEhuCJDcEWG4IoM4YwL/Shc5Ofnm5nZpEmTLCUlxSpVqmQtW7a0Sy+91BISEqxChQr27rvvHvf5gXHunTp1svPOO8+2bNliZseeXDIrK8uGDBliSUlJ9vDDD5+Fs0E4kCG4IkNwRYbgigzBFRmCKzIEV2QIZxMFuzDZv3+/NWzY0OrUqWOffPKJ+f1+y8vLs0mTJlmRIkWsZMmSNm/evOAF4Eh5eXlWpkwZ69y5s/n9/gL7Bf4d+PuXX34JrhiDwoMMwRUZgisyBFdkCK7IEFyRIbgiQzhbKNiFyeuvv26e59nTTz8d3Baoor/88suWnJxsV111lS1fvvyYz587d655nmfPPfdccNuePXts8uTJ9s4775iZHfeCgMKBDMEVGYIrMgRXZAiuyBBckSG4IkM4W1glNsQCq7bk5uZKkurXr1/gZ0m67bbbdNdddyktLU3vvfeeDhw4cNTzv/zyS0lS69atJUlpaWkaMmSIunfvrgceeEAZGRnHHR+P6EaG4IoMwRUZgisyBFdkCK7IEFyRIZxtFOzOslWrVmn79u3BF2ZgpZjAz998840kqUiRIsHHUlJS1KVLF9WvX18TJ07U6tWrg8ezfy/vPG/ePF144YXav3+/hg8frh49eujll19W3759tW7dOpUuXTpk54iziwzBFRmCKzIEV2QIrsgQXJEhuCJDCLnwde4r3KZPn25Nmza1ypUrW7FixaxZs2bB7qxmh8aee55nbdq0CU4seXg317y8PHvyyScLdI3Ny8szM7Ndu3ZZmTJlrGrVqvZf//Vf5nmeXXPNNbZq1aoQniHONjIEV2QIrsgQXJEhuCJDcEWG4IoMIVwo2J1hmzdvtj/96U8WFxdnDRs2tJtuuslSU1PN8zxLSEiwzz//3PLz8y07O9tuuOEGK1WqlL399tsFjhF4cS9YsMBSUlKsfv36BR7/4IMPzPM88zzPatasaR9++GHIzg9nHxmCKzIEV2QIrsgQXJEhuCJDcEWGEG4U7M6gLVu2WPfu3a1s2bL2yCOPFJhU8plnnrEiRYrY9ddfb2ZmOTk59u6771pSUpJ16tTJVq9ebWZHL9/cqFEjq1ixov3888/BbZs3b7Y6derYK6+8EoKzQiiRIbgiQ3BFhuCKDMEVGYIrMgRXZAiRgILdGfTmm2+a53k2cODAYBfXgO3bt9uFF15oCQkJwW6yGzdutK5du1pCQoL9z//8T7D6npuba7m5uWZmduONN1rlypXt4MGDZvafrrOBx1G4kCG4IkNwRYbgigzBFRmCKzIEV2QIkYCC3Rm0aNEiGz58ePDFGfg78EK85pprrFq1arZ169bgc9LS0qxatWpWtmxZe/PNNwscb9WqVXbuuedas2bNLCsr66gKPQofMgRXZAiuyBBckSG4IkNwRYbgigwhElCwO4Py8/Nt165dwX8fLi8vz6pXr25169a1/fv3F3hs2rRp5nmeFSlSxJ5//nlbvHixvf/++5aammrJyck2adKkkJ0DwosMwRUZgisyBFdkCK7IEFyRIbgiQ4gEFOxCZO3atVamTBnr0aOHmR09nn306NFWv3598zzPihYtakWLFrVixYrZ888/H/rGIiKRIbgiQ3BFhuCKDMEVGYIrMgRXZAihEi+cVfn5+YqLi9PSpUuVkZGhJk2aFNge0KtXL3Xp0kVvv/229u7dK5/Pp549e6ps2bLhajoiBBmCKzIEV2QIrsgQXJEhuCJDcEWGEGoU7M6ywAt3zpw5SkhIUOPGjSVJ8fGH/uuzs7MVHx8vn8+nUqVK6c9//nPY2orIRIbgigzBFRmCKzIEV2QIrsgQXJEhhJpnZhbuRhR2eXl5uuKKK3Tw4EGtWLFCkpSTk6P58+frm2++UatWrdS0adMwtxKRjAzBFRmCKzIEV2QIrsgQXJEhuCJDCCV62IXAzz//rPT0dPXs2VOStHjxYn388ccaM2aMNm3apI8++ijMLUSkI0NwRYbgigzBFRmCKzIEV2QIrsgQQomC3VlkZvI8T4sWLdKBAwdUtmxZTZw4Ua+88ooWLVqk66+/XmlpaapWrVq4m4oIRYbgigzBFRmCKzIEV2QIrsgQXJEhhAMFu7PI8zxJ0ty5c5Wfn6+ZM2dq0aJFuuCCC/TFF1+oTZs2YW4hIh0ZgisyBFdkCK7IEFyRIbgiQ3BFhhAOcb+/C1xkZWVpw4YNkg51nx0xYoSWL1/OCxonjQzBFRmCKzIEV2QIrsgQXJEhuCJDCDUWnQiBF198Ubt27dLgwYOVmJgY7uYgCpEhuCJDcEWG4IoMwRUZgisyBFdkCKFEwS4EAuPdgdNFhuCKDMEVGYIrMgRXZAiuyBBckSGEEgU7AAAAAAAAIIIwhx0AAAAAAAAQQSjYAQAAAAAAABGEgh0AAAAAAAAQQSjYAQAAAAAAABGEgh0AAAAAAAAQQSjYAQAAAAAAABGEgh0AAAAAAAAQQSjYAQAAAAAAABGEgh0AAAAAAAAQQSjYAQAAAAAAABGEgh0AAAAAAAAQQf4fCZQHu6CD7G4AAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "display.Image('nonlocal_cli__regionedu_calpoly_marine_morro_salt.png')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "89be8444-a663-4996-96eb-9e3371711a3b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<IPython.core.display.Image object>"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "display.Image('nonlocal_cli__regionsccoos_ucsd_salt.png')"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

From 5a0c116b29fa28eff5d74e598b135b1ddad8c37e Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Tue, 3 Jan 2023 10:47:03 -0600
Subject: [PATCH 08/19] WIP: adding kwargs_xarray

---
 docs/index.rst                      | 4 +---
 ocean_model_skill_assessor/CLI.py   | 9 +++++++++
 ocean_model_skill_assessor/main.py  | 6 +++++-
 ocean_model_skill_assessor/utils.py | 2 +-
 4 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/docs/index.rst b/docs/index.rst
index b9cd7d0..dbcc2b5 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -9,11 +9,9 @@ Welcome to ocean-model-skill-assessor's documentation!
 .. toctree::
    :maxdepth: 3
 
+   demo.md
    cli.md
    create_vocabs.md
-   .. Demo-AK.md
-   .. Demo-CA
-   .. Demo_workflows
    api
    GitHub repository <https://github.com/axiom-data-science/ocean-model-skill-assessor>
 
diff --git a/ocean_model_skill_assessor/CLI.py b/ocean_model_skill_assessor/CLI.py
index 4a674ee..6017f87 100644
--- a/ocean_model_skill_assessor/CLI.py
+++ b/ocean_model_skill_assessor/CLI.py
@@ -88,6 +88,13 @@ def main():
         help="Max number of datasets from input catalog(s) to use.",
     )
 
+    parser.add_argument(
+        "--kwargs_xarray",
+        nargs="*",
+        action=ParseKwargs,
+        help="Input keyword arguments to be passed onto xarray open_mfdataset.",
+    )
+
     args = parser.parse_args()
 
     # Make a catalog.
@@ -101,6 +108,7 @@ def main():
             kwargs_search=args.kwargs_search,
             vocab=args.vocab_name,
             save_cat=True,
+            kwargs_xarray=args.kwargs_xarray,
         )
 
     # Print path for project name.
@@ -120,4 +128,5 @@ def main():
             key_variable=args.key,
             model_path=args.model_path,
             ndatasets=args.ndatasets,
+            kwargs_xarray=args.kwargs_xarray,
         )
diff --git a/ocean_model_skill_assessor/main.py b/ocean_model_skill_assessor/main.py
index d19aa92..f7fd36d 100644
--- a/ocean_model_skill_assessor/main.py
+++ b/ocean_model_skill_assessor/main.py
@@ -251,6 +251,7 @@ def run(
     model_path: str,
     vocabs: Union[str, Vocab, Sequence],
     ndatasets: Optional[int] = None,
+    kwargs_xarray: Optional[Dict] = None,
 ):
     """Run the model-data comparison.
 
@@ -270,6 +271,8 @@ def run(
         Criteria to use to map from variable to attributes describing the variable. This is to be used with a key representing what variable to search for. This input is for the name of one or more existing vocabularies which are stored in a user application cache.
     ndatasets : int, optional
         Max number of datasets from each input catalog to use.
+    kwargs_xarray : dict, optional
+        Keyword arguments to pass on to xr.open_mfdataset call.
     """
 
     # After this, we have a single Vocab object with vocab stored in vocab.vocab
@@ -307,7 +310,7 @@ def run(
         print(f"Note that there are {ndata} datasets to use. This might take awhile.")
 
     # read in model output
-    dsm = xr.open_mfdataset(cfp.astype(model_path, list), preprocess=em.preprocess)
+    dsm = xr.open_mfdataset(cfp.astype(model_path, list), preprocess=em.preprocess, **kwargs_xarray)
 
     # use only one variable from model
     dam = dsm.cf[key_variable]
@@ -410,6 +413,7 @@ def run(
             # instead turn off time zone for data
 
             if model_var.size == 0:
+                import pdb; pdb.set_trace()
                 # model output isn't available to match data
                 # data must not be in the space/time range of model
                 maps.pop(-1)
diff --git a/ocean_model_skill_assessor/utils.py b/ocean_model_skill_assessor/utils.py
index aa26803..972cc1a 100644
--- a/ocean_model_skill_assessor/utils.py
+++ b/ocean_model_skill_assessor/utils.py
@@ -144,7 +144,7 @@ def kwargs_search_from_model(kwargs_search: Dict[str, Union[str, float]]) -> dic
 
         # read in model output
         dsm = xr.open_mfdataset(
-            cfp.astype(kwargs_search["model_path"], list), preprocess=em.preprocess
+            cfp.astype(kwargs_search["model_path"], list), preprocess=em.preprocess, **kwargs_xarray
         )
 
         kwargs_search.pop("model_path")

From d8f44b49760484052e3f46a62327e1971f217915 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Mon, 9 Jan 2023 14:24:51 -0600
Subject: [PATCH 09/19] improvements and changes in cli

inputs to CLI are better checked as float or ints
inputs to CLI as lists are now only split by first = so filenames can have = in them
model_path is now model_name since models have their own catalogs now
local_catalog has kwargs_open instead of kwargs_xarray since might need inputs for read_csv or others
can pass arguments to the map plot with kwargs_map
---
 ocean_model_skill_assessor/CLI.py | 47 ++++++++++++++++++++++++++-----
 1 file changed, 40 insertions(+), 7 deletions(-)

diff --git a/ocean_model_skill_assessor/CLI.py b/ocean_model_skill_assessor/CLI.py
index 6017f87..f33096f 100644
--- a/ocean_model_skill_assessor/CLI.py
+++ b/ocean_model_skill_assessor/CLI.py
@@ -6,6 +6,18 @@
 
 import ocean_model_skill_assessor as omsa
 
+def is_int(s):
+    try:
+        int(s)
+        return True
+    except (ValueError, TypeError):
+        return False
+def is_float(s):
+    try:
+        float(s)
+        return True
+    except (ValueError, TypeError):
+        return False
 
 # https://sumit-ghosh.com/articles/parsing-dictionary-key-value-pairs-kwargs-argparse-python/
 class ParseKwargs(argparse.Action):
@@ -15,11 +27,17 @@ def __call__(self, parser, namespace, values, option_string=None):
         """With can user can input dicts on CLI."""
         setattr(namespace, self.dest, dict())
         for value in values:
-            key, value = value.split("=")
+            # maxsplit helps in case righthand side of input has = in it, like filenames can have
+            key, value = value.split("=", maxsplit=1)
             # catch list case
             if value.startswith("[") and value.endswith("]"):
                 # if "[" in value and "]" in value:
                 value = value.strip("][").split(",")
+            # change numbers to numbers but with attention to decimals and negative numbers
+            if is_int(value):
+                value = int(value)
+            elif is_float(value):
+                value = float(value)
             getattr(namespace, self.dest)[key] = value
 
 
@@ -81,7 +99,7 @@ def main():
     parser.add_argument(
         "--key", help="Key from vocab representing the variable to compare."
     )
-    parser.add_argument("--model_path", help="Path for model output.")
+    parser.add_argument("--model_name", help="Name of catalog for model output, created in a `make_Catalog` command.")
     parser.add_argument(
         "--ndatasets",
         type=int,
@@ -89,10 +107,24 @@ def main():
     )
 
     parser.add_argument(
-        "--kwargs_xarray",
+        "--kwargs_open",
         nargs="*",
         action=ParseKwargs,
-        help="Input keyword arguments to be passed onto xarray open_mfdataset.",
+        help="Input keyword arguments to be passed onto xarray open_mfdataset or pandas read_csv.",
+    )
+
+    parser.add_argument(
+        "--metadata",
+        nargs="*",
+        action=ParseKwargs,
+        help="Metadata to be passed into catalog.",
+    )
+
+    parser.add_argument(
+        "--kwargs_map",
+        nargs="*",
+        action=ParseKwargs,
+        help="Input keyword arguments to be passed onto map plot.",
     )
 
     args = parser.parse_args()
@@ -104,11 +136,12 @@ def main():
             project_name=args.project_name,
             catalog_name=args.catalog_name,
             description=args.description,
+            metadata=args.metadata,
             kwargs=args.kwargs,
             kwargs_search=args.kwargs_search,
+            kwargs_open=args.kwargs_open,
             vocab=args.vocab_name,
             save_cat=True,
-            kwargs_xarray=args.kwargs_xarray,
         )
 
     # Print path for project name.
@@ -126,7 +159,7 @@ def main():
             catalogs=args.catalog_names,
             vocabs=args.vocab_names,
             key_variable=args.key,
-            model_path=args.model_path,
+            model_name=args.model_name,
             ndatasets=args.ndatasets,
-            kwargs_xarray=args.kwargs_xarray,
+            kwargs_map=args.kwargs_map,
         )

From c70f8fdaa58a473e5f8fa388e3de75c3545b6972 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Mon, 9 Jan 2023 15:37:49 -0600
Subject: [PATCH 10/19] tons of changes to main

make_local_catalogs
* separated metadata for sources, which could input min/max lon/lat from catalog level metadata
* can input kwargs_open for datasets with read_csv but is also used if setting up a model catalog

make_catalog and run access the model through a catalog now

a full demo works now
---
 ocean_model_skill_assessor/main.py | 206 +++++++++++++++++++++--------
 1 file changed, 153 insertions(+), 53 deletions(-)

diff --git a/ocean_model_skill_assessor/main.py b/ocean_model_skill_assessor/main.py
index f7fd36d..7b26ab1 100644
--- a/ocean_model_skill_assessor/main.py
+++ b/ocean_model_skill_assessor/main.py
@@ -10,7 +10,7 @@
 from typing import Any, DefaultDict, Dict, List, Optional, Union
 
 import cf_pandas as cfp
-import cf_xarray
+import cf_xarray as cfx
 import extract_model as em
 import intake
 import numpy as np
@@ -42,9 +42,15 @@ def make_local_catalog(
     name: str = "local_catalog",
     description: str = "Catalog of user files.",
     metadata: dict = None,
+    metadata_catalog: dict = None,
     skip_entry_metadata: bool = False,
+    kwargs_open: Optional[Dict] = None,
 ) -> Catalog:
-    """Make an intake catalog from specified data files.
+    """Make an intake catalog from specified data files, including model output locations.
+    
+    Pass keywords for xarray for model output into the catalog through kwargs_xarray.
+    
+    kwargs_open and metadata must be the same for all filenames. If it is not, make multiple catalogs and you can input them individually into the run command.
 
     Parameters
     ----------
@@ -55,40 +61,129 @@ def make_local_catalog(
     description : str, optional
         Description for catalog.
     metadata : dict, optional
+        Metadata for individual source. If input dataset does not include the longitude and latitude position(s), you will need to include it in the metadata as keys `minLongitude`, `minLatitude`, `maxLongitude`, `maxLatitude`.
+    metadata_catalog : dict, optional
         Metadata for catalog.
+    kwargs_open : dict, optional
+        Keyword arguments to pass on to local catalof for model for xr.open_mfdataset call or pandas open_csv.
     skip_entry_metadata : bool, optional
-        This is useful for testing in which case we don't want to actually read the file.
+        This is useful for testing in which case we don't want to actually read the file. If inputting kwargs_xarray, you may want to set this to True since you are presumably making a catalog file for a model.
 
     Returns
     -------
     Catalog
         Intake catalog with an entry for each dataset represented by a filename.
+    
+    Examples
+    --------
+    
+    Make catalog to represent local or remote files with specific locations:
+    
+    >>> make_local_catalog([filename1, filename2])
+    
+    Make catalog to represent model output:
+    
+    >>> make_local_catalog([model output location(s)], skip_entry_metadata=True, kwargs_open={"drop_variables": "tau"})
     """
+    
+    metadata = metadata or {}
+    metadata_catalog = metadata_catalog or {}
+    
+    kwargs_open = kwargs_open or {}
+    
+    # if any of kwargs_open came in with "None" instead of None because of CLI, change back to None
+    kwargs_open.update({key: None for key, val in kwargs_open.items() if val == "None"})
 
     sources = []
     for filename in filenames:
         mtype = mimetypes.guess_type(filename)[0]
-        if (mtype is not None and "csv" in mtype) or ".csv" in filename:
-            source = getattr(intake, "open_csv")(filename)
-        elif (mtype is not None and "netcdf" in mtype) or ".netcdf" in filename:
-            source = getattr(intake, "open_netcdf")(filename)
+        if (mtype is not None and ("csv" in mtype or "text" in mtype)) or "csv" in filename or "text" in filename:
+            source = getattr(intake, "open_csv")(filename, csv_kwargs=kwargs_open)
+        elif "thredds" in filename and "dodsC" in filename:
+            # use netcdf4 engine if not input in kwargs_xarray
+            kwargs_open.setdefault("engine", "netcdf4")
+            source = getattr(intake, "open_opendap")(filename, **kwargs_open)
+        elif (mtype is not None and "netcdf" in mtype) or "netcdf" in filename or ".nc" in filename:
+            source = getattr(intake, "open_netcdf")(filename, **kwargs_open)
+        
+        # combine input metadata with source metadata
+        source.metadata.update(metadata)
+        
+        sources.append(source)
+
+    # create dictionary of catalog entries
+    entries = {
+        PurePath(source.urlpath).stem: LocalCatalogEntry(
+            name=PurePath(source.urlpath).stem,
+            description=source.description if source.description is not None else "",
+            driver=source._yaml()["sources"][source.name]["driver"],
+            args=source._yaml()["sources"][source.name]["args"],
+            metadata=source.metadata,
+            direct_access="allow",
+        )
+        for i, source in enumerate(sources)
+    }
+
+    # create catalog
+    cat = Catalog.from_dict(
+        entries,
+        name=name,
+        description=description,
+        metadata=metadata_catalog,
+    )
+
+    # now that catalog is made, go through sources and add metadata
+    for source in list(cat):
         if not skip_entry_metadata:
-            dd = source.read()
+            dd = cat[source].read()
+
+            # only read lon/lat from file if didn't input lon/lat info
+            if cat[source].metadata.keys() >= {
+                "maxLongitude",
+                "minLongitude",
+                "minLatitude",
+                "maxLatitude",
+            }:
+                dd['longitude'] = cat[source].metadata["minLongitude"]
+                dd['latitude'] = cat[source].metadata["minLatitude"]
+                cat[source].metadata = {
+                    "minLongitude": cat[source].metadata["minLongitude"],
+                    "minLatitude": cat[source].metadata["minLatitude"],
+                    "maxLongitude": cat[source].metadata["minLongitude"],
+                    "maxLatitude": cat[source].metadata["minLatitude"],
+                }
+
+            else:
+                metadata = {
+                    "minLongitude": float(dd.cf["longitude"].min()),
+                    "minLatitude": float(dd.cf["latitude"].min()),
+                    "maxLongitude": float(dd.cf["longitude"].max()),
+                    "maxLatitude": float(dd.cf["latitude"].max()),
+                }
+
             # set up some basic metadata for each source
-            source.metadata = {
-                "minLongitude": float(dd.cf["longitude"].min()),
-                "minLatitude": float(dd.cf["latitude"].min()),
-                "maxLongitude": float(dd.cf["longitude"].max()),
-                "maxLatitude": float(dd.cf["latitude"].max()),
+            dd.cf["T"] = pd.to_datetime(dd.cf["T"])
+            dd.set_index(dd.cf["T"], inplace=True)
+            if dd.index.tz is not None:
+                warnings.warn(
+                    f"Dataset {source} had a timezone {dd.index.tz} which is being removed. Make sure the timezone matches the model output.",
+                    RuntimeWarning,
+                )
+                dd.index = dd.index.tz_convert(None)
+                dd.cf["T"] = dd.index
+            metadata.update({
                 "minTime": str(dd.cf["T"].min()),
                 "maxTime": str(dd.cf["T"].max()),
-            }
-        sources.append(source)
+            })
+
+            cat[source].metadata.update(metadata)
+            cat[source]._entry._metadata.update(metadata)
 
     # create dictionary of catalog entries
+    sources = [cat[source] for source in list(cat)]
     entries = {
-        PurePath(source._urlpath).stem: LocalCatalogEntry(
-            name=PurePath(source._urlpath).stem,
+        PurePath(source.urlpath).stem: LocalCatalogEntry(
+            name=PurePath(source.urlpath).stem,
             description=source.description if source.description is not None else "",
             driver=source._yaml()["sources"][source.name]["driver"],
             args=source._yaml()["sources"][source.name]["args"],
@@ -103,8 +198,9 @@ def make_local_catalog(
         entries,
         name=name,
         description=description,
-        metadata=metadata,
+        metadata=metadata_catalog,
     )
+
     return cat
 
 
@@ -116,6 +212,7 @@ def make_catalog(
     metadata: Optional[dict] = None,
     kwargs: Optional[Dict[str, Any]] = None,
     kwargs_search: Optional[Dict[str, Union[str, int, float]]] = None,
+    kwargs_open: Optional[Dict] = None,
     vocab: Optional[Union[cfp.Vocab, str, PurePath]] = None,
     return_cat: bool = True,
     save_cat: bool = False,
@@ -137,12 +234,14 @@ def make_catalog(
     kwargs : dict, optional
         Available keyword arguments for catalog types. Find more information about options in the original docs for each type. Some inputs might be required, depending on the catalog type.
     kwargs_search : dict, optional
-        Keyword arguments to input to search on the server before making the catalog. These are not used with `make_local_catalog()`.
+        Keyword arguments to input to search on the server before making the catalog. These are not used with `make_local_catalog()`; only for catalog types erddap and axds.
         Options are:
         * to search by bounding box: include all of min_lon, max_lon, min_lat, max_lat: (int, float). Longitudes must be between -180 to +180.
         * to search within a datetime range: include both of min_time, max_time: interpretable datetime string, e.g., "2021-1-1"
         * to search using a textual keyword: include `search_for` as a string.
-        * model_path can be input in place of either the spatial box or the time range or both in which case those values will be found from the model output.
+        * model_name can be input in place of either the spatial box or the time range or both in which case those values will be found from the model output.
+    kwargs_open : dict, optional
+        Keyword arguments to save into local catalog for model to pass on to xr.open_mfdataset call or pandas open_csv. Only for use with catalog_type=local.
     vocab : dict, optional
         Criteria to use to map from variable to attributes describing the variable. This is to be used with a key representing what variable to search for.
     return_cat : bool, optional
@@ -157,11 +256,19 @@ def make_catalog(
             UserWarning,
         )
 
-    kwargs = {} if kwargs is None else kwargs
-    kwargs_search = {} if kwargs_search is None else kwargs_search
+    if kwargs_open is not None and catalog_type != "local":
+        warnings.warn(
+            f"`kwargs_open` were input but will not be used since `catalog_type=={catalog_type}`.",
+            UserWarning,
+        )
+
+    kwargs = kwargs or {}
+    kwargs_search = kwargs_search or {}
 
     # get spatial and/or temporal search terms from model if desired
-    kwargs_search = kwargs_search_from_model(kwargs_search)
+    kwargs_search.update({"project_name": project_name})
+    if catalog_type != "local":
+        kwargs_search = kwargs_search_from_model(kwargs_search)
 
     # Should I require vocab if nickname is not None?
     # if vocab is None:
@@ -190,6 +297,7 @@ def make_catalog(
             name=catalog_name,
             description=description,
             metadata=metadata,
+            kwargs_open=kwargs_open,
             **kwargs,
         )
 
@@ -207,6 +315,7 @@ def make_catalog(
                     **kwargs,
                 )
         else:
+            # import pdb; pdb.set_trace()
             cat = intake.open_erddap_cat(
                 kwargs_search=kwargs_search,
                 name=catalog_name,
@@ -248,10 +357,10 @@ def run(
     catalogs: Union[str, Catalog, Sequence],
     project_name: str,
     key_variable: str,
-    model_path: str,
+    model_name: str,
     vocabs: Union[str, Vocab, Sequence],
     ndatasets: Optional[int] = None,
-    kwargs_xarray: Optional[Dict] = None,
+    kwargs_map: Optional[Dict] = None,
 ):
     """Run the model-data comparison.
 
@@ -265,16 +374,18 @@ def run(
         Subdirectory in cache dir to store files associated together.
     key_variable : str
         Key in vocab(s) representing variable to compare between model and datasets.
-    model_path : str, Path
-        Where to find model output. Must be readable by xarray.open_mfdataset() (will be converted to list if needed).
+    model_name : str, Path
+        Name of catalog for model output, created with `make_catalog` call.
     vocabs : str, list, Vocab, optional
         Criteria to use to map from variable to attributes describing the variable. This is to be used with a key representing what variable to search for. This input is for the name of one or more existing vocabularies which are stored in a user application cache.
     ndatasets : int, optional
         Max number of datasets from each input catalog to use.
-    kwargs_xarray : dict, optional
-        Keyword arguments to pass on to xr.open_mfdataset call.
+    kwargs_map : dict, optional
+        Keyword arguments to pass on to omsa.plot.map.plot_map call.
     """
 
+    kwargs_map = kwargs_map or {}
+
     # After this, we have a single Vocab object with vocab stored in vocab.vocab
     vocabs = cfp.always_iterable(vocabs)
     if isinstance(vocabs[0], str):
@@ -302,7 +413,7 @@ def run(
 
     # Warning about number of datasets
     ndata = np.sum([len(list(cat)) for cat in cats])
-    if ndatasets != -1:
+    if ndatasets is not None:
         print(
             f"Note that we are using {ndatasets} datasets of {ndata} datasets. This might take awhile."
         )
@@ -310,15 +421,21 @@ def run(
         print(f"Note that there are {ndata} datasets to use. This might take awhile.")
 
     # read in model output
-    dsm = xr.open_mfdataset(cfp.astype(model_path, list), preprocess=em.preprocess, **kwargs_xarray)
+    model_cat = intake.open_catalog(omsa.CAT_PATH(model_name, project_name))
+    dsm = model_cat[list(model_cat)[0]].to_dask()
 
     # use only one variable from model
-    dam = dsm.cf[key_variable]
+    with cfx.set_options(custom_criteria=vocab.vocab):
+        dam = dsm.cf[key_variable]
 
     # shift if 0 to 360
     if dam.cf["longitude"].max() > 180:
         lkey = dam.cf["longitude"].name
-        dam[lkey] = dam[lkey] - 360
+        dam = dam.assign_coords(lon=(((dam[lkey] + 180) % 360) - 180))
+        # rotate arrays so that the locations and values are -180 to 180
+        # instead of 0 to 180 to -180 to 0
+        dam = dam.roll(lon=int((dam[lkey]<0).sum()), roll_coords=True)
+        print("Longitudes are being shifted because they look like they are not -180 to 180.")
 
     # loop over catalogs and sources to pull out lon/lat locations for plot
     maps = []
@@ -377,6 +494,7 @@ def run(
                         RuntimeWarning,
                     )
                     dfd.index = dfd.index.tz_convert(None)
+                    dfd.cf["T"] = dfd.index
 
             # Pull out nearest model output to data
             kwargs = dict(
@@ -393,7 +511,6 @@ def run(
                 if isinstance(kwargs["T"], slice):
                     Targ = kwargs.pop("T")
                     model_var = dam.cf.sel(**kwargs)  # .to_dataset()
-                    # import pdb; pdb.set_trace()
                     model_var = model_var.cf.sel(T=Targ)
                 else:
                     model_var = dam.cf.sel(**kwargs)  # .to_dataset()
@@ -407,11 +524,6 @@ def run(
                 else:
                     model_var = dam.em.sel2dcf(**kwargs)  # .to_dataset()
 
-            # # set model output to UTC
-            # tkey = model_var.cf["T"].name
-            # model_var[tkey] = model_var[tkey].to_index().tz_localize("UTC")
-            # instead turn off time zone for data
-
             if model_var.size == 0:
                 import pdb; pdb.set_trace()
                 # model output isn't available to match data
@@ -425,25 +537,13 @@ def run(
 
             # Combine and align the two time series of variable
             with cfp.set_options(custom_criteria=vocab.vocab):
-                #     print("source name: ", source_name)
-                #     dfd = cat[source_name].read()
-                #     import pdb; pdb.set_trace()
-                #     dfd.cf["T"] = pd.to_datetime(dfd.cf["T"])
-                #     dfd.set_index(dfd.cf["T"], inplace=True)
-                #     if dfd.index.tz is not None:
-                #         warnings.warn(
-                #             f"Dataset {source_name} had a timezone {dfd.index.tz} which is being removed. Make sure the timezone matches the model output.",
-                #             RuntimeWarning,
-                #         )
-                #         dfd.index = dfd.index.tz_convert(None)
-
-                # import pdb; pdb.set_trace()
                 df = omsa.stats._align(dfd.cf[key_variable], model_var)
 
             # pull out depth at surface?
 
             # Where to save stats to?
             stats = df.omsa.compute_stats
+            omsa.stats.save_stats(source_name, stats, project_name)
 
             # Write stats on plot
             figname = omsa.PROJ_DIR(project_name) / f"{source_name}_{key_variable}.png"
@@ -459,7 +559,7 @@ def run(
     # map of model domain with data locations
     if CARTOPY_AVAILABLE and len(maps) > 0:
         figname = omsa.PROJ_DIR(project_name) / "map.png"
-        omsa.plot.map.plot_map(np.asarray(maps), figname, dam)
+        omsa.plot.map.plot_map(np.asarray(maps), figname, dsm, **kwargs_map)
     else:
         print(
             "Not plotting map since cartopy is not installed or no datasets to work with."

From c85864d3cb9b9bfec0cb01ffdef0f4d21e7bc676 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Mon, 9 Jan 2023 15:38:07 -0600
Subject: [PATCH 11/19] fixed example

---
 ocean_model_skill_assessor/main.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ocean_model_skill_assessor/main.py b/ocean_model_skill_assessor/main.py
index 7b26ab1..8b29ac8 100644
--- a/ocean_model_skill_assessor/main.py
+++ b/ocean_model_skill_assessor/main.py
@@ -83,7 +83,7 @@ def make_local_catalog(
     
     Make catalog to represent model output:
     
-    >>> make_local_catalog([model output location(s)], skip_entry_metadata=True, kwargs_open={"drop_variables": "tau"})
+    >>> make_local_catalog([model output location], skip_entry_metadata=True, kwargs_open={"drop_variables": "tau"})
     """
     
     metadata = metadata or {}

From 957119e8dffb240631aac5bc7bdd018bc6d8f0ac Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Mon, 9 Jan 2023 15:39:10 -0600
Subject: [PATCH 12/19] stats updates

changed all results to floats because numpy types messed up yaml dump. Added descriptions so that stats can be saved and understood by a human.
---
 ocean_model_skill_assessor/stats.py | 50 +++++++++++++++++++++++------
 1 file changed, 41 insertions(+), 9 deletions(-)

diff --git a/ocean_model_skill_assessor/stats.py b/ocean_model_skill_assessor/stats.py
index 79b3f21..9e043fc 100644
--- a/ocean_model_skill_assessor/stats.py
+++ b/ocean_model_skill_assessor/stats.py
@@ -5,7 +5,10 @@
 from typing import Tuple, Union
 
 import numpy as np
+import ocean_model_skill_assessor as omsa
 import pandas as pd
+import yaml
+
 
 from pandas import DataFrame
 from xarray import DataArray
@@ -58,14 +61,14 @@ def _align(
 
 
 def compute_bias(obs: DataFrame, model: DataFrame) -> DataFrame:
-    """Given obs and model signals return bias (or, MSD in some communities)."""
+    """Given obs and model signals return bias."""
 
     # check if aligned already
     if (len(obs) != len(model)) or (obs.index != model.index).any():
         aligned_signals = _align(obs, model)
         obs = aligned_signals["obs"]
         model = aligned_signals["model"]
-    return (model - obs).mean()
+    return float((model - obs).mean())
 
 
 def compute_correlation_coefficient(obs: DataFrame, model: DataFrame) -> DataFrame:
@@ -78,7 +81,7 @@ def compute_correlation_coefficient(obs: DataFrame, model: DataFrame) -> DataFra
         model = aligned_signals["model"]
     # can't send nan's in
     inds = obs.notnull() * model.notnull()
-    return np.corrcoef(obs[inds], model[inds])[0, 1]
+    return float(np.corrcoef(obs[inds], model[inds])[0, 1])
 
 
 def compute_index_of_agreement(obs: DataFrame, model: DataFrame) -> DataFrame:
@@ -98,13 +101,13 @@ def compute_index_of_agreement(obs: DataFrame, model: DataFrame) -> DataFrame:
     # handle underfloat
     if denom < 1e-16:
         return 1
-    return 1 - num / denom
+    return float(1 - num / denom)
 
 
 def compute_mean_square_error(
     obs: DataFrame, model: DataFrame, centered=False
 ) -> DataFrame:
-    """Given obs and model signals, return mean square error (MSE)"""
+    """Given obs and model signals, return mean squared error (MSE)"""
 
     # check if aligned
     if (len(obs) != len(model)) or (obs.index != model.index).any():
@@ -115,7 +118,7 @@ def compute_mean_square_error(
     error = obs - model
     if centered:
         error += -obs.mean() + model.mean()
-    return (error**2).mean()
+    return float((error**2).mean())
 
 
 def compute_murphy_skill_score(
@@ -141,7 +144,7 @@ def compute_murphy_skill_score(
     mse_obs_model = compute_mean_square_error(obs_model, obs, centered=False)
     if mse_obs_model <= 0:
         return -1
-    return 1 - mse_model / mse_obs_model
+    return float(1 - mse_model / mse_obs_model)
 
 
 def compute_root_mean_square_error(
@@ -156,12 +159,12 @@ def compute_root_mean_square_error(
         model = aligned_signals["model"]
 
     mse = compute_mean_square_error(obs, model, centered=centered)
-    return np.sqrt(mse)
+    return float(np.sqrt(mse))
 
 
 def compute_descriptive_statistics(model: DataFrame, ddof=0) -> Tuple:
     """Given obs and model signals, return the standard deviation"""
-    return (model.max(), model.min(), model.mean(), model.std(ddof=ddof))
+    return list([float(model.max()), float(model.min()), float(model.mean()), float(model.std(ddof=ddof))])
 
 
 def compute_stats(obs: DataFrame, model: DataFrame) -> dict:
@@ -182,3 +185,32 @@ def compute_stats(obs: DataFrame, model: DataFrame) -> dict:
         "rmse": compute_root_mean_square_error(obs, model),
         "descriptive": compute_descriptive_statistics(model),
     }
+    
+
+def save_stats(source_name: str, stats: dict, project_name: str):
+    """Save computed stats to file."""
+    
+    stats["bias"] = {'value': stats['bias'],
+            'name': "Bias",
+            'long_name': "Bias or MSD",}
+    stats["corr"] = {"value": stats["corr"],
+            "name": "Correlation Coefficient",
+            "long_name": "Pearson product-moment correlation coefficient",}
+    stats["ioa"] =  {"value": stats["ioa"],
+            "name": "Index of Agreement",
+            "long_name": "Index of Agreement (Willmott 1981)",}
+    stats["mse"] =  {"value": stats["mse"],
+            "name": "Mean Squared Error",
+            "long_name": "Mean Squared Error (MSE)",}
+    stats["mss"] = {"value": stats["mss"],
+            "name": "Murphy Skill Score",
+            "long_name": "Murphy Skill Score (Murphy 1988)",}
+    stats["rmse"] =  {"value": stats["rmse"],
+            "name": "RMSE",
+            "long_name": "Root Mean Square Error (RMSE)",}
+    stats["descriptive"] = {"value": stats["descriptive"],
+            "name": "Descriptive Statistics",
+            "long_name": "Max, Min, Mean, Standard Deviation"}
+    
+    with open(omsa.PROJ_DIR(project_name) / f"stats_{source_name}.yaml", "w") as outfile:
+        yaml.dump(stats, outfile, default_flow_style=False)

From 080f4256ca11ca854f7f81dff01a18bdb12a862d Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Mon, 9 Jan 2023 15:42:04 -0600
Subject: [PATCH 13/19] fixes in utils to get things working

---
 ocean_model_skill_assessor/utils.py | 79 ++++++++++++++++++-----------
 1 file changed, 49 insertions(+), 30 deletions(-)

diff --git a/ocean_model_skill_assessor/utils.py b/ocean_model_skill_assessor/utils.py
index 972cc1a..0fb1893 100644
--- a/ocean_model_skill_assessor/utils.py
+++ b/ocean_model_skill_assessor/utils.py
@@ -2,11 +2,12 @@
 Utility functions.
 """
 
-from typing import Dict, Union
+from typing import Dict, Optional, Union
 
 import cf_pandas as cfp
 import cf_xarray
 import extract_model as em
+import intake
 import numpy as np
 import shapely.geometry
 import xarray as xr
@@ -59,21 +60,21 @@ def find_bbox(ds: xr.DataArray, dd: int = 1, alpha: int = 5) -> tuple:
 
     # this function is being used on DataArrays instead of Datasets, and the model I'm using as
     # an example doesn't have a mask, so bring this back when I have a relevant example.
-    # # check for corresponding mask (rectilinear and curvilinear grids)
-    # if any([var for var in ds.data_vars if "mask" in var]):
-    #     if ("mask_rho" in ds) and (lonkey == "lon_rho"):
-    #         maskkey = lonkey.replace("lon", "mask")
-    #     elif "mask" in ds:
-    #         maskkey = "mask"
-    #     else:
-    #         maskkey = None
-    #     if maskkey in ds:
-    #         lon = ds[lonkey].where(ds[maskkey] == 1).values
-    #         lon = lon[~np.isnan(lon)].flatten()
-    #         lat = ds[latkey].where(ds[maskkey] == 1).values
-    #         lat = lat[~np.isnan(lat)].flatten()
-    #         hasmask = True
-
+    # check for corresponding mask (rectilinear and curvilinear grids)
+    if any([var for var in ds.data_vars if "mask" in var]):
+        if ("mask_rho" in ds) and (lonkey == "lon_rho"):
+            maskkey = lonkey.replace("lon", "mask")
+        elif "mask" in ds:
+            maskkey = "mask"
+        else:
+            maskkey = None
+        if maskkey in ds:
+            lon = ds[lonkey].where(ds[maskkey] == 1).values
+            lon = lon[~np.isnan(lon)].flatten()
+            lat = ds[latkey].where(ds[maskkey] == 1).values
+            lat = lat[~np.isnan(lat)].flatten()
+            hasmask = True
+    # import pdb; pdb.set_trace()
     # This is structured, rectilinear
     # GFS, RTOFS, HYCOM
     if (lon.ndim == 1) and ("nele" not in ds.dims) and not hasmask:
@@ -95,13 +96,31 @@ def find_bbox(ds: xr.DataArray, dd: int = 1, alpha: int = 5) -> tuple:
 
         # this leads to a circular import error if read in at top level bc of other packages brought in.
         import alphashape
+        
+        lon, lat = lon[::dd], lat[::dd]
+        pts = list(zip(lon, lat))
 
         # need to calculate concave hull or alphashape of grid
         # low res, same as convex hull
-        p0 = alphashape.alphashape(list(zip(lon, lat)), 0.0)
+        p0 = alphashape.alphashape(pts, 0.0)
         # downsample a bit to save time, still should clearly see shape of domain
-        pts = shapely.geometry.MultiPoint(list(zip(lon[::dd], lat[::dd])))
+        # import pdb; pdb.set_trace()
+        # pts = shapely.geometry.MultiPoint(list(zip(lon, lat)))
         p1 = alphashape.alphashape(pts, alpha)
+        
+    # else:  # 2D coordinates
+        
+    #     # this leads to a circular import error if read in at top level bc of other packages brought in.
+    #     import alphashape
+        
+    #     lon, lat = lon.flatten()[::dd], lat.flatten()[::dd]
+
+    #     # need to calculate concave hull or alphashape of grid
+    #     # low res, same as convex hull
+    #     p0 = alphashape.alphashape(list(zip(lon, lat)), 0.0)
+    #     # downsample a bit to save time, still should clearly see shape of domain
+    #     pts = shapely.geometry.MultiPoint(list(zip(lon, lat)))
+    #     p1 = alphashape.alphashape(pts, alpha)
 
     # useful things to look at: p.wkt  #shapely.geometry.mapping(p)
     return lonkey, latkey, list(p0.bounds), p1
@@ -125,11 +144,11 @@ def kwargs_search_from_model(kwargs_search: Dict[str, Union[str, float]]) -> dic
     Raises
     ------
     KeyError
-        If all of `max_lon`, `min_lon`, `max_lat`, `min_lat` and `min_time`, `max_time` are already specified along with `model_path`.
+        If all of `max_lon`, `min_lon`, `max_lat`, `min_lat` and `min_time`, `max_time` are already specified along with `model_name`.
     """
 
-    # if model_path input, use it to select the search kwargs
-    if "model_path" in kwargs_search:
+    # if model_name input, use it to select the search kwargs
+    if "model_name" in kwargs_search:
         if kwargs_search.keys() >= {
             "max_lon",
             "min_lon",
@@ -139,15 +158,15 @@ def kwargs_search_from_model(kwargs_search: Dict[str, Union[str, float]]) -> dic
             "max_time",
         }:
             raise KeyError(
-                "Can input `model_path` to `kwargs_search` to determine the spatial and/or temporal search box OR specify `max_lon`, `min_lon`, `max_lat`, `min_lat` and `min_time`, `max_time`. Can also do a combination of the two."
+                "Can input `model_name` to `kwargs_search` to determine the spatial and/or temporal search box OR specify `max_lon`, `min_lon`, `max_lat`, `min_lat` and `min_time`, `max_time`. Can also do a combination of the two."
             )
 
         # read in model output
-        dsm = xr.open_mfdataset(
-            cfp.astype(kwargs_search["model_path"], list), preprocess=em.preprocess, **kwargs_xarray
-        )
+        model_cat = intake.open_catalog(omsa.CAT_PATH(kwargs_search['model_name'], kwargs_search['project_name']))
+        dsm = model_cat[list(model_cat)[0]].to_dask()
 
-        kwargs_search.pop("model_path")
+        kwargs_search.pop("model_name")
+        kwargs_search.pop("project_name")
 
         # if none of these present, read from model output
         if kwargs_search.keys().isdisjoint(
@@ -158,11 +177,11 @@ def kwargs_search_from_model(kwargs_search: Dict[str, Union[str, float]]) -> dic
                 "max_lat",
             }
         ):
-            min_lon, max_lon = float(dsm.cf["longitude"].min()), float(
-                dsm.cf["longitude"].max()
+            min_lon, max_lon = float(dsm[dsm.cf.coordinates["longitude"][0]].min()), float(
+                dsm[dsm.cf.coordinates["longitude"][0]].max()
             )
-            min_lat, max_lat = float(dsm.cf["latitude"].min()), float(
-                dsm.cf["latitude"].max()
+            min_lat, max_lat = float(dsm[dsm.cf.coordinates["latitude"][0]].min()), float(
+                dsm[dsm.cf.coordinates["latitude"][0]].max()
             )
 
             if abs(min_lon) > 180 or abs(max_lon) > 180:

From b52a020ceca49e96a182c70ddf376859106ab123 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Mon, 9 Jan 2023 15:42:28 -0600
Subject: [PATCH 14/19] better alpha and dd vals in plot map

---
 ocean_model_skill_assessor/plot/map.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ocean_model_skill_assessor/plot/map.py b/ocean_model_skill_assessor/plot/map.py
index c5cef32..f4abf08 100644
--- a/ocean_model_skill_assessor/plot/map.py
+++ b/ocean_model_skill_assessor/plot/map.py
@@ -17,7 +17,7 @@
 
 
 def plot_map(
-    maps: np.array, figname: Union[str, PurePath], ds: Union[DataArray, Dataset]
+    maps: np.array, figname: Union[str, PurePath], ds: Union[DataArray, Dataset], alpha: int = 5, dd: int = 2,
 ):
     """Plot and save to file map of model domain and data locations.
 
@@ -58,7 +58,7 @@ def plot_map(
     ax.add_feature(land_10m, facecolor="0.8")
 
     # alphashape
-    _, _, bbox, p = find_bbox(ds, dd=10, alpha=5)
+    _, _, bbox, p = find_bbox(ds, dd=dd, alpha=alpha)
     ax.add_geometries([p], crs=pc, facecolor="none", edgecolor="r", linestyle="-")
 
     # plot stations

From 721f6f3115db4db2351baf1255201e8912399aaf Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Mon, 9 Jan 2023 15:43:02 -0600
Subject: [PATCH 15/19] small change to time series plot with dict

---
 ocean_model_skill_assessor/plot/time_series.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ocean_model_skill_assessor/plot/time_series.py b/ocean_model_skill_assessor/plot/time_series.py
index fc61bd5..67265c6 100644
--- a/ocean_model_skill_assessor/plot/time_series.py
+++ b/ocean_model_skill_assessor/plot/time_series.py
@@ -53,7 +53,7 @@ def plot(
         stat_sum = ""
         types = ["bias", "corr", "ioa", "mse", "mss", "rmse"]
         for type in types:
-            stat_sum += f"{type}: {stats[type]:.1f}  "
+            stat_sum += f"{type}: {stats[type]['value']:.1f}  "
         title = f"{title}: {stat_sum}"
 
     ax.set_title(title, fontsize=fs_title, loc="left")

From f80ce81120e6be749fbe4ba6e545d60b5f5e7196 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Mon, 9 Jan 2023 15:43:24 -0600
Subject: [PATCH 16/19] removed coords from general vocab

---
 ocean_model_skill_assessor/vocab/general.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ocean_model_skill_assessor/vocab/general.json b/ocean_model_skill_assessor/vocab/general.json
index 09140b6..14b3ab9 100644
--- a/ocean_model_skill_assessor/vocab/general.json
+++ b/ocean_model_skill_assessor/vocab/general.json
@@ -1 +1 @@
-{"temp": {"name": "^(?!.*(air|qc|status|atmospheric))(?=.*temp)"}, "salt": {"name": "^(?!.*(soil|qc|status))(?=.*sal)"}, "ssh": {"name": "^(?!.*(qc|status))(?=.*sea_surface_height)(?=.*surface_elevation)"}, "T": {"name": "(?=.*time)"}, "longitude": {"name": "(?=.*lon)"}, "latitude": {"name": "(?=.*lat)"}}
+{"temp": {"name": "^(?!.*(air|qc|status|atmospheric|bottom))(?=.*temp)"}, "salt": {"name": "^(?!.*(soil|qc|status|bottom))(?=.*sal)"}, "ssh": {"name": "^(?!.*(qc|status))(?=.*sea_surface_height)(?=.*surface_elevation)"}}

From cd90cf89b683d976c66fab3d5a7262a69cec8c13 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Mon, 9 Jan 2023 15:43:52 -0600
Subject: [PATCH 17/19] got tests running

---
 tests/test_main.py       | 38 +++++++++++++++++++++++++++++++-------
 tests/test_main_local.py |  2 +-
 tests/test_utils.py      | 40 ++++++++++++++++++++++++++++++++--------
 3 files changed, 64 insertions(+), 16 deletions(-)

diff --git a/tests/test_main.py b/tests/test_main.py
index 1b2d5e7..41600d7 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -1,6 +1,7 @@
 from unittest import mock
 
 import cf_pandas as cfp
+import intake_xarray
 import numpy as np
 import pandas as pd
 import pytest
@@ -13,11 +14,31 @@
 
 
 @mock.patch("intake.source.csv.CSVSource.read")
-@mock.patch("xarray.open_mfdataset")
-def test_run_variable(mock_ds, mock_read):
+@mock.patch("intake_xarray.base.DataSourceMixin.to_dask")
+@mock.patch("intake.open_catalog")
+@mock.patch("intake.open_catalog")
+def test_run_variable(mock_open_cat, mock_open_cat_model, mock_to_dask, mock_read):
     """Test running with variable that is not present in catalog dataset."""
+    
+    # make model catalog
+    entries = {
+        "name": LocalCatalogEntry(
+            name="name",
+            description="description",
+            driver=intake_xarray.opendap.OpenDapSource,
+            args={"urlpath": "path", "engine": "netcdf4"},
+            metadata={},
+            direct_access="allow",
+        ),
+    }
+    catm = Catalog.from_dict(
+        entries,
+        name="model_cat",
+        description="description",
+        metadata={},
+    )
 
-    # make catalog
+    # make Data catalog
     entries = {
         "test_source": LocalCatalogEntry(
             "test_source",
@@ -56,7 +77,10 @@ def test_run_variable(mock_ds, mock_read):
         np.arange(9),
         {"standard_name": "sea_water_temperature", "coordinates": "lon"},
     )
-    mock_ds.return_value = ds
+    mock_to_dask.return_value = ds
+    
+    mock_open_cat.return_value = cat
+    mock_open_cat_model.return_value = catm
 
     df = pd.DataFrame(
         columns=[
@@ -73,7 +97,7 @@ def test_run_variable(mock_ds, mock_read):
             catalogs=cat,
             project_name="projectB",
             key_variable="temp",
-            model_path="fake.nc",
+            model_name="model_cat",
             vocabs=vocab,
             ndatasets=None,
         )
@@ -87,7 +111,7 @@ def test_run_errors():
             catalogs="",
             project_name="projectB",
             key_variable="temp",
-            model_path="fake.nc",
+            model_name="fake.nc",
             vocabs=[dict()],
             ndatasets=None,
         )
@@ -100,7 +124,7 @@ def test_run_errors():
             catalogs=[dict()],
             project_name="projectB",
             key_variable="temp",
-            model_path="fake.nc",
+            model_name="fake.nc",
             vocabs=vocab,
             ndatasets=None,
         )
diff --git a/tests/test_main_local.py b/tests/test_main_local.py
index 0e38f70..2066359 100644
--- a/tests/test_main_local.py
+++ b/tests/test_main_local.py
@@ -89,4 +89,4 @@ def test_make_catalog_local_read(read):
     )
     assert cat["filename"].metadata["minLongitude"] == 0.0
     assert cat["filename"].metadata["maxLatitude"] == 8.0
-    assert cat["filename"].metadata["minTime"] == "0"
+    assert cat["filename"].metadata["minTime"] == "1970-01-01 00:00:00"
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 4cef7ce..8eaa82b 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -1,10 +1,12 @@
 from unittest import mock
 
+import intake_xarray
 import numpy as np
 import pytest
 import shapely.geometry
 import xarray as xr
-
+from intake.catalog import Catalog
+from intake.catalog.local import LocalCatalogEntry
 import ocean_model_skill_assessor as omsa
 
 
@@ -26,12 +28,32 @@
 )
 
 
-@mock.patch("xarray.open_mfdataset")
-def test_kwargs_search_from_model(mock_xarray):
+@mock.patch("intake_xarray.base.DataSourceMixin.to_dask")
+@mock.patch("intake.open_catalog")
+def test_kwargs_search_from_model(mock_open_cat, mock_to_dask):
+
+    kwargs_search = {"model_name": "path", "project_name": "test_project"}
 
-    kwargs_search = {"model_path": "path"}
+    entries = {
+        "name": LocalCatalogEntry(
+            name="name",
+            description="description",
+            driver=intake_xarray.opendap.OpenDapSource,
+            args={"urlpath": "path", "engine": "netcdf4"},
+            metadata={},
+            direct_access="allow",
+        ),
+    }
+    cat = Catalog.from_dict(
+        entries,
+        name="name",
+        description="description",
+        metadata={},
+    )
 
-    mock_xarray.return_value = ds
+    mock_open_cat.return_value = cat
+    
+    mock_to_dask.return_value = ds
 
     kwargs_search = omsa.utils.kwargs_search_from_model(kwargs_search)
     output = {
@@ -44,7 +66,7 @@ def test_kwargs_search_from_model(mock_xarray):
     }
     assert kwargs_search == output
 
-    kwargs_search = {"min_time": 1, "max_time": 2, "model_path": "path"}
+    kwargs_search = {"min_time": 1, "max_time": 2, "model_name": "path", "project_name": "test_project"}
     kwargs_search = omsa.utils.kwargs_search_from_model(kwargs_search)
     output = {
         "min_lon": 0.0,
@@ -61,7 +83,8 @@ def test_kwargs_search_from_model(mock_xarray):
         "max_lon": 2,
         "min_lat": 1,
         "max_lat": 2,
-        "model_path": "path",
+        "model_name": "path",
+        "project_name": "test_project"
     }
     kwargs_search = omsa.utils.kwargs_search_from_model(kwargs_search)
     output = {
@@ -81,7 +104,8 @@ def test_kwargs_search_from_model(mock_xarray):
         "max_lon": "2",
         "min_lat": "1",
         "max_lat": "2",
-        "model_path": "path",
+        "model_name": "path",
+        "project_name": "test_project"
     }
     with pytest.raises(KeyError):
         kwargs_search = omsa.utils.kwargs_search_from_model(kwargs_search)

From 136df23b865cd6cee43545e5b7970c6f361989cb Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Mon, 9 Jan 2023 15:49:40 -0600
Subject: [PATCH 18/19] precommit

---
 .pre-commit-config.yaml                |  2 +-
 docs/cli.md                            | 22 +++----
 ocean_model_skill_assessor/CLI.py      | 11 +++-
 ocean_model_skill_assessor/main.py     | 61 +++++++++++--------
 ocean_model_skill_assessor/plot/map.py |  6 +-
 ocean_model_skill_assessor/stats.py    | 81 +++++++++++++++++---------
 ocean_model_skill_assessor/utils.py    | 24 ++++----
 tests/test_main.py                     |  4 +-
 tests/test_utils.py                    | 15 +++--
 9 files changed, 142 insertions(+), 84 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index d291cb1..7642fae 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -51,7 +51,7 @@ repos:
   rev: v0.982
   hooks:
   - id: mypy
-    additional_dependencies: [types-setuptools]
+    additional_dependencies: [types-setuptools, types-PyYAML]
     exclude: docs/source/conf.py
     args: [--ignore-missing-imports]
 
diff --git a/docs/cli.md b/docs/cli.md
index 60bdfe3..cd4d64d 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -15,7 +15,7 @@ Make a catalog with known local or remote file(s).
 
 #### Available options
 
-    omsa make_catalog --project_name PROJ_NAME --catalog_type local --catalog_name CATALOG_NAME --description "Catalog description" --kwargs filenames="[FILE1,FILE2]" 
+    omsa make_catalog --project_name PROJ_NAME --catalog_type local --catalog_name CATALOG_NAME --description "Catalog description" --kwargs filenames="[FILE1,FILE2]"
 
 * `project_name`: Will be used as the name of the directory where the catalog is saved. The directory is located in a user application cache directory, the address of which can be found for your setup with  `omsa proj_path --project_name PROJ_NAME`.
 * `catalog_type`: Type of catalog to make. Options are "erddap", "axds", or "local".
@@ -30,19 +30,19 @@ Make a catalog with known local or remote file(s).
 
 
 
-    
 
 
 
-   
 
 
 
-    
 
 
 
-    
+
+
+
+
 
 
 
@@ -52,7 +52,7 @@ Make a catalog with known local or remote file(s).
 #### Examples
 
 ```{code-cell} ipython3
-!omsa make_catalog --project_name test1 --catalog_type local --catalog_name example_local_catalog --description "Example local catalog description" --kwargs filenames="[https://researchworkspace.com/files/8114311/ecofoci_2011CHAOZ_CTD_Nutrient_mb1101.csv]" 
+!omsa make_catalog --project_name test1 --catalog_type local --catalog_name example_local_catalog --description "Example local catalog description" --kwargs filenames="[https://researchworkspace.com/files/8114311/ecofoci_2011CHAOZ_CTD_Nutrient_mb1101.csv]"
 ```
 
 ### ERDDAP Catalog
@@ -70,11 +70,11 @@ Make a catalog from datasets available from an ERDDAP server using `intake-erdda
 * `metadata`: Metadata for catalog.
 * `kwargs`: Keyword arguments to make the ERDDAP catalog. See `intake-erddap.erddap_cat()` for more details.
   * `server`: ERDDAP server address, for example: "http://erddap.sensors.ioos.us/erddap"
-  * `category_search`: 
-  * `erddap_client`: 
-  * `use_source_constraints`: 
-  * `protocol`: 
-  * `metadata`: 
+  * `category_search`:
+  * `erddap_client`:
+  * `use_source_constraints`:
+  * `protocol`:
+  * `metadata`:
   * other keyword arguments can be passed into the intake `Catalog` class
 * `kwargs_search`: Keyword arguments to input to search on the server before making the catalog.
   * `min_lon`, `min_lat`, `max_lon`, `max_lat`: search for datasets within this spatial box
diff --git a/ocean_model_skill_assessor/CLI.py b/ocean_model_skill_assessor/CLI.py
index f33096f..119a5fe 100644
--- a/ocean_model_skill_assessor/CLI.py
+++ b/ocean_model_skill_assessor/CLI.py
@@ -6,19 +6,25 @@
 
 import ocean_model_skill_assessor as omsa
 
+
 def is_int(s):
+    """Check if string is actually int."""
     try:
         int(s)
         return True
     except (ValueError, TypeError):
         return False
+
+
 def is_float(s):
+    """Check if string is actually float."""
     try:
         float(s)
         return True
     except (ValueError, TypeError):
         return False
 
+
 # https://sumit-ghosh.com/articles/parsing-dictionary-key-value-pairs-kwargs-argparse-python/
 class ParseKwargs(argparse.Action):
     """With can user can input dicts on CLI."""
@@ -99,7 +105,10 @@ def main():
     parser.add_argument(
         "--key", help="Key from vocab representing the variable to compare."
     )
-    parser.add_argument("--model_name", help="Name of catalog for model output, created in a `make_Catalog` command.")
+    parser.add_argument(
+        "--model_name",
+        help="Name of catalog for model output, created in a `make_Catalog` command.",
+    )
     parser.add_argument(
         "--ndatasets",
         type=int,
diff --git a/ocean_model_skill_assessor/main.py b/ocean_model_skill_assessor/main.py
index 8b29ac8..fdea3ae 100644
--- a/ocean_model_skill_assessor/main.py
+++ b/ocean_model_skill_assessor/main.py
@@ -47,9 +47,9 @@ def make_local_catalog(
     kwargs_open: Optional[Dict] = None,
 ) -> Catalog:
     """Make an intake catalog from specified data files, including model output locations.
-    
+
     Pass keywords for xarray for model output into the catalog through kwargs_xarray.
-    
+
     kwargs_open and metadata must be the same for all filenames. If it is not, make multiple catalogs and you can input them individually into the run command.
 
     Parameters
@@ -73,42 +73,50 @@ def make_local_catalog(
     -------
     Catalog
         Intake catalog with an entry for each dataset represented by a filename.
-    
+
     Examples
     --------
-    
+
     Make catalog to represent local or remote files with specific locations:
-    
+
     >>> make_local_catalog([filename1, filename2])
-    
+
     Make catalog to represent model output:
-    
+
     >>> make_local_catalog([model output location], skip_entry_metadata=True, kwargs_open={"drop_variables": "tau"})
     """
-    
+
     metadata = metadata or {}
     metadata_catalog = metadata_catalog or {}
-    
+
     kwargs_open = kwargs_open or {}
-    
+
     # if any of kwargs_open came in with "None" instead of None because of CLI, change back to None
     kwargs_open.update({key: None for key, val in kwargs_open.items() if val == "None"})
 
     sources = []
     for filename in filenames:
         mtype = mimetypes.guess_type(filename)[0]
-        if (mtype is not None and ("csv" in mtype or "text" in mtype)) or "csv" in filename or "text" in filename:
+        if (
+            (mtype is not None and ("csv" in mtype or "text" in mtype))
+            or "csv" in filename
+            or "text" in filename
+        ):
             source = getattr(intake, "open_csv")(filename, csv_kwargs=kwargs_open)
         elif "thredds" in filename and "dodsC" in filename:
             # use netcdf4 engine if not input in kwargs_xarray
             kwargs_open.setdefault("engine", "netcdf4")
             source = getattr(intake, "open_opendap")(filename, **kwargs_open)
-        elif (mtype is not None and "netcdf" in mtype) or "netcdf" in filename or ".nc" in filename:
+        elif (
+            (mtype is not None and "netcdf" in mtype)
+            or "netcdf" in filename
+            or ".nc" in filename
+        ):
             source = getattr(intake, "open_netcdf")(filename, **kwargs_open)
-        
+
         # combine input metadata with source metadata
         source.metadata.update(metadata)
-        
+
         sources.append(source)
 
     # create dictionary of catalog entries
@@ -144,8 +152,8 @@ def make_local_catalog(
                 "minLatitude",
                 "maxLatitude",
             }:
-                dd['longitude'] = cat[source].metadata["minLongitude"]
-                dd['latitude'] = cat[source].metadata["minLatitude"]
+                dd["longitude"] = cat[source].metadata["minLongitude"]
+                dd["latitude"] = cat[source].metadata["minLatitude"]
                 cat[source].metadata = {
                     "minLongitude": cat[source].metadata["minLongitude"],
                     "minLatitude": cat[source].metadata["minLatitude"],
@@ -171,10 +179,12 @@ def make_local_catalog(
                 )
                 dd.index = dd.index.tz_convert(None)
                 dd.cf["T"] = dd.index
-            metadata.update({
-                "minTime": str(dd.cf["T"].min()),
-                "maxTime": str(dd.cf["T"].max()),
-            })
+            metadata.update(
+                {
+                    "minTime": str(dd.cf["T"].min()),
+                    "maxTime": str(dd.cf["T"].max()),
+                }
+            )
 
             cat[source].metadata.update(metadata)
             cat[source]._entry._metadata.update(metadata)
@@ -347,7 +357,9 @@ def make_catalog(
     if save_cat:
         # save cat to file
         cat.save(omsa.CAT_PATH(catalog_name, project_name))
-        print(f"Catalog saved to {omsa.CAT_PATH(catalog_name, project_name)} with {len(list(cat))} entries.")
+        print(
+            f"Catalog saved to {omsa.CAT_PATH(catalog_name, project_name)} with {len(list(cat))} entries."
+        )
 
     if return_cat:
         return cat
@@ -434,8 +446,10 @@ def run(
         dam = dam.assign_coords(lon=(((dam[lkey] + 180) % 360) - 180))
         # rotate arrays so that the locations and values are -180 to 180
         # instead of 0 to 180 to -180 to 0
-        dam = dam.roll(lon=int((dam[lkey]<0).sum()), roll_coords=True)
-        print("Longitudes are being shifted because they look like they are not -180 to 180.")
+        dam = dam.roll(lon=int((dam[lkey] < 0).sum()), roll_coords=True)
+        print(
+            "Longitudes are being shifted because they look like they are not -180 to 180."
+        )
 
     # loop over catalogs and sources to pull out lon/lat locations for plot
     maps = []
@@ -525,7 +539,6 @@ def run(
                     model_var = dam.em.sel2dcf(**kwargs)  # .to_dataset()
 
             if model_var.size == 0:
-                import pdb; pdb.set_trace()
                 # model output isn't available to match data
                 # data must not be in the space/time range of model
                 maps.pop(-1)
diff --git a/ocean_model_skill_assessor/plot/map.py b/ocean_model_skill_assessor/plot/map.py
index f4abf08..c79fad6 100644
--- a/ocean_model_skill_assessor/plot/map.py
+++ b/ocean_model_skill_assessor/plot/map.py
@@ -17,7 +17,11 @@
 
 
 def plot_map(
-    maps: np.array, figname: Union[str, PurePath], ds: Union[DataArray, Dataset], alpha: int = 5, dd: int = 2,
+    maps: np.array,
+    figname: Union[str, PurePath],
+    ds: Union[DataArray, Dataset],
+    alpha: int = 5,
+    dd: int = 2,
 ):
     """Plot and save to file map of model domain and data locations.
 
diff --git a/ocean_model_skill_assessor/stats.py b/ocean_model_skill_assessor/stats.py
index 9e043fc..1ea5b07 100644
--- a/ocean_model_skill_assessor/stats.py
+++ b/ocean_model_skill_assessor/stats.py
@@ -5,14 +5,14 @@
 from typing import Tuple, Union
 
 import numpy as np
-import ocean_model_skill_assessor as omsa
 import pandas as pd
 import yaml
 
-
 from pandas import DataFrame
 from xarray import DataArray
 
+import ocean_model_skill_assessor as omsa
+
 
 def _align(
     obs: Union[DataFrame, DataArray], model: Union[DataFrame, DataArray]
@@ -162,9 +162,16 @@ def compute_root_mean_square_error(
     return float(np.sqrt(mse))
 
 
-def compute_descriptive_statistics(model: DataFrame, ddof=0) -> Tuple:
+def compute_descriptive_statistics(model: DataFrame, ddof=0) -> list:
     """Given obs and model signals, return the standard deviation"""
-    return list([float(model.max()), float(model.min()), float(model.mean()), float(model.std(ddof=ddof))])
+    return list(
+        [
+            float(model.max()),
+            float(model.min()),
+            float(model.mean()),
+            float(model.std(ddof=ddof)),
+        ]
+    )
 
 
 def compute_stats(obs: DataFrame, model: DataFrame) -> dict:
@@ -185,32 +192,48 @@ def compute_stats(obs: DataFrame, model: DataFrame) -> dict:
         "rmse": compute_root_mean_square_error(obs, model),
         "descriptive": compute_descriptive_statistics(model),
     }
-    
+
 
 def save_stats(source_name: str, stats: dict, project_name: str):
     """Save computed stats to file."""
-    
-    stats["bias"] = {'value': stats['bias'],
-            'name': "Bias",
-            'long_name': "Bias or MSD",}
-    stats["corr"] = {"value": stats["corr"],
-            "name": "Correlation Coefficient",
-            "long_name": "Pearson product-moment correlation coefficient",}
-    stats["ioa"] =  {"value": stats["ioa"],
-            "name": "Index of Agreement",
-            "long_name": "Index of Agreement (Willmott 1981)",}
-    stats["mse"] =  {"value": stats["mse"],
-            "name": "Mean Squared Error",
-            "long_name": "Mean Squared Error (MSE)",}
-    stats["mss"] = {"value": stats["mss"],
-            "name": "Murphy Skill Score",
-            "long_name": "Murphy Skill Score (Murphy 1988)",}
-    stats["rmse"] =  {"value": stats["rmse"],
-            "name": "RMSE",
-            "long_name": "Root Mean Square Error (RMSE)",}
-    stats["descriptive"] = {"value": stats["descriptive"],
-            "name": "Descriptive Statistics",
-            "long_name": "Max, Min, Mean, Standard Deviation"}
-    
-    with open(omsa.PROJ_DIR(project_name) / f"stats_{source_name}.yaml", "w") as outfile:
+
+    stats["bias"] = {
+        "value": stats["bias"],
+        "name": "Bias",
+        "long_name": "Bias or MSD",
+    }
+    stats["corr"] = {
+        "value": stats["corr"],
+        "name": "Correlation Coefficient",
+        "long_name": "Pearson product-moment correlation coefficient",
+    }
+    stats["ioa"] = {
+        "value": stats["ioa"],
+        "name": "Index of Agreement",
+        "long_name": "Index of Agreement (Willmott 1981)",
+    }
+    stats["mse"] = {
+        "value": stats["mse"],
+        "name": "Mean Squared Error",
+        "long_name": "Mean Squared Error (MSE)",
+    }
+    stats["mss"] = {
+        "value": stats["mss"],
+        "name": "Murphy Skill Score",
+        "long_name": "Murphy Skill Score (Murphy 1988)",
+    }
+    stats["rmse"] = {
+        "value": stats["rmse"],
+        "name": "RMSE",
+        "long_name": "Root Mean Square Error (RMSE)",
+    }
+    stats["descriptive"] = {
+        "value": stats["descriptive"],
+        "name": "Descriptive Statistics",
+        "long_name": "Max, Min, Mean, Standard Deviation",
+    }
+
+    with open(
+        omsa.PROJ_DIR(project_name) / f"stats_{source_name}.yaml", "w"
+    ) as outfile:
         yaml.dump(stats, outfile, default_flow_style=False)
diff --git a/ocean_model_skill_assessor/utils.py b/ocean_model_skill_assessor/utils.py
index 0fb1893..5e2586c 100644
--- a/ocean_model_skill_assessor/utils.py
+++ b/ocean_model_skill_assessor/utils.py
@@ -96,7 +96,7 @@ def find_bbox(ds: xr.DataArray, dd: int = 1, alpha: int = 5) -> tuple:
 
         # this leads to a circular import error if read in at top level bc of other packages brought in.
         import alphashape
-        
+
         lon, lat = lon[::dd], lat[::dd]
         pts = list(zip(lon, lat))
 
@@ -107,12 +107,12 @@ def find_bbox(ds: xr.DataArray, dd: int = 1, alpha: int = 5) -> tuple:
         # import pdb; pdb.set_trace()
         # pts = shapely.geometry.MultiPoint(list(zip(lon, lat)))
         p1 = alphashape.alphashape(pts, alpha)
-        
+
     # else:  # 2D coordinates
-        
+
     #     # this leads to a circular import error if read in at top level bc of other packages brought in.
     #     import alphashape
-        
+
     #     lon, lat = lon.flatten()[::dd], lat.flatten()[::dd]
 
     #     # need to calculate concave hull or alphashape of grid
@@ -162,7 +162,9 @@ def kwargs_search_from_model(kwargs_search: Dict[str, Union[str, float]]) -> dic
             )
 
         # read in model output
-        model_cat = intake.open_catalog(omsa.CAT_PATH(kwargs_search['model_name'], kwargs_search['project_name']))
+        model_cat = intake.open_catalog(
+            omsa.CAT_PATH(kwargs_search["model_name"], kwargs_search["project_name"])
+        )
         dsm = model_cat[list(model_cat)[0]].to_dask()
 
         kwargs_search.pop("model_name")
@@ -177,12 +179,12 @@ def kwargs_search_from_model(kwargs_search: Dict[str, Union[str, float]]) -> dic
                 "max_lat",
             }
         ):
-            min_lon, max_lon = float(dsm[dsm.cf.coordinates["longitude"][0]].min()), float(
-                dsm[dsm.cf.coordinates["longitude"][0]].max()
-            )
-            min_lat, max_lat = float(dsm[dsm.cf.coordinates["latitude"][0]].min()), float(
-                dsm[dsm.cf.coordinates["latitude"][0]].max()
-            )
+            min_lon, max_lon = float(
+                dsm[dsm.cf.coordinates["longitude"][0]].min()
+            ), float(dsm[dsm.cf.coordinates["longitude"][0]].max())
+            min_lat, max_lat = float(
+                dsm[dsm.cf.coordinates["latitude"][0]].min()
+            ), float(dsm[dsm.cf.coordinates["latitude"][0]].max())
 
             if abs(min_lon) > 180 or abs(max_lon) > 180:
                 min_lon -= 360
diff --git a/tests/test_main.py b/tests/test_main.py
index 41600d7..35f7a69 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -19,7 +19,7 @@
 @mock.patch("intake.open_catalog")
 def test_run_variable(mock_open_cat, mock_open_cat_model, mock_to_dask, mock_read):
     """Test running with variable that is not present in catalog dataset."""
-    
+
     # make model catalog
     entries = {
         "name": LocalCatalogEntry(
@@ -78,7 +78,7 @@ def test_run_variable(mock_open_cat, mock_open_cat_model, mock_to_dask, mock_rea
         {"standard_name": "sea_water_temperature", "coordinates": "lon"},
     )
     mock_to_dask.return_value = ds
-    
+
     mock_open_cat.return_value = cat
     mock_open_cat_model.return_value = catm
 
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 8eaa82b..9935c7b 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -5,8 +5,10 @@
 import pytest
 import shapely.geometry
 import xarray as xr
+
 from intake.catalog import Catalog
 from intake.catalog.local import LocalCatalogEntry
+
 import ocean_model_skill_assessor as omsa
 
 
@@ -52,7 +54,7 @@ def test_kwargs_search_from_model(mock_open_cat, mock_to_dask):
     )
 
     mock_open_cat.return_value = cat
-    
+
     mock_to_dask.return_value = ds
 
     kwargs_search = omsa.utils.kwargs_search_from_model(kwargs_search)
@@ -66,7 +68,12 @@ def test_kwargs_search_from_model(mock_open_cat, mock_to_dask):
     }
     assert kwargs_search == output
 
-    kwargs_search = {"min_time": 1, "max_time": 2, "model_name": "path", "project_name": "test_project"}
+    kwargs_search = {
+        "min_time": 1,
+        "max_time": 2,
+        "model_name": "path",
+        "project_name": "test_project",
+    }
     kwargs_search = omsa.utils.kwargs_search_from_model(kwargs_search)
     output = {
         "min_lon": 0.0,
@@ -84,7 +91,7 @@ def test_kwargs_search_from_model(mock_open_cat, mock_to_dask):
         "min_lat": 1,
         "max_lat": 2,
         "model_name": "path",
-        "project_name": "test_project"
+        "project_name": "test_project",
     }
     kwargs_search = omsa.utils.kwargs_search_from_model(kwargs_search)
     output = {
@@ -105,7 +112,7 @@ def test_kwargs_search_from_model(mock_open_cat, mock_to_dask):
         "min_lat": "1",
         "max_lat": "2",
         "model_name": "path",
-        "project_name": "test_project"
+        "project_name": "test_project",
     }
     with pytest.raises(KeyError):
         kwargs_search = omsa.utils.kwargs_search_from_model(kwargs_search)

From 2d4ba36f30243138b2d5138d33ffd6af7ef59d41 Mon Sep 17 00:00:00 2001
From: Kristen Thyng <kthyng@gmail.com>
Date: Mon, 9 Jan 2023 16:33:22 -0600
Subject: [PATCH 19/19] removed erddap test

---
 tests/test_main_erddap.py | 34 ----------------------------------
 1 file changed, 34 deletions(-)
 delete mode 100644 tests/test_main_erddap.py

diff --git a/tests/test_main_erddap.py b/tests/test_main_erddap.py
deleted file mode 100644
index dee3285..0000000
--- a/tests/test_main_erddap.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from unittest import mock
-
-import pandas as pd
-
-import ocean_model_skill_assessor as omsa
-
-
-SERVER_URL = "http://erddap.invalid/erddap"
-
-
-@mock.patch("intake_erddap.erddap_cat.ERDDAPCatalog._load_metadata")
-@mock.patch("pandas.read_csv")
-def test_make_catalog_erddap(mock_read_csv, load_metadata_mock):
-    load_metadata_mock.return_value = {}
-    results = pd.DataFrame()
-    results["datasetID"] = ["abc123"]
-    mock_read_csv.return_value = results
-    cat = omsa.make_catalog(
-        catalog_type="erddap",
-        project_name="test_project_erddap",
-        catalog_name="test_catalog_erddap",
-        description="description of test erddap catalog",
-        kwargs={"server": SERVER_URL},
-        kwargs_search={"min_time": "2022-1-1", "max_time": "2022-1-2"},
-        return_cat=True,
-        save_cat=False,
-    )
-
-    assert list(cat) == ["abc123"]
-    assert cat.name == "test_catalog_erddap"
-    assert cat["abc123"].describe()["args"]["server"] == SERVER_URL
-    assert cat.description == "description of test erddap catalog"
-    # assert cat.metadata["kwargs_search"]["min_time"] == '2022-1-1'
-    # assert cat.metadata["kwargs_search"]["max_time"] == '2022-1-2'