diff --git a/pyphare/pyphare/core/box.py b/pyphare/pyphare/core/box.py
index e52828223..62a278283 100644
--- a/pyphare/pyphare/core/box.py
+++ b/pyphare/pyphare/core/box.py
@@ -207,7 +207,7 @@ def amr_to_local(box, ref_box):
 
 
 def select(data, box):
-    return data[tuple([slice(l, u + 1) for l, u in zip(box.lower, box.upper)])]
+    return data[tuple([slice(lo, up + 1) for lo, up in zip(box.lower, box.upper)])]
 
 
 class DataSelector:
diff --git a/pyphare/pyphare/core/gridlayout.py b/pyphare/pyphare/core/gridlayout.py
index ec35311ca..9aaccb9df 100644
--- a/pyphare/pyphare/core/gridlayout.py
+++ b/pyphare/pyphare/core/gridlayout.py
@@ -44,6 +44,10 @@
         "Pyz": "primal",
         "Pzz": "primal",
         "tags": "dual",
+        "value": "primal",
+        "x": "primal",
+        "y": "primal",
+        "z": "primal",
     },
     "y": {
         "Bx": "dual",
@@ -79,6 +83,10 @@
         "Pyz": "primal",
         "Pzz": "primal",
         "tags": "dual",
+        "value": "primal",
+        "x": "primal",
+        "y": "primal",
+        "z": "primal",
     },
     "z": {
         "Bx": "dual",
@@ -114,6 +122,10 @@
         "Pyz": "primal",
         "Pzz": "primal",
         "tags": "dual",
+        "value": "primal",
+        "x": "primal",
+        "y": "primal",
+        "z": "primal",
     },
 }
 yee_centering_lower = {
diff --git a/pyphare/pyphare/core/operators.py b/pyphare/pyphare/core/operators.py
index 1bd81fb12..6c0d20308 100644
--- a/pyphare/pyphare/core/operators.py
+++ b/pyphare/pyphare/core/operators.py
@@ -96,7 +96,7 @@ def dot(hier_left, hier_right, **kwargs):
         (hl, hr),
     )
 
-    return ScalarField(h)
+    return ScalarField.FROM(h)
 
 
 def cross(hier_left, hier_right, **kwargs):
@@ -115,7 +115,7 @@ def cross(hier_left, hier_right, **kwargs):
         (hl, hr),
     )
 
-    return VectorField(h)
+    return VectorField.FROM(h)
 
 
 def sqrt(hier, **kwargs):
@@ -124,7 +124,7 @@ def sqrt(hier, **kwargs):
         hier,
     )
 
-    return ScalarField(h)
+    return ScalarField.FROM(h)
 
 
 def modulus(hier):
@@ -138,4 +138,4 @@ def grad(hier, **kwargs):
     nb_ghosts = list(hier.level(0).patches[0].patch_datas.values())[0].ghosts_nbr[0]
     h = compute_hier_from(_compute_grad, hier, nb_ghosts=nb_ghosts)
 
-    return VectorField(h)
+    return VectorField.FROM(h)
diff --git a/pyphare/pyphare/pharesee/hierarchy/.ipynb_checkpoints/__init__-checkpoint.py b/pyphare/pyphare/pharesee/hierarchy/.ipynb_checkpoints/__init__-checkpoint.py
new file mode 100644
index 000000000..318b1a24c
--- /dev/null
+++ b/pyphare/pyphare/pharesee/hierarchy/.ipynb_checkpoints/__init__-checkpoint.py
@@ -0,0 +1,46 @@
+from .scalarfield import ScalarField
+from .vectorfield import VectorField
+from .hierarchy import PatchHierarchy
+from pyphare.core.phare_utilities import listify
+
+__all__ = [
+    "ScalarField",
+    "VectorField",
+    "PatchHierarchy",
+]
+
+
+def hierarchy_from(
+    simulator=None, qty=None, pop="", h5_filename=None, times=None, hier=None, func=None, **kwargs
+):
+    from .fromh5 import hierarchy_fromh5
+    from .fromsim import hierarchy_from_sim
+    from .fromfunc import hierarchy_from_func
+
+    """
+    this function reads an HDF5 PHARE file and returns a PatchHierarchy from
+    which data is accessible.
+    if 'time' is None, all times in the file will be read, if a time is given
+    then only that time will be read
+    if 'hier' is None, then a new hierarchy will be created, if not then the
+    given hierarchy 'hier' will be filled.
+
+    The function fails if the data is already in hierarchy
+    """
+
+    if times is not None:
+        times = listify(times)
+
+    if simulator is not None and h5_filename is not None:
+        raise ValueError("cannot pass both a simulator and a h5 file")
+
+    if h5_filename is not None:
+        return hierarchy_fromh5(h5_filename, times, hier, **kwargs)
+
+    if simulator is not None and qty is not None:
+        return hierarchy_from_sim(simulator, qty, pop=pop)
+
+    if func is not None and hier is not None:
+        return hierarchy_from_func(func, hier, **kwargs)
+
+    raise ValueError("can't make hierarchy")
diff --git a/pyphare/pyphare/pharesee/hierarchy/hierarchy.py b/pyphare/pyphare/pharesee/hierarchy/hierarchy.py
index 724eb6409..3dc75660a 100644
--- a/pyphare/pyphare/pharesee/hierarchy/hierarchy.py
+++ b/pyphare/pyphare/pharesee/hierarchy/hierarchy.py
@@ -16,6 +16,40 @@ def format_timestamp(timestamp):
     return "{:.10f}".format(timestamp)
 
 
+class IndexHierarchy:
+    def __init__(self, time, hier, indexes):
+        self.time = time
+        self.hier = hier
+        self.indexes = indexes
+
+    def __str__(self):
+        s = "IndexHierarchy: \n"
+        s += "Time {}\n".format(self.time)
+        for ilvl, lvl in self.indexes.items():
+            s += "Level {}\n".format(ilvl)
+            for ip, qty_indexes in enumerate(lvl):
+                for qty_name, indexes in qty_indexes.items():
+                    s += f"    P{ip} {type} {qty_name} {indexes} \n"
+        return s
+
+
+class ValueHierarchy:
+    def __init__(self, time, hier, values):
+        self.time = time
+        self.hier = hier
+        self.values = values
+
+    def __str__(self):
+        s = "ValueHierarchy: \n"
+        s += "Time {}\n".format(self.time)
+        for ilvl, lvl in self.values.items():
+            s += "Level {}\n".format(ilvl)
+            for ip, qty_values in enumerate(lvl):
+                for qty_name, values in qty_values.items():
+                    s += f"    P{ip} {type} {qty_name} {values} \n"
+        return s
+
+
 class PatchHierarchy(object):
     """is a collection of patch levels"""
 
@@ -57,6 +91,7 @@ def __init__(
 
         self._sim = None
 
+        self.data_files = {}
         if data_files is not None and isinstance(data_files, dict):
             self.data_files = data_files
         elif data_files is not None:
@@ -64,8 +99,6 @@ def __init__(
                 self.data_files.update({data_files.filename: data_files})
             else:
                 self.data_files = {data_files.filename: data_files}
-        else:
-            self.data_files = {}
 
         self.update()
 
@@ -614,6 +647,51 @@ def dist_plot(self, **kwargs):
 
         return final, dp(final, **kwargs)
 
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        return hierarchy_array_ufunc(self, ufunc, method, *inputs, **kwargs)
+
+    def __array_function__(self, func, types, args, kwargs):
+        return hierarchy_array_function(self, func, types, args, kwargs)
+
+
+def hierarchy_array_ufunc(hier, ufunc, method, *inputs, **kwargs):
+    if method != "__call__":
+        return NotImplemented
+
+    def extract(time, ilvl):
+        return [x.level(ilvl, time) if type(x) is type(hier) else x for x in inputs]
+
+    from copy import deepcopy
+
+    ret = deepcopy(hier)
+    for time in hier.time_hier:
+        for ilvl in hier.levels(time):
+            ret.time_hier[time][ilvl] = getattr(ufunc, method)(
+                *extract(time, ilvl), **kwargs
+            )
+    return ret
+
+
+def hierarchy_array_function(hier, func, types, args, kwargs):
+    def extract(time, ilvl):
+        return [x.level(ilvl, time) if type(x) is type(hier) else x for x in args]
+
+    time_hier = {}
+    for time in hier.time_hier:
+        time_hier[time] = {}
+        for ilvl in hier.levels(time):
+            time_hier[time][ilvl] = func(*extract(time, ilvl), **kwargs)
+
+    any_level = next(iter(next(iter(time_hier.values())).values()))
+    if type(any_level[0]) is dict:
+        return time_hier  # return a dictionary of times[]
+
+    from copy import deepcopy
+
+    ret = deepcopy(hier)
+    ret.time_hier = time_hier
+    return ret
+
 
 def finest_part_data(hierarchy, time=None):
     """
diff --git a/pyphare/pyphare/pharesee/hierarchy/hierarchy_compute.py b/pyphare/pyphare/pharesee/hierarchy/hierarchy_compute.py
new file mode 100644
index 000000000..86c62f89b
--- /dev/null
+++ b/pyphare/pyphare/pharesee/hierarchy/hierarchy_compute.py
@@ -0,0 +1,57 @@
+#
+#
+#
+
+import numpy as np
+
+
+def _compute_gaussian_filter_on_scalarfield(patch_datas, **kwargs):
+    from scipy.ndimage import gaussian_filter
+
+    ndim = patch_datas["value"].box.ndim
+    nb_ghosts = patch_datas["value"].ghosts_nbr[0]
+    sigma = kwargs["sigma"]
+    ds = np.asarray(patch_datas["value"][:])
+
+    ds_ = np.full(list(ds.shape), np.nan)
+
+    gf_ = gaussian_filter(ds, sigma=sigma)
+    select = tuple([slice(nb_ghosts, -nb_ghosts) for _ in range(ndim)])
+    ds_[select] = np.asarray(gf_[select])
+
+    return (
+        {"name": "value", "data": ds_, "centering": patch_datas["value"].centerings},
+    )
+
+
+def _compute_gaussian_filter_on_vectorfield(patch_datas, **kwargs):
+    from scipy.ndimage import gaussian_filter
+
+    ref_name = next(iter(patch_datas.keys()))
+
+    ndim = patch_datas[ref_name].box.ndim
+    nb_ghosts = patch_datas[ref_name].ghosts_nbr[0]
+    sigma = kwargs["sigma"]
+    ds_x = np.asarray(patch_datas["x"][:])
+    ds_y = np.asarray(patch_datas["y"][:])
+    ds_z = np.asarray(patch_datas["z"][:])
+
+    dsx_ = np.full(list(ds_x.shape), np.nan)
+    dsy_ = np.full(list(ds_y.shape), np.nan)
+    dsz_ = np.full(list(ds_z.shape), np.nan)
+
+    gfx_ = gaussian_filter(ds_x, sigma=sigma)
+    gfy_ = gaussian_filter(ds_y, sigma=sigma)
+    gfz_ = gaussian_filter(ds_z, sigma=sigma)
+
+    select = tuple([slice(nb_ghosts, -nb_ghosts) for _ in range(ndim)])
+
+    dsx_[select] = np.asarray(gfx_[select])
+    dsy_[select] = np.asarray(gfy_[select])
+    dsz_[select] = np.asarray(gfz_[select])
+
+    return (
+        {"name": "x", "data": dsx_, "centering": patch_datas["x"].centerings},
+        {"name": "y", "data": dsy_, "centering": patch_datas["y"].centerings},
+        {"name": "z", "data": dsz_, "centering": patch_datas["z"].centerings},
+    )
diff --git a/pyphare/pyphare/pharesee/hierarchy/hierarchy_utils.py b/pyphare/pyphare/pharesee/hierarchy/hierarchy_utils.py
index d3856873d..15c4c364a 100644
--- a/pyphare/pyphare/pharesee/hierarchy/hierarchy_utils.py
+++ b/pyphare/pyphare/pharesee/hierarchy/hierarchy_utils.py
@@ -699,3 +699,64 @@ def _skip(qty):
                 else:
                     raise RuntimeError("unexpected state")
     return cier
+
+
+def plot_velocity_peaks_over_time(run, times, temperature, out_file, sigma=0):
+    """POC - not clean or finished"""
+    import matplotlib.pyplot as plt
+    from scipy.signal import find_peaks
+    from pyphare.pharesee.run.utils import _compute_to_primal
+
+    def get_velocities():
+        for it, t in enumerate(times):
+            Vi = run.GetVi(t)[:]
+            if sigma > 0:
+                Vi = Vi.gaussian(sigma)
+            xV = Vi.level(0, t)[0]["x"].x[2:-2]  # constant
+            v = Vi.level(0, t)[0]["x"].dataset[2:-2]  # nans on borders
+
+            if np.isnan(np.sum(v)):
+                print("summary")
+                print("nan", np.count_nonzero(np.isnan(v)))
+                print("notnan", np.count_nonzero(~np.isnan(v)))
+                raise RuntimeError("Nan!")
+
+            if it == 0:
+                vt = np.zeros((len(v), len(times)))
+            vt[:, it] = v
+
+        return xV, vt
+
+    def get_peaks(x, Vs):
+        nt = Vs.shape[1]
+        positions = np.zeros((nt, 2))
+        amplitudes = np.zeros((nt, 2))
+        for it in range(nt):
+            ps = find_peaks(Vs[:, it], height=0.010)
+            if len(ps[0]) == 1:
+                positions[it, 0] = x[ps[0][0]]
+                positions[it, 1] = x[ps[0][0]]
+                amplitudes[it, 0] = Vs[ps[0][0], it]
+                amplitudes[it, 1] = Vs[ps[0][0], it]
+            else:
+                positions[it, 0] = x[ps[0][0]]
+                positions[it, 1] = x[ps[0][1]]
+                amplitudes[it, 0] = Vs[ps[0][0], it]
+                amplitudes[it, 1] = Vs[ps[0][1], it]
+        return positions, amplitudes
+
+    x, Vs = get_velocities()
+    positions, amplitudes = get_peaks(x, Vs)
+
+    fig, ax = plt.subplots()
+
+    for it, t in enumerate(times):
+        ax.plot(x, Vs[:, it], label=r"t={:6.4f}".format(t))
+        ax.set_ylim((-0.03, 0.1))
+        ax.axhline(0, ls="--", color="k")
+        for p in positions[it, :]:
+            ax.axvline(p, color="gray", ls="-.")
+    ax.set_title("$T_e$ = {:6.4f}".format(temperature))
+    ax.legend()
+
+    fig.savefig(out_file)
diff --git a/pyphare/pyphare/pharesee/hierarchy/patch.py b/pyphare/pyphare/pharesee/hierarchy/patch.py
index 0ac18f3d8..ee135fb84 100644
--- a/pyphare/pyphare/pharesee/hierarchy/patch.py
+++ b/pyphare/pyphare/pharesee/hierarchy/patch.py
@@ -38,7 +38,9 @@ def __repr__(self):
         return self.__str__()
 
     def __getitem__(self, key):
-        return self.patch_datas[key]
+        if key in self.patch_datas:
+            return self.patch_datas[key]
+        raise IndexError(f"No patchdata for key: {key} in {self.patch_datas}")
 
     def copy(self):
         """does not copy patchdatas.datasets (see class PatchData)"""
@@ -67,3 +69,39 @@ def __call__(self, qty, **kwargs):
             return pd.dataset[idx + nbrGhosts, nbrGhosts:-nbrGhosts]
         elif idim == 1:
             return pd.dataset[nbrGhosts:-nbrGhosts, idx + nbrGhosts]
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        return patch_array_ufunc(self, ufunc, method, *inputs, **kwargs)
+
+    def __array_function__(self, func, types, args, kwargs):
+        return patch_array_function(self, func, types, args, kwargs)
+
+
+def patch_array_ufunc(patch, ufunc, method, *inputs, **kwargs):
+    if method != "__call__":
+        return NotImplemented
+
+    def extract(key):
+        return [x.patch_datas[key] if type(x) is type(patch) else x for x in inputs]
+
+    patch_datas = {
+        key: getattr(ufunc, method)(*extract(key), **kwargs)
+        for key in patch.patch_datas
+    }
+    return type(patch)(
+        patch_datas, patch_id=patch.id, layout=patch.layout, attrs=patch.attrs
+    )
+
+
+def patch_array_function(patch, func, types, args, kwargs):
+    def extract(key):
+        return [x.patch_datas[key] if type(x) is type(patch) else x for x in args]
+
+    final = {key: func(*extract(key), **kwargs) for key in patch.patch_datas}
+    any_patch_data = next(iter(patch.patch_datas.values()))
+    any_data = next(iter(final.values()))
+
+    if type(any_patch_data) is not type(any_data):
+        return final
+
+    return type(patch)(final, patch_id=patch.id, layout=patch.layout, attrs=patch.attrs)
diff --git a/pyphare/pyphare/pharesee/hierarchy/patchdata.py b/pyphare/pyphare/pharesee/hierarchy/patchdata.py
index 7c4801b28..70b867b6b 100644
--- a/pyphare/pyphare/pharesee/hierarchy/patchdata.py
+++ b/pyphare/pyphare/pharesee/hierarchy/patchdata.py
@@ -1,8 +1,12 @@
+#
+#
+#
+
 import numpy as np
 
-from ...core import phare_utilities as phut
+from ...core import gridlayout
 from ...core import box as boxm
-from ...core.box import Box
+from ...core import phare_utilities as phut
 
 
 class PatchData:
@@ -35,38 +39,20 @@ class FieldData(PatchData):
 
     @property
     def x(self):
-        withGhosts = self.field_name != "tags"
         if self._x is None:
-            self._x = self.layout.yeeCoordsFor(
-                self.field_name,
-                "x",
-                withGhosts=withGhosts,
-                centering=self.centerings[0],
-            )
+            self._x = self.yeeCoordsFor(0)
         return self._x
 
     @property
     def y(self):
-        withGhosts = self.field_name != "tags"
         if self._y is None:
-            self._y = self.layout.yeeCoordsFor(
-                self.field_name,
-                "y",
-                withGhosts=withGhosts,
-                centering=self.centerings[1],
-            )
+            self._y = self.yeeCoordsFor(1)
         return self._y
 
     @property
     def z(self):
-        withGhosts = self.field_name != "tags"
         if self._z is None:
-            self._z = self.layout.yeeCoordsFor(
-                self.field_name,
-                "z",
-                withGhosts=withGhosts,
-                centering=self.centerings[2],
-            )
+            self._z = self.yeeCoordsFor(2)
         return self._z
 
     def primal_directions(self):
@@ -91,12 +77,16 @@ def __eq__(self, that):
     def __ne__(self, that):
         return not (self == that)
 
-    def select(self, box):
+    def select(self, box_or_slice):
         """
         return view of internal data based on overlap of input box
            returns a view +1 in size in primal directions
         """
-        assert isinstance(box, Box) and box.ndim == self.box.ndim
+        if isinstance(box_or_slice, (slice, list, tuple)):
+            return self.dataset[box_or_slice]
+
+        box = box_or_slice
+        assert isinstance(box, boxm.Box) and box.ndim == self.box.ndim
 
         gbox = self.ghost_box.copy()
         gbox.upper += self.primal_directions()
@@ -114,8 +104,6 @@ def select(self, box):
         return np.array([])
 
     def __getitem__(self, box_or_slice):
-        if isinstance(box_or_slice, slice):
-            return self.dataset[box_or_slice]
         return self.select(box_or_slice)
 
     def __setitem__(self, box_or_slice, val):
@@ -132,38 +120,15 @@ def __init__(self, layout, field_name, data, **kwargs):
         self._y = None
         self._z = None
 
+        self.dl = np.asarray(layout.dl)
         self.field_name = field_name
         self.name = field_name
-        self.dl = np.asarray(layout.dl)
         self.ndim = layout.box.ndim
-        self.ghosts_nbr = np.zeros(self.ndim, dtype=int)
 
-        if field_name in layout.centering["X"]:
-            directions = ["X", "Y", "Z"][: layout.box.ndim]  # drop unused directions
-            self.centerings = [
-                layout.qtyCentering(field_name, direction) for direction in directions
-            ]
-        elif "centering" in kwargs:
-            if isinstance(kwargs["centering"], list):
-                self.centerings = kwargs["centering"]
-                assert len(self.centerings) == self.ndim
-            else:
-                if self.ndim != 1:
-                    raise ValueError(
-                        "FieldData invalid dimenion for centering argument, expected list for dim > 1"
-                    )
-                self.centerings = [kwargs["centering"]]
-        else:
-            raise ValueError(
-                f"centering not specified and cannot be inferred from field name : {field_name}"
-            )
-
-        if self.field_name != "tags":
-            for i, centering in enumerate(self.centerings):
-                self.ghosts_nbr[i] = layout.nbrGhosts(layout.interp_order, centering)
+        self.centerings = self._resolve_centering(**kwargs)
+        self.ghosts_nbr = self._resolve_ghost_nbr(**kwargs)
 
         self.ghost_box = boxm.grow(layout.box, self.ghosts_nbr)
-
         self.size = np.copy(self.ghost_box.shape)
         self.offset = np.zeros(self.ndim)
 
@@ -189,6 +154,88 @@ def grid():
             return tuple(g[select] for g in mesh)
         return mesh
 
+    def yeeCoordsFor(self, idx):
+        return self.layout.yeeCoordsFor(
+            self.field_name,
+            gridlayout.directions[idx],
+            withGhosts=any(self.ghosts_nbr) and self.field_name != "tags",
+            centering=self.centerings[idx],
+            nbrGhosts=self.ghosts_nbr,
+        )
+
+    def _resolve_ghost_nbr(self, **kwargs):
+        layout = self.layout
+        ghosts_nbr = kwargs.get("ghosts_nbr", np.zeros(self.ndim, dtype=int))
+        if "ghosts_nbr" not in kwargs:
+            if self.field_name != "tags":
+                for i, centering in enumerate(self.centerings):
+                    ghosts_nbr[i] = layout.nbrGhosts(layout.interp_order, centering)
+        return phut.np_array_ify(ghosts_nbr, layout.box.ndim)
+
+    def _resolve_centering(self, **kwargs):
+        field_name = self.field_name
+        if "centering" in kwargs:
+            if isinstance(kwargs["centering"], list):
+                assert len(kwargs["centering"]) == self.ndim
+                return kwargs["centering"]
+            else:
+                if self.ndim != 1:
+                    raise ValueError(
+                        "FieldData invalid dimenion for centering argument, expected list for dim > 1"
+                    )
+                return phut.listify(kwargs["centering"])
+
+        if field_name in self.layout.centering["X"]:
+            directions = ["X", "Y", "Z"][: self.ndim]  # drop unused directions
+            return [
+                self.layout.qtyCentering(field_name, direction)
+                for direction in directions
+            ]
+        raise ValueError(
+            f"centering not specified and cannot be inferred from field name : {field_name}"
+        )
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        return field_data_array_ufunc(self, ufunc, method, *inputs, **kwargs)
+
+    def __array_function__(self, func, types, args, kwargs):
+        return field_data_array_function(self, func, types, args, kwargs)
+
+
+def field_data_array_ufunc(patch_data, ufunc, method, *inputs, **kwargs):
+    if method != "__call__":
+        return NotImplemented
+
+    in_ = [i.dataset if isinstance(i, FieldData) else i for i in inputs]
+    out_ = getattr(ufunc, method)(*in_, **kwargs)
+
+    if isinstance(out_, np.ndarray) and out_.shape == patch_data.dataset.shape:
+        return type(patch_data)(
+            layout=patch_data.layout,
+            field_name=patch_data.field_name,
+            data=out_,
+            centering=patch_data.centerings,
+            ghosts_nbr=patch_data.ghosts_nbr,
+        )
+
+    return out_
+
+
+def field_data_array_function(patch_data, func, types, args, kwargs):
+    in_ = [a.dataset if isinstance(a, FieldData) else a for a in args]
+    out_ = func(*in_, **kwargs)
+
+    if isinstance(out_, np.ndarray) and out_.shape == patch_data.dataset.shape:
+        return type(patch_data)(
+            layout=patch_data.layout,
+            field_name=patch_data.field_name,
+            data=out_,
+            centering=patch_data.centerings,
+            ghosts_nbr=patch_data.ghosts_nbr,
+        )
+
+    return out_
+
 
 class ParticleData(PatchData):
     """
diff --git a/pyphare/pyphare/pharesee/hierarchy/patchlevel.py b/pyphare/pyphare/pharesee/hierarchy/patchlevel.py
index 72fee0d5d..59fad3eb8 100644
--- a/pyphare/pyphare/pharesee/hierarchy/patchlevel.py
+++ b/pyphare/pyphare/pharesee/hierarchy/patchlevel.py
@@ -1,3 +1,8 @@
+#
+#
+#
+
+
 class PatchLevel:
     """is a collection of patches"""
 
@@ -13,3 +18,42 @@ def level_range(self):
         return min([patch.patch_datas[name].x.min() for patch in self.patches]), max(
             [patch.patch_datas[name].x.max() for patch in self.patches]
         )
+
+    def __getitem__(self, idx):
+        if type(idx) is int:
+            return self.patches[idx]
+        raise IndexError(f"PatchLevel::__getitem__ unhandled input type: {type(idx)}")
+
+    @property
+    def cell_width(self):
+        return self.patches[0].layout.dl
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        return patch_level_array_ufunc(self, ufunc, method, *inputs, **kwargs)
+
+    def __array_function__(self, func, types, args, kwargs):
+        return patch_level_array_function(self, func, types, args, kwargs)
+
+
+def patch_level_array_ufunc(patch_level, ufunc, method, *inputs, **kwargs):
+    if method != "__call__":
+        return NotImplemented
+
+    def extract(pidx):
+        return [x.patches[pidx] if type(x) is type(patch_level) else x for x in inputs]
+
+    out = [
+        getattr(ufunc, method)(*extract(pidx), **kwargs)
+        for pidx in range(len(patch_level.patches))
+    ]
+    return type(patch_level)(patch_level.level_number, out)
+
+
+def patch_level_array_function(patch_level, func, types, args, kwargs):
+    def extract(pidx):
+        return [x.patches[pidx] if type(x) is type(patch_level) else x for x in args]
+
+    out = [func(*extract(pidx), **kwargs) for pidx in range(len(patch_level.patches))]
+    if type(out[0]) is not type(patch_level[0]):
+        return out
+    return type(patch_level)(patch_level.level_number, out)
diff --git a/pyphare/pyphare/pharesee/hierarchy/scalarfield.py b/pyphare/pyphare/pharesee/hierarchy/scalarfield.py
index f8691098d..d2757842e 100644
--- a/pyphare/pyphare/pharesee/hierarchy/scalarfield.py
+++ b/pyphare/pyphare/pharesee/hierarchy/scalarfield.py
@@ -1,18 +1,22 @@
-from .hierarchy import PatchHierarchy
+#
+#
+#
+
+
+from . import tensorfield
+from . import hierarchy_compute as hc
+from . import hierarchy_utils as hootils
 from .hierarchy_utils import compute_hier_from, compute_rename, rename, _compute_neg
 
 
-class ScalarField(PatchHierarchy):
-    def __init__(self, hier):
-        renamed_hier = compute_hier_from(compute_rename, hier, new_names=("value",))
-        patch_levels = renamed_hier.patch_levels
-        domain_box = renamed_hier.domain_box
-        refinement_ratio = renamed_hier.refinement_ratio
-        data_files = renamed_hier.data_files
+class ScalarField(tensorfield.AnyTensorField):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
 
-        super().__init__(
-            patch_levels, domain_box, refinement_ratio, renamed_hier.times(), data_files
-        )
+    @classmethod
+    def FROM(cls, hier):
+        renamed_hier = compute_hier_from(compute_rename, hier, new_names=("value",))
+        return super().FROM(cls, renamed_hier)
 
     def __add__(self, other):
         assert isinstance(other, (ScalarField, int, float))
@@ -29,7 +33,7 @@ def __add__(self, other):
         else:
             raise RuntimeError("right operand not supported")
 
-        return ScalarField(h)
+        return ScalarField.FROM(h)
 
     def __radd__(self, other):
         return self.__add__(other)
@@ -49,7 +53,7 @@ def __sub__(self, other):
         else:
             raise RuntimeError("right operand not supported")
 
-        return ScalarField(h)
+        return ScalarField.FROM(h)
 
     def __mul__(self, other):
         assert isinstance(other, (ScalarField, int, float))
@@ -63,7 +67,7 @@ def __mul__(self, other):
         else:
             raise RuntimeError("right operand not supported")
 
-        return ScalarField(h)
+        return ScalarField.FROM(h)
 
     def __rmul__(self, other):
         return self.__mul__(other)
@@ -80,7 +84,7 @@ def __truediv__(self, other):
         else:
             raise RuntimeError("right operand not supported")
 
-        return ScalarField(h)
+        return ScalarField.FROM(h)
 
     def __rtruediv__(self, other):
         assert isinstance(other, (int, float))
@@ -88,7 +92,7 @@ def __rtruediv__(self, other):
 
         h = compute_hier_from(self._compute_rtruediv, (h_self,), other=other)
 
-        return ScalarField(h)
+        return ScalarField.FROM(h)
 
     def _compute_add(self, patch_datas, **kwargs):
         ref_name = next(iter(patch_datas.keys()))
@@ -209,4 +213,14 @@ def _compute_rtruediv(self, patch_datas, **kwargs):
     def __neg__(self):
         names_self = self.quantities()
         h = compute_hier_from(_compute_neg, self, new_names=names_self)
-        return ScalarField(h)
+        return ScalarField.FROM(h)
+
+    def gaussian(self, sigma=2):
+        return ScalarField.FROM(
+            hootils.compute_hier_from(
+                hc._compute_gaussian_filter_on_scalarfield,
+                self,
+                sigma=sigma,
+                qty=next(iter(self.quantities())),
+            )
+        )
diff --git a/pyphare/pyphare/pharesee/hierarchy/tensorfield.py b/pyphare/pyphare/pharesee/hierarchy/tensorfield.py
new file mode 100644
index 000000000..dfef9802f
--- /dev/null
+++ b/pyphare/pyphare/pharesee/hierarchy/tensorfield.py
@@ -0,0 +1,194 @@
+#
+#
+#
+
+import numpy as np
+from copy import deepcopy
+
+
+from pyphare.core.box import Box
+from .hierarchy import PatchHierarchy
+from .hierarchy import ValueHierarchy
+from .hierarchy import IndexHierarchy
+
+from .patch import Patch
+from . import hierarchy_utils as hootils
+
+
+class AnyTensorField(PatchHierarchy):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @staticmethod
+    def FROM(cls, hier):
+        return cls(
+            hier.patch_levels,
+            hier.domain_box,
+            hier.refinement_ratio,
+            hier.times(),
+            hier.data_files,
+        )
+
+    def __getitem__(self, input):
+        cls = type(input)
+        if cls is Box or cls is slice:
+            return get_interpolated_selection_from(self, input)
+        if cls is IndexHierarchy:
+            return get_from_index_hierarchy(self, input)
+        if input in self.__dict__:
+            return self.__dict__[input]
+        raise IndexError("AnyTensorField.__getitem__ cannot handle input", input)
+
+    def peak_coordinates(self, qty=None, **kwargs):
+        return peak_coordinates(self, qty, **kwargs)
+
+    def find_peaks(self, qty=None, **kwargs):
+        return find_peaks(self, qty, **kwargs)
+
+    def as_peaks(self, qty=None, **kwargs):
+        return as_peaks(self, qty, **kwargs)
+
+
+def GetDomainSize(hier, **kwargs):
+    root_cell_width = hier.level(0).cell_width
+    domain_box = hier.domain_box
+    return (domain_box.upper + 1) * root_cell_width
+
+
+def GetDl(hier, time, level="finest"):
+    level = hier.finest_level(time) if level == "finest" else level
+    return hier.level(level, time).cell_width
+
+
+def peak_coordinates(hier: AnyTensorField, qty, **kwargs):
+    domain = GetDomainSize(hier)
+    peaks, _ = find_peaks(hier, qty, **kwargs)
+    dl = GetDl(hier, hier.times()[0])
+    return peaks * dl[0]  # only works for 1D!
+
+
+def find_peaks(hier: AnyTensorField, qty, **kwargs):
+    # https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.find_peaks.html
+
+    if hier.ndim > 1:
+        raise ValueError("AnyTensorField::find_peaks only supports 1d simulations")
+    if not qty or qty not in hier.quantities():
+        raise ValueError(f"AnyTensorField::find_peaks unknown quantity: {qty}")
+
+    from scipy.signal import find_peaks
+
+    times = hier.times()
+    if len(times) > 1:
+        raise ValueError("AnyTensorField::find_peaks does not support multiple times")
+
+    levels = hier.levels(times[0])
+    if len(levels) > 1:
+        raise ValueError("AnyTensorField::find_peaks does not support multiple levels")
+    if len(next(iter(levels.values())).patches) > 1:
+        raise ValueError("AnyTensorField::find_peaks does not support multiple patches")
+
+    patch = next(iter(levels.values())).patches[0]
+    for k, v in patch.patch_datas.items():
+        if qty == k:
+            peaks, props = find_peaks(v.dataset[:], **kwargs)
+            if "peak_heights" in props:
+                return peaks, props["peak_heights"]
+            return peaks, props
+
+    raise ValueError("AnyTensorField::find_peaks found nothing")
+
+
+def as_peaks(hier: AnyTensorField, qty=None, **kwargs):
+    if hier.ndim > 1:
+        raise ValueError("AnyTensorField::find_peaks only supports 1d simulations")
+    if qty and qty not in hier.quantities():
+        raise ValueError(f"AnyTensorField::find_peaks unknown quantitiy: {qty}")
+
+    from scipy.signal import find_peaks
+
+    times = hier.times()
+    if len(times) > 1:
+        raise ValueError("AnyTensorField::find_peaks does not support multiple times")
+
+    indexes = {}
+    for ilvl, lvl in hier.levels(times[0]).items():
+        indexes[ilvl] = []
+        for patch in lvl:
+            peaks = {}
+            for k, v in patch.patch_datas.items():
+                if qty is None or qty == k:
+                    peaks[k] = find_peaks(v.dataset[:], **kwargs)[0]
+            indexes[ilvl].append(peaks)
+    return IndexHierarchy(times[0], hier, indexes)
+
+
+def get_from_index_hierarchy(hier, index_hier):
+    if hier != index_hier.hier:
+        raise ValueError(
+            "AnyTensorField::get_from_index_hierarchy cannot operate on two different hierarchies"
+        )
+
+    values = {}
+    for ilvl, lvl in index_hier.indexes.items():
+        patch_level = hier.level(ilvl, index_hier.time)
+        values[ilvl] = []
+        for idx, indexes in enumerate(lvl):
+            data = {}
+            patch = patch_level[idx]
+            for k, v in indexes.items():
+                if k in patch.patch_datas:
+                    data[k] = patch[k].dataset[v]
+            values[ilvl].append(data)
+    return ValueHierarchy(index_hier.time, hier, values)
+
+
+def get_interpolated_selection_from(hier: AnyTensorField, input, interp="nearest"):
+    if type(hier) is PatchHierarchy:
+        raise ValueError("PatchHierarchy not supported, must be AnyTensorField")
+
+    times = hier.times()
+    if len(times) > 1:
+        raise ValueError(
+            "AnyTensorField interpoloation does not support multiple times"
+        )
+
+    from pyphare.pharesee.run import utils as rutils
+
+    time = times[0]
+
+    dl = GetDl(hier, time)
+    domain = GetDomainSize(hier)
+
+    cpy = deepcopy(hier)
+    levels = cpy.levels(time)
+    level0 = levels[0]
+    patch0 = level0.patches[0]
+
+    patch0.layout.box = hier.level_domain_box(len(levels) - 1)  # hax todo etc
+    patch0.layout.dl = dl
+    patch0.layout.origin = dl * 0
+
+    new_patch0 = Patch({}, patch0.id, patch0.layout)
+
+    nbrGhosts = list(hier.level(0).patches[0].patch_datas.values())[0].ghosts_nbr
+    for qty in hier.quantities():
+        data, coords = hootils.flat_finest_field(hier, qty, time=time)
+        interpolator, finest_coords = rutils.make_interpolator(
+            data, coords, interp, domain, dl, qty, nbrGhosts
+        )
+
+        mesh = np.meshgrid(*finest_coords, indexing="ij")
+
+        pdata = type(patch0[qty])(
+            layout=patch0.layout,
+            field_name=patch0[qty].name,
+            data=interpolator(*mesh),
+            ghosts_nbr=nbrGhosts,
+            centering=patch0[qty].centerings,
+        )
+        new_patch0.patch_datas[qty] = pdata
+
+    level0.patches = [new_patch0]
+    cpy.time_hier[time] = {0: level0}
+
+    return cpy
diff --git a/pyphare/pyphare/pharesee/hierarchy/vectorfield.py b/pyphare/pyphare/pharesee/hierarchy/vectorfield.py
index e9afa59ba..909f1de97 100644
--- a/pyphare/pyphare/pharesee/hierarchy/vectorfield.py
+++ b/pyphare/pyphare/pharesee/hierarchy/vectorfield.py
@@ -1,4 +1,7 @@
-from .hierarchy import PatchHierarchy
+#
+#
+#
+
 from .hierarchy_utils import (
     compute_hier_from,
     compute_rename,
@@ -11,27 +14,27 @@
 )
 from .scalarfield import ScalarField
 
+from . import tensorfield
+from . import hierarchy_compute as hc
+from . import hierarchy_utils as hootils
 
-class VectorField(PatchHierarchy):
-    def __init__(self, hier):
-        renamed_hier = compute_hier_from(
-            compute_rename, hier, new_names=("x", "y", "z")
-        )
-        patch_levels = renamed_hier.patch_levels
-        domain_box = renamed_hier.domain_box
-        refinement_ratio = renamed_hier.refinement_ratio
-        data_files = renamed_hier.data_files
 
+class VectorField(tensorfield.AnyTensorField):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self.names = ["x", "y", "z"]
 
-        super().__init__(
-            patch_levels, domain_box, refinement_ratio, renamed_hier.times(), data_files
+    @classmethod
+    def FROM(cls, hier):
+        renamed_hier = compute_hier_from(
+            compute_rename, hier, new_names=("x", "y", "z")
         )
+        return super().FROM(cls, renamed_hier)
 
     def __mul__(self, other):
         assert isinstance(other, (int, float))
         h = compute_hier_from(_compute_mul, self, names=["x", "y", "z"], other=other)
-        return VectorField(h)
+        return VectorField.FROM(h)
 
     def __rmul__(self, other):
         return self.__mul__(other)
@@ -57,7 +60,7 @@ def __add__(self, other):
         self = rename(h_self, names_self_kept)  # needed ?
         other = rename(h_other, names_other_kept)
 
-        return VectorField(h)
+        return VectorField.FROM(h)
 
     def __sub__(self, other):
         names_self_kept = self.quantities()
@@ -80,21 +83,28 @@ def __sub__(self, other):
         self = rename(h_self, names_self_kept)
         other = rename(h_other, names_other_kept)
 
-        return VectorField(h)
+        return VectorField.FROM(h)
 
     def __truediv__(self, other):
         if not isinstance(other, (ScalarField, int, float)):
             raise RuntimeError("type of operand not considered")
 
         if isinstance(other, ScalarField):
-            return VectorField(
+            return VectorField.FROM(
                 compute_hier_from(
                     _compute_truediv, (self, other), res_names=("x", "y", "z")
                 )
             )
         elif isinstance(other, (int, float)):
-            return VectorField(
+            return VectorField.FROM(
                 compute_hier_from(
                     _compute_scalardiv, (self,), res_names=("x", "y", "z"), scalar=other
                 )
             )
+
+    def gaussian(self, sigma=2):
+        return VectorField.FROM(
+            hootils.compute_hier_from(
+                hc._compute_gaussian_filter_on_vectorfield, self, sigma=sigma
+            )
+        )
diff --git a/pyphare/pyphare/pharesee/run/run.py b/pyphare/pyphare/pharesee/run/run.py
index ce6ca3794..3b90c6c3d 100644
--- a/pyphare/pyphare/pharesee/run/run.py
+++ b/pyphare/pyphare/pharesee/run/run.py
@@ -97,7 +97,7 @@ def GetB(self, time, merged=False, interp="nearest", all_primal=True, **kwargs):
             return self._get(hier, time, merged, interp)
 
         h = compute_hier_from(_compute_to_primal, hier, x="Bx", y="By", z="Bz")
-        return VectorField(h)
+        return VectorField.FROM(h)
 
     def GetE(self, time, merged=False, interp="nearest", all_primal=True, **kwargs):
         if merged:
@@ -107,27 +107,27 @@ def GetE(self, time, merged=False, interp="nearest", all_primal=True, **kwargs):
             return self._get(hier, time, merged, interp)
 
         h = compute_hier_from(_compute_to_primal, hier, x="Ex", y="Ey", z="Ez")
-        return VectorField(h)
+        return VectorField.FROM(h)
 
     def GetMassDensity(self, time, merged=False, interp="nearest", **kwargs):
         hier = self._get_hierarchy(time, "ions_mass_density.h5", **kwargs)
-        return ScalarField(self._get(hier, time, merged, interp))
+        return ScalarField.FROM(self._get(hier, time, merged, interp))
 
     def GetNi(self, time, merged=False, interp="nearest", **kwargs):
         hier = self._get_hierarchy(time, "ions_charge_density.h5", **kwargs)
-        return ScalarField(self._get(hier, time, merged, interp))
+        return ScalarField.FROM(self._get(hier, time, merged, interp))
 
     def GetN(self, time, pop_name, merged=False, interp="nearest", **kwargs):
         hier = self._get_hierarchy(time, f"ions_pop_{pop_name}_density.h5", **kwargs)
-        return ScalarField(self._get(hier, time, merged, interp))
+        return ScalarField.FROM(self._get(hier, time, merged, interp))
 
     def GetVi(self, time, merged=False, interp="nearest", **kwargs):
         hier = self._get_hierarchy(time, "ions_bulkVelocity.h5", **kwargs)
-        return VectorField(self._get(hier, time, merged, interp))
+        return VectorField.FROM(self._get(hier, time, merged, interp))
 
     def GetFlux(self, time, pop_name, merged=False, interp="nearest", **kwargs):
         hier = self._get_hierarchy(time, f"ions_pop_{pop_name}_flux.h5", **kwargs)
-        return VectorField(self._get(hier, time, merged, interp))
+        return VectorField.FROM(self._get(hier, time, merged, interp))
 
     def GetPressure(self, time, pop_name, merged=False, interp="nearest", **kwargs):
         M = self._get_hierarchy(
@@ -159,7 +159,7 @@ def GetPe(self, time, merged=False, interp="nearest", all_primal=True):
             return Te * self._get(hier, time, merged, interp)
 
         h = compute_hier_from(_compute_to_primal, hier, scalar="rho")
-        return ScalarField(h) * Te
+        return ScalarField.FROM(h) * Te
 
     def GetJ(self, time, merged=False, interp="nearest", all_primal=True, **kwargs):
         if merged:
@@ -169,12 +169,12 @@ def GetJ(self, time, merged=False, interp="nearest", all_primal=True, **kwargs):
         if not all_primal:
             return self._get(J, time, merged, interp)
         h = compute_hier_from(_compute_to_primal, J, x="Jx", y="Jy", z="Jz")
-        return VectorField(h)
+        return VectorField.FROM(h)
 
     def GetDivB(self, time, merged=False, interp="nearest", **kwargs):
         B = self.GetB(time, all_primal=False, **kwargs)
         db = compute_hier_from(_compute_divB, B)
-        return ScalarField(self._get(db, time, merged, interp))
+        return ScalarField.FROM(self._get(db, time, merged, interp))
 
     def GetRanks(self, time, merged=False, interp="nearest", **kwargs):
         """
@@ -185,7 +185,7 @@ def GetRanks(self, time, merged=False, interp="nearest", **kwargs):
         """
         B = self.GetB(time, all_primal=False, **kwargs)
         ranks = compute_hier_from(_get_rank, B)
-        return ScalarField(self._get(ranks, time, merged, interp))
+        return ScalarField.FROM(self._get(ranks, time, merged, interp))
 
     def GetParticles(self, time, pop_name, hier=None, **kwargs):
         def filename(name):
@@ -220,7 +220,9 @@ def GetMass(self, pop_name, **kwargs):
     def GetDomainSize(self, **kwargs):
         import h5py
 
-        data_file = h5py.File(self.available_diags[0], "r")  # That is the first file in th available diags
+        data_file = h5py.File(
+            self.available_diags[0], "r"
+        )  # That is the first file in th available diags
         root_cell_width = np.asarray(data_file.attrs["cell_width"])
 
         return (data_file.attrs["domain_box"] + 1) * root_cell_width
@@ -265,7 +267,7 @@ def _get_time():
                 return root_cell_width / fac
 
             except KeyError:
-                ...  # time may not be avilaable for given quantity
+                ...  # time may not be available for given quantity
 
         raise RuntimeError("Unable toGetDl")
 
@@ -281,7 +283,8 @@ def all_times(self):
             time = np.zeros(len(time_keys))
             for it, t in enumerate(time_keys):
                 time[it] = float(t)
-            ts[quantities_per_file[basename]] = time
+            if basename in quantities_per_file:
+                ts[quantities_per_file[basename]] = time
             ff.close()
         return ts
 
diff --git a/pyphare/pyphare/pharesee/run/utils.py b/pyphare/pyphare/pharesee/run/utils.py
index d6ffac24c..be492b879 100644
--- a/pyphare/pyphare/pharesee/run/utils.py
+++ b/pyphare/pyphare/pharesee/run/utils.py
@@ -462,9 +462,9 @@ def make_interpolator(data, coords, interp, domain, dl, qty, nbrGhosts):
             coords, data, kind=interp, fill_value="extrapolate", assume_sorted=False
         )
 
-        nx = 1 + int(domain[0] / dl[0])
+        nx = int(domain[0] / dl[0])
 
-        x = yeeCoordsFor([0] * dim, nbrGhosts, dl, [nx], qty, "x")
+        x = yeeCoordsFor([0] * dim, nbrGhosts[0], dl, [nx], qty, "x", withGhosts=True)
         finest_coords = (x,)
 
     elif dim == 2:
@@ -478,8 +478,8 @@ def make_interpolator(data, coords, interp, domain, dl, qty, nbrGhosts):
             raise ValueError("interp can only be 'nearest' or 'bilinear'")
 
         nCells = [1 + int(d / dl) for d, dl in zip(domain, dl)]
-        x = yeeCoordsFor([0] * dim, nbrGhosts, dl, nCells, qty, "x")
-        y = yeeCoordsFor([0] * dim, nbrGhosts, dl, nCells, qty, "y")
+        x = yeeCoordsFor([0] * dim, nbrGhosts[0], dl, nCells, qty, "x", withGhosts=True)
+        y = yeeCoordsFor([0] * dim, nbrGhosts[1], dl, nCells, qty, "y", withGhosts=True)
         # x = np.arange(0, domain[0]+dl[0], dl[0])
         # y = np.arange(0, domain[1]+dl[1], dl[1])
         finest_coords = (x, y)
diff --git a/pyphare/pyphare_tests/test_pharesee/test_hierarchy.py b/pyphare/pyphare_tests/test_pharesee/test_hierarchy.py
index edd8a7fbd..82cfda1c9 100644
--- a/pyphare/pyphare_tests/test_pharesee/test_hierarchy.py
+++ b/pyphare/pyphare_tests/test_pharesee/test_hierarchy.py
@@ -10,12 +10,12 @@
 from pyphare.core.operators import dot, cross, sqrt, modulus, grad
 
 diag_outputs = "phare_outputs/"
-time_step_nbr = 20
+time_step_nbr = 2
 time_step = 0.005
 final_time = time_step * time_step_nbr
 dt = 10 * time_step
 nt = int(final_time / dt) + 1
-timestamps = dt * np.arange(nt)
+timestamps = [0, final_time]
 
 
 @ddt
@@ -159,7 +159,7 @@ def _test_data_is_a_hierarchy(self):
 
     def _test_can_read_multiple_times(self):
         r = Run(self.diag_dir())
-        times = (0.0, 0.1)
+        times = timestamps
         B = r.GetB(times)
         E = r.GetE(times)
         Ni = r.GetNi(times)
diff --git a/res/convert_to_script.py b/res/convert_to_script.py
new file mode 100644
index 000000000..28b37a649
--- /dev/null
+++ b/res/convert_to_script.py
@@ -0,0 +1 @@
+convert_to_script.py
diff --git a/res/convert_to_tutorial.py b/res/convert_to_tutorial.py
new file mode 100644
index 000000000..15947d887
--- /dev/null
+++ b/res/convert_to_tutorial.py
@@ -0,0 +1 @@
+convert_to_tutorial.py
diff --git a/res/eg/1d/jupyter/strong/strong.ipynb b/res/eg/1d/jupyter/strong/strong.ipynb
new file mode 100644
index 000000000..3ba125c21
--- /dev/null
+++ b/res/eg/1d/jupyter/strong/strong.ipynb
@@ -0,0 +1,674 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "dd273196-9b25-466f-a10e-c74f2a261cff",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-22T14:15:51.475957Z",
+     "iopub.status.busy": "2024-05-22T14:15:51.475605Z",
+     "iopub.status.idle": "2024-05-22T14:15:51.479454Z",
+     "shell.execute_reply": "2024-05-22T14:15:51.478855Z",
+     "shell.execute_reply.started": "2024-05-22T14:15:51.475941Z"
+    }
+   },
+   "source": [
+    "Strong perturbation\n",
+    "==================="
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8f8c4e3-0501-4d54-805b-22f985268e27",
+   "metadata": {},
+   "source": [
+    "In this numerical experiment, one considers the propagation of a **strong** perturbation in a collisionless plasma model.\n",
+    "The perturbation is initiated by sinusoidal velocity with an amplitude on the order of the ion acoustic velocity.\n",
+    "The wavelength of this sinusoid is equal to the size of the simulation domain and moving in the $x$ direction.\n",
+    "\n",
+    "The perturbation being strong, things will not occure in a linear way and we aim at understanding how this velocity fluctuation is developping."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "71fddce6-4c1c-4b6b-8cb6-9f55d41b7053",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import sys"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d9c4bce6-7b43-473a-8345-353aa0c11207",
+   "metadata": {},
+   "source": [
+    "The paths below have eventually to be modified, depending on where you install the src of this practical training as well as the PHARE code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "35208823-fbf1-479d-b717-3b78d8706a09",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "home = os.environ['HOME']\n",
+    "work_path = os.path.join(home, 'far/farTeach/2026/strong')\n",
+    "src_path = os.path.join(home, 'far/PHARE')\n",
+    "build_path = os.path.join(home, 'far/builds/release/ufunc')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "16aba76a-0ad6-4585-be9f-af7a5294e766",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sys.path.append(os.path.join(src_path, \"pyphare\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c25cdac8-2a36-403e-ba08-892c15559e6d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import subprocess\n",
+    "import pyphare\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pyphare.pharesee.run import Run\n",
+    "from pyphare.core.operators import dot, cross, sqrt, modulus, grad\n",
+    "from pyphare.core.ufuncs import gF, peakIds\n",
+    "import numpy as np\n",
+    "from numpy import polyfit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "40bcfabf-14c0-490f-a020-e6a8b4819720",
+   "metadata": {},
+   "source": [
+    "# Fluid case"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "51998f6a-d13f-469d-a07c-9edee18647f3",
+   "metadata": {},
+   "source": [
+    "You will focus on two simulations that only differ by the fluid temperature, that is $T=0.01$ for run **A** and $T=1.0$ for run **B**.\n",
+    "\n",
+    "*We will use capital letter for the names of the fluid runs and non-capital for hybrid runs*.\n",
+    "\n",
+    "Being in the MHD case, these temperature are then the one of a single fluid (composed of protons and electrons).\n",
+    "\n",
+    "The initial velocity profile $u$ is sinusoidal with an amplitude equal 1.5.\n",
+    "This velocity fluctuation is hence comparable to the ion acoustic speed.\n",
+    "\n",
+    "For this set of simulation, you will study how the velocity profile is modifying with time, and how it is related to the density profile.\n",
+    "Consider that for an isothermal or polytropic MHD fluid, the density profile straightforwardly gives the pressure profile."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b606835-5d50-4fd7-9d9a-3ff58559bfec",
+   "metadata": {},
+   "source": [
+    "## Sample questions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89fa0581-f65f-4386-bc7b-439347868316",
+   "metadata": {},
+   "source": [
+    "1. What determines the time $t^{\\star}$ (linear time scale or steepening time scale) corresponding to the formation of the steep gradients in both cold and hot cases ?\n",
+    "2. Can you explain the numerical catastroph that happens in the cold case **A** ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e771b59-70a8-4846-88da-4dc990ebeacd",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "285b290e-0fa0-49ca-98fe-452ab2a13438",
+   "metadata": {},
+   "source": [
+    "# Hybrid case"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3863b745-9ae9-4cea-b9c9-fae806046152",
+   "metadata": {},
+   "source": [
+    "In the hybrid case, both electron and proton temperature can be different, and can also evolve in a diffrernt way.\n",
+    "You will then focus on three different cases :\n",
+    "1. run **a** for which $T_e = T_p = 0.005$\n",
+    "2. run **b** for which $T_e = 0.12$, $T_p = 0.005$\n",
+    "3. run **c** for which $T_e = 0.25$, $T_p = 0.02$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f4b051f-29da-4c89-a209-49a32eb833b1",
+   "metadata": {},
+   "source": [
+    "## Run the `PHARE` code in dedicated conditions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5fca0035-0f9e-4c3e-9ee0-2377c3e41151",
+   "metadata": {},
+   "source": [
+    "In the cold case, you will focus on the proton dynamics in the phase space ($x; u$) for the case **a**.\n",
+    "The simulation can be seen as the collisionless version of the case .\n",
+    "Protons are essentially free streaming with no force acting on them."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8f729f57-3954-450d-90ed-977e4d86d91a",
+   "metadata": {},
+   "source": [
+    " ## Cold electron case : run a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a3fbd572-f937-46c2-8151-43162ea3c78d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Ti = 0.005\n",
+    "Te = 0.005\n",
+    "run_name = \"spa\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "06bed654-476a-4fa8-9be5-4dbcb6873a37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_path = os.path.join(work_path, run_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "205ed8c7-542f-40ae-a70d-47e36a8d2f66",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if os.path.isdir(run_path):\n",
+    "    files = os.listdir(run_path)\n",
+    "else:\n",
+    "    files = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f3bd8bef-eea1-4c74-b9f5-3370e0e170ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if 'PYTHONPATH' in os.environ:\n",
+    "    os.environ['PYTHONPATH'] += os.pathsep + os.path.join(src_path, \"pyphare\")\n",
+    "else:\n",
+    "    os.environ['PYTHONPATH'] = os.pathsep + os.path.join(src_path, \"pyphare\")\n",
+    "os.environ['PYTHONPATH'] += os.pathsep + build_path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "93f4a112-d97a-427f-b1b6-0b4bda0e5691",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if 'ions_charge_density.h5' not in files :\n",
+    "    os.chdir(work_path)\n",
+    "    subprocess.run(['mpirun', '-n', '2', '/usr/bin/python3', work_path+'/sp.py', run_name, str(Te), str(Ti)], env=os.environ)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "6143a900-1efb-488c-9f16-1132eb23ae24",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run  = Run(run_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "7c9e1d07-9efc-4567-a7a1-7768f81f2ff1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "times = np.arange(0, 21, 4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "fd7d43f1-4bdb-4c42-821b-4288e82099cb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "colors = plt.rcParams['axes.prop_cycle'].by_key()['color']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "0b380dca-3678-401d-9182-06c984423709",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+cAAADZCAYAAABCZkH8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAxGFJREFUeJzs3XV4ZNX9x/H3Hbdk4u6y7pY11oHiWqDI4t6WQgUqQIEfpYVCWyheilPcfZd1d9e4T3yScbu/P2422Wx8N9ld4LyeZ54Jd66cGbJJPvec8z2SLMsygiAIgiAIgiAIgiCcMKoT3QBBEARBEARBEARB+LET4VwQBEEQBEEQBEEQTjARzgVBEARBEARBEAThBBPhXBAEQRAEQRAEQRBOMBHOBUEQBEEQBEEQBOEEE+FcEARBEARBEARBEE4wEc4FQRAEQRAEQRAE4QQT4VwQBEEQBEEQBEEQTjDNiW7A8RQKhaisrCQsLAxJkk50cwRBEARBEARBEIQfOFmWaWlpISkpCZWq+/7xH1U4r6ysJDU19UQ3QxAEQRAEQRAEQfiRKSsrIyUlpdvXf1ThPCwsDFo/lPDw8BPdHEEQBEEQBEEQBOEHrrm5mdTU1LY82p0fVTg/NJQ9PDxchHNBEARBEARBEAThuOltarUoCCcIgiAIgiAIgiAIJ5gI54IgCIIgCIIgCIJwgv2ohrULgvD94Q0EaXD6aHYHcHiVh9MbwOFRvnb5AvgCIfwhGX8gRCAk4wuGCARD+IMy/mAIAJUkoZJApZLav5YkJElCp5YwaNUYtGqMOjUGjUp5bt1m0qmxGrVYjVoijDrCDBpUKgmCAXA3grsBfA7wucDnVL72H/q69RHyQygIoUD7sxxs/xpApQWVGlSa9of60Nda0JnbH1oT6CzK14ZwMEaBKQo0+rbPzhf04fQ7cQVcyrPfpTwO/XfAhS/oIygHCYQC7Q9ZeQ6GgsjIqCU1KkmFWlKjVrV/rZJUaFVajBojRo0Rk9bU4eswbRgRhgjCtF2vjCHLMrLbTcjtJuT2IHsOe/Z4CLndyF4vss+HHApBSAY51P51KKh8DUgaLZJGg6TVIukO+9pgRG0xozKbUVksysNkQlKr+/V9GAqG8PtCBLxBAv4gckhpfygkg0zbs6SS0OpVaPUaNDoVWp0aSSVWBREEQRAEoe9EOBcE4bgJhmRqWjxUNnmosruptnuoc/hocHppcPpav1YeDm/guLbNgJcEqYF4moiXGoiXGomV7ERJLUTSQmTrc7TKQTjO49o2tyRRp1ZTo1ZTq1FTr1bRpFLTqFZhV6loUquwq7U0qtXYVRLu45gJ1UGZcBdEOMHqlLE6weIBi1vG4pWI9GkJ96kJ80iYPDJGdwid04eq9ebJYJKBgMaIX2shoDHh15gImiMIWmMJWaIImKwEDGEENGYCagMBSUsALUFZhd8fIuANEQwcfTsNFi3h0QbCog1YY03EpoWRkBWOJdIwoO9TEARBEIQfBhHOBUEYMMGQTJXdTUm9i6I6J2UNLirtHqqa3FQ2ubG1eAmG5OPeLokQcTSRItWSKtWSKtWQKtWSKNUTLzWSIDUSLrmOe7tkoFmlolKjplKjoVrTGsDVGmo0amrVyqNFffxnIKmDMlEtEN0C0c0yMc0Q4ZCVEO5qD+Lh7p7OIgPeAW2XErhNePURePUR+LQW/LowfNpwfDoLPm2Y8t+6MHzaMGRVD7/mZKBT+wfuppDH4cfj8FNT0tJhe1SSmazxsQybmoA11jRg1xMEQRAE4ftNhHNBEPqt3uFlv62FglonJXVOiuudFNe7KG1w4TuGnkaACJOWKLOOaLOOKLOOCKMOs16DxaDBoldj0Wsx69WYdRp0GhVatQqtWkJHAJOzBFNzIYaWEnQtZWiaS1Hby9C0lCMFjz0kOiQLTYTRIFuoDVpowoJDNuDCgFM24EaPEwMuWY8LAy70uKUgXp0Dr9aFT+vEr3Xg1zoIaVuUh8p3zO0C0MhgDclEBANYQ0HMIRlzKIRJljGFQphCMmZZeTaFZAwu0LdI6BwqtE4VaqeExqlG5dEjOVXgDCIN8H0Ulx4cBnAawGmQcOvApwGfFrwa8GrBr7UQ1EQSUkcgSZFoiMCsjscgxaIOWQkFjIRCg3SzQg6hDnpbHz7UIR/qoBdVUHlWh/xIEqjDLGiiItFGRaGJiUJjDScUAr832OHhsntxNnmRj/gcGyqdNFQ62fRFMVnjY5l0ZgaxqT0vrSIIgiAIwg+fCOeCIHSrxePngM3BAVsL+6tbOGBTHnWO/gfKSJOWpAgjiVYjSREGEq1GEq0GYsP0RFuUIB5p0qHtrZfY1QB1B6DuYMfnxmJlLnd/aQwQlqg8whPbvw5LUB6mGDBFgzESi1qDBUgB/MEQdQ4vNc1eihprOdhQhM1eSqWrjAZvJc3BavxSDaiPvkdeI+mx6qJJNMeTEh5PrCmWOGMc0cZoIg2RROgjsOqtROgjsGgtyvxuWQaPnZCtCF/BLvyF+fjLSvBVVuOvacRf78RnDyAHuhv7LgO9f46SQY8mOgZ1TDSa6Bg0MTFoYqJRR0ejiYxEFW5FbQ1HHR6OKjycoElPvddOma2Kxqo6mmtbaKlz42kKEWpWo3bqMXnDUcutv5YOb0Kgtce8j5+bpJIwhmkxhukwhWkxWHQYTBr0Zi16kwa9SYNOJ6EJuNB4WlA7G1E7GpBrqglUlOMvL8dXUUGguppOyboLqrAwjGPHYp42DfO86eiHDm2bax8MhHA0emmoclJT3EzZ3gZsxc3KGwIKt9ZSuK2W0bNTyDsvC71R/FoWBEEQhB8rSZb78JfHD0RzczNWqxW73S7WOReEIzQ4feyssLOzvImdFXZ2VTRT0dTjmOUO9BoV6dEm0qPNZESbyIgxkx5lbgviRl3/CnHhc0HtXrDthupdynPtXnDV9+88WhNEpENEGkSmK18feramgDESellzEiAkh6hyVlHQVND2KLIXUdJSgt1r71+bAGQNIX8EIV8kIX8Esr/1ORCOHAgnFAiHkB5Q2hZu0DAiKZxRSVZGJoczMslKpkkiWFaKt6gIX1ExvuJifGWl+MsrCNb383NqbxhqQwitKYjWFETT+qw1BdEYQ2gMQdSGECoNSLFDIHkipE2FtGnIUTk47D5a6t0013torvPQUu+mpd5Dc70HR6MX+RimNfhUHhz6Jpy6Qw87Lm0LHm0LPr2H5Ng4hicPYUrGRCYmTMSoMR71tQBknw9faSne/Hy8B/Nbnw/iKyrqMbSro6MxT5uG5ZSZWObMQW21dnjd0ehl//oqdiwtx2Vvv9EVHmvkjJtHEZMietEFQRAE4YekrzlUhHNB+BGyu/1sK2s6qiAeY9EzNMHCkPgwcuPCyIgxkRFtJiHcoFQy7y9ZBntZewC37VIe9QW0dS/2RmuC6ByIGaI8orMhMkMJ4OaYPoXvQ0JyiApHBYVNhRTY24N4ob0Qd6DvNysAEswJpIelkxqeSrIlmWRLMonmRJItyUQbo/EHZUrqXeTXOCiocZBf61C+rnXg8bdWm5dDxLkaSXHUkOyoI8VRQ0pLLSmOWmI8/b8pIOl0aJOT0aamKM+JSWgTE9AmJKBJTEQbE4PkqYGafcrNkNr9UL0TavZCyI8sSzhDUTQFErEHlYfydRL2YAJBWdfvNgHoTRoskXrMEQYskfrWr5Vng1VNrVTFQdd+9jXsY2/9XvY37sfpd4IM2oCEyavG6NFg8qoxedQYAxoSdXHEa2OI1kURbYlBozOg1esJi44lMjGJhJwhGC39D8JBhxPPrl24d+zAvWM77u3bCdbWdb2zRoM5L4+w004j/CendwjqAX+QHUvK2fhFEQGf8v9bo1Vx2o2jyBwTc1SfoyAIgiAIJx8RzrsgwrnwYyTLMkV1TjaXNLKltJHNJY0csDl6Pc6sUzMsMZyhCWEMjQ9jSHwYQ+ItRFv0vR7bQ2OguRIqt0LlltbnrcqyZH1hSYDYIe0hPCZXeQ5LAlX/5yG3+Fo40HiA/Q372d+oBL/CpkI8QU+fz3F4AD/8OSUsBYOm71W55WCwQy9t4579uA8cRF1Zhjrg79f7coRHIccnYs5IJ3ZIJrrUFHSpqWhTUtDExiL18lnJsoy7xU9jtRN7jZumGhd2mxN7VSP2+gCBYP8/a71RIizGTHi0kbBoA+ExBsKijUo18ygDuh6Gc4dCQRz19TTZqpRHdRWN1VXUVpXQXFOD7O3f53O42IwshuTNYNScBViioo/qHLIs4yssxLl6Dc41a3Bt2EDI1Xk6g6TVYpk3D+sF52OZORNJo7zn5jo3X7+wi9pSpXCcSiVx6vUjyZkYd9TvSxAEQRCEk4cI510Q4Vz4MfAHQ+wob2JDUSObSxrYUtpEg7PnOeJmnZqRyVZGtz5GJVvJijEfXU/44Zx1ULGlYxh32Ho/Tq2HuOEQPwoSRkH8SIgbCeajD0+VzkolhB8WxCscFX06XkIiNSyVrIgssq3ZZEcoj4zwDEza/lXbloNB/OXlHYdK5+fjKyxE9vV9Lr/baKHcEkeRMYpySxwVlljKLbFUmaPxq7Vt+4UZNEzOiCIvM4opmVGMSra2zesPBkM017pprHbRZHPRWO1s+9rr6l/VcpUUxKqxYVWVE662Ea6uIVxtI0xdQ5i6Fr3Kpczlz5oDWXMhZ0GH/59+n5fmGltr+K6myVaF3VZFk60ae42NUHBwl9ZTazSMnL2AGZdeickacUznkv1+3Nu20bL4O1oWLcJfWdlpH01SIlGXX07ExRejjogg4A+y5LV9HNyo/PuQVBLn/HwsqSOijqktgiAIgiCceCKcd0GEc+GHKBiS2VVhZ21hPWsL6tlY3IDL131BL41KYmRSOOPTIhmXGjFwQTwUhNp9ULoOyjZA2TqlSFtvzLGQNB4SRishPH4URGWD+ugKY4XkEGUtZeyu282u+l1tQ6BbfC29HishkRae1hbAsyKyyInIISM8o1+94LTeEAjU1ODdtw/P/gN48w8qIbygENnbx8rxGg269HT0WZnoMjLRZWaiy8hAl5mBJjISgGq7h62lyqiILaXKNIUjK+brQxAVkogKqYhHTaZOR2RQQuUMIPejuL5KJREea8QaZyQi1qQ8xynPligDKmSo2w+la6F4NRQtB2dt2/GBkITdb6DRZ6TRZ6ZRm0YjUTQ5ZRxNRzFEX6UiPDaO8Jg4LFHRyiMyCktkFAZLOI2hZnY172Vj7Sa2V21DDgTQBiQsLg2RLTriG/TENHccCWIwW5h7zU2MmDWv3+3piizLeHbvofmzz7B//nmnWgCSwUDEhRcQfdNNqOPiWfbGPvauqQJAZ1Bz4e8mEp1kGZC2CIIgCIJwYohw3gURzoUfAlmW2Vfdwur8OtYV1rO+sIEWb/e9ihEmLRPTIpmQHsnE9EjGpkT0vzhbV7wOqNikBPHSdVC+EbzNPR9jsCpBPGkCJE9Qvg5P7tec8MPJskyVs4rd9bvZVbeL3fW72VO3hxZ/70HcqDEyJHIIw6KGtT3nROT0uyec1sJh3qIiJYjv3Ydn/z68+/YTbOzjcH21WgnhOTnKI1d51qWnI+n6Pofb4/RjK2thz756SgqbaLa5kFoCmEL9+3wtkXoiE0xExJuJiDcREWfEGmciLEqPqpdq+nIoREt9HQ1VFTRWltNYsJPGkgM01tbT7Aoh07+2aPR6IuITiYhPwBqf2PZ1RHwiYTGxqDV9u4nj8rtYW7mWJWVLWFG+giZvk/JeXWqGlIYxrDQMXaD9vY0/4xzmXHUDKvUA/FtpJfv9OFauoumdd3AsX97hNUmnI+LSS4m64QYWfVBN8Q5lDrs1zsglf5iMziCquAuCIAjC95UI510Q4Vz4vmpy+Vh5sI4VB2pZfqCWmpbue17jwvRMz45malY0kzOjyIoxty3rdExaqqF4FZStV8K4bRc9druq9UoAT57YGsjHQ1TWUQdxgFpXLbvrd7eF8T31e2jwNPR6XJwpjmFRwxgaOZShUUMZFjWM1LBUVFL/504HGhvx7t+PZ58SwD379+PNzwd/H+Y9q1To0tLQ5+agOxTEc3LRZWag6kcI93uDNFY7qa9wUN+6ZnZDhQOnve/D4gPINKhkGtQhGlQy9WqZBlUIXaSeaUNimJkbw8ycmG5rDPg8bhoqymmoKKO+oozGygoaqypoqq4i4O/fUntGtZ8IrRurzkOEzkOERUvEsDwiJp2HacR8pKMcRdGdQCjAhqoNfFH0Bd+VfofT78TgVTF5bxTZlea2/ayjcrjq7r+i1/Vv1ERfeIuKaHzjTZo++gj5sPnpksFAxI23sLxxHHXlTgCGz0hk3lXDB7wNgiAIgiAcHyKcd0GEc+H7IhiS2V7e1BbGt5c10d0KVNFmHVOzopmWrTwGLIw3VypDk4tXQslqqM/veX9zHKTlQepUSM2DxLGgObrK3QC+oI+9DXvZXrOd7bXb2VG3g2pnda/HxRpjGRkzkpHRrY+YkUQZ+j9v99CwdM/u3Xh27cazZw+effuUta/7QB0Tg2HoUPTDhmIYNgx9bi66zExU+r4X1AsGQjTZXDRUOqmvdLQ+O2muc/e5kL0xTEtkgpmIBBOR8SYi4k24DRI7GpysLapnVX49dY7ub/ZMiNczKy7EMIMLg7OO+ooy6stLaamr7faYruiMRiITk1sfScqzSSayeTv64sXKUPhQFyNALAkw4jwYeYHyfXUUhf964gl4WFG+gs8LP2dF+QqySo1M2xWFSlb+DVWkBhi58Kf8dNhPCdcN/O+NQGMjDS+9RMMbbyJ72gsR+nPGsTbjRgKtH8kZt4wma1zsgF9fEARBEITBJ8J5F0Q4F05mDm+AlQdqWbTHxpL9NTS5uu6JNWhVTMuK5pTcWGbkxDAk3jIwYdxeoYTw4pVKD3lDYQ87SxA3ojWMtz4iM46pV7zaWc222m3sqN3B9trt7K3fiz/Uc290hD6iLYiPih7FyJiRxJn6X+FalmUCNpsSxHfvxr17N57dewjWdbM81uHUanSZGRiGDccwbCj6ocMwDBuKJrbvQUqWZRyNXurLHdSVO2ioVHrEm6pdhPq4LrjepCE62UJUkpnoJDNRScrXBrO2x+NkWWZvVTMrdxSxbed+qktKCPc0EOlvJMrfiDnYuep4d1RqDREJiR0CeFRiMpFJyZisET1/n7qbIH8x7P4IDi6CYBc3DCLSYdzlMPYy5fttgNW6avko/yOWrfiQcavVqFunA2zPaWL/CD8XDbmIq4ZfRaIlccCvHairo+6552n83/8gqNSMqEqYyt5hV0HrVIOf3Z8nhrcLgiAIwveQCOddEOFcONnYmj0s2mNj8V4ba/Lr8QW7HiY+JN7C7CGxzB4Sx6SMSAzaAZgH625SgnjBUihc2nMYV2mU4ekZMyFtOqRMAuPRV7T2Br3srd/L9trtbY8aV02Px5g0JkbFKAH8UBBPMif1+8aELMsEqqsPC+GtQfyIQl1dUYWFtfaGKwFcP2w4+tycfvWGB3xBGqqc1JU72sJ4fYWjz9XRNXo1UYmHAriZ6CQLUclmTOG6Xj8LWZaV+eDlpUoPeEUZ9eVlNFSU4XH0Pk//EK9KR5MuCn1sIunZWeSNG0ZqVibhsbGoVAPwvelphgNfK0E9fzEEuxgmn3GKEtSHnwv6gS2YFgwF+XLRa+x/+QOk1t+QiybZqIjzoJbU/CTzJ9w85mYyrZkDel0Az759VD/4EO4tW5CB7aNvoyF6JADjFqQy4+LcAb+mIAiCIAiDS4TzLohwLpwM8mscfLWzisV7bWwv77pCtUWv4ZTcGOYMjWXWkFgSrcZjv3DQDxWboWCJEsgrNoPcTVV3lVYJ4OkzlECeOgV05q737QOHz8G22m1stm1mi20LO+t29tornhGewZjYMYyNHcvY2LHkROSgPorgF6itxb1jB+5du5Th6bt3E2zofZ662mrFMHJk+2PUSLTJyX2+GSDLMs4mH3XlLcrc8NYg3mRz0Zefuiq1RGSCqa0HPDrJTHSyhbAoA1IvlfVDoSD2GpsyH7w1fNeXl1JfUY7f4+5T+wFM1ggs8Um0GKIp8JvZYtdhU0fgUps6jJLQqCRm5MRw1uhEThsZT4Tp6KczdOKxw/6vYMe7yvfukeP5tWZlyPvk65QbSANo46cfsOLNlwHwakN8NKsCj165gaaSVJyddTa3jL2F1LDUAb2uHAph/+hjbH/5C46gkQ2T/0hIrUNC5rL784hKFNXbBUEQBOH7RITzLohwLpwohbUOvthRxRc7q9hX3XUPZaLVwILh8Zw6Ip68rCj0mgHogawvaA/jRSugu+XEVBpImaz0RmbMgJQpoOt/1fJDGjwNbLFtYbNtM5ttm9nfuJ9QD8XjTBoTo2NHtwXxMTFjiDD0v2c+5Hbj2bMH9/YdSiDfsZ1AZVWvx3UO4qPQJve9Vz4YCCm94WWtIbyihfpyJx5nH4rEAWarjuiUMGJSLESnKCE8It6EupfK6ADOpkbqSkuoLS2irrSY2tJiGsrL+lWUzRIdQ3RyqvJISSMqOYWo5FRM4daO1/IGWHmwju/22li6v4Y6R+draFQS03NiOGt0AqeNSCDSPIBB3V4BO96BbW9B/cHOryeNh8k3wKiLQHvsN7RkWebTxx8mf+M6ANTDE/lg2L62Su8AGknDeTnncfOYmwd8uLuvrIzK3/yWPU3JFGWeBUCSpprznri4XwUEBUEQBEE4sUQ474II58LxVFTn5MudVXy+o4q9VV0vMTYiMZwFI+I5bUQ8I5PCj33ueMAHpWvgwLdw8Juei7jFDIXsuZA9T+khP4ahwdXOajbZNrWF8SJ7UY/7p4WlMT5uPGPjlDCebc3ud6+4HArhKy5Wgvj2bbh37MC7/0DbfN3uqCMiOgbxkSP7H8QrndSUNFNb2kJtaQt1FQ5Cgd5/lKo0ElGJZmKSLUSnWFrDuAWjpfeg5fd5aSgvo7a0mLrSImpLiqkrK8Flb+r1WAAkCWtcPNHJqUS1hvDolFSiklLRm/p/IyYUktla1sRXO6v4alc1FU2de+QPBfXzxiZx+qgELPoBmi8ty1C+Cba9Cbs+BO8RI1AMETD+Sph0HURnH9OlXM12Xr7rVjwtyr/hM359N2uM+3l518s0+9r/XetUOhaOXMgNo2/ArD36USZHkgMBqv/9LJ/vSMXXWpBuuuszRv/rvra17gVBEARBOLmJcN4FEc6FwVZt9/Dxtgo+217J7squA/mEtAjOGpPE6SPjSYk8+t7pNo4aOPgtHPhG6SHvrnfcFA1Zc5VAnjUXrMlHfckGTwMbqzeyoWoDG6o3UNxc3O2+EhK5kblMiJvAxISJTIybSKyp/1WnA42NuLcpIdyzfQfunTsJtfQ8T1oymTCOHIlx7BgMo8dgHDUSTdLxCeKmcF1b+I5JsSi94Qm994bLoRDNdTVK+G7tCa8rLaaxqhK5p6XrDr1nSUVEYhIxKWmtIVwJ4pGJSWj1A78kGK09zNvKmvhyZxVf7uw6qBu0Kk4bkcAF45OZmRuDtg+jAvrE54JdH8DGF6Fqe+fXc0+D6b9QRoUc5c2vPSuW8NXTTwAQEZ/INU88gyvk4Y09b/Dantdw+B1t+8YYY7hjwh2cm33uUS3V151Nzy9m/VblfJGN+8hr+pS0/76ENvno/x0LgiAIgnB8iHDeBRHOhcHg9Ab4elc1H22tYHVBXZfzicelRnD2mETOGJ1IcsQxDrcNhaBqW2sg/xoqt3a9n6SGtKmQe6rSOx4/+qiXoXL4HGy2bWZ99XrWV63nQOOBbvfVSBpGxIxgYtxEJsZPZFzcOKx6a7f7d0WWZXxFRbi3bMG1ZSvurVvxFfXcG48koc/JwTB2DMYxYzCOHYs+JwdJ3bce+aMO4hJExpuITQsjJjWsLYibwnvvDfc4HR0CeG1pMfVlJfjcfZsXbgy3EpuWQWx6BjGpGcSmZxKVkopW1/cCdQNNlmW2l9v5cmcVX+yo6jKoR5t1nDM2ifPHJzM2xTowqw3IslJHYeN/lN70I6u9J46F6b9UlmVT91zBvvOpZd578A+U7dkJwLxrb2b8T84BwO6189LOl3hj7xsd6iiMiB7BPVPuYXzc+GN/b0AwGOLN36+gpVm5QTNx82PEWAOkv/4a2sSBrx4vCIIgCMLAEeG8CyKcCwMlEAyxuqCej7aU881uG25/56HUY1OsnDUmkTNGJZIadYw95AEvFC6HfZ8rgdxh63o/Y5QSxoecrgRy49ENe3UH3Gyr2caG6g1sqNrA7vrdBLspHqeRNIyJHcPkhMlMSpjEmJgxmLT9e78hrxfPrl24tmzB3RrGg009D9dWx8ZgHDO2LYgbRo1CbenbcOIjg3hNSQv1lf0L4rFpYcSlK4G8t+WtgoEAjVUVbSG8rrSY2pJiWur7tla4WqslOjlNCeFpyiM2LQNzxMk9rFmWZbaUNvLR1go+31HV5fKAmTFmzhuXxAXjk0mPHqDh4M562PYGbHgR7GUdXwtPgam3woSFYOj774HqgoO8+Yc7ofWmyPX/erHDdICy5jIe3/w435V+1+G4i3Iv4q5Jdw3IGul7Vley9PV9AMTU7WDMrufRpqUpAT0+/pjPLwiCIAjC4PhBhvMVK1bw2GOPsXnzZqqqqvjoo484//zz+3y8COfCscqvaeHdTeV8tLWC2pbO6zCnRZm4YHwyF4xPJiPmGIOGx66s97zvc+XZ5+h6v/jRShgfcrpSrfpoKpqHAuyq28W6qnVsqN7Atppt3VZTl5AYHj2cvIQ8piROYULchH6H8UB9fXsQ37IF95494O+heJpWi3HECIzjx2McpwRyTWJin3pcDw/iNaUt1B51EA8nJtXSYxBXKrQ3UldS1KE3vKGijGCgb0ulhcfGE5OWTmxaZttzZGISqj6OADhZ+QIhlh+o5eOtFSzaa8MX6DxEf0pmFJdMSuXM0QmYdAMwPz0YgD0fw5qnlNEmh9OHw5SbYOptYI7u0+k+/+ff2L92JQAzL1tI3gWXdNpnQ9UG/rbxbx1Gl8QYY/hD3h9YkLbgmEYJBAMh3rh3LY5G5WfPlI0PY3FWosvIIO21V9HGxR31uQVBEARBGDw/yHD+1VdfsXr1aiZMmMBFF10kwrlwXLh9Qb7YWcXbG0rZVNLY6XWrUcvZYxK5cEIyE9Iij22IbosN9n8B+75Qesq7CsgaI2TNUcJ47mlHPXe8rKWMtZVrWVu5lvVV62nxdz9/OycihykJU5iSOIVJ8ZP6NUxdDoXwFRTg2roV95atuLZuwV9S2uMx6ogIJYiPH49pwngMo0ahMvQ+X3oggnhcenjrEPWeg7jf66G+rJTa0uLWSukl1JYWtxUO643OaGrrAT80LD0mLR29aeCKiZ2smj1+vt5ZzcfbKlhbWN9pKohZp+acsUn8dFIqE9Iijn3YuyxDyWolpB/4uuNrWpNSOG76LyAsocfTNFZV8PKdtyLLIUzWCG7490tdTiEIhoK8s/8d/rXlX7gCrrbtc1Pn8se8PxJvPvpe7u1Lylj1rlKpPql5B8O2PA+AfsRwMt54A9VRFPcTBEEQBGFw/SDD+eEkSRLhXBhUuyrs/G9DKZ9uq6TF27HXU6uWmDs0jgsnJDN3WNyxLXtWX6D0ju/9HMo3dl7HGZTh6UPOgOFnK8XcjmKZsxZfCxuqN7C2ci1rKtdQ1lLW7b4plhTyEvPIS8xjcsJkYowxfb5OyO3GvXNnWxB3b9tOyN71eu6H6DIyME6YgGnCeIwTJqDLzOw1kMkhmUabSwniRc3Yipv7N0c8PYy4tN6DuCzLtNTXUlNcRG1xYduSZY3VVfRlwXJJpSIqKYWY1HRi09t7w8NiYgdmrvX3XJXdzSfbKnlvUxkFtc5Or2fHmrlkUioXTEgmLmwACtrV7ldC+va3O978Uuth4tXKvPSI7tctP7z3fP71tzHutDO73bfaWc3D6x5mWfmytm0WrYU/Tv0jZ2edfVTN93uDvPr71XhdAVRqiVkH/oGqTAnrYaefTvI/nkA6ytoSgiAIgiAMDhHOAa/Xi9fbPvS4ubmZ1NRUEc6Fbtndfj7dVsHbG8u6rLaeG2fh0smpXDghhahjWb+57qAy3Hb3J2Db2fU+4SlKGB92FqRNB3X/hvkeGqp+KIzvrNvZ7bxxq97KtMRpTEuaRl5iHsmWvvfGB+12XJu34Nq0CdfmTXh274EehnBLWi2G0aOVIN7aO66Jiur1Oo5GLzXFSgi3FTdTW9KMz9Pzsmn9DeLBgJ/68jJqigupLVHCeE1JIV5n59DYFXNEZIc54TFpGUQnp6IRa1L3Spmf3sT7m8v4bHsVjiNuiKlVyg2xSyalMHdY3LFXe7eXw+onYcurEPC0b1dpYdzlMOu3XYZ0W1EBb9xzBwDWuHiu+9cLqHqYSiLLMt+WfMtf1v+FBk9D2/YzMs/gT1P/dFRz0dd8kM/WRcrokwnTw4n6582EXEoPfcxttxH7y1/0+5yCIAiCIAweEc6BP//5zzzwwAOdtotwLhzuUHXp19eW8MXOSjz+jnNhjVo154xN5NLJacc2xLZ2P+z+WAnlNXu63iduhBLGh52tVJfu57UODVVfU7mGDVUbuh2qrlFpGB83nulJ05mWOI1hUcP6vM64v6YG9+bNuDZtxrVpE94DB3rsQVZHRrb3io+fgGHUSFS9hFWvy09NSQu24mZqWh9Ou6/XtkUm9D2Iux0t1BYXUVtS2BbG68vLCAV7nxuu0eqITk1v6wU/VKjNFN6/qvRC11y+AF/trObdTWWsL2ro9HqMRcdFE1K4PC/t2IvItdhg7VOw8b/gP+wmjFoHE6+FU+7qNNz9/YfvpWSHskrCeb+9l5xJeb1exu6188iGR/ii8Iu2bQnmBP4y8y9MTpjcvyY3eHj9T2uRQzLGcB0Xnuaj6hc/b/t3mPzE44Sf2X2PviAIgiAIx5cI56LnXOiF2xfks+2VvL6uhJ0VnYddj02N4LLJqZw9JpEwQ/+WXoLWea41e2HPJ0ogr93X9X7Jk2DEuUogj87u1yWcfifrqtaxpmINayrXUO4o73bfLGsW05KmMT1pOpPiJ/WpiJssy/grKpRe8U2bcG/chK+kpMdjdFlZGCeMxzR+AsYJ49FlZPR4QyPoD1FX7mgL4rbiZppsrm73P8QcoSc+I5y4jDDiM8KJTQ9Hb+wcxGVZxm6rpqZECeA1xYXUFhf1uVK6JTKK2PRMYjOyiMvIIjY9k4iExB57S4WBU1zn5P3N5by/uZzqZk+n10/JjeGKvHTmDz/G3nRnPax/FtY/D97DRs1ojDDlRpjxq7bCcYVbN/LRX5UbvxljJ3DRHx7s82W+KvqKh9Y9RItPuXEmIXHNqGv4xfhfoFX1/efM1y/spGCL8j18+o2jiNz2OTWPPaac02gk84MP0Gdl9vl8giAIgiAMHhHOuyDmnAsARXVO3lhXwnubymj2dOwlDTdouHBCCpdOTmV44lF8j8gy2HYrYXzPJ1DXzXrgKVOU9ZZHnNfj/NbOp5c50HiA1ZWrWVWxiq22rQTkrnt6I/QRTE2cqvSOJ00jwdxzsatD5/cVFLT1irs2bSJQXd39ASoVhmHDME2ehHHSJEwTJ/Y4RL1tnnhrCK8pbqau3EEo2POPIZ1RQ1x6WGsYDycuPRxLZOdCXKFgkIYKZVi6raiAmuICaouL8Lp6H5Z+aG54XEYWsa0hPC49E5M1otdjhcEXDMmsPFjLe5vK+XZPNf4jvmfiw/VcOjmNyyankhRhPPoLuRqUOenrnwP/YTeJdBZlCbbpvyCks/DfO27CXqMsaXjdP58nMrHvU0GqndX8cdUf2VC9oW3bhLgJ/H3234k1xfbpHGX7Gvj0n0oF+tThkZzzy3FU/f4P2D/+GADDyJFk/O8tJDGlQhAEQRBOOBHOuyDC+Y9XIBhiyb4aXl9XwsqDdZ1eH51s5app6ZwzJgmjrp89orIMtl2w+yMlkNfnd71f6lQYeT4MPwesKX0+fbOvmXWV61hVsYrVFaupcdd0uV+HoepJ0xgeNRyV1HNPohwI4Nm3H/fmTa1hfDPBxs4V6dtotRhHj8Y0aZISyMePR22xdLv70cwTV2kkYlKUIB6fEUZcRjgRcSYkVcfe94DPR11pcWsQz6emuJC6kmIC/t6Hv+uMRmLTWwN4a494dEqamBv+PVHn8PL+5nLeWl9KaUPHURYqCeYNi+eKvDRmDYlFrTrKaSiOWlj1D9j4HwgetmyiMQpm383G6ihW/O81ACaedT5zFt7Qr9OH5BCv73mdf275J4GQcoMt2hDNY7Mf69Mwdzkk88Z9a2muU0YTXPnQNMLMMkUXXYyvqEg53403Evfru/rVLkEQBEEQBt4PMpw7HA7y85XgM378eJ544gnmzp1LVFQUaWlpvR4vwvmPT22Ll3c2lvLW+lIq7R2HxOo0Ks4Zk8RV09IZl3oUvaP1BbDzfdj1fjc95BKkTWsP5OFJfTptSA6xr2FfWxjfXru920JuKZYUZibPZGbyTCYnTO51qHrI58Ozaxeuja3D1LdsIdRDsTPJaMQ0fpzSKz5pEsYxY7pd0izoD1Fb1kJ1ob310YyzqfNa8EeKTDC194hnhBOTbEGt7XhTwetyKcXZigtae8QLqS8vRQ51Xiv7SJaoaCWAZ2a3DkvPwhobJypa/wCEQjKr8ut4c30Ji/fWEAx1/HWWHGHkyqnpXDY5lcijLeDYXAkr/g5bXutQ3d1lyeaFLakEg0GMYeHc/NyrqDX9n/6yo3YHdy27C5tL6YVXS2rumHAH14y8ptf6Fpu/Lmbdx4UATPxJOlPPz8a9ezfFl/0M/H6QJNJeeQVz3pR+t0sQBEEQhIHzgwzny5YtY+7cuZ22X3311bzyyiu9Hi/C+Y/HjvImXl5dzOc7KjsNf02LMnHl1DR+OvEo/mC3V8DuD5VQXrWtix0kSJ+hBPJhZ0N4Yp9O2+RpYm3V2rZAXu+p73I/vVrP5ITJbYE8PTy9x/PKPh/unTtxrl+Pa/0G3Nu2IXu7D8yq8HBMEye29Ywbhg9H0nYdOByNHqoLm9vCeG1ZS6/LmPVlnrjL3kRNUQG24kJqWoemN1VX9XjeQyISEonLzCEuI4v41kAuhqX/OFTbPbyzsYy3N5ZSdcSNOINWxQXjk7lmeiZDE8KO7gKNxbDk/2Dne22bPisfxoEWZRj6eb/5EzmTpx7VqRs8Ddyz4h7WVq1t27YgbQEPz3y4xxtuTruX136/hlBIxhSuY+Ej01GrVdT/5z/U/P1xADQJCWR98jFqqyhWKAiCIAgnyg8ynB8rEc5/2ALBEN/usfHfVUVsKuk4NFuSYN7QOK6cls7s3FhU/Rnq6qxX5pDv+gBK1nS9DnnadBh1IQw/F8Liez3lobnjy8uXs7x8ObvqdhGSu+4FzgjPaAvjE+MnYtB0v9azHAjg2b0b5/oNuNatw7V1K7Lb3e3+6tgYJYhPmoRp0mT0uTld9ih37BVvxlZkx9HYc6+4Vq8mLiOc+MxwJZAfMU9clmVa6mqxFRdQU1RITevQdEdD1zcmDiepVESnpBHf2hsel5FNbEYWelP/138XflgCwRBL99fy5voSlh+o7bSQwPTsaK6dkcm8YXFHN+S9cit8ey8Ur6TIEcmHZaMAyEnUcN69j/e7qOMhwVCQZ7c/y/M7nm/bNjxqOE/Ne4p4c/c/U756bieF25TCcGfcMpqscbHIoRCl116Ha/16ACIuvZTEB/58VO0SBEEQBOHYiXDeBRHOf5jsLj9vbyzltbUlVDR1DKIRJi2XTU7jirw0UqP6Edy8LbDvC6WXrGApdDWsPHEsjLpYCeV9mEPuDXrZULWB5eXLWVG+gipn173BRo2RvIQ8ZibPZEbyDFLCuj+3HAzi2bcP17r1ODesx71pc4/D1LXJyZgmT8Y0WSnepk1P73LorLPJ22F4em1pC8FAz0PIrXFGErKsrY9wopIsbTdB5FCIxupKZUj6oUdxIR5H10u9HU6j1RGTntEaxLOJy8wmJjVdzA8XelVc5+TVtcW8t6m807rpaVEmFk5L55LJqYT3dzUGWYaDiwh9ex8vrg3DEdCjIsTNw7ZiOuVmOOU3oO++FkNPVpSv4O4Vd+PwOwCIM8bx1PynGBE9osv9S3bX8/lT2wFIHxXN2T8fC4C/qorCs85uW/88/a23ME0Yf1RtEgRBEATh2Ihw3gURzn9Y8mscvLKmiA82V+D2dwzPuXEWrpuZyfnjkvte4M3vgYPfKD3kB76BQOdlm4jOhdEXK6E8JqfXU9a561hRvoJlZctYV7UOd6DrXuxsa7bSO54ykwlxE9Cpuw6eciiE9+BBXOvXK73jGzcSam7ucl8ATXw85ql5mKbkYcrLQ5fSuaJ0MBCirsyhBPEiJZA7GnruFdfo1cRnhJGQqYTx+KxwjBZdWxsbqiqoKczHVpSPrVCZJ+73dN+Df4jeZG6dH57VFsSjklJQqcWyZcLRa/H4+WBzOa+sKaa4vmMBOZNOzcUTU7huRiYZMf1cMz0UZMU/72bjemWZxLnxBUyIqgRLApz6IIy5RBm2008FTQXc/t3tVDgqoPWG3SOnPML8tPmdmxCSef1Pa5R/sxIsfHg6YVHK6JqG117D9pdHANDn5pL54QfdTlMRBEEQBGHwiHDeBRHOv/9kWWbFwTr+u6qI5Qc6r1M9b1gc183IZEZOdK/FlAAIhaB0DWx/W6m07u0i6IanKL3joy+GhDE9/rEtyzL7GvaxrHwZK8pWsKt+V5f7aVVaJidMZnbKbGalzOq2d1yWZXyFhW1zxl0bNvRYTV0dE4N5yhRMeXmY86Z02TPutHvbh6cX2qkpbSHo76VXPNbY1iMen2UlOsmMSq06piBuskYoveGHhqZn5mCNi+/b/zdBOAqhkMyyAzW8vLq406oNkgSnjYjnplnZTEyP7PM560qLefW3Pwcg2dTMZenb219MmQJn/A2SJ/S7rQ2eBn619FdsrdmqtA+JOyfe2WWhuI1fFLHhM6VC++SzM5lytrK+uRwMUvzTS/Ds2QNA3G9+TfQN/asqLwiCIAjCsRPhvAsinH9/eQNBPtlayYsrCzlY4+jw2qGer2umZ5AV28ehpLX7lUC+8z2wl3V+3RQDIy9QAnnKFOihsrcn4GF91fq2+eM1rq6XOosyRDErZRazU2YzLWkaZm3nXjpZlvGXlraFceeG9QRrOy/9dojaasWUl4cpbwrmvDx02dkd/nAPBtt7xW2tgbyloYsRAYfR6FTKMmaHhqhnhmMM0x1TEA+LjiU+K5v4zBwljGdmY4nsfj10QRhsB20tvLq2uMuRNxPTI7nxlCxOHRHf67x0WZZ55de30VBRBpLEzaeZsJR+fdgeEkxYCAv+DKb+fc97g17uX3M/XxR+0bZt4YiF/HrSrzssk9jS4OG1P64BGcKiDVz10LS2pQfdO3dRfOmlEAohGQxkff55lyNoBEEQBEEYPCKcd0GE8+8fu9vPW+tLeXl1ETUtHYdaJ0cYuWZ6BpdMTsVq7MNQTUetsuzZ9re7rrSusygF3UZfDJmzQa3p6iwA2Jw2VlSsYEXZCtZVrcMT7DrwDo0cyqyUWcxJncOomFFdrjvur6hQhqivX4dz/QYC1dXdXlcVFoZp8mTMeUrvuH7IkA4F3Jx2L7ZDFdSL7NSU9N4rHh5jOGyuuJXoZDOSxDEG8ZwOD1O4qBQtnJzsLj9vbej6Z0xGtInrT8ni4gkpPU6PWfPem6x9/38AzL3mZibkGuGre6D+YPtOphg4/WEYc2m/hrrLsszzO57n6W1Pt207N/tcHpj+ABpV+8+oz57cRumeBgDO+9U4Uoa13wio/r+HaXzjDQDCTl1AylNP9fn6giAIgiAcOxHOuyDC+fdHld3Nf1cV8b8NZZ0KOU1Kj+SGUzJZMDwejbqXtap9Ltj/Jex4B/K/61zYTVJD9jwYexkMPRN0XReNC8kh9tbvZXn5cpaVLWNvw94u99OpdExJnMKclDnMSplFoqXzUmp+Ww2uDetxrluHa/0G/OXl3TZfZTJhnDQRc54yb9wwYjhS6/zrYDBEfbmjbTkzW5Gd5rpeesW1KuIywpXh6a3zxY0WTacgXlNcgK+HKu+HiCAu/FD4AiE+3V7JiysK2W/rWKgwyqzjqqnpLJyWTrRF3+nYurISXv3N7QAkDxvBZQ88CgEfbHgBlv0VfIedL3MWnPUExOT2q30fHPiAB9c92Laqw5zUOTw267G21RsObrLx7X92AzAkL55Trx3ZdmzQ4aDgjDPaRuGkv/4apsmT+3V9QRAEQRCOngjnXRDh/OS3r7qZF1YU8um2SgKh9m/Nfs0HDYWgeKUSyPd82vEP40MSxyk9WKMvBktcl6dx+V1tw9VXlK+g1t15jjtAjDGmbe741MSpndYlDtrtODdswLV2Hc716/EVFHTbdMlgwDRhPKYpeZin5mEYObKtgJOr2dcWwqsLm6kpbibQh17xQyFcqaBuwl5TJYK4IHRDlmWWH6jlxZWFrM7vuKyfXqPiookp3DAzs9MUmld+fRv15aUA3PTsK4RFxSgvNFfCV3fD3k/bd1brYOZdMPNO0Ha/NOKRFpUs4u4Vd+MP+QGYFD+JJ+c9SZgujIA/yCt3r8brCqDWqrj20Znoje09603vv0/Vn+4FwDB6NBnvvN3lsomCIAiCIAw8Ec67IML5yUmWZdYW1vPCikKW7e8YgHUaFRd388dwJ7Y9sONt2Pk+NFd0ft2aCqN/qoTyuGFdnqLOXcfysuUsLVvKuqp1eINdVy0fHjWc2amzmZMyh+HRwzsMVw+53bg2b8G1bi3OdeuVYkyhrkO0pNViHDdOKeA2NQ/DmDGodDpCwRD1Fc7DljPrvVdcrVURlx7WNjw9Lt2C11UngrggHKVdFXb+s7KQz3ZUETziZuEZoxK4bU4Oo5KVfxdr3nuLte+/BcDcq29kwpnndTzZgW/gy99AU2n7tqhsOPsJyJrT5zatr1rPL5f8EldAqTo/PGo4L5z6AhGGCFa8fYCdy5SROLMvH8qoWe1zy+VgkKILLsR74AAASY89hvWcs4/qcxEEQRAEoX8GLZw7nU7M5n4uN3OSEOH85BIMyXyzu5pnlxWws8Le4TWrUcvCaeksnJZBbFjnYaRtXA1KGN/2ZtfzyPXhMOI8Zdh62vQuC7sV24tZWraUJaVL2F67HZnO/yT0aj1TE6cyO3U2s5JnEW+Ob3tN9vtx79yJc+1aXOvW4962Ddnv77q9ajXGUaMwTZ2KedpUjOPGoTIYcDt8yvD0AiWI15Q0E/D13CseFm1or6CeEYZK3UxdScFRBvFs4rNyRRAXhC5UNLl5eVUR/9tQitPXcWrMKbkx3DYnh1ydo21oe9KQ4fzsocc6n8jnguV/g7X/htBh03XGXAqnPwLm6D61Z3fdbm5dfCuNXmXlhqGRQ3nxtBcJ1Gh49y8bAYjPDOfiuyd1OM6xajVlrdXaNUmJZH/5JSpD33vuBUEQBEE4OoMWzi0WC5dccgnXXXcdM2fOHIi2HjcinJ8c/MEQH2+t4NnlBRTWOju8lhxh5IZTMrlkUipmfTcF2YIBKFgC296A/V9B0NfxdZUGchYof/AOPQO0xg4vh+QQu+p2saR0CUvLllJoL+zyMrHG2Lbe8SmJUzBqlPPIoRDe/ftxrl2Hc91aXJs2I7tcXZ4DQD9kCOZpUzFNnYpp8mRUZjNNNhdVBXaqCuxUF9hpsnV/PIBao/SKx2dZic+0YDS7aK4pEUFcEI6jQwUqX1pVRJ2j46ia8WkRLNj7Gp4aZdTOjU+/THhMbNcnsu2Bz++EsnXt20wxcOZjyioRfSgYV2gv5IZvbmibbjMkcggvnPoCix4voL5cWdHisvumEJ3UccRR6Q034ly1CoDYX99FzI039vNTEARBEAShvwYtnH/22We88sorfP7556Snp3PdddexcOFCkpKSBqLdg0qE8xPL4w/y7qYynl9eSEVTxyA5Mimcm2ZlcdboxO6LvNXuV3rIt78Dji4qmieNh7E/g1EXgTmmw0u+oI8N1RtYUrqEZWXLup0/nm3NZl7aPOalzWNE9AhUkkpZ3qykBOe6dTjXrsO1fj3BpqZu36c2NRVza8+4KS8PwiOoKWmh+rAw7nF207PeyhKlJyHLSnxGGKZwN353JbUlBSKIC8JJwOMP8v7mcp5fUUBZQ/u/xcmNm5japPRcn3LFdUw598LuTxIKKTcYv70XPIf9PBl2Npz1OIQl9NqOYnsx139zPTVuZfnGnIgcfmd4hC0fVQIwbkEqMy7uWHjOc+AARedfAKEQKouFnMWLUEdE9PszEARBEASh7wZ9znl9fT2vvfYar7zyCnv27OH000/nuuuu49xzz0Wj6X4JqhNJhPMTo8Xj5411pby0qpA6R8de7rzMKG6fm8MpuTEd1udu426C3R/C1jehYlPn182xSg/5uMshfmSHl5p9zawsX8nSsqWsqliF0+/sdLiExPi48cxNncvctLmkh6fDoYrq69YqvePr1xOoqur2/aljYzDnHQrjUwmEx7YG8SaqCuzUlrYQCnb/z0yllohNCyM+K4zwSC+hoA27rfjognhmDvHZucRnZmOyij+4BWEwBYIhvthZxbPLCthX3UKEr5GrKt4GoN6cxPAb/8BPJ6Vi0Ha/DBstNvjiLtj3efs2g1UZ5j7u8l570UuaS7jum+uocSkBfbhpFHOX3UQoKGMM03L1X2egPuKGZ+Wf/oT9/Q8AiL75ZuLu/NUxfAqCIAiCIPTmuBaEe+qpp/jtb3+Lz+cjJiaGW265hXvuuQeTqetlqU4UEc6Prwanj1dWF/HKmmKaPR2XQ5s7NJbb5+YwKSOq84GhIBQug21vKX+wBo4ohKbSwJCfwLgrIPdUULevcV7trG6bP76pehMBOdDp9Hq1nmmJ05ibNpfZKbOJNkYTcjpxbtyIc/UanKtX4yvseqg7h9YanzIF89SpmKbm4TQnKnPFW3vG7bU9h2m9WUNilpXIBBmNpg53Szk1xfnYCg7idXW+gXAkEcQF4eQiyzJL9tXwzLIChq5+lmh/IzLwUtrVmK3K0o9XTU3vfqqOLMOej+HL34LzsFE92fPhnH9BRGqP1y9tLuW6b67D5rIBcEHRz4mvVnrMz7hlNFnjOg6v91dUkP+TM8DvRzKZyFm8CE1UFz+LBUEQBEEYEIMezqurq3nttdd4+eWXKS0t5YILLuD666+nsrKSv/71ryQmJvLtt98ey3sYcCKcHx/Vdg8vrizkrfWluP3txZMkCc4cnchtc7IZmdTF8Or6AiWQb/9f19XW40fD+CuUiuutw9ZlWeZg00GWli5lSdkS9tTv6bJNVr2V2SmzmZc6j2lJ0zCqDXh278G5ejXO1atxbdsG3RRxk/R6TBMnYJo6Df2kPOzGJKqLHW3F27yuzjcAOlw7zkhsmhajqYmgvwp7TTG2goM4Ght6+SRFEBeE7xNZlnn3uRcoX/YZAN/FzGZP2AhoXSv9hlMyWTgtA0t3Id3VAF/foywDeYjOAqc+ABOv67Kg5SFlzWVc9+11VDurSW0czln7bgEgY0wMZ902ptP+1Q8+RONbSnX5qGuvJf7u3x3Tex8ooWCQ6oID1JYU47I3odZqCYuOIXXkGCyR4gaCIAiC8P00aOH8ww8/5OWXX+abb75hxIgR3HDDDVx55ZVEHDZnbffu3YwfPx6fz9fjuY43Ec4HV2m9i2eXF/DB5nJ8wfZK4xqVxAXjk7llTjbZRy6H5m2B3R8pobx0beeTGqNgzCXK8M7EsQAEQgG21WxjSdkSlpYupdxR3mV7ki3JzE2dy7y0eYyPG49sq8W5RukZd65Z2/28cbUa4+jRmKZNRRqTR5MpFVupUsCtrrSFUKiHIeoaiZgUI+GRLUiqGjwt5dSVFtBYVdnr52eOiCQhZwgJWbkiiAvC91R1/gHe/ONdADjjh/CyeT6H/5aNMGm5fkYmV8/IINyg7fok+79WCsa1HPZzI3M2nP8MWFO6vXZZSxlXf3U1da46rtjyZyy+CCQVXP3IDMzWjqte+G01FJx2GrLXi6TXk/3tt2jj44717R+1xqoKtnz1KXtXLcPr7GIEkSSROnwU0y+9kpRhI7s6hSAIgiCctAYtnFutVi677DJuuOEGJk+e3OU+brebRx99lPvvv7//LR9EIpwPjrIGF08vzee9zeUd1gLWa1T8bEoaN87KIjnisIrpoRCUrFLmke/9FPxHVCqX1Mpw9XFXwJDTQaPHHXCztnItS0qXsLx8OU3eroP18KjhzE2by7zUeeToknFt2tQayNfgKyjo9j1o09IwTZ9OYPQMmsIysVV4qC7ofW1xvVlNZLwHvaGeoE/pFa8rK0HuZl3zQ3RGEwnZucojZwgJ2UOwREV3Pe9eEITvDTkU4oXbr8XRUI9aq+X0v7zA82vK+XR7JYff1ws3aLhuZibXzsjEauwipHvsSrG4La+2b9Nb4Yy/KUtDdvOzoqCpgGu/vpbcgzOYUHEqAHkXZDDp9KxO+9r++jcaXnkFgMjLLyfhvnuP/QPoJ1eznTXvvsGOxd8gyz3/3Dxk5Oz5zL/+VrR6sQycIAiC8P0waOHc5XKddHPJ+0qE84FV2eTm30vzeW9TGf7DCp5Z9BqumpbOdTMyO65R3lINW9+ALa9BU0nnE8YOUwL5mEshLJ5GTyPLypaxtGwpayvX4gl2DspqSc2khEnMTZ3LnOTZRJXa24eqb93a7VB1lcWCYep0vKNn0WTNoaYOqgrs+NzdD1GXZZnwaC/mcDtgw20vp76iiIDX2+0xAGqtlrj0rNYQroTxyIQkpB6GqAqC8P21+KVn2f7tFwCcc+c9DJk6k8JaB/9ems8n2yo73MQM02u4dkYG183MJMKk63yygiXw8e0de9GHna3MRT9iVYpD9tTv4Vcf/47zNio9+N7wFn7xyJlo1R1vAgTq68k/9TRlKUitlpyvv0KbnDxAn0LvDm5Yw7cv/BtPS3PbNo1eT9b4yaSOHENYdAwBn4+60iL2rVlBU3V7Yc6E7FzO/919mCMij1t7BUEQBOFoDVo4V6vVVFVVERfXcfhbfX09cXFxBIPBbo890UQ4HxjVdg/PLMvn7Q1lHYavhxk0XH9kT1AoqPxxufkVZU1y+YjvD4MVRl2szCVPmkCNu5bvSr9jccliNtk2EeqiJ8WoMTIzeSbz0uYxXTMU1cadrUPV1/Q4VF0zZiLuMXOxRw2hrkWPraSFoL/7nhpJ5SY8yo5WW4fPU4ndVozX6ejxs5EkFdEpqe1BPHsIMWnpqDXdDF8VBOEHp2THNt5/+E8ADJ85hzN/8Zu214rrnDy9NJ8Pt1Z0COkWvYarp6dz/cwsosxHhHR3E3x1N+x4u32bKUYJ6MPP7rINW2u28tHftxDfnAlAzekbuP/836GSOt4UrPnHP6l//nkAIi65hMQHHxiAT6BnoWCQpa++wLZvvmjbpjUYmXLexYw77SwMFkvnY0JBdn73DcvfeBm/Rym6GZWcys8efKzL/QVBEAThZDJo4VylUlFdXd0pnFdWVpKdnY27D8s+nSginB+bmhYPzy4r4M31pfgC7aHWotdw3YwMrp+ZhdXUGkLtFUov+dbXwV52xJkkyJ4L46+EoWdR4a1nccliFpcsZlvtti6vHW2IZk7qHObFzmB0uYR37YZeh6qHMobhHjcfe/Qw6twW6qtcdPfdLsteNNp6TGGNELLhbCzDZa/v9TOxxsUTnz2ExNYgHpeVjc5g7PU4QRB+uIKBAM/eeAVelxO9ycytL76J+oglRkvrXTyzLJ/3N5cTOCykm3RqFk7L4MZTMom2dJwnzp5P4fNfgeuwn01jL4cz/qrc6DzCZ1+uoPRTZTTQnrg1ZJ1r5NeTft2xrU1N5M9fQMjpBI2GnG++HtTec4/Twef//BslO7a2bcuZPI0FN9zWp17w2pIiPvrbg7TUK1XtU4aP4qI/PoRGK26ACoIgCCevAQ/nTz75JAB33nknDz30EJbD7lQHg0FWrFhBcXExW7du7eEsJ5YI50enzuHl+eUFvL6uBM9hPc0mnZprpmdw4ylZRJp1EAxA/iKll/zgt3Bkr7clASZcBeOvokgVYnHJYhaVLGJvw94ur5salsqClPnM92aRtLcG1+q1uLdsQe5iqLoMeKPTcY2bT3PsCOq84TQ3dj2kXZYDyMFadIZ6tLp6fK4KnE02uk3urYzhVhJzhhCflas8Z+diCu+i6rwgCD96Xz71d/auWgbARX98iIwx47vcr7zRxTPLCjpNDzLp1Fw9PYObDv18PcRRA5/9Cva39zoTnqIUi8ua3eHcPk+A//x2ObJfwqf28PrE+7gj7xdcPfLqDvvV/Otf1D/7HAARP/0piQ89OCCfwZGabNV89LcHaKhQbtiq1BrmX38ro+ed1q96G022av53729w2ZWRUuPPOId519w8KG0WBEEQhIEw4OE8M1MZGldSUkJKSgpqtbrtNZ1OR0ZGBg8++CB5eXkD0f5BIcJ5/zQ4fbywopBX1xR3WBLNqFWzcHo6N52SpfTsNJXClteVXvKWqo4nkVSQcyryhIUciM1kcfkyFpcsJr8pv8tr5kTkcJZlKjMrwrBsK8C1di3BxsZO+8lIOMJScQ4/heaEUdT7rbjdnb+VZTmEHGogFKxGr69HDtlwN1chh3qefqE1GEnIUpYvS2wt2BYWEysKtgmC0CcH1q3is3/8FYCxp53Fgutv7XH/yiY3zy4r4J2NHacLdTkySZaVFS6+uht8Le0nmXIzLPgz6Nrrwix9fS97Vis/l1dmvsfuhFU8csojnJ3VPhw+aLcrvecOB2g0ZH/9FbqU7qvCH4260mLe+78/tQVqQ1g45/36D6QMH3VU56vOP8A7f76HgF9ZFaanGyCCIAiCcKIN2rD2uXPn8uGHHxIZ+f0rwiLCed80uXy8uLKQV1YX4/S1h1i9RsVVU9O5eXY2sSYVHPha6SXP/6617/ow4cnI469iV+YUFtVv57uS7yhtKe3yemMsQ7nAMYQxRTLqTTvx5Xceqh5UaWgOy8CRNp7mxDE0hCLxBzoGZVmWkUPNyEEbcqgatboOv6eKUKDngm0qtYbY9My2eeKJOUOITEpGpVL3eJwgCEJ3fG4Xz9x4BUG/H0tUNDc9/XKfikD2VNPjhplZXDvzsCXYmkrh49ugeGX7CWKGwIUvQJISVOvKHbzzfxsAaDTYeGfcI2hUap6e/zTTk6e3HVb75FPUPfMMANaLLyLp//5vwD6LmuJC3vu/P7UVfotKSuGCu+8nIiHxmM675atPWfrKCwBYIqO45onn0H9PC9YKgiAIP2yDFs6/z0Q475nd7eelVUW8vKqIFm971XKdRsXlU9K4bU42cYEqpdr6tjfBYet4AklNMPd0tg2ZxeJgE4vLllDtrO50HUmWOc03lNNq4sjY10Ro++5OQ9X9GiP28CyaY4fTnDiaJimakHxEGA+5CAWrkQM2ZNkGIRtBfxfr43a4uERUUsphS5jlEpueJeYrCoIw4D762wMUbtkIwBUPP0FCzpA+H1vZ5Obppfm8e8Rwd6tRy02zsrh6egYWvUZZmnLDC7D4fgi0rmih0sDse2DmnaDW8NHjW6g8qPRYfz78Gcoj9mPUGHn59JcZGaOsGR6028lfcCqhlhal9/yrL9Glph7zZ2ArzOf9h+/F41B6+BNyhnDR7x8ckCJucijEB4/c3zZ/ffJ5FzPr8muO+byCIAiCMNAGNJzfddddPPTQQ5jNZu66664e933iiSeOrsXHgQjnXWvx+Hl5dTH/WVlIs6c9lGvVEpdNTuO2WakkVn6nrLdbuKzT8X5rGhuHL+A7k57vqtZR7+lcSC3aIXFufTpTywxE7SpHbuxYVd2rs9JkzaYpIpfm+JG0aKKUwnGtZNmHHKghFKwmFKiGkI1Q0N7rewuLiW2rmp6QPYT4rBzRsyIIwnGx47tvWPTCUwDkXXAJMy9b2O9zlDW4+PeSfN7fUt6hunuUWcfNs7K4alo6Jp0Gag/AhzdC1WFFNVOmwAXPUVAaxtfP7wLAmVDD65kPK+cwRPHaGa+RHp4OQO1T/6bu6acBsF50IUkPP3xM799WVMB7D/0Br1O5aZo4ZBgX/f4B9CbzMZ33cPaaal6+61aCfj9qjYarH3+GyISkATu/IAiCIAyEAQ3nc+fO5aOPPiIiIoK5c+d2fzJJYsmSJUff6kEmwnlHTm+AV9YU8+LKQppc7T3XGpXEJZNTuWOcRPzBd5S5ja66Dsf6VBrW5sxgUWQsy5r2Y/d1DMo6v8yochWn2+IZXuDDUFrT9poMuIxx2CNyaLJmY48eilvbPk1CloPIwbrWXnEljMuhhs5D549gsIR1WMIsITtXrIErCMIJ42xq5LlbFoIsE52SxjWPP3PU5yqpd/Lkd/l8tLWcwzI6MRYdt8zO5sqp6RhUIVj+KKz8e3tBTq2Z0Gl/4c2Ph9Bcr/Ss75r9Gat8iwFItiTzxplvEGOMIdjcrMw9b2kBtVrpPU9LO6r2NlSW8/b9d+NuVn43JA8byYX33I/OOPA3R1e9/RrrP3oXgNy86Zx71x8G/BqCIAiCcCzEsPYuiHCucPkCvL62hOdXFNLg9LVtV6skLhsXy12p+4ne/3bHeYyAS5JYHZvOorgMVnircQZcba9Jsky6DSaUqJhZEUZygR0poMxXD0kqHJYU7NZsJYxH5ODThkHbPPFGJYS39orLwVqg54JtGr2e+Mycw4anD8EaFy8KtgmCcFL5332/o3L/HgCu/cfzRCUd2zJlBbUOnvzuIJ9ur+ywwERcmJ7b5mRz2ZQ0DNWb4cOboLGo7fVdlrtYnn8KAGnjIvlv4oNthTmHRQ3j5dNfxqKzUPv009Q99W8ArBdcQNIjf+l3G5vranj7vrvbljtLGjqCi/7wwKAtM+nzuPnvHTfhbFKKhy587N/EpmUMyrUEQRAE4WgMWji32+0Eg0GioqI6bG9oaECj0ZzUoffHHs49/iBvrCvhueUF1DnaQ7lKgptHBLg1bBXh+98Dd3t1dIcksdxsYVFCJqtlJ55Qew97ZIvMmCKZCSUqxpWoMLYo5wyqtDSHZyjD1K05NIdnEtQYkGUZZAeh1iCu9IrbAB89UanVxKRmkJDT2iOeM4To5FRUalGwTRCEk9vGzz5kxRv/BWDWFdcy+dyLBuS8B20t/PO7g3yxo+MKGYlWA7fPzeGSMZHovrtXKdoJBGQtr9W9iDtoBQlO+20Ot2+5gSqncnxeQh7PLHgGtcur9J43Nyu9519+gS49vc/tcjY18s6f76GxqgKA2IwsLrnvLxjMxz7HvCdbvvyEpa++CMCQaadwzq/uHtTrCYIgCEJ/DFo4P+OMMzjnnHO47bbbOmx/7rnn+PTTT/nyyy+PvtWD7Mcazj3+IG9vKOXpZQXUtrRXLjdIPu7N2M+FfIexakPbdrtKYpnJxKKIGNboJPytwyN1fpnhpTJjimXGF6tIqVF6t/0aE3ZrFk1WZZh6S1gaskqDHHITCtpae8VtylxxuZeCbUBkYnLHgm0ZWWh1+kH5bARBEAZTY3Ul/73jJgCShgznZw89NqDn31vVzD8XH+Cb3R0LdCZHGPnFvBwuDtuF5vNfgrOWLY7zWetQ1jjPGhPB0CsiWPjVQuxeZej56Rmn8+isR6l/9jnqnlTmylvPP5+kvz7Sp7Z4nA7efeD31JYoPfaRiclc9sDfMFkjBvQ9d8Xv9fCfX9ygLNUmSVzz96eJTjm6IfmCIAiCMNAGLZxHRUWxevVqhg8f3mH7vn37mDFjBvX1nYuBnSx+bOHcGwjy7sYynl5aQHWzp237MFUpv49bz0z3EtStf5Q1qFQsNRlZZLGw3mgggIwky6TVwNgipYd8eJmMNggefQRN1hzs1hyarFk4LcnIsh85WKP0igeqkYPVyKHeC7ZZoqI7FmzLzhn0HhZBEITj6dXf3E5dWQlIErc899qg1MLYVWHnn4sPsHhvTYftaVEmfjMzmrOLHyG47zveqHsGV0gZ+XbhQj01uRZu+OYGPEHld8Tlwy7ntyN+TsGCUwnZ7aBSKb3nGT0PE/d7PLz/8L1UHtgLQFh0LJc9+DfCY+IG/L12Z9NnH7K8dZTC6HmncdrNvzxu1xYEQRCEngxaODebzaxbt47Ro0d32L5z507y8vJwuVzdHnui/VjC+aFQ/uyyAirtyh9cRjycrV7HrWGryPIo8x/r1Cq+M5lYZDax0WAgJEGEQwniY4tkRhfJWF3gMiW0DVG3R2Tj1kd2LNgWtCEH63ot2KY3m9sKtR16tkRFH5fPRBAE4URZ/c7rrPvwHQBOvennjJn/k0G71rayJv6x6ADLD9R22J4VbeLxITvRrt/A8obrAEjQ7uPCc2tZOWQmv1z+a4KyMhrqjgl3cP7qALX//BcA1vPOJelvf+v2mgGfj48fe6htSTNjuJXLHnj0mOfX95fP7eL5W6/B53ah0eq48ZmXMYVbj2sbBEEQBKErgxbO58yZw+jRo3nqqac6bL/99tvZsWMHK1eu7PbYE+2HHs4PDV9/bnlha0+5zFipgEvVy7hAuw6j7KJareY7s5FvzSa26vVoAzC8TAnkY4pkUutUOCypyhD1iGyawrPwqQPIQWV+uNIrXgMEemyLRqsjNjOLxENhPGcIEQlJomCbIAg/OrbCfN74/a8AyBw3kQt//8CgX3NzSQP/WHSQVfkdV9o4JdrBqWUSLb4YAGaHP8uorGo+nnI59+5sryb/f+P+wPCb/kWwtfc86/PP0WdldrpOMBDgs3/8lYJN6wDQm8z89L6/EJ+ZPejvsStLX32RLV9+AsDMn11N3vk/PSHtEARBEITDDVo4X716NQsWLGDy5MnMnz8fgO+++46NGzfy7bffcsoppxx76wfJDzWcu31B3tpQyvPLC6hp8WLFwQXqVVyqXspwVRkVGjWLTSa+NZvYqdeRVkNb73huhRa3OZOmiGxlmLolloDccNhc8WqQvT1eX5JUxKSmtVVNT8gZQnRKGmqN5rh9BoIgCCcrWZZ54fZrcdTXodZouPXFt9CbBn5Jsa6sL6zniUUHWF/U0LYtww8/dSqV03WSk5/F/BKLzsl/JpzHv+qUkK2W1LxY9RMsLytBN/zcc0h+9NGO7ysU4st/P86+1cuhdRWNi//4fyQP7Tjt7Xhqqq7ipV/dBLKMJTqGG596SRQPFQRBEE64QV1Kbdu2bTz66KNs374do9HImDFj+P3vf09ubu6xtntQ/dDCeZPLx5vrS3l5dTH1DjdTVXu5TL2Un6g2Uq2VWWQ2schspNKva+sZH1FuQtYqQ9Qbw9NoNmoIBWvbljFDdvR63Yj4ROKzc0nMGUJ8di7xGdloDYbj8p4FQRC+j77773Ns++ZzAM7+1d0MnXb8bmTLsszagnoeX3SAzSXKahw/cWkZ7VNuoCZpd3Fu1J9RSUEezRzFGzQDYA3oeP55FapmR2vv+Wfos7Lazrn4P0+zY/HXAKg1Gi64+8+kjxl33N5Xdz569EEKNytFTs//3X1kT5xyopskCIIg/MiJdc678EMJ54W1Dv67uoj3N5eTEijlfPVqzlWvpsnQzFKTkTUaI/pqDaNKZIZVxGIJZtEQnkFjWAQubaBtrrgcauz1WiZrRFvV9MRsJYwbw76/n50gCMKJULJzG+//358AGDZjNmf98rfHvQ2yLLPyYB2PLzrAvpImrm0xECYrU43GmD7nlPCXCAH3JCTwlVEHwMXrVFyyVFnuMuzUU0l56klkWWb5G/9l8+cfASCpVJz76z+SMynvuL+nrhRu2chHf1OmDmRPmsr5v/3TiW6SIAiC8CPX1xx6VOOOg8EgH3/8MXv37kWSJEaMGMG5556LWgwdGzTBkMyKg7W8ua6EPfv2coZqHW9pVuGIsLFMb+KhJgOp+YkMsaVylS+TxvBY7EYdhUn21oJtmyAg9zhVXGswts0PPxTEw6JjxDxxQRCEY5QyfBR6sxmv00nhlo0EA37UGu1xbYMkScwaEsspuTEs3V/Dfz/Zx5SiAGokdrjOxivJzLf8l4erq3HHxbDMbOKzCUFO2ygR4ZBpWbQI54YNbNizjS1ffXropJzx81+fNMEcIGPsBCyRUTgaGyjcsgFnU+OgVMgXBEEQhIHW757z/Px8zjrrLMrLyxk6dCiyLHPgwAFSU1P54osvyM4e3CIwzzzzDI899hhVVVWMHDmSf/7zn32e5/597DnPr2nhoy3l7Ny0inHuNQw1bqZe10BRswmpLpHUuhSMvliaTRZcGj+hUG1r5fRQj+dVqTXEpGWSNGRoWyCPSkxGUqmO23sTBEH4Mfny34+zd+VSAC76w4NkjJ1wQtsjyzLvvbeP2iVVbdtMhh1cEf4IqDz8Kj6WlSYjc7eHuPXLEDKwZ/QQSlTBtv0Hu/r80Vr19mus/+hdAE65/BqmnHfxiW6SIAiC8CM2aMPazzzzTGRZ5s033yQqSlkrtb6+niuvvBKVSsUXX3xx7K3vxjvvvMNVV13FM888w4wZM3j++ef5z3/+w549e0hLS+v1+O9DOJdlmZ0VdtZs3krd3u8w+DcS6SvHbY8lZE9B74lAlvR41H5CoUbkUFOvS5ghqbDGJZM0JJekIcNIyM4lNj3juPfaCIIg/JgdXL+GT5/4CwBjTz2TBTfcdqKbBMC278pY/d7Btv/2q9xMN7/DUNMS7k4wsMZg4K8vB2kwJmCLMENrIdBTb/45o+eedgJb3r2m6ipeuuNGAKJT0rjm8Wd6PUYQBEEQBstxX+d8+/btzJgxA4ej94JiRysvL48JEybw7LPPtm0bPnw4559/Po888kivx38fwvkLD91JoLCBkN+IHFITkoMEcSGH7ECwD2eQsEQlEJ+VS9rIYSTk5BKbnolWLwq2CYIgnEh+j4dnbricgN+HOTKKm555GZXq5JgOtm9dFcvf2k/A13HUlUlVT4PGAw2rwF+hbFRJnP3Luxk6beaJaWwf/e++31G5fw8AVz/2b2LSMk50kwRBEIQfqUGbc67X62lpaem03eFwoNPp+t/SPvL5fGzevJl77rmnw/bTTjuNNWvWDNp1jze52IXbVd+nfSVJjSksjuj0TFJGDCV1xDDiMrLQGYyD3k5BEAShf7QGA+ljJ1CwaR3OxgbK9+wmbdSYE90sAIZNTSQx28ryt/ZTtre9WKgrFI3eK+OXrISoADREjs486YM5wLDpp7SF831rVjJThHNBEIQfHL/Xg7vFQXhMzIluyoDodzg/++yzuemmm3jppZeYMkVZnmT9+vXccsstnHvuuYPRRgDq6uoIBoPEx8d32B4fH091dXWXx3i9Xrze9jW6m5ubB619AyUhJ538bRVHbFWj1ViwWGOIz8klbfwokoZkE5mQJNZvFQRB+B4ZNv0UCjYpa4nvW7P8pAnnANZYE+feMZ76Cgd711ZRU9xMfZUTry+ITjoFD03oDdl4AlP55tU9WCw6ohLNJA+JIDzm5LspPGTqTJa+8iKyHGL/mhXMuPRKUeBUEATheygUDNJYXUnF/kIqdu2jtqiQ5oZafN5mZNmDWhXJr/73+olu5oDodzh/8sknufrqq5k2bRparTJnORAIcO655/Kvf/1rMNrYwZG/WGVZ7vaX7SOPPMIDDzww6G0aSJPOvZCmchuJ2TlkTJlIwvAhhEVGiUJtgiAIPwDZE/PQ6PUEvF4OrlvN/OtuOenqf0QnW5h5cW77BlnmHz+/H3w2fEHQVYwjv/Kwm+ISpA6LZMo5WSRkWU9Im7tijogkdeRoSndtp8lWha0wn4Ts3D4cKQiCIJwoLnsT1QUHKd29n6oDBTRWlOB29lzsOhhyHdc2DqZ+h/OIiAg++eQTDh48yL59+5BlmREjRpCTkzM4LWwVExODWq3u1EteU1PTqTf9kN///vfcddddbf/d3NxMamrqoLbzWCWPHMbVTw/+TQ5BEATh+NMaDORMmsq+1cvxOB0Ub99K9sQpJ7pZPdqx/BuCdVuRkJGDlQQ9m9AYp7XvIEPZ3kbK9m1m9JwUZlyYg1p7ctxQHjp9FqW7tgOwb80KEc4FQRBOIq5mO7bCfCr27ads9z7qygrwue19P4FkRiVZ0MhayosPkpLx/f8Zf1TrnAPk5uaSm3v8PgCdTsfEiRNZtGgRF1xwQdv2RYsWcd5553V5jF6vR6/XH7c2CoIgCEJvhs2Yxb7VywHYu3LpSR3Odyz+mkX/eRqpdVWQKJeGFUNWUR+/jN/Zgmhd2WxynwWhcJBh59JyGqucnHHLaHSGo/4TY8Dk5k3nu5eeIRQMsn/tSmZfca0YiSYIgnACuFuasRUcxFZUQPm+fdgK8nG3NPThSBWSKhKNFIYuqEbCT1DTgspcRchajS8qiYTsBYRFJxyHdzH4+vSb8/De59488cQTx9KeXttx1VVXMWnSJKZNm8YLL7xAaWkpt9xyy6BdUxAEQRAGUsbYCRjDwnG3NJO/aR0ehwODxXKim9XJps8/YvnrL7X9d2p9M6PKa4lywp8WqvmdSeaF6p3c6n2fpc6fsdtxIWpUlO9r5PW/bmTh7yej1Z/YgG60hJExdgKFWzbiqK+j4sBeUoaNPKFtEgRB+KHzezzYivKpLjhIdf4BKg/sp6W+pg9H6pA0cWiJxOyT0QVaaNZX0xS1G1NMPSajjib3CBqss0kft4AF47JIjTIdh3d0/PTpt+bWrVv7dLLBLrRy6aWXUl9fz4MPPkhVVRWjRo3iyy+/JD09fVCvKwiCIAgDRa3RMnzmHLZ89SlBv599a1Yw7rQzT3SzOtj69WcdgvnEs84n5d2P8VPLkEqYckBmw1AVtyTE8XKVjfnSm4zQbeLDxj+DbMBT7eb++1YyZ+FwTh0Rf0ILsQ2ddgqFWzYCsH/NChHOBUEQBlAwEKCurARbwUGq8g9Qnb+f+vJSel+tW4ukiUOljsPk1xDpaEHrq6A8cicHUhqxxHuZJLlJdsaz0TeZVaopjBkxjUunpDE0Iew4vbvjr9/rnH+ffR/WORcEQRB++GqKC3n97l8CkJAzhCseHrxRZ/21c+m3fPvck23/Pf2nVzD1ostwLF1G+W23AVAfa+Dn1/oJqiViZBWvlZeTGghQ68/kg4a/EJQNACwx+PBmm/nV/CHMHx53QkK61+Xi2ZuuIOj3Y7JGcPNzr54068sLgiB8n8iyTFN1JdX5B6guOEhVwQFqigoJ+n29HKlBUseh0sSjlmII9/iItlej8RVSHFXM7nQf9sQgo3RuZrnchLti+DI4nU9D09HHZnPDKZmcNy4Zg/b7+7N70NY5PyQ/P5+CggJmzZqF0WjssWq6IAiCIAjt4jKyiM3Iora4kOr8A9SVFhNzEqzDvW/1cr59/qm2/8674BKmXfwzACxz52CaNAnXpk1E13q4Ij+Z14baqJNC3Jg1lFdKS0igiFOt/+LrprsBmOXR8kppCze8tonRyVZ+tSCXecOOb0jXm0xkjptE/sa1uOxNVO7fS8rwUcft+oIgCN9XjsaGtiBeXXCA6oIDeJ3OXo6SkNQxqNTxSJoEdLKVSEcDkQ1FGB2bKIkqZ2dmiB1TJKwWH6e63NzpcmFtMfJh8BQeCJ7CXjmNU3JjeeiULGblxvyoMma/e87r6+u55JJLWLp0KZIkcfDgQbKysrj++uuJiIjg8ccfH7zWHiPRcy4IgiCcLLZ89RlLX3kegLGnnsmCG247oe0p2LyBTx9/mFAwCMCEM89jzsIbOvxR5N6+neJLLwNAFR3FfXfEsMddCEC2JZVX6x1YK7ezqvlatrvOBaBW7eVVSwi59TRjU6zceeoQZg+JPW5/cO1ZuZSv/q38fTLxrPOZs/CG43JdQRCE7wuvy9k2R/xQGHc01Pd6nKSyIqkTUGmUh9GnJrK5BKu9gAh7PlXhNezMhO2ZEgeTYHTQx3ynmwUuF0mBICuCo3k7OJfFoYn40HLm6AR+PjeXEUk/rKzW1xza73C+cOFCampq+M9//sPw4cPZvn07WVlZfPvtt9x5553s3r17INo/KEQ4FwRBEE4WXpeT52+5Gr/Xg9Zg5OZnX0VvOjGFbcp27+DDR/5MoHVo4pj5P2HBjbd3GZ7L7/gVLd98A4Dptuu5NWUJZS1lAIyPHcfz2iw0q5/j7donaA4mAuCNPciT/pQO55mQFsFdpw5lRk70oId0j8PBMzdejhwKYY1P4Pp/vfij6okRBEE4XMDno7akiKr8A9gKDlBVcJDGyvLeD5RMSghXJyBpElCpYglzNypBvCkfa3MhTl0TOzIltmdK7MyQcBlhssfDqU43c10uYoMhaojk7cBs3g3OoVyOQ5LgrNGJ/GJe7g92PvmgDWv/9ttv+eabb0hJ6fhLNjc3l5KSkqNrrSAIgiD8yOhNZkbMmsv2RV/h97jZs+I7xv/knOPejuqCg3z06ENtwXzYjNksuOG2bsNr3J2/omXxYggG8bzxHs998ioLV9xCvaeerbXb+F1KBP+4+n3mvfUEH5f9AoDI+mhWjnuXO52XsckWAmBLaRNXvrSeKZlR3HXqEKZmRQ/aezRYLKSOGE3pru3YbdXUlZUQexJMIxAEQRhsoVCQhoryDj3itSXFhIKBXo7UodLEt/aKx6PSJKKS9YS3lBJRX0CEfTPhzUWEcLM7TWLtGIntWRIV0Wp0wHSXm9853cytdWMNhQihZjkTed03m+WhsQRRo5LgvHFJ/GJeDjlxP8xQ3l/9DudOpxNTF3f26+rqxJrigiAIgtAP4047i+2LvgJg69efM/a0M49rsbL68lI+eOR+/B43AFkTJvOT2+7scS1wXUYG1vPOw/7hh4SamzF+8B3P/uxZrv3mWpx+J8vKl/GgIZIH7nqZrEc+obAmFVcoiqr9et5L+Q3rT3uE+7ZbOWBzALChqIHLXljH9Oxo7jp1CJMyogblveZMnkrpru0A5G9cK8K5IAg/OLIs01JXq1RNb50jbissaPsZ3z21Mk/8sF5xSRWFNuDG2lyA1b6HiKbPCHOUog4FKIyHlUOU3vH9KWoCGgmjLDHL6eBXtW5Ocbkxtw7OthuSedI7m9fdM6glEgCVBBeOS+b2eTlkx558S4meSP0e1n7WWWcxYcIEHnroIcLCwtixYwfp6elcdtllhEIh3n///cFr7TESw9oFQRCEk827D/6Bst07ADj7V/cwdNrM43Jde001b9/3OxyNDQCkjBjFhb9/AK2u9xvtvrIyCs44EwIBVBYLOd8tZpNrH7cuvhV/yA/AjaNvZGHyDfzvgbWEQhIayc3C2JsxqhzIM+7k85ir+ceSYgprOxYXmjUkljsX5DI+LXJA329zXS0v3n4tAHGZ2Vz1138N6PkFQRCON1ezvW0JM1uh8uxutvd6nKSKRtLEo2qdKy6pY5AkDXpPIxH2/Nb54gWYnVVIyDRalDnjh4aqN5uVkVVhkoa5ThcLWuxMc3swtMZKWa0jP3oej9VOYZF7CDLKDV+VBOePT+YX83LJjDEP8qdzchm0Oed79uxhzpw5TJw4kSVLlnDuueeye/duGhoaWL16NdnZ2QPR/kEhwrkgCIJwsinesZUPHr4XgNiMLK76678GfT60o7GBd+6/myZbFQDxWTn89N6/9GvOe9W999H03nsARN96C3F33ME3xd/w2+W/RUb50+KeKfeQsm0Su5ZXADDJ/C55Yf9TTpA4juAFL/JphYl/LT5Icb2rw/nnDYvjzgVDGJ1iHai3zRu//xW2wnwAbnz6v4THxA3YuQVBEAaT3+PBVpTfYXi6vcbW+4GqsMNCeLwyVF1SbsKanVVY7flE2AuwNhVg8DYgAX6txO5UJZDvyJQoiwFafy9FqY3M9wRZUF/OZLcH7WGXCsUMY23E2fypcCRFrvYbvSoJzh+XzM/n5ZD1I+0pH7RwDlBdXc2zzz7L5s2bCYVCTJgwgdtvv53ExMRjbfegEuFcEARBONnIssybf7gLW+FBAC64+36yJkwetOu5HS28++d7qCtT6sREJaVw6QN/wxTevxDsr6gg/ydngN+PymQi+7vFaCIjeWvvWzyy4RFQFtTh4XGPUv68nlBIRqcNsjD6OvQ0KyfRmuD0vxAYt5APt1Xy5HcHKW/sOPzytBHx/GrBkAGp3Lvug7dZ/e4bAMy95mYmnHH85/gLgiD0JhgIUFdW0hrElTBeX1aKLId6PlAytA5Lj0elTlSCuErpoZZCQcJaSpQgbi8gwl6INtA+cqk6ycD6VC87MiX2pUr4Ne03iRP0kSwI6lhQsZdxLgcdJl9pzQRGXMDnmgU8tNVMvcvf9pJKgnPHJvGL+bk/+uHrgxrOv69EOBcEQRBORgc3ruXTvz8MQExqOlc9+uSgzD13O1r44OH72m4EhMfGcdkDjxIWHXNU56v6859pevsdAKJvvJG4X98FwFNbn+KFHS8AoFFpuNv5T+q3KUu0TZ1nYKLtl1B/sP1EQ8+Cc5/Ep4/i/c3l/HvJQSrtng7XOnN0Ar9aMIQh8UdfNKiutJhXf/tzANJGjeGn9/7lqM8lCIIwEORQiMbqqtaq6UoQry0qbCvS2T1NawiPb+0VT1CWNWvt4VaHvFibCtoqqYe3lKAOtQdnb4SJ3VkaVic72JEhYbd0HLGVYUlmgTqSBWW7GFFfSqfxXMmT8I25greck/j3Ght1jvb2SodC+bxccuJ+3KH8kEEL55mZmVx55ZVceeWVDB06dCDaetyIcC4IgiCcjGRZ5q0//Zrq/AMAnHrTzxkz/ycDeg13SzPv/9+91BQXAGCyRnDZg48SmZB01Of0V1VRcNrpyH4/kslEzuJFaKKikGWZB9Y+wAcHPwAgIZDG+Zt+DTKYrTqu+vNY1N/dB5v+234ySzyc/wzkLMAbCPLOxjKeXpqPrdnbtoskwTljkrhjwdH1wsiyzH/vuIkmWxWSSsWtL76J0SIqBAuCcPw4GurbhqUfmivudTp7OUpSCrYdWsJMnYCkjkaS2ot36kMurA37sTbmE2HPx+ysRHVYT7ts0FM7NJY1yU5WJjV3GKp+yPDIYcw3pbCguoCsgpVIR/bUG6Ng7GV4R1/O64VmnlteSJ2j48/os8ckccd8UX39SIMWzp944gn+97//sXnzZsaPH89VV13FpZdeetIPaUeEc0EQBOEkVrFvD2/f/ztoDc7XPvEcBsvA9Di4mu28/9AfqS0tbjv/T+99mJjU9GM+d/VD/0fjm28CEHX9dcT/9rcABEIB7lx2J8vKlgFw9sFbSKkbDsCp149gyOQE2PclfPpzcNW3nzDvVljwZ9Aa8PiDvLW+lGeWFXT4A/BQUaFfzsslo59FhZa9/hKbP/8IgDNuv4sRs+Yd82cgCILQFa/LqQTxw4anOxrqez1OpYkE1eEF22KRJG2HfSw0Y63bR3jtPqz2Aoyeuo692yoVgSHpHMw18XVMFRti7QTVneuZjIsdx4LoscyrryB192fgrD1iDwmy58L4q/Bk/4Q3N9t4bnkBtS0dQ/mZoxO5Y37uMY1u+iEb9GHtBw4c4M033+Ttt9+msLCQuXPncuWVV7Jw4cJjafegEuFcEARBOJl99o+/cmDdKgCGnzKXM3/+62M+Z3NtDR/+9c/Ul5cCYI6M4qf3Pkx0cuoxnxvAb6uh4NRTkX0+JINB6T2PUYbJewIebl50M1tqtpBkz+HcPcq65/GZ4Vx89yTlBC02+OQ2yF/cftK4EXDRfyB+JABuX5DX1xXz3PJCGpztQyfVKomLJiiVf1Oj+lbMrnzfbt65/24AcqdM59xf/2FAPgdBEH7cAj4fNcWFbb3i1QUHaaws7/U4tdYCUjySKr61VzweSWXssI9KJROpbiasZg/h5duw2os6zBc/RJOaSvPYDDam+vggbD/Vakfn60lqJidMZkHyKcxzuojd+RGUrevcMGsqjLsCxl+B25TMm+tLeGFFITWHhXKAs0Yn8sv5uQxNEKG8J8d1zvm6deu49dZb2bFjB8Fg8FhPN2hEOBcEQRBOZi31dbz6m9vxupQ/us656/cMyZtx1OerOrifjx97CJe9CQBLVDQ/vfcvRCUlD1ibAWyPPELDq68BEHX11cT//p621+xeO9d8fQ35jflcvON3xLiUa1989yTiM1t/F8sybHgBvr0Xgq1/+Kn1Sg963i3Quu660xvg1bXFvLCikKbDig5pVBKXTE7l53NzSIro+EftkUKhIM/dvBB3sx2NXs9t/3mrT8vHCYIgHBIM+KkrLcFWmI+tMJ/qwoPUlRYT6iUHqTQGNPoEgsHYtl5xJEunFTp0OojW2gmv2YP5wFrCWkpQhwKdz2e1opsykbJhUXwXX8dX3s24A53XNNepdExPns6CtPnMUUdg3fkh7PoQfC1HnFALw86CCQshaw5Ov8zr60r4z8rCDnPKAc4YlcAdC3IZliAyVV8cl3C+YcMG3nrrLd555x3sdjvnnHMO77zzztGebtCJcC4IgiCc7PasWMJXTz8BgM5o5LIHHyM2LaPf59m/diVfP/2PtqJCkYlJXHjPA0QkDPw0tEBtLfmnnobs8SDp9WR/+y3a+PZlymxOG1d9dRXWwnTmFP4MgKHT41mwcGTHE9n2wIc3gm1X+7asuXD+sxDe3u4Wj5+XVxfz4spCWjztf7Dq1Coum5LK7XNziA83dNveb557kl1LvwXg/N/dS/bEvAH5HARB+OEJBYPUl5dSXXgQW0E+tsKD1JYUEQx0DsuHk1QaDJZEZDmWYDAOSZOApIrscqnMMKuaaI0Sxo27lmFqLEWic0STtFqMEyYgTxrDjkz4QrOXDTWbCMid22LSmJidMpv56fM5JXIEpj2fwdbXoWZP58bGDlcC+ZhLwRxNi8fPa2uVUN542I1QgJ+MTOCX83MHZAWNH5NBC+eHhrO/9dZbFBcXM3fuXK644gouvPBCwsJO7uEMIpwLgiAIJztZlvn8n39rG94eFh3LZQ/+rc9rcgd8Pla+9Qpbvvq0bVvqiNGc8+s/DGrxM9vfHqXh5ZcBiLzyShL+9McOrxfaC7nusxs4b+1v0AUNhDQBbnxsDgajruOJ/B5Y8hCs/Xf7NkMEnPl3GH1xhwJGdrefl1YV8d9VRTi8h4V0jYor89K5ZU4WcWGdQ3rB5g18/OiDAIyaeyqn33LHgH0OgiB8f4VCQRoqyjv0iPelcrokSRjD41HrEvF5o5HluNZ54p1X3ZBUEtEJ+vYwvm0xmuribs+tHzoU8/TptIzLZEV0HYttK9lZt7PLfSP0EcxNncuC9AXkxU9GX7JGCeT7voDgEe9BZ4FRF8KEqyF5IkgSdpefl9coP1ObD7vxeajQ28/n5ojh60dp0MK5SqVi0qRJXH755Vx22WUkJCQMRHuPCxHOBUEQhO8Dv9fDuw/8nuoCZbkxc0Qk5//uPhKyc3s8rmTnNpb89zkaDpvnOHL2Ak696XbUGm2Pxx6rQH09+QtORXa7kbRashd9i/aIvxG2127npae/ZGi10lPtmlHAb668ocueJAqWwEe3gqO6fdvwc+GsJ8AS22HXRqePF1cW8sqaYly+9mGlBq2KhdMyuHlWFtGW9qHrfp+XZ2+4Ar/XgzEsnFteeH1Qlq4TBOHkpSxhVomt4CDVhUqPeE1RIX6vp9djLVEJ6M1JBIOxuBwRSKpYJEnX5b5avZr4dDPRumbCbXvQb/2OUP6+bs+tiYvDPH06punTKBlqZYljC0tKl1Dc3HWATzInMS9tHvPS5jE+bjwaezlsewu2/Q/spZ0PSM1TeslHnA96pehoo9PHS6uKeHVNMS2H3ehUSXDeuGRun5sjlkQ7RoPacz5kyJCBaONxJ8K5IAiC8H3hbGrknT/fTWNVJQAqtZrxPzmbiWdd0GFd8oDPR8nObWz58hNKd21v267Wapl1xXWM/8nZXYffQVDz+OPUv/gfACJ+dhmJ99/faZ+vNyyn4L9KgLZZikldGOTGMTd2fUJXA3z5G9j1Qfs2Uwyc/Q8YcW6n3esdXp5fUchra4vx+NuXADLp1Fw+JY0bZ2W1DXf/9Im/cHD9GgAuvf+vpIwYdYzvXhCEk5Usy9ht1crQ9MJ8bAUHsRXl43N3np99pLCYBMyRqUiqONyOCNzOCCSp+zoVZquOxGwr0UYH4bbdaLYux7t9G3QzDF5lMmGaMgXz9Onop05hm6mWJWVLWVq2lFr3kZXTFUMjh7YF8qGRQ5H8btj7KWx9A4pXdj7AFAPjfgbjr4LY9qWw6xxeXlxZyOtrSzrc2NSoJC4Yr4Ty/q6IIXTtuMw5Dw8PZ9u2bWRlZR3tKY4rEc4FQRCE7xNXs51P/v4wlfs7zhGMSU3HHBmFx+GgoaKsU09PYs5QTrv5F8QcxVz1YxFobKRg/gJCLhdoteR8/RXa5I7F52RZ5sX7FuOvVXqq3x3zV+449RYuzL2w+xPv/hi+uKvjkmujfwpnPAqmqE6717R4eHZZAW+uL8UXaA/pOrWKiyelcOvsbBy71/Plvx8HYMIZ5zL3mpsG4BMQBOFEk2WZ5toabIWtPeKtQbz3tcQhPCaO8Lh0tIZE/N5o7HUW/L4eRh1JEJ1kJiHLSlyEH4ttD2xeiXvDBkItLV0fo1ZjHD0a8/TpmKdPIzQil1U1a1lSuoSV5Stx+DtXWFdJKsbHjWde6jzmps0lNSxVKaRZvlEZtr7ro87F3SQVZM9XesmH/AQ07T37Nc0enl9RyJvrSzrcyNSqJS6emMptc7L7vAKG0DfHJZyHhYWxfft2Ec4FQRAEYZAE/H42fPwuGz/5oNd5jxEJieRdcCkjZ81Daq1wfrzV/POf1D/3vNKeSy4h8cEHOu2zc1k5K94+AMCOhGWsy/qEf875J3PT5nZ/YkcNfH4n7Pu8fZslAc59Eoac3uUh1XYPzy7L5+2NZXgPC+lqlcT5wyNJ/uqvyMEgYTGx3Pjv/x63EQaCIAwMWZZxNNR3KNZWXZiPp6W512PDomOJTs3CEJZMKBSDo8lKY3UIOdR9NFJrVcSlh5GUE0FcvJow2x78m9bgXLOGQGVVt8fpMjIwT5+mDFfPy6NR42VZ2TKWlC5hXdU6/CF/52NUOqYnTWde2jxmp84mytB6I7K5Cna8DVvfhPqDnS8WlQ3jr4CxP4PwpA4vVdndPL+8kLc2HHHjUqPissmp3DI7u9cVL4SjI8J5F0Q4FwRBEL6vmutq2L3sOw6uX019RTmhYABJUmGJjiZt5Fhypkwja8KkEz53OtjURP6CUwk5HKDRkP31V+hSUjrs43H6eeWe1QT9ITwaJ69PvA+NVs2/5/+bqYlTuz+5LMPO95Sh7h57+/ZxV8DpD4MxssvDalo8vLSqiDfWluA8bOjmudWfk+4uA+DKR/5JfFbOMb9/QRAGj6OxQQngrUHcVpjftlRkT8wRkcRn5RIWk4ZKE4/bGUldeRBHg7fH44zhyhD1xGwr8cl6TLYDeDauw7V2HZ69e5WfSV1QR0S0hXHztGlok5MpbS5lSekSlpQtYVvNNuQuqrGH6cKYkzKHeWnzmJ40HZO2tfc64IMDXynD1vMXgxzqeKDOAiMvgPFXKnPKj7jRWFzn5PkVBXywuQJfsP1Yg1bF5VPSuXl2Vo8rXAjHbsDD+X333cd9992HRqNp23brrbfy0EMPERMTQ2lpKddffz2LFi0amHcwCEQ4FwRBEH4I5FAIr8uF1mBAfdjv5ZNF7ZNPUffMMwBYL7qQpIcf7rTPopd3c2C9DYDFua+SH7MFg9rAU/Of6jmgAzRXwqe/hPzD/uYwx8GZj8GI8zr9YXqI3eXnlTXFvLymiCaXn5HNe5hXvxwAW9ZMLrrxRvKyoo/hnQuCMFBc9qa2iumH5ok7Ght6Pc4YbiUhO5eYtCx0xiT8/hgaq2Sqi5rxe3pehzwqyUxCaxhPSDOjrTqIa50Sxl3bt4O/cw83gKTTYZo0EdM0JZAbhg8HSWJPwx4lkJcuIb8pv8tj403xbfPHJ8ZPRKs6bBh99U4lkO94F9xdvPf0mUov+YjzQNd5bvjuSjvPLivgy51VHD4gwKRTc9XUdG44JYvYsO7nzwsDZ8DDeVpaGtHR0bz22muMHj26w2svvPACv/nNb5gxYwZfffXVsbd+kIhwLgiCIAiDL9jcTP78BcqcS7Wa7C+/QJee3mGfyoONfPT4VgCc8TW8nqUE+D4HdFlW5lp+80fwHjaEdehZcNbfOw3nPJzTG+Ct9aW8tmQn5+19EQlo0EbyZsplTM6I5La5OcwZEiuGuQvCceJuaW5fvqx1jnhLXdfF0A5nsIQRn5VDQnYu4XHpyHIsTTYV1UXN1Jc7uuvYBkCjVRGXEa4E8Wwr8ZlhSGWFONeuw7luLa5Nm5Fdrm6P1w8f3j5UfeJEVAYD/qCfjbaNLCtbxtKypVQ7q7s8Nicih7mpc5mfNp8R0SM6/qxxNSgjhLa+AdU7Oh8cnqIUdxt3OUR1PXp5Q1EDzyzLZ9n+jp9hmF7DVdOUUB5l7rq6vDA4BjycNzc38/Of/5x3332X+++/n7vvvpvy8nKuu+46Nm3axN///nduuOGGgXwPA06Ec0EQBEE4PmqfeYa6J58CwHreeST97a8dXpdlmTfuW0dzrRskKDjzGxY1fAn9Cei09qJ/8RvY/0X7Nn04nPoATLgGeph77/EHeeF3d+GvLADgjeTLaNQpQ+NHJoVz+9wcfjIyAZVKhHRBGCgep4OaogIlhLcuYWavsfV6nN5kJj4rm/isXOIystGZk2lp0FJd2Ex1gR1HY89D1E3WQ0PUI0jIthKdYiZUXoZz3Xqc69bhWr+eYGNjt8dr09Mw503FPG0qprw8NFHKHHC7186K8hUsL1/O6orVXRZ0k5AYGzu2rYc8PbzjzUoCPmUk0Pb/wYFvOq9JrtbD8HOUXvLM2dDF9CVZllm6v4ZnlhawqaTj+4ix6LhuZiZXTk0n3DC4y2oKXRu0OeeffPIJN998MwkJCRQVFTFt2jRefPFFUlNTB6Ldg0qEc0EQBEE4PoIOh9J7breDSkXW55+jz8rssM+mL4tY/2kRAJPOTudN079YWrYU+hvQZRn2fAxf/hach/UUpc+Ac/4FMd2vD7/5i49Z9pqy/Nv+lFP4VttxSbWsWDM3z8ri/PHJ6DViLXRB6A+vy0VNcUFrxfQCbIUH25aH7InWYGwL4glZOUQkZOJ2GrAVtVBdaMdW3ELA28MQdQmikyxtQ9QTs62ERRsI1NTiWr+utXd8HYGq7ou4qWNjME+dhnnqVMxT8zqsPFHSXNLWO76tZhtBuXNbtCoteYl5zE+bz5zUOcQYYzruIMtQvkkp7rbrw66HrSdNUOaRj7oIjBFdtjMQDPHFziqeXVbAvuqOFduTI4zcMjuLn05KxaAVP79OpEEL59XV1Vx11VV89913mM1mPvnkE+bNmzcQbR50IpwLgiAIwvFT9/wL1P7jHwCEn3UWyY//vcPrLQ0eXvvjGpAhPNbIpfdP5DcrftMW0PVqPU/MeYJZKbP6dkFXAyy6VxkOeohaD7N/B9N/2WEpoUPsNTb+84vrAYjPyiHmirt5emkBOyvsHfaLC9Nz3cxMLs9LEz1PgtAFn9tFTVEhtqJDQ9MLaKws7/U4jV5PXEY2CVk5xGfnEp+Rjfz/7d15fGRVnffxT+1bUtn3Pd3pfe/0At1NNyDMIIvgKCDKMjoz8ggqwjg4Oj6oI4vwyDiK4ICOAoogKosbCAi90Fu60+l9z75vlVRVaq97nz9upTrpVLbuhvTye79e93WTqlu3bpJDU997zvkdXSqd9V7aavtpP95PX8fow8u1cxjIiQ1Rz5uWQk55ChabkWh/PwPbt+OL9Y6Hjh8f9Rz65GTsK5bHAvkKzNOmxYebR5QIu7t2s75pPe82vUu9uz7hOVIsKVxScAlri9ayKn8VSeakkQe56rU55LtfhN4E1+PIhgU3aqE8e/ao1xsIR/ntzmae3lBLY+/w309FdhL/Z900rl2Yj8kwNSt3iOE+kHD+61//mrvvvptFixbx5JNP8rOf/Yz//u//5s477+SRRx7BZju7S+9LOBdCCCE+PFHvAMevuEIbKqrTUfqbl7CdVLfmtR/sovmQNgTzhvuWkFXu4L7198UDulFn5Lurv8vV5VdP/I1r34M/fFn7EDwoc6Y2F71sZNB//v4v01mvfUj+5x//L8kZWWw42s2P3z3G9rrhvVlJFiOfXlHMP64qIzdFqhuLC1Mo4KezvlZbvqxOK9bW29YyavXyQUaTmazSMnLKp8d7xZPS8+hqGqA9FsTb69yE/JExz5OUZiG3PCXeM55ZmITeoEfx+/FVV+PbqvWOBw4cAEVJeA6dxYJ96RLsKy/CcdFKrHPmoDOc6F0eCA/wfsv7vNf0HhtbNtIXTFwVvtRZyrqidawtXMui7EUY9QmKdPr7tNE9u1+Exi0JfjE2mHW1tvxZ+TowjF7os9sb5LktDfxyawO9A8OHvy8uTuUL66Zz+axsmY5zljnj4fwTn/gEb775Jg899BBf/OIX449v2bKFO+64A1VVefbZZ7nooovOzE/wAZBwLoQQQny4ep99lo6HtfnmtoULKfn1C8PWYD+yvZ23/vcAALMvzuOy22YTjob5+qav80b9GxCbr/nvK/6dT8361MTfOOSD9x6CLT8evuzQ/E/Cld+F5Nz4Q1t/9yLv/0brbV976+eovOaG+HO7Gl38z/pa3jzQPix3mAw6blhcwL9cUs707ORT+dUIcU4IBwN01tdpS5fFesR7WprGDeIGo5GskhNBPKd8OukFRXhd4RNBvNZNT6uXBKuKxekNOjKLksmLhfHccidJadqNMTUUwr9vnzZnfMtW/DU1qKNUVMdgwDZ/PvaLVuJYeRG2RQvRW4ZXKm/ztvFe83u81/QeVe1VCdcf1+v0LM5ezLrCdawtWktZStmIY2BwHvnb2rD1w29A9OQ58TooWwMLbtbmk1vHzibHOr38bFMtv6tuGbZGOcCaiky+sG46K8vTpZDlWeqMh/NVq1bx7LPPMn36yDVAA4EA999/P0899RShUCjh688GEs6FEEKID5caDlN7/Q3x4aT533uElI99LP58OBTlF/+2iVAgisli4B8fXY3JYiCqRHlo20P85shv4sd+YdEXuHPBnZP78Nm2G/54L7TsOPGYxQmXfgOW/RMYjPS2NvPzr9wJQO60Cj790H+NOE1tl5dnNtbxu+rmER+MPzI7h/+zrpylJemT+t0IcbYJBwN0NdTFK6d31B6jp7kJ9eR1tU+iNxjJKimNBXEtjGcWFaMoeroa3LTFgnh7bT8B7yjhOcaWbNJ6xWNhPLs4GaNZ69FWIxECBw4wsG0bvq3b8FVXo/r9o57LMnMmjpUrsK9ciX3ZMgxJw4eZK6rCgZ4DvNekBfLDrsMJz+MwOViVv4p1RetYU7CGVGvi+d+oKrRUa4F8728TzyPPmgULbtKGrqcUjvm7UFWVrbW9/HRjLe8c6hz2nEGv45oFefzzmnLmFaSMeR4x9c54OFcUBf0YFU8BNmzYwCWXTHBe2BSQcC6EEEJ8+Lyb3qcptqKLISuTaX95A0PSiTV53/3VIQ5s1IpEXX7HbGatzIPYB9Mf7foRz+x9Jn7sp2d/mq9WfhVDgmrFo1IU2PUcvP0t8A+pYpw7H67+LyhaxnP3f4mu+loAPvfDn5Kak5vwVJ2eAL94v57ntzbgCQwfeltZksY/rSnnijk5GGRIqTjLhQMBOhvq6Kw7FivWdoye5kbUUYaBD9IbDGQWa0E8N9YjnlFUgsFoxOsKxnrEta27yYuijB41dDrIKEwit2ywVzwFZ6Y1fgNOjUYJHDqEb9t2fNu24duxA2VgYNTzmYqKtAJugxXVMzJGHOML+9jWto31zevZ0LyBLn/iJdvyHHmsK1rHuqJ1LMtZhskwRq0JV4M2j3zPi9CTYD1zRxbM+wQsvAnyFmk/+BjCUYU/723jmY217GtxD3suyWLkU8uLuGNVGQWpZ/eUYnHCB1YQ7lwm4VwIIYSYGk133Y33nXcAyPjnfyL7vvviz7XX9vO7R3cCUDAjlevvXTLstc/uf5b/t+NEMblLiy7lkTWPYDfZJ3cRAz3wzreg+rnhjy++le2hZWz87csArL75NlbccOOYp/IGI7y4vZGfbqyj3R0Y9lxRuo3bLyrlxmVFUjxOnBWCvgE6647TUXc8vne1tkygR9xARlEJOWXTyZ0W6xEvLsVoMhENK3Q1eeJBvL3WzUDf2MuZWezGWK+4k9zyFLJLnZitJ+ZXq4pC8OhRfNu2MbBtO76qKhS3e9TzGXNytCJuK1ZgX7ESc2FBwuOaPc1saN7AhpYNVLVVEVISj/SdnzmftYVrWVe0jhlpM8YepePt0uaR730ZmrYluDirNo98wc0w7VIYK9zHeAJhXtzexM/fr6O1f/i/K/kpVj67uoyblhWRLP+unHMknCcg4VwIIYSYGqHGRmqvvkabD2oyUf7aa/Gl1VRV5YVvbYtXZL71uxfhzBzeI/TK0Vf49pZvx5csmp0+mx9d9iNyHDmTv5im7fCne6F9b/yhfjL56UGtMnJmcSm3P/bExH6uiMLru1t5esNxjnQMX984yWLkk5WF3HFxKSUZjlHPIcSZ5HP3a8Xaao/RGQvjfR2jLxk2SKfXk1lYrFVML5tOzrTpZBWXYTRrqxwM9AfpqHXTVttPR20/nQ0eopGxw31arj3eI55bnkJajh3dkFElqqoSqq09MUy9qmrMtcYNGRk4VizHvmIljhXLMZWUJAzQYSVMTWcNG5s3sr55PbX9tQnPZzFYuCjvItYWrWVt4Vqy7Flj/5KCHjj0Jy2QH38XEiyhRukabdj6nOvAOrHh5k29Pp7bUs+L25vwBIePyJlX4OSf15Tz0fl5Unn9HCbhPAEJ50IIIcTU6fyvH9DzP/8DgG3xYkp++Xy8OvLON+rZ+qr2AXrZ1aUsv7Z8xOs3t27mvvfuwxvWQnC2PZsnLnuC2RmjLzc0qmgEqn4K7z4IQa1n7oW6hbQFtM8Ht37vh2SXjryG0SiKysZj3fzvpjrWHxk+TFan0+alf3ZVmRRsEmeU19Ub6wk/Fu8R93QnHqY9lN5gJLO4hJyyaWSXTSe7tJys0jJMZq1AWiQUpavRQ0e9m/ZaNx31/Xh7x+4VN1kM5JQ540E8p8yJ1TG8h1dVVcINDVqv+LZtDFRtJ9rVPeo5Damp2Jcvj/eOD13e7GS9gV42tWxiQ/MGNrdsxhP2JDwux57DJYWXcEnhJazIW4HNOM7Q8EhQK+y292U4/BeIBEYekz0X5v+DVnAytXjs88UMzif/xeY63jrQwcmj/y+flc0/rSmXfzPOExLOE5BwLoQQQkwdxe+n9mPXE25sBCDn379G+u23A+B1BXnu6++jqpCcYeXW/7xoWA/boON9x7nrnbto8bYAYDPa+N6a73Fp8aWndlGeDvjbf8KuX7KrN5e/dWiFb5eW6Vj3lUcgZ+6kT3m0w8PPN9fz++pmAuHhPYuz85x8dlUp1y7Mx2qaxLx5cUFTVRVPd9ewEN5Zd5yBvtF7mQcZzRaySkrJLpseC+PTyCwqxmA0xc/d3+mno05bxqyjzk1P89hzxQGcWTatgnq5k9xpKaTnJ41YvktVVcKNjfiqqrT1xrdtJ9LRMeo59cnJ2Jct04q4rViBpaJi2OoOJ5/7UO+h+HD1vV17UROUfdfr9CzIXMDaorWsKVgz/nB1ACUKDe9rgfzAaxDoH3lMSjHM/4S2TeLfiUA4yms1Lfz8/XoOtQ+/gWA26vmHJQV8bnWZrAJxnpFwnoCEcyGEEGJq+aqqaLj1NgB0Vivlr72KuaQEgD/8qIbG/Vp14499ZTGFM9MSnqPH38OX3v0Se7r2aOdBx+cXfp47F9w5uUJxQ7Xtxv/6v/OTv4GCHochxL/MqEJfeQes/RokT374vGsgxK+rGnluc8OIeelpdhM3Livi08tLKM6Y5Nx5cV5TFYW+jrZh88M7644T8CbuCR7KbLORXaoF8MEgnp5fiH7I+t2BgTAd9VoI76jrp6PeTXBg7HXFjRYD2cXJw3rG7U7zyGtXVULHjuHbsQNf1Q58VVVEukbvydc7HNgql+JYroVx6+xZw9YaP5kv7GNr21Y2NG9gY/NGOv2dCY9zmp2sKljFJYWXsDp/9ejV1YdfPLTVaFXW9/0OPAmmAtgzYO7HtR7youXjFnYbqrXPz/NbG/j19kb6fMMr1mcnW7h1ZQmfWlFMZpJl1HOIc5eE8wQknAshhBBTr/0/v4vrV78CwF5ZSfFzz6LT6zm6o4O//nQ/ABXLcrjyc6P3RgUiAb75/jfja6EDrMpfxSNrHpnYB/FEVJXXvvVFjh2qB+DjRfsoS3KByQ4X3QUXf2nctYgTCUcV/rKvnZ9tqmN3U9+w53Q6WDcji1svKmHtjGyp8n6BiYTD9DQ30lVfS2dDLZ11tXQ11BIaY3mwQdak5GEhPKdsGqk5ecN6mqNRhZ5mrxbEY4F8sLbDqHSQluvQgniZk5wyJ+l5DvQJ5jur0SjBw4djYbwK346dY84Z19ls2Jcswb5iBY4Vy7HOnYvOaBz1eFVVOdp3lPdb3uf9lvfZ2bmTiJL4RsL01Onx4eoLsxZi1I9+3iFvAO17YP+rsP8VcNWNPMbkgNnXwPwboXzthAq7Db3+HQ0ufvF+PW/sbyd60miExcWp3HFxKVfNy8NslPnk5zMJ5wlIOBdCCCGmnjIwoA1vb26GIcPbI+Eoz/77ZgLeMHqDjtsfXpWwd26Qqqr8fP/P+e/q/0aJVZ3Oc+Tx+LrHmZc575Su7VjVVl77f98FYEaKi2vz95140pYOl3wVln0OjKfWu7WzwcXzW+r58952QtHhQ94L02x8ekUJN1YWkiG9Z+edgNdLV0MtnfV1dNYfp6u+lp6WJpRogqJiJ7GnpGrrh8eD+HSSM7OGDc9WVRWvK3iiR7zOTWejh2h47KJttmQTOaVOcsq0eeLZpU4stsTBVg2HCRw4oAXxqh34qqtRPKP36OvtdmxLlmCvrMS+rBLb/PnozKP/Nw3QH+xnS9sW3m95n80tm0ftHbcYLCzPXc7awrWsKVxDflL+mOc98UOoWjHI/a9o1dZ7ExSL05ug4gptyPqMq8A8udEtnkCYV3a18KutjRzuGP77MRl0XD0/jztWlbGo6BRvJIpzznkXzh988EH+9Kc/UVNTg9lspq+vbwKvGk7CuRBCCHF2GNi6lcY7/lH7xmSi9PnnsC1axJZXjlH9pjYnfcXHyqm8qnTcc21v285XN3yV3oA2JN6kN3H/svu5ceaNky6kFI2EefoL/4ivvw+9wcC//MM0HPufA2XIMNSUYrj067DgRjjFYfTd3iC/2dHEr7Y20tI3vJfUbNBz9YI8PrOyhCXFqVIM6hyjqirurk46G2q1HvH6OroaanF3JQ6ZJ0vOyCKn/EQIzy6bRlJa+ojjAgNhuhq0om2dDVrPuK8/8RJhg/RGHVlF2vB0rWc8heQM66htTAkGCezdeyKM19Sg+kbvedc7ndiXLsW+bBn2ZZVYZ88es2ccIKpEOdBzgE2tm3i/5X32du+N32w7WUFSAasLVnNJ4SUsy102fjG3QYOB/ECshzxRINfpoWSVFshnXwf2kb/z8exr6edX2xp4raYVX2j4TZfMJDO3rCjhMyuKyXZaJ31ucW4778L5Aw88QGpqKs3NzfzsZz+TcC6EEEKc4zoefYze//1fAIx5eZT9/nf4olae/+YWUCEpzcKtD148oshUwnMNdHDf+vvY3bU7/ti6onV8++Jvk26d3Ifsjb9+lu2vDlnzfO0yrar73peHH5g1C9b+G8y5/pRDelRRefdQJ89vbRhR5R1gRk4SNy0r5obFBaQ7xu5xFB++aCRMT3MTXQ11dNbXxoenBwcGxn2tTq8no6AoVim9XNuXlGFLHvkZNRKK0tXkpbPeHQ/j/Z3jD313ZlrjPeI5ZU6yCpMxmEYfPh31DhDYs1sbpr69Cv+ePaih0QO/IT091iuuhXHLjBmjFnAbqtvfzebWzWxq2cSW1i30BRN/rrcarCzLXcaqglWsLlhNcXLxxG9WxQP5a7FAfnzkMYOBfO4NWiBPGmcptQT8oSh/2NPKr7Y1jpi2ArC0JI1Pryjm6gV5WIxSBPJCdd6F80G/+MUvuOeeeyScCyGEEOc4NRym4Y5/xL9zJwCO1aspevp/+PNTe6nf2wPAR//PfMoWTuwDczga5vs7v8+vDv4q/liGNYPvrPoOlxReMuHr6u9s56df+mdQVZxZ2Xzuh8+g1xugbTe8/W04/s7wF5yBkA5Q3z3AC9sb+c2OphEFo8wGPVfMzeGmyiJWT8+c0A0LcWYFfQN01dfF54Z3NtTS09SIEh27mBqAyWoju7SMrBIthGeXlpNRWBxfQ3woJarQ2zZAZ/2JXvGelgHUcaqnm21GckqTtTBeqoVxW/LYN3TCra34qnfh37UL365qgocOgzL6MHhjTo4WxCsrsS9fhrmsbEJh2Rf2saNjB1vbtrKtbRtHXEdGPXZayjRWFaxiVcEqluYsxWKYxBSPaASatmprkR/6I/Q1jjwmHsivjwXy7ImfP0ZVVfa29PPyjmZeq2nBHRjeBpIsRm5YXMAtK4qZnSeZQ0g4T0jCuRBCCHF2CXd0UvfxjxPt0cJ45t1341t3M398QusBL5qTznVfWjSpc77X9B4PbH4gPswd4KaZN3Ff5X0THgb7u4cfoL5Gu2nwsX/9D6YvW3niydr1Wk9607bhL4qH9BtgAr2HowmEo/xhdysvVTWxo2Fkca2CVBufrCzkk5VFFKROcFivmDBVVfH0dGnD0etrtR7xhlr6O0dfAmyopPSMWC94uRbIS8tJzc5N2KOsqir9XX46G9x01nnobHDT1eghMs48cYNRT2ZREjml2hzxnFInKVm2hMsPxt8rEiFw6DD+Xbvw76rGV72LSHv7mO9jKirSgngsjJsKCycUxsNKmL1de9nWto2tbVvZ07WHiJr4JkaSKYmVeSu1QJ6/irykvHHPP/zN/HD8XS2MH/4L+HsTHKSD0tWnFcgBerxBXtnVwss7mkfMJQeYk+fkMytLuG5RPkmWCRSkExcMCedAMBgkGAzGv3e73RQVFUk4F0IIIc4iA1u20PjZz2nDUIHchx7mj9XZuLu15cc+/e2VpOZMriBTt7+bBzY/wIbmDfHHipOLeeCiB1iet3zc19dWV/HK974NQMGsudz87e8NP0BVofZdeO+RxCF91Zdh3ifAeHpD0Y91evjNjmZ+t7OZnoHhw4t1OlhTkcVNlUVcPjtb1k0/BaGAn+7GBrob6+lqrKOroZ7uxnqCvgkMS9fpSS8oJKukbNjQdLszJeHxWugP0NXoobPRo+3r3QR9Y/e863SQnu8gu+REEE8vcGBIUD19qKjHg7+mRusVr96lDVEfY744Oh2WigpsSxZr88YrKzHlTSwoD1ZV39q6lW3t29jRvgNfJPF76dAxO2M2q/K13vEFWQsw6SdeAR0AXy8ceVML5Mf/BuEE76U3aoF81jVaID+F5RABIlGF9w538fLOJt452EnkpBEMNpMhXiNiYWGK1IgQCZ0T4fxb3/oW3/72t8c8pqqqisrKyvj3kwnno51fwrkQQghxdul+5hm6vv+49o3BQP8Xn2BnjdZ7uPAjRaz+RMWkz6mqKi8feZnHqh4jED2xzvj106/nvqX3jbnkmqoo/OJf76K3pQmAW777ffIqZiZ6k9FDurMAVn4Blt4OluRJX/9QoYjC3w518GJVExuOdHHyCOdkq5Gr5+dxw+IClpWmy7D3k6iKQn9nRyyAnwjhfR0J1rJOwGixaCF86LD04hJM5sRDrlVVxd2tBfGuRjedDR66mjzjridObJ74YAjPLnGSVZyMyTL2jRdVVQk3N8eCeDX+6l0Ejx6N3/BKRGe3Y1uwAPuSxdgWL8G2aCGG5Im301ZvK9vatrGlbQvb2rYNG6lyslJnKSvyVrAybyXLcpeRYkl8A2NMfY1w6M9aIG/YDGqCKvcmB1R8RAvkFVeALW3y7xNzrNPLyzub+H11C12e4Ijnl5akcWNlIVcvkF5yMb5zIpx3d3fT3d095jGlpaVYrScqGkrPuRBCCHH+UVWVjv/8Lq4XXgAgkpzB+8u/QzQKZquB2x5eNeryTuOp7a/lgfcfoKarJv5YujWd+5fdz1VlV43a07X3b3/lr//zQwAqVlzMdfd+fawfIBbSv6fNeR3KmgLL/glW3HnKw2mHauv389sdzby0o4lm18iiYAWpNj62KJ+PLylgevbp3RQ4FwUGvLGe8Hq6G7Qe8e7GBsLBwAReDUkZmWQVl2pbaTnZpdNIzc3V6g4kMDg0vavRQ1eD1ive3eQZt0ecIcuYZQ9uJcnYksYfbaGEQgQPHsS3axf+am2+eLRr7M/UxtzcE0F8yWKsM2eOW0l9qG5/N1XtVVS1V7GtbRuNngTzuWMyrBmszF/Jyjxty3XkTvh94pQoNO+AI29oveSd+xMf58iCmVdpgbxsLZhOvRJ6pzvA67tbea2mlb0t/SOez0q28A9LCvnE0kKmZyed8vuIC885Ec5Phcw5F0IIIc5PajRKy7334XnzTQAOz7+DloxlAFx0wzSW/F3JKZ9bURVePvwyP6j+Ad6wN/74yryV/Nuyf6MibWTPfCQU4pm7P4uvX/vMcev3fkh2afn4b9a4FTb9AI78ZfjjBgssvAmWfx5yT20d9mE/k6KypbaH31U388a+9hFLNwHMK3Byw+JCrl2YR3by+bV8kxKN4mprjYXveq1HvLEeT/fIqveJGM0WMotLyCouJbO4jKySUjKLS7EljX5DQ1Vic8Qb3XTFesO7Gr2E/BMI4k4z2cXJZA3ZktIs4w6DVlWVSFubNkR99278NbsJHDiAGg6P/iK9HsusmdhjQdy+ZMmEh6gP6vH3sKNjRzyQ1/YnWH4sxmFysCxnWbx3fFrqtFMb3u3v0wouHnkTjr41yvxxIK0MZl+jBfLCZadViNETCPPm/g5eq2nh/WPdI0alGPU6PjI7h09WFrJ2RhbGcaYTCJHIeRfOGxsb6e3t5fXXX+exxx5j48aNAEyfPp2kpInduZJwLoQQQpzdlGCQpn/6Z21dZVsWW5f/X9DpsTnN3PbdizCaT29edcdAB49sf4S3G9+OP6bX6fnkjE/yhUVfGLHs2s4/vcZ7zz0DQPnS5dzwb/934m/WeQg2/wj2vDR8nXTQqkUv/xctXBhOf0isLxThrQMdvLKrhY1Hu4melDD0OlhdkcU1C/L4uzm5pNgnOcd3CqmKQn9XJ91NDfQ0NWj75kZ6W5uJjhVQh0jJzokFcC2EZxWXkpIzem84sZsf/Z2+E3PEG7Qe8VAgwXDqk9hTtCCeWZwcC+ROHKnmCQVWxe8nsH//sDAe6Rr7hoPe4cC2aFE8iNsWLEDvcIz7XkO5Aq5hYfxY37FRjzXqjSzMWhjvGZ+bOXfy88aJjTjpPgpH39QC+WjD1dFBwVKY8fdaKM+apU3GP0WhiML6I128WtPC2wc6CEZGFuCbV+Dk+kUF3LC4gIykSVSMFyKB8y6c33HHHTz77LMjHn/33XdZt27dhM4h4VwIIYQ4+0U9Hpo+fyf+6mr2zfkcndlLALjk5hnMX1d4Rt7jncZ3eHT7o7QOtMYfSzYl8/mFn+eWWbdgMmhBIxIK8bN7/gVvjzZk+ObvPEbBzNmTezN3K2x9Enb8AkInVXh2FkDlZ2HpHeDIPAM/GXR5gvxhdyuv1rSwp3nk0FyTQceq6ZlcPT+PK8+ioK4VTOump7lxSBBvpKelkUhw5JzfRMw2mxbCi0tjPeFlZBaVYLGPXVAwHIrS0+Klu8lLd7OX7iYPPS1eIqGxq6YDOFLMZMXmhmcXJ5NVkowjZWJhTlVVwo2NsRBeo/WKHz4M0bFvAJhLS7EtXIht0UJsixdjqahAZ5jcjav+YH88jG9v385R19FRjzXoDMzNnMvy3OUsy13GoqxF2E2TK9IYFwlqIfzIm9qQdVdd4uPMyTDtUi2QV1xx2lNCIlGFbXW9/GlvG3/e2zZiuUKAonQb1y8q4GOL8i/IKSHig3PehfMzQcK5EEIIcW5Q/H6av/Rl2nfVUVX57wDYzFFu/X+XYTrN3vNBgUiAXx78Jc/seWZYZel8Rz6fX/h5rp12LSa9iT3vvMFbTz8BQE75dG558Ptj9riOKuiB3S/C9qeh+6R1ng0WmHMdLLkNSlaf1lJsQx3r9PDqrlZe2dVCS9/I+ekmg441FVlcPT+Pj8zJIcX2wQd1VVXx9ffR3dhAT3MD3fEw3kjIP0Y18SF0ej1puflkFpWQVVJGZokWyJ1Z2eP2Tg/0B+MBXNt76e/0jVU7LS4pzTJsWHpW8cSDOECkp4fAvn349+4jsHcv/j17iLpGLpc3lD4pCduCBVoQX7QI6/z5GNMmX+isY6CD6s5qqjuqqe6s5qjrKCqJf2i9Ts/cjLlU5layPHc5S7KXnHoYV1WtvR97R6usXr8JIiPbIgDp5VoYn/F3UHzxaa92EI4qbD7ew1/2tvHm/nZcCQJ5usPMNQvy+NiiApYUp0q1dfGBkHCegIRzIYQQ4tyhhkK0/Nv9bG4qpCtrMQBz7ce45OHb0VvO3DDTLl8XP9r1I1499uqwsFKYVMidC+/k74v/jhe/fh/dTQ0AXPaPn2fx31976m84WDxu29Naz+HJASmtTAvpi26B5FMopJXwLVVqmvr40x6t17C1f2RxNJNBx0XTMrliTg5XzM4hN+X056j7PW56mrTw3d3cGB+WHvCOXCM6IZ2O1OxcMopKyCwq1vaFxaTlF2I0jX0jYXBYutYb7qG7yUtXsxe/OzTm6wY5s2xkFiaRVaT1hmcVJWN3TjwsRt1ubXj6YBDfv49I6zjV4XU6LNOna0F8oRbGzeXlCddIH4uiKtT117GzYye7Onexq3MXLd6WUY/X6/TMSp8V7xlfkr2EJPNpFDzz9ULte9r88ePvgnuU99YbofiiWCD/e8icfurvGROMRHn/WDd/3tvOWwc66PePDOQ2k4Er5+Zw/aICVldkYpJ55OIDJuE8AQnnQgghxLlFjUY5+t3/5q3WBaDTYwwPsK7/Rcp+8CjmwoIz+l4Hew7yw10/ZFPLpmGPlzhL+HTS1bT+9E8AmG12bn/sCZxZp195nd46qPop1PwK/Cf1oOoMWmBZcitM/wgYzkyvtqKo1DSfCOptCYI6wMLCFC2oz8llRk7SqD2Kgz3hPc1N9LY00dPSqO2bmxjoG7tXeKjkzCwyi0rIKCwms6iEzKIS0gsKMVnGv0kQ9IXpaR2gtyU2LL3ZS0+zl0h4/GHpeqOOjPwkMouSyCxM1vYFSZgnsTqA4vMROHgQ/969BPbuI7BvH6GGhnFfZ0hNPTE8PdYrbphgLaWhQtEQB3oOsKtzF9Wd1ezq3EV/cOSUhkF6nZ6ZaTNP9IznLMFpPo3PxmE/NFdB3Qatd7yleuRNp0HJeVB+qTZUfdplYBt9ScOJcg2EePdwJ+8c6mTD4S48wZEF+mwmA5fNzuaj8/JYNzMLhyx/Jj5EEs4TkHAuhBBCnJv+8t03qW3WwmlBy0Zmt7xO9lf/ldSbbpp0r+J4ajpreLLmSba0bRn2+GUH8imu164hf8ZsbnzgYQyTWIpqTJGgtn5z9XNaj+PJbOkw9wZYcBMULT+tYlhDKYrKrliP+pv72xMOfQcoybBzxaws1uQbKdB56Gttjofx3pYmAgPehK9LxJGWPiyEZxQWk1FYPO68cIBoRMHV7qOnxUtvq5eelgF6Wrx4XRObk25xGMkqSiazMInM2D41145hEj2nUa+X4MGDBA4eInDwIIF9+wgePw7K2DcC9HY71rlzsc6bh23+PKzz52MqLJz0MGpVVWn2NrO3ay97uvewp2sPh3oPET656ODQn9tgYX7mfJbkLGFJ9hIWZC0g2Xwac6oHw3j9Jm1rroLoKCMSjFYouRimXa6F8ezZp91+VVXlaKeXdw528s7BDqobXSOqrAMkWYxcPjubq+blsXZGFrYzNCVGiMmScJ6AhHMhhBDi3DTQF+RX39xMOKyCqlBZ/RhOTyP25cvJ++5/Yi4uPuPvubNjJz+u+TFV7VUAmMM6rt2UT7JfC+QVV17OdZ/7yhl/X3rrYNcvtd50T4Jh0KklsOBGmH8jZM04Y2+rqioH2ty8ubeVzdWH6W1tIj3sIi3k0vbhPkzq+EuGDbIlO7XwXTQkhBeVjLlU2dBr8fQG6G0ZoLvFS2+Ll57WAfrafSiJUlgCziwbWYXDe8QdqeMvXTb0GiJdXbEgfpDAgYMEDh0i3Dj6+t6DdGYzltmzsM2bHw/j5rKySRdtA/CGvOzr2ceerj3xQN4bGGWJsZgUSwqLsxezJHsJS3KWMCd9TrzI4SmZTBgHyJ6rFXObfrk2bN1kO/X3jvGFImyr62X94S7eOdRBU2/iG0kpNhOXzcrmo/PzWFORidUkgVxMPQnnCUg4F0IIIc5du95qZPPvtOWdkjxNVFY/hl6NojOZSLvtVjI//3kMH8D/32s6a3juwHO83fA2GX0mProlF72qBbz2FclcfsPtXFZ8GWbD6RWvGiEa0ebs7nkJDv0JIgmGn2fPhdnXasXksudMqkfS7/Xgam3B1daCq62V3tYmeluacbW1okQnHsID5mSsWXkUlJYyc9Z0sgqLSS8swu5MGfe1qqoy0BfC1T6Aq32A3tYBeloG6G31TmjJMgCz1UBGQRLpBUlk5DvIKEgis3Byw9JVRSHU0DC8R/zgQaI9PeO/2GDAMmMGtnlzsc6bj23+PCzTp6MzT749BCIBDrsOc6DnAAd6DrCvex/H+46PWrhtUKmzlAVZC1iUvYgl2UsoSylDrzuNESWeDmjaFtu2Q1vN2GE8rQxKV0PpGii7BJyTW1M9EUVR2dfaz8aj3Ww82kV1Qx+haOLRCdOzk7h8VjaXzcpmaUmarEUuzjoSzhOQcC6EEEKcu6JRhd88WEVv6wAAZb2bKdvzq/jzhtRUMr/wBVJv/CR66+kXMztZk7uJ5w48x763/0rl3hO9v9tm99I+y8j106/numnXMT3t9ItajRD0wME/akG9bj2oCUJKerkW1GdfB/lLQK8nHAzgamvF1dZKX3srrrYWemNhPOBxT/jtdTo9xtRM+ixpHA856NCn0mtOw2VKJaw/EUKdViNrKrJYNT2TleXplGU60Ol0KIqKp8ePq81Hb9tALIz7cLUNTDiE6w060nLtpOcnkVGghfCMgiSS0ibeGw4QcbkIHjlK8MgRgkdj+yNHUHzjV4rXWa1YZs7AOns21lmzsc6ZjWXGjFNqb/6In8O9J4L4gd4D1PbVEk24zvcJTrOT+VnzWZi5kPlZ85mfOZ8Uy/g3QkalRKHzIDRt1YJ40zZw1Y/9mqFhvHQVpJyZJQ6ben1sPt7NhqPdbD7WnbC6OrHihSvKMrhsVjaXz86mJGNya7oL8WGTcJ6AhHMhhBDi3NbV6OG339uBElVBB5fkH8P08o9RQyd69QyZmaTffhtpn/rUKRXXGk9foI8Xfvog/o0H448dKvZQNdtF1KAyM20mV5dfzVVlV5HrODPV1ofxtMO+32lby07Cip7+sJX+kJW+kBVXyIZLSaU3kozXN7HgO8hgMpGWV0BGQRHpBUVkFGr7tNx8jLGe4HBUYWeDi/VHunjvcBcH206EfIMKqYqOjKiODEVPgd5Ins6INaBAdOIfOZPTrWQUOLTe8AIHGflJpObYMRgn3iOq+HwEjx07EcCPHiVw9CjRru6J/S5SUrDMmY119hwtjM+Zjbm09JSGpg8G8f09++NhvK6/btwgbtAZmJE2gwVZC7QtcwElzpLTW+7L1wut1dC8Axq3avvQONXz06dpw9PL1mih/AyEcVVVqe/xsa22h211vWyv6x215gFAcbqd1RWZrJmeyeqKTJKtH/yyf0KcKRLOE5BwLoQQQpz7qt9sYMsrxwGw2I1cf0cRweefwv2HPww7Tp+cTOrHbyD1ppuwlJef0WtQVZX3X3qeba/8Jv6Y2x6maraLpmw/6ECHjqU5S/lIyUe4rOgy8pJObaivqqr43f30dbTR39FOX0c7/Z3t9HW00dfWwkD/6FW5R5OckUVaXj5peQXalq99nZKdM+4a7tGogqc7QF+nj/5OP63Nbpoa3Az0BDAFFXRMPDgmZ1hJy3WQlmcnPc9BWq6DjHzH5CqlDwwQrK0jVFdL8HitFsiPHCHc3MyEFi8HTPn5sSB+YjPm5p5SsbbWgVaO9B7hsOswR1xHOOo6SoO7Ydyh6QadgfLUcuakz2FOhrbNTJ+JzXga87WDHmjbrVVPb63W9n3jVJE3WKBgCRStiG3LwZF56tcQoygqx7q8bKvrZVttD9vreun0jF7IL9lqZNU0LYivqciU3nFxTpNwnoCEcyGEEOLcpygqf35yDw37tPnAqTl2rr93MYaW43Q//QyeN98cEcrsy5eT+g8fJ+nyj2BIOnMf8ve9+xZv/+xJouETw2/7kkLU5vtoyfLjSg6hxDp7Z6fP5tKiS7m0+FJmps2MB79oJMKAqxdPTzee3m68Pd14entwd3XS39FGX2cH4cDoPYqjsRrCpJn9pJv9pMU3H6kpVkxlF8eGJa/W5q2fVPFeG4YeoL/TR1+nP77v6/Th6QmgTrAoG0AUlT69So9BpUevxPcug4rFamRhUQpLitNYUpzG4uJUUu0j52qrqkqks0sL4LW1hI7Xxr6uI9LePuFrMaSlYZkxA0tFhbbN0PanMsJiIDzAUddRjriOxLejrqN4w+NXrjfqjExLnRYP4XMy5jAjbQZW42lMxwh6oOOAFsZbd2lhvOvw6EuaDUrKheIVJ8J47gIwnn79hB5vkJqmPmqa+tjV2Mfupr6ES5wNspr0LClOY0VZBqsrMllYmCJzx8V5Q8J5AhLOhRBCiPNDyB/ht4/uxNWmzT9PzbFz/VcW40i1EKyto+dnP8X9hz8OG+4OoLNYSFq3DudVf49j1SoMyaexnFRMb2szb/7kh7QePjDiuahOZcAWIWCOouhB0Wkfu2yKmWTVhiVsIOoLTLiH92T2lFRScnJJzckjJTuX1JxcrSc8Mx1b71449ra2dR8ZeW2qEU80C7dhGm7nSvpMs+gPZ9PvNtPfE0CJTO6aLHYjKdl2UrNtpOXaSctzkJxtozEUZlt9L1tre9hR78IfHn0otykaptLiZ6XJy6xQL3n97TjaW4jU16F4J75cm85uxzJ9OpYZFVgrKuKB3JCRMene8P5gP7X9tdT21XK8/zi1/bXU9dXROtA6oddbDBamp05nZvrMeK/4jPQZWAyWSV1HnKJovd8d+6FjH7Tv1b521Y3/WqMN8hZC/mIoWKr1iqcWn/bSZt5ghENtbva19GthvKmPhp6x5/A7zAaWlqazoiydleXpzC9IxTyJaQtCnEsknCcg4VwIIYQ4f7i7/bz6+C48vVoVc0eqhb///Dxyy7TiWBGXi/7XXqPvxZcI1ScocGUwYF+8GMfaS0i6ZC2WGRWnPJdXVVXqdu1g+2u/peXQ/tP7wYbQGww4s7K18J2TR2p2Dim5eaRm55KSk4vZOvqQZ1VV8XvCuLv9uBuacB89TH9rF+4+BXcoA6+SAUwuDBktBlKzbaRm20mJ7VNztK+tDtO4v79QRGHv8Q4OVx+k9cARvMcbSO5tJ9/bTd5AN1n+fvTj9fQOYUhJwTxtGubyMixl5ZinlWOZNg1TQQE6/cR/NlVV6fR1Uueu43jfcer666jtr+V43/Fxly0bKt+Rz4y0GVSkVTAjfQYz02ZSnFyMYZypAqNclFZfoPuItnUejAXy/ePPEQfQGyFnrlYcsGCJts+aBYaJTxlIpNMTYH+rmwODW5ub+p6Bce8vZSdbWFycytISrXd8br5TesbFBUPCeQISzoUQQojzi7vHz2v/tQt3txbQ9UYdlVeVsuTvSuLFw1RVxV9djftPf8b9xhtEexOHLUNWJvbFS7AtWYx9yRKss2ejM02+6JS7q5PjO7fRdvQwXY31uLs6CfmH9yKqqISNKiGjgt8SZcAawWeLMmCN4rNGMDodlBXOpqJ4PnOy5jAzbSbZ9uxh4TcaURjoC+LpDeB1BfG6Anh7tb2nN0B/d4BIcHIF4QAMhEgxtpFqaCPF2EqqoY1Uu4eU/DTsReXocudB7jwt6BlH9v6qkQjh9g7CrS2EW1u1raWFcGMTocZGIh0dk7oeBR2d9lSakrJpSs6hOTmbpqQsgvnF5BbnUpHjZEZOEhU5yVTkJOEcpVBYVInS7mun0d1Ik6eJJk8Tje5GGj2NNHuaCUQTLFU3iiRTEuWp5cxImxHfKtIqcJpP4fNlNKL1encf0Yahdx+F7tg+OMGK+ia7tpRezlzIna8F8Zy5YDr1YfK9AyGOdng42unlWGw71O6h2zv6PPFBFqOe+QUpLC5OZVGRNl0hL8V6eoXshDiHSThPQMK5EEIIcf7xuUO88fRe2o6dKIzmzLJReVUJM5blYjCd6J1TIxEGtm3Du349Axs2Ju5Rj9FZrVjnzME6ayaWWbOwzpqFpaICvW3yBbpURSEajaJEI6iKis5kYG/vPra0bmFL2xb2d+8/UblbBXPUhj3kxB52xveZ0VyylQKc4XSMPhuKTz/udOLRWB0mnJlWnJk2nBlWnBYXzvBhUn3VJHVvRNc7chg8sc5cJawj4jcQ9psJ6/MIR1IJ+y2E3VHCvQNEevq0odeTpHc6MZeUYCgswp2ZS2NSDvsMaWwL29nbHRp1jesTouiMHjJTfeSk+3HY3RjM/YR1PbgjHXQGWokoE1+/HSDDmkF5ajnlKbEt9nWWLWtyQTPo1ZYnc9VrQdxVD72xfV8jKImXDEsopTgWwudBTmxLL4NT6J33hSI09fpp7PXR2OujtsvL0U4vxzu99AyMsa75EBajnlm5yczJT2FOvpOFhSnMynXKEHUhhpBwnoCEcyGEEOL8FI0obP9DLbveahpWrMxiNzK9MofSeRnkTkvB6hjeqxpqaMC7YSPeTRvx76wef16zXo+psBBzScmJrbQEU0EBppwc9I6RxeZUVSUSVggOhAkMRAgMhAkOhPF7Qgy4Q/jcITx9fnp7+xnoD6L49OiVUxgGPYTOAI50M2lZDlIy7VoIz4qF8UwblpOqoavhMNH+fqIuF5GeHiLNdUSO7SbSeIRwewuR3n4i3igRvx41euqhy5DqjP3OyjAVF2MuLsFcUoy5uBhDamrC16iqiivgZmdzIzUtTRzsaqGhr4NOXxdhnQudyYXe2IfO5Eanm/xNAYPORLYtj6LkImamT2Na6okQPqH1w8MB8LSCuxXcbeBu0b4efKyvCQY6J31dpBZD5gzInAmZFZA1U+sdtyX+PZ1MVVVcvjAd7kB8a3adCOJNvf4J9YIPuyS7iTl5TubmO5mT72RufgrlmQ4Zni7EOCScJyDhXAghhDi/dTd7eP+3x2g+5Er4fFKahYyCJFKz7dicJmzJZqwOE0aTHr0eou0tRI4eJnjoIIFDhwl39aDq9Cg6A6pOj6ozoBhMRA0WonqLtjeY43vFkkTUkULE4iRstBHGQkg1oqhnLryoKPhMbgbMffhMLvzGPoIGFwFDH2GDC1VxoY+6sYVV7CEdmWoSmaqDNMVGUsRAkh/sAxGsA2FMHj969wC6gclXg0/EYIliskcxOWKbPYrBEUVxRAknK4SsENDpCZgd+OxpuG2peKwO3GY7/UYTboMBNwoeNYJbCdIT9tAd7CMYnVgv7qi/M8WEEspACWWghjPiXyuhDNRICgZUHARI1gUoTFIoskfJtUXJMofINAyQofOSigen4sYe7ccadmEKutD7e9EF+k79wkwOSCvVwnfmDC2AZ86AjOlgtmvXrqoEIwq+UBRfKIInEMHlC9HvC+Pyhenzh+jzhenzhXD5wvQOhOhwB+h0Bycw2iCxrGQLFdlJVGQnMT07ienZ2pSBDIdZhqYLcQoknCcg4VwIIYS4MLQd62PfhhaO7+oiGj61gPKhUxVMYS+WkAdz2I057MES9mAOeTBHvFjC/Vj8vZh93RiikxuefSb4rHo8TiOeFBNepwl3ioneFAMup0pPcpTupCgBQ5hINIyiRgipCgGdnpD+gw9zKejJx0guRvIwka0YyIgaSAvrSA9GcQRDKOEQSjSMLhrGRASTLoKFMA4C2HSnF/5Ho6Cj35BGlzGfblMe3aYCuoy5dBjyaTfm4iKFqAoRRUVRVCKKSiAcjQXxKP5QBH84yiRWrpuwHKeF4nQ7Rel2bZ9mpzTTzvSsZFLsk6+1IIQY3URz6OmVaxRCCCGEOAvlTU8lb3oqawMRmg+5aD7soqfZS0+Ll6Dvwwm2+mgQU9iHKTKA8aS9KezDFPZiDrmxhNyYQ25MYQ969cO7kaAAXpu2eWzgtelw28Bth95kHX1J0Jukw5UEriQIm3SxVwVj2ygn1RFbmuv0huYDpEajZEajZEQVMmNfZ0aiZChRMiIKOdEIeZEo9sn0NZ2hQQxu1U6vmkw3KbSr6bSp6bTHtsGvO0klMurH7QjQc2Yu5iRpdhM5TivZTis5yRZynFZyUqzkp1gpybBTmGbHajr9v48Q4syScC6EEEKI85bZaqR8URbli7IgNkTY69IqnPs9IfzuEIGBCNGIQjSioERUba+o6A069Hoduther9eh0+swmvWYLAZMFgNGsyH+9bAt6kfn7dfmcQ9ufdpe8RhRAlbUgB0l4EQNBFCCQdRAADUS0aquqSoqqlbwTVHij6HToTOZ0JnN2n5wG/K93uEYsSk2MwMmBa8xQr9Voc8SpccYoC/ixhVw4Y/48YV92j6i7Qc3RVVIUqJE1AhRJYqiKkSUCDqdDoPOgEFvQK/TY9QZh31t1BuxGW1YjVasRis2ow2bYfj3yQYbThWc0SjOSIiUcIDkSAhnyE9S0Icx6AZ/HwT6IOIDxQ9KUJvnHQlolc4nSmcAgzm2mU7szUlgSdL2ZgdYkomaHAR0Vgaw4dEl0YeTbjWZroiDtrCD1pCVXr+KPxRlIBSJ731BbX86Pd0Wox672YDdbMRmNmA3G7CZDDgs2vdJZiOpDhNpdjOpNhOpdjOp9tj3dhOpdhMWowRvIc5FEs6FEEIIccHQ6XQkp1tJTj/1JaYmxgqZaR/we0xO+lRfwAdBUSAaBDV2AwN1+F6nOxHIJ1HN3AA4Ylv2JC9JVVUUFSKKQjQ2VD0aVQkrCooCej0YdDqMeq3OwbC9DpnTLcQFTMK5EEIIIYQ4N+n1oJ/80nYfJG1EARhOYWkzIcSFTdY9EEIIIYQQQgghppiEcyGEEEIIIYQQYopJOBdCCCGEEEIIIabYBTXnfHBJd7fbPdWXIoQQQgghhBDiAjCYP9Vxln28oMK5x+MBoKioaKovRQghhBBCCCHEBcTj8ZCSkjLq8zp1vPh+HlEUhdbWVpKTk8/qZSrcbjdFRUU0NTXhdDqn+nLEFJP2IIaS9iCGkvYghpL2IE4mbUIMJe1h6qiqisfjIT8/H71+9JnlF1TPuV6vp7CwcKovY8KcTqf8hyPipD2IoaQ9iKGkPYihpD2Ik0mbEENJe5gaY/WYD5KCcEIIIYQQQgghxBSTcC6EEEIIIYQQQkwxCednIYvFwgMPPIDFYpnqSxFnAWkPYihpD2IoaQ9iKGkP4mTSJsRQ0h7OfhdUQTghhBBCCCGEEOJsJD3nQgghhBBCCCHEFJNwLoQQQgghhBBCTDEJ50IIIYQQQgghxBSTcC6EEEIIIYQQQkwxCednmSeffJKysjKsVitLly5l48aNU31J4kPw8MMPs2zZMpKTk8nOzub666/n8OHDw45RVZVvfetb5OfnY7PZWLduHfv375+yaxYfnocffhidTsc999wTf0zaw4WlpaWFz3zmM2RkZGC321m0aBE7d+6MPy/t4cISiUT4j//4D8rKyrDZbJSXl/Od73wHRVHix0ibOH9t2LCBa6+9lvz8fHQ6Ha+++uqw5yfytw8Gg3zxi18kMzMTh8PBddddR3Nz84f8k4gzYaz2EA6Huf/++5k/fz4Oh4P8/Hxuu+02Wltbh51D2sPZQ8L5WeSll17innvu4Rvf+Aa7du1izZo1XHXVVTQ2Nk71pYkP2Pr167nrrrvYunUrb731FpFIhCuvvJKBgYH4MY8++iiPP/44TzzxBFVVVeTm5nLFFVfg8Xim9NrFB6uqqoqnn36aBQsWDHtc2sOFw+VysWrVKkwmE3/5y184cOAA3//+90lNTY0fI+3hwvK9732Pn/zkJzzxxBMcPHiQRx99lMcee4wf/ehH8WOkTZy/BgYGWLhwIU888UTC5yfyt7/nnnt45ZVXePHFF9m0aRNer5drrrmGaDT6If4k4kwYqz34fD6qq6v55je/SXV1Nb///e85cuQI11133bDjpD2cRVRx1li+fLl65513Dnts1qxZ6te+9rUpuyYxNTo7O1VAXb9+vaqqqqooipqbm6s+8sgj8WMCgYCakpKi/uQnP5nCKxUfJI/Ho1ZUVKhvvfWWunbtWvXLX/6yqkp7uODcf//96urVq0d9XtrDhefqq69WP/vZzw577OMf/7j6mc98RlWlTVxQAPWVV16Jfz+Rv31fX59qMpnUF198MX5MS0uLqtfr1TfeeOND/gnEmXRye0hk+/btKqA2NDSoqrSHs470nJ8lQqEQO3fu5Morrxz2+JVXXsnmzZun7LrE1Ojv7wcgPT0dgLq6Otrb24e1D4vFwtq1a6V9nMfuuusurr76aj7ykY8Me1zaw4Xl9ddfp7Kykk9+8pNkZ2ezePFinnnmmfjz0h4uPKtXr+add97hyJEjAOzevZtNmzbx0Y9+FKRNXNAm8rffuXMn4XB42DH5+fnMmzdP2scFoL+/H51OFx99Je3h7GKc6gsQmu7ubqLRKDk5OcMez8nJob29fcquS3z4VFXl3nvvZfXq1cybNw8g3gYStY+GhoYpuU7xwXrxxReprq6mqqpqxHPSHi4stbW1PPXUU9x77718/etfZ/v27XzpS1/CYrFw2223SXu4AN1///309/cza9YsDAYD0WiUBx98kE996lMg/0Zc0Cbyt29vb8dsNpOWljbiGPnMeX4LBAJ87Wtf45ZbbsHpdIK0h7OOhPOzjE6nG/a9qqojHhPnt7vvvps9e/awadOmEc9J+7gwNDU18eUvf5m//vWvWK3WUY+T9nBhUBSFyspKHnroIQAWL17M/v37eeqpp7jtttvix0l7uHC89NJL/PKXv+SFF15g7ty51NTUcM8995Cfn8/tt98eP07axIXrVP720j7Ob+FwmJtvvhlFUXjyySfHPV7aw9SQYe1niczMTAwGw4g7VJ2dnSPuforz1xe/+EVef/113n33XQoLC+OP5+bmwpA74oOkfZyfdu7cSWdnJ0uXLsVoNGI0Glm/fj0//OEPMRqN8b+5tIcLQ15eHnPmzBn22OzZs+PFQuXfhwvPV7/6Vb72ta9x8803M3/+fG699Va+8pWv8PDDD4O0iQvaRP72ubm5hEIhXC7XqMeI80s4HObGG2+krq6Ot956K95rjrSHs46E87OE2Wxm6dKlvPXWW8Mef+utt7j44oun7LrEh0NVVe6++25+//vf87e//Y2ysrJhz5eVlZGbmzusfYRCIdavXy/t4zx0+eWXs3fvXmpqauJbZWUln/70p6mpqaG8vFzawwVk1apVI5ZWPHLkCCUlJSD/PlyQfD4fev3wj3AGgyG+lJq0iQvXRP72S5cuxWQyDTumra2Nffv2Sfs4Dw0G86NHj/L222+TkZEx7HlpD2cXGdZ+Frn33nu59dZbqays5KKLLuLpp5+msbGRO++8c6ovTXzA7rrrLl544QVee+01kpOT43e8U1JSsNls8TWuH3roISoqKqioqOChhx7Cbrdzyy23TPXlizMsOTk5Xm9gkMPhICMjI/64tIcLx1e+8hUuvvhiHnroIW688Ua2b9/O008/zdNPPw2x4avSHi4s1157LQ8++CDFxcXMnTuXXbt28fjjj/PZz34WpE2c97xeL8eOHYt/X1dXR01NDenp6RQXF4/7t09JSeFzn/sc9913HxkZGaSnp/Ov//qvzJ8/f0QBUnH2G6s95Ofn84lPfILq6mr++Mc/Eo1G458x09PTMZvN0h7ONlNdLl4M9+Mf/1gtKSlRzWazumTJkvhSWuL8BiTcfv7zn8ePURRFfeCBB9Tc3FzVYrGol1xyibp3794pvW7x4Rm6lJoq7eGC84c//EGdN2+earFY1FmzZqlPP/30sOelPVxY3G63+uUvf1ktLi5WrVarWl5ern7jG99Qg8Fg/BhpE+evd999N+Fnhttvv11VJ/i39/v96t13362mp6erNptNveaaa9TGxsYp+onE6RirPdTV1Y36GfPdd9+Nn0Paw9lDp2rBQAghhBBCCCGEEFNE5pwLIYQQQgghhBBTTMK5EEIIIYQQQggxxSScCyGEEEIIIYQQU0zCuRBCCCGEEEIIMcUknAshhBBCCCGEEFNMwrkQQgghhBBCCDHFJJwLIYQQQgghhBBTTMK5EEIIIYQQQggxxSScCyGEEEIIIYQQU0zCuRBCCCGEEEIIMcUknAshhBAioa6uLnJzc3nooYfij23btg2z2cxf//rXKb02IYQQ4nyjU1VVneqLEEIIIcTZ6c9//jPXX389mzdvZtasWSxevJirr76aH/zgB1N9aUIIIcR5RcK5EEIIIcZ011138fbbb7Ns2TJ2795NVVUVVqt1qi9LCCGEOK9IOBdCCCHEmPx+P/PmzaOpqYkdO3awYMGCqb4kIYQQ4rwjc86FEEIIMaba2lpaW1tRFIWGhoapvhwhhBDivCQ950IIIYQYVSgUYvny5SxatIhZs2bx+OOPs3fvXnJycqb60oQQQojzioRzIYQQQozqq1/9Kr/97W/ZvXs3SUlJXHrppSQnJ/PHP/5xqi9NCCGEOK/IsHYhhBBCJPTee+/xgx/8gOeffx6n04ler+f5559n06ZNPPXUU1N9eUIIIcR5RXrOhRBCCCGEEEKIKSY950IIIYQQQgghxBSTcC6EEEIIIYQQQkwxCedCCCGEEEIIIcQUk3AuhBBCCCGEEEJMMQnnQgghhBBCCCHEFJNwLoQQQgghhBBCTDEJ50IIIYQQQgghxBSTcC6EEEIIIYQQQkwxCedCCCGEEEIIIcQUk3AuhBBCCCGEEEJMMQnnQgghhBBCCCHEFJNwLoQQQgghhBBCTLH/D1Rtfv46N+JcAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(12,2))\n",
+    "\n",
+    "for i, time in enumerate(times):\n",
+    "    V = run.GetVi(time)\n",
+    "    v = gF(V, sigma=6)\n",
+    "\n",
+    "    v.plot(qty='x', ax=ax, ls='solid', lw=2.0, color=colors[i%10], ylabel='X-velocity')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "1db1ea09-da75-4120-9bc9-2de624d6d38d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(12,2))\n",
+    "\n",
+    "for i, time in enumerate(times):\n",
+    "    N = run.GetNi(time)\n",
+    "    n = gF(N, sigma=6)\n",
+    "\n",
+    "    n.plot(qty='value', ax=ax, ls='solid', lw=2.0, color=colors[i%10], ylabel='Density')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "f60f3f2c-3b14-4805-9d79-7287229502ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.0, 15.0)"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "time = 16.0\n",
+    "\n",
+    "fig, ax1 = plt.subplots(figsize=(10,4))\n",
+    "\n",
+    "V = run.GetVi(time)\n",
+    "v = gF(V, sigma=6)\n",
+    "\n",
+    "v.plot(qty='x', ax=ax1, ls='solid', lw=2.0, color=colors[0], ylabel='X-velocity')\n",
+    "\n",
+    "N = run.GetNi(time)\n",
+    "n = gF(N, sigma=6)\n",
+    "\n",
+    "ax2 = ax1.twinx()\n",
+    "\n",
+    "n.plot(qty='value', ax=ax2, ls='solid', lw=2.0, color=colors[i%10], ylabel='Density')\n",
+    "\n",
+    "ax1.set_xlim([32, 96])\n",
+    "ax1.set_ylim([-2, +2])\n",
+    "ax2.set_ylim([0, 15])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "83ccb859-56a6-46f2-8b3d-2b49aca41f00",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "cc26b561-20ea-4914-8ae6-7758ce9a9e30",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "time=20\n",
+    "r = Run(run_path)\n",
+    "ions = r.GetParticles(time, [\"protons\",])\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(10,4))\n",
+    "\n",
+    "p,f = ions.dist_plot(axis=(\"x\", \"Vx\"),\n",
+    "                     ax=ax,\n",
+    "                     norm = 0.4,\n",
+    "                     finest=True,\n",
+    "                     gaussian_filter_sigma=1,\n",
+    "                     vmin=-2,vmax=2,\n",
+    "                     dv=0.01,\n",
+    "                     title=\"weak perturbation at time : {:.2f}\".format(time),\n",
+    "                    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b717b6c3-0972-41c0-8cf3-94fb1e22896a",
+   "metadata": {},
+   "source": [
+    "Protons are essentially free streaming with no force acting on them.\n",
+    "During the late phase of the evolution, in some regions of space, three distinct populations of protons with distinct average velocity coexist without any notable interaction.\n",
+    "This can be observed with a slice of the ($x; u$) phase space at a given $x$ value, more precisely close to the folding of the phase-space ribbon."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04690aac-0191-4260-abe7-0a1ea0c8c921",
+   "metadata": {},
+   "source": [
+    "Fluid quantities such as the particle density $n$, the fluid velocity $u$, the pressure $p$ and the heat flux $q$ are defined as the moments of the distribution function $f(x,v,t)$ for the one-dimensional case.\n",
+    "These moments are defined as\n",
+    "\\begin{eqnarray}\n",
+    "n(x, t) & = & \\int f(x,v,t) \\mathrm{d} v \\\\\n",
+    "n(x, t) u(x,t) & = & \\int v f(x,v,t) \\mathrm{d} v \\\\\n",
+    "p(x, t) & = & \\int (v-u)^2 f(x,v,t) \\mathrm{d} v \\\\\n",
+    "q(x, t) & = & \\int (v-u)^3 f(x,v,t) \\mathrm{d} v \\\\\n",
+    "\\end{eqnarray}\n",
+    "\n",
+    "The temperature is defined as $T = p/n$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d131d8b5-c911-4198-a2b5-c0d070b3dce5",
+   "metadata": {},
+   "source": [
+    "## Sample questions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "03d700a1-3112-48d8-965f-d24be69acea4",
+   "metadata": {},
+   "source": [
+    "You may address various questions by noting that the distribution function can be approximated at any position $x$ by $f = \\sum_i v_i \\delta(v_i)$ where $n_i$ and $v_i$ are the density and the velocity of the various branches of the distribution function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f38dc11-4d7f-4fb5-94c5-3c72993c48ad",
+   "metadata": {},
+   "source": [
+    "1. How do you explain the high pressure building up in the center\n",
+    "2. Can you give an estimate of the maximum temperature at the center as a func-\n",
+    "tion of the parameters of the initial condition ?\n",
+    "3. Can you calculate and plot the fluid velocity $u$ ?\n",
+    "4. What can you say about the heat flux $q$ ?\n",
+    "5. In order to approximate a collisionless system using a fluid model one has to choose a closure relation9. A simple possible closure (which at least works dimensionally) could be $q = Apu$ where $A$ is a numerical constant, $p$ the pressure and $u$ the fluid velocity. Could such a closure apply to the above case ?\n",
+    "6. any suggestions of question ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "234298b2-8450-48ab-93e4-df93087c7390",
+   "metadata": {},
+   "source": [
+    "## Hot electron case : run b & c"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d2a74031-17e8-461d-b837-0ea9170c1135",
+   "metadata": {},
+   "source": [
+    "The pressure of the electrons is no longer negligible for run **b** and **c**.\n",
+    "As a consequence, the gradients of the electron pressure which appear in the system induce a sufficiently strong electric field to affect the protons' trajectories as you can see in the phase space.\n",
+    "In particular, with respect to the case **a**, in **b** some of the protons are accelerated to form beams of high velocity (with respect to the simulation frame).\n",
+    "To see this, you can plot the spatial profile of the electric field."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2c216767-de18-4827-be07-4d5a38b43a9b",
+   "metadata": {},
+   "source": [
+    "## Sample questions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4a398c47-8a00-4bce-bd01-dfcfeae5da11",
+   "metadata": {},
+   "source": [
+    "1. Where do the high energy protons come from ? By what are they accelerated ?\n",
+    "2. Discuss differences between the colde case (run **a**) and warm cases (run **b** and **c**) ?\n",
+    "3. What are the differences between runs **b** and **c** ?\n",
+    "4. Any suggestions of questions ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "48186d51-6140-4958-9f4b-43bb59bc7e93",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "76cf36f7-cc62-4b50-ad56-c177a3018970",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f31c4086d50>]"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot([1, 2, 3], [2, 3, 5], color='b', linestyle=None, marker='.', linewidth=0, markersize=0.5, alpha=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "e74c9c69-6fae-47c2-8484-7ce88e39eff4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.arange(0,30,0.2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "1f5c0959-d8ca-4d06-8bc7-9c9d28ad0787",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 0. ,  0.4,  0.8,  1.2,  1.6,  2. ,  2.4,  2.8,  3.2,  3.6,  4. ,\n",
+       "        4.4,  4.8,  5.2,  5.6,  6. ,  6.4,  6.8,  7.2,  7.6,  8. ,  8.4,\n",
+       "        8.8,  9.2,  9.6, 10. , 10.4, 10.8, 11.2, 11.6, 12. , 12.4, 12.8,\n",
+       "       13.2, 13.6, 14. , 14.4, 14.8, 15.2, 15.6, 16. , 16.4, 16.8, 17.2,\n",
+       "       17.6, 18. , 18.4, 18.8, 19.2, 19.6, 20. , 20.4, 20.8, 21.2, 21.6,\n",
+       "       22. , 22.4, 22.8, 23.2, 23.6, 24. , 24.4, 24.8, 25.2, 25.6, 26. ,\n",
+       "       26.4, 26.8, 27.2, 27.6, 28. , 28.4, 28.8, 29.2, 29.6])"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a[::2] # subsampling every 2 points"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "728313a2-1941-471e-8baf-e1c52bcba4d7",
+   "metadata": {},
+   "source": [
+    "draw a slice of the phase space... dist_plot(..., slice=(None, 12), ...)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "74e5fdc9-9d7a-4b60-b612-db1509c2d460",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8a736a4b-9af0-4feb-b1c1-d20b1c64a5e5",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b6986f9e-9cc8-4600-8ba1-e46da36e904f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3af158e6-3056-4ea2-9595-3589ee64969c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4119ae9f-b603-48cb-b408-d1dbfd993aa5",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16ebd8e4-51b0-47bf-805a-c1912fc0d0a9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.13.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/res/eg/1d/jupyter/strong/strong.py b/res/eg/1d/jupyter/strong/strong.py
new file mode 100644
index 000000000..eaaf962d5
--- /dev/null
+++ b/res/eg/1d/jupyter/strong/strong.py
@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+
+import pyphare.pharein as ph  # lgtm [py/import-and-import-from]
+from pyphare.pharein import Simulation
+from pyphare.pharein import MaxwellianFluidModel
+from pyphare.pharein import ElectromagDiagnostics, FluidDiagnostics, ParticleDiagnostics
+from pyphare.pharein import ElectronModel
+from pyphare.simulator.simulator import Simulator
+from pyphare.pharein import global_vars as gv
+from pyphare.pharesee.run import Run
+
+
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+import numpy as np
+
+mpl.use("Agg")
+
+
+def config(**kwargs):
+    Simulation(
+        time_step=0.001,
+        final_time=20.0,
+        boundary_types="periodic",
+        hyper_resistivity=0.02,
+        cells=512,
+        dl=0.25,
+        diag_options={
+            "format": "phareh5",
+            "options": {"dir": kwargs["diagdir"], "mode": "overwrite"},
+        },
+    )
+
+    def density(x):
+        return 1.0
+
+    def bx(x):
+        return 1.0
+
+    def by(x):
+        return 0.0
+
+    def bz(x):
+        return 0.0
+
+    def vStrong(x):
+        from pyphare.pharein.global_vars import sim
+
+        L = sim.simulation_domain()[0]
+        return np.sin(2 * np.pi / L * x) * 1.5
+
+    def vNull(x):
+        return 0.0
+
+    def vth(x):
+        Ti = kwargs.get("Ti", 0.005)
+        return np.sqrt(Ti)
+
+    vvv = {
+        "vbulkx": vStrong,
+        "vbulky": vNull,
+        "vbulkz": vNull,
+        "vthx": vth,
+        "vthy": vth,
+        "vthz": vth,
+    }
+
+    MaxwellianFluidModel(
+        bx=bx,
+        by=by,
+        bz=bz,
+        protons={"charge": 1, "density": density, "nbr_part_per_cell": 200, **vvv},
+    )
+
+    ElectronModel(closure="isothermal", Te=kwargs.get("Te", 0.005))
+
+    sim = ph.global_vars.sim
+    dt = sim.time_step * 500
+    timestamps = np.arange(0, sim.final_time + dt, dt)
+
+    for quantity in ["E", "B"]:
+        ElectromagDiagnostics(
+            quantity=quantity,
+            write_timestamps=timestamps,
+        )
+
+    for quantity in ["density", "charge_density", "bulkVelocity"]:
+        FluidDiagnostics(
+            quantity=quantity,
+            write_timestamps=timestamps,
+        )
+
+    for quantity in ["domain"]:  # , 'levelGhost', 'patchGhost']:
+        ParticleDiagnostics(
+            quantity=quantity, write_timestamps=timestamps, population_name="protons"
+        )
+
+
+def main():
+    from pyphare import cpp
+    import sys
+
+    if len(sys.argv) != 4:
+        print('This code needs 3 paramaters, "run_name", Te, Ti')
+    else:
+        diagdir = sys.argv[1]
+        Te = float(sys.argv[2])
+        Ti = float(sys.argv[3])
+
+    config(diagdir=diagdir, Te=Te, Ti=Ti)
+    Simulator(gv.sim).run()
+    gv.sim = None
+
+
+if __name__ == "__main__":
+    main()
diff --git a/res/eg/1d/jupyter/weak/weak.ipynb b/res/eg/1d/jupyter/weak/weak.ipynb
new file mode 100644
index 000000000..d632501f0
--- /dev/null
+++ b/res/eg/1d/jupyter/weak/weak.ipynb
@@ -0,0 +1,636 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c0e8f518-5df2-42d3-b202-0548a55be9d4",
+   "metadata": {},
+   "source": [
+    "Weak perturbation\n",
+    "================="
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8e429c8-2084-4201-aec8-a92289b9ee22",
+   "metadata": {},
+   "source": [
+    "In this numerical experiment, one considers the propagation of a small perturbation in a collisionless plasma model. The perturbation is initiated by a thin slab of fluid slowly moving with respect to the surrounding resting fluid. The simulation domain is one-dimensional in the $x$ direction. The slab (we call it slab even if this term is inproper at one dimension) is also moving in the $x$ direction.\n",
+    "\n",
+    "The perturbation is said to be **small** because the initial speed of the slab is small with respect to the ion acoustic speed. In such a case, the mode is linear and we aim in this practical work at calculating the speed at which this small perturbation is propagating and verify that it is the ion acoustic speed."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "90b32318-c9db-42d7-88bd-8df4c50d4ea4",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import sys\n",
+    "from pathlib import Path\n",
+    "\n",
+    "WORK_DIR  = Path(os.getcwd())\n",
+    "PROJECT_DIR = Path(WORK_DIR).parent.parent.parent.parent.parent\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "18a361ac-75a1-4fdb-8cb1-c4e81ff553bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# home = os.environ['HOME']\n",
+    "work_path = str(WORK_DIR)\n",
+    "src_path = str(PROJECT_DIR/'PHARE')\n",
+    "build_path = str(PROJECT_DIR/'build')\n",
+    "build_path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "12a7f206-7757-4ba5-bbfb-118081203f50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sys.path.append(build_path)\n",
+    "sys.path.append(os.path.join(str(PROJECT_DIR), \"pyphare\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6eb1097d-7b04-4eaf-b82b-38ba73cb7011",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import subprocess\n",
+    "import pyphare\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pyphare.pharesee.run import Run\n",
+    "from pyphare.core.operators import dot, cross, sqrt, modulus, grad\n",
+    "# from pyphare.core.ufuncs import gF, peakIds\n",
+    "import numpy as np\n",
+    "from numpy import polyfit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b21ff00f-a777-4095-867a-87d6fe31054c",
+   "metadata": {},
+   "source": [
+    "# Fluid case"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c2859f63-1ae3-4caf-ab09-2962d5d8ed19",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    " "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "54d523ba-d112-4ca9-9918-25a9aa2222fb",
+   "metadata": {},
+   "source": [
+    "## Theory"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae6b9aae-79cc-4ecd-9ad7-c2b369e0ec4a",
+   "metadata": {},
+   "source": [
+    "The one-dimensional fluid equations, neglecting viscosity and conductivity are given by the continuity, momentum and energy equations ($\\gamma$ is the polytropic)\n",
+    "\\begin{eqnarray}\n",
+    "\\partial_t n & = & - \\partial_x (n u) \\\\\n",
+    "\\partial_t u & = & - u \\partial_x u - (1/n) \\partial_x p \\\\\n",
+    "\\partial_t p & = & -u \\partial_x p - \\gamma p \\partial_x u \\\\\n",
+    "\\end{eqnarray}\n",
+    "\n",
+    "where $n$, $u$ and $p$ are the particle density, velocity component in the $x$ direction and fluid kinetic pressure, respectively.\n",
+    "Two modes in opposite directions exist which do satisfy $\\partial_t u \\pm c \\partial_x u = 0$ propagating where $c =\\sqrt{\\gamma p_0/n_0 m} = \\sqrt{\\gamma T_0}$ is the sound speed, with $p_0$ and $n_0 m$ the average pressure and mass density, respectively.\n",
+    "The velocity, density and pressure fluctuations associated with the two modes are related through $u/c = \\pm n_1/n_0$ and $p_1/ p_0 = \\gamma n_1/n_0$.\n",
+    "Note that in the code the normalized temperature is defined as $T = p/n$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d8e1196-3761-4661-8a71-6dd3ae486906",
+   "metadata": {},
+   "source": [
+    "# Hybrid case"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b8179ec-115d-4d93-8969-78e7fa6038b7",
+   "metadata": {},
+   "source": [
+    "## Run the `PHARE` code in dedicated conditions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d70f4d7d-0d16-4671-93b9-a9ac5b397c2e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Ti = 0.02\n",
+    "Te = 0.1\n",
+    "run_name = \"wpc\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7964c6a-99d2-42eb-85f9-e10184ff6dfd",
+   "metadata": {},
+   "source": [
+    "It is suggested to play first with the electron temperature and consider a small ion temperature $T_i = 0.1$.\n",
+    "The electron temperature $T_e$ will be investigated for values ranging from 0.01 to 1.0.\n",
+    "The plasma is magnetized with a DC field along the $x$ direction.\n",
+    "\n",
+    "The modes for which the wave number $k$ is along the DC magnetic field, are the same as the ones that can exist un an unmagnetized plasma, that is :\n",
+    "* the Bohm and Gross mode\n",
+    "* the light mode\n",
+    "* the ion acoustic mode\n",
+    "\n",
+    "The 2 first modes are very high frequency... above the plasma frequency. Hence, in the hybrid limit ($\\omega < \\omega_{pe}$), the ion acoustic mode is the only one that can propagate."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71da8893-c5c2-4e03-b81c-91f926db96bf",
+   "metadata": {},
+   "source": [
+    "For the size of the domain and total integration time, these temperature are controlling :\n",
+    "* the ion acoustic speed. If this one is too small, the mde wont be seable. If it is too large, it will exit the domain (with BC problems)\n",
+    "* the rate of the Landau damping, because the ion acoustic speed has to be close to the ion thermal velocity\n",
+    "\n",
+    "As $m_e \\to 0$, $v_{te}$ will always be very large compared to $\\omega/k$, whatever $T_e$. But if the ion thermal velocity is too small, they won't be able to be Landau damped.\n",
+    "\n",
+    "The average electron density in the system is $n_e = n_i = 1$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c364b018-717e-409b-9480-da93632161d3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_path = os.path.join(work_path, run_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e5a33652-fabf-40b4-bc12-6fba20ec510c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "files = []\n",
+    "if os.path.isdir(run_path):\n",
+    "    files = os.listdir(run_path)\n",
+    "print(\"files\", files)    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20106c04-fdfd-49b1-bc4f-0a49d8cbbedc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if 'PYTHONPATH' in os.environ:\n",
+    "    os.environ['PYTHONPATH'] += os.pathsep + os.path.join(src_path, \"pyphare\")\n",
+    "else:\n",
+    "    os.environ['PYTHONPATH'] = os.pathsep + os.path.join(src_path, \"pyphare\")\n",
+    "os.environ['PYTHONPATH'] += os.pathsep + build_path"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "99a24337-dab6-4bbd-83e4-3d3adc464008",
+   "metadata": {},
+   "source": [
+    "All the path are now set, so that a **PHARE** simulation is ready to run. If the `h5` files of  the run doesn't exist, the cell below will then run the code and store the data using a `h5` file format in the direction given in the simulation script `wp.py`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d18212bd-350d-4e89-becd-1a6b0fc84775",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if 'ions_charge_density.h5' not in files :\n",
+    "    os.chdir(work_path)\n",
+    "    subprocess.run(['mpirun', '-n', '2', 'python3', '-Ou', work_path+'/weak.py', run_name, str(Te), str(Ti)], env=os.environ)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "938b861e-17bf-4849-833a-f81420471c56",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run  = Run(run_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc8f85d3-7285-4e44-a43b-49bbebc2f867",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "times = np.asarray((20, 40, 60, 80, 100))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "72fdb857-cabf-41b2-938d-67dcc26b7a85",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "colors = plt.rcParams['axes.prop_cycle'].by_key()['color']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "898d0901-163e-428d-be5a-4e3f6eda4276",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "time = times[3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "32d15ae9-b068-4ef9-9f0d-915c97a7766b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "V = run.GetVi(time)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e5fcfcba-fe64-41f5-b53e-cdd0dceb7139",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(6,2))\n",
+    "\n",
+    "V.plot(qty='x', ax=ax, ls='solid', lw=1.0, color='tab:blue', ylabel='X-velocity')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "325c4fcc-ab61-4c62-b213-41f20ef1cd00",
+   "metadata": {},
+   "source": [
+    "The data obtained from the **PHARE** simlulation are too noisy so that the peaks can not easily be found. We then create a new patch hierarchy as a deepcopy of the former one, but for which all the dataset are smoothed using a Gaussian filter. This one is then the Gaussian filter of `pyphare`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2fad3fee-dc7f-4afc-ac5b-af770310713c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "V = V[:]\n",
+    "v = V.gaussian(sigma=6)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ad4e8039-8703-4e71-9bc8-f451fb0154e3",
+   "metadata": {},
+   "source": [
+    "We then use a `find_peaks` version of `pyphare`, called `peaksIds` to find the peaks (using the same syntax and format as the method of `scipy`)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c439746-10fa-468c-86d3-879b1e671856",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# pks, hgs = peakIds(v, names=['x',], height=0.015)\n",
+    "pks = v.peak_coordinates(\"x\", height=0.015)\n",
+    "pks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "73f5fed2-b36c-4617-9824-349a18831185",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(6,2))\n",
+    "\n",
+    "V.plot(qty='x', ax=ax, ls='solid', lw=1.0, color='tab:blue', ylabel='X-velocity')\n",
+    "v.plot(qty='x', ax=ax, ls='solid', lw=2.0, color='tab:orange', ylabel='X-velocity')\n",
+    "for p in pks:\n",
+    "    ax.axvline(x=p, color='black', linestyle='dotted')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "617ab8ab-1e82-4ad7-86ab-b53589ee804c",
+   "metadata": {},
+   "source": [
+    "You can then do the job for a set of times to investigate how the small perturbation is propagating"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1f19e2af-1b21-45ef-bda0-d39af47701de",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7ebb7502-3947-4d2e-b68a-68da4baaf8f5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(12,2))\n",
+    "\n",
+    "pks_plus = []\n",
+    "pks_minus = []\n",
+    "hgs_plus = []\n",
+    "hgs_minus = []\n",
+    "\n",
+    "for i, time in enumerate(times):\n",
+    "    V = run.GetVi(time)[:]\n",
+    "    v = V.gaussian(sigma=6)\n",
+    "    pks, hgs = v.find_peaks( qty='x', height=0.0135, distance=20)\n",
+    "    \n",
+    "    if len(pks)==1:\n",
+    "        pks_minus.append(pks[0])\n",
+    "        pks_plus.append(pks[0])\n",
+    "        hgs_minus.append(hgs[0])\n",
+    "        hgs_plus.append(hgs[0])\n",
+    "\n",
+    "    else:\n",
+    "        pks_minus.append(pks[1])\n",
+    "        pks_plus.append(pks[0])\n",
+    "        hgs_minus.append(hgs[1])\n",
+    "        hgs_plus.append(hgs[0])\n",
+    "\n",
+    "    v.plot(qty='x', ax=ax, ls='solid', lw=2.0, color=colors[i], ylabel='X-velocity')\n",
+    "\n",
+    "    for p in v.peak_coordinates(\"x\", height=0.0135, distance=20):\n",
+    "        ax.axvline(x=p, color='black', linestyle='dotted')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "95f0c968-2c37-4242-90c4-6ce5cc8909b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(8,3))\n",
+    "\n",
+    "ax.plot(times, pks_minus, marker=\"o\", color=colors[5], ls=\"None\")\n",
+    "slope_m, origin_m = polyfit(times, pks_minus, 1)\n",
+    "ax.plot(times, times*slope_m+origin_m, color=colors[5])\n",
+    "\n",
+    "ax.plot(times, pks_plus, marker=\"o\", color=colors[6], ls=\"None\")\n",
+    "slope_p, origin_p = polyfit(times, pks_plus, 1)\n",
+    "ax.plot(times, times*slope_p+origin_p, color=colors[6])\n",
+    "\n",
+    "ax.text(20, 100, 'positive slope : {:.3f}'.format(slope_p))\n",
+    "ax.text(20, 20, 'negative slope : {:.3f}'.format(slope_m))\n",
+    "\n",
+    "ax.set_ylim([0, 128])\n",
+    "ax.set_xlabel('Time')\n",
+    "ax.set_ylabel('X-position')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29685313-e2f8-44bf-92f3-9ba6476ac6eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "v_phi = np.mean(np.abs([slope_m, slope_p]))\n",
+    "print('phase velocity of the mode : {:.3f}'.format(v_phi))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b6e61de-ac14-4ffd-9191-e1877704d59e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Gamma_e = 1\n",
+    "Gamma_i = 3\n",
+    "print(\"ion acoustic speed : \", np.sqrt(Gamma_e*Te+Gamma_i*Ti))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c41677e-4535-47f2-9818-f36ed6206b30",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scipy import odr\n",
+    "\n",
+    "def model_fn(p, x):\n",
+    "    a, b, c = p\n",
+    "    return a+b*np.exp(c*x)\n",
+    "model = odr.Model(model_fn)\n",
+    "\n",
+    "x = times\n",
+    "model = odr.Model(model_fn)\n",
+    "\n",
+    "y = hgs_minus\n",
+    "data = odr.Data(x, y)\n",
+    "odr_obj = odr.ODR(data, model, beta0=[0.01,0.01,0.01])\n",
+    "out_minus = odr_obj.run()\n",
+    "# out_minus.pprint()\n",
+    "b0, b1, b2 = out_minus.beta\n",
+    "\n",
+    "y = hgs_plus\n",
+    "odr_obj = odr.ODR(odr.Data(x, y), model, beta0=[0.001,0.001,0.001])\n",
+    "out_plus = odr_obj.run()\n",
+    "# out_plus.pprint()\n",
+    "B0, B1, B2 = out_plus.beta\n",
+    "\n",
+    "print(\"growth rate for the minus side : \", b2)\n",
+    "print(\"growth rate for the plus side : \", B2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e450d2b-83b6-4dc4-b991-06b96a2cd3c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(8,3))\n",
+    "\n",
+    "ax.semilogy(times, hgs_minus, marker=\"o\", color=colors[5], ls=\"None\")\n",
+    "ax.semilogy(times, model_fn(out_minus.beta, times), color=colors[5], ls=\":\")\n",
+    "\n",
+    "ax.semilogy(times, hgs_plus, marker=\"o\", color=colors[6], ls=\"None\")\n",
+    "ax.semilogy(times, model_fn(out_plus.beta, times), color=colors[6], ls=\":\")\n",
+    "\n",
+    "ax.set_xlabel('Time')\n",
+    "ax.set_ylabel('Amplitude')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3286ceec-aa0d-4aa9-99a2-376e933267ec",
+   "metadata": {},
+   "source": [
+    "In fact, even in the collisionless situation where the particles are essentially free streaming the behavior of the system is very similar to the fluid (collisional) case, showing a density \"hole\" moving to the left and a density \"bump\" moving to the right, both associated with a positive velocity bump. A picture of the evolution of the particles in ($x, v_x$) phase space for the hybrid case is shown in the next figure"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "832c65f7-eddc-4367-ad06-37054d12bb71",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "time=100\n",
+    "r = Run(run_path)\n",
+    "ions = r.GetParticles(time, [\"protons\",])\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(10,4))\n",
+    "\n",
+    "p,f = ions.dist_plot(axis=(\"x\", \"Vx\"),\n",
+    "                     ax=ax,\n",
+    "                     norm = 0.4,\n",
+    "                     finest=True,\n",
+    "                     gaussian_filter_sigma=1,\n",
+    "                     vmin=-1,vmax=1,\n",
+    "                     dv=0.01,\n",
+    "                     title=\"weak perturbation at time : {:.2f}\".format(time),\n",
+    "                    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "066672f9-410f-412b-958a-0f646c271211",
+   "metadata": {},
+   "source": [
+    " ## Theory"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c15b4fc9-572e-40a3-99da-6e64e8b055cd",
+   "metadata": {},
+   "source": [
+    "The velocity of a singly charged ion (charge $+e$, mass $m$) in the $x$ direction, i.e. along the magnetic field, changes under the effect of an the electric field component $E_x$ :\n",
+    "$$\n",
+    "\\frac{\\mathrm{d} v_x}{\\mathrm{d}t} = \\frac{e}{m} E_x(x; t)\n",
+    "$$\n",
+    "\n",
+    "In the hybrid approximation where $n = n_i \\sim n_e$ and the mass of electron is zero, the electrostatic field $E$ can be written as (a reduced version of Ohm's law):\n",
+    "\n",
+    "$$\n",
+    "E_x = - \\frac{1}{e n_e} \\frac{\\partial p_e}{\\partial x}\n",
+    "$$\n",
+    "\n",
+    "where $p_e = n T_e$. The first two fluid equations describing the ions' motion can therefore be written as :\n",
+    "\\begin{eqnarray}\n",
+    "\\partial_t n & = & - \\partial_x (n u) \\\\\n",
+    "\\partial_t u & = & - u \\partial_x u - (1/n) \\partial_x p\n",
+    "\\end{eqnarray}\n",
+    "\n",
+    "where the pressure $p$ is intended to represent the $p_{xx}$ component of the ion pressure tensor.\n",
+    "A simple energy equation similar to the one of the fluid case is not easily written in this case as electrons and protons may behave very differently.\n",
+    "The modes phase velocity may therefore depend on various parameters including the mode's wavelength.\n",
+    "In the limit $p_i \\ll p_e$ a propagating mode exists which is reminiscent of the standard sound mode with a phase velocity $v_{\\phi} = \\sqrt{\\gamma_e T_e + \\gamma_i T_i}$ where $\\gamma_e = 1$ in the isothermal case and $\\gamma_i = 3$ in the adiabatic monodimensional case.\n",
+    "Given the above fluid equations, the relations for the eigenmodes are those of the standard sound mode:\n",
+    "$$\n",
+    "\\frac{u_1}{v_{\\phi}} = \\frac{n_1}{n_0} = \\frac{1}{\\gamma} \\frac{p_1}{p_0}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf1b3a96-36c0-42be-a42a-634f98c134c6",
+   "metadata": {},
+   "source": [
+    "## Sample of questions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e901392-c817-4257-8ef9-8a1cb632e72e",
+   "metadata": {},
+   "source": [
+    "1. How can a positive velocity bump move with a negative phase velocity (i.e. to the left) ?\n",
+    "2. Measure the propagation velocity of the perturbations in the fluid and hybrid simulations and compare to the sound velocity\n",
+    "3. Can you explain the fluid behavior of the hybrid system (i.e. the propagation of a quasi-sound wave) by observing the motion of the particles ?\n",
+    "4. any suggestions of question ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc14885e-cbf2-4090-aab2-6df0780bc966",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.13.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/res/eg/1d/jupyter/weak/weak.py b/res/eg/1d/jupyter/weak/weak.py
new file mode 100644
index 000000000..8b21ddfa3
--- /dev/null
+++ b/res/eg/1d/jupyter/weak/weak.py
@@ -0,0 +1,124 @@
+#
+#
+#
+
+
+import sys
+import numpy as np
+from pathlib import Path
+
+from pyphare import cpp
+import pyphare.pharein as ph
+from pyphare.simulator.simulator import Simulator, startMPI
+
+# ph.NO_GUI()
+SCRIPT_DIR = Path(__file__).parent
+
+
+time_step = 0.005
+final_time = 100.0
+dt = time_step * 100
+timestamps = np.arange(0, final_time + dt, dt)
+
+
+def density(x):
+    return 1.0
+
+
+def bx(x):
+    return 1.0
+
+
+def by(x):
+    return 0.0
+
+
+def bz(x):
+    return 0.0
+
+
+def T(x):
+    return 0.125**2
+
+
+def vWeak(x):
+    from pyphare.pharein.global_vars import sim
+
+    L = sim.simulation_domain()[0]
+    x0 = 0.5 * L
+    sigma = 2.0
+    bubble = 0.08 * np.exp(-((x - x0) ** 2) / (2 * sigma**2))
+    return bubble
+
+
+def vNull(x):
+    return 0.0
+
+
+def vth(x):
+    return np.sqrt(T(x))
+
+
+vvv = {
+    "vbulkx": vWeak,
+    "vbulky": vNull,
+    "vbulkz": vNull,
+    "vthx": vth,
+    "vthy": vth,
+    "vthz": vth,
+}
+
+
+def config(**kwargs):
+    sim = ph.Simulation(
+        time_step=time_step,
+        final_time=final_time,
+        boundary_types="periodic",
+        hyper_resistivity=0.001,
+        cells=512,
+        dl=0.25,
+        diag_options={
+            "format": "phareh5",
+            "options": {"dir": kwargs["diagdir"], "mode": "overwrite"},
+        },
+    )
+
+    ph.MaxwellianFluidModel(
+        bx=bx,
+        by=by,
+        bz=bz,
+        protons={"charge": 1, "density": density, "nbr_part_per_cell": 200, **vvv},
+    )
+
+    ph.ElectronModel(closure="isothermal", Te=kwargs.get("Te", 0.0))
+
+    for quantity in ["E", "B"]:
+        ph.ElectromagDiagnostics(quantity=quantity, write_timestamps=timestamps)
+
+    for quantity in ["charge_density", "bulkVelocity"]:
+        ph.FluidDiagnostics(quantity=quantity, write_timestamps=timestamps)
+
+    for quantity in ["domain"]:
+        ph.ParticleDiagnostics(
+            quantity=quantity, write_timestamps=timestamps, population_name="protons"
+        )
+    return sim
+
+
+if __name__ == "__main__":
+    startMPI()
+
+    if len(sys.argv) != 4:
+        print('This code needs 3 paramaters, "run_name", Te, Ti')
+    else:
+        diagdir = sys.argv[1]
+        Te = float(sys.argv[2])
+        Ti = float(sys.argv[3])
+
+    # Te = 0.2
+    # if len(sys.argv) > 1:
+    #     Te = float(sys.argv[1])
+
+    # diag_dir = f"{SCRIPT_DIR}/outputs"
+    Simulator(config(diagdir=diagdir, Te=Te), print_one_line=True).run().reset()
+    ph.global_vars.sim = None
diff --git a/tests/simulator/CMakeLists.txt b/tests/simulator/CMakeLists.txt
index e06de6d05..f94f5ff16 100644
--- a/tests/simulator/CMakeLists.txt
+++ b/tests/simulator/CMakeLists.txt
@@ -35,6 +35,7 @@ if(HighFive)
 
   else() # serial only
     phare_python3_exec(11 test_diagnostic_timestamps test_diagnostic_timestamps.py ${CMAKE_CURRENT_BINARY_DIR})
+    phare_python3_exec(09 test_weak_perturbation test_weak_perturbation.py ${CMAKE_CURRENT_BINARY_DIR})
   endif(testMPI)
 
 
diff --git a/tests/simulator/test_run.py b/tests/simulator/test_run.py
index 66b19e908..721dc6891 100644
--- a/tests/simulator/test_run.py
+++ b/tests/simulator/test_run.py
@@ -5,29 +5,27 @@
 
 from pyphare import cpp
 import pyphare.pharein as ph
-from pyphare.simulator.simulator import Simulator, startMPI
 from pyphare.pharesee.run import Run
 from tests.simulator import SimulatorTest
+from pyphare.simulator.simulator import Simulator, startMPI
+
+from pyphare.pharesee.hierarchy import hierarchy_utils as hootils
 
 ph.NO_GUI()
 
 
 time_step = 0.005
-final_time = 0.05
-time_step_nbr = int(final_time / time_step)
-timestamps = np.arange(0, final_time + 0.01, 0.05)
-diag_dir = "phare_outputs/test_run"
-plot_dir = Path(f"{diag_dir}_plots")
-plot_dir.mkdir(parents=True, exist_ok=True)
+final_time = time_step
+timestamps = [0, final_time]
 
 
-def config():
+def config_2d(diag_dir, diag_format):
     L = 0.5
 
     sim = ph.Simulation(
         time_step=time_step,
         final_time=final_time,
-        cells=(40, 40),
+        cells=(20, 20),
         dl=(0.40, 0.40),
         refinement="tagging",
         max_nbr_levels=3,
@@ -37,7 +35,7 @@ def config():
         hyper_resistivity=0.002,
         resistivity=0.001,
         diag_options={
-            "format": "phareh5",
+            "format": diag_format,
             "options": {"dir": diag_dir, "mode": "overwrite"},
         },
     )
@@ -160,61 +158,95 @@ def vthz(x, y):
     return sim
 
 
-def plot_file_for_qty(qty, time):
+def plot_file_for_qty(plot_dir, qty, time):
     return f"{plot_dir}/harris_{qty}_t{time}.png"
 
 
-def plot(diag_dir):
+def plot(test, diag_dir):
     run = Run(diag_dir)
+    plot_dir = Path(f"{diag_dir}_plots")
+    plot_dir.mkdir(parents=True, exist_ok=True)
+
     pop_name = "protons"
     for time in timestamps:
-        run.GetDivB(time).plot(
-            filename=plot_file_for_qty("divb", time),
-            plot_patches=True,
-            vmin=1e-11,
-            vmax=2e-10,
-        )
-        run.GetRanks(time).plot(
-            filename=plot_file_for_qty("Ranks", time), plot_patches=True
-        )
-        run.GetN(time, pop_name=pop_name).plot(
-            filename=plot_file_for_qty("N", time), plot_patches=True
-        )
         for c in ["x", "y", "z"]:
             run.GetB(time, all_primal=False).plot(
-                filename=plot_file_for_qty(f"b{c}", time),
+                filename=plot_file_for_qty(plot_dir, f"b{c}", time),
                 qty=f"B{c}",
                 plot_patches=True,
             )
-        run.GetJ(time).plot(
-            all_primal=False,
-            filename=plot_file_for_qty("jz", time),
-            qty="z",
-            plot_patches=True,
-            vmin=-2,
-            vmax=2,
-        )
-        run.GetPressure(time, pop_name=pop_name).plot(
-            filename=plot_file_for_qty(f"{pop_name}_Pxx", time),
-            qty=pop_name + "_Pxx",
-            plot_patches=True,
-        )
-        run.GetPressure(time, pop_name=pop_name).plot(
-            filename=plot_file_for_qty(f"{pop_name}_Pzz", time),
-            qty=pop_name + "_Pzz",
-            plot_patches=True,
-        )
-        run.GetPi(time).plot(
-            filename=plot_file_for_qty("Pxx", time),
-            qty="Pxx",
-            plot_patches=True,
-        )
-        run.GetPi(time).plot(
-            filename=plot_file_for_qty("Pzz", time),
-            qty="Pzz",
-            plot_patches=True,
+        B = run.GetB(time)
+        if B.ndim == 1:  # only 1d for now
+            peaks = B.as_peaks()
+            print("peaks", type(peaks), peaks)
+            values = B[peaks]
+            print("values", values)
+        B_finest = run.GetB(time)[:]
+        B_gaussian = B_finest.gaussian()
+        for c in ["x", "y", "z"]:
+            B_gaussian.plot(
+                filename=plot_file_for_qty(plot_dir, f"b{c}_gaussian", time),
+                qty=f"{c}",
+            )
+            np.exp(B_finest).plot(
+                filename=plot_file_for_qty(plot_dir, f"b{c}_exp", time), qty=f"{c}"
+            )
+            print("np.add(hier, 2)", np.add(2, B_finest))
+            print("np.mean(B_finest)", np.mean(B_finest))
+            print("np.clip(B_finest)", np.clip(B_finest, 0, 1))
+
+            if B.ndim > 1:  # in 1d it returns a scalar?
+                np.dot(B_finest, B_finest).plot(
+                    filename=plot_file_for_qty(plot_dir, f"b{c}_mean", time), qty=f"{c}"
+                )
+
+            B_finest.plot(
+                filename=plot_file_for_qty(plot_dir, f"b{c}_finest", time), qty=f"{c}"
+            )
+
+        run.GetN(time, pop_name=pop_name).plot(
+            filename=plot_file_for_qty(plot_dir, "N", time), plot_patches=True
         )
 
+        if B.ndim > 1:  # divB is 0 by construction in 1D
+            run.GetDivB(time).plot(
+                filename=plot_file_for_qty(plot_dir, "divb", time),
+                plot_patches=True,
+                vmin=1e-11,
+                vmax=2e-10,
+            )
+            run.GetRanks(time).plot(  # not implemented in 1d
+                filename=plot_file_for_qty(plot_dir, "Ranks", time), plot_patches=True
+            )
+            run.GetJ(time).plot(  # Jx in 1d has issues?
+                filename=plot_file_for_qty(plot_dir, "jz", time),
+                qty="z",
+                plot_patches=True,
+                vmin=-2,
+                vmax=2,
+            )
+            run.GetPressure(time, pop_name=pop_name).plot(
+                filename=plot_file_for_qty(plot_dir, f"{pop_name}_Pxx", time),
+                qty=pop_name + "_Pxx",
+                plot_patches=True,
+            )
+            run.GetPressure(time, pop_name=pop_name).plot(
+                filename=plot_file_for_qty(plot_dir, f"{pop_name}_Pzz", time),
+                qty=pop_name + "_Pzz",
+                plot_patches=True,
+            )
+            run.GetPi(time).plot(
+                filename=plot_file_for_qty(plot_dir, "Pxx", time),
+                qty="Pxx",
+                plot_patches=True,
+            )
+            run.GetPi(time).plot(
+                filename=plot_file_for_qty(plot_dir, "Pzz", time),
+                qty="Pzz",
+                plot_patches=True,
+            )
+    return plot_dir
+
 
 def assert_file_exists_with_size_at_least(file, size=10000):
     path = Path(file)
@@ -227,23 +259,153 @@ def assert_file_exists_with_size_at_least(file, size=10000):
         )
 
 
-class RunTest(SimulatorTest):
+def config_1d(diag_dir, diag_format):
+    sim = ph.Simulation(
+        time_step=time_step,
+        final_time=final_time,
+        cells=(200),
+        dl=(0.40),
+        refinement="tagging",
+        max_nbr_levels=3,
+        nesting_buffer=1,
+        clustering="tile",
+        tag_buffer="1",
+        hyper_resistivity=0.002,
+        resistivity=0.001,
+        diag_options={
+            "format": diag_format,
+            "options": {"dir": diag_dir, "mode": "overwrite"},
+        },
+    )
+    L = sim.simulation_domain()
+
+    def density(x):
+        return 1.0
+
+    def by(x):
+        return 0.01 * np.cos(2 * np.pi * x / L[0])
+
+    def bz(x):
+        return 0.01 * np.sin(2 * np.pi * x / L[0])
+
+    def bx(x):
+        return 1.0
+
+    def vx(x):
+        return 0.0
+
+    def vy(x):
+        return 0.01 * np.cos(2 * np.pi * x / L[0])
+
+    def vz(x):
+        return 0.01 * np.sin(2 * np.pi * x / L[0])
+
+    def vthx(x):
+        return 0.01
+
+    def vthy(x):
+        return 0.01
+
+    def vthz(x):
+        return 0.01
+
+    vvv = {
+        "vbulkx": vx,
+        "vbulky": vy,
+        "vbulkz": vz,
+        "vthx": vthx,
+        "vthy": vthy,
+        "vthz": vthz,
+    }
+
+    ph.MaxwellianFluidModel(
+        bx=bx, by=by, bz=bz, protons={"charge": 1, "density": density, **vvv}
+    )
+    ph.ElectronModel(closure="isothermal", Te=0.0)
+
+    for quantity in ["E", "B"]:
+        ph.ElectromagDiagnostics(quantity=quantity, write_timestamps=timestamps)
+
+    for quantity in [
+        "mass_density",
+        "charge_density",
+        "bulkVelocity",
+        "pressure_tensor",
+    ]:
+        ph.FluidDiagnostics(quantity=quantity, write_timestamps=timestamps)
+
+    pop = "protons"
+    ph.ParticleDiagnostics(
+        quantity="domain", write_timestamps=timestamps, population_name=pop
+    )
+
+    for quantity in ["density", "charge_density", "pressure_tensor"]:
+        ph.FluidDiagnostics(
+            quantity=quantity, write_timestamps=timestamps, population_name=pop
+        )
+    return sim
+
+
+class RunTest1D(SimulatorTest):
     def __init__(self, *args, **kwargs):
-        super(RunTest, self).__init__(*args, **kwargs)
+        super(RunTest1D, self).__init__(*args, **kwargs)
         self.simulator = None
 
     def tearDown(self):
-        super(RunTest, self).tearDown()
+        super(RunTest1D, self).tearDown()
         if self.simulator is not None:
             self.simulator.reset()
         self.simulator = None
         ph.global_vars.sim = None
 
-    def test_run(self):
-        sim = config()
+    def _test_any_format(self, sim, diag_dir):
         self.register_diag_dir_for_cleanup(diag_dir)
         Simulator(sim).run().reset()
+        run = Run(diag_dir)
+        B = run.GetB(timestamps[-1], all_primal=False)
+        self.assertTrue(B.ndim == 1)
 
+        self.assertTrue(B.levels()[0].patches[0].attrs)
+
+        B = run.GetB(timestamps[-1])
+        self.assertTrue(B.levels()[0].patches[0].attrs)
+
+    def test_run_phareh5(self):
+        diag_dir = "phare_outputs/test_run_phareh5_1d"
+        sim = config_1d(diag_dir, "phareh5")
+        self._test_any_format(sim, diag_dir)
+
+        # move to _test_any_format when vtkhdf supports divb etc
+        if cpp.mpi_rank() == 0:
+            plot_dir = plot(self, diag_dir)
+
+            for time in timestamps:
+                for q in ["N"]:
+                    assert_file_exists_with_size_at_least(
+                        plot_file_for_qty(plot_dir, q, time)
+                    )
+
+                for c in ["x", "y", "z"]:
+                    assert_file_exists_with_size_at_least(
+                        plot_file_for_qty(plot_dir, f"b{c}", time)
+                    )
+
+
+class RunTest2D(SimulatorTest):
+    def __init__(self, *args, **kwargs):
+        super(RunTest2D, self).__init__(*args, **kwargs)
+        self.simulator = None
+
+    def tearDown(self):
+        super(RunTest2D, self).tearDown()
+        if self.simulator is not None:
+            self.simulator.reset()
+        self.simulator = None
+        ph.global_vars.sim = None
+
+    def _test_any_format(self, sim, diag_dir):
+        self.register_diag_dir_for_cleanup(diag_dir)
+        Simulator(sim).run().reset()
         run = Run(diag_dir)
         B = run.GetB(timestamps[-1], all_primal=False)
         self.assertTrue(B.levels()[0].patches[0].attrs)
@@ -251,20 +413,26 @@ def test_run(self):
         B = run.GetB(timestamps[-1])
         self.assertTrue(B.levels()[0].patches[0].attrs)
 
+    def test_run_phareh5(self):
+        diag_dir = "phare_outputs/test_run_phareh5_2d"
+        sim = config_2d(diag_dir, "phareh5")
+        self._test_any_format(sim, diag_dir)
+
+        # move to _test_any_format when vtkhdf supports divb etc
         if cpp.mpi_rank() == 0:
-            plot(diag_dir)
+            plot_dir = plot(self, diag_dir)
 
             for time in timestamps:
                 for q in ["divb", "Ranks", "N", "jz"]:
-                    assert_file_exists_with_size_at_least(plot_file_for_qty(q, time))
+                    assert_file_exists_with_size_at_least(
+                        plot_file_for_qty(plot_dir, q, time)
+                    )
 
                 for c in ["x", "y", "z"]:
                     assert_file_exists_with_size_at_least(
-                        plot_file_for_qty(f"b{c}", time)
+                        plot_file_for_qty(plot_dir, f"b{c}", time)
                     )
 
-        cpp.mpi_barrier()
-
 
 if __name__ == "__main__":
     import unittest
diff --git a/tests/simulator/test_weak_perturbation.py b/tests/simulator/test_weak_perturbation.py
new file mode 100644
index 000000000..c3f596bed
--- /dev/null
+++ b/tests/simulator/test_weak_perturbation.py
@@ -0,0 +1,163 @@
+#
+#
+#
+
+
+import sys
+import numpy as np
+from pathlib import Path
+
+from pyphare import cpp
+import pyphare.pharein as ph
+from pyphare.pharesee.run import Run
+from pyphare.simulator.simulator import Simulator, startMPI
+from pyphare.pharesee.hierarchy import hierarchy_utils as hootils
+
+from tests.simulator import SimulatorTest
+
+ph.NO_GUI()
+
+
+time_step = 0.005
+final_time = 100.0
+dt = time_step * 100
+timestamps = np.arange(0, final_time + dt, dt)
+
+
+def density(x):
+    return 1.0
+
+
+def bx(x):
+    return 1.0
+
+
+def by(x):
+    return 0.0
+
+
+def bz(x):
+    return 0.0
+
+
+def T(x):
+    return 0.125**2
+
+
+def vWeak(x):
+    from pyphare.pharein.global_vars import sim
+
+    L = sim.simulation_domain()[0]
+    x0 = 0.5 * L
+    sigma = 2.0
+    bubble = 0.08 * np.exp(-((x - x0) ** 2) / (2 * sigma**2))
+    return bubble
+
+
+def vNull(x):
+    return 0.0
+
+
+def vth(x):
+    return np.sqrt(T(x))
+
+
+vvv = {
+    "vbulkx": vWeak,
+    "vbulky": vNull,
+    "vbulkz": vNull,
+    "vthx": vth,
+    "vthy": vth,
+    "vthz": vth,
+}
+
+
+def config(**kwargs):
+    sim = ph.Simulation(
+        time_step=time_step,
+        final_time=final_time,
+        boundary_types="periodic",
+        hyper_resistivity=0.001,
+        cells=512,
+        dl=0.25,
+        diag_options={
+            "format": "phareh5",
+            "options": {"dir": kwargs["diagdir"], "mode": "overwrite"},
+        },
+    )
+
+    ph.MaxwellianFluidModel(
+        bx=bx,
+        by=by,
+        bz=bz,
+        protons={"charge": 1, "density": density, "nbr_part_per_cell": 200, **vvv},
+    )
+
+    ph.ElectronModel(closure="isothermal", Te=kwargs.get("Te", 0.0))
+
+    for quantity in ["E", "B"]:
+        ph.ElectromagDiagnostics(quantity=quantity, write_timestamps=timestamps)
+
+    for quantity in ["mass_density", "bulkVelocity"]:
+        ph.FluidDiagnostics(quantity=quantity, write_timestamps=timestamps)
+
+    for quantity in ["domain"]:
+        ph.ParticleDiagnostics(
+            quantity=quantity, write_timestamps=timestamps, population_name="protons"
+        )
+    return sim
+
+
+def plot_file_for_qty(plot_dir, qty, time):
+    return f"{plot_dir}/harris_{qty}_t{time}.png"
+
+
+def plot(test, diag_dir, Te):
+    run = Run(diag_dir)
+    plot_dir = Path(f"{diag_dir}_plots")
+    plot_dir.mkdir(parents=True, exist_ok=True)
+
+    time = 0
+    V_finest = run.GetVi(time)[:]
+    V_gaussian = V_finest.gaussian()
+    for c in ["x", "y", "z"]:
+        V_gaussian.plot(
+            filename=plot_file_for_qty(plot_dir, f"v{c}_gaussian", time), qty=f"{c}"
+        )
+
+    times = np.asarray((0, 20, 40, 60, 80, 100))
+    hootils.plot_velocity_peaks_over_time(
+        run, times, Te, plot_dir / "velocity_peaks.png", sigma=6
+    )
+
+
+class TestWeakPerbabtion1D(SimulatorTest):
+    def __init__(self, *args, **kwargs):
+        super(TestWeakPerbabtion1D, self).__init__(*args, **kwargs)
+        self.simulator = None
+
+    def tearDown(self):
+        super(TestWeakPerbabtion1D, self).tearDown()
+        if self.simulator is not None:
+            self.simulator.reset()
+        self.simulator = None
+        ph.global_vars.sim = None
+
+    def run(self, Te):
+        diag_dir = f"phare_outputs/test_weak_perturbation1d/{cpp.mpi_size()}"
+        self.register_diag_dir_for_cleanup(diag_dir)
+        Simulator(config(diagdir=diag_dir, Te=Te)).run().reset()
+
+        if cpp.mpi_rank() == 0:
+            plot(self, diag_dir, Te)
+        return self
+
+
+if __name__ == "__main__":
+    startMPI()
+
+    Te = 0.2
+    if len(sys.argv) > 1:
+        Te = float(sys.argv[1])
+
+    TestWeakPerbabtion1D().run(Te).tearDown()